This is the mail archive of the libstdc++@gcc.gnu.org mailing list for the libstdc++ project.


Index Nav: [Date Index] [Subject Index] [Author Index] [Thread Index]
Message Nav: [Date Prev] [Date Next] [Thread Prev] [Thread Next]
Other format: [Raw text]

[v3 patch] Remove __gnu_cxx::__alloc_traits::_S_nothrow_swap()


As I suggested recently, this removes the _S_nothrow_swap() function
because it's redundant: allocators are not allowed to throw exceptions
when swapped, so we can assume they don't.

So now exception specifications for swapping containers don't depend
on allocators.

This also adds a _GLIBCXX_NOEXCEPT_IF macro for helping to define
conditional noexcept guarantees.

Tested powerpc64le-linux, committed to trunk.

commit 54d85a21c3b1c94d1bf28bc095ae9d373e180802
Author: Jonathan Wakely <jwakely@redhat.com>
Date:   Sat Jul 11 12:13:09 2015 +0100

    	* include/bits/c++config (_GLIBCXX_NOEXCEPT_IF): Define.
    	* include/bits/forward_list.h (forward_list::swap): Make noexcept
    	unconditional.
    	* include/bits/hashtable.h (_Hashtable::swap): Do not use
    	_S_nothrow_swap().
    	* include/bits/stl_bvector.h (vector<bool>::swap): Make noexcept
    	unconditional.
    	* include/bits/stl_deque.h (deque::swap): Likewise.
    	(swap(deque&, deque&)): Use _GLIBCXX_NOEXCEPT_IF.
    	* include/bits/stl_list.h (list::swap): Make noexcept unconditional.
    	(swap(list&, list&)): Use _GLIBCXX_NOEXCEPT_IF.
    	* include/bits/stl_map.h (map::swap, swap(map&, map&)): Use
    	_GLIBCXX_NOEXCEPT_IF, do not depend on _S_nothrow_swap.
    	* include/bits/stl_multimap.h (multimap::swap,
    	swap(multimap&, multimap&)): Likewise.
    	* include/bits/stl_multiset.h (multiset::swap,
    	swap(multiset&, multiset&)): Likewise.
    	* include/bits/stl_set.h (set::swap, swap(set&, set&)): Likewise.
    	* include/bits/stl_tree.h (_Rb_tree::swap,
    	swap(_Rb_tree&, _Rb_tree&)): Likewise.
    	* include/bits/stl_vector.h (vector::swap): Make noexcept
    	unconditional.
    	(swap(vector&, vector&)): Use _GLIBCXX_NOEXCEPT_IF.
    	* include/debug/deque (deque::swap, swap): Likewise.
    	* include/debug/forward_list (swap): Add noexcept.
    	* include/debug/list (list::swap, swap): Use _GLIBCXX_NOEXCEPT_IF.
    	* include/debug/map.h (map::swap, swap): Likewise.
    	* include/debug/multimap.h (multimap::swap, swap): Likewise.
    	* include/debug/multiset.h (multiset::Swap, swap): Likewise.
    	* include/debug/set.h (set::swap, swap): Likewise.
    	* include/debug/unordered_map (unordered_map::swap,
    	unordered_multimap::swap, swap): Likewise.
    	* include/debug/unordered_set (unordered_set::swap,
    	unordered_multiset::swap, swap): Likewise.
    	* include/debug/vector (vector::swap, swap): Likewise.
    	* include/ext/alloc_traits.h (__alloc_traits::_S_nothrow_swap()):
    	Remove.
    	* include/profile/deque (deque::swap, swap): Use _GLIBCXX_NOEXCEPT_IF.
    	* include/profile/forward_list (swap): Add noexcept.
    	* include/profile/list (list::swap, swap) : Use _GLIBCXX_NOEXCEPT_IF.
    	* include/profile/map.h (map::swap, swap): Likewise.
    	* include/profile/multimap.h (multimap::swap, swap): Likewise.
    	* include/profile/multiset.h (multiset::swap, swap): Likewise.
    	* include/profile/set.h (set::swap, swap): Likewise.
    	* include/profile/unordered_map (swap): Likewise.
    	* include/profile/unordered_set (swap): Likewise.
    	* include/profile/vector (vector::swap, swap): Likewise. Remove
    	overloads for swapping rvalues.
    	* testsuite/23_containers/deque/allocator/noexcept.cc: Update tests
    	for noexcept on swap.
    	* testsuite/23_containers/forward_list/allocator/noexcept.cc:
    	Likewise.
    	* testsuite/23_containers/list/allocator/noexcept.cc: Likewise.
    	* testsuite/23_containers/map/allocator/noexcept.cc: Likewise.
    	* testsuite/23_containers/multimap/allocator/noexcept.cc: Likewise.
    	* testsuite/23_containers/multiset/allocator/noexcept.cc: Likewise.
    	* testsuite/23_containers/set/allocator/noexcept.cc: Likewise.
    	* testsuite/23_containers/unordered_map/allocator/noexcept.cc:
    	Likewise.
    	* testsuite/23_containers/unordered_multimap/allocator/noexcept.cc:
    	Likewise.
    	* testsuite/23_containers/unordered_multiset/allocator/noexcept.cc:
    	Likewise.
    	* testsuite/23_containers/unordered_set/allocator/noexcept.cc:
    	Likewise.
    	* testsuite/23_containers/vector/allocator/noexcept.cc: Likewise.
    	* testsuite/23_containers/vector/bool/allocator/noexcept.cc: Likewise.
    	* testsuite/ext/profile/mutex_extensions_neg.cc: Adjust dg-error line
    	number.

diff --git a/libstdc++-v3/include/bits/c++config b/libstdc++-v3/include/bits/c++config
index ae3065f..34acca3 100644
--- a/libstdc++-v3/include/bits/c++config
+++ b/libstdc++-v3/include/bits/c++config
@@ -115,10 +115,12 @@
 #ifndef _GLIBCXX_NOEXCEPT
 # if __cplusplus >= 201103L
 #  define _GLIBCXX_NOEXCEPT noexcept
+#  define _GLIBCXX_NOEXCEPT_IF(_COND) noexcept(_COND)
 #  define _GLIBCXX_USE_NOEXCEPT noexcept
 #  define _GLIBCXX_THROW(_EXC)
 # else
 #  define _GLIBCXX_NOEXCEPT
+#  define _GLIBCXX_NOEXCEPT_IF(_COND)
 #  define _GLIBCXX_USE_NOEXCEPT throw()
 #  define _GLIBCXX_THROW(_EXC) throw(_EXC)
 # endif
diff --git a/libstdc++-v3/include/bits/forward_list.h b/libstdc++-v3/include/bits/forward_list.h
index db02661..d87f175 100644
--- a/libstdc++-v3/include/bits/forward_list.h
+++ b/libstdc++-v3/include/bits/forward_list.h
@@ -992,8 +992,7 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER
        *  function.
        */
       void
