Patchwork [v3] typeinfo tuning

login
register
mail settings
Submitter Benjamin Kosnik
Date March 15, 2011, 2:59 a.m.
Message ID <20110314195940.02ee5099@shotwell>
Download mbox | patch
Permalink /patch/86843/
State New
Headers show

Comments

Benjamin Kosnik - March 15, 2011, 2:59 a.m.
> 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.

Here is the complete set. 

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

This is versioned for 4.6.0, but I'll wait a day or two to see how it
goes before I plead with the RMs.

tested x86_64/linux

-benjamin
Hans-Peter Nilsson - March 15, 2011, 4:17 a.m.
On Mon, 14 Mar 2011, Benjamin Kosnik wrote:
> This is versioned for 4.6.0, but I'll wait a day or two to see how it
> goes before I plead with the RMs.

It broke build, hopefully for trivial reasons.  It seems like
your bugzilla options are set to not receive email, so I'll have
to bug you like this, and ask that you please have a look at
PR48130.

> tested x86_64/linux

Broke cris-elf (et al, presumably).

brgds, H-P

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.
	* src/thread.cc: Add dtor for thread::_Impl_base.
	* include/std/system_error: Adjust.
	* include/std/stdexcept: Same.
	* include/std/future: Same.
	* include/std/functional: Same.
	* include/std/thread: 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.

	* include/bits/regex_compiler.h: Nest namespace versioning.
	* include/bits/regex_grep_matcher.tcc: Same.
	* include/bits/regex_grep_matcher.h: Same.
	* include/bits/regex_cursor.h: Same.
	* include/bits/regex_nfa.h: Same.
	* include/bits/regex_nfa.tcc: Same.


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 170967)
+++ 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 170967)
+++ 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 170967)
+++ src/future.cc	(working copy)
@@ -79,8 +79,14 @@ 
   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;
+
+  __future_base::_State_base::~_State_base() = default;
+
 _GLIBCXX_END_NAMESPACE_VERSION
-} // namespace
+} // namespace std
 
 // XXX GLIBCXX_ABI Deprecated
 // gcc-4.6.0
Index: src/thread.cc
===================================================================
--- src/thread.cc	(revision 170967)
+++ src/thread.cc	(working copy)
@@ -54,6 +54,8 @@ 
 
 _GLIBCXX_BEGIN_NAMESPACE_VERSION
 
+  thread::_Impl_base::~_Impl_base() = default;
+
   void
   thread::join()
   {
Index: src/Makefile.am
===================================================================
--- src/Makefile.am	(revision 170967)
+++ 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 170967)
+++ 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 170967)
+++ 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/thread
===================================================================
--- include/std/thread	(revision 170967)
+++ include/std/thread	(working copy)
@@ -100,7 +100,7 @@ 
     {
       __shared_base_type	_M_this_ptr;
 
-      inline virtual ~_Impl_base();
+      virtual ~_Impl_base();
 
       virtual void _M_run() = 0;
     };
@@ -195,8 +195,6 @@ 
       }
   };
 
-  inline thread::_Impl_base::~_Impl_base() = default;
-
   inline void
   swap(thread& __x, thread& __y)
   { __x.swap(__y); }
Index: include/std/future
===================================================================
--- include/std/future	(revision 170967)
+++ 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.
@@ -273,8 +273,9 @@ 
       }
 
 
