Patchwork [v3] typeinfo tuning

login
register
mail settings
Submitter Benjamin Kosnik
Date March 14, 2011, 5:29 p.m.
Message ID <20110314102944.565db3c8@shotwell>
Download mbox | patch
Permalink /patch/86780/
State New
Headers show

Comments

Benjamin Kosnik - March 14, 2011, 5:29 p.m.
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
Jonathan Wakely - March 15, 2011, 11:45 a.m.
On 14 March 2011 17:29, Benjamin Kosnik wrote:
>
> 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.

Does exporting some of these symbols and vtables from the library mean
we're less able to change them?  I'm not confident all ofthe C++0x
bits are entirely stable yet.

I see you've given future_base::_Result_base a virtual destructor, is
there a specific reason for that?  Destruction should always be via
the virtual _M_destroy function and so 'delete' is called in the final
overrider, where the static type and dynamic type are the same. The
virtual destructor adds unnecessary overhead, though it's probably
negligible.
Benjamin Kosnik - March 15, 2011, 7:19 p.m.
> Does exporting some of these symbols and vtables from the library mean
> we're less able to change them?  I'm not confident all ofthe C++0x
> bits are entirely stable yet.

Yes, it does. What are the new exports that concern you? 

There are some things I purposely did not include. For instance,
<regex>. Some of <future> can be further optimized for the void
specializations, but I did not do that to give implementation
flexibility in the future. 

> I see you've given future_base::_Result_base a virtual destructor, is
> there a specific reason for that?  

Yes...

> Destruction should always be via
> the virtual _M_destroy function and so 'delete' is called in the final
> overrider, where the static type and dynamic type are the same. The
> virtual destructor adds unnecessary overhead, though it's probably
> negligible.

Yeah on negligible. I don't see the addition as a correctness issue,
right? The __future_base nested classes don't seem to be changing all
that much, but I will defer to you if you are uneasy about specific
changes.

Doing this may allow the control of all vague symbols in <future> for
standard instantiations in the future. 

best,
-benjamin
Jonathan Wakely - March 15, 2011, 8:15 p.m.
On 15 March 2011 19:19, Benjamin Kosnik wrote:
>
>> Does exporting some of these symbols and vtables from the library mean
>> we're less able to change them?  I'm not confident all ofthe C++0x
>> bits are entirely stable yet.
>
> Yes, it does. What are the new exports that concern you?

thread::_Impl_base was one I'd been prototyping some changes to. If we
need to rework it in order for thread::id to be a trivially-copyable
(and less-than-comparable) type then we might need additional virtuals
in Impl_base, but as all I have are untested ideas for now it probably
shouldn't hold up the changes.  We could always preserve the old type
and use a new one for any rework needed.

> There are some things I purposely did not include. For instance,
> <regex>. Some of <future> can be further optimized for the void
> specializations, but I did not do that to give implementation
> flexibility in the future.
>
>> I see you've given future_base::_Result_base a virtual destructor, is
>> there a specific reason for that?
>
> Yes...
>
>> Destruction should always be via
>> the virtual _M_destroy function and so 'delete' is called in the final
>> overrider, where the static type and dynamic type are the same. The
>> virtual destructor adds unnecessary overhead, though it's probably
>> negligible.
>
> Yeah on negligible. I don't see the addition as a correctness issue,
> right? The __future_base nested classes don't seem to be changing all
> that much, but I will defer to you if you are uneasy about specific
> changes.
>
> Doing this may allow the control of all vague symbols in <future> for
> standard instantiations in the future.

OK, I'm not objecting to the change as all I have is a non-specific
sense of unease and
the advantages outweigh my slight uneasiness :)
Benjamin Kosnik - March 15, 2011, 11:22 p.m.
> thread::_Impl_base was one I'd been prototyping some changes to. If we
> need to rework it in order for thread::id to be a trivially-copyable
> (and less-than-comparable) type then we might need additional virtuals
> in Impl_base, but as all I have are untested ideas for now it probably
> shouldn't hold up the changes.  We could always preserve the old type
> and use a new one for any rework needed.

Eh, I'll revert this part.

-benjamin
Marc Glisse - March 16, 2011, 10:27 a.m.
On Mon, 14 Mar 2011, Benjamin Kosnik wrote:

> 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.

Could that be related to the fact that I now keep getting linker errors 
about std::range_error::~range_error() being undefined?
The .o file is looking for _ZNSt11range_errorD2Ev but libstdc++ has D0Ev 
and D1Ev.

Patch

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;