-      swap(forward_list& __list)
-      noexcept(_Node_alloc_traits::_S_nothrow_swap())
+      swap(forward_list& __list) noexcept
       {
         std::swap(this->_M_impl._M_head._M_next,
 		  __list._M_impl._M_head._M_next);
diff --git a/libstdc++-v3/include/bits/hashtable.h b/libstdc++-v3/include/bits/hashtable.h
index 0495f4b..fcecdc4 100644
--- a/libstdc++-v3/include/bits/hashtable.h
+++ b/libstdc++-v3/include/bits/hashtable.h
@@ -475,8 +475,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
 
       void
       swap(_Hashtable&)
-      noexcept(__node_alloc_traits::_S_nothrow_swap()
-	       && __is_nothrow_swappable<_H1>::value
+      noexcept(__is_nothrow_swappable<_H1>::value
 	       && __is_nothrow_swappable<_Equal>::value);
 
       // Basic container operations
@@ -1237,8 +1236,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
     _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
 	       _H1, _H2, _Hash, _RehashPolicy, _Traits>::
     swap(_Hashtable& __x)
-    noexcept(__node_alloc_traits::_S_nothrow_swap()
-	     && __is_nothrow_swappable<_H1>::value
+    noexcept(__is_nothrow_swappable<_H1>::value
 	     && __is_nothrow_swappable<_Equal>::value)
     {
       // The only base class with member variables is hash_code_base.
diff --git a/libstdc++-v3/include/bits/stl_bvector.h b/libstdc++-v3/include/bits/stl_bvector.h
index 71bee21..800b474 100644
--- a/libstdc++-v3/include/bits/stl_bvector.h
+++ b/libstdc++-v3/include/bits/stl_bvector.h
@@ -927,10 +927,7 @@ template<typename _Alloc>
     }
 
     void
-    swap(vector& __x)
-#if __cplusplus >= 201103L
-      noexcept(_Bit_alloc_traits::_S_nothrow_swap())
-#endif
+    swap(vector& __x) _GLIBCXX_NOEXCEPT
     {
       std::swap(this->_M_impl._M_start, __x._M_impl._M_start);
       std::swap(this->_M_impl._M_finish, __x._M_impl._M_finish);
diff --git a/libstdc++-v3/include/bits/stl_deque.h b/libstdc++-v3/include/bits/stl_deque.h
index 9b99668..50570ef 100644
--- a/libstdc++-v3/include/bits/stl_deque.h
+++ b/libstdc++-v3/include/bits/stl_deque.h
@@ -1777,10 +1777,7 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER
        *  std::swap(d1,d2) will feed to this function.
        */
       void
-      swap(deque& __x)
-#if __cplusplus >= 201103L
-      noexcept(_Alloc_traits::_S_nothrow_swap())
-#endif
+      swap(deque& __x) _GLIBCXX_NOEXCEPT
       {
 	_M_impl._M_swap_data(__x._M_impl);
 	_Alloc_traits::_S_on_swap(_M_get_Tp_allocator(),
@@ -2271,9 +2268,7 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER
   template<typename _Tp, typename _Alloc>
     inline void
     swap(deque<_Tp,_Alloc>& __x, deque<_Tp,_Alloc>& __y)
-#if __cplusplus >= 201103L
-    noexcept(noexcept(__x.swap(__y)))
-#endif
+    _GLIBCXX_NOEXCEPT_IF(noexcept(__x.swap(__y)))
     { __x.swap(__y); }
 
 #undef _GLIBCXX_DEQUE_BUF_SIZE
diff --git a/libstdc++-v3/include/bits/stl_list.h b/libstdc++-v3/include/bits/stl_list.h
index 409f1fc..0509164 100644
--- a/libstdc++-v3/include/bits/stl_list.h
+++ b/libstdc++-v3/include/bits/stl_list.h
@@ -1350,10 +1350,7 @@ _GLIBCXX_BEGIN_NAMESPACE_CXX11
        *  function.
        */
       void
-      swap(list& __x)
-#if __cplusplus >= 201103L
-      noexcept(_Node_alloc_traits::_S_nothrow_swap())
-#endif
+      swap(list& __x) _GLIBCXX_NOEXCEPT
       {
 	__detail::_List_node_base::swap(this->_M_impl._M_node,
 				        __x._M_impl._M_node);
@@ -1919,9 +1916,7 @@ _GLIBCXX_END_NAMESPACE_CXX11
   template<typename _Tp, typename _Alloc>
     inline void
     swap(list<_Tp, _Alloc>& __x, list<_Tp, _Alloc>& __y)
-#if __cplusplus >= 201103L
-    noexcept(noexcept(__x.swap(__y)))
-#endif
+    _GLIBCXX_NOEXCEPT_IF(noexcept(__x.swap(__y)))
     { __x.swap(__y); }
 
 _GLIBCXX_END_NAMESPACE_CONTAINER
diff --git a/libstdc++-v3/include/bits/stl_map.h b/libstdc++-v3/include/bits/stl_map.h
index d6ad16a..6e9fdcc 100644
--- a/libstdc++-v3/include/bits/stl_map.h
+++ b/libstdc++-v3/include/bits/stl_map.h
@@ -794,10 +794,7 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER
        */
       void
       swap(map& __x)
-#if __cplusplus >= 201103L
-      noexcept(_Alloc_traits::_S_nothrow_swap()
-	       && __is_nothrow_swappable<_Compare>::value)
-#endif
+      _GLIBCXX_NOEXCEPT_IF(__is_nothrow_swappable<_Compare>::value)
       { _M_t.swap(__x._M_t); }
 
       /**
@@ -1125,9 +1122,7 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER
     inline void
     swap(map<_Key, _Tp, _Compare, _Alloc>& __x,
 	 map<_Key, _Tp, _Compare, _Alloc>& __y)
-#if __cplusplus >= 201103L
-    noexcept(noexcept(__x.swap(__y)))
-#endif
+    _GLIBCXX_NOEXCEPT_IF(noexcept(__x.swap(__y)))
     { __x.swap(__y); }
 
 _GLIBCXX_END_NAMESPACE_CONTAINER
diff --git a/libstdc++-v3/include/bits/stl_multimap.h b/libstdc++-v3/include/bits/stl_multimap.h
index 725dea3..12ff6e6 100644
--- a/libstdc++-v3/include/bits/stl_multimap.h
+++ b/libstdc++-v3/include/bits/stl_multimap.h
@@ -704,10 +704,7 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER
        */
       void
       swap(multimap& __x)
-#if __cplusplus >= 201103L
-      noexcept(_Alloc_traits::_S_nothrow_swap()
-	       && __is_nothrow_swappable<_Compare>::value)
-#endif
+      _GLIBCXX_NOEXCEPT_IF(__is_nothrow_swappable<_Compare>::value)
       { _M_t.swap(__x._M_t); }
 
       /**
@@ -1026,9 +1023,7 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER
     inline void
     swap(multimap<_Key, _Tp, _Compare, _Alloc>& __x,
          multimap<_Key, _Tp, _Compare, _Alloc>& __y)
-#if __cplusplus >= 201103L
-    noexcept(noexcept(__x.swap(__y)))
-#endif
+    _GLIBCXX_NOEXCEPT_IF(noexcept(__x.swap(__y)))
     { __x.swap(__y); }
 
 _GLIBCXX_END_NAMESPACE_CONTAINER
diff --git a/libstdc++-v3/include/bits/stl_multiset.h b/libstdc++-v3/include/bits/stl_multiset.h
index 578b679..5ccc6dd 100644
--- a/libstdc++-v3/include/bits/stl_multiset.h
+++ b/libstdc++-v3/include/bits/stl_multiset.h
@@ -406,10 +406,7 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER
        */
       void
       swap(multiset& __x)
-#if __cplusplus >= 201103L
-      noexcept(_Alloc_traits::_S_nothrow_swap()
-	       && __is_nothrow_swappable<_Compare>::value)
-#endif
+      _GLIBCXX_NOEXCEPT_IF(__is_nothrow_swappable<_Compare>::value)
       { _M_t.swap(__x._M_t); }
 
       // insert/erase
@@ -875,9 +872,7 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER
     inline void
     swap(multiset<_Key, _Compare, _Alloc>& __x,
 	 multiset<_Key, _Compare, _Alloc>& __y)
-#if __cplusplus >= 201103L
-    noexcept(noexcept(__x.swap(__y)))
-#endif
+    _GLIBCXX_NOEXCEPT_IF(noexcept(__x.swap(__y)))
     { __x.swap(__y); }
 
 _GLIBCXX_END_NAMESPACE_CONTAINER
diff --git a/libstdc++-v3/include/bits/stl_set.h b/libstdc++-v3/include/bits/stl_set.h
index 21c7db9..cf74368 100644
--- a/libstdc++-v3/include/bits/stl_set.h
+++ b/libstdc++-v3/include/bits/stl_set.h
@@ -410,10 +410,7 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER
        */
       void
       swap(set& __x)
-#if __cplusplus >= 201103L
-      noexcept(_Alloc_traits::_S_nothrow_swap()
-	       && __is_nothrow_swappable<_Compare>::value)
-#endif
+      _GLIBCXX_NOEXCEPT_IF(__is_nothrow_swappable<_Compare>::value)
       { _M_t.swap(__x._M_t); }
 
       // insert/erase
@@ -891,9 +888,7 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER
   template<typename _Key, typename _Compare, typename _Alloc>
     inline void
     swap(set<_Key, _Compare, _Alloc>& __x, set<_Key, _Compare, _Alloc>& __y)
-#if __cplusplus >= 201103L
-    noexcept(noexcept(__x.swap(__y)))
-#endif
+    _GLIBCXX_NOEXCEPT_IF(noexcept(__x.swap(__y)))
     { __x.swap(__y); }
 
 _GLIBCXX_END_NAMESPACE_CONTAINER
diff --git a/libstdc++-v3/include/bits/stl_tree.h b/libstdc++-v3/include/bits/stl_tree.h
index 58c6b43..3030e1e 100644
--- a/libstdc++-v3/include/bits/stl_tree.h
+++ b/libstdc++-v3/include/bits/stl_tree.h
@@ -920,11 +920,8 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
       { return _Alloc_traits::max_size(_M_get_Node_allocator()); }
 
       void
-#if __cplusplus >= 201103L
-      swap(_Rb_tree& __t) noexcept(_Alloc_traits::_S_nothrow_swap());
-#else
-      swap(_Rb_tree& __t);
-#endif
+      swap(_Rb_tree& __t)
+      _GLIBCXX_NOEXCEPT_IF(__is_nothrow_swappable<_Compare>::value);
 
       // Insert/erase.
 #if __cplusplus >= 201103L
@@ -1747,10 +1744,8 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
            typename _Compare, typename _Alloc>
     void
     _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
-    swap(_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __t)
-#if __cplusplus >= 201103L
-    noexcept(_Alloc_traits::_S_nothrow_swap())
-#endif
+    swap(_Rb_tree& __t)
+    _GLIBCXX_NOEXCEPT_IF(__is_nothrow_swappable<_Compare>::value)
     {
       if (_M_root() == 0)
 	{
diff --git a/libstdc++-v3/include/bits/stl_vector.h b/libstdc++-v3/include/bits/stl_vector.h
index 1f3269b..8407a15 100644
--- a/libstdc++-v3/include/bits/stl_vector.h
+++ b/libstdc++-v3/include/bits/stl_vector.h
@@ -1190,10 +1190,7 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER
        *  std::swap(v1,v2) will feed to this function.
        */
       void
-      swap(vector& __x)
-#if __cplusplus >= 201103L
-      noexcept(_Alloc_traits::_S_nothrow_swap())
-#endif
+      swap(vector& __x) _GLIBCXX_NOEXCEPT
       {
 	this->_M_impl._M_swap_data(__x._M_impl);
 	_Alloc_traits::_S_on_swap(_M_get_Tp_allocator(),
@@ -1556,9 +1553,7 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER
   template<typename _Tp, typename _Alloc>
     inline void
     swap(vector<_Tp, _Alloc>& __x, vector<_Tp, _Alloc>& __y)
-#if __cplusplus >= 201103L
-    noexcept(noexcept(__x.swap(__y)))
-#endif
+    _GLIBCXX_NOEXCEPT_IF(noexcept(__x.swap(__y)))
     { __x.swap(__y); }
 
 _GLIBCXX_END_NAMESPACE_CONTAINER
diff --git a/libstdc++-v3/include/debug/deque b/libstdc++-v3/include/debug/deque
index 7d15e33..fe8b3ac 100644
--- a/libstdc++-v3/include/debug/deque
+++ b/libstdc++-v3/include/debug/deque
@@ -588,9 +588,7 @@ namespace __debug
 
       void
       swap(deque& __x)
-#if __cplusplus >= 201103L
-	noexcept( noexcept(declval<_Base>().swap(__x)) )
-#endif
+      _GLIBCXX_NOEXCEPT_IF( noexcept(declval<_Base&>().swap(__x)) )
       {
 	_Safe::_M_swap(__x);
 	_Base::swap(__x);
@@ -649,6 +647,7 @@ namespace __debug
   template<typename _Tp, typename _Alloc>
     inline void
     swap(deque<_Tp, _Alloc>& __lhs, deque<_Tp, _Alloc>& __rhs)
+    _GLIBCXX_NOEXCEPT_IF(noexcept(__lhs.swap(__rhs)))
     { __lhs.swap(__rhs); }
 
 } // namespace __debug
diff --git a/libstdc++-v3/include/debug/forward_list b/libstdc++-v3/include/debug/forward_list
index df35bc2..ad2d265 100644
--- a/libstdc++-v3/include/debug/forward_list
+++ b/libstdc++-v3/include/debug/forward_list
@@ -473,7 +473,7 @@ namespace __debug
 
       void
       swap(forward_list& __list)
-	noexcept( noexcept(declval<_Base>().swap(__list)) )
+	noexcept( noexcept(declval<_Base&>().swap(__list)) )
       {
 	_Safe::_M_swap(__list);
 	_Base::swap(__list);
@@ -814,8 +814,8 @@ namespace __debug
   /// See std::forward_list::swap().
   template<typename _Tp, typename _Alloc>
     inline void
-    swap(forward_list<_Tp, _Alloc>& __lx,
-	 forward_list<_Tp, _Alloc>& __ly)
+    swap(forward_list<_Tp, _Alloc>& __lx, forward_list<_Tp, _Alloc>& __ly)
+    noexcept(noexcept(__lx.swap(__ly)))
     { __lx.swap(__ly); }
 
 } // namespace __debug
diff --git a/libstdc++-v3/include/debug/list b/libstdc++-v3/include/debug/list
index 0f3f1a0..bd9f5a3 100644
--- a/libstdc++-v3/include/debug/list
+++ b/libstdc++-v3/include/debug/list
@@ -525,9 +525,7 @@ namespace __debug
 
       void
       swap(list& __x)
-#if __cplusplus >= 201103L
-	noexcept( noexcept(declval<_Base>().swap(__x)) )
-#endif
+      _GLIBCXX_NOEXCEPT_IF( noexcept(declval<_Base&>().swap(__x)) )
       {
 	_Safe::_M_swap(__x);
 	_Base::swap(__x);
@@ -808,6 +806,7 @@ namespace __debug
   template<typename _Tp, typename _Alloc>
     inline void
     swap(list<_Tp, _Alloc>& __lhs, list<_Tp, _Alloc>& __rhs)
+    _GLIBCXX_NOEXCEPT_IF(noexcept(__lhs.swap(__rhs)))
     { __lhs.swap(__rhs); }
 
 } // namespace __debug
diff --git a/libstdc++-v3/include/debug/map.h b/libstdc++-v3/include/debug/map.h
index 9bda8eb..d45cf79 100644
--- a/libstdc++-v3/include/debug/map.h
+++ b/libstdc++-v3/include/debug/map.h
@@ -393,9 +393,7 @@ namespace __debug
 
       void
       swap(map& __x)
-#if __cplusplus >= 201103L
-	noexcept( noexcept(declval<_Base>().swap(__x)) )
-#endif
+      _GLIBCXX_NOEXCEPT_IF( noexcept(declval<_Base&>().swap(__x)) )
       {
 	_Safe::_M_swap(__x);
 	_Base::swap(__x);
@@ -589,6 +587,7 @@ namespace __debug
     inline void
     swap(map<_Key, _Tp, _Compare, _Allocator>& __lhs,
 	 map<_Key, _Tp, _Compare, _Allocator>& __rhs)
+    _GLIBCXX_NOEXCEPT_IF(noexcept(__lhs.swap(__rhs)))
     { __lhs.swap(__rhs); }
 
 } // namespace __debug
diff --git a/libstdc++-v3/include/debug/multimap.h b/libstdc++-v3/include/debug/multimap.h
index b9b0a74..710cd46 100644
--- a/libstdc++-v3/include/debug/multimap.h
+++ b/libstdc++-v3/include/debug/multimap.h
@@ -374,9 +374,7 @@ namespace __debug
 
       void
       swap(multimap& __x)
-#if __cplusplus >= 201103L
-	noexcept( noexcept(declval<_Base>().swap(__x)) )
-#endif
+      _GLIBCXX_NOEXCEPT_IF( noexcept(declval<_Base&>().swap(__x)) )
       {
 	_Safe::_M_swap(__x);
 	_Base::swap(__x);
@@ -570,6 +568,7 @@ namespace __debug
     inline void
     swap(multimap<_Key, _Tp, _Compare, _Allocator>& __lhs,
 	 multimap<_Key, _Tp, _Compare, _Allocator>& __rhs)
+    _GLIBCXX_NOEXCEPT_IF(noexcept(__lhs.swap(__rhs)))
     { __lhs.swap(__rhs); }
 
 } // namespace __debug
diff --git a/libstdc++-v3/include/debug/multiset.h b/libstdc++-v3/include/debug/multiset.h
index f1f6e2c..94fa359 100644
--- a/libstdc++-v3/include/debug/multiset.h
+++ b/libstdc++-v3/include/debug/multiset.h
@@ -361,9 +361,7 @@ namespace __debug
 
       void
       swap(multiset& __x)
-#if __cplusplus >= 201103L
-	noexcept( noexcept(declval<_Base>().swap(__x)) )
-#endif
+      _GLIBCXX_NOEXCEPT_IF( noexcept(declval<_Base&>().swap(__x)) )
       {
 	_Safe::_M_swap(__x);
 	_Base::swap(__x);
@@ -550,6 +548,7 @@ namespace __debug
     void
     swap(multiset<_Key, _Compare, _Allocator>& __x,
 	 multiset<_Key, _Compare, _Allocator>& __y)
+    _GLIBCXX_NOEXCEPT_IF(noexcept(__x.swap(__y)))
     { return __x.swap(__y); }
 
 } // namespace __debug
diff --git a/libstdc++-v3/include/debug/set.h b/libstdc++-v3/include/debug/set.h
index 1ca6dda..ad2c76e 100644
--- a/libstdc++-v3/include/debug/set.h
+++ b/libstdc++-v3/include/debug/set.h
@@ -368,9 +368,7 @@ namespace __debug
 
       void
       swap(set& __x)
-#if __cplusplus >= 201103L
-	noexcept( noexcept(declval<_Base>().swap(__x)) )
-#endif
+      _GLIBCXX_NOEXCEPT_IF( noexcept(declval<_Base&>().swap(__x)) )
       {
 	_Safe::_M_swap(__x);
 	_Base::swap(__x);
@@ -557,6 +555,7 @@ namespace __debug
     void
     swap(set<_Key, _Compare, _Allocator>& __x,
 	 set<_Key, _Compare, _Allocator>& __y)
+    _GLIBCXX_NOEXCEPT_IF(noexcept(__x.swap(__y)))
     { return __x.swap(__y); }
 
 } // namespace __debug
diff --git a/libstdc++-v3/include/debug/unordered_map b/libstdc++-v3/include/debug/unordered_map
index 41e20d7..cc3bc3f 100644
--- a/libstdc++-v3/include/debug/unordered_map
+++ b/libstdc++-v3/include/debug/unordered_map
@@ -185,7 +185,7 @@ namespace __debug
 
       void
       swap(unordered_map& __x)
-	noexcept( noexcept(declval<_Base>().swap(__x)) )
+	noexcept( noexcept(declval<_Base&>().swap(__x)) )
       {
 	_Safe::_M_swap(__x);
 	_Base::swap(__x);
@@ -486,6 +486,7 @@ namespace __debug
     inline void
     swap(unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>& __x,
 	 unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>& __y)
+    noexcept(noexcept(__x.swap(__y)))
     { __x.swap(__y); }
 
   template<typename _Key, typename _Tp, typename _Hash,
@@ -641,7 +642,7 @@ namespace __debug
 
       void
       swap(unordered_multimap& __x)
-	noexcept( noexcept(declval<_Base>().swap(__x)) )
+	noexcept( noexcept(declval<_Base&>().swap(__x)) )
       {
 	_Safe::_M_swap(__x);
 	_Base::swap(__x);
@@ -938,6 +939,7 @@ namespace __debug
     inline void
     swap(unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>& __x,
 	 unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>& __y)
+    noexcept(noexcept(__x.swap(__y)))
     { __x.swap(__y); }
 
   template<typename _Key, typename _Tp, typename _Hash,
diff --git a/libstdc++-v3/include/debug/unordered_set b/libstdc++-v3/include/debug/unordered_set
index 1e68461..a45d3b5 100644
--- a/libstdc++-v3/include/debug/unordered_set
+++ b/libstdc++-v3/include/debug/unordered_set
@@ -182,7 +182,7 @@ namespace __debug
 
       void
       swap(unordered_set& __x)
-	noexcept( noexcept(declval<_Base>().swap(__x)) )
+	noexcept( noexcept(declval<_Base&>().swap(__x)) )
       {
 	_Safe::_M_swap(__x);
 	_Base::swap(__x);
@@ -480,6 +480,7 @@ namespace __debug
     inline void
     swap(unordered_set<_Value, _Hash, _Pred, _Alloc>& __x,
 	 unordered_set<_Value, _Hash, _Pred, _Alloc>& __y)
+    noexcept(noexcept(__x.swap(__y)))
     { __x.swap(__y); }
 
   template<typename _Value, typename _Hash, typename _Pred, typename _Alloc>
@@ -634,7 +635,7 @@ namespace __debug
 
       void
       swap(unordered_multiset& __x)
-	noexcept( noexcept(declval<_Base>().swap(__x)) )
+	noexcept( noexcept(declval<_Base&>().swap(__x)) )
       {
 	_Safe::_M_swap(__x);
 	_Base::swap(__x);
@@ -920,6 +921,7 @@ namespace __debug
     inline void
     swap(unordered_multiset<_Value, _Hash, _Pred, _Alloc>& __x,
 	 unordered_multiset<_Value, _Hash, _Pred, _Alloc>& __y)
+    noexcept(noexcept(__x.swap(__y)))
     { __x.swap(__y); }
 
   template<typename _Value, typename _Hash, typename _Pred, typename _Alloc>
diff --git a/libstdc++-v3/include/debug/vector b/libstdc++-v3/include/debug/vector
index 3100097..fede4f0 100644
--- a/libstdc++-v3/include/debug/vector
+++ b/libstdc++-v3/include/debug/vector
@@ -674,9 +674,7 @@ namespace __debug
 
       void
       swap(vector& __x)
-#if __cplusplus >= 201103L
-	noexcept( noexcept(declval<_Base>().swap(__x)) )
-#endif
+      _GLIBCXX_NOEXCEPT_IF( noexcept(declval<_Base&>().swap(__x)) )
       {
 	_Safe::_M_swap(__x);
 	_Base::swap(__x);
@@ -744,6 +742,7 @@ namespace __debug
   template<typename _Tp, typename _Alloc>
     inline void
     swap(vector<_Tp, _Alloc>& __lhs, vector<_Tp, _Alloc>& __rhs)
+    _GLIBCXX_NOEXCEPT_IF(noexcept(__lhs.swap(__rhs)))
     { __lhs.swap(__rhs); }
 
 } // namespace __debug
diff --git a/libstdc++-v3/include/ext/alloc_traits.h b/libstdc++-v3/include/ext/alloc_traits.h
index 5da32c5..4d322fb 100644
--- a/libstdc++-v3/include/ext/alloc_traits.h
+++ b/libstdc++-v3/include/ext/alloc_traits.h
@@ -112,12 +112,6 @@ template<typename _Alloc>
     static constexpr bool _S_nothrow_move()
     { return _S_propagate_on_move_assign() || _S_always_equal(); }
 
-    static constexpr bool _S_nothrow_swap()
-    {
-      return !_S_propagate_on_swap()
-	|| std::__is_nothrow_swappable<_Alloc>::value;
-    }
-
     template<typename _Tp>
       struct rebind
       { typedef typename _Base_type::template rebind_alloc<_Tp> other; };
diff --git a/libstdc++-v3/include/profile/deque b/libstdc++-v3/include/profile/deque
index c0c6db2..724bc43 100644
--- a/libstdc++-v3/include/profile/deque
+++ b/libstdc++-v3/include/profile/deque
@@ -130,9 +130,7 @@ namespace __profile
 
       void
       swap(deque& __x)
-#if __cplusplus >= 201103L
-	noexcept( noexcept(declval<_Base>().swap(__x)) )
-#endif
+      _GLIBCXX_NOEXCEPT_IF( noexcept(declval<_Base&>().swap(__x)) )
       { _Base::swap(__x); }
 
       _Base&
@@ -181,6 +179,7 @@ namespace __profile
   template<typename _Tp, typename _Alloc>
     inline void
     swap(deque<_Tp, _Alloc>& __lhs, deque<_Tp, _Alloc>& __rhs)
+    _GLIBCXX_NOEXCEPT_IF(noexcept(__lhs.swap(__rhs)))
     { __lhs.swap(__rhs); }
 
 } // namespace __profile
diff --git a/libstdc++-v3/include/profile/forward_list b/libstdc++-v3/include/profile/forward_list
index ab7ed04..081b202 100644
--- a/libstdc++-v3/include/profile/forward_list
+++ b/libstdc++-v3/include/profile/forward_list
@@ -108,7 +108,7 @@ namespace __profile
 
       void
       swap(forward_list& __fl)
-	noexcept( noexcept(declval<_Base>().swap(__fl)) )
+	noexcept( noexcept(declval<_Base&>().swap(__fl)) )
       { _Base::swap(__fl); }
 
       void
@@ -208,6 +208,7 @@ namespace __profile
     inline void
     swap(forward_list<_Tp, _Alloc>& __lx,
 	 forward_list<_Tp, _Alloc>& __ly)
+    noexcept(noexcept(__lx.swap(__ly)))
     { __lx.swap(__ly); }
 
 } // namespace __profile
diff --git a/libstdc++-v3/include/profile/list b/libstdc++-v3/include/profile/list
index b5943ee..edc321e 100644
--- a/libstdc++-v3/include/profile/list
+++ b/libstdc++-v3/include/profile/list
@@ -411,9 +411,7 @@ namespace __profile
 
       void
       swap(list& __x)
-#if __cplusplus >= 201103L
-	noexcept( noexcept(declval<_Base>().swap(__x)) )
-#endif
+      _GLIBCXX_NOEXCEPT_IF( noexcept(declval<_Base&>().swap(__x)) )
       {
 	_Base::swap(__x);
 	this->_M_swap(__x);
@@ -643,6 +641,7 @@ namespace __profile
   template<typename _Tp, typename _Alloc>
     inline void
     swap(list<_Tp, _Alloc>& __lhs, list<_Tp, _Alloc>& __rhs)
+    _GLIBCXX_NOEXCEPT_IF(noexcept(__lhs.swap(__rhs)))
     { __lhs.swap(__rhs); }
 
 } // namespace __profile
diff --git a/libstdc++-v3/include/profile/map.h b/libstdc++-v3/include/profile/map.h
index 210b9b4..8a19592 100644
--- a/libstdc++-v3/include/profile/map.h
+++ b/libstdc++-v3/include/profile/map.h
@@ -405,9 +405,7 @@ namespace __profile
 
       void
       swap(map& __x)
-#if __cplusplus >= 201103L
-	noexcept( noexcept(declval<_Base>().swap(__x)) )
-#endif
+      _GLIBCXX_NOEXCEPT_IF( noexcept(declval<_Base&>().swap(__x)) )
       {
 	_Base::swap(__x);
 	this->_M_swap(__x);
@@ -698,6 +696,7 @@ namespace __profile
     inline void
     swap(map<_Key, _Tp, _Compare, _Allocator>& __lhs,
 	 map<_Key, _Tp, _Compare, _Allocator>& __rhs)
+    _GLIBCXX_NOEXCEPT_IF(noexcept(__lhs.swap(__rhs)))
     { __lhs.swap(__rhs); }
 
 } // namespace __profile
diff --git a/libstdc++-v3/include/profile/multimap.h b/libstdc++-v3/include/profile/multimap.h
index 4ec77d7..1055e9e 100644
--- a/libstdc++-v3/include/profile/multimap.h
+++ b/libstdc++-v3/include/profile/multimap.h
@@ -364,9 +364,7 @@ namespace __profile
 
       void
       swap(multimap& __x)
-#if __cplusplus >= 201103L
-	noexcept( noexcept(declval<_Base>().swap(__x)) )
-#endif
+      _GLIBCXX_NOEXCEPT_IF( noexcept(declval<_Base&>().swap(__x)) )
       {
 	std::swap(this->_M_map2umap_info, __x._M_map2umap_info);
 	_Base::swap(__x);
@@ -656,6 +654,7 @@ namespace __profile
     inline void
     swap(multimap<_Key, _Tp, _Compare, _Allocator>& __lhs,
 	 multimap<_Key, _Tp, _Compare, _Allocator>& __rhs)
+    _GLIBCXX_NOEXCEPT_IF(noexcept(__lhs.swap(__rhs)))
     { __lhs.swap(__rhs); }
 
 } // namespace __profile
diff --git a/libstdc++-v3/include/profile/multiset.h b/libstdc++-v3/include/profile/multiset.h
index b304e5c..55090e3 100644
--- a/libstdc++-v3/include/profile/multiset.h
+++ b/libstdc++-v3/include/profile/multiset.h
@@ -226,9 +226,7 @@ namespace __profile
 
       void
       swap(multiset& __x)
-#if __cplusplus >= 201103L
-	noexcept( noexcept(declval<_Base>().swap(__x)) )
-#endif
+      _GLIBCXX_NOEXCEPT_IF( noexcept(declval<_Base&>().swap(__x)) )
       {
 	_Base::swap(__x);
 	this->_M_swap(__x);
@@ -640,6 +638,7 @@ namespace __profile
     void
     swap(multiset<_Key, _Compare, _Allocator>& __x,
 	 multiset<_Key, _Compare, _Allocator>& __y)
+    _GLIBCXX_NOEXCEPT_IF(noexcept(__x.swap(__y)))
     { return __x.swap(__y); }
 
 } // namespace __profile
diff --git a/libstdc++-v3/include/profile/set.h b/libstdc++-v3/include/profile/set.h
index 3717fde..24d2ed5 100644
--- a/libstdc++-v3/include/profile/set.h
+++ b/libstdc++-v3/include/profile/set.h
@@ -223,9 +223,7 @@ namespace __profile
 
       void
       swap(set& __x)
-#if __cplusplus >= 201103L
-	noexcept( noexcept(declval<_Base>().swap(__x)) )
-#endif
+      _GLIBCXX_NOEXCEPT_IF( noexcept(declval<_Base&>().swap(__x)) )
       {
 	_Base::swap(__x);
 	this->_M_swap(__x);
@@ -621,6 +619,7 @@ namespace __profile
     void
     swap(set<_Key, _Compare, _Allocator>& __x,
 	 set<_Key, _Compare, _Allocator>& __y)
+    _GLIBCXX_NOEXCEPT_IF(noexcept(__x.swap(__y)))
     { return __x.swap(__y); }
 
 } // namespace __profile
diff --git a/libstdc++-v3/include/profile/unordered_map b/libstdc++-v3/include/profile/unordered_map
index 480faba..619486e 100644
--- a/libstdc++-v3/include/profile/unordered_map
+++ b/libstdc++-v3/include/profile/unordered_map
@@ -299,6 +299,7 @@ namespace __profile
     inline void
     swap(unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>& __x,
 	 unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>& __y)
+    noexcept(noexcept(__x.swap(__y)))
     { __x.swap(__y); }
 
   template<typename _Key, typename _Tp, typename _Hash,
@@ -557,6 +558,7 @@ namespace __profile
     inline void
     swap(unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>& __x,
 	 unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>& __y)
+    noexcept(noexcept(__x.swap(__y)))
     { __x.swap(__y); }
 
   template<typename _Key, typename _Tp, typename _Hash,
diff --git a/libstdc++-v3/include/profile/unordered_set b/libstdc++-v3/include/profile/unordered_set
index 15950b9..4c2a7ff 100644
--- a/libstdc++-v3/include/profile/unordered_set
+++ b/libstdc++-v3/include/profile/unordered_set
@@ -279,6 +279,7 @@ namespace __profile
     inline void
     swap(unordered_set<_Key, _Hash, _Pred, _Alloc>& __x,
 	 unordered_set<_Key, _Hash, _Pred, _Alloc>& __y)
+    noexcept(noexcept(__x.swap(__y)))
     { __x.swap(__y); }
 
   template<typename _Key, typename _Hash, typename _Pred, typename _Alloc>
@@ -534,6 +535,7 @@ namespace __profile
     inline void
     swap(unordered_multiset<_Value, _Hash, _Pred, _Alloc>& __x,
 	 unordered_multiset<_Value, _Hash, _Pred, _Alloc>& __y)
+    noexcept(noexcept(__x.swap(__y)))
     { __x.swap(__y); }
 
   template<typename _Value, typename _Hash, typename _Pred, typename _Alloc>
diff --git a/libstdc++-v3/include/profile/vector b/libstdc++-v3/include/profile/vector
index fdc73ef..dc015f2 100644
--- a/libstdc++-v3/include/profile/vector
+++ b/libstdc++-v3/include/profile/vector
@@ -547,20 +547,9 @@ namespace __profile
   template<typename _Tp, typename _Alloc>
     inline void
     swap(vector<_Tp, _Alloc>& __lhs, vector<_Tp, _Alloc>& __rhs)
+    _GLIBCXX_NOEXCEPT_IF(noexcept(__lhs.swap(__rhs)))
     { __lhs.swap(__rhs); }
 
-#if __cplusplus >= 201103L
-  template<typename _Tp, typename _Alloc>
-    inline void
-    swap(vector<_Tp, _Alloc>&& __lhs, vector<_Tp, _Alloc>& __rhs)
-    { __lhs.swap(__rhs); }
-
-  template<typename _Tp, typename _Alloc>
-    inline void
-    swap(vector<_Tp, _Alloc>& __lhs, vector<_Tp, _Alloc>&& __rhs)
-    { __lhs.swap(__rhs); }
-#endif
-
 } // namespace __profile
 
 #if __cplusplus >= 201103L
diff --git a/libstdc++-v3/testsuite/23_containers/deque/allocator/noexcept.cc b/libstdc++-v3/testsuite/23_containers/deque/allocator/noexcept.cc
index bf4b7de..c6f8266 100644
--- a/libstdc++-v3/testsuite/23_containers/deque/allocator/noexcept.cc
+++ b/libstdc++-v3/testsuite/23_containers/deque/allocator/noexcept.cc
@@ -23,15 +23,6 @@
 
 struct T { int i; };
 
-namespace __gnu_test
-{
-  template<typename U>
-    inline void
-    swap(propagating_allocator<U, true>& l, propagating_allocator<U, true>& r)
-    noexcept(false)
-    { }
-}
-
 using __gnu_test::propagating_allocator;
 
 void test01()
@@ -62,6 +53,5 @@ void test03()
   test_type v1(alloc_type(1));
   test_type v2(alloc_type(2));
   // static_assert( noexcept( v1 = std::move(v2) ), "Move assign cannot throw" );
-  // noexcept spec of deque::swap depends on swap overload at top of this file
-  static_assert( !noexcept( v1.swap(v2) ), "Swap can throw" );
+  static_assert( noexcept( v1.swap(v2) ), "Swap cannot throw" );
 }
diff --git a/libstdc++-v3/testsuite/23_containers/forward_list/allocator/noexcept.cc b/libstdc++-v3/testsuite/23_containers/forward_list/allocator/noexcept.cc
index 9b096c9..51af42d 100644
--- a/libstdc++-v3/testsuite/23_containers/forward_list/allocator/noexcept.cc
+++ b/libstdc++-v3/testsuite/23_containers/forward_list/allocator/noexcept.cc
@@ -23,15 +23,6 @@
 
 struct T { int i; };
 
-namespace __gnu_test
-{
-  template<typename U>
-    inline void
-    swap(propagating_allocator<U, true>& l, propagating_allocator<U, true>& r)
-    noexcept(false)
-    { }
-}
-
 using __gnu_test::propagating_allocator;
 
 void test01()
@@ -62,5 +53,5 @@ void test03()
   test_type v1(alloc_type(1));
   test_type v2(alloc_type(2));
   static_assert( noexcept( v1 = std::move(v2) ), "Move assign cannot throw" );
-  static_assert( !noexcept( v1.swap(v2) ), "Swap can throw" );
+  static_assert( noexcept( v1.swap(v2) ), "Swap cannot throw" );
 }
diff --git a/libstdc++-v3/testsuite/23_containers/list/allocator/noexcept.cc b/libstdc++-v3/testsuite/23_containers/list/allocator/noexcept.cc
index 4a84fce..bc80d37 100644
--- a/libstdc++-v3/testsuite/23_containers/list/allocator/noexcept.cc
+++ b/libstdc++-v3/testsuite/23_containers/list/allocator/noexcept.cc
@@ -23,15 +23,6 @@
 
 struct T { int i; };
 
-namespace __gnu_test
-{
-  template<typename U>
-    inline void
-    swap(propagating_allocator<U, true>& l, propagating_allocator<U, true>& r)
-    noexcept(false)
-    { }
-}
-
 using __gnu_test::propagating_allocator;
 
 void test01()
@@ -62,5 +53,5 @@ void test03()
   test_type v1(alloc_type(1));
   test_type v2(alloc_type(2));
   static_assert( noexcept( v1 = std::move(v2) ), "Move assign cannot throw" );
-  static_assert( !noexcept( v1.swap(v2) ), "Swap can throw" );
+  static_assert( noexcept( v1.swap(v2) ), "Swap cannot throw" );
 }
diff --git a/libstdc++-v3/testsuite/23_containers/map/allocator/noexcept.cc b/libstdc++-v3/testsuite/23_containers/map/allocator/noexcept.cc
index 44119cc..47a8a14 100644
--- a/libstdc++-v3/testsuite/23_containers/map/allocator/noexcept.cc
+++ b/libstdc++-v3/testsuite/23_containers/map/allocator/noexcept.cc
@@ -27,16 +27,10 @@ bool operator<(T l, T r) { return l.i < r.i; }
 
 using Cmp = std::less<T>;
 
-struct U { };
+struct CmpThrow : Cmp { };
+void swap(CmpThrow&, CmpThrow&) noexcept(false) { }
 
-namespace __gnu_test
-{
-  template<typename U>
-    inline void
-    swap(propagating_allocator<U, true>& l, propagating_allocator<U, true>& r)
-    noexcept(false)
-    { }
-}
+struct U { };
 
 using __gnu_test::propagating_allocator;
 
@@ -53,6 +47,16 @@ void test01()
 
 void test02()
 {
+  typedef std::allocator<std::pair<const T, U>> alloc_type;
+  typedef std::map<T, U, CmpThrow, alloc_type> test_type;
+  test_type v1;
+  test_type v2;
+  static_assert( noexcept( v1 = std::move(v2) ), "Move assign cannot throw" );
+  static_assert( !noexcept( v1.swap(v2) ), "Swap can throw" );
+}
+
+void test03()
+{
   typedef propagating_allocator<std::pair<const T, U>, false> alloc_type;
   typedef std::map<T, U, Cmp, alloc_type> test_type;
   test_type v1(alloc_type(1));
@@ -61,12 +65,12 @@ void test02()
   static_assert( noexcept( v1.swap(v2) ), "Swap cannot throw" );
 }
 
-void test03()
+void test04()
 {
   typedef propagating_allocator<std::pair<const T, U>, true> alloc_type;
   typedef std::map<T, U, Cmp, alloc_type> test_type;
   test_type v1(alloc_type(1));
   test_type v2(alloc_type(2));
   static_assert( noexcept( v1 = std::move(v2) ), "Move assign cannot throw" );
-  static_assert( !noexcept( v1.swap(v2) ), "Swap can throw" );
+  static_assert( noexcept( v1.swap(v2) ), "Swap cannot throw" );
 }
diff --git a/libstdc++-v3/testsuite/23_containers/multimap/allocator/noexcept.cc b/libstdc++-v3/testsuite/23_containers/multimap/allocator/noexcept.cc
index eb1c27b..2f27fd7 100644
--- a/libstdc++-v3/testsuite/23_containers/multimap/allocator/noexcept.cc
+++ b/libstdc++-v3/testsuite/23_containers/multimap/allocator/noexcept.cc
@@ -27,16 +27,10 @@ bool operator<(T l, T r) { return l.i < r.i; }
 
 using Cmp = std::less<T>;
 
-struct U { };
+struct CmpThrow : Cmp { };
+void swap(CmpThrow&, CmpThrow&) noexcept(false) { }
 
-namespace __gnu_test
-{
-  template<typename U>
-    inline void
-    swap(propagating_allocator<U, true>& l, propagating_allocator<U, true>& r)
-    noexcept(false)
-    { }
-}
+struct U { };
 
 using __gnu_test::propagating_allocator;
 
@@ -53,20 +47,20 @@ void test01()
 
 void test02()
 {
-  typedef propagating_allocator<std::pair<const T, U>, false> alloc_type;
-  typedef std::multimap<T, U, Cmp, alloc_type> test_type;
-  test_type v1(alloc_type(1));
-  test_type v2(alloc_type(2));
-  static_assert( !noexcept( v1 = std::move(v2) ), "Move assign can throw" );
-  static_assert( noexcept( v1.swap(v2) ), "Swap cannot throw" );
+  typedef std::allocator<std::pair<const T, U>> alloc_type;
+  typedef std::multimap<T, U, CmpThrow, alloc_type> test_type;
+  test_type v1;
+  test_type v2;
+  static_assert( noexcept( v1 = std::move(v2) ), "Move assign cannot throw" );
+  static_assert( !noexcept( v1.swap(v2) ), "Swap can throw" );
 }
 
 void test03()
 {
-  typedef propagating_allocator<std::pair<const T, U>, true> alloc_type;
+  typedef propagating_allocator<std::pair<const T, U>, false> alloc_type;
   typedef std::multimap<T, U, Cmp, alloc_type> test_type;
   test_type v1(alloc_type(1));
   test_type v2(alloc_type(2));
-  static_assert( noexcept( v1 = std::move(v2) ), "Move assign cannot throw" );
-  static_assert( !noexcept( v1.swap(v2) ), "Swap can throw" );
+  static_assert( !noexcept( v1 = std::move(v2) ), "Move assign can throw" );
+  static_assert( noexcept( v1.swap(v2) ), "Swap cannot throw" );
 }
diff --git a/libstdc++-v3/testsuite/23_containers/multiset/allocator/noexcept.cc b/libstdc++-v3/testsuite/23_containers/multiset/allocator/noexcept.cc
index 5d50601..665a8d2 100644
--- a/libstdc++-v3/testsuite/23_containers/multiset/allocator/noexcept.cc
+++ b/libstdc++-v3/testsuite/23_containers/multiset/allocator/noexcept.cc
@@ -28,14 +28,8 @@ bool operator<(T l, T r) { return l.i < r.i; }
 
 using Cmp = std::less<T>;
 
-namespace __gnu_test
-{
-  template<typename U>
-    inline void
-    swap(propagating_allocator<U, true>& l, propagating_allocator<U, true>& r)
-    noexcept(false)
-    { }
-}
+struct CmpThrow : Cmp { };
+void swap(CmpThrow&, CmpThrow&) noexcept(false) { }
 
 using __gnu_test::propagating_allocator;
 
@@ -52,6 +46,16 @@ void test01()
 
 void test02()
 {
+  typedef std::allocator<T> alloc_type;
+  typedef std::multiset<T, CmpThrow, alloc_type> test_type;
+  test_type v1;
+  test_type v2;
+  static_assert( noexcept( v1 = std::move(v2) ), "Move assign cannot throw" );
+  static_assert( !noexcept( v1.swap(v2) ), "Swap can throw" );
+}
+
+void test03()
+{
   typedef propagating_allocator<T, false> alloc_type;
   typedef std::multiset<T, Cmp, alloc_type> test_type;
   test_type v1(alloc_type(1));
@@ -60,12 +64,12 @@ void test02()
   static_assert( noexcept( v1.swap(v2) ), "Swap cannot throw" );
 }
 
-void test03()
+void test04()
 {
   typedef propagating_allocator<T, true> alloc_type;
   typedef std::multiset<T, Cmp, alloc_type> test_type;
   test_type v1(alloc_type(1));
   test_type v2(alloc_type(2));
   static_assert( noexcept( v1 = std::move(v2) ), "Move assign cannot throw" );
-  static_assert( !noexcept( v1.swap(v2) ), "Swap can throw" );
+  static_assert( noexcept( v1.swap(v2) ), "Swap cannot throw" );
 }
diff --git a/libstdc++-v3/testsuite/23_containers/set/allocator/noexcept.cc b/libstdc++-v3/testsuite/23_containers/set/allocator/noexcept.cc
index 2645edd..3252645 100644
--- a/libstdc++-v3/testsuite/23_containers/set/allocator/noexcept.cc
+++ b/libstdc++-v3/testsuite/23_containers/set/allocator/noexcept.cc
@@ -27,14 +27,8 @@ bool operator<(T l, T r) { return l.i < r.i; }
 
 using Cmp = std::less<T>;
 
-namespace __gnu_test
-{
-  template<typename U>
-    inline void
-    swap(propagating_allocator<U, true>& l, propagating_allocator<U, true>& r)
-    noexcept(false)
-    { }
-}
+struct CmpThrow : Cmp { };
+void swap(CmpThrow&, CmpThrow&) noexcept(false) { }
 
 using __gnu_test::propagating_allocator;
 
@@ -51,6 +45,16 @@ void test01()
 
 void test02()
 {
+  typedef std::allocator<T> alloc_type;
+  typedef std::set<T, CmpThrow, alloc_type> test_type;
+  test_type v1;
+  test_type v2;
+  static_assert( noexcept( v1 = std::move(v2) ), "Move assign cannot throw" );
+  static_assert( !noexcept( v1.swap(v2) ), "Swap can throw" );
+}
+
+void test03()
+{
   typedef propagating_allocator<T, false> alloc_type;
   typedef std::set<T, Cmp, alloc_type> test_type;
   test_type v1(alloc_type(1));
@@ -59,12 +63,12 @@ void test02()
   static_assert( noexcept( v1.swap(v2) ), "Swap cannot throw" );
 }
 
-void test03()
+void test04()
 {
   typedef propagating_allocator<T, true> alloc_type;
   typedef std::set<T, Cmp, alloc_type> test_type;
   test_type v1(alloc_type(1));
   test_type v2(alloc_type(2));
   static_assert( noexcept( v1 = std::move(v2) ), "Move assign cannot throw" );
-  static_assert( !noexcept( v1.swap(v2) ), "Swap can throw" );
+  static_assert( noexcept( v1.swap(v2) ), "Swap cannot throw" );
 }
diff --git a/libstdc++-v3/testsuite/23_containers/unordered_map/allocator/noexcept.cc b/libstdc++-v3/testsuite/23_containers/unordered_map/allocator/noexcept.cc
index 621e02e..dca473d 100644
--- a/libstdc++-v3/testsuite/23_containers/unordered_map/allocator/noexcept.cc
+++ b/libstdc++-v3/testsuite/23_containers/unordered_map/allocator/noexcept.cc
@@ -35,14 +35,11 @@ struct equal_to
   { return lhs.i == rhs.i; }
 };
 
-namespace __gnu_test
-{
-  template<typename U>
-    inline void
-    swap(propagating_allocator<U, true>& l, propagating_allocator<U, true>& r)
-    noexcept(false)
-    { }
-}
+// Versions of the function objects without nothrow swap.
+struct hash_t : hash { };
+void swap(hash_t&, hash_t&) noexcept(false) { }
+struct equal_to_t : equal_to { };
+void swap(equal_to_t&, equal_to_t&) noexcept(false) { }
 
 using __gnu_test::propagating_allocator;
 
@@ -59,6 +56,26 @@ void test01()
 
 void test02()
 {
+  typedef std::allocator<T> alloc_type;
+  typedef std::unordered_map<T, T, hash_t, equal_to, alloc_type> test_type;
+  test_type v1;
+  test_type v2;
+  static_assert( noexcept( v1 = std::move(v2) ), "Move assign cannot throw" );
+  static_assert( !noexcept( v1.swap(v2) ), "Swap can throw" );
+}
+
+void test03()
+{
+  typedef std::allocator<T> alloc_type;
+  typedef std::unordered_map<T, T, hash, equal_to_t, alloc_type> test_type;
+  test_type v1;
+  test_type v2;
+  static_assert( noexcept( v1 = std::move(v2) ), "Move assign cannot throw" );
+  static_assert( !noexcept( v1.swap(v2) ), "Swap can throw" );
+}
+
+void test04()
+{
   typedef propagating_allocator<T, false> alloc_type;
   typedef std::unordered_map<T, T, hash, equal_to, alloc_type> test_type;
   test_type v1(alloc_type(1));
@@ -67,19 +84,19 @@ void test02()
   static_assert( noexcept( v1.swap(v2) ), "Swap cannot throw" );
 }
 
-void test03()
+void test05()
 {
   typedef propagating_allocator<T, true> alloc_type;
   typedef std::unordered_map<T, T, hash, equal_to, alloc_type> test_type;
   test_type v1(alloc_type(1));
   test_type v2(alloc_type(2));
   static_assert( noexcept( v1 = std::move(v2) ), "Move assign cannot throw" );
-  static_assert( !noexcept( v1.swap(v2) ), "Swap can throw" );
+  static_assert( noexcept( v1.swap(v2) ), "Swap cannot throw" );
 }
 
-void test04()
+void test06()
 {
   typedef std::unordered_map<int, int> test_type;
-  static_assert( noexcept( test_type() ), "Default constructor do not throw" );
-  static_assert( noexcept( test_type(test_type()) ), "Move constructor do not throw" );
+  static_assert( noexcept( test_type() ), "Default constructor does not throw" );
+  static_assert( noexcept( test_type(test_type()) ), "Move constructor does not throw" );
 }
diff --git a/libstdc++-v3/testsuite/23_containers/unordered_multimap/allocator/noexcept.cc b/libstdc++-v3/testsuite/23_containers/unordered_multimap/allocator/noexcept.cc
index a3b3c81..3c67d23 100644
--- a/libstdc++-v3/testsuite/23_containers/unordered_multimap/allocator/noexcept.cc
+++ b/libstdc++-v3/testsuite/23_containers/unordered_multimap/allocator/noexcept.cc
@@ -35,14 +35,11 @@ struct equal_to
   { return lhs.i == rhs.i; }
 };
 
-namespace __gnu_test
-{
-  template<typename U>
-    inline void
-    swap(propagating_allocator<U, true>& l, propagating_allocator<U, true>& r)
-    noexcept(false)
-    { }
-}
+// Versions of the function objects without nothrow swap.
+struct hash_t : hash { };
+void swap(hash_t&, hash_t&) noexcept(false) { }
+struct equal_to_t : equal_to { };
+void swap(equal_to_t&, equal_to_t&) noexcept(false) { }
 
 using __gnu_test::propagating_allocator;
 
@@ -59,6 +56,27 @@ void test01()
 
 void test02()
 {
+  typedef std::allocator<T> alloc_type;
+  typedef std::unordered_multimap<T, T, hash_t, equal_to, alloc_type> test_type;
+  test_type v1;
+  test_type v2;
+  static_assert( noexcept( v1 = std::move(v2) ), "Move assign cannot throw" );
+  static_assert( !noexcept( v1.swap(v2) ), "Swap can throw" );
+}
+
+void test03()
+{
+  typedef std::allocator<T> alloc_type;
+  typedef std::unordered_multimap<T, T, hash, equal_to_t, alloc_type>
+    test_type;
+  test_type v1;
+  test_type v2;
+  static_assert( noexcept( v1 = std::move(v2) ), "Move assign cannot throw" );
+  static_assert( !noexcept( v1.swap(v2) ), "Swap can throw" );
+}
+
+void test04()
+{
   typedef propagating_allocator<T, false> alloc_type;
   typedef std::unordered_multimap<T, T, hash, equal_to, alloc_type> test_type;
   test_type v1(alloc_type(1));
@@ -67,19 +85,19 @@ void test02()
   static_assert( noexcept( v1.swap(v2) ), "Swap cannot throw" );
 }
 
-void test03()
+void test05()
 {
   typedef propagating_allocator<T, true> alloc_type;
   typedef std::unordered_multimap<T, T, hash, equal_to, alloc_type> test_type;
   test_type v1(alloc_type(1));
   test_type v2(alloc_type(2));
   static_assert( noexcept( v1 = std::move(v2) ), "Move assign cannot throw" );
-  static_assert( !noexcept( v1.swap(v2) ), "Swap can throw" );
+  static_assert( noexcept( v1.swap(v2) ), "Swap cannot throw" );
 }
 
-void test04()
+void test06()
 {
   typedef std::unordered_multimap<int, int> test_type;
-  static_assert( noexcept( test_type() ), "Default constructor do not throw" );
-  static_assert( noexcept( test_type(test_type()) ), "Move constructor do not throw" );
+  static_assert( noexcept( test_type() ), "Default constructor does not throw" );
+  static_assert( noexcept( test_type(test_type()) ), "Move constructor does not throw" );
 }
diff --git a/libstdc++-v3/testsuite/23_containers/unordered_multiset/allocator/noexcept.cc b/libstdc++-v3/testsuite/23_containers/unordered_multiset/allocator/noexcept.cc
index 1152ab9..37c3eb1 100644
--- a/libstdc++-v3/testsuite/23_containers/unordered_multiset/allocator/noexcept.cc
+++ b/libstdc++-v3/testsuite/23_containers/unordered_multiset/allocator/noexcept.cc
@@ -35,14 +35,11 @@ struct equal_to
   { return lhs.i == rhs.i; }
 };
 
-namespace __gnu_test
-{
-  template<typename U>
-    inline void
-    swap(propagating_allocator<U, true>& l, propagating_allocator<U, true>& r)
-    noexcept(false)
-    { }
-}
+// Versions of the function objects without nothrow swap.
+struct hash_t : hash { };
+void swap(hash_t&, hash_t&) noexcept(false) { }
+struct equal_to_t : equal_to { };
+void swap(equal_to_t&, equal_to_t&) noexcept(false) { }
 
 using __gnu_test::propagating_allocator;
 
@@ -59,6 +56,26 @@ void test01()
 
 void test02()
 {
+  typedef std::allocator<T> alloc_type;
+  typedef std::unordered_multiset<T, hash_t, equal_to, alloc_type> test_type;
+  test_type v1;
+  test_type v2;
+  static_assert( noexcept( v1 = std::move(v2) ), "Move assign cannot throw" );
+  static_assert( !noexcept( v1.swap(v2) ), "Swap can throw" );
+}
+
+void test03()
+{
+  typedef std::allocator<T> alloc_type;
+  typedef std::unordered_multiset<T, hash, equal_to_t, alloc_type> test_type;
+  test_type v1;
+  test_type v2;
+  static_assert( noexcept( v1 = std::move(v2) ), "Move assign cannot throw" );
+  static_assert( !noexcept( v1.swap(v2) ), "Swap can throw" );
+}
+
+void test04()
+{
   typedef propagating_allocator<T, false> alloc_type;
   typedef std::unordered_multiset<T, hash, equal_to, alloc_type> test_type;
   test_type v1(alloc_type(1));
@@ -67,19 +84,19 @@ void test02()
   static_assert( noexcept( v1.swap(v2) ), "Swap cannot throw" );
 }
 
-void test03()
+void test05()
 {
   typedef propagating_allocator<T, true> alloc_type;
   typedef std::unordered_multiset<T, hash, equal_to, alloc_type> test_type;
   test_type v1(alloc_type(1));
   test_type v2(alloc_type(2));
   static_assert( noexcept( v1 = std::move(v2) ), "Move assign cannot throw" );
-  static_assert( !noexcept( v1.swap(v2) ), "Swap can throw" );
+  static_assert( noexcept( v1.swap(v2) ), "Swap cannot throw" );
 }
 
-void test04()
+void test06()
 {
   typedef std::unordered_multiset<int> test_type;
-  static_assert( noexcept( test_type() ), "Default constructor do not throw" );
-  static_assert( noexcept( test_type(test_type()) ), "Move constructor do not throw" );
+  static_assert( noexcept( test_type() ), "Default constructor does not throw" );
+  static_assert( noexcept( test_type(test_type()) ), "Move constructor does not throw" );
 }
diff --git a/libstdc++-v3/testsuite/23_containers/unordered_set/allocator/noexcept.cc b/libstdc++-v3/testsuite/23_containers/unordered_set/allocator/noexcept.cc
index b9f5d52..a844c35 100644
--- a/libstdc++-v3/testsuite/23_containers/unordered_set/allocator/noexcept.cc
+++ b/libstdc++-v3/testsuite/23_containers/unordered_set/allocator/noexcept.cc
@@ -35,14 +35,11 @@ struct equal_to
   { return lhs.i == rhs.i; }
 };
 
-namespace __gnu_test
-{
-  template<typename U>
-    inline void
-    swap(propagating_allocator<U, true>& l, propagating_allocator<U, true>& r)
-    noexcept(false)
-    { }
-}
+// Versions of the function objects without nothrow swap.
+struct hash_t : hash { };
+void swap(hash_t&, hash_t&) noexcept(false) { }
+struct equal_to_t : equal_to { };
+void swap(equal_to_t&, equal_to_t&) noexcept(false) { }
 
 using __gnu_test::propagating_allocator;
 
@@ -59,6 +56,26 @@ void test01()
 
 void test02()
 {
+  typedef std::allocator<T> alloc_type;
+  typedef std::unordered_set<T, hash_t, equal_to, alloc_type> test_type;
+  test_type v1;
+  test_type v2;
+  static_assert( noexcept( v1 = std::move(v2) ), "Move assign cannot throw" );
+  static_assert( !noexcept( v1.swap(v2) ), "Swap can throw" );
+}
+
+void test03()
+{
+  typedef std::allocator<T> alloc_type;
+  typedef std::unordered_set<T, hash, equal_to_t, alloc_type> test_type;
+  test_type v1;
+  test_type v2;
+  static_assert( noexcept( v1 = std::move(v2) ), "Move assign cannot throw" );
+  static_assert( !noexcept( v1.swap(v2) ), "Swap can throw" );
+}
+
+void test04()
+{
   typedef propagating_allocator<T, false> alloc_type;
   typedef std::unordered_set<T, hash, equal_to, alloc_type> test_type;
   test_type v1(alloc_type(1));
@@ -67,19 +84,19 @@ void test02()
   static_assert( noexcept( v1.swap(v2) ), "Swap cannot throw" );
 }
 
-void test03()
+void test05()
 {
   typedef propagating_allocator<T, true> alloc_type;
   typedef std::unordered_set<T, hash, equal_to, alloc_type> test_type;
   test_type v1(alloc_type(1));
   test_type v2(alloc_type(2));
   static_assert( noexcept( v1 = std::move(v2) ), "Move assign cannot throw" );
-  static_assert( !noexcept( v1.swap(v2) ), "Swap can throw" );
+  static_assert( noexcept( v1.swap(v2) ), "Swap cannot throw" );
 }
 
-void test04()
+void test06()
 {
   typedef std::unordered_set<int> test_type;
-  static_assert( noexcept( test_type() ), "Default constructor do not throw" );
-  static_assert( noexcept( test_type(test_type()) ), "Move constructor do not throw" );
+  static_assert( noexcept( test_type() ), "Default constructor does not throw" );
+  static_assert( noexcept( test_type(test_type()) ), "Move constructor does not throw" );
 }
diff --git a/libstdc++-v3/testsuite/23_containers/vector/allocator/noexcept.cc b/libstdc++-v3/testsuite/23_containers/vector/allocator/noexcept.cc
index 38f69d6..0cb1205 100644
--- a/libstdc++-v3/testsuite/23_containers/vector/allocator/noexcept.cc
+++ b/libstdc++-v3/testsuite/23_containers/vector/allocator/noexcept.cc
@@ -23,15 +23,6 @@
  
 struct T { int i; };
 
-namespace __gnu_test
-{
-  template<typename U>
-    inline void
-    swap(propagating_allocator<U, true>& l, propagating_allocator<U, true>& r)
-    noexcept(false)
-    { }
-}
-
 using __gnu_test::propagating_allocator;
 
 void test01()
@@ -62,5 +53,5 @@ void test03()
   test_type v1(alloc_type(1));
   test_type v2(alloc_type(2));
   static_assert( noexcept( v1 = std::move(v2) ), "Move assign cannot throw" );
-  static_assert( !noexcept( v1.swap(v2) ), "Swap can throw" );
+  static_assert( noexcept( v1.swap(v2) ), "Swap cannot throw" );
 }
diff --git a/libstdc++-v3/testsuite/23_containers/vector/bool/allocator/noexcept.cc b/libstdc++-v3/testsuite/23_containers/vector/bool/allocator/noexcept.cc
index 250362d..1e2b954 100644
--- a/libstdc++-v3/testsuite/23_containers/vector/bool/allocator/noexcept.cc
+++ b/libstdc++-v3/testsuite/23_containers/vector/bool/allocator/noexcept.cc
@@ -23,15 +23,6 @@
 
 using T = bool;
 
-namespace __gnu_test
-{
-  template<typename U>
-    inline void
-    swap(propagating_allocator<U, true>& l, propagating_allocator<U, true>& r)
-    noexcept(false)
-    { }
-}
-
 using __gnu_test::propagating_allocator;
 
 void test01()
@@ -62,5 +53,5 @@ void test03()
   test_type v1(alloc_type(1));
   test_type v2(alloc_type(2));
   static_assert( noexcept( v1 = std::move(v2) ), "Move assign cannot throw" );
-  static_assert( !noexcept( v1.swap(v2) ), "Swap can throw" );
+  static_assert( noexcept( v1.swap(v2) ), "Swap cannot throw" );
 }
diff --git a/libstdc++-v3/testsuite/ext/profile/mutex_extensions_neg.cc b/libstdc++-v3/testsuite/ext/profile/mutex_extensions_neg.cc
index 78365e7..8ed54ea 100644
--- a/libstdc++-v3/testsuite/ext/profile/mutex_extensions_neg.cc
+++ b/libstdc++-v3/testsuite/ext/profile/mutex_extensions_neg.cc
@@ -25,7 +25,7 @@
 
 #include <vector>
 
-// { dg-error "multiple inlined namespaces" "" { target *-*-* } 322 }
+// { dg-error "multiple inlined namespaces" "" { target *-*-* } 324 }
 
 // "template argument 1 is invalid"
 // { dg-prune-output "tuple:993" }

Index Nav: [Date Index] [Subject Index] [Author Index] [Thread Index]
Message Nav: [Date Prev] [Date Next] [Thread Prev] [Thread Next]