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.

60 files changed, 4243 insertions, 0 deletions

diff --git a/libstdc++-v3/testsuite/20_util/shared_ptr/assign/assign.cc b/libstdc++-v3/testsuite/20_util/shared_ptr/assign/assign.cc
new file mode 100644
index 000000000..7c93eb077
--- /dev/null
+++ b/libstdc++-v3/testsuite/20_util/shared_ptr/assign/assign.cc
@@ -0,0 +1,72 @@
+// { dg-options "-std=gnu++0x" }
+
+// Copyright (C) 2005, 2006, 2007, 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/>.
+
+// 20.6.6.2 Template class shared_ptr [util.smartptr.shared]
+
+#include <memory>
+#include <testsuite_hooks.h>
+
+struct A
+{
+  A() { ++ctor_count; }
+  virtual ~A() { ++dtor_count; }
+  static long ctor_count;
+  static long dtor_count;
+};
+long A::ctor_count = 0;
+long A::dtor_count = 0;
+
+struct reset_count_struct
+{
+  ~reset_count_struct()
+  {
+    A::ctor_count = 0;
+    A::dtor_count = 0;
+  }
+};
+
+
+// 20.6.6.2.3 shared_ptr assignment [util.smartptr.shared.assign]
+
+// Assignment from shared_ptr<Y>
+void
+test01()
+{
+  reset_count_struct __attribute__((unused)) reset;
+  bool test __attribute__((unused)) = true;
+
+  std::shared_ptr<A> a;
+
+  a = std::shared_ptr<A>(new A);
+  VERIFY( a.get() != 0 );
+  VERIFY( A::ctor_count == 1 );
+  VERIFY( A::dtor_count == 0 );
+
+  a = std::shared_ptr<A>();
+  VERIFY( a.get() == 0 );
+  VERIFY( A::ctor_count == 1 );
+  VERIFY( A::dtor_count == 1 );
+}
+
+int 
+main()
+{
+  test01();
+  return 0;
+}
diff --git a/libstdc++-v3/testsuite/20_util/shared_ptr/assign/auto_ptr.cc b/libstdc++-v3/testsuite/20_util/shared_ptr/assign/auto_ptr.cc
new file mode 100644
index 000000000..e2ec07860
--- /dev/null
+++ b/libstdc++-v3/testsuite/20_util/shared_ptr/assign/auto_ptr.cc
@@ -0,0 +1,85 @@
+// { dg-options "-std=gnu++0x" }
+
+// Copyright (C) 2005, 2006, 2007, 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/>.
+
+// 20.6.6.2 Template class shared_ptr [util.smartptr.shared]
+
+#include <memory>
+#include <testsuite_hooks.h>
+
+struct A
+{
+  A() { ++ctor_count; }
+  virtual ~A() { ++dtor_count; }
+  static long ctor_count;
+  static long dtor_count;
+};
+long A::ctor_count = 0;
+long A::dtor_count = 0;
+
+struct B : A
+{
+  B() { ++ctor_count; }
+  virtual ~B() { ++dtor_count; }
+  static long ctor_count;
+  static long dtor_count;
+};
+long B::ctor_count = 0;
+long B::dtor_count = 0;
+
+
+struct reset_count_struct
+{
+  ~reset_count_struct()
+  {
+    A::ctor_count = 0;
+    A::dtor_count = 0;
+    B::ctor_count = 0;
+    B::dtor_count = 0;
+  }
+};
+
+
+// 20.6.6.2.3 shared_ptr assignment [util.smartptr.shared.assign]
+
+// Assignment from auto_ptr<Y>
+int
+test01()
+{
+  reset_count_struct __attribute__((unused)) reset;
+  bool test __attribute__((unused)) = true;
+
+  std::shared_ptr<A> a(new A);
+  std::auto_ptr<B> b(new B);
+  a = std::move(b);
+  VERIFY( a.get() != 0 );
+  VERIFY( b.get() == 0 );
+  VERIFY( A::ctor_count == 2 );
+  VERIFY( A::dtor_count == 1 );
+  VERIFY( B::ctor_count == 1 );
+  VERIFY( B::dtor_count == 0 );
+
+  return 0;
+}
+
+int 
+main()
+{
+  test01();
+  return 0;
+}
diff --git a/libstdc++-v3/testsuite/20_util/shared_ptr/assign/auto_ptr_neg.cc b/libstdc++-v3/testsuite/20_util/shared_ptr/assign/auto_ptr_neg.cc
new file mode 100644
index 000000000..b79a25b13
--- /dev/null
+++ b/libstdc++-v3/testsuite/20_util/shared_ptr/assign/auto_ptr_neg.cc
@@ -0,0 +1,50 @@
+// { dg-options "-std=gnu++0x" }
+// { dg-do compile }
+
+// Copyright (C) 2005, 2006, 2007, 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/>.
+
+// 20.6.6.2 Template class shared_ptr [util.smartptr.shared]
+
+#include <memory>
+#include <testsuite_hooks.h>
+
+struct A { };
+struct B { };
+
+// 20.6.6.2.3 shared_ptr assignment [util.smartptr.shared.assign]
+
+// Assignment from incompatible auto_ptr<Y>
+int
+test01()
+{
+  bool test __attribute__((unused)) = true;
+
+  std::shared_ptr<A> a;
+  std::auto_ptr<B> b;
+  a = std::move(b);                      // { dg-error "here" }
+
+  return 0;
+}
+
+int 
+main()
+{
+  test01();
+  return 0;
+}
+// { dg-excess-errors "In constructor" }
diff --git a/libstdc++-v3/testsuite/20_util/shared_ptr/assign/auto_ptr_rvalue.cc b/libstdc++-v3/testsuite/20_util/shared_ptr/assign/auto_ptr_rvalue.cc
new file mode 100644
index 000000000..376e8945f
--- /dev/null
+++ b/libstdc++-v3/testsuite/20_util/shared_ptr/assign/auto_ptr_rvalue.cc
@@ -0,0 +1,61 @@
+// { dg-options "-std=gnu++0x -Wno-deprecated" }
+// { dg-do compile }
+
+// 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/>.
+
+// 20.7.12.2 Template class shared_ptr [util.smartptr.shared]
+
+#include <memory>
+#include <testsuite_hooks.h>
+
+struct A { };
+std::auto_ptr<A> source() { return std::auto_ptr<A>(); }
+
+// 20.7.12.2.3 shared_ptr assignment [util.smartptr.shared.assign]
+
+// Assignment from rvalue auto_ptr
+int
+test01()
+{
+  bool test __attribute__((unused)) = true;
+
+  std::shared_ptr<A> a;
+  a = source();
+
+  return 0;
+}
+
+int
+test02()
+{
+  bool test __attribute__((unused)) = true;
+
+  std::shared_ptr<A> a;
+  std::auto_ptr<A> au;
+  a = std::move(au);
+
+  return 0;
+}
+
+int 
+main()
+{
+  test01();
+  test02();
+  return 0;
+}
diff --git a/libstdc++-v3/testsuite/20_util/shared_ptr/assign/dr541.cc b/libstdc++-v3/testsuite/20_util/shared_ptr/assign/dr541.cc
new file mode 100644
index 000000000..48ddf9053
--- /dev/null
+++ b/libstdc++-v3/testsuite/20_util/shared_ptr/assign/dr541.cc
@@ -0,0 +1,30 @@
+// { dg-options "-std=gnu++0x" }
+// { dg-do compile }
+
+// Copyright (C) 2006, 2007, 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/>.
+
+// 20.6.6.2 Template class shared_ptr [util.smartptr.shared]
+
+#include <memory>
+
+// DR 541. shared_ptr template assignment and void
+void test01()
+{
+  std::shared_ptr<void> p;
+  p.operator=<void>(p);
+}
diff --git a/libstdc++-v3/testsuite/20_util/shared_ptr/assign/move.cc b/libstdc++-v3/testsuite/20_util/shared_ptr/assign/move.cc
new file mode 100644
index 000000000..1a7b20caf
--- /dev/null
+++ b/libstdc++-v3/testsuite/20_util/shared_ptr/assign/move.cc
@@ -0,0 +1,118 @@
+// { dg-options "-std=gnu++0x" }
+
+// Copyright (C) 2007, 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/>.
+
+// 20.6.6.2 Template class shared_ptr [util.smartptr.shared]
+
+#include <memory>
+#include <utility>
+#include <testsuite_hooks.h>
+
+struct A
+{
+  A() { ++ctor_count; }
+  virtual ~A() { ++dtor_count; }
+  static long ctor_count;
+  static long dtor_count;
+};
+long A::ctor_count = 0;
+long A::dtor_count = 0;
+
+struct B : A
+{
+  B() { ++ctor_count; }
+  virtual ~B() { ++dtor_count; }
+  static long ctor_count;
+  static long dtor_count;
+};
+long B::ctor_count = 0;
+long B::dtor_count = 0;
+
+struct reset_count_struct
+{
+  ~reset_count_struct()
+  {
+    A::ctor_count = 0;
+    A::dtor_count = 0;
+    B::ctor_count = 0;
+    B::dtor_count = 0;
+  }
+};
+
+
+// 20.6.6.2.1 shared_ptr constructors [util.smartptr.shared.const]
+
+// Rvalue assignment from shared_ptr
+void
+test01()
+{
+  reset_count_struct __attribute__((unused)) reset;
+  bool test __attribute__((unused)) = true;
+
+  std::shared_ptr<A> a1;
+  std::shared_ptr<A> a2(new A);
+
+  a1 = std::move(a2);
+  VERIFY( a1.get() != 0 );
+  VERIFY( a2.get() == 0 );
+  VERIFY( a1.use_count() == 1 );
+  VERIFY( a2.use_count() == 0 );
+  VERIFY( A::ctor_count == 1 );
+  VERIFY( A::dtor_count == 0 );
+
+  a1 = std::move(std::shared_ptr<A>());
+  VERIFY( a1.get() == 0 );
+  VERIFY( A::ctor_count == 1 );
+  VERIFY( A::dtor_count == 1 );
+}
+
+// Rvalue assignment from shared_ptr<Y>
+void
+test02()
+{
+  reset_count_struct __attribute__((unused)) reset;
+  bool test __attribute__((unused)) = true;
+
+  std::shared_ptr<A> a;
+  std::shared_ptr<B> b(new B);
+
+  a = std::move(b);
+  VERIFY( a.get() != 0 );
+  VERIFY( b.get() == 0 );
+  VERIFY( a.use_count() == 1 );
+  VERIFY( b.use_count() == 0 );
+  VERIFY( A::ctor_count == 1 );
+  VERIFY( A::dtor_count == 0 );
+  VERIFY( B::ctor_count == 1 );
+  VERIFY( B::dtor_count == 0 );
+
+  a = std::move(std::shared_ptr<A>());
+  VERIFY( a.get() == 0 );
+  VERIFY( A::ctor_count == 1 );
+  VERIFY( A::dtor_count == 1 );
+  VERIFY( B::ctor_count == 1 );
+  VERIFY( B::dtor_count == 1 );
+}
+
+int 
+main()
+{
+  test01();
+  test02();
+  return 0;
+}
diff --git a/libstdc++-v3/testsuite/20_util/shared_ptr/assign/shared_ptr.cc b/libstdc++-v3/testsuite/20_util/shared_ptr/assign/shared_ptr.cc
new file mode 100644
index 000000000..4543be696
--- /dev/null
+++ b/libstdc++-v3/testsuite/20_util/shared_ptr/assign/shared_ptr.cc
@@ -0,0 +1,96 @@
+// { dg-options "-std=gnu++0x" }
+
+// Copyright (C) 2005, 2006, 2007, 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/>.
+
+// 20.6.6.2 Template class shared_ptr [util.smartptr.shared]
+
+#include <memory>
+#include <testsuite_hooks.h>
+
+struct A
+{
+  A() { ++ctor_count; }
+  virtual ~A() { ++dtor_count; }
+  static long ctor_count;
+  static long dtor_count;
+};
+long A::ctor_count = 0;
+long A::dtor_count = 0;
+
+struct B : A
+{
+  B() { ++ctor_count; }
+  virtual ~B() { ++dtor_count; }
+  static long ctor_count;
+  static long dtor_count;
+};
+long B::ctor_count = 0;
+long B::dtor_count = 0;
+
+
+struct reset_count_struct
+{
+  ~reset_count_struct()
+  {
+    A::ctor_count = 0;
+    A::dtor_count = 0;
+    B::ctor_count = 0;
+    B::dtor_count = 0;
+  }
+};
+
+
+// 20.6.6.2.3 shared_ptr assignment [util.smartptr.shared.assign]
+
+// Assignment from shared_ptr<Y>
+void
+test01()
+{
+  reset_count_struct __attribute__((unused)) reset;
+  bool test __attribute__((unused)) = true;
+
+  std::shared_ptr<A> a;
+
+  a = std::shared_ptr<A>();
+  VERIFY( a.get() == 0 );
+  VERIFY( A::ctor_count == 0 );
+  VERIFY( A::dtor_count == 0 );
+  VERIFY( B::ctor_count == 0 );
+  VERIFY( B::dtor_count == 0 );
+
+  a = std::shared_ptr<A>(new A);
+  VERIFY( a.get() != 0 );
+  VERIFY( A::ctor_count == 1 );
+  VERIFY( A::dtor_count == 0 );
+  VERIFY( B::ctor_count == 0 );
+  VERIFY( B::dtor_count == 0 );
+
+  a = std::shared_ptr<B>(new B);
+  VERIFY( a.get() != 0 );
+  VERIFY( A::ctor_count == 2 );
+  VERIFY( A::dtor_count == 1 );
+  VERIFY( B::ctor_count == 1 );
+  VERIFY( B::dtor_count == 0 );
+}
+
+int 
+main()
+{
+  test01();
+  return 0;
+}
diff --git a/libstdc++-v3/testsuite/20_util/shared_ptr/assign/shared_ptr_neg.cc b/libstdc++-v3/testsuite/20_util/shared_ptr/assign/shared_ptr_neg.cc
new file mode 100644
index 000000000..e0d09dee9
--- /dev/null
+++ b/libstdc++-v3/testsuite/20_util/shared_ptr/assign/shared_ptr_neg.cc
@@ -0,0 +1,52 @@
+// { dg-options "-std=gnu++0x" }
+// { dg-do compile }
+
+// Copyright (C) 2005, 2006, 2007, 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/>.
+
+// 20.6.6.2 Template class shared_ptr [util.smartptr.shared]
+
+#include <memory>
+#include <testsuite_hooks.h>
+
+struct A { };
+struct B { };
+
+// 20.6.6.2.3 shared_ptr assignment [util.smartptr.shared.assign]
+
+// Assignment from incompatible shared_ptr<Y>
+int
+test01()
+{
+  bool test __attribute__((unused)) = true;
+
+  std::shared_ptr<A> a;
+  std::shared_ptr<B> b;
+  a = b;                      // { dg-error "here" }
+
+  return 0;
+}
+
+int 
+main()
+{
+  test01();
+  return 0;
+}
+// { dg-error "In member function" "" { target *-*-* } 0 }
+// { dg-error "cannot convert" "" { target *-*-* } 0 }
+// { dg-error "instantiated from" "" { target *-*-* } 0 }
diff --git a/libstdc++-v3/testsuite/20_util/shared_ptr/assign/unique_ptr_lvalue_neg.cc b/libstdc++-v3/testsuite/20_util/shared_ptr/assign/unique_ptr_lvalue_neg.cc
new file mode 100644
index 000000000..dae967bfd
--- /dev/null
+++ b/libstdc++-v3/testsuite/20_util/shared_ptr/assign/unique_ptr_lvalue_neg.cc
@@ -0,0 +1,49 @@
+// { dg-options "-std=gnu++0x" }
+// { dg-do compile }
+
+// Copyright (C) 2008, 2009, 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/>.
+
+// 20.7.12.2 Template class shared_ptr [util.smartptr.shared]
+
+#include <memory>
+#include <testsuite_hooks.h>
+
+struct A { };
+
+// 20.7.12.2.3 shared_ptr assignment [util.smartptr.shared.assign]
+
+// Assignment from lvalue unique_ptr
+int
+test01()
+{
+  bool test __attribute__((unused)) = true;
+
+  std::shared_ptr<A> a;
+  std::unique_ptr<A> u;
+  a = u; // { dg-error "cannot bind" }
+
+  return 0;
+}
+
+int 
+main()
+{
+  test01();
+  return 0;
+}
+// { dg-excess-errors "initializing argument" }
diff --git a/libstdc++-v3/testsuite/20_util/shared_ptr/assign/unique_ptr_rvalue.cc b/libstdc++-v3/testsuite/20_util/shared_ptr/assign/unique_ptr_rvalue.cc
new file mode 100644
index 000000000..e759a42c3
--- /dev/null
+++ b/libstdc++-v3/testsuite/20_util/shared_ptr/assign/unique_ptr_rvalue.cc
@@ -0,0 +1,61 @@
+// { dg-options "-std=gnu++0x" }
+// { dg-do compile }
+
+// 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/>.
+
+// 20.7.12.2 Template class shared_ptr [util.smartptr.shared]
+
+#include <memory>
+#include <testsuite_hooks.h>
+
+struct A { };
+std::unique_ptr<A> source() { return std::unique_ptr<A>(); }
+
+// 20.7.12.2.3 shared_ptr assignment [util.smartptr.shared.assign]
+
+// Assignment from rvalue unique_ptr
+int
+test01()
+{
+  bool test __attribute__((unused)) = true;
+
+  std::shared_ptr<A> a;
+  a = source();
+
+  return 0;
+}
+
+int
+test02()
+{
+  bool test __attribute__((unused)) = true;
+
+  std::shared_ptr<A> a;
+  std::unique_ptr<A> u;
+  a = std::move(u);
+
+  return 0;
+}
+
+int 
+main()
+{
+  test01();
+  test02();
+  return 0;
+}
diff --git a/libstdc++-v3/testsuite/20_util/shared_ptr/casts/1.cc b/libstdc++-v3/testsuite/20_util/shared_ptr/casts/1.cc
new file mode 100644
index 000000000..a12c54964
--- /dev/null
+++ b/libstdc++-v3/testsuite/20_util/shared_ptr/casts/1.cc
@@ -0,0 +1,45 @@
+// { dg-options "-std=gnu++0x" }
+
+// Copyright (C) 2006, 2007, 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/>.
+
+// 20.6.6.2.10 shared_ptr casts [util.smartptr.shared.cast]
+
+#include <memory>
+#include <testsuite_tr1.h>
+
+// { dg-do compile }
+
+struct MyP { virtual ~MyP() { }; };
+struct MyDP : MyP { };
+
+int main()
+{
+  using __gnu_test::check_ret_type;
+  using std::shared_ptr;
+  using std::static_pointer_cast;
+  using std::const_pointer_cast;
+  using std::dynamic_pointer_cast;
+
+  shared_ptr<double> spd;
+  shared_ptr<const int> spci;
+  shared_ptr<MyP> spa;
+
+  check_ret_type<shared_ptr<void> >(static_pointer_cast<void>(spd));
+  check_ret_type<shared_ptr<int> >(const_pointer_cast<int>(spci));
+  check_ret_type<shared_ptr<MyDP> >(static_pointer_cast<MyDP>(spa));  
+}
diff --git a/libstdc++-v3/testsuite/20_util/shared_ptr/comparison/42925.cc b/libstdc++-v3/testsuite/20_util/shared_ptr/comparison/42925.cc
new file mode 100644
index 000000000..41e09d666
--- /dev/null
+++ b/libstdc++-v3/testsuite/20_util/shared_ptr/comparison/42925.cc
@@ -0,0 +1,37 @@
+// { dg-options "-std=gnu++0x" }
+// { dg-do compile }
+
+// 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/>.
+
+// 20.9.11.2 Class template shared_ptr [util.smartptr.shared]
+
+#include <memory>
+
+// libstdc++/42925 (also see GB 99)
+void test01()
+{
+  std::shared_ptr<int> ptr;
+  if (ptr == 0)
+    { }
+  if (0 == ptr)
+    { }
+  if (ptr != 0)
+    { }
+  if (0 != ptr)
+    { }
+}
diff --git a/libstdc++-v3/testsuite/20_util/shared_ptr/comparison/cmp.cc b/libstdc++-v3/testsuite/20_util/shared_ptr/comparison/cmp.cc
new file mode 100644
index 000000000..ba8280716
--- /dev/null
+++ b/libstdc++-v3/testsuite/20_util/shared_ptr/comparison/cmp.cc
@@ -0,0 +1,88 @@
+// { dg-options "-std=gnu++0x" }
+
+// Copyright (C) 2005, 2006, 2007, 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/>.
+
+// 20.6.6.2 Template class shared_ptr [util.smartptr.shared]
+
+#include <memory>
+#include <testsuite_hooks.h>
+
+struct A
+{
+  virtual ~A() { }
+};
+
+struct B : A
+{
+};
+
+// 20.6.6.2.6 shared_ptr comparison [util.smartptr.shared.cmp]
+
+int
+test01()
+{
+  bool test __attribute__((unused)) = true;
+
+  // test empty shared_ptrs compare equivalent
+  std::shared_ptr<A> p1;
+  std::shared_ptr<B> p2;
+  VERIFY( p1 == p2 );
+  VERIFY( !(p1 != p2) );
+  VERIFY( !(p1 < p2) && !(p2 < p1) );
+  return 0;
+}
+
+
+// Construction from pointer
+int
+test02()
+{
+  bool test __attribute__((unused)) = true;
+
+  std::shared_ptr<A> A_default;
+
+  std::shared_ptr<A> A_from_A(new A);
+  VERIFY( A_default != A_from_A );
+  VERIFY( !(A_default == A_from_A) );
+  VERIFY( (A_default < A_from_A) || (A_from_A < A_default) );
+
+  std::shared_ptr<B> B_from_B(new B);
+  VERIFY( B_from_B != A_from_A );
+  VERIFY( !(B_from_B == A_from_A) );
+  VERIFY( (B_from_B < A_from_A) || (A_from_A < B_from_B) );
+
+  A_from_A.reset();
+  VERIFY( A_default == A_from_A );
+  VERIFY( !(A_default != A_from_A) );
+  VERIFY( !(A_default < A_from_A) && !(A_from_A < A_default) );
+
+  B_from_B.reset();
+  VERIFY( B_from_B == A_from_A );
+  VERIFY( !(B_from_B != A_from_A) );
+  VERIFY( !(B_from_B < A_from_A) && !(A_from_A < B_from_B) );
+
+  return 0;
+}
+
+int 
+main()
+{
+  test01();
+  test02();
+  return 0;
+}
diff --git a/libstdc++-v3/testsuite/20_util/shared_ptr/comparison/less.cc b/libstdc++-v3/testsuite/20_util/shared_ptr/comparison/less.cc
new file mode 100644
index 000000000..b51b222a0
--- /dev/null
+++ b/libstdc++-v3/testsuite/20_util/shared_ptr/comparison/less.cc
@@ -0,0 +1,102 @@
+// { dg-options "-std=gnu++0x" }
+
+// 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/>.
+
+// 20.8.13.2 Template class shared_ptr [util.smartptr.shared]
+
+#include <memory>
+#include <testsuite_hooks.h>
+
+struct A { };
+
+namespace std
+{
+  template<>
+    struct less<A*> : binary_function<A*,A*,bool>
+    {
+      static int count;
+      bool operator()(A* l, A* r) { ++count; return l < r; }
+    };
+  int less<A*>::count = 0;
+}
+
+// 20.8.13.2.7 shared_ptr comparison [util.smartptr.shared.cmp]
+
+
+int
+test01()
+{
+  bool test __attribute__((unused)) = true;
+
+  std::less<std::shared_ptr<A>> less;
+  // test empty shared_ptrs compare equivalent
+  std::shared_ptr<A> p1;
+  std::shared_ptr<A> p2;
+  VERIFY( !less(p1, p2) && !less(p2, p1) );
+  VERIFY( std::less<A*>::count == 2 );
+  return 0;
+}
+
+
+// Construction from pointer
+int
+test02()
+{
+  bool test __attribute__((unused)) = true;
+
+  std::less<std::shared_ptr<A>> less;
+
+  std::shared_ptr<A> empty;
+  std::shared_ptr<A> p1(new A);
+  std::shared_ptr<A> p2(new A);
+
+  VERIFY( less(p1, p2) || less(p2, p1) );
+  VERIFY( !(less(p1, p2) && less(p2, p1)) );
+
+  p1.reset();
+  VERIFY( !less(p1, empty) && !less(empty, p1) );
+
+  p2.reset();
+  VERIFY( !less(p1, p2) && !less(p2, p1) );
+
+  return 0;
+}
+
+// Aliasing
+int
+test03()
+{
+  bool test __attribute__((unused)) = true;
+
+  std::less<std::shared_ptr<A>> less;
+
+  A a;
+  std::shared_ptr<A> p1(new A);
+  std::shared_ptr<A> p2(p1, &a);
+  VERIFY( less(p1, p2) || less(p2, p1) );
+
+  return 0;
+}
+int 
+main()
+{
+  test01();
+  test02();
+  test03();
+  return 0;
+}
diff --git a/libstdc++-v3/testsuite/20_util/shared_ptr/cons/39405.cc b/libstdc++-v3/testsuite/20_util/shared_ptr/cons/39405.cc
new file mode 100644
index 000000000..d5b3f7dea
--- /dev/null
+++ b/libstdc++-v3/testsuite/20_util/shared_ptr/cons/39405.cc
@@ -0,0 +1,30 @@
+// { dg-options "-std=gnu++0x" }
+// { dg-do compile }
+
+// Copyright (C) 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/>.
+
+#include <memory>
+
+// libstdc++/39405
+template<typename T>
+  struct foo
+  {
+    std::shared_ptr<foo<T> > m_foo;
+  };
+
+std::shared_ptr<foo<int> > t;
diff --git a/libstdc++-v3/testsuite/20_util/shared_ptr/cons/43820_neg.cc b/libstdc++-v3/testsuite/20_util/shared_ptr/cons/43820_neg.cc
new file mode 100644
index 000000000..f5899d399
--- /dev/null
+++ b/libstdc++-v3/testsuite/20_util/shared_ptr/cons/43820_neg.cc
@@ -0,0 +1,40 @@
+// { dg-options "-std=gnu++0x" }
+// { dg-do compile }
+
+// 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/>.
+
+// 20.9.11.2 Template class shared_ptr [util.smartptr.shared]
+
+#include <memory>
+
+// incomplete type
+struct X;
+
+// get an auto_ptr rvalue
+std::auto_ptr<X>&& ap();
+
+void test01()
+{
+  X* px = 0;
+  std::shared_ptr<X> p1(px);   // { dg-error "here" }
+  // { dg-error "incomplete" "" { target *-*-* } 766 }
+
+  std::shared_ptr<X> p9(ap());  // { dg-error "here" }
+  // { dg-error "incomplete" "" { target *-*-* } 859 }
+
+}
diff --git a/libstdc++-v3/testsuite/20_util/shared_ptr/cons/46910.cc b/libstdc++-v3/testsuite/20_util/shared_ptr/cons/46910.cc
new file mode 100644
index 000000000..d8275198c
--- /dev/null
+++ b/libstdc++-v3/testsuite/20_util/shared_ptr/cons/46910.cc
@@ -0,0 +1,46 @@
+// { dg-options "-std=gnu++0x" }
+// { dg-do compile }
+
+// 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/>.
+
+// 20.9.10.2 Class template shared_ptr [util.smartptr.shared]
+
+#include <memory>
+#include <testsuite_hooks.h>
+
+// 20.9.10.2.1 shared_ptr constructors [util.smartptr.shared.const]
+
+struct deleter;
+
+class A
+{
+  ~A() = default;
+  friend struct deleter;
+};
+
+struct deleter
+{
+  void operator()(A* a) const;
+};
+
+void
+test01()
+{
+  std::shared_ptr<A> p(new A, deleter());
+}
+
diff --git a/libstdc++-v3/testsuite/20_util/shared_ptr/cons/alias.cc b/libstdc++-v3/testsuite/20_util/shared_ptr/cons/alias.cc
new file mode 100644
index 000000000..9c39ed50d
--- /dev/null
+++ b/libstdc++-v3/testsuite/20_util/shared_ptr/cons/alias.cc
@@ -0,0 +1,107 @@
+// { dg-options "-std=gnu++0x" }
+
+// Copyright (C) 2007, 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/>.
+
+// 20.6.6.2 Template class shared_ptr [util.smartptr.shared]
+
+#include <memory>
+#include <testsuite_hooks.h>
+
+struct A
+{
+  A() : i() { }
+  virtual ~A() { }
+  int i;
+};
+
+struct B : A
+{
+  B() : A(), a() { }
+  virtual ~B() { }
+  A a;
+};
+
+void deletefunc(A* p) { delete p; }
+
+// 20.6.6.2.1 shared_ptr constructors [util.smartptr.shared.const]
+
+// Aliasing constructors
+
+int test01()
+{
+  bool test __attribute__((unused)) = true;
+
+  std::shared_ptr<A> a;
+  std::shared_ptr<bool> b1(a, &test);
+  VERIFY( b1.use_count() == 0 );
+  VERIFY( a.get() == 0 );
+  VERIFY( b1.get() == &test );
+
+  std::shared_ptr<bool> b2(b1);
+  VERIFY( b2.use_count() == 0 );
+  VERIFY( b1.get() == b2.get() );
+
+  return 0;
+}
+
+int
+test02()
+{
+  bool test __attribute__((unused)) = true;
+
+  std::shared_ptr<A> a(new A);
+  std::shared_ptr<int> i1(a, &a->i);
+  VERIFY( i1.use_count() == 2 );
+
+  std::shared_ptr<int> i2(i1);
+  VERIFY( i2.use_count() == 3 );
+  VERIFY( i2.get() == &a->i );
+
+  return 0;
+}
+
+int
+test03()
+{
+  bool test __attribute__((unused)) = true;
+
+  std::shared_ptr<B> b(new B);
+  std::shared_ptr<A> a1(b, b.get());
+  std::shared_ptr<A> a2(b, &b->a);
+  VERIFY( a2.use_count() == 3 );
+  VERIFY( a1 == b );
+  VERIFY( a2 != b );
+  VERIFY( a1.get() != a2.get() );
+
+  std::shared_ptr<A> a3(a1);
+  VERIFY( a3 == b );
+
+  a3 = a2;
+  VERIFY( a3.get() == &b->a );
+
+  return 0;
+}
+
+int
+main()
+{
+  test01();
+  test02();
+  test03();
+  return 0;
+}
diff --git a/libstdc++-v3/testsuite/20_util/shared_ptr/cons/alloc.cc b/libstdc++-v3/testsuite/20_util/shared_ptr/cons/alloc.cc
new file mode 100644
index 000000000..4a4be9a68
--- /dev/null
+++ b/libstdc++-v3/testsuite/20_util/shared_ptr/cons/alloc.cc
@@ -0,0 +1,103 @@
+// { dg-options "-std=gnu++0x" }
+
+// Copyright (C) 2007, 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/>.
+
+// 20.6.6.2 Template class shared_ptr [util.smartptr.shared]
+
+#include <memory>
+#include <testsuite_hooks.h>
+#include <testsuite_allocator.h>
+
+using __gnu_test::tracker_allocator_counter;
+using __gnu_test::tracker_allocator;
+
+struct A { };
+void deletefunc(A* p) { delete p; }
+struct D
+{
+  void operator()(A* p) { delete p; ++delete_count; }
+  static long delete_count;
+};
+long D::delete_count = 0;
+
+// 20.6.6.2.1 shared_ptr constructors [util.smartptr.shared.const]
+
+// Construction with allocator
+int
+test01()
+{
+  bool test __attribute__((unused)) = true;
+  tracker_allocator_counter::reset();
+
+  std::shared_ptr<A> p1(new A, deletefunc, tracker_allocator<A>());
+  std::size_t const sz = tracker_allocator_counter::get_allocation_count();
+  VERIFY( sz > 0 );
+  {
+    std::shared_ptr<A> p2(p1);
+    VERIFY( p2.use_count() == 2 );
+    VERIFY( tracker_allocator_counter::get_allocation_count() == sz );
+    VERIFY( tracker_allocator_counter::get_deallocation_count() == 0 );
+  }
+  VERIFY( p1.use_count() == 1 );
+  VERIFY( tracker_allocator_counter::get_allocation_count() == sz );
+  VERIFY( tracker_allocator_counter::get_deallocation_count() == 0 );
+  p1.reset();
+  VERIFY( p1.use_count() == 0 );
+  VERIFY( tracker_allocator_counter::get_allocation_count() == sz );
+  VERIFY( tracker_allocator_counter::get_deallocation_count() == sz );
+
+  return 0;
+}
+
+// Construction with allocator
+int
+test02()
+{
+  bool test __attribute__((unused)) = true;
+  tracker_allocator_counter::reset();
+
+  std::shared_ptr<A> p1(new A, deletefunc, tracker_allocator<A>());
+  std::size_t const sz1 = tracker_allocator_counter::get_allocation_count();
+  VERIFY( sz1 > 0 );
+  std::shared_ptr<A> p2(new A, D(), tracker_allocator<A>());
+  std::size_t const sz2 = tracker_allocator_counter::get_allocation_count();
+  VERIFY( sz2 > sz1 );
+  VERIFY( tracker_allocator_counter::get_deallocation_count() == 0 );
+  p1 = p2;
+  VERIFY( p2.use_count() == 2 );
+  VERIFY( tracker_allocator_counter::get_allocation_count() == sz2 );
+  VERIFY( tracker_allocator_counter::get_deallocation_count() == sz1 );
+  p1.reset();
+  VERIFY( p2.use_count() == 1 );
+  VERIFY( tracker_allocator_counter::get_allocation_count() == sz2 );
+  VERIFY( tracker_allocator_counter::get_deallocation_count() == sz1 );
+  p2.reset();
+  VERIFY( tracker_allocator_counter::get_allocation_count() == sz2 );
+  VERIFY( tracker_allocator_counter::get_deallocation_count() == sz2 );
+  VERIFY( D::delete_count == 1 );
+
+  return 0;
+}
+
+int
+main()
+{
+  test01();
+  test02();
+  return 0;
+}
diff --git a/libstdc++-v3/testsuite/20_util/shared_ptr/cons/auto_ptr.cc b/libstdc++-v3/testsuite/20_util/shared_ptr/cons/auto_ptr.cc
new file mode 100644
index 000000000..eb5bb9590
--- /dev/null
+++ b/libstdc++-v3/testsuite/20_util/shared_ptr/cons/auto_ptr.cc
@@ -0,0 +1,49 @@
+// { dg-options "-std=gnu++0x" }
+
+// Copyright (C) 2005, 2006, 2007, 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/>.
+
+// 20.6.6.2 Template class shared_ptr [util.smartptr.shared]
+
+#include <memory>
+#include <testsuite_hooks.h>
+
+struct A { };
+
+// 20.6.6.2.1 shared_ptr constructors [util.smartptr.shared.const]
+
+// Construction from auto_ptr
+int
+test01()
+{
+  bool test __attribute__((unused)) = true;
+
+  std::auto_ptr<A> a(new A);
+  std::shared_ptr<A> a2(std::move(a));
+  VERIFY( a.get() == 0 );
+  VERIFY( a2.get() != 0 );
+  VERIFY( a2.use_count() == 1 );
+
+  return 0;
+}
+
+int
+main()
+{
+  test01();
+  return 0;
+}
diff --git a/libstdc++-v3/testsuite/20_util/shared_ptr/cons/auto_ptr_neg.cc b/libstdc++-v3/testsuite/20_util/shared_ptr/cons/auto_ptr_neg.cc
new file mode 100644
index 000000000..b078a7df7
--- /dev/null
+++ b/libstdc++-v3/testsuite/20_util/shared_ptr/cons/auto_ptr_neg.cc
@@ -0,0 +1,36 @@
+// { dg-options "-std=gnu++0x" }
+// { dg-do compile }
+
+// Copyright (C) 2005, 2006, 2007, 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/>.
+
+// 20.6.6.2 Template class shared_ptr [util.smartptr.shared]
+
+#include <memory>
+
+struct A { };
+
+// 20.6.6.2.3 shared_ptr assignment [util.smartptr.shared.const]
+
+// Construction from const auto_ptr
+void
+test01()
+{
+  const std::auto_ptr<A> a;
+  std::shared_ptr<A> p(std::move(a)); // { dg-error "no match" }
+}
+// { dg-excess-errors "candidates are" }
diff --git a/libstdc++-v3/testsuite/20_util/shared_ptr/cons/constexpr.cc b/libstdc++-v3/testsuite/20_util/shared_ptr/cons/constexpr.cc
new file mode 100644
index 000000000..5a1fc818f
--- /dev/null
+++ b/libstdc++-v3/testsuite/20_util/shared_ptr/cons/constexpr.cc
@@ -0,0 +1,35 @@
+// { dg-do compile }
+// { dg-options "-std=gnu++0x -fno-inline -save-temps -g0" }
+// { dg-final { scan-assembler-not "_ZNSt10shared_ptrIiEC2Ev" } }
+// { dg-final { scan-assembler-not "_ZNSt10shared_ptrIiEC2EDn" } }
+
+// 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 <memory>
+#include <testsuite_common_types.h>
+
+int main()
+{
+  __gnu_test::constexpr_default_constructible test1;  //not literal
+  test1.operator()<std::shared_ptr<int>>();
+
+  __gnu_test::constexpr_single_value_constructible test2;  //not literal
+  test2.operator()<std::shared_ptr<int>, std::nullptr_t>();
+
+  return 0;
+}
diff --git a/libstdc++-v3/testsuite/20_util/shared_ptr/cons/copy.cc b/libstdc++-v3/testsuite/20_util/shared_ptr/cons/copy.cc
new file mode 100644
index 000000000..c5dcffea0
--- /dev/null
+++ b/libstdc++-v3/testsuite/20_util/shared_ptr/cons/copy.cc
@@ -0,0 +1,136 @@
+// { dg-options "-std=gnu++0x" }
+
+// Copyright (C) 2005, 2006, 2007, 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/>.
+
+// 20.6.6.2 Template class shared_ptr [util.smartptr.shared]
+
+#include <memory>
+#include <testsuite_hooks.h>
+
+struct A
+{
+  A() { ++ctor_count; }
+  virtual ~A() { ++dtor_count; }
+  static long ctor_count;
+  static long dtor_count;
+};
+long A::ctor_count = 0;
+long A::dtor_count = 0;
+
+struct B : A
+{
+  B() { ++ctor_count; }
+  virtual ~B() { ++dtor_count; }
+  static long ctor_count;
+  static long dtor_count;
+};
+long B::ctor_count = 0;
+long B::dtor_count = 0;
+
+void deleter(A* p) { delete p; }
+
+struct reset_count_struct
+{
+  ~reset_count_struct()
+  {
+    A::ctor_count = 0;
+    A::dtor_count = 0;
+    B::ctor_count = 0;
+    B::dtor_count = 0;
+  }
+};
+
+// 20.6.6.2.1 shared_ptr constructors [util.smartptr.shared.const]
+
+// Copy construction
+int test01()
+{
+  reset_count_struct __attribute__((unused)) reset;
+  bool test __attribute__((unused)) = true;
+
+  std::shared_ptr<A> a1;
+  std::shared_ptr<A> a2(a1);
+  VERIFY( a2.use_count() == 0 );
+  VERIFY( A::ctor_count == 0 );
+  VERIFY( A::dtor_count == 0 );
+  VERIFY( B::ctor_count == 0 );
+  VERIFY( B::dtor_count == 0 );
+
+  return 0;
+}
+
+int
+test02()
+{
+  reset_count_struct __attribute__((unused)) reset;
+  bool test __attribute__((unused)) = true;
+
+  std::shared_ptr<A> a1(new A);
+  std::shared_ptr<A> a2(a1);
+  VERIFY( a2.use_count() == 2 );
+  VERIFY( A::ctor_count == 1 );
+  VERIFY( A::dtor_count == 0 );
+  VERIFY( B::ctor_count == 0 );
+  VERIFY( B::dtor_count == 0 );
+
+  return 0;
+}
+
+int
+test03()
+{
+  reset_count_struct __attribute__((unused)) reset;
+  bool test __attribute__((unused)) = true;
+
+  std::shared_ptr<B> b(new B);
+  std::shared_ptr<A> a(b);
+  VERIFY( a.use_count() == 2 );
+  VERIFY( A::ctor_count == 1 );
+  VERIFY( A::dtor_count == 0 );
+  VERIFY( B::ctor_count == 1 );
+  VERIFY( B::dtor_count == 0 );
+
+  return 0;
+}
+
+int
+test04()
+{
+  reset_count_struct __attribute__((unused)) reset;
+  bool test __attribute__((unused)) = true;
+
+  std::shared_ptr<B> b(new B, &deleter);
+  std::shared_ptr<A> a(b);
+  VERIFY( a.use_count() == 2 );
+  VERIFY( A::ctor_count == 1 );
+  VERIFY( A::dtor_count == 0 );
+  VERIFY( B::ctor_count == 1 );
+  VERIFY( B::dtor_count == 0 );
+
+  return 0;
+}
+
+int
+main()
+{
+  test01();
+  test02();
+  test03();
+  test04();
+  return 0;
+}
diff --git a/libstdc++-v3/testsuite/20_util/shared_ptr/cons/default.cc b/libstdc++-v3/testsuite/20_util/shared_ptr/cons/default.cc
new file mode 100644
index 000000000..ec4c1fdab
--- /dev/null
+++ b/libstdc++-v3/testsuite/20_util/shared_ptr/cons/default.cc
@@ -0,0 +1,46 @@
+// { dg-options "-std=gnu++0x" }
+
+// Copyright (C) 2005, 2006, 2007, 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/>.
+
+// 20.6.6.2 Template class shared_ptr [util.smartptr.shared]
+
+#include <memory>
+#include <testsuite_hooks.h>
+
+struct A { };
+
+// 20.6.6.2.1 shared_ptr constructors [util.smartptr.shared.const]
+
+// Default construction
+int
+test01()
+{
+  bool test __attribute__((unused)) = true;
+
+  std::shared_ptr<A> a;
+  VERIFY( a.get() == 0 );
+
+  return 0;
+}
+
+int
+main()
+{
+  test01();
+  return 0;
+}
diff --git a/libstdc++-v3/testsuite/20_util/shared_ptr/cons/move.cc b/libstdc++-v3/testsuite/20_util/shared_ptr/cons/move.cc
new file mode 100644
index 000000000..795155829
--- /dev/null
+++ b/libstdc++-v3/testsuite/20_util/shared_ptr/cons/move.cc
@@ -0,0 +1,164 @@
+// { dg-options "-std=gnu++0x" }
+
+// Copyright (C) 2007, 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/>.
+
+// TR1 20.6.6.2 Template class shared_ptr [util.smartptr.shared]
+
+#include <memory>
+#include <utility>
+#include <testsuite_hooks.h>
+
+struct A
+{
+  A() { ++ctor_count; }
+  virtual ~A() { ++dtor_count; }
+  static long ctor_count;
+  static long dtor_count;
+};
+long A::ctor_count = 0;
+long A::dtor_count = 0;
+
+struct B : A
+{
+  B() { ++ctor_count; }
+  virtual ~B() { ++dtor_count; }
+  static long ctor_count;
+  static long dtor_count;
+};
+long B::ctor_count = 0;
+long B::dtor_count = 0;
+
+struct D
+{
+  void operator()(B* p) const { delete p; ++delete_count; }
+  static long delete_count;
+};
+long D::delete_count = 0;
+
+struct reset_count_struct
+{
+  ~reset_count_struct()
+  {
+    A::ctor_count = 0;
+    A::dtor_count = 0;
+    B::ctor_count = 0;
+    B::dtor_count = 0;
+    D::delete_count = 0;
+  }
+};
+
+// 20.6.6.2.1 shared_ptr constructors [util.smartptr.shared.const]
+
+// Rvalue construction
+int test01()
+{
+  reset_count_struct __attribute__((unused)) reset;
+  bool test __attribute__((unused)) = true;
+
+  std::shared_ptr<A> a1;
+  std::shared_ptr<A> a2(std::move(a1));
+  VERIFY( a1.use_count() == 0 );
+  VERIFY( a2.use_count() == 0 );
+  VERIFY( A::ctor_count == 0 );
+  VERIFY( A::dtor_count == 0 );
+  VERIFY( B::ctor_count == 0 );
+  VERIFY( B::dtor_count == 0 );
+
+  return 0;
+}
+
+int
+test02()
+{
+  reset_count_struct __attribute__((unused)) reset;
+  bool test __attribute__((unused)) = true;
+
+  std::shared_ptr<A> a1(new A);
+  std::shared_ptr<A> a2(std::move(a1));
+  VERIFY( a1.use_count() == 0 );
+  VERIFY( a2.use_count() == 1 );
+  VERIFY( A::ctor_count == 1 );
+  VERIFY( A::dtor_count == 0 );
+
+  return 0;
+}
+
+int
+test03()
+{
+  reset_count_struct __attribute__((unused)) reset;
+  bool test __attribute__((unused)) = true;
+
+  std::shared_ptr<B> b(new B);
+  std::shared_ptr<A> a(std::move(b));
+  VERIFY( b.use_count() == 0 );
+  VERIFY( a.use_count() == 1 );
+  VERIFY( A::ctor_count == 1 );
+  VERIFY( A::dtor_count == 0 );
+  VERIFY( B::ctor_count == 1 );
+  VERIFY( B::dtor_count == 0 );
+
+  return 0;
+}
+
+int
+test04()
+{
+  reset_count_struct __attribute__((unused)) reset;
+  bool test __attribute__((unused)) = true;
+
+  std::shared_ptr<B> b(new B, D());
+  std::shared_ptr<A> a(std::move(b));
+  VERIFY( b.use_count() == 0 );
+  VERIFY( a.use_count() == 1 );
+  VERIFY( A::ctor_count == 1 );
+  VERIFY( A::dtor_count == 0 );
+  VERIFY( B::ctor_count == 1 );
+  VERIFY( B::dtor_count == 0 );
+
+  a = std::move(std::shared_ptr<A>());
+  VERIFY( D::delete_count == 1 );
+  VERIFY( B::dtor_count == 1 );
+
+  return 0;
+}
+
+int
+test05()
+{
+  reset_count_struct __attribute__((unused)) reset;
+  bool test __attribute__((unused)) = true;
+
+  std::shared_ptr<A> a(std::move(std::shared_ptr<A>(new A)));
+  VERIFY( a.use_count() == 1 );
+  VERIFY( A::ctor_count == 1 );
+  VERIFY( A::dtor_count == 0 );
+
+  return 0;
+}
+
+int
+main()
+{
+  test01();
+  test02();
+  test03();
+  test04();
+  test05();
+  return 0;
+}
diff --git a/libstdc++-v3/testsuite/20_util/shared_ptr/cons/nullptr.cc b/libstdc++-v3/testsuite/20_util/shared_ptr/cons/nullptr.cc
new file mode 100644
index 000000000..82acaed36
--- /dev/null
+++ b/libstdc++-v3/testsuite/20_util/shared_ptr/cons/nullptr.cc
@@ -0,0 +1,93 @@
+// { dg-options "-std=gnu++0x" }
+
+// 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/>.
+
+// 20.9.11.2 Class template shared_ptr [util.smartptr.shared]
+
+#include <memory>
+#include <cstddef>
+#include <testsuite_hooks.h>
+#include <testsuite_allocator.h>
+
+// 20.9.11.2.1 shared_ptr constructors [util.smartptr.shared.const]
+
+// Construction from nullptr
+
+struct deleter
+{
+  int count;
+  deleter() : count(0) { }
+  void operator()(std::nullptr_t) { ++count; }
+  void operator()(int*) const { throw "wrong type passed to deleter"; }
+};
+
+void
+test01()
+{
+  bool test __attribute__((unused)) = true;
+
+  std::shared_ptr<int> p = nullptr;
+  VERIFY( p.get() == nullptr );
+  VERIFY( p.use_count() == 0 );
+
+}
+
+void
+test02()
+{
+  bool test __attribute__((unused)) = true;
+
+  deleter d;
+  std::shared_ptr<int> p(nullptr, std::ref(d));
+  VERIFY( p.get() == nullptr );
+  VERIFY( p.use_count() == 1 );
+
+  p = nullptr;
+  VERIFY( p.use_count() == 0 );
+  VERIFY( d.count == 1 );
+}
+
+
+void
+test03()
+{
+  bool test __attribute__((unused)) = true;
+
+  deleter d;
+  __gnu_test::tracker_allocator<int> a;
+  std::shared_ptr<int> p(nullptr, std::ref(d), a);
+  VERIFY( p.get() == nullptr );
+  VERIFY( p.use_count() == 1 );
+
+  p = nullptr;
+  VERIFY( p.use_count() == 0 );
+  VERIFY( d.count == 1 );
+
+  typedef __gnu_test::tracker_allocator_counter c;
+  VERIFY( c::get_destruct_count() == c::get_construct_count() );
+  VERIFY( c::get_deallocation_count() == c::get_allocation_count() );
+}
+
+int
+main()
+{
+  test01();
+  test02();
+  test03();
+  return 0;
+}
diff --git a/libstdc++-v3/testsuite/20_util/shared_ptr/cons/pointer.cc b/libstdc++-v3/testsuite/20_util/shared_ptr/cons/pointer.cc
new file mode 100644
index 000000000..701f12439
--- /dev/null
+++ b/libstdc++-v3/testsuite/20_util/shared_ptr/cons/pointer.cc
@@ -0,0 +1,80 @@
+// { dg-options "-std=gnu++0x" }
+
+// Copyright (C) 2005, 2006, 2007, 2009, 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/>.
+
+// 20.6.6.2 Template class shared_ptr [util.smartptr.shared]
+
+#include <memory>
+#include <testsuite_hooks.h>
+
+struct A { };
+struct B : A { };
+
+
+// 20.6.6.2.1 shared_ptr constructors [util.smartptr.shared.const]
+
+// Construction from pointer
+
+int
+test01()
+{
+  bool test __attribute__((unused)) = true;
+
+  A * const a = 0;
+  std::shared_ptr<A> p(a);
+  VERIFY( p.get() == 0 );
+  VERIFY( p.use_count() == 1 );
+
+  return 0;
+}
+
+int
+test02()
+{
+  bool test __attribute__((unused)) = true;
+
+  A * const a = new A;
+  std::shared_ptr<A> p(a);
+  VERIFY( p.get() == a );
+  VERIFY( p.use_count() == 1 );
+
+  return 0;
+}
+
+
+int
+test03()
+{
+  bool test __attribute__((unused)) = true;
+
+  B * const b = new B;
+  std::shared_ptr<A> p(b);
+  VERIFY( p.get() == b );
+  VERIFY( p.use_count() == 1 );
+
+  return 0;
+}
+
+int
+main()
+{
+  test01();
+  test02();
+  test03();
+  return 0;
+}
diff --git a/libstdc++-v3/testsuite/20_util/shared_ptr/cons/unique_ptr.cc b/libstdc++-v3/testsuite/20_util/shared_ptr/cons/unique_ptr.cc
new file mode 100644
index 000000000..cfca90d90
--- /dev/null
+++ b/libstdc++-v3/testsuite/20_util/shared_ptr/cons/unique_ptr.cc
@@ -0,0 +1,49 @@
+// { dg-options "-std=gnu++0x" }
+
+// 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/>.
+
+// 20.7.12.2 Template class shared_ptr [util.smartptr.shared]
+
+#include <memory>
+#include <testsuite_hooks.h>
+
+struct A { };
+
+// 20.7.12.2.1 shared_ptr constructors [util.smartptr.shared.const]
+
+// Construction from unique_ptr
+int
+test01()
+{
+  bool test __attribute__((unused)) = true;
+
+  std::unique_ptr<A> up(new A);
+  std::shared_ptr<A> sp(std::move(up));
+  VERIFY( up.get() == 0 );
+  VERIFY( sp.get() != 0 );
+  VERIFY( sp.use_count() == 1 );
+
+  return 0;
+}
+
+int
+main()
+{
+  test01();
+  return 0;
+}
diff --git a/libstdc++-v3/testsuite/20_util/shared_ptr/cons/unique_ptr_deleter.cc b/libstdc++-v3/testsuite/20_util/shared_ptr/cons/unique_ptr_deleter.cc
new file mode 100644
index 000000000..67485aee7
--- /dev/null
+++ b/libstdc++-v3/testsuite/20_util/shared_ptr/cons/unique_ptr_deleter.cc
@@ -0,0 +1,59 @@
+// { dg-options "-std=gnu++0x" }
+
+// 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/>.
+
+// 20.7.12.2 Template class shared_ptr [util.smartptr.shared]
+
+#include <memory>
+#include <testsuite_hooks.h>
+
+struct A { };
+
+struct D {
+    void operator()(A* p) const { delete p;  ++count; }
+    static int count;
+};
+
+int D::count = 0;
+
+// 20.7.12.2.1 shared_ptr constructors [util.smartptr.shared.const]
+
+// Construction from unique_ptr
+int
+test01()
+{
+  bool test __attribute__((unused)) = true;
+
+  std::unique_ptr<A, D> up(new A, D());
+  {
+      std::shared_ptr<A> sp(std::move(up));
+      VERIFY( up.get() == 0 );
+      VERIFY( sp.get() != 0 );
+      VERIFY( sp.use_count() == 1 );
+  }
+  VERIFY( D::count == 1 );
+
+  return 0;
+}
+
+int
+main()
+{
+  test01();
+  return 0;
+}
diff --git a/libstdc++-v3/testsuite/20_util/shared_ptr/cons/unique_ptr_deleter_ref_1.cc b/libstdc++-v3/testsuite/20_util/shared_ptr/cons/unique_ptr_deleter_ref_1.cc
new file mode 100644
index 000000000..d0998c94c
--- /dev/null
+++ b/libstdc++-v3/testsuite/20_util/shared_ptr/cons/unique_ptr_deleter_ref_1.cc
@@ -0,0 +1,60 @@
+// { dg-options "-std=gnu++0x" }
+
+// 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/>.
+
+// 20.7.12.2 Template class shared_ptr [util.smartptr.shared]
+
+#include <memory>
+#include <testsuite_hooks.h>
+
+struct A { };
+
+struct D {
+    typedef void result_type;
+    void operator()(A* p) { delete p;  ++count; }
+    int count;
+};
+
+
+// 20.7.12.2.1 shared_ptr constructors [util.smartptr.shared.const]
+
+// Construction from unique_ptr
+int
+test01()
+{
+  bool test __attribute__((unused)) = true;
+
+  D d = D();
+  std::unique_ptr<A, D&> up(new A, d);
+  {
+      std::shared_ptr<A> sp(std::move(up));
+      VERIFY( up.get() == 0 );
+      VERIFY( sp.get() != 0 );
+      VERIFY( sp.use_count() == 1 );
+  }
+  VERIFY( d.count == 1 );
+
+  return 0;
+}
+
+int
+main()
+{
+  test01();
+  return 0;
+}
diff --git a/libstdc++-v3/testsuite/20_util/shared_ptr/cons/unique_ptr_deleter_ref_2.cc b/libstdc++-v3/testsuite/20_util/shared_ptr/cons/unique_ptr_deleter_ref_2.cc
new file mode 100644
index 000000000..7b09cfa7d
--- /dev/null
+++ b/libstdc++-v3/testsuite/20_util/shared_ptr/cons/unique_ptr_deleter_ref_2.cc
@@ -0,0 +1,63 @@
+// { dg-options "-std=gnu++0x" }
+
+// 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/>.
+
+// 20.7.12.2 Template class shared_ptr [util.smartptr.shared]
+
+#include <memory>
+#include <functional>
+#include <testsuite_hooks.h>
+
+struct A { };
+
+struct D {
+    typedef void result_type;
+    void operator()(A* p) { delete p;  ++count; }
+    int count;
+};
+
+
+// 20.7.12.2.1 shared_ptr constructors [util.smartptr.shared.const]
+
+// Construction from unique_ptr
+// See: http://gcc.gnu.org/ml/libstdc++/2008-09/msg00070.html.
+int
+test01()
+{
+  bool test __attribute__((unused)) = true;
+
+  D d;
+  std::unique_ptr<A, D&> p1(new A, d);
+
+  std::shared_ptr<A> p2(std::move(p1));
+
+  typedef std::reference_wrapper<D> D2;
+  D2* p3 = std::get_deleter<D2>(p2);
+
+  VERIFY( p3 != 0 );
+  VERIFY( &p3->get() == &d );
+
+  return 0;
+}
+
+int
+main()
+{
+  test01();
+  return 0;
+}
diff --git a/libstdc++-v3/testsuite/20_util/shared_ptr/cons/unique_ptr_neg.cc b/libstdc++-v3/testsuite/20_util/shared_ptr/cons/unique_ptr_neg.cc
new file mode 100644
index 000000000..0e2fd68d5
--- /dev/null
+++ b/libstdc++-v3/testsuite/20_util/shared_ptr/cons/unique_ptr_neg.cc
@@ -0,0 +1,48 @@
+// { dg-options "-std=gnu++0x" }
+// { dg-do compile }
+
+// Copyright (C) 2008, 2009, 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/>.
+
+// 20.7.12.2 Template class shared_ptr [util.smartptr.shared]
+
+#include <memory>
+#include <testsuite_hooks.h>
+
+struct A { };
+
+// 20.7.12.2.1 shared_ptr constructors [util.smartptr.shared.const]
+
+// Construction from lvalue unique_ptr
+int
+test01()
+{
+  bool test __attribute__((unused)) = true;
+
+  std::unique_ptr<A> a;
+  std::shared_ptr<A> p(a); // { dg-error "cannot bind" }
+
+  return 0;
+}
+
+int 
+main()
+{
+  test01();
+  return 0;
+}
+// { dg-excess-errors "initializing argument" }
diff --git a/libstdc++-v3/testsuite/20_util/shared_ptr/cons/weak_ptr.cc b/libstdc++-v3/testsuite/20_util/shared_ptr/cons/weak_ptr.cc
new file mode 100644
index 000000000..7e24c1822
--- /dev/null
+++ b/libstdc++-v3/testsuite/20_util/shared_ptr/cons/weak_ptr.cc
@@ -0,0 +1,51 @@
+// { dg-options "-std=gnu++0x" }
+
+// Copyright (C) 2005, 2006, 2007, 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/>.
+
+// 20.6.6.2 Template class shared_ptr [util.smartptr.shared]
+
+#include <memory>
+#include <testsuite_hooks.h>
+
+struct A { };
+
+// 20.6.6.2.1 shared_ptr constructors [util.smartptr.shared.const]
+
+// Construction from weak_ptr
+int
+test01()
+{
+  bool test __attribute__((unused)) = true;
+
+  A * const a = new A;
+  std::shared_ptr<A> a1(a);
+  std::weak_ptr<A> wa(a1);
+  std::shared_ptr<A> a2(wa);
+  VERIFY( a2.get() == a );
+  VERIFY( a2.use_count() == wa.use_count() );
+
+  return 0;
+}
+
+
+int
+main()
+{
+  test01();
+  return 0;
+}
diff --git a/libstdc++-v3/testsuite/20_util/shared_ptr/cons/weak_ptr_expired.cc b/libstdc++-v3/testsuite/20_util/shared_ptr/cons/weak_ptr_expired.cc
new file mode 100644
index 000000000..cff9b3b99
--- /dev/null
+++ b/libstdc++-v3/testsuite/20_util/shared_ptr/cons/weak_ptr_expired.cc
@@ -0,0 +1,62 @@
+// { dg-options "-std=gnu++0x" }
+// { dg-do run { xfail *-*-* } }
+
+// Copyright (C) 2005, 2006, 2007, 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/>.
+
+// 20.6.6.2 Template class shared_ptr [util.smartptr.shared]
+
+#include <memory>
+#include <testsuite_hooks.h>
+
+struct A { };
+
+// 20.6.6.2.1 shared_ptr constructors [util.smartptr.shared.const]
+
+// Construction from expired weak_ptr
+int
+test01()
+{
+  bool test __attribute__((unused)) = true;
+
+  std::shared_ptr<A> a1(new A);
+  std::weak_ptr<A> wa(a1);
+  a1.reset();
+  VERIFY( wa.expired() );
+  try
+  {
+    std::shared_ptr<A> a2(wa);
+  }
+  catch (const std::bad_weak_ptr&)
+  {
+    // Expected.
+      __throw_exception_again;
+  }
+  catch (...)
+  {
+    // Failed.
+  }
+
+  return 0;
+}
+
+int
+main()
+{
+  test01();
+  return 0;
+}
diff --git a/libstdc++-v3/testsuite/20_util/shared_ptr/creation/36949.cc b/libstdc++-v3/testsuite/20_util/shared_ptr/creation/36949.cc
new file mode 100644
index 000000000..31230776e
--- /dev/null
+++ b/libstdc++-v3/testsuite/20_util/shared_ptr/creation/36949.cc
@@ -0,0 +1,34 @@
+// { dg-options "-std=gnu++0x" }
+
+// 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/>.
+
+#include <memory>
+
+struct A : std::enable_shared_from_this<A> { };
+
+// libstdc++/36949
+void test01()
+{
+  std::make_shared<A>()->shared_from_this();
+}
+
+int main()
+{
+  test01();
+  return 0;
+}
diff --git a/libstdc++-v3/testsuite/20_util/shared_ptr/creation/alloc.cc b/libstdc++-v3/testsuite/20_util/shared_ptr/creation/alloc.cc
new file mode 100644
index 000000000..e6bc6f47f
--- /dev/null
+++ b/libstdc++-v3/testsuite/20_util/shared_ptr/creation/alloc.cc
@@ -0,0 +1,110 @@
+// { dg-options "-std=gnu++0x" }
+
+// Copyright (C) 2007, 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/>.
+
+// 20.6.6.2 Template class shared_ptr [util.smartptr.shared]
+
+#include <memory>
+#include <testsuite_hooks.h>
+#include <testsuite_allocator.h>
+
+using __gnu_test::tracker_allocator_counter;
+using __gnu_test::tracker_allocator;
+
+struct A
+{
+  A(int i, double d, char c = '\0') : i(i), d(d), c(c) { ++ctor_count; }
+  explicit A(int i) : i(i), d(), c() { ++ctor_count; }
+  A() : i(), d(), c() { ++ctor_count; }
+  ~A() { ++dtor_count; }
+  int i;
+  double d;
+  char c;
+  static int ctor_count;
+  static int dtor_count;
+};
+int A::ctor_count = 0;
+int A::dtor_count = 0;
+
+struct reset_count_struct
+{
+  ~reset_count_struct()
+  {
+    A::ctor_count = 0;
+    A::dtor_count = 0;
+    tracker_allocator_counter::reset();
+  }
+};
+
+// 20.6.6.2.6 shared_ptr creation [util.smartptr.shared.create]
+
+void
+test01()
+{
+  bool test __attribute__((unused)) = true;
+  reset_count_struct __attribute__((unused)) reset;
+
+  {
+    std::shared_ptr<A> p1 = std::allocate_shared<A>(tracker_allocator<A>());
+    VERIFY( p1.get() != 0 );
+    VERIFY( p1.use_count() == 1 );
+    VERIFY( A::ctor_count == 1 );
+    VERIFY( tracker_allocator_counter::get_allocation_count() > 0 );
+  }
+  VERIFY( A::ctor_count == A::dtor_count );
+  VERIFY( tracker_allocator_counter::get_allocation_count()
+	  == tracker_allocator_counter::get_deallocation_count() );
+}
+
+void
+test02()
+{
+  bool test __attribute__((unused)) = true;
+  reset_count_struct __attribute__((unused)) reset;
+
+  std::shared_ptr<A> p1;
+  
+  p1 = std::allocate_shared<A>(tracker_allocator<A>(), 1);
+  VERIFY( A::ctor_count == 1 );
+  VERIFY( tracker_allocator_counter::get_allocation_count() > 0 );
+
+  p1 = std::allocate_shared<A>(tracker_allocator<A>(), 1, 2.0);
+  VERIFY( A::ctor_count == 2 );
+  VERIFY( A::dtor_count == 1 );
+  VERIFY( tracker_allocator_counter::get_deallocation_count() > 0 );
+
+  p1 = std::allocate_shared<A>(tracker_allocator<A>(), 1, 2.0, '3');
+  VERIFY( A::ctor_count == 3 );
+  VERIFY( A::dtor_count == 2 );
+  VERIFY( p1->i == 1 );
+  VERIFY( p1->d == 2.0 );
+  VERIFY( p1->c == '3' );
+
+  p1 = std::shared_ptr<A>();
+  VERIFY( A::ctor_count == A::dtor_count );
+  VERIFY( tracker_allocator_counter::get_allocation_count()
+	  == tracker_allocator_counter::get_deallocation_count() );
+}
+
+int
+main()
+{
+  test01();
+  test02();
+  return 0;
+}
diff --git a/libstdc++-v3/testsuite/20_util/shared_ptr/creation/dr402.cc b/libstdc++-v3/testsuite/20_util/shared_ptr/creation/dr402.cc
new file mode 100644
index 000000000..462c6f848
--- /dev/null
+++ b/libstdc++-v3/testsuite/20_util/shared_ptr/creation/dr402.cc
@@ -0,0 +1,48 @@
+// { dg-options "-std=gnu++0x" }
+// { dg-do compile }
+
+// Copyright (C) 2007, 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/>.
+
+// 20.6.6.2 Template class shared_ptr [util.smartptr.shared]
+
+#include <memory>
+#include <new>
+#include <testsuite_hooks.h>
+
+struct A
+{
+    void* operator new(size_t n) { return new char[sizeof(A)]; }
+    void operator delete(void* p, size_t) { delete (char*)p; }
+};
+
+// 20.6.6.2.6 shared_ptr creation [util.smartptr.shared.create]
+
+void
+test01()
+{
+  bool test __attribute__((unused)) = true;
+
+  std::shared_ptr<A> p = std::make_shared<A>();
+}
+
+int
+main()
+{
+  test01();
+  return 0;
+}
diff --git a/libstdc++-v3/testsuite/20_util/shared_ptr/creation/dr925.cc b/libstdc++-v3/testsuite/20_util/shared_ptr/creation/dr925.cc
new file mode 100644
index 000000000..db176650e
--- /dev/null
+++ b/libstdc++-v3/testsuite/20_util/shared_ptr/creation/dr925.cc
@@ -0,0 +1,90 @@
+// { dg-options "-std=gnu++0x -Wno-deprecated" }
+
+// 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/>.
+
+// 20.9.11.2 Template class shared_ptr [util.smartptr.shared]
+
+#include <memory>
+#include <testsuite_hooks.h>
+
+struct A
+{
+};
+
+std::unique_ptr<A> 
+create_unique_ptr()
+{
+  return std::unique_ptr<A>(new A());
+}
+
+std::auto_ptr<A> 
+create_auto_ptr()
+{
+  return std::auto_ptr<A>(new A());
+}
+
+void 
+process(std::shared_ptr<A> a)
+{
+  bool test __attribute__((unused)) = true;
+
+  VERIFY( a.get() != 0 );
+  VERIFY( a.use_count() == 1 );
+}
+
+// 20.9.11.2.1 shared_ptr creation [util.smartptr.shared.const]
+
+// Implicit conversion of auto_ptr to shared_ptr is allowed
+
+void
+test01()
+{
+  process(create_auto_ptr());
+}
+
+void
+test02()
+{
+  std::auto_ptr<A> a = create_auto_ptr();
+  process(std::move(a));
+}
+
+// Implicit conversion of unique_ptr to shared_ptr is allowed
+
+void
+test03()
+{
+  process(create_unique_ptr());
+}
+
+void
+test04()
+{
+  std::unique_ptr<A> a = create_unique_ptr();
+  process(std::move(a));
+}
+
+int
+main()
+{
+  test01();
+  test02();
+  test03();
+  test04();
+  return 0;
+}
diff --git a/libstdc++-v3/testsuite/20_util/shared_ptr/creation/make.cc b/libstdc++-v3/testsuite/20_util/shared_ptr/creation/make.cc
new file mode 100644
index 000000000..2441b9302
--- /dev/null
+++ b/libstdc++-v3/testsuite/20_util/shared_ptr/creation/make.cc
@@ -0,0 +1,97 @@
+// { dg-options "-std=gnu++0x" }
+
+// Copyright (C) 2007, 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/>.
+
+// 20.6.6.2 Template class shared_ptr [util.smartptr.shared]
+
+#include <memory>
+#include <testsuite_hooks.h>
+
+struct A
+{
+  A(int i, double d, char c = '\0') : i(i), d(d), c(c) { ++ctor_count; }
+  explicit A(int i) : i(i), d(), c() { ++ctor_count; }
+  A() : i(), d(), c() { ++ctor_count; }
+  ~A() { ++dtor_count; }
+  int i;
+  double d;
+  char c;
+  static int ctor_count;
+  static int dtor_count;
+};
+int A::ctor_count = 0;
+int A::dtor_count = 0;
+
+struct reset_count_struct
+{
+  ~reset_count_struct()
+  {
+    A::ctor_count = 0;
+    A::dtor_count = 0;
+  }
+};
+
+// 20.6.6.2.6 shared_ptr creation [util.smartptr.shared.create]
+
+void
+test01()
+{
+  bool test __attribute__((unused)) = true;
+  reset_count_struct __attribute__((unused)) reset;
+
+  {
+    std::shared_ptr<A> p1 = std::make_shared<A>();
+    VERIFY( p1.get() != 0 );
+    VERIFY( p1.use_count() == 1 );
+    VERIFY( A::ctor_count == 1 );
+  }
+  VERIFY( A::ctor_count == A::dtor_count );
+}
+
+void
+test02()
+{
+  bool test __attribute__((unused)) = true;
+  reset_count_struct __attribute__((unused)) reset;
+
+  std::shared_ptr<A> p1;
+  
+  p1 = std::make_shared<A>(1);
+  VERIFY( A::ctor_count == 1 );
+
+  p1 = std::make_shared<A>(1, 2.0);
+  VERIFY( A::ctor_count == 2 );
+  VERIFY( A::dtor_count == 1 );
+
+  p1 = std::make_shared<A>(1, 2.0, '3');
+  VERIFY( A::ctor_count == 3 );
+  VERIFY( A::dtor_count == 2 );
+  VERIFY( p1->i == 1 );
+  VERIFY( p1->d == 2.0 );
+  VERIFY( p1->c == '3' );
+
+  p1 = std::shared_ptr<A>();
+  VERIFY( A::ctor_count == A::dtor_count );
+}
+
+int
+main()
+{
+  test01();
+  test02();
+}
diff --git a/libstdc++-v3/testsuite/20_util/shared_ptr/dest/dest.cc b/libstdc++-v3/testsuite/20_util/shared_ptr/dest/dest.cc
new file mode 100644
index 000000000..5e1a6135f
--- /dev/null
+++ b/libstdc++-v3/testsuite/20_util/shared_ptr/dest/dest.cc
@@ -0,0 +1,134 @@
+// { dg-options "-std=gnu++0x" }
+
+// Copyright (C) 2005, 2006, 2007, 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/>.
+
+// 20.6.6.2 Template class shared_ptr [util.smartptr.shared]
+
+#include <memory>
+#include <testsuite_hooks.h>
+
+struct A
+{
+  A() { ++ctor_count; }
+  ~A() { ++dtor_count; }
+  static long ctor_count;
+  static long dtor_count;
+};
+long A::ctor_count = 0;
+long A::dtor_count = 0;
+
+struct B : A
+{
+  B() { ++ctor_count; }
+  ~B() { ++dtor_count; }
+  static long ctor_count;
+  static long dtor_count;
+};
+long B::ctor_count = 0;
+long B::dtor_count = 0;
+
+struct D
+{
+  void operator()(const B* p) { delete p; ++delete_count; }
+  static long delete_count;
+};
+long D::delete_count = 0;
+
+struct reset_count_struct
+{
+  ~reset_count_struct()
+  {
+    A::ctor_count = 0;
+    A::dtor_count = 0;
+    B::ctor_count = 0;
+    B::dtor_count = 0;
+    D::delete_count = 0;
+  }
+};
+
+
+// 20.6.6.2.2 shared_ptr destructor [util.smartptr.shared.dest]
+
+// empty shared_ptr
+int
+test01()
+{
+  reset_count_struct __attribute__((unused)) reset;
+  bool test __attribute__((unused)) = true;
+
+  {
+    std::shared_ptr<A> a;
+  }
+  VERIFY( A::ctor_count == 0 );
+  VERIFY( A::dtor_count == 0 );
+  VERIFY( B::ctor_count == 0 );
+  VERIFY( B::dtor_count == 0 );
+  VERIFY( D::delete_count == 0 );
+
+  return 0;
+}
+
+// shared ownership
+int
+test02()
+{
+  reset_count_struct __attribute__((unused)) reset;
+  bool test __attribute__((unused)) = true;
+
+  std::shared_ptr<A> a;
+  {
+    a = std::shared_ptr<A>(new B, D());
+  }
+  VERIFY( A::ctor_count == 1 );
+  VERIFY( A::dtor_count == 0 );
+  VERIFY( B::ctor_count == 1 );
+  VERIFY( B::dtor_count == 0 );
+  VERIFY( D::delete_count == 0 );
+
+  return 0;
+}
+
+// exclusive ownership
+int
+test03()
+{
+  reset_count_struct __attribute__((unused)) reset;
+  bool test __attribute__((unused)) = true;
+
+  {
+    std::shared_ptr<A> a1(new B);
+    std::shared_ptr<A> a2(new B, D());
+  }
+  VERIFY( A::ctor_count == 2 );
+  VERIFY( A::dtor_count == 2 );
+  VERIFY( B::ctor_count == 2 );
+  VERIFY( B::dtor_count == 2 );
+  VERIFY( D::delete_count == 1 );
+
+  return 0;
+}
+
+
+int
+main()
+{
+  test01();
+  test02();
+  test03();
+  return 0;
+}
diff --git a/libstdc++-v3/testsuite/20_util/shared_ptr/hash/1.cc b/libstdc++-v3/testsuite/20_util/shared_ptr/hash/1.cc
new file mode 100644
index 000000000..93f4739d7
--- /dev/null
+++ b/libstdc++-v3/testsuite/20_util/shared_ptr/hash/1.cc
@@ -0,0 +1,48 @@
+// { dg-options "-std=gnu++0x" }
+
+// 2010-06-11  Paolo Carlini  <paolo.carlini@oracle.com>
+
+// 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 <memory>
+#include <testsuite_hooks.h>
+
+void test01()
+{
+  bool test __attribute__((unused)) = true;
+
+  struct T { };
+
+  std::shared_ptr<T>                s0(new T);
+  std::hash<std::shared_ptr<T>>     hs0;
+  std::hash<T*>                     hp0;
+
+  VERIFY( hs0(s0) == hp0(s0.get()) );
+
+  std::__shared_ptr<T>              s1(new T);
+  std::hash<std::__shared_ptr<T>>   hs1;
+  std::hash<T*>                     hp1;
+
+  VERIFY( hs1(s1) == hp1(s1.get()) );
+}
+
+int main()
+{
+  test01();
+  return 0;
+}
diff --git a/libstdc++-v3/testsuite/20_util/shared_ptr/misc/24595.cc b/libstdc++-v3/testsuite/20_util/shared_ptr/misc/24595.cc
new file mode 100644
index 000000000..b44c9bdf8
--- /dev/null
+++ b/libstdc++-v3/testsuite/20_util/shared_ptr/misc/24595.cc
@@ -0,0 +1,40 @@
+// { dg-options "-std=gnu++0x" }
+
+// Copyright (C) 2005, 2006, 2007, 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/>.
+
+// 20.6.6.2 Template class shared_ptr [util.smartptr.shared]
+
+#include <memory>
+#include <testsuite_hooks.h>
+
+using std::get_deleter;
+
+// libstdc++/24595
+void test01()
+{
+  bool test __attribute__((unused)) = true;
+
+  std::shared_ptr<int> sp;
+  VERIFY( !get_deleter<void(*)(int*)>(sp) );
+}
+
+int main()
+{
+  test01();
+  return 0;
+}
diff --git a/libstdc++-v3/testsuite/20_util/shared_ptr/misc/42019.cc b/libstdc++-v3/testsuite/20_util/shared_ptr/misc/42019.cc
new file mode 100644
index 000000000..bea1771d2
--- /dev/null
+++ b/libstdc++-v3/testsuite/20_util/shared_ptr/misc/42019.cc
@@ -0,0 +1,56 @@
+// { dg-options "-std=gnu++0x -fno-rtti" }
+// Copyright (C) 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/>.
+
+// 20.8.15.2 Template class shared_ptr [util.smartptr.shared]
+
+#include <memory>
+#include <testsuite_hooks.h>
+
+// libstdc++/42019
+
+class A {};
+
+struct B {
+  explicit B(int i) : i(i) { }
+  int i;
+};
+
+void test01()
+{
+  bool test __attribute__((unused)) = true;
+
+  std::shared_ptr<A> spA = std::make_shared<A>();
+
+  VERIFY( spA.get() != 0 );
+}
+
+void test02()
+{
+  bool test __attribute__((unused)) = true;
+
+  std::shared_ptr<B> spB = std::make_shared<B>(99);
+
+  VERIFY( spB->i == 99 );
+}
+
+int main()
+{
+  test01();
+  test02();
+  return 0;
+}
diff --git a/libstdc++-v3/testsuite/20_util/shared_ptr/misc/io.cc b/libstdc++-v3/testsuite/20_util/shared_ptr/misc/io.cc
new file mode 100644
index 000000000..a84f4bebf
--- /dev/null
+++ b/libstdc++-v3/testsuite/20_util/shared_ptr/misc/io.cc
@@ -0,0 +1,52 @@
+// { dg-options "-std=gnu++0x" }
+
+// Copyright (C) 2005, 2006, 2007, 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/>.
+
+// 20.6.6.2 Template class shared_ptr [util.smartptr.shared]
+
+#include <memory>
+#include <sstream>
+#include <testsuite_hooks.h>
+
+struct A { };
+
+// 20.6.6.2.8 shared_ptr I/O [util.smartptr.shared.io]
+
+// operator<<
+int
+test01()
+{
+  bool test __attribute__((unused)) = true;
+
+  std::shared_ptr<A> p(new A);
+  std::ostringstream buf;
+  buf << p;
+  const std::string s = buf.str();
+  buf.str("");
+  buf << p.get();
+  VERIFY( s == buf.str() );
+
+  return 0;
+}
+
+int 
+main()
+{
+  test01();
+  return 0;
+}
diff --git a/libstdc++-v3/testsuite/20_util/shared_ptr/misc/swap.cc b/libstdc++-v3/testsuite/20_util/shared_ptr/misc/swap.cc
new file mode 100644
index 000000000..10ccf8cad
--- /dev/null
+++ b/libstdc++-v3/testsuite/20_util/shared_ptr/misc/swap.cc
@@ -0,0 +1,51 @@
+// { dg-options "-std=gnu++0x" }
+
+// Copyright (C) 2005, 2006, 2007, 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/>.
+
+// 20.6.6.2 Template class shared_ptr [util.smartptr.shared]
+
+#include <memory>
+#include <testsuite_hooks.h>
+
+struct A { };
+
+// 20.6.6.2.9 shared_ptr specialized algorithms [util.smartptr.shared.spec]
+
+// std::swap
+int
+test01()
+{
+  bool test __attribute__((unused)) = true;
+
+  A * const a1 = new A;
+  A * const a2 = new A;
+  std::shared_ptr<A> p1(a1);
+  std::shared_ptr<A> p2(a2);
+  std::swap(p1, p2);
+  VERIFY( p1.get() == a2 );
+  VERIFY( p2.get() == a1 );
+
+  return 0;
+}
+
+int 
+main()
+{
+  test01();
+  return 0;
+}
diff --git a/libstdc++-v3/testsuite/20_util/shared_ptr/modifiers/24805.cc b/libstdc++-v3/testsuite/20_util/shared_ptr/modifiers/24805.cc
new file mode 100644
index 000000000..8b64014c0
--- /dev/null
+++ b/libstdc++-v3/testsuite/20_util/shared_ptr/modifiers/24805.cc
@@ -0,0 +1,30 @@
+// { dg-options "-std=gnu++0x" }
+// { dg-do compile }
+
+// Copyright (C) 2005, 2006, 2007, 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/>.
+
+// 20.6.6.2 Template class shared_ptr [util.smartptr.shared]
+
+#include <memory>
+
+// 20.6.6.2.4 shared_ptr modifiers [util.smartptr.shared.mod]
+
+// swap
+
+// libstdc++/24805
+using std::swap;
diff --git a/libstdc++-v3/testsuite/20_util/shared_ptr/modifiers/reset.cc b/libstdc++-v3/testsuite/20_util/shared_ptr/modifiers/reset.cc
new file mode 100644
index 000000000..c3b6745b4
--- /dev/null
+++ b/libstdc++-v3/testsuite/20_util/shared_ptr/modifiers/reset.cc
@@ -0,0 +1,89 @@
+// { dg-options "-std=gnu++0x" }
+
+// Copyright (C) 2005, 2006, 2007, 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/>.
+
+// 20.6.6.2 Template class shared_ptr [util.smartptr.shared]
+
+#include <memory>
+#include <testsuite_hooks.h>
+
+struct A { };
+struct B : A { };
+struct D
+{
+  void operator()(B* p) { delete p; ++delete_count; }
+  static long delete_count;
+};
+long D::delete_count = 0;
+
+// 20.6.6.2.4 shared_ptr modifiers [util.smartptr.shared.mod]
+
+// reset
+int
+test01()
+{
+  bool test __attribute__((unused)) = true;
+
+  A * const a = new A;
+  std::shared_ptr<A> p1(a);
+  std::shared_ptr<A> p2(p1);
+  p1.reset();
+  VERIFY( p1.get() == 0 );
+  VERIFY( p2.get() == a );
+
+  return 0;
+}
+
+int
+test02()
+{
+  bool test __attribute__((unused)) = true;
+
+  A * const a = new A;
+  B * const b = new B;
+  std::shared_ptr<A> p1(a);
+  std::shared_ptr<A> p2(p1);
+  p1.reset(b);
+  VERIFY( p1.get() == b );
+  VERIFY( p2.get() == a );
+
+  return 0;
+}
+
+int
+test03()
+{
+  bool test __attribute__((unused)) = true;
+
+  {
+    std::shared_ptr<A> p1;
+    p1.reset(new B, D());
+  }
+  VERIFY( D::delete_count == 1 );
+
+  return 0;
+}   
+
+int
+main()
+{
+  test01();
+  test02();
+  test03();
+  return 0;
+}
diff --git a/libstdc++-v3/testsuite/20_util/shared_ptr/modifiers/reset_alloc.cc b/libstdc++-v3/testsuite/20_util/shared_ptr/modifiers/reset_alloc.cc
new file mode 100644
index 000000000..61ac3b98e
--- /dev/null
+++ b/libstdc++-v3/testsuite/20_util/shared_ptr/modifiers/reset_alloc.cc
@@ -0,0 +1,63 @@
+// { dg-options "-std=gnu++0x" }
+
+// Copyright (C) 2007, 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/>.
+
+// 20.6.6.2 Template class shared_ptr [util.smartptr.shared]
+
+#include <memory>
+#include <testsuite_hooks.h>
+#include <testsuite_allocator.h>
+
+using __gnu_test::tracker_allocator_counter;
+using __gnu_test::tracker_allocator;
+
+struct A { };
+struct B : A { };
+struct D
+{
+  void operator()(B* p) { delete p; ++delete_count; }
+  static long delete_count;
+};
+long D::delete_count = 0;
+
+// 20.6.6.2.4 shared_ptr modifiers [util.smartptr.shared.mod]
+
+// Reset with allocator
+int
+test01()
+{
+  bool test __attribute__((unused)) = true;
+  tracker_allocator_counter::reset();
+
+  {
+    std::shared_ptr<A> p1;
+    p1.reset(new B, D(), tracker_allocator<B>());
+    VERIFY( tracker_allocator_counter::get_allocation_count() > 0 );
+  }
+  VERIFY( D::delete_count == 1 );
+  VERIFY( tracker_allocator_counter::get_allocation_count() == tracker_allocator_counter::get_deallocation_count() );
+
+  return 0;
+}   
+
+int
+main()
+{
+  test01();
+  return 0;
+}
diff --git a/libstdc++-v3/testsuite/20_util/shared_ptr/modifiers/reset_neg.cc b/libstdc++-v3/testsuite/20_util/shared_ptr/modifiers/reset_neg.cc
new file mode 100644
index 000000000..5f133f547
--- /dev/null
+++ b/libstdc++-v3/testsuite/20_util/shared_ptr/modifiers/reset_neg.cc
@@ -0,0 +1,47 @@
+// { dg-do compile }
+// { dg-options "-std=gnu++0x" }
+
+// Copyright (C) 2005, 2006, 2007, 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/>.
+
+// 20.6.6.2 Template class shared_ptr [util.smartptr.shared]
+
+#include <memory>
+#include <testsuite_hooks.h>
+
+struct A { };
+
+// 20.6.6.2.4 shared_ptr modifiers [util.smartptr.shared.mod]
+
+// reset
+int
+test01()
+{
+  bool test __attribute__((unused)) = true;
+
+  const std::shared_ptr<A> p1(new A);
+  p1.reset();     // { dg-error "discards qualifiers" }
+
+  return 0;
+}
+
+int
+main()
+{
+  test01();
+  return 0;
+}
diff --git a/libstdc++-v3/testsuite/20_util/shared_ptr/modifiers/swap.cc b/libstdc++-v3/testsuite/20_util/shared_ptr/modifiers/swap.cc
new file mode 100644
index 000000000..aab41ddc8
--- /dev/null
+++ b/libstdc++-v3/testsuite/20_util/shared_ptr/modifiers/swap.cc
@@ -0,0 +1,51 @@
+// { dg-options "-std=gnu++0x" }
+
+// Copyright (C) 2005, 2006, 2007, 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/>.
+
+// 20.6.6.2 Template class shared_ptr [util.smartptr.shared]
+
+#include <memory>
+#include <testsuite_hooks.h>
+
+struct A { };
+
+// 20.6.6.2.4 shared_ptr modifiers [util.smartptr.shared.mod]
+
+// swap
+int
+test01()
+{
+  bool test __attribute__((unused)) = true;
+
+  A * const a1 = new A;
+  A * const a2 = new A;
+  std::shared_ptr<A> p1(a1);
+  std::shared_ptr<A> p2(a2);
+  p1.swap(p2);
+  VERIFY( p1.get() == a2 );
+  VERIFY( p2.get() == a1 );
+
+  return 0;
+}
+
+int 
+main()
+{
+  test01();
+  return 0;
+}
diff --git a/libstdc++-v3/testsuite/20_util/shared_ptr/modifiers/swap_neg.cc b/libstdc++-v3/testsuite/20_util/shared_ptr/modifiers/swap_neg.cc
new file mode 100644
index 000000000..db173630f
--- /dev/null
+++ b/libstdc++-v3/testsuite/20_util/shared_ptr/modifiers/swap_neg.cc
@@ -0,0 +1,48 @@
+// { dg-options "-std=gnu++0x" }
+// { dg-do compile }
+
+// Copyright (C) 2005, 2006, 2007, 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/>.
+
+// 20.6.6.2 Template class shared_ptr [util.smartptr.shared]
+
+#include <memory>
+#include <testsuite_hooks.h>
+
+struct A { };
+
+// 20.6.6.2.4 shared_ptr modifiers [util.smartptr.shared.mod]
+
+// swap
+int
+test01()
+{
+  bool test __attribute__((unused)) = true;
+
+  const std::shared_ptr<A> p1(new A);
+  std::shared_ptr<A> p2(new A);
+  p1.swap(p2);   // { dg-error "discards qualifiers" }
+
+  return 0;
+}
+
+int 
+main()
+{
+  test01();
+  return 0;
+}
diff --git a/libstdc++-v3/testsuite/20_util/shared_ptr/observers/bool_conv.cc b/libstdc++-v3/testsuite/20_util/shared_ptr/observers/bool_conv.cc
new file mode 100644
index 000000000..dc2d53386
--- /dev/null
+++ b/libstdc++-v3/testsuite/20_util/shared_ptr/observers/bool_conv.cc
@@ -0,0 +1,75 @@
+// { dg-options "-std=gnu++0x" }
+
+// Copyright (C) 2005, 2006, 2007, 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/>.
+
+// 20.6.6.2 Template class shared_ptr [util.smartptr.shared]
+
+#include <memory>
+#include <testsuite_hooks.h>
+
+struct A { };
+
+// 20.6.6.2.5 shared_ptr observers [util.smartptr.shared.obs]
+
+// conversion to bool
+void
+test01()
+{
+  bool test __attribute__((unused)) = true;
+
+  const std::shared_ptr<A> p1;
+  VERIFY( static_cast<bool>(p1) == false );
+  const std::shared_ptr<A> p2(p1);
+  VERIFY( static_cast<bool>(p2) == false );
+}
+
+void
+test02()
+{
+  bool test __attribute__((unused)) = true;
+
+  std::shared_ptr<A> p1(new A);
+  VERIFY( static_cast<bool>(p1) );
+  std::shared_ptr<A> p2(p1);
+  VERIFY( static_cast<bool>(p2) );
+  p1.reset();
+  VERIFY( !static_cast<bool>(p1) );
+  VERIFY( static_cast<bool>(p2) );
+}
+
+void
+test03()
+{
+  bool test __attribute__((unused)) = true;
+
+  std::shared_ptr<A> p1(new A);
+  std::shared_ptr<A> p2(p1);
+  p2.reset(new A);
+  VERIFY( static_cast<bool>(p1) );
+  VERIFY( static_cast<bool>(p2) );
+}
+
+
+int 
+main()
+{
+  test01();
+  test02();
+  test03();
+  return 0;
+}
diff --git a/libstdc++-v3/testsuite/20_util/shared_ptr/observers/get.cc b/libstdc++-v3/testsuite/20_util/shared_ptr/observers/get.cc
new file mode 100644
index 000000000..104c7219d
--- /dev/null
+++ b/libstdc++-v3/testsuite/20_util/shared_ptr/observers/get.cc
@@ -0,0 +1,73 @@
+// { dg-options "-std=gnu++0x" }
+
+// Copyright (C) 2005, 2006, 2007, 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/>.
+
+// 20.6.6.2 Template class shared_ptr [util.smartptr.shared]
+
+#include <memory>
+#include <testsuite_hooks.h>
+
+struct A
+{
+  A() : i() {}
+  int i;
+};
+
+// 20.6.6.2.5 shared_ptr observers [util.smartptr.shared.obs]
+
+// get
+void
+test01()
+{
+  bool test __attribute__((unused)) = true;
+
+  A * const a = new A;
+  const std::shared_ptr<A> p(a);
+  VERIFY( p.get() == a );
+}
+
+// operator*
+void
+test02()
+{
+  bool test __attribute__((unused)) = true;
+
+  A * const a = new A;
+  const std::shared_ptr<A> p(a);
+  VERIFY( &*p == a );
+}
+
+// operator->
+void
+test03()
+{
+  bool test __attribute__((unused)) = true;
+
+  A * const a = new A;
+  const std::shared_ptr<A> p(a);
+  VERIFY( &p->i == &a->i );
+}
+
+int 
+main()
+{
+  test01();
+  test02();
+  test03();
+  return 0;
+}
diff --git a/libstdc++-v3/testsuite/20_util/shared_ptr/observers/owner_before.cc b/libstdc++-v3/testsuite/20_util/shared_ptr/observers/owner_before.cc
new file mode 100644
index 000000000..79ede6833
--- /dev/null
+++ b/libstdc++-v3/testsuite/20_util/shared_ptr/observers/owner_before.cc
@@ -0,0 +1,94 @@
+// { dg-options "-std=gnu++0x" }
+
+// 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/>.
+
+// 20.8.13.2 Template class shared_ptr [util.smartptr.shared]
+
+#include <memory>
+#include <testsuite_hooks.h>
+
+struct A
+{
+  int i;
+  virtual ~A() { }
+};
+
+struct B : A
+{
+};
+
+// 20.6.6.2.5 shared_ptr observers [util.smartptr.shared.obs]
+
+void
+test01()
+{
+  bool test __attribute__((unused)) = true;
+
+  // test empty shared_ptrs compare equivalent
+  std::shared_ptr<A> p1;
+  std::shared_ptr<B> p2;
+  VERIFY( !p1.owner_before(p2) && !p2.owner_before(p1) );
+}
+
+
+// Construction from pointer
+void
+test02()
+{
+  bool test __attribute__((unused)) = true;
+
+  std::shared_ptr<A> a0;
+
+  std::shared_ptr<A> a1(new A);
+  VERIFY( a1.owner_before(a0) || a0.owner_before(a1) );
+  VERIFY( !(a1.owner_before(a0) && a0.owner_before(a1)) );
+
+  std::shared_ptr<B> b1(new B);
+  VERIFY( a1.owner_before(b1) || b1.owner_before(a1) );
+  VERIFY( !(a1.owner_before(b1) && b1.owner_before(a1)) );
+
+  std::shared_ptr<A> a2(a1);
+  VERIFY( !a1.owner_before(a2) && !a2.owner_before(a1) );
+  a2 = b1;
+  VERIFY( !b1.owner_before(a2) && !a2.owner_before(b1) );
+
+  std::weak_ptr<A> w1(a1);
+  VERIFY( !a1.owner_before(w1) && !w1.owner_before(a1) );
+  std::weak_ptr<A> w2(a2);
+  VERIFY( !b1.owner_before(w2) && !w2.owner_before(b1) );
+}
+
+// Aliasing
+void
+test03()
+{
+  bool test __attribute__((unused)) = true;
+
+  std::shared_ptr<A> p1(new A());
+  std::shared_ptr<int> p2(p1, &p1->i);
+  VERIFY( !p1.owner_before(p2) && !p2.owner_before(p1) );
+}
+
+int 
+main()
+{
+  test01();
+  test02();
+  test03();
+  return 0;
+}
diff --git a/libstdc++-v3/testsuite/20_util/shared_ptr/observers/unique.cc b/libstdc++-v3/testsuite/20_util/shared_ptr/observers/unique.cc
new file mode 100644
index 000000000..fae5eba37
--- /dev/null
+++ b/libstdc++-v3/testsuite/20_util/shared_ptr/observers/unique.cc
@@ -0,0 +1,75 @@
+// { dg-options "-std=gnu++0x" }
+
+// Copyright (C) 2005, 2006, 2007, 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/>.
+
+// 20.6.6.2 Template class shared_ptr [util.smartptr.shared]
+
+#include <memory>
+#include <testsuite_hooks.h>
+
+struct A { };
+
+// 20.6.6.2.5 shared_ptr observers [util.smartptr.shared.obs]
+
+// unique
+void
+test01()
+{
+  bool test __attribute__((unused)) = true;
+
+  const std::shared_ptr<A> p1;
+  VERIFY( !p1.unique() );
+  const std::shared_ptr<A> p2(p1);
+  VERIFY( !p1.unique() );
+}
+
+void
+test02()
+{
+  bool test __attribute__((unused)) = true;
+
+  std::shared_ptr<A> p1(new A);
+  VERIFY( p1.unique() );
+  std::shared_ptr<A> p2(p1);
+  VERIFY( !p1.unique() );
+  p1.reset();
+  VERIFY( !p1.unique() );
+  VERIFY( p2.unique() );
+}
+
+void
+test03()
+{
+  bool test __attribute__((unused)) = true;
+
+  std::shared_ptr<A> p1(new A);
+  std::shared_ptr<A> p2(p1);
+  p2.reset(new A);
+  VERIFY( p1.unique() );
+  VERIFY( p2.unique() );
+}
+
+
+int 
+main()
+{
+  test01();
+  test02();
+  test03();
+  return 0;
+}
diff --git a/libstdc++-v3/testsuite/20_util/shared_ptr/observers/use_count.cc b/libstdc++-v3/testsuite/20_util/shared_ptr/observers/use_count.cc
new file mode 100644
index 000000000..a7f34cfac
--- /dev/null
+++ b/libstdc++-v3/testsuite/20_util/shared_ptr/observers/use_count.cc
@@ -0,0 +1,74 @@
+// { dg-options "-std=gnu++0x" }
+
+// Copyright (C) 2005, 2006, 2007, 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/>.
+
+// 20.6.6.2 Template class shared_ptr [util.smartptr.shared]
+
+#include <memory>
+#include <testsuite_hooks.h>
+
+struct A { };
+struct B : A { };
+
+// 20.6.6.2.5 shared_ptr observers [util.smartptr.shared.obs]
+
+// use_count
+void
+test01()
+{
+  bool test __attribute__((unused)) = true;
+
+  const std::shared_ptr<A> p1;
+  VERIFY( p1.use_count() == 0 );
+  const std::shared_ptr<A> p2(p1);
+  VERIFY( p1.use_count() == 0 );
+}
+
+void
+test02()
+{
+  bool test __attribute__((unused)) = true;
+
+  std::shared_ptr<A> p1(new A);
+  std::shared_ptr<A> p2(p1);
+  p1.reset();
+  VERIFY( p1.use_count() == 0 );
+  VERIFY( p2.use_count() == 1 );
+}
+
+void
+test03()
+{
+  bool test __attribute__((unused)) = true;
+
+  std::shared_ptr<A> p1(new A);
+  std::shared_ptr<A> p2(p1);
+  p2.reset(new B);
+  VERIFY( p1.use_count() == 1 );
+  VERIFY( p2.use_count() == 1 );
+}
+
+
+int 
+main()
+{
+  test01();
+  test02();
+  test03();
+  return 0;
+}
diff --git a/libstdc++-v3/testsuite/20_util/shared_ptr/requirements/explicit_instantiation/1.cc b/libstdc++-v3/testsuite/20_util/shared_ptr/requirements/explicit_instantiation/1.cc
new file mode 100644
index 000000000..0f2d2c366
--- /dev/null
+++ b/libstdc++-v3/testsuite/20_util/shared_ptr/requirements/explicit_instantiation/1.cc
@@ -0,0 +1,31 @@
+// { dg-options "-std=gnu++0x" }
+// { dg-do compile }
+
+// Copyright (C) 2006, 2007, 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/>.
+
+// 20.6.6.2 Template class shared_ptr [util.smartptr.shared]
+
+#include <memory>
+#include <testsuite_tr1.h>
+
+using namespace __gnu_test;
+using std::shared_ptr;
+template class shared_ptr<int>;
+template class shared_ptr<void>;
+template class shared_ptr<ClassType>;
+template class shared_ptr<IncompleteClass>;
diff --git a/libstdc++-v3/testsuite/20_util/shared_ptr/requirements/explicit_instantiation/2.cc b/libstdc++-v3/testsuite/20_util/shared_ptr/requirements/explicit_instantiation/2.cc
new file mode 100644
index 000000000..781657cb0
--- /dev/null
+++ b/libstdc++-v3/testsuite/20_util/shared_ptr/requirements/explicit_instantiation/2.cc
@@ -0,0 +1,34 @@
+// { dg-options "-std=gnu++0x" }
+// { dg-do compile }
+
+// Copyright (C) 2007, 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/>.
+
+// 20.6.6.2 Template class shared_ptr [util.smartptr.shared]
+
+#include <memory>
+#include <testsuite_tr1.h>
+
+// Check the _S_single lock policy can be instantiated. For a thread-enabled
+// library this checks the templates can be instantiated for non-default
+// lock policy, for a single-threaded lib this is redundant but harmless.
+using namespace __gnu_test;
+using std::__shared_ptr;
+using std::_S_single;
+template class __shared_ptr<int, _S_single>;
+template class __shared_ptr<ClassType, _S_single>;
+template class __shared_ptr<IncompleteClass, _S_single>;
diff --git a/libstdc++-v3/testsuite/20_util/shared_ptr/thread/default_weaktoshared.cc b/libstdc++-v3/testsuite/20_util/shared_ptr/thread/default_weaktoshared.cc
new file mode 100644
index 000000000..b215f654a
--- /dev/null
+++ b/libstdc++-v3/testsuite/20_util/shared_ptr/thread/default_weaktoshared.cc
@@ -0,0 +1,197 @@
+// Copyright (C) 2006, 2007, 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/>.
+
+// 20.6.6.2 Template class shared_ptr [util.smartptr.shared]
+
+// { dg-do run { target *-*-freebsd* *-*-netbsd* *-*-linux* *-*-solaris* *-*-cygwin *-*-darwin* alpha*-*-osf* mips-sgi-irix6* } }
+// { dg-options "-pthread -std=gnu++0x" { target *-*-freebsd* *-*-netbsd* *-*-linux* alpha*-*-osf* mips-sgi-irix6* } }
+// { dg-options "-pthreads -std=gnu++0x" { target *-*-solaris* } }
+// { dg-options " -std=gnu++0x " { target *-*-cygwin *-*-darwin* } }
+
+#include <memory>
+#include <random>
+#include <vector>
+#include <testsuite_hooks.h>
+#include <iostream>
+#include <cstdlib>
+
+#include <pthread.h>
+
+#ifdef _GLIBCXX_HAVE_UNISTD_H
+#include <unistd.h>	// To test for _POSIX_THREAD_PRIORITY_SCHEDULING
+#endif
+
+/* This (brute-force) tests the atomicity and thus thread safety of the
+ * shared_ptr <- weak_ptr
+ * assignment operation by allocating a test object, retrieving a weak
+ * reference to it, and letting a number of threads repeatedly create strong
+ * references from the weak reference.
+ * Specifically, this tests the function _Sp_counted_base<true>::add_ref_lock()
+ */
+
+
+const unsigned int HAMMER_MAX_THREADS = 10;
+const unsigned int POOL_SIZE = 1000;
+const unsigned long HAMMER_REPEAT = 100000;
+const unsigned long KILL_ONE_IN = 1000;
+
+struct A
+  {
+    static _Atomic_word counter;
+    A()
+      {
+	__gnu_cxx::__atomic_add(&counter, 1);
+      }
+    ~A()
+      {
+	__gnu_cxx::__atomic_add(&counter, -1);
+      }
+  };
+
+_Atomic_word A::counter = 0;
+
+typedef std::shared_ptr<A> sp_A_t;
+typedef std::weak_ptr<A> wp_A_t;
+
+typedef std::vector<sp_A_t> sp_vector_t;
+typedef std::vector<wp_A_t> wp_vector_t;
+
+struct shared_and_weak_pools
+{
+  sp_vector_t& shared_pool;
+  wp_vector_t& weak_pool;
+  
+  shared_and_weak_pools(sp_vector_t& _shared_pool, wp_vector_t& _weak_pool)
+    : shared_pool(_shared_pool), weak_pool(_weak_pool)
+    { }
+};
+
+void* thread_hammer_and_kill(void* opaque_pools)
+{
+  shared_and_weak_pools& pools = *static_cast<shared_and_weak_pools*>(opaque_pools);
+  // Using the same parameters as in the RNG test cases.
+  std::mersenne_twister_engine<
+    unsigned long, 32, 624, 397, 31,
+    0x9908b0dful, 11,
+    0xfffffffful, 7,
+    0x9d2c5680ul, 15,
+    0xefc60000ul, 18, 1812433253ul> rng;
+  
+  sp_vector_t::iterator cur_shared = pools.shared_pool.begin();
+  wp_vector_t::iterator cur_weak = pools.weak_pool.begin();
+  
+  for (unsigned int i = 0; i < HAMMER_REPEAT; ++i)
+    {
+      try
+      {
+        sp_A_t strong(*cur_weak);
+      }
+      catch (std::bad_weak_ptr& exception)
+      {
+        ++cur_weak;
+        if (cur_weak == pools.weak_pool.end())
+          break;
+      }
+      
+      if (rng() % KILL_ONE_IN == 0)
+      {
+        cur_shared->reset();
+        ++cur_shared;
+      }
+    }
+  return 0;
+}
+
+void* thread_hammer(void* opaque_weak)
+{
+  wp_vector_t& weak_pool = *static_cast<wp_vector_t*>(opaque_weak);
+  // Using the same parameters as in the RNG test cases.
+  std::mersenne_twister_engine<
+    unsigned long, 32, 624, 397, 31,
+    0x9908b0dful, 11,
+    0xfffffffful, 7,
+    0x9d2c5680ul, 15,
+    0xefc60000ul, 18, 1812433253ul> rng;
+
+  wp_vector_t::iterator cur_weak = weak_pool.begin();
+
+  for (unsigned int i = 0; i < HAMMER_REPEAT; ++i)
+    {
+      try
+      {
+        sp_A_t strong(*cur_weak);
+      }
+      catch (std::bad_weak_ptr& exception)
+      {
+        ++cur_weak;
+        if (cur_weak == weak_pool.end())
+          break;
+      }
+    }
+  return 0;
+}
+
+int
+test01()
+{
+  bool test __attribute__((unused)) = true;
+  sp_vector_t obj_pool(POOL_SIZE);
+  
+  for(sp_vector_t::iterator cur = obj_pool.begin(); cur != obj_pool.end(); ++cur)
+  {
+    cur->reset(new A);
+  }
+  // Obtain weak references.
+  std::vector<wp_vector_t> weak_pool(HAMMER_MAX_THREADS, wp_vector_t(obj_pool.begin(), obj_pool.end()));
+  
+  // Launch threads with pointer to weak reference.
+  pthread_t threads[HAMMER_MAX_THREADS];
+#if defined(__sun) && defined(__svr4__) && _XOPEN_VERSION >= 500
+  pthread_setconcurrency (HAMMER_MAX_THREADS);
+#endif
+  
+  pthread_attr_t tattr;
+  pthread_attr_init(&tattr);
+
+  shared_and_weak_pools pools(obj_pool, weak_pool[0]);
+  pthread_create(threads, &tattr, thread_hammer_and_kill, static_cast<void*>(&pools));
+  for (unsigned int worker = 1; worker < HAMMER_MAX_THREADS; worker++)
+    {
+      if (pthread_create(&threads[worker], &tattr,
+			 thread_hammer, static_cast<void*>(&weak_pool[worker])))
+	std::abort();
+    }
+  // Wait for threads to complete, then check integrity of reference.
+  void* status;
+  for (unsigned int worker = 0; worker < HAMMER_MAX_THREADS; worker++)
+    {
+      if (pthread_join(threads[worker], &status))
+	std::abort();
+    }
+  obj_pool.clear();
+  
+  VERIFY( A::counter == 0 );
+  
+  return 0;
+}
+
+int 
+main()
+{
+  test01();
+  return 0;
+}
diff --git a/libstdc++-v3/testsuite/20_util/shared_ptr/thread/mutex_weaktoshared.cc b/libstdc++-v3/testsuite/20_util/shared_ptr/thread/mutex_weaktoshared.cc
new file mode 100644
index 000000000..c1ca796bb
--- /dev/null
+++ b/libstdc++-v3/testsuite/20_util/shared_ptr/thread/mutex_weaktoshared.cc
@@ -0,0 +1,199 @@
+// Copyright (C) 2006, 2007, 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/>.
+
+// 20.6.6.2 Template class shared_ptr [util.smartptr.shared]
+
+// { dg-do run { target *-*-freebsd* *-*-netbsd* *-*-linux* *-*-solaris* *-*-cygwin *-*-darwin* alpha*-*-osf* mips-sgi-irix6* } }
+// { dg-options " -std=gnu++0x -pthread" { target *-*-freebsd* *-*-netbsd* *-*-linux* alpha*-*-osf* mips-sgi-irix6* } }
+// { dg-options " -std=gnu++0x -pthreads" { target *-*-solaris* } }
+// { dg-options " -std=gnu++0x " { target *-*-cygwin *-*-darwin* } }
+
+#include <memory>
+#include <random>
+#include <vector>
+#include <testsuite_hooks.h>
+#include <iostream>
+#include <cstdlib>
+
+#include <pthread.h>
+
+#ifdef _GLIBCXX_HAVE_UNISTD_H
+#include <unistd.h>	// To test for _POSIX_THREAD_PRIORITY_SCHEDULING
+#endif
+
+/* This (brute-force) tests the atomicity and thus thread safety of the
+ * shared_ptr <- weak_ptr
+ * assignment operation by allocating a test object, retrieving a weak
+ * reference to it, and letting a number of threads repeatedly create strong
+ * references from the weak reference.
+ * Specifically, this tests the function _Sp_counted_base<true>::add_ref_lock()
+ */
+
+
+const unsigned int HAMMER_MAX_THREADS = 10;
+const unsigned int POOL_SIZE = 1000;
+const unsigned long HAMMER_REPEAT = 100000;
+const unsigned long KILL_ONE_IN = 1000;
+
+struct A
+  {
+    static _Atomic_word counter;
+    A()
+      {
+	__gnu_cxx::__atomic_add(&counter, 1);
+      }
+    ~A()
+      {
+	__gnu_cxx::__atomic_add(&counter, -1);
+      }
+  };
+
+_Atomic_word A::counter = 0;
+
+using std::_S_mutex;
+
+typedef std::__shared_ptr<A, _S_mutex> sp_A_t;
+typedef std::__weak_ptr<A, _S_mutex> wp_A_t;
+
+typedef std::vector<sp_A_t> sp_vector_t;
+typedef std::vector<wp_A_t> wp_vector_t;
+
+struct shared_and_weak_pools
+{
+  sp_vector_t& shared_pool;
+  wp_vector_t& weak_pool;
+  
+  shared_and_weak_pools(sp_vector_t& _shared_pool, wp_vector_t& _weak_pool)
+    : shared_pool(_shared_pool), weak_pool(_weak_pool)
+    { }
+};
+
+void* thread_hammer_and_kill(void* opaque_pools)
+{
+  shared_and_weak_pools& pools = *static_cast<shared_and_weak_pools*>(opaque_pools);
+  // Using the same parameters as in the RNG test cases.
+  std::mersenne_twister_engine<
+    unsigned long, 32, 624, 397, 31,
+    0x9908b0dful, 11,
+    0xfffffffful, 7,
+    0x9d2c5680ul, 15,
+    0xefc60000ul, 18, 1812433253ul> rng;
+
+  sp_vector_t::iterator cur_shared = pools.shared_pool.begin();
+  wp_vector_t::iterator cur_weak = pools.weak_pool.begin();
+  
+  for (unsigned int i = 0; i < HAMMER_REPEAT; ++i)
+    {
+      try
+      {
+        sp_A_t strong(*cur_weak);
+      }
+      catch (std::bad_weak_ptr& exception)
+      {
+        ++cur_weak;
+        if (cur_weak == pools.weak_pool.end())
+          break;
+      }
+      
+      if (rng() % KILL_ONE_IN == 0)
+      {
+        cur_shared->reset();
+        ++cur_shared;
+      }
+    }
+  return 0;
+}
+
+void* thread_hammer(void* opaque_weak)
+{
+  wp_vector_t& weak_pool = *static_cast<wp_vector_t*>(opaque_weak);
+  // Using the same parameters as in the RNG test cases.
+  std::mersenne_twister_engine<
+    unsigned long, 32, 624, 397, 31,
+    0x9908b0dful, 11,
+    0xfffffffful, 7,
+    0x9d2c5680ul, 15,
+    0xefc60000ul, 18, 1812433253ul> rng;
+
+  wp_vector_t::iterator cur_weak = weak_pool.begin();
+
+  for (unsigned int i = 0; i < HAMMER_REPEAT; ++i)
+    {
+      try
+      {
+        sp_A_t strong(*cur_weak);
+      }
+      catch (std::bad_weak_ptr& exception)
+      {
+        ++cur_weak;
+        if (cur_weak == weak_pool.end())
+          break;
+      }
+    }
+  return 0;
+}
+
+int
+test01()
+{
+  bool test __attribute__((unused)) = true;
+  sp_vector_t obj_pool(POOL_SIZE);
+  
+  for(sp_vector_t::iterator cur = obj_pool.begin(); cur != obj_pool.end(); ++cur)
+  {
+    cur->reset(new A);
+  }
+  // Obtain weak references.
+  std::vector<wp_vector_t> weak_pool(HAMMER_MAX_THREADS, wp_vector_t(obj_pool.begin(), obj_pool.end()));
+  
+  // Launch threads with pointer to weak reference.
+  pthread_t threads[HAMMER_MAX_THREADS];
+#if defined(__sun) && defined(__svr4__) && _XOPEN_VERSION >= 500
+  pthread_setconcurrency (HAMMER_MAX_THREADS);
+#endif
+  
+  pthread_attr_t tattr;
+  pthread_attr_init(&tattr);
+
+  shared_and_weak_pools pools(obj_pool, weak_pool[0]);
+  pthread_create(threads, &tattr, thread_hammer_and_kill, static_cast<void*>(&pools));
+  for (unsigned int worker = 1; worker < HAMMER_MAX_THREADS; worker++)
+    {
+      if (pthread_create(&threads[worker], &tattr,
+			 thread_hammer, static_cast<void*>(&weak_pool[worker])))
+	std::abort();
+    }
+  // Wait for threads to complete, then check integrity of reference.
+  void* status;
+  for (unsigned int worker = 0; worker < HAMMER_MAX_THREADS; worker++)
+    {
+      if (pthread_join(threads[worker], &status))
+	std::abort();
+    }
+  obj_pool.clear();
+  
+  VERIFY( A::counter == 0 );
+  
+  return 0;
+}
+
+int 
+main()
+{
+  test01();
+  return 0;
+}