[multiple changes]

2011-04-13  Daniel Krugler  <daniel.kruegler@googlemail.com>
	    Paolo Carlini  <paolo.carlini@oracle.com>

	PR libstdc++/48526
	* include/std/type_traits (struct is_constructible): Re-implement,
	according to n3290.
	(struct is_default_constructible): Add.
	(struct is_destructible): Likewise.
	(struct __and_, __or_, __not_): Add and use throughout; reorder some
	facilities, other minor tweaks.
	* testsuite/util/testsuite_tr1.h: Add test types.
	* testsuite/20_util/is_constructible/value-2.cc: New.
	* testsuite/20_util/is_default_constructible/value.cc: Likewise.
	* testsuite/20_util/is_default_constructible/requirements/typedefs.cc:
	Likewise.
	* testsuite/20_util/is_default_constructible/requirements/
	explicit_instantiation.cc: Likewise.
	* testsuite/20_util/is_destructible/value.cc: Likewise.
	* testsuite/20_util/is_destructible/requirements/typedefs.cc:
	Likewise.
	* testsuite/20_util/is_destructible/requirements/
	explicit_instantiation.cc: Likewise.
	* testsuite/20_util/make_signed/requirements/typedefs_neg.cc: Adjust
	dg-error line numbers.
	* testsuite/20_util/make_unsigned/requirements/typedefs_neg.cc:
	Likewise.
	* testsuite/20_util/declval/requirements/1_neg.cc: Likewise.
	* testsuite/20_util/ratio/cons/cons_overflow_neg.cc: Likewise.

2011-04-13  Paolo Carlini  <paolo.carlini@oracle.com>

	* testsuite/20_util/is_function/value.cc: Add, adapted from the tr
	testsuite. 
	* testsuite/20_util/is_function/requirements/typedefs.cc: Likewise.
	* testsuite/20_util/is_function/requirements/
	explicit_instantiation.cc: Likewise.
	* testsuite/20_util/is_function/24808.cc: Likewise.
	* testsuite/20_util/is_function/35637.cc: Likewise.
	* testsuite/20_util/is_object/value.cc: Likewise.
	* testsuite/20_util/is_object/requirements/typedefs.cc: Likewise.
	* testsuite/20_util/is_object/requirements/explicit_instantiation.cc:
	: Likewise.
	* testsuite/20_util/is_object/24808.cc: Likewise.
	* testsuite/20_util/is_compound/value.cc: Likewise.
	* testsuite/20_util/is_compound/requirements/typedefs.cc: Likewise.
	* testsuite/20_util/is_compound/requirements/
	explicit_instantiation.cc: Likewise.
	* testsuite/20_util/is_member_object_pointer/value.cc: Likewise.
	* testsuite/20_util/is_member_object_pointer/requirements/
	typedefs.cc: Likewise.
	* testsuite/20_util/is_member_object_pointer/requirements/
	explicit_instantiation.cc: Likewise.
	* testsuite/20_util/is_fundamental/value.cc: Likewise.
	* testsuite/20_util/is_fundamental/requirements/typedefs.cc: Likewise.
	* testsuite/20_util/is_fundamental/requirements/
	explicit_instantiation.cc: Likewise.
	* testsuite/20_util/is_member_pointer/value.cc: Likewise.
	* testsuite/20_util/is_member_pointer/requirements/typedefs.cc: 
	Likewise.
	* testsuite/20_util/is_member_pointer/requirements/
	explicit_instantiation.cc: Likewise.
	* testsuite/20_util/is_member_function_pointer/value.cc: Likewise.
	* testsuite/20_util/is_member_function_pointer/
	requirements/typedefs.cc: Likewise.
	* testsuite/20_util/is_member_function_pointer/requirements/
	explicit_instantiation.cc: Likewise.

	* testsuite/20_util/is_convertible/value.cc: Minor tweak, adjust
	Copyright years.

From-SVN: r172401

1 files changed, 792 insertions, 420 deletions

diff --git a/libstdc++-v3/include/std/type_traits b/libstdc++-v3/include/std/type_traits
index f5d867b..a4c7673 100644
--- a/libstdc++-v3/include/std/type_traits
+++ b/libstdc++-v3/include/std/type_traits
@@ -1,6 +1,6 @@
 // C++0x type_traits -*- 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
@@ -51,21 +51,46 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
     typedef struct { char __arr[2]; } __two;
   };
 
-#define _DEFINE_SPEC_0_HELPER                          \
-  template<>
+  // Meta programming helper types.
 
-#define _DEFINE_SPEC_1_HELPER                          \
-  template<typename _Tp>
+  template<bool, typename, typename>
+    struct conditional;
 
-#define _DEFINE_SPEC_2_HELPER                          \
-  template<typename _Tp, typename _Cp>
+  template<typename _Tp, _Tp>
+    struct integral_constant;
+
+  template<typename, typename, typename...>
+    struct __or_;
+
+  template<typename _B1, typename _B2>
+    struct __or_<_B1, _B2>
+    : public conditional<_B1::value, _B1, _B2>::type
+    { };
+
+  template<typename _B1, typename _B2, typename _B3, typename... _Bn>
+    struct __or_<_B1, _B2, _B3, _Bn...>
+    : public conditional<_B1::value, _B1, __or_<_B2, _B3, _Bn...>>::type
+    { };
+
+  template<typename, typename, typename...>
+    struct __and_;
+
+  template<typename _B1, typename _B2>
+    struct __and_<_B1, _B2>
+    : public conditional<_B1::value, _B2, _B1>::type
+    { };
 
-#define _DEFINE_SPEC(_Order, _Trait, _Type, _Value)    \
-  _DEFINE_SPEC_##_Order##_HELPER                       \
-    struct _Trait<_Type>                               \
-    : public integral_constant<bool, _Value> { };
+  template<typename _B1, typename _B2, typename _B3, typename... _Bn>
+    struct __and_<_B1, _B2, _B3, _Bn...>
+    : public conditional<_B1::value, __and_<_B2, _B3, _Bn...>, _B1>::type
+    { };
+
+  template<typename _Pp>
+    struct __not_
+    : public integral_constant<bool, !_Pp::value>
+    { };
 
-  // helper classes.
+  // helper class.
 
   /// integral_constant
   template<typename _Tp, _Tp __v>
@@ -86,16 +111,18 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
   template<typename _Tp, _Tp __v>
     constexpr _Tp integral_constant<_Tp, __v>::value;
 
-  /// remove_cv
+  // primary type categories.
+
   template<typename>
     struct remove_cv;
 
   template<typename>
     struct __is_void_helper
     : public false_type { };
-  _DEFINE_SPEC(0, __is_void_helper, void, true)
 
-  // primary type categories.
+  template<>
+    struct __is_void_helper<void>
+    : public true_type { };
 
   /// is_void
   template<typename _Tp>
@@ -107,23 +134,68 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
   template<typename>
     struct __is_integral_helper
     : public false_type { };
