Makefile.am: Add functional.cc, shared_ptr.cc.

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.

From-SVN: r170975

libstdc++-v3/ChangeLog

+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.
+
 2011-03-14  Rainer Orth  <ro@CeBiTec.Uni-Bielefeld.DE>
 
 	* doc/xml/manual/abi.xml: Replace docs.sun.com URLs by their OTN

libstdc++-v3/config/abi/pre/gnu.ver

@@ -124,7 +124,7 @@ GLIBCXX_3.4 {
       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 @@ GLIBCXX_3.4.15 {
     _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 @@ CXXABI_1.3.5 {
     _ZTSSt17bad_function_call;
     _ZTVSt17bad_function_call;
 
+    # std::nested_exception
+    _ZNSt16nested_exceptionD*;
+    _ZTISt16nested_exception;
+    _ZTSSt16nested_exception;
+    _ZTVSt16nested_exception;
+
 } CXXABI_1.3.4;

libstdc++-v3/include/bits/regex_compiler.h

@@ -30,10 +30,10 @@
 
 namespace std _GLIBCXX_VISIBILITY(default)
 {
-_GLIBCXX_BEGIN_NAMESPACE_VERSION
-
 namespace __regex
 {
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
   struct _Scanner_base
   {
     typedef unsigned int _StateT;
@@ -41,6 +41,8 @@ namespace __regex
     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 @@ namespace __regex
     { return _AutomatonPtr(new _Nfa(_Compiler<_InIter, _TraitsT>(__b, __e, __t,
                                         __f)._M_nfa())); }
 
-} // namespace __regex
-
 _GLIBCXX_END_NAMESPACE_VERSION
-} // namespace
+} // namespace __regex
+} // namespace std
 
 /* vim: set ts=8 sw=2 sts=2: */

libstdc++-v3/include/bits/regex_cursor.h

@@ -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 @@ namespace __regex
     __cursor(const _FwdIterT& __b, const _FwdIterT __e)
     { return _SpecializedCursor<_FwdIterT>(__b, __e); }
 
-} // namespace __regex
-
 _GLIBCXX_END_NAMESPACE_VERSION
+} // namespace __regex
 } // namespace

libstdc++-v3/include/bits/regex_grep_matcher.h

@@ -30,7 +30,6 @@
 
 namespace std _GLIBCXX_VISIBILITY(default)
 {
-_GLIBCXX_BEGIN_NAMESPACE_VERSION
 
   template<typename _BiIter>
     class sub_match;
@@ -40,6 +39,8 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
   
 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 @@ namespace __regex
     _Results&                          _M_results;
   };
 
-} // namespace __regex
-
 _GLIBCXX_END_NAMESPACE_VERSION
+} // namespace __regex
 } // namespace
 
 #include <bits/regex_grep_matcher.tcc>

libstdc++-v3/include/bits/regex_grep_matcher.tcc

@@ -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
 
 namespace __regex
 {
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
   inline _Grep_matcher::
   _Grep_matcher(_PatternCursor& __p, _Results& __r,
 		const _AutomatonPtr& __nfa,
@@ -175,7 +174,6 @@ namespace __regex
     return __e;
   }
 
-} // namespace __regex
-
 _GLIBCXX_END_NAMESPACE_VERSION
+} // namespace __regex
 } // namespace

libstdc++-v3/include/bits/regex_nfa.h

@@ -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 @@ namespace __regex
 
   public:
     virtual
-    ~_Automaton()
-    { }
+    ~_Automaton() { }
 
     virtual _SizeT
     _M_sub_count() const = 0;
@@ -394,10 +392,9 @@ namespace __regex
 
   };
 
-} // namespace __regex
-
 _GLIBCXX_END_NAMESPACE_VERSION
-} // namespace
+} // namespace __regex
+} // namespace std
 
 #include <bits/regex_nfa.tcc>
 

libstdc++-v3/include/bits/regex_nfa.tcc

 // 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 @@ inline _StateIdT _StateSeq::
 _M_clone()
 { return 0; }
 
-} // namespace __regex
-
 _GLIBCXX_END_NAMESPACE_VERSION
+} // namespace __regex
 } // namespace

libstdc++-v3/include/bits/shared_ptr_base.h