-    /// Shared state between a promise and one or more associated futures.
-    class _State
+    /// Base class for state between a promise and one or more
+    /// associated futures.
+    class _State_base
     {
       typedef _Ptr<_Result_base>::type _Ptr_type;
 
@@ -285,18 +286,18 @@ 
       once_flag			_M_once;
 
     public:
-      _State() : _M_result(), _M_retrieved(ATOMIC_FLAG_INIT) { }
+      _State_base() : _M_result(), _M_retrieved(ATOMIC_FLAG_INIT) { }
+      _State_base(const _State_base&) = delete;
+      _State_base& operator=(const _State_base&) = delete;
+      virtual ~_State_base();
 
-      _State(const _State&) = delete;
-      _State& operator=(const _State&) = delete;
-
       _Result_base&
       wait()
       {
 	_M_run_deferred();
 	unique_lock<mutex> __lock(_M_mutex);
 	if (!_M_ready())
-	  _M_cond.wait(__lock, std::bind<bool>(&_State::_M_ready, this));
+	  _M_cond.wait(__lock, std::bind<bool>(&_State_base::_M_ready, this));
 	return *_M_result;
       }
 
@@ -305,7 +306,7 @@ 
         wait_for(const chrono::duration<_Rep, _Period>& __rel)
         {
 	  unique_lock<mutex> __lock(_M_mutex);
-	  auto __bound = std::bind<bool>(&_State::_M_ready, this);
+	  auto __bound = std::bind<bool>(&_State_base::_M_ready, this);
 	  return _M_ready() || _M_cond.wait_for(__lock, __rel, __bound);
 	}
 
@@ -314,7 +315,7 @@ 
         wait_until(const chrono::time_point<_Clock, _Duration>& __abs)
         {
 	  unique_lock<mutex> __lock(_M_mutex);
-	  auto __bound = std::bind<bool>(&_State::_M_ready, this);
+	  auto __bound = std::bind<bool>(&_State_base::_M_ready, this);
 	  return _M_ready() || _M_cond.wait_until(__lock, __abs, __bound);
 	}
 
@@ -324,7 +325,7 @@ 
         bool __set = __ignore_failure;
         // all calls to this function are serialized,
         // side-effects of invoking __res only happen once
-        call_once(_M_once, &_State::_M_do_set, this, ref(__res),
+        call_once(_M_once, &_State_base::_M_do_set, this, ref(__res),
             ref(__set));
         if (!__set)
           __throw_future_error(int(future_errc::promise_already_satisfied));
@@ -368,7 +369,7 @@ 
 
           typename promise<_Res>::_Ptr_type operator()()
           {
-            _State::_S_check(_M_promise->_M_future);
+            _State_base::_S_check(_M_promise->_M_future);
             _M_promise->_M_storage->_M_set(_M_arg);
             return std::move(_M_promise->_M_storage);
           }
@@ -382,7 +383,7 @@ 
         {
           typename promise<_Res>::_Ptr_type operator()()
           {
-            _State::_S_check(_M_promise->_M_future);
+            _State_base::_S_check(_M_promise->_M_future);
             _M_promise->_M_storage->_M_set(std::move(_M_arg));
             return std::move(_M_promise->_M_storage);
           }
@@ -398,7 +399,7 @@ 
         {
           typename promise<_Res>::_Ptr_type operator()()
           {
-            _State::_S_check(_M_promise->_M_future);
+            _State_base::_S_check(_M_promise->_M_future);
             _M_promise->_M_storage->_M_error = _M_ex;
             return std::move(_M_promise->_M_storage);
           }
@@ -463,8 +464,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
@@ -495,7 +494,7 @@ 
     class __basic_future : public __future_base
     {
     protected:
-      typedef shared_ptr<_State>		__state_type;
+      typedef shared_ptr<_State_base>		__state_type;
       typedef __future_base::_Result<_Res>&	__result_type;
 
     private:
@@ -512,7 +511,7 @@ 
       void 
       wait() const
       {
-        _State::_S_check(_M_state);
+        _State_base::_S_check(_M_state);
         _M_state->wait();
       }
 
@@ -520,7 +519,7 @@ 
         bool
         wait_for(const chrono::duration<_Rep, _Period>& __rel) const
         {
-          _State::_S_check(_M_state);
+          _State_base::_S_check(_M_state);
           return _M_state->wait_for(__rel);
         }
 
@@ -528,7 +527,7 @@ 
         bool
         wait_until(const chrono::time_point<_Clock, _Duration>& __abs) const
         {
-          _State::_S_check(_M_state);
+          _State_base::_S_check(_M_state);
           return _M_state->wait_until(__abs);
         }
 
@@ -537,7 +536,7 @@ 
       __result_type
       _M_get_result()
       {
-        _State::_S_check(_M_state);
+        _State_base::_S_check(_M_state);
         _Result_base& __res = _M_state->wait();
         if (!(__res._M_error == 0))
           rethrow_exception(__res._M_error);
@@ -553,7 +552,7 @@ 
       explicit
       __basic_future(const __state_type& __state) : _M_state(__state)
       {
-        _State::_S_check(_M_state);
+        _State_base::_S_check(_M_state);
         _M_state->_M_set_retrieved_flag();
       }
 
@@ -850,9 +849,9 @@ 
   template<typename _Res>
     class promise
     {
-      typedef __future_base::_State 		_State;
-      typedef __future_base::_Result<_Res>	_Res_type;
-      typedef typename __future_base::_Ptr<_Res_type>::type _Ptr_type;
+      typedef __future_base::_State_base 			_State;
+      typedef __future_base::_Result<_Res>			_Res_type;
+      typedef typename __future_base::_Ptr<_Res_type>::type	_Ptr_type;
       template<typename, typename> friend class _State::_Setter;
       
       shared_ptr<_State>                        _M_future;
@@ -942,9 +941,9 @@ 
   template<typename _Res>
     class promise<_Res&>
     {
-      typedef __future_base::_State 		_State;
-      typedef __future_base::_Result<_Res&>	_Res_type;
-      typedef typename __future_base::_Ptr<_Res_type>::type _Ptr_type;
+      typedef __future_base::_State_base			_State;
+      typedef __future_base::_Result<_Res&>			_Res_type;
+      typedef typename __future_base::_Ptr<_Res_type>::type 	_Ptr_type;
       template<typename, typename> friend class _State::_Setter;
 
       shared_ptr<_State>                        _M_future;
@@ -1017,9 +1016,9 @@ 
   template<>
     class promise<void>
     {
-      typedef __future_base::_State 		_State;
-      typedef __future_base::_Result<void>	_Res_type;
-      typedef typename __future_base::_Ptr<_Res_type>::type _Ptr_type;
+      typedef __future_base::_State_base			_State;
+      typedef __future_base::_Result<void>			_Res_type;
+      typedef typename __future_base::_Ptr<_Res_type>::type 	_Ptr_type;
       template<typename, typename> friend class _State::_Setter;
 
       shared_ptr<_State>                        _M_future;
@@ -1085,19 +1084,19 @@ 
 
   // set void
   template<>
-    struct __future_base::_State::_Setter<void, void>
+    struct __future_base::_State_base::_Setter<void, void>
     {
       promise<void>::_Ptr_type operator()()
       {
-        _State::_S_check(_M_promise->_M_future);
+        _State_base::_S_check(_M_promise->_M_future);
         return std::move(_M_promise->_M_storage);
       }
 
       promise<void>*    _M_promise;
     };
 
-  inline __future_base::_State::_Setter<void, void>
-  __future_base::_State::__setter(promise<void>* __prom)
+  inline __future_base::_State_base::_Setter<void, void>
+  __future_base::_State_base::__setter(promise<void>* __prom)
   {
     return _Setter<void, void>{ __prom };
   }
@@ -1149,7 +1148,8 @@ 
     };
 
   template<typename _Res, typename... _Args>
-    struct __future_base::_Task_state<_Res(_Args...)> : __future_base::_State
+    struct __future_base::_Task_state<_Res(_Args...)> 
+    : __future_base::_State_base
     {
       typedef _Res _Res_type;
 
@@ -1263,14 +1263,14 @@ 
       void
       operator()(_ArgTypes... __args)
       {
-        __future_base::_State::_S_check(_M_state);
+        __future_base::_State_base::_S_check(_M_state);
         _M_state->_M_run(std::forward<_ArgTypes>(__args)...);
       }
 
       void
       reset()
       {
-        __future_base::_State::_S_check(_M_state);
+        __future_base::_State_base::_S_check(_M_state);
         packaged_task(std::move(_M_state->_M_task)).swap(*this);
       }
     };
@@ -1288,7 +1288,7 @@ 
 
 
   template<typename _Res>
-    class __future_base::_Deferred_state : public __future_base::_State
+    class __future_base::_Deferred_state : public __future_base::_State_base
     {
     public:
       typedef _Res _Res_type;
@@ -1314,7 +1314,7 @@ 
     };
 
   template<typename _Res>
-    class __future_base::_Async_state : public __future_base::_State
+    class __future_base::_Async_state : public __future_base::_State_base
     {
     public:
       typedef _Res _Res_type;
@@ -1347,7 +1347,7 @@ 
     async(launch __policy, _Fn&& __fn, _Args&&... __args)
     {
       typedef typename result_of<_Fn(_Args...)>::type result_type;
-      std::shared_ptr<__future_base::_State> __state;
+      std::shared_ptr<__future_base::_State_base> __state;
       if (__policy == launch::async)
 	{
 	  typedef typename __future_base::_Async_state<result_type> _State;
Index: include/std/functional
===================================================================
--- include/std/functional	(revision 170967)
+++ 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/regex_compiler.h
===================================================================
--- include/bits/regex_compiler.h	(revision 170967)
+++ include/bits/regex_compiler.h	(working copy)
@@ -30,10 +30,10 @@ 
 
 namespace std _GLIBCXX_VISIBILITY(default)
 {
+namespace __regex
+{
 _GLIBCXX_BEGIN_NAMESPACE_VERSION
 
-namespace __regex
-{
   struct _Scanner_base
   {
     typedef unsigned int _StateT;
@@ -41,6 +41,8 @@ 
     static constexpr _StateT _S_state_at_start    = 1 << 0;
     static constexpr _StateT _S_state_in_brace    = 1 << 2;
     static constexpr _StateT _S_state_in_bracket  = 1 << 3;
+
+    virtual ~_Scanner_base() { };
   };
 
   //
@@ -1100,9 +1102,8 @@ 
     { return _AutomatonPtr(new _Nfa(_Compiler<_InIter, _TraitsT>(__b, __e, __t,
                                         __f)._M_nfa())); }
 
+_GLIBCXX_END_NAMESPACE_VERSION
 } // namespace __regex
+} // namespace std
 
-_GLIBCXX_END_NAMESPACE_VERSION
-} // namespace
-
 /* vim: set ts=8 sw=2 sts=2: */
Index: include/bits/regex_grep_matcher.tcc
===================================================================
--- include/bits/regex_grep_matcher.tcc	(revision 170967)
+++ include/bits/regex_grep_matcher.tcc	(working copy)
@@ -32,11 +32,8 @@ 
 
 namespace std _GLIBCXX_VISIBILITY(default)
 {
-_GLIBCXX_BEGIN_NAMESPACE_VERSION
-
 namespace
 {
-
   // A stack of states used in evaluating the NFA.
   typedef std::stack<std::__regex::_StateIdT,
                      std::vector<std::__regex::_StateIdT>
@@ -104,6 +101,8 @@ 
 
 namespace __regex
 {
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
   inline _Grep_matcher::
   _Grep_matcher(_PatternCursor& __p, _Results& __r,
 		const _AutomatonPtr& __nfa,
@@ -175,7 +174,6 @@ 
     return __e;
   }
 
-} // namespace __regex
-
 _GLIBCXX_END_NAMESPACE_VERSION
+} // namespace __regex
 } // namespace
Index: include/bits/regex_grep_matcher.h
===================================================================
--- include/bits/regex_grep_matcher.h	(revision 170967)
+++ include/bits/regex_grep_matcher.h	(working copy)
@@ -30,7 +30,6 @@ 
 
 namespace std _GLIBCXX_VISIBILITY(default)
 {
-_GLIBCXX_BEGIN_NAMESPACE_VERSION
 
   template<typename _BiIter>
     class sub_match;
@@ -40,6 +39,8 @@ 
   
 namespace __regex
 {
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
   // A _Results facade specialized for wrapping a templated match_results.
   template<typename _FwdIterT, typename _Alloc>
     class _SpecializedResults
@@ -121,9 +122,8 @@ 
     _Results&                          _M_results;
   };
 
+_GLIBCXX_END_NAMESPACE_VERSION
 } // namespace __regex
-
-_GLIBCXX_END_NAMESPACE_VERSION
 } // namespace
 
 #include <bits/regex_grep_matcher.tcc>
Index: include/bits/regex_cursor.h
===================================================================
--- include/bits/regex_cursor.h	(revision 170967)
+++ include/bits/regex_cursor.h	(working copy)
@@ -30,10 +30,10 @@ 
 
 namespace std _GLIBCXX_VISIBILITY(default)
 {
-_GLIBCXX_BEGIN_NAMESPACE_VERSION
-
 namespace __regex
 {
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
   // ABC for pattern matching
   struct _PatternCursor
   {
@@ -88,7 +88,6 @@ 
     __cursor(const _FwdIterT& __b, const _FwdIterT __e)
     { return _SpecializedCursor<_FwdIterT>(__b, __e); }
 
-} // namespace __regex
-
 _GLIBCXX_END_NAMESPACE_VERSION
+} // namespace __regex
 } // namespace
Index: include/bits/regex_nfa.tcc
===================================================================
--- include/bits/regex_nfa.tcc	(revision 170967)
+++ include/bits/regex_nfa.tcc	(working copy)
@@ -1,6 +1,6 @@ 
 // class template regex -*- C++ -*-
 
-// Copyright (C) 2010 Free Software Foundation, Inc.
+// Copyright (C) 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
@@ -31,10 +31,10 @@ 
 
 namespace std _GLIBCXX_VISIBILITY(default)
 {
-_GLIBCXX_BEGIN_NAMESPACE_VERSION
-
 namespace __regex
 {
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
 #ifdef _GLIBCXX_DEBUG
 inline std::ostream& _State::
 _M_print(std::ostream& ostr) const
@@ -169,7 +169,6 @@ 
 _M_clone()
 { return 0; }
 
-} // namespace __regex
-
 _GLIBCXX_END_NAMESPACE_VERSION
+} // namespace __regex
 } // namespace
Index: include/bits/shared_ptr_base.h
===================================================================
--- include/bits/shared_ptr_base.h	(revision 170967)
+++ 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: include/bits/regex_nfa.h
===================================================================
--- include/bits/regex_nfa.h	(revision 170967)
+++ include/bits/regex_nfa.h	(working copy)
@@ -30,10 +30,9 @@ 
 
 namespace std _GLIBCXX_VISIBILITY(default)
 {
-_GLIBCXX_BEGIN_NAMESPACE_VERSION
-
 namespace __regex
 {
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
 
   // Base class for, um, automata.  Could be an NFA or a DFA.  Your choice.
   class _Automaton
@@ -43,8 +42,7 @@ 
 
   public:
     virtual
-    ~_Automaton()
-    { }
+    ~_Automaton() { }
 
     virtual _SizeT
     _M_sub_count() const = 0;
@@ -394,10 +392,9 @@ 
 
   };
 
+_GLIBCXX_END_NAMESPACE_VERSION
 } // namespace __regex
+} // namespace std
 
-_GLIBCXX_END_NAMESPACE_VERSION
-} // namespace
-
 #include <bits/regex_nfa.tcc>
 
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 170967)
+++ 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 170967)
+++ 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 170967)
+++ 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 170967)
+++ 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 170967)
+++ 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,31 @@ 
     _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;
+
+    _ZNSt13__future_base11_State_baseD*;
+    _ZTINSt13__future_base11_State_baseE;
+    _ZTSNSt13__future_base11_State_baseE;
+    _ZTVNSt13__future_base11_State_baseE;
+
+    _ZNSt6thread10_Impl_baseD*;
+    _ZTINSt6thread10_Impl_baseE;
+    _ZTSNSt6thread10_Impl_baseE;
+    _ZTVNSt6thread10_Impl_baseE;
+
 } GLIBCXX_3.4.14;
 
 # Symbols in the support library (libsupc++) have their own tag.
@@ -1403,4 +1428,10 @@ 
     _ZTSSt17bad_function_call;
     _ZTVSt17bad_function_call;
 
+    # std::nested_exception
+    _ZNSt16nested_exceptionD*;
+    _ZTISt16nested_exception;
+    _ZTSSt16nested_exception;
+    _ZTVSt16nested_exception;
+
 } CXXABI_1.3.4;