-  _DEFINE_SPEC(0, __is_integral_helper, bool, true)
-  _DEFINE_SPEC(0, __is_integral_helper, char, true)
-  _DEFINE_SPEC(0, __is_integral_helper, signed char, true)
-  _DEFINE_SPEC(0, __is_integral_helper, unsigned char, true)
+
+  template<>
+    struct __is_integral_helper<bool>
+    : public true_type { };
+  
+  template<>
+    struct __is_integral_helper<char>
+    : public true_type { };
+
+  template<>
+    struct __is_integral_helper<signed char>
+    : public true_type { };
+
+  template<>
+    struct __is_integral_helper<unsigned char>
+    : public true_type { };
+
 #ifdef _GLIBCXX_USE_WCHAR_T
-  _DEFINE_SPEC(0, __is_integral_helper, wchar_t, true)
+  template<>
+    struct __is_integral_helper<wchar_t>
+    : public true_type { };
 #endif
-  _DEFINE_SPEC(0, __is_integral_helper, char16_t, true)
-  _DEFINE_SPEC(0, __is_integral_helper, char32_t, true)
-  _DEFINE_SPEC(0, __is_integral_helper, short, true)
-  _DEFINE_SPEC(0, __is_integral_helper, unsigned short, true)
-  _DEFINE_SPEC(0, __is_integral_helper, int, true)
-  _DEFINE_SPEC(0, __is_integral_helper, unsigned int, true)
-  _DEFINE_SPEC(0, __is_integral_helper, long, true)
-  _DEFINE_SPEC(0, __is_integral_helper, unsigned long, true)
-  _DEFINE_SPEC(0, __is_integral_helper, long long, true)
-  _DEFINE_SPEC(0, __is_integral_helper, unsigned long long, true)
+
+  template<>
+    struct __is_integral_helper<char16_t>
+    : public true_type { };
+
+  template<>
+    struct __is_integral_helper<char32_t>
+    : public true_type { };
+
+  template<>
+    struct __is_integral_helper<short>
+    : public true_type { };
+
+  template<>
+    struct __is_integral_helper<unsigned short>
+    : public true_type { };
+
+  template<>
+    struct __is_integral_helper<int>
+    : public true_type { };
+
+  template<>
+    struct __is_integral_helper<unsigned int>
+    : public true_type { };
+
+  template<>
+    struct __is_integral_helper<long>
+    : public true_type { };
+
+  template<>
+    struct __is_integral_helper<unsigned long>
+    : public true_type { };
+
+  template<>
+    struct __is_integral_helper<long long>
+    : public true_type { };
+
+  template<>
+    struct __is_integral_helper<unsigned long long>
+    : public true_type { };
 
   /// is_integral
   template<typename _Tp>
@@ -135,9 +207,18 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
   template<typename>
     struct __is_floating_point_helper
     : public false_type { };
-  _DEFINE_SPEC(0, __is_floating_point_helper, float, true)
-  _DEFINE_SPEC(0, __is_floating_point_helper, double, true)
-  _DEFINE_SPEC(0, __is_floating_point_helper, long double, true)
+
+  template<>
+    struct __is_floating_point_helper<float>
+    : public true_type { };
+
+  template<>
+    struct __is_floating_point_helper<double>
+    : public true_type { };
+
+  template<>
+    struct __is_floating_point_helper<long double>
+    : public true_type { };
 
   /// is_floating_point
   template<typename _Tp>
@@ -162,7 +243,10 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
   template<typename>
     struct __is_pointer_helper
     : public false_type { };
-  _DEFINE_SPEC(1, __is_pointer_helper, _Tp*, true)
+
+  template<typename _Tp>
+    struct __is_pointer_helper<_Tp*>
+    : public true_type { };
 
   /// is_pointer
   template<typename _Tp>
@@ -171,19 +255,34 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
 				      remove_cv<_Tp>::type>::value)>
     { };
 
-  /// is_reference
+  /// is_lvalue_reference
+  template<typename>
+    struct is_lvalue_reference
+    : public false_type { };
+
   template<typename _Tp>
-    struct is_reference;
+    struct is_lvalue_reference<_Tp&>
+    : public true_type { };
+
+  /// is_rvalue_reference
+  template<typename>
+    struct is_rvalue_reference
+    : public false_type { };
 
-  /// is_function
   template<typename _Tp>
+    struct is_rvalue_reference<_Tp&&>
+    : public true_type { };
+
+  template<typename>
     struct is_function;
 
   template<typename>
     struct __is_member_object_pointer_helper
     : public false_type { };
-  _DEFINE_SPEC(2, __is_member_object_pointer_helper, _Tp _Cp::*,
-	       !is_function<_Tp>::value)
+
+  template<typename _Tp, typename _Cp>
+    struct __is_member_object_pointer_helper<_Tp _Cp::*>
+    : public integral_constant<bool, !is_function<_Tp>::value> { };
 
   /// is_member_object_pointer
   template<typename _Tp>
@@ -195,8 +294,10 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
   template<typename>
     struct __is_member_function_pointer_helper
     : public false_type { };
-  _DEFINE_SPEC(2, __is_member_function_pointer_helper, _Tp _Cp::*,
-	       is_function<_Tp>::value)
+
+  template<typename _Tp, typename _Cp>
+    struct __is_member_function_pointer_helper<_Tp _Cp::*>
+    : public integral_constant<bool, is_function<_Tp>::value> { };
 
   /// is_member_function_pointer
   template<typename _Tp>
@@ -227,27 +328,35 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
   template<typename>
     struct is_function
     : public false_type { };
+
   template<typename _Res, typename... _ArgTypes>
     struct is_function<_Res(_ArgTypes...)>
     : public true_type { };
+
   template<typename _Res, typename... _ArgTypes>
     struct is_function<_Res(_ArgTypes......)>
     : public true_type { };
+
   template<typename _Res, typename... _ArgTypes>
     struct is_function<_Res(_ArgTypes...) const>
     : public true_type { };
+
   template<typename _Res, typename... _ArgTypes>
     struct is_function<_Res(_ArgTypes......) const>
     : public true_type { };
+
   template<typename _Res, typename... _ArgTypes>
     struct is_function<_Res(_ArgTypes...) volatile>
     : public true_type { };
+
   template<typename _Res, typename... _ArgTypes>
     struct is_function<_Res(_ArgTypes......) volatile>
     : public true_type { };
+
   template<typename _Res, typename... _ArgTypes>
     struct is_function<_Res(_ArgTypes...) const volatile>
     : public true_type { };
+
   template<typename _Res, typename... _ArgTypes>
     struct is_function<_Res(_ArgTypes......) const volatile>
     : public true_type { };
@@ -255,7 +364,10 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
   template<typename>
     struct __is_nullptr_t_helper
     : public false_type { };
