public inbox for libstdc++-cvs@sourceware.org
help / color / mirror / Atom feed
* [gcc r9-9328] libstdc++: Fix unordered containers move constructors noexcept qualification
@ 2021-04-08 23:37 Jonathan Wakely
0 siblings, 0 replies; only message in thread
From: Jonathan Wakely @ 2021-04-08 23:37 UTC (permalink / raw)
To: gcc-cvs, libstdc++-cvs
https://gcc.gnu.org/g:5f63261c3e54995b45dd411ad76526870c4b8be3
commit r9-9328-g5f63261c3e54995b45dd411ad76526870c4b8be3
Author: François Dumont <fdumont@gcc.gnu.org>
Date: Mon Jan 20 19:15:43 2020 +0100
libstdc++: Fix unordered containers move constructors noexcept qualification
_Hashtable move constructor is wrongly qualified as noexcept(true) regardless of
_Equal and _H1 copy constructor qualifications.
_Hashtable allocator-aware move constructor is missing its noexcept
qualification like the depending unordered containers ones.
This backport also includes the changes from r11-8062 and r11-2438.
libstdc++-v3/ChangeLog:
PR libstdc++/96029
* include/bits/hashtable.h
(_Hashtable(_Hashtable&& __ht, __node_alloc_type&& __a, true_type)):
Add noexcept qualification.
(_Hashtable(_Hashtable&&)): Fix noexcept qualification.
(_Hashtable(_Hashtable&&, const allocator_type&)): Add noexcept
qualification.
* include/bits/unordered_map.h
(unordered_map(unordered_map&&, const allocator_type&)): Add noexcept
qualification.
(unordered_multimap(unordered_multimap&&, const allocator_type&)):
Likewise.
* include/bits/unordered_set.h
(unordered_set(unordered_set&&, const allocator_type&)): Likewise.
(unordered_multiset(unordered_multiset&&, const allocator_type&)):
Likewise.
* include/debug/unordered_map
(unordered_map(unordered_map&&, const allocator_type&)): Likewise.
(unordered_multimap(unordered_multimap&&, const allocator_type&)):
Likewise.
* include/debug/unordered_set
(unordered_set(unordered_set&&, const allocator_type&)): Likewise.
(unordered_multiset(unordered_multiset&&, const allocator_type&)):
Likewise.
* testsuite/23_containers/unordered_map/allocator/default_init.cc:
New test.
* testsuite/23_containers/unordered_map/cons/noexcept_default_construct.cc:
New test.
* testsuite/23_containers/unordered_map/cons/noexcept_move_construct.cc:
New test.
* testsuite/23_containers/unordered_map/modifiers/move_assign.cc:
New test.
* testsuite/23_containers/unordered_multimap/cons/noexcept_default_construct.cc:
New test.
* testsuite/23_containers/unordered_multimap/cons/noexcept_move_construct.cc:
New test.
* testsuite/23_containers/unordered_multiset/cons/noexcept_default_construct.cc:
New test.
* testsuite/23_containers/unordered_multiset/cons/noexcept_move_construct.cc:
New test.
* testsuite/23_containers/unordered_set/allocator/default_init.cc:
New test.
* testsuite/23_containers/unordered_set/cons/noexcept_default_construct.cc:
New test.
* testsuite/23_containers/unordered_set/cons/noexcept_move_construct.cc:
New test.
(cherry picked from commit 12324b9a934654a5c3bf4a614853ded2e0a958af)
Diff:
---
libstdc++-v3/include/bits/hashtable.h | 44 ++++++++++--
libstdc++-v3/include/bits/unordered_map.h | 2 +
libstdc++-v3/include/bits/unordered_set.h | 2 +
libstdc++-v3/include/debug/unordered_map | 18 ++---
libstdc++-v3/include/debug/unordered_set | 26 +++----
.../unordered_map/allocator/default_init.cc | 69 ++++++++++++++++++
.../cons/noexcept_default_construct.cc | 68 ++++++++++++++++++
.../unordered_map/cons/noexcept_move_construct.cc | 65 +++++++++++++++++
.../unordered_map/modifiers/move_assign.cc | 81 ++++++++++++++++++++++
.../cons/noexcept_default_construct.cc | 68 ++++++++++++++++++
.../cons/noexcept_move_construct.cc | 65 +++++++++++++++++
.../cons/noexcept_default_construct.cc | 68 ++++++++++++++++++
.../cons/noexcept_move_construct.cc | 65 +++++++++++++++++
.../unordered_set/allocator/default_init.cc | 69 ++++++++++++++++++
.../cons/noexcept_default_construct.cc | 68 ++++++++++++++++++
.../unordered_set/cons/noexcept_move_construct.cc | 65 +++++++++++++++++
16 files changed, 816 insertions(+), 27 deletions(-)
diff --git a/libstdc++-v3/include/bits/hashtable.h b/libstdc++-v3/include/bits/hashtable.h
index d7d9e9940e3..76f9c7ff0d8 100644
--- a/libstdc++-v3/include/bits/hashtable.h
+++ b/libstdc++-v3/include/bits/hashtable.h
@@ -409,6 +409,24 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
__hashtable_alloc(__node_alloc_type(__a))
{ }
+ template<bool _No_realloc = true>
+ static constexpr bool
+ _S_nothrow_move()
+ {
+ if _GLIBCXX17_CONSTEXPR (_No_realloc)
+ if _GLIBCXX17_CONSTEXPR (is_nothrow_copy_constructible<_H1>())
+ return is_nothrow_copy_constructible<_Equal>();
+ return false;
+ }
+
+ _Hashtable(_Hashtable&& __ht, __node_alloc_type&& __a,
+ true_type /* alloc always equal */)
+ noexcept(_S_nothrow_move());
+
+ _Hashtable(_Hashtable&&, __node_alloc_type&&,
+ false_type /* alloc always equal */);
+
+
public:
// Constructor, destructor, assignment, swap
_Hashtable() = default;
@@ -426,11 +444,19 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
_Hashtable(const _Hashtable&);
- _Hashtable(_Hashtable&&) noexcept;
+ _Hashtable(_Hashtable&& __ht)
+ noexcept(_S_nothrow_move())
+ : _Hashtable(std::move(__ht), std::move(__ht._M_node_allocator()),
+ true_type{})
+ { }
_Hashtable(const _Hashtable&, const allocator_type&);
- _Hashtable(_Hashtable&&, const allocator_type&);
+ _Hashtable(_Hashtable&& __ht, const allocator_type& __a)
+ noexcept(_S_nothrow_move<__node_alloc_traits::_S_always_equal()>())
+ : _Hashtable(std::move(__ht), __node_alloc_type(__a),
+ typename __node_alloc_traits::is_always_equal{})
+ { }
// Use delegating constructors.
explicit
@@ -1249,18 +1275,21 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
typename _Traits>
_Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
_H1, _H2, _Hash, _RehashPolicy, _Traits>::
- _Hashtable(_Hashtable&& __ht) noexcept
+ _Hashtable(_Hashtable&& __ht, __node_alloc_type&& __a,
+ true_type /* alloc always equal */)
+ noexcept(std::is_nothrow_copy_constructible<_H1>::value &&
+ std::is_nothrow_copy_constructible<_Equal>::value)
: __hashtable_base(__ht),
__map_base(__ht),
__rehash_base(__ht),
- __hashtable_alloc(std::move(__ht._M_base_alloc())),
+ __hashtable_alloc(std::move(__a)),
_M_buckets(__ht._M_buckets),
_M_bucket_count(__ht._M_bucket_count),
_M_before_begin(__ht._M_before_begin._M_nxt),
_M_element_count(__ht._M_element_count),
_M_rehash_policy(__ht._M_rehash_policy)
{
- // Update, if necessary, buckets if __ht is using its single bucket.
+ // Update buckets if __ht is using its single bucket.
if (__ht._M_uses_single_bucket())
{
_M_buckets = &_M_single_bucket;
@@ -1302,11 +1331,12 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
typename _Traits>
_Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
_H1, _H2, _Hash, _RehashPolicy, _Traits>::
- _Hashtable(_Hashtable&& __ht, const allocator_type& __a)
+ _Hashtable(_Hashtable&& __ht, __node_alloc_type&& __a,
+ false_type /* alloc always equal */)
: __hashtable_base(__ht),
__map_base(__ht),
__rehash_base(__ht),
- __hashtable_alloc(__node_alloc_type(__a)),
+ __hashtable_alloc(std::move(__a)),
_M_buckets(nullptr),
_M_bucket_count(__ht._M_bucket_count),
_M_element_count(__ht._M_element_count),
diff --git a/libstdc++-v3/include/bits/unordered_map.h b/libstdc++-v3/include/bits/unordered_map.h
index 9959c39d083..a71ed327e2e 100644
--- a/libstdc++-v3/include/bits/unordered_map.h
+++ b/libstdc++-v3/include/bits/unordered_map.h
@@ -209,6 +209,7 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER
*/
unordered_map(unordered_map&& __umap,
const allocator_type& __a)
+ noexcept( noexcept(_Hashtable(std::move(__umap._M_h), __a)) )
: _M_h(std::move(__umap._M_h), __a)
{ }
@@ -1356,6 +1357,7 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER
*/
unordered_multimap(unordered_multimap&& __ummap,
const allocator_type& __a)
+ noexcept( noexcept(_Hashtable(std::move(__ummap._M_h), __a)) )
: _M_h(std::move(__ummap._M_h), __a)
{ }
diff --git a/libstdc++-v3/include/bits/unordered_set.h b/libstdc++-v3/include/bits/unordered_set.h
index 8ebcaf40263..34707df524e 100644
--- a/libstdc++-v3/include/bits/unordered_set.h
+++ b/libstdc++-v3/include/bits/unordered_set.h
@@ -203,6 +203,7 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER
*/
unordered_set(unordered_set&& __uset,
const allocator_type& __a)
+ noexcept( noexcept(_Hashtable(std::move(__uset._M_h), __a)) )
: _M_h(std::move(__uset._M_h), __a)
{ }
@@ -1044,6 +1045,7 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER
*/
unordered_multiset(unordered_multiset&& __umset,
const allocator_type& __a)
+ noexcept( noexcept(_Hashtable(std::move(__umset._M_h), __a)) )
: _M_h(std::move(__umset._M_h), __a)
{ }
diff --git a/libstdc++-v3/include/debug/unordered_map b/libstdc++-v3/include/debug/unordered_map
index d844ee9fa0e..b4531a3b1e9 100644
--- a/libstdc++-v3/include/debug/unordered_map
+++ b/libstdc++-v3/include/debug/unordered_map
@@ -136,6 +136,7 @@ namespace __debug
unordered_map(unordered_map&& __umap,
const allocator_type& __a)
+ noexcept( noexcept(_Base(std::move(__umap._M_base()), __a)) )
: _Safe(std::move(__umap._M_safe()), __a),
_Base(std::move(__umap._M_base()), __a) { }
@@ -160,7 +161,7 @@ namespace __debug
unordered_map(_InputIterator __first, _InputIterator __last,
size_type __n,
const allocator_type& __a)
- : unordered_map(__first, __last, __n, hasher(), key_equal(), __a)
+ : unordered_map(__first, __last, __n, hasher(), key_equal(), __a)
{ }
template<typename _InputIterator>
@@ -168,20 +169,20 @@ namespace __debug
size_type __n,
const hasher& __hf,
const allocator_type& __a)
- : unordered_map(__first, __last, __n, __hf, key_equal(), __a)
+ : unordered_map(__first, __last, __n, __hf, key_equal(), __a)
{ }
unordered_map(initializer_list<value_type> __l,
size_type __n,
const allocator_type& __a)
- : unordered_map(__l, __n, hasher(), key_equal(), __a)
+ : unordered_map(__l, __n, hasher(), key_equal(), __a)
{ }
unordered_map(initializer_list<value_type> __l,
size_type __n,
const hasher& __hf,
const allocator_type& __a)
- : unordered_map(__l, __n, __hf, key_equal(), __a)
+ : unordered_map(__l, __n, __hf, key_equal(), __a)
{ }
~unordered_map() = default;
@@ -830,6 +831,7 @@ namespace __debug
unordered_multimap(unordered_multimap&& __umap,
const allocator_type& __a)
+ noexcept( noexcept(_Base(std::move(__umap._M_base()), __a)) )
: _Safe(std::move(__umap._M_safe()), __a),
_Base(std::move(__umap._M_base()), __a) { }
@@ -853,26 +855,26 @@ namespace __debug
unordered_multimap(_InputIterator __first, _InputIterator __last,
size_type __n,
const allocator_type& __a)
- : unordered_multimap(__first, __last, __n, hasher(), key_equal(), __a)
+ : unordered_multimap(__first, __last, __n, hasher(), key_equal(), __a)
{ }
template<typename _InputIterator>
unordered_multimap(_InputIterator __first, _InputIterator __last,
size_type __n, const hasher& __hf,
const allocator_type& __a)
- : unordered_multimap(__first, __last, __n, __hf, key_equal(), __a)
+ : unordered_multimap(__first, __last, __n, __hf, key_equal(), __a)
{ }
unordered_multimap(initializer_list<value_type> __l,
size_type __n,
const allocator_type& __a)
- : unordered_multimap(__l, __n, hasher(), key_equal(), __a)
+ : unordered_multimap(__l, __n, hasher(), key_equal(), __a)
{ }
unordered_multimap(initializer_list<value_type> __l,
size_type __n, const hasher& __hf,
const allocator_type& __a)
- : unordered_multimap(__l, __n, __hf, key_equal(), __a)
+ : unordered_multimap(__l, __n, __hf, key_equal(), __a)
{ }
~unordered_multimap() = default;
diff --git a/libstdc++-v3/include/debug/unordered_set b/libstdc++-v3/include/debug/unordered_set
index ecc084e3846..17ae5909ef5 100644
--- a/libstdc++-v3/include/debug/unordered_set
+++ b/libstdc++-v3/include/debug/unordered_set
@@ -133,6 +133,7 @@ namespace __debug
unordered_set(unordered_set&& __uset,
const allocator_type& __a)
+ noexcept( noexcept(_Base(std::move(__uset._M_base()), __a)) )
: _Safe(std::move(__uset._M_safe()), __a),
_Base(std::move(__uset._M_base()), __a) { }
@@ -144,38 +145,38 @@ namespace __debug
: _Base(__l, __n, __hf, __eql, __a) { }
unordered_set(size_type __n, const allocator_type& __a)
- : unordered_set(__n, hasher(), key_equal(), __a)
+ : unordered_set(__n, hasher(), key_equal(), __a)
{ }
unordered_set(size_type __n, const hasher& __hf,
const allocator_type& __a)
- : unordered_set(__n, __hf, key_equal(), __a)
+ : unordered_set(__n, __hf, key_equal(), __a)
{ }
template<typename _InputIterator>
unordered_set(_InputIterator __first, _InputIterator __last,
size_type __n,
const allocator_type& __a)
- : unordered_set(__first, __last, __n, hasher(), key_equal(), __a)
+ : unordered_set(__first, __last, __n, hasher(), key_equal(), __a)
{ }
template<typename _InputIterator>
unordered_set(_InputIterator __first, _InputIterator __last,
size_type __n, const hasher& __hf,
const allocator_type& __a)
- : unordered_set(__first, __last, __n, __hf, key_equal(), __a)
+ : unordered_set(__first, __last, __n, __hf, key_equal(), __a)
{ }
unordered_set(initializer_list<value_type> __l,
size_type __n,
const allocator_type& __a)
- : unordered_set(__l, __n, hasher(), key_equal(), __a)
+ : unordered_set(__l, __n, hasher(), key_equal(), __a)
{ }
unordered_set(initializer_list<value_type> __l,
size_type __n, const hasher& __hf,
const allocator_type& __a)
- : unordered_set(__l, __n, __hf, key_equal(), __a)
+ : unordered_set(__l, __n, __hf, key_equal(), __a)
{ }
~unordered_set() = default;
@@ -700,6 +701,7 @@ namespace __debug
unordered_multiset(unordered_multiset&& __uset,
const allocator_type& __a)
+ noexcept( noexcept(_Base(std::move(__uset._M_base()), __a)) )
: _Safe(std::move(__uset._M_safe()), __a),
_Base(std::move(__uset._M_base()), __a) { }
@@ -711,38 +713,38 @@ namespace __debug
: _Base(__l, __n, __hf, __eql, __a) { }
unordered_multiset(size_type __n, const allocator_type& __a)
- : unordered_multiset(__n, hasher(), key_equal(), __a)
+ : unordered_multiset(__n, hasher(), key_equal(), __a)
{ }
unordered_multiset(size_type __n, const hasher& __hf,
const allocator_type& __a)
- : unordered_multiset(__n, __hf, key_equal(), __a)
+ : unordered_multiset(__n, __hf, key_equal(), __a)
{ }
template<typename _InputIterator>
unordered_multiset(_InputIterator __first, _InputIterator __last,
size_type __n,
const allocator_type& __a)
- : unordered_multiset(__first, __last, __n, hasher(), key_equal(), __a)
+ : unordered_multiset(__first, __last, __n, hasher(), key_equal(), __a)
{ }
template<typename _InputIterator>
unordered_multiset(_InputIterator __first, _InputIterator __last,
size_type __n, const hasher& __hf,
const allocator_type& __a)
- : unordered_multiset(__first, __last, __n, __hf, key_equal(), __a)
+ : unordered_multiset(__first, __last, __n, __hf, key_equal(), __a)
{ }
unordered_multiset(initializer_list<value_type> __l,
size_type __n,
const allocator_type& __a)
- : unordered_multiset(__l, __n, hasher(), key_equal(), __a)
+ : unordered_multiset(__l, __n, hasher(), key_equal(), __a)
{ }
unordered_multiset(initializer_list<value_type> __l,
size_type __n, const hasher& __hf,
const allocator_type& __a)
- : unordered_multiset(__l, __n, __hf, key_equal(), __a)
+ : unordered_multiset(__l, __n, __hf, key_equal(), __a)
{ }
~unordered_multiset() = default;
diff --git a/libstdc++-v3/testsuite/23_containers/unordered_map/allocator/default_init.cc b/libstdc++-v3/testsuite/23_containers/unordered_map/allocator/default_init.cc
new file mode 100644
index 00000000000..473a5f1ce47
--- /dev/null
+++ b/libstdc++-v3/testsuite/23_containers/unordered_map/allocator/default_init.cc
@@ -0,0 +1,69 @@
+// Copyright (C) 2020 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/>.
+
+// { dg-do run { target c++11 } }
+// { dg-options "-O0" }
+// { dg-xfail-run-if "PR c++/65816" { *-*-* } }
+
+#include <unordered_map>
+#include <testsuite_hooks.h>
+#include <testsuite_allocator.h>
+
+#include <ext/aligned_buffer.h>
+
+using T = int;
+
+using __gnu_test::default_init_allocator;
+
+void test01()
+{
+ typedef default_init_allocator<std::pair<const T, T>> alloc_type;
+ typedef std::unordered_map<T, T, std::hash<T>, std::equal_to<T>,
+ alloc_type> test_type;
+
+ __gnu_cxx::__aligned_buffer<test_type> buf;
+ __builtin_memset(buf._M_addr(), ~0, sizeof(test_type));
+
+ test_type *tmp = ::new(buf._M_addr()) test_type;
+
+ VERIFY( tmp->get_allocator().state == 0 );
+
+ tmp->~test_type();
+}
+
+void test02()
+{
+ typedef default_init_allocator<std::pair<const T, T>> alloc_type;
+ typedef std::unordered_map<T, T, std::hash<T>, std::equal_to<T>,
+ alloc_type> test_type;
+
+ __gnu_cxx::__aligned_buffer<test_type> buf;
+ __builtin_memset(buf._M_addr(), ~0, sizeof(test_type));
+
+ test_type *tmp = ::new(buf._M_addr()) test_type();
+
+ VERIFY( tmp->get_allocator().state == 0 );
+
+ tmp->~test_type();
+}
+
+int main()
+{
+ test01();
+ test02();
+ return 0;
+}
diff --git a/libstdc++-v3/testsuite/23_containers/unordered_map/cons/noexcept_default_construct.cc b/libstdc++-v3/testsuite/23_containers/unordered_map/cons/noexcept_default_construct.cc
new file mode 100644
index 00000000000..f859ec939d0
--- /dev/null
+++ b/libstdc++-v3/testsuite/23_containers/unordered_map/cons/noexcept_default_construct.cc
@@ -0,0 +1,68 @@
+// Copyright (C) 2020 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/>.
+
+// { dg-do compile { target c++11 } }
+
+#include <unordered_map>
+
+using type1 = std::unordered_map<int, int>;
+
+static_assert(std::is_nothrow_default_constructible<type1>::value,
+ "noexcept default constructible");
+
+struct not_noexcept_dflt_cons_hash
+{
+ not_noexcept_dflt_cons_hash() /* noexcept */;
+
+ std::size_t
+ operator()(int) const noexcept;
+};
+
+using type2 = std::unordered_map<int, int, not_noexcept_dflt_cons_hash>;
+
+static_assert( !std::is_nothrow_default_constructible<type2>::value,
+ "not noexcept default constructible");
+
+struct not_noexcept_dflt_cons_equal_to
+{
+ not_noexcept_dflt_cons_equal_to() /* noexcept */;
+
+ bool
+ operator()(int, int) const noexcept;
+};
+
+using type3 = std::unordered_map<int, int, std::hash<int>,
+ not_noexcept_dflt_cons_equal_to>;
+
+static_assert( !std::is_nothrow_default_constructible<type3>::value,
+ "not noexcept default constructible");
+
+template<typename _Tp>
+ struct not_noexcept_dflt_cons_alloc : std::allocator<_Tp>
+ {
+ not_noexcept_dflt_cons_alloc() /* noexcept */;
+
+ template<typename _Tp1>
+ struct rebind
+ { typedef not_noexcept_dflt_cons_alloc<_Tp1> other; };
+ };
+
+using type4 = std::unordered_map<int, int, std::hash<int>, std::equal_to<int>,
+ not_noexcept_dflt_cons_alloc<std::pair<const int, int>>>;
+
+static_assert(!std::is_nothrow_default_constructible<type4>::value,
+ "not noexcept default constructible");
diff --git a/libstdc++-v3/testsuite/23_containers/unordered_map/cons/noexcept_move_construct.cc b/libstdc++-v3/testsuite/23_containers/unordered_map/cons/noexcept_move_construct.cc
new file mode 100644
index 00000000000..b6b5b473553
--- /dev/null
+++ b/libstdc++-v3/testsuite/23_containers/unordered_map/cons/noexcept_move_construct.cc
@@ -0,0 +1,65 @@
+// { dg-do compile { target c++11 } }
+
+// Copyright (C) 2020 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 <unordered_map>
+
+using type1 = std::unordered_map<int, int>;
+
+static_assert( std::is_nothrow_move_constructible<type1>::value,
+ "noexcept move constructor" );
+static_assert( std::is_nothrow_constructible<type1,
+ type1&&, const typename type1::allocator_type&>::value,
+ "noexcept move constructor with allocator" );
+
+struct not_noexcept_copy_cons_hash
+{
+ not_noexcept_copy_cons_hash() noexcept;
+ not_noexcept_copy_cons_hash(const not_noexcept_copy_cons_hash&) /* noexcept */;
+ not_noexcept_copy_cons_hash(not_noexcept_copy_cons_hash&&) noexcept;
+
+ std::size_t
+ operator()(int) const noexcept;
+};
+
+using type2 = std::unordered_map<int, int, not_noexcept_copy_cons_hash>;
+
+static_assert( !std::is_nothrow_move_constructible<type2>::value,
+ "not noexcept move constructor" );
+static_assert( !std::is_nothrow_constructible<type2, type2&&,
+ const typename type2::allocator_type&>::value,
+ "not noexcept move constructor with allocator" );
+
+struct not_noexcept_copy_cons_equal_to
+{
+ not_noexcept_copy_cons_equal_to() noexcept;
+ not_noexcept_copy_cons_equal_to(const not_noexcept_copy_cons_equal_to&) /* noexcept */;
+ not_noexcept_copy_cons_equal_to(not_noexcept_copy_cons_equal_to&&) noexcept;
+
+ bool
+ operator()(int, int) const noexcept;
+};
+
+using type3 = std::unordered_map<int, int, std::hash<int>,
+ not_noexcept_copy_cons_equal_to>;
+
+static_assert( !std::is_nothrow_move_constructible<type3>::value,
+ "not noexcept move constructor" );
+static_assert( !std::is_nothrow_constructible<type3, type3&&,
+ const typename type3::allocator_type&>::value,
+ "not noexcept move constructor with allocator" );
diff --git a/libstdc++-v3/testsuite/23_containers/unordered_map/modifiers/move_assign.cc b/libstdc++-v3/testsuite/23_containers/unordered_map/modifiers/move_assign.cc
new file mode 100644
index 00000000000..0a5ef1113d9
--- /dev/null
+++ b/libstdc++-v3/testsuite/23_containers/unordered_map/modifiers/move_assign.cc
@@ -0,0 +1,81 @@
+// { dg-do compile { target c++11 } }
+
+// Copyright (C) 2020 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 <utility>
+#include <unordered_map>
+#include <vector>
+
+#include <testsuite_hooks.h>
+#include <testsuite_counter_type.h>
+#include <testsuite_allocator.h>
+
+void test01()
+{
+ using namespace std;
+ using __gnu_test::counter_type;
+
+ std::vector<pair<int, counter_type>> insts { { 0, 0 }, { 1, 1 }, { 2, 2 } };
+ typedef unordered_map<int, counter_type> Map;
+ Map m;
+
+ counter_type::reset();
+
+ m.insert(make_move_iterator(insts.begin()), make_move_iterator(insts.end()));
+
+ VERIFY( m.size() == 3 );
+ VERIFY( counter_type::default_count == 0 );
+ VERIFY( counter_type::copy_count == 0 );
+ VERIFY( counter_type::move_count == 3 );
+}
+
+void test02()
+{
+ using namespace std;
+ using __gnu_test::counter_type;
+ using __gnu_test::propagating_allocator;
+
+ typedef propagating_allocator<pair<const int, counter_type>, false> Alloc;
+ typedef unordered_map<int, counter_type,
+ hash<int>, equal_to<int>,
+ Alloc> Map;
+
+ Alloc a1(1);
+ Map m1(3, a1);
+ m1 = { { 0, 0 }, { 1, 1 }, { 2, 2 } };
+ Alloc a2(2);
+ Map m2(3, a2);
+ m2 = { { 3, 0 }, { 4, 1 }, { 5, 2 } };
+
+ counter_type::reset();
+
+ m2 = move(m1);
+
+ VERIFY( m1.empty() );
+ VERIFY( m2.size() == 3 );
+ VERIFY( counter_type::default_count == 0 );
+ VERIFY( counter_type::copy_count == 0 );
+ VERIFY( counter_type::move_count == 3 );
+}
+
+int main()
+{
+ test01();
+ test02();
+ return 0;
+}
diff --git a/libstdc++-v3/testsuite/23_containers/unordered_multimap/cons/noexcept_default_construct.cc b/libstdc++-v3/testsuite/23_containers/unordered_multimap/cons/noexcept_default_construct.cc
new file mode 100644
index 00000000000..98e2b017ca9
--- /dev/null
+++ b/libstdc++-v3/testsuite/23_containers/unordered_multimap/cons/noexcept_default_construct.cc
@@ -0,0 +1,68 @@
+// Copyright (C) 2020 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/>.
+
+// { dg-do compile { target c++11 } }
+
+#include <unordered_map>
+
+using type1 = std::unordered_multimap<int, int>;
+
+static_assert(std::is_nothrow_default_constructible<type1>::value,
+ "noexcept default constructible");
+
+struct not_noexcept_dflt_cons_hash
+{
+ not_noexcept_dflt_cons_hash() /* noexcept */;
+
+ std::size_t
+ operator()(int) const noexcept;
+};
+
+using type2 = std::unordered_multimap<int, int, not_noexcept_dflt_cons_hash>;
+
+static_assert( !std::is_nothrow_default_constructible<type2>::value,
+ "not noexcept default constructible");
+
+struct not_noexcept_dflt_cons_equal_to
+{
+ not_noexcept_dflt_cons_equal_to() /* noexcept */;
+
+ bool
+ operator()(int, int) const noexcept;
+};
+
+using type3 = std::unordered_multimap<int, int, std::hash<int>,
+ not_noexcept_dflt_cons_equal_to>;
+
+static_assert( !std::is_nothrow_default_constructible<type3>::value,
+ "not noexcept default constructible");
+
+template<typename _Tp>
+ struct not_noexcept_dflt_cons_alloc : std::allocator<_Tp>
+ {
+ not_noexcept_dflt_cons_alloc() /* noexcept */;
+
+ template<typename _Tp1>
+ struct rebind
+ { typedef not_noexcept_dflt_cons_alloc<_Tp1> other; };
+ };
+
+using type4 = std::unordered_multimap<int, int, std::hash<int>, std::equal_to<int>,
+ not_noexcept_dflt_cons_alloc<std::pair<const int, int>>>;
+
+static_assert(!std::is_nothrow_default_constructible<type4>::value,
+ "not noexcept default constructible");
diff --git a/libstdc++-v3/testsuite/23_containers/unordered_multimap/cons/noexcept_move_construct.cc b/libstdc++-v3/testsuite/23_containers/unordered_multimap/cons/noexcept_move_construct.cc
new file mode 100644
index 00000000000..e51ad5065a8
--- /dev/null
+++ b/libstdc++-v3/testsuite/23_containers/unordered_multimap/cons/noexcept_move_construct.cc
@@ -0,0 +1,65 @@
+// { dg-do compile { target c++11 } }
+
+// Copyright (C) 2020 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 <unordered_map>
+
+using type1 = std::unordered_multimap<int, int>;
+
+static_assert( std::is_nothrow_move_constructible<type1>::value,
+ "noexcept move constructor" );
+static_assert( std::is_nothrow_constructible<type1,
+ type1&&, const typename type1::allocator_type&>::value,
+ "noexcept move constructor with allocator" );
+
+struct not_noexcept_copy_cons_hash
+{
+ not_noexcept_copy_cons_hash() noexcept;
+ not_noexcept_copy_cons_hash(const not_noexcept_copy_cons_hash&) /* noexcept */;
+ not_noexcept_copy_cons_hash(not_noexcept_copy_cons_hash&&) noexcept;
+
+ std::size_t
+ operator()(int) const noexcept;
+};
+
+using type2 = std::unordered_multimap<int, int, not_noexcept_copy_cons_hash>;
+
+static_assert( !std::is_nothrow_move_constructible<type2>::value,
+ "not noexcept move constructor" );
+static_assert( !std::is_nothrow_constructible<type2, type2&&,
+ const typename type2::allocator_type&>::value,
+ "not noexcept move constructor with allocator" );
+
+struct not_noexcept_copy_cons_equal_to
+{
+ not_noexcept_copy_cons_equal_to() noexcept;
+ not_noexcept_copy_cons_equal_to(const not_noexcept_copy_cons_equal_to&) /* noexcept */;
+ not_noexcept_copy_cons_equal_to(not_noexcept_copy_cons_equal_to&&) noexcept;
+
+ bool
+ operator()(int, int) const noexcept;
+};
+
+using type3 = std::unordered_multimap<int, int, std::hash<int>,
+ not_noexcept_copy_cons_equal_to>;
+
+static_assert( !std::is_nothrow_move_constructible<type3>::value,
+ "not noexcept move constructor" );
+static_assert( !std::is_nothrow_constructible<type3, type3&&,
+ const typename type3::allocator_type&>::value,
+ "not noexcept move constructor with allocator" );
diff --git a/libstdc++-v3/testsuite/23_containers/unordered_multiset/cons/noexcept_default_construct.cc b/libstdc++-v3/testsuite/23_containers/unordered_multiset/cons/noexcept_default_construct.cc
new file mode 100644
index 00000000000..8511cb95421
--- /dev/null
+++ b/libstdc++-v3/testsuite/23_containers/unordered_multiset/cons/noexcept_default_construct.cc
@@ -0,0 +1,68 @@
+// Copyright (C) 2020 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/>.
+
+// { dg-do compile { target c++11 } }
+
+#include <unordered_set>
+
+using type1 = std::unordered_multiset<int>;
+
+static_assert(std::is_nothrow_default_constructible<type1>::value,
+ "noexcept default constructible");
+
+struct not_noexcept_dflt_cons_hash
+{
+ not_noexcept_dflt_cons_hash() /* noexcept */;
+
+ std::size_t
+ operator()(int) const noexcept;
+};
+
+using type2 = std::unordered_multiset<int, not_noexcept_dflt_cons_hash>;
+
+static_assert( !std::is_nothrow_default_constructible<type2>::value,
+ "not noexcept default constructible");
+
+struct not_noexcept_dflt_cons_equal_to
+{
+ not_noexcept_dflt_cons_equal_to() /* noexcept */;
+
+ bool
+ operator()(int, int) const noexcept;
+};
+
+using type3 = std::unordered_multiset<int, std::hash<int>,
+ not_noexcept_dflt_cons_equal_to>;
+
+static_assert( !std::is_nothrow_default_constructible<type3>::value,
+ "not noexcept default constructible");
+
+template<typename _Tp>
+ struct not_noexcept_dflt_cons_alloc : std::allocator<_Tp>
+ {
+ not_noexcept_dflt_cons_alloc() /* noexcept */;
+
+ template<typename _Tp1>
+ struct rebind
+ { typedef not_noexcept_dflt_cons_alloc<_Tp1> other; };
+ };
+
+using type4 = std::unordered_multiset<int, std::hash<int>, std::equal_to<int>,
+ not_noexcept_dflt_cons_alloc<int>>;
+
+static_assert(!std::is_nothrow_default_constructible<type4>::value,
+ "not noexcept default constructible");
diff --git a/libstdc++-v3/testsuite/23_containers/unordered_multiset/cons/noexcept_move_construct.cc b/libstdc++-v3/testsuite/23_containers/unordered_multiset/cons/noexcept_move_construct.cc
new file mode 100644
index 00000000000..1ccb8b0cf41
--- /dev/null
+++ b/libstdc++-v3/testsuite/23_containers/unordered_multiset/cons/noexcept_move_construct.cc
@@ -0,0 +1,65 @@
+// { dg-do compile { target c++11 } }
+
+// Copyright (C) 2020 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 <unordered_set>
+
+using type1 = std::unordered_multiset<int>;
+
+static_assert( std::is_nothrow_move_constructible<type1>::value,
+ "noexcept move constructor" );
+static_assert( std::is_nothrow_constructible<type1,
+ type1&&, const typename type1::allocator_type&>::value,
+ "noexcept move constructor with allocator" );
+
+struct not_noexcept_copy_cons_hash
+{
+ not_noexcept_copy_cons_hash() noexcept;
+ not_noexcept_copy_cons_hash(const not_noexcept_copy_cons_hash&) /* noexcept */;
+ not_noexcept_copy_cons_hash(not_noexcept_copy_cons_hash&&) noexcept;
+
+ std::size_t
+ operator()(int) const noexcept;
+};
+
+using type2 = std::unordered_multiset<int, not_noexcept_copy_cons_hash>;
+
+static_assert( !std::is_nothrow_move_constructible<type2>::value,
+ "not noexcept move constructor" );
+static_assert( !std::is_nothrow_constructible<type2, type2&&,
+ const typename type2::allocator_type&>::value,
+ "not noexcept move constructor with allocator" );
+
+struct not_noexcept_copy_cons_equal_to
+{
+ not_noexcept_copy_cons_equal_to() noexcept;
+ not_noexcept_copy_cons_equal_to(const not_noexcept_copy_cons_equal_to&) /* noexcept */;
+ not_noexcept_copy_cons_equal_to(not_noexcept_copy_cons_equal_to&&) noexcept;
+
+ bool
+ operator()(int, int) const noexcept;
+};
+
+using type3 = std::unordered_multiset<int, std::hash<int>,
+ not_noexcept_copy_cons_equal_to>;
+
+static_assert( !std::is_nothrow_move_constructible<type3>::value,
+ "not noexcept move constructor" );
+static_assert( !std::is_nothrow_constructible<type3, type3&&,
+ const typename type3::allocator_type&>::value,
+ "not noexcept move constructor with allocator" );
diff --git a/libstdc++-v3/testsuite/23_containers/unordered_set/allocator/default_init.cc b/libstdc++-v3/testsuite/23_containers/unordered_set/allocator/default_init.cc
new file mode 100644
index 00000000000..37110dd6eb0
--- /dev/null
+++ b/libstdc++-v3/testsuite/23_containers/unordered_set/allocator/default_init.cc
@@ -0,0 +1,69 @@
+// Copyright (C) 2020 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/>.
+
+// { dg-do run { target c++11 } }
+// { dg-options "-O0" }
+// { dg-xfail-run-if "PR c++/65816" { *-*-* } }
+
+#include <unordered_set>
+#include <testsuite_hooks.h>
+#include <testsuite_allocator.h>
+
+#include <ext/aligned_buffer.h>
+
+using T = int;
+
+using __gnu_test::default_init_allocator;
+
+void test01()
+{
+ typedef default_init_allocator<T> alloc_type;
+ typedef std::unordered_set<T, std::hash<T>, std::equal_to<T>,
+ alloc_type> test_type;
+
+ __gnu_cxx::__aligned_buffer<test_type> buf;
+ __builtin_memset(buf._M_addr(), ~0, sizeof(test_type));
+
+ test_type *tmp = ::new(buf._M_addr()) test_type;
+
+ VERIFY( tmp->get_allocator().state == 0 );
+
+ tmp->~test_type();
+}
+
+void test02()
+{
+ typedef default_init_allocator<T> alloc_type;
+ typedef std::unordered_set<T, std::hash<T>, std::equal_to<T>,
+ alloc_type> test_type;
+
+ __gnu_cxx::__aligned_buffer<test_type> buf;
+ __builtin_memset(buf._M_addr(), ~0, sizeof(test_type));
+
+ test_type *tmp = ::new(buf._M_addr()) test_type();
+
+ VERIFY( tmp->get_allocator().state == 0 );
+
+ tmp->~test_type();
+}
+
+int main()
+{
+ test01();
+ test02();
+ return 0;
+}
diff --git a/libstdc++-v3/testsuite/23_containers/unordered_set/cons/noexcept_default_construct.cc b/libstdc++-v3/testsuite/23_containers/unordered_set/cons/noexcept_default_construct.cc
new file mode 100644
index 00000000000..44db4aec6cf
--- /dev/null
+++ b/libstdc++-v3/testsuite/23_containers/unordered_set/cons/noexcept_default_construct.cc
@@ -0,0 +1,68 @@
+// Copyright (C) 2020 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/>.
+
+// { dg-do compile { target c++11 } }
+
+#include <unordered_set>
+
+using type1 = std::unordered_set<int>;
+
+static_assert(std::is_nothrow_default_constructible<type1>::value,
+ "noexcept default constructible");
+
+struct not_noexcept_dflt_cons_hash
+{
+ not_noexcept_dflt_cons_hash() /* noexcept */;
+
+ std::size_t
+ operator()(int) const noexcept;
+};
+
+using type2 = std::unordered_set<int, not_noexcept_dflt_cons_hash>;
+
+static_assert( !std::is_nothrow_default_constructible<type2>::value,
+ "not noexcept default constructible");
+
+struct not_noexcept_dflt_cons_equal_to
+{
+ not_noexcept_dflt_cons_equal_to() /* noexcept */;
+
+ bool
+ operator()(int, int) const noexcept;
+};
+
+using type3 = std::unordered_set<int, std::hash<int>,
+ not_noexcept_dflt_cons_equal_to>;
+
+static_assert( !std::is_nothrow_default_constructible<type3>::value,
+ "not noexcept default constructible");
+
+template<typename _Tp>
+ struct not_noexcept_dflt_cons_alloc : std::allocator<_Tp>
+ {
+ not_noexcept_dflt_cons_alloc() /* noexcept */;
+
+ template<typename _Tp1>
+ struct rebind
+ { typedef not_noexcept_dflt_cons_alloc<_Tp1> other; };
+ };
+
+using type4 = std::unordered_set<int, std::hash<int>, std::equal_to<int>,
+ not_noexcept_dflt_cons_alloc<int>>;
+
+static_assert(!std::is_nothrow_default_constructible<type4>::value,
+ "not noexcept default constructible");
diff --git a/libstdc++-v3/testsuite/23_containers/unordered_set/cons/noexcept_move_construct.cc b/libstdc++-v3/testsuite/23_containers/unordered_set/cons/noexcept_move_construct.cc
new file mode 100644
index 00000000000..65df57613ae
--- /dev/null
+++ b/libstdc++-v3/testsuite/23_containers/unordered_set/cons/noexcept_move_construct.cc
@@ -0,0 +1,65 @@
+// { dg-do compile { target c++11 } }
+
+// Copyright (C) 2020 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 <unordered_set>
+
+using type1 = std::unordered_set<int>;
+
+static_assert( std::is_nothrow_move_constructible<type1>::value,
+ "noexcept move constructor" );
+static_assert( std::is_nothrow_constructible<type1,
+ type1&&, const typename type1::allocator_type&>::value,
+ "noexcept move constructor with allocator" );
+
+struct not_noexcept_copy_cons_hash
+{
+ not_noexcept_copy_cons_hash() noexcept;
+ not_noexcept_copy_cons_hash(const not_noexcept_copy_cons_hash&) /* noexcept */;
+ not_noexcept_copy_cons_hash(not_noexcept_copy_cons_hash&&) noexcept;
+
+ std::size_t
+ operator()(int) const noexcept;
+};
+
+using type2 = std::unordered_set<int, not_noexcept_copy_cons_hash>;
+
+static_assert( !std::is_nothrow_move_constructible<type2>::value,
+ "not noexcept move constructor" );
+static_assert( !std::is_nothrow_constructible<type2, type2&&,
+ const typename type2::allocator_type&>::value,
+ "not noexcept move constructor with allocator" );
+
+struct not_noexcept_copy_cons_equal_to
+{
+ not_noexcept_copy_cons_equal_to() noexcept;
+ not_noexcept_copy_cons_equal_to(const not_noexcept_copy_cons_equal_to&) /* noexcept */;
+ not_noexcept_copy_cons_equal_to(not_noexcept_copy_cons_equal_to&&) noexcept;
+
+ bool
+ operator()(int, int) const noexcept;
+};
+
+using type3 = std::unordered_set<int, std::hash<int>,
+ not_noexcept_copy_cons_equal_to>;
+
+static_assert( !std::is_nothrow_move_constructible<type3>::value,
+ "not noexcept move constructor" );
+static_assert( !std::is_nothrow_constructible<type3, type3&&,
+ const typename type3::allocator_type&>::value,
+ "not noexcept move constructor with allocator" );
^ permalink raw reply [flat|nested] only message in thread
only message in thread, other threads:[~2021-04-08 23:37 UTC | newest]
Thread overview: (only message) (download: mbox.gz / follow: Atom feed)
-- links below jump to the message on this page --
2021-04-08 23:37 [gcc r9-9328] libstdc++: Fix unordered containers move constructors noexcept qualification Jonathan Wakely
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox;
as well as URLs for read-only IMAP folder(s) and NNTP newsgroup(s).