@@ -61,8 +61,9 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
   {
   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.

libstdc++-v3/include/std/functional

@@ -83,90 +83,90 @@ _GLIBCXX_HAS_NESTED_TYPE(result_type)
     { };
 
   /// 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 @@ _GLIBCXX_HAS_NESTED_TYPE(result_type)
     {
     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 @@ _GLIBCXX_HAS_NESTED_TYPE(result_type)
     {
     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 @@ _GLIBCXX_HAS_NESTED_TYPE(result_type)
   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 @@ _GLIBCXX_HAS_NESTED_TYPE(result_type)
   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 @@ _GLIBCXX_HAS_NESTED_TYPE(result_type)
       // 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 @@ _GLIBCXX_HAS_NESTED_TYPE(result_type)
       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 @@ _GLIBCXX_HAS_NESTED_TYPE(result_type)
       { 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 @@ _GLIBCXX_HAS_NESTED_TYPE(result_type)
    * 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 @@ _GLIBCXX_HAS_NESTED_TYPE(result_type)
       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 @@ _GLIBCXX_HAS_NESTED_TYPE(result_type)
 
       // 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 @@ _GLIBCXX_HAS_NESTED_TYPE(result_type)
   /// 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 @@ _GLIBCXX_HAS_NESTED_TYPE(result_type)
 
       // 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 @@ _GLIBCXX_HAS_NESTED_TYPE(result_type)
   /// 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 @@ _GLIBCXX_HAS_NESTED_TYPE(result_type)
 
       // 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 @@ _GLIBCXX_HAS_NESTED_TYPE(result_type)
   /// 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 @@ _GLIBCXX_HAS_NESTED_TYPE(result_type)
       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 @@ _GLIBCXX_HAS_NESTED_TYPE(result_type)
       // 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 @@ _GLIBCXX_HAS_NESTED_TYPE(result_type)
 
       // 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 @@ _GLIBCXX_HAS_NESTED_TYPE(result_type)
    *  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 @@ _GLIBCXX_HAS_NESTED_TYPE(result_type)
     : 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 @@ _GLIBCXX_HAS_NESTED_TYPE(result_type)
    */
  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 @@ _GLIBCXX_HAS_NESTED_TYPE(result_type)
    *  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 @@ _GLIBCXX_HAS_NESTED_TYPE(result_type)
        * 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 @@ _GLIBCXX_HAS_NESTED_TYPE(result_type)
     {
     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 @@ _GLIBCXX_HAS_NESTED_TYPE(result_type)
 
     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 @@ _GLIBCXX_HAS_NESTED_TYPE(result_type)
       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 @@ _GLIBCXX_HAS_NESTED_TYPE(result_type)
 	};
 
       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 @@ _GLIBCXX_HAS_NESTED_TYPE(result_type)
       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 @@ _GLIBCXX_HAS_NESTED_TYPE(result_type)
     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 @@ _GLIBCXX_HAS_NESTED_TYPE(result_type)
     {
       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 @@ _GLIBCXX_HAS_NESTED_TYPE(result_type)
 
       // 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 @@ _GLIBCXX_HAS_NESTED_TYPE(result_type)
     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 @@ _GLIBCXX_HAS_NESTED_TYPE(result_type)
 
       // 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 @@ _GLIBCXX_HAS_NESTED_TYPE(result_type)
     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 @@ _GLIBCXX_HAS_NESTED_TYPE(result_type)
       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 @@ _GLIBCXX_HAS_NESTED_TYPE(result_type)
       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 @@ _GLIBCXX_HAS_NESTED_TYPE(result_type)
    *  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 @@ _GLIBCXX_HAS_NESTED_TYPE(result_type)
       {
       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 @@ _GLIBCXX_HAS_NESTED_TYPE(result_type)
 	{
 	  __victim._M_access<_Functor>().~_Functor();
 	}
-	
+
 	// Destroying an object located on the heap.
 	static void
 	_M_destroy(_Any_data& __victim, false_type)
 	{
 	  delete __victim._M_access<_Functor*>();
 	}
-	
+
       public:
 	static bool
 	_M_manager(_Any_data& __dest, const _Any_data& __source,
@@ -1634,7 +1638,7 @@ _GLIBCXX_HAS_NESTED_TYPE(result_type)
 	    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 @@ _GLIBCXX_HAS_NESTED_TYPE(result_type)
 	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 @@ _GLIBCXX_HAS_NESTED_TYPE(result_type)
 	  { 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 @@ _GLIBCXX_HAS_NESTED_TYPE(result_type)
 	      __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 @@ _GLIBCXX_HAS_NESTED_TYPE(result_type)
       };
 
     _Function_base() : _M_manager(0) { }
-    
+
     ~_Function_base()
     {
       if (_M_manager)
@@ -1728,7 +1732,7 @@ _GLIBCXX_HAS_NESTED_TYPE(result_type)
     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 @@ _GLIBCXX_HAS_NESTED_TYPE(result_type)
       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 @@ _GLIBCXX_HAS_NESTED_TYPE(result_type)
       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 @@ _GLIBCXX_HAS_NESTED_TYPE(result_type)
       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 @@ _GLIBCXX_HAS_NESTED_TYPE(result_type)
       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 @@ _GLIBCXX_HAS_NESTED_TYPE(result_type)
      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 @@ _GLIBCXX_HAS_NESTED_TYPE(result_type)
       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 @@ _GLIBCXX_HAS_NESTED_TYPE(result_type)
        */
       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 @@ _GLIBCXX_HAS_NESTED_TYPE(result_type)
        *  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 @@ _GLIBCXX_HAS_NESTED_TYPE(result_type)
       function&
       operator=(const function& __x)
       {
-        function(__x).swap(*this);
-        return *this;
+	function(__x).swap(*this);
+	return *this;
       }
 
       /**
@@ -1965,8 +1969,8 @@ _GLIBCXX_HAS_NESTED_TYPE(result_type)
       function&
       operator=(function&& __x)
       {
-        function(std::move(__x)).swap(*this);
-        return *this;
+	function(std::move(__x)).swap(*this);
+	return *this;
       }
 
       /**
@@ -1979,13 +1983,13 @@ _GLIBCXX_HAS_NESTED_TYPE(result_type)
       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 @@ _GLIBCXX_HAS_NESTED_TYPE(result_type)
        *  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 @@ _GLIBCXX_HAS_NESTED_TYPE(result_type)
 
       /// @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 @@ _GLIBCXX_HAS_NESTED_TYPE(result_type)
 	}
 
       // [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 @@ _GLIBCXX_HAS_NESTED_TYPE(result_type)
       // 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 @@ _GLIBCXX_HAS_NESTED_TYPE(result_type)
        *  This function will not throw an %exception.
        */
       const type_info& target_type() const;
-      
+
       /**
        *  @brief Access the stored target function object.
        *
@@ -2096,7 +2100,7 @@ _GLIBCXX_HAS_NESTED_TYPE(result_type)
        * 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 @@ _GLIBCXX_HAS_NESTED_TYPE(result_type)
       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 @@ _GLIBCXX_HAS_NESTED_TYPE(result_type)
     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 @@ _GLIBCXX_HAS_NESTED_TYPE(result_type)
     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);
     }

libstdc++-v3/include/std/future

@@ -160,7 +160,6 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
     {
       exception_ptr		_M_error;
 
-      _Result_base() = default;
       _Result_base(const _Result_base&) = delete;
       _Result_base& operator=(const _Result_base&) = delete;
 
@@ -173,7 +172,8 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
       };
 
     protected:
-      ~_Result_base();
+      _Result_base();
+      virtual ~_Result_base();
     };
 
     /// Result.
@@ -273,8 +273,9 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
       }
 
 
-    /// 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,10 +286,10 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
       once_flag			_M_once;
 
     public:
-      _State() : _M_result(), _M_retrieved(ATOMIC_FLAG_INIT) { }
-
-      _State(const _State&) = delete;
-      _State& operator=(const _State&) = delete;
+      _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();
 
       _Result_base&
       wait()
@@ -296,7 +297,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
 	_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 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
         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 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
         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 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
         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 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
 
           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 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
         {
           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 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
         {
           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 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
       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 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
     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 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
       void 
       wait() const
       {
-        _State::_S_check(_M_state);
+        _State_base::_S_check(_M_state);
         _M_state->wait();
       }
 
@@ -520,7 +519,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
         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 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
         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 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
       __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 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
       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 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
   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 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
   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 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
   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 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
 
   // 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 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
     };
 
   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 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
       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 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
 
 
   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 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
     };
 
   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 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
     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;

libstdc++-v3/include/std/stdexcept

 // 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 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
     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 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
   {
   public:
     explicit domain_error(const string& __arg);
+    virtual ~domain_error() throw();
   };
 
   /** Thrown to report invalid arguments to functions.  */
@@ -84,6 +84,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
   {
   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 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
   {
   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 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
   {
   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 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
     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 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
   {
   public:
     explicit range_error(const string& __arg);
+    virtual ~range_error() throw();
   };
 
   /** Thrown to indicate arithmetic overflow.  */
@@ -137,6 +140,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
   {
   public:
     explicit overflow_error(const string& __arg);
+    virtual ~overflow_error() throw();
   };
 
   /** Thrown to indicate arithmetic underflow.  */
@@ -144,6 +148,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
   {
   public:
     explicit underflow_error(const string& __arg);
+    virtual ~underflow_error() throw();
   };
 
   // @} group exceptions

libstdc++-v3/include/std/system_error

 // <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 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
     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 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
     { 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();

libstdc++-v3/include/std/thread

@@ -100,7 +100,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
     {
       __shared_base_type	_M_this_ptr;
 
-      inline virtual ~_Impl_base();
+      virtual ~_Impl_base();
 
       virtual void _M_run() = 0;
     };
@@ -195,8 +195,6 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
       }
   };
 
-  inline thread::_Impl_base::~_Impl_base() = default;
-
   inline void
   swap(thread& __x, thread& __y)
   { __x.swap(__y); }

libstdc++-v3/libsupc++/Makefile.am

@@ -77,6 +77,7 @@ sources = \
 	guard.cc \
 	guard_error.cc \
 	hash_bytes.cc \
+	nested_exception.cc \
 	new_handler.cc \
 	new_op.cc \
 	new_opnt.cc \
@@ -134,6 +135,11 @@ cp-demangle.o: cp-demangle.c
 	$(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

libstdc++-v3/libsupc++/Makefile.in

@@ -98,10 +98,10 @@ am__objects_1 = array_type_info.lo atexit_arm.lo bad_alloc.lo \
 	eh_term_handler.lo eh_terminate.lo eh_throw.lo eh_type.lo \
 	eh_unex_handler.lo enum_type_info.lo function_type_info.lo \
 	fundamental_type_info.lo guard.lo guard_error.lo hash_bytes.lo \
-	new_handler.lo new_op.lo new_opnt.lo new_opv.lo new_opvnt.lo \
-	pbase_type_info.lo pmem_type_info.lo pointer_type_info.lo \
-	pure.lo si_class_type_info.lo tinfo.lo tinfo2.lo vec.lo \
-	vmi_class_type_info.lo vterminate.lo
+	nested_exception.lo new_handler.lo new_op.lo new_opnt.lo \
+	new_opv.lo new_opvnt.lo pbase_type_info.lo pmem_type_info.lo \
+	pointer_type_info.lo pure.lo si_class_type_info.lo tinfo.lo \
+	tinfo2.lo vec.lo vmi_class_type_info.lo vterminate.lo
 @GLIBCXX_HOSTED_TRUE@am__objects_2 = cp-demangle.lo
 am_libsupc___la_OBJECTS = $(am__objects_1) $(am__objects_2)
 libsupc___la_OBJECTS = $(am_libsupc___la_OBJECTS)
@@ -383,6 +383,7 @@ sources = \
 	guard.cc \
 	guard_error.cc \
 	hash_bytes.cc \
+	nested_exception.cc \
 	new_handler.cc \
 	new_op.cc \
 	new_opnt.cc \
@@ -766,6 +767,11 @@ cp-demangle.lo: cp-demangle.c
 cp-demangle.o: cp-demangle.c
 	$(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 $<
+
 install-stdHEADERS: $(std_HEADERS)
 	@$(NORMAL_INSTALL)
 	$(mkinstalldirs) $(DESTDIR)$(stddir)

libstdc++-v3/libsupc++/nested_exception.cc

+// 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

libstdc++-v3/libsupc++/nested_exception.h

@@ -63,7 +63,7 @@ namespace std
 
     nested_exception& operator=(const nested_exception&) = default;
 
-    inline virtual ~nested_exception();
+    virtual ~nested_exception();
 
     void
     rethrow_nested() const __attribute__ ((__noreturn__))
@@ -74,8 +74,6 @@ namespace std
     { return _M_ptr; }
   };
 
-  inline nested_exception::~nested_exception() = default;
-
   template<typename _Except>
     struct _Nested_exception : public _Except, public nested_exception
     {

libstdc++-v3/src/Makefile.am

@@ -201,6 +201,7 @@ sources = \
 	ctype.cc \
 	debug.cc \
 	functexcept.cc \
+	functional.cc \
 	globals_io.cc \
 	hash_c++0x.cc \
 	hash_tr1.cc \
@@ -225,6 +226,7 @@ sources = \
 	istream.cc \
 	placeholders.cc \
 	regex.cc \
+	shared_ptr.cc \
 	streambuf.cc \
 	mutex.cc \
 	condition_variable.cc \
@@ -292,6 +294,11 @@ functexcept.lo: functexcept.cc
 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.lo: compatibility-c++0x.cc
 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

libstdc++-v3/src/Makefile.in

@@ -110,13 +110,13 @@ am__objects_6 = atomic.lo bitmap_allocator.lo pool_allocator.lo \
 	compatibility-c++0x.lo compatibility-debug_list.lo \
 	compatibility-debug_list-2.lo compatibility-list.lo \
 	compatibility-list-2.lo complex_io.lo ctype.lo debug.lo \
-	functexcept.lo globals_io.lo hash_c++0x.lo hash_tr1.lo \
-	hashtable_c++0x.lo hashtable_tr1.lo ios.lo ios_failure.lo \
-	ios_init.lo ios_locale.lo limits.lo list.lo locale.lo \
-	locale_init.lo locale_facets.lo localename.lo \
+	functexcept.lo functional.lo globals_io.lo hash_c++0x.lo \
+	hash_tr1.lo hashtable_c++0x.lo hashtable_tr1.lo ios.lo \
+	ios_failure.lo ios_init.lo ios_locale.lo limits.lo list.lo \
+	locale.lo locale_init.lo locale_facets.lo localename.lo \
 	math_stubs_float.lo math_stubs_long_double.lo stdexcept.lo \
 	strstream.lo system_error.lo tree.lo istream.lo \
-	placeholders.lo regex.lo streambuf.lo mutex.lo \
+	placeholders.lo regex.lo shared_ptr.lo streambuf.lo mutex.lo \
 	condition_variable.lo chrono.lo thread.lo future.lo \
 	valarray.lo $(am__objects_1) $(am__objects_5)
 am_libstdc___la_OBJECTS = $(am__objects_6)
@@ -420,6 +420,7 @@ sources = \
 	ctype.cc \
 	debug.cc \
 	functexcept.cc \
+	functional.cc \
 	globals_io.cc \
 	hash_c++0x.cc \
 	hash_tr1.cc \
@@ -444,6 +445,7 @@ sources = \
 	istream.cc \
 	placeholders.cc \
 	regex.cc \
+	shared_ptr.cc \
 	streambuf.cc \
 	mutex.cc \
 	condition_variable.cc \
@@ -885,6 +887,11 @@ functexcept.lo: functexcept.cc
 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
@@ -905,6 +912,11 @@ compatibility-c++0x.lo: compatibility-c++0x.cc
 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

libstdc++-v3/src/functional.cc

+// 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

libstdc++-v3/src/future.cc

@@ -79,8 +79,14 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
   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

libstdc++-v3/src/shared_ptr.cc

+// 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

libstdc++-v3/src/stdexcept.cc

 // 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 @@ namespace std _GLIBCXX_VISIBILITY(default)
 {
 _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 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
   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 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
   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
-

libstdc++-v3/src/system_error.cc

 // <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 @@ namespace std _GLIBCXX_VISIBILITY(default)
 {
 _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

libstdc++-v3/src/thread.cc

@@ -54,6 +54,8 @@ namespace std _GLIBCXX_VISIBILITY(default)
 
 _GLIBCXX_BEGIN_NAMESPACE_VERSION
 
+  thread::_Impl_base::~_Impl_base() = default;
+
   void
   thread::join()
   {

libstdc++-v3/testsuite/20_util/shared_ptr/cons/43820_neg.cc

@@ -32,9 +32,9 @@ void test01()
 {
   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 }
 
 }

libstdc++-v3/testsuite/20_util/weak_ptr/comparison/cmp_neg.cc

@@ -43,7 +43,7 @@ main()
 }
 
 // { 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 }