-  _DEFINE_SPEC(0, __is_nullptr_t_helper, std::nullptr_t, true)
+
+  template<>
+    struct __is_nullptr_t_helper<std::nullptr_t>
+    : public true_type { };
 
   // __is_nullptr_t (extension).
   template<typename _Tp>
@@ -264,42 +376,42 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
 				      remove_cv<_Tp>::type>::value)>
     { };
 
-  // composite type traits.
-  
+  // composite type categories.
+
+  /// is_reference
+  template<typename _Tp>
+    struct is_reference
+    : public __or_<is_lvalue_reference<_Tp>,
+                   is_rvalue_reference<_Tp>>::type
+    { };
+
   /// is_arithmetic
   template<typename _Tp>
     struct is_arithmetic
-    : public integral_constant<bool, (is_integral<_Tp>::value
-				      || is_floating_point<_Tp>::value)>
+    : public __or_<is_integral<_Tp>, is_floating_point<_Tp>>::type
     { };
 
   /// is_fundamental
   template<typename _Tp>
     struct is_fundamental
-    : public integral_constant<bool, (is_arithmetic<_Tp>::value
-				      || is_void<_Tp>::value)>
+    : public __or_<is_arithmetic<_Tp>, is_void<_Tp>>::type
     { };
 
   /// is_object
   template<typename _Tp>
     struct is_object
-    : public integral_constant<bool, !(is_function<_Tp>::value
-				       || is_reference<_Tp>::value
-				       || is_void<_Tp>::value)>
+    : public __not_<__or_<is_function<_Tp>, is_reference<_Tp>,
+                          is_void<_Tp>>>::type
     { };
 
-  /// is_member_pointer
-  template<typename _Tp>
+  template<typename>
     struct is_member_pointer;
 
   /// is_scalar
   template<typename _Tp>
     struct is_scalar
-    : public integral_constant<bool, (is_arithmetic<_Tp>::value
-				      || is_enum<_Tp>::value
-				      || is_pointer<_Tp>::value
-				      || is_member_pointer<_Tp>::value
-				      || __is_nullptr_t<_Tp>::value)>
+    : public __or_<is_arithmetic<_Tp>, is_enum<_Tp>, is_pointer<_Tp>,
+                   is_member_pointer<_Tp>, __is_nullptr_t<_Tp>>::type
     { };
 
   /// is_compound
@@ -311,15 +423,19 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
   template<typename _Tp>
     struct __is_member_pointer_helper
     : public false_type { };
-  _DEFINE_SPEC(2, __is_member_pointer_helper, _Tp _Cp::*, true)
+
+  template<typename _Tp, typename _Cp>
+    struct __is_member_pointer_helper<_Tp _Cp::*>
+    : public true_type { };
 
   template<typename _Tp>
-  struct is_member_pointer
+    struct is_member_pointer
     : public integral_constant<bool, (__is_member_pointer_helper<
 				      typename remove_cv<_Tp>::type>::value)>
     { };
 
   // type properties.
+
   /// is_const
   template<typename>
     struct is_const
@@ -338,6 +454,33 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
     struct is_volatile<_Tp volatile>
     : public true_type { };
 
+  /// is_trivial
+  template<typename _Tp>
+    struct is_trivial
+    : public integral_constant<bool, __is_trivial(_Tp)>
+    { };
+
+  /// is_trivially_copyable (still unimplemented)
+
+  /// is_standard_layout
+  template<typename _Tp>
+    struct is_standard_layout
+    : public integral_constant<bool, __is_standard_layout(_Tp)>
+    { };
+
+  /// is_pod
+  // Could use is_standard_layout && is_trivial instead of the builtin.
+  template<typename _Tp>
+    struct is_pod
+    : public integral_constant<bool, __is_pod(_Tp)>
+    { };
+
+  /// is_literal_type
+  template<typename _Tp>
+    struct is_literal_type
+    : public integral_constant<bool, __is_literal_type(_Tp)>
+    { };
+
   /// is_empty
   template<typename _Tp>
     struct is_empty
@@ -356,336 +499,362 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
     : public integral_constant<bool, __is_abstract(_Tp)>
     { };
 
-  /// has_virtual_destructor
-  template<typename _Tp>
-    struct has_virtual_destructor
-    : public integral_constant<bool, __has_virtual_destructor(_Tp)>
-    { };
+  template<typename _Tp,
+	   bool = is_integral<_Tp>::value,
+	   bool = is_floating_point<_Tp>::value>
+    struct __is_signed_helper
+    : public false_type { };
 
-  /// alignment_of
   template<typename _Tp>
-    struct alignment_of
-    : public integral_constant<std::size_t, __alignof__(_Tp)> { };
-  
-  /// rank
-  template<typename>
-    struct rank
-    : public integral_constant<std::size_t, 0> { };
-   
-  template<typename _Tp, std::size_t _Size>
-    struct rank<_Tp[_Size]>
-    : public integral_constant<std::size_t, 1 + rank<_Tp>::value> { };
+    struct __is_signed_helper<_Tp, false, true>
+    : public true_type { };
 
   template<typename _Tp>
-    struct rank<_Tp[]>
-    : public integral_constant<std::size_t, 1 + rank<_Tp>::value> { };
+    struct __is_signed_helper<_Tp, true, false>
+    : public integral_constant<bool, static_cast<bool>(_Tp(-1) < _Tp(0))>
+    { };
 
-  /// extent
-  template<typename, unsigned _Uint = 0>
-    struct extent
-    : public integral_constant<std::size_t, 0> { };
-  
-  template<typename _Tp, unsigned _Uint, std::size_t _Size>
-    struct extent<_Tp[_Size], _Uint>
-    : public integral_constant<std::size_t,
-			       _Uint == 0 ? _Size : extent<_Tp,
-							   _Uint - 1>::value>
+  /// is_signed
+  template<typename _Tp>
+    struct is_signed
+    : public integral_constant<bool, __is_signed_helper<_Tp>::value>
     { };
 
-  template<typename _Tp, unsigned _Uint>
-    struct extent<_Tp[], _Uint>
-    : public integral_constant<std::size_t,
-			       _Uint == 0 ? 0 : extent<_Tp,
-						       _Uint - 1>::value>
+  /// is_unsigned
+  template<typename _Tp>
+    struct is_unsigned
+    : public __and_<is_arithmetic<_Tp>, __not_<is_signed<_Tp>>>::type
     { };
 
-  // relationships between types [4.6].
 
-  /// is_same
-  template<typename, typename>
-    struct is_same
-    : public false_type { };
+  // destructible and constructible type properties
+
+  template<typename>
+    struct add_rvalue_reference;
 
   template<typename _Tp>
-    struct is_same<_Tp, _Tp>
-    : public true_type { };
+    typename add_rvalue_reference<_Tp>::type declval() noexcept;
 
-  // const-volatile modifications [4.7.1].
+  template<typename, unsigned = 0>
+    struct extent;
 
