obtained gcc-4.6.4.tar.bz2 from upstream website;upstream

verified gcc-4.6.4.tar.bz2.sig;
imported gcc-4.6.4 source tree from verified upstream tarball.

downloading a git-generated archive based on the 'upstream' tag
should provide you with a source tree that is binary identical
to the one extracted from the above tarball.

if you have obtained the source via the command 'git clone',
however, do note that line-endings of files in your working
directory might differ from line-endings of the respective
files in the upstream repository.

20 files changed, 1285 insertions, 0 deletions

diff --git a/libstdc++-v3/testsuite/18_support/numeric_limits/29989.cc b/libstdc++-v3/testsuite/18_support/numeric_limits/29989.cc
new file mode 100644
index 000000000..2ca723a78
--- /dev/null
+++ b/libstdc++-v3/testsuite/18_support/numeric_limits/29989.cc
@@ -0,0 +1,22 @@
+// { dg-do compile }
+
+// Copyright (C) 2006, 2009 Free Software Foundation
+//
+// 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.
+
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING3.  If not see
+// <http://www.gnu.org/licenses/>.
+
+// libstdc++/29989
+#define max(a,b) quirk
+#include <limits>
diff --git a/libstdc++-v3/testsuite/18_support/numeric_limits/char16_32_t.cc b/libstdc++-v3/testsuite/18_support/numeric_limits/char16_32_t.cc
new file mode 100644
index 000000000..62628c862
--- /dev/null
+++ b/libstdc++-v3/testsuite/18_support/numeric_limits/char16_32_t.cc
@@ -0,0 +1,77 @@
+// { dg-options "-std=gnu++0x" }
+// { dg-require-cstdint "" }
+
+// 2008-05-20  Paolo Carlini  <paolo.carlini@oracle.com>
+//
+// Copyright (C) 2008, 2009 Free Software Foundation
+//
+// 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.
+
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING3.  If not see
+// <http://www.gnu.org/licenses/>.
+
+// 18.2.1.1 template class numeric_limits
+
+#include <limits>
+#include <cstdint>
+#include <testsuite_hooks.h>
+
+// Test specializations for char16_t and char32_t, in C++0x.
+template<typename T, typename R>
+  void
+  do_test()
+  {
+    bool test __attribute__((unused)) = true;
+
+    typedef std::numeric_limits<T> char_type;
+    typedef std::numeric_limits<R> impl_type;
+
+    VERIFY( char_type::is_specialized == impl_type::is_specialized );
+    VERIFY( char_type::min() == impl_type::min() );
+    VERIFY( char_type::max() == impl_type::max() );
+    VERIFY( char_type::digits == impl_type::digits );
+    VERIFY( char_type::digits10 == impl_type::digits10 );
+    VERIFY( char_type::is_signed == impl_type::is_signed );
+    VERIFY( char_type::is_integer == impl_type::is_integer );
+    VERIFY( char_type::is_exact == impl_type::is_exact );
+    VERIFY( char_type::radix == impl_type::radix );
+    VERIFY( char_type::epsilon() == impl_type::epsilon() );
+    VERIFY( char_type::round_error() == impl_type::round_error() );
+    VERIFY( char_type::min_exponent == impl_type::min_exponent );
+    VERIFY( char_type::min_exponent10 == impl_type::min_exponent10 );
+    VERIFY( char_type::max_exponent == impl_type::max_exponent );
+    VERIFY( char_type::max_exponent10 == impl_type::max_exponent10 );
+    VERIFY( char_type::has_infinity == impl_type::has_infinity );
+    VERIFY( char_type::has_quiet_NaN == impl_type::has_quiet_NaN );
+    VERIFY( char_type::has_signaling_NaN == impl_type::has_signaling_NaN );
+    VERIFY( char_type::has_denorm == impl_type::has_denorm );
+    VERIFY( char_type::has_denorm_loss == impl_type::has_denorm_loss );
+    VERIFY( char_type::infinity() == impl_type::infinity() );
+    VERIFY( char_type::quiet_NaN() == impl_type::quiet_NaN() );
+    VERIFY( char_type::signaling_NaN() == impl_type::signaling_NaN() );
+    VERIFY( char_type::denorm_min() == impl_type::denorm_min() );
+    VERIFY( char_type::is_iec559 == impl_type::is_iec559 );
+    VERIFY( char_type::is_bounded == impl_type::is_bounded );
+    VERIFY( char_type::is_modulo == impl_type::is_modulo );
+    VERIFY( char_type::traps == impl_type::traps );
+    VERIFY( char_type::tinyness_before == impl_type::tinyness_before );
+    VERIFY( char_type::round_style == impl_type::round_style );
+  }
+
+int main()
+{
+  do_test<char16_t, uint_least16_t>();
+  do_test<char32_t, uint_least32_t>();
+
+  return 0;
+}
diff --git a/libstdc++-v3/testsuite/18_support/numeric_limits/cons/default.cc b/libstdc++-v3/testsuite/18_support/numeric_limits/cons/default.cc
new file mode 100644
index 000000000..6b492569c
--- /dev/null
+++ b/libstdc++-v3/testsuite/18_support/numeric_limits/cons/default.cc
@@ -0,0 +1,26 @@
+// Copyright (C) 2008, 2009, 2010 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.
+
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING3.  If not see
+// <http://www.gnu.org/licenses/>.
+
+#include <limits>
+#include <testsuite_common_types.h>
+
+int main()
+{
+  __gnu_test::default_constructible test;
+  __gnu_cxx::typelist::apply_generator(test, __gnu_test::limits_tl());
+  return 0;
+}
diff --git a/libstdc++-v3/testsuite/18_support/numeric_limits/cons/default_c++0x.cc b/libstdc++-v3/testsuite/18_support/numeric_limits/cons/default_c++0x.cc
new file mode 100644
index 000000000..17ee4c79e
--- /dev/null
+++ b/libstdc++-v3/testsuite/18_support/numeric_limits/cons/default_c++0x.cc
@@ -0,0 +1,28 @@
+// { dg-options "-std=gnu++0x" }
+
+// Copyright (C) 2008, 2009, 2010 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.
+
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING3.  If not see
+// <http://www.gnu.org/licenses/>.
+
+#include <limits>
+#include <testsuite_common_types.h>
+
+int main()
+{
+  __gnu_test::default_constructible test;
+  __gnu_cxx::typelist::apply_generator(test, __gnu_test::limits_tl());
+  return 0;
+}
diff --git a/libstdc++-v3/testsuite/18_support/numeric_limits/denorm_min.cc b/libstdc++-v3/testsuite/18_support/numeric_limits/denorm_min.cc
new file mode 100644
index 000000000..b07cd7b06
--- /dev/null
+++ b/libstdc++-v3/testsuite/18_support/numeric_limits/denorm_min.cc
@@ -0,0 +1,54 @@
+// { dg-add-options ieee }
+
+// 1999-08-23 bkoz
+
+// Copyright (C) 1999, 2001, 2002, 2003, 2004, 2009 Free Software Foundation
+//
+// 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.
+
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING3.  If not see
+// <http://www.gnu.org/licenses/>.
+
+// 18.2.1.1 template class numeric_limits
+
+#include <limits>
+#include <limits.h>
+#include <float.h>
+#include <cwchar>
+#include <testsuite_hooks.h>
+
+template<typename T>
+void
+test_denorm_min()
+{
+  bool test;
+
+  if (std::numeric_limits<T>::has_denorm == std::denorm_present)
+    {
+      T denorm = std::numeric_limits<T>::denorm_min();
+      test = (denorm > 0);
+    }
+  else
+    test = true;
+
+  VERIFY (test);
+}
+
+int main()
+{
+  test_denorm_min<float>();
+  test_denorm_min<double>();
+  test_denorm_min<long double>();
+
+  return 0;
+}
diff --git a/libstdc++-v3/testsuite/18_support/numeric_limits/digits10.cc b/libstdc++-v3/testsuite/18_support/numeric_limits/digits10.cc
new file mode 100644
index 000000000..a8a865937
--- /dev/null
+++ b/libstdc++-v3/testsuite/18_support/numeric_limits/digits10.cc
@@ -0,0 +1,64 @@
+// { dg-add-options ieee }
+
+// 1999-08-23 bkoz
+
+// Copyright (C) 1999, 2001, 2002, 2003, 2004, 2009 Free Software Foundation
+//
+// 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.
+
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING3.  If not see
+// <http://www.gnu.org/licenses/>.
+
+// 18.2.1.1 template class numeric_limits
+
+#include <limits>
+#include <limits.h>
+#include <float.h>
+#include <cwchar>
+#include <testsuite_hooks.h>
+
+// libstdc++/5045
+bool test03()
+{
+  bool test __attribute__((unused)) = true;
+
+  VERIFY( std::numeric_limits<bool>::digits10 == 0 );
+  if (__CHAR_BIT__ == 8)
+    {
+      VERIFY( std::numeric_limits<signed char>::digits10 == 2 );
+      VERIFY( std::numeric_limits<unsigned char>::digits10 == 2 );
+    }
+  if (__CHAR_BIT__ * sizeof(short) == 16)
+    {
+      VERIFY( std::numeric_limits<signed short>::digits10 == 4 );
+      VERIFY( std::numeric_limits<unsigned short>::digits10 == 4 );
+    }
+  if (__CHAR_BIT__ * sizeof(int) == 32)
+    {
+      VERIFY( std::numeric_limits<signed int>::digits10 == 9 );
+      VERIFY( std::numeric_limits<unsigned int>::digits10 == 9 );
+    }
+  if (__CHAR_BIT__ * sizeof(long long) == 64)
+    {
+      VERIFY( std::numeric_limits<signed long long>::digits10 == 18 );
+      VERIFY( std::numeric_limits<unsigned long long>::digits10 == 19 );
+    }
+  return test;
+}
+
+int main()
+{
+  test03();
+
+  return 0;
+}
diff --git a/libstdc++-v3/testsuite/18_support/numeric_limits/dr559.cc b/libstdc++-v3/testsuite/18_support/numeric_limits/dr559.cc
new file mode 100644
index 000000000..ffe5a4ba0
--- /dev/null
+++ b/libstdc++-v3/testsuite/18_support/numeric_limits/dr559.cc
@@ -0,0 +1,102 @@
+// { dg-options "-std=gnu++0x" }
+
+// 2010-02-17  Paolo Carlini  <paolo.carlini@oracle.com>
+//
+// Copyright (C) 2010 Free Software Foundation
+//
+// 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.
+
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING3.  If not see
+// <http://www.gnu.org/licenses/>.
+
+#include <limits>
+#include <type_traits>
+#include <testsuite_hooks.h>
+
+template<typename T>
+  void do_test_aux()
+  {
+    bool test __attribute__((unused)) = true;
+    typedef std::numeric_limits<T> cv_limits;
+    typedef std::numeric_limits<typename std::remove_cv<T>::type> limits;
+
+    VERIFY( cv_limits::is_specialized == limits::is_specialized );
+    VERIFY( cv_limits::min() == limits::min() );
+    VERIFY( cv_limits::max() == limits::max() );
+    VERIFY( cv_limits::lowest() == limits::lowest() );
+    VERIFY( cv_limits::digits == limits::digits );
+    VERIFY( cv_limits::digits10 == limits::digits10 );
+    VERIFY( cv_limits::max_digits10 == limits::max_digits10 );
+    VERIFY( cv_limits::is_signed == limits::is_signed );
+    VERIFY( cv_limits::is_integer == limits::is_integer );
+    VERIFY( cv_limits::is_exact == limits::is_exact );
+    VERIFY( cv_limits::radix == limits::radix );
+    VERIFY( cv_limits::epsilon() == limits::epsilon() );
+    VERIFY( cv_limits::round_error() == limits::round_error() );
+    VERIFY( cv_limits::min_exponent == limits::min_exponent );
+    VERIFY( cv_limits::min_exponent10 == limits::min_exponent10 );
+    VERIFY( cv_limits::max_exponent == limits::max_exponent );
+    VERIFY( cv_limits::max_exponent10 == limits::max_exponent10 );
+    VERIFY( cv_limits::has_infinity == limits::has_infinity );
+    VERIFY( cv_limits::has_quiet_NaN == limits::has_quiet_NaN );
+    VERIFY( cv_limits::has_signaling_NaN == limits::has_signaling_NaN );
+    VERIFY( cv_limits::has_denorm == limits::has_denorm );
+    VERIFY( cv_limits::has_denorm_loss == limits::has_denorm_loss );
+    VERIFY( cv_limits::infinity() == limits::infinity() );
+    if (!std::is_floating_point<T>::value)
+      {
+	VERIFY( cv_limits::quiet_NaN() == limits::quiet_NaN() );
+	VERIFY( cv_limits::signaling_NaN() == limits::signaling_NaN() );
+      }
+    VERIFY( cv_limits::denorm_min() == limits::denorm_min() );
+    VERIFY( cv_limits::is_iec559 == limits::is_iec559 );
+    VERIFY( cv_limits::is_bounded == limits::is_bounded );
+    VERIFY( cv_limits::is_modulo == limits::is_modulo );
+    VERIFY( cv_limits::traps == limits::traps );
+    VERIFY( cv_limits::tinyness_before == limits::tinyness_before );
+    VERIFY( cv_limits::round_style == limits::round_style );
+  }
+
+template<typename T>
+  void
+  do_test()
+  {
+    do_test_aux<T>();
+    do_test_aux<const T>();
+    do_test_aux<volatile T>();
+    do_test_aux<const volatile T>();
+  }
+
+// DR 559.
+int main()
+{
+  do_test<bool>();
+  do_test<char>();
+  do_test<signed char>();
+  do_test<unsigned char>();
+  do_test<wchar_t>();
+  do_test<char16_t>();
+  do_test<char32_t>();
+  do_test<short>();
+  do_test<unsigned short>();
+  do_test<int>();
+  do_test<unsigned int>();
+  do_test<long>();
+  do_test<unsigned long>();
+  do_test<long long>();
+  do_test<unsigned long long>();
+  do_test<float>();
+  do_test<double>();
+  do_test<long double>();
+  return 0;
+}
diff --git a/libstdc++-v3/testsuite/18_support/numeric_limits/epsilon.cc b/libstdc++-v3/testsuite/18_support/numeric_limits/epsilon.cc
new file mode 100644
index 000000000..9ef546403
--- /dev/null
+++ b/libstdc++-v3/testsuite/18_support/numeric_limits/epsilon.cc
@@ -0,0 +1,47 @@
+// { dg-add-options ieee }
+
+// 1999-08-23 bkoz
+
+// Copyright (C) 1999, 2001, 2002, 2003, 2004, 2009 Free Software Foundation
+//
+// 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.
+
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING3.  If not see
+// <http://www.gnu.org/licenses/>.
+
+// 18.2.1.1 template class numeric_limits
+
+#include <limits>
+#include <limits.h>
+#include <float.h>
+#include <cwchar>
+#include <testsuite_hooks.h>
+
+template<typename T>
+void test_epsilon()
+{
+  bool test __attribute__((unused)) = true;
+  T epsilon = std::numeric_limits<T>::epsilon();
+  T one = 1;
+
+  VERIFY( one != (one + epsilon) );
+}
+
+int main()
+{
+  test_epsilon<float>();
+  test_epsilon<double>();
+  test_epsilon<long double>();
+
+  return 0;
+}
diff --git a/libstdc++-v3/testsuite/18_support/numeric_limits/infinity.cc b/libstdc++-v3/testsuite/18_support/numeric_limits/infinity.cc
new file mode 100644
index 000000000..92744c781
--- /dev/null
+++ b/libstdc++-v3/testsuite/18_support/numeric_limits/infinity.cc
@@ -0,0 +1,54 @@
+// { dg-add-options ieee }
+
+// 1999-08-23 bkoz
+
+// Copyright (C) 1999, 2001, 2002, 2003, 2004, 2009 Free Software Foundation
+//
+// 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.
+
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING3.  If not see
+// <http://www.gnu.org/licenses/>.
+
+// 18.2.1.1 template class numeric_limits
+
+#include <limits>
+#include <limits.h>
+#include <float.h>
+#include <cwchar>
+#include <testsuite_hooks.h>
+
+template<typename T>
+void
+test_infinity()
+{
+  bool test;
+
+  if (std::numeric_limits<T>::has_infinity)
+    {
+      T inf = std::numeric_limits<T>::infinity();
+      test = (inf + inf == inf);
+    }
+  else
+    test = true;
+
+  VERIFY (test);
+}
+
+int main()
+{
+  test_infinity<float>();
+  test_infinity<double>();
+  test_infinity<long double>();
+
+  return 0;
+}
diff --git a/libstdc++-v3/testsuite/18_support/numeric_limits/is_iec559.cc b/libstdc++-v3/testsuite/18_support/numeric_limits/is_iec559.cc
new file mode 100644
index 000000000..ce1c74d5e
--- /dev/null
+++ b/libstdc++-v3/testsuite/18_support/numeric_limits/is_iec559.cc
@@ -0,0 +1,79 @@
+// { dg-add-options ieee }
+
+// 1999-08-23 bkoz
+
+// Copyright (C) 1999, 2001, 2002, 2003, 2004, 2009 Free Software Foundation
+//
+// 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.
+
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING3.  If not see
+// <http://www.gnu.org/licenses/>.
+
+// 18.2.1.1 template class numeric_limits
+
+#include <limits>
+#include <limits.h>
+#include <float.h>
+#include <cwchar>
+#include <testsuite_hooks.h>
+
+template<typename T>
+void
+test_is_iec559()
+{
+  bool test;
+
+  if (std::numeric_limits<T>::is_iec559)
+    {
+      // IEC 559 requires all of the following.
+      test = (std::numeric_limits<T>::has_infinity
+	      && std::numeric_limits<T>::has_quiet_NaN
+	      && std::numeric_limits<T>::has_signaling_NaN);
+    }
+  else
+    {
+      // If we had all of the following, why didn't we set IEC 559?
+      test = (!std::numeric_limits<T>::has_infinity
+	      || !std::numeric_limits<T>::has_quiet_NaN
+	      || !std::numeric_limits<T>::has_signaling_NaN);
+    }
+
+  VERIFY (test);
+}
+
+// libstdc++/8949
+bool test04()
+{
+  bool test __attribute__((unused)) = true;
+
+  VERIFY( !std::numeric_limits<short>::is_iec559 );
+  VERIFY( !std::numeric_limits<unsigned short>::is_iec559 );
+  VERIFY( !std::numeric_limits<int>::is_iec559 );
+  VERIFY( !std::numeric_limits<unsigned int>::is_iec559 );
+  VERIFY( !std::numeric_limits<long>::is_iec559 );
+  VERIFY( !std::numeric_limits<unsigned long>::is_iec559 );
+  VERIFY( !std::numeric_limits<long long>::is_iec559 );
+  VERIFY( !std::numeric_limits<unsigned long long>::is_iec559 );
+  return test;
+}
+
+int main()
+{
+  test_is_iec559<float>();
+  test_is_iec559<double>();
+  test_is_iec559<long double>();
+
+  test04();
+
+  return 0;
+}
diff --git a/libstdc++-v3/testsuite/18_support/numeric_limits/is_signed.cc b/libstdc++-v3/testsuite/18_support/numeric_limits/is_signed.cc
new file mode 100644
index 000000000..299cd571f
--- /dev/null
+++ b/libstdc++-v3/testsuite/18_support/numeric_limits/is_signed.cc
@@ -0,0 +1,58 @@
+// { dg-add-options ieee }
+
+// 1999-08-23 bkoz
+
+// Copyright (C) 1999, 2001, 2002, 2003, 2004, 2009 Free Software Foundation
+//
+// 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.
+
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING3.  If not see
+// <http://www.gnu.org/licenses/>.
+
+// 18.2.1.1 template class numeric_limits
+
+#include <limits>
+#include <limits.h>
+#include <float.h>
+#include <cwchar>
+#include <testsuite_hooks.h>
+
+#ifdef __CHAR_UNSIGNED__
+#define char_is_signed false
+#else
+#define char_is_signed true
+#endif
+
+void test_sign()
+{
+  bool test __attribute__((unused)) = true;
+  VERIFY( std::numeric_limits<char>::is_signed == char_is_signed );
+  VERIFY( std::numeric_limits<signed char>::is_signed == true );
+  VERIFY( std::numeric_limits<unsigned char>::is_signed == false );
+  VERIFY( std::numeric_limits<short>::is_signed == true );
+  VERIFY( std::numeric_limits<unsigned short>::is_signed == false );
+  VERIFY( std::numeric_limits<int>::is_signed == true );
+  VERIFY( std::numeric_limits<unsigned>::is_signed == false );
+  VERIFY( std::numeric_limits<long>::is_signed == true );
+  VERIFY( std::numeric_limits<unsigned long>::is_signed == false );
+  VERIFY( std::numeric_limits<float>::is_signed == true );
+  VERIFY( std::numeric_limits<double>::is_signed == true );
+  VERIFY( std::numeric_limits<long double>::is_signed == true );
+}
+
+int main()
+{
+  test_sign();
+
+  return 0;
+}
diff --git a/libstdc++-v3/testsuite/18_support/numeric_limits/lowest.cc b/libstdc++-v3/testsuite/18_support/numeric_limits/lowest.cc
new file mode 100644
index 000000000..34b603e16
--- /dev/null
+++ b/libstdc++-v3/testsuite/18_support/numeric_limits/lowest.cc
@@ -0,0 +1,84 @@
+// { dg-options "-std=gnu++0x" }
+// { dg-add-options ieee }
+
+// 2010-02-25  Ed Smith-Rowland
+
+// Copyright (C) 2010, 2011 Free Software Foundation
+//
+// 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.
+
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING3.  If not see
+// <http://www.gnu.org/licenses/>.
+
+// 18.2.1.1 template class numeric_limits
+
+#include <limits>
+#include <type_traits>
+#include <testsuite_hooks.h>
+
+template<typename T>
+  void
+  do_test(std::true_type)
+  {
+    bool test __attribute__((unused)) = true;
+    T limits_min = std::numeric_limits<T>::min();
+    VERIFY( std::numeric_limits<T>::lowest() == limits_min );
+  }
+
+template<typename T>
+  void
+  do_test(std::false_type)
+  {
+    bool test __attribute__((unused)) = true;
+    T limits_max = std::numeric_limits<T>::max();
+    VERIFY( std::numeric_limits<T>::lowest() == -limits_max );
+  }
+
+template<typename Tp>
+  void
+  do_test()
+  { do_test<Tp>(typename std::is_integral<Tp>::type()); }
+
+void test01()
+{
+  do_test<char>();
+  do_test<signed char>();
+  do_test<unsigned char>();
+#ifdef _GLIBCXX_USE_WCHAR_T
+  do_test<wchar_t>();
+#endif
+  do_test<char16_t>();
+  do_test<char32_t>();
+
+  do_test<short>();
+  do_test<unsigned short>();
+
+  do_test<int>();
+  do_test<unsigned int>();
+
+  do_test<long>();
+  do_test<unsigned long>();
+
+  do_test<long long>();
+  do_test<unsigned long long>();
+
+  do_test<float>();
+  do_test<double>();
+  do_test<long double>();
+}
+
+int main()
+{
+  test01();
+  return 0;
+}
diff --git a/libstdc++-v3/testsuite/18_support/numeric_limits/max_digits10.cc b/libstdc++-v3/testsuite/18_support/numeric_limits/max_digits10.cc
new file mode 100644
index 000000000..fdce19c36
--- /dev/null
+++ b/libstdc++-v3/testsuite/18_support/numeric_limits/max_digits10.cc
@@ -0,0 +1,67 @@
+// { dg-options "-std=gnu++0x" }
+// { dg-add-options ieee }
+
+// 2010-02-25  Ed Smith-Rowland
+
+// Copyright (C) 2010 Free Software Foundation
+//
+// 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.
+
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING3.  If not see
+// <http://www.gnu.org/licenses/>.
+
+// 18.2.1.1 template class numeric_limits
+
+#include <limits>
+#include <cmath>
+#include <testsuite_hooks.h>
+
+void
+test01()
+{
+  bool test __attribute__((unused)) = true;
+
+  VERIFY( std::numeric_limits<bool>::max_digits10 == 0 );
+  VERIFY( std::numeric_limits<char>::max_digits10 == 0 );
+  VERIFY( std::numeric_limits<signed char>::max_digits10 == 0 );
+  VERIFY( std::numeric_limits<unsigned char>::max_digits10 == 0 );
+  VERIFY( std::numeric_limits<wchar_t>::max_digits10 == 0 );
+  VERIFY( std::numeric_limits<short>::max_digits10 == 0 );
+  VERIFY( std::numeric_limits<unsigned short>::max_digits10 == 0 );
+  VERIFY( std::numeric_limits<int>::max_digits10 == 0 );
+  VERIFY( std::numeric_limits<unsigned int>::max_digits10 == 0 );
+  VERIFY( std::numeric_limits<long>::max_digits10 == 0 );
+  VERIFY( std::numeric_limits<unsigned long>::max_digits10 == 0 );
+  VERIFY( std::numeric_limits<long long>::max_digits10 == 0 );
+  VERIFY( std::numeric_limits<unsigned long long>::max_digits10 == 0 );
+  VERIFY( std::numeric_limits<char16_t>::max_digits10 == 0 );
+  VERIFY( std::numeric_limits<char32_t>::max_digits10 == 0 );
+
+  const int f_max_digits10 = (2 + std::numeric_limits<float>::digits
+			      * 643 / 2136);
+  VERIFY( std::numeric_limits<float>::max_digits10 == f_max_digits10 );
+
+  const int d_max_digits10 = (2 + std::numeric_limits<double>::digits
+			      * 643 / 2136);
+  VERIFY( std::numeric_limits<double>::max_digits10 == d_max_digits10 );
+
+  const int ld_max_digits10 = (2 + std::numeric_limits<long double>::digits
+			       * 643 / 2136);
+  VERIFY( std::numeric_limits<long double>::max_digits10 == ld_max_digits10 );
+}
+
+int main()
+{
+  test01();
+  return 0;
+}
diff --git a/libstdc++-v3/testsuite/18_support/numeric_limits/min_max.cc b/libstdc++-v3/testsuite/18_support/numeric_limits/min_max.cc
new file mode 100644
index 000000000..ba2a9f61e
--- /dev/null
+++ b/libstdc++-v3/testsuite/18_support/numeric_limits/min_max.cc
@@ -0,0 +1,93 @@
+// { dg-add-options ieee }
+
+// 1999-08-23 bkoz
+
+// Copyright (C) 1999, 2001, 2002, 2003, 2004, 2009 Free Software Foundation
+//
+// 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.
+
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING3.  If not see
+// <http://www.gnu.org/licenses/>.
+
+// 18.2.1.1 template class numeric_limits
+
+#include <limits>
+#include <limits.h>
+#include <float.h>
+#include <cwchar>
+#include <testsuite_hooks.h>
+
+template<typename T>
+struct extrema {
+  static T min;
+  static T max;
+};
+
+
+#define DEFINE_EXTREMA(T, m, M) \
+  template<> T extrema<T>::min = m; \
+  template<> T extrema<T>::max = M
+
+DEFINE_EXTREMA(char, CHAR_MIN, CHAR_MAX);
+DEFINE_EXTREMA(signed char, SCHAR_MIN, SCHAR_MAX);
+DEFINE_EXTREMA(unsigned char, 0, UCHAR_MAX);
+DEFINE_EXTREMA(short, SHRT_MIN, SHRT_MAX);
+DEFINE_EXTREMA(unsigned short, 0, USHRT_MAX);
+DEFINE_EXTREMA(int, INT_MIN, INT_MAX);
+DEFINE_EXTREMA(unsigned, 0U, UINT_MAX);
+DEFINE_EXTREMA(long, LONG_MIN, LONG_MAX);
+DEFINE_EXTREMA(unsigned long, 0UL, ULONG_MAX);
+
+#if _GLIBCXX_USE_WCHAR_T
+DEFINE_EXTREMA(wchar_t, WCHAR_MIN, WCHAR_MAX);
+#endif //_GLIBCXX_USE_WCHAR_T
+
+DEFINE_EXTREMA(float, FLT_MIN, FLT_MAX);
+DEFINE_EXTREMA(double, DBL_MIN, DBL_MAX);
+DEFINE_EXTREMA(long double, LDBL_MIN, LDBL_MAX);
+
+#undef DEFINE_EXTREMA
+
+template<typename T>
+void test_extrema()
+{
+  bool test __attribute__((unused)) = true;
+  T limits_min = std::numeric_limits<T>::min();
+  T limits_max = std::numeric_limits<T>::max();
+  T extrema_min = extrema<T>::min;
+  T extrema_max = extrema<T>::max;
+  VERIFY( extrema_min == limits_min );
+  VERIFY( extrema_max == limits_max );
+}
+
+int main()
+{
+  test_extrema<char>();
+  test_extrema<signed char>();
+  test_extrema<unsigned char>();
+  
+  test_extrema<short>();
+  test_extrema<unsigned short>();
+
+  test_extrema<int>();
+  test_extrema<unsigned>();
+
+  test_extrema<long>();
+  test_extrema<unsigned long>();
+
+  test_extrema<float>();
+  test_extrema<double>();
+  test_extrema<long double>();
+
+  return 0;
+}
diff --git a/libstdc++-v3/testsuite/18_support/numeric_limits/quiet_NaN.cc b/libstdc++-v3/testsuite/18_support/numeric_limits/quiet_NaN.cc
new file mode 100644
index 000000000..7d1db7835
--- /dev/null
+++ b/libstdc++-v3/testsuite/18_support/numeric_limits/quiet_NaN.cc
@@ -0,0 +1,54 @@
+// { dg-add-options ieee }
+
+// 1999-08-23 bkoz
+
+// Copyright (C) 1999, 2001, 2002, 2003, 2004, 2009 Free Software Foundation
+//
+// 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.
+
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING3.  If not see
+// <http://www.gnu.org/licenses/>.
+
+// 18.2.1.1 template class numeric_limits
+
+#include <limits>
+#include <limits.h>
+#include <float.h>
+#include <cwchar>
+#include <testsuite_hooks.h>
+
+template<typename T>
+void
+test_qnan()
+{
+  bool test;
+
+  if (std::numeric_limits<T>::has_quiet_NaN)
+    {
+      T nan = std::numeric_limits<T>::quiet_NaN();
+      test = (nan != nan);
+    }
+  else
+    test = true;
+
+  VERIFY (test);
+}
+
+int main()
+{
+  test_qnan<float>();
+  test_qnan<double>();
+  test_qnan<long double>();
+
+  return 0;
+}
diff --git a/libstdc++-v3/testsuite/18_support/numeric_limits/requirements/constexpr_data.cc b/libstdc++-v3/testsuite/18_support/numeric_limits/requirements/constexpr_data.cc
new file mode 100644
index 000000000..0b82a75db
--- /dev/null
+++ b/libstdc++-v3/testsuite/18_support/numeric_limits/requirements/constexpr_data.cc
@@ -0,0 +1,98 @@
+// { dg-do compile }
+// { dg-options "-std=gnu++0x" }
+
+// Copyright (C) 2010 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.
+
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING3.  If not see
+// <http://www.gnu.org/licenses/>.
+
+#include <limits>
+#include <testsuite_common_types.h>
+
+namespace __gnu_test
+{
+  struct constexpr_member_data
+  {
+    template<typename _Ttesttype>
+      void
+      operator()()
+      {
+	struct _Concept
+	{
+	  void __constraint()
+	  { 
+	    using std::float_denorm_style;
+	    using std::float_round_style;
+	    constexpr bool v1 __attribute__((unused))
+	      = _Ttesttype::is_specialized;
+	    constexpr int v2 __attribute__((unused))
+	      = _Ttesttype::digits;
+	    constexpr int v3 __attribute__((unused))
+	      = _Ttesttype::digits10;
+	    constexpr int v4 __attribute__((unused))
+	      = _Ttesttype::max_digits10;
+	    constexpr bool v5 __attribute__((unused))
+	      = _Ttesttype::is_signed;
+	    constexpr bool v6 __attribute__((unused))
+	      = _Ttesttype::is_integer;
+	    constexpr bool v7 __attribute__((unused))
+	      = _Ttesttype::is_exact;
+	    constexpr int v8 __attribute__((unused))
+	      = _Ttesttype::radix;
+	    constexpr int v9 __attribute__((unused))
+	      = _Ttesttype::min_exponent;
+	    constexpr int v10 __attribute__((unused))
+	      = _Ttesttype::min_exponent10;
+	    constexpr int v11 __attribute__((unused))
+	      = _Ttesttype::max_exponent;
+	    constexpr int v12 __attribute__((unused))
+	      = _Ttesttype::max_exponent10;
+	    constexpr bool v13 __attribute__((unused))
+	      = _Ttesttype::has_infinity;
+	    constexpr bool v14 __attribute__((unused))
+	      = _Ttesttype::has_quiet_NaN;
+	    constexpr bool v15 __attribute__((unused))
+	      = _Ttesttype::has_signaling_NaN;
+	    constexpr float_denorm_style v16 __attribute__((unused))
+	      = _Ttesttype::has_denorm;
+	    constexpr bool v17 __attribute__((unused))
+	      = _Ttesttype::has_denorm_loss;
+	    constexpr bool v18 __attribute__((unused))
+	      = _Ttesttype::is_iec559;
+	    constexpr bool v19 __attribute__((unused))
+	      = _Ttesttype::is_bounded;
+	    constexpr bool v20 __attribute__((unused))
+	      = _Ttesttype::is_modulo;
+	    constexpr bool v21 __attribute__((unused))
+	      = _Ttesttype::traps;
+	    constexpr bool v22 __attribute__((unused))
+	      = _Ttesttype::tinyness_before;
+	    constexpr float_round_style v23 __attribute__((unused))
+	      = _Ttesttype::round_style;
+	  }
+	};
+
+	_Concept c;
+	c.__constraint();
+      }
+  };
+}
+
+int main()
+{
+  __gnu_test::constexpr_member_data test;
+  __gnu_cxx::typelist::apply_generator(test, __gnu_test::limits_tl());
+  return 0;
+}
diff --git a/libstdc++-v3/testsuite/18_support/numeric_limits/requirements/constexpr_functions.cc b/libstdc++-v3/testsuite/18_support/numeric_limits/requirements/constexpr_functions.cc
new file mode 100644
index 000000000..f1848f218
--- /dev/null
+++ b/libstdc++-v3/testsuite/18_support/numeric_limits/requirements/constexpr_functions.cc
@@ -0,0 +1,70 @@
+// { dg-do compile }
+// { dg-options "-std=gnu++0x" }
+
+// Copyright (C) 2010 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.
+
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING3.  If not see
+// <http://www.gnu.org/licenses/>.
+
+#include <limits>
+#include <testsuite_common_types.h>
+
+namespace __gnu_test
+{
+  struct constexpr_member_functions
+  {
+    template<typename _Ttesttype, typename _Tbasetype>
+      void
+      operator()()
+      {
+	struct _Concept
+	{
+	  void __constraint()
+	  { 
+	    constexpr _Tbasetype v1 __attribute__((unused))
+	      = _Ttesttype::min();
+	    constexpr _Tbasetype v2 __attribute__((unused))
+	      = _Ttesttype::max();
+	    constexpr _Tbasetype v3 __attribute__((unused))
+	      = _Ttesttype::lowest();
+	    constexpr _Tbasetype v4 __attribute__((unused))
+	      = _Ttesttype::epsilon();
+	    constexpr _Tbasetype v5 __attribute__((unused))
+	      = _Ttesttype::round_error();
+	    constexpr _Tbasetype v6 __attribute__((unused))
+	      = _Ttesttype::infinity();
+	    constexpr _Tbasetype v7 __attribute__((unused))
+	      = _Ttesttype::quiet_NaN();
+	    constexpr _Tbasetype v8 __attribute__((unused))
+	      = _Ttesttype::signaling_NaN();
+	    constexpr _Tbasetype v9 __attribute__((unused))
+	      = _Ttesttype::denorm_min();
+	  }
+	};
+
+	_Concept c;
+	c.__constraint();
+      }
+  };
+}
+
+int main()
+{
+  __gnu_test::constexpr_member_functions test;
+  __gnu_cxx::typelist::apply_generator(test,
+				       __gnu_test::limits_tl(),
+				       __gnu_test::integral_types::type());
+  return 0;
+}
diff --git a/libstdc++-v3/testsuite/18_support/numeric_limits/requirements/explicit_instantiation/1.cc b/libstdc++-v3/testsuite/18_support/numeric_limits/requirements/explicit_instantiation/1.cc
new file mode 100644
index 000000000..aa75bd14c
--- /dev/null
+++ b/libstdc++-v3/testsuite/18_support/numeric_limits/requirements/explicit_instantiation/1.cc
@@ -0,0 +1,41 @@
+// { dg-do compile }
+
+// Copyright (C) 2007, 2009 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.
+
+// You should have received a copy of the GNU General Public License
+// along with this library; see the file COPYING3.  If not see
+// <http://www.gnu.org/licenses/>.
+
+
+// This file tests explicit instantiation of library containers.
+
+#include <limits>
+
+template<typename T>
+  struct A 
+  {
+    int key;
+  public:
+    A(int i = 0): key(i) { }
+    bool
+    operator==(int i) { return i == key; }
+  };
+
+struct B 
+{
+  B(int = 0) { }
+};
+
+// XXX Should this work for POD types?
+template class std::numeric_limits<A<B> >;
diff --git a/libstdc++-v3/testsuite/18_support/numeric_limits/specialization_default_values.cc b/libstdc++-v3/testsuite/18_support/numeric_limits/specialization_default_values.cc
new file mode 100644
index 000000000..e2036d77d
--- /dev/null
+++ b/libstdc++-v3/testsuite/18_support/numeric_limits/specialization_default_values.cc
@@ -0,0 +1,106 @@
+// { dg-add-options ieee }
+
+// 1999-08-23 bkoz
+
+// Copyright (C) 1999, 2001, 2002, 2003, 2004, 2005, 2006, 2009
+// Free Software Foundation
+//
+// 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.
+
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING3.  If not see
+// <http://www.gnu.org/licenses/>.
+
+// 18.2.1.1 template class numeric_limits
+
+#include <limits>
+#include <limits.h>
+#include <float.h>
+#include <cwchar>
+#include <testsuite_hooks.h>
+
+template<typename T>
+  struct A 
+  {
+    int key;
+  public:
+    A(int i = 0): key(i) { }
+    bool
+    operator==(int i) { return i == key; }
+  };
+
+struct B 
+{
+  B(int = 0) { }
+};
+
+
+bool test01()
+{
+  bool test __attribute__((unused)) = true;
+  std::numeric_limits< A<B> > obj;
+
+  VERIFY( !obj.is_specialized );
+  VERIFY( obj.min() == 0 );
+  VERIFY( obj.max() == 0 );
+  VERIFY( obj.digits ==  0 );
+  VERIFY( obj.digits10 == 0 );
+  VERIFY( !obj.is_signed );
+  VERIFY( !obj.is_integer );
+  VERIFY( !obj.is_exact );
+  VERIFY( obj.radix == 0 );
+  VERIFY( obj.epsilon() == 0 );
+  VERIFY( obj.round_error() == 0 );
+  VERIFY( obj.min_exponent == 0 );
+  VERIFY( obj.min_exponent10 == 0 );
+  VERIFY( obj.max_exponent == 0 );
+  VERIFY( obj.max_exponent10 == 0 );
+  VERIFY( !obj.has_infinity );
+  VERIFY( !obj.has_quiet_NaN );
+  VERIFY( !obj.has_signaling_NaN );
+  VERIFY( !obj.has_denorm );
+  VERIFY( !obj.has_denorm_loss );
+  VERIFY( obj.infinity() == 0 );
+  VERIFY( obj.quiet_NaN() == 0 );
+  VERIFY( obj.signaling_NaN() == 0 );
+  VERIFY( obj.denorm_min() == 0 );
+  VERIFY( !obj.is_iec559 );
+  VERIFY( !obj.is_bounded );
+  VERIFY( !obj.is_modulo );
+  VERIFY( !obj.traps );
+  VERIFY( !obj.tinyness_before );
+  VERIFY( obj.round_style == std::round_toward_zero );
+  return test;
+}
+
+// test linkage of the generic bits
+template struct std::numeric_limits<B>;
+
+void test02()
+{
+  typedef std::numeric_limits<B> b_nl_type;
+  
+  // Should probably do all of them...
+  const int* __attribute__((unused)) pi1 = &b_nl_type::digits;
+  const int* __attribute__((unused)) pi2 = &b_nl_type::digits10;
+  const int* __attribute__((unused)) pi3 = &b_nl_type::max_exponent10;
+  const bool* __attribute__((unused)) pb1 = &b_nl_type::traps;
+}
+
+
+int main()
+{
+  test01();
+  test02();
+
+  return 0;
+}
diff --git a/libstdc++-v3/testsuite/18_support/numeric_limits/traps.cc b/libstdc++-v3/testsuite/18_support/numeric_limits/traps.cc
new file mode 100644
index 000000000..39c5576fa
--- /dev/null
+++ b/libstdc++-v3/testsuite/18_support/numeric_limits/traps.cc
@@ -0,0 +1,61 @@
+// { dg-add-options ieee }
+
+// Copyright (C) 2005, 2009 Free Software Foundation
+//
+// 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.
+
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING3.  If not see
+// <http://www.gnu.org/licenses/>.
+
+// 18.2.1.1 template class numeric_limits
+
+#include <limits>
+#include <testsuite_hooks.h>
+
+template<typename T>
+  void 
+  test_traps(T r = T(0))
+  {
+    typedef T value_type;
+    volatile value_type i(5);
+    volatile value_type j(0);
+    
+    if (!std::numeric_limits<value_type>::traps)
+      r = i / j;
+  }
+
+// libstdc++/22203
+int main()
+{
+  test_traps<int>();
+  test_traps<unsigned int>();
+  test_traps<long>();
+  test_traps<unsigned long>();
+  test_traps<long long>();
+  test_traps<unsigned long long>();
+ 
+  /*
+    For floating points, trapping is a different, more complicated
+    story.  If is_iecxxx is true, then division by zero would not trap
+    (infinity).  If is_iecxxx is false, we don't know (VAX may trap for
+    0/0 -- I have to check).  For most cases (i.e. IEE-754), trapping
+    for floating points have to do with whether there is a support for
+    signaling NaN.
+    - Gaby.
+  */
+  //  test_traps<float>();
+  //  test_traps<double>();
+  //  test_traps<long double>();
+
+  return 0;
+}