From: Jonathan Wakely Date: Fri, 21 Oct 2016 15:32:25 +0000 (+0100) Subject: Split into smaller pieces X-Git-Url: https://git.libre-soc.org/?a=commitdiff_plain;h=c05986b936078409c99a8eb4ce81e371323132d0;p=gcc.git Split into smaller pieces * include/Makefile.am: Add and . Order alphabetically. * include/Makefile.in: Regenerate. * include/bits/refwrap.h: New header. (_Maybe_get_result_type,_Weak_result_type_impl, _Weak_result_type) (_Reference_wrapper_base_impl, _Reference_wrapper_base) (reference_wrapper, ref, cref): Move here from . * include/bits/shared_ptr_base.h: Include and instead of . * include/bits/std_function.h: New header. (_Maybe_unary_or_binary_function, bad_function_call) (__is_location_invariant, _Nocopy_types, _Any_data) (_Simple_type_wrapper, _Function_base, _Function_handler, function): Move here from . * include/bits/unique_ptr.h: Include . * include/std/functional: Include new headers and move components to them. * include/std/future: Include instead of . * include/std/mutex: Likewise. * include/std/regex: Likewise. * src/c++11/compatibility-thread-c++0x.cc: Include . * testsuite/20_util/default_delete/48631_neg.cc: Adjust dg-error line. * testsuite/20_util/default_delete/void_neg.cc: Likewise. * testsuite/20_util/unique_ptr/assign/48635_neg.cc: Adjust dg-error lines. * testsuite/20_util/unique_ptr/cons/cv_qual_neg.cc: Likewise. * testsuite/30_threads/packaged_task/49668.cc: Include . From-SVN: r241410 --- diff --git a/libstdc++-v3/ChangeLog b/libstdc++-v3/ChangeLog index 933d8d32e17..51e9653d521 100644 --- a/libstdc++-v3/ChangeLog +++ b/libstdc++-v3/ChangeLog @@ -1,5 +1,34 @@ 2016-10-21 Jonathan Wakely + * include/Makefile.am: Add and . + Order alphabetically. + * include/Makefile.in: Regenerate. + * include/bits/refwrap.h: New header. + (_Maybe_get_result_type,_Weak_result_type_impl, _Weak_result_type) + (_Reference_wrapper_base_impl, _Reference_wrapper_base) + (reference_wrapper, ref, cref): Move here from . + * include/bits/shared_ptr_base.h: Include and + instead of . + * include/bits/std_function.h: New header. + (_Maybe_unary_or_binary_function, bad_function_call) + (__is_location_invariant, _Nocopy_types, _Any_data) + (_Simple_type_wrapper, _Function_base, _Function_handler, function): + Move here from . + * include/bits/unique_ptr.h: Include . + * include/std/functional: Include new headers and move components to + them. + * include/std/future: Include instead of + . + * include/std/mutex: Likewise. + * include/std/regex: Likewise. + * src/c++11/compatibility-thread-c++0x.cc: Include . + * testsuite/20_util/default_delete/48631_neg.cc: Adjust dg-error line. + * testsuite/20_util/default_delete/void_neg.cc: Likewise. + * testsuite/20_util/unique_ptr/assign/48635_neg.cc: Adjust dg-error + lines. + * testsuite/20_util/unique_ptr/cons/cv_qual_neg.cc: Likewise. + * testsuite/30_threads/packaged_task/49668.cc: Include . + * libsupc++/exception_ptr.h (make_exception_ptr): Qualify new. * testsuite/18_support/exception_ptr/make_exception_ptr_2.cc: New test. @@ -3582,6 +3611,7 @@ * include/std/future: Include . * include/std/memory: Do not include . * include/std/mutex: [_GLIBCXX_HAVE_TLS]: Likewise. + * src/c++11/compatibility-thread-c++0x.cc: Include . * testsuite/20_util/shared_ptr/thread/default_weaktoshared.cc: Add missing includes. * testsuite/20_util/shared_ptr/thread/mutex_weaktoshared.cc: Likewise. diff --git a/libstdc++-v3/include/Makefile.am b/libstdc++-v3/include/Makefile.am index bb4a5329280..15a164e4969 100644 --- a/libstdc++-v3/include/Makefile.am +++ b/libstdc++-v3/include/Makefile.am @@ -140,6 +140,7 @@ bits_headers = \ ${bits_srcdir}/random.h \ ${bits_srcdir}/random.tcc \ ${bits_srcdir}/range_access.h \ + ${bits_srcdir}/refwrap.h \ ${bits_srcdir}/regex.h \ ${bits_srcdir}/regex.tcc \ ${bits_srcdir}/regex_constants.h \ @@ -152,14 +153,13 @@ bits_headers = \ ${bits_srcdir}/regex_compiler.tcc \ ${bits_srcdir}/regex_executor.h \ ${bits_srcdir}/regex_executor.tcc \ - ${bits_srcdir}/stream_iterator.h \ - ${bits_srcdir}/streambuf_iterator.h \ ${bits_srcdir}/shared_ptr.h \ ${bits_srcdir}/shared_ptr_atomic.h \ ${bits_srcdir}/shared_ptr_base.h \ ${bits_srcdir}/slice_array.h \ ${bits_srcdir}/sstream.tcc \ ${bits_srcdir}/std_abs.h \ + ${bits_srcdir}/std_function.h \ ${bits_srcdir}/std_mutex.h \ ${bits_srcdir}/stl_algo.h \ ${bits_srcdir}/stl_algobase.h \ @@ -186,6 +186,8 @@ bits_headers = \ ${bits_srcdir}/stl_tree.h \ ${bits_srcdir}/stl_uninitialized.h \ ${bits_srcdir}/stl_vector.h \ + ${bits_srcdir}/stream_iterator.h \ + ${bits_srcdir}/streambuf_iterator.h \ ${bits_srcdir}/streambuf.tcc \ ${bits_srcdir}/stringfwd.h \ ${bits_srcdir}/string_view.tcc \ diff --git a/libstdc++-v3/include/Makefile.in b/libstdc++-v3/include/Makefile.in index 3bef9d04537..1a8e2b2908e 100644 --- a/libstdc++-v3/include/Makefile.in +++ b/libstdc++-v3/include/Makefile.in @@ -431,6 +431,7 @@ bits_headers = \ ${bits_srcdir}/random.h \ ${bits_srcdir}/random.tcc \ ${bits_srcdir}/range_access.h \ + ${bits_srcdir}/refwrap.h \ ${bits_srcdir}/regex.h \ ${bits_srcdir}/regex.tcc \ ${bits_srcdir}/regex_constants.h \ @@ -443,14 +444,13 @@ bits_headers = \ ${bits_srcdir}/regex_compiler.tcc \ ${bits_srcdir}/regex_executor.h \ ${bits_srcdir}/regex_executor.tcc \ - ${bits_srcdir}/stream_iterator.h \ - ${bits_srcdir}/streambuf_iterator.h \ ${bits_srcdir}/shared_ptr.h \ ${bits_srcdir}/shared_ptr_atomic.h \ ${bits_srcdir}/shared_ptr_base.h \ ${bits_srcdir}/slice_array.h \ ${bits_srcdir}/sstream.tcc \ ${bits_srcdir}/std_abs.h \ + ${bits_srcdir}/std_function.h \ ${bits_srcdir}/std_mutex.h \ ${bits_srcdir}/stl_algo.h \ ${bits_srcdir}/stl_algobase.h \ @@ -477,6 +477,8 @@ bits_headers = \ ${bits_srcdir}/stl_tree.h \ ${bits_srcdir}/stl_uninitialized.h \ ${bits_srcdir}/stl_vector.h \ + ${bits_srcdir}/stream_iterator.h \ + ${bits_srcdir}/streambuf_iterator.h \ ${bits_srcdir}/streambuf.tcc \ ${bits_srcdir}/stringfwd.h \ ${bits_srcdir}/string_view.tcc \ diff --git a/libstdc++-v3/include/bits/refwrap.h b/libstdc++-v3/include/bits/refwrap.h new file mode 100644 index 00000000000..06948ff8d5c --- /dev/null +++ b/libstdc++-v3/include/bits/refwrap.h @@ -0,0 +1,383 @@ +// Implementation of std::reference_wrapper -*- C++ -*- + +// Copyright (C) 2004-2016 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 +// . + +/** @file include/bits/bind.h + * This is an internal header file, included by other library headers. + * Do not attempt to use it directly. @headername{functional} + */ + +#ifndef _GLIBCXX_REFWRAP_H +#define _GLIBCXX_REFWRAP_H 1 + +#pragma GCC system_header + +#if __cplusplus < 201103L +# include +#else + +#include +#include +#include // for unary_function and binary_function + +namespace std _GLIBCXX_VISIBILITY(default) +{ +_GLIBCXX_BEGIN_NAMESPACE_VERSION + + /// If we have found a result_type, extract it. + template> + struct _Maybe_get_result_type + { }; + + template + struct _Maybe_get_result_type<_Functor, + __void_t> + { typedef typename _Functor::result_type result_type; }; + + /** + * Base class for any function object that has a weak result type, as + * defined in 20.8.2 [func.require] of C++11. + */ + template + struct _Weak_result_type_impl + : _Maybe_get_result_type<_Functor> + { }; + + /// Retrieve the result type for a function type. + template + struct _Weak_result_type_impl<_Res(_ArgTypes...)> + { typedef _Res result_type; }; + + template + struct _Weak_result_type_impl<_Res(_ArgTypes......)> + { typedef _Res result_type; }; + + template + struct _Weak_result_type_impl<_Res(_ArgTypes...) const> + { typedef _Res result_type; }; + + template + struct _Weak_result_type_impl<_Res(_ArgTypes......) const> + { typedef _Res result_type; }; + + template + struct _Weak_result_type_impl<_Res(_ArgTypes...) volatile> + { typedef _Res result_type; }; + + template + struct _Weak_result_type_impl<_Res(_ArgTypes......) volatile> + { typedef _Res result_type; }; + + template + struct _Weak_result_type_impl<_Res(_ArgTypes...) const volatile> + { typedef _Res result_type; }; + + template + struct _Weak_result_type_impl<_Res(_ArgTypes......) const volatile> + { typedef _Res result_type; }; + + /// Retrieve the result type for a function reference. + template + struct _Weak_result_type_impl<_Res(&)(_ArgTypes...)> + { typedef _Res result_type; }; + + template + struct _Weak_result_type_impl<_Res(&)(_ArgTypes......)> + { typedef _Res result_type; }; + + /// Retrieve the result type for a function pointer. + template + struct _Weak_result_type_impl<_Res(*)(_ArgTypes...)> + { typedef _Res result_type; }; + + template + struct _Weak_result_type_impl<_Res(*)(_ArgTypes......)> + { typedef _Res result_type; }; + + /// Retrieve result type for a member function pointer. + template + struct _Weak_result_type_impl<_Res (_Class::*)(_ArgTypes...)> + { typedef _Res result_type; }; + + template + struct _Weak_result_type_impl<_Res (_Class::*)(_ArgTypes......)> + { typedef _Res result_type; }; + + /// Retrieve result type for a const member function pointer. + template + struct _Weak_result_type_impl<_Res (_Class::*)(_ArgTypes...) const> + { typedef _Res result_type; }; + + template + struct _Weak_result_type_impl<_Res (_Class::*)(_ArgTypes......) const> + { typedef _Res result_type; }; + + /// Retrieve result type for a volatile member function pointer. + template + struct _Weak_result_type_impl<_Res (_Class::*)(_ArgTypes...) volatile> + { typedef _Res result_type; }; + + template + struct _Weak_result_type_impl<_Res (_Class::*)(_ArgTypes......) volatile> + { typedef _Res result_type; }; + + /// Retrieve result type for a const volatile member function pointer. + template + struct _Weak_result_type_impl<_Res (_Class::*)(_ArgTypes...) + const volatile> + { typedef _Res result_type; }; + + template + struct _Weak_result_type_impl<_Res (_Class::*)(_ArgTypes......) + const volatile> + { typedef _Res result_type; }; + + /** + * Strip top-level cv-qualifiers from the function object and let + * _Weak_result_type_impl perform the real work. + */ + template + struct _Weak_result_type + : _Weak_result_type_impl::type> + { }; + + // Detect nested argument_type. + template> + struct _Refwrap_base_arg1 + { }; + + // Nested argument_type. + template + struct _Refwrap_base_arg1<_Tp, + __void_t> + { + typedef typename _Tp::argument_type argument_type; + }; + + // Detect nested first_argument_type and second_argument_type. + template> + struct _Refwrap_base_arg2 + { }; + + // Nested first_argument_type and second_argument_type. + template + struct _Refwrap_base_arg2<_Tp, + __void_t> + { + typedef typename _Tp::first_argument_type first_argument_type; + typedef typename _Tp::second_argument_type second_argument_type; + }; + + /** + * Derives from unary_function or binary_function when it + * can. Specializations handle all of the easy cases. The primary + * template determines what to do with a class type, which may + * derive from both unary_function and binary_function. + */ + template + struct _Reference_wrapper_base + : _Weak_result_type<_Tp>, _Refwrap_base_arg1<_Tp>, _Refwrap_base_arg2<_Tp> + { }; + + // - a function type (unary) + template + struct _Reference_wrapper_base<_Res(_T1)> + : unary_function<_T1, _Res> + { }; + + template + struct _Reference_wrapper_base<_Res(_T1) const> + : unary_function<_T1, _Res> + { }; + + template + struct _Reference_wrapper_base<_Res(_T1) volatile> + : unary_function<_T1, _Res> + { }; + + template + struct _Reference_wrapper_base<_Res(_T1) const volatile> + : unary_function<_T1, _Res> + { }; + + // - a function type (binary) + template + struct _Reference_wrapper_base<_Res(_T1, _T2)> + : binary_function<_T1, _T2, _Res> + { }; + + template + struct _Reference_wrapper_base<_Res(_T1, _T2) const> + : binary_function<_T1, _T2, _Res> + { }; + + template + struct _Reference_wrapper_base<_Res(_T1, _T2) volatile> + : binary_function<_T1, _T2, _Res> + { }; + + template + struct _Reference_wrapper_base<_Res(_T1, _T2) const volatile> + : binary_function<_T1, _T2, _Res> + { }; + + // - a function pointer type (unary) + template + struct _Reference_wrapper_base<_Res(*)(_T1)> + : unary_function<_T1, _Res> + { }; + + // - a function pointer type (binary) + template + struct _Reference_wrapper_base<_Res(*)(_T1, _T2)> + : binary_function<_T1, _T2, _Res> + { }; + + // - a pointer to member function type (unary, no qualifiers) + template + struct _Reference_wrapper_base<_Res (_T1::*)()> + : unary_function<_T1*, _Res> + { }; + + // - a pointer to member function type (binary, no qualifiers) + template + struct _Reference_wrapper_base<_Res (_T1::*)(_T2)> + : binary_function<_T1*, _T2, _Res> + { }; + + // - a pointer to member function type (unary, const) + template + struct _Reference_wrapper_base<_Res (_T1::*)() const> + : unary_function + { }; + + // - a pointer to member function type (binary, const) + template + struct _Reference_wrapper_base<_Res (_T1::*)(_T2) const> + : binary_function + { }; + + // - a pointer to member function type (unary, volatile) + template + struct _Reference_wrapper_base<_Res (_T1::*)() volatile> + : unary_function + { }; + + // - a pointer to member function type (binary, volatile) + template + struct _Reference_wrapper_base<_Res (_T1::*)(_T2) volatile> + : binary_function + { }; + + // - a pointer to member function type (unary, const volatile) + template + struct _Reference_wrapper_base<_Res (_T1::*)() const volatile> + : unary_function + { }; + + // - a pointer to member function type (binary, const volatile) + template + struct _Reference_wrapper_base<_Res (_T1::*)(_T2) const volatile> + : binary_function + { }; + + /** + * @brief Primary class template for reference_wrapper. + * @ingroup functors + * @{ + */ + template + class reference_wrapper + : public _Reference_wrapper_base::type> + { + _Tp* _M_data; + + public: + typedef _Tp type; + + reference_wrapper(_Tp& __indata) noexcept + : _M_data(std::__addressof(__indata)) + { } + + reference_wrapper(_Tp&&) = delete; + + reference_wrapper(const reference_wrapper&) = default; + + reference_wrapper& + operator=(const reference_wrapper&) = default; + + operator _Tp&() const noexcept + { return this->get(); } + + _Tp& + get() const noexcept + { return *_M_data; } + + template + typename result_of<_Tp&(_Args&&...)>::type + operator()(_Args&&... __args) const + { + return std::__invoke(get(), std::forward<_Args>(__args)...); + } + }; + + + /// Denotes a reference should be taken to a variable. + template + inline reference_wrapper<_Tp> + ref(_Tp& __t) noexcept + { return reference_wrapper<_Tp>(__t); } + + /// Denotes a const reference should be taken to a variable. + template + inline reference_wrapper + cref(const _Tp& __t) noexcept + { return reference_wrapper(__t); } + + template + void ref(const _Tp&&) = delete; + + template + void cref(const _Tp&&) = delete; + + /// Partial specialization. + template + inline reference_wrapper<_Tp> + ref(reference_wrapper<_Tp> __t) noexcept + { return ref(__t.get()); } + + /// Partial specialization. + template + inline reference_wrapper + cref(reference_wrapper<_Tp> __t) noexcept + { return cref(__t.get()); } + + // @} group functors + +_GLIBCXX_END_NAMESPACE_VERSION +} // namespace std + +#endif // C++11 + +#endif // _GLIBCXX_REFWRAP_H diff --git a/libstdc++-v3/include/bits/shared_ptr_base.h b/libstdc++-v3/include/bits/shared_ptr_base.h index c74c92ae730..1a9e3e901e9 100644 --- a/libstdc++-v3/include/bits/shared_ptr_base.h +++ b/libstdc++-v3/include/bits/shared_ptr_base.h @@ -49,11 +49,12 @@ #ifndef _SHARED_PTR_BASE_H #define _SHARED_PTR_BASE_H 1 -#include #if __cpp_rtti # include #endif #include +#include +#include #include namespace std _GLIBCXX_VISIBILITY(default) diff --git a/libstdc++-v3/include/bits/std_function.h b/libstdc++-v3/include/bits/std_function.h new file mode 100644 index 00000000000..97399a16d70 --- /dev/null +++ b/libstdc++-v3/include/bits/std_function.h @@ -0,0 +1,848 @@ +// Implementation of std::function -*- C++ -*- + +// Copyright (C) 2004-2016 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 +// . + +/** @file include/bits/function.h + * This is an internal header file, included by other library headers. + * Do not attempt to use it directly. @headername{functional} + */ + +#ifndef _GLIBCXX_STD_FUNCTION_H +#define _GLIBCXX_STD_FUNCTION_H 1 + +#pragma GCC system_header + +#if __cplusplus < 201103L +# include +#else + +#if __cpp_rtti +# include +#endif +#include +#include +#include +#include + +namespace std _GLIBCXX_VISIBILITY(default) +{ +_GLIBCXX_BEGIN_NAMESPACE_VERSION + + /** + * Derives from @c unary_function or @c binary_function, or perhaps + * nothing, depending on the number of arguments provided. The + * primary template is the basis case, which derives nothing. + */ + template + struct _Maybe_unary_or_binary_function { }; + + /// Derives from @c unary_function, as appropriate. + template + struct _Maybe_unary_or_binary_function<_Res, _T1> + : std::unary_function<_T1, _Res> { }; + + /// Derives from @c binary_function, as appropriate. + template + struct _Maybe_unary_or_binary_function<_Res, _T1, _T2> + : std::binary_function<_T1, _T2, _Res> { }; + + + /** + * @brief Exception class thrown when class template function's + * operator() is called with an empty target. + * @ingroup exceptions + */ + class bad_function_call : public std::exception + { + public: + virtual ~bad_function_call() noexcept; + + const char* what() const noexcept; + }; + + /** + * Trait identifying "location-invariant" types, meaning that the + * address of the object (or any of its members) will not escape. + * Trivially copyable types are location-invariant and users can + * specialize this trait for other types. + */ + template + struct __is_location_invariant + : is_trivially_copyable<_Tp>::type + { }; + + class _Undefined_class; + + union _Nocopy_types + { + void* _M_object; + const void* _M_const_object; + void (*_M_function_pointer)(); + void (_Undefined_class::*_M_member_pointer)(); + }; + + union [[gnu::may_alias]] _Any_data + { + void* _M_access() { return &_M_pod_data[0]; } + const void* _M_access() const { return &_M_pod_data[0]; } + + template + _Tp& + _M_access() + { return *static_cast<_Tp*>(_M_access()); } + + template + const _Tp& + _M_access() const + { return *static_cast(_M_access()); } + + _Nocopy_types _M_unused; + char _M_pod_data[sizeof(_Nocopy_types)]; + }; + + enum _Manager_operation + { + __get_type_info, + __get_functor_ptr, + __clone_functor, + __destroy_functor + }; + + // Simple type wrapper that helps avoid annoying const problems + // when casting between void pointers and pointers-to-pointers. + template + struct _Simple_type_wrapper + { + _Simple_type_wrapper(_Tp __value) : __value(__value) { } + + _Tp __value; + }; + + template + struct __is_location_invariant<_Simple_type_wrapper<_Tp> > + : __is_location_invariant<_Tp> + { }; + + template + class function; + + /// Base class of all polymorphic function object wrappers. + class _Function_base + { + public: + static const std::size_t _M_max_size = sizeof(_Nocopy_types); + static const std::size_t _M_max_align = __alignof__(_Nocopy_types); + + template + class _Base_manager + { + protected: + static const bool __stored_locally = + (__is_location_invariant<_Functor>::value + && sizeof(_Functor) <= _M_max_size + && __alignof__(_Functor) <= _M_max_align + && (_M_max_align % __alignof__(_Functor) == 0)); + + typedef integral_constant _Local_storage; + + // Retrieve a pointer to the function object + static _Functor* + _M_get_pointer(const _Any_data& __source) + { + const _Functor* __ptr = + __stored_locally? std::__addressof(__source._M_access<_Functor>()) + /* have stored a pointer */ : __source._M_access<_Functor*>(); + return const_cast<_Functor*>(__ptr); + } + + // Clone a location-invariant function object that fits within + // an _Any_data structure. + static void + _M_clone(_Any_data& __dest, const _Any_data& __source, true_type) + { + ::new (__dest._M_access()) _Functor(__source._M_access<_Functor>()); + } + + // Clone a function object that is not location-invariant or + // that cannot fit into an _Any_data structure. + static void + _M_clone(_Any_data& __dest, const _Any_data& __source, false_type) + { + __dest._M_access<_Functor*>() = + new _Functor(*__source._M_access<_Functor*>()); + } + + // Destroying a location-invariant object may still require + // destruction. + static void + _M_destroy(_Any_data& __victim, true_type) + { + __victim._M_access<_Functor>().~_Functor(); + } + + // Destroying an object located on the heap. + static void + _M_destroy(_Any_data& __victim, false_type) + { + delete __victim._M_access<_Functor*>(); + } + + public: + static bool + _M_manager(_Any_data& __dest, const _Any_data& __source, + _Manager_operation __op) + { + switch (__op) + { +#if __cpp_rtti + case __get_type_info: + __dest._M_access() = &typeid(_Functor); + break; +#endif + case __get_functor_ptr: + __dest._M_access<_Functor*>() = _M_get_pointer(__source); + break; + + case __clone_functor: + _M_clone(__dest, __source, _Local_storage()); + break; + + case __destroy_functor: + _M_destroy(__dest, _Local_storage()); + break; + } + return false; + } + + static void + _M_init_functor(_Any_data& __functor, _Functor&& __f) + { _M_init_functor(__functor, std::move(__f), _Local_storage()); } + + template + static bool + _M_not_empty_function(const function<_Signature>& __f) + { return static_cast(__f); } + + template + static bool + _M_not_empty_function(_Tp* __fp) + { return __fp != nullptr; } + + template + static bool + _M_not_empty_function(_Tp _Class::* __mp) + { return __mp != nullptr; } + + template + static bool + _M_not_empty_function(const _Tp&) + { return true; } + + private: + static void + _M_init_functor(_Any_data& __functor, _Functor&& __f, true_type) + { ::new (__functor._M_access()) _Functor(std::move(__f)); } + + static void + _M_init_functor(_Any_data& __functor, _Functor&& __f, false_type) + { __functor._M_access<_Functor*>() = new _Functor(std::move(__f)); } + }; + + template + class _Ref_manager : public _Base_manager<_Functor*> + { + typedef _Function_base::_Base_manager<_Functor*> _Base; + + public: + static bool + _M_manager(_Any_data& __dest, const _Any_data& __source, + _Manager_operation __op) + { + switch (__op) + { +#if __cpp_rtti + case __get_type_info: + __dest._M_access() = &typeid(_Functor); + break; +#endif + case __get_functor_ptr: + __dest._M_access<_Functor*>() = *_Base::_M_get_pointer(__source); + return is_const<_Functor>::value; + break; + + default: + _Base::_M_manager(__dest, __source, __op); + } + return false; + } + + static void + _M_init_functor(_Any_data& __functor, reference_wrapper<_Functor> __f) + { + _Base::_M_init_functor(__functor, std::__addressof(__f.get())); + } + }; + + _Function_base() : _M_manager(nullptr) { } + + ~_Function_base() + { + if (_M_manager) + _M_manager(_M_functor, _M_functor, __destroy_functor); + } + + + bool _M_empty() const { return !_M_manager; } + + typedef bool (*_Manager_type)(_Any_data&, const _Any_data&, + _Manager_operation); + + _Any_data _M_functor; + _Manager_type _M_manager; + }; + + template + class _Function_handler; + + template + class _Function_handler<_Res(_ArgTypes...), _Functor> + : public _Function_base::_Base_manager<_Functor> + { + typedef _Function_base::_Base_manager<_Functor> _Base; + + public: + static _Res + _M_invoke(const _Any_data& __functor, _ArgTypes&&... __args) + { + return (*_Base::_M_get_pointer(__functor))( + std::forward<_ArgTypes>(__args)...); + } + }; + + template + class _Function_handler + : public _Function_base::_Base_manager<_Functor> + { + typedef _Function_base::_Base_manager<_Functor> _Base; + + public: + static void + _M_invoke(const _Any_data& __functor, _ArgTypes&&... __args) + { + (*_Base::_M_get_pointer(__functor))( + std::forward<_ArgTypes>(__args)...); + } + }; + + template + class _Function_handler<_Res(_ArgTypes...), reference_wrapper<_Functor> > + : public _Function_base::_Ref_manager<_Functor> + { + typedef _Function_base::_Ref_manager<_Functor> _Base; + + public: + static _Res + _M_invoke(const _Any_data& __functor, _ArgTypes&&... __args) + { + return std::__invoke(**_Base::_M_get_pointer(__functor), + std::forward<_ArgTypes>(__args)...); + } + }; + + template + class _Function_handler > + : public _Function_base::_Ref_manager<_Functor> + { + typedef _Function_base::_Ref_manager<_Functor> _Base; + + public: + static void + _M_invoke(const _Any_data& __functor, _ArgTypes&&... __args) + { + std::__invoke(**_Base::_M_get_pointer(__functor), + std::forward<_ArgTypes>(__args)...); + } + }; + + template + class _Function_handler<_Res(_ArgTypes...), _Member _Class::*> + : public _Function_handler + { + typedef _Function_handler + _Base; + + public: + static _Res + _M_invoke(const _Any_data& __functor, _ArgTypes&&... __args) + { + return std::__invoke(_Base::_M_get_pointer(__functor)->__value, + std::forward<_ArgTypes>(__args)...); + } + }; + + template + class _Function_handler + : public _Function_base::_Base_manager< + _Simple_type_wrapper< _Member _Class::* > > + { + typedef _Member _Class::* _Functor; + typedef _Simple_type_wrapper<_Functor> _Wrapper; + typedef _Function_base::_Base_manager<_Wrapper> _Base; + + public: + static bool + _M_manager(_Any_data& __dest, const _Any_data& __source, + _Manager_operation __op) + { + switch (__op) + { +#if __cpp_rtti + case __get_type_info: + __dest._M_access() = &typeid(_Functor); + break; +#endif + case __get_functor_ptr: + __dest._M_access<_Functor*>() = + &_Base::_M_get_pointer(__source)->__value; + break; + + default: + _Base::_M_manager(__dest, __source, __op); + } + return false; + } + + static void + _M_invoke(const _Any_data& __functor, _ArgTypes&&... __args) + { + std::__invoke(_Base::_M_get_pointer(__functor)->__value, + std::forward<_ArgTypes>(__args)...); + } + }; + + template + using __check_func_return_type + = __or_, is_same<_From, _To>, is_convertible<_From, _To>>; + + /** + * @brief Primary class template for std::function. + * @ingroup functors + * + * Polymorphic function wrapper. + */ + template + class function<_Res(_ArgTypes...)> + : public _Maybe_unary_or_binary_function<_Res, _ArgTypes...>, + private _Function_base + { + typedef _Res _Signature_type(_ArgTypes...); + + template::type> + struct _Callable : __check_func_return_type<_Res2, _Res> { }; + + // Used so the return type convertibility checks aren't done when + // performing overload resolution for copy construction/assignment. + template + struct _Callable : false_type { }; + + template + using _Requires = typename enable_if<_Cond::value, _Tp>::type; + + public: + typedef _Res result_type; + + // [3.7.2.1] construct/copy/destroy + + /** + * @brief Default construct creates an empty function call wrapper. + * @post @c !(bool)*this + */ + function() noexcept + : _Function_base() { } + + /** + * @brief Creates an empty function call wrapper. + * @post @c !(bool)*this + */ + function(nullptr_t) noexcept + : _Function_base() { } + + /** + * @brief %Function copy constructor. + * @param __x A %function object with identical call signature. + * @post @c bool(*this) == bool(__x) + * + * The newly-created %function contains a copy of the target of @a + * __x (if it has one). + */ + function(const function& __x); + + /** + * @brief %Function move constructor. + * @param __x A %function object rvalue with identical call signature. + * + * The newly-created %function contains the target of @a __x + * (if it has one). + */ + function(function&& __x) : _Function_base() + { + __x.swap(*this); + } + + /** + * @brief Builds a %function that targets a copy of the incoming + * function object. + * @param __f A %function object that is callable with parameters of + * type @c T1, @c T2, ..., @c TN and returns a value convertible + * to @c Res. + * + * The newly-created %function object will target a copy of + * @a __f. If @a __f is @c reference_wrapper, then this function + * object will contain a reference to the function object @c + * __f.get(). If @a __f is a NULL function pointer or NULL + * pointer-to-member, the newly-created object will be empty. + * + * If @a __f is a non-NULL function pointer or an object of type @c + * reference_wrapper, this function will not throw. + */ + template>, void>, + typename = _Requires<_Callable<_Functor>, void>> + function(_Functor); + + /** + * @brief %Function assignment operator. + * @param __x A %function with identical call signature. + * @post @c (bool)*this == (bool)x + * @returns @c *this + * + * The target of @a __x is copied to @c *this. If @a __x has no + * target, then @c *this will be empty. + * + * If @a __x targets a function pointer or a reference to a function + * object, then this operation will not throw an %exception. + */ + function& + operator=(const function& __x) + { + function(__x).swap(*this); + return *this; + } + + /** + * @brief %Function move-assignment operator. + * @param __x A %function rvalue with identical call signature. + * @returns @c *this + * + * The target of @a __x is moved to @c *this. If @a __x has no + * target, then @c *this will be empty. + * + * If @a __x targets a function pointer or a reference to a function + * object, then this operation will not throw an %exception. + */ + function& + operator=(function&& __x) + { + function(std::move(__x)).swap(*this); + return *this; + } + + /** + * @brief %Function assignment to zero. + * @post @c !(bool)*this + * @returns @c *this + * + * The target of @c *this is deallocated, leaving it empty. + */ + function& + operator=(nullptr_t) noexcept + { + if (_M_manager) + { + _M_manager(_M_functor, _M_functor, __destroy_functor); + _M_manager = nullptr; + _M_invoker = nullptr; + } + return *this; + } + + /** + * @brief %Function assignment to a new target. + * @param __f A %function object that is callable with parameters of + * type @c T1, @c T2, ..., @c TN and returns a value convertible + * to @c Res. + * @return @c *this + * + * This %function object wrapper will target a copy of @a + * __f. If @a __f is @c reference_wrapper, then this function + * object will contain a reference to the function object @c + * __f.get(). If @a __f is a NULL function pointer or NULL + * pointer-to-member, @c this object will be empty. + * + * If @a __f is a non-NULL function pointer or an object of type @c + * reference_wrapper, this function will not throw. + */ + template + _Requires<_Callable::type>, function&> + operator=(_Functor&& __f) + { + function(std::forward<_Functor>(__f)).swap(*this); + return *this; + } + + /// @overload + template + function& + operator=(reference_wrapper<_Functor> __f) noexcept + { + function(__f).swap(*this); + return *this; + } + + // [3.7.2.2] function modifiers + + /** + * @brief Swap the targets of two %function objects. + * @param __x A %function with identical call signature. + * + * Swap the targets of @c this function object and @a __f. This + * function will not throw an %exception. + */ + void swap(function& __x) noexcept + { + std::swap(_M_functor, __x._M_functor); + std::swap(_M_manager, __x._M_manager); + std::swap(_M_invoker, __x._M_invoker); + } + + // [3.7.2.3] function capacity + + /** + * @brief Determine if the %function wrapper has a target. + * + * @return @c true when this %function object contains a target, + * or @c false when it is empty. + * + * This function will not throw an %exception. + */ + explicit operator bool() const noexcept + { return !_M_empty(); } + + // [3.7.2.4] function invocation + + /** + * @brief Invokes the function targeted by @c *this. + * @returns the result of the target. + * @throws bad_function_call when @c !(bool)*this + * + * The function call operator invokes the target function object + * stored by @c this. + */ + _Res operator()(_ArgTypes... __args) const; + +#if __cpp_rtti + // [3.7.2.5] function target access + /** + * @brief Determine the type of the target of this function object + * wrapper. + * + * @returns the type identifier of the target function object, or + * @c typeid(void) if @c !(bool)*this. + * + * This function will not throw an %exception. + */ + const type_info& target_type() const noexcept; + + /** + * @brief Access the stored target function object. + * + * @return Returns a pointer to the stored target function object, + * if @c typeid(Functor).equals(target_type()); otherwise, a NULL + * pointer. + * + * This function will not throw an %exception. + */ + template _Functor* target() noexcept; + + /// @overload + template const _Functor* target() const noexcept; +#endif + + private: + using _Invoker_type = _Res (*)(const _Any_data&, _ArgTypes&&...); + _Invoker_type _M_invoker; + }; + + // Out-of-line member definitions. + template + function<_Res(_ArgTypes...)>:: + function(const function& __x) + : _Function_base() + { + if (static_cast(__x)) + { + __x._M_manager(_M_functor, __x._M_functor, __clone_functor); + _M_invoker = __x._M_invoker; + _M_manager = __x._M_manager; + } + } + + template + template + function<_Res(_ArgTypes...)>:: + function(_Functor __f) + : _Function_base() + { + typedef _Function_handler<_Signature_type, _Functor> _My_handler; + + if (_My_handler::_M_not_empty_function(__f)) + { + _My_handler::_M_init_functor(_M_functor, std::move(__f)); + _M_invoker = &_My_handler::_M_invoke; + _M_manager = &_My_handler::_M_manager; + } + } + + template + _Res + function<_Res(_ArgTypes...)>:: + operator()(_ArgTypes... __args) const + { + if (_M_empty()) + __throw_bad_function_call(); + return _M_invoker(_M_functor, std::forward<_ArgTypes>(__args)...); + } + +#if __cpp_rtti + template + const type_info& + function<_Res(_ArgTypes...)>:: + target_type() const noexcept + { + if (_M_manager) + { + _Any_data __typeinfo_result; + _M_manager(__typeinfo_result, _M_functor, __get_type_info); + return *__typeinfo_result._M_access(); + } + else + return typeid(void); + } + + template + template + _Functor* + function<_Res(_ArgTypes...)>:: + target() noexcept + { + if (typeid(_Functor) == target_type() && _M_manager) + { + _Any_data __ptr; + if (_M_manager(__ptr, _M_functor, __get_functor_ptr) + && !is_const<_Functor>::value) + return 0; + else + return __ptr._M_access<_Functor*>(); + } + else + return 0; + } + + template + template + const _Functor* + function<_Res(_ArgTypes...)>:: + target() const noexcept + { + if (typeid(_Functor) == target_type() && _M_manager) + { + _Any_data __ptr; + _M_manager(__ptr, _M_functor, __get_functor_ptr); + return __ptr._M_access(); + } + else + return 0; + } +#endif + + // [20.7.15.2.6] null pointer comparisons + + /** + * @brief Compares a polymorphic function object wrapper against 0 + * (the NULL pointer). + * @returns @c true if the wrapper has no target, @c false otherwise + * + * This function will not throw an %exception. + */ + template + inline bool + operator==(const function<_Res(_Args...)>& __f, nullptr_t) noexcept + { return !static_cast(__f); } + + /// @overload + template + inline bool + operator==(nullptr_t, const function<_Res(_Args...)>& __f) noexcept + { return !static_cast(__f); } + + /** + * @brief Compares a polymorphic function object wrapper against 0 + * (the NULL pointer). + * @returns @c false if the wrapper has no target, @c true otherwise + * + * This function will not throw an %exception. + */ + template + inline bool + operator!=(const function<_Res(_Args...)>& __f, nullptr_t) noexcept + { return static_cast(__f); } + + /// @overload + template + inline bool + operator!=(nullptr_t, const function<_Res(_Args...)>& __f) noexcept + { return static_cast(__f); } + + + // [20.7.15.2.7] specialized algorithms + + /** + * @brief Swap the targets of two polymorphic function object wrappers. + * + * This function will not throw an %exception. + */ + // _GLIBCXX_RESOLVE_LIB_DEFECTS + // 2062. Effect contradictions w/o no-throw guarantee of std::function swaps + template + inline void + swap(function<_Res(_Args...)>& __x, function<_Res(_Args...)>& __y) noexcept + { __x.swap(__y); } + +_GLIBCXX_END_NAMESPACE_VERSION +} // namespace std + +#endif // C++11 + +#endif // _GLIBCXX_STD_FUNCTION_H diff --git a/libstdc++-v3/include/bits/unique_ptr.h b/libstdc++-v3/include/bits/unique_ptr.h index e32b6c959b3..996c9eac3c3 100644 --- a/libstdc++-v3/include/bits/unique_ptr.h +++ b/libstdc++-v3/include/bits/unique_ptr.h @@ -35,6 +35,7 @@ #include #include #include +#include namespace std _GLIBCXX_VISIBILITY(default) { diff --git a/libstdc++-v3/include/std/functional b/libstdc++-v3/include/std/functional index ad67a1d6dc0..24854c003ab 100644 --- a/libstdc++-v3/include/std/functional +++ b/libstdc++-v3/include/std/functional @@ -50,149 +50,24 @@ #if __cplusplus >= 201103L -#include #include #include #include -#include #include #include - +#include #if __cplusplus > 201402L -#include -#include -#include -#include -#include +# include +# include +# include +# include +# include #endif namespace std _GLIBCXX_VISIBILITY(default) { _GLIBCXX_BEGIN_NAMESPACE_VERSION - template - class _Mem_fn; - template - _Mem_fn<_Tp _Class::*> - mem_fn(_Tp _Class::*) noexcept; - - /// If we have found a result_type, extract it. - template> - struct _Maybe_get_result_type - { }; - - template - struct _Maybe_get_result_type<_Functor, - __void_t> - { typedef typename _Functor::result_type result_type; }; - - /** - * Base class for any function object that has a weak result type, as - * defined in 20.8.2 [func.require] of C++11. - */ - template - struct _Weak_result_type_impl - : _Maybe_get_result_type<_Functor> - { }; - - /// Retrieve the result type for a function type. - template - struct _Weak_result_type_impl<_Res(_ArgTypes...)> - { typedef _Res result_type; }; - - template - struct _Weak_result_type_impl<_Res(_ArgTypes......)> - { typedef _Res result_type; }; - - template - struct _Weak_result_type_impl<_Res(_ArgTypes...) const> - { typedef _Res result_type; }; - - template - struct _Weak_result_type_impl<_Res(_ArgTypes......) const> - { typedef _Res result_type; }; - - template - struct _Weak_result_type_impl<_Res(_ArgTypes...) volatile> - { typedef _Res result_type; }; - - template - struct _Weak_result_type_impl<_Res(_ArgTypes......) volatile> - { typedef _Res result_type; }; - - template - struct _Weak_result_type_impl<_Res(_ArgTypes...) const volatile> - { typedef _Res result_type; }; - - template - struct _Weak_result_type_impl<_Res(_ArgTypes......) const volatile> - { typedef _Res result_type; }; - - /// Retrieve the result type for a function reference. - template - struct _Weak_result_type_impl<_Res(&)(_ArgTypes...)> - { typedef _Res result_type; }; - - template - struct _Weak_result_type_impl<_Res(&)(_ArgTypes......)> - { typedef _Res result_type; }; - - /// Retrieve the result type for a function pointer. - template - struct _Weak_result_type_impl<_Res(*)(_ArgTypes...)> - { typedef _Res result_type; }; - - template - struct _Weak_result_type_impl<_Res(*)(_ArgTypes......)> - { typedef _Res result_type; }; - - /// Retrieve result type for a member function pointer. - template - struct _Weak_result_type_impl<_Res (_Class::*)(_ArgTypes...)> - { typedef _Res result_type; }; - - template - struct _Weak_result_type_impl<_Res (_Class::*)(_ArgTypes......)> - { typedef _Res result_type; }; - - /// Retrieve result type for a const member function pointer. - template - struct _Weak_result_type_impl<_Res (_Class::*)(_ArgTypes...) const> - { typedef _Res result_type; }; - - template - struct _Weak_result_type_impl<_Res (_Class::*)(_ArgTypes......) const> - { typedef _Res result_type; }; - - /// Retrieve result type for a volatile member function pointer. - template - struct _Weak_result_type_impl<_Res (_Class::*)(_ArgTypes...) volatile> - { typedef _Res result_type; }; - - template - struct _Weak_result_type_impl<_Res (_Class::*)(_ArgTypes......) volatile> - { typedef _Res result_type; }; - - /// Retrieve result type for a const volatile member function pointer. - template - struct _Weak_result_type_impl<_Res (_Class::*)(_ArgTypes...) - const volatile> - { typedef _Res result_type; }; - - template - struct _Weak_result_type_impl<_Res (_Class::*)(_ArgTypes......) - const volatile> - { typedef _Res result_type; }; - - /** - * Strip top-level cv-qualifiers from the function object and let - * _Weak_result_type_impl perform the real work. - */ - template - struct _Weak_result_type - : _Weak_result_type_impl::type> - { }; - #if __cplusplus > 201402L # define __cpp_lib_invoke 201411 @@ -207,220 +82,6 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION } #endif - // Detect nested argument_type. - template> - struct _Refwrap_base_arg1 - { }; - - // Nested argument_type. - template - struct _Refwrap_base_arg1<_Tp, - __void_t> - { - typedef typename _Tp::argument_type argument_type; - }; - - // Detect nested first_argument_type and second_argument_type. - template> - struct _Refwrap_base_arg2 - { }; - - // Nested first_argument_type and second_argument_type. - template - struct _Refwrap_base_arg2<_Tp, - __void_t> - { - typedef typename _Tp::first_argument_type first_argument_type; - typedef typename _Tp::second_argument_type second_argument_type; - }; - - /** - * Derives from unary_function or binary_function when it - * can. Specializations handle all of the easy cases. The primary - * template determines what to do with a class type, which may - * derive from both unary_function and binary_function. - */ - template - struct _Reference_wrapper_base - : _Weak_result_type<_Tp>, _Refwrap_base_arg1<_Tp>, _Refwrap_base_arg2<_Tp> - { }; - - // - a function type (unary) - template - struct _Reference_wrapper_base<_Res(_T1)> - : unary_function<_T1, _Res> - { }; - - template - struct _Reference_wrapper_base<_Res(_T1) const> - : unary_function<_T1, _Res> - { }; - - template - struct _Reference_wrapper_base<_Res(_T1) volatile> - : unary_function<_T1, _Res> - { }; - - template - struct _Reference_wrapper_base<_Res(_T1) const volatile> - : unary_function<_T1, _Res> - { }; - - // - a function type (binary) - template - struct _Reference_wrapper_base<_Res(_T1, _T2)> - : binary_function<_T1, _T2, _Res> - { }; - - template - struct _Reference_wrapper_base<_Res(_T1, _T2) const> - : binary_function<_T1, _T2, _Res> - { }; - - template - struct _Reference_wrapper_base<_Res(_T1, _T2) volatile> - : binary_function<_T1, _T2, _Res> - { }; - - template - struct _Reference_wrapper_base<_Res(_T1, _T2) const volatile> - : binary_function<_T1, _T2, _Res> - { }; - - // - a function pointer type (unary) - template - struct _Reference_wrapper_base<_Res(*)(_T1)> - : unary_function<_T1, _Res> - { }; - - // - a function pointer type (binary) - template - struct _Reference_wrapper_base<_Res(*)(_T1, _T2)> - : binary_function<_T1, _T2, _Res> - { }; - - // - a pointer to member function type (unary, no qualifiers) - template - struct _Reference_wrapper_base<_Res (_T1::*)()> - : unary_function<_T1*, _Res> - { }; - - // - a pointer to member function type (binary, no qualifiers) - template - struct _Reference_wrapper_base<_Res (_T1::*)(_T2)> - : binary_function<_T1*, _T2, _Res> - { }; - - // - a pointer to member function type (unary, const) - template - struct _Reference_wrapper_base<_Res (_T1::*)() const> - : unary_function - { }; - - // - a pointer to member function type (binary, const) - template - struct _Reference_wrapper_base<_Res (_T1::*)(_T2) const> - : binary_function - { }; - - // - a pointer to member function type (unary, volatile) - template - struct _Reference_wrapper_base<_Res (_T1::*)() volatile> - : unary_function - { }; - - // - a pointer to member function type (binary, volatile) - template - struct _Reference_wrapper_base<_Res (_T1::*)(_T2) volatile> - : binary_function - { }; - - // - a pointer to member function type (unary, const volatile) - template - struct _Reference_wrapper_base<_Res (_T1::*)() const volatile> - : unary_function - { }; - - // - a pointer to member function type (binary, const volatile) - template - struct _Reference_wrapper_base<_Res (_T1::*)(_T2) const volatile> - : binary_function - { }; - - /** - * @brief Primary class template for reference_wrapper. - * @ingroup functors - * @{ - */ - template - class reference_wrapper - : public _Reference_wrapper_base::type> - { - _Tp* _M_data; - - public: - typedef _Tp type; - - reference_wrapper(_Tp& __indata) noexcept - : _M_data(std::__addressof(__indata)) - { } - - reference_wrapper(_Tp&&) = delete; - - reference_wrapper(const reference_wrapper&) = default; - - reference_wrapper& - operator=(const reference_wrapper&) = default; - - operator _Tp&() const noexcept - { return this->get(); } - - _Tp& - get() const noexcept - { return *_M_data; } - - template - typename result_of<_Tp&(_Args&&...)>::type - operator()(_Args&&... __args) const - { - return std::__invoke(get(), std::forward<_Args>(__args)...); - } - }; - - - /// Denotes a reference should be taken to a variable. - template - inline reference_wrapper<_Tp> - ref(_Tp& __t) noexcept - { return reference_wrapper<_Tp>(__t); } - - /// Denotes a const reference should be taken to a variable. - template - inline reference_wrapper - cref(const _Tp& __t) noexcept - { return reference_wrapper(__t); } - - template - void ref(const _Tp&&) = delete; - - template - void cref(const _Tp&&) = delete; - - /// Partial specialization. - template - inline reference_wrapper<_Tp> - ref(reference_wrapper<_Tp> __t) noexcept - { return ref(__t.get()); } - - /// Partial specialization. - template - inline reference_wrapper - cref(reference_wrapper<_Tp> __t) noexcept - { return cref(__t.get()); } - - // @} group functors - template struct _Pack : integral_constant { }; @@ -438,24 +99,6 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION using _NotSame = __not_::type, typename std::decay<_Tp2>::type>>; - /** - * Derives from @c unary_function or @c binary_function, or perhaps - * nothing, depending on the number of arguments provided. The - * primary template is the basis case, which derives nothing. - */ - template - struct _Maybe_unary_or_binary_function { }; - - /// Derives from @c unary_function, as appropriate. - template - struct _Maybe_unary_or_binary_function<_Res, _T1> - : std::unary_function<_T1, _Res> { }; - - /// Derives from @c binary_function, as appropriate. - template - struct _Maybe_unary_or_binary_function<_Res, _T1, _T2> - : std::binary_function<_T1, _T2, _Res> { }; - template struct _Mem_fn_traits; @@ -550,6 +193,9 @@ _GLIBCXX_MEM_FN_TRAITS(&&, false_type, true_type) { return std::__invoke(_M_pm, std::forward<_Tp>(__obj)); } }; + template + struct _Mem_fn; // undefined + template struct _Mem_fn<_Res _Class::*> : _Mem_fn_base<_Res _Class::*> @@ -1251,778 +897,6 @@ _GLIBCXX_MEM_FN_TRAITS(&&, false_type, true_type) std::forward<_BoundArgs>(__args)...); } - /** - * @brief Exception class thrown when class template function's - * operator() is called with an empty target. - * @ingroup exceptions - */ - class bad_function_call : public std::exception - { - public: - virtual ~bad_function_call() noexcept; - - const char* what() const noexcept; - }; - - /** - * Trait identifying "location-invariant" types, meaning that the - * address of the object (or any of its members) will not escape. - * Trivially copyable types are location-invariant and users can - * specialize this trait for other types. - */ - template - struct __is_location_invariant - : is_trivially_copyable<_Tp>::type - { }; - - class _Undefined_class; - - union _Nocopy_types - { - void* _M_object; - const void* _M_const_object; - void (*_M_function_pointer)(); - void (_Undefined_class::*_M_member_pointer)(); - }; - - union [[gnu::may_alias]] _Any_data - { - void* _M_access() { return &_M_pod_data[0]; } - const void* _M_access() const { return &_M_pod_data[0]; } - - template - _Tp& - _M_access() - { return *static_cast<_Tp*>(_M_access()); } - - template - const _Tp& - _M_access() const - { return *static_cast(_M_access()); } - - _Nocopy_types _M_unused; - char _M_pod_data[sizeof(_Nocopy_types)]; - }; - - enum _Manager_operation - { - __get_type_info, - __get_functor_ptr, - __clone_functor, - __destroy_functor - }; - - // Simple type wrapper that helps avoid annoying const problems - // when casting between void pointers and pointers-to-pointers. - template - struct _Simple_type_wrapper - { - _Simple_type_wrapper(_Tp __value) : __value(__value) { } - - _Tp __value; - }; - - template - struct __is_location_invariant<_Simple_type_wrapper<_Tp> > - : __is_location_invariant<_Tp> - { }; - - template - class function; - - /// Base class of all polymorphic function object wrappers. - class _Function_base - { - public: - static const std::size_t _M_max_size = sizeof(_Nocopy_types); - static const std::size_t _M_max_align = __alignof__(_Nocopy_types); - - template - class _Base_manager - { - protected: - static const bool __stored_locally = - (__is_location_invariant<_Functor>::value - && sizeof(_Functor) <= _M_max_size - && __alignof__(_Functor) <= _M_max_align - && (_M_max_align % __alignof__(_Functor) == 0)); - - typedef integral_constant _Local_storage; - - // Retrieve a pointer to the function object - static _Functor* - _M_get_pointer(const _Any_data& __source) - { - const _Functor* __ptr = - __stored_locally? std::__addressof(__source._M_access<_Functor>()) - /* have stored a pointer */ : __source._M_access<_Functor*>(); - return const_cast<_Functor*>(__ptr); - } - - // Clone a location-invariant function object that fits within - // an _Any_data structure. - static void - _M_clone(_Any_data& __dest, const _Any_data& __source, true_type) - { - ::new (__dest._M_access()) _Functor(__source._M_access<_Functor>()); - } - - // Clone a function object that is not location-invariant or - // that cannot fit into an _Any_data structure. - static void - _M_clone(_Any_data& __dest, const _Any_data& __source, false_type) - { - __dest._M_access<_Functor*>() = - new _Functor(*__source._M_access<_Functor*>()); - } - - // Destroying a location-invariant object may still require - // destruction. - static void - _M_destroy(_Any_data& __victim, true_type) - { - __victim._M_access<_Functor>().~_Functor(); - } - - // Destroying an object located on the heap. - static void - _M_destroy(_Any_data& __victim, false_type) - { - delete __victim._M_access<_Functor*>(); - } - - public: - static bool - _M_manager(_Any_data& __dest, const _Any_data& __source, - _Manager_operation __op) - { - switch (__op) - { -#if __cpp_rtti - case __get_type_info: - __dest._M_access() = &typeid(_Functor); - break; -#endif - case __get_functor_ptr: - __dest._M_access<_Functor*>() = _M_get_pointer(__source); - break; - - case __clone_functor: - _M_clone(__dest, __source, _Local_storage()); - break; - - case __destroy_functor: - _M_destroy(__dest, _Local_storage()); - break; - } - return false; - } - - static void - _M_init_functor(_Any_data& __functor, _Functor&& __f) - { _M_init_functor(__functor, std::move(__f), _Local_storage()); } - - template - static bool - _M_not_empty_function(const function<_Signature>& __f) - { return static_cast(__f); } - - template - static bool - _M_not_empty_function(_Tp* __fp) - { return __fp != nullptr; } - - template - static bool - _M_not_empty_function(_Tp _Class::* __mp) - { return __mp != nullptr; } - - template - static bool - _M_not_empty_function(const _Tp&) - { return true; } - - private: - static void - _M_init_functor(_Any_data& __functor, _Functor&& __f, true_type) - { ::new (__functor._M_access()) _Functor(std::move(__f)); } - - static void - _M_init_functor(_Any_data& __functor, _Functor&& __f, false_type) - { __functor._M_access<_Functor*>() = new _Functor(std::move(__f)); } - }; - - template - class _Ref_manager : public _Base_manager<_Functor*> - { - typedef _Function_base::_Base_manager<_Functor*> _Base; - - public: - static bool - _M_manager(_Any_data& __dest, const _Any_data& __source, - _Manager_operation __op) - { - switch (__op) - { -#if __cpp_rtti - case __get_type_info: - __dest._M_access() = &typeid(_Functor); - break; -#endif - case __get_functor_ptr: - __dest._M_access<_Functor*>() = *_Base::_M_get_pointer(__source); - return is_const<_Functor>::value; - break; - - default: - _Base::_M_manager(__dest, __source, __op); - } - return false; - } - - static void - _M_init_functor(_Any_data& __functor, reference_wrapper<_Functor> __f) - { - _Base::_M_init_functor(__functor, std::__addressof(__f.get())); - } - }; - - _Function_base() : _M_manager(nullptr) { } - - ~_Function_base() - { - if (_M_manager) - _M_manager(_M_functor, _M_functor, __destroy_functor); - } - - - bool _M_empty() const { return !_M_manager; } - - typedef bool (*_Manager_type)(_Any_data&, const _Any_data&, - _Manager_operation); - - _Any_data _M_functor; - _Manager_type _M_manager; - }; - - template - class _Function_handler; - - template - class _Function_handler<_Res(_ArgTypes...), _Functor> - : public _Function_base::_Base_manager<_Functor> - { - typedef _Function_base::_Base_manager<_Functor> _Base; - - public: - static _Res - _M_invoke(const _Any_data& __functor, _ArgTypes&&... __args) - { - return (*_Base::_M_get_pointer(__functor))( - std::forward<_ArgTypes>(__args)...); - } - }; - - template - class _Function_handler - : public _Function_base::_Base_manager<_Functor> - { - typedef _Function_base::_Base_manager<_Functor> _Base; - - public: - static void - _M_invoke(const _Any_data& __functor, _ArgTypes&&... __args) - { - (*_Base::_M_get_pointer(__functor))( - std::forward<_ArgTypes>(__args)...); - } - }; - - template - class _Function_handler<_Res(_ArgTypes...), reference_wrapper<_Functor> > - : public _Function_base::_Ref_manager<_Functor> - { - typedef _Function_base::_Ref_manager<_Functor> _Base; - - public: - static _Res - _M_invoke(const _Any_data& __functor, _ArgTypes&&... __args) - { - return std::__invoke(**_Base::_M_get_pointer(__functor), - std::forward<_ArgTypes>(__args)...); - } - }; - - template - class _Function_handler > - : public _Function_base::_Ref_manager<_Functor> - { - typedef _Function_base::_Ref_manager<_Functor> _Base; - - public: - static void - _M_invoke(const _Any_data& __functor, _ArgTypes&&... __args) - { - std::__invoke(**_Base::_M_get_pointer(__functor), - std::forward<_ArgTypes>(__args)...); - } - }; - - template - class _Function_handler<_Res(_ArgTypes...), _Member _Class::*> - : public _Function_handler - { - typedef _Function_handler - _Base; - - public: - static _Res - _M_invoke(const _Any_data& __functor, _ArgTypes&&... __args) - { - return std::__invoke(_Base::_M_get_pointer(__functor)->__value, - std::forward<_ArgTypes>(__args)...); - } - }; - - template - class _Function_handler - : public _Function_base::_Base_manager< - _Simple_type_wrapper< _Member _Class::* > > - { - typedef _Member _Class::* _Functor; - typedef _Simple_type_wrapper<_Functor> _Wrapper; - typedef _Function_base::_Base_manager<_Wrapper> _Base; - - public: - static bool - _M_manager(_Any_data& __dest, const _Any_data& __source, - _Manager_operation __op) - { - switch (__op) - { -#if __cpp_rtti - case __get_type_info: - __dest._M_access() = &typeid(_Functor); - break; -#endif - case __get_functor_ptr: - __dest._M_access<_Functor*>() = - &_Base::_M_get_pointer(__source)->__value; - break; - - default: - _Base::_M_manager(__dest, __source, __op); - } - return false; - } - - static void - _M_invoke(const _Any_data& __functor, _ArgTypes&&... __args) - { - std::__invoke(_Base::_M_get_pointer(__functor)->__value, - std::forward<_ArgTypes>(__args)...); - } - }; - - template - using __check_func_return_type - = __or_, is_same<_From, _To>, is_convertible<_From, _To>>; - - /** - * @brief Primary class template for std::function. - * @ingroup functors - * - * Polymorphic function wrapper. - */ - template - class function<_Res(_ArgTypes...)> - : public _Maybe_unary_or_binary_function<_Res, _ArgTypes...>, - private _Function_base - { - typedef _Res _Signature_type(_ArgTypes...); - - template::type> - struct _Callable : __check_func_return_type<_Res2, _Res> { }; - - // Used so the return type convertibility checks aren't done when - // performing overload resolution for copy construction/assignment. - template - struct _Callable : false_type { }; - - template - using _Requires = typename enable_if<_Cond::value, _Tp>::type; - - public: - typedef _Res result_type; - - // [3.7.2.1] construct/copy/destroy - - /** - * @brief Default construct creates an empty function call wrapper. - * @post @c !(bool)*this - */ - function() noexcept - : _Function_base() { } - - /** - * @brief Creates an empty function call wrapper. - * @post @c !(bool)*this - */ - function(nullptr_t) noexcept - : _Function_base() { } - - /** - * @brief %Function copy constructor. - * @param __x A %function object with identical call signature. - * @post @c bool(*this) == bool(__x) - * - * The newly-created %function contains a copy of the target of @a - * __x (if it has one). - */ - function(const function& __x); - - /** - * @brief %Function move constructor. - * @param __x A %function object rvalue with identical call signature. - * - * The newly-created %function contains the target of @a __x - * (if it has one). - */ - function(function&& __x) : _Function_base() - { - __x.swap(*this); - } - - /** - * @brief Builds a %function that targets a copy of the incoming - * function object. - * @param __f A %function object that is callable with parameters of - * type @c T1, @c T2, ..., @c TN and returns a value convertible - * to @c Res. - * - * The newly-created %function object will target a copy of - * @a __f. If @a __f is @c reference_wrapper, then this function - * object will contain a reference to the function object @c - * __f.get(). If @a __f is a NULL function pointer or NULL - * pointer-to-member, the newly-created object will be empty. - * - * If @a __f is a non-NULL function pointer or an object of type @c - * reference_wrapper, this function will not throw. - */ - template>, void>, - typename = _Requires<_Callable<_Functor>, void>> - function(_Functor); - - /** - * @brief %Function assignment operator. - * @param __x A %function with identical call signature. - * @post @c (bool)*this == (bool)x - * @returns @c *this - * - * The target of @a __x is copied to @c *this. If @a __x has no - * target, then @c *this will be empty. - * - * If @a __x targets a function pointer or a reference to a function - * object, then this operation will not throw an %exception. - */ - function& - operator=(const function& __x) - { - function(__x).swap(*this); - return *this; - } - - /** - * @brief %Function move-assignment operator. - * @param __x A %function rvalue with identical call signature. - * @returns @c *this - * - * The target of @a __x is moved to @c *this. If @a __x has no - * target, then @c *this will be empty. - * - * If @a __x targets a function pointer or a reference to a function - * object, then this operation will not throw an %exception. - */ - function& - operator=(function&& __x) - { - function(std::move(__x)).swap(*this); - return *this; - } - - /** - * @brief %Function assignment to zero. - * @post @c !(bool)*this - * @returns @c *this - * - * The target of @c *this is deallocated, leaving it empty. - */ - function& - operator=(nullptr_t) noexcept - { - if (_M_manager) - { - _M_manager(_M_functor, _M_functor, __destroy_functor); - _M_manager = nullptr; - _M_invoker = nullptr; - } - return *this; - } - - /** - * @brief %Function assignment to a new target. - * @param __f A %function object that is callable with parameters of - * type @c T1, @c T2, ..., @c TN and returns a value convertible - * to @c Res. - * @return @c *this - * - * This %function object wrapper will target a copy of @a - * __f. If @a __f is @c reference_wrapper, then this function - * object will contain a reference to the function object @c - * __f.get(). If @a __f is a NULL function pointer or NULL - * pointer-to-member, @c this object will be empty. - * - * If @a __f is a non-NULL function pointer or an object of type @c - * reference_wrapper, this function will not throw. - */ - template - _Requires<_Callable::type>, function&> - operator=(_Functor&& __f) - { - function(std::forward<_Functor>(__f)).swap(*this); - return *this; - } - - /// @overload - template - function& - operator=(reference_wrapper<_Functor> __f) noexcept - { - function(__f).swap(*this); - return *this; - } - - // [3.7.2.2] function modifiers - - /** - * @brief Swap the targets of two %function objects. - * @param __x A %function with identical call signature. - * - * Swap the targets of @c this function object and @a __f. This - * function will not throw an %exception. - */ - void swap(function& __x) noexcept - { - std::swap(_M_functor, __x._M_functor); - std::swap(_M_manager, __x._M_manager); - std::swap(_M_invoker, __x._M_invoker); - } - - // [3.7.2.3] function capacity - - /** - * @brief Determine if the %function wrapper has a target. - * - * @return @c true when this %function object contains a target, - * or @c false when it is empty. - * - * This function will not throw an %exception. - */ - explicit operator bool() const noexcept - { return !_M_empty(); } - - // [3.7.2.4] function invocation - - /** - * @brief Invokes the function targeted by @c *this. - * @returns the result of the target. - * @throws bad_function_call when @c !(bool)*this - * - * The function call operator invokes the target function object - * stored by @c this. - */ - _Res operator()(_ArgTypes... __args) const; - -#if __cpp_rtti - // [3.7.2.5] function target access - /** - * @brief Determine the type of the target of this function object - * wrapper. - * - * @returns the type identifier of the target function object, or - * @c typeid(void) if @c !(bool)*this. - * - * This function will not throw an %exception. - */ - const type_info& target_type() const noexcept; - - /** - * @brief Access the stored target function object. - * - * @return Returns a pointer to the stored target function object, - * if @c typeid(Functor).equals(target_type()); otherwise, a NULL - * pointer. - * - * This function will not throw an %exception. - */ - template _Functor* target() noexcept; - - /// @overload - template const _Functor* target() const noexcept; -#endif - - private: - using _Invoker_type = _Res (*)(const _Any_data&, _ArgTypes&&...); - _Invoker_type _M_invoker; - }; - - // Out-of-line member definitions. - template - function<_Res(_ArgTypes...)>:: - function(const function& __x) - : _Function_base() - { - if (static_cast(__x)) - { - __x._M_manager(_M_functor, __x._M_functor, __clone_functor); - _M_invoker = __x._M_invoker; - _M_manager = __x._M_manager; - } - } - - template - template - function<_Res(_ArgTypes...)>:: - function(_Functor __f) - : _Function_base() - { - typedef _Function_handler<_Signature_type, _Functor> _My_handler; - - if (_My_handler::_M_not_empty_function(__f)) - { - _My_handler::_M_init_functor(_M_functor, std::move(__f)); - _M_invoker = &_My_handler::_M_invoke; - _M_manager = &_My_handler::_M_manager; - } - } - - template - _Res - function<_Res(_ArgTypes...)>:: - operator()(_ArgTypes... __args) const - { - if (_M_empty()) - __throw_bad_function_call(); - return _M_invoker(_M_functor, std::forward<_ArgTypes>(__args)...); - } - -#if __cpp_rtti - template - const type_info& - function<_Res(_ArgTypes...)>:: - target_type() const noexcept - { - if (_M_manager) - { - _Any_data __typeinfo_result; - _M_manager(__typeinfo_result, _M_functor, __get_type_info); - return *__typeinfo_result._M_access(); - } - else - return typeid(void); - } - - template - template - _Functor* - function<_Res(_ArgTypes...)>:: - target() noexcept - { - if (typeid(_Functor) == target_type() && _M_manager) - { - _Any_data __ptr; - if (_M_manager(__ptr, _M_functor, __get_functor_ptr) - && !is_const<_Functor>::value) - return 0; - else - return __ptr._M_access<_Functor*>(); - } - else - return 0; - } - - template - template - const _Functor* - function<_Res(_ArgTypes...)>:: - target() const noexcept - { - if (typeid(_Functor) == target_type() && _M_manager) - { - _Any_data __ptr; - _M_manager(__ptr, _M_functor, __get_functor_ptr); - return __ptr._M_access(); - } - else - return 0; - } -#endif - - // [20.7.15.2.6] null pointer comparisons - - /** - * @brief Compares a polymorphic function object wrapper against 0 - * (the NULL pointer). - * @returns @c true if the wrapper has no target, @c false otherwise - * - * This function will not throw an %exception. - */ - template - inline bool - operator==(const function<_Res(_Args...)>& __f, nullptr_t) noexcept - { return !static_cast(__f); } - - /// @overload - template - inline bool - operator==(nullptr_t, const function<_Res(_Args...)>& __f) noexcept - { return !static_cast(__f); } - - /** - * @brief Compares a polymorphic function object wrapper against 0 - * (the NULL pointer). - * @returns @c false if the wrapper has no target, @c true otherwise - * - * This function will not throw an %exception. - */ - template - inline bool - operator!=(const function<_Res(_Args...)>& __f, nullptr_t) noexcept - { return static_cast(__f); } - - /// @overload - template - inline bool - operator!=(nullptr_t, const function<_Res(_Args...)>& __f) noexcept - { return static_cast(__f); } - - // [20.7.15.2.7] specialized algorithms - - /** - * @brief Swap the targets of two polymorphic function object wrappers. - * - * This function will not throw an %exception. - */ - // _GLIBCXX_RESOLVE_LIB_DEFECTS - // 2062. Effect contradictions w/o no-throw guarantee of std::function swaps - template - inline void - swap(function<_Res(_Args...)>& __x, function<_Res(_Args...)>& __y) noexcept - { __x.swap(__y); } - #if __cplusplus >= 201402L /// Generalized negator. template @@ -2084,12 +958,9 @@ _GLIBCXX_MEM_FN_TRAITS(&&, false_type, true_type) private: _Fn _M_fn; }; -#endif // C++14 #if __cplusplus > 201402L - #define __cpp_lib_not_fn 201603 - /// [func.not_fn] Function template not_fn template inline auto @@ -2410,6 +1281,7 @@ _GLIBCXX_MEM_FN_TRAITS(&&, false_type, true_type) } #endif // C++17 +#endif // C++14 _GLIBCXX_END_NAMESPACE_VERSION } // namespace std diff --git a/libstdc++-v3/include/std/future b/libstdc++-v3/include/std/future index 5542d49584f..fea915b0a87 100644 --- a/libstdc++-v3/include/std/future +++ b/libstdc++-v3/include/std/future @@ -40,12 +40,12 @@ #include #include #include -#include #include #include #include #include #include +#include #include #include #include diff --git a/libstdc++-v3/include/std/mutex b/libstdc++-v3/include/std/mutex index 0e1bc7fd412..c34ba4b50b6 100644 --- a/libstdc++-v3/include/std/mutex +++ b/libstdc++-v3/include/std/mutex @@ -46,7 +46,7 @@ # include #endif #ifndef _GLIBCXX_HAVE_TLS -# include +# include #endif #ifdef _GLIBCXX_USE_C99_STDINT_TR1 diff --git a/libstdc++-v3/include/std/regex b/libstdc++-v3/include/std/regex index b003868ef68..f5728245eb8 100644 --- a/libstdc++-v3/include/std/regex +++ b/libstdc++-v3/include/std/regex @@ -37,7 +37,6 @@ #include #include -#include #ifdef _GLIBCXX_DEBUG # include #endif @@ -54,6 +53,7 @@ #include #include +#include #include #include #include diff --git a/libstdc++-v3/src/c++11/compatibility-thread-c++0x.cc b/libstdc++-v3/src/c++11/compatibility-thread-c++0x.cc index 066b08b77de..0f9dc3dcaa9 100644 --- a/libstdc++-v3/src/c++11/compatibility-thread-c++0x.cc +++ b/libstdc++-v3/src/c++11/compatibility-thread-c++0x.cc @@ -29,6 +29,7 @@ #include #include +#include #if __cplusplus < 201103L # error "compatibility-thread-c++0x.cc must be compiled with -std=gnu++0x" diff --git a/libstdc++-v3/testsuite/20_util/default_delete/48631_neg.cc b/libstdc++-v3/testsuite/20_util/default_delete/48631_neg.cc index 5a2c5df7f93..23b3f8b6c46 100644 --- a/libstdc++-v3/testsuite/20_util/default_delete/48631_neg.cc +++ b/libstdc++-v3/testsuite/20_util/default_delete/48631_neg.cc @@ -26,4 +26,4 @@ struct D : B { }; D d; std::default_delete db; typedef decltype(db(&d)) type; // { dg-error "no match" } -// { dg-error "no type" "" { target *-*-* } 106 } +// { dg-error "no type" "" { target *-*-* } 107 } diff --git a/libstdc++-v3/testsuite/20_util/default_delete/void_neg.cc b/libstdc++-v3/testsuite/20_util/default_delete/void_neg.cc index 96caa4ff7e8..c9688bcda7b 100644 --- a/libstdc++-v3/testsuite/20_util/default_delete/void_neg.cc +++ b/libstdc++-v3/testsuite/20_util/default_delete/void_neg.cc @@ -25,5 +25,5 @@ void test01() { std::default_delete d; d(nullptr); // { dg-error "here" } - // { dg-error "incomplete" "" { target *-*-* } 72 } + // { dg-error "incomplete" "" { target *-*-* } 73 } } diff --git a/libstdc++-v3/testsuite/20_util/unique_ptr/assign/48635_neg.cc b/libstdc++-v3/testsuite/20_util/unique_ptr/assign/48635_neg.cc index 311e8d55f5c..9d248265be9 100644 --- a/libstdc++-v3/testsuite/20_util/unique_ptr/assign/48635_neg.cc +++ b/libstdc++-v3/testsuite/20_util/unique_ptr/assign/48635_neg.cc @@ -42,10 +42,10 @@ void f() std::unique_ptr ud(nullptr, d); ub = std::move(ud); // { dg-error "no match" } ub2 = ud; // { dg-error "no match" } -// { dg-error "no type" "" { target *-*-* } 287 } +// { dg-error "no type" "" { target *-*-* } 288 } std::unique_ptr uba(nullptr, b); std::unique_ptr uda(nullptr, d); uba = std::move(uda); // { dg-error "no match" } -// { dg-error "no type" "" { target *-*-* } 538 } +// { dg-error "no type" "" { target *-*-* } 539 } } diff --git a/libstdc++-v3/testsuite/20_util/unique_ptr/cons/cv_qual_neg.cc b/libstdc++-v3/testsuite/20_util/unique_ptr/cons/cv_qual_neg.cc index d744c1b7013..a0f77c0c009 100644 --- a/libstdc++-v3/testsuite/20_util/unique_ptr/cons/cv_qual_neg.cc +++ b/libstdc++-v3/testsuite/20_util/unique_ptr/cons/cv_qual_neg.cc @@ -39,7 +39,7 @@ test07() std::unique_ptr cA3(p); // { dg-error "no matching function" } std::unique_ptr vA3(p); // { dg-error "no matching function" } std::unique_ptr cvA3(p); // { dg-error "no matching function" } - // { dg-error "no type" "" { target *-*-* } 446 } + // { dg-error "no type" "" { target *-*-* } 447 } } template diff --git a/libstdc++-v3/testsuite/30_threads/packaged_task/49668.cc b/libstdc++-v3/testsuite/30_threads/packaged_task/49668.cc index d3d91aeb484..1ab9d192ac5 100644 --- a/libstdc++-v3/testsuite/30_threads/packaged_task/49668.cc +++ b/libstdc++-v3/testsuite/30_threads/packaged_task/49668.cc @@ -24,6 +24,7 @@ #include +#include #include struct moveable