-  /// remove_const
-  template<typename _Tp>
-    struct remove_const
-    { typedef _Tp     type; };
+  template<typename>
+    struct remove_all_extents;
 
   template<typename _Tp>
-    struct remove_const<_Tp const>
-    { typedef _Tp     type; };
-  
-  /// remove_volatile
-  template<typename _Tp>
-    struct remove_volatile
-    { typedef _Tp     type; };
+    struct __is_array_known_bounds
+    : public integral_constant<bool, (extent<_Tp>::value > 0)>
+    { };
 
   template<typename _Tp>
-    struct remove_volatile<_Tp volatile>
-    { typedef _Tp     type; };
-  
-  /// remove_cv
-  template<typename _Tp>
-    struct remove_cv
-    {
-      typedef typename
-      remove_const<typename remove_volatile<_Tp>::type>::type     type;
-    };
-  
-  /// add_const
-  template<typename _Tp>
-    struct add_const
-    { typedef _Tp const     type; };
-   
-  /// add_volatile
-  template<typename _Tp>
-    struct add_volatile
-    { typedef _Tp volatile     type; };
-  
-  /// add_cv
-  template<typename _Tp>
-    struct add_cv
-    {
-      typedef typename
-      add_const<typename add_volatile<_Tp>::type>::type     type;
-    };
+    struct __is_array_unknown_bounds
+    : public __and_<is_array<_Tp>, __not_<extent<_Tp>>>::type
+    { };
 
-  // array modifications.
+  struct __do_is_destructible_impl_1
+  {
+    template<typename _Up>
+      struct __w { _Up __u; };
 
-  /// remove_extent
-  template<typename _Tp>
-    struct remove_extent
-    { typedef _Tp     type; };
+    template<typename _Tp, typename
+             = decltype(declval<__w<_Tp>&>().~__w<_Tp>())>
+      static true_type __test(int);
 
-  template<typename _Tp, std::size_t _Size>
-    struct remove_extent<_Tp[_Size]>
-    { typedef _Tp     type; };
+    template<typename>
+      static false_type __test(...);
+  };
 
   template<typename _Tp>
-    struct remove_extent<_Tp[]>
-    { typedef _Tp     type; };
+    struct __is_destructible_impl_1
+    : public __do_is_destructible_impl_1
+    {
+      typedef decltype(__test<_Tp>(0)) type;
+    };
 
-  /// remove_all_extents
-  template<typename _Tp>
-    struct remove_all_extents
-    { typedef _Tp     type; };
+  struct __do_is_destructible_impl_2
+  {
+    template<typename _Tp, typename = decltype(declval<_Tp&>().~_Tp())>
+      static true_type __test(int);
 
-  template<typename _Tp, std::size_t _Size>
-    struct remove_all_extents<_Tp[_Size]>
-    { typedef typename remove_all_extents<_Tp>::type     type; };
+    template<typename>
+      static false_type __test(...);
+  };
 
   template<typename _Tp>
-    struct remove_all_extents<_Tp[]>
-    { typedef typename remove_all_extents<_Tp>::type     type; };
-
-  // pointer modifications.
-
-  template<typename _Tp, typename>
-    struct __remove_pointer_helper
-    { typedef _Tp     type; };
+    struct __is_destructible_impl_2
+    : public __do_is_destructible_impl_2
+    {
+      typedef decltype(__test<_Tp>(0)) type;
+    };
 
-  template<typename _Tp, typename _Up>
-    struct __remove_pointer_helper<_Tp, _Up*>
-    { typedef _Up     type; };
+  template<typename _Tp,
+           bool = __or_<is_void<_Tp>,
+                        __is_array_unknown_bounds<_Tp>>::value,
+           bool = __or_<is_reference<_Tp>, is_function<_Tp>>::value>
+    struct __is_destructible_safe;
 
-  /// remove_pointer
   template<typename _Tp>
-    struct remove_pointer
-    : public __remove_pointer_helper<_Tp, typename remove_cv<_Tp>::type>
+    struct __is_destructible_safe<_Tp, false, false>
+    : public conditional<is_abstract<_Tp>::value,
+			 __is_destructible_impl_2<_Tp>,
+                         __is_destructible_impl_1<_Tp>>::type::type
     { };
 
-  template<typename>
-    struct remove_reference;
-
-  /// add_pointer
   template<typename _Tp>
-    struct add_pointer
-    { typedef typename remove_reference<_Tp>::type*     type; };
-
-  // Primary classification traits.
-
-  /// is_lvalue_reference
-  template<typename>
-    struct is_lvalue_reference
+    struct __is_destructible_safe<_Tp, true, false>
     : public false_type { };
 
   template<typename _Tp>
-    struct is_lvalue_reference<_Tp&>
+    struct __is_destructible_safe<_Tp, false, true>
     : public true_type { };
 
-  /// is_rvalue_reference
-  template<typename>
-    struct is_rvalue_reference
-    : public false_type { };
-
-  template<typename _Tp>
-    struct is_rvalue_reference<_Tp&&>
-    : public true_type { };
-
-  // Secondary classification traits.
-
-  /// is_reference
+  /// is_destructible
   template<typename _Tp>
-    struct is_reference
-    : public integral_constant<bool, (is_lvalue_reference<_Tp>::value
-				      || is_rvalue_reference<_Tp>::value)>
+    struct is_destructible
+    : public integral_constant<bool, (__is_destructible_safe<_Tp>::value)>
     { };
 
-  // Reference transformations.
+  struct __do_is_default_constructible_impl
+  {
+    template<typename _Tp, typename = decltype(_Tp())>
+      static true_type __test(int);
 
-  /// remove_reference
-  template<typename _Tp>
-    struct remove_reference
-    { typedef _Tp   type; };
+    template<typename>
+      static false_type __test(...);
+  };
 
   template<typename _Tp>
-    struct remove_reference<_Tp&>
-    { typedef _Tp   type; };
+    struct __is_default_constructible_impl
+    : public __do_is_default_constructible_impl
+    {
+      typedef decltype(__test<_Tp>(0)) type;
+    };
 
   template<typename _Tp>
-    struct remove_reference<_Tp&&>
-    { typedef _Tp   type; };
+    struct __is_default_constructible_atom
+    : public __and_<is_destructible<_Tp>,
+                    __is_default_constructible_impl<_Tp>>::type::type
+    { };
 
-  template<typename _Tp,
-	   bool = !is_reference<_Tp>::value && !is_void<_Tp>::value,
-	   bool = is_rvalue_reference<_Tp>::value>
-    struct __add_lvalue_reference_helper
-    { typedef _Tp   type; };
+  template<typename _Tp, bool = is_array<_Tp>::value>
+    struct __is_default_constructible_safe;
+
+  // The following technique is a workaround for a gcc defect, which does
+  // not sfinae away attempts to default-construct arrays of unknown bounds.
+  // Complete arrays can be default-constructed, if the element type is
+  // default-constructible, but arrays with unknown bounds are not:
 
   template<typename _Tp>
