This is the mail archive of the
libstdc++@gcc.gnu.org
mailing list for the libstdc++ project.
[v3] typeinfo tuning
- From: Benjamin Kosnik <bkoz at redhat dot com>
- To: gcc-patches at gcc dot gnu dot org, libstdc++ at gcc dot gnu dot org
- Date: Mon, 14 Mar 2011 10:29:44 -0700
- Subject: [v3] typeinfo tuning
I hacked up scripts/check_compile and ran the libstdc++ testsuite to
generate 4k+ .s files, and then analyzed the resulting assembly files
for vague linkage.
Here are the clear wins that are ABI-compatible, or in C++0x code. There
are other issues, like the locale base classes, that are not as easy to
fix. There are a couple other issues in C++0x code that I am working
out, will post later today.
I'm holding off on this patch until branching is clear. But I thought
I'd post it so that this effort is public. It's set up for 4.6.0 but
may be moved to 4.7.0.
tested x86_64/linux
-benjamin
2011-03-14 Benjamin Kosnik <bkoz@redhat.com>
* src/Makefile.am: Add functional.cc, shared_ptr.cc.
* src/Makefile.in: Regenerate.
* libsupc++/Makefile.am: Add nested_exception.cc.
* libsupc++/Makefile.in: Regenerate.
* src/system_error.cc: Add ctor and dtor definitions for error_category.
* src/functional.cc: New. Add dtor definition for bad_function_call.
* src/stdexcept.cc: Add dtor definitions for domain_error,
invalid_argument, length_error, out_of_range, range_error,
overflow_error, underflow_error.
* src/future.cc: Add dtor definition for __future_base::_Result_base.
* src/shared_ptr.cc: New. Add dtor definition for bad_weak_ptr.
* include/std/system_error: Adjust.
* include/std/stdexcept: Same.
* include/std/future: Same.
* include/std/functional: Same.
* include/bits/shared_ptr_base.h: Same.
* libsupc++/nested_exception.cc: New. Add dtor for nested_exception.
* libsupc++/nested_exception.h: Adjust.
* testsuite/20_util/shared_ptr/cons/43820_neg.cc: Adjust line numbers.
* testsuite/20_util/weak_ptr/comparison/cmp_neg.cc: Same.
* config/abi/pre/gnu.ver: Add new exports.
Index: src/shared_ptr.cc
===================================================================
--- src/shared_ptr.cc (revision 0)
+++ src/shared_ptr.cc (revision 0)
@@ -0,0 +1,39 @@
+// Support for pointer abstractions -*- C++ -*-
+
+// Copyright (C) 2011
+// Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library. This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
+// <http://www.gnu.org/licenses/>.
+
+#include <memory>
+
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
+ bad_weak_ptr::~bad_weak_ptr() throw() = default;
+
+ char const*
+ bad_weak_ptr::what() const throw()
+ { return "std::bad_weak_ptr"; }
+
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
Index: src/system_error.cc
===================================================================
--- src/system_error.cc (revision 170943)
+++ src/system_error.cc (working copy)
@@ -1,6 +1,6 @@
// <system_error> implementation file
-// Copyright (C) 2007, 2008, 2009, 2010 Free Software Foundation, Inc.
+// Copyright (C) 2007, 2008, 2009, 2010, 2011 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
@@ -74,13 +74,17 @@
{
_GLIBCXX_BEGIN_NAMESPACE_VERSION
+ error_category::error_category() = default;
+
+ error_category::~error_category() = default;
+
const error_category&
system_category() throw() { return system_category_instance; }
const error_category&
generic_category() throw() { return generic_category_instance; }
- system_error::~system_error() throw() { }
+ system_error::~system_error() throw() = default;
error_condition
error_category::default_error_condition(int __i) const
Index: src/functional.cc
===================================================================
--- src/functional.cc (revision 0)
+++ src/functional.cc (revision 0)
@@ -0,0 +1,35 @@
+// Support for <functional> -*- C++ -*-
+
+// Copyright (C) 2011
+// Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library. This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
+// <http://www.gnu.org/licenses/>.
+
+#include <functional>
+
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
+ bad_function_call::~bad_function_call() throw() = default;
+
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
Index: src/stdexcept.cc
===================================================================
--- src/stdexcept.cc (revision 170943)
+++ src/stdexcept.cc (working copy)
@@ -1,6 +1,6 @@
// Methods for Exception Support for -*- C++ -*-
-// Copyright (C) 1997, 1999, 2001, 2002, 2005, 2009
+// Copyright (C) 1997, 1999, 2001, 2002, 2005, 2009, 2011
// Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
@@ -34,7 +34,7 @@
{
_GLIBCXX_BEGIN_NAMESPACE_VERSION
- logic_error::logic_error(const string& __arg)
+ logic_error::logic_error(const string& __arg)
: exception(), _M_msg(__arg) { }
logic_error::~logic_error() throw() { }
@@ -46,16 +46,24 @@
domain_error::domain_error(const string& __arg)
: logic_error(__arg) { }
+ domain_error::~domain_error() throw() { }
+
invalid_argument::invalid_argument(const string& __arg)
: logic_error(__arg) { }
+ invalid_argument::~invalid_argument() throw() { }
+
length_error::length_error(const string& __arg)
: logic_error(__arg) { }
+ length_error::~length_error() throw() { }
+
out_of_range::out_of_range(const string& __arg)
: logic_error(__arg) { }
- runtime_error::runtime_error(const string& __arg)
+ out_of_range::~out_of_range() throw() { }
+
+ runtime_error::runtime_error(const string& __arg)
: exception(), _M_msg(__arg) { }
runtime_error::~runtime_error() throw() { }
@@ -67,12 +75,17 @@
range_error::range_error(const string& __arg)
: runtime_error(__arg) { }
+ range_error::~range_error() throw() { }
+
overflow_error::overflow_error(const string& __arg)
: runtime_error(__arg) { }
+ overflow_error::~overflow_error() throw() { }
+
underflow_error::underflow_error(const string& __arg)
: runtime_error(__arg) { }
+ underflow_error::~underflow_error() throw() { }
+
_GLIBCXX_END_NAMESPACE_VERSION
} // namespace
-
Index: src/future.cc
===================================================================
--- src/future.cc (revision 170943)
+++ src/future.cc (working copy)
@@ -79,8 +79,12 @@
const char*
future_error::what() const throw() { return _M_code.message().c_str(); }
+ __future_base::_Result_base::_Result_base() = default;
+
+ __future_base::_Result_base::~_Result_base() = default;
+
_GLIBCXX_END_NAMESPACE_VERSION
-} // namespace
+} // namespace std
// XXX GLIBCXX_ABI Deprecated
// gcc-4.6.0
Index: src/Makefile.am
===================================================================
--- src/Makefile.am (revision 170943)
+++ src/Makefile.am (working copy)
@@ -201,6 +201,7 @@
ctype.cc \
debug.cc \
functexcept.cc \
+ functional.cc \
globals_io.cc \
hash_c++0x.cc \
hash_tr1.cc \
@@ -225,6 +226,7 @@
istream.cc \
placeholders.cc \
regex.cc \
+ shared_ptr.cc \
streambuf.cc \
mutex.cc \
condition_variable.cc \
@@ -292,6 +294,11 @@
functexcept.o: functexcept.cc
$(CXXCOMPILE) -std=gnu++0x -c $<
+shared_ptr.lo: shared_ptr.cc
+ $(LTCXXCOMPILE) -std=gnu++0x -c $<
+shared_ptr.o: shared_ptr.cc
+ $(CXXCOMPILE) -std=gnu++0x -c $<
+
system_error.lo: system_error.cc
$(LTCXXCOMPILE) -std=gnu++0x -c $<
system_error.o: system_error.cc
@@ -312,6 +319,11 @@
compatibility-c++0x.o: compatibility-c++0x.cc
$(CXXCOMPILE) -std=gnu++0x -c $<
+functional.lo: functional.cc
+ $(LTCXXCOMPILE) -std=gnu++0x -c $<
+functional.o: functional.cc
+ $(CXXCOMPILE) -std=gnu++0x -c $<
+
hash_c++0x.lo: hash_c++0x.cc
$(LTCXXCOMPILE) -std=gnu++0x -c $<
hash_c++0x.o: hash_c++0x.cc
Index: include/std/system_error
===================================================================
--- include/std/system_error (revision 170943)
+++ include/std/system_error (working copy)
@@ -1,6 +1,6 @@
// <system_error> -*- C++ -*-
-// Copyright (C) 2007, 2008, 2009, 2010 Free Software Foundation, Inc.
+// Copyright (C) 2007, 2008, 2009, 2010, 2011 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
@@ -69,7 +69,7 @@
error_category();
public:
- virtual ~error_category() { }
+ virtual ~error_category();
error_category(const error_category&) = delete;
error_category& operator=(const error_category&) = delete;
@@ -102,8 +102,6 @@
{ return this != &__other; }
};
- inline error_category::error_category() = default;
-
// DR 890.
_GLIBCXX_CONST const error_category& system_category() throw();
_GLIBCXX_CONST const error_category& generic_category() throw();
Index: include/std/stdexcept
===================================================================
--- include/std/stdexcept (revision 170943)
+++ include/std/stdexcept (working copy)
@@ -1,6 +1,6 @@
// Standard exception classes -*- C++ -*-
-// Copyright (C) 2001, 2002, 2005, 2007, 2009, 2010
+// Copyright (C) 2001, 2002, 2005, 2007, 2009, 2010, 2011
// Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
@@ -62,8 +62,7 @@
explicit
logic_error(const string& __arg);
- virtual
- ~logic_error() throw();
+ virtual ~logic_error() throw();
/** Returns a C-style character string describing the general cause of
* the current error (the same string passed to the ctor). */
@@ -77,6 +76,7 @@
{
public:
explicit domain_error(const string& __arg);
+ virtual ~domain_error() throw();
};
/** Thrown to report invalid arguments to functions. */
@@ -84,6 +84,7 @@
{
public:
explicit invalid_argument(const string& __arg);
+ virtual ~invalid_argument() throw();
};
/** Thrown when an object is constructed that would exceed its maximum
@@ -92,6 +93,7 @@
{
public:
explicit length_error(const string& __arg);
+ virtual ~length_error() throw();
};
/** This represents an argument whose value is not within the expected
@@ -100,6 +102,7 @@
{
public:
explicit out_of_range(const string& __arg);
+ virtual ~out_of_range() throw();
};
/** Runtime errors represent problems outside the scope of a program;
@@ -116,8 +119,7 @@
explicit
runtime_error(const string& __arg);
- virtual
- ~runtime_error() throw();
+ virtual ~runtime_error() throw();
/** Returns a C-style character string describing the general cause of
* the current error (the same string passed to the ctor). */
@@ -130,6 +132,7 @@
{
public:
explicit range_error(const string& __arg);
+ virtual ~range_error() throw();
};
/** Thrown to indicate arithmetic overflow. */
@@ -137,6 +140,7 @@
{
public:
explicit overflow_error(const string& __arg);
+ virtual ~overflow_error() throw();
};
/** Thrown to indicate arithmetic underflow. */
@@ -144,6 +148,7 @@
{
public:
explicit underflow_error(const string& __arg);
+ virtual ~underflow_error() throw();
};
// @} group exceptions
Index: include/std/future
===================================================================
--- include/std/future (revision 170943)
+++ include/std/future (working copy)
@@ -160,7 +160,6 @@
{
exception_ptr _M_error;
- _Result_base() = default;
_Result_base(const _Result_base&) = delete;
_Result_base& operator=(const _Result_base&) = delete;
@@ -173,7 +172,8 @@
};
protected:
- ~_Result_base();
+ _Result_base();
+ virtual ~_Result_base();
};
/// Result.
@@ -463,8 +463,6 @@
struct _Task_setter;
};
- inline __future_base::_Result_base::~_Result_base() = default;
-
/// Partial specialization for reference types.
template<typename _Res>
struct __future_base::_Result<_Res&> : __future_base::_Result_base
Index: include/std/functional
===================================================================
--- include/std/functional (revision 170943)
+++ include/std/functional (working copy)
@@ -83,90 +83,90 @@
{ };
/// Retrieve the result type for a function type.
- template<typename _Res, typename... _ArgTypes>
+ template<typename _Res, typename... _ArgTypes>
struct _Weak_result_type_impl<_Res(_ArgTypes...)>
{ typedef _Res result_type; };
- template<typename _Res, typename... _ArgTypes>
+ template<typename _Res, typename... _ArgTypes>
struct _Weak_result_type_impl<_Res(_ArgTypes......)>
{ typedef _Res result_type; };
- template<typename _Res, typename... _ArgTypes>
+ template<typename _Res, typename... _ArgTypes>
struct _Weak_result_type_impl<_Res(_ArgTypes...) const>
{ typedef _Res result_type; };
- template<typename _Res, typename... _ArgTypes>
+ template<typename _Res, typename... _ArgTypes>
struct _Weak_result_type_impl<_Res(_ArgTypes......) const>
{ typedef _Res result_type; };
- template<typename _Res, typename... _ArgTypes>
+ template<typename _Res, typename... _ArgTypes>
struct _Weak_result_type_impl<_Res(_ArgTypes...) volatile>
{ typedef _Res result_type; };
- template<typename _Res, typename... _ArgTypes>
+ template<typename _Res, typename... _ArgTypes>
struct _Weak_result_type_impl<_Res(_ArgTypes......) volatile>
{ typedef _Res result_type; };
- template<typename _Res, typename... _ArgTypes>
+ template<typename _Res, typename... _ArgTypes>
struct _Weak_result_type_impl<_Res(_ArgTypes...) const volatile>
{ typedef _Res result_type; };
- template<typename _Res, typename... _ArgTypes>
+ template<typename _Res, typename... _ArgTypes>
struct _Weak_result_type_impl<_Res(_ArgTypes......) const volatile>
{ typedef _Res result_type; };
/// Retrieve the result type for a function reference.
- template<typename _Res, typename... _ArgTypes>
+ template<typename _Res, typename... _ArgTypes>
struct _Weak_result_type_impl<_Res(&)(_ArgTypes...)>
{ typedef _Res result_type; };
- template<typename _Res, typename... _ArgTypes>
+ template<typename _Res, typename... _ArgTypes>
struct _Weak_result_type_impl<_Res(&)(_ArgTypes......)>
{ typedef _Res result_type; };
/// Retrieve the result type for a function pointer.
- template<typename _Res, typename... _ArgTypes>
+ template<typename _Res, typename... _ArgTypes>
struct _Weak_result_type_impl<_Res(*)(_ArgTypes...)>
{ typedef _Res result_type; };
- template<typename _Res, typename... _ArgTypes>
+ template<typename _Res, typename... _ArgTypes>
struct _Weak_result_type_impl<_Res(*)(_ArgTypes......)>
{ typedef _Res result_type; };
- /// Retrieve result type for a member function pointer.
- template<typename _Res, typename _Class, typename... _ArgTypes>
+ /// Retrieve result type for a member function pointer.
+ template<typename _Res, typename _Class, typename... _ArgTypes>
struct _Weak_result_type_impl<_Res (_Class::*)(_ArgTypes...)>
{ typedef _Res result_type; };
- template<typename _Res, typename _Class, typename... _ArgTypes>
+ template<typename _Res, typename _Class, typename... _ArgTypes>
struct _Weak_result_type_impl<_Res (_Class::*)(_ArgTypes......)>
{ typedef _Res result_type; };
- /// Retrieve result type for a const member function pointer.
- template<typename _Res, typename _Class, typename... _ArgTypes>
+ /// Retrieve result type for a const member function pointer.
+ template<typename _Res, typename _Class, typename... _ArgTypes>
struct _Weak_result_type_impl<_Res (_Class::*)(_ArgTypes...) const>
{ typedef _Res result_type; };
- template<typename _Res, typename _Class, typename... _ArgTypes>
+ template<typename _Res, typename _Class, typename... _ArgTypes>
struct _Weak_result_type_impl<_Res (_Class::*)(_ArgTypes......) const>
{ typedef _Res result_type; };
- /// Retrieve result type for a volatile member function pointer.
- template<typename _Res, typename _Class, typename... _ArgTypes>
+ /// Retrieve result type for a volatile member function pointer.
+ template<typename _Res, typename _Class, typename... _ArgTypes>
struct _Weak_result_type_impl<_Res (_Class::*)(_ArgTypes...) volatile>
{ typedef _Res result_type; };
- template<typename _Res, typename _Class, typename... _ArgTypes>
+ template<typename _Res, typename _Class, typename... _ArgTypes>
struct _Weak_result_type_impl<_Res (_Class::*)(_ArgTypes......) volatile>
{ typedef _Res result_type; };
- /// Retrieve result type for a const volatile member function pointer.
- template<typename _Res, typename _Class, typename... _ArgTypes>
- struct _Weak_result_type_impl<_Res (_Class::*)(_ArgTypes...)
+ /// Retrieve result type for a const volatile member function pointer.
+ template<typename _Res, typename _Class, typename... _ArgTypes>
+ struct _Weak_result_type_impl<_Res (_Class::*)(_ArgTypes...)
const volatile>
{ typedef _Res result_type; };
- template<typename _Res, typename _Class, typename... _ArgTypes>
+ template<typename _Res, typename _Class, typename... _ArgTypes>
struct _Weak_result_type_impl<_Res (_Class::*)(_ArgTypes......)
const volatile>
{ typedef _Res result_type; };
@@ -186,7 +186,7 @@
{
private:
template<typename _T1, typename _Res>
- static __one __test(const volatile unary_function<_T1, _Res>*);
+ static __one __test(const volatile unary_function<_T1, _Res>*);
// It's tempting to change "..." to const volatile void*, but
// that fails when _Tp is a function type.
@@ -202,7 +202,7 @@
{
private:
template<typename _T1, typename _T2, typename _Res>
- static __one __test(const volatile binary_function<_T1, _T2, _Res>*);
+ static __one __test(const volatile binary_function<_T1, _T2, _Res>*);
// It's tempting to change "..." to const volatile void*, but
// that fails when _Tp is a function type.
@@ -232,11 +232,11 @@
template<typename _Functor, typename... _Args>
inline
typename enable_if<
- (!is_member_pointer<_Functor>::value
- && !is_function<_Functor>::value
- && !is_function<typename remove_pointer<_Functor>::type>::value),
- typename result_of<_Functor(_Args...)>::type
- >::type
+ (!is_member_pointer<_Functor>::value
+ && !is_function<_Functor>::value
+ && !is_function<typename remove_pointer<_Functor>::type>::value),
+ typename result_of<_Functor(_Args...)>::type
+ >::type
__invoke(_Functor& __f, _Args&&... __args)
{
return __f(std::forward<_Args>(__args)...);
@@ -246,10 +246,10 @@
template<typename _Functor, typename... _Args>
inline
typename enable_if<
- (is_pointer<_Functor>::value
- && is_function<typename remove_pointer<_Functor>::type>::value),
- typename result_of<_Functor(_Args...)>::type
- >::type
+ (is_pointer<_Functor>::value
+ && is_function<typename remove_pointer<_Functor>::type>::value),
+ typename result_of<_Functor(_Args...)>::type
+ >::type
__invoke(_Functor __f, _Args&&... __args)
{
return __f(std::forward<_Args>(__args)...);
@@ -425,7 +425,7 @@
// If _Tp is a function type, we can't form result_of<_Tp(...)>,
// so turn it into a function pointer type.
typedef typename _Function_to_function_pointer<_Tp>::type
- _M_func_type;
+ _M_func_type;
_Tp* _M_data;
public:
@@ -444,8 +444,8 @@
reference_wrapper&
operator=(const reference_wrapper<_Tp>& __inref)
{
- _M_data = __inref._M_data;
- return *this;
+ _M_data = __inref._M_data;
+ return *this;
}
operator _Tp&() const
@@ -456,9 +456,9 @@
{ return *_M_data; }
template<typename... _Args>
- typename result_of<_M_func_type(_Args...)>::type
- operator()(_Args&&... __args) const
- {
+ typename result_of<_M_func_type(_Args...)>::type
+ operator()(_Args&&... __args) const
+ {
return __invoke(get(), std::forward<_Args>(__args)...);
}
};
@@ -498,16 +498,16 @@
* nothing, depending on the number of arguments provided. The
* primary template is the basis case, which derives nothing.
*/
- template<typename _Res, typename... _ArgTypes>
+ template<typename _Res, typename... _ArgTypes>
struct _Maybe_unary_or_binary_function { };
- /// Derives from @c unary_function, as appropriate.
- template<typename _Res, typename _T1>
+ /// Derives from @c unary_function, as appropriate.
+ template<typename _Res, typename _T1>
struct _Maybe_unary_or_binary_function<_Res, _T1>
: std::unary_function<_T1, _Res> { };
- /// Derives from @c binary_function, as appropriate.
- template<typename _Res, typename _T1, typename _T2>
+ /// Derives from @c binary_function, as appropriate.
+ template<typename _Res, typename _T1, typename _T2>
struct _Maybe_unary_or_binary_function<_Res, _T1, _T2>
: std::binary_function<_T1, _T2, _Res> { };
@@ -519,15 +519,15 @@
typedef _Res (_Class::*_Functor)(_ArgTypes...);
template<typename _Tp>
- _Res
- _M_call(_Tp& __object, const volatile _Class *,
- _ArgTypes... __args) const
- { return (__object.*__pmf)(std::forward<_ArgTypes>(__args)...); }
+ _Res
+ _M_call(_Tp& __object, const volatile _Class *,
+ _ArgTypes... __args) const
+ { return (__object.*__pmf)(std::forward<_ArgTypes>(__args)...); }
template<typename _Tp>
- _Res
- _M_call(_Tp& __ptr, const volatile void *, _ArgTypes... __args) const
- { return ((*__ptr).*__pmf)(std::forward<_ArgTypes>(__args)...); }
+ _Res
+ _M_call(_Tp& __ptr, const volatile void *, _ArgTypes... __args) const
+ { return ((*__ptr).*__pmf)(std::forward<_ArgTypes>(__args)...); }
public:
typedef _Res result_type;
@@ -546,12 +546,12 @@
// Handle smart pointers, references and pointers to derived
template<typename _Tp>
- _Res
+ _Res
operator()(_Tp& __object, _ArgTypes... __args) const
- {
- return _M_call(__object, &__object,
- std::forward<_ArgTypes>(__args)...);
- }
+ {
+ return _M_call(__object, &__object,
+ std::forward<_ArgTypes>(__args)...);
+ }
private:
_Functor __pmf;
@@ -560,21 +560,21 @@
/// Implementation of @c mem_fn for const member function pointers.
template<typename _Res, typename _Class, typename... _ArgTypes>
class _Mem_fn<_Res (_Class::*)(_ArgTypes...) const>
- : public _Maybe_unary_or_binary_function<_Res, const _Class*,
+ : public _Maybe_unary_or_binary_function<_Res, const _Class*,
_ArgTypes...>
{
typedef _Res (_Class::*_Functor)(_ArgTypes...) const;
template<typename _Tp>
- _Res
- _M_call(_Tp& __object, const volatile _Class *,
- _ArgTypes... __args) const
- { return (__object.*__pmf)(std::forward<_ArgTypes>(__args)...); }
+ _Res
+ _M_call(_Tp& __object, const volatile _Class *,
+ _ArgTypes... __args) const
+ { return (__object.*__pmf)(std::forward<_ArgTypes>(__args)...); }
template<typename _Tp>
- _Res
- _M_call(_Tp& __ptr, const volatile void *, _ArgTypes... __args) const
- { return ((*__ptr).*__pmf)(std::forward<_ArgTypes>(__args)...); }
+ _Res
+ _M_call(_Tp& __ptr, const volatile void *, _ArgTypes... __args) const
+ { return ((*__ptr).*__pmf)(std::forward<_ArgTypes>(__args)...); }
public:
typedef _Res result_type;
@@ -593,11 +593,11 @@
// Handle smart pointers, references and pointers to derived
template<typename _Tp>
- _Res operator()(_Tp& __object, _ArgTypes... __args) const
- {
- return _M_call(__object, &__object,
- std::forward<_ArgTypes>(__args)...);
- }
+ _Res operator()(_Tp& __object, _ArgTypes... __args) const
+ {
+ return _M_call(__object, &__object,
+ std::forward<_ArgTypes>(__args)...);
+ }
private:
_Functor __pmf;
@@ -606,21 +606,21 @@
/// Implementation of @c mem_fn for volatile member function pointers.
template<typename _Res, typename _Class, typename... _ArgTypes>
class _Mem_fn<_Res (_Class::*)(_ArgTypes...) volatile>
- : public _Maybe_unary_or_binary_function<_Res, volatile _Class*,
+ : public _Maybe_unary_or_binary_function<_Res, volatile _Class*,
_ArgTypes...>
{
typedef _Res (_Class::*_Functor)(_ArgTypes...) volatile;
template<typename _Tp>
- _Res
- _M_call(_Tp& __object, const volatile _Class *,
- _ArgTypes... __args) const
- { return (__object.*__pmf)(std::forward<_ArgTypes>(__args)...); }
+ _Res
+ _M_call(_Tp& __object, const volatile _Class *,
+ _ArgTypes... __args) const
+ { return (__object.*__pmf)(std::forward<_ArgTypes>(__args)...); }
template<typename _Tp>
- _Res
- _M_call(_Tp& __ptr, const volatile void *, _ArgTypes... __args) const
- { return ((*__ptr).*__pmf)(std::forward<_ArgTypes>(__args)...); }
+ _Res
+ _M_call(_Tp& __ptr, const volatile void *, _ArgTypes... __args) const
+ { return ((*__ptr).*__pmf)(std::forward<_ArgTypes>(__args)...); }
public:
typedef _Res result_type;
@@ -639,12 +639,12 @@
// Handle smart pointers, references and pointers to derived
template<typename _Tp>
- _Res
+ _Res
operator()(_Tp& __object, _ArgTypes... __args) const
- {
- return _M_call(__object, &__object,
- std::forward<_ArgTypes>(__args)...);
- }
+ {
+ return _M_call(__object, &__object,
+ std::forward<_ArgTypes>(__args)...);
+ }
private:
_Functor __pmf;
@@ -653,21 +653,21 @@
/// Implementation of @c mem_fn for const volatile member function pointers.
template<typename _Res, typename _Class, typename... _ArgTypes>
class _Mem_fn<_Res (_Class::*)(_ArgTypes...) const volatile>
- : public _Maybe_unary_or_binary_function<_Res, const volatile _Class*,
+ : public _Maybe_unary_or_binary_function<_Res, const volatile _Class*,
_ArgTypes...>
{
typedef _Res (_Class::*_Functor)(_ArgTypes...) const volatile;
template<typename _Tp>
- _Res
- _M_call(_Tp& __object, const volatile _Class *,
- _ArgTypes... __args) const
- { return (__object.*__pmf)(std::forward<_ArgTypes>(__args)...); }
+ _Res
+ _M_call(_Tp& __object, const volatile _Class *,
+ _ArgTypes... __args) const
+ { return (__object.*__pmf)(std::forward<_ArgTypes>(__args)...); }
template<typename _Tp>
- _Res
- _M_call(_Tp& __ptr, const volatile void *, _ArgTypes... __args) const
- { return ((*__ptr).*__pmf)(std::forward<_ArgTypes>(__args)...); }
+ _Res
+ _M_call(_Tp& __ptr, const volatile void *, _ArgTypes... __args) const
+ { return ((*__ptr).*__pmf)(std::forward<_ArgTypes>(__args)...); }
public:
typedef _Res result_type;
@@ -675,22 +675,22 @@
explicit _Mem_fn(_Functor __pmf) : __pmf(__pmf) { }
// Handle objects
- _Res
+ _Res
operator()(const volatile _Class& __object, _ArgTypes... __args) const
{ return (__object.*__pmf)(std::forward<_ArgTypes>(__args)...); }
// Handle pointers
- _Res
+ _Res
operator()(const volatile _Class* __object, _ArgTypes... __args) const
{ return (__object->*__pmf)(std::forward<_ArgTypes>(__args)...); }
// Handle smart pointers, references and pointers to derived
template<typename _Tp>
- _Res operator()(_Tp& __object, _ArgTypes... __args) const
- {
- return _M_call(__object, &__object,
- std::forward<_ArgTypes>(__args)...);
- }
+ _Res operator()(_Tp& __object, _ArgTypes... __args) const
+ {
+ return _M_call(__object, &__object,
+ std::forward<_ArgTypes>(__args)...);
+ }
private:
_Functor __pmf;
@@ -715,60 +715,60 @@
// This bit of genius is due to Peter Dimov, improved slightly by
// Douglas Gregor.
template<typename _Tp>
- _Res&
- _M_call(_Tp& __object, _Class *) const
- { return __object.*__pm; }
+ _Res&
+ _M_call(_Tp& __object, _Class *) const
+ { return __object.*__pm; }
template<typename _Tp, typename _Up>
- _Res&
- _M_call(_Tp& __object, _Up * const *) const
- { return (*__object).*__pm; }
+ _Res&
+ _M_call(_Tp& __object, _Up * const *) const
+ { return (*__object).*__pm; }
template<typename _Tp, typename _Up>
- const _Res&
- _M_call(_Tp& __object, const _Up * const *) const
- { return (*__object).*__pm; }
+ const _Res&
+ _M_call(_Tp& __object, const _Up * const *) const
+ { return (*__object).*__pm; }
template<typename _Tp>
- const _Res&
- _M_call(_Tp& __object, const _Class *) const
- { return __object.*__pm; }
+ const _Res&
+ _M_call(_Tp& __object, const _Class *) const
+ { return __object.*__pm; }
template<typename _Tp>
- const _Res&
- _M_call(_Tp& __ptr, const volatile void*) const
- { return (*__ptr).*__pm; }
+ const _Res&
+ _M_call(_Tp& __ptr, const volatile void*) const
+ { return (*__ptr).*__pm; }
template<typename _Tp> static _Tp& __get_ref();
template<typename _Tp>
- static __sfinae_types::__one __check_const(_Tp&, _Class*);
+ static __sfinae_types::__one __check_const(_Tp&, _Class*);
template<typename _Tp, typename _Up>
- static __sfinae_types::__one __check_const(_Tp&, _Up * const *);
+ static __sfinae_types::__one __check_const(_Tp&, _Up * const *);
template<typename _Tp, typename _Up>
- static __sfinae_types::__two __check_const(_Tp&, const _Up * const *);
+ static __sfinae_types::__two __check_const(_Tp&, const _Up * const *);
template<typename _Tp>
- static __sfinae_types::__two __check_const(_Tp&, const _Class*);
+ static __sfinae_types::__two __check_const(_Tp&, const _Class*);
template<typename _Tp>
- static __sfinae_types::__two __check_const(_Tp&, const volatile void*);
+ static __sfinae_types::__two __check_const(_Tp&, const volatile void*);
public:
template<typename _Tp>
- struct _Result_type
+ struct _Result_type
: _Mem_fn_const_or_non<_Res,
(sizeof(__sfinae_types::__two)
== sizeof(__check_const<_Tp>(__get_ref<_Tp>(), (_Tp*)0)))>
- { };
+ { };
template<typename _Signature>
- struct result;
+ struct result;
template<typename _CVMem, typename _Tp>
- struct result<_CVMem(_Tp)>
+ struct result<_CVMem(_Tp)>
: public _Result_type<_Tp> { };
template<typename _CVMem, typename _Tp>
- struct result<_CVMem(_Tp&)>
+ struct result<_CVMem(_Tp&)>
: public _Result_type<_Tp> { };
explicit
@@ -794,9 +794,9 @@
// Handle smart pointers and derived
template<typename _Tp>
- typename _Result_type<_Tp>::type
- operator()(_Tp& __unknown) const
- { return _M_call(__unknown, &__unknown); }
+ typename _Result_type<_Tp>::type
+ operator()(_Tp& __unknown) const
+ { return _M_call(__unknown, &__unknown); }
private:
_Res _Class::*__pm;
@@ -847,7 +847,7 @@
* simplify this with variadic templates, because we're introducing
* unique names for each.
*/
- namespace placeholders
+ namespace placeholders
{
_GLIBCXX_BEGIN_NAMESPACE_VERSION
extern const _Placeholder<1> _1;
@@ -894,7 +894,7 @@
: public integral_constant<int, _Num>
{ };
- /**
+ /**
* Used by _Safe_tuple_element to indicate that there is no tuple
* element at this position.
*/
@@ -926,8 +926,8 @@
*/
template<int __i, typename _Tuple>
struct _Safe_tuple_element
- : _Safe_tuple_element_impl<__i, _Tuple,
- (__i >= 0 && __i < tuple_size<_Tuple>::value)>
+ : _Safe_tuple_element_impl<__i, _Tuple,
+ (__i >= 0 && __i < tuple_size<_Tuple>::value)>
{ };
/**
@@ -942,8 +942,8 @@
* rest of the arguments.
*/
template<typename _Arg,
- bool _IsBindExp = is_bind_expression<_Arg>::value,
- bool _IsPlaceholder = (is_placeholder<_Arg>::value > 0)>
+ bool _IsBindExp = is_bind_expression<_Arg>::value,
+ bool _IsPlaceholder = (is_placeholder<_Arg>::value > 0)>
class _Mu;
/**
@@ -961,9 +961,9 @@
* but not volatile-qualified. This might be a defect in the TR.
*/
template<typename _CVRef, typename _Tuple>
- result_type
- operator()(_CVRef& __arg, _Tuple&) const volatile
- { return __arg.get(); }
+ result_type
+ operator()(_CVRef& __arg, _Tuple&) const volatile
+ { return __arg.get(); }
};
/**
@@ -976,11 +976,11 @@
{
public:
template<typename _CVArg, typename... _Args>
- auto
- operator()(_CVArg& __arg,
+ auto
+ operator()(_CVArg& __arg,
tuple<_Args...>& __tuple) const volatile
- -> decltype(__arg(declval<_Args>()...))
- {
+ -> decltype(__arg(declval<_Args>()...))
+ {
// Construct an index tuple and forward to __call
typedef typename _Build_index_tuple<sizeof...(_Args)>::__type
_Indexes;
@@ -989,13 +989,13 @@
private:
// Invokes the underlying function object __arg by unpacking all
- // of the arguments in the tuple.
+ // of the arguments in the tuple.
template<typename _CVArg, typename... _Args, int... _Indexes>
- auto
- __call(_CVArg& __arg, tuple<_Args...>& __tuple,
+ auto
+ __call(_CVArg& __arg, tuple<_Args...>& __tuple,
const _Index_tuple<_Indexes...>&) const volatile
- -> decltype(__arg(declval<_Args>()...))
- {
+ -> decltype(__arg(declval<_Args>()...))
+ {
return __arg(std::forward<_Args>(get<_Indexes>(__tuple))...);
}
};
@@ -1012,8 +1012,8 @@
template<typename _Signature> class result;
template<typename _CVMu, typename _CVArg, typename _Tuple>
- class result<_CVMu(_CVArg, _Tuple)>
- {
+ class result<_CVMu(_CVArg, _Tuple)>
+ {
// Add a reference, if it hasn't already been done for us.
// This allows us to be a little bit sloppy in constructing
// the tuple that we pass to result_of<...>.
@@ -1026,11 +1026,11 @@
};
template<typename _Tuple>
- typename result<_Mu(_Arg, _Tuple)>::type
- operator()(const volatile _Arg&, _Tuple& __tuple) const volatile
- {
+ typename result<_Mu(_Arg, _Tuple)>::type
+ operator()(const volatile _Arg&, _Tuple& __tuple) const volatile
+ {
return std::forward<typename result<_Mu(_Arg, _Tuple)>::type>(
- ::std::get<(is_placeholder<_Arg>::value - 1)>(__tuple));
+ ::std::get<(is_placeholder<_Arg>::value - 1)>(__tuple));
}
};
@@ -1046,16 +1046,16 @@
template<typename _Signature> struct result;
template<typename _CVMu, typename _CVArg, typename _Tuple>
- struct result<_CVMu(_CVArg, _Tuple)>
- {
+ struct result<_CVMu(_CVArg, _Tuple)>
+ {
typedef typename add_lvalue_reference<_CVArg>::type type;
};
// Pick up the cv-qualifiers of the argument
template<typename _CVArg, typename _Tuple>
- _CVArg&&
- operator()(_CVArg&& __arg, _Tuple&) const volatile
- { return std::forward<_CVArg>(__arg); }
+ _CVArg&&
+ operator()(_CVArg&& __arg, _Tuple&) const volatile
+ { return std::forward<_CVArg>(__arg); }
};
/**
@@ -1086,7 +1086,7 @@
struct _Maybe_wrap_member_pointer<_Tp _Class::*>
{
typedef _Mem_fn<_Tp _Class::*> type;
-
+
static type
__do_wrap(_Tp _Class::* __pm)
{ return type(__pm); }
@@ -1126,59 +1126,59 @@
{
typedef _Bind __self_type;
typedef typename _Build_index_tuple<sizeof...(_Bound_args)>::__type
- _Bound_indexes;
+ _Bound_indexes;
_Functor _M_f;
tuple<_Bound_args...> _M_bound_args;
// Call unqualified
template<typename _Result, typename... _Args, int... _Indexes>
- _Result
- __call(tuple<_Args...>&& __args, _Index_tuple<_Indexes...>)
- {
- return _M_f(_Mu<_Bound_args>()
- (get<_Indexes>(_M_bound_args), __args)...);
- }
+ _Result
+ __call(tuple<_Args...>&& __args, _Index_tuple<_Indexes...>)
+ {
+ return _M_f(_Mu<_Bound_args>()
+ (get<_Indexes>(_M_bound_args), __args)...);
+ }
// Call as const
template<typename _Result, typename... _Args, int... _Indexes>
- _Result
- __call_c(tuple<_Args...>&& __args, _Index_tuple<_Indexes...>) const
- {
- return _M_f(_Mu<_Bound_args>()
- (get<_Indexes>(_M_bound_args), __args)...);
- }
+ _Result
+ __call_c(tuple<_Args...>&& __args, _Index_tuple<_Indexes...>) const
+ {
+ return _M_f(_Mu<_Bound_args>()
+ (get<_Indexes>(_M_bound_args), __args)...);
+ }
// Call as volatile
template<typename _Result, typename... _Args, int... _Indexes>
- _Result
- __call_v(tuple<_Args...>&& __args,
+ _Result
+ __call_v(tuple<_Args...>&& __args,
_Index_tuple<_Indexes...>) volatile
- {
- return _M_f(_Mu<_Bound_args>()
- (__volget<_Indexes>(_M_bound_args), __args)...);
- }
+ {
+ return _M_f(_Mu<_Bound_args>()
+ (__volget<_Indexes>(_M_bound_args), __args)...);
+ }
// Call as const volatile
template<typename _Result, typename... _Args, int... _Indexes>
- _Result
- __call_c_v(tuple<_Args...>&& __args,
+ _Result
+ __call_c_v(tuple<_Args...>&& __args,
_Index_tuple<_Indexes...>) const volatile
- {
- return _M_f(_Mu<_Bound_args>()
- (__volget<_Indexes>(_M_bound_args), __args)...);
- }
+ {
+ return _M_f(_Mu<_Bound_args>()
+ (__volget<_Indexes>(_M_bound_args), __args)...);
+ }
public:
template<typename... _Args>
- explicit _Bind(const _Functor& __f, _Args&&... __args)
- : _M_f(__f), _M_bound_args(std::forward<_Args>(__args)...)
- { }
+ explicit _Bind(const _Functor& __f, _Args&&... __args)
+ : _M_f(__f), _M_bound_args(std::forward<_Args>(__args)...)
+ { }
template<typename... _Args>
- explicit _Bind(_Functor&& __f, _Args&&... __args)
- : _M_f(std::move(__f)), _M_bound_args(std::forward<_Args>(__args)...)
- { }
+ explicit _Bind(_Functor&& __f, _Args&&... __args)
+ : _M_f(std::move(__f)), _M_bound_args(std::forward<_Args>(__args)...)
+ { }
_Bind(const _Bind&) = default;
@@ -1188,55 +1188,55 @@
// Call unqualified
template<typename... _Args, typename _Result
- = decltype( std::declval<_Functor>()(
- _Mu<_Bound_args>()( std::declval<_Bound_args&>(),
+ = decltype( std::declval<_Functor>()(
+ _Mu<_Bound_args>()( std::declval<_Bound_args&>(),
std::declval<tuple<_Args...>&>() )... ) )>
- _Result
- operator()(_Args&&... __args)
- {
- return this->__call<_Result>(
- std::forward_as_tuple(std::forward<_Args>(__args)...),
- _Bound_indexes());
- }
+ _Result
+ operator()(_Args&&... __args)
+ {
+ return this->__call<_Result>(
+ std::forward_as_tuple(std::forward<_Args>(__args)...),
+ _Bound_indexes());
+ }
// Call as const
template<typename... _Args, typename _Result
- = decltype( std::declval<const _Functor>()(
+ = decltype( std::declval<const _Functor>()(
_Mu<_Bound_args>()( std::declval<const _Bound_args&>(),
std::declval<tuple<_Args...>&>() )... ) )>
- _Result
- operator()(_Args&&... __args) const
- {
- return this->__call_c<_Result>(
- std::forward_as_tuple(std::forward<_Args>(__args)...),
- _Bound_indexes());
- }
+ _Result
+ operator()(_Args&&... __args) const
+ {
+ return this->__call_c<_Result>(
+ std::forward_as_tuple(std::forward<_Args>(__args)...),
+ _Bound_indexes());
+ }
// Call as volatile
template<typename... _Args, typename _Result
- = decltype( std::declval<volatile _Functor>()(
- _Mu<_Bound_args>()( std::declval<volatile _Bound_args&>(),
- std::declval<tuple<_Args...>&>() )... ) )>
- _Result
- operator()(_Args&&... __args) volatile
- {
- return this->__call_v<_Result>(
- std::forward_as_tuple(std::forward<_Args>(__args)...),
- _Bound_indexes());
- }
+ = decltype( std::declval<volatile _Functor>()(
+ _Mu<_Bound_args>()( std::declval<volatile _Bound_args&>(),
+ std::declval<tuple<_Args...>&>() )... ) )>
+ _Result
+ operator()(_Args&&... __args) volatile
+ {
+ return this->__call_v<_Result>(
+ std::forward_as_tuple(std::forward<_Args>(__args)...),
+ _Bound_indexes());
+ }
// Call as const volatile
template<typename... _Args, typename _Result
- = decltype( std::declval<const volatile _Functor>()(
- _Mu<_Bound_args>()( std::declval<const volatile _Bound_args&>(),
- std::declval<tuple<_Args...>&>() )... ) )>
- _Result
- operator()(_Args&&... __args) const volatile
- {
- return this->__call_c_v<_Result>(
- std::forward_as_tuple(std::forward<_Args>(__args)...),
- _Bound_indexes());
- }
+ = decltype( std::declval<const volatile _Functor>()(
+ _Mu<_Bound_args>()( std::declval<const volatile _Bound_args&>(),
+ std::declval<tuple<_Args...>&>() )... ) )>
+ _Result
+ operator()(_Args&&... __args) const volatile
+ {
+ return this->__call_c_v<_Result>(
+ std::forward_as_tuple(std::forward<_Args>(__args)...),
+ _Bound_indexes());
+ }
};
/// Type of the function object returned from bind<R>().
@@ -1247,111 +1247,111 @@
class _Bind_result<_Result, _Functor(_Bound_args...)>
{
typedef _Bind_result __self_type;
- typedef typename _Build_index_tuple<sizeof...(_Bound_args)>::__type
- _Bound_indexes;
+ typedef typename _Build_index_tuple<sizeof...(_Bound_args)>::__type
+ _Bound_indexes;
_Functor _M_f;
tuple<_Bound_args...> _M_bound_args;
// sfinae types
template<typename _Res>
- struct __enable_if_void : enable_if<is_void<_Res>::value, int> { };
+ struct __enable_if_void : enable_if<is_void<_Res>::value, int> { };
template<typename _Res>
- struct __disable_if_void : enable_if<!is_void<_Res>::value, int> { };
+ struct __disable_if_void : enable_if<!is_void<_Res>::value, int> { };
// Call unqualified
template<typename _Res, typename... _Args, int... _Indexes>
- _Result
- __call(tuple<_Args...>&& __args, _Index_tuple<_Indexes...>,
- typename __disable_if_void<_Res>::type = 0)
- {
- return _M_f(_Mu<_Bound_args>()
- (get<_Indexes>(_M_bound_args), __args)...);
- }
+ _Result
+ __call(tuple<_Args...>&& __args, _Index_tuple<_Indexes...>,
+ typename __disable_if_void<_Res>::type = 0)
+ {
+ return _M_f(_Mu<_Bound_args>()
+ (get<_Indexes>(_M_bound_args), __args)...);
+ }
// Call unqualified, return void
template<typename _Res, typename... _Args, int... _Indexes>
- void
- __call(tuple<_Args...>&& __args, _Index_tuple<_Indexes...>,
- typename __enable_if_void<_Res>::type = 0)
- {
- _M_f(_Mu<_Bound_args>()
+ void
+ __call(tuple<_Args...>&& __args, _Index_tuple<_Indexes...>,
+ typename __enable_if_void<_Res>::type = 0)
+ {
+ _M_f(_Mu<_Bound_args>()
(get<_Indexes>(_M_bound_args), __args)...);
- }
+ }
// Call as const
template<typename _Res, typename... _Args, int... _Indexes>
- _Result
- __call(tuple<_Args...>&& __args, _Index_tuple<_Indexes...>,
- typename __disable_if_void<_Res>::type = 0) const
- {
- return _M_f(_Mu<_Bound_args>()
- (get<_Indexes>(_M_bound_args), __args)...);
- }
+ _Result
+ __call(tuple<_Args...>&& __args, _Index_tuple<_Indexes...>,
+ typename __disable_if_void<_Res>::type = 0) const
+ {
+ return _M_f(_Mu<_Bound_args>()
+ (get<_Indexes>(_M_bound_args), __args)...);
+ }
// Call as const, return void
template<typename _Res, typename... _Args, int... _Indexes>
- void
- __call(tuple<_Args...>&& __args, _Index_tuple<_Indexes...>,
- typename __enable_if_void<_Res>::type = 0) const
- {
- _M_f(_Mu<_Bound_args>()
+ void
+ __call(tuple<_Args...>&& __args, _Index_tuple<_Indexes...>,
+ typename __enable_if_void<_Res>::type = 0) const
+ {
+ _M_f(_Mu<_Bound_args>()
(get<_Indexes>(_M_bound_args), __args)...);
- }
+ }
// Call as volatile
template<typename _Res, typename... _Args, int... _Indexes>
- _Result
- __call(tuple<_Args...>&& __args, _Index_tuple<_Indexes...>,
- typename __disable_if_void<_Res>::type = 0) volatile
- {
- return _M_f(_Mu<_Bound_args>()
- (__volget<_Indexes>(_M_bound_args), __args)...);
- }
+ _Result
+ __call(tuple<_Args...>&& __args, _Index_tuple<_Indexes...>,
+ typename __disable_if_void<_Res>::type = 0) volatile
+ {
+ return _M_f(_Mu<_Bound_args>()
+ (__volget<_Indexes>(_M_bound_args), __args)...);
+ }
// Call as volatile, return void
template<typename _Res, typename... _Args, int... _Indexes>
- void
- __call(tuple<_Args...>&& __args, _Index_tuple<_Indexes...>,
- typename __enable_if_void<_Res>::type = 0) volatile
- {
- _M_f(_Mu<_Bound_args>()
+ void
+ __call(tuple<_Args...>&& __args, _Index_tuple<_Indexes...>,
+ typename __enable_if_void<_Res>::type = 0) volatile
+ {
+ _M_f(_Mu<_Bound_args>()
(__volget<_Indexes>(_M_bound_args), __args)...);
- }
+ }
// Call as const volatile
template<typename _Res, typename... _Args, int... _Indexes>
- _Result
- __call(tuple<_Args...>&& __args, _Index_tuple<_Indexes...>,
- typename __disable_if_void<_Res>::type = 0) const volatile
- {
- return _M_f(_Mu<_Bound_args>()
- (__volget<_Indexes>(_M_bound_args), __args)...);
- }
+ _Result
+ __call(tuple<_Args...>&& __args, _Index_tuple<_Indexes...>,
+ typename __disable_if_void<_Res>::type = 0) const volatile
+ {
+ return _M_f(_Mu<_Bound_args>()
+ (__volget<_Indexes>(_M_bound_args), __args)...);
+ }
// Call as const volatile, return void
template<typename _Res, typename... _Args, int... _Indexes>
- void
- __call(tuple<_Args...>&& __args,
- _Index_tuple<_Indexes...>,
- typename __enable_if_void<_Res>::type = 0) const volatile
- {
- _M_f(_Mu<_Bound_args>()
+ void
+ __call(tuple<_Args...>&& __args,
+ _Index_tuple<_Indexes...>,
+ typename __enable_if_void<_Res>::type = 0) const volatile
+ {
+ _M_f(_Mu<_Bound_args>()
(__volget<_Indexes>(_M_bound_args), __args)...);
- }
+ }
public:
typedef _Result result_type;
template<typename... _Args>
- explicit _Bind_result(const _Functor& __f, _Args&&... __args)
- : _M_f(__f), _M_bound_args(std::forward<_Args>(__args)...)
- { }
+ explicit _Bind_result(const _Functor& __f, _Args&&... __args)
+ : _M_f(__f), _M_bound_args(std::forward<_Args>(__args)...)
+ { }
template<typename... _Args>
- explicit _Bind_result(_Functor&& __f, _Args&&... __args)
- : _M_f(std::move(__f)), _M_bound_args(std::forward<_Args>(__args)...)
- { }
+ explicit _Bind_result(_Functor&& __f, _Args&&... __args)
+ : _M_f(std::move(__f)), _M_bound_args(std::forward<_Args>(__args)...)
+ { }
_Bind_result(const _Bind_result&) = default;
@@ -1361,43 +1361,43 @@
// Call unqualified
template<typename... _Args>
- result_type
- operator()(_Args&&... __args)
- {
- return this->__call<_Result>(
- std::forward_as_tuple(std::forward<_Args>(__args)...),
- _Bound_indexes());
- }
+ result_type
+ operator()(_Args&&... __args)
+ {
+ return this->__call<_Result>(
+ std::forward_as_tuple(std::forward<_Args>(__args)...),
+ _Bound_indexes());
+ }
// Call as const
template<typename... _Args>
- result_type
- operator()(_Args&&... __args) const
- {
- return this->__call<_Result>(
- std::forward_as_tuple(std::forward<_Args>(__args)...),
- _Bound_indexes());
- }
+ result_type
+ operator()(_Args&&... __args) const
+ {
+ return this->__call<_Result>(
+ std::forward_as_tuple(std::forward<_Args>(__args)...),
+ _Bound_indexes());
+ }
// Call as volatile
template<typename... _Args>
- result_type
- operator()(_Args&&... __args) volatile
- {
- return this->__call<_Result>(
- std::forward_as_tuple(std::forward<_Args>(__args)...),
- _Bound_indexes());
- }
+ result_type
+ operator()(_Args&&... __args) volatile
+ {
+ return this->__call<_Result>(
+ std::forward_as_tuple(std::forward<_Args>(__args)...),
+ _Bound_indexes());
+ }
// Call as const volatile
template<typename... _Args>
- result_type
- operator()(_Args&&... __args) const volatile
- {
- return this->__call<_Result>(
- std::forward_as_tuple(std::forward<_Args>(__args)...),
- _Bound_indexes());
- }
+ result_type
+ operator()(_Args&&... __args) const volatile
+ {
+ return this->__call<_Result>(
+ std::forward_as_tuple(std::forward<_Args>(__args)...),
+ _Bound_indexes());
+ }
};
/**
@@ -1420,7 +1420,7 @@
struct _Bind_helper
{
typedef _Maybe_wrap_member_pointer<typename decay<_Functor>::type>
- __maybe_type;
+ __maybe_type;
typedef typename __maybe_type::type __functor_type;
typedef _Bind<__functor_type(typename decay<_ArgTypes>::type...)> type;
};
@@ -1438,18 +1438,18 @@
typedef typename __helper_type::__maybe_type __maybe_type;
typedef typename __helper_type::type __result_type;
return __result_type(__maybe_type::__do_wrap(std::forward<_Functor>(__f)),
- std::forward<_ArgTypes>(__args)...);
- }
+ std::forward<_ArgTypes>(__args)...);
+ }
template<typename _Result, typename _Functor, typename... _ArgTypes>
struct _Bindres_helper
{
typedef _Maybe_wrap_member_pointer<typename decay<_Functor>::type>
- __maybe_type;
+ __maybe_type;
typedef typename __maybe_type::type __functor_type;
typedef _Bind_result<_Result,
- __functor_type(typename decay<_ArgTypes>::type...)>
- type;
+ __functor_type(typename decay<_ArgTypes>::type...)>
+ type;
};
/**
@@ -1465,7 +1465,7 @@
typedef typename __helper_type::__maybe_type __maybe_type;
typedef typename __helper_type::type __result_type;
return __result_type(__maybe_type::__do_wrap(std::forward<_Functor>(__f)),
- std::forward<_ArgTypes>(__args)...);
+ std::forward<_ArgTypes>(__args)...);
}
/**
@@ -1473,7 +1473,11 @@
* operator() is called with an empty target.
* @ingroup exceptions
*/
- class bad_function_call : public std::exception { };
+ class bad_function_call : public std::exception
+ {
+ public:
+ virtual ~bad_function_call() throw();
+ };
/**
* Trait identifying "location-invariant" types, meaning that the
@@ -1570,11 +1574,11 @@
{
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));
-
+ (__is_location_invariant<_Functor>::value
+ && sizeof(_Functor) <= _M_max_size
+ && __alignof__(_Functor) <= _M_max_align
+ && (_M_max_align % __alignof__(_Functor) == 0));
+
typedef integral_constant<bool, __stored_locally> _Local_storage;
// Retrieve a pointer to the function object
@@ -1611,14 +1615,14 @@
{
__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,
@@ -1634,7 +1638,7 @@
case __get_functor_ptr:
__dest._M_access<_Functor*>() = _M_get_pointer(__source);
break;
-
+
case __clone_functor:
_M_clone(__dest, __source, _Local_storage());
break;
@@ -1649,11 +1653,11 @@
static void
_M_init_functor(_Any_data& __functor, _Functor&& __f)
{ _M_init_functor(__functor, std::move(__f), _Local_storage()); }
-
+
template<typename _Signature>
static bool
_M_not_empty_function(const function<_Signature>& __f)
- { return static_cast<bool>(__f); }
+ { return static_cast<bool>(__f); }
template<typename _Tp>
static bool
@@ -1671,7 +1675,7 @@
{ return true; }
private:
- static void
+ static void
_M_init_functor(_Any_data& __functor, _Functor&& __f, true_type)
{ new (__functor._M_access()) _Functor(std::move(__f)); }
@@ -1701,7 +1705,7 @@
__dest._M_access<_Functor*>() = *_Base::_M_get_pointer(__source);
return is_const<_Functor>::value;
break;
-
+
default:
_Base::_M_manager(__dest, __source, __op);
}
@@ -1717,7 +1721,7 @@
};
_Function_base() : _M_manager(0) { }
-
+
~_Function_base()
{
if (_M_manager)
@@ -1728,7 +1732,7 @@
bool _M_empty() const { return !_M_manager; }
typedef bool (*_Manager_type)(_Any_data&, const _Any_data&,
- _Manager_operation);
+ _Manager_operation);
_Any_data _M_functor;
_Manager_type _M_manager;
@@ -1747,8 +1751,8 @@
static _Res
_M_invoke(const _Any_data& __functor, _ArgTypes... __args)
{
- return (*_Base::_M_get_pointer(__functor))(
- std::forward<_ArgTypes>(__args)...);
+ return (*_Base::_M_get_pointer(__functor))(
+ std::forward<_ArgTypes>(__args)...);
}
};
@@ -1762,8 +1766,8 @@
static void
_M_invoke(const _Any_data& __functor, _ArgTypes... __args)
{
- (*_Base::_M_get_pointer(__functor))(
- std::forward<_ArgTypes>(__args)...);
+ (*_Base::_M_get_pointer(__functor))(
+ std::forward<_ArgTypes>(__args)...);
}
};
@@ -1777,8 +1781,8 @@
static _Res
_M_invoke(const _Any_data& __functor, _ArgTypes... __args)
{
- return __callable_functor(**_Base::_M_get_pointer(__functor))(
- std::forward<_ArgTypes>(__args)...);
+ return __callable_functor(**_Base::_M_get_pointer(__functor))(
+ std::forward<_ArgTypes>(__args)...);
}
};
@@ -1792,32 +1796,32 @@
static void
_M_invoke(const _Any_data& __functor, _ArgTypes... __args)
{
- __callable_functor(**_Base::_M_get_pointer(__functor))(
- std::forward<_ArgTypes>(__args)...);
+ __callable_functor(**_Base::_M_get_pointer(__functor))(
+ std::forward<_ArgTypes>(__args)...);
}
};
- template<typename _Class, typename _Member, typename _Res,
- typename... _ArgTypes>
+ template<typename _Class, typename _Member, typename _Res,
+ typename... _ArgTypes>
class _Function_handler<_Res(_ArgTypes...), _Member _Class::*>
: public _Function_handler<void(_ArgTypes...), _Member _Class::*>
{
typedef _Function_handler<void(_ArgTypes...), _Member _Class::*>
- _Base;
+ _Base;
public:
static _Res
_M_invoke(const _Any_data& __functor, _ArgTypes... __args)
{
- return mem_fn(_Base::_M_get_pointer(__functor)->__value)(
- std::forward<_ArgTypes>(__args)...);
+ return mem_fn(_Base::_M_get_pointer(__functor)->__value)(
+ std::forward<_ArgTypes>(__args)...);
}
};
template<typename _Class, typename _Member, typename... _ArgTypes>
class _Function_handler<void(_ArgTypes...), _Member _Class::*>
: public _Function_base::_Base_manager<
- _Simple_type_wrapper< _Member _Class::* > >
+ _Simple_type_wrapper< _Member _Class::* > >
{
typedef _Member _Class::* _Functor;
typedef _Simple_type_wrapper<_Functor> _Wrapper;
@@ -1826,31 +1830,31 @@
public:
static bool
_M_manager(_Any_data& __dest, const _Any_data& __source,
- _Manager_operation __op)
+ _Manager_operation __op)
{
- switch (__op)
+ switch (__op)
{
#ifdef __GXX_RTTI
case __get_type_info:
__dest._M_access<const type_info*>() = &typeid(_Functor);
break;
-#endif
+#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;
+ return false;
}
static void
_M_invoke(const _Any_data& __functor, _ArgTypes... __args)
{
mem_fn(_Base::_M_get_pointer(__functor)->__value)(
- std::forward<_ArgTypes>(__args)...);
+ std::forward<_ArgTypes>(__args)...);
}
};
@@ -1866,26 +1870,26 @@
private _Function_base
{
typedef _Res _Signature_type(_ArgTypes...);
-
+
struct _Useless { };
-
+
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() : _Function_base() { }
-
+
/**
* @brief Creates an empty function call wrapper.
* @post @c !(bool)*this
*/
function(nullptr_t) : _Function_base() { }
-
+
/**
* @brief %Function copy constructor.
* @param x A %function object with identical call signature.
@@ -1905,11 +1909,11 @@
*/
function(function&& __x) : _Function_base()
{
- __x.swap(*this);
+ __x.swap(*this);
}
// TODO: needs allocator_arg_t
-
+
/**
* @brief Builds a %function that targets a copy of the incoming
* function object.
@@ -1927,10 +1931,10 @@
* reference_wrapper<F>, this function will not throw.
*/
template<typename _Functor>
- function(_Functor __f,
- typename enable_if<
- !is_integral<_Functor>::value, _Useless>::type
- = _Useless());
+ function(_Functor __f,
+ typename enable_if<
+ !is_integral<_Functor>::value, _Useless>::type
+ = _Useless());
/**
* @brief %Function assignment operator.
@@ -1947,8 +1951,8 @@
function&
operator=(const function& __x)
{
- function(__x).swap(*this);
- return *this;
+ function(__x).swap(*this);
+ return *this;
}
/**
@@ -1965,8 +1969,8 @@
function&
operator=(function&& __x)
{
- function(std::move(__x)).swap(*this);
- return *this;
+ function(std::move(__x)).swap(*this);
+ return *this;
}
/**
@@ -1979,13 +1983,13 @@
function&
operator=(nullptr_t)
{
- if (_M_manager)
+ if (_M_manager)
{
_M_manager(_M_functor, _M_functor, __destroy_functor);
_M_manager = 0;
_M_invoker = 0;
}
- return *this;
+ return *this;
}
/**
@@ -2005,7 +2009,7 @@
* reference_wrapper<F>, this function will not throw.
*/
template<typename _Functor>
- typename enable_if<!is_integral<_Functor>::value, function&>::type
+ typename enable_if<!is_integral<_Functor>::value, function&>::type
operator=(_Functor&& __f)
{
function(std::forward<_Functor>(__f)).swap(*this);
@@ -2014,7 +2018,7 @@
/// @overload
template<typename _Functor>
- typename enable_if<!is_integral<_Functor>::value, function&>::type
+ typename enable_if<!is_integral<_Functor>::value, function&>::type
operator=(reference_wrapper<_Functor> __f)
{
function(__f).swap(*this);
@@ -2022,7 +2026,7 @@
}
// [3.7.2.2] function modifiers
-
+
/**
* @brief Swap the targets of two %function objects.
* @param f A %function with identical call signature.
@@ -2040,14 +2044,14 @@
// TODO: needs allocator_arg_t
/*
template<typename _Functor, typename _Alloc>
- void
- assign(_Functor&& __f, const _Alloc& __a)
- {
- function(allocator_arg, __a,
- std::forward<_Functor>(__f)).swap(*this);
- }
+ void
+ assign(_Functor&& __f, const _Alloc& __a)
+ {
+ function(allocator_arg, __a,
+ std::forward<_Functor>(__f)).swap(*this);
+ }
*/
-
+
// [3.7.2.3] function capacity
/**
@@ -2085,7 +2089,7 @@
* This function will not throw an %exception.
*/
const type_info& target_type() const;
-
+
/**
* @brief Access the stored target function object.
*
@@ -2096,7 +2100,7 @@
* This function will not throw an %exception.
*/
template<typename _Functor> _Functor* target();
-
+
/// @overload
template<typename _Functor> const _Functor* target() const;
#endif
@@ -2125,7 +2129,7 @@
function<_Res(_ArgTypes...)>::
function(_Functor __f,
typename enable_if<
- !is_integral<_Functor>::value, _Useless>::type)
+ !is_integral<_Functor>::value, _Useless>::type)
: _Function_base()
{
typedef _Function_handler<_Signature_type, _Functor> _My_handler;
@@ -2144,7 +2148,7 @@
operator()(_ArgTypes... __args) const
{
if (_M_empty())
- __throw_bad_function_call();
+ __throw_bad_function_call();
return _M_invoker(_M_functor, std::forward<_ArgTypes>(__args)...);
}
@@ -2155,11 +2159,11 @@
target_type() const
{
if (_M_manager)
- {
- _Any_data __typeinfo_result;
- _M_manager(__typeinfo_result, _M_functor, __get_type_info);
- return *__typeinfo_result._M_access<const type_info*>();
- }
+ {
+ _Any_data __typeinfo_result;
+ _M_manager(__typeinfo_result, _M_functor, __get_type_info);
+ return *__typeinfo_result._M_access<const type_info*>();
+ }
else
return typeid(void);
}
Index: include/bits/shared_ptr_base.h
===================================================================
--- include/bits/shared_ptr_base.h (revision 170943)
+++ include/bits/shared_ptr_base.h (working copy)
@@ -61,8 +61,9 @@
{
public:
virtual char const*
- what() const throw()
- { return "std::bad_weak_ptr"; }
+ what() const throw();
+
+ virtual ~bad_weak_ptr() throw();
};
// Substitute for bad_weak_ptr object in the case of -fno-exceptions.
Index: libsupc++/nested_exception.cc
===================================================================
--- libsupc++/nested_exception.cc (revision 0)
+++ libsupc++/nested_exception.cc (revision 0)
@@ -0,0 +1,29 @@
+// Copyright (C) 2011 Free Software Foundation
+//
+// This file is part of GCC.
+//
+// GCC 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.
+
+// GCC 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/>.
+
+#include <exception>
+
+namespace std
+{
+ nested_exception::~nested_exception() = default;
+} // namespace std
Index: libsupc++/nested_exception.h
===================================================================
--- libsupc++/nested_exception.h (revision 170943)
+++ libsupc++/nested_exception.h (working copy)
@@ -63,7 +63,7 @@
nested_exception& operator=(const nested_exception&) = default;
- inline virtual ~nested_exception();
+ virtual ~nested_exception();
void
rethrow_nested() const __attribute__ ((__noreturn__))
@@ -74,8 +74,6 @@
{ return _M_ptr; }
};
- inline nested_exception::~nested_exception() = default;
-
template<typename _Except>
struct _Nested_exception : public _Except, public nested_exception
{
Index: libsupc++/Makefile.am
===================================================================
--- libsupc++/Makefile.am (revision 170943)
+++ libsupc++/Makefile.am (working copy)
@@ -77,6 +77,7 @@
guard.cc \
guard_error.cc \
hash_bytes.cc \
+ nested_exception.cc \
new_handler.cc \
new_op.cc \
new_opnt.cc \
@@ -134,6 +135,11 @@
$(C_COMPILE) -DIN_GLIBCPP_V3 -Wno-error -c $<
+nested_exception.lo: nested_exception.cc
+ $(LTCXXCOMPILE) -std=gnu++0x -c $<
+nested_exception.o: nested_exception.cc
+ $(CXXCOMPILE) -std=gnu++0x -c $<
+
# Libtool notes
# 1) Need to explicitly set LTCXXCOMPILE so that AM_CXXFLAGS is
Index: testsuite/20_util/shared_ptr/cons/43820_neg.cc
===================================================================
--- testsuite/20_util/shared_ptr/cons/43820_neg.cc (revision 170943)
+++ testsuite/20_util/shared_ptr/cons/43820_neg.cc (working copy)
@@ -32,9 +32,9 @@
{
X* px = 0;
std::shared_ptr<X> p1(px); // { dg-error "here" }
- // { dg-error "incomplete" "" { target *-*-* } 765 }
+ // { dg-error "incomplete" "" { target *-*-* } 766 }
std::shared_ptr<X> p9(ap()); // { dg-error "here" }
- // { dg-error "incomplete" "" { target *-*-* } 857 }
+ // { dg-error "incomplete" "" { target *-*-* } 858 }
}
Index: testsuite/20_util/weak_ptr/comparison/cmp_neg.cc
===================================================================
--- testsuite/20_util/weak_ptr/comparison/cmp_neg.cc (revision 170943)
+++ testsuite/20_util/weak_ptr/comparison/cmp_neg.cc (working copy)
@@ -43,7 +43,7 @@
}
// { dg-warning "note" "" { target *-*-* } 354 }
-// { dg-warning "note" "" { target *-*-* } 1085 }
+// { dg-warning "note" "" { target *-*-* } 1086 }
// { dg-warning "note" "" { target *-*-* } 467 }
// { dg-warning "note" "" { target *-*-* } 587 }
// { dg-warning "note" "" { target *-*-* } 1050 }
Index: config/abi/pre/gnu.ver
===================================================================
--- config/abi/pre/gnu.ver (revision 170943)
+++ config/abi/pre/gnu.ver (working copy)
@@ -124,7 +124,7 @@
std::messages*;
std::money*;
# std::n[^u]*;
- std::n[^au]*;
+ std::n[^aue]*;
std::nu[^m]*;
std::num[^e]*;
std::ostrstream*;
@@ -1219,6 +1219,21 @@
_ZTISt11regex_error;
_ZSt19__throw_regex_errorNSt15regex_constants10error_typeE;
+ _ZNSt12bad_weak_ptrD*;
+ _ZNKSt12bad_weak_ptr4whatEv;
+ _ZTSSt12bad_weak_ptr;
+ _ZTVSt12bad_weak_ptr;
+ _ZTISt12bad_weak_ptr;
+
+ _ZNSt14error_categoryC*;
+ _ZNSt14error_categoryD*;
+
+ _ZNSt13__future_base12_Result_baseC*;
+ _ZNSt13__future_base12_Result_baseD*;
+ _ZTINSt13__future_base12_Result_baseE;
+ _ZTSNSt13__future_base12_Result_baseE;
+ _ZTVNSt13__future_base12_Result_baseE;
+
} GLIBCXX_3.4.14;
# Symbols in the support library (libsupc++) have their own tag.
@@ -1403,4 +1418,10 @@
_ZTSSt17bad_function_call;
_ZTVSt17bad_function_call;
+ # std::nested_exception
+ _ZNSt16nested_exceptionD*;
+ _ZTISt16nested_exception;
+ _ZTSSt16nested_exception;
+ _ZTVSt16nested_exception;
+
} CXXABI_1.3.4;