diff options
Diffstat (limited to 'libstdc++-v3')
111 files changed, 6177 insertions, 2873 deletions
diff --git a/libstdc++-v3/ChangeLog b/libstdc++-v3/ChangeLog index 510bc4e6b28..c78c71f2bf9 100644 --- a/libstdc++-v3/ChangeLog +++ b/libstdc++-v3/ChangeLog @@ -1,3 +1,229 @@ +2010-11-01 Benjamin Kosnik <bkoz@redhat.com> + + * include/std/chrono: Extend constexpr application. + * testsuite/util/testsuite_common_types.h + (constexpr_default_constructible, constexpr_single_value_constructible) + : Add comments about implied constraints. + * testsuite/20_util/duration/cons/constexpr.cc: Activate all tests. + * testsuite/20_util/time_point/cons/constexpr.cc: Same. + * testsuite/20_util/time_point/requirements/constexpr_functions.cc: + Same. + * testsuite/20_util/ratio/cons/cons_overflow_neg.cc: Adjust line + numbers. + * testsuite/20_util/time_point_cast/constexpr.cc: New. + + * include/std/bitset: Use __SIZEOF_* macros to re-create original + logic instead of slipshod application of + std::numeric_limits<T>::max() macros. + * testsuite/util/testsuite_common_types.h + (constexpr_default_constructible): Modify. + + * include/std/chrono: Tested constexpr. + * testsuite/20_util/duration_cast/constexpr.cc: New. + * testsuite/20_util/time_point/cons/constexpr.cc: New. + + * testsuite/20_util/duration/cons/constexpr.cc: Add single_value tests. + * testsuite/20_util/duration/requirements/typedefs_neg1.cc: Adjust + line numbers. + * testsuite/20_util/duration/requirements/typedefs_neg2.cc: Same. + * testsuite/20_util/duration/requirements/typedefs_neg3.cc: Same. + * testsuite/20_util/time_point/cons/constexpr.cc: Add single_value + tests. + * testsuite/20_util/time_point/requirements/constexpr_functions.cc: Add. + + * testsuite/util/testsuite_common_types.h: Adjust init. + + * include/std/chrono (duration): Remove defaulted constructor, + replace with mem-init list. + * testsuite/20_util/duration/cons/constexpr.cc: Add single value. + * testsuite/20_util/duration/requirements/constexpr_functions.cc: + Add non-static member functions. + + * testsuite/20_util/default_delete/cons/constexpr.cc: New, xfail. + * testsuite/20_util/enable_shared_from_this/cons/constexpr.cc: Same. + * testsuite/20_util/shared_ptr/cons/constexpr.cc: Same. + * testsuite/20_util/time_point/requirements/constexpr_functions.cc: + Same. + * testsuite/20_util/unique_ptr/cons/constexpr.cc: Same. + * testsuite/20_util/weak_ptr/cons/constexpr.cc: Same. + + * include/std/bitset: Add constexpr as per N3126 draft. + * testsuite/23_containers/bitset/cons/constexpr.cc: New. + * testsuite/23_containers/bitset/requirements/constexpr_functions.cc: + New. + + * testsuite/util/testsuite_common_types.h: Reset condition. + + * include/bits/random.h: Remove misleading comments. + * include/bits/regex.h: Add constexpr. + * testsuite/28_regex/05_constants/syntax_option_type.cc: Add tests. + * testsuite/28_regex/08_basic_regex/requirements/constexpr_data.cc: New. + + PR libstdc++/46134 + * include/std/chrono: Use default constructor. + * testsuite/util/testsuite_common_types.h + (constexpr_default_constructible): Adjust condition. + + PR libstdc++/46133 + * include/std/complex: Adjust complex specialization default + constructors for constexpr. + * testsuite/26_numerics/complex/cons/constexpr.cc: Enable tests. + + * include/bits/random.h: Adjust for constexpr as per N3126 draft. + * testsuite/26_numerics/random/discard_block_engine/requirements/ + constexpr_data.cc: New. + * testsuite/26_numerics/random/discard_block_engine/requirements/ + constexpr_functions.cc: New. + * testsuite/26_numerics/random/independent_bits_engine/requirements/ + constexpr_functions.cc: New. + * testsuite/26_numerics/random/linear_congruential_engine/requirements/ + constexpr_data.cc: New. + * testsuite/26_numerics/random/linear_congruential_engine/requirements/ + constexpr_functions.cc: New. + * testsuite/26_numerics/random/mersenne_twister_engine/requirements/ + constexpr_data.cc: New. + * testsuite/26_numerics/random/mersenne_twister_engine/requirements/ + constexpr_functions.cc: New. + * testsuite/26_numerics/random/shuffle_order_engine/requirements/ + constexpr_data.cc: New. + * testsuite/26_numerics/random/shuffle_order_engine/requirements/ + constexpr_functions.cc: New. + * testsuite/26_numerics/random/subtract_with_carry_engine/requirements/ + constexpr_data.cc: New. + * testsuite/26_numerics/random/subtract_with_carry_engine/requirements/ + constexpr_functions.cc: New. + + * include/bits/stream_iterator.h: Add constexpr as per N3126 draft. + * include/bits/streambuf_iterator.h: Same. + * include/std/complex: Same. + * testsuite/24_iterators/istream_iterator/cons/constexpr.cc: New. + * testsuite/24_iterators/istreambuf_iterator/cons/constexpr.cc: New. + * testsuite/26_numerics/complex/cons/constexpr.cc: New. + * testsuite/26_numerics/complex/requirements/constexpr_functions.cc: + New. + + * include/bits/char_traits.h: Add constexpr as per N3126 draft. + * testsuite/21_strings/char_traits/requirements/constexpr_functions.cc: + New. + + * include/tr1_impl/array: Add constexpr as per N3126 draft. + * testsuite/23_containers/array/requirements/ + constexpr_functions.cc: New. + + * include/bits/shared_ptr.h: Revert changes. + * include/bits/unique_ptr.h: Same. + + * include/std/chrono: Adjust. + * include/tr1_impl/type_traits: Same. + + * testsuite/util/testsuite_common_types.h: Add test functors. + * testsuite/20_util/duration/cons/constexpr.cc: New. + * testsuite/20_util/duration/requirements/constexpr_functions.cc: Same. + * testsuite/20_util/pair/cons/constexpr.cc: Same. + * testsuite/20_util/ratio/requirements/constexpr_data.cc: Same. + * testsuite/27_io/ios_base/types/fmtflags/constexpr_operators.cc: Same. + * testsuite/27_io/ios_base/types/iostate/constexpr_operators.cc: Same. + * testsuite/27_io/ios_base/types/openmode/constexpr_operators.cc: Same. + * testsuite/30_threads/call_once/constexpr.cc: Same. + * testsuite/30_threads/mutex/cons/constexpr.cc: Same. + * testsuite/30_threads/once_flag/cons/constexpr.cc: Same. + * testsuite/tr1/4_metaprogramming/integral_constant/requirements/ + constexpr_data.cc: Same. + + * testsuite/29_atomics/atomic/cons/assign_neg.cc: Adjust line numbers. + * testsuite/29_atomics/atomic/cons/copy_neg.cc: Same. + * testsuite/29_atomics/atomic_integral/cons/assign_neg.cc: Same. + * testsuite/29_atomics/atomic_integral/cons/copy_neg.cc: Same. + * testsuite/29_atomics/atomic_integral/operators/bitwise_neg.cc: Same. + + * include/bits/allocator.h: Add constexpr as per N3126 draft. + * include/bits/ios_base.h: Same. + * include/bits/shared_ptr.h: Same. + * include/bits/unique_ptr.h: Same. + * include/bits/stl_iterator.h: Same. + * include/bits/stl_pair.h: Same. + * include/std/tuple: Same. + * include/tr1_impl/type_traits: Same. + * include/std/chrono: Same. + * include/std/ratio: Same. + * include/std/mutex: Same. + * src/mutex.cc: Same. + * testsuite/20_util/duration/requirements/typedefs_neg1.cc: Adjust. + * testsuite/20_util/duration/requirements/typedefs_neg2.cc: Same. + * testsuite/20_util/duration/requirements/typedefs_neg3.cc: Same. + * testsuite/20_util/weak_ptr/comparison/cmp_neg.cc: Same. + * testsuite/27_io/ios_base/cons/assign_neg.cc: Same. + * testsuite/27_io/ios_base/cons/copy_neg.cc: Same. + + * doc/doxygen/user.cfg.in: Replace _GLIBCXX_USE_CONSTEXPR, + _GLIBCXX_CONSTEXPR for doxygen generation. + + * src/limits.cc: Undef. + * testsuite/29_atomics/atomic/cons/constexpr.cc: Adjust. + * testsuite/29_atomics/atomic_address/cons/constexpr.cc: Same. + * testsuite/29_atomics/atomic_integral/cons/constexpr.cc: Same. + * testsuite/29_atomics/atomic_integral/operators/bitwise_neg.c: Same. + * testsuite/18_support/numeric_limits/constexpr.cc: To... + * testsuite/18_support/numeric_limits/requirements/ + constexpr_data.cc, constexpr_functions.cc: ...this + + * testsuite/util/testsuite_common_types.h + (constexpr_single_value_constructible): Add. + * testsuite/29_atomics/atomic/cons/constexpr.cc: Adjust name. + * testsuite/29_atomics/atomic_integral/cons/constexpr.cc: Same. + * testsuite/29_atomics/atomic_address/cons/constexpr.cc: New. + * testsuite/18_support/numeric_limits/constexpr.cc: New. + + * testsuite/29_atomics/atomic/cons/assign_neg.cc: Adjust line numbers. + * testsuite/29_atomics/atomic/cons/constexpr.cc: Same. + * testsuite/29_atomics/atomic/cons/copy_neg.cc: Same. + * testsuite/29_atomics/atomic_integral/cons/assign_neg.cc: Same. + * testsuite/29_atomics/atomic_integral/cons/constexpr.cc: Same. + * testsuite/29_atomics/atomic_integral/cons/copy_neg.cc: Same. + * testsuite/29_atomics/atomic_integral/operators/bitwise_neg.cc: Same. + * testsuite/29_atomics/atomic_integral/operators/decrement_neg.cc: Same. + * testsuite/29_atomics/atomic_integral/operators/increment_neg.cc: Same. + + * include/bits/c++config (_GLIBCXX_CONSTEXPR): Add. + (_GLIBCXX_USE_CONSTEXPR): Add. + * include/std/limits: Use it. + * src/limits.cc: Adjust. + * testsuite/ext/profile/mutex_extensions.cc: Change line number. + + * include/bits/atomic_0.h: Rework for N3126 draft, add constexpr. + * include/bits/atomic_2.h: Same. + * include/bits/atomic_base.h: Same. + * include/std/atomic: Same. + * src/atomic.cc: Same. + * include/bits/atomicfwd_c.h: Remove. + * include/bits/atomicfwd_cxx.h: Remove. + * include/c_compatibility/stdatomic.h: Remove. + * include/Makefile.am: Remove atomicfwd_c.h, atomicfwd_cxx.h, + stdatomic.h. + * include/Makefile.in: Regenerate. + * doc/xml/manual/using.xml: Update list of header files for changes. + * testsuite/util/testsuite_common_types.h + (constexpr_constructible): Add. + * testsuite/29_atomics/atomic/cons/constexpr.cc: New. + * testsuite/29_atomics/atomic_integral/cons/constexpr.cc: New. + * testsuite/17_intro/headers/c++200x/stdc++.cc: Modify. + * testsuite/29_atomics/atomic/cons/assign_neg.cc: Same. + * testsuite/29_atomics/atomic_address/cons/assign_neg.cc: Same. + * testsuite/29_atomics/atomic_flag/cons/1.cc: Same. + * testsuite/29_atomics/atomic_integral/cons/assign_neg.cc: Same. + * testsuite/29_atomics/headers/atomic/macros.cc: Same. + * testsuite/29_atomics/headers/atomic/types_std_c++0x.cc: Same. + * testsuite/29_atomics/headers/atomic/types_std_c++0x_neg.cc: Same. + * testsuite/29_atomics/atomic_flag/test_and_set/implicit.c: Remove. + * testsuite/29_atomics/atomic_flag/test_and_set/explicit.c: Same. + * testsuite/29_atomics/atomic_flag/clear/1.c: Same. + * testsuite/29_atomics/headers/stdatomic.h/debug_mode.c: Same. + * testsuite/29_atomics/headers/stdatomic.h/functions.c: Same. + * testsuite/29_atomics/headers/stdatomic.h/macros.c: Same. + * testsuite/29_atomics/headers/stdatomic.h/types.c: Same. + + * testsuite/util/testsuite_abi.cc: Add GLIBCXX_3.4.16. + 2010-11-01 Jason Merrill <jason@redhat.com> * libsupc++/initializer_list: Decorate with constexpr. diff --git a/libstdc++-v3/config/abi/pre/gnu.ver b/libstdc++-v3/config/abi/pre/gnu.ver index e374c379f16..eec63a016da 100644 --- a/libstdc++-v3/config/abi/pre/gnu.ver +++ b/libstdc++-v3/config/abi/pre/gnu.ver @@ -1193,6 +1193,13 @@ GLIBCXX_3.4.15 { } GLIBCXX_3.4.14; +GLIBCXX_3.4.16 { + + # std::future_category is now a function + _ZSt15future_categoryv; + +} GLIBCXX_3.4.15; + # Symbols in the support library (libsupc++) have their own tag. CXXABI_1.3 { diff --git a/libstdc++-v3/doc/doxygen/user.cfg.in b/libstdc++-v3/doc/doxygen/user.cfg.in index c9e86a51884..8550aa54bf1 100644 --- a/libstdc++-v3/doc/doxygen/user.cfg.in +++ b/libstdc++-v3/doc/doxygen/user.cfg.in @@ -599,6 +599,7 @@ INPUT = @srcdir@/doc/doxygen/doxygroups.cc \ include/complex \ include/condition_variable \ include/deque \ + include/forward_list \ include/fstream \ include/functional \ include/future \ @@ -1539,6 +1540,8 @@ PREDEFINED = __cplusplus \ _GLIBCXX_END_NESTED_NAMESPACE=} \ "_GLIBCXX_TEMPLATE_ARGS=... " \ _GLIBCXX_DEPRECATED \ + _GLIBCXX_CONSTEXPR=constexpr \ + _GLIBCXX_USE_CONSTEXPR=constexpr \ _GLIBCXX_USE_WCHAR_T \ _GLIBCXX_USE_LONG_LONG \ _GLIBCXX_USE_C99_STDINT_TR1 \ diff --git a/libstdc++-v3/doc/xml/manual/using.xml b/libstdc++-v3/doc/xml/manual/using.xml index e3400a678c1..6e3123e11b1 100644 --- a/libstdc++-v3/doc/xml/manual/using.xml +++ b/libstdc++-v3/doc/xml/manual/using.xml @@ -354,10 +354,6 @@ mode, i.e. <literal>-std=c++0x</literal> or <literal>-std=gnu++0x</literal>. <entry><filename class="headerfile">cwchar</filename></entry> <entry><filename class="headerfile">cwctype</filename></entry> </row> -<row> -<entry><filename class="headerfile">stdatomic.h</filename></entry> -</row> - </tbody> </tgroup> </table> diff --git a/libstdc++-v3/include/Makefile.am b/libstdc++-v3/include/Makefile.am index 8093425c06b..d1ac203aee7 100644 --- a/libstdc++-v3/include/Makefile.am +++ b/libstdc++-v3/include/Makefile.am @@ -1,4 +1,4 @@ -#o# Makefile for the include subdirectory of the GNU C++ Standard library. +## Makefile for the include subdirectory of the GNU C++ Standard library. ## ## Copyright (C) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010 ## Free Software Foundation, Inc. @@ -80,8 +80,6 @@ bits_headers = \ ${bits_srcdir}/algorithmfwd.h \ ${bits_srcdir}/allocator.h \ ${bits_srcdir}/atomic_base.h \ - ${bits_srcdir}/atomicfwd_c.h \ - ${bits_srcdir}/atomicfwd_cxx.h \ ${bits_srcdir}/atomic_0.h \ ${bits_srcdir}/atomic_2.h \ ${bits_srcdir}/basic_ios.h \ @@ -679,8 +677,7 @@ if GLIBCXX_C_HEADERS_C_GLOBAL c_compatibility_headers = \ ${c_compatibility_srcdir}/complex.h \ ${c_compatibility_srcdir}/fenv.h \ - ${c_compatibility_srcdir}/tgmath.h \ - ${c_compatibility_srcdir}/stdatomic.h + ${c_compatibility_srcdir}/tgmath.h endif if GLIBCXX_C_HEADERS_C diff --git a/libstdc++-v3/include/Makefile.in b/libstdc++-v3/include/Makefile.in index 256bac6e437..778b0c0445a 100644 --- a/libstdc++-v3/include/Makefile.in +++ b/libstdc++-v3/include/Makefile.in @@ -14,8 +14,6 @@ # PARTICULAR PURPOSE. @SET_MAKE@ - -#o# Makefile for the include subdirectory of the GNU C++ Standard library. VPATH = @srcdir@ pkgdatadir = $(datadir)/@PACKAGE@ pkgincludedir = $(includedir)/@PACKAGE@ @@ -322,8 +320,6 @@ bits_headers = \ ${bits_srcdir}/algorithmfwd.h \ ${bits_srcdir}/allocator.h \ ${bits_srcdir}/atomic_base.h \ - ${bits_srcdir}/atomicfwd_c.h \ - ${bits_srcdir}/atomicfwd_cxx.h \ ${bits_srcdir}/atomic_0.h \ ${bits_srcdir}/atomic_2.h \ ${bits_srcdir}/basic_ios.h \ @@ -914,8 +910,7 @@ c_compatibility_builddir = . @GLIBCXX_C_HEADERS_C_GLOBAL_TRUE@c_compatibility_headers = \ @GLIBCXX_C_HEADERS_C_GLOBAL_TRUE@ ${c_compatibility_srcdir}/complex.h \ @GLIBCXX_C_HEADERS_C_GLOBAL_TRUE@ ${c_compatibility_srcdir}/fenv.h \ -@GLIBCXX_C_HEADERS_C_GLOBAL_TRUE@ ${c_compatibility_srcdir}/tgmath.h \ -@GLIBCXX_C_HEADERS_C_GLOBAL_TRUE@ ${c_compatibility_srcdir}/stdatomic.h +@GLIBCXX_C_HEADERS_C_GLOBAL_TRUE@ ${c_compatibility_srcdir}/tgmath.h @GLIBCXX_C_HEADERS_C_STD_TRUE@c_compatibility_headers = @GLIBCXX_C_HEADERS_C_TRUE@c_compatibility_headers = \ diff --git a/libstdc++-v3/include/bits/allocator.h b/libstdc++-v3/include/bits/allocator.h index e73ab7ea5cd..70327acd25b 100644 --- a/libstdc++-v3/include/bits/allocator.h +++ b/libstdc++-v3/include/bits/allocator.h @@ -208,7 +208,7 @@ _GLIBCXX_BEGIN_NAMESPACE(std) /// [allocator.tag] struct allocator_arg_t { }; - static const allocator_arg_t allocator_arg = allocator_arg_t(); + constexpr allocator_arg_t allocator_arg = allocator_arg_t(); _GLIBCXX_HAS_NESTED_TYPE(allocator_type) diff --git a/libstdc++-v3/include/bits/atomic_0.h b/libstdc++-v3/include/bits/atomic_0.h index a39de4a7926..cd73e43caef 100644 --- a/libstdc++-v3/include/bits/atomic_0.h +++ b/libstdc++-v3/include/bits/atomic_0.h @@ -1,6 +1,6 @@ // -*- C++ -*- header. -// Copyright (C) 2008, 2009 +// Copyright (C) 2008, 2009, 2010 // Free Software Foundation, Inc. // // This file is part of the GNU ISO C++ Library. This library is free @@ -33,24 +33,42 @@ #pragma GCC system_header -// _GLIBCXX_BEGIN_NAMESPACE(std) +_GLIBCXX_BEGIN_NAMESPACE(std) - // 0 == __atomic0 == Never lock-free +// 0 == __atomic0 == Never lock-free namespace __atomic0 { - struct atomic_flag; + _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) \ - ({__typeof__ _ATOMIC_MEMBER_* __p = &_ATOMIC_MEMBER_; \ + ({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); \ - __typeof__ _ATOMIC_MEMBER_ __r = *__p; \ + __i_type __r = *__p; \ atomic_flag_clear_explicit(__g, __x); \ __r; }) #define _ATOMIC_STORE_(__a, __m, __x) \ - ({__typeof__ _ATOMIC_MEMBER_* __p = &_ATOMIC_MEMBER_; \ + ({typedef __typeof__(_ATOMIC_MEMBER_) __i_type; \ + __i_type* __p = &_ATOMIC_MEMBER_; \ __typeof__(__m) __v = (__m); \ __atomic_flag_base* __g = __atomic_flag_for_address(__p); \ __atomic_flag_wait_explicit(__g, __x); \ @@ -59,34 +77,42 @@ namespace __atomic0 __v; }) #define _ATOMIC_MODIFY_(__a, __o, __m, __x) \ - ({__typeof__ _ATOMIC_MEMBER_* __p = &_ATOMIC_MEMBER_; \ + ({typedef __typeof__(_ATOMIC_MEMBER_) __i_type; \ + __i_type* __p = &_ATOMIC_MEMBER_; \ __typeof__(__m) __v = (__m); \ __atomic_flag_base* __g = __atomic_flag_for_address(__p); \ __atomic_flag_wait_explicit(__g, __x); \ - __typeof__ _ATOMIC_MEMBER_ __r = *__p; \ + __i_type __r = *__p; \ *__p __o __v; \ atomic_flag_clear_explicit(__g, __x); \ __r; }) #define _ATOMIC_CMPEXCHNG_(__a, __e, __m, __x) \ - ({__typeof__ _ATOMIC_MEMBER_* __p = &_ATOMIC_MEMBER_; \ + ({typedef __typeof__(_ATOMIC_MEMBER_) __i_type; \ + __i_type* __p = &_ATOMIC_MEMBER_; \ __typeof__(__e) __q = (__e); \ __typeof__(__m) __v = (__m); \ bool __r; \ __atomic_flag_base* __g = __atomic_flag_for_address(__p); \ __atomic_flag_wait_explicit(__g, __x); \ - __typeof__ _ATOMIC_MEMBER_ __t__ = *__p; \ - if (__t__ == *__q) { *__p = __v; __r = true; } \ - else { *__q = __t__; __r = false; } \ + __i_type __t = *__p; \ + if (*__q == __t) \ + { \ + *__p = const_cast<__i_type>(__v); \ + __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() = default; ~atomic_flag() = 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. @@ -95,11 +121,18 @@ namespace __atomic0 bool test_and_set(memory_order __m = memory_order_seq_cst); + bool + test_and_set(memory_order __m = memory_order_seq_cst) volatile; + void clear(memory_order __m = memory_order_seq_cst); + + void + clear(memory_order __m = memory_order_seq_cst) volatile; }; - /// 29.4.2, address types + + /// atomic_address struct atomic_address { private: @@ -109,13 +142,16 @@ namespace __atomic0 atomic_address() = default; ~atomic_address() = default; atomic_address(const atomic_address&) = delete; + atomic_address& operator=(const atomic_address&) = delete; atomic_address& operator=(const atomic_address&) volatile = delete; - atomic_address(void* __v) { _M_i = __v; } + constexpr atomic_address(void* __v): _M_i (__v) { } + + bool + is_lock_free() const { return false; } bool - is_lock_free() const - { return false; } + is_lock_free() const volatile { return false; } void store(void* __v, memory_order __m = memory_order_seq_cst) @@ -126,6 +162,15 @@ namespace __atomic0 _ATOMIC_STORE_(this, __v, __m); } + void + store(void* __v, memory_order __m = memory_order_seq_cst) volatile + { + __glibcxx_assert(__m != memory_order_acquire); + __glibcxx_assert(__m != memory_order_acq_rel); + __glibcxx_assert(__m != memory_order_consume); + _ATOMIC_STORE_(this, __v, __m); + } + void* load(memory_order __m = memory_order_seq_cst) const { @@ -135,9 +180,21 @@ namespace __atomic0 } void* + load(memory_order __m = memory_order_seq_cst) const volatile + { + __glibcxx_assert(__m != memory_order_release); + __glibcxx_assert(__m != memory_order_acq_rel); + return _ATOMIC_LOAD_(this, __m); + } + + void* exchange(void* __v, memory_order __m = memory_order_seq_cst) { return _ATOMIC_MODIFY_(this, =, __v, __m); } + void* + exchange(void* __v, memory_order __m = memory_order_seq_cst) volatile + { return _ATOMIC_MODIFY_(this, =, __v, __m); } + bool compare_exchange_weak(void*& __v1, void* __v2, memory_order __m1, memory_order __m2) @@ -149,6 +206,16 @@ namespace __atomic0 } bool + compare_exchange_weak(void*& __v1, void* __v2, memory_order __m1, + memory_order __m2) volatile + { + __glibcxx_assert(__m2 != memory_order_release); + __glibcxx_assert(__m2 != memory_order_acq_rel); + __glibcxx_assert(__m2 <= __m1); + return _ATOMIC_CMPEXCHNG_(this, &__v1, __v2, __m1); + } + + bool compare_exchange_weak(void*& __v1, void* __v2, memory_order __m = memory_order_seq_cst) { @@ -157,6 +224,50 @@ namespace __atomic0 } bool + compare_exchange_weak(void*& __v1, void* __v2, + memory_order __m = memory_order_seq_cst) volatile + { + return compare_exchange_weak(__v1, __v2, __m, + __calculate_memory_order(__m)); + } + + bool + compare_exchange_weak(const void*& __v1, const void* __v2, + memory_order __m1, memory_order __m2) + { + __glibcxx_assert(__m2 != memory_order_release); + __glibcxx_assert(__m2 != memory_order_acq_rel); + __glibcxx_assert(__m2 <= __m1); + return _ATOMIC_CMPEXCHNG_(this, &__v1, __v2, __m1); + } + + bool + compare_exchange_weak(const void*& __v1, const void* __v2, + memory_order __m1, memory_order __m2) volatile + { + __glibcxx_assert(__m2 != memory_order_release); + __glibcxx_assert(__m2 != memory_order_acq_rel); + __glibcxx_assert(__m2 <= __m1); + return _ATOMIC_CMPEXCHNG_(this, &__v1, __v2, __m1); + } + + bool + compare_exchange_weak(const void*& __v1, const void* __v2, + memory_order __m = memory_order_seq_cst) + { + return compare_exchange_weak(__v1, __v2, __m, + __calculate_memory_order(__m)); + } + + bool + compare_exchange_weak(const void*& __v1, const void* __v2, + memory_order __m = memory_order_seq_cst) volatile + { + return compare_exchange_weak(__v1, __v2, __m, + __calculate_memory_order(__m)); + } + + bool compare_exchange_strong(void*& __v1, void* __v2, memory_order __m1, memory_order __m2) { @@ -167,8 +278,62 @@ namespace __atomic0 } bool + compare_exchange_strong(void*& __v1, void* __v2, memory_order __m1, + memory_order __m2) volatile + { + __glibcxx_assert(__m2 != memory_order_release); + __glibcxx_assert(__m2 != memory_order_acq_rel); + __glibcxx_assert(__m2 <= __m1); + return _ATOMIC_CMPEXCHNG_(this, &__v1, __v2, __m1); + } + + bool compare_exchange_strong(void*& __v1, void* __v2, - memory_order __m = memory_order_seq_cst) + memory_order __m = memory_order_seq_cst) + { + return compare_exchange_strong(__v1, __v2, __m, + __calculate_memory_order(__m)); + } + + bool + compare_exchange_strong(void*& __v1, void* __v2, + memory_order __m = memory_order_seq_cst) volatile + { + return compare_exchange_strong(__v1, __v2, __m, + __calculate_memory_order(__m)); + } + + bool + compare_exchange_strong(const void*& __v1, const void* __v2, + memory_order __m1, memory_order __m2) + { + __glibcxx_assert(__m2 != memory_order_release); + __glibcxx_assert(__m2 != memory_order_acq_rel); + __glibcxx_assert(__m2 <= __m1); + return _ATOMIC_CMPEXCHNG_(this, &__v1, __v2, __m1); + } + + bool + compare_exchange_strong(const void*& __v1, const void* __v2, + memory_order __m1, memory_order __m2) volatile + { + __glibcxx_assert(__m2 != memory_order_release); + __glibcxx_assert(__m2 != memory_order_acq_rel); + __glibcxx_assert(__m2 <= __m1); + return _ATOMIC_CMPEXCHNG_(this, &__v1, __v2, __m1); + } + + bool + compare_exchange_strong(const void*& __v1, const void* __v2, + memory_order __m = memory_order_seq_cst) + { + return compare_exchange_strong(__v1, __v2, __m, + __calculate_memory_order(__m)); + } + + bool + compare_exchange_strong(const void*& __v1, const void* __v2, + memory_order __m = memory_order_seq_cst) volatile { return compare_exchange_strong(__v1, __v2, __m, __calculate_memory_order(__m)); @@ -187,6 +352,18 @@ namespace __atomic0 } void* + fetch_add(ptrdiff_t __d, memory_order __m = memory_order_seq_cst) volatile + { + void* volatile* __p = &(_M_i); + __atomic_flag_base* __g = __atomic_flag_for_address(__p); + __atomic_flag_wait_explicit(__g, __m); + void* __r = *__p; + *__p = (void*)((char*)(*__p) + __d); + atomic_flag_clear_explicit(__g, __m); + return __r; + } + + void* fetch_sub(ptrdiff_t __d, memory_order __m = memory_order_seq_cst) { void** __p = &(_M_i); @@ -198,9 +375,25 @@ namespace __atomic0 return __r; } + void* + fetch_sub(ptrdiff_t __d, memory_order __m = memory_order_seq_cst) volatile + { + void* volatile* __p = &(_M_i); + __atomic_flag_base* __g = __atomic_flag_for_address(__p); + __atomic_flag_wait_explicit(__g, __m); + void* __r = *__p; + *__p = (void*)((char*)(*__p) - __d); + atomic_flag_clear_explicit(__g, __m); + return __r; + } + operator void*() const { return load(); } + operator void*() const volatile + { return load(); } + + // XXX void* operator=(void* __v) { @@ -209,16 +402,32 @@ namespace __atomic0 } void* + operator=(void* __v) volatile + { + store(__v); + return __v; + } + + void* operator+=(ptrdiff_t __d) { return fetch_add(__d) + __d; } void* + operator+=(ptrdiff_t __d) volatile + { return fetch_add(__d) + __d; } + + void* operator-=(ptrdiff_t __d) { return fetch_sub(__d) - __d; } + + void* + operator-=(ptrdiff_t __d) volatile + { return fetch_sub(__d) - __d; } }; - // 29.3.1 atomic integral types + /// Base class for atomic integrals. + // // For each of the integral types, define atomic_[integral type] struct // // atomic_bool bool @@ -244,71 +453,131 @@ namespace __atomic0 struct __atomic_base { private: - typedef _ITp __integral_type; + typedef _ITp __int_type; - __integral_type _M_i; + __int_type _M_i; public: __atomic_base() = default; ~__atomic_base() = default; __atomic_base(const __atomic_base&) = delete; + __atomic_base& operator=(const __atomic_base&) = delete; __atomic_base& operator=(const __atomic_base&) volatile = delete; - // Requires __integral_type convertible to _M_base._M_i. - __atomic_base(__integral_type __i) { _M_i = __i; } + // Requires __int_type convertible to _M_base._M_i. + constexpr __atomic_base(__int_type __i): _M_i (__i) { } - operator __integral_type() const + operator __int_type() const { return load(); } - __integral_type - operator=(__integral_type __i) + operator __int_type() const volatile + { return load(); } + + __int_type + operator=(__int_type __i) { store(__i); return __i; } - __integral_type + __int_type + operator=(__int_type __i) volatile + { + store(__i); + return __i; + } + + __int_type operator++(int) { return fetch_add(1); } - __integral_type + __int_type + operator++(int) volatile + { return fetch_add(1); } + + __int_type operator--(int) { return fetch_sub(1); } - __integral_type + __int_type + operator--(int) volatile + { return fetch_sub(1); } + + __int_type operator++() { return fetch_add(1) + 1; } - __integral_type + __int_type + operator++() volatile + { return fetch_add(1) + 1; } + + __int_type operator--() { return fetch_sub(1) - 1; } - __integral_type - operator+=(__integral_type __i) + __int_type + operator--() volatile + { return fetch_sub(1) - 1; } + + __int_type + operator+=(__int_type __i) { return fetch_add(__i) + __i; } - __integral_type - operator-=(__integral_type __i) + __int_type + operator+=(__int_type __i) volatile + { return fetch_add(__i) + __i; } + + __int_type + operator-=(__int_type __i) { return fetch_sub(__i) - __i; } - __integral_type - operator&=(__integral_type __i) + __int_type + operator-=(__int_type __i) volatile + { return fetch_sub(__i) - __i; } + + __int_type + operator&=(__int_type __i) + { return fetch_and(__i) & __i; } + + __int_type + operator&=(__int_type __i) volatile { return fetch_and(__i) & __i; } - __integral_type - operator|=(__integral_type __i) + __int_type + operator|=(__int_type __i) { return fetch_or(__i) | __i; } - __integral_type - operator^=(__integral_type __i) + __int_type + operator|=(__int_type __i) volatile + { return fetch_or(__i) | __i; } + + __int_type + operator^=(__int_type __i) + { return fetch_xor(__i) ^ __i; } + + __int_type + operator^=(__int_type __i) volatile { return fetch_xor(__i) ^ __i; } bool is_lock_free() const { return false; } + bool + is_lock_free() const volatile + { return false; } + + void + store(__int_type __i, memory_order __m = memory_order_seq_cst) + { + __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(__integral_type __i, memory_order __m = memory_order_seq_cst) + store(__int_type __i, memory_order __m = memory_order_seq_cst) volatile { __glibcxx_assert(__m != memory_order_acquire); __glibcxx_assert(__m != memory_order_acq_rel); @@ -316,7 +585,7 @@ namespace __atomic0 _ATOMIC_STORE_(this, __i, __m); } - __integral_type + __int_type load(memory_order __m = memory_order_seq_cst) const { __glibcxx_assert(__m != memory_order_release); @@ -324,12 +593,24 @@ namespace __atomic0 return _ATOMIC_LOAD_(this, __m); } - __integral_type - exchange(__integral_type __i, memory_order __m = memory_order_seq_cst) + __int_type + load(memory_order __m = memory_order_seq_cst) const volatile + { + __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) + { return _ATOMIC_MODIFY_(this, =, __i, __m); } + + __int_type + exchange(__int_type __i, memory_order __m = memory_order_seq_cst) volatile { return _ATOMIC_MODIFY_(this, =, __i, __m); } bool - compare_exchange_weak(__integral_type& __i1, __integral_type __i2, + compare_exchange_weak(__int_type& __i1, __int_type __i2, memory_order __m1, memory_order __m2) { __glibcxx_assert(__m2 != memory_order_release); @@ -339,7 +620,17 @@ namespace __atomic0 } bool - compare_exchange_weak(__integral_type& __i1, __integral_type __i2, + compare_exchange_weak(__int_type& __i1, __int_type __i2, + memory_order __m1, memory_order __m2) volatile + { + __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) { return compare_exchange_weak(__i1, __i2, __m, @@ -347,7 +638,15 @@ namespace __atomic0 } bool - compare_exchange_strong(__integral_type& __i1, __integral_type __i2, + compare_exchange_weak(__int_type& __i1, __int_type __i2, + memory_order __m = memory_order_seq_cst) volatile + { + 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) { __glibcxx_assert(__m2 != memory_order_release); @@ -357,94 +656,75 @@ namespace __atomic0 } bool - compare_exchange_strong(__integral_type& __i1, __integral_type __i2, + compare_exchange_strong(__int_type& __i1, __int_type __i2, + memory_order __m1, memory_order __m2) volatile + { + __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) { return compare_exchange_strong(__i1, __i2, __m, __calculate_memory_order(__m)); } - __integral_type - fetch_add(__integral_type __i, memory_order __m = memory_order_seq_cst) - { return _ATOMIC_MODIFY_(this, +=, __i, __m); } - - __integral_type - fetch_sub(__integral_type __i, memory_order __m = memory_order_seq_cst) - { return _ATOMIC_MODIFY_(this, -=, __i, __m); } - - __integral_type - fetch_and(__integral_type __i, memory_order __m = memory_order_seq_cst) - { return _ATOMIC_MODIFY_(this, &=, __i, __m); } - - __integral_type - fetch_or(__integral_type __i, memory_order __m = memory_order_seq_cst) - { return _ATOMIC_MODIFY_(this, |=, __i, __m); } - - __integral_type - fetch_xor(__integral_type __i, memory_order __m = memory_order_seq_cst) - { return _ATOMIC_MODIFY_(this, ^=, __i, __m); } - }; - - - /// atomic_bool - // NB: No operators or fetch-operations for this type. - struct atomic_bool - { - private: - __atomic_base<bool> _M_base; - - public: - atomic_bool() = default; - ~atomic_bool() = default; - atomic_bool(const atomic_bool&) = delete; - atomic_bool& operator=(const atomic_bool&) volatile = delete; - - atomic_bool(bool __i) : _M_base(__i) { } - - bool - operator=(bool __i) - { return _M_base.operator=(__i); } + bool + compare_exchange_strong(__int_type& __i1, __int_type __i2, + memory_order __m = memory_order_seq_cst) volatile + { + return compare_exchange_strong(__i1, __i2, __m, + __calculate_memory_order(__m)); + } - operator bool() const - { return _M_base.load(); } + __int_type + fetch_add(__int_type __i, memory_order __m = memory_order_seq_cst) + { return _ATOMIC_MODIFY_(this, +=, __i, __m); } - bool - is_lock_free() const - { return _M_base.is_lock_free(); } + __int_type + fetch_add(__int_type __i, + memory_order __m = memory_order_seq_cst) volatile + { return _ATOMIC_MODIFY_(this, +=, __i, __m); } - void - store(bool __i, memory_order __m = memory_order_seq_cst) - { _M_base.store(__i, __m); } + __int_type + fetch_sub(__int_type __i, memory_order __m = memory_order_seq_cst) + { return _ATOMIC_MODIFY_(this, -=, __i, __m); } - bool - load(memory_order __m = memory_order_seq_cst) const - { return _M_base.load(__m); } + __int_type + fetch_sub(__int_type __i, + memory_order __m = memory_order_seq_cst) volatile + { return _ATOMIC_MODIFY_(this, -=, __i, __m); } - bool - exchange(bool __i, memory_order __m = memory_order_seq_cst) - { return _M_base.exchange(__i, __m); } + __int_type + fetch_and(__int_type __i, memory_order __m = memory_order_seq_cst) + { return _ATOMIC_MODIFY_(this, &=, __i, __m); } - bool - compare_exchange_weak(bool& __i1, bool __i2, memory_order __m1, - memory_order __m2) - { return _M_base.compare_exchange_weak(__i1, __i2, __m1, __m2); } + __int_type + fetch_and(__int_type __i, + memory_order __m = memory_order_seq_cst) volatile + { return _ATOMIC_MODIFY_(this, &=, __i, __m); } - bool - compare_exchange_weak(bool& __i1, bool __i2, - memory_order __m = memory_order_seq_cst) - { return _M_base.compare_exchange_weak(__i1, __i2, __m); } + __int_type + fetch_or(__int_type __i, memory_order __m = memory_order_seq_cst) + { return _ATOMIC_MODIFY_(this, |=, __i, __m); } - bool - compare_exchange_strong(bool& __i1, bool __i2, memory_order __m1, - memory_order __m2) - { return _M_base.compare_exchange_strong(__i1, __i2, __m1, __m2); } + __int_type + fetch_or(__int_type __i, memory_order __m = memory_order_seq_cst) volatile + { return _ATOMIC_MODIFY_(this, |=, __i, __m); } + __int_type + fetch_xor(__int_type __i, memory_order __m = memory_order_seq_cst) + { return _ATOMIC_MODIFY_(this, ^=, __i, __m); } - bool - compare_exchange_strong(bool& __i1, bool __i2, - memory_order __m = memory_order_seq_cst) - { return _M_base.compare_exchange_strong(__i1, __i2, __m); } - }; + __int_type + fetch_xor(__int_type __i, + memory_order __m = memory_order_seq_cst) volatile + { return _ATOMIC_MODIFY_(this, ^=, __i, __m); } + }; #undef _ATOMIC_LOAD_ #undef _ATOMIC_STORE_ @@ -452,6 +732,6 @@ namespace __atomic0 #undef _ATOMIC_CMPEXCHNG_ } // namespace __atomic0 -// _GLIBCXX_END_NAMESPACE +_GLIBCXX_END_NAMESPACE #endif diff --git a/libstdc++-v3/include/bits/atomic_2.h b/libstdc++-v3/include/bits/atomic_2.h index fa6c0d5b9d6..e4cf24dc94d 100644 --- a/libstdc++-v3/include/bits/atomic_2.h +++ b/libstdc++-v3/include/bits/atomic_2.h @@ -1,6 +1,6 @@ // -*- C++ -*- header. -// Copyright (C) 2008, 2009 +// Copyright (C) 2008, 2009, 2010 // Free Software Foundation, Inc. // // This file is part of the GNU ISO C++ Library. This library is free @@ -33,7 +33,7 @@ #pragma GCC system_header -// _GLIBCXX_BEGIN_NAMESPACE(std) +_GLIBCXX_BEGIN_NAMESPACE(std) // 2 == __atomic2 == Always lock-free // Assumed: @@ -49,6 +49,7 @@ namespace __atomic2 atomic_flag() = default; ~atomic_flag() = 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. @@ -63,6 +64,15 @@ namespace __atomic2 return __sync_lock_test_and_set(&_M_i, 1); } + bool + test_and_set(memory_order __m = memory_order_seq_cst) volatile + { + // 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) { @@ -74,10 +84,22 @@ namespace __atomic2 if (__m != memory_order_acquire && __m != memory_order_acq_rel) __sync_synchronize(); } + + void + clear(memory_order __m = memory_order_seq_cst) volatile + { + __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(); + } }; - /// 29.4.2, address types + /// atomic_address struct atomic_address { private: @@ -87,13 +109,16 @@ namespace __atomic2 atomic_address() = default; ~atomic_address() = default; atomic_address(const atomic_address&) = delete; + atomic_address& operator=(const atomic_address&) = delete; atomic_address& operator=(const atomic_address&) volatile = delete; - atomic_address(void* __v) { _M_i = __v; } + constexpr atomic_address(void* __v): _M_i (__v) { } bool - is_lock_free() const - { return true; } + is_lock_free() const { return true; } + + bool + is_lock_free() const volatile { return true; } void store(void* __v, memory_order __m = memory_order_seq_cst) @@ -113,6 +138,24 @@ namespace __atomic2 } } + void + store(void* __v, memory_order __m = memory_order_seq_cst) volatile + { + __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 = __v; + else + { + // write_mem_barrier(); + _M_i = __v; + if (__m == memory_order_seq_cst) + __sync_synchronize(); + } + } + void* load(memory_order __m = memory_order_seq_cst) const { @@ -126,19 +169,69 @@ namespace __atomic2 } void* + load(memory_order __m = memory_order_seq_cst) const volatile + { + __glibcxx_assert(__m != memory_order_release); + __glibcxx_assert(__m != memory_order_acq_rel); + + __sync_synchronize(); + void* __ret = _M_i; + __sync_synchronize(); + return __ret; + } + + void* exchange(void* __v, memory_order __m = memory_order_seq_cst) { // XXX built-in assumes memory_order_acquire. return __sync_lock_test_and_set(&_M_i, __v); } + void* + exchange(void* __v, memory_order __m = memory_order_seq_cst) volatile + { + // XXX built-in assumes memory_order_acquire. + return __sync_lock_test_and_set(&_M_i, __v); + } + bool compare_exchange_weak(void*& __v1, void* __v2, memory_order __m1, memory_order __m2) { return compare_exchange_strong(__v1, __v2, __m1, __m2); } bool + compare_exchange_weak(void*& __v1, void* __v2, memory_order __m1, + memory_order __m2) volatile + { return compare_exchange_strong(__v1, __v2, __m1, __m2); } + + bool + compare_exchange_weak(void*& __v1, void* __v2, + memory_order __m = memory_order_seq_cst) + { + return compare_exchange_weak(__v1, __v2, __m, + __calculate_memory_order(__m)); + } + + bool compare_exchange_weak(void*& __v1, void* __v2, + memory_order __m = memory_order_seq_cst) volatile + { + return compare_exchange_weak(__v1, __v2, __m, + __calculate_memory_order(__m)); + } + + bool + compare_exchange_weak(const void*& __v1, const void* __v2, + memory_order __m1, memory_order __m2) + { return compare_exchange_strong(__v1, __v2, __m1, __m2); } + + bool + compare_exchange_weak(const void*& __v1, const void* __v2, + memory_order __m1, memory_order __m2) volatile + { return compare_exchange_strong(__v1, __v2, __m1, __m2); } + + bool + compare_exchange_weak(const void*& __v1, const void* __v2, memory_order __m = memory_order_seq_cst) { return compare_exchange_weak(__v1, __v2, __m, @@ -146,6 +239,14 @@ namespace __atomic2 } bool + compare_exchange_weak(const void*& __v1, const void* __v2, + memory_order __m = memory_order_seq_cst) volatile + { + return compare_exchange_weak(__v1, __v2, __m, + __calculate_memory_order(__m)); + } + + bool compare_exchange_strong(void*& __v1, void* __v2, memory_order __m1, memory_order __m2) { @@ -162,8 +263,80 @@ namespace __atomic2 } bool + compare_exchange_strong(void*& __v1, void* __v2, memory_order __m1, + memory_order __m2) volatile + { + __glibcxx_assert(__m2 != memory_order_release); + __glibcxx_assert(__m2 != memory_order_acq_rel); + __glibcxx_assert(__m2 <= __m1); + + void* __v1o = __v1; + void* __v1n = __sync_val_compare_and_swap(&_M_i, __v1o, __v2); + + // Assume extra stores (of same value) allowed in true case. + __v1 = __v1n; + return __v1o == __v1n; + } + + bool compare_exchange_strong(void*& __v1, void* __v2, - memory_order __m = memory_order_seq_cst) + memory_order __m = memory_order_seq_cst) + { + return compare_exchange_strong(__v1, __v2, __m, + __calculate_memory_order(__m)); + } + + bool + compare_exchange_strong(void*& __v1, void* __v2, + memory_order __m = memory_order_seq_cst) volatile + { + return compare_exchange_strong(__v1, __v2, __m, + __calculate_memory_order(__m)); + } + + bool + compare_exchange_strong(const void*& __v1, const void* __v2, + memory_order __m1, memory_order __m2) + { + __glibcxx_assert(__m2 != memory_order_release); + __glibcxx_assert(__m2 != memory_order_acq_rel); + __glibcxx_assert(__m2 <= __m1); + + const void* __v1o = __v1; + const void* __v1n = __sync_val_compare_and_swap(&_M_i, __v1o, __v2); + + // Assume extra stores (of same value) allowed in true case. + __v1 = __v1n; + return __v1o == __v1n; + } + + bool + compare_exchange_strong(const void*& __v1, const void* __v2, + memory_order __m1, memory_order __m2) volatile + { + __glibcxx_assert(__m2 != memory_order_release); + __glibcxx_assert(__m2 != memory_order_acq_rel); + __glibcxx_assert(__m2 <= __m1); + + const void* __v1o = __v1; + const void* __v1n = __sync_val_compare_and_swap(&_M_i, __v1o, __v2); + + // Assume extra stores (of same value) allowed in true case. + __v1 = __v1n; + return __v1o == __v1n; + } + + bool + compare_exchange_strong(const void*& __v1, const void* __v2, + memory_order __m = memory_order_seq_cst) + { + return compare_exchange_strong(__v1, __v2, __m, + __calculate_memory_order(__m)); + } + + bool + compare_exchange_strong(const void*& __v1, const void* __v2, + memory_order __m = memory_order_seq_cst) volatile { return compare_exchange_strong(__v1, __v2, __m, __calculate_memory_order(__m)); @@ -174,14 +347,46 @@ namespace __atomic2 { return __sync_fetch_and_add(&_M_i, __d); } void* + fetch_add(ptrdiff_t __d, memory_order __m = memory_order_seq_cst) volatile + { return __sync_fetch_and_add(&_M_i, __d); } + + void* fetch_sub(ptrdiff_t __d, memory_order __m = memory_order_seq_cst) { return __sync_fetch_and_sub(&_M_i, __d); } + void* + fetch_sub(ptrdiff_t __d, memory_order __m = memory_order_seq_cst) volatile + { return __sync_fetch_and_sub(&_M_i, __d); } + operator void*() const { return load(); } + operator void*() const volatile + { return load(); } + void* - operator=(void* __v) +#if 0 + // XXX as specified but won't compile as store takes void*, + // invalid conversion from const void* to void* + // CD1 had this signature + operator=(const void* __v) +#else + operator=(void* __v) +#endif + { + store(__v); + return __v; + } + + void* +#if 0 + // XXX as specified but won't compile as store takes void*, + // invalid conversion from const void* to void* + // CD1 had this signature, but store and this could both be const void*? + operator=(const void* __v) volatile +#else + operator=(void* __v) volatile +#endif { store(__v); return __v; @@ -192,11 +397,21 @@ namespace __atomic2 { return __sync_add_and_fetch(&_M_i, __d); } void* + operator+=(ptrdiff_t __d) volatile + { return __sync_add_and_fetch(&_M_i, __d); } + + void* operator-=(ptrdiff_t __d) { return __sync_sub_and_fetch(&_M_i, __d); } + + void* + operator-=(ptrdiff_t __d) volatile + { return __sync_sub_and_fetch(&_M_i, __d); } }; - // 29.3.1 atomic integral types + + /// Base class for atomic integrals. + // // For each of the integral types, define atomic_[integral type] struct // // atomic_bool bool @@ -214,79 +429,148 @@ namespace __atomic2 // 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. + // + // 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 __integral_type; + typedef _ITp __int_type; - __integral_type _M_i; + __int_type _M_i; public: __atomic_base() = default; ~__atomic_base() = default; __atomic_base(const __atomic_base&) = delete; + __atomic_base& operator=(const __atomic_base&) = delete; __atomic_base& operator=(const __atomic_base&) volatile = delete; - // Requires __integral_type convertible to _M_base._M_i. - __atomic_base(__integral_type __i) { _M_i = __i; } + // Requires __int_type convertible to _M_i. + constexpr __atomic_base(__int_type __i): _M_i (__i) { } - operator __integral_type() const + operator __int_type() const { return load(); } - __integral_type - operator=(__integral_type __i) + operator __int_type() const volatile + { return load(); } + + __int_type + operator=(__int_type __i) + { + store(__i); + return __i; + } + + __int_type + operator=(__int_type __i) volatile { store(__i); return __i; } - __integral_type + __int_type operator++(int) { return fetch_add(1); } - __integral_type + __int_type + operator++(int) volatile + { return fetch_add(1); } + + __int_type operator--(int) { return fetch_sub(1); } - __integral_type + __int_type + operator--(int) volatile + { return fetch_sub(1); } + + __int_type operator++() { return __sync_add_and_fetch(&_M_i, 1); } - __integral_type + __int_type + operator++() volatile + { return __sync_add_and_fetch(&_M_i, 1); } + + __int_type operator--() { return __sync_sub_and_fetch(&_M_i, 1); } - __integral_type - operator+=(__integral_type __i) + __int_type + operator--() volatile + { return __sync_sub_and_fetch(&_M_i, 1); } + + __int_type + operator+=(__int_type __i) + { return __sync_add_and_fetch(&_M_i, __i); } + + __int_type + operator+=(__int_type __i) volatile { return __sync_add_and_fetch(&_M_i, __i); } - __integral_type - operator-=(__integral_type __i) + __int_type + operator-=(__int_type __i) { return __sync_sub_and_fetch(&_M_i, __i); } - __integral_type - operator&=(__integral_type __i) + __int_type + operator-=(__int_type __i) volatile + { return __sync_sub_and_fetch(&_M_i, __i); } + + __int_type + operator&=(__int_type __i) { return __sync_and_and_fetch(&_M_i, __i); } - __integral_type - operator|=(__integral_type __i) + __int_type + operator&=(__int_type __i) volatile + { return __sync_and_and_fetch(&_M_i, __i); } + + __int_type + operator|=(__int_type __i) + { return __sync_or_and_fetch(&_M_i, __i); } + + __int_type + operator|=(__int_type __i) volatile { return __sync_or_and_fetch(&_M_i, __i); } - __integral_type - operator^=(__integral_type __i) + __int_type + operator^=(__int_type __i) + { return __sync_xor_and_fetch(&_M_i, __i); } + + __int_type + operator^=(__int_type __i) volatile { return __sync_xor_and_fetch(&_M_i, __i); } bool is_lock_free() const { return true; } + bool + is_lock_free() const volatile + { return true; } + + void + store(__int_type __i, memory_order __m = memory_order_seq_cst) + { + __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(__integral_type __i, memory_order __m = memory_order_seq_cst) + store(__int_type __i, memory_order __m = memory_order_seq_cst) volatile { __glibcxx_assert(__m != memory_order_acquire); __glibcxx_assert(__m != memory_order_acq_rel); @@ -303,32 +587,57 @@ namespace __atomic2 } } - __integral_type - load(memory_order __m = memory_order_seq_cst) const + __int_type + load(memory_order __m = memory_order_seq_cst) const { __glibcxx_assert(__m != memory_order_release); __glibcxx_assert(__m != memory_order_acq_rel); __sync_synchronize(); - __integral_type __ret = _M_i; + __int_type __ret = _M_i; __sync_synchronize(); return __ret; } - __integral_type - exchange(__integral_type __i, memory_order __m = memory_order_seq_cst) + __int_type + load(memory_order __m = memory_order_seq_cst) const volatile + { + __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) + { + // 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 { // XXX built-in assumes memory_order_acquire. return __sync_lock_test_and_set(&_M_i, __i); } bool - compare_exchange_weak(__integral_type& __i1, __integral_type __i2, + compare_exchange_weak(__int_type& __i1, __int_type __i2, memory_order __m1, memory_order __m2) { return compare_exchange_strong(__i1, __i2, __m1, __m2); } bool - compare_exchange_weak(__integral_type& __i1, __integral_type __i2, + compare_exchange_weak(__int_type& __i1, __int_type __i2, + memory_order __m1, memory_order __m2) volatile + { 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) { return compare_exchange_weak(__i1, __i2, __m, @@ -336,15 +645,39 @@ namespace __atomic2 } bool - compare_exchange_strong(__integral_type& __i1, __integral_type __i2, - memory_order __m1, memory_order __m2) + compare_exchange_weak(__int_type& __i1, __int_type __i2, + memory_order __m = memory_order_seq_cst) volatile + { + 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) + { + __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 { __glibcxx_assert(__m2 != memory_order_release); __glibcxx_assert(__m2 != memory_order_acq_rel); __glibcxx_assert(__m2 <= __m1); - __integral_type __i1o = __i1; - __integral_type __i1n = __sync_val_compare_and_swap(&_M_i, __i1o, __i2); + __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; @@ -352,101 +685,68 @@ namespace __atomic2 } bool - compare_exchange_strong(__integral_type& __i1, __integral_type __i2, + compare_exchange_strong(__int_type& __i1, __int_type __i2, memory_order __m = memory_order_seq_cst) { return compare_exchange_strong(__i1, __i2, __m, __calculate_memory_order(__m)); } - __integral_type - fetch_add(__integral_type __i, - memory_order __m = memory_order_seq_cst) - { return __sync_fetch_and_add(&_M_i, __i); } - - __integral_type - fetch_sub(__integral_type __i, - memory_order __m = memory_order_seq_cst) - { return __sync_fetch_and_sub(&_M_i, __i); } - - __integral_type - fetch_and(__integral_type __i, - memory_order __m = memory_order_seq_cst) - { return __sync_fetch_and_and(&_M_i, __i); } - - __integral_type - fetch_or(__integral_type __i, - memory_order __m = memory_order_seq_cst) - { return __sync_fetch_and_or(&_M_i, __i); } - - __integral_type - fetch_xor(__integral_type __i, - memory_order __m = memory_order_seq_cst) - { return __sync_fetch_and_xor(&_M_i, __i); } - }; - - - /// atomic_bool - // NB: No operators or fetch-operations for this type. - struct atomic_bool - { - private: - __atomic_base<bool> _M_base; - - public: - atomic_bool() = default; - ~atomic_bool() = default; - atomic_bool(const atomic_bool&) = delete; - atomic_bool& operator=(const atomic_bool&) volatile = delete; - - atomic_bool(bool __i) : _M_base(__i) { } - - bool - operator=(bool __i) - { return _M_base.operator=(__i); } + bool + compare_exchange_strong(__int_type& __i1, __int_type __i2, + memory_order __m = memory_order_seq_cst) volatile + { + return compare_exchange_strong(__i1, __i2, __m, + __calculate_memory_order(__m)); + } - operator bool() const - { return _M_base.load(); } + __int_type + fetch_add(__int_type __i, memory_order __m = memory_order_seq_cst) + { return __sync_fetch_and_add(&_M_i, __i); } - bool - is_lock_free() const - { return _M_base.is_lock_free(); } + __int_type + fetch_add(__int_type __i, + memory_order __m = memory_order_seq_cst) volatile + { return __sync_fetch_and_add(&_M_i, __i); } - void - store(bool __i, memory_order __m = memory_order_seq_cst) - { _M_base.store(__i, __m); } + __int_type + fetch_sub(__int_type __i, memory_order __m = memory_order_seq_cst) + { return __sync_fetch_and_sub(&_M_i, __i); } - bool - load(memory_order __m = memory_order_seq_cst) const - { return _M_base.load(__m); } + __int_type + fetch_sub(__int_type __i, + memory_order __m = memory_order_seq_cst) volatile + { return __sync_fetch_and_sub(&_M_i, __i); } - bool - exchange(bool __i, memory_order __m = memory_order_seq_cst) - { return _M_base.exchange(__i, __m); } + __int_type + fetch_and(__int_type __i, memory_order __m = memory_order_seq_cst) + { return __sync_fetch_and_and(&_M_i, __i); } - bool - compare_exchange_weak(bool& __i1, bool __i2, memory_order __m1, - memory_order __m2) - { return _M_base.compare_exchange_weak(__i1, __i2, __m1, __m2); } + __int_type + fetch_and(__int_type __i, + memory_order __m = memory_order_seq_cst) volatile + { return __sync_fetch_and_and(&_M_i, __i); } - bool - compare_exchange_weak(bool& __i1, bool __i2, - memory_order __m = memory_order_seq_cst) - { return _M_base.compare_exchange_weak(__i1, __i2, __m); } + __int_type + fetch_or(__int_type __i, memory_order __m = memory_order_seq_cst) + { return __sync_fetch_and_or(&_M_i, __i); } - bool - compare_exchange_strong(bool& __i1, bool __i2, memory_order __m1, - memory_order __m2) - { return _M_base.compare_exchange_strong(__i1, __i2, __m1, __m2); } + __int_type + fetch_or(__int_type __i, + memory_order __m = memory_order_seq_cst) volatile + { return __sync_fetch_and_or(&_M_i, __i); } + __int_type + fetch_xor(__int_type __i, memory_order __m = memory_order_seq_cst) + { return __sync_fetch_and_xor(&_M_i, __i); } - bool - compare_exchange_strong(bool& __i1, bool __i2, - memory_order __m = memory_order_seq_cst) - { return _M_base.compare_exchange_strong(__i1, __i2, __m); } - }; + __int_type + fetch_xor(__int_type __i, + memory_order __m = memory_order_seq_cst) volatile + { return __sync_fetch_and_xor(&_M_i, __i); } + }; } // namespace __atomic2 -// _GLIBCXX_END_NAMESPACE +_GLIBCXX_END_NAMESPACE #endif diff --git a/libstdc++-v3/include/bits/atomic_base.h b/libstdc++-v3/include/bits/atomic_base.h index 454699f8175..7c89de22e5d 100644 --- a/libstdc++-v3/include/bits/atomic_base.h +++ b/libstdc++-v3/include/bits/atomic_base.h @@ -1,6 +1,6 @@ -// -*- C++ -*- compatibility header. +// -*- C++ -*- header. -// Copyright (C) 2008, 2009 Free Software Foundation, Inc. +// Copyright (C) 2008, 2009, 2010 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 @@ -23,18 +23,21 @@ // <http://www.gnu.org/licenses/>. /** @file bits/atomic_base.h - * This is a Standard C++ Library header. + * This is an internal header file, included by other library headers. + * You should not attempt to use it directly. */ -#include <bits/c++config.h> -#include <stddef.h> -#include <stdbool.h> // XXX need to define bool w/o stdbool.h in tr1/cstdbool - #ifndef _GLIBCXX_ATOMIC_BASE_H #define _GLIBCXX_ATOMIC_BASE_H 1 +#pragma GCC system_header + +#include <bits/c++config.h> +#include <stddef.h> +#include <stdbool.h> +#include <stdint.h> + _GLIBCXX_BEGIN_NAMESPACE(std) -_GLIBCXX_BEGIN_EXTERN_C /** * @defgroup atomics Atomics @@ -54,15 +57,85 @@ _GLIBCXX_BEGIN_EXTERN_C memory_order_seq_cst } memory_order; - // Base for atomic_flag. - typedef struct __atomic_flag_base + inline memory_order + __calculate_memory_order(memory_order __m) + { + const bool __cond1 = __m == memory_order_release; + const bool __cond2 = __m == memory_order_acq_rel; + memory_order __mo1(__cond1 ? memory_order_relaxed : __m); + memory_order __mo2(__cond2 ? memory_order_acquire : __mo1); + return __mo2; + } + + /// kill_dependency + template<typename _Tp> + inline _Tp + kill_dependency(_Tp __y) + { + _Tp ret(__y); + 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 + + struct __atomic_flag_base { bool _M_i; - } __atomic_flag_base; + }; + + _GLIBCXX_END_EXTERN_C #define ATOMIC_FLAG_INIT { false } - /// 29.2 Lock-free Property + + // 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; + struct atomic_address; + + template<typename _IntTp> + struct __atomic_base; + } + + namespace __atomic2 + { + struct atomic_flag; + struct atomic_address; + + template<typename _IntTp> + struct __atomic_base; + } + + namespace __atomic1 + { + using __atomic2::atomic_flag; + using __atomic0::atomic_address; + 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 @@ -75,150 +148,143 @@ _GLIBCXX_BEGIN_EXTERN_C # define _GLIBCXX_ATOMIC_NAMESPACE __atomic0 #endif -#define ATOMIC_INTEGRAL_LOCK_FREE _GLIBCXX_ATOMIC_PROPERTY +#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 #define ATOMIC_ADDRESS_LOCK_FREE _GLIBCXX_ATOMIC_PROPERTY - // Switch atomic integral base types based on C or C++. In - // addition, for "C" only provide type-generic macros for atomic - // operations. (As C++ accomplishes the same thing with sets of - // overloaded functions. -#ifdef __cplusplus inline namespace _GLIBCXX_ATOMIC_NAMESPACE { } -# include <bits/atomicfwd_cxx.h> -#else -# include <bits/atomicfwd_c.h> -#endif - // Typedefs for other atomic integral types. - typedef atomic_schar atomic_int_least8_t; - typedef atomic_uchar atomic_uint_least8_t; - typedef atomic_short atomic_int_least16_t; - typedef atomic_ushort atomic_uint_least16_t; - typedef atomic_int atomic_int_least32_t; - typedef atomic_uint atomic_uint_least32_t; - typedef atomic_llong atomic_int_least64_t; - typedef atomic_ullong atomic_uint_least64_t; - - typedef atomic_schar atomic_int_fast8_t; - typedef atomic_uchar atomic_uint_fast8_t; - typedef atomic_short atomic_int_fast16_t; - typedef atomic_ushort atomic_uint_fast16_t; - typedef atomic_int atomic_int_fast32_t; - typedef atomic_uint atomic_uint_fast32_t; - typedef atomic_llong atomic_int_fast64_t; - typedef atomic_ullong atomic_uint_fast64_t; - - typedef atomic_long atomic_intptr_t; - typedef atomic_ulong atomic_uintptr_t; - - typedef atomic_long atomic_ssize_t; - typedef atomic_ulong atomic_size_t; - - typedef atomic_llong atomic_intmax_t; - typedef atomic_ullong atomic_uintmax_t; - - typedef atomic_long atomic_ptrdiff_t; - - // Accessor functions for base atomic_flag type. - bool - atomic_flag_test_and_set_explicit(__atomic_flag_base*, memory_order) - _GLIBCXX_NOTHROW; - - inline bool - atomic_flag_test_and_set(__atomic_flag_base* __a) - { return atomic_flag_test_and_set_explicit(__a, memory_order_seq_cst); } - - void - atomic_flag_clear_explicit(__atomic_flag_base*, memory_order) - _GLIBCXX_NOTHROW; - - inline void - atomic_flag_clear(__atomic_flag_base* __a) - { atomic_flag_clear_explicit(__a, memory_order_seq_cst); } - - void - __atomic_flag_wait_explicit(__atomic_flag_base*, memory_order) - _GLIBCXX_NOTHROW; - - _GLIBCXX_CONST __atomic_flag_base* - __atomic_flag_for_address(const void* __z) _GLIBCXX_NOTHROW; - - // Implementation specific defines. -#define _ATOMIC_LOAD_(__a, __x) \ - ({__typeof__ _ATOMIC_MEMBER_* __p = &_ATOMIC_MEMBER_; \ - atomic_flag* __g = __atomic_flag_for_address(__p); \ - __atomic_flag_wait_explicit(__g, __x); \ - __typeof__ _ATOMIC_MEMBER_ __r = *__p; \ - atomic_flag_clear_explicit(__g, __x); \ - __r; }) - -#define _ATOMIC_STORE_(__a, __m, __x) \ - ({__typeof__ _ATOMIC_MEMBER_* __p = &_ATOMIC_MEMBER_; \ - __typeof__(__m) __v = (__m); \ - atomic_flag* __g = __atomic_flag_for_address(__p); \ - __atomic_flag_wait_explicit(__g, __x); \ - *__p = __v; \ - atomic_flag_clear_explicit(__g, __x); \ - __v; }) - -#define _ATOMIC_MODIFY_(__a, __o, __m, __x) \ - ({__typeof__ _ATOMIC_MEMBER_* __p = &_ATOMIC_MEMBER_; \ - __typeof__(__m) __v = (__m); \ - atomic_flag* __g = __atomic_flag_for_address(__p); \ - __atomic_flag_wait_explicit(__g, __x); \ - __typeof__ _ATOMIC_MEMBER_ __r = *__p; \ - *__p __o __v; \ - atomic_flag_clear_explicit(__g, __x); \ - __r; }) - -#define _ATOMIC_CMPEXCHNG_(__a, __e, __m, __x) \ - ({__typeof__ _ATOMIC_MEMBER_* __p = &_ATOMIC_MEMBER_; \ - __typeof__(__e) __q = (__e); \ - __typeof__(__m) __v = (__m); \ - bool __r; \ - atomic_flag* __g = __atomic_flag_for_address(__p); \ - __atomic_flag_wait_explicit(__g, __x); \ - __typeof__ _ATOMIC_MEMBER_ __t__ = *__p; \ - if (__t__ == *__q) { *__p = __v; __r = true; } \ - else { *__q = __t__; __r = false; } \ - atomic_flag_clear_explicit(__g, __x); \ - __r; }) + + /// atomic_char + typedef __atomic_base<char> atomic_char; + + /// atomic_schar + typedef __atomic_base<signed char> atomic_schar; + + /// atomic_uchar + typedef __atomic_base<unsigned char> atomic_uchar; + + /// atomic_short + typedef __atomic_base<short> atomic_short; + + /// atomic_ushort + typedef __atomic_base<unsigned short> atomic_ushort; + + /// atomic_int + typedef __atomic_base<int> atomic_int; + + /// atomic_uint + typedef __atomic_base<unsigned int> atomic_uint; + + /// atomic_long + typedef __atomic_base<long> atomic_long; + + /// atomic_ulong + typedef __atomic_base<unsigned long> atomic_ulong; + + /// atomic_llong + typedef __atomic_base<long long> atomic_llong; + + /// atomic_ullong + typedef __atomic_base<unsigned long long> atomic_ullong; + + /// atomic_wchar_t + typedef __atomic_base<wchar_t> atomic_wchar_t; + + /// atomic_char16_t + typedef __atomic_base<char16_t> atomic_char16_t; + + /// atomic_char32_t + typedef __atomic_base<char32_t> atomic_char32_t; + + /// atomic_char32_t + typedef __atomic_base<char32_t> atomic_char32_t; + + + /// atomic_int_least8_t + typedef __atomic_base<int_least8_t> atomic_int_least8_t; + + /// atomic_uint_least8_t + typedef __atomic_base<uint_least8_t> atomic_uint_least8_t; + + /// atomic_int_least16_t + typedef __atomic_base<int_least16_t> atomic_int_least16_t; + + /// atomic_uint_least16_t + typedef __atomic_base<uint_least16_t> atomic_uint_least16_t; + + /// atomic_int_least32_t + typedef __atomic_base<int_least32_t> atomic_int_least32_t; + + /// atomic_uint_least32_t + typedef __atomic_base<uint_least32_t> atomic_uint_least32_t; + + /// atomic_int_least64_t + typedef __atomic_base<int_least64_t> atomic_int_least64_t; + + /// atomic_uint_least64_t + typedef __atomic_base<uint_least64_t> atomic_uint_least64_t; + + + /// atomic_int_fast8_t + typedef __atomic_base<int_fast8_t> atomic_int_fast8_t; + + /// atomic_uint_fast8_t + typedef __atomic_base<uint_fast8_t> atomic_uint_fast8_t; + + /// atomic_int_fast16_t + typedef __atomic_base<int_fast16_t> atomic_int_fast16_t; + + /// atomic_uint_fast16_t + typedef __atomic_base<uint_fast16_t> atomic_uint_fast16_t; + + /// atomic_int_fast32_t + typedef __atomic_base<int_fast32_t> atomic_int_fast32_t; + + /// atomic_uint_fast32_t + typedef __atomic_base<uint_fast32_t> atomic_uint_fast32_t; + + /// atomic_int_fast64_t + typedef __atomic_base<int_fast64_t> atomic_int_fast64_t; + + /// atomic_uint_fast64_t + typedef __atomic_base<uint_fast64_t> atomic_uint_fast64_t; + + + /// atomic_intptr_t + typedef __atomic_base<intptr_t> atomic_intptr_t; + + /// atomic_uintptr_t + typedef __atomic_base<uintptr_t> atomic_uintptr_t; + + /// atomic_size_t + typedef __atomic_base<size_t> atomic_size_t; + + /// atomic_intmax_t + typedef __atomic_base<intmax_t> atomic_intmax_t; + + /// atomic_uintmax_t + typedef __atomic_base<uintmax_t> atomic_uintmax_t; + + /// atomic_ptrdiff_t + typedef __atomic_base<ptrdiff_t> atomic_ptrdiff_t; + + + struct atomic_bool; + +#define ATOMIC_VAR_INIT(_VI) { _VI } + + template<typename _Tp> + struct atomic; // @} group atomics -_GLIBCXX_END_EXTERN_C _GLIBCXX_END_NAMESPACE -// Inject into global namespace. -#ifdef __cplusplus - -#include <atomic> - -using std::memory_order; -using std::memory_order_relaxed; -using std::memory_order_consume; -using std::memory_order_acquire; -using std::memory_order_release; -using std::memory_order_acq_rel; -using std::memory_order_seq_cst; -using std::atomic_flag; -using std::atomic_bool; -using std::atomic_char; -using std::atomic_schar; -using std::atomic_uchar; -using std::atomic_short; -using std::atomic_ushort; -using std::atomic_int; -using std::atomic_uint; -using std::atomic_long; -using std::atomic_ulong; -using std::atomic_llong; -using std::atomic_ullong; -using std::atomic_wchar_t; -using std::atomic_char16_t; -using std::atomic_char32_t; -using std::atomic_address; -using std::atomic; -#endif - #endif diff --git a/libstdc++-v3/include/bits/atomicfwd_c.h b/libstdc++-v3/include/bits/atomicfwd_c.h deleted file mode 100644 index 08418439345..00000000000 --- a/libstdc++-v3/include/bits/atomicfwd_c.h +++ /dev/null @@ -1,174 +0,0 @@ -// -*- C++ -*- header. - -// Copyright (C) 2008, 2009 -// 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/atomicfwd_c.h - * This is an internal header file, included by other library headers. - * You should not attempt to use it directly. - */ - -// "C" only bits. - -#define _ATOMIC_MEMBER_ ((__a)->_M_i) - - // POD base classes for atomic intgral types. - struct __atomic_bool_base - { - bool _M_i; - }; - - struct __atomic_char_base - { - char _M_i; - }; - - struct __atomic_schar_base - { - signed char _M_i; - }; - - struct __atomic_uchar_base - { - unsigned char _M_i; - }; - - struct __atomic_short_base - { - short _M_i; - }; - - struct __atomic_ushort_base - { - unsigned short _M_i; - }; - - struct __atomic_int_base - { - int _M_i; - }; - - struct __atomic_uint_base - { - unsigned int _M_i; - }; - - struct __atomic_long_base - { - long _M_i; - }; - - struct __atomic_ulong_base - { - unsigned long _M_i; - }; - - struct __atomic_llong_base - { - long long _M_i; - }; - - struct __atomic_ullong_base - { - unsigned long long _M_i; - }; - - struct __atomic_wchar_t_base - { - wchar_t _M_i; - }; - - typedef struct __atomic_flag_base atomic_flag; - typedef struct __atomic_address_base atomic_address; - typedef struct __atomic_bool_base atomic_bool; - typedef struct __atomic_char_base atomic_char; - typedef struct __atomic_schar_base atomic_schar; - typedef struct __atomic_uchar_base atomic_uchar; - typedef struct __atomic_short_base atomic_short; - typedef struct __atomic_ushort_base atomic_ushort; - typedef struct __atomic_int_base atomic_int; - typedef struct __atomic_uint_base atomic_uint; - typedef struct __atomic_long_base atomic_long; - typedef struct __atomic_ulong_base atomic_ulong; - typedef struct __atomic_llong_base atomic_llong; - typedef struct __atomic_ullong_base atomic_ullong; - typedef struct __atomic_wchar_t_base atomic_wchar_t; - typedef struct __atomic_short_base atomic_char16_t; - typedef struct __atomic_int_base atomic_char32_t; - -#define atomic_is_lock_free(__a) \ - false - -#define atomic_load_explicit(__a, __x) \ - _ATOMIC_LOAD_(__a, __x) - -#define atomic_load(__a) \ - atomic_load_explicit(__a, memory_order_seq_cst) - -#define atomic_store_explicit(__a, __m, __x) \ - _ATOMIC_STORE_(__a, __m, __x) - -#define atomic_store(__a, __m) \ - atomic_store_explicit(__a, __m, memory_order_seq_cst) - -#define atomic_exchange_explicit(__a, __m, __x) \ - _ATOMIC_MODIFY_(__a, =, __m, __x) - -#define atomic_exchange(__a, __m) \ - atomic_exchange_explicit(__a, __m, memory_order_seq_cst) - -#define atomic_compare_exchange_explicit(__a, __e, __m, __x, __y) \ - _ATOMIC_CMPEXCHNG_(__a, __e, __m, __x) - -#define atomic_compare_exchange(__a, __e, __m) \ - _ATOMIC_CMPEXCHNG_(__a, __e, __m, memory_order_seq_cst) - -#define atomic_fetch_add_explicit(__a, __m, __x) \ - _ATOMIC_MODIFY_(__a, +=, __m, __x) - -#define atomic_fetch_add(__a, __m) \ - atomic_fetch_add_explicit(__a, __m, memory_order_seq_cst) - -#define atomic_fetch_sub_explicit(__a, __m, __x) \ - _ATOMIC_MODIFY_(__a, -=, __m, __x) - -#define atomic_fetch_sub(__a, __m) \ - atomic_fetch_sub_explicit(__a, __m, memory_order_seq_cst) - -#define atomic_fetch_and_explicit(__a, __m, __x) \ - _ATOMIC_MODIFY_(__a, &=, __m, __x) - -#define atomic_fetch_and(__a, __m) \ - atomic_fetch_and_explicit(__a, __m, memory_order_seq_cst) - -#define atomic_fetch_or_explicit(__a, __m, __x) \ - _ATOMIC_MODIFY_(__a, |=, __m, __x) - -#define atomic_fetch_or(__a, __m) \ - atomic_fetch_or_explicit(__a, __m, memory_order_seq_cst) - -#define atomic_fetch_xor_explicit(__a, __m, __x) \ - _ATOMIC_MODIFY_(__a, ^=, __m, __x) - -#define atomic_fetch_xor(__a, __m) \ - atomic_fetch_xor_explicit(__a, __m, memory_order_seq_cst) diff --git a/libstdc++-v3/include/bits/atomicfwd_cxx.h b/libstdc++-v3/include/bits/atomicfwd_cxx.h deleted file mode 100644 index 8ef25e622cc..00000000000 --- a/libstdc++-v3/include/bits/atomicfwd_cxx.h +++ /dev/null @@ -1,117 +0,0 @@ -// -*- C++ -*- header. - -// Copyright (C) 2008, 2009, 2010 -// 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/atomicfwd_cxx.h - * This is an internal header file, included by other library headers. - * You should not attempt to use it directly. - */ - -// "C++" only bits. - -#define _ATOMIC_MEMBER_ _M_i - -_GLIBCXX_END_EXTERN_C - - namespace __atomic0 - { - template<typename _IntTp> - struct __atomic_base; - - struct atomic_flag; - struct atomic_address; - struct atomic_bool; - } - - namespace __atomic2 - { - template<typename _IntTp> - struct __atomic_base; - - struct atomic_flag; - struct atomic_address; - struct atomic_bool; - } - - namespace __atomic1 - { - using __atomic2::atomic_flag; - using __atomic2::atomic_bool; - using __atomic0::atomic_address; - using __atomic0::__atomic_base; - } - - /** - * @addtogroup atomics - * @{ - */ - - /// atomic_char - typedef __atomic_base<char> atomic_char; - - /// atomic_schar - typedef __atomic_base<signed char> atomic_schar; - - /// atomic_uchar - typedef __atomic_base<unsigned char> atomic_uchar; - - /// atomic_short - typedef __atomic_base<short> atomic_short; - - /// atomic_ushort - typedef __atomic_base<unsigned short> atomic_ushort; - - /// atomic_int - typedef __atomic_base<int> atomic_int; - - /// atomic_uint - typedef __atomic_base<unsigned int> atomic_uint; - - /// atomic_long - typedef __atomic_base<long> atomic_long; - - /// atomic_ulong - typedef __atomic_base<unsigned long> atomic_ulong; - - /// atomic_llong - typedef __atomic_base<long long> atomic_llong; - - /// atomic_ullong - typedef __atomic_base<unsigned long long> atomic_ullong; - - /// atomic_wchar_t - typedef __atomic_base<wchar_t> atomic_wchar_t; - - /// atomic_char16_t - typedef __atomic_base<char16_t> atomic_char16_t; - - /// atomic_char32_t - typedef __atomic_base<char32_t> atomic_char32_t; - - template<typename _Tp> - struct atomic; - - // @} group atomics - -_GLIBCXX_BEGIN_EXTERN_C diff --git a/libstdc++-v3/include/bits/c++config b/libstdc++-v3/include/bits/c++config index 19b55bc5b08..1c556eb5b4e 100644 --- a/libstdc++-v3/include/bits/c++config +++ b/libstdc++-v3/include/bits/c++config @@ -34,6 +34,27 @@ // The current version of the C++ library in compressed ISO date format. #define __GLIBCXX__ +// Macros for various attributes. +#ifndef _GLIBCXX_PURE +# define _GLIBCXX_PURE __attribute__ ((__pure__)) +#endif + +#ifndef _GLIBCXX_CONST +# define _GLIBCXX_CONST __attribute__ ((__const__)) +#endif + +#ifndef _GLIBCXX_NORETURN +# define _GLIBCXX_NORETURN __attribute__ ((__noreturn__)) +#endif + +#ifndef _GLIBCXX_NOTHROW +# ifdef __cplusplus +# define _GLIBCXX_NOTHROW throw() +# else +# define _GLIBCXX_NOTHROW __attribute__((__nothrow__)) +# endif +#endif + // Macros for visibility. // _GLIBCXX_HAVE_ATTRIBUTE_VISIBILITY // _GLIBCXX_VISIBILITY_ATTR @@ -60,33 +81,39 @@ # define _GLIBCXX_DEPRECATED_ATTR #endif -// Macros for race detectors. -// _GLIBCXX_SYNCHRONIZATION_HAPPENS_BEFORE(A) and -// _GLIBCXX_SYNCHRONIZATION_HAPPENS_AFTER(A) should be used to explain -// atomic (lock-free) synchronization to race detectors: -// the race detector will infer a happens-before arc from the former to the -// latter when they share the same argument pointer. -// -// The most frequent use case for these macros (and the only case in the -// current implementation of the library) is atomic reference counting: -// void _M_remove_reference() -// { -// _GLIBCXX_SYNCHRONIZATION_HAPPENS_BEFORE(&this->_M_refcount); -// if (__gnu_cxx::__exchange_and_add_dispatch(&this->_M_refcount, -1) <= 0) -// { -// _GLIBCXX_SYNCHRONIZATION_HAPPENS_AFTER(&this->_M_refcount); -// _M_destroy(__a); -// } -// } -// The annotations in this example tell the race detector that all memory -// accesses occurred when the refcount was positive do not race with -// memory accesses which occurred after the refcount became zero. +#if __cplusplus -#ifndef _GLIBCXX_SYNCHRONIZATION_HAPPENS_BEFORE -# define _GLIBCXX_SYNCHRONIZATION_HAPPENS_BEFORE(A) +namespace std +{ + typedef __SIZE_TYPE__ size_t; + typedef __PTRDIFF_TYPE__ ptrdiff_t; + +#ifdef __GXX_EXPERIMENTAL_CXX0X__ + typedef decltype(nullptr) nullptr_t; #endif -#ifndef _GLIBCXX_SYNCHRONIZATION_HAPPENS_AFTER -# define _GLIBCXX_SYNCHRONIZATION_HAPPENS_AFTER(A) +} + +// Macros for C compatibility. In particular, define extern "C" +// linkage only when using C++. +# define _GLIBCXX_BEGIN_EXTERN_C extern "C" { +# define _GLIBCXX_END_EXTERN_C } + + +// Macro for constexpr, to support in mixed 03/0x mode. +#ifndef _GLIBCXX_CONSTEXPR +# ifdef __GXX_EXPERIMENTAL_CXX0X__ +# define _GLIBCXX_CONSTEXPR constexpr +# else +# define _GLIBCXX_CONSTEXPR +# endif +#endif + +#ifndef _GLIBCXX_USE_CONSTEXPR +# ifdef __GXX_EXPERIMENTAL_CXX0X__ +# define _GLIBCXX_USE_CONSTEXPR constexpr +# else +# define _GLIBCXX_USE_CONSTEXPR const +# endif #endif // Macros for activating various namespace association modes. @@ -106,7 +133,6 @@ namespace tr1 { } } */ -#if __cplusplus #ifdef _GLIBCXX_DEBUG # define _GLIBCXX_NAMESPACE_ASSOCIATION_DEBUG 1 @@ -136,6 +162,7 @@ // _GLIBCXX_STD // _GLIBCXX_STD_D // _GLIBCXX_STD_P +// _GLIBCXX_STD_PR // // Macros for enclosing namespaces and possibly nested namespaces. // _GLIBCXX_BEGIN_NAMESPACE @@ -283,19 +310,42 @@ namespace std # define _GLIBCXX_END_LDBL_NAMESPACE #endif +// Macros for race detectors. +// _GLIBCXX_SYNCHRONIZATION_HAPPENS_BEFORE(A) and +// _GLIBCXX_SYNCHRONIZATION_HAPPENS_AFTER(A) should be used to explain +// atomic (lock-free) synchronization to race detectors: +// the race detector will infer a happens-before arc from the former to the +// latter when they share the same argument pointer. +// +// The most frequent use case for these macros (and the only case in the +// current implementation of the library) is atomic reference counting: +// void _M_remove_reference() +// { +// _GLIBCXX_SYNCHRONIZATION_HAPPENS_BEFORE(&this->_M_refcount); +// if (__gnu_cxx::__exchange_and_add_dispatch(&this->_M_refcount, -1) <= 0) +// { +// _GLIBCXX_SYNCHRONIZATION_HAPPENS_AFTER(&this->_M_refcount); +// _M_destroy(__a); +// } +// } +// The annotations in this example tell the race detector that all memory +// accesses occurred when the refcount was positive do not race with +// memory accesses which occurred after the refcount became zero. -// Defines for C compatibility. In particular, define extern "C" -// linkage only when using C++. -# define _GLIBCXX_BEGIN_EXTERN_C extern "C" { -# define _GLIBCXX_END_EXTERN_C } +#ifndef _GLIBCXX_SYNCHRONIZATION_HAPPENS_BEFORE +# define _GLIBCXX_SYNCHRONIZATION_HAPPENS_BEFORE(A) +#endif +#ifndef _GLIBCXX_SYNCHRONIZATION_HAPPENS_AFTER +# define _GLIBCXX_SYNCHRONIZATION_HAPPENS_AFTER(A) +#endif #else // !__cplusplus +# define _GLIBCXX_BEGIN_EXTERN_C +# define _GLIBCXX_END_EXTERN_C # undef _GLIBCXX_BEGIN_NAMESPACE # undef _GLIBCXX_END_NAMESPACE # define _GLIBCXX_BEGIN_NAMESPACE(X) # define _GLIBCXX_END_NAMESPACE -# define _GLIBCXX_BEGIN_EXTERN_C -# define _GLIBCXX_END_EXTERN_C #endif // First includes. @@ -385,39 +435,4 @@ _GLIBCXX_END_NAMESPACE #undef min #undef max -#ifndef _GLIBCXX_PURE -# define _GLIBCXX_PURE __attribute__ ((__pure__)) -#endif - -#ifndef _GLIBCXX_CONST -# define _GLIBCXX_CONST __attribute__ ((__const__)) -#endif - -#ifndef _GLIBCXX_NORETURN -# define _GLIBCXX_NORETURN __attribute__ ((__noreturn__)) -#endif - -#ifndef _GLIBCXX_NOTHROW -# ifdef __cplusplus -# define _GLIBCXX_NOTHROW throw() -# else -# define _GLIBCXX_NOTHROW __attribute__((__nothrow__)) -# endif -#endif - -#ifdef __cplusplus - -_GLIBCXX_BEGIN_NAMESPACE(std) - - typedef __SIZE_TYPE__ size_t; - typedef __PTRDIFF_TYPE__ ptrdiff_t; - -#ifdef __GXX_EXPERIMENTAL_CXX0X__ - typedef decltype(nullptr) nullptr_t; -#endif - -_GLIBCXX_END_NAMESPACE - -#endif // __cplusplus - // End of prewritten config; the discovered settings follow. diff --git a/libstdc++-v3/include/bits/char_traits.h b/libstdc++-v3/include/bits/char_traits.h index 786c1c6b380..2c1a5fd6b3c 100644 --- a/libstdc++-v3/include/bits/char_traits.h +++ b/libstdc++-v3/include/bits/char_traits.h @@ -92,11 +92,11 @@ _GLIBCXX_BEGIN_NAMESPACE(__gnu_cxx) assign(char_type& __c1, const char_type& __c2) { __c1 = __c2; } - static bool + static _GLIBCXX_CONSTEXPR bool eq(const char_type& __c1, const char_type& __c2) { return __c1 == __c2; } - static bool + static _GLIBCXX_CONSTEXPR bool lt(const char_type& __c1, const char_type& __c2) { return __c1 < __c2; } @@ -118,23 +118,23 @@ _GLIBCXX_BEGIN_NAMESPACE(__gnu_cxx) static char_type* assign(char_type* __s, std::size_t __n, char_type __a); - static char_type + static _GLIBCXX_CONSTEXPR char_type to_char_type(const int_type& __c) { return static_cast<char_type>(__c); } - static int_type + static _GLIBCXX_CONSTEXPR int_type to_int_type(const char_type& __c) { return static_cast<int_type>(__c); } - static bool + static _GLIBCXX_CONSTEXPR bool eq_int_type(const int_type& __c1, const int_type& __c2) { return __c1 == __c2; } - static int_type + static _GLIBCXX_CONSTEXPR int_type eof() { return static_cast<int_type>(_GLIBCXX_STDIO_EOF); } - static int_type + static _GLIBCXX_CONSTEXPR int_type not_eof(const int_type& __c) { return !eq_int_type(__c, eof()) ? __c : to_int_type(char_type()); } }; @@ -239,11 +239,11 @@ _GLIBCXX_BEGIN_NAMESPACE(std) assign(char_type& __c1, const char_type& __c2) { __c1 = __c2; } - static bool + static _GLIBCXX_CONSTEXPR bool eq(const char_type& __c1, const char_type& __c2) { return __c1 == __c2; } - static bool + static _GLIBCXX_CONSTEXPR bool lt(const char_type& __c1, const char_type& __c2) { return __c1 < __c2; } @@ -271,25 +271,25 @@ _GLIBCXX_BEGIN_NAMESPACE(std) assign(char_type* __s, size_t __n, char_type __a) { return static_cast<char_type*>(__builtin_memset(__s, __a, __n)); } - static char_type + static _GLIBCXX_CONSTEXPR char_type to_char_type(const int_type& __c) { return static_cast<char_type>(__c); } // To keep both the byte 0xff and the eof symbol 0xffffffff // from ending up as 0xffffffff. - static int_type + static _GLIBCXX_CONSTEXPR int_type to_int_type(const char_type& __c) { return static_cast<int_type>(static_cast<unsigned char>(__c)); } - static bool + static _GLIBCXX_CONSTEXPR bool eq_int_type(const int_type& __c1, const int_type& __c2) { return __c1 == __c2; } - static int_type + static _GLIBCXX_CONSTEXPR int_type eof() { return static_cast<int_type>(_GLIBCXX_STDIO_EOF); } - static int_type + static _GLIBCXX_CONSTEXPR int_type not_eof(const int_type& __c) { return (__c == eof()) ? 0 : __c; } }; @@ -310,11 +310,11 @@ _GLIBCXX_BEGIN_NAMESPACE(std) assign(char_type& __c1, const char_type& __c2) { __c1 = __c2; } - static bool + static _GLIBCXX_CONSTEXPR bool eq(const char_type& __c1, const char_type& __c2) { return __c1 == __c2; } - static bool + static _GLIBCXX_CONSTEXPR bool lt(const char_type& __c1, const char_type& __c2) { return __c1 < __c2; } @@ -342,23 +342,23 @@ _GLIBCXX_BEGIN_NAMESPACE(std) assign(char_type* __s, size_t __n, char_type __a) { return wmemset(__s, __a, __n); } - static char_type + static _GLIBCXX_CONSTEXPR char_type to_char_type(const int_type& __c) { return char_type(__c); } - static int_type + static _GLIBCXX_CONSTEXPR int_type to_int_type(const char_type& __c) { return int_type(__c); } - static bool + static _GLIBCXX_CONSTEXPR bool eq_int_type(const int_type& __c1, const int_type& __c2) { return __c1 == __c2; } - static int_type + static _GLIBCXX_CONSTEXPR int_type eof() { return static_cast<int_type>(WEOF); } - static int_type + static _GLIBCXX_CONSTEXPR int_type not_eof(const int_type& __c) { return eq_int_type(__c, eof()) ? 0 : __c; } }; @@ -386,11 +386,11 @@ _GLIBCXX_BEGIN_NAMESPACE(std) assign(char_type& __c1, const char_type& __c2) { __c1 = __c2; } - static bool + static _GLIBCXX_CONSTEXPR bool eq(const char_type& __c1, const char_type& __c2) { return __c1 == __c2; } - static bool + static _GLIBCXX_CONSTEXPR bool lt(const char_type& __c1, const char_type& __c2) { return __c1 < __c2; } @@ -445,23 +445,23 @@ _GLIBCXX_BEGIN_NAMESPACE(std) return __s; } - static char_type + static _GLIBCXX_CONSTEXPR char_type to_char_type(const int_type& __c) { return char_type(__c); } - static int_type + static _GLIBCXX_CONSTEXPR int_type to_int_type(const char_type& __c) { return int_type(__c); } - static bool + static _GLIBCXX_CONSTEXPR bool eq_int_type(const int_type& __c1, const int_type& __c2) { return __c1 == __c2; } - static int_type + static _GLIBCXX_CONSTEXPR int_type eof() { return static_cast<int_type>(-1); } - static int_type + static _GLIBCXX_CONSTEXPR int_type not_eof(const int_type& __c) { return eq_int_type(__c, eof()) ? 0 : __c; } }; @@ -479,11 +479,11 @@ _GLIBCXX_BEGIN_NAMESPACE(std) assign(char_type& __c1, const char_type& __c2) { __c1 = __c2; } - static bool + static _GLIBCXX_CONSTEXPR bool eq(const char_type& __c1, const char_type& __c2) { return __c1 == __c2; } - static bool + static _GLIBCXX_CONSTEXPR bool lt(const char_type& __c1, const char_type& __c2) { return __c1 < __c2; } @@ -538,23 +538,23 @@ _GLIBCXX_BEGIN_NAMESPACE(std) return __s; } - static char_type + static _GLIBCXX_CONSTEXPR char_type to_char_type(const int_type& __c) { return char_type(__c); } - static int_type + static _GLIBCXX_CONSTEXPR int_type to_int_type(const char_type& __c) { return int_type(__c); } - static bool + static _GLIBCXX_CONSTEXPR bool eq_int_type(const int_type& __c1, const int_type& __c2) { return __c1 == __c2; } - static int_type + static _GLIBCXX_CONSTEXPR int_type eof() { return static_cast<int_type>(-1); } - static int_type + static _GLIBCXX_CONSTEXPR int_type not_eof(const int_type& __c) { return eq_int_type(__c, eof()) ? 0 : __c; } }; diff --git a/libstdc++-v3/include/bits/ios_base.h b/libstdc++-v3/include/bits/ios_base.h index 6749a731065..f161a4d997c 100644 --- a/libstdc++-v3/include/bits/ios_base.h +++ b/libstdc++-v3/include/bits/ios_base.h @@ -71,34 +71,34 @@ _GLIBCXX_BEGIN_NAMESPACE(std) _S_ios_fmtflags_end = 1L << 16 }; - inline _Ios_Fmtflags + inline _GLIBCXX_CONSTEXPR _Ios_Fmtflags operator&(_Ios_Fmtflags __a, _Ios_Fmtflags __b) { return _Ios_Fmtflags(static_cast<int>(__a) & static_cast<int>(__b)); } - inline _Ios_Fmtflags + inline _GLIBCXX_CONSTEXPR _Ios_Fmtflags operator|(_Ios_Fmtflags __a, _Ios_Fmtflags __b) { return _Ios_Fmtflags(static_cast<int>(__a) | static_cast<int>(__b)); } - inline _Ios_Fmtflags + inline _GLIBCXX_CONSTEXPR _Ios_Fmtflags operator^(_Ios_Fmtflags __a, _Ios_Fmtflags __b) { return _Ios_Fmtflags(static_cast<int>(__a) ^ static_cast<int>(__b)); } - inline _Ios_Fmtflags& + inline _GLIBCXX_CONSTEXPR _Ios_Fmtflags + operator~(_Ios_Fmtflags __a) + { return _Ios_Fmtflags(~static_cast<int>(__a)); } + + inline const _Ios_Fmtflags& operator|=(_Ios_Fmtflags& __a, _Ios_Fmtflags __b) { return __a = __a | __b; } - inline _Ios_Fmtflags& + inline const _Ios_Fmtflags& operator&=(_Ios_Fmtflags& __a, _Ios_Fmtflags __b) { return __a = __a & __b; } - inline _Ios_Fmtflags& + inline const _Ios_Fmtflags& operator^=(_Ios_Fmtflags& __a, _Ios_Fmtflags __b) { return __a = __a ^ __b; } - inline _Ios_Fmtflags - operator~(_Ios_Fmtflags __a) - { return _Ios_Fmtflags(~static_cast<int>(__a)); } - enum _Ios_Openmode { @@ -111,34 +111,34 @@ _GLIBCXX_BEGIN_NAMESPACE(std) _S_ios_openmode_end = 1L << 16 }; - inline _Ios_Openmode + inline _GLIBCXX_CONSTEXPR _Ios_Openmode operator&(_Ios_Openmode __a, _Ios_Openmode __b) { return _Ios_Openmode(static_cast<int>(__a) & static_cast<int>(__b)); } - inline _Ios_Openmode + inline _GLIBCXX_CONSTEXPR _Ios_Openmode operator|(_Ios_Openmode __a, _Ios_Openmode __b) { return _Ios_Openmode(static_cast<int>(__a) | static_cast<int>(__b)); } - inline _Ios_Openmode + inline _GLIBCXX_CONSTEXPR _Ios_Openmode operator^(_Ios_Openmode __a, _Ios_Openmode __b) { return _Ios_Openmode(static_cast<int>(__a) ^ static_cast<int>(__b)); } - inline _Ios_Openmode& + inline _GLIBCXX_CONSTEXPR _Ios_Openmode + operator~(_Ios_Openmode __a) + { return _Ios_Openmode(~static_cast<int>(__a)); } + + inline const _Ios_Openmode& operator|=(_Ios_Openmode& __a, _Ios_Openmode __b) { return __a = __a | __b; } - inline _Ios_Openmode& + inline const _Ios_Openmode& operator&=(_Ios_Openmode& __a, _Ios_Openmode __b) { return __a = __a & __b; } - inline _Ios_Openmode& + inline const _Ios_Openmode& operator^=(_Ios_Openmode& __a, _Ios_Openmode __b) { return __a = __a ^ __b; } - inline _Ios_Openmode - operator~(_Ios_Openmode __a) - { return _Ios_Openmode(~static_cast<int>(__a)); } - enum _Ios_Iostate { @@ -149,33 +149,34 @@ _GLIBCXX_BEGIN_NAMESPACE(std) _S_ios_iostate_end = 1L << 16 }; - inline _Ios_Iostate + inline _GLIBCXX_CONSTEXPR _Ios_Iostate operator&(_Ios_Iostate __a, _Ios_Iostate __b) { return _Ios_Iostate(static_cast<int>(__a) & static_cast<int>(__b)); } - inline _Ios_Iostate + inline _GLIBCXX_CONSTEXPR _Ios_Iostate operator|(_Ios_Iostate __a, _Ios_Iostate __b) { return _Ios_Iostate(static_cast<int>(__a) | static_cast<int>(__b)); } - inline _Ios_Iostate + inline _GLIBCXX_CONSTEXPR _Ios_Iostate operator^(_Ios_Iostate __a, _Ios_Iostate __b) { return _Ios_Iostate(static_cast<int>(__a) ^ static_cast<int>(__b)); } - inline _Ios_Iostate& + inline _GLIBCXX_CONSTEXPR _Ios_Iostate + operator~(_Ios_Iostate __a) + { return _Ios_Iostate(~static_cast<int>(__a)); } + + inline const _Ios_Iostate& operator|=(_Ios_Iostate& __a, _Ios_Iostate __b) { return __a = __a | __b; } - inline _Ios_Iostate& + inline const _Ios_Iostate& operator&=(_Ios_Iostate& __a, _Ios_Iostate __b) { return __a = __a & __b; } - inline _Ios_Iostate& + inline const _Ios_Iostate& operator^=(_Ios_Iostate& __a, _Ios_Iostate __b) { return __a = __a ^ __b; } - inline _Ios_Iostate - operator~(_Ios_Iostate __a) - { return _Ios_Iostate(~static_cast<int>(__a)); } enum _Ios_Seekdir { diff --git a/libstdc++-v3/include/bits/random.h b/libstdc++-v3/include/bits/random.h index cfb286a3c97..28ced236e27 100644 --- a/libstdc++-v3/include/bits/random.h +++ b/libstdc++-v3/include/bits/random.h @@ -169,12 +169,12 @@ namespace std typedef _UIntType result_type; /** The multiplier. */ - static const result_type multiplier = __a; + static constexpr result_type multiplier = __a; /** An increment. */ - static const result_type increment = __c; + static constexpr result_type increment = __c; /** The modulus. */ - static const result_type modulus = __m; - static const result_type default_seed = 1u; + static constexpr result_type modulus = __m; + static constexpr result_type default_seed = 1u; /** * @brief Constructs a %linear_congruential_engine random number @@ -225,26 +225,20 @@ namespace std * * The minimum depends on the @p __c parameter: if it is zero, the * minimum generated must be > 0, otherwise 0 is allowed. - * - * @todo This should be constexpr. */ - result_type - min() const + static constexpr result_type + min() { return __c == 0u ? 1u : 0u; } /** * @brief Gets the largest possible value in the output range. - * - * @todo This should be constexpr. */ - result_type - max() const + static constexpr result_type + max() { return __m - 1u; } /** * @brief Discard a sequence of random numbers. - * - * @todo Look for a faster way to do discard. */ void discard(unsigned long long __z) @@ -402,20 +396,20 @@ namespace std typedef _UIntType result_type; // parameter values - static const size_t word_size = __w; - static const size_t state_size = __n; - static const size_t shift_size = __m; - static const size_t mask_bits = __r; - static const result_type xor_mask = __a; - static const size_t tempering_u = __u; - static const result_type tempering_d = __d; - static const size_t tempering_s = __s; - static const result_type tempering_b = __b; - static const size_t tempering_t = __t; - static const result_type tempering_c = __c; - static const size_t tempering_l = __l; - static const result_type initialization_multiplier = __f; - static const result_type default_seed = 5489u; + static constexpr size_t word_size = __w; + static constexpr size_t state_size = __n; + static constexpr size_t shift_size = __m; + static constexpr size_t mask_bits = __r; + static constexpr result_type xor_mask = __a; + static constexpr size_t tempering_u = __u; + static constexpr result_type tempering_d = __d; + static constexpr size_t tempering_s = __s; + static constexpr result_type tempering_b = __b; + static constexpr size_t tempering_t = __t; + static constexpr result_type tempering_c = __c; + static constexpr size_t tempering_l = __l; + static constexpr result_type initialization_multiplier = __f; + static constexpr result_type default_seed = 5489u; // constructors and member function explicit @@ -444,26 +438,20 @@ namespace std /** * @brief Gets the smallest possible value in the output range. - * - * @todo This should be constexpr. */ - result_type - min() const + static constexpr result_type + min() { return 0; }; /** * @brief Gets the largest possible value in the output range. - * - * @todo This should be constexpr. */ - result_type - max() const + static constexpr result_type + max() { return __detail::_Shift<_UIntType, __w>::__value - 1; } /** * @brief Discard a sequence of random numbers. - * - * @todo Look for a faster way to do discard. */ void discard(unsigned long long __z) @@ -608,10 +596,10 @@ namespace std typedef _UIntType result_type; // parameter values - static const size_t word_size = __w; - static const size_t short_lag = __s; - static const size_t long_lag = __r; - static const result_type default_seed = 19780503u; + static constexpr size_t word_size = __w; + static constexpr size_t short_lag = __s; + static constexpr size_t long_lag = __r; + static constexpr result_type default_seed = 19780503u; /** * @brief Constructs an explicitly seeded % subtract_with_carry_engine @@ -660,27 +648,21 @@ namespace std /** * @brief Gets the inclusive minimum value of the range of random * integers returned by this generator. - * - * @todo This should be constexpr. */ - result_type - min() const + static constexpr result_type + min() { return 0; } /** * @brief Gets the inclusive maximum value of the range of random * integers returned by this generator. - * - * @todo This should be constexpr. */ - result_type - max() const + static constexpr result_type + max() { return __detail::_Shift<_UIntType, __w>::__value - 1; } /** * @brief Discard a sequence of random numbers. - * - * @todo Look for a faster way to do discard. */ void discard(unsigned long long __z) @@ -794,8 +776,8 @@ namespace std typedef typename _RandomNumberEngine::result_type result_type; // parameter values - static const size_t block_size = __p; - static const size_t used_block = __r; + static constexpr size_t block_size = __p; + static constexpr size_t used_block = __r; /** * @brief Constructs a default %discard_block_engine engine. @@ -894,26 +876,20 @@ namespace std /** * @brief Gets the minimum value in the generated random number range. - * - * @todo This should be constexpr. */ - result_type - min() const - { return _M_b.min(); } + static constexpr result_type + min() + { return _RandomNumberEngine::min(); } /** * @brief Gets the maximum value in the generated random number range. - * - * @todo This should be constexpr. */ - result_type - max() const - { return _M_b.max(); } + static constexpr result_type + max() + { return _RandomNumberEngine::max(); } /** * @brief Discard a sequence of random numbers. - * - * @todo Look for a faster way to do discard. */ void discard(unsigned long long __z) @@ -1109,26 +1085,20 @@ namespace std /** * @brief Gets the minimum value in the generated random number range. - * - * @todo This should be constexpr. */ - result_type - min() const + static constexpr result_type + min() { return 0U; } /** * @brief Gets the maximum value in the generated random number range. - * - * @todo This should be constexpr. */ - result_type - max() const + static constexpr result_type + max() { return __detail::_Shift<_UIntType, __w>::__value - 1; } /** * @brief Discard a sequence of random numbers. - * - * @todo Look for a faster way to do discard. */ void discard(unsigned long long __z) @@ -1243,7 +1213,7 @@ namespace std /** The type of the generated random value. */ typedef typename _RandomNumberEngine::result_type result_type; - static const size_t table_size = __k; + static constexpr size_t table_size = __k; /** * @brief Constructs a default %shuffle_order_engine engine. @@ -1345,26 +1315,20 @@ namespace std /** * Gets the minimum value in the generated random number range. - * - * @todo This should be constexpr. */ - result_type - min() const - { return _M_b.min(); } + static constexpr result_type + min() + { return _RandomNumberEngine::min(); } /** * Gets the maximum value in the generated random number range. - * - * @todo This should be constexpr. */ - result_type - max() const - { return _M_b.max(); } + static constexpr result_type + max() + { return _RandomNumberEngine::max(); } /** * Discard a sequence of random numbers. - * - * @todo Look for a faster way to do discard. */ void discard(unsigned long long __z) @@ -1617,7 +1581,7 @@ namespace std */ /** - * @addtogroup random_distributions_uniform Uniform + * @addtogroup random_distributions_uniform Uniform Distributions * @ingroup random_distributions * @{ */ @@ -1975,7 +1939,7 @@ namespace std /* @} */ // group random_distributions_uniform /** - * @addtogroup random_distributions_normal Normal + * @addtogroup random_distributions_normal Normal Distributions * @ingroup random_distributions * @{ */ @@ -3229,7 +3193,7 @@ namespace std /* @} */ // group random_distributions_normal /** - * @addtogroup random_distributions_bernoulli Bernoulli + * @addtogroup random_distributions_bernoulli Bernoulli Distributions * @ingroup random_distributions * @{ */ @@ -3960,7 +3924,7 @@ namespace std /* @} */ // group random_distributions_bernoulli /** - * @addtogroup random_distributions_poisson Poisson + * @addtogroup random_distributions_poisson Poisson Distributions * @ingroup random_distributions * @{ */ diff --git a/libstdc++-v3/include/bits/random.tcc b/libstdc++-v3/include/bits/random.tcc index e3faf481423..bfc43887b02 100644 --- a/libstdc++-v3/include/bits/random.tcc +++ b/libstdc++-v3/include/bits/random.tcc @@ -104,19 +104,19 @@ namespace std template<typename _UIntType, _UIntType __a, _UIntType __c, _UIntType __m> - const _UIntType + constexpr _UIntType linear_congruential_engine<_UIntType, __a, __c, __m>::multiplier; template<typename _UIntType, _UIntType __a, _UIntType __c, _UIntType __m> - const _UIntType + constexpr _UIntType linear_congruential_engine<_UIntType, __a, __c, __m>::increment; template<typename _UIntType, _UIntType __a, _UIntType __c, _UIntType __m> - const _UIntType + constexpr _UIntType linear_congruential_engine<_UIntType, __a, __c, __m>::modulus; template<typename _UIntType, _UIntType __a, _UIntType __c, _UIntType __m> - const _UIntType + constexpr _UIntType linear_congruential_engine<_UIntType, __a, __c, __m>::default_seed; /** @@ -205,7 +205,7 @@ namespace std _UIntType __a, size_t __u, _UIntType __d, size_t __s, _UIntType __b, size_t __t, _UIntType __c, size_t __l, _UIntType __f> - const size_t + constexpr size_t mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, __s, __b, __t, __c, __l, __f>::word_size; @@ -214,7 +214,7 @@ namespace std _UIntType __a, size_t __u, _UIntType __d, size_t __s, _UIntType __b, size_t __t, _UIntType __c, size_t __l, _UIntType __f> - const size_t + constexpr size_t mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, __s, __b, __t, __c, __l, __f>::state_size; @@ -223,7 +223,7 @@ namespace std _UIntType __a, size_t __u, _UIntType __d, size_t __s, _UIntType __b, size_t __t, _UIntType __c, size_t __l, _UIntType __f> - const size_t + constexpr size_t mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, __s, __b, __t, __c, __l, __f>::shift_size; @@ -232,7 +232,7 @@ namespace std _UIntType __a, size_t __u, _UIntType __d, size_t __s, _UIntType __b, size_t __t, _UIntType __c, size_t __l, _UIntType __f> - const size_t + constexpr size_t mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, __s, __b, __t, __c, __l, __f>::mask_bits; @@ -241,7 +241,7 @@ namespace std _UIntType __a, size_t __u, _UIntType __d, size_t __s, _UIntType __b, size_t __t, _UIntType __c, size_t __l, _UIntType __f> - const _UIntType + constexpr _UIntType mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, __s, __b, __t, __c, __l, __f>::xor_mask; @@ -250,7 +250,7 @@ namespace std _UIntType __a, size_t __u, _UIntType __d, size_t __s, _UIntType __b, size_t __t, _UIntType __c, size_t __l, _UIntType __f> - const size_t + constexpr size_t mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, __s, __b, __t, __c, __l, __f>::tempering_u; @@ -259,7 +259,7 @@ namespace std _UIntType __a, size_t __u, _UIntType __d, size_t __s, _UIntType __b, size_t __t, _UIntType __c, size_t __l, _UIntType __f> - const _UIntType + constexpr _UIntType mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, __s, __b, __t, __c, __l, __f>::tempering_d; @@ -268,7 +268,7 @@ namespace std _UIntType __a, size_t __u, _UIntType __d, size_t __s, _UIntType __b, size_t __t, _UIntType __c, size_t __l, _UIntType __f> - const size_t + constexpr size_t mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, __s, __b, __t, __c, __l, __f>::tempering_s; @@ -277,7 +277,7 @@ namespace std _UIntType __a, size_t __u, _UIntType __d, size_t __s, _UIntType __b, size_t __t, _UIntType __c, size_t __l, _UIntType __f> - const _UIntType + constexpr _UIntType mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, __s, __b, __t, __c, __l, __f>::tempering_b; @@ -286,7 +286,7 @@ namespace std _UIntType __a, size_t __u, _UIntType __d, size_t __s, _UIntType __b, size_t __t, _UIntType __c, size_t __l, _UIntType __f> - const size_t + constexpr size_t mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, __s, __b, __t, __c, __l, __f>::tempering_t; @@ -295,7 +295,7 @@ namespace std _UIntType __a, size_t __u, _UIntType __d, size_t __s, _UIntType __b, size_t __t, _UIntType __c, size_t __l, _UIntType __f> - const _UIntType + constexpr _UIntType mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, __s, __b, __t, __c, __l, __f>::tempering_c; @@ -304,7 +304,7 @@ namespace std _UIntType __a, size_t __u, _UIntType __d, size_t __s, _UIntType __b, size_t __t, _UIntType __c, size_t __l, _UIntType __f> - const size_t + constexpr size_t mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, __s, __b, __t, __c, __l, __f>::tempering_l; @@ -313,7 +313,7 @@ namespace std _UIntType __a, size_t __u, _UIntType __d, size_t __s, _UIntType __b, size_t __t, _UIntType __c, size_t __l, _UIntType __f> - const _UIntType + constexpr _UIntType mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, __s, __b, __t, __c, __l, __f>:: initialization_multiplier; @@ -323,7 +323,7 @@ namespace std _UIntType __a, size_t __u, _UIntType __d, size_t __s, _UIntType __b, size_t __t, _UIntType __c, size_t __l, _UIntType __f> - const _UIntType + constexpr _UIntType mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, __s, __b, __t, __c, __l, __f>::default_seed; @@ -500,19 +500,19 @@ namespace std template<typename _UIntType, size_t __w, size_t __s, size_t __r> - const size_t + constexpr size_t subtract_with_carry_engine<_UIntType, __w, __s, __r>::word_size; template<typename _UIntType, size_t __w, size_t __s, size_t __r> - const size_t + constexpr size_t subtract_with_carry_engine<_UIntType, __w, __s, __r>::short_lag; template<typename _UIntType, size_t __w, size_t __s, size_t __r> - const size_t + constexpr size_t subtract_with_carry_engine<_UIntType, __w, __s, __r>::long_lag; template<typename _UIntType, size_t __w, size_t __s, size_t __r> - const _UIntType + constexpr _UIntType subtract_with_carry_engine<_UIntType, __w, __s, __r>::default_seed; template<typename _UIntType, size_t __w, size_t __s, size_t __r> @@ -651,11 +651,11 @@ namespace std template<typename _RandomNumberEngine, size_t __p, size_t __r> - const size_t + constexpr size_t discard_block_engine<_RandomNumberEngine, __p, __r>::block_size; template<typename _RandomNumberEngine, size_t __p, size_t __r> - const size_t + constexpr size_t discard_block_engine<_RandomNumberEngine, __p, __r>::used_block; template<typename _RandomNumberEngine, size_t __p, size_t __r> @@ -761,7 +761,7 @@ namespace std template<typename _RandomNumberEngine, size_t __k> - const size_t + constexpr size_t shuffle_order_engine<_RandomNumberEngine, __k>::table_size; template<typename _RandomNumberEngine, size_t __k> diff --git a/libstdc++-v3/include/bits/regex.h b/libstdc++-v3/include/bits/regex.h index 64d4407fd72..65de5532289 100644 --- a/libstdc++-v3/include/bits/regex.h +++ b/libstdc++-v3/include/bits/regex.h @@ -349,28 +349,27 @@ namespace std /** * @name Constants * std [28.8.1](1) - * @todo These should be constexpr. */ //@{ - static const regex_constants::syntax_option_type icase + static constexpr regex_constants::syntax_option_type icase = regex_constants::icase; - static const regex_constants::syntax_option_type nosubs + static constexpr regex_constants::syntax_option_type nosubs = regex_constants::nosubs; - static const regex_constants::syntax_option_type optimize + static constexpr regex_constants::syntax_option_type optimize = regex_constants::optimize; - static const regex_constants::syntax_option_type collate + static constexpr regex_constants::syntax_option_type collate = regex_constants::collate; - static const regex_constants::syntax_option_type ECMAScript + static constexpr regex_constants::syntax_option_type ECMAScript = regex_constants::ECMAScript; - static const regex_constants::syntax_option_type basic + static constexpr regex_constants::syntax_option_type basic = regex_constants::basic; - static const regex_constants::syntax_option_type extended + static constexpr regex_constants::syntax_option_type extended = regex_constants::extended; - static const regex_constants::syntax_option_type awk + static constexpr regex_constants::syntax_option_type awk = regex_constants::awk; - static const regex_constants::syntax_option_type grep + static constexpr regex_constants::syntax_option_type grep = regex_constants::grep; - static const regex_constants::syntax_option_type egrep + static constexpr regex_constants::syntax_option_type egrep = regex_constants::egrep; //@} diff --git a/libstdc++-v3/include/bits/stl_iterator.h b/libstdc++-v3/include/bits/stl_iterator.h index 83a390d3d9e..cf543baebd0 100644 --- a/libstdc++-v3/include/bits/stl_iterator.h +++ b/libstdc++-v3/include/bits/stl_iterator.h @@ -709,7 +709,7 @@ _GLIBCXX_BEGIN_NAMESPACE(__gnu_cxx) typedef typename __traits_type::reference reference; typedef typename __traits_type::pointer pointer; - __normal_iterator() : _M_current(_Iterator()) { } + _GLIBCXX_CONSTEXPR __normal_iterator() : _M_current(_Iterator()) { } explicit __normal_iterator(const _Iterator& __i) : _M_current(__i) { } diff --git a/libstdc++-v3/include/bits/stl_pair.h b/libstdc++-v3/include/bits/stl_pair.h index f4b339db91a..0e651e7ba76 100644 --- a/libstdc++-v3/include/bits/stl_pair.h +++ b/libstdc++-v3/include/bits/stl_pair.h @@ -66,10 +66,11 @@ _GLIBCXX_BEGIN_NAMESPACE(std) #ifdef __GXX_EXPERIMENTAL_CXX0X__ + /// piecewise_construct_t struct piecewise_construct_t { }; - static const piecewise_construct_t piecewise_construct - = piecewise_construct_t(); + /// piecewise_construct + constexpr piecewise_construct_t piecewise_construct = piecewise_construct_t(); // forward declarations template<typename...> @@ -93,7 +94,7 @@ _GLIBCXX_BEGIN_NAMESPACE(std) // 265. std::pair::pair() effects overly restrictive /** The default constructor creates @c first and @c second using their * respective default constructors. */ - pair() + _GLIBCXX_CONSTEXPR pair() : first(), second() { } /** Two objects may be passed to a @c pair constructor to be copied. */ diff --git a/libstdc++-v3/include/bits/stream_iterator.h b/libstdc++-v3/include/bits/stream_iterator.h index 90f1b552b60..a5675cb1415 100644 --- a/libstdc++-v3/include/bits/stream_iterator.h +++ b/libstdc++-v3/include/bits/stream_iterator.h @@ -1,6 +1,6 @@ // Stream iterators -// Copyright (C) 2001, 2004, 2005, 2009 Free Software Foundation, Inc. +// Copyright (C) 2001, 2004, 2005, 2009, 2010 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 @@ -59,7 +59,7 @@ _GLIBCXX_BEGIN_NAMESPACE(std) public: /// Construct end of input stream iterator. - istream_iterator() + _GLIBCXX_CONSTEXPR istream_iterator() : _M_stream(0), _M_value(), _M_ok(false) {} /// Construct start of input stream iterator. diff --git a/libstdc++-v3/include/bits/streambuf_iterator.h b/libstdc++-v3/include/bits/streambuf_iterator.h index 71c323035a2..3ec1df18092 100644 --- a/libstdc++-v3/include/bits/streambuf_iterator.h +++ b/libstdc++-v3/include/bits/streambuf_iterator.h @@ -1,7 +1,7 @@ // Streambuf iterators // Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, -// 2006, 2007, 2009 +// 2006, 2007, 2009, 2010 // Free Software Foundation, Inc. // // This file is part of the GNU ISO C++ Library. This library is free @@ -93,7 +93,7 @@ _GLIBCXX_BEGIN_NAMESPACE(std) public: /// Construct end of input stream iterator. - istreambuf_iterator() throw() + _GLIBCXX_CONSTEXPR istreambuf_iterator() throw() : _M_sbuf(0), _M_c(traits_type::eof()) { } /// Construct start of input stream iterator. diff --git a/libstdc++-v3/include/bits/unique_ptr.h b/libstdc++-v3/include/bits/unique_ptr.h index d6adb1459e3..ebbc521873a 100644 --- a/libstdc++-v3/include/bits/unique_ptr.h +++ b/libstdc++-v3/include/bits/unique_ptr.h @@ -44,7 +44,7 @@ _GLIBCXX_BEGIN_NAMESPACE(std) */ /// Primary template, default_delete. - template<typename _Tp> + template<typename _Tp> struct default_delete { default_delete() { } @@ -65,7 +65,7 @@ _GLIBCXX_BEGIN_NAMESPACE(std) // _GLIBCXX_RESOLVE_LIB_DEFECTS // DR 740 - omit specialization for array objects with a compile time length /// Specialization, default_delete. - template<typename _Tp> + template<typename _Tp> struct default_delete<_Tp[]> { void @@ -78,11 +78,9 @@ _GLIBCXX_BEGIN_NAMESPACE(std) }; /// 20.7.12.2 unique_ptr for single objects. - template <typename _Tp, typename _Dp = default_delete<_Tp> > + template <typename _Tp, typename _Dp = default_delete<_Tp> > class unique_ptr { - typedef std::tuple<_Tp*, _Dp> __tuple_type; - // use SFINAE to determine whether _Del::pointer exists class _Pointer { @@ -95,19 +93,24 @@ _GLIBCXX_BEGIN_NAMESPACE(std) typedef typename remove_reference<_Dp>::type _Del; public: - typedef decltype( __test<_Del>(0) ) type; + typedef decltype( __test<_Del>(0)) type; }; + typedef std::tuple<_Tp*, _Dp> __tuple_type; + __tuple_type _M_t; + public: typedef typename _Pointer::type pointer; typedef _Tp element_type; typedef _Dp deleter_type; + static_assert(!std::is_pointer<deleter_type>::value, + "constructed with null function pointer deleter"); + // Constructors. unique_ptr() : _M_t(pointer(), deleter_type()) - { static_assert(!std::is_pointer<deleter_type>::value, - "constructed with null function pointer deleter"); } + { } explicit unique_ptr(pointer __p) @@ -116,14 +119,14 @@ _GLIBCXX_BEGIN_NAMESPACE(std) "constructed with null function pointer deleter"); } unique_ptr(pointer __p, - typename std::conditional<std::is_reference<deleter_type>::value, - deleter_type, const deleter_type&>::type __d) + typename std::conditional<std::is_reference<deleter_type>::value, + deleter_type, const deleter_type&>::type __d) : _M_t(__p, __d) { } unique_ptr(pointer __p, - typename std::remove_reference<deleter_type>::type&& __d) + typename std::remove_reference<deleter_type>::type&& __d) : _M_t(std::move(__p), std::move(__d)) - { static_assert(!std::is_reference<deleter_type>::value, + { static_assert(!std::is_reference<deleter_type>::value, "rvalue deleter bound to reference"); } unique_ptr(nullptr_t) @@ -131,7 +134,7 @@ _GLIBCXX_BEGIN_NAMESPACE(std) { } // Move constructors. - unique_ptr(unique_ptr&& __u) + unique_ptr(unique_ptr&& __u) : _M_t(__u.release(), std::forward<deleter_type>(__u.get_deleter())) { } template<typename _Up, typename _Ep, typename = typename @@ -143,9 +146,9 @@ _GLIBCXX_BEGIN_NAMESPACE(std) && std::is_same<_Ep, _Dp>::value) || (!std::is_reference<_Dp>::value && std::is_convertible<_Ep, _Dp>::value))> - ::type> - unique_ptr(unique_ptr<_Up, _Ep>&& __u) - : _M_t(__u.release(), std::forward<deleter_type>(__u.get_deleter())) + ::type> + unique_ptr(unique_ptr<_Up, _Ep>&& __u) + : _M_t(__u.release(), std::forward<deleter_type>(__u.get_deleter())) { } #if _GLIBCXX_DEPRECATED @@ -153,7 +156,7 @@ _GLIBCXX_BEGIN_NAMESPACE(std) std::enable_if<std::is_convertible<_Up*, _Tp*>::value && std::is_same<_Dp, default_delete<_Tp>>::value>::type> - unique_ptr(auto_ptr<_Up>&& __u) + unique_ptr(auto_ptr<_Up>&& __u) : _M_t(__u.release(), deleter_type()) { } #endif @@ -163,24 +166,24 @@ _GLIBCXX_BEGIN_NAMESPACE(std) // Assignment. unique_ptr& operator=(unique_ptr&& __u) - { - reset(__u.release()); - get_deleter() = std::move(__u.get_deleter()); - return *this; + { + reset(__u.release()); + get_deleter() = std::move(__u.get_deleter()); + return *this; } template<typename _Up, typename _Ep, typename = typename - std::enable_if + std::enable_if <std::is_convertible<typename unique_ptr<_Up, _Ep>::pointer, pointer>::value - && !std::is_array<_Up>::value>::type> - unique_ptr& - operator=(unique_ptr<_Up, _Ep>&& __u) + && !std::is_array<_Up>::value>::type> + unique_ptr& + operator=(unique_ptr<_Up, _Ep>&& __u) { - reset(__u.release()); - get_deleter() = std::move(__u.get_deleter()); - return *this; - } + reset(__u.release()); + get_deleter() = std::move(__u.get_deleter()); + return *this; + } unique_ptr& operator=(nullptr_t) @@ -221,7 +224,7 @@ _GLIBCXX_BEGIN_NAMESPACE(std) // Modifiers. pointer - release() + release() { pointer __p = get(); std::get<0>(_M_t) = pointer(); @@ -247,11 +250,8 @@ _GLIBCXX_BEGIN_NAMESPACE(std) // Disable copy from lvalue. unique_ptr(const unique_ptr&) = delete; unique_ptr& operator=(const unique_ptr&) = delete; - - private: - __tuple_type _M_t; }; - + /// 20.7.12.3 unique_ptr for array objects with a runtime length // [unique.ptr.runtime] // _GLIBCXX_RESOLVE_LIB_DEFECTS @@ -259,34 +259,36 @@ _GLIBCXX_BEGIN_NAMESPACE(std) template<typename _Tp, typename _Dp> class unique_ptr<_Tp[], _Dp> { - typedef std::tuple<_Tp*, _Dp> __tuple_type; + typedef std::tuple<_Tp*, _Dp> __tuple_type; + __tuple_type _M_t; public: - typedef _Tp* pointer; - typedef _Tp element_type; - typedef _Dp deleter_type; + typedef _Tp* pointer; + typedef _Tp element_type; + typedef _Dp deleter_type; + + static_assert(!std::is_pointer<deleter_type>::value, + "constructed with null function pointer deleter"); // Constructors. unique_ptr() : _M_t(pointer(), deleter_type()) - { static_assert(!std::is_pointer<deleter_type>::value, - "constructed with null function pointer deleter"); } + { } explicit unique_ptr(pointer __p) : _M_t(__p, deleter_type()) - { static_assert(!std::is_pointer<deleter_type>::value, - "constructed with null function pointer deleter"); } + { } unique_ptr(pointer __p, - typename std::conditional<std::is_reference<deleter_type>::value, - deleter_type, const deleter_type&>::type __d) + typename std::conditional<std::is_reference<deleter_type>::value, + deleter_type, const deleter_type&>::type __d) : _M_t(__p, __d) { } unique_ptr(pointer __p, typename std::remove_reference<deleter_type>::type && __d) : _M_t(std::move(__p), std::move(__d)) - { static_assert(!std::is_reference<deleter_type>::value, + { static_assert(!std::is_reference<deleter_type>::value, "rvalue deleter bound to reference"); } /* TODO: use delegating constructor */ @@ -295,11 +297,11 @@ _GLIBCXX_BEGIN_NAMESPACE(std) { } // Move constructors. - unique_ptr(unique_ptr&& __u) + unique_ptr(unique_ptr&& __u) : _M_t(__u.release(), std::forward<deleter_type>(__u.get_deleter())) { } - template<typename _Up, typename _Ep> - unique_ptr(unique_ptr<_Up, _Ep>&& __u) + template<typename _Up, typename _Ep> + unique_ptr(unique_ptr<_Up, _Ep>&& __u) : _M_t(__u.release(), std::forward<deleter_type>(__u.get_deleter())) { } @@ -311,18 +313,18 @@ _GLIBCXX_BEGIN_NAMESPACE(std) operator=(unique_ptr&& __u) { reset(__u.release()); - get_deleter() = std::move(__u.get_deleter()); - return *this; + get_deleter() = std::move(__u.get_deleter()); + return *this; } - template<typename _Up, typename _Ep> - unique_ptr& - operator=(unique_ptr<_Up, _Ep>&& __u) + template<typename _Up, typename _Ep> + unique_ptr& + operator=(unique_ptr<_Up, _Ep>&& __u) { - reset(__u.release()); - get_deleter() = std::move(__u.get_deleter()); - return *this; - } + reset(__u.release()); + get_deleter() = std::move(__u.get_deleter()); + return *this; + } unique_ptr& operator=(nullptr_t) @@ -332,8 +334,8 @@ _GLIBCXX_BEGIN_NAMESPACE(std) } // Observers. - typename std::add_lvalue_reference<element_type>::type - operator[](size_t __i) const + typename std::add_lvalue_reference<element_type>::type + operator[](size_t __i) const { _GLIBCXX_DEBUG_ASSERT(get() != pointer()); return get()[__i]; @@ -343,20 +345,20 @@ _GLIBCXX_BEGIN_NAMESPACE(std) get() const { return std::get<0>(_M_t); } - deleter_type& + deleter_type& get_deleter() { return std::get<1>(_M_t); } const deleter_type& get_deleter() const - { return std::get<1>(_M_t); } + { return std::get<1>(_M_t); } - explicit operator bool() const + explicit operator bool() const { return get() == pointer() ? false : true; } - + // Modifiers. pointer - release() + release() { pointer __p = get(); std::get<0>(_M_t) = pointer(); @@ -364,7 +366,7 @@ _GLIBCXX_BEGIN_NAMESPACE(std) } void - reset(pointer __p = pointer()) + reset(pointer __p = pointer()) { using std::swap; swap(std::get<0>(_M_t), __p); @@ -383,7 +385,7 @@ _GLIBCXX_BEGIN_NAMESPACE(std) // DR 821. template<typename _Up> - void reset(_Up) = delete; + void reset(_Up) = delete; void swap(unique_ptr& __u) @@ -399,27 +401,24 @@ _GLIBCXX_BEGIN_NAMESPACE(std) // Disable construction from convertible pointer types. // (N2315 - 20.6.5.3.1) template<typename _Up> - unique_ptr(_Up*, typename + unique_ptr(_Up*, typename std::conditional<std::is_reference<deleter_type>::value, deleter_type, const deleter_type&>::type, - typename std::enable_if<std::is_convertible<_Up*, + typename std::enable_if<std::is_convertible<_Up*, pointer>::value>::type* = 0) = delete; template<typename _Up> - unique_ptr(_Up*, typename std::remove_reference<deleter_type>::type&&, - typename std::enable_if<std::is_convertible<_Up*, + unique_ptr(_Up*, typename std::remove_reference<deleter_type>::type&&, + typename std::enable_if<std::is_convertible<_Up*, pointer>::value>::type* = 0) = delete; template<typename _Up> - explicit - unique_ptr(_Up*, typename std::enable_if<std::is_convertible<_Up*, + explicit + unique_ptr(_Up*, typename std::enable_if<std::is_convertible<_Up*, pointer>::value>::type* = 0) = delete; - - private: - __tuple_type _M_t; }; - - template<typename _Tp, typename _Dp> + + template<typename _Tp, typename _Dp> inline void swap(unique_ptr<_Tp, _Dp>& __x, unique_ptr<_Tp, _Dp>& __y) diff --git a/libstdc++-v3/include/c_compatibility/stdatomic.h b/libstdc++-v3/include/c_compatibility/stdatomic.h deleted file mode 100644 index 1b24b494f11..00000000000 --- a/libstdc++-v3/include/c_compatibility/stdatomic.h +++ /dev/null @@ -1,37 +0,0 @@ -// -*- C++ -*- compatibility header. - -// Copyright (C) 2008, 2009 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 stdatomic.h - * This is a Standard C++ Library header. - */ - -#include <bits/atomic_base.h> - -#ifndef _GLIBCXX_STDATOMIC_H -#define _GLIBCXX_STDATOMIC_H 1 - -#ifdef _GLIBCXX_NAMESPACE_C -#endif - -#endif diff --git a/libstdc++-v3/include/std/atomic b/libstdc++-v3/include/std/atomic index c94597db6f3..fc4cb86c49d 100644 --- a/libstdc++-v3/include/std/atomic +++ b/libstdc++-v3/include/std/atomic @@ -38,8 +38,9 @@ # include <bits/c++0x_warning.h> #endif -#include <bits/c++config.h> #include <bits/atomic_base.h> +#include <bits/atomic_0.h> +#include <bits/atomic_2.h> _GLIBCXX_BEGIN_NAMESPACE(std) @@ -48,37 +49,103 @@ _GLIBCXX_BEGIN_NAMESPACE(std) * @{ */ - /// kill_dependency - template<typename _Tp> - inline _Tp - kill_dependency(_Tp __y) - { - _Tp ret(__y); - return ret; - } - - inline memory_order - __calculate_memory_order(memory_order __m) + /// atomic_bool + // NB: No operators or fetch-operations for this type. + struct atomic_bool { - const bool __cond1 = __m == memory_order_release; - const bool __cond2 = __m == memory_order_acq_rel; - memory_order __mo1(__cond1 ? memory_order_relaxed : __m); - memory_order __mo2(__cond2 ? memory_order_acquire : __mo1); - return __mo2; - } + private: + __atomic_base<bool> _M_base; + + public: + atomic_bool() = default; + ~atomic_bool() = default; + atomic_bool(const atomic_bool&) = delete; + atomic_bool& operator=(const atomic_bool&) = delete; + atomic_bool& operator=(const atomic_bool&) volatile = delete; + + constexpr atomic_bool(bool __i) : _M_base(__i) { } + + bool + operator=(bool __i) + { return _M_base.operator=(__i); } + + operator bool() const + { return _M_base.load(); } + + operator bool() const volatile + { return _M_base.load(); } + + bool + is_lock_free() const { return _M_base.is_lock_free(); } + + bool + is_lock_free() const volatile { return _M_base.is_lock_free(); } + + void + store(bool __i, memory_order __m = memory_order_seq_cst) + { _M_base.store(__i, __m); } + + void + store(bool __i, memory_order __m = memory_order_seq_cst) volatile + { _M_base.store(__i, __m); } + + bool + load(memory_order __m = memory_order_seq_cst) const + { return _M_base.load(__m); } + + bool + load(memory_order __m = memory_order_seq_cst) const volatile + { return _M_base.load(__m); } + + bool + exchange(bool __i, memory_order __m = memory_order_seq_cst) + { return _M_base.exchange(__i, __m); } + + bool + exchange(bool __i, memory_order __m = memory_order_seq_cst) volatile + { return _M_base.exchange(__i, __m); } + + bool + compare_exchange_weak(bool& __i1, bool __i2, memory_order __m1, + memory_order __m2) + { return _M_base.compare_exchange_weak(__i1, __i2, __m1, __m2); } + + bool + compare_exchange_weak(bool& __i1, bool __i2, memory_order __m1, + memory_order __m2) volatile + { return _M_base.compare_exchange_weak(__i1, __i2, __m1, __m2); } + + bool + compare_exchange_weak(bool& __i1, bool __i2, + memory_order __m = memory_order_seq_cst) + { return _M_base.compare_exchange_weak(__i1, __i2, __m); } + + bool + compare_exchange_weak(bool& __i1, bool __i2, + memory_order __m = memory_order_seq_cst) volatile + { return _M_base.compare_exchange_weak(__i1, __i2, __m); } + + bool + compare_exchange_strong(bool& __i1, bool __i2, memory_order __m1, + memory_order __m2) + { return _M_base.compare_exchange_strong(__i1, __i2, __m1, __m2); } + + bool + compare_exchange_strong(bool& __i1, bool __i2, memory_order __m1, + memory_order __m2) volatile + { return _M_base.compare_exchange_strong(__i1, __i2, __m1, __m2); } + + bool + compare_exchange_strong(bool& __i1, bool __i2, + memory_order __m = memory_order_seq_cst) + { return _M_base.compare_exchange_strong(__i1, __i2, __m); } + + bool + compare_exchange_strong(bool& __i1, bool __i2, + memory_order __m = memory_order_seq_cst) volatile + { return _M_base.compare_exchange_strong(__i1, __i2, __m); } + }; - // - // 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. See file atomic_base.h. - // - // 0 == __atomic0 == Never lock-free - // 1 == __atomic1 == Best available, sometimes lock-free - // 2 == __atomic2 == Always lock-free -#include <bits/atomic_0.h> -#include <bits/atomic_2.h> /// atomic /// 29.4.3, Generic atomic type, primary class template. @@ -92,38 +159,68 @@ _GLIBCXX_BEGIN_NAMESPACE(std) atomic() = default; ~atomic() = default; atomic(const atomic&) = delete; + atomic& operator=(const atomic&) = delete; atomic& operator=(const atomic&) volatile = delete; - atomic(_Tp __i) : _M_i(__i) { } + constexpr atomic(_Tp __i) : _M_i(__i) { } operator _Tp() const; + operator _Tp() const volatile; + _Tp operator=(_Tp __i) { store(__i); return __i; } + _Tp + operator=(_Tp __i) volatile { store(__i); return __i; } + + bool + is_lock_free() const; + bool is_lock_free() const volatile; void + store(_Tp, memory_order = memory_order_seq_cst); + + void store(_Tp, memory_order = memory_order_seq_cst) volatile; _Tp + load(memory_order = memory_order_seq_cst) const; + + _Tp load(memory_order = memory_order_seq_cst) const volatile; _Tp + exchange(_Tp __i, memory_order = memory_order_seq_cst); + + _Tp exchange(_Tp __i, memory_order = memory_order_seq_cst) volatile; bool + compare_exchange_weak(_Tp&, _Tp, memory_order, memory_order); + + bool compare_exchange_weak(_Tp&, _Tp, memory_order, memory_order) volatile; bool - compare_exchange_strong(_Tp&, _Tp, memory_order, memory_order) volatile; + compare_exchange_weak(_Tp&, _Tp, memory_order = memory_order_seq_cst); bool compare_exchange_weak(_Tp&, _Tp, memory_order = memory_order_seq_cst) volatile; bool + compare_exchange_strong(_Tp&, _Tp, memory_order, memory_order); + + bool + compare_exchange_strong(_Tp&, _Tp, memory_order, memory_order) volatile; + + bool + compare_exchange_strong(_Tp&, _Tp, memory_order = memory_order_seq_cst); + + bool compare_exchange_strong(_Tp&, _Tp, memory_order = memory_order_seq_cst) volatile; }; @@ -138,41 +235,70 @@ _GLIBCXX_BEGIN_NAMESPACE(std) atomic(const atomic&) = delete; atomic& operator=(const atomic&) volatile = delete; - atomic(_Tp* __v) : atomic_address(__v) { } + constexpr atomic(_Tp* __v) : atomic_address(__v) { } + + void + store(_Tp*, memory_order = memory_order_seq_cst); void - store(_Tp* __v, memory_order __m = memory_order_seq_cst) - { atomic_address::store(__v, __m); } + store(_Tp*, memory_order = memory_order_seq_cst) volatile; _Tp* - load(memory_order __m = memory_order_seq_cst) const - { return static_cast<_Tp*>(atomic_address::load(__m)); } + load(memory_order = memory_order_seq_cst) const; _Tp* - exchange(_Tp* __v, memory_order __m = memory_order_seq_cst) - { return static_cast<_Tp*>(atomic_address::exchange(__v, __m)); } + load(memory_order = memory_order_seq_cst) const volatile; + + _Tp* + exchange(_Tp*, memory_order = memory_order_seq_cst); + + _Tp* + exchange(_Tp*, memory_order = memory_order_seq_cst) volatile; bool compare_exchange_weak(_Tp*&, _Tp*, memory_order, memory_order); bool - compare_exchange_strong(_Tp*&, _Tp*, memory_order, memory_order); + compare_exchange_weak(_Tp*&, _Tp*, memory_order, memory_order) volatile; bool compare_exchange_weak(_Tp*&, _Tp*, memory_order = memory_order_seq_cst); bool + compare_exchange_weak(_Tp*&, _Tp*, + memory_order = memory_order_seq_cst) volatile; + + bool + compare_exchange_strong(_Tp*&, _Tp*, memory_order, memory_order); + + bool + compare_exchange_strong(_Tp*&, _Tp*, memory_order, memory_order) volatile; + + bool compare_exchange_strong(_Tp*&, _Tp*, memory_order = memory_order_seq_cst); + bool + compare_exchange_strong(_Tp*&, _Tp*, + memory_order = memory_order_seq_cst) volatile; + _Tp* fetch_add(ptrdiff_t, memory_order = memory_order_seq_cst); _Tp* + fetch_add(ptrdiff_t, memory_order = memory_order_seq_cst) volatile; + + _Tp* fetch_sub(ptrdiff_t, memory_order = memory_order_seq_cst); + _Tp* + fetch_sub(ptrdiff_t, memory_order = memory_order_seq_cst) volatile; + operator _Tp*() const { return load(); } + operator _Tp*() const volatile + { return load(); } + _Tp* operator=(_Tp* __v) { @@ -181,43 +307,51 @@ _GLIBCXX_BEGIN_NAMESPACE(std) } _Tp* + operator=(_Tp* __v) volatile + { + store(__v); + return __v; + } + + _Tp* operator++(int) { return fetch_add(1); } _Tp* + operator++(int) volatile { return fetch_add(1); } + + _Tp* operator--(int) { return fetch_sub(1); } _Tp* + operator--(int) volatile { return fetch_sub(1); } + + _Tp* operator++() { return fetch_add(1) + 1; } _Tp* + operator++() volatile { return fetch_add(1) + 1; } + + _Tp* operator--() { return fetch_sub(1) - 1; } _Tp* + operator--() volatile { return fetch_sub(1) - 1; } + + _Tp* operator+=(ptrdiff_t __d) { return fetch_add(__d) + __d; } _Tp* + operator+=(ptrdiff_t __d) volatile + { return fetch_add(__d) + __d; } + + _Tp* operator-=(ptrdiff_t __d) { return fetch_sub(__d) - __d; } - }; - - - /// Explicit specialization for void* - template<> - struct atomic<void*> : public atomic_address - { - typedef void* __integral_type; - typedef atomic_address __base_type; - - atomic() = default; - ~atomic() = default; - atomic(const atomic&) = delete; - atomic& operator=(const atomic&) volatile = delete; - - atomic(__integral_type __i) : __base_type(__i) { } - using __base_type::operator __integral_type; - using __base_type::operator=; + _Tp* + operator-=(ptrdiff_t __d) volatile + { return fetch_sub(__d) - __d; } }; /// Explicit specialization for bool. @@ -230,9 +364,10 @@ _GLIBCXX_BEGIN_NAMESPACE(std) atomic() = default; ~atomic() = default; atomic(const atomic&) = delete; + atomic& operator=(const atomic&) = delete; atomic& operator=(const atomic&) volatile = delete; - atomic(__integral_type __i) : __base_type(__i) { } + constexpr atomic(__integral_type __i) : __base_type(__i) { } using __base_type::operator __integral_type; using __base_type::operator=; @@ -248,9 +383,10 @@ _GLIBCXX_BEGIN_NAMESPACE(std) atomic() = default; ~atomic() = default; atomic(const atomic&) = delete; + atomic& operator=(const atomic&) = delete; atomic& operator=(const atomic&) volatile = delete; - atomic(__integral_type __i) : __base_type(__i) { } + constexpr atomic(__integral_type __i) : __base_type(__i) { } using __base_type::operator __integral_type; using __base_type::operator=; @@ -266,9 +402,10 @@ _GLIBCXX_BEGIN_NAMESPACE(std) atomic() = default; ~atomic() = default; atomic(const atomic&) = delete; + atomic& operator=(const atomic&) = delete; atomic& operator=(const atomic&) volatile = delete; - atomic(__integral_type __i) : __base_type(__i) { } + constexpr atomic(__integral_type __i) : __base_type(__i) { } using __base_type::operator __integral_type; using __base_type::operator=; @@ -284,9 +421,10 @@ _GLIBCXX_BEGIN_NAMESPACE(std) atomic() = default; ~atomic() = default; atomic(const atomic&) = delete; + atomic& operator=(const atomic&) = delete; atomic& operator=(const atomic&) volatile = delete; - atomic(__integral_type __i) : __base_type(__i) { } + constexpr atomic(__integral_type __i) : __base_type(__i) { } using __base_type::operator __integral_type; using __base_type::operator=; @@ -302,9 +440,10 @@ _GLIBCXX_BEGIN_NAMESPACE(std) atomic() = default; ~atomic() = default; atomic(const atomic&) = delete; + atomic& operator=(const atomic&) = delete; atomic& operator=(const atomic&) volatile = delete; - atomic(__integral_type __i) : __base_type(__i) { } + constexpr atomic(__integral_type __i) : __base_type(__i) { } using __base_type::operator __integral_type; using __base_type::operator=; @@ -320,9 +459,10 @@ _GLIBCXX_BEGIN_NAMESPACE(std) atomic() = default; ~atomic() = default; atomic(const atomic&) = delete; + atomic& operator=(const atomic&) = delete; atomic& operator=(const atomic&) volatile = delete; - atomic(__integral_type __i) : __base_type(__i) { } + constexpr atomic(__integral_type __i) : __base_type(__i) { } using __base_type::operator __integral_type; using __base_type::operator=; @@ -338,9 +478,10 @@ _GLIBCXX_BEGIN_NAMESPACE(std) atomic() = default; ~atomic() = default; atomic(const atomic&) = delete; + atomic& operator=(const atomic&) = delete; atomic& operator=(const atomic&) volatile = delete; - atomic(__integral_type __i) : __base_type(__i) { } + constexpr atomic(__integral_type __i) : __base_type(__i) { } using __base_type::operator __integral_type; using __base_type::operator=; @@ -356,9 +497,10 @@ _GLIBCXX_BEGIN_NAMESPACE(std) atomic() = default; ~atomic() = default; atomic(const atomic&) = delete; + atomic& operator=(const atomic&) = delete; atomic& operator=(const atomic&) volatile = delete; - atomic(__integral_type __i) : __base_type(__i) { } + constexpr atomic(__integral_type __i) : __base_type(__i) { } using __base_type::operator __integral_type; using __base_type::operator=; @@ -374,9 +516,10 @@ _GLIBCXX_BEGIN_NAMESPACE(std) atomic() = default; ~atomic() = default; atomic(const atomic&) = delete; + atomic& operator=(const atomic&) = delete; atomic& operator=(const atomic&) volatile = delete; - atomic(__integral_type __i) : __base_type(__i) { } + constexpr atomic(__integral_type __i) : __base_type(__i) { } using __base_type::operator __integral_type; using __base_type::operator=; @@ -392,9 +535,10 @@ _GLIBCXX_BEGIN_NAMESPACE(std) atomic() = default; ~atomic() = default; atomic(const atomic&) = delete; + atomic& operator=(const atomic&) = delete; atomic& operator=(const atomic&) volatile = delete; - atomic(__integral_type __i) : __base_type(__i) { } + constexpr atomic(__integral_type __i) : __base_type(__i) { } using __base_type::operator __integral_type; using __base_type::operator=; @@ -410,9 +554,10 @@ _GLIBCXX_BEGIN_NAMESPACE(std) atomic() = default; ~atomic() = default; atomic(const atomic&) = delete; + atomic& operator=(const atomic&) = delete; atomic& operator=(const atomic&) volatile = delete; - atomic(__integral_type __i) : __base_type(__i) { } + constexpr atomic(__integral_type __i) : __base_type(__i) { } using __base_type::operator __integral_type; using __base_type::operator=; @@ -428,9 +573,10 @@ _GLIBCXX_BEGIN_NAMESPACE(std) atomic() = default; ~atomic() = default; atomic(const atomic&) = delete; + atomic& operator=(const atomic&) = delete; atomic& operator=(const atomic&) volatile = delete; - atomic(__integral_type __i) : __base_type(__i) { } + constexpr atomic(__integral_type __i) : __base_type(__i) { } using __base_type::operator __integral_type; using __base_type::operator=; @@ -446,9 +592,10 @@ _GLIBCXX_BEGIN_NAMESPACE(std) atomic() = default; ~atomic() = default; atomic(const atomic&) = delete; + atomic& operator=(const atomic&) = delete; atomic& operator=(const atomic&) volatile = delete; - atomic(__integral_type __i) : __base_type(__i) { } + constexpr atomic(__integral_type __i) : __base_type(__i) { } using __base_type::operator __integral_type; using __base_type::operator=; @@ -464,9 +611,10 @@ _GLIBCXX_BEGIN_NAMESPACE(std) atomic() = default; ~atomic() = default; atomic(const atomic&) = delete; + atomic& operator=(const atomic&) = delete; atomic& operator=(const atomic&) volatile = delete; - atomic(__integral_type __i) : __base_type(__i) { } + constexpr atomic(__integral_type __i) : __base_type(__i) { } using __base_type::operator __integral_type; using __base_type::operator=; @@ -482,14 +630,36 @@ _GLIBCXX_BEGIN_NAMESPACE(std) atomic() = default; ~atomic() = default; atomic(const atomic&) = delete; + atomic& operator=(const atomic&) = delete; atomic& operator=(const atomic&) volatile = delete; - atomic(__integral_type __i) : __base_type(__i) { } + constexpr atomic(__integral_type __i) : __base_type(__i) { } using __base_type::operator __integral_type; using __base_type::operator=; }; + + template<typename _Tp> + _Tp* + atomic<_Tp*>::load(memory_order __m) const + { return static_cast<_Tp*>(atomic_address::load(__m)); } + + template<typename _Tp> + _Tp* + atomic<_Tp*>::load(memory_order __m) const volatile + { return static_cast<_Tp*>(atomic_address::load(__m)); } + + template<typename _Tp> + _Tp* + atomic<_Tp*>::exchange(_Tp* __v, memory_order __m) + { return static_cast<_Tp*>(atomic_address::exchange(__v, __m)); } + + template<typename _Tp> + _Tp* + atomic<_Tp*>::exchange(_Tp* __v, memory_order __m) volatile + { return static_cast<_Tp*>(atomic_address::exchange(__v, __m)); } + template<typename _Tp> bool atomic<_Tp*>::compare_exchange_weak(_Tp*& __r, _Tp* __v, memory_order __m1, @@ -502,6 +672,33 @@ _GLIBCXX_BEGIN_NAMESPACE(std) template<typename _Tp> bool + atomic<_Tp*>::compare_exchange_weak(_Tp*& __r, _Tp* __v, memory_order __m1, + memory_order __m2) volatile + { + void** __vr = reinterpret_cast<void**>(&__r); + void* __vv = static_cast<void*>(__v); + return atomic_address::compare_exchange_weak(*__vr, __vv, __m1, __m2); + } + + template<typename _Tp> + bool + atomic<_Tp*>::compare_exchange_weak(_Tp*& __r, _Tp* __v, memory_order __m) + { + return compare_exchange_weak(__r, __v, __m, + __calculate_memory_order(__m)); + } + + template<typename _Tp> + bool + atomic<_Tp*>::compare_exchange_weak(_Tp*& __r, _Tp* __v, + memory_order __m) volatile + { + return compare_exchange_weak(__r, __v, __m, + __calculate_memory_order(__m)); + } + + template<typename _Tp> + bool atomic<_Tp*>::compare_exchange_strong(_Tp*& __r, _Tp* __v, memory_order __m1, memory_order __m2) @@ -513,17 +710,28 @@ _GLIBCXX_BEGIN_NAMESPACE(std) template<typename _Tp> bool - atomic<_Tp*>::compare_exchange_weak(_Tp*& __r, _Tp* __v, - memory_order __m) + atomic<_Tp*>::compare_exchange_strong(_Tp*& __r, _Tp* __v, + memory_order __m1, + memory_order __m2) volatile { - return compare_exchange_weak(__r, __v, __m, - __calculate_memory_order(__m)); + void** __vr = reinterpret_cast<void**>(&__r); + void* __vv = static_cast<void*>(__v); + return atomic_address::compare_exchange_strong(*__vr, __vv, __m1, __m2); + } + + template<typename _Tp> + bool + atomic<_Tp*>::compare_exchange_strong(_Tp*& __r, _Tp* __v, + memory_order __m) + { + return compare_exchange_strong(__r, __v, __m, + __calculate_memory_order(__m)); } template<typename _Tp> bool atomic<_Tp*>::compare_exchange_strong(_Tp*& __r, _Tp* __v, - memory_order __m) + memory_order __m) volatile { return compare_exchange_strong(__r, __v, __m, __calculate_memory_order(__m)); @@ -539,50 +747,141 @@ _GLIBCXX_BEGIN_NAMESPACE(std) template<typename _Tp> _Tp* + atomic<_Tp*>::fetch_add(ptrdiff_t __d, memory_order __m) volatile + { + void* __p = atomic_fetch_add_explicit(this, sizeof(_Tp) * __d, __m); + return static_cast<_Tp*>(__p); + } + + template<typename _Tp> + _Tp* atomic<_Tp*>::fetch_sub(ptrdiff_t __d, memory_order __m) { void* __p = atomic_fetch_sub_explicit(this, sizeof(_Tp) * __d, __m); return static_cast<_Tp*>(__p); } - // Convenience function definitions, atomic_flag. + template<typename _Tp> + _Tp* + atomic<_Tp*>::fetch_sub(ptrdiff_t __d, memory_order __m) volatile + { + void* __p = atomic_fetch_sub_explicit(this, sizeof(_Tp) * __d, __m); + return static_cast<_Tp*>(__p); + } + + + // Function definitions, atomic_flag operations. inline bool atomic_flag_test_and_set_explicit(atomic_flag* __a, memory_order __m) { return __a->test_and_set(__m); } + inline bool + atomic_flag_test_and_set_explicit(volatile atomic_flag* __a, + memory_order __m) + { return __a->test_and_set(__m); } + inline void atomic_flag_clear_explicit(atomic_flag* __a, memory_order __m) - { return __a->clear(__m); } + { __a->clear(__m); } + + inline void + atomic_flag_clear_explicit(volatile atomic_flag* __a, memory_order __m) + { __a->clear(__m); } + inline bool + atomic_flag_test_and_set(atomic_flag* __a) + { return atomic_flag_test_and_set_explicit(__a, memory_order_seq_cst); } - // Convenience function definitions, atomic_address. + inline bool + atomic_flag_test_and_set(volatile atomic_flag* __a) + { return atomic_flag_test_and_set_explicit(__a, memory_order_seq_cst); } + + inline void + atomic_flag_clear(atomic_flag* __a) + { atomic_flag_clear_explicit(__a, memory_order_seq_cst); } + + inline void + atomic_flag_clear(volatile atomic_flag* __a) + { atomic_flag_clear_explicit(__a, memory_order_seq_cst); } + + + // Function definitions, atomic_address operations. inline bool atomic_is_lock_free(const atomic_address* __a) { return __a->is_lock_free(); } + inline bool + atomic_is_lock_free(const volatile atomic_address* __a) + { return __a->is_lock_free(); } + + inline void + atomic_init(atomic_address* __a, void* __v); + + inline void + atomic_init(volatile atomic_address* __a, void* __v); + + inline void + atomic_store_explicit(atomic_address* __a, void* __v, memory_order __m) + { __a->store(__v, __m); } + + inline void + atomic_store_explicit(volatile atomic_address* __a, void* __v, + memory_order __m) + { __a->store(__v, __m); } + inline void atomic_store(atomic_address* __a, void* __v) { __a->store(__v); } inline void - atomic_store_explicit(atomic_address* __a, void* __v, memory_order __m) - { __a->store(__v, __m); } + atomic_store(volatile atomic_address* __a, void* __v) + { __a->store(__v); } + + inline void* + atomic_load_explicit(const atomic_address* __a, memory_order __m) + { return __a->load(__m); } + + inline void* + atomic_load_explicit(const volatile atomic_address* __a, memory_order __m) + { return __a->load(__m); } inline void* atomic_load(const atomic_address* __a) { return __a->load(); } inline void* - atomic_load_explicit(const atomic_address* __a, memory_order __m) - { return __a->load(__m); } + atomic_load(const volatile atomic_address* __a) + { return __a->load(); } + + inline void* + atomic_exchange_explicit(atomic_address* __a, void* __v, memory_order __m) + { return __a->exchange(__v, __m); } + + inline void* + atomic_exchange_explicit(volatile atomic_address* __a, void* __v, + memory_order __m) + { return __a->exchange(__v, __m); } inline void* atomic_exchange(atomic_address* __a, void* __v) { return __a->exchange(__v); } inline void* - atomic_exchange_explicit(atomic_address* __a, void* __v, memory_order __m) - { return __a->exchange(__v, __m); } + atomic_exchange(volatile atomic_address* __a, void* __v) + { return __a->exchange(__v); } + + + inline bool + atomic_compare_exchange_weak_explicit(atomic_address* __a, + void** __v1, void* __v2, + memory_order __m1, memory_order __m2) + { return __a->compare_exchange_weak(*__v1, __v2, __m1, __m2); } + + inline bool + atomic_compare_exchange_weak_explicit(volatile atomic_address* __a, + void** __v1, void* __v2, + memory_order __m1, memory_order __m2) + { return __a->compare_exchange_weak(*__v1, __v2, __m1, __m2); } inline bool atomic_compare_exchange_weak(atomic_address* __a, void** __v1, void* __v2) @@ -592,72 +891,152 @@ _GLIBCXX_BEGIN_NAMESPACE(std) } inline bool - atomic_compare_exchange_strong(atomic_address* __a, - void** __v1, void* __v2) + atomic_compare_exchange_weak(volatile atomic_address* __a, void** __v1, + void* __v2) { - return __a->compare_exchange_strong(*__v1, __v2, memory_order_seq_cst, + return __a->compare_exchange_weak(*__v1, __v2, memory_order_seq_cst, memory_order_seq_cst); } inline bool - atomic_compare_exchange_weak_explicit(atomic_address* __a, - void** __v1, void* __v2, - memory_order __m1, memory_order __m2) - { return __a->compare_exchange_weak(*__v1, __v2, __m1, __m2); } + atomic_compare_exchange_strong_explicit(atomic_address* __a, + void** __v1, void* __v2, + memory_order __m1, memory_order __m2) + { return __a->compare_exchange_strong(*__v1, __v2, __m1, __m2); } inline bool - atomic_compare_exchange_strong_explicit(atomic_address* __a, + atomic_compare_exchange_strong_explicit(volatile atomic_address* __a, void** __v1, void* __v2, memory_order __m1, memory_order __m2) { return __a->compare_exchange_strong(*__v1, __v2, __m1, __m2); } + inline bool + atomic_compare_exchange_strong(atomic_address* __a, void** __v1, void* __v2) + { + return __a->compare_exchange_strong(*__v1, __v2, memory_order_seq_cst, + memory_order_seq_cst); + } + + inline bool + atomic_compare_exchange_strong(volatile atomic_address* __a, + void** __v1, void* __v2) + { + return __a->compare_exchange_strong(*__v1, __v2, memory_order_seq_cst, + memory_order_seq_cst); + } + inline void* atomic_fetch_add_explicit(atomic_address* __a, ptrdiff_t __d, memory_order __m) { return __a->fetch_add(__d, __m); } inline void* + atomic_fetch_add_explicit(volatile atomic_address* __a, ptrdiff_t __d, + memory_order __m) + { return __a->fetch_add(__d, __m); } + + inline void* atomic_fetch_add(atomic_address* __a, ptrdiff_t __d) { return __a->fetch_add(__d); } inline void* + atomic_fetch_add(volatile atomic_address* __a, ptrdiff_t __d) + { return __a->fetch_add(__d); } + + inline void* atomic_fetch_sub_explicit(atomic_address* __a, ptrdiff_t __d, memory_order __m) { return __a->fetch_sub(__d, __m); } inline void* + atomic_fetch_sub_explicit(volatile atomic_address* __a, ptrdiff_t __d, + memory_order __m) + { return __a->fetch_sub(__d, __m); } + + inline void* atomic_fetch_sub(atomic_address* __a, ptrdiff_t __d) { return __a->fetch_sub(__d); } + inline void* + atomic_fetch_sub(volatile atomic_address* __a, ptrdiff_t __d) + { return __a->fetch_sub(__d); } + - // Convenience function definitions, atomic_bool. + // Function definitions, atomic_bool operations. inline bool atomic_is_lock_free(const atomic_bool* __a) { return __a->is_lock_free(); } + inline bool + atomic_is_lock_free(const volatile atomic_bool* __a) + { return __a->is_lock_free(); } + + inline void + atomic_init(atomic_bool* __a, bool __b); + + inline void + atomic_init(volatile atomic_bool* __a, bool __b); + + inline void + atomic_store_explicit(atomic_bool* __a, bool __i, memory_order __m) + { __a->store(__i, __m); } + + inline void + atomic_store_explicit(volatile atomic_bool* __a, bool __i, memory_order __m) + { __a->store(__i, __m); } + inline void atomic_store(atomic_bool* __a, bool __i) { __a->store(__i); } inline void - atomic_store_explicit(atomic_bool* __a, bool __i, memory_order __m) - { __a->store(__i, __m); } + atomic_store(volatile atomic_bool* __a, bool __i) + { __a->store(__i); } + + inline bool + atomic_load_explicit(const atomic_bool* __a, memory_order __m) + { return __a->load(__m); } + + inline bool + atomic_load_explicit(const volatile atomic_bool* __a, memory_order __m) + { return __a->load(__m); } inline bool atomic_load(const atomic_bool* __a) { return __a->load(); } inline bool - atomic_load_explicit(const atomic_bool* __a, memory_order __m) - { return __a->load(__m); } + atomic_load(const volatile atomic_bool* __a) + { return __a->load(); } + + inline bool + atomic_exchange_explicit(atomic_bool* __a, bool __i, memory_order __m) + { return __a->exchange(__i, __m); } + + inline bool + atomic_exchange_explicit(volatile atomic_bool* __a, bool __i, + memory_order __m) + { return __a->exchange(__i, __m); } inline bool atomic_exchange(atomic_bool* __a, bool __i) { return __a->exchange(__i); } inline bool - atomic_exchange_explicit(atomic_bool* __a, bool __i, memory_order __m) - { return __a->exchange(__i, __m); } + atomic_exchange(volatile atomic_bool* __a, bool __i) + { return __a->exchange(__i); } + + inline bool + atomic_compare_exchange_weak_explicit(atomic_bool* __a, bool* __i1, + bool __i2, memory_order __m1, + memory_order __m2) + { return __a->compare_exchange_weak(*__i1, __i2, __m1, __m2); } + + inline bool + atomic_compare_exchange_weak_explicit(volatile atomic_bool* __a, bool* __i1, + bool __i2, memory_order __m1, + memory_order __m2) + { return __a->compare_exchange_weak(*__i1, __i2, __m1, __m2); } inline bool atomic_compare_exchange_weak(atomic_bool* __a, bool* __i1, bool __i2) @@ -667,45 +1046,96 @@ _GLIBCXX_BEGIN_NAMESPACE(std) } inline bool - atomic_compare_exchange_strong(atomic_bool* __a, bool* __i1, bool __i2) + atomic_compare_exchange_weak(volatile atomic_bool* __a, bool* __i1, bool __i2) { - return __a->compare_exchange_strong(*__i1, __i2, memory_order_seq_cst, - memory_order_seq_cst); + return __a->compare_exchange_weak(*__i1, __i2, memory_order_seq_cst, + memory_order_seq_cst); } inline bool - atomic_compare_exchange_weak_explicit(atomic_bool* __a, bool* __i1, - bool __i2, memory_order __m1, - memory_order __m2) - { return __a->compare_exchange_weak(*__i1, __i2, __m1, __m2); } + atomic_compare_exchange_strong_explicit(atomic_bool* __a, + bool* __i1, bool __i2, + memory_order __m1, memory_order __m2) + { return __a->compare_exchange_strong(*__i1, __i2, __m1, __m2); } inline bool - atomic_compare_exchange_strong_explicit(atomic_bool* __a, + atomic_compare_exchange_strong_explicit(volatile atomic_bool* __a, bool* __i1, bool __i2, memory_order __m1, memory_order __m2) { return __a->compare_exchange_strong(*__i1, __i2, __m1, __m2); } + inline bool + atomic_compare_exchange_strong(atomic_bool* __a, bool* __i1, bool __i2) + { + return __a->compare_exchange_strong(*__i1, __i2, memory_order_seq_cst, + memory_order_seq_cst); + } + inline bool + atomic_compare_exchange_strong(volatile atomic_bool* __a, + bool* __i1, bool __i2) + { + return __a->compare_exchange_strong(*__i1, __i2, memory_order_seq_cst, + memory_order_seq_cst); + } + + + // Function templates for atomic_integral operations, using + // __atomic_base . Template argument should be constricted to + // intergral types as specified in the standard. + template<typename _ITp> + inline bool + atomic_is_lock_free(const __atomic_base<_ITp>* __a) + { return __a->is_lock_free(); } + + template<typename _ITp> + inline bool + atomic_is_lock_free(const volatile __atomic_base<_ITp>* __a) + { return __a->is_lock_free(); } + + template<typename _ITp> + inline void + atomic_init(__atomic_base<_ITp>* __a, _ITp __i); + + template<typename _ITp> + inline void + atomic_init(volatile __atomic_base<_ITp>* __a, _ITp __i); - // Free standing functions. Template argument should be constricted - // to intergral types as specified in the standard. template<typename _ITp> inline void atomic_store_explicit(__atomic_base<_ITp>* __a, _ITp __i, memory_order __m) { __a->store(__i, __m); } template<typename _ITp> + inline void + atomic_store_explicit(volatile __atomic_base<_ITp>* __a, _ITp __i, + memory_order __m) + { __a->store(__i, __m); } + + template<typename _ITp> inline _ITp atomic_load_explicit(const __atomic_base<_ITp>* __a, memory_order __m) { return __a->load(__m); } template<typename _ITp> inline _ITp + atomic_load_explicit(const volatile __atomic_base<_ITp>* __a, + memory_order __m) + { return __a->load(__m); } + + template<typename _ITp> + inline _ITp atomic_exchange_explicit(__atomic_base<_ITp>* __a, _ITp __i, memory_order __m) { return __a->exchange(__i, __m); } template<typename _ITp> + inline _ITp + atomic_exchange_explicit(volatile __atomic_base<_ITp>* __a, _ITp __i, + memory_order __m) + { return __a->exchange(__i, __m); } + + template<typename _ITp> inline bool atomic_compare_exchange_weak_explicit(__atomic_base<_ITp>* __a, _ITp* __i1, _ITp __i2, @@ -714,6 +1144,13 @@ _GLIBCXX_BEGIN_NAMESPACE(std) template<typename _ITp> inline bool + atomic_compare_exchange_weak_explicit(volatile __atomic_base<_ITp>* __a, + _ITp* __i1, _ITp __i2, + memory_order __m1, memory_order __m2) + { return __a->compare_exchange_weak(*__i1, __i2, __m1, __m2); } + + template<typename _ITp> + inline bool atomic_compare_exchange_strong_explicit(__atomic_base<_ITp>* __a, _ITp* __i1, _ITp __i2, memory_order __m1, @@ -721,6 +1158,14 @@ _GLIBCXX_BEGIN_NAMESPACE(std) { return __a->compare_exchange_strong(*__i1, __i2, __m1, __m2); } template<typename _ITp> + inline bool + atomic_compare_exchange_strong_explicit(volatile __atomic_base<_ITp>* __a, + _ITp* __i1, _ITp __i2, + memory_order __m1, + memory_order __m2) + { return __a->compare_exchange_strong(*__i1, __i2, __m1, __m2); } + + template<typename _ITp> inline _ITp atomic_fetch_add_explicit(__atomic_base<_ITp>* __a, _ITp __i, memory_order __m) @@ -728,32 +1173,57 @@ _GLIBCXX_BEGIN_NAMESPACE(std) template<typename _ITp> inline _ITp + atomic_fetch_add_explicit(volatile __atomic_base<_ITp>* __a, _ITp __i, + memory_order __m) + { return __a->fetch_add(__i, __m); } + + template<typename _ITp> + inline _ITp atomic_fetch_sub_explicit(__atomic_base<_ITp>* __a, _ITp __i, memory_order __m) { return __a->fetch_sub(__i, __m); } template<typename _ITp> inline _ITp + atomic_fetch_sub_explicit(volatile __atomic_base<_ITp>* __a, _ITp __i, + memory_order __m) + { return __a->fetch_sub(__i, __m); } + + template<typename _ITp> + inline _ITp atomic_fetch_and_explicit(__atomic_base<_ITp>* __a, _ITp __i, memory_order __m) { return __a->fetch_and(__i, __m); } template<typename _ITp> inline _ITp + atomic_fetch_and_explicit(volatile __atomic_base<_ITp>* __a, _ITp __i, + memory_order __m) + { return __a->fetch_and(__i, __m); } + + template<typename _ITp> + inline _ITp atomic_fetch_or_explicit(__atomic_base<_ITp>* __a, _ITp __i, memory_order __m) { return __a->fetch_or(__i, __m); } template<typename _ITp> inline _ITp + atomic_fetch_or_explicit(volatile __atomic_base<_ITp>* __a, _ITp __i, + memory_order __m) + { return __a->fetch_or(__i, __m); } + + template<typename _ITp> + inline _ITp atomic_fetch_xor_explicit(__atomic_base<_ITp>* __a, _ITp __i, memory_order __m) { return __a->fetch_xor(__i, __m); } template<typename _ITp> - inline bool - atomic_is_lock_free(const __atomic_base<_ITp>* __a) - { return __a->is_lock_free(); } + inline _ITp + atomic_fetch_xor_explicit(volatile __atomic_base<_ITp>* __a, _ITp __i, + memory_order __m) + { return __a->fetch_xor(__i, __m); } template<typename _ITp> inline void @@ -761,16 +1231,31 @@ _GLIBCXX_BEGIN_NAMESPACE(std) { atomic_store_explicit(__a, __i, memory_order_seq_cst); } template<typename _ITp> + inline void + atomic_store(volatile __atomic_base<_ITp>* __a, _ITp __i) + { atomic_store_explicit(__a, __i, memory_order_seq_cst); } + + template<typename _ITp> inline _ITp atomic_load(const __atomic_base<_ITp>* __a) { return atomic_load_explicit(__a, memory_order_seq_cst); } template<typename _ITp> inline _ITp + atomic_load(const volatile __atomic_base<_ITp>* __a) + { return atomic_load_explicit(__a, memory_order_seq_cst); } + + template<typename _ITp> + inline _ITp atomic_exchange(__atomic_base<_ITp>* __a, _ITp __i) { return atomic_exchange_explicit(__a, __i, memory_order_seq_cst); } template<typename _ITp> + inline _ITp + atomic_exchange(volatile __atomic_base<_ITp>* __a, _ITp __i) + { return atomic_exchange_explicit(__a, __i, memory_order_seq_cst); } + + template<typename _ITp> inline bool atomic_compare_exchange_weak(__atomic_base<_ITp>* __a, _ITp* __i1, _ITp __i2) @@ -782,6 +1267,16 @@ _GLIBCXX_BEGIN_NAMESPACE(std) template<typename _ITp> inline bool + atomic_compare_exchange_weak(volatile __atomic_base<_ITp>* __a, + _ITp* __i1, _ITp __i2) + { + return atomic_compare_exchange_weak_explicit(__a, __i1, __i2, + memory_order_seq_cst, + memory_order_seq_cst); + } + + template<typename _ITp> + inline bool atomic_compare_exchange_strong(__atomic_base<_ITp>* __a, _ITp* __i1, _ITp __i2) { @@ -791,30 +1286,65 @@ _GLIBCXX_BEGIN_NAMESPACE(std) } template<typename _ITp> + inline bool + atomic_compare_exchange_strong(volatile __atomic_base<_ITp>* __a, + _ITp* __i1, _ITp __i2) + { + return atomic_compare_exchange_strong_explicit(__a, __i1, __i2, + memory_order_seq_cst, + memory_order_seq_cst); + } + + template<typename _ITp> inline _ITp atomic_fetch_add(__atomic_base<_ITp>* __a, _ITp __i) { return atomic_fetch_add_explicit(__a, __i, memory_order_seq_cst); } template<typename _ITp> inline _ITp + atomic_fetch_add(volatile __atomic_base<_ITp>* __a, _ITp __i) + { return atomic_fetch_add_explicit(__a, __i, memory_order_seq_cst); } + + template<typename _ITp> + inline _ITp atomic_fetch_sub(__atomic_base<_ITp>* __a, _ITp __i) { return atomic_fetch_sub_explicit(__a, __i, memory_order_seq_cst); } template<typename _ITp> inline _ITp + atomic_fetch_sub(volatile __atomic_base<_ITp>* __a, _ITp __i) + { return atomic_fetch_sub_explicit(__a, __i, memory_order_seq_cst); } + + template<typename _ITp> + inline _ITp atomic_fetch_and(__atomic_base<_ITp>* __a, _ITp __i) { return atomic_fetch_and_explicit(__a, __i, memory_order_seq_cst); } template<typename _ITp> inline _ITp + atomic_fetch_and(volatile __atomic_base<_ITp>* __a, _ITp __i) + { return atomic_fetch_and_explicit(__a, __i, memory_order_seq_cst); } + + template<typename _ITp> + inline _ITp atomic_fetch_or(__atomic_base<_ITp>* __a, _ITp __i) { return atomic_fetch_or_explicit(__a, __i, memory_order_seq_cst); } template<typename _ITp> inline _ITp + atomic_fetch_or(volatile __atomic_base<_ITp>* __a, _ITp __i) + { return atomic_fetch_or_explicit(__a, __i, memory_order_seq_cst); } + + template<typename _ITp> + inline _ITp atomic_fetch_xor(__atomic_base<_ITp>* __a, _ITp __i) { return atomic_fetch_xor_explicit(__a, __i, memory_order_seq_cst); } + template<typename _ITp> + inline _ITp + atomic_fetch_xor(volatile __atomic_base<_ITp>* __a, _ITp __i) + { return atomic_fetch_xor_explicit(__a, __i, memory_order_seq_cst); } + // @} group atomics _GLIBCXX_END_NAMESPACE diff --git a/libstdc++-v3/include/std/bitset b/libstdc++-v3/include/std/bitset index 1c71c4fb969..fafbb32dd0c 100644 --- a/libstdc++-v3/include/std/bitset +++ b/libstdc++-v3/include/std/bitset @@ -72,36 +72,39 @@ _GLIBCXX_BEGIN_NESTED_NAMESPACE(std, _GLIBCXX_STD_D) /// 0 is the least significant word. _WordT _M_w[_Nw]; +#ifdef __GXX_EXPERIMENTAL_CXX0X__ + constexpr _Base_bitset() : _M_w({ }) { } + + constexpr _Base_bitset(unsigned long long __val) + : _M_w({ __val +#if __SIZEOF_LONG_LONG__ > __SIZEOF_LONG__ + , __val >> _GLIBCXX_BITSET_BITS_PER_WORD +#endif + }) { } +#else _Base_bitset() { _M_do_reset(); } -#ifdef __GXX_EXPERIMENTAL_CXX0X__ - _Base_bitset(unsigned long long __val) -#else _Base_bitset(unsigned long __val) -#endif { _M_do_reset(); _M_w[0] = __val; -#ifdef __GXX_EXPERIMENTAL_CXX0X__ - if (sizeof(unsigned long long) > sizeof(unsigned long)) - _M_w[1] = __val >> _GLIBCXX_BITSET_BITS_PER_WORD; -#endif } +#endif - static size_t + static _GLIBCXX_CONSTEXPR size_t _S_whichword(size_t __pos ) { return __pos / _GLIBCXX_BITSET_BITS_PER_WORD; } - static size_t + static _GLIBCXX_CONSTEXPR size_t _S_whichbyte(size_t __pos ) { return (__pos % _GLIBCXX_BITSET_BITS_PER_WORD) / __CHAR_BIT__; } - static size_t + static _GLIBCXX_CONSTEXPR size_t _S_whichbit(size_t __pos ) { return __pos % _GLIBCXX_BITSET_BITS_PER_WORD; } - static _WordT + static _GLIBCXX_CONSTEXPR _WordT _S_maskbit(size_t __pos ) { return (static_cast<_WordT>(1)) << _S_whichbit(__pos); } @@ -123,7 +126,7 @@ _GLIBCXX_BEGIN_NESTED_NAMESPACE(std, _GLIBCXX_STD_D) _M_hiword() { return _M_w[_Nw - 1]; } - _WordT + _GLIBCXX_CONSTEXPR _WordT _M_hiword() const { return _M_w[_Nw - 1]; } @@ -368,31 +371,31 @@ _GLIBCXX_BEGIN_NESTED_NAMESPACE(std, _GLIBCXX_STD_D) typedef unsigned long _WordT; _WordT _M_w; - _Base_bitset(void) + _GLIBCXX_CONSTEXPR _Base_bitset() : _M_w(0) { } #ifdef __GXX_EXPERIMENTAL_CXX0X__ - _Base_bitset(unsigned long long __val) + constexpr _Base_bitset(unsigned long long __val) #else _Base_bitset(unsigned long __val) #endif : _M_w(__val) { } - static size_t + static _GLIBCXX_CONSTEXPR size_t _S_whichword(size_t __pos ) { return __pos / _GLIBCXX_BITSET_BITS_PER_WORD; } - static size_t + static _GLIBCXX_CONSTEXPR size_t _S_whichbyte(size_t __pos ) { return (__pos % _GLIBCXX_BITSET_BITS_PER_WORD) / __CHAR_BIT__; } - static size_t + static _GLIBCXX_CONSTEXPR size_t _S_whichbit(size_t __pos ) { return __pos % _GLIBCXX_BITSET_BITS_PER_WORD; } - static _WordT + static _GLIBCXX_CONSTEXPR _WordT _S_maskbit(size_t __pos ) { return (static_cast<_WordT>(1)) << _S_whichbit(__pos); } @@ -414,7 +417,7 @@ _GLIBCXX_BEGIN_NESTED_NAMESPACE(std, _GLIBCXX_STD_D) _M_hiword() { return _M_w; } - _WordT + _GLIBCXX_CONSTEXPR _WordT _M_hiword() const { return _M_w; } @@ -511,29 +514,29 @@ _GLIBCXX_BEGIN_NESTED_NAMESPACE(std, _GLIBCXX_STD_D) { typedef unsigned long _WordT; - _Base_bitset() + _GLIBCXX_CONSTEXPR _Base_bitset() { } #ifdef __GXX_EXPERIMENTAL_CXX0X__ - _Base_bitset(unsigned long long) + constexpr _Base_bitset(unsigned long long) #else _Base_bitset(unsigned long) #endif { } - static size_t + static _GLIBCXX_CONSTEXPR size_t _S_whichword(size_t __pos ) { return __pos / _GLIBCXX_BITSET_BITS_PER_WORD; } - static size_t + static _GLIBCXX_CONSTEXPR size_t _S_whichbyte(size_t __pos ) { return (__pos % _GLIBCXX_BITSET_BITS_PER_WORD) / __CHAR_BIT__; } - static size_t + static _GLIBCXX_CONSTEXPR size_t _S_whichbit(size_t __pos ) { return __pos % _GLIBCXX_BITSET_BITS_PER_WORD; } - static _WordT + static _GLIBCXX_CONSTEXPR _WordT _S_maskbit(size_t __pos ) { return (static_cast<_WordT>(1)) << _S_whichbit(__pos); } @@ -545,13 +548,17 @@ _GLIBCXX_BEGIN_NESTED_NAMESPACE(std, _GLIBCXX_STD_D) // make an unchecked call; all the memory ugliness is therefore // localized to this single should-never-get-this-far function. _WordT& - _M_getword(size_t) const + _M_getword(size_t) { __throw_out_of_range(__N("_Base_bitset::_M_getword")); return *new _WordT; } _WordT + _M_getword(size_t __pos) const + { return 0; } + + _GLIBCXX_CONSTEXPR _WordT _M_hiword() const { return 0; } @@ -632,13 +639,21 @@ _GLIBCXX_BEGIN_NESTED_NAMESPACE(std, _GLIBCXX_STD_D) template<size_t _Extrabits> struct _Sanitize { - static void _S_do_sanitize(unsigned long& __val) - { __val &= ~((~static_cast<unsigned long>(0)) << _Extrabits); } + typedef unsigned long _WordT; + + static void + _S_do_sanitize(_WordT& __val) + { __val &= ~((~static_cast<_WordT>(0)) << _Extrabits); } }; template<> struct _Sanitize<0> - { static void _S_do_sanitize(unsigned long) {} }; + { + typedef unsigned long _WordT; + + static void + _S_do_sanitize(_WordT) { } + }; /** * @brief The %bitset class represents a @e fixed-size sequence of bits. @@ -713,11 +728,11 @@ _GLIBCXX_BEGIN_NESTED_NAMESPACE(std, _GLIBCXX_STD_D) typedef unsigned long _WordT; void - _M_do_sanitize() - { - _Sanitize<_Nb % _GLIBCXX_BITSET_BITS_PER_WORD>:: - _S_do_sanitize(this->_M_hiword()); - } + _M_do_sanitize() + { + typedef _Sanitize<_Nb % _GLIBCXX_BITSET_BITS_PER_WORD> __sanitize_type; + __sanitize_type::_S_do_sanitize(this->_M_hiword()); + } #ifdef __GXX_EXPERIMENTAL_CXX0X__ template<typename> friend class hash; @@ -740,8 +755,8 @@ _GLIBCXX_BEGIN_NESTED_NAMESPACE(std, _GLIBCXX_STD_D) { friend class bitset; - _WordT *_M_wp; - size_t _M_bpos; + _WordT* _M_wp; + size_t _M_bpos; // left undefined reference(); @@ -799,17 +814,18 @@ _GLIBCXX_BEGIN_NESTED_NAMESPACE(std, _GLIBCXX_STD_D) // 23.3.5.1 constructors: /// All bits set to zero. - bitset() + _GLIBCXX_CONSTEXPR bitset() { } /// Initial bits bitwise-copied from a single word (others set to zero). #ifdef __GXX_EXPERIMENTAL_CXX0X__ - bitset(unsigned long long __val) + constexpr bitset(unsigned long long __val) + : _Base(__val) { } #else bitset(unsigned long __val) -#endif : _Base(__val) { _M_do_sanitize(); } +#endif /** * @brief Use a subset of a string. @@ -1088,8 +1104,8 @@ _GLIBCXX_BEGIN_NESTED_NAMESPACE(std, _GLIBCXX_STD_D) /** * @brief Array-indexing support. * @param position Index into the %bitset. - * @return A bool for a <em>const %bitset</em>. For non-const bitsets, an - * instance of the reference proxy class. + * @return A bool for a <em>const %bitset</em>. For non-const + * bitsets, an instance of the reference proxy class. * @note These operators do no range checking and throw no exceptions, * as required by DR 11 to the standard. * @@ -1101,7 +1117,7 @@ _GLIBCXX_BEGIN_NESTED_NAMESPACE(std, _GLIBCXX_STD_D) */ reference operator[](size_t __position) - { return reference(*this,__position); } + { return reference(*this, __position); } bool operator[](size_t __position) const @@ -1236,7 +1252,7 @@ _GLIBCXX_BEGIN_NESTED_NAMESPACE(std, _GLIBCXX_STD_D) { return this->_M_do_count(); } /// Returns the total number of bits. - size_t + _GLIBCXX_CONSTEXPR size_t size() const { return _Nb; } diff --git a/libstdc++-v3/include/std/chrono b/libstdc++-v3/include/std/chrono index 230b7f4e813..1d9552a9914 100644 --- a/libstdc++-v3/include/std/chrono +++ b/libstdc++-v3/include/std/chrono @@ -46,7 +46,7 @@ #ifdef _GLIBCXX_USE_C99_STDINT_TR1 -namespace std +namespace std { /** * @defgroup chrono Time @@ -71,71 +71,75 @@ namespace std // 20.8.2.3 specialization of common_type (for duration) template<typename _Rep1, typename _Period1, typename _Rep2, typename _Period2> struct common_type<chrono::duration<_Rep1, _Period1>, - chrono::duration<_Rep2, _Period2>> + chrono::duration<_Rep2, _Period2>> { typedef chrono::duration<typename common_type<_Rep1, _Rep2>::type, - ratio<__static_gcd<_Period1::num, _Period2::num>::value, - (_Period1::den / __static_gcd<_Period1::den, _Period2::den>::value) - * _Period2::den>> type; + ratio<__static_gcd<_Period1::num, _Period2::num>::value, + (_Period1::den / __static_gcd<_Period1::den, _Period2::den>::value) + * _Period2::den>> type; }; - + // 20.8.2.3 specialization of common_type (for time_point) template<typename _Clock, typename _Duration1, typename _Duration2> struct common_type<chrono::time_point<_Clock, _Duration1>, - chrono::time_point<_Clock, _Duration2>> + chrono::time_point<_Clock, _Duration2>> { - typedef chrono::time_point<_Clock, - typename common_type<_Duration1, _Duration2>::type> type; + typedef chrono::time_point<_Clock, + typename common_type<_Duration1, _Duration2>::type> type; }; - namespace chrono + namespace chrono { // Primary template for duration_cast impl. template<typename _ToDuration, typename _CF, typename _CR, - bool _NumIsOne = false, bool _DenIsOne = false> + bool _NumIsOne = false, bool _DenIsOne = false> struct __duration_cast_impl { - template<typename _Rep, typename _Period> - static _ToDuration __cast(const duration<_Rep, _Period>& __d) - { - return _ToDuration(static_cast< - typename _ToDuration::rep>(static_cast<_CR>(__d.count()) - * static_cast<_CR>(_CF::num) - / static_cast<_CR>(_CF::den))); - } + template<typename _Rep, typename _Period> + static constexpr _ToDuration + __cast(const duration<_Rep, _Period>& __d) + { + return _ToDuration(static_cast< + typename _ToDuration::rep>(static_cast<_CR>(__d.count()) + * static_cast<_CR>(_CF::num) + / static_cast<_CR>(_CF::den))); + } }; template<typename _ToDuration, typename _CF, typename _CR> struct __duration_cast_impl<_ToDuration, _CF, _CR, true, true> { - template<typename _Rep, typename _Period> - static _ToDuration __cast(const duration<_Rep, _Period>& __d) - { - return _ToDuration( - static_cast<typename _ToDuration::rep>(__d.count())); - } + template<typename _Rep, typename _Period> + static constexpr _ToDuration + __cast(const duration<_Rep, _Period>& __d) + { + return _ToDuration( + static_cast<typename _ToDuration::rep>(__d.count())); + } }; template<typename _ToDuration, typename _CF, typename _CR> struct __duration_cast_impl<_ToDuration, _CF, _CR, true, false> { - template<typename _Rep, typename _Period> - static _ToDuration __cast(const duration<_Rep, _Period>& __d) - { - return _ToDuration(static_cast<typename _ToDuration::rep>( - static_cast<_CR>(__d.count()) / static_cast<_CR>(_CF::den))); - } + template<typename _Rep, typename _Period> + static constexpr _ToDuration + __cast(const duration<_Rep, _Period>& __d) + { + return _ToDuration(static_cast<typename _ToDuration::rep>( + static_cast<_CR>(__d.count()) / static_cast<_CR>(_CF::den))); + } }; template<typename _ToDuration, typename _CF, typename _CR> struct __duration_cast_impl<_ToDuration, _CF, _CR, false, true> { - template<typename _Rep, typename _Period> - static _ToDuration __cast(const duration<_Rep, _Period>& __d) - { - return _ToDuration(static_cast<typename _ToDuration::rep>( - static_cast<_CR>(__d.count()) * static_cast<_CR>(_CF::num))); - } + template<typename _Rep, typename _Period> + static constexpr _ToDuration + __cast(const duration<_Rep, _Period>& __d) + { + return _ToDuration(static_cast<typename _ToDuration::rep>( + static_cast<_CR>(__d.count()) * static_cast<_CR>(_CF::num))); + } }; template<typename _Tp> @@ -150,17 +154,17 @@ namespace std /// duration_cast template<typename _ToDuration, typename _Rep, typename _Period> - inline typename enable_if<__is_duration<_ToDuration>::value, + inline constexpr typename enable_if<__is_duration<_ToDuration>::value, _ToDuration>::type duration_cast(const duration<_Rep, _Period>& __d) { - typedef typename - ratio_divide<_Period, typename _ToDuration::period>::type __cf; - typedef typename - common_type<typename _ToDuration::rep, _Rep, intmax_t>::type __cr; + typedef typename + ratio_divide<_Period, typename _ToDuration::period>::type __cf; + typedef typename + common_type<typename _ToDuration::rep, _Rep, intmax_t>::type __cr; - return __duration_cast_impl<_ToDuration, __cf, __cr, - __cf::num == 1, __cf::den == 1>::__cast(__d); + return __duration_cast_impl<_ToDuration, __cf, __cr, + __cf::num == 1, __cf::den == 1>::__cast(__d); } /// treat_as_floating_point @@ -173,17 +177,17 @@ namespace std template<typename _Rep> struct duration_values { - static const _Rep - zero() - { return _Rep(0); } - - static const _Rep - max() - { return numeric_limits<_Rep>::max(); } - - static const _Rep - min() - { return numeric_limits<_Rep>::min(); } + static constexpr _Rep + zero() + { return _Rep(0); } + + static constexpr _Rep + max() + { return numeric_limits<_Rep>::max(); } + + static constexpr _Rep + min() + { return numeric_limits<_Rep>::min(); } }; template<typename T> @@ -200,98 +204,98 @@ namespace std template<typename _Rep, typename _Period> struct duration { + typedef _Rep rep; + typedef _Period period; + static_assert(!__is_duration<_Rep>::value, "rep cannot be a duration"); - static_assert(__is_ratio<_Period>::value, + static_assert(__is_ratio<_Period>::value, "period must be a specialization of ratio"); - static_assert(_Period::num > 0, "period must be positive"); - - typedef _Rep rep; - typedef _Period period; - - // 20.8.3.1 construction / copy / destroy - duration() = default; - - template<typename _Rep2, typename = typename + static_assert(_Period::num > 0, "period must be positive"); + + // 20.8.3.1 construction / copy / destroy + constexpr duration() : __r() { } + + template<typename _Rep2, typename = typename enable_if<is_convertible<_Rep2, rep>::value && (treat_as_floating_point<rep>::value || !treat_as_floating_point<_Rep2>::value)>::type> - explicit duration(const _Rep2& __rep) - : __r(static_cast<rep>(__rep)) { } + constexpr explicit duration(const _Rep2& __rep) + : __r(static_cast<rep>(__rep)) { } - template<typename _Rep2, typename _Period2, typename = typename - enable_if<treat_as_floating_point<rep>::value + template<typename _Rep2, typename _Period2, typename = typename + enable_if<treat_as_floating_point<rep>::value || (ratio_divide<_Period2, period>::type::den == 1 && !treat_as_floating_point<_Rep2>::value)>::type> - duration(const duration<_Rep2, _Period2>& __d) - : __r(duration_cast<duration>(__d).count()) { } + constexpr duration(const duration<_Rep2, _Period2>& __d) + : __r(duration_cast<duration>(__d).count()) { } ~duration() = default; duration(const duration&) = default; duration& operator=(const duration&) = default; - // 20.8.3.2 observer - rep - count() const - { return __r; } - - // 20.8.3.3 arithmetic - duration - operator+() const - { return *this; } - - duration - operator-() const - { return duration(-__r); } - - duration& - operator++() - { - ++__r; - return *this; - } - - duration - operator++(int) - { return duration(__r++); } - - duration& - operator--() - { - --__r; - return *this; - } - - duration - operator--(int) - { return duration(__r--); } - - duration& - operator+=(const duration& __d) - { - __r += __d.count(); - return *this; - } - - duration& - operator-=(const duration& __d) - { - __r -= __d.count(); - return *this; - } - - duration& - operator*=(const rep& __rhs) - { - __r *= __rhs; - return *this; - } - - duration& - operator/=(const rep& __rhs) - { - __r /= __rhs; - return *this; - } + // 20.8.3.2 observer + constexpr rep + count() const + { return __r; } + + // 20.8.3.3 arithmetic + constexpr duration + operator+() const + { return *this; } + + constexpr duration + operator-() const + { return duration(-__r); } + + duration& + operator++() + { + ++__r; + return *this; + } + + duration + operator++(int) + { return duration(__r++); } + + duration& + operator--() + { + --__r; + return *this; + } + + duration + operator--(int) + { return duration(__r--); } + + duration& + operator+=(const duration& __d) + { + __r += __d.count(); + return *this; + } + + duration& + operator-=(const duration& __d) + { + __r -= __d.count(); + return *this; + } + + duration& + operator*=(const rep& __rhs) + { + __r *= __rhs; + return *this; + } + + duration& + operator/=(const rep& __rhs) + { + __r /= __rhs; + return *this; + } // DR 934. template<typename _Rep2 = rep> @@ -312,46 +316,45 @@ namespace std return *this; } - // 20.8.3.4 special values - // TODO: These should be constexprs. - static const duration - zero() - { return duration(duration_values<rep>::zero()); } + // 20.8.3.4 special values + static constexpr duration + zero() + { return duration(duration_values<rep>::zero()); } + + static constexpr duration + min() + { return duration(duration_values<rep>::min()); } - static const duration - min() - { return duration(duration_values<rep>::min()); } - - static const duration - max() - { return duration(duration_values<rep>::max()); } + static constexpr duration + max() + { return duration(duration_values<rep>::max()); } private: - rep __r; + rep __r; }; template<typename _Rep1, typename _Period1, - typename _Rep2, typename _Period2> - inline typename common_type<duration<_Rep1, _Period1>, - duration<_Rep2, _Period2>>::type - operator+(const duration<_Rep1, _Period1>& __lhs, - const duration<_Rep2, _Period2>& __rhs) + typename _Rep2, typename _Period2> + inline typename common_type<duration<_Rep1, _Period1>, + duration<_Rep2, _Period2>>::type + operator+(const duration<_Rep1, _Period1>& __lhs, + const duration<_Rep2, _Period2>& __rhs) { - typedef typename common_type<duration<_Rep1, _Period1>, - duration<_Rep2, _Period2>>::type __ct; - return __ct(__lhs) += __rhs; + typedef typename common_type<duration<_Rep1, _Period1>, + duration<_Rep2, _Period2>>::type __ct; + return __ct(__lhs) += __rhs; } - template<typename _Rep1, typename _Period1, - typename _Rep2, typename _Period2> - inline typename common_type<duration<_Rep1, _Period1>, - duration<_Rep2, _Period2>>::type - operator-(const duration<_Rep1, _Period1>& __lhs, - const duration<_Rep2, _Period2>& __rhs) + template<typename _Rep1, typename _Period1, + typename _Rep2, typename _Period2> + inline typename common_type<duration<_Rep1, _Period1>, + duration<_Rep2, _Period2>>::type + operator-(const duration<_Rep1, _Period1>& __lhs, + const duration<_Rep2, _Period2>& __rhs) { - typedef typename common_type<duration<_Rep1, _Period1>, - duration<_Rep2, _Period2>>::type __ct; - return __ct(__lhs) -= __rhs; + typedef typename common_type<duration<_Rep1, _Period1>, + duration<_Rep2, _Period2>>::type __ct; + return __ct(__lhs) -= __rhs; } template<typename _Rep1, typename _Rep2, bool = @@ -361,21 +364,21 @@ namespace std template<typename _Rep1, typename _Rep2> struct __common_rep_type<_Rep1, _Rep2, true> - { typedef typename common_type<_Rep1, _Rep2>::type type; }; + { typedef typename common_type<_Rep1, _Rep2>::type type; }; template<typename _Rep1, typename _Period, typename _Rep2> inline duration<typename __common_rep_type<_Rep1, _Rep2>::type, _Period> operator*(const duration<_Rep1, _Period>& __d, const _Rep2& __s) { - typedef typename common_type<_Rep1, _Rep2>::type __cr; - return duration<__cr, _Period>(__d) *= __s; + typedef typename common_type<_Rep1, _Rep2>::type __cr; + return duration<__cr, _Period>(__d) *= __s; } template<typename _Rep1, typename _Period, typename _Rep2> inline duration<typename __common_rep_type<_Rep2, _Rep1>::type, _Period> operator*(const _Rep1& __s, const duration<_Rep2, _Period>& __d) { return __d * __s; } - + template<typename _Rep1, typename _Period, typename _Rep2> inline duration<typename __common_rep_type<_Rep1, typename enable_if<!__is_duration<_Rep2>::value, _Rep2>::type>::type, _Period> @@ -388,12 +391,12 @@ namespace std template<typename _Rep1, typename _Period1, typename _Rep2, typename _Period2> inline typename common_type<_Rep1, _Rep2>::type - operator/(const duration<_Rep1, _Period1>& __lhs, - const duration<_Rep2, _Period2>& __rhs) + operator/(const duration<_Rep1, _Period1>& __lhs, + const duration<_Rep2, _Period2>& __rhs) { - typedef typename common_type<duration<_Rep1, _Period1>, - duration<_Rep2, _Period2>>::type __ct; - return __ct(__lhs).count() / __ct(__rhs).count(); + typedef typename common_type<duration<_Rep1, _Period1>, + duration<_Rep2, _Period2>>::type __ct; + return __ct(__lhs).count() / __ct(__rhs).count(); } // DR 934. @@ -408,112 +411,112 @@ namespace std template<typename _Rep1, typename _Period1, typename _Rep2, typename _Period2> - inline typename common_type<duration<_Rep1, _Period1>, - duration<_Rep2, _Period2>>::type - operator%(const duration<_Rep1, _Period1>& __lhs, - const duration<_Rep2, _Period2>& __rhs) + inline typename common_type<duration<_Rep1, _Period1>, + duration<_Rep2, _Period2>>::type + operator%(const duration<_Rep1, _Period1>& __lhs, + const duration<_Rep2, _Period2>& __rhs) { - typedef typename common_type<duration<_Rep1, _Period1>, - duration<_Rep2, _Period2>>::type __ct; - return __ct(__lhs) %= __rhs; + typedef typename common_type<duration<_Rep1, _Period1>, + duration<_Rep2, _Period2>>::type __ct; + return __ct(__lhs) %= __rhs; } // comparisons template<typename _Rep1, typename _Period1, - typename _Rep2, typename _Period2> - inline bool - operator==(const duration<_Rep1, _Period1>& __lhs, - const duration<_Rep2, _Period2>& __rhs) + typename _Rep2, typename _Period2> + inline constexpr bool + operator==(const duration<_Rep1, _Period1>& __lhs, + const duration<_Rep2, _Period2>& __rhs) { - typedef typename common_type<duration<_Rep1, _Period1>, - duration<_Rep2, _Period2>>::type __ct; - return __ct(__lhs).count() == __ct(__rhs).count(); + typedef typename common_type<duration<_Rep1, _Period1>, + duration<_Rep2, _Period2>>::type __ct; + return __ct(__lhs).count() == __ct(__rhs).count(); } template<typename _Rep1, typename _Period1, - typename _Rep2, typename _Period2> - inline bool - operator<(const duration<_Rep1, _Period1>& __lhs, - const duration<_Rep2, _Period2>& __rhs) + typename _Rep2, typename _Period2> + inline constexpr bool + operator<(const duration<_Rep1, _Period1>& __lhs, + const duration<_Rep2, _Period2>& __rhs) { - typedef typename common_type<duration<_Rep1, _Period1>, - duration<_Rep2, _Period2>>::type __ct; - return __ct(__lhs).count() < __ct(__rhs).count(); + typedef typename common_type<duration<_Rep1, _Period1>, + duration<_Rep2, _Period2>>::type __ct; + return __ct(__lhs).count() < __ct(__rhs).count(); } template<typename _Rep1, typename _Period1, - typename _Rep2, typename _Period2> - inline bool - operator!=(const duration<_Rep1, _Period1>& __lhs, - const duration<_Rep2, _Period2>& __rhs) + typename _Rep2, typename _Period2> + inline constexpr bool + operator!=(const duration<_Rep1, _Period1>& __lhs, + const duration<_Rep2, _Period2>& __rhs) { return !(__lhs == __rhs); } template<typename _Rep1, typename _Period1, - typename _Rep2, typename _Period2> - inline bool - operator<=(const duration<_Rep1, _Period1>& __lhs, - const duration<_Rep2, _Period2>& __rhs) + typename _Rep2, typename _Period2> + inline constexpr bool + operator<=(const duration<_Rep1, _Period1>& __lhs, + const duration<_Rep2, _Period2>& __rhs) { return !(__rhs < __lhs); } template<typename _Rep1, typename _Period1, - typename _Rep2, typename _Period2> - inline bool - operator>(const duration<_Rep1, _Period1>& __lhs, - const duration<_Rep2, _Period2>& __rhs) + typename _Rep2, typename _Period2> + inline constexpr bool + operator>(const duration<_Rep1, _Period1>& __lhs, + const duration<_Rep2, _Period2>& __rhs) { return __rhs < __lhs; } - template<typename _Rep1, typename _Period1, - typename _Rep2, typename _Period2> - inline bool - operator>=(const duration<_Rep1, _Period1>& __lhs, - const duration<_Rep2, _Period2>& __rhs) + template<typename _Rep1, typename _Period1, + typename _Rep2, typename _Period2> + inline constexpr bool + operator>=(const duration<_Rep1, _Period1>& __lhs, + const duration<_Rep2, _Period2>& __rhs) { return !(__lhs < __rhs); } /// nanoseconds - typedef duration<int64_t, nano> nanoseconds; + typedef duration<int64_t, nano> nanoseconds; /// microseconds - typedef duration<int64_t, micro> microseconds; + typedef duration<int64_t, micro> microseconds; /// milliseconds - typedef duration<int64_t, milli> milliseconds; - + typedef duration<int64_t, milli> milliseconds; + /// seconds - typedef duration<int64_t > seconds; + typedef duration<int64_t> seconds; /// minutes - typedef duration<int, ratio< 60>> minutes; + typedef duration<int, ratio< 60>> minutes; /// hours - typedef duration<int, ratio<3600>> hours; + typedef duration<int, ratio<3600>> hours; /// time_point template<typename _Clock, typename _Duration> struct time_point { - typedef _Clock clock; - typedef _Duration duration; - typedef typename duration::rep rep; - typedef typename duration::period period; + typedef _Clock clock; + typedef _Duration duration; + typedef typename duration::rep rep; + typedef typename duration::period period; - time_point() : __d(duration::zero()) + constexpr time_point() : __d(duration::zero()) { } - explicit time_point(const duration& __dur) - : __d(duration::zero() + __dur) + constexpr explicit time_point(const duration& __dur) + : __d(__dur) { } // conversions template<typename _Duration2> - time_point(const time_point<clock, _Duration2>& __t) + constexpr time_point(const time_point<clock, _Duration2>& __t) : __d(__t.time_since_epoch()) { } // observer - duration + constexpr duration time_since_epoch() const { return __d; } - + // arithmetic time_point& operator+=(const duration& __dur) @@ -521,124 +524,127 @@ namespace std __d += __dur; return *this; } - + time_point& operator-=(const duration& __dur) { __d -= __dur; return *this; } - + // special values - // TODO: These should be constexprs. - static const time_point + static constexpr time_point min() { return time_point(duration::min()); } - - static const time_point + + static constexpr time_point max() { return time_point(duration::max()); } - + private: duration __d; }; - + /// time_point_cast template<typename _ToDuration, typename _Clock, typename _Duration> - inline typename enable_if<__is_duration<_ToDuration>::value, + inline constexpr typename enable_if<__is_duration<_ToDuration>::value, time_point<_Clock, _ToDuration>>::type time_point_cast(const time_point<_Clock, _Duration>& __t) { - return time_point<_Clock, _ToDuration>( - duration_cast<_ToDuration>(__t.time_since_epoch())); + return time_point<_Clock, _ToDuration>( + duration_cast<_ToDuration>(__t.time_since_epoch())); } template<typename _Clock, typename _Duration1, - typename _Rep2, typename _Period2> - inline time_point<_Clock, - typename common_type<_Duration1, duration<_Rep2, _Period2>>::type> - operator+(const time_point<_Clock, _Duration1>& __lhs, - const duration<_Rep2, _Period2>& __rhs) + typename _Rep2, typename _Period2> + inline time_point<_Clock, + typename common_type<_Duration1, duration<_Rep2, _Period2>>::type> + operator+(const time_point<_Clock, _Duration1>& __lhs, + const duration<_Rep2, _Period2>& __rhs) { - typedef time_point<_Clock, - typename common_type<_Duration1, - duration<_Rep2, _Period2>>::type> __ct; - return __ct(__lhs) += __rhs; + typedef time_point<_Clock, + typename common_type<_Duration1, + duration<_Rep2, _Period2>>::type> __ct; + return __ct(__lhs) += __rhs; } template<typename _Rep1, typename _Period1, - typename _Clock, typename _Duration2> - inline time_point<_Clock, - typename common_type<duration<_Rep1, _Period1>, _Duration2>::type> - operator+(const duration<_Rep1, _Period1>& __lhs, - const time_point<_Clock, _Duration2>& __rhs) + typename _Clock, typename _Duration2> + inline time_point<_Clock, + typename common_type<duration<_Rep1, _Period1>, _Duration2>::type> + operator+(const duration<_Rep1, _Period1>& __lhs, + const time_point<_Clock, _Duration2>& __rhs) { return __rhs + __lhs; } template<typename _Clock, typename _Duration1, - typename _Rep2, typename _Period2> - inline time_point<_Clock, - typename common_type<_Duration1, duration<_Rep2, _Period2>>::type> - operator-(const time_point<_Clock, _Duration1>& __lhs, - const duration<_Rep2, _Period2>& __rhs) + typename _Rep2, typename _Period2> + inline time_point<_Clock, + typename common_type<_Duration1, duration<_Rep2, _Period2>>::type> + operator-(const time_point<_Clock, _Duration1>& __lhs, + const duration<_Rep2, _Period2>& __rhs) { return __lhs + (-__rhs); } template<typename _Clock, typename _Duration1, typename _Duration2> inline typename common_type<_Duration1, _Duration2>::type - operator-(const time_point<_Clock, _Duration1>& __lhs, - const time_point<_Clock, _Duration2>& __rhs) + operator-(const time_point<_Clock, _Duration1>& __lhs, + const time_point<_Clock, _Duration2>& __rhs) { return __lhs.time_since_epoch() - __rhs.time_since_epoch(); } template<typename _Clock, typename _Duration1, typename _Duration2> - inline bool + inline constexpr bool operator==(const time_point<_Clock, _Duration1>& __lhs, - const time_point<_Clock, _Duration2>& __rhs) + const time_point<_Clock, _Duration2>& __rhs) { return __lhs.time_since_epoch() == __rhs.time_since_epoch(); } template<typename _Clock, typename _Duration1, typename _Duration2> - inline bool + inline constexpr bool operator!=(const time_point<_Clock, _Duration1>& __lhs, - const time_point<_Clock, _Duration2>& __rhs) + const time_point<_Clock, _Duration2>& __rhs) { return !(__lhs == __rhs); } template<typename _Clock, typename _Duration1, typename _Duration2> - inline bool + inline constexpr bool operator<(const time_point<_Clock, _Duration1>& __lhs, - const time_point<_Clock, _Duration2>& __rhs) + const time_point<_Clock, _Duration2>& __rhs) { return __lhs.time_since_epoch() < __rhs.time_since_epoch(); } template<typename _Clock, typename _Duration1, typename _Duration2> - inline bool + inline constexpr bool operator<=(const time_point<_Clock, _Duration1>& __lhs, - const time_point<_Clock, _Duration2>& __rhs) + const time_point<_Clock, _Duration2>& __rhs) { return !(__rhs < __lhs); } template<typename _Clock, typename _Duration1, typename _Duration2> - inline bool + inline constexpr bool operator>(const time_point<_Clock, _Duration1>& __lhs, - const time_point<_Clock, _Duration2>& __rhs) + const time_point<_Clock, _Duration2>& __rhs) { return __rhs < __lhs; } template<typename _Clock, typename _Duration1, typename _Duration2> - inline bool + inline constexpr bool operator>=(const time_point<_Clock, _Duration1>& __lhs, - const time_point<_Clock, _Duration2>& __rhs) + const time_point<_Clock, _Duration2>& __rhs) { return !(__lhs < __rhs); } /// system_clock struct system_clock { #ifdef _GLIBCXX_USE_CLOCK_REALTIME - typedef chrono::nanoseconds duration; + typedef chrono::nanoseconds duration; #elif defined(_GLIBCXX_USE_GETTIMEOFDAY) - typedef chrono::microseconds duration; + typedef chrono::microseconds duration; #else - typedef chrono::seconds duration; + typedef chrono::seconds duration; #endif typedef duration::rep rep; typedef duration::period period; typedef chrono::time_point<system_clock, duration> time_point; + static_assert(system_clock::duration::min() + < system_clock::duration::zero(), + "a clock's minimum duration cannot be less than its epoch"); + static const bool is_monotonic = false; static time_point @@ -648,25 +654,17 @@ namespace std static std::time_t to_time_t(const time_point& __t) { - return std::time_t( - duration_cast<chrono::seconds>(__t.time_since_epoch()).count()); + return std::time_t( + duration_cast<chrono::seconds>(__t.time_since_epoch()).count()); } static time_point from_time_t(std::time_t __t) - { - return time_point_cast<system_clock::duration>( - chrono::time_point<system_clock, chrono::seconds>( - chrono::seconds(__t))); + { + return time_point_cast<system_clock::duration>( + chrono::time_point<system_clock, chrono::seconds>( + chrono::seconds(__t))); } - - // TODO: requires constexpr - /* - static_assert( - system_clock::duration::min() < - system_clock::duration::zero(), - "a clock's minimum duration cannot be less than its epoch"); - */ }; #ifdef _GLIBCXX_USE_CLOCK_MONOTONIC diff --git a/libstdc++-v3/include/std/complex b/libstdc++-v3/include/std/complex index 93056510e08..6f0fe44eefc 100644 --- a/libstdc++-v3/include/std/complex +++ b/libstdc++-v3/include/std/complex @@ -126,49 +126,49 @@ _GLIBCXX_BEGIN_NAMESPACE(std) /// Default constructor. First parameter is x, second parameter is y. /// Unspecified parameters default to 0. - complex(const _Tp& __r = _Tp(), const _Tp& __i = _Tp()) + _GLIBCXX_CONSTEXPR complex(const _Tp& __r = _Tp(), const _Tp& __i = _Tp()) : _M_real(__r), _M_imag(__i) { } // Lets the compiler synthesize the copy constructor // complex (const complex<_Tp>&); /// Copy constructor. template<typename _Up> - complex(const complex<_Up>& __z) + _GLIBCXX_CONSTEXPR complex(const complex<_Up>& __z) : _M_real(__z.real()), _M_imag(__z.imag()) { } #ifdef __GXX_EXPERIMENTAL_CXX0X__ // _GLIBCXX_RESOLVE_LIB_DEFECTS // DR 387. std::complex over-encapsulated. - _Tp real() const - { return _M_real; } + constexpr _Tp + real() const { return _M_real; } - _Tp imag() const - { return _M_imag; } + constexpr _Tp + imag() const { return _M_imag; } #else /// Return real part of complex number. - _Tp& real() - { return _M_real; } + _Tp& + real() { return _M_real; } /// Return real part of complex number. - const _Tp& real() const - { return _M_real; } + const _Tp& + real() const { return _M_real; } /// Return imaginary part of complex number. - _Tp& imag() - { return _M_imag; } + _Tp& + imag() { return _M_imag; } /// Return imaginary part of complex number. - const _Tp& imag() const - { return _M_imag; } + const _Tp& + imag() const { return _M_imag; } #endif // _GLIBCXX_RESOLVE_LIB_DEFECTS // DR 387. std::complex over-encapsulated. - void real(_Tp __val) - { _M_real = __val; } + void + real(_Tp __val) { _M_real = __val; } - void imag(_Tp __val) - { _M_imag = __val; } + void + imag(_Tp __val) { _M_imag = __val; } /// Assign this complex number to scalar @a t. complex<_Tp>& operator=(const _Tp&); @@ -215,7 +215,7 @@ _GLIBCXX_BEGIN_NAMESPACE(std) template<typename _Up> complex<_Tp>& operator/=(const complex<_Up>&); - const complex& __rep() const + _GLIBCXX_USE_CONSTEXPR complex __rep() const { return *this; } private: @@ -1041,46 +1041,43 @@ _GLIBCXX_BEGIN_NAMESPACE(std) typedef float value_type; typedef __complex__ float _ComplexT; - complex(_ComplexT __z) : _M_value(__z) { } + _GLIBCXX_CONSTEXPR complex(_ComplexT __z) : _M_value(__z) { } - complex(float __r = 0.0f, float __i = 0.0f) - { - __real__ _M_value = __r; - __imag__ _M_value = __i; - } + _GLIBCXX_CONSTEXPR complex(float __r = 0.0f, float __i = 0.0f) + : _M_value(__r + __i * 1.0fi) { } - explicit complex(const complex<double>&); - explicit complex(const complex<long double>&); + explicit _GLIBCXX_CONSTEXPR complex(const complex<double>&); + explicit _GLIBCXX_CONSTEXPR complex(const complex<long double>&); #ifdef __GXX_EXPERIMENTAL_CXX0X__ // _GLIBCXX_RESOLVE_LIB_DEFECTS // DR 387. std::complex over-encapsulated. - float real() const - { return __real__ _M_value; } + constexpr float + real() const { return __real__ _M_value; } - float imag() const - { return __imag__ _M_value; } + constexpr float + imag() const { return __imag__ _M_value; } #else - float& real() - { return __real__ _M_value; } + float& + real() { return __real__ _M_value; } - const float& real() const - { return __real__ _M_value; } + const float& + real() const { return __real__ _M_value; } - float& imag() - { return __imag__ _M_value; } + float& + imag() { return __imag__ _M_value; } - const float& imag() const - { return __imag__ _M_value; } + const float& + imag() const { return __imag__ _M_value; } #endif // _GLIBCXX_RESOLVE_LIB_DEFECTS // DR 387. std::complex over-encapsulated. - void real(float __val) - { __real__ _M_value = __val; } + void + real(float __val) { __real__ _M_value = __val; } - void imag(float __val) - { __imag__ _M_value = __val; } + void + imag(float __val) { __imag__ _M_value = __val; } complex& operator=(float __f) @@ -1170,7 +1167,7 @@ _GLIBCXX_BEGIN_NAMESPACE(std) return *this; } - const _ComplexT& __rep() const { return _M_value; } + _GLIBCXX_USE_CONSTEXPR _ComplexT __rep() const { return _M_value; } private: _ComplexT _M_value; @@ -1184,48 +1181,45 @@ _GLIBCXX_BEGIN_NAMESPACE(std) typedef double value_type; typedef __complex__ double _ComplexT; - complex(_ComplexT __z) : _M_value(__z) { } + _GLIBCXX_CONSTEXPR complex(_ComplexT __z) : _M_value(__z) { } - complex(double __r = 0.0, double __i = 0.0) - { - __real__ _M_value = __r; - __imag__ _M_value = __i; - } + _GLIBCXX_CONSTEXPR complex(double __r = 0.0, double __i = 0.0) + : _M_value(__r + __i * 1.0i) { } - complex(const complex<float>& __z) + _GLIBCXX_CONSTEXPR complex(const complex<float>& __z) : _M_value(__z.__rep()) { } - explicit complex(const complex<long double>&); + explicit _GLIBCXX_CONSTEXPR complex(const complex<long double>&); #ifdef __GXX_EXPERIMENTAL_CXX0X__ // _GLIBCXX_RESOLVE_LIB_DEFECTS // DR 387. std::complex over-encapsulated. - double real() const - { return __real__ _M_value; } + constexpr double + real() const { return __real__ _M_value; } - double imag() const - { return __imag__ _M_value; } + constexpr double + imag() const { return __imag__ _M_value; } #else - double& real() - { return __real__ _M_value; } + double& + real() { return __real__ _M_value; } - const double& real() const - { return __real__ _M_value; } + const double& + real() const { return __real__ _M_value; } - double& imag() - { return __imag__ _M_value; } + double& + imag() { return __imag__ _M_value; } - const double& imag() const - { return __imag__ _M_value; } + const double& + imag() const { return __imag__ _M_value; } #endif // _GLIBCXX_RESOLVE_LIB_DEFECTS // DR 387. std::complex over-encapsulated. - void real(double __val) - { __real__ _M_value = __val; } + void + real(double __val) { __real__ _M_value = __val; } - void imag(double __val) - { __imag__ _M_value = __val; } + void + imag(double __val) { __imag__ _M_value = __val; } complex& operator=(double __d) @@ -1314,7 +1308,7 @@ _GLIBCXX_BEGIN_NAMESPACE(std) return *this; } - const _ComplexT& __rep() const { return _M_value; } + _GLIBCXX_USE_CONSTEXPR _ComplexT __rep() const { return _M_value; } private: _ComplexT _M_value; @@ -1328,49 +1322,47 @@ _GLIBCXX_BEGIN_NAMESPACE(std) typedef long double value_type; typedef __complex__ long double _ComplexT; - complex(_ComplexT __z) : _M_value(__z) { } + _GLIBCXX_CONSTEXPR complex(_ComplexT __z) : _M_value(__z) { } - complex(long double __r = 0.0L, long double __i = 0.0L) - { - __real__ _M_value = __r; - __imag__ _M_value = __i; - } + _GLIBCXX_CONSTEXPR complex(long double __r = 0.0L, + long double __i = 0.0L) + : _M_value(__r + __i * 1.0Li) { } - complex(const complex<float>& __z) + _GLIBCXX_CONSTEXPR complex(const complex<float>& __z) : _M_value(__z.__rep()) { } - complex(const complex<double>& __z) + _GLIBCXX_CONSTEXPR complex(const complex<double>& __z) : _M_value(__z.__rep()) { } #ifdef __GXX_EXPERIMENTAL_CXX0X__ // _GLIBCXX_RESOLVE_LIB_DEFECTS // DR 387. std::complex over-encapsulated. - long double real() const - { return __real__ _M_value; } + constexpr long double + real() const { return __real__ _M_value; } - long double imag() const - { return __imag__ _M_value; } + constexpr long double + imag() const { return __imag__ _M_value; } #else - long double& real() - { return __real__ _M_value; } + long double& + real() { return __real__ _M_value; } - const long double& real() const - { return __real__ _M_value; } + const long double& + real() const { return __real__ _M_value; } - long double& imag() - { return __imag__ _M_value; } + long double& + imag() { return __imag__ _M_value; } - const long double& imag() const - { return __imag__ _M_value; } + const long double& + imag() const { return __imag__ _M_value; } #endif // _GLIBCXX_RESOLVE_LIB_DEFECTS // DR 387. std::complex over-encapsulated. - void real(long double __val) - { __real__ _M_value = __val; } + void + real(long double __val) { __real__ _M_value = __val; } - void imag(long double __val) - { __imag__ _M_value = __val; } + void + imag(long double __val) { __imag__ _M_value = __val; } complex& operator=(long double __r) @@ -1459,7 +1451,7 @@ _GLIBCXX_BEGIN_NAMESPACE(std) return *this; } - const _ComplexT& __rep() const { return _M_value; } + _GLIBCXX_USE_CONSTEXPR _ComplexT __rep() const { return _M_value; } private: _ComplexT _M_value; @@ -1467,15 +1459,15 @@ _GLIBCXX_BEGIN_NAMESPACE(std) // These bits have to be at the end of this file, so that the // specializations have all been defined. - inline + inline _GLIBCXX_CONSTEXPR complex<float>::complex(const complex<double>& __z) : _M_value(__z.__rep()) { } - inline + inline _GLIBCXX_CONSTEXPR complex<float>::complex(const complex<long double>& __z) : _M_value(__z.__rep()) { } - inline + inline _GLIBCXX_CONSTEXPR complex<double>::complex(const complex<long double>& __z) : _M_value(__z.__rep()) { } diff --git a/libstdc++-v3/include/std/future b/libstdc++-v3/include/std/future index 2933c8be63f..aff0a33db30 100644 --- a/libstdc++-v3/include/std/future +++ b/libstdc++-v3/include/std/future @@ -64,19 +64,23 @@ namespace std no_state }; + /// Specialization. template<> struct is_error_code_enum<future_errc> : public true_type { }; /// Points to a statically-allocated object derived from error_category. - extern const error_category* const future_category; + const error_category& + future_category(); - // TODO: requires constexpr - inline error_code make_error_code(future_errc __errc) - { return error_code(static_cast<int>(__errc), *future_category); } + /// Overload for make_error_code. + inline error_code + make_error_code(future_errc __errc) + { return error_code(static_cast<int>(__errc), future_category()); } - // TODO: requires constexpr - inline error_condition make_error_condition(future_errc __errc) - { return error_condition(static_cast<int>(__errc), *future_category); } + /// Overload for make_error_condition. + inline error_condition + make_error_condition(future_errc __errc) + { return error_condition(static_cast<int>(__errc), future_category()); } /** * @brief Exception type thrown by futures. @@ -116,7 +120,21 @@ namespace std template<typename _Res> class promise; - enum class launch { any, async, sync }; + /// Launch code for futures + enum class launch + { + any, + async, + sync + }; + + /// Status code for futures + enum class future_status + { + ready, + timeout, + deferred + }; template<typename _Fn, typename... _Args> future<typename result_of<_Fn(_Args...)>::type> @@ -1242,6 +1260,7 @@ namespace std } }; + /// swap template<typename _Res, typename... _ArgTypes> inline void swap(packaged_task<_Res(_ArgTypes...)>& __x, @@ -1307,6 +1326,7 @@ namespace std thread _M_thread; }; + /// async template<typename _Fn, typename... _Args> future<typename result_of<_Fn(_Args...)>::type> async(launch __policy, _Fn&& __fn, _Args&&... __args) @@ -1328,6 +1348,7 @@ namespace std return future<result_type>(__state); } + /// async, potential overload template<typename _Fn, typename... _Args> inline typename enable_if<!is_same<typename decay<_Fn>::type, launch>::value, diff --git a/libstdc++-v3/include/std/limits b/libstdc++-v3/include/std/limits index 65b623e853d..ce557d6a76c 100644 --- a/libstdc++-v3/include/std/limits +++ b/libstdc++-v3/include/std/limits @@ -1,4 +1,4 @@ -// The template and inlines for the numeric_limits classes. -*- C++ -*- +// The template and inlines for the numeric_limits classes. -*- C++ -*- // Copyright (C) 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, // 2008, 2009, 2010 Free Software Foundation, Inc. @@ -47,7 +47,7 @@ // of fundamental arithmetic data types (integers and floating points). // From Standard C++ point of view, there are 14 such types: // * integers -// bool (1) +// bool (1) // char, signed char, unsigned char, wchar_t (4) // short, unsigned short (2) // int, unsigned (2) @@ -190,83 +190,101 @@ _GLIBCXX_BEGIN_NAMESPACE(std) struct __numeric_limits_base { /** This will be true for all fundamental types (which have - specializations), and false for everything else. */ - static const bool is_specialized = false; + specializations), and false for everything else. */ + static _GLIBCXX_USE_CONSTEXPR bool is_specialized = false; /** The number of @c radix digits that be represented without change: for - integer types, the number of non-sign bits in the mantissa; for - floating types, the number of @c radix digits in the mantissa. */ - static const int digits = 0; + integer types, the number of non-sign bits in the mantissa; for + floating types, the number of @c radix digits in the mantissa. */ + static _GLIBCXX_USE_CONSTEXPR int digits = 0; + /** The number of base 10 digits that can be represented without change. */ - static const int digits10 = 0; + static _GLIBCXX_USE_CONSTEXPR int digits10 = 0; + #ifdef __GXX_EXPERIMENTAL_CXX0X__ /** The number of base 10 digits required to ensure that values which differ are always differentiated. */ - static const int max_digits10 = 0; + static constexpr int max_digits10 = 0; #endif + /** True if the type is signed. */ - static const bool is_signed = false; + static _GLIBCXX_USE_CONSTEXPR bool is_signed = false; + /** True if the type is integer. * Is this supposed to be <em>if the type is integral?</em> */ - static const bool is_integer = false; + static _GLIBCXX_USE_CONSTEXPR bool is_integer = false; + /** True if the type uses an exact representation. <em>All integer types are - exact, but not all exact types are integer. For example, rational and - fixed-exponent representations are exact but not integer.</em> - [18.2.1.2]/15 */ - static const bool is_exact = false; + exact, but not all exact types are integer. For example, rational and + fixed-exponent representations are exact but not integer.</em> + [18.2.1.2]/15 */ + static _GLIBCXX_USE_CONSTEXPR bool is_exact = false; + /** For integer types, specifies the base of the representation. For - floating types, specifies the base of the exponent representation. */ - static const int radix = 0; + floating types, specifies the base of the exponent representation. */ + static _GLIBCXX_USE_CONSTEXPR int radix = 0; /** The minimum negative integer such that @c radix raised to the power of - (one less than that integer) is a normalized floating point number. */ - static const int min_exponent = 0; + (one less than that integer) is a normalized floating point number. */ + static _GLIBCXX_USE_CONSTEXPR int min_exponent = 0; + /** The minimum negative integer such that 10 raised to that power is in - the range of normalized floating point numbers. */ - static const int min_exponent10 = 0; + the range of normalized floating point numbers. */ + static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = 0; + /** The maximum positive integer such that @c radix raised to the power of - (one less than that integer) is a representable finite floating point + (one less than that integer) is a representable finite floating point number. */ - static const int max_exponent = 0; + static _GLIBCXX_USE_CONSTEXPR int max_exponent = 0; + /** The maximum positive integer such that 10 raised to that power is in - the range of representable finite floating point numbers. */ - static const int max_exponent10 = 0; + the range of representable finite floating point numbers. */ + static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = 0; /** True if the type has a representation for positive infinity. */ - static const bool has_infinity = false; + static _GLIBCXX_USE_CONSTEXPR bool has_infinity = false; + /** True if the type has a representation for a quiet (non-signaling) - <em>Not a Number</em>. */ - static const bool has_quiet_NaN = false; + <em>Not a Number</em>. */ + static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = false; + /** True if the type has a representation for a signaling - <em>Not a Number</em>. */ - static const bool has_signaling_NaN = false; + <em>Not a Number</em>. */ + static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = false; + /** See std::float_denorm_style for more information. */ - static const float_denorm_style has_denorm = denorm_absent; + static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm = denorm_absent; + /** <em>True if loss of accuracy is detected as a denormalization loss, - rather than as an inexact result.</em> [18.2.1.2]/42 */ - static const bool has_denorm_loss = false; + rather than as an inexact result.</em> [18.2.1.2]/42 */ + static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss = false; /** True if-and-only-if the type adheres to the IEC 559 standard, also - known as IEEE 754. (Only makes sense for floating point types.) */ - static const bool is_iec559 = false; + known as IEEE 754. (Only makes sense for floating point types.) */ + static _GLIBCXX_USE_CONSTEXPR bool is_iec559 = false; + /** <em>True if the set of values representable by the type is - finite. All built-in types are bounded, this member would be - false for arbitrary precision types.</em> [18.2.1.2]/54 */ - static const bool is_bounded = false; + finite. All built-in types are bounded, this member would be + false for arbitrary precision types.</em> [18.2.1.2]/54 */ + static _GLIBCXX_USE_CONSTEXPR bool is_bounded = false; + /** True if the type is @e modulo, that is, if it is possible to add two - positive numbers and have a result that wraps around to a third number - that is less. Typically false for floating types, true for unsigned - integers, and true for signed integers. */ - static const bool is_modulo = false; + positive numbers and have a result that wraps around to a third number + that is less. Typically false for floating types, true for unsigned + integers, and true for signed integers. */ + static _GLIBCXX_USE_CONSTEXPR bool is_modulo = false; /** True if trapping is implemented for this type. */ - static const bool traps = false; + static _GLIBCXX_USE_CONSTEXPR bool traps = false; + /** True if tininess is detected before rounding. (see IEC 559) */ - static const bool tinyness_before = false; + static _GLIBCXX_USE_CONSTEXPR bool tinyness_before = false; + /** See std::float_round_style for more information. This is only - meaningful for floating types; integer types will all be + meaningful for floating types; integer types will all be round_toward_zero. */ - static const float_round_style round_style = round_toward_zero; + static _GLIBCXX_USE_CONSTEXPR float_round_style round_style = + round_toward_zero; }; /** @@ -284,33 +302,49 @@ _GLIBCXX_BEGIN_NAMESPACE(std) struct numeric_limits : public __numeric_limits_base { /** The minimum finite value, or for floating types with - denormalization, the minimum positive normalized value. */ - static _Tp min() throw() { return static_cast<_Tp>(0); } + denormalization, the minimum positive normalized value. */ + static _GLIBCXX_CONSTEXPR _Tp + min() throw() { return static_cast<_Tp>(0); } + /** The maximum finite value. */ - static _Tp max() throw() { return static_cast<_Tp>(0); } + static _GLIBCXX_CONSTEXPR _Tp + max() throw() { return static_cast<_Tp>(0); } + #ifdef __GXX_EXPERIMENTAL_CXX0X__ /** A finite value x such that there is no other finite value y * where y < x. */ - static _Tp lowest() throw() { return static_cast<_Tp>(0); } + static constexpr _Tp + lowest() throw() { return static_cast<_Tp>(0); } #endif + /** The @e machine @e epsilon: the difference between 1 and the least - value greater than 1 that is representable. */ - static _Tp epsilon() throw() { return static_cast<_Tp>(0); } + value greater than 1 that is representable. */ + static _GLIBCXX_CONSTEXPR _Tp + epsilon() throw() { return static_cast<_Tp>(0); } + /** The maximum rounding error measurement (see LIA-1). */ - static _Tp round_error() throw() { return static_cast<_Tp>(0); } + static _GLIBCXX_CONSTEXPR _Tp + round_error() throw() { return static_cast<_Tp>(0); } + /** The representation of positive infinity, if @c has_infinity. */ - static _Tp infinity() throw() { return static_cast<_Tp>(0); } + static _GLIBCXX_CONSTEXPR _Tp + infinity() throw() { return static_cast<_Tp>(0); } - /** The representation of a quiet <em>Not a Number</em>, + /** The representation of a quiet <em>Not a Number</em>, if @c has_quiet_NaN. */ - static _Tp quiet_NaN() throw() { return static_cast<_Tp>(0); } + static _GLIBCXX_CONSTEXPR _Tp + quiet_NaN() throw() { return static_cast<_Tp>(0); } + /** The representation of a signaling <em>Not a Number</em>, if - @c has_signaling_NaN. */ - static _Tp signaling_NaN() throw() { return static_cast<_Tp>(0); } + @c has_signaling_NaN. */ + static _GLIBCXX_CONSTEXPR _Tp + signaling_NaN() throw() { return static_cast<_Tp>(0); } + /** The minimum positive denormalized value. For types where - @c has_denorm is false, this is the minimum positive normalized + @c has_denorm is false, this is the minimum positive normalized value. */ - static _Tp denorm_min() throw() { return static_cast<_Tp>(0); } + static _GLIBCXX_CONSTEXPR _Tp + denorm_min() throw() { return static_cast<_Tp>(0); } }; #ifdef __GXX_EXPERIMENTAL_CXX0X__ @@ -334,292 +368,341 @@ _GLIBCXX_BEGIN_NAMESPACE(std) template<> struct numeric_limits<bool> { - static const bool is_specialized = true; + static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true; + + static _GLIBCXX_CONSTEXPR bool + min() throw() { return false; } + + static _GLIBCXX_CONSTEXPR bool + max() throw() { return true; } - static bool min() throw() - { return false; } - static bool max() throw() - { return true; } #ifdef __GXX_EXPERIMENTAL_CXX0X__ - static bool lowest() throw() - { return min(); } + static constexpr bool + lowest() throw() { return min(); } #endif - static const int digits = 1; - static const int digits10 = 0; + static _GLIBCXX_USE_CONSTEXPR int digits = 1; + static _GLIBCXX_USE_CONSTEXPR int digits10 = 0; #ifdef __GXX_EXPERIMENTAL_CXX0X__ - static const int max_digits10 = 0; + static constexpr int max_digits10 = 0; #endif - static const bool is_signed = false; - static const bool is_integer = true; - static const bool is_exact = true; - static const int radix = 2; - static bool epsilon() throw() - { return false; } - static bool round_error() throw() - { return false; } - - static const int min_exponent = 0; - static const int min_exponent10 = 0; - static const int max_exponent = 0; - static const int max_exponent10 = 0; - - static const bool has_infinity = false; - static const bool has_quiet_NaN = false; - static const bool has_signaling_NaN = false; - static const float_denorm_style has_denorm = denorm_absent; - static const bool has_denorm_loss = false; - - static bool infinity() throw() - { return false; } - static bool quiet_NaN() throw() - { return false; } - static bool signaling_NaN() throw() - { return false; } - static bool denorm_min() throw() - { return false; } - - static const bool is_iec559 = false; - static const bool is_bounded = true; - static const bool is_modulo = false; + static _GLIBCXX_USE_CONSTEXPR bool is_signed = false; + static _GLIBCXX_USE_CONSTEXPR bool is_integer = true; + static _GLIBCXX_USE_CONSTEXPR bool is_exact = true; + static _GLIBCXX_USE_CONSTEXPR int radix = 2; + + static _GLIBCXX_CONSTEXPR bool + epsilon() throw() { return false; } + + static _GLIBCXX_CONSTEXPR bool + round_error() throw() { return false; } + + static _GLIBCXX_USE_CONSTEXPR int min_exponent = 0; + static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = 0; + static _GLIBCXX_USE_CONSTEXPR int max_exponent = 0; + static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = 0; + + static _GLIBCXX_USE_CONSTEXPR bool has_infinity = false; + static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = false; + static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = false; + static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm + = denorm_absent; + static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss = false; + + static _GLIBCXX_CONSTEXPR bool + infinity() throw() { return false; } + + static _GLIBCXX_CONSTEXPR bool + quiet_NaN() throw() { return false; } + + static _GLIBCXX_CONSTEXPR bool + signaling_NaN() throw() { return false; } + + static _GLIBCXX_CONSTEXPR bool + denorm_min() throw() { return false; } + + static _GLIBCXX_USE_CONSTEXPR bool is_iec559 = false; + static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true; + static _GLIBCXX_USE_CONSTEXPR bool is_modulo = false; // It is not clear what it means for a boolean type to trap. // This is a DR on the LWG issue list. Here, I use integer // promotion semantics. - static const bool traps = __glibcxx_integral_traps; - static const bool tinyness_before = false; - static const float_round_style round_style = round_toward_zero; + static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_integral_traps; + static _GLIBCXX_USE_CONSTEXPR bool tinyness_before = false; + static _GLIBCXX_USE_CONSTEXPR float_round_style round_style + = round_toward_zero; }; /// numeric_limits<char> specialization. template<> struct numeric_limits<char> { - static const bool is_specialized = true; + static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true; + + static _GLIBCXX_CONSTEXPR char + min() throw() { return __glibcxx_min(char); } + + static _GLIBCXX_CONSTEXPR char + max() throw() { return __glibcxx_max(char); } - static char min() throw() - { return __glibcxx_min(char); } - static char max() throw() - { return __glibcxx_max(char); } #ifdef __GXX_EXPERIMENTAL_CXX0X__ - static char lowest() throw() - { return min(); } + static constexpr char + lowest() throw() { return min(); } #endif - static const int digits = __glibcxx_digits (char); - static const int digits10 = __glibcxx_digits10 (char); + static _GLIBCXX_USE_CONSTEXPR int digits = __glibcxx_digits (char); + static _GLIBCXX_USE_CONSTEXPR int digits10 = __glibcxx_digits10 (char); #ifdef __GXX_EXPERIMENTAL_CXX0X__ - static const int max_digits10 = 0; + static constexpr int max_digits10 = 0; #endif - static const bool is_signed = __glibcxx_signed (char); - static const bool is_integer = true; - static const bool is_exact = true; - static const int radix = 2; - static char epsilon() throw() - { return 0; } - static char round_error() throw() - { return 0; } - - static const int min_exponent = 0; - static const int min_exponent10 = 0; - static const int max_exponent = 0; - static const int max_exponent10 = 0; - - static const bool has_infinity = false; - static const bool has_quiet_NaN = false; - static const bool has_signaling_NaN = false; - static const float_denorm_style has_denorm = denorm_absent; - static const bool has_denorm_loss = false; - - static char infinity() throw() - { return char(); } - static char quiet_NaN() throw() - { return char(); } - static char signaling_NaN() throw() - { return char(); } - static char denorm_min() throw() - { return static_cast<char>(0); } - - static const bool is_iec559 = false; - static const bool is_bounded = true; - static const bool is_modulo = true; - - static const bool traps = __glibcxx_integral_traps; - static const bool tinyness_before = false; - static const float_round_style round_style = round_toward_zero; + static _GLIBCXX_USE_CONSTEXPR bool is_signed = __glibcxx_signed (char); + static _GLIBCXX_USE_CONSTEXPR bool is_integer = true; + static _GLIBCXX_USE_CONSTEXPR bool is_exact = true; + static _GLIBCXX_USE_CONSTEXPR int radix = 2; + + static _GLIBCXX_CONSTEXPR char + epsilon() throw() { return 0; } + + static _GLIBCXX_CONSTEXPR char + round_error() throw() { return 0; } + + static _GLIBCXX_USE_CONSTEXPR int min_exponent = 0; + static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = 0; + static _GLIBCXX_USE_CONSTEXPR int max_exponent = 0; + static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = 0; + + static _GLIBCXX_USE_CONSTEXPR bool has_infinity = false; + static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = false; + static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = false; + static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm + = denorm_absent; + static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss = false; + + static _GLIBCXX_CONSTEXPR + char infinity() throw() { return char(); } + + static _GLIBCXX_CONSTEXPR char + quiet_NaN() throw() { return char(); } + + static _GLIBCXX_CONSTEXPR char + signaling_NaN() throw() { return char(); } + + static _GLIBCXX_CONSTEXPR char + denorm_min() throw() { return static_cast<char>(0); } + + static _GLIBCXX_USE_CONSTEXPR bool is_iec559 = false; + static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true; + static _GLIBCXX_USE_CONSTEXPR bool is_modulo = true; + + static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_integral_traps; + static _GLIBCXX_USE_CONSTEXPR bool tinyness_before = false; + static _GLIBCXX_USE_CONSTEXPR float_round_style round_style + = round_toward_zero; }; /// numeric_limits<signed char> specialization. template<> struct numeric_limits<signed char> { - static const bool is_specialized = true; + static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true; + + static _GLIBCXX_CONSTEXPR signed char + min() throw() { return -__SCHAR_MAX__ - 1; } + + static _GLIBCXX_CONSTEXPR signed char + max() throw() { return __SCHAR_MAX__; } - static signed char min() throw() - { return -__SCHAR_MAX__ - 1; } - static signed char max() throw() - { return __SCHAR_MAX__; } #ifdef __GXX_EXPERIMENTAL_CXX0X__ - static signed char lowest() throw() - { return min(); } + static constexpr signed char + lowest() throw() { return min(); } #endif - static const int digits = __glibcxx_digits (signed char); - static const int digits10 = __glibcxx_digits10 (signed char); + static _GLIBCXX_USE_CONSTEXPR int digits = __glibcxx_digits (signed char); + static _GLIBCXX_USE_CONSTEXPR int digits10 + = __glibcxx_digits10 (signed char); #ifdef __GXX_EXPERIMENTAL_CXX0X__ - static const int max_digits10 = 0; + static constexpr int max_digits10 = 0; #endif - static const bool is_signed = true; - static const bool is_integer = true; - static const bool is_exact = true; - static const int radix = 2; - static signed char epsilon() throw() - { return 0; } - static signed char round_error() throw() - { return 0; } - - static const int min_exponent = 0; - static const int min_exponent10 = 0; - static const int max_exponent = 0; - static const int max_exponent10 = 0; - - static const bool has_infinity = false; - static const bool has_quiet_NaN = false; - static const bool has_signaling_NaN = false; - static const float_denorm_style has_denorm = denorm_absent; - static const bool has_denorm_loss = false; - - static signed char infinity() throw() - { return static_cast<signed char>(0); } - static signed char quiet_NaN() throw() - { return static_cast<signed char>(0); } - static signed char signaling_NaN() throw() - { return static_cast<signed char>(0); } - static signed char denorm_min() throw() - { return static_cast<signed char>(0); } - - static const bool is_iec559 = false; - static const bool is_bounded = true; - static const bool is_modulo = true; - - static const bool traps = __glibcxx_integral_traps; - static const bool tinyness_before = false; - static const float_round_style round_style = round_toward_zero; + static _GLIBCXX_USE_CONSTEXPR bool is_signed = true; + static _GLIBCXX_USE_CONSTEXPR bool is_integer = true; + static _GLIBCXX_USE_CONSTEXPR bool is_exact = true; + static _GLIBCXX_USE_CONSTEXPR int radix = 2; + + static _GLIBCXX_CONSTEXPR signed char + epsilon() throw() { return 0; } + + static _GLIBCXX_CONSTEXPR signed char + round_error() throw() { return 0; } + + static _GLIBCXX_USE_CONSTEXPR int min_exponent = 0; + static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = 0; + static _GLIBCXX_USE_CONSTEXPR int max_exponent = 0; + static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = 0; + + static _GLIBCXX_USE_CONSTEXPR bool has_infinity = false; + static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = false; + static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = false; + static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm + = denorm_absent; + static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss = false; + + static _GLIBCXX_CONSTEXPR signed char + infinity() throw() { return static_cast<signed char>(0); } + + static _GLIBCXX_CONSTEXPR signed char + quiet_NaN() throw() { return static_cast<signed char>(0); } + + static _GLIBCXX_CONSTEXPR signed char + signaling_NaN() throw() { return static_cast<signed char>(0); } + + static _GLIBCXX_CONSTEXPR signed char + denorm_min() throw() { return static_cast<signed char>(0); } + + static _GLIBCXX_USE_CONSTEXPR bool is_iec559 = false; + static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true; + static _GLIBCXX_USE_CONSTEXPR bool is_modulo = true; + + static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_integral_traps; + static _GLIBCXX_USE_CONSTEXPR bool tinyness_before = false; + static _GLIBCXX_USE_CONSTEXPR float_round_style round_style + = round_toward_zero; }; /// numeric_limits<unsigned char> specialization. template<> struct numeric_limits<unsigned char> { - static const bool is_specialized = true; + static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true; + + static _GLIBCXX_CONSTEXPR unsigned char + min() throw() { return 0; } + + static _GLIBCXX_CONSTEXPR unsigned char + max() throw() { return __SCHAR_MAX__ * 2U + 1; } - static unsigned char min() throw() - { return 0; } - static unsigned char max() throw() - { return __SCHAR_MAX__ * 2U + 1; } #ifdef __GXX_EXPERIMENTAL_CXX0X__ - static unsigned char lowest() throw() - { return min(); } + static constexpr unsigned char + lowest() throw() { return min(); } #endif - static const int digits = __glibcxx_digits (unsigned char); - static const int digits10 = __glibcxx_digits10 (unsigned char); + static _GLIBCXX_USE_CONSTEXPR int digits + = __glibcxx_digits (unsigned char); + static _GLIBCXX_USE_CONSTEXPR int digits10 + = __glibcxx_digits10 (unsigned char); #ifdef __GXX_EXPERIMENTAL_CXX0X__ - static const int max_digits10 = 0; + static constexpr int max_digits10 = 0; #endif - static const bool is_signed = false; - static const bool is_integer = true; - static const bool is_exact = true; - static const int radix = 2; - static unsigned char epsilon() throw() - { return 0; } - static unsigned char round_error() throw() - { return 0; } - - static const int min_exponent = 0; - static const int min_exponent10 = 0; - static const int max_exponent = 0; - static const int max_exponent10 = 0; - - static const bool has_infinity = false; - static const bool has_quiet_NaN = false; - static const bool has_signaling_NaN = false; - static const float_denorm_style has_denorm = denorm_absent; - static const bool has_denorm_loss = false; - - static unsigned char infinity() throw() - { return static_cast<unsigned char>(0); } - static unsigned char quiet_NaN() throw() - { return static_cast<unsigned char>(0); } - static unsigned char signaling_NaN() throw() - { return static_cast<unsigned char>(0); } - static unsigned char denorm_min() throw() - { return static_cast<unsigned char>(0); } - - static const bool is_iec559 = false; - static const bool is_bounded = true; - static const bool is_modulo = true; - - static const bool traps = __glibcxx_integral_traps; - static const bool tinyness_before = false; - static const float_round_style round_style = round_toward_zero; + static _GLIBCXX_USE_CONSTEXPR bool is_signed = false; + static _GLIBCXX_USE_CONSTEXPR bool is_integer = true; + static _GLIBCXX_USE_CONSTEXPR bool is_exact = true; + static _GLIBCXX_USE_CONSTEXPR int radix = 2; + + static _GLIBCXX_CONSTEXPR unsigned char + epsilon() throw() { return 0; } + + static _GLIBCXX_CONSTEXPR unsigned char + round_error() throw() { return 0; } + + static _GLIBCXX_USE_CONSTEXPR int min_exponent = 0; + static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = 0; + static _GLIBCXX_USE_CONSTEXPR int max_exponent = 0; + static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = 0; + + static _GLIBCXX_USE_CONSTEXPR bool has_infinity = false; + static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = false; + static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = false; + static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm + = denorm_absent; + static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss = false; + + static _GLIBCXX_CONSTEXPR unsigned char + infinity() throw() { return static_cast<unsigned char>(0); } + + static _GLIBCXX_CONSTEXPR unsigned char + quiet_NaN() throw() { return static_cast<unsigned char>(0); } + + static _GLIBCXX_CONSTEXPR unsigned char + signaling_NaN() throw() { return static_cast<unsigned char>(0); } + + static _GLIBCXX_CONSTEXPR unsigned char + denorm_min() throw() { return static_cast<unsigned char>(0); } + + static _GLIBCXX_USE_CONSTEXPR bool is_iec559 = false; + static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true; + static _GLIBCXX_USE_CONSTEXPR bool is_modulo = true; + + static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_integral_traps; + static _GLIBCXX_USE_CONSTEXPR bool tinyness_before = false; + static _GLIBCXX_USE_CONSTEXPR float_round_style round_style + = round_toward_zero; }; /// numeric_limits<wchar_t> specialization. template<> struct numeric_limits<wchar_t> { - static const bool is_specialized = true; + static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true; + + static _GLIBCXX_CONSTEXPR wchar_t + min() throw() { return __glibcxx_min (wchar_t); } + + static _GLIBCXX_CONSTEXPR wchar_t + max() throw() { return __glibcxx_max (wchar_t); } - static wchar_t min() throw() - { return __glibcxx_min (wchar_t); } - static wchar_t max() throw() - { return __glibcxx_max (wchar_t); } #ifdef __GXX_EXPERIMENTAL_CXX0X__ - static wchar_t lowest() throw() - { return min(); } + static constexpr wchar_t + lowest() throw() { return min(); } #endif - static const int digits = __glibcxx_digits (wchar_t); - static const int digits10 = __glibcxx_digits10 (wchar_t); + static _GLIBCXX_USE_CONSTEXPR int digits = __glibcxx_digits (wchar_t); + static _GLIBCXX_USE_CONSTEXPR int digits10 + = __glibcxx_digits10 (wchar_t); #ifdef __GXX_EXPERIMENTAL_CXX0X__ - static const int max_digits10 = 0; + static constexpr int max_digits10 = 0; #endif - static const bool is_signed = __glibcxx_signed (wchar_t); - static const bool is_integer = true; - static const bool is_exact = true; - static const int radix = 2; - static wchar_t epsilon() throw() - { return 0; } - static wchar_t round_error() throw() - { return 0; } - - static const int min_exponent = 0; - static const int min_exponent10 = 0; - static const int max_exponent = 0; - static const int max_exponent10 = 0; - - static const bool has_infinity = false; - static const bool has_quiet_NaN = false; - static const bool has_signaling_NaN = false; - static const float_denorm_style has_denorm = denorm_absent; - static const bool has_denorm_loss = false; - - static wchar_t infinity() throw() - { return wchar_t(); } - static wchar_t quiet_NaN() throw() - { return wchar_t(); } - static wchar_t signaling_NaN() throw() - { return wchar_t(); } - static wchar_t denorm_min() throw() - { return wchar_t(); } - - static const bool is_iec559 = false; - static const bool is_bounded = true; - static const bool is_modulo = true; - - static const bool traps = __glibcxx_integral_traps; - static const bool tinyness_before = false; - static const float_round_style round_style = round_toward_zero; + static _GLIBCXX_USE_CONSTEXPR bool is_signed = __glibcxx_signed (wchar_t); + static _GLIBCXX_USE_CONSTEXPR bool is_integer = true; + static _GLIBCXX_USE_CONSTEXPR bool is_exact = true; + static _GLIBCXX_USE_CONSTEXPR int radix = 2; + + static _GLIBCXX_CONSTEXPR wchar_t + epsilon() throw() { return 0; } + + static _GLIBCXX_CONSTEXPR wchar_t + round_error() throw() { return 0; } + + static _GLIBCXX_USE_CONSTEXPR int min_exponent = 0; + static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = 0; + static _GLIBCXX_USE_CONSTEXPR int max_exponent = 0; + static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = 0; + + static _GLIBCXX_USE_CONSTEXPR bool has_infinity = false; + static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = false; + static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = false; + static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm + = denorm_absent; + static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss = false; + + static _GLIBCXX_CONSTEXPR wchar_t + infinity() throw() { return wchar_t(); } + + static _GLIBCXX_CONSTEXPR wchar_t + quiet_NaN() throw() { return wchar_t(); } + + static _GLIBCXX_CONSTEXPR wchar_t + signaling_NaN() throw() { return wchar_t(); } + + static _GLIBCXX_CONSTEXPR wchar_t + denorm_min() throw() { return wchar_t(); } + + static _GLIBCXX_USE_CONSTEXPR bool is_iec559 = false; + static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true; + static _GLIBCXX_USE_CONSTEXPR bool is_modulo = true; + + static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_integral_traps; + static _GLIBCXX_USE_CONSTEXPR bool tinyness_before = false; + static _GLIBCXX_USE_CONSTEXPR float_round_style round_style + = round_toward_zero; }; #ifdef __GXX_EXPERIMENTAL_CXX0X__ @@ -627,116 +710,139 @@ _GLIBCXX_BEGIN_NAMESPACE(std) template<> struct numeric_limits<char16_t> { - static const bool is_specialized = true; + static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true; + + static _GLIBCXX_CONSTEXPR char16_t + min() throw() { return __glibcxx_min (char16_t); } + + static _GLIBCXX_CONSTEXPR char16_t + max() throw() { return __glibcxx_max (char16_t); } - static char16_t min() throw() - { return __glibcxx_min (char16_t); } - static char16_t max() throw() - { return __glibcxx_max (char16_t); } #ifdef __GXX_EXPERIMENTAL_CXX0X__ - static char16_t lowest() throw() - { return min(); } + static constexpr char16_t + lowest() throw() { return min(); } #endif - static const int digits = __glibcxx_digits (char16_t); - static const int digits10 = __glibcxx_digits10 (char16_t); + static _GLIBCXX_USE_CONSTEXPR int digits + = __glibcxx_digits (char16_t); + static _GLIBCXX_USE_CONSTEXPR int digits10 + = __glibcxx_digits10 (char16_t); #ifdef __GXX_EXPERIMENTAL_CXX0X__ - static const int max_digits10 = 0; + static constexpr int max_digits10 = 0; #endif - static const bool is_signed = __glibcxx_signed (char16_t); - static const bool is_integer = true; - static const bool is_exact = true; - static const int radix = 2; - static char16_t epsilon() throw() - { return 0; } - static char16_t round_error() throw() - { return 0; } - - static const int min_exponent = 0; - static const int min_exponent10 = 0; - static const int max_exponent = 0; - static const int max_exponent10 = 0; - - static const bool has_infinity = false; - static const bool has_quiet_NaN = false; - static const bool has_signaling_NaN = false; - static const float_denorm_style has_denorm = denorm_absent; - static const bool has_denorm_loss = false; - - static char16_t infinity() throw() - { return char16_t(); } - static char16_t quiet_NaN() throw() - { return char16_t(); } - static char16_t signaling_NaN() throw() - { return char16_t(); } - static char16_t denorm_min() throw() - { return char16_t(); } - - static const bool is_iec559 = false; - static const bool is_bounded = true; - static const bool is_modulo = true; - - static const bool traps = __glibcxx_integral_traps; - static const bool tinyness_before = false; - static const float_round_style round_style = round_toward_zero; + static _GLIBCXX_USE_CONSTEXPR bool is_signed + = __glibcxx_signed (char16_t); + static _GLIBCXX_USE_CONSTEXPR bool is_integer = true; + static _GLIBCXX_USE_CONSTEXPR bool is_exact = true; + static _GLIBCXX_USE_CONSTEXPR int radix = 2; + + static _GLIBCXX_CONSTEXPR char16_t + epsilon() throw() { return 0; } + + static _GLIBCXX_CONSTEXPR char16_t + round_error() throw() { return 0; } + + static _GLIBCXX_USE_CONSTEXPR int min_exponent = 0; + static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = 0; + static _GLIBCXX_USE_CONSTEXPR int max_exponent = 0; + static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = 0; + + static _GLIBCXX_USE_CONSTEXPR bool has_infinity = false; + static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = false; + static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = false; + static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm + = denorm_absent; + static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss = false; + + static _GLIBCXX_CONSTEXPR char16_t + infinity() throw() { return char16_t(); } + + static _GLIBCXX_CONSTEXPR char16_t + quiet_NaN() throw() { return char16_t(); } + + static _GLIBCXX_CONSTEXPR char16_t + signaling_NaN() throw() { return char16_t(); } + + static _GLIBCXX_CONSTEXPR char16_t + denorm_min() throw() { return char16_t(); } + + static _GLIBCXX_USE_CONSTEXPR bool is_iec559 = false; + static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true; + static _GLIBCXX_USE_CONSTEXPR bool is_modulo = true; + + static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_integral_traps; + static _GLIBCXX_USE_CONSTEXPR bool tinyness_before = false; + static _GLIBCXX_USE_CONSTEXPR float_round_style round_style + = round_toward_zero; }; /// numeric_limits<char32_t> specialization. template<> struct numeric_limits<char32_t> { - static const bool is_specialized = true; + static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true; + + static _GLIBCXX_CONSTEXPR char32_t + min() throw() { return __glibcxx_min (char32_t); } + + static _GLIBCXX_CONSTEXPR char32_t + max() throw() { return __glibcxx_max (char32_t); } - static char32_t min() throw() - { return __glibcxx_min (char32_t); } - static char32_t max() throw() - { return __glibcxx_max (char32_t); } #ifdef __GXX_EXPERIMENTAL_CXX0X__ - static char32_t lowest() throw() - { return min(); } + static constexpr char32_t + lowest() throw() { return min(); } #endif - static const int digits = __glibcxx_digits (char32_t); - static const int digits10 = __glibcxx_digits10 (char32_t); + static _GLIBCXX_USE_CONSTEXPR int digits = __glibcxx_digits (char32_t); + static _GLIBCXX_USE_CONSTEXPR int digits10 + = __glibcxx_digits10 (char32_t); #ifdef __GXX_EXPERIMENTAL_CXX0X__ - static const int max_digits10 = 0; + static constexpr int max_digits10 = 0; #endif - static const bool is_signed = __glibcxx_signed (char32_t); - static const bool is_integer = true; - static const bool is_exact = true; - static const int radix = 2; - static char32_t epsilon() throw() - { return 0; } - static char32_t round_error() throw() - { return 0; } - - static const int min_exponent = 0; - static const int min_exponent10 = 0; - static const int max_exponent = 0; - static const int max_exponent10 = 0; - - static const bool has_infinity = false; - static const bool has_quiet_NaN = false; - static const bool has_signaling_NaN = false; - static const float_denorm_style has_denorm = denorm_absent; - static const bool has_denorm_loss = false; - - static char32_t infinity() throw() - { return char32_t(); } - static char32_t quiet_NaN() throw() - { return char32_t(); } - static char32_t signaling_NaN() throw() - { return char32_t(); } - static char32_t denorm_min() throw() - { return char32_t(); } - - static const bool is_iec559 = false; - static const bool is_bounded = true; - static const bool is_modulo = true; - - static const bool traps = __glibcxx_integral_traps; - static const bool tinyness_before = false; - static const float_round_style round_style = round_toward_zero; + static _GLIBCXX_USE_CONSTEXPR bool is_signed + = __glibcxx_signed (char32_t); + static _GLIBCXX_USE_CONSTEXPR bool is_integer = true; + static _GLIBCXX_USE_CONSTEXPR bool is_exact = true; + static _GLIBCXX_USE_CONSTEXPR int radix = 2; + + static _GLIBCXX_CONSTEXPR char32_t + epsilon() throw() { return 0; } + + static _GLIBCXX_CONSTEXPR char32_t + round_error() throw() { return 0; } + + static _GLIBCXX_USE_CONSTEXPR int min_exponent = 0; + static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = 0; + static _GLIBCXX_USE_CONSTEXPR int max_exponent = 0; + static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = 0; + + static _GLIBCXX_USE_CONSTEXPR bool has_infinity = false; + static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = false; + static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = false; + static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm + = denorm_absent; + static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss = false; + + static _GLIBCXX_CONSTEXPR char32_t + infinity() throw() { return char32_t(); } + + static _GLIBCXX_CONSTEXPR char32_t + quiet_NaN() throw() { return char32_t(); } + + static _GLIBCXX_CONSTEXPR char32_t + signaling_NaN() throw() { return char32_t(); } + + static _GLIBCXX_CONSTEXPR char32_t + denorm_min() throw() { return char32_t(); } + + static _GLIBCXX_USE_CONSTEXPR bool is_iec559 = false; + static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true; + static _GLIBCXX_USE_CONSTEXPR bool is_modulo = true; + + static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_integral_traps; + static _GLIBCXX_USE_CONSTEXPR bool tinyness_before = false; + static _GLIBCXX_USE_CONSTEXPR float_round_style round_style + = round_toward_zero; }; #endif @@ -744,525 +850,617 @@ _GLIBCXX_BEGIN_NAMESPACE(std) template<> struct numeric_limits<short> { - static const bool is_specialized = true; + static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true; + + static _GLIBCXX_CONSTEXPR short + min() throw() { return -__SHRT_MAX__ - 1; } + + static _GLIBCXX_CONSTEXPR short + max() throw() { return __SHRT_MAX__; } - static short min() throw() - { return -__SHRT_MAX__ - 1; } - static short max() throw() - { return __SHRT_MAX__; } #ifdef __GXX_EXPERIMENTAL_CXX0X__ - static short lowest() throw() - { return min(); } + static constexpr short + lowest() throw() { return min(); } #endif - static const int digits = __glibcxx_digits (short); - static const int digits10 = __glibcxx_digits10 (short); + static _GLIBCXX_USE_CONSTEXPR int digits = __glibcxx_digits (short); + static _GLIBCXX_USE_CONSTEXPR int digits10 = __glibcxx_digits10 (short); #ifdef __GXX_EXPERIMENTAL_CXX0X__ - static const int max_digits10 = 0; + static constexpr int max_digits10 = 0; #endif - static const bool is_signed = true; - static const bool is_integer = true; - static const bool is_exact = true; - static const int radix = 2; - static short epsilon() throw() - { return 0; } - static short round_error() throw() - { return 0; } - - static const int min_exponent = 0; - static const int min_exponent10 = 0; - static const int max_exponent = 0; - static const int max_exponent10 = 0; - - static const bool has_infinity = false; - static const bool has_quiet_NaN = false; - static const bool has_signaling_NaN = false; - static const float_denorm_style has_denorm = denorm_absent; - static const bool has_denorm_loss = false; - - static short infinity() throw() - { return short(); } - static short quiet_NaN() throw() - { return short(); } - static short signaling_NaN() throw() - { return short(); } - static short denorm_min() throw() - { return short(); } - - static const bool is_iec559 = false; - static const bool is_bounded = true; - static const bool is_modulo = true; - - static const bool traps = __glibcxx_integral_traps; - static const bool tinyness_before = false; - static const float_round_style round_style = round_toward_zero; + static _GLIBCXX_USE_CONSTEXPR bool is_signed = true; + static _GLIBCXX_USE_CONSTEXPR bool is_integer = true; + static _GLIBCXX_USE_CONSTEXPR bool is_exact = true; + static _GLIBCXX_USE_CONSTEXPR int radix = 2; + + static _GLIBCXX_CONSTEXPR short + epsilon() throw() { return 0; } + + static _GLIBCXX_CONSTEXPR short + round_error() throw() { return 0; } + + static _GLIBCXX_USE_CONSTEXPR int min_exponent = 0; + static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = 0; + static _GLIBCXX_USE_CONSTEXPR int max_exponent = 0; + static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = 0; + + static _GLIBCXX_USE_CONSTEXPR bool has_infinity = false; + static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = false; + static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = false; + static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm + = denorm_absent; + static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss = false; + + static _GLIBCXX_CONSTEXPR short + infinity() throw() { return short(); } + + static _GLIBCXX_CONSTEXPR short + quiet_NaN() throw() { return short(); } + + static _GLIBCXX_CONSTEXPR short + signaling_NaN() throw() { return short(); } + + static _GLIBCXX_CONSTEXPR short + denorm_min() throw() { return short(); } + + static _GLIBCXX_USE_CONSTEXPR bool is_iec559 = false; + static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true; + static _GLIBCXX_USE_CONSTEXPR bool is_modulo = true; + + static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_integral_traps; + static _GLIBCXX_USE_CONSTEXPR bool tinyness_before = false; + static _GLIBCXX_USE_CONSTEXPR float_round_style round_style + = round_toward_zero; }; /// numeric_limits<unsigned short> specialization. template<> struct numeric_limits<unsigned short> { - static const bool is_specialized = true; + static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true; + + static _GLIBCXX_CONSTEXPR unsigned short + min() throw() { return 0; } + + static _GLIBCXX_CONSTEXPR unsigned short + max() throw() { return __SHRT_MAX__ * 2U + 1; } - static unsigned short min() throw() - { return 0; } - static unsigned short max() throw() - { return __SHRT_MAX__ * 2U + 1; } #ifdef __GXX_EXPERIMENTAL_CXX0X__ - static unsigned short lowest() throw() - { return min(); } + static constexpr unsigned short + lowest() throw() { return min(); } #endif - static const int digits = __glibcxx_digits (unsigned short); - static const int digits10 = __glibcxx_digits10 (unsigned short); + static _GLIBCXX_USE_CONSTEXPR int digits + = __glibcxx_digits (unsigned short); + static _GLIBCXX_USE_CONSTEXPR int digits10 + = __glibcxx_digits10 (unsigned short); #ifdef __GXX_EXPERIMENTAL_CXX0X__ - static const int max_digits10 = 0; + static constexpr int max_digits10 = 0; #endif - static const bool is_signed = false; - static const bool is_integer = true; - static const bool is_exact = true; - static const int radix = 2; - static unsigned short epsilon() throw() - { return 0; } - static unsigned short round_error() throw() - { return 0; } - - static const int min_exponent = 0; - static const int min_exponent10 = 0; - static const int max_exponent = 0; - static const int max_exponent10 = 0; - - static const bool has_infinity = false; - static const bool has_quiet_NaN = false; - static const bool has_signaling_NaN = false; - static const float_denorm_style has_denorm = denorm_absent; - static const bool has_denorm_loss = false; - - static unsigned short infinity() throw() - { return static_cast<unsigned short>(0); } - static unsigned short quiet_NaN() throw() - { return static_cast<unsigned short>(0); } - static unsigned short signaling_NaN() throw() - { return static_cast<unsigned short>(0); } - static unsigned short denorm_min() throw() - { return static_cast<unsigned short>(0); } - - static const bool is_iec559 = false; - static const bool is_bounded = true; - static const bool is_modulo = true; - - static const bool traps = __glibcxx_integral_traps; - static const bool tinyness_before = false; - static const float_round_style round_style = round_toward_zero; + static _GLIBCXX_USE_CONSTEXPR bool is_signed = false; + static _GLIBCXX_USE_CONSTEXPR bool is_integer = true; + static _GLIBCXX_USE_CONSTEXPR bool is_exact = true; + static _GLIBCXX_USE_CONSTEXPR int radix = 2; + + static _GLIBCXX_CONSTEXPR unsigned short + epsilon() throw() { return 0; } + + static _GLIBCXX_CONSTEXPR unsigned short + round_error() throw() { return 0; } + + static _GLIBCXX_USE_CONSTEXPR int min_exponent = 0; + static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = 0; + static _GLIBCXX_USE_CONSTEXPR int max_exponent = 0; + static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = 0; + + static _GLIBCXX_USE_CONSTEXPR bool has_infinity = false; + static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = false; + static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = false; + static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm + = denorm_absent; + static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss = false; + + static _GLIBCXX_CONSTEXPR unsigned short + infinity() throw() { return static_cast<unsigned short>(0); } + + static _GLIBCXX_CONSTEXPR unsigned short + quiet_NaN() throw() { return static_cast<unsigned short>(0); } + + static _GLIBCXX_CONSTEXPR unsigned short + signaling_NaN() throw() { return static_cast<unsigned short>(0); } + + static _GLIBCXX_CONSTEXPR unsigned short + denorm_min() throw() { return static_cast<unsigned short>(0); } + + static _GLIBCXX_USE_CONSTEXPR bool is_iec559 = false; + static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true; + static _GLIBCXX_USE_CONSTEXPR bool is_modulo = true; + + static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_integral_traps; + static _GLIBCXX_USE_CONSTEXPR bool tinyness_before = false; + static _GLIBCXX_USE_CONSTEXPR float_round_style round_style + = round_toward_zero; }; /// numeric_limits<int> specialization. template<> struct numeric_limits<int> { - static const bool is_specialized = true; + static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true; + + static _GLIBCXX_CONSTEXPR int + min() throw() { return -__INT_MAX__ - 1; } + + static _GLIBCXX_CONSTEXPR int + max() throw() { return __INT_MAX__; } - static int min() throw() - { return -__INT_MAX__ - 1; } - static int max() throw() - { return __INT_MAX__; } #ifdef __GXX_EXPERIMENTAL_CXX0X__ - static int lowest() throw() - { return min(); } + static constexpr int + lowest() throw() { return min(); } #endif - static const int digits = __glibcxx_digits (int); - static const int digits10 = __glibcxx_digits10 (int); + static _GLIBCXX_USE_CONSTEXPR int digits = __glibcxx_digits (int); + static _GLIBCXX_USE_CONSTEXPR int digits10 = __glibcxx_digits10 (int); #ifdef __GXX_EXPERIMENTAL_CXX0X__ - static const int max_digits10 = 0; + static constexpr int max_digits10 = 0; #endif - static const bool is_signed = true; - static const bool is_integer = true; - static const bool is_exact = true; - static const int radix = 2; - static int epsilon() throw() - { return 0; } - static int round_error() throw() - { return 0; } - - static const int min_exponent = 0; - static const int min_exponent10 = 0; - static const int max_exponent = 0; - static const int max_exponent10 = 0; - - static const bool has_infinity = false; - static const bool has_quiet_NaN = false; - static const bool has_signaling_NaN = false; - static const float_denorm_style has_denorm = denorm_absent; - static const bool has_denorm_loss = false; - - static int infinity() throw() - { return static_cast<int>(0); } - static int quiet_NaN() throw() - { return static_cast<int>(0); } - static int signaling_NaN() throw() - { return static_cast<int>(0); } - static int denorm_min() throw() - { return static_cast<int>(0); } - - static const bool is_iec559 = false; - static const bool is_bounded = true; - static const bool is_modulo = true; - - static const bool traps = __glibcxx_integral_traps; - static const bool tinyness_before = false; - static const float_round_style round_style = round_toward_zero; + static _GLIBCXX_USE_CONSTEXPR bool is_signed = true; + static _GLIBCXX_USE_CONSTEXPR bool is_integer = true; + static _GLIBCXX_USE_CONSTEXPR bool is_exact = true; + static _GLIBCXX_USE_CONSTEXPR int radix = 2; + + static _GLIBCXX_CONSTEXPR int + epsilon() throw() { return 0; } + + static _GLIBCXX_CONSTEXPR int + round_error() throw() { return 0; } + + static _GLIBCXX_USE_CONSTEXPR int min_exponent = 0; + static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = 0; + static _GLIBCXX_USE_CONSTEXPR int max_exponent = 0; + static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = 0; + + static _GLIBCXX_USE_CONSTEXPR bool has_infinity = false; + static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = false; + static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = false; + static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm + = denorm_absent; + static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss = false; + + static _GLIBCXX_CONSTEXPR int + infinity() throw() { return static_cast<int>(0); } + + static _GLIBCXX_CONSTEXPR int + quiet_NaN() throw() { return static_cast<int>(0); } + + static _GLIBCXX_CONSTEXPR int + signaling_NaN() throw() { return static_cast<int>(0); } + + static _GLIBCXX_CONSTEXPR int + denorm_min() throw() { return static_cast<int>(0); } + + static _GLIBCXX_USE_CONSTEXPR bool is_iec559 = false; + static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true; + static _GLIBCXX_USE_CONSTEXPR bool is_modulo = true; + + static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_integral_traps; + static _GLIBCXX_USE_CONSTEXPR bool tinyness_before = false; + static _GLIBCXX_USE_CONSTEXPR float_round_style round_style + = round_toward_zero; }; /// numeric_limits<unsigned int> specialization. template<> struct numeric_limits<unsigned int> { - static const bool is_specialized = true; + static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true; + + static _GLIBCXX_CONSTEXPR unsigned int + min() throw() { return 0; } + + static _GLIBCXX_CONSTEXPR unsigned int + max() throw() { return __INT_MAX__ * 2U + 1; } - static unsigned int min() throw() - { return 0; } - static unsigned int max() throw() - { return __INT_MAX__ * 2U + 1; } #ifdef __GXX_EXPERIMENTAL_CXX0X__ - static unsigned int lowest() throw() - { return min(); } + static constexpr unsigned int + lowest() throw() { return min(); } #endif - static const int digits = __glibcxx_digits (unsigned int); - static const int digits10 = __glibcxx_digits10 (unsigned int); + static _GLIBCXX_USE_CONSTEXPR int digits + = __glibcxx_digits (unsigned int); + static _GLIBCXX_USE_CONSTEXPR int digits10 + = __glibcxx_digits10 (unsigned int); #ifdef __GXX_EXPERIMENTAL_CXX0X__ - static const int max_digits10 = 0; + static constexpr int max_digits10 = 0; #endif - static const bool is_signed = false; - static const bool is_integer = true; - static const bool is_exact = true; - static const int radix = 2; - static unsigned int epsilon() throw() - { return 0; } - static unsigned int round_error() throw() - { return 0; } - - static const int min_exponent = 0; - static const int min_exponent10 = 0; - static const int max_exponent = 0; - static const int max_exponent10 = 0; - - static const bool has_infinity = false; - static const bool has_quiet_NaN = false; - static const bool has_signaling_NaN = false; - static const float_denorm_style has_denorm = denorm_absent; - static const bool has_denorm_loss = false; - - static unsigned int infinity() throw() - { return static_cast<unsigned int>(0); } - static unsigned int quiet_NaN() throw() - { return static_cast<unsigned int>(0); } - static unsigned int signaling_NaN() throw() - { return static_cast<unsigned int>(0); } - static unsigned int denorm_min() throw() - { return static_cast<unsigned int>(0); } - - static const bool is_iec559 = false; - static const bool is_bounded = true; - static const bool is_modulo = true; - - static const bool traps = __glibcxx_integral_traps; - static const bool tinyness_before = false; - static const float_round_style round_style = round_toward_zero; + static _GLIBCXX_USE_CONSTEXPR bool is_signed = false; + static _GLIBCXX_USE_CONSTEXPR bool is_integer = true; + static _GLIBCXX_USE_CONSTEXPR bool is_exact = true; + static _GLIBCXX_USE_CONSTEXPR int radix = 2; + + static _GLIBCXX_CONSTEXPR unsigned int + epsilon() throw() { return 0; } + + static _GLIBCXX_CONSTEXPR unsigned int + round_error() throw() { return 0; } + + static _GLIBCXX_USE_CONSTEXPR int min_exponent = 0; + static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = 0; + static _GLIBCXX_USE_CONSTEXPR int max_exponent = 0; + static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = 0; + + static _GLIBCXX_USE_CONSTEXPR bool has_infinity = false; + static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = false; + static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = false; + static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm + = denorm_absent; + static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss = false; + + static _GLIBCXX_CONSTEXPR unsigned int + infinity() throw() { return static_cast<unsigned int>(0); } + + static _GLIBCXX_CONSTEXPR unsigned int + quiet_NaN() throw() { return static_cast<unsigned int>(0); } + + static _GLIBCXX_CONSTEXPR unsigned int + signaling_NaN() throw() { return static_cast<unsigned int>(0); } + + static _GLIBCXX_CONSTEXPR unsigned int + denorm_min() throw() { return static_cast<unsigned int>(0); } + + static _GLIBCXX_USE_CONSTEXPR bool is_iec559 = false; + static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true; + static _GLIBCXX_USE_CONSTEXPR bool is_modulo = true; + + static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_integral_traps; + static _GLIBCXX_USE_CONSTEXPR bool tinyness_before = false; + static _GLIBCXX_USE_CONSTEXPR float_round_style round_style + = round_toward_zero; }; /// numeric_limits<long> specialization. template<> struct numeric_limits<long> { - static const bool is_specialized = true; + static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true; + + static _GLIBCXX_CONSTEXPR long + min() throw() { return -__LONG_MAX__ - 1; } + + static _GLIBCXX_CONSTEXPR long + max() throw() { return __LONG_MAX__; } - static long min() throw() - { return -__LONG_MAX__ - 1; } - static long max() throw() - { return __LONG_MAX__; } #ifdef __GXX_EXPERIMENTAL_CXX0X__ - static long lowest() throw() - { return min(); } + static constexpr long + lowest() throw() { return min(); } #endif - static const int digits = __glibcxx_digits (long); - static const int digits10 = __glibcxx_digits10 (long); + static _GLIBCXX_USE_CONSTEXPR int digits = __glibcxx_digits (long); + static _GLIBCXX_USE_CONSTEXPR int digits10 = __glibcxx_digits10 (long); #ifdef __GXX_EXPERIMENTAL_CXX0X__ - static const int max_digits10 = 0; + static constexpr int max_digits10 = 0; #endif - static const bool is_signed = true; - static const bool is_integer = true; - static const bool is_exact = true; - static const int radix = 2; - static long epsilon() throw() - { return 0; } - static long round_error() throw() - { return 0; } - - static const int min_exponent = 0; - static const int min_exponent10 = 0; - static const int max_exponent = 0; - static const int max_exponent10 = 0; - - static const bool has_infinity = false; - static const bool has_quiet_NaN = false; - static const bool has_signaling_NaN = false; - static const float_denorm_style has_denorm = denorm_absent; - static const bool has_denorm_loss = false; - - static long infinity() throw() - { return static_cast<long>(0); } - static long quiet_NaN() throw() - { return static_cast<long>(0); } - static long signaling_NaN() throw() - { return static_cast<long>(0); } - static long denorm_min() throw() - { return static_cast<long>(0); } - - static const bool is_iec559 = false; - static const bool is_bounded = true; - static const bool is_modulo = true; - - static const bool traps = __glibcxx_integral_traps; - static const bool tinyness_before = false; - static const float_round_style round_style = round_toward_zero; + static _GLIBCXX_USE_CONSTEXPR bool is_signed = true; + static _GLIBCXX_USE_CONSTEXPR bool is_integer = true; + static _GLIBCXX_USE_CONSTEXPR bool is_exact = true; + static _GLIBCXX_USE_CONSTEXPR int radix = 2; + + static _GLIBCXX_CONSTEXPR long + epsilon() throw() { return 0; } + + static _GLIBCXX_CONSTEXPR long + round_error() throw() { return 0; } + + static _GLIBCXX_USE_CONSTEXPR int min_exponent = 0; + static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = 0; + static _GLIBCXX_USE_CONSTEXPR int max_exponent = 0; + static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = 0; + + static _GLIBCXX_USE_CONSTEXPR bool has_infinity = false; + static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = false; + static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = false; + static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm + = denorm_absent; + static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss = false; + + static _GLIBCXX_CONSTEXPR long + infinity() throw() { return static_cast<long>(0); } + + static _GLIBCXX_CONSTEXPR long + quiet_NaN() throw() { return static_cast<long>(0); } + + static _GLIBCXX_CONSTEXPR long + signaling_NaN() throw() { return static_cast<long>(0); } + + static _GLIBCXX_CONSTEXPR long + denorm_min() throw() { return static_cast<long>(0); } + + static _GLIBCXX_USE_CONSTEXPR bool is_iec559 = false; + static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true; + static _GLIBCXX_USE_CONSTEXPR bool is_modulo = true; + + static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_integral_traps; + static _GLIBCXX_USE_CONSTEXPR bool tinyness_before = false; + static _GLIBCXX_USE_CONSTEXPR float_round_style round_style + = round_toward_zero; }; /// numeric_limits<unsigned long> specialization. template<> struct numeric_limits<unsigned long> { - static const bool is_specialized = true; + static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true; + + static _GLIBCXX_CONSTEXPR unsigned long + min() throw() { return 0; } + + static _GLIBCXX_CONSTEXPR unsigned long + max() throw() { return __LONG_MAX__ * 2UL + 1; } - static unsigned long min() throw() - { return 0; } - static unsigned long max() throw() - { return __LONG_MAX__ * 2UL + 1; } #ifdef __GXX_EXPERIMENTAL_CXX0X__ - static unsigned long lowest() throw() - { return min(); } + static constexpr unsigned long + lowest() throw() { return min(); } #endif - static const int digits = __glibcxx_digits (unsigned long); - static const int digits10 = __glibcxx_digits10 (unsigned long); + static _GLIBCXX_USE_CONSTEXPR int digits + = __glibcxx_digits (unsigned long); + static _GLIBCXX_USE_CONSTEXPR int digits10 + = __glibcxx_digits10 (unsigned long); #ifdef __GXX_EXPERIMENTAL_CXX0X__ - static const int max_digits10 = 0; + static constexpr int max_digits10 = 0; #endif - static const bool is_signed = false; - static const bool is_integer = true; - static const bool is_exact = true; - static const int radix = 2; - static unsigned long epsilon() throw() - { return 0; } - static unsigned long round_error() throw() - { return 0; } - - static const int min_exponent = 0; - static const int min_exponent10 = 0; - static const int max_exponent = 0; - static const int max_exponent10 = 0; - - static const bool has_infinity = false; - static const bool has_quiet_NaN = false; - static const bool has_signaling_NaN = false; - static const float_denorm_style has_denorm = denorm_absent; - static const bool has_denorm_loss = false; - - static unsigned long infinity() throw() - { return static_cast<unsigned long>(0); } - static unsigned long quiet_NaN() throw() - { return static_cast<unsigned long>(0); } - static unsigned long signaling_NaN() throw() - { return static_cast<unsigned long>(0); } - static unsigned long denorm_min() throw() - { return static_cast<unsigned long>(0); } - - static const bool is_iec559 = false; - static const bool is_bounded = true; - static const bool is_modulo = true; - - static const bool traps = __glibcxx_integral_traps; - static const bool tinyness_before = false; - static const float_round_style round_style = round_toward_zero; + static _GLIBCXX_USE_CONSTEXPR bool is_signed = false; + static _GLIBCXX_USE_CONSTEXPR bool is_integer = true; + static _GLIBCXX_USE_CONSTEXPR bool is_exact = true; + static _GLIBCXX_USE_CONSTEXPR int radix = 2; + + static _GLIBCXX_CONSTEXPR unsigned long + epsilon() throw() { return 0; } + + static _GLIBCXX_CONSTEXPR unsigned long + round_error() throw() { return 0; } + + static _GLIBCXX_USE_CONSTEXPR int min_exponent = 0; + static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = 0; + static _GLIBCXX_USE_CONSTEXPR int max_exponent = 0; + static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = 0; + + static _GLIBCXX_USE_CONSTEXPR bool has_infinity = false; + static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = false; + static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = false; + static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm + = denorm_absent; + static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss = false; + + static _GLIBCXX_CONSTEXPR unsigned long + infinity() throw() { return static_cast<unsigned long>(0); } + + static _GLIBCXX_CONSTEXPR unsigned long + quiet_NaN() throw() { return static_cast<unsigned long>(0); } + + static _GLIBCXX_CONSTEXPR unsigned long + signaling_NaN() throw() { return static_cast<unsigned long>(0); } + + static _GLIBCXX_CONSTEXPR unsigned long + denorm_min() throw() { return static_cast<unsigned long>(0); } + + static _GLIBCXX_USE_CONSTEXPR bool is_iec559 = false; + static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true; + static _GLIBCXX_USE_CONSTEXPR bool is_modulo = true; + + static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_integral_traps; + static _GLIBCXX_USE_CONSTEXPR bool tinyness_before = false; + static _GLIBCXX_USE_CONSTEXPR float_round_style round_style + = round_toward_zero; }; /// numeric_limits<long long> specialization. template<> struct numeric_limits<long long> { - static const bool is_specialized = true; + static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true; + + static _GLIBCXX_CONSTEXPR long long + min() throw() { return -__LONG_LONG_MAX__ - 1; } + + static _GLIBCXX_CONSTEXPR long long + max() throw() { return __LONG_LONG_MAX__; } - static long long min() throw() - { return -__LONG_LONG_MAX__ - 1; } - static long long max() throw() - { return __LONG_LONG_MAX__; } #ifdef __GXX_EXPERIMENTAL_CXX0X__ - static long long lowest() throw() - { return min(); } + static constexpr long long + lowest() throw() { return min(); } #endif - static const int digits = __glibcxx_digits (long long); - static const int digits10 = __glibcxx_digits10 (long long); + static _GLIBCXX_USE_CONSTEXPR int digits + = __glibcxx_digits (long long); + static _GLIBCXX_USE_CONSTEXPR int digits10 + = __glibcxx_digits10 (long long); #ifdef __GXX_EXPERIMENTAL_CXX0X__ - static const int max_digits10 = 0; + static constexpr int max_digits10 = 0; #endif - static const bool is_signed = true; - static const bool is_integer = true; - static const bool is_exact = true; - static const int radix = 2; - static long long epsilon() throw() - { return 0; } - static long long round_error() throw() - { return 0; } - - static const int min_exponent = 0; - static const int min_exponent10 = 0; - static const int max_exponent = 0; - static const int max_exponent10 = 0; - - static const bool has_infinity = false; - static const bool has_quiet_NaN = false; - static const bool has_signaling_NaN = false; - static const float_denorm_style has_denorm = denorm_absent; - static const bool has_denorm_loss = false; - - static long long infinity() throw() - { return static_cast<long long>(0); } - static long long quiet_NaN() throw() - { return static_cast<long long>(0); } - static long long signaling_NaN() throw() - { return static_cast<long long>(0); } - static long long denorm_min() throw() - { return static_cast<long long>(0); } - - static const bool is_iec559 = false; - static const bool is_bounded = true; - static const bool is_modulo = true; - - static const bool traps = __glibcxx_integral_traps; - static const bool tinyness_before = false; - static const float_round_style round_style = round_toward_zero; + static _GLIBCXX_USE_CONSTEXPR bool is_signed = true; + static _GLIBCXX_USE_CONSTEXPR bool is_integer = true; + static _GLIBCXX_USE_CONSTEXPR bool is_exact = true; + static _GLIBCXX_USE_CONSTEXPR int radix = 2; + + static _GLIBCXX_CONSTEXPR long long + epsilon() throw() { return 0; } + + static _GLIBCXX_CONSTEXPR long long + round_error() throw() { return 0; } + + static _GLIBCXX_USE_CONSTEXPR int min_exponent = 0; + static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = 0; + static _GLIBCXX_USE_CONSTEXPR int max_exponent = 0; + static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = 0; + + static _GLIBCXX_USE_CONSTEXPR bool has_infinity = false; + static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = false; + static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = false; + static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm + = denorm_absent; + static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss = false; + + static _GLIBCXX_CONSTEXPR long long + infinity() throw() { return static_cast<long long>(0); } + + static _GLIBCXX_CONSTEXPR long long + quiet_NaN() throw() { return static_cast<long long>(0); } + + static _GLIBCXX_CONSTEXPR long long + signaling_NaN() throw() { return static_cast<long long>(0); } + + static _GLIBCXX_CONSTEXPR long long + denorm_min() throw() { return static_cast<long long>(0); } + + static _GLIBCXX_USE_CONSTEXPR bool is_iec559 = false; + static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true; + static _GLIBCXX_USE_CONSTEXPR bool is_modulo = true; + + static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_integral_traps; + static _GLIBCXX_USE_CONSTEXPR bool tinyness_before = false; + static _GLIBCXX_USE_CONSTEXPR float_round_style round_style + = round_toward_zero; }; /// numeric_limits<unsigned long long> specialization. template<> struct numeric_limits<unsigned long long> { - static const bool is_specialized = true; + static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true; + + static _GLIBCXX_CONSTEXPR unsigned long long + min() throw() { return 0; } + + static _GLIBCXX_CONSTEXPR unsigned long long + max() throw() { return __LONG_LONG_MAX__ * 2ULL + 1; } - static unsigned long long min() throw() - { return 0; } - static unsigned long long max() throw() - { return __LONG_LONG_MAX__ * 2ULL + 1; } #ifdef __GXX_EXPERIMENTAL_CXX0X__ - static unsigned long long lowest() throw() - { return min(); } + static constexpr unsigned long long + lowest() throw() { return min(); } #endif - static const int digits = __glibcxx_digits (unsigned long long); - static const int digits10 = __glibcxx_digits10 (unsigned long long); + static _GLIBCXX_USE_CONSTEXPR int digits + = __glibcxx_digits (unsigned long long); + static _GLIBCXX_USE_CONSTEXPR int digits10 + = __glibcxx_digits10 (unsigned long long); #ifdef __GXX_EXPERIMENTAL_CXX0X__ - static const int max_digits10 = 0; + static constexpr int max_digits10 = 0; #endif - static const bool is_signed = false; - static const bool is_integer = true; - static const bool is_exact = true; - static const int radix = 2; - static unsigned long long epsilon() throw() - { return 0; } - static unsigned long long round_error() throw() - { return 0; } - - static const int min_exponent = 0; - static const int min_exponent10 = 0; - static const int max_exponent = 0; - static const int max_exponent10 = 0; - - static const bool has_infinity = false; - static const bool has_quiet_NaN = false; - static const bool has_signaling_NaN = false; - static const float_denorm_style has_denorm = denorm_absent; - static const bool has_denorm_loss = false; - - static unsigned long long infinity() throw() - { return static_cast<unsigned long long>(0); } - static unsigned long long quiet_NaN() throw() - { return static_cast<unsigned long long>(0); } - static unsigned long long signaling_NaN() throw() - { return static_cast<unsigned long long>(0); } - static unsigned long long denorm_min() throw() - { return static_cast<unsigned long long>(0); } - - static const bool is_iec559 = false; - static const bool is_bounded = true; - static const bool is_modulo = true; - - static const bool traps = __glibcxx_integral_traps; - static const bool tinyness_before = false; - static const float_round_style round_style = round_toward_zero; + static _GLIBCXX_USE_CONSTEXPR bool is_signed = false; + static _GLIBCXX_USE_CONSTEXPR bool is_integer = true; + static _GLIBCXX_USE_CONSTEXPR bool is_exact = true; + static _GLIBCXX_USE_CONSTEXPR int radix = 2; + + static _GLIBCXX_CONSTEXPR unsigned long long + epsilon() throw() { return 0; } + + static _GLIBCXX_CONSTEXPR unsigned long long + round_error() throw() { return 0; } + + static _GLIBCXX_USE_CONSTEXPR int min_exponent = 0; + static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = 0; + static _GLIBCXX_USE_CONSTEXPR int max_exponent = 0; + static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = 0; + + static _GLIBCXX_USE_CONSTEXPR bool has_infinity = false; + static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = false; + static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = false; + static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm + = denorm_absent; + static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss = false; + + static _GLIBCXX_CONSTEXPR unsigned long long + infinity() throw() { return static_cast<unsigned long long>(0); } + + static _GLIBCXX_CONSTEXPR unsigned long long + quiet_NaN() throw() { return static_cast<unsigned long long>(0); } + + static _GLIBCXX_CONSTEXPR unsigned long long + signaling_NaN() throw() { return static_cast<unsigned long long>(0); } + + static _GLIBCXX_CONSTEXPR unsigned long long + denorm_min() throw() { return static_cast<unsigned long long>(0); } + + static _GLIBCXX_USE_CONSTEXPR bool is_iec559 = false; + static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true; + static _GLIBCXX_USE_CONSTEXPR bool is_modulo = true; + + static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_integral_traps; + static _GLIBCXX_USE_CONSTEXPR bool tinyness_before = false; + static _GLIBCXX_USE_CONSTEXPR float_round_style round_style + = round_toward_zero; }; /// numeric_limits<float> specialization. template<> struct numeric_limits<float> { - static const bool is_specialized = true; + static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true; + + static _GLIBCXX_CONSTEXPR float + min() throw() { return __FLT_MIN__; } + + static _GLIBCXX_CONSTEXPR float + max() throw() { return __FLT_MAX__; } - static float min() throw() - { return __FLT_MIN__; } - static float max() throw() - { return __FLT_MAX__; } #ifdef __GXX_EXPERIMENTAL_CXX0X__ - static float lowest() throw() - { return -__FLT_MAX__; } + static constexpr float + lowest() throw() { return -__FLT_MAX__; } #endif - static const int digits = __FLT_MANT_DIG__; - static const int digits10 = __FLT_DIG__; + static _GLIBCXX_USE_CONSTEXPR int digits = __FLT_MANT_DIG__; + static _GLIBCXX_USE_CONSTEXPR int digits10 = __FLT_DIG__; #ifdef __GXX_EXPERIMENTAL_CXX0X__ - static const int max_digits10 + static constexpr int max_digits10 = __glibcxx_max_digits10 (__FLT_MANT_DIG__); #endif - static const bool is_signed = true; - static const bool is_integer = false; - static const bool is_exact = false; - static const int radix = __FLT_RADIX__; - static float epsilon() throw() - { return __FLT_EPSILON__; } - static float round_error() throw() - { return 0.5F; } - - static const int min_exponent = __FLT_MIN_EXP__; - static const int min_exponent10 = __FLT_MIN_10_EXP__; - static const int max_exponent = __FLT_MAX_EXP__; - static const int max_exponent10 = __FLT_MAX_10_EXP__; - - static const bool has_infinity = __FLT_HAS_INFINITY__; - static const bool has_quiet_NaN = __FLT_HAS_QUIET_NAN__; - static const bool has_signaling_NaN = has_quiet_NaN; - static const float_denorm_style has_denorm + static _GLIBCXX_USE_CONSTEXPR bool is_signed = true; + static _GLIBCXX_USE_CONSTEXPR bool is_integer = false; + static _GLIBCXX_USE_CONSTEXPR bool is_exact = false; + static _GLIBCXX_USE_CONSTEXPR int radix = __FLT_RADIX__; + + static _GLIBCXX_CONSTEXPR float + epsilon() throw() { return __FLT_EPSILON__; } + + static _GLIBCXX_CONSTEXPR float + round_error() throw() { return 0.5F; } + + static _GLIBCXX_USE_CONSTEXPR int min_exponent = __FLT_MIN_EXP__; + static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = __FLT_MIN_10_EXP__; + static _GLIBCXX_USE_CONSTEXPR int max_exponent = __FLT_MAX_EXP__; + static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = __FLT_MAX_10_EXP__; + + static _GLIBCXX_USE_CONSTEXPR bool has_infinity = __FLT_HAS_INFINITY__; + static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = __FLT_HAS_QUIET_NAN__; + static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = has_quiet_NaN; + static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm = bool(__FLT_HAS_DENORM__) ? denorm_present : denorm_absent; - static const bool has_denorm_loss = __glibcxx_float_has_denorm_loss; - - static float infinity() throw() - { return __builtin_huge_valf (); } - static float quiet_NaN() throw() - { return __builtin_nanf (""); } - static float signaling_NaN() throw() - { return __builtin_nansf (""); } - static float denorm_min() throw() - { return __FLT_DENORM_MIN__; } - - static const bool is_iec559 - = has_infinity && has_quiet_NaN && has_denorm == denorm_present; - static const bool is_bounded = true; - static const bool is_modulo = false; + static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss + = __glibcxx_float_has_denorm_loss; + + static _GLIBCXX_CONSTEXPR float + infinity() throw() { return __builtin_huge_valf (); } - static const bool traps = __glibcxx_float_traps; - static const bool tinyness_before = __glibcxx_float_tinyness_before; - static const float_round_style round_style = round_to_nearest; + static _GLIBCXX_CONSTEXPR float + quiet_NaN() throw() { return __builtin_nanf (""); } + + static _GLIBCXX_CONSTEXPR float + signaling_NaN() throw() { return __builtin_nansf (""); } + + static _GLIBCXX_CONSTEXPR float + denorm_min() throw() { return __FLT_DENORM_MIN__; } + + static _GLIBCXX_USE_CONSTEXPR bool is_iec559 + = has_infinity && has_quiet_NaN && has_denorm == denorm_present; + static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true; + static _GLIBCXX_USE_CONSTEXPR bool is_modulo = false; + + static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_float_traps; + static _GLIBCXX_USE_CONSTEXPR bool tinyness_before + = __glibcxx_float_tinyness_before; + static _GLIBCXX_USE_CONSTEXPR float_round_style round_style + = round_to_nearest; }; #undef __glibcxx_float_has_denorm_loss @@ -1273,61 +1471,71 @@ _GLIBCXX_BEGIN_NAMESPACE(std) template<> struct numeric_limits<double> { - static const bool is_specialized = true; + static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true; + + static _GLIBCXX_CONSTEXPR double + min() throw() { return __DBL_MIN__; } + + static _GLIBCXX_CONSTEXPR double + max() throw() { return __DBL_MAX__; } - static double min() throw() - { return __DBL_MIN__; } - static double max() throw() - { return __DBL_MAX__; } #ifdef __GXX_EXPERIMENTAL_CXX0X__ - static double lowest() throw() - { return -__DBL_MAX__; } + static constexpr double + lowest() throw() { return -__DBL_MAX__; } #endif - static const int digits = __DBL_MANT_DIG__; - static const int digits10 = __DBL_DIG__; + static _GLIBCXX_USE_CONSTEXPR int digits = __DBL_MANT_DIG__; + static _GLIBCXX_USE_CONSTEXPR int digits10 = __DBL_DIG__; #ifdef __GXX_EXPERIMENTAL_CXX0X__ - static const int max_digits10 + static constexpr int max_digits10 = __glibcxx_max_digits10 (__DBL_MANT_DIG__); #endif - static const bool is_signed = true; - static const bool is_integer = false; - static const bool is_exact = false; - static const int radix = __FLT_RADIX__; - static double epsilon() throw() - { return __DBL_EPSILON__; } - static double round_error() throw() - { return 0.5; } - - static const int min_exponent = __DBL_MIN_EXP__; - static const int min_exponent10 = __DBL_MIN_10_EXP__; - static const int max_exponent = __DBL_MAX_EXP__; - static const int max_exponent10 = __DBL_MAX_10_EXP__; - - static const bool has_infinity = __DBL_HAS_INFINITY__; - static const bool has_quiet_NaN = __DBL_HAS_QUIET_NAN__; - static const bool has_signaling_NaN = has_quiet_NaN; - static const float_denorm_style has_denorm + static _GLIBCXX_USE_CONSTEXPR bool is_signed = true; + static _GLIBCXX_USE_CONSTEXPR bool is_integer = false; + static _GLIBCXX_USE_CONSTEXPR bool is_exact = false; + static _GLIBCXX_USE_CONSTEXPR int radix = __FLT_RADIX__; + + static _GLIBCXX_CONSTEXPR double + epsilon() throw() { return __DBL_EPSILON__; } + + static _GLIBCXX_CONSTEXPR double + round_error() throw() { return 0.5; } + + static _GLIBCXX_USE_CONSTEXPR int min_exponent = __DBL_MIN_EXP__; + static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = __DBL_MIN_10_EXP__; + static _GLIBCXX_USE_CONSTEXPR int max_exponent = __DBL_MAX_EXP__; + static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = __DBL_MAX_10_EXP__; + + static _GLIBCXX_USE_CONSTEXPR bool has_infinity = __DBL_HAS_INFINITY__; + static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = __DBL_HAS_QUIET_NAN__; + static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = has_quiet_NaN; + static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm = bool(__DBL_HAS_DENORM__) ? denorm_present : denorm_absent; - static const bool has_denorm_loss = __glibcxx_double_has_denorm_loss; - - static double infinity() throw() - { return __builtin_huge_val(); } - static double quiet_NaN() throw() - { return __builtin_nan (""); } - static double signaling_NaN() throw() - { return __builtin_nans (""); } - static double denorm_min() throw() - { return __DBL_DENORM_MIN__; } - - static const bool is_iec559 - = has_infinity && has_quiet_NaN && has_denorm == denorm_present; - static const bool is_bounded = true; - static const bool is_modulo = false; + static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss + = __glibcxx_double_has_denorm_loss; + + static _GLIBCXX_CONSTEXPR double + infinity() throw() { return __builtin_huge_val(); } + + static _GLIBCXX_CONSTEXPR double + quiet_NaN() throw() { return __builtin_nan (""); } - static const bool traps = __glibcxx_double_traps; - static const bool tinyness_before = __glibcxx_double_tinyness_before; - static const float_round_style round_style = round_to_nearest; + static _GLIBCXX_CONSTEXPR double + signaling_NaN() throw() { return __builtin_nans (""); } + + static _GLIBCXX_CONSTEXPR double + denorm_min() throw() { return __DBL_DENORM_MIN__; } + + static _GLIBCXX_USE_CONSTEXPR bool is_iec559 + = has_infinity && has_quiet_NaN && has_denorm == denorm_present; + static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true; + static _GLIBCXX_USE_CONSTEXPR bool is_modulo = false; + + static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_double_traps; + static _GLIBCXX_USE_CONSTEXPR bool tinyness_before + = __glibcxx_double_tinyness_before; + static _GLIBCXX_USE_CONSTEXPR float_round_style round_style + = round_to_nearest; }; #undef __glibcxx_double_has_denorm_loss @@ -1338,62 +1546,71 @@ _GLIBCXX_BEGIN_NAMESPACE(std) template<> struct numeric_limits<long double> { - static const bool is_specialized = true; + static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true; + + static _GLIBCXX_CONSTEXPR long double + min() throw() { return __LDBL_MIN__; } + + static _GLIBCXX_CONSTEXPR long double + max() throw() { return __LDBL_MAX__; } - static long double min() throw() - { return __LDBL_MIN__; } - static long double max() throw() - { return __LDBL_MAX__; } #ifdef __GXX_EXPERIMENTAL_CXX0X__ - static long double lowest() throw() - { return -__LDBL_MAX__; } + static constexpr long double + lowest() throw() { return -__LDBL_MAX__; } #endif - static const int digits = __LDBL_MANT_DIG__; - static const int digits10 = __LDBL_DIG__; + static _GLIBCXX_USE_CONSTEXPR int digits = __LDBL_MANT_DIG__; + static _GLIBCXX_USE_CONSTEXPR int digits10 = __LDBL_DIG__; #ifdef __GXX_EXPERIMENTAL_CXX0X__ - static const int max_digits10 + static _GLIBCXX_USE_CONSTEXPR int max_digits10 = __glibcxx_max_digits10 (__LDBL_MANT_DIG__); #endif - static const bool is_signed = true; - static const bool is_integer = false; - static const bool is_exact = false; - static const int radix = __FLT_RADIX__; - static long double epsilon() throw() - { return __LDBL_EPSILON__; } - static long double round_error() throw() - { return 0.5L; } - - static const int min_exponent = __LDBL_MIN_EXP__; - static const int min_exponent10 = __LDBL_MIN_10_EXP__; - static const int max_exponent = __LDBL_MAX_EXP__; - static const int max_exponent10 = __LDBL_MAX_10_EXP__; - - static const bool has_infinity = __LDBL_HAS_INFINITY__; - static const bool has_quiet_NaN = __LDBL_HAS_QUIET_NAN__; - static const bool has_signaling_NaN = has_quiet_NaN; - static const float_denorm_style has_denorm + static _GLIBCXX_USE_CONSTEXPR bool is_signed = true; + static _GLIBCXX_USE_CONSTEXPR bool is_integer = false; + static _GLIBCXX_USE_CONSTEXPR bool is_exact = false; + static _GLIBCXX_USE_CONSTEXPR int radix = __FLT_RADIX__; + + static _GLIBCXX_CONSTEXPR long double + epsilon() throw() { return __LDBL_EPSILON__; } + + static _GLIBCXX_CONSTEXPR long double + round_error() throw() { return 0.5L; } + + static _GLIBCXX_USE_CONSTEXPR int min_exponent = __LDBL_MIN_EXP__; + static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = __LDBL_MIN_10_EXP__; + static _GLIBCXX_USE_CONSTEXPR int max_exponent = __LDBL_MAX_EXP__; + static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = __LDBL_MAX_10_EXP__; + + static _GLIBCXX_USE_CONSTEXPR bool has_infinity = __LDBL_HAS_INFINITY__; + static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = __LDBL_HAS_QUIET_NAN__; + static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = has_quiet_NaN; + static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm = bool(__LDBL_HAS_DENORM__) ? denorm_present : denorm_absent; - static const bool has_denorm_loss + static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss = __glibcxx_long_double_has_denorm_loss; - static long double infinity() throw() - { return __builtin_huge_vall (); } - static long double quiet_NaN() throw() - { return __builtin_nanl (""); } - static long double signaling_NaN() throw() - { return __builtin_nansl (""); } - static long double denorm_min() throw() - { return __LDBL_DENORM_MIN__; } + static _GLIBCXX_CONSTEXPR long double + infinity() throw() { return __builtin_huge_vall (); } - static const bool is_iec559 - = has_infinity && has_quiet_NaN && has_denorm == denorm_present; - static const bool is_bounded = true; - static const bool is_modulo = false; + static _GLIBCXX_CONSTEXPR long double + quiet_NaN() throw() { return __builtin_nanl (""); } - static const bool traps = __glibcxx_long_double_traps; - static const bool tinyness_before = __glibcxx_long_double_tinyness_before; - static const float_round_style round_style = round_to_nearest; + static _GLIBCXX_CONSTEXPR long double + signaling_NaN() throw() { return __builtin_nansl (""); } + + static _GLIBCXX_CONSTEXPR long double + denorm_min() throw() { return __LDBL_DENORM_MIN__; } + + static _GLIBCXX_USE_CONSTEXPR bool is_iec559 + = has_infinity && has_quiet_NaN && has_denorm == denorm_present; + static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true; + static _GLIBCXX_USE_CONSTEXPR bool is_modulo = false; + + static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_long_double_traps; + static _GLIBCXX_USE_CONSTEXPR bool tinyness_before = + __glibcxx_long_double_tinyness_before; + static _GLIBCXX_USE_CONSTEXPR float_round_style round_style = + round_to_nearest; }; #undef __glibcxx_long_double_has_denorm_loss diff --git a/libstdc++-v3/include/std/mutex b/libstdc++-v3/include/std/mutex index c11ddd44668..8a2780247dc 100644 --- a/libstdc++-v3/include/std/mutex +++ b/libstdc++-v3/include/std/mutex @@ -67,16 +67,15 @@ namespace std public: typedef __native_type* native_handle_type; +#ifdef __GTHREAD_MUTEX_INIT + constexpr mutex() : _M_mutex(__GTHREAD_MUTEX_INIT) { } +#else mutex() { // XXX EAGAIN, ENOMEM, EPERM, EBUSY(may), EINVAL(may) -#ifdef __GTHREAD_MUTEX_INIT - __native_type __tmp = __GTHREAD_MUTEX_INIT; - _M_mutex = __tmp; -#else __GTHREAD_MUTEX_INIT_FUNCTION(&_M_mutex); -#endif } +#endif mutex(const mutex&) = delete; mutex& operator=(const mutex&) = delete; @@ -381,9 +380,9 @@ namespace std /// and manage it. struct adopt_lock_t { }; - extern const defer_lock_t defer_lock; - extern const try_to_lock_t try_to_lock; - extern const adopt_lock_t adopt_lock; + constexpr defer_lock_t defer_lock { }; + constexpr try_to_lock_t try_to_lock { }; + constexpr adopt_lock_t adopt_lock { }; /// @brief Scoped lock idiom. // Acquire the mutex here with a constructor call, then release with @@ -679,11 +678,7 @@ namespace std __native_type _M_once; public: - once_flag() - { - __native_type __tmp = __GTHREAD_ONCE_INIT; - _M_once = __tmp; - } + constexpr once_flag() : _M_once(__GTHREAD_ONCE_INIT) { } once_flag(const once_flag&) = delete; once_flag& operator=(const once_flag&) = delete; diff --git a/libstdc++-v3/include/std/ratio b/libstdc++-v3/include/std/ratio index b999e31a56f..3688ea46d7c 100644 --- a/libstdc++-v3/include/std/ratio +++ b/libstdc++-v3/include/std/ratio @@ -155,20 +155,20 @@ namespace std "out of range"); // Note: sign(N) * abs(N) == N - static const intmax_t num = + static constexpr intmax_t num = _Num * __static_sign<_Den>::value / __static_gcd<_Num, _Den>::value; - static const intmax_t den = + static constexpr intmax_t den = __static_abs<_Den>::value / __static_gcd<_Num, _Den>::value; typedef ratio<num, den> type; }; template<intmax_t _Num, intmax_t _Den> - const intmax_t ratio<_Num, _Den>::num; + constexpr intmax_t ratio<_Num, _Den>::num; template<intmax_t _Num, intmax_t _Den> - const intmax_t ratio<_Num, _Den>::den; + constexpr intmax_t ratio<_Num, _Den>::den; /// ratio_add template<typename _R1, typename _R2> diff --git a/libstdc++-v3/include/std/tuple b/libstdc++-v3/include/std/tuple index 67a6eb79e94..d0260deef9a 100644 --- a/libstdc++-v3/include/std/tuple +++ b/libstdc++-v3/include/std/tuple @@ -225,7 +225,7 @@ namespace std typedef _Tuple_impl<0, _Elements...> _Inherited; public: - tuple() + _GLIBCXX_CONSTEXPR tuple() : _Inherited() { } explicit diff --git a/libstdc++-v3/include/tr1_impl/array b/libstdc++-v3/include/tr1_impl/array index db0364e5357..a4c20edf726 100644 --- a/libstdc++-v3/include/tr1_impl/array +++ b/libstdc++-v3/include/tr1_impl/array @@ -132,13 +132,13 @@ _GLIBCXX_BEGIN_NAMESPACE_TR1 #endif // Capacity. - size_type + _GLIBCXX_CONSTEXPR size_type size() const { return _Nm; } - size_type + _GLIBCXX_CONSTEXPR size_type max_size() const { return _Nm; } - bool + _GLIBCXX_CONSTEXPR bool empty() const { return size() == 0; } // Element access. diff --git a/libstdc++-v3/include/tr1_impl/type_traits b/libstdc++-v3/include/tr1_impl/type_traits index 47f5e8f7e60..2f6080a19bf 100644 --- a/libstdc++-v3/include/tr1_impl/type_traits +++ b/libstdc++-v3/include/tr1_impl/type_traits @@ -1,6 +1,6 @@ // TR1 type_traits -*- C++ -*- -// Copyright (C) 2007, 2008, 2009 Free Software Foundation, Inc. +// Copyright (C) 2007, 2008, 2009, 2010 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 @@ -66,9 +66,13 @@ _GLIBCXX_BEGIN_NAMESPACE_TR1 template<typename _Tp, _Tp __v> struct integral_constant { - static const _Tp value = __v; + static _GLIBCXX_USE_CONSTEXPR _Tp value = __v; typedef _Tp value_type; typedef integral_constant<_Tp, __v> type; + +#ifdef _GLIBCXX_INCLUDE_AS_CXX0X + constexpr operator value_type() { return value; } +#endif }; /// typedef for true_type @@ -78,7 +82,7 @@ _GLIBCXX_BEGIN_NAMESPACE_TR1 typedef integral_constant<bool, false> false_type; template<typename _Tp, _Tp __v> - const _Tp integral_constant<_Tp, __v>::value; + _GLIBCXX_USE_CONSTEXPR _Tp integral_constant<_Tp, __v>::value; /// remove_cv template<typename> diff --git a/libstdc++-v3/src/atomic.cc b/libstdc++-v3/src/atomic.cc index 906b0884e2c..08d4d03ac8c 100644 --- a/libstdc++-v3/src/atomic.cc +++ b/libstdc++-v3/src/atomic.cc @@ -72,47 +72,49 @@ namespace std #endif _M_i = false; } + + _GLIBCXX_BEGIN_EXTERN_C + + bool + atomic_flag_test_and_set_explicit(__atomic_flag_base* __a, + memory_order __m) _GLIBCXX_NOTHROW + { + atomic_flag* d = static_cast<atomic_flag*>(__a); + return d->test_and_set(__m); } - extern "C" + void + atomic_flag_clear_explicit(__atomic_flag_base* __a, + memory_order __m) _GLIBCXX_NOTHROW { - bool - atomic_flag_test_and_set_explicit(__atomic_flag_base* __a, - memory_order __m) throw() - { - atomic_flag* d = static_cast<volatile atomic_flag*>(__a); - return d->test_and_set(__m); - } + atomic_flag* d = static_cast<atomic_flag*>(__a); + return d->clear(__m); + } - void - atomic_flag_clear_explicit(__atomic_flag_base* __a, - memory_order __m) throw() - { - atomic_flag* d = static_cast<volatile atomic_flag*>(__a); - return d->clear(__m); - } + void + __atomic_flag_wait_explicit(__atomic_flag_base* __a, + memory_order __x) _GLIBCXX_NOTHROW + { + while (atomic_flag_test_and_set_explicit(__a, __x)) + { }; + } - void - __atomic_flag_wait_explicit(__atomic_flag_base* __a, - memory_order __x) throw() - { - while (atomic_flag_test_and_set_explicit(__a, __x)) - { }; - } + _GLIBCXX_CONST __atomic_flag_base* + __atomic_flag_for_address(const volatile void* __z) _GLIBCXX_NOTHROW + { + uintptr_t __u = reinterpret_cast<uintptr_t>(__z); + __u += (__u >> 2) + (__u << 4); + __u += (__u >> 7) + (__u << 5); + __u += (__u >> 17) + (__u << 13); + if (sizeof(uintptr_t) > 4) + __u += (__u >> 31); + __u &= ~((~uintptr_t(0)) << LOGSIZE); + return flag_table + __u; + } - __atomic_flag_base* - __atomic_flag_for_address(const void* __z) throw() - { - uintptr_t __u = reinterpret_cast<uintptr_t>(__z); - __u += (__u >> 2) + (__u << 4); - __u += (__u >> 7) + (__u << 5); - __u += (__u >> 17) + (__u << 13); - if (sizeof(uintptr_t) > 4) - __u += (__u >> 31); - __u &= ~((~uintptr_t(0)) << LOGSIZE); - return flag_table + __u; - } - } // extern "C" + _GLIBCXX_END_EXTERN_C + + } // namespace __atomic0 } // namespace std diff --git a/libstdc++-v3/src/future.cc b/libstdc++-v3/src/future.cc index d9289487bab..1c9151972af 100644 --- a/libstdc++-v3/src/future.cc +++ b/libstdc++-v3/src/future.cc @@ -66,7 +66,8 @@ namespace namespace std { - const error_category* const future_category = &__future_category_instance(); + const error_category& future_category() + { return __future_category_instance(); } future_error::~future_error() throw() { } diff --git a/libstdc++-v3/src/limits.cc b/libstdc++-v3/src/limits.cc index 9c953c96afd..ac46cf03a60 100644 --- a/libstdc++-v3/src/limits.cc +++ b/libstdc++-v3/src/limits.cc @@ -34,6 +34,8 @@ _GLIBCXX_BEGIN_NAMESPACE(std) +#define const _GLIBCXX_USE_CONSTEXPR + const bool __numeric_limits_base::is_specialized; const int __numeric_limits_base::digits; const int __numeric_limits_base::digits10; @@ -510,6 +512,8 @@ _GLIBCXX_BEGIN_NAMESPACE(std) const bool numeric_limits<char32_t>::tinyness_before; const float_round_style numeric_limits<char32_t>::round_style; +#undef const + _GLIBCXX_END_NAMESPACE // XXX GLIBCXX_ABI Deprecated diff --git a/libstdc++-v3/src/mutex.cc b/libstdc++-v3/src/mutex.cc index 74a82c8aa82..2e9124d3d5f 100644 --- a/libstdc++-v3/src/mutex.cc +++ b/libstdc++-v3/src/mutex.cc @@ -1,6 +1,6 @@ // mutex -*- C++ -*- -// Copyright (C) 2008, 2009 Free Software Foundation, Inc. +// Copyright (C) 2008, 2009, 2010 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 @@ -39,10 +39,6 @@ namespace namespace std { - const defer_lock_t defer_lock = defer_lock_t(); - const try_to_lock_t try_to_lock = try_to_lock_t(); - const adopt_lock_t adopt_lock = adopt_lock_t(); - #ifdef _GLIBCXX_HAVE_TLS __thread void* __once_callable; __thread void (*__once_call)(); @@ -94,4 +90,28 @@ namespace std } } +// XXX GLIBCXX_ABI Deprecated +// gcc-4.6.0 +// <mutex> export changes +#if defined(_GLIBCXX_SYMVER_GNU) && defined(PIC) \ + && defined(_GLIBCXX_HAVE_AS_SYMVER_DIRECTIVE) \ + && defined(_GLIBCXX_HAVE_SYMVER_SYMBOL_RENAMING_RUNTIME_SUPPORT) + +namespace __gnu_cxx +{ + std::defer_lock_t defer_lock; + std::try_to_lock_t try_to_lock; + std::adopt_lock_t adopt_lock; +} + +#define _GLIBCXX_ASM_SYMVER(cur, old, version) \ + asm (".symver " #cur "," #old "@@" #version); + +_GLIBCXX_ASM_SYMVER(_ZN9__gnu_cxx10adopt_lockE, _ZSt10adopt_lock, GLIBCXX_3.4.11) +_GLIBCXX_ASM_SYMVER(_ZN9__gnu_cxx10defer_lockE, _ZSt10defer_lock, GLIBCXX_3.4.11) +_GLIBCXX_ASM_SYMVER(_ZN9__gnu_cxx11try_to_lockE, _ZSt11try_to_lock, GLIBCXX_3.4.11) + + +#endif + #endif // _GLIBCXX_HAS_GTHREADS && _GLIBCXX_USE_C99_STDINT_TR1 diff --git a/libstdc++-v3/testsuite/17_intro/headers/c++200x/stdc++.cc b/libstdc++-v3/testsuite/17_intro/headers/c++200x/stdc++.cc index f3e19f5003b..357373a0a82 100644 --- a/libstdc++-v3/testsuite/17_intro/headers/c++200x/stdc++.cc +++ b/libstdc++-v3/testsuite/17_intro/headers/c++200x/stdc++.cc @@ -3,7 +3,7 @@ // { dg-options "-std=gnu++0x" } // { dg-do compile } -// Copyright (C) 2007, 2008, 2009 Free Software Foundation, Inc. +// Copyright (C) 2007, 2008, 2009, 2010 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 @@ -44,7 +44,6 @@ #include <math.h> #include <setjmp.h> #include <signal.h> -#include <stdatomic.h> #include <stdarg.h> #ifdef _GLIBCXX_HAVE_STDBOOL_H #include <stdbool.h> diff --git a/libstdc++-v3/testsuite/29_atomics/atomic_flag/test_and_set/implicit.c b/libstdc++-v3/testsuite/18_support/numeric_limits/cons/default.cc index 1ab92948416..6b492569c3d 100644 --- a/libstdc++-v3/testsuite/29_atomics/atomic_flag/test_and_set/implicit.c +++ b/libstdc++-v3/testsuite/18_support/numeric_limits/cons/default.cc @@ -1,6 +1,4 @@ -// { dg-options "-x c -shared-libgcc -lstdc++" } - -// Copyright (C) 2008, 2009 Free Software Foundation, Inc. +// Copyright (C) 2008, 2009, 2010 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 @@ -17,14 +15,12 @@ // with this library; see the file COPYING3. If not see // <http://www.gnu.org/licenses/>. -#include <stdatomic.h> +#include <limits> +#include <testsuite_common_types.h> int main() { - atomic_flag af = ATOMIC_FLAG_INIT; - - if (!atomic_flag_test_and_set(&af)) - atomic_flag_clear(&af); - + __gnu_test::default_constructible test; + __gnu_cxx::typelist::apply_generator(test, __gnu_test::limits_tl()); return 0; } diff --git a/libstdc++-v3/testsuite/29_atomics/atomic_flag/test_and_set/explicit.c b/libstdc++-v3/testsuite/18_support/numeric_limits/cons/default_c++0x.cc index 025fdcb08e5..17ee4c79e87 100644 --- a/libstdc++-v3/testsuite/29_atomics/atomic_flag/test_and_set/explicit.c +++ b/libstdc++-v3/testsuite/18_support/numeric_limits/cons/default_c++0x.cc @@ -1,6 +1,6 @@ -// { dg-options "-x c -shared-libgcc -lstdc++" } +// { dg-options "-std=gnu++0x" } -// Copyright (C) 2008, 2009 Free Software Foundation, Inc. +// Copyright (C) 2008, 2009, 2010 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 @@ -17,14 +17,12 @@ // with this library; see the file COPYING3. If not see // <http://www.gnu.org/licenses/>. -#include <stdatomic.h> +#include <limits> +#include <testsuite_common_types.h> int main() { - atomic_flag af = ATOMIC_FLAG_INIT; - - if (!atomic_flag_test_and_set_explicit(&af, memory_order_acquire)) - atomic_flag_clear_explicit(&af, memory_order_release); - + __gnu_test::default_constructible test; + __gnu_cxx::typelist::apply_generator(test, __gnu_test::limits_tl()); return 0; } diff --git a/libstdc++-v3/testsuite/18_support/numeric_limits/requirements/constexpr_data.cc b/libstdc++-v3/testsuite/18_support/numeric_limits/requirements/constexpr_data.cc new file mode 100644 index 00000000000..d5f3b3f3926 --- /dev/null +++ b/libstdc++-v3/testsuite/18_support/numeric_limits/requirements/constexpr_data.cc @@ -0,0 +1,75 @@ +// { dg-do compile } +// { dg-options "-std=gnu++0x" } + +// Copyright (C) 2010 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. + +// You should have received a copy of the GNU General Public License along +// with this library; see the file COPYING3. If not see +// <http://www.gnu.org/licenses/>. + +#include <limits> +#include <testsuite_common_types.h> + +namespace __gnu_test +{ + struct constexpr_member_data + { + template<typename _Ttesttype> + void + operator()() + { + struct _Concept + { + void __constraint() + { + using std::float_denorm_style; + using std::float_round_style; + constexpr bool v1(_Ttesttype::is_specialized); + constexpr int v2(_Ttesttype::digits); + constexpr int v3(_Ttesttype::digits10); + constexpr int v4(_Ttesttype::max_digits10); + constexpr bool v5(_Ttesttype::is_signed); + constexpr bool v6(_Ttesttype::is_integer); + constexpr bool v7(_Ttesttype::is_exact); + constexpr int v8(_Ttesttype::radix); + constexpr int v9(_Ttesttype::min_exponent); + constexpr int v10(_Ttesttype::min_exponent10); + constexpr int v11(_Ttesttype::max_exponent); + constexpr int v12(_Ttesttype::max_exponent10); + constexpr bool v13(_Ttesttype::has_infinity); + constexpr bool v14(_Ttesttype::has_quiet_NaN); + constexpr bool v15(_Ttesttype::has_signaling_NaN); + constexpr float_denorm_style v16(_Ttesttype::has_denorm); + constexpr bool v17(_Ttesttype::has_denorm_loss); + constexpr bool v18(_Ttesttype::is_iec559); + constexpr bool v19(_Ttesttype::is_bounded); + constexpr bool v20(_Ttesttype::is_modulo); + constexpr bool v21(_Ttesttype::traps); + constexpr bool v22(_Ttesttype::tinyness_before); + constexpr float_round_style v23(_Ttesttype::round_style); + } + }; + + _Concept c; + c.__constraint(); + } + }; +} + +int main() +{ + __gnu_test::constexpr_member_data test; + __gnu_cxx::typelist::apply_generator(test, __gnu_test::limits_tl()); + return 0; +} diff --git a/libstdc++-v3/testsuite/18_support/numeric_limits/requirements/constexpr_functions.cc b/libstdc++-v3/testsuite/18_support/numeric_limits/requirements/constexpr_functions.cc new file mode 100644 index 00000000000..7c4852b2bbb --- /dev/null +++ b/libstdc++-v3/testsuite/18_support/numeric_limits/requirements/constexpr_functions.cc @@ -0,0 +1,61 @@ +// { dg-do compile } +// { dg-options "-std=gnu++0x" } + +// Copyright (C) 2010 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. + +// You should have received a copy of the GNU General Public License along +// with this library; see the file COPYING3. If not see +// <http://www.gnu.org/licenses/>. + +#include <limits> +#include <testsuite_common_types.h> + +namespace __gnu_test +{ + struct constexpr_member_functions + { + template<typename _Ttesttype, typename _Tbasetype> + void + operator()() + { + struct _Concept + { + void __constraint() + { + constexpr _Tbasetype v1(_Ttesttype::min()); + constexpr _Tbasetype v2(_Ttesttype::max()); + constexpr _Tbasetype v3(_Ttesttype::lowest()); + constexpr _Tbasetype v4(_Ttesttype::epsilon()); + constexpr _Tbasetype v5(_Ttesttype::round_error()); + constexpr _Tbasetype v6(_Ttesttype::infinity()); + constexpr _Tbasetype v7(_Ttesttype::quiet_NaN()); + constexpr _Tbasetype v8(_Ttesttype::signaling_NaN()); + constexpr _Tbasetype v9(_Ttesttype::denorm_min()); + } + }; + + _Concept c; + c.__constraint(); + } + }; +} + +int main() +{ + __gnu_test::constexpr_member_functions test; + __gnu_cxx::typelist::apply_generator(test, + __gnu_test::limits_tl(), + __gnu_test::integral_types::type()); + return 0; +} diff --git a/libstdc++-v3/testsuite/20_util/default_delete/cons/constexpr.cc b/libstdc++-v3/testsuite/20_util/default_delete/cons/constexpr.cc new file mode 100644 index 00000000000..897394a57b2 --- /dev/null +++ b/libstdc++-v3/testsuite/20_util/default_delete/cons/constexpr.cc @@ -0,0 +1,29 @@ +// { dg-do compile { xfail *-*-* } } +// { dg-options "-std=gnu++0x" } + +// Copyright (C) 2010 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. + +// You should have received a copy of the GNU General Public License along +// with this library; see the file COPYING3. If not see +// <http://www.gnu.org/licenses/>. + +#include <memory> +#include <testsuite_common_types.h> + +int main() +{ + __gnu_test::constexpr_default_constructible test; + test.operator()<std::default_delete<int>>(); // { dg-excess-errors "" } + return 0; +} diff --git a/libstdc++-v3/testsuite/20_util/duration/cons/constexpr.cc b/libstdc++-v3/testsuite/20_util/duration/cons/constexpr.cc new file mode 100644 index 00000000000..6f78dbb37e3 --- /dev/null +++ b/libstdc++-v3/testsuite/20_util/duration/cons/constexpr.cc @@ -0,0 +1,33 @@ +// { dg-do compile } +// { dg-options "-std=gnu++0x" } + +// Copyright (C) 2010 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. + +// You should have received a copy of the GNU General Public License along +// with this library; see the file COPYING3. If not see +// <http://www.gnu.org/licenses/>. + +#include <chrono> +#include <testsuite_common_types.h> + +int main() +{ + __gnu_test::constexpr_default_constructible test1; + test1.operator()<std::chrono::seconds>(); + + __gnu_test::constexpr_single_value_constructible test2; + test2.operator()<std::chrono::seconds, std::chrono::seconds::rep>(); + test2.operator()<std::chrono::minutes, std::chrono::hours>(); + return 0; +} diff --git a/libstdc++-v3/testsuite/20_util/duration/requirements/constexpr_functions.cc b/libstdc++-v3/testsuite/20_util/duration/requirements/constexpr_functions.cc new file mode 100644 index 00000000000..3986659f064 --- /dev/null +++ b/libstdc++-v3/testsuite/20_util/duration/requirements/constexpr_functions.cc @@ -0,0 +1,58 @@ +// { dg-do compile } +// { dg-options "-std=gnu++0x" } + +// Copyright (C) 2010 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. + +// You should have received a copy of the GNU General Public License along +// with this library; see the file COPYING3. If not see +// <http://www.gnu.org/licenses/>. + +#include <chrono> +#include <testsuite_common_types.h> + +namespace __gnu_test +{ + struct constexpr_member_functions + { + template<typename _Ttesttype> + void + operator()() + { + struct _Concept + { + void __constraint() + { + constexpr auto v1(_Ttesttype::min()); + constexpr auto v2(_Ttesttype::max()); + constexpr auto v3(_Ttesttype::zero()); + + constexpr _Ttesttype obj { }; + constexpr auto v4 = obj.count(); + constexpr auto v5 = -obj; + constexpr auto v6 = +obj; + } + }; + + _Concept c; + c.__constraint(); + } + }; +} + +int main() +{ + __gnu_test::constexpr_member_functions test; + test.operator()<std::chrono::nanoseconds>(); + return 0; +} diff --git a/libstdc++-v3/testsuite/20_util/duration/requirements/typedefs_neg1.cc b/libstdc++-v3/testsuite/20_util/duration/requirements/typedefs_neg1.cc index 98a35f10539..7dab6f12977 100644 --- a/libstdc++-v3/testsuite/20_util/duration/requirements/typedefs_neg1.cc +++ b/libstdc++-v3/testsuite/20_util/duration/requirements/typedefs_neg1.cc @@ -3,7 +3,7 @@ // { dg-require-cstdint "" } // 2008-07-31 Chris Fairles <chris.fairles@gmail.com> -// Copyright (C) 2008, 2009 Free Software Foundation, Inc. +// Copyright (C) 2008, 2009, 2010 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 @@ -31,5 +31,5 @@ void test01() test_type d; } -// { dg-error "rep cannot be a duration" "" { target *-*-* } 203 } +// { dg-error "rep cannot be a duration" "" { target *-*-* } 210 } // { dg-error "instantiated from here" "" { target *-*-* } 31 } diff --git a/libstdc++-v3/testsuite/20_util/duration/requirements/typedefs_neg2.cc b/libstdc++-v3/testsuite/20_util/duration/requirements/typedefs_neg2.cc index b83bf494db5..640574991bf 100644 --- a/libstdc++-v3/testsuite/20_util/duration/requirements/typedefs_neg2.cc +++ b/libstdc++-v3/testsuite/20_util/duration/requirements/typedefs_neg2.cc @@ -32,6 +32,6 @@ void test01() test_type d; } -// { dg-error "must be a specialization of ratio" "" { target *-*-* } 204 } +// { dg-error "must be a specialization of ratio" "" { target *-*-* } 211 } // { dg-error "instantiated from here" "" { target *-*-* } 32 } // { dg-excess-errors "In instantiation of" } diff --git a/libstdc++-v3/testsuite/20_util/duration/requirements/typedefs_neg3.cc b/libstdc++-v3/testsuite/20_util/duration/requirements/typedefs_neg3.cc index 86f349319f0..d6163867fb5 100644 --- a/libstdc++-v3/testsuite/20_util/duration/requirements/typedefs_neg3.cc +++ b/libstdc++-v3/testsuite/20_util/duration/requirements/typedefs_neg3.cc @@ -33,5 +33,5 @@ void test01() test_type d; } -// { dg-error "period must be positive" "" { target *-*-* } 206 } +// { dg-error "period must be positive" "" { target *-*-* } 213 } // { dg-error "instantiated from here" "" { target *-*-* } 33 } diff --git a/libstdc++-v3/testsuite/20_util/duration_cast/constexpr.cc b/libstdc++-v3/testsuite/20_util/duration_cast/constexpr.cc new file mode 100644 index 00000000000..a68aed6d45d --- /dev/null +++ b/libstdc++-v3/testsuite/20_util/duration_cast/constexpr.cc @@ -0,0 +1,37 @@ +// { dg-do compile } +// { dg-options "-std=gnu++0x" } + +// Copyright (C) 2010 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. + +// You should have received a copy of the GNU General Public License along +// with this library; see the file COPYING3. If not see +// <http://www.gnu.org/licenses/>. + +#include <chrono> +#include <testsuite_common_types.h> + +int main() +{ + using namespace std::chrono; + + // non-constexpr + minutes mn1(6000); + hours hr1 = duration_cast<hours>(mn1); + + // constexpr + constexpr minutes mn2(6000); + constexpr hours hr2 = duration_cast<hours>(mn2); + + return 0; +} diff --git a/libstdc++-v3/testsuite/29_atomics/atomic_flag/clear/1.c b/libstdc++-v3/testsuite/20_util/enable_shared_from_this/cons/constexpr.cc index 3fd2f2c799d..0df6dcf3896 100644 --- a/libstdc++-v3/testsuite/29_atomics/atomic_flag/clear/1.c +++ b/libstdc++-v3/testsuite/20_util/enable_shared_from_this/cons/constexpr.cc @@ -1,6 +1,7 @@ -// { dg-options "-x c -shared-libgcc -lstdc++" } +// { dg-do compile { xfail *-*-* } } +// { dg-options "-std=gnu++0x" } -// Copyright (C) 2009 Free Software Foundation, Inc. +// Copyright (C) 2010 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 @@ -17,18 +18,18 @@ // with this library; see the file COPYING3. If not see // <http://www.gnu.org/licenses/>. -#include <cassert> -#include <stdatomic.h> +#include <memory> +#include <testsuite_common_types.h> -// libstdc++/40826 -// libstdc++/40654 -int main() +struct derived : public std::enable_shared_from_this<int> { - atomic_flag f = ATOMIC_FLAG_INIT; - - atomic_flag_clear(&f); // set to false - assert( false == atomic_flag_test_and_set(&f) ); // return previous false, set to true - assert( true == atomic_flag_test_and_set(&f) ); // return true + constexpr derived() { } +}; +int main() +{ + __gnu_test::constexpr_default_constructible test; + test.operator()<derived>(); // { dg-excess-errors "" } + derived d; return 0; } diff --git a/libstdc++-v3/testsuite/29_atomics/headers/stdatomic.h/functions.c b/libstdc++-v3/testsuite/20_util/pair/cons/constexpr.cc index d56937678e2..7bf6b71162d 100644 --- a/libstdc++-v3/testsuite/29_atomics/headers/stdatomic.h/functions.c +++ b/libstdc++-v3/testsuite/20_util/pair/cons/constexpr.cc @@ -1,7 +1,7 @@ -// { dg-options "-x c" } // { dg-do compile } +// { dg-options "-std=gnu++0x" } -// Copyright (C) 2008, 2009 Free Software Foundation, Inc. +// Copyright (C) 2010 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 @@ -18,19 +18,12 @@ // with this library; see the file COPYING3. If not see // <http://www.gnu.org/licenses/>. -#include <stdatomic.h> +#include <memory> +#include <testsuite_common_types.h> int main() { - atomic_flag f; - atomic_flag* p = &f; - memory_order m = memory_order_relaxed; - - // For position only. - atomic_flag_test_and_set(p); - atomic_flag_test_and_set_explicit(p, m); - atomic_flag_clear(p); - atomic_flag_clear_explicit(p, m); - + __gnu_test::constexpr_default_constructible test; + test.operator()<std::pair<int, int>>(); return 0; } diff --git a/libstdc++-v3/testsuite/20_util/ratio/requirements/constexpr_data.cc b/libstdc++-v3/testsuite/20_util/ratio/requirements/constexpr_data.cc new file mode 100644 index 00000000000..bc90adce0b0 --- /dev/null +++ b/libstdc++-v3/testsuite/20_util/ratio/requirements/constexpr_data.cc @@ -0,0 +1,52 @@ +// { dg-do compile } +// { dg-options "-std=gnu++0x" } + +// Copyright (C) 2010 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. + +// You should have received a copy of the GNU General Public License along +// with this library; see the file COPYING3. If not see +// <http://www.gnu.org/licenses/>. + +#include <ratio> +#include <testsuite_common_types.h> + +namespace __gnu_test +{ + struct constexpr_member_data + { + template<typename _Ttesttype> + void + operator()() + { + struct _Concept + { + void __constraint() + { + constexpr intmax_t v1(_Ttesttype::num); + constexpr intmax_t v2(_Ttesttype::den); + } + }; + + _Concept c; + c.__constraint(); + } + }; +} + +int main() +{ + __gnu_test::constexpr_member_data test; + test.operator()<std::ratio<600, 900>>(); + return 0; +} diff --git a/libstdc++-v3/testsuite/20_util/shared_ptr/cons/constexpr.cc b/libstdc++-v3/testsuite/20_util/shared_ptr/cons/constexpr.cc new file mode 100644 index 00000000000..d040ea49666 --- /dev/null +++ b/libstdc++-v3/testsuite/20_util/shared_ptr/cons/constexpr.cc @@ -0,0 +1,33 @@ +// { dg-do compile { xfail *-*-* } } +// { dg-options "-std=gnu++0x" } + +// Copyright (C) 2010 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. + +// You should have received a copy of the GNU General Public License along +// with this library; see the file COPYING3. If not see +// <http://www.gnu.org/licenses/>. + +#include <memory> +#include <testsuite_common_types.h> + +int main() +{ + __gnu_test::constexpr_default_constructible test1; + test1.operator()<std::shared_ptr<int>>(); // { dg-excess-errors "" } + + __gnu_test::constexpr_single_value_constructible test2; + test2.operator()<std::shared_ptr<int>, std::nullptr_t>(); // { dg-excess-errors "" } + + return 0; +} diff --git a/libstdc++-v3/testsuite/20_util/time_point/cons/constexpr.cc b/libstdc++-v3/testsuite/20_util/time_point/cons/constexpr.cc new file mode 100644 index 00000000000..d12d2f164c9 --- /dev/null +++ b/libstdc++-v3/testsuite/20_util/time_point/cons/constexpr.cc @@ -0,0 +1,37 @@ +// { dg-do compile } +// { dg-options "-std=gnu++0x" } + +// Copyright (C) 2010 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. + +// You should have received a copy of the GNU General Public License along +// with this library; see the file COPYING3. If not see +// <http://www.gnu.org/licenses/>. + +#include <chrono> +#include <testsuite_common_types.h> + +int main() +{ + using namespace std::chrono; + + __gnu_test::constexpr_default_constructible test1; + test1.operator()<time_point<system_clock>>(); + + __gnu_test::constexpr_single_value_constructible test2; + test2.operator()<time_point<system_clock>, seconds>(); + test2.operator()<time_point<system_clock, seconds>, + time_point<system_clock, minutes>>(); + + return 0; +} diff --git a/libstdc++-v3/testsuite/20_util/time_point/requirements/constexpr_functions.cc b/libstdc++-v3/testsuite/20_util/time_point/requirements/constexpr_functions.cc new file mode 100644 index 00000000000..feb77fb17fa --- /dev/null +++ b/libstdc++-v3/testsuite/20_util/time_point/requirements/constexpr_functions.cc @@ -0,0 +1,56 @@ +// { dg-do compile } +// { dg-options "-std=gnu++0x" } + +// Copyright (C) 2010 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. + +// You should have received a copy of the GNU General Public License along +// with this library; see the file COPYING3. If not see +// <http://www.gnu.org/licenses/>. + +#include <chrono> +#include <testsuite_common_types.h> + +namespace __gnu_test +{ + struct constexpr_member_functions + { + template<typename _Ttesttype> + void + operator()() + { + struct _Concept + { + void __constraint() + { + constexpr auto v1(_Ttesttype::min()); + constexpr auto v2(_Ttesttype::max()); + + constexpr _Ttesttype obj; + constexpr auto v3 = obj.time_since_epoch(); + } + }; + + _Concept c; + c.__constraint(); + } + }; +} + +int main() +{ + using namespace std::chrono; + __gnu_test::constexpr_member_functions test; + test.operator()<time_point<system_clock>>(); + return 0; +} diff --git a/libstdc++-v3/testsuite/20_util/time_point_cast/constexpr.cc b/libstdc++-v3/testsuite/20_util/time_point_cast/constexpr.cc new file mode 100644 index 00000000000..436a4fbfc6c --- /dev/null +++ b/libstdc++-v3/testsuite/20_util/time_point_cast/constexpr.cc @@ -0,0 +1,39 @@ +// { dg-do compile } +// { dg-options "-std=gnu++0x" } + +// Copyright (C) 2010 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. + +// You should have received a copy of the GNU General Public License along +// with this library; see the file COPYING3. If not see +// <http://www.gnu.org/licenses/>. + +#include <chrono> +#include <testsuite_common_types.h> + +int main() +{ + using namespace std::chrono; + typedef time_point<system_clock, hours> to_type; + typedef time_point<system_clock, minutes> from_type; + + // constexpr + constexpr minutes m(6000); + constexpr hours h(19); + constexpr to_type tpm(h); // time_point object with minutes + constexpr from_type tph(m); // time_point object with hours + + constexpr auto res(time_point_cast<hours>(tpm)); + + return 0; +} diff --git a/libstdc++-v3/testsuite/20_util/unique_ptr/cons/constexpr.cc b/libstdc++-v3/testsuite/20_util/unique_ptr/cons/constexpr.cc new file mode 100644 index 00000000000..20db7615ba8 --- /dev/null +++ b/libstdc++-v3/testsuite/20_util/unique_ptr/cons/constexpr.cc @@ -0,0 +1,32 @@ +// { dg-do compile { xfail *-*-* } } +// { dg-options "-std=gnu++0x" } + +// Copyright (C) 2010 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. + +// You should have received a copy of the GNU General Public License along +// with this library; see the file COPYING3. If not see +// <http://www.gnu.org/licenses/>. + +#include <memory> +#include <testsuite_common_types.h> + +int main() +{ + __gnu_test::constexpr_default_constructible test1; + test1.operator()<std::unique_ptr<int>>(); // { dg-excess-errors "" } + + __gnu_test::constexpr_single_value_constructible test2; + test2.operator()<std::unique_ptr<int>, std::nullptr_t>(); // { dg-excess-errors "" } + return 0; +} diff --git a/libstdc++-v3/testsuite/20_util/weak_ptr/comparison/cmp_neg.cc b/libstdc++-v3/testsuite/20_util/weak_ptr/comparison/cmp_neg.cc index fbb24c002f4..b8cf6d8c08c 100644 --- a/libstdc++-v3/testsuite/20_util/weak_ptr/comparison/cmp_neg.cc +++ b/libstdc++-v3/testsuite/20_util/weak_ptr/comparison/cmp_neg.cc @@ -42,10 +42,10 @@ main() } // { dg-warning "note" "" { target *-*-* } 347 } -// { dg-warning "note" "" { target *-*-* } 466 } +// { dg-warning "note" "" { target *-*-* } 465 } // { dg-warning "note" "" { target *-*-* } 883 } // { dg-warning "note" "" { target *-*-* } 580 } // { dg-warning "note" "" { target *-*-* } 1027 } // { dg-warning "note" "" { target *-*-* } 340 } // { dg-warning "note" "" { target *-*-* } 290 } -// { dg-warning "note" "" { target *-*-* } 200 } +// { dg-warning "note" "" { target *-*-* } 201 } diff --git a/libstdc++-v3/testsuite/20_util/weak_ptr/cons/constexpr.cc b/libstdc++-v3/testsuite/20_util/weak_ptr/cons/constexpr.cc new file mode 100644 index 00000000000..3b43769bff3 --- /dev/null +++ b/libstdc++-v3/testsuite/20_util/weak_ptr/cons/constexpr.cc @@ -0,0 +1,32 @@ +// { dg-do compile { xfail *-*-* } } +// { dg-options "-std=gnu++0x" } + +// Copyright (C) 2010 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. + +// You should have received a copy of the GNU General Public License along +// with this library; see the file COPYING3. If not see +// <http://www.gnu.org/licenses/>. + +#include <memory> +#include <testsuite_common_types.h> + +int main() +{ + __gnu_test::constexpr_default_constructible test; + test.operator()<std::weak_ptr<int>>(); // { dg-excess-errors "" } + // test.operator()<std::__weak_ptr<int>>(); + // test.operator()<std::__weak_count<__gnu_cxx::__default_lock_policy>>(); + // test.operator()<std::_Sp_counted_base<__gnu_cxx::__default_lock_policy>>(); + return 0; +} diff --git a/libstdc++-v3/testsuite/21_strings/char_traits/requirements/constexpr_functions.cc b/libstdc++-v3/testsuite/21_strings/char_traits/requirements/constexpr_functions.cc new file mode 100644 index 00000000000..ecb9a3e243a --- /dev/null +++ b/libstdc++-v3/testsuite/21_strings/char_traits/requirements/constexpr_functions.cc @@ -0,0 +1,67 @@ +// { dg-do compile } +// { dg-options "-std=gnu++0x" } + +// Copyright (C) 2010 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. + +// You should have received a copy of the GNU General Public License along +// with this library; see the file COPYING3. If not see +// <http://www.gnu.org/licenses/>. + +#include <string> +#include <testsuite_common_types.h> + +namespace __gnu_test +{ + struct constexpr_member_functions + { + template<typename _Ttesttype> + void + operator()() + { + struct _Concept + { + void __constraint() + { + typedef typename _Ttesttype::char_type char_type; + typedef typename _Ttesttype::int_type int_type; + const char_type c1(0); + const char_type c2 = c1; + const int_type i(0); + constexpr auto v1(_Ttesttype::eq(c1, c2)); + constexpr auto v2(_Ttesttype::lt(c1, c2)); + constexpr auto v3(_Ttesttype::to_char_type(i)); + constexpr auto v4(_Ttesttype::to_int_type(c1)); + constexpr auto v5(_Ttesttype::eq_int_type(i, i)); + constexpr auto v6(_Ttesttype::eof()); + constexpr auto v7(_Ttesttype::not_eof(i)); + } + }; + + _Concept c; + c.__constraint(); + } + }; +} + +int main() +{ + __gnu_test::constexpr_member_functions test; + test.operator()<std::char_traits<char>>(); +#ifdef _GLIBCXX_USE_WCHAR_T + test.operator()<std::char_traits<wchar_t>>(); +#endif + test.operator()<std::char_traits<char16_t>>(); + test.operator()<std::char_traits<char32_t>>(); + return 0; +} diff --git a/libstdc++-v3/testsuite/23_containers/array/requirements/constexpr_functions.cc b/libstdc++-v3/testsuite/23_containers/array/requirements/constexpr_functions.cc new file mode 100644 index 00000000000..494a8dedd6f --- /dev/null +++ b/libstdc++-v3/testsuite/23_containers/array/requirements/constexpr_functions.cc @@ -0,0 +1,54 @@ +// { dg-do compile } +// { dg-options "-std=gnu++0x" } + +// Copyright (C) 2010 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. + +// You should have received a copy of the GNU General Public License along +// with this library; see the file COPYING3. If not see +// <http://www.gnu.org/licenses/>. + +#include <array> +#include <testsuite_common_types.h> + +namespace __gnu_test +{ + struct constexpr_member_functions + { + template<typename _Ttesttype> + void + operator()() + { + struct _Concept + { + void __constraint() + { + constexpr _Ttesttype a = { }; + constexpr auto v1 = a.size(); + constexpr auto v2 = a.max_size(); + constexpr auto v3 = a.empty(); + } + }; + + _Concept c; + c.__constraint(); + } + }; +} + +int main() +{ + __gnu_test::constexpr_member_functions test; + test.operator()<std::array<long, 60>>(); + return 0; +} diff --git a/libstdc++-v3/testsuite/23_containers/bitset/cons/constexpr.cc b/libstdc++-v3/testsuite/23_containers/bitset/cons/constexpr.cc new file mode 100644 index 00000000000..aea50301375 --- /dev/null +++ b/libstdc++-v3/testsuite/23_containers/bitset/cons/constexpr.cc @@ -0,0 +1,37 @@ +// { dg-do compile } +// { dg-options "-std=gnu++0x" } + +// Copyright (C) 2010 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. + +// You should have received a copy of the GNU General Public License along +// with this library; see the file COPYING3. If not see +// <http://www.gnu.org/licenses/>. + +#include <bitset> +#include <testsuite_common_types.h> + +int main() +{ + __gnu_test::constexpr_default_constructible test1; + test1.operator()<std::bitset<0>>(); + test1.operator()<std::bitset<1>>(); + test1.operator()<std::bitset<256>>(); + + __gnu_test::constexpr_single_value_constructible test2; + test2.operator()<std::bitset<0>, unsigned long long>(); + test2.operator()<std::bitset<1>, unsigned long long>(); + test2.operator()<std::bitset<256>, unsigned long long>(); + + return 0; +} diff --git a/libstdc++-v3/testsuite/23_containers/bitset/requirements/constexpr_functions.cc b/libstdc++-v3/testsuite/23_containers/bitset/requirements/constexpr_functions.cc new file mode 100644 index 00000000000..ac9a07f379c --- /dev/null +++ b/libstdc++-v3/testsuite/23_containers/bitset/requirements/constexpr_functions.cc @@ -0,0 +1,55 @@ +// { dg-do compile } +// { dg-options "-std=gnu++0x" } + +// Copyright (C) 2010 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. + +// You should have received a copy of the GNU General Public License along +// with this library; see the file COPYING3. If not see +// <http://www.gnu.org/licenses/>. + +#include <bitset> +#include <testsuite_common_types.h> + +namespace __gnu_test +{ + struct constexpr_member_functions + { + template<typename _Ttesttype> + void + operator()() + { + struct _Concept + { + void __constraint() + { + constexpr _Ttesttype obj; + constexpr auto v1 = obj.size(); + // constexpr auto v2 = obj[4]; + } + }; + + _Concept c; + c.__constraint(); + } + }; +} + +int main() +{ + __gnu_test::constexpr_member_functions test; + test.operator()<std::bitset<0>>(); + test.operator()<std::bitset<1>>(); + test.operator()<std::bitset<64>>(); + return 0; +} diff --git a/libstdc++-v3/testsuite/24_iterators/istream_iterator/cons/constexpr.cc b/libstdc++-v3/testsuite/24_iterators/istream_iterator/cons/constexpr.cc new file mode 100644 index 00000000000..20b41997303 --- /dev/null +++ b/libstdc++-v3/testsuite/24_iterators/istream_iterator/cons/constexpr.cc @@ -0,0 +1,29 @@ +// { dg-do compile } +// { dg-options "-std=gnu++0x" } + +// Copyright (C) 2010 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. + +// You should have received a copy of the GNU General Public License along +// with this library; see the file COPYING3. If not see +// <http://www.gnu.org/licenses/>. + +#include <iterator> +#include <testsuite_common_types.h> + +int main() +{ + __gnu_test::constexpr_default_constructible test; + test.operator()<std::istream_iterator<char>>(); + return 0; +} diff --git a/libstdc++-v3/testsuite/24_iterators/istreambuf_iterator/cons/constexpr.cc b/libstdc++-v3/testsuite/24_iterators/istreambuf_iterator/cons/constexpr.cc new file mode 100644 index 00000000000..0a6980ec1f0 --- /dev/null +++ b/libstdc++-v3/testsuite/24_iterators/istreambuf_iterator/cons/constexpr.cc @@ -0,0 +1,29 @@ +// { dg-do compile } +// { dg-options "-std=gnu++0x" } + +// Copyright (C) 2010 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. + +// You should have received a copy of the GNU General Public License along +// with this library; see the file COPYING3. If not see +// <http://www.gnu.org/licenses/>. + +#include <iterator> +#include <testsuite_common_types.h> + +int main() +{ + __gnu_test::constexpr_default_constructible test; + test.operator()<std::istreambuf_iterator<char, std::char_traits<char>>>(); + return 0; +} diff --git a/libstdc++-v3/testsuite/26_numerics/complex/cons/constexpr.cc b/libstdc++-v3/testsuite/26_numerics/complex/cons/constexpr.cc new file mode 100644 index 00000000000..13d3c81685f --- /dev/null +++ b/libstdc++-v3/testsuite/26_numerics/complex/cons/constexpr.cc @@ -0,0 +1,37 @@ +// { dg-do compile } +// { dg-options "-std=gnu++0x" } + +// Copyright (C) 2010 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. + +// You should have received a copy of the GNU General Public License along +// with this library; see the file COPYING3. If not see +// <http://www.gnu.org/licenses/>. + +#include <complex> +#include <testsuite_common_types.h> + +int main() +{ + __gnu_test::constexpr_default_constructible test1; + test1.operator()<std::complex<float>>(); + test1.operator()<std::complex<double>>(); + test1.operator()<std::complex<long double>>(); + + __gnu_test::constexpr_single_value_constructible test2; + test2.operator()<std::complex<float>, float>(); + test2.operator()<std::complex<double>, double>(); + test2.operator()<std::complex<long double>, long double>(); + + return 0; +} diff --git a/libstdc++-v3/testsuite/26_numerics/complex/requirements/constexpr_functions.cc b/libstdc++-v3/testsuite/26_numerics/complex/requirements/constexpr_functions.cc new file mode 100644 index 00000000000..74f7bf5515f --- /dev/null +++ b/libstdc++-v3/testsuite/26_numerics/complex/requirements/constexpr_functions.cc @@ -0,0 +1,57 @@ +// { dg-do compile } +// { dg-options "-std=gnu++0x" } + +// Copyright (C) 2010 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. + +// You should have received a copy of the GNU General Public License along +// with this library; see the file COPYING3. If not see +// <http://www.gnu.org/licenses/>. + +#include <complex> +#include <testsuite_common_types.h> + +namespace __gnu_test +{ + struct constexpr_member_functions + { + template<typename _Ttesttype> + void + operator()() + { + struct _Concept + { + void __constraint() + { + typedef typename _Ttesttype::_ComplexT _ComplexT; + const _ComplexT cc = { 1.1 }; + constexpr _Ttesttype a(cc); + constexpr auto v1 = a.real(); + constexpr auto v2 = a.imag(); + } + }; + + _Concept c; + c.__constraint(); + } + }; +} + +int main() +{ + __gnu_test::constexpr_member_functions test; + test.operator()<std::complex<float>>(); + test.operator()<std::complex<double>>(); + test.operator()<std::complex<long double>>(); + return 0; +} diff --git a/libstdc++-v3/testsuite/26_numerics/random/discard_block_engine/requirements/constexpr_data.cc b/libstdc++-v3/testsuite/26_numerics/random/discard_block_engine/requirements/constexpr_data.cc new file mode 100644 index 00000000000..7f82bfee55f --- /dev/null +++ b/libstdc++-v3/testsuite/26_numerics/random/discard_block_engine/requirements/constexpr_data.cc @@ -0,0 +1,57 @@ +// { dg-do compile } +// { dg-options "-std=gnu++0x" } + +// Copyright (C) 2010 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. + +// You should have received a copy of the GNU General Public License along +// with this library; see the file COPYING3. If not see +// <http://www.gnu.org/licenses/>. + +#include <random> +#include <testsuite_common_types.h> + +namespace __gnu_test +{ + struct constexpr_member_data + { + template<typename _Ttesttype> + void + operator()() + { + struct _Concept + { + void __constraint() + { + constexpr auto v1(_Ttesttype::block_size); + constexpr auto v2(_Ttesttype::used_block); + } + }; + + _Concept c; + c.__constraint(); + } + }; +} + +int main() +{ + __gnu_test::constexpr_member_data test; + typedef std::discard_block_engine + < + std::subtract_with_carry_engine<unsigned long, 24, 10, 24>, + 389, 24 + > type; + test.operator()<type>(); + return 0; +} diff --git a/libstdc++-v3/testsuite/26_numerics/random/discard_block_engine/requirements/constexpr_functions.cc b/libstdc++-v3/testsuite/26_numerics/random/discard_block_engine/requirements/constexpr_functions.cc new file mode 100644 index 00000000000..faec5bfad2f --- /dev/null +++ b/libstdc++-v3/testsuite/26_numerics/random/discard_block_engine/requirements/constexpr_functions.cc @@ -0,0 +1,57 @@ +// { dg-do compile } +// { dg-options "-std=gnu++0x" } + +// Copyright (C) 2010 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. + +// You should have received a copy of the GNU General Public License along +// with this library; see the file COPYING3. If not see +// <http://www.gnu.org/licenses/>. + +#include <random> +#include <testsuite_common_types.h> + +namespace __gnu_test +{ + struct constexpr_member_functions + { + template<typename _Ttesttype> + void + operator()() + { + struct _Concept + { + void __constraint() + { + constexpr auto v1(_Ttesttype::min()); + constexpr auto v2(_Ttesttype::max()); + } + }; + + _Concept c; + c.__constraint(); + } + }; +} + +int main() +{ + __gnu_test::constexpr_member_functions test; + typedef std::discard_block_engine + < + std::subtract_with_carry_engine<unsigned long, 24, 10, 24>, + 389, 24 + > type; + test.operator()<type>(); + return 0; +} diff --git a/libstdc++-v3/testsuite/26_numerics/random/independent_bits_engine/requirements/constexpr_functions.cc b/libstdc++-v3/testsuite/26_numerics/random/independent_bits_engine/requirements/constexpr_functions.cc new file mode 100644 index 00000000000..2b84ec855df --- /dev/null +++ b/libstdc++-v3/testsuite/26_numerics/random/independent_bits_engine/requirements/constexpr_functions.cc @@ -0,0 +1,60 @@ +// { dg-do compile } +// { dg-options "-std=gnu++0x" } + +// Copyright (C) 2010 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. + +// You should have received a copy of the GNU General Public License along +// with this library; see the file COPYING3. If not see +// <http://www.gnu.org/licenses/>. + +#include <random> +#include <testsuite_common_types.h> + +namespace __gnu_test +{ + struct constexpr_member_functions + { + template<typename _Ttesttype> + void + operator()() + { + struct _Concept + { + void __constraint() + { + constexpr auto v1(_Ttesttype::min()); + constexpr auto v2(_Ttesttype::max()); + } + }; + + _Concept c; + c.__constraint(); + } + }; +} + +int main() +{ + __gnu_test::constexpr_member_functions test; + typedef std::independent_bits_engine + < + std::subtract_with_carry_engine + < + uint_fast64_t, 48, 5, 12 + >, + 48, uint_fast64_t + > type; + test.operator()<type>(); + return 0; +} diff --git a/libstdc++-v3/testsuite/26_numerics/random/linear_congruential_engine/requirements/constexpr_data.cc b/libstdc++-v3/testsuite/26_numerics/random/linear_congruential_engine/requirements/constexpr_data.cc new file mode 100644 index 00000000000..e7e9fc05311 --- /dev/null +++ b/libstdc++-v3/testsuite/26_numerics/random/linear_congruential_engine/requirements/constexpr_data.cc @@ -0,0 +1,55 @@ +// { dg-do compile } +// { dg-options "-std=gnu++0x" } + +// Copyright (C) 2010 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. + +// You should have received a copy of the GNU General Public License along +// with this library; see the file COPYING3. If not see +// <http://www.gnu.org/licenses/>. + +#include <random> +#include <testsuite_common_types.h> + +namespace __gnu_test +{ + struct constexpr_member_data + { + template<typename _Ttesttype> + void + operator()() + { + struct _Concept + { + void __constraint() + { + constexpr auto v1(_Ttesttype::multiplier); + constexpr auto v2(_Ttesttype::increment); + constexpr auto v3(_Ttesttype::modulus); + constexpr auto v4(_Ttesttype::default_seed); + } + }; + + _Concept c; + c.__constraint(); + } + }; +} + +int main() +{ + __gnu_test::constexpr_member_data test; + typedef std::linear_congruential_engine<unsigned int, 41, 0, 2147483647> type; + test.operator()<type>(); + return 0; +} diff --git a/libstdc++-v3/testsuite/26_numerics/random/linear_congruential_engine/requirements/constexpr_functions.cc b/libstdc++-v3/testsuite/26_numerics/random/linear_congruential_engine/requirements/constexpr_functions.cc new file mode 100644 index 00000000000..cff1a67caf1 --- /dev/null +++ b/libstdc++-v3/testsuite/26_numerics/random/linear_congruential_engine/requirements/constexpr_functions.cc @@ -0,0 +1,53 @@ +// { dg-do compile } +// { dg-options "-std=gnu++0x" } + +// Copyright (C) 2010 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. + +// You should have received a copy of the GNU General Public License along +// with this library; see the file COPYING3. If not see +// <http://www.gnu.org/licenses/>. + +#include <random> +#include <testsuite_common_types.h> + +namespace __gnu_test +{ + struct constexpr_member_functions + { + template<typename _Ttesttype> + void + operator()() + { + struct _Concept + { + void __constraint() + { + constexpr auto v1(_Ttesttype::min()); + constexpr auto v2(_Ttesttype::max()); + } + }; + + _Concept c; + c.__constraint(); + } + }; +} + +int main() +{ + __gnu_test::constexpr_member_functions test; + typedef std::linear_congruential_engine<unsigned int, 41, 0, 2147483647> type; + test.operator()<type>(); + return 0; +} diff --git a/libstdc++-v3/testsuite/26_numerics/random/mersenne_twister_engine/requirements/constexpr_data.cc b/libstdc++-v3/testsuite/26_numerics/random/mersenne_twister_engine/requirements/constexpr_data.cc new file mode 100644 index 00000000000..17c89e13bf9 --- /dev/null +++ b/libstdc++-v3/testsuite/26_numerics/random/mersenne_twister_engine/requirements/constexpr_data.cc @@ -0,0 +1,65 @@ +// { dg-do compile } +// { dg-options "-std=gnu++0x" } + +// Copyright (C) 2010 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. + +// You should have received a copy of the GNU General Public License along +// with this library; see the file COPYING3. If not see +// <http://www.gnu.org/licenses/>. + +#include <random> +#include <testsuite_common_types.h> + +namespace __gnu_test +{ + struct constexpr_member_data + { + template<typename _Ttesttype> + void + operator()() + { + struct _Concept + { + void __constraint() + { + constexpr auto v1(_Ttesttype::word_size); + constexpr auto v2(_Ttesttype::state_size); + constexpr auto v3(_Ttesttype::shift_size); + constexpr auto v4(_Ttesttype::mask_bits); + constexpr auto v5(_Ttesttype::xor_mask); + constexpr auto v6(_Ttesttype::tempering_u); + constexpr auto v7(_Ttesttype::tempering_d); + constexpr auto v8(_Ttesttype::tempering_s); + constexpr auto v9(_Ttesttype::tempering_b); + constexpr auto v10(_Ttesttype::tempering_t); + constexpr auto v11(_Ttesttype::tempering_c); + constexpr auto v12(_Ttesttype::tempering_l); + constexpr auto v13(_Ttesttype::initialization_multiplier); + constexpr auto v14(_Ttesttype::default_seed); + } + }; + + _Concept c; + c.__constraint(); + } + }; +} + +int main() +{ + __gnu_test::constexpr_member_data test; + typedef std::mt19937 type; + test.operator()<type>(); + return 0; +} diff --git a/libstdc++-v3/testsuite/26_numerics/random/mersenne_twister_engine/requirements/constexpr_functions.cc b/libstdc++-v3/testsuite/26_numerics/random/mersenne_twister_engine/requirements/constexpr_functions.cc new file mode 100644 index 00000000000..dd350e7fbd8 --- /dev/null +++ b/libstdc++-v3/testsuite/26_numerics/random/mersenne_twister_engine/requirements/constexpr_functions.cc @@ -0,0 +1,53 @@ +// { dg-do compile } +// { dg-options "-std=gnu++0x" } + +// Copyright (C) 2010 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. + +// You should have received a copy of the GNU General Public License along +// with this library; see the file COPYING3. If not see +// <http://www.gnu.org/licenses/>. + +#include <random> +#include <testsuite_common_types.h> + +namespace __gnu_test +{ + struct constexpr_member_functions + { + template<typename _Ttesttype> + void + operator()() + { + struct _Concept + { + void __constraint() + { + constexpr auto v1(_Ttesttype::min()); + constexpr auto v2(_Ttesttype::max()); + } + }; + + _Concept c; + c.__constraint(); + } + }; +} + +int main() +{ + __gnu_test::constexpr_member_functions test; + typedef std::mt19937 type; + test.operator()<type>(); + return 0; +} diff --git a/libstdc++-v3/testsuite/26_numerics/random/shuffle_order_engine/requirements/constexpr_data.cc b/libstdc++-v3/testsuite/26_numerics/random/shuffle_order_engine/requirements/constexpr_data.cc new file mode 100644 index 00000000000..8a158fb9a42 --- /dev/null +++ b/libstdc++-v3/testsuite/26_numerics/random/shuffle_order_engine/requirements/constexpr_data.cc @@ -0,0 +1,59 @@ +// { dg-do compile } +// { dg-options "-std=gnu++0x" } + +// Copyright (C) 2010 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. + +// You should have received a copy of the GNU General Public License along +// with this library; see the file COPYING3. If not see +// <http://www.gnu.org/licenses/>. + +#include <random> +#include <testsuite_common_types.h> + +namespace __gnu_test +{ + struct constexpr_member_data + { + template<typename _Ttesttype> + void + operator()() + { + struct _Concept + { + void __constraint() + { + constexpr auto v1(_Ttesttype::table_size); + } + }; + + _Concept c; + c.__constraint(); + } + }; +} + +int main() +{ + __gnu_test::constexpr_member_data test; + typedef std::shuffle_order_engine + < + std::linear_congruential_engine + < + uint_fast32_t,16807UL, 0UL, 2147483647UL + >, + 256 + > type; + test.operator()<type>(); + return 0; +} diff --git a/libstdc++-v3/testsuite/26_numerics/random/shuffle_order_engine/requirements/constexpr_functions.cc b/libstdc++-v3/testsuite/26_numerics/random/shuffle_order_engine/requirements/constexpr_functions.cc new file mode 100644 index 00000000000..65e2e5612d5 --- /dev/null +++ b/libstdc++-v3/testsuite/26_numerics/random/shuffle_order_engine/requirements/constexpr_functions.cc @@ -0,0 +1,60 @@ +// { dg-do compile } +// { dg-options "-std=gnu++0x" } + +// Copyright (C) 2010 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. + +// You should have received a copy of the GNU General Public License along +// with this library; see the file COPYING3. If not see +// <http://www.gnu.org/licenses/>. + +#include <random> +#include <testsuite_common_types.h> + +namespace __gnu_test +{ + struct constexpr_member_functions + { + template<typename _Ttesttype> + void + operator()() + { + struct _Concept + { + void __constraint() + { + constexpr auto v1(_Ttesttype::min()); + constexpr auto v2(_Ttesttype::max()); + } + }; + + _Concept c; + c.__constraint(); + } + }; +} + +int main() +{ + __gnu_test::constexpr_member_functions test; + typedef std::shuffle_order_engine + < + std::linear_congruential_engine + < + uint_fast32_t,16807UL, 0UL, 2147483647UL + >, + 256 + > type; + test.operator()<type>(); + return 0; +} diff --git a/libstdc++-v3/testsuite/26_numerics/random/subtract_with_carry_engine/requirements/constexpr_data.cc b/libstdc++-v3/testsuite/26_numerics/random/subtract_with_carry_engine/requirements/constexpr_data.cc new file mode 100644 index 00000000000..0b51727b1cd --- /dev/null +++ b/libstdc++-v3/testsuite/26_numerics/random/subtract_with_carry_engine/requirements/constexpr_data.cc @@ -0,0 +1,55 @@ +// { dg-do compile } +// { dg-options "-std=gnu++0x" } + +// Copyright (C) 2010 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. + +// You should have received a copy of the GNU General Public License along +// with this library; see the file COPYING3. If not see +// <http://www.gnu.org/licenses/>. + +#include <random> +#include <testsuite_common_types.h> + +namespace __gnu_test +{ + struct constexpr_member_data + { + template<typename _Ttesttype> + void + operator()() + { + struct _Concept + { + void __constraint() + { + constexpr auto v1(_Ttesttype::word_size); + constexpr auto v2(_Ttesttype::short_lag); + constexpr auto v3(_Ttesttype::long_lag); + constexpr auto v4(_Ttesttype::default_seed); + } + }; + + _Concept c; + c.__constraint(); + } + }; +} + +int main() +{ + __gnu_test::constexpr_member_data test; + typedef std::ranlux24_base type; + test.operator()<type>(); + return 0; +} diff --git a/libstdc++-v3/testsuite/26_numerics/random/subtract_with_carry_engine/requirements/constexpr_functions.cc b/libstdc++-v3/testsuite/26_numerics/random/subtract_with_carry_engine/requirements/constexpr_functions.cc new file mode 100644 index 00000000000..b05710a9e67 --- /dev/null +++ b/libstdc++-v3/testsuite/26_numerics/random/subtract_with_carry_engine/requirements/constexpr_functions.cc @@ -0,0 +1,53 @@ +// { dg-do compile } +// { dg-options "-std=gnu++0x" } + +// Copyright (C) 2010 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. + +// You should have received a copy of the GNU General Public License along +// with this library; see the file COPYING3. If not see +// <http://www.gnu.org/licenses/>. + +#include <random> +#include <testsuite_common_types.h> + +namespace __gnu_test +{ + struct constexpr_member_functions + { + template<typename _Ttesttype> + void + operator()() + { + struct _Concept + { + void __constraint() + { + constexpr auto v1(_Ttesttype::min()); + constexpr auto v2(_Ttesttype::max()); + } + }; + + _Concept c; + c.__constraint(); + } + }; +} + +int main() +{ + __gnu_test::constexpr_member_functions test; + typedef std::ranlux24_base type; + test.operator()<type>(); + return 0; +} diff --git a/libstdc++-v3/testsuite/27_io/ios_base/cons/assign_neg.cc b/libstdc++-v3/testsuite/27_io/ios_base/cons/assign_neg.cc index a7adff4d3f4..8e97d329942 100644 --- a/libstdc++-v3/testsuite/27_io/ios_base/cons/assign_neg.cc +++ b/libstdc++-v3/testsuite/27_io/ios_base/cons/assign_neg.cc @@ -34,5 +34,5 @@ void test01() } // { dg-error "synthesized" "" { target *-*-* } 33 } // { dg-error "within this context" "" { target *-*-* } 26 } -// { dg-error "is private" "" { target *-*-* } 788 } +// { dg-error "is private" "" { target *-*-* } 789 } // { dg-error "operator=" "" { target *-*-* } 0 } diff --git a/libstdc++-v3/testsuite/27_io/ios_base/cons/copy_neg.cc b/libstdc++-v3/testsuite/27_io/ios_base/cons/copy_neg.cc index 44f7af87da8..6e527cdc262 100644 --- a/libstdc++-v3/testsuite/27_io/ios_base/cons/copy_neg.cc +++ b/libstdc++-v3/testsuite/27_io/ios_base/cons/copy_neg.cc @@ -34,5 +34,5 @@ void test02() } // { dg-error "within this context" "" { target *-*-* } 26 } // { dg-error "synthesized" "" { target *-*-* } 33 } -// { dg-error "is private" "" { target *-*-* } 785 } +// { dg-error "is private" "" { target *-*-* } 786 } // { dg-error "copy constructor" "" { target *-*-* } 0 } diff --git a/libstdc++-v3/testsuite/27_io/ios_base/types/fmtflags/constexpr_operators.cc b/libstdc++-v3/testsuite/27_io/ios_base/types/fmtflags/constexpr_operators.cc new file mode 100644 index 00000000000..349f7f9f2d0 --- /dev/null +++ b/libstdc++-v3/testsuite/27_io/ios_base/types/fmtflags/constexpr_operators.cc @@ -0,0 +1,28 @@ +// { dg-do compile } +// { dg-options "-std=gnu++0x" } + +// Copyright (C) 2010 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. + +// You should have received a copy of the GNU General Public License along +// with this library; see the file COPYING3. If not see +// <http://www.gnu.org/licenses/>. + +#include <ios> +#include <testsuite_common_types.h> + +int main() +{ + __gnu_test::constexpr_bitwise_operators<std::ios_base::fmtflags>(); + return 0; +} diff --git a/libstdc++-v3/testsuite/29_atomics/headers/stdatomic.h/debug_mode.c b/libstdc++-v3/testsuite/27_io/ios_base/types/iostate/constexpr_operators.cc index a8abfbe929f..fd3ce10553b 100644 --- a/libstdc++-v3/testsuite/29_atomics/headers/stdatomic.h/debug_mode.c +++ b/libstdc++-v3/testsuite/27_io/ios_base/types/iostate/constexpr_operators.cc @@ -1,7 +1,7 @@ -// { dg-options "-x c -D_GLIBCXX_DEBUG" } // { dg-do compile } +// { dg-options "-std=gnu++0x" } -// Copyright (C) 2008, 2009 Free Software Foundation, Inc. +// Copyright (C) 2010 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 @@ -18,5 +18,11 @@ // with this library; see the file COPYING3. If not see // <http://www.gnu.org/licenses/>. -// libstdc++/36130 -#include <stdatomic.h> +#include <ios> +#include <testsuite_common_types.h> + +int main() +{ + __gnu_test::constexpr_bitwise_operators<std::ios_base::iostate>(); + return 0; +} diff --git a/libstdc++-v3/testsuite/27_io/ios_base/types/openmode/constexpr_operators.cc b/libstdc++-v3/testsuite/27_io/ios_base/types/openmode/constexpr_operators.cc new file mode 100644 index 00000000000..66041b87e1f --- /dev/null +++ b/libstdc++-v3/testsuite/27_io/ios_base/types/openmode/constexpr_operators.cc @@ -0,0 +1,28 @@ +// { dg-do compile } +// { dg-options "-std=gnu++0x" } + +// Copyright (C) 2010 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. + +// You should have received a copy of the GNU General Public License along +// with this library; see the file COPYING3. If not see +// <http://www.gnu.org/licenses/>. + +#include <ios> +#include <testsuite_common_types.h> + +int main() +{ + __gnu_test::constexpr_bitwise_operators<std::ios_base::openmode>(); + return 0; +} diff --git a/libstdc++-v3/testsuite/28_regex/05_constants/syntax_option_type.cc b/libstdc++-v3/testsuite/28_regex/05_constants/syntax_option_type.cc index 2aebf46d19e..71a11ef2106 100644 --- a/libstdc++-v3/testsuite/28_regex/05_constants/syntax_option_type.cc +++ b/libstdc++-v3/testsuite/28_regex/05_constants/syntax_option_type.cc @@ -23,29 +23,68 @@ // 28.5.1 #include <regex> -#include <testsuite_hooks.h> void test01() { - bool test __attribute__((unused)) = true; + std::regex_constants::syntax_option_type option { }; + option = option | std::regex_constants::icase; + option = option | std::regex_constants::nosubs; + option = option | std::regex_constants::optimize; + option = option | std::regex_constants::collate; + option = option | std::regex_constants::ECMAScript; + option = option | std::regex_constants::basic; + option = option | std::regex_constants::extended; + option = option | std::regex_constants::awk; + option = option | std::regex_constants::grep; + option = option | std::regex_constants::egrep; +} + +void +test02() +{ + std::regex_constants::syntax_option_type option { }; + option = option & std::regex_constants::icase; + option = option & std::regex_constants::nosubs; + option = option & std::regex_constants::optimize; + option = option & std::regex_constants::collate; + option = option & std::regex_constants::ECMAScript; + option = option & std::regex_constants::basic; + option = option & std::regex_constants::extended; + option = option & std::regex_constants::awk; + option = option & std::regex_constants::grep; + option = option & std::regex_constants::egrep; +} - std::regex_constants::syntax_option_type option = 0; +void +test03() +{ + std::regex_constants::syntax_option_type option { }; + option = ~std::regex_constants::icase; + option = ~std::regex_constants::nosubs; + option = ~std::regex_constants::optimize; + option = ~std::regex_constants::collate; + option = ~std::regex_constants::ECMAScript; + option = ~std::regex_constants::basic; + option = ~std::regex_constants::extended; + option = ~std::regex_constants::awk; + option = ~std::regex_constants::grep; + option = ~std::regex_constants::egrep; +} - option |= std::regex_constants::icase; - option |= std::regex_constants::nosubs; - option |= std::regex_constants::optimize; - option |= std::regex_constants::collate; - option |= std::regex_constants::ECMAScript; - option |= std::regex_constants::basic; - option |= std::regex_constants::extended; - option |= std::regex_constants::awk; - option |= std::regex_constants::grep; - option |= std::regex_constants::egrep; +void +test04_constexpr() +{ + using namespace std::regex_constants; + constexpr auto a1 = icase | awk; + constexpr auto a2 = icase & awk; + constexpr auto a3 = ~grep; } int main() { test01(); + test02(); + test03(); return 0; } diff --git a/libstdc++-v3/testsuite/28_regex/08_basic_regex/requirements/constexpr_data.cc b/libstdc++-v3/testsuite/28_regex/08_basic_regex/requirements/constexpr_data.cc new file mode 100644 index 00000000000..7db1bbd5a4a --- /dev/null +++ b/libstdc++-v3/testsuite/28_regex/08_basic_regex/requirements/constexpr_data.cc @@ -0,0 +1,61 @@ +// { dg-do compile } +// { dg-options "-std=gnu++0x" } + +// Copyright (C) 2010 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. + +// You should have received a copy of the GNU General Public License along +// with this library; see the file COPYING3. If not see +// <http://www.gnu.org/licenses/>. + +#include <regex> +#include <testsuite_common_types.h> + +namespace __gnu_test +{ + struct constexpr_member_data + { + template<typename _Ttesttype> + void + operator()() + { + struct _Concept + { + void __constraint() + { + constexpr auto v1(_Ttesttype::icase); + constexpr auto v2(_Ttesttype::nosubs); + constexpr auto v3(_Ttesttype::optimize); + constexpr auto v4(_Ttesttype::collate); + constexpr auto v5(_Ttesttype::ECMAScript); + constexpr auto v6(_Ttesttype::basic); + constexpr auto v7(_Ttesttype::extended); + constexpr auto v8(_Ttesttype::awk); + constexpr auto v9(_Ttesttype::grep); + constexpr auto v10(_Ttesttype::egrep); + } + }; + + _Concept c; + c.__constraint(); + } + }; +} + +int main() +{ + __gnu_test::constexpr_member_data test; + test.operator()<std::regex>(); + test.operator()<std::wregex>(); + return 0; +} diff --git a/libstdc++-v3/testsuite/29_atomics/atomic/cons/assign_neg.cc b/libstdc++-v3/testsuite/29_atomics/atomic/cons/assign_neg.cc index 66f5a81a5e5..9272c7eb3da 100644 --- a/libstdc++-v3/testsuite/29_atomics/atomic/cons/assign_neg.cc +++ b/libstdc++-v3/testsuite/29_atomics/atomic/cons/assign_neg.cc @@ -28,5 +28,5 @@ int main() return 0; } -// { dg-error "ambiguous" "" { target *-*-* } 522 } +// { dg-error "deleted" "" { target *-*-* } 544 } // { dg-prune-output "include" } diff --git a/libstdc++-v3/testsuite/29_atomics/atomic/cons/constexpr.cc b/libstdc++-v3/testsuite/29_atomics/atomic/cons/constexpr.cc new file mode 100644 index 00000000000..875c5490053 --- /dev/null +++ b/libstdc++-v3/testsuite/29_atomics/atomic/cons/constexpr.cc @@ -0,0 +1,32 @@ +// { dg-do compile } +// { dg-options "-std=gnu++0x" } + +// Copyright (C) 2010 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. + +// You should have received a copy of the GNU General Public License along +// with this library; see the file COPYING3. If not see +// <http://www.gnu.org/licenses/>. + +#include <atomic> +#include <testsuite_common_types.h> + +int main() +{ + __gnu_test::constexpr_single_value_constructible test; + + // test.operator()<std::atomic<int>, int>(); + __gnu_cxx::typelist::apply_generator(test, __gnu_test::atomics_tl(), + __gnu_test::integral_types::type()); + return 0; +} diff --git a/libstdc++-v3/testsuite/29_atomics/atomic/cons/copy_neg.cc b/libstdc++-v3/testsuite/29_atomics/atomic/cons/copy_neg.cc index 69b1eff1297..19b3a150c19 100644 --- a/libstdc++-v3/testsuite/29_atomics/atomic/cons/copy_neg.cc +++ b/libstdc++-v3/testsuite/29_atomics/atomic/cons/copy_neg.cc @@ -28,5 +28,5 @@ int main() return 0; } -// { dg-error "deleted" "" { target *-*-* } 561 } +// { dg-error "deleted" "" { target *-*-* } 583 } // { dg-prune-output "include" } diff --git a/libstdc++-v3/testsuite/29_atomics/atomic_address/cons/assign_neg.cc b/libstdc++-v3/testsuite/29_atomics/atomic_address/cons/assign_neg.cc index 9405e459bf8..fad25935446 100644 --- a/libstdc++-v3/testsuite/29_atomics/atomic_address/cons/assign_neg.cc +++ b/libstdc++-v3/testsuite/29_atomics/atomic_address/cons/assign_neg.cc @@ -26,6 +26,6 @@ void test01() typedef std::atomic_address test_type; test_type t1; test_type t2; - t1 = t2; // { dg-error "ambiguous" } + t1 = t2; // { dg-error "deleted" } } // { dg-prune-output "include" } diff --git a/libstdc++-v3/testsuite/29_atomics/atomic_address/cons/constexpr.cc b/libstdc++-v3/testsuite/29_atomics/atomic_address/cons/constexpr.cc new file mode 100644 index 00000000000..6b4963512a4 --- /dev/null +++ b/libstdc++-v3/testsuite/29_atomics/atomic_address/cons/constexpr.cc @@ -0,0 +1,29 @@ +// { dg-do compile } +// { dg-options "-std=gnu++0x" } + +// Copyright (C) 2010 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. + +// You should have received a copy of the GNU General Public License along +// with this library; see the file COPYING3. If not see +// <http://www.gnu.org/licenses/>. + +#include <atomic> +#include <testsuite_common_types.h> + +int main() +{ + __gnu_test::constexpr_single_value_constructible test; + test.operator()<std::atomic_address, void*>(); + return 0; +} diff --git a/libstdc++-v3/testsuite/29_atomics/atomic_flag/cons/1.cc b/libstdc++-v3/testsuite/29_atomics/atomic_flag/cons/1.cc index b7724403412..b91de112650 100644 --- a/libstdc++-v3/testsuite/29_atomics/atomic_flag/cons/1.cc +++ b/libstdc++-v3/testsuite/29_atomics/atomic_flag/cons/1.cc @@ -18,7 +18,7 @@ // with this library; see the file COPYING3. If not see // <http://www.gnu.org/licenses/>. -#include <stdatomic.h> +#include <atomic> void test01() { diff --git a/libstdc++-v3/testsuite/29_atomics/atomic_integral/cons/assign_neg.cc b/libstdc++-v3/testsuite/29_atomics/atomic_integral/cons/assign_neg.cc index 751c6cdc696..12da321abd8 100644 --- a/libstdc++-v3/testsuite/29_atomics/atomic_integral/cons/assign_neg.cc +++ b/libstdc++-v3/testsuite/29_atomics/atomic_integral/cons/assign_neg.cc @@ -29,5 +29,5 @@ int main() return 0; } -// { dg-error "ambiguous" "" { target *-*-* } 522 } +// { dg-error "deleted" "" { target *-*-* } 544 } // { dg-prune-output "include" } diff --git a/libstdc++-v3/testsuite/29_atomics/atomic_integral/cons/constexpr.cc b/libstdc++-v3/testsuite/29_atomics/atomic_integral/cons/constexpr.cc new file mode 100644 index 00000000000..a91db8d66a0 --- /dev/null +++ b/libstdc++-v3/testsuite/29_atomics/atomic_integral/cons/constexpr.cc @@ -0,0 +1,31 @@ +// { dg-do compile } +// { dg-options "-std=gnu++0x" } + +// Copyright (C) 2010 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. + +// You should have received a copy of the GNU General Public License along +// with this library; see the file COPYING3. If not see +// <http://www.gnu.org/licenses/>. + +#include <atomic> +#include <testsuite_common_types.h> + +int main() +{ + __gnu_test::constexpr_single_value_constructible test; + __gnu_cxx::typelist::apply_generator(test, + __gnu_test::atomic_integrals::type(), + __gnu_test::integral_types::type()); + return 0; +} diff --git a/libstdc++-v3/testsuite/29_atomics/atomic_integral/cons/copy_neg.cc b/libstdc++-v3/testsuite/29_atomics/atomic_integral/cons/copy_neg.cc index 976a6991d43..e334f1b0447 100644 --- a/libstdc++-v3/testsuite/29_atomics/atomic_integral/cons/copy_neg.cc +++ b/libstdc++-v3/testsuite/29_atomics/atomic_integral/cons/copy_neg.cc @@ -29,5 +29,5 @@ int main() return 0; } -// { dg-error "deleted" "" { target *-*-* } 561 } +// { dg-error "deleted" "" { target *-*-* } 583 } // { dg-prune-output "include" } diff --git a/libstdc++-v3/testsuite/29_atomics/atomic_integral/operators/bitwise_neg.cc b/libstdc++-v3/testsuite/29_atomics/atomic_integral/operators/bitwise_neg.cc index 2a112c95838..b2f1ea4e3bf 100644 --- a/libstdc++-v3/testsuite/29_atomics/atomic_integral/operators/bitwise_neg.cc +++ b/libstdc++-v3/testsuite/29_atomics/atomic_integral/operators/bitwise_neg.cc @@ -27,7 +27,7 @@ int main() return 0; } -// { dg-error "operator" "" { target *-*-* } 405 } -// { dg-error "operator" "" { target *-*-* } 406 } -// { dg-error "operator" "" { target *-*-* } 407 } +// { dg-error "operator" "" { target *-*-* } 427 } +// { dg-error "operator" "" { target *-*-* } 428 } +// { dg-error "operator" "" { target *-*-* } 429 } // { dg-excess-errors "In file included from" } diff --git a/libstdc++-v3/testsuite/29_atomics/atomic_integral/operators/decrement_neg.cc b/libstdc++-v3/testsuite/29_atomics/atomic_integral/operators/decrement_neg.cc index 974c947e664..dd84c836d9b 100644 --- a/libstdc++-v3/testsuite/29_atomics/atomic_integral/operators/decrement_neg.cc +++ b/libstdc++-v3/testsuite/29_atomics/atomic_integral/operators/decrement_neg.cc @@ -28,6 +28,6 @@ int main() return 0; } -// { dg-error "operator" "" { target *-*-* } 376 } -// { dg-error "operator" "" { target *-*-* } 377 } -// { dg-error "operator" "" { target *-*-* } 378 } +// { dg-error "operator" "" { target *-*-* } 384 } +// { dg-error "operator" "" { target *-*-* } 385 } +// { dg-error "operator" "" { target *-*-* } 386 } diff --git a/libstdc++-v3/testsuite/29_atomics/atomic_integral/operators/increment_neg.cc b/libstdc++-v3/testsuite/29_atomics/atomic_integral/operators/increment_neg.cc index 4927fcf1854..90b75556d18 100644 --- a/libstdc++-v3/testsuite/29_atomics/atomic_integral/operators/increment_neg.cc +++ b/libstdc++-v3/testsuite/29_atomics/atomic_integral/operators/increment_neg.cc @@ -28,6 +28,6 @@ int main() return 0; } -// { dg-error "operator" "" { target *-*-* } 354 } -// { dg-error "operator" "" { target *-*-* } 355 } -// { dg-error "operator" "" { target *-*-* } 356 } +// { dg-error "operator" "" { target *-*-* } 362 } +// { dg-error "operator" "" { target *-*-* } 363 } +// { dg-error "operator" "" { target *-*-* } 364 } diff --git a/libstdc++-v3/testsuite/29_atomics/headers/atomic/macros.cc b/libstdc++-v3/testsuite/29_atomics/headers/atomic/macros.cc index c0419c9b8d8..022cd90b250 100644 --- a/libstdc++-v3/testsuite/29_atomics/headers/atomic/macros.cc +++ b/libstdc++-v3/testsuite/29_atomics/headers/atomic/macros.cc @@ -1,7 +1,7 @@ // { dg-options "-std=gnu++0x" } // { dg-do compile } -// Copyright (C) 2008, 2009 Free Software Foundation, Inc. +// Copyright (C) 2008, 2009, 2010 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 @@ -22,24 +22,91 @@ namespace gnu { -#ifndef ATOMIC_INTEGRAL_LOCK_FREE -# error "ATOMIC_INTEGRAL_LOCK_FREE must be a macro" +#ifndef ATOMIC_CHAR_LOCK_FREE +# error "ATOMIC_CHAR_LOCK_FREE must be a macro" #else -# if ATOMIC_INTEGRAL_LOCK_FREE != 0 \ - && ATOMIC_INTEGRAL_LOCK_FREE != 1 && ATOMIC_INTEGRAL_LOCK_FREE != 2 -# error "ATOMIC_INTEGRAL_LOCK_FREE must be 0, 1, or 2" +# if ATOMIC_CHAR_LOCK_FREE != 0 \ + && ATOMIC_CHAR_LOCK_FREE != 1 && ATOMIC_CHAR_LOCK_FREE != 2 +# error "ATOMIC_CHAR_LOCK_FREE must be 0, 1, or 2" +# endif +#endif + +#ifndef ATOMIC_CHAR16_T_LOCK_FREE +# error "ATOMIC_CHAR16_T_LOCK_FREE must be a macro" +#else +# if ATOMIC_CHAR16_T_LOCK_FREE != 0 \ + && ATOMIC_CHAR16_T_LOCK_FREE != 1 && ATOMIC_CHAR16_T_LOCK_FREE != 2 +# error "ATOMIC_CHAR16_T_LOCK_FREE must be 0, 1, or 2" +# endif +#endif + +#ifndef ATOMIC_CHAR32_T_LOCK_FREE +# error "ATOMIC_CHAR32_T_LOCK_FREE must be a macro" +#else +# if ATOMIC_CHAR32_T_LOCK_FREE != 0 \ + && ATOMIC_CHAR32_T_LOCK_FREE != 1 && ATOMIC_CHAR32_T_LOCK_FREE != 2 +# error "ATOMIC_CHAR32_T_LOCK_FREE must be 0, 1, or 2" +# endif +#endif + +#ifndef ATOMIC_WCHAR_T_LOCK_FREE +# error "ATOMIC_WCHAR_T_LOCK_FREE must be a macro" +#else +# if ATOMIC_WCHAR_T_LOCK_FREE != 0 \ + && ATOMIC_WCHAR_T_LOCK_FREE != 1 && ATOMIC_WCHAR_T_LOCK_FREE != 2 +# error "ATOMIC_WCHAR_T_LOCK_FREE must be 0, 1, or 2" +# endif +#endif + +#ifndef ATOMIC_SHORT_LOCK_FREE +# error "ATOMIC_SHORT_LOCK_FREE must be a macro" +#else +# if ATOMIC_SHORT_LOCK_FREE != 0 \ + && ATOMIC_SHORT_LOCK_FREE != 1 && ATOMIC_SHORT_LOCK_FREE != 2 +# error "ATOMIC_SHORT_LOCK_FREE must be 0, 1, or 2" +# endif +#endif + +#ifndef ATOMIC_INT_LOCK_FREE +# error "ATOMIC_INT_LOCK_FREE must be a macro" +#else +# if ATOMIC_INT_LOCK_FREE != 0 \ + && ATOMIC_INT_LOCK_FREE != 1 && ATOMIC_INT_LOCK_FREE != 2 +# error "ATOMIC_INT_LOCK_FREE must be 0, 1, or 2" +# endif +#endif + +#ifndef ATOMIC_LONG_LOCK_FREE +# error "ATOMIC_LONG_LOCK_FREE must be a macro" +#else +# if ATOMIC_LONG_LOCK_FREE != 0 \ + && ATOMIC_LONG_LOCK_FREE != 1 && ATOMIC_LONG_LOCK_FREE != 2 +# error "ATOMIC_LONG_LOCK_FREE must be 0, 1, or 2" +# endif +#endif + +#ifndef ATOMIC_LLONG_LOCK_FREE +# error "ATOMIC_LLONG_LOCK_FREE must be a macro" +#else +# if ATOMIC_LLONG_LOCK_FREE != 0 \ + && ATOMIC_LLONG_LOCK_FREE != 1 && ATOMIC_LLONG_LOCK_FREE != 2 +# error "ATOMIC_LLONG_LOCK_FREE must be 0, 1, or 2" # endif #endif #ifndef ATOMIC_ADDRESS_LOCK_FREE # error "ATOMIC_ADDRESS_LOCK_FREE must be a macro" -# if ATOMIC_INTEGRAL_LOCK_FREE != 0 \ - && ATOMIC_INTEGRAL_LOCK_FREE != 1 && ATOMIC_INTEGRAL_LOCK_FREE != 2 -# error "ATOMIC_INTEGRAL_LOCK_FREE must be 0, 1, or 2" +# if ATOMIC_ADDRESS_LOCK_FREE != 0 \ + && ATOMIC_ADDRESS_LOCK_FREE != 1 && ATOMIC_ADDRESS_LOCK_FREE != 2 +# error "ATOMIC_ADDRESS_LOCK_FREE must be 0, 1, or 2" # endif #endif #ifndef ATOMIC_FLAG_INIT #error "ATOMIC_FLAG_INIT_must_be_a_macro" #endif + +#ifndef ATOMIC_VAR_INIT + #error "ATOMIC_VAR_INIT_must_be_a_macro" +#endif } diff --git a/libstdc++-v3/testsuite/29_atomics/headers/atomic/types_std_c++0x.cc b/libstdc++-v3/testsuite/29_atomics/headers/atomic/types_std_c++0x.cc index ce1e04359ad..13e4949e9b1 100644 --- a/libstdc++-v3/testsuite/29_atomics/headers/atomic/types_std_c++0x.cc +++ b/libstdc++-v3/testsuite/29_atomics/headers/atomic/types_std_c++0x.cc @@ -1,7 +1,7 @@ // { dg-options "-std=gnu++0x" } // { dg-do compile } -// Copyright (C) 2008, 2009 Free Software Foundation, Inc. +// Copyright (C) 2008, 2009, 2010 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 @@ -69,7 +69,6 @@ void test01() using std::atomic_intptr_t; using std::atomic_uintptr_t; using std::atomic_size_t; - using std::atomic_ssize_t; using std::atomic_ptrdiff_t; using std::atomic_intmax_t; using std::atomic_uintmax_t; diff --git a/libstdc++-v3/testsuite/29_atomics/headers/atomic/types_std_c++0x_neg.cc b/libstdc++-v3/testsuite/29_atomics/headers/atomic/types_std_c++0x_neg.cc index cbdb5e6fcb2..57907734304 100644 --- a/libstdc++-v3/testsuite/29_atomics/headers/atomic/types_std_c++0x_neg.cc +++ b/libstdc++-v3/testsuite/29_atomics/headers/atomic/types_std_c++0x_neg.cc @@ -1,7 +1,7 @@ // { dg-options "-std=gnu++0x" } // { dg-do compile } -// Copyright (C) 2009 Free Software Foundation, Inc. +// Copyright (C) 2009, 2010 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 @@ -49,6 +49,29 @@ void test01() using atomic_char16_t; using atomic_char32_t; + using atomic_int_least8_t; + using atomic_uint_least8_t; + using atomic_int_least16_t; + using atomic_uint_least16_t; + using atomic_int_least32_t; + using atomic_uint_least32_t; + using atomic_int_least64_t; + using atomic_uint_least64_t; + using atomic_int_fast8_t; + using atomic_uint_fast8_t; + using atomic_int_fast16_t; + using atomic_uint_fast16_t; + using atomic_int_fast32_t; + using atomic_uint_fast32_t; + using atomic_int_fast64_t; + using atomic_uint_fast64_t; + using atomic_intptr_t; + using atomic_uintptr_t; + using atomic_size_t; + using atomic_ptrdiff_t; + using atomic_intmax_t; + using atomic_uintmax_t; + using atomic_address; } @@ -76,3 +99,72 @@ void test01() // { dg-error "expected nested-name-specifier" "" { target *-*-* } 49 } // { dg-error "expected nested-name-specifier" "" { target *-*-* } 50 } // { dg-error "expected nested-name-specifier" "" { target *-*-* } 52 } +// { dg-error "expected nested-name-specifier" "" { target *-*-* } 53 } +// { dg-error "expected nested-name-specifier" "" { target *-*-* } 54 } +// { dg-error "expected nested-name-specifier" "" { target *-*-* } 55 } +// { dg-error "expected nested-name-specifier" "" { target *-*-* } 56 } +// { dg-error "expected nested-name-specifier" "" { target *-*-* } 57 } +// { dg-error "expected nested-name-specifier" "" { target *-*-* } 58 } +// { dg-error "expected nested-name-specifier" "" { target *-*-* } 59 } +// { dg-error "expected nested-name-specifier" "" { target *-*-* } 60 } +// { dg-error "expected nested-name-specifier" "" { target *-*-* } 61 } +// { dg-error "expected nested-name-specifier" "" { target *-*-* } 62 } +// { dg-error "expected nested-name-specifier" "" { target *-*-* } 63 } +// { dg-error "expected nested-name-specifier" "" { target *-*-* } 64 } +// { dg-error "expected nested-name-specifier" "" { target *-*-* } 65 } +// { dg-error "expected nested-name-specifier" "" { target *-*-* } 66 } +// { dg-error "expected nested-name-specifier" "" { target *-*-* } 67 } +// { dg-error "expected nested-name-specifier" "" { target *-*-* } 68 } +// { dg-error "expected nested-name-specifier" "" { target *-*-* } 69 } +// { dg-error "expected nested-name-specifier" "" { target *-*-* } 70 } +// { dg-error "expected nested-name-specifier" "" { target *-*-* } 71 } +// { dg-error "expected nested-name-specifier" "" { target *-*-* } 72 } +// { dg-error "expected nested-name-specifier" "" { target *-*-* } 73 } +// { dg-error "expected nested-name-specifier" "" { target *-*-* } 75 } + +// { dg-error "declared" "" { target *-*-* } 26 } +// { dg-error "declared" "" { target *-*-* } 27 } +// { dg-error "declared" "" { target *-*-* } 28 } +// { dg-error "declared" "" { target *-*-* } 29 } +// { dg-error "declared" "" { target *-*-* } 30 } +// { dg-error "declared" "" { target *-*-* } 31 } +// { dg-error "declared" "" { target *-*-* } 32 } +// { dg-error "declared" "" { target *-*-* } 34 } +// { dg-error "declared" "" { target *-*-* } 36 } +// { dg-error "declared" "" { target *-*-* } 37 } +// { dg-error "declared" "" { target *-*-* } 38 } +// { dg-error "declared" "" { target *-*-* } 39 } +// { dg-error "declared" "" { target *-*-* } 40 } +// { dg-error "declared" "" { target *-*-* } 41 } +// { dg-error "declared" "" { target *-*-* } 42 } +// { dg-error "declared" "" { target *-*-* } 43 } +// { dg-error "declared" "" { target *-*-* } 44 } +// { dg-error "declared" "" { target *-*-* } 45 } +// { dg-error "declared" "" { target *-*-* } 46 } +// { dg-error "declared" "" { target *-*-* } 47 } +// { dg-error "declared" "" { target *-*-* } 48 } +// { dg-error "declared" "" { target *-*-* } 49 } +// { dg-error "declared" "" { target *-*-* } 50 } +// { dg-error "declared" "" { target *-*-* } 52 } +// { dg-error "declared" "" { target *-*-* } 53 } +// { dg-error "declared" "" { target *-*-* } 54 } +// { dg-error "declared" "" { target *-*-* } 55 } +// { dg-error "declared" "" { target *-*-* } 56 } +// { dg-error "declared" "" { target *-*-* } 57 } +// { dg-error "declared" "" { target *-*-* } 58 } +// { dg-error "declared" "" { target *-*-* } 59 } +// { dg-error "declared" "" { target *-*-* } 60 } +// { dg-error "declared" "" { target *-*-* } 61 } +// { dg-error "declared" "" { target *-*-* } 62 } +// { dg-error "declared" "" { target *-*-* } 63 } +// { dg-error "declared" "" { target *-*-* } 64 } +// { dg-error "declared" "" { target *-*-* } 65 } +// { dg-error "declared" "" { target *-*-* } 66 } +// { dg-error "declared" "" { target *-*-* } 67 } +// { dg-error "declared" "" { target *-*-* } 68 } +// { dg-error "declared" "" { target *-*-* } 69 } +// { dg-error "declared" "" { target *-*-* } 70 } +// { dg-error "declared" "" { target *-*-* } 71 } +// { dg-error "declared" "" { target *-*-* } 72 } +// { dg-error "declared" "" { target *-*-* } 73 } +// { dg-error "declared" "" { target *-*-* } 75 } diff --git a/libstdc++-v3/testsuite/29_atomics/headers/stdatomic.h/macros.c b/libstdc++-v3/testsuite/29_atomics/headers/stdatomic.h/macros.c deleted file mode 100644 index 7d6992e4a38..00000000000 --- a/libstdc++-v3/testsuite/29_atomics/headers/stdatomic.h/macros.c +++ /dev/null @@ -1,114 +0,0 @@ -// { dg-options "-x c" } -// { dg-do compile } - -// Copyright (C) 2008, 2009 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. - -// You should have received a copy of the GNU General Public License along -// with this library; see the file COPYING3. If not see -// <http://www.gnu.org/licenses/>. - -#include <stdatomic.h> - -int main() -{ -#ifndef ATOMIC_INTEGRAL_LOCK_FREE - #error "ATOMIC_INTEGRAL_LOCK_FREE_must_be_a_macro" -#endif - -#ifndef ATOMIC_ADDRESS_LOCK_FREE - #error "ATOMIC_ADDRESS_LOCK_FREE_must_be_a_macro" -#endif - -#ifndef ATOMIC_FLAG_INIT - #error "ATOMIC_FLAG_INIT_must_be_a_macro" -#endif - -#ifndef atomic_is_lock_free - #error "atomic_is_lock_free_must_be_a_macro" -#endif - -#ifndef atomic_load - #error "atomic_load_must_be_a_macro" -#endif - -#ifndef atomic_load_explicit - #error "atomic_load_explicit_must_be_a_macro" -#endif - -#ifndef atomic_store_explicit - #error "atomic_store_explicit_must_be_a_macro" -#endif - -#ifndef atomic_store - #error "atomic_store_must_be_a_macro" -#endif - -#ifndef atomic_exchange_explicit - #error "atomic_exchange_explicit_must_be_a_macro" -#endif - -#ifndef atomic_exchange - #error "atomic_exchange_must_be_a_macro" -#endif - -#ifndef atomic_compare_exchange - #error "atomic_compare_exchange_must_be_a_macro" -#endif - -#ifndef atomic_compare_exchange_explicit - #error "atomic_compare_exchange_explicit_must_be_a_macro" -#endif - -#ifndef atomic_fetch_add_explicit - #error "atomic_fetch_add_explicit_must_be_a_macro" -#endif - -#ifndef atomic_fetch_add - #error "atomic_fetch_add_must_be_a_macro" -#endif - -#ifndef atomic_fetch_sub_explicit - #error "atomic_fetch_sub_explicit_must_be_a_macro" -#endif - -#ifndef atomic_fetch_sub - #error "atomic_fetch_sub_must_be_a_macro" -#endif - -#ifndef atomic_fetch_and_explicit - #error "atomic_fetch_and_explicit_must_be_a_macro" -#endif - -#ifndef atomic_fetch_and - #error "atomic_fetch_and_must_be_a_macro" -#endif - -#ifndef atomic_fetch_or_explicit - #error "atomic_fetch_or_explicit_must_be_a_macro" -#endif - -#ifndef atomic_fetch_or - #error "atomic_fetch_or_must_be_a_macro" -#endif - -#ifndef atomic_fetch_xor_explicit - #error "atomic_fetch_xor_explicit_must_be_a_macro" -#endif - -#ifndef atomic_fetch_xor - #error "atomic_fetch_xor_must_be_a_macro" -#endif - - return 0; -} diff --git a/libstdc++-v3/testsuite/29_atomics/headers/stdatomic.h/types.c b/libstdc++-v3/testsuite/29_atomics/headers/stdatomic.h/types.c deleted file mode 100644 index 48d6d926759..00000000000 --- a/libstdc++-v3/testsuite/29_atomics/headers/stdatomic.h/types.c +++ /dev/null @@ -1,77 +0,0 @@ -// { dg-options "-x c" } -// { dg-do compile } - -// Copyright (C) 2008, 2009 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. -// -// You should have received a copy of the GNU General Public License along -// with this library; see the file COPYING3. If not see -// <http://www.gnu.org/licenses/>. - -#include <stdatomic.h> - -void test01() -{ - typedef memory_order t_01; - memory_order t_02 __attribute__((unused)) = memory_order_relaxed; - memory_order t_03 __attribute__((unused)) = memory_order_acquire; - memory_order t_04 __attribute__((unused)) = memory_order_release; - memory_order t_05 __attribute__((unused)) = memory_order_acq_rel; - memory_order t_06 __attribute__((unused)) = memory_order_seq_cst; - - typedef atomic_flag t_07; - - // atomics for builtins types - typedef atomic_bool t_08; - typedef atomic_char t_09; - typedef atomic_schar t_10; - typedef atomic_uchar t_11; - typedef atomic_short t_12; - typedef atomic_ushort t_13; - typedef atomic_int t_14; - typedef atomic_uint t_15; - typedef atomic_long t_16; - typedef atomic_ulong t_17; - typedef atomic_llong t_18; - typedef atomic_ullong t_19; - typedef atomic_wchar_t t_20; - typedef atomic_char16_t t_21; - typedef atomic_char32_t t_22; - - // atomics for standard typedefs - typedef atomic_int_least8_t t_23; - typedef atomic_uint_least8_t t_24; - typedef atomic_int_least16_t t_25; - typedef atomic_uint_least16_t t_26; - typedef atomic_int_least32_t t_27; - typedef atomic_uint_least32_t t_28; - typedef atomic_int_least64_t t_29; - typedef atomic_uint_least64_t t_30; - typedef atomic_int_fast8_t t_31; - typedef atomic_uint_fast8_t t_32; - typedef atomic_int_fast16_t t_33; - typedef atomic_uint_fast16_t t_34; - typedef atomic_int_fast32_t t_35; - typedef atomic_uint_fast32_t t_36; - typedef atomic_int_fast64_t t_37; - typedef atomic_uint_fast64_t t_38; - typedef atomic_intptr_t t_39; - typedef atomic_uintptr_t t_40; - typedef atomic_size_t t_41; - typedef atomic_ssize_t t_42; - typedef atomic_ptrdiff_t t_43; - typedef atomic_intmax_t t_44; - typedef atomic_uintmax_t t_45; - - typedef atomic_address t_46; -} diff --git a/libstdc++-v3/testsuite/30_threads/call_once/constexpr.cc b/libstdc++-v3/testsuite/30_threads/call_once/constexpr.cc new file mode 100644 index 00000000000..9518b72ea92 --- /dev/null +++ b/libstdc++-v3/testsuite/30_threads/call_once/constexpr.cc @@ -0,0 +1,29 @@ +// { dg-do compile } +// { dg-options "-std=gnu++0x" } + +// Copyright (C) 2010 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. + +// You should have received a copy of the GNU General Public License along +// with this library; see the file COPYING3. If not see +// <http://www.gnu.org/licenses/>. + +#include <mutex> +#include <testsuite_common_types.h> + +int main() +{ + __gnu_test::constexpr_default_constructible test; + test.operator()<std::mutex>(); + return 0; +} diff --git a/libstdc++-v3/testsuite/30_threads/mutex/cons/constexpr.cc b/libstdc++-v3/testsuite/30_threads/mutex/cons/constexpr.cc new file mode 100644 index 00000000000..9518b72ea92 --- /dev/null +++ b/libstdc++-v3/testsuite/30_threads/mutex/cons/constexpr.cc @@ -0,0 +1,29 @@ +// { dg-do compile } +// { dg-options "-std=gnu++0x" } + +// Copyright (C) 2010 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. + +// You should have received a copy of the GNU General Public License along +// with this library; see the file COPYING3. If not see +// <http://www.gnu.org/licenses/>. + +#include <mutex> +#include <testsuite_common_types.h> + +int main() +{ + __gnu_test::constexpr_default_constructible test; + test.operator()<std::mutex>(); + return 0; +} diff --git a/libstdc++-v3/testsuite/30_threads/once_flag/cons/constexpr.cc b/libstdc++-v3/testsuite/30_threads/once_flag/cons/constexpr.cc new file mode 100644 index 00000000000..52f3b5d3d4d --- /dev/null +++ b/libstdc++-v3/testsuite/30_threads/once_flag/cons/constexpr.cc @@ -0,0 +1,29 @@ +// { dg-do compile } +// { dg-options "-std=gnu++0x" } + +// Copyright (C) 2010 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. + +// You should have received a copy of the GNU General Public License along +// with this library; see the file COPYING3. If not see +// <http://www.gnu.org/licenses/>. + +#include <mutex> +#include <testsuite_common_types.h> + +int main() +{ + __gnu_test::constexpr_default_constructible test; + test.operator()<std::once_flag>(); + return 0; +} diff --git a/libstdc++-v3/testsuite/ext/profile/mutex_extensions.cc b/libstdc++-v3/testsuite/ext/profile/mutex_extensions.cc index 471c4482b2d..7f8072427ca 100644 --- a/libstdc++-v3/testsuite/ext/profile/mutex_extensions.cc +++ b/libstdc++-v3/testsuite/ext/profile/mutex_extensions.cc @@ -22,4 +22,4 @@ #include <vector> -// { dg-error "Cannot use -D_GLIBCXX_PROFILE with " "" { target *-*-* } 196 } +// { dg-error "Cannot use -D_GLIBCXX_PROFILE with " "" { target *-*-* } 223 } diff --git a/libstdc++-v3/testsuite/tr1/4_metaprogramming/integral_constant/requirements/constexpr_data.cc b/libstdc++-v3/testsuite/tr1/4_metaprogramming/integral_constant/requirements/constexpr_data.cc new file mode 100644 index 00000000000..a44cace607c --- /dev/null +++ b/libstdc++-v3/testsuite/tr1/4_metaprogramming/integral_constant/requirements/constexpr_data.cc @@ -0,0 +1,52 @@ +// { dg-do compile } +// { dg-options "-std=gnu++0x" } + +// Copyright (C) 2010 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. + +// You should have received a copy of the GNU General Public License along +// with this library; see the file COPYING3. If not see +// <http://www.gnu.org/licenses/>. + +#include <type_traits> +#include <testsuite_common_types.h> + +namespace __gnu_test +{ + struct constexpr_member_data + { + template<typename _Ttesttype> + void + operator()() + { + struct _Concept + { + void __constraint() + { + constexpr auto v(_Ttesttype::value); + } + }; + + _Concept c; + c.__constraint(); + } + }; +} + +int main() +{ + __gnu_test::constexpr_member_data test; + test.operator()<std::integral_constant<unsigned short, 69>>(); + test.operator()<std::integral_constant<bool, true>>(); + return 0; +} diff --git a/libstdc++-v3/testsuite/util/testsuite_abi.cc b/libstdc++-v3/testsuite/util/testsuite_abi.cc index 4921716b75c..91f4aefde61 100644 --- a/libstdc++-v3/testsuite/util/testsuite_abi.cc +++ b/libstdc++-v3/testsuite/util/testsuite_abi.cc @@ -193,6 +193,7 @@ check_version(symbol& test, bool added) known_versions.push_back("GLIBCXX_3.4.13"); known_versions.push_back("GLIBCXX_3.4.14"); known_versions.push_back("GLIBCXX_3.4.15"); + known_versions.push_back("GLIBCXX_3.4.16"); known_versions.push_back("GLIBCXX_LDBL_3.4"); known_versions.push_back("GLIBCXX_LDBL_3.4.7"); known_versions.push_back("GLIBCXX_LDBL_3.4.10"); diff --git a/libstdc++-v3/testsuite/util/testsuite_common_types.h b/libstdc++-v3/testsuite/util/testsuite_common_types.h index 1db0ca08c79..4da2634367c 100644 --- a/libstdc++-v3/testsuite/util/testsuite_common_types.h +++ b/libstdc++-v3/testsuite/util/testsuite_common_types.h @@ -339,6 +339,14 @@ namespace __gnu_test typedef transform<integral_types::type, atomics>::type atomics_tl; #endif + template<typename Tp> + struct numeric_limits + { + typedef Tp value_type; + typedef std::numeric_limits<value_type> type; + }; + + typedef transform<integral_types::type, numeric_limits>::type limits_tl; struct has_increment_operators { @@ -384,6 +392,20 @@ namespace __gnu_test } }; +#ifdef __GXX_EXPERIMENTAL_CXX0X__ + template<typename _Tp> + void + constexpr_bitwise_operators() + { + constexpr _Tp a = _Tp(); + constexpr _Tp b = _Tp(); + constexpr _Tp c1 = a | b; + constexpr _Tp c2 = a & b; + constexpr _Tp c3 = a ^ b; + constexpr _Tp c4 = ~b; + } +#endif + template<typename _Tp> void bitwise_operators() @@ -588,6 +610,53 @@ namespace __gnu_test } }; + // Generator to test constexpr constructor +#ifdef __GXX_EXPERIMENTAL_CXX0X__ + // Generator to test default constructor. + struct constexpr_default_constructible + { + template<typename _Tp> + void + operator()() + { + struct _Concept + { + // Have to have user-defined default ctor for this to work. + void __constraint() + { constexpr _Tp __v; } + }; + + void (_Concept::*__x)() __attribute__((unused)) + = &_Concept::__constraint; + } + }; + + struct constexpr_single_value_constructible + { + template<typename _Ttesttype, typename _Tbasetype> + void + operator()() + { + struct _Concept + { + // Additional constraint on _Tbasetype needed. + // Either assume user-defined default ctor as per + // constexpr_default_constructible and provide no + // initializer, provide an initializer, or assume empty-list + // init-able. Choose the latter. + void __constraint() + { + constexpr _Tbasetype __v { }; + constexpr _Ttesttype __t(__v); + } + }; + + _Concept c; + c.__constraint(); + } + }; +#endif + // Generator to test direct list initialization #ifdef __GXX_EXPERIMENTAL_CXX0X__ struct direct_list_initializable |