-    struct __add_lvalue_reference_helper<_Tp, true, false>
-    { typedef _Tp&   type; };
+    struct __is_default_constructible_safe<_Tp, true>
+    : public __and_<__is_array_known_bounds<_Tp>,
+		    __is_default_constructible_atom<typename
+                      remove_all_extents<_Tp>::type>>::type::type
+    { };
 
   template<typename _Tp>
-    struct __add_lvalue_reference_helper<_Tp, false, true>
-    { typedef typename remove_reference<_Tp>::type&   type; };
+    struct __is_default_constructible_safe<_Tp, false>
+    : public __is_default_constructible_atom<_Tp>::type
+    { };
 
-  /// add_lvalue_reference
+  /// is_default_constructible
   template<typename _Tp>
-    struct add_lvalue_reference
-    : public __add_lvalue_reference_helper<_Tp>
+    struct is_default_constructible
+    : public integral_constant<bool, (__is_default_constructible_safe<
+				      _Tp>::value)>
     { };
 
-  template<typename _Tp,
-	   bool = !is_reference<_Tp>::value && !is_void<_Tp>::value>
-    struct __add_rvalue_reference_helper
-    { typedef _Tp   type; };
+  struct __do_is_static_castable_impl
+  {
+    template<typename _From, typename _To, typename
+             = decltype(static_cast<_To>(declval<_From>()))>
+      static true_type __test(int);
 
-  template<typename _Tp>
-    struct __add_rvalue_reference_helper<_Tp, true>
-    { typedef _Tp&&   type; };
+    template<typename, typename>
+      static false_type __test(...);
+  };
 
-  /// add_rvalue_reference
-  template<typename _Tp>
-    struct add_rvalue_reference
-    : public __add_rvalue_reference_helper<_Tp>
+  template<typename _From, typename _To>
+    struct __is_static_castable_impl
+    : public __do_is_static_castable_impl
+    {
+      typedef decltype(__test<_From, _To>(0)) type;
+    };
+
+  template<typename _From, typename _To>
+    struct __is_static_castable_safe
+    : public __and_<__or_<is_void<_To>, is_destructible<_To>>,
+                    __is_static_castable_impl<_From, _To>>::type::type
     { };
 
-  // Scalar properties and transformations.
+  // __is_static_castable
+  template<typename _From, typename _To>
+    struct __is_static_castable
+    : public integral_constant<bool, (__is_static_castable_safe<
+				      _From, _To>::value)>
+    { };
 
-  template<typename _Tp,
-	   bool = is_integral<_Tp>::value,
-	   bool = is_floating_point<_Tp>::value>
-    struct __is_signed_helper
-    : public false_type { };
+  struct __do_is_direct_constructible_impl
+  {
+    template<typename _Tp, typename _Arg, typename
+	     = decltype(::new _Tp(declval<_Arg>()))>
+      static true_type __test(int);
 
-  template<typename _Tp>
-    struct __is_signed_helper<_Tp, false, true>
-    : public true_type { };
+    template<typename, typename>
+      static false_type __test(...);
+  };
 
-  template<typename _Tp>
-    struct __is_signed_helper<_Tp, true, false>
-    : public integral_constant<bool, static_cast<bool>(_Tp(-1) < _Tp(0))>
-    { };
+  template<typename _Tp, typename _Arg>
+    struct __is_direct_constructible_impl
+    : public __do_is_direct_constructible_impl
+    {
+      typedef decltype(__test<_Tp, _Arg>(0)) type;
+    };
 
-  /// is_signed
-  template<typename _Tp>
-    struct is_signed
-    : public integral_constant<bool, __is_signed_helper<_Tp>::value>
+  template<typename _Tp, typename _Arg>
+    struct __is_direct_constructible_new_safe
+    : public __and_<is_destructible<_Tp>,
+                    __is_direct_constructible_impl<_Tp, _Arg>>::type::type
     { };
 
-  /// is_unsigned
-  template<typename _Tp>
-    struct is_unsigned
-    : public integral_constant<bool, (is_arithmetic<_Tp>::value
-				      && !is_signed<_Tp>::value)>
+  template<typename, typename>
+    struct is_same;
+
+  template<typename, typename>
+    struct is_base_of;
+
+  template<typename>
+    struct remove_reference;
+
+  template<typename _From, typename _To, bool
+           = is_reference<_From>::value>
+    struct __is_base_to_derived_ref;
+
+  template<typename _From, typename _To>
+    struct __is_base_to_derived_ref<_From, _To, true>
+    {
+      typedef typename remove_cv<typename remove_reference<_From
+        >::type>::type __src_t;
+      typedef typename remove_cv<typename remove_reference<_To
+        >::type>::type __dst_t;
+      typedef typename __and_<
+        __not_<is_same<__src_t, __dst_t>>,
+        is_base_of<__src_t, __dst_t>
+      >::type type;
+      static constexpr bool value = type::value;
+    };
+
+  template<typename _From, typename _To>
+    struct __is_base_to_derived_ref<_From, _To, false>
+    : public false_type
     { };
 
-  // Member introspection.
+  template<typename _From, typename _To, bool
+           = __and_<is_lvalue_reference<_From>,
+                    is_rvalue_reference<_To>>::value>
+    struct __is_lvalue_to_rvalue_ref;
 
-  /// is_trivial
-  template<typename _Tp>
-    struct is_trivial
-    : public integral_constant<bool, __is_trivial(_Tp)>
+  template<typename _From, typename _To>
+    struct __is_lvalue_to_rvalue_ref<_From, _To, true>
+    {
+      typedef typename remove_cv<typename remove_reference<
+        _From>::type>::type __src_t;
+      typedef typename remove_cv<typename remove_reference<
+        _To>::type>::type __dst_t;
+      typedef typename __or_<
+        is_same<__src_t, __dst_t>,
+        is_base_of<__dst_t, __src_t>
+      >::type type;
+      static constexpr bool value = type::value;
+    };
+
+  template<typename _From, typename _To>
+    struct __is_lvalue_to_rvalue_ref<_From, _To, false>
+    : public false_type
     { };
 
-  /// is_standard_layout
-  template<typename _Tp>
-    struct is_standard_layout
-    : public integral_constant<bool, __is_standard_layout(_Tp)>
+  // Here we handle direct-initialization to a reference type
+  // as equivalent to a static_cast modulo overshooting conversions.
+  // These are restricted to the following conversion:
+  //    a) A base class to a derived class reference
+  //    b) An lvalue-reference to an rvalue-reference
+
+  template<typename _Tp, typename _Arg>
+    struct __is_direct_constructible_ref_cast
+    : public __and_<__is_static_castable<_Arg, _Tp>,
+                    __not_<__or_<__is_base_to_derived_ref<_Arg, _Tp>,
+                                 __is_lvalue_to_rvalue_ref<_Arg, _Tp>
+                   >>>::type::type
     { };
 
-  /// is_pod
-  // Could use is_standard_layout && is_trivial instead of the builtin.
-  template<typename _Tp>
-    struct is_pod
-    : public integral_constant<bool, __is_pod(_Tp)>
+  // Direct-initialization is tricky, because of functional
+  // casts: For a conversion to reference we fall back to a
+  // static_cast modulo extra cases, otherwise we use a
+  // new expression:
+
+  template<typename _Tp, typename _Arg>
+    struct __is_direct_constructible_new
+    : public conditional<is_reference<_Tp>::value,
+			 __is_direct_constructible_ref_cast<_Tp, _Arg>,
+			 __is_direct_constructible_new_safe<_Tp, _Arg>
+			 >::type
     { };
 
-  /// is_literal_type
-  template<typename _Tp>
-    struct is_literal_type
-    : public integral_constant<bool, __is_literal_type(_Tp)>
+  template<typename _Tp, typename _Arg>
+    struct __is_direct_constructible
+    : public integral_constant<bool, (__is_direct_constructible_new<
+				      _Tp, _Arg>::type::value)>
     { };
 
-  template<typename _Tp>
-    typename add_rvalue_reference<_Tp>::type declval() noexcept;
+  struct __do_is_nary_constructible_impl
+  {
+    template<typename _Tp, typename... _Args, typename
+             = decltype(_Tp(declval<_Args>()...))>
+      static true_type __test(int);
+
+    template<typename, typename...>
+      static false_type __test(...);
+  };
 
   template<typename _Tp, typename... _Args>
-    class __is_constructible_helper
-    : public __sfinae_types
+    struct __is_nary_constructible_impl
+    : public __do_is_nary_constructible_impl
     {
-      template<typename _Tp1, typename... _Args1>
-        static decltype(_Tp1(declval<_Args1>()...), __one()) __test(int);
-
-      template<typename, typename...>
-        static __two __test(...);
-
-    public:
-      static const bool __value = sizeof(__test<_Tp, _Args...>(0)) == 1;
+      typedef decltype(__test<_Tp, _Args...>(0)) type;
     };
 
-  template<typename _Tp, typename _Arg>
-    class __is_constructible_helper<_Tp, _Arg>
-    : public __sfinae_types
+  template<typename _Tp, typename... _Args>
+    struct __is_nary_constructible
+    : public __and_<is_destructible<_Tp>,
+		    __is_nary_constructible_impl<_Tp, _Args...>
+                   >::type::type
     {
-      template<typename _Tp1, typename _Arg1>
-        static decltype(static_cast<_Tp1>(declval<_Arg1>()), __one())
-	__test(int);
+      static_assert(sizeof...(_Args) > 1,
+                    "Only useful for > 1 arguments");
+    };
 
-      template<typename, typename>
-        static __two __test(...);
+  template<typename _Tp, typename... _Args>
+    struct __is_constructible_impl
+    : public __is_nary_constructible<_Tp, _Args...>
+    { };
 
-    public:
-      static const bool __value = sizeof(__test<_Tp, _Arg>(0)) == 1;
-    };
+  template<typename _Tp, typename _Arg>
+    struct __is_constructible_impl<_Tp, _Arg>
+    : public __is_direct_constructible<_Tp, _Arg>
+    { };
+
+  template<typename _Tp>
+    struct __is_constructible_impl<_Tp>
+    : public is_default_constructible<_Tp>
+    { };
 
   /// is_constructible
-  // XXX FIXME
-  // The C++0x specifications require front-end support, see N2255.
   template<typename _Tp, typename... _Args>
     struct is_constructible
-    : public integral_constant<bool,
-			       __is_constructible_helper<_Tp,
-							 _Args...>::__value>
+    : public integral_constant<bool, (__is_constructible_impl<_Tp,
+				      _Args...>::value)>
     { };
 
+
   template<bool, typename _Tp, typename... _Args>
     struct __is_nt_constructible_helper
     { static const bool __value = false; };
@@ -750,7 +919,63 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
     : public integral_constant<bool, __has_nothrow_assign(_Tp)>
     { };
 
-  // Relationships between types.
+  /// has_virtual_destructor
+  template<typename _Tp>
+    struct has_virtual_destructor
+    : public integral_constant<bool, __has_virtual_destructor(_Tp)>
+    { };
+
+  
+  // type property queries.
+
+  /// alignment_of
+  template<typename _Tp>
+    struct alignment_of
+    : public integral_constant<std::size_t, __alignof__(_Tp)> { };
+  
+  /// rank
+  template<typename>
+    struct rank
+    : public integral_constant<std::size_t, 0> { };
+   
+  template<typename _Tp, std::size_t _Size>
+    struct rank<_Tp[_Size]>
+    : public integral_constant<std::size_t, 1 + rank<_Tp>::value> { };
+
+  template<typename _Tp>
+    struct rank<_Tp[]>
+    : public integral_constant<std::size_t, 1 + rank<_Tp>::value> { };
+
+  /// extent
+  template<typename, unsigned _Uint>
+    struct extent
+    : public integral_constant<std::size_t, 0> { };
+  
+  template<typename _Tp, unsigned _Uint, std::size_t _Size>
+    struct extent<_Tp[_Size], _Uint>
+    : public integral_constant<std::size_t,
+			       _Uint == 0 ? _Size : extent<_Tp,
+							   _Uint - 1>::value>
+    { };
+
+  template<typename _Tp, unsigned _Uint>
+    struct extent<_Tp[], _Uint>
+    : public integral_constant<std::size_t,
+			       _Uint == 0 ? 0 : extent<_Tp,
+						       _Uint - 1>::value>
+    { };
+
+
+  // type relations.
+
+  /// is_same
+  template<typename, typename>
+    struct is_same
+    : public false_type { };
+
+  template<typename _Tp>
+    struct is_same<_Tp, _Tp>
+    : public true_type { };
 
   /// is_base_of
   template<typename _Base, typename _Derived>
@@ -759,8 +984,8 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
     { };
 
   template<typename _From, typename _To,
-	   bool = (is_void<_From>::value || is_function<_To>::value
-		   || is_array<_To>::value)>
+           bool = __or_<is_void<_From>, is_function<_To>,
+                        is_array<_To>>::value>
     struct __is_convertible_helper
     { static const bool __value = is_void<_To>::value; };
 
@@ -783,8 +1008,6 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
     };
 
   /// is_convertible
-  // XXX FIXME
-  // The C++0x specifications require front-end support, see N2255.
   template<typename _From, typename _To>
     struct is_convertible
     : public integral_constant<bool,
@@ -797,123 +1020,108 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
     : public is_constructible<_To, _From>
     { };
 
-  template<std::size_t _Len>
-    struct __aligned_storage_msa
-    { 
-      union __type
-      {
-	unsigned char __data[_Len];
-	struct __attribute__((__aligned__)) { } __align; 
-      };
-    };
 
-  /**
-   *  @brief Alignment type.
-   *
-   *  The value of _Align is a default-alignment which shall be the
-   *  most stringent alignment requirement for any C++ object type
-   *  whose size is no greater than _Len (3.9). The member typedef
-   *  type shall be a POD type suitable for use as uninitialized
-   *  storage for any object whose size is at most _Len and whose
-   *  alignment is a divisor of _Align.
-  */
-  template<std::size_t _Len, std::size_t _Align =
-	   __alignof__(typename __aligned_storage_msa<_Len>::__type)>
-    struct aligned_storage
-    { 
-      union type
-      {
-	unsigned char __data[_Len];
-	struct __attribute__((__aligned__((_Align)))) { } __align; 
-      };
-    };
+  // const-volatile modifications.
 
-
-  // Define a nested type if some predicate holds.
-  // Primary template.
-  /// enable_if
-  template<bool, typename _Tp = void>
-    struct enable_if 
-    { };
-
-  // Partial specialization for true.
+  /// remove_const
   template<typename _Tp>
-    struct enable_if<true, _Tp>
-    { typedef _Tp type; };
-
+    struct remove_const
+    { typedef _Tp     type; };
 
-  // A conditional expression, but for types. If true, first, if false, second.
-  // Primary template.
-  /// conditional
-  template<bool _Cond, typename _Iftrue, typename _Iffalse>
-    struct conditional
-    { typedef _Iftrue type; };
+  template<typename _Tp>
+    struct remove_const<_Tp const>
+    { typedef _Tp     type; };
+  
+  /// remove_volatile
+  template<typename _Tp>
+    struct remove_volatile
+    { typedef _Tp     type; };
 
-  // Partial specialization for false.
-  template<typename _Iftrue, typename _Iffalse>
-    struct conditional<false, _Iftrue, _Iffalse>
-    { typedef _Iffalse type; };
+  template<typename _Tp>
+    struct remove_volatile<_Tp volatile>
+    { typedef _Tp     type; };
+  
+  /// remove_cv
+  template<typename _Tp>
+    struct remove_cv
+    {
+      typedef typename
+      remove_const<typename remove_volatile<_Tp>::type>::type     type;
+    };
+  
+  /// add_const
+  template<typename _Tp>
+    struct add_const
+    { typedef _Tp const     type; };
+   
+  /// add_volatile
+  template<typename _Tp>
+    struct add_volatile
+    { typedef _Tp volatile     type; };
+  
+  /// add_cv
+  template<typename _Tp>
+    struct add_cv
+    {
+      typedef typename
+      add_const<typename add_volatile<_Tp>::type>::type     type;
+    };
 
 
-  // Decay trait for arrays and functions, used for perfect forwarding
-  // in make_pair, make_tuple, etc.
-  template<typename _Up, 
-	   bool _IsArray = is_array<_Up>::value,
-	   bool _IsFunction = is_function<_Up>::value> 
-    struct __decay_selector;
-
-  // NB: DR 705.
-  template<typename _Up> 
-    struct __decay_selector<_Up, false, false>
-    { typedef typename remove_cv<_Up>::type __type; };
+  // Reference transformations.
 
-  template<typename _Up> 
-    struct __decay_selector<_Up, true, false>
-    { typedef typename remove_extent<_Up>::type* __type; };
+  /// remove_reference
+  template<typename _Tp>
+    struct remove_reference
+    { typedef _Tp   type; };
 
-  template<typename _Up> 
-    struct __decay_selector<_Up, false, true>
-    { typedef typename add_pointer<_Up>::type __type; };
+  template<typename _Tp>
+    struct remove_reference<_Tp&>
+    { typedef _Tp   type; };
 
-  /// decay
-  template<typename _Tp> 
-    class decay 
-    { 
-      typedef typename remove_reference<_Tp>::type __remove_type;
+  template<typename _Tp>
+    struct remove_reference<_Tp&&>
+    { typedef _Tp   type; };
 
-    public:
-      typedef typename __decay_selector<__remove_type>::__type type;
-    };
+  template<typename _Tp,
+	   bool = __and_<__not_<is_reference<_Tp>>,
+                         __not_<is_void<_Tp>>>::value,
+	   bool = is_rvalue_reference<_Tp>::value>
+    struct __add_lvalue_reference_helper
+    { typedef _Tp   type; };
 
   template<typename _Tp>
-    class reference_wrapper;
+    struct __add_lvalue_reference_helper<_Tp, true, false>
+    { typedef _Tp&   type; };
 
-  // Helper which adds a reference to a type when given a reference_wrapper
   template<typename _Tp>
-    struct __strip_reference_wrapper
-    {
-      typedef _Tp __type;
-    };
+    struct __add_lvalue_reference_helper<_Tp, false, true>
+    { typedef typename remove_reference<_Tp>::type&   type; };
 
+  /// add_lvalue_reference
   template<typename _Tp>
-    struct __strip_reference_wrapper<reference_wrapper<_Tp> >
-    {
-      typedef _Tp& __type;
-    };
+    struct add_lvalue_reference
+    : public __add_lvalue_reference_helper<_Tp>
+    { };
+
+  template<typename _Tp,
+           bool = __and_<__not_<is_reference<_Tp>>,
+                         __not_<is_void<_Tp>>>::value>
+    struct __add_rvalue_reference_helper
+    { typedef _Tp   type; };
 
   template<typename _Tp>
-    struct __strip_reference_wrapper<const reference_wrapper<_Tp> >
-    {
-      typedef _Tp& __type;
-    };
+    struct __add_rvalue_reference_helper<_Tp, true>
+    { typedef _Tp&&   type; };
 
+  /// add_rvalue_reference
   template<typename _Tp>
-    struct __decay_and_strip
-    {
-      typedef typename __strip_reference_wrapper<
-	typename decay<_Tp>::type>::__type __type;
-    };
+    struct add_rvalue_reference
+    : public __add_rvalue_reference_helper<_Tp>
+    { };
+
 
+  // sign modifications.
 
   // Utility for constructing identically cv-qualified types.
   template<typename _Unqualified, bool _IsConst, bool _IsVol>
@@ -946,7 +1154,6 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
       typedef typename __match::__type __type; 
     };
 
-
   // Utility for finding the unsigned versions of signed integral types.
   template<typename _Tp>
     struct __make_unsigned
@@ -976,7 +1183,6 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
     struct __make_unsigned<long long>
     { typedef unsigned long long __type; };
 
-
   // Select between integral and enum: not possible to be both.
   template<typename _Tp, 
 	   bool _IsInt = is_integral<_Tp>::value,
@@ -1053,7 +1259,6 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
     struct __make_signed<unsigned long long>
     { typedef signed long long __type; };
 
-
   // Select between integral and enum: not possible to be both.
   template<typename _Tp, 
 	   bool _IsInt = is_integral<_Tp>::value,
@@ -1100,6 +1305,176 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
   template<>
     struct make_signed<bool>;
 
+
+  // array modifications.
+
+  /// remove_extent
+  template<typename _Tp>
+    struct remove_extent
+    { typedef _Tp     type; };
+
+  template<typename _Tp, std::size_t _Size>
+    struct remove_extent<_Tp[_Size]>
+    { typedef _Tp     type; };
+
+  template<typename _Tp>
+    struct remove_extent<_Tp[]>
+    { typedef _Tp     type; };
+
+  /// remove_all_extents
+  template<typename _Tp>
+    struct remove_all_extents
+    { typedef _Tp     type; };
+
+  template<typename _Tp, std::size_t _Size>
+    struct remove_all_extents<_Tp[_Size]>
+    { typedef typename remove_all_extents<_Tp>::type     type; };
+
+  template<typename _Tp>
+    struct remove_all_extents<_Tp[]>
+    { typedef typename remove_all_extents<_Tp>::type     type; };
+
+
+  // pointer modifications.
+
+  template<typename _Tp, typename>
+    struct __remove_pointer_helper
+    { typedef _Tp     type; };
+
+  template<typename _Tp, typename _Up>
+    struct __remove_pointer_helper<_Tp, _Up*>
+    { typedef _Up     type; };
+
+  /// remove_pointer
+  template<typename _Tp>
+    struct remove_pointer
+    : public __remove_pointer_helper<_Tp, typename remove_cv<_Tp>::type>
+    { };
+
+  /// add_pointer
+  template<typename _Tp>
+    struct add_pointer
+    { typedef typename remove_reference<_Tp>::type*     type; };
+
+
+  template<std::size_t _Len>
+    struct __aligned_storage_msa
+    { 
+      union __type
+      {
+	unsigned char __data[_Len];
+	struct __attribute__((__aligned__)) { } __align; 
+      };
+    };
+
+  /**
+   *  @brief Alignment type.
+   *
+   *  The value of _Align is a default-alignment which shall be the
+   *  most stringent alignment requirement for any C++ object type
+   *  whose size is no greater than _Len (3.9). The member typedef
+   *  type shall be a POD type suitable for use as uninitialized
+   *  storage for any object whose size is at most _Len and whose
+   *  alignment is a divisor of _Align.
+  */
+  template<std::size_t _Len, std::size_t _Align =
+	   __alignof__(typename __aligned_storage_msa<_Len>::__type)>
+    struct aligned_storage
+    { 
+      union type
+      {
+	unsigned char __data[_Len];
+	struct __attribute__((__aligned__((_Align)))) { } __align; 
+      };
+    };
+
+
+  // Decay trait for arrays and functions, used for perfect forwarding
+  // in make_pair, make_tuple, etc.
+  template<typename _Up, 
+	   bool _IsArray = is_array<_Up>::value,
+	   bool _IsFunction = is_function<_Up>::value> 
+    struct __decay_selector;
+
+  // NB: DR 705.
+  template<typename _Up> 
+    struct __decay_selector<_Up, false, false>
+    { typedef typename remove_cv<_Up>::type __type; };
+
+  template<typename _Up> 
+    struct __decay_selector<_Up, true, false>
+    { typedef typename remove_extent<_Up>::type* __type; };
+
+  template<typename _Up> 
+    struct __decay_selector<_Up, false, true>
+    { typedef typename add_pointer<_Up>::type __type; };
+
+  /// decay
+  template<typename _Tp> 
+    class decay 
+    { 
+      typedef typename remove_reference<_Tp>::type __remove_type;
+
+    public:
+      typedef typename __decay_selector<__remove_type>::__type type;
+    };
+
+  template<typename _Tp>
+    class reference_wrapper;
+
+  // Helper which adds a reference to a type when given a reference_wrapper
+  template<typename _Tp>
+    struct __strip_reference_wrapper
+    {
+      typedef _Tp __type;
+    };
+
+  template<typename _Tp>
+    struct __strip_reference_wrapper<reference_wrapper<_Tp> >
+    {
+      typedef _Tp& __type;
+    };
+
+  template<typename _Tp>
+    struct __strip_reference_wrapper<const reference_wrapper<_Tp> >
+    {
+      typedef _Tp& __type;
+    };
+
+  template<typename _Tp>
+    struct __decay_and_strip
+    {
+      typedef typename __strip_reference_wrapper<
+	typename decay<_Tp>::type>::__type __type;
+    };
+
+
+  // Define a nested type if some predicate holds.
+  // Primary template.
+  /// enable_if
+  template<bool, typename _Tp = void>
+    struct enable_if 
+    { };
+
+  // Partial specialization for true.
+  template<typename _Tp>
+    struct enable_if<true, _Tp>
+    { typedef _Tp type; };
+
+
+  // A conditional expression, but for types. If true, first, if false, second.
+  // Primary template.
+  /// conditional
+  template<bool _Cond, typename _Iftrue, typename _Iffalse>
+    struct conditional
+    { typedef _Iftrue type; };
+
+  // Partial specialization for false.
+  template<typename _Iftrue, typename _Iffalse>
+    struct conditional<false, _Iftrue, _Iffalse>
+    { typedef _Iffalse type; };
+
+
   /// common_type
   template<typename... _Tp>
     struct common_type;
@@ -1119,6 +1494,20 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
         common_type<typename common_type<_Tp, _Up>::type, _Vp...>::type type;
     };
 
+  /// underlying_type (still unimplemented)
+
+  /// result_of
+  template<typename _Signature>
+    class result_of;
+
+  template<typename _Functor, typename... _ArgTypes>
+    struct result_of<_Functor(_ArgTypes...)>
+    {
+      typedef
+        decltype( std::declval<_Functor>()(std::declval<_ArgTypes>()...) )
+        type;
+    };
+
   /// declval
   template<typename _Tp>
     struct __declval_protector
@@ -1136,18 +1525,6 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
       return __declval_protector<_Tp>::__delegate();
     }
 
-  /// result_of
-  template<typename _Signature>
-    class result_of;
-
-  template<typename _Functor, typename... _ArgTypes>
-    struct result_of<_Functor(_ArgTypes...)>
-    {
-      typedef
-        decltype( std::declval<_Functor>()(std::declval<_ArgTypes>()...) )
-        type;
-    };
-
   /**
    *  Use SFINAE to determine if the type _Tp has a publicly-accessible
    *  member type _NTYPE.
@@ -1177,11 +1554,6 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
 			<typename remove_cv<_Tp>::type>::value>  \
     { };
 
-#undef _DEFINE_SPEC_0_HELPER
-#undef _DEFINE_SPEC_1_HELPER
-#undef _DEFINE_SPEC_2_HELPER
-#undef _DEFINE_SPEC
-
   // @} group metaprogramming
 _GLIBCXX_END_NAMESPACE_VERSION
 } // namespace