From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (qmail 56233 invoked by alias); 17 Nov 2019 20:59:16 -0000 Mailing-List: contact libstdc++-help@gcc.gnu.org; run by ezmlm Precedence: bulk List-Id: List-Subscribe: List-Archive: List-Post: List-Help: , Sender: libstdc++-owner@gcc.gnu.org Received: (qmail 56208 invoked by uid 89); 17 Nov 2019 20:59:15 -0000 Authentication-Results: sourceware.org; auth=none X-Spam-SWARE-Status: No, score=-26.9 required=5.0 tests=BAYES_00,FREEMAIL_FROM,GIT_PATCH_0,GIT_PATCH_1,GIT_PATCH_2,GIT_PATCH_3,KAM_SHORT,RCVD_IN_DNSWL_NONE,SPF_PASS autolearn=ham version=3.3.1 spammy= X-HELO: mail-wm1-f42.google.com Received: from mail-wm1-f42.google.com (HELO mail-wm1-f42.google.com) (209.85.128.42) by sourceware.org (qpsmtpd/0.93/v0.84-503-g423c35a) with ESMTP; Sun, 17 Nov 2019 20:59:10 +0000 Received: by mail-wm1-f42.google.com with SMTP id 8so16575225wmo.0; Sun, 17 Nov 2019 12:59:10 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20161025; h=to:from:subject:message-id:date:user-agent:mime-version :content-language; bh=Tu0cpobz6Q1PpPOlvzg6QTXliRniceFydz5s/keVkXU=; b=sqpieqz86uWUWSSZEPQsYUfBcnYlyPZ48um2FVpF0k/OInZ3YZt8ZogDzykdpK0HKe TzuTT49WHJbJEx5ZXI2rqBixKerwFf2iTGRUnppnjv9/hnovNXmjzxkrSBHXbvKJJq0p iizIckCSQvlVJlF1SfaThrpari1rZpUjUq8xeD4VZZEpjdgwjx8jT/7gEw2hiLDjt9YT kfg7aJgf8EqhiH6RjI5xpCxj4rOSoI/gKq/xLfISsFbfZJdQTBmJD0lVFQVFVA3OwLTf 3DZUyYpaiUBbCykq9iXl9Br7XNnTk27PkpjhZeKjm2K+kDhNyIskm1Tnog+QtUpKxH/a jogw== Return-Path: Received: from ?IPv6:2a01:e0a:1dc:b1c0:2de3:6b55:97a4:2396? ([2a01:e0a:1dc:b1c0:2de3:6b55:97a4:2396]) by smtp.googlemail.com with ESMTPSA id 16sm22032132wmf.0.2019.11.17.12.59.06 (version=TLS1_2 cipher=ECDHE-RSA-AES128-GCM-SHA256 bits=128/128); Sun, 17 Nov 2019 12:59:07 -0800 (PST) To: "libstdc++@gcc.gnu.org" , gcc-patches From: =?UTF-8?Q?Fran=c3=a7ois_Dumont?= Subject: [PATCH][Hashtable 3/6] Fix noexcept qualifications Message-ID: Date: Sun, 17 Nov 2019 20:59:00 -0000 User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:60.0) Gecko/20100101 Thunderbird/60.9.0 MIME-Version: 1.0 Content-Type: multipart/mixed; boundary="------------8B4544AFB9C755CE853EFF7E" X-IsSubscribed: yes X-SW-Source: 2019-11/txt/msg00066.txt.bz2 This is a multi-part message in MIME format. --------------8B4544AFB9C755CE853EFF7E Content-Type: text/plain; charset=utf-8; format=flowed Content-Transfer-Encoding: 8bit Content-length: 2013 This patch adds noexcept qualification on allocator aware constructors and fix the one on the default constructor.     * 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&)): Add     noexcept qualification.     * include/bits/unordered_set.h     (unordered_set(unordered_set&&, const allocator_type&)): Add noexcept     qualification.     (unordered_multiset(unordered_multiset&&, const allocator_type&)): Add     noexcept qualification.     * testsuite/23_containers/unordered_map/allocator/default_init.cc:     New.     * testsuite/23_containers/unordered_map/cons/     noexcept_default_construct.cc: New.     * testsuite/23_containers/unordered_map/cons/     noexcept_move_construct.cc: New.     * testsuite/23_containers/unordered_map/modifiers/move_assign.cc:     New.     * testsuite/23_containers/unordered_multimap/cons/     noexcept_default_construct.cc: New.     * testsuite/23_containers/unordered_multimap/cons/     noexcept_move_construct.cc: New.     * testsuite/23_containers/unordered_multiset/cons/     noexcept_default_construct.cc: New.     * testsuite/23_containers/unordered_multiset/cons/     noexcept_move_construct.cc: New.     * testsuite/23_containers/unordered_set/allocator/default_init.cc: New.     * testsuite/23_containers/unordered_set/cons/     noexcept_default_construct.cc: New.     * testsuite/23_containers/unordered_set/cons/noexcept_move_construct.cc:     New. Tested under Linux x86_64. François --------------8B4544AFB9C755CE853EFF7E Content-Type: text/x-patch; name="hashtable#4.patch" Content-Transfer-Encoding: 7bit Content-Disposition: attachment; filename="hashtable#4.patch" Content-length: 35199 diff --git a/libstdc++-v3/include/bits/hashtable.h b/libstdc++-v3/include/bits/hashtable.h index 5f785d4904d..ad07a36eb83 100644 --- a/libstdc++-v3/include/bits/hashtable.h +++ b/libstdc++-v3/include/bits/hashtable.h @@ -463,6 +463,35 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION __hashtable_alloc(__node_alloc_type(__a)) { } + _Hashtable(_Hashtable&& __ht, __node_alloc_type&& __a, true_type) + 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(__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. + if (__ht._M_uses_single_bucket()) + { + _M_buckets = &_M_single_bucket; + _M_single_bucket = __ht._M_single_bucket; + } + + // Fix bucket containing the _M_before_begin pointer that can't be + // moved. + _M_update_bbegin(); + + __ht._M_reset(); + } + + _Hashtable(_Hashtable&&, __node_alloc_type&&, false_type); + template _Hashtable(_InputIterator __first, _InputIterator __last, size_type __bkt_count_hint, @@ -489,11 +518,24 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION _Hashtable(const _Hashtable&); - _Hashtable(_Hashtable&&) noexcept; + _Hashtable(_Hashtable&& __ht) + noexcept( noexcept( + _Hashtable(std::declval<_Hashtable&&>(), + std::declval<__node_alloc_type&&>(), std::declval())) ) + : _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( noexcept( + _Hashtable(std::declval<_Hashtable&&>(), + std::declval<__node_alloc_type&&>(), + std::declval())) ) + : _Hashtable(std::move(__ht), __node_alloc_type(__a), + typename __node_alloc_traits::is_always_equal{}) + { } // Use delegating constructors. template @@ -1368,36 +1410,6 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION _M_assign(__ht, __alloc_node_gen); } - template - _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, - _H1, _H2, _Hash, _RehashPolicy, _Traits>:: - _Hashtable(_Hashtable&& __ht) noexcept - : __hashtable_base(__ht), - __map_base(__ht), - __rehash_base(__ht), - __hashtable_alloc(std::move(__ht._M_base_alloc())), - _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. - if (__ht._M_uses_single_bucket()) - { - _M_buckets = &_M_single_bucket; - _M_single_bucket = __ht._M_single_bucket; - } - - // Fix bucket containing the _M_before_begin pointer that can't be moved. - _M_update_bbegin(); - - __ht._M_reset(); - } - template _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) : __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 49c175a90be..5131e02e8aa 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(declval<_Hashtable&&>(), __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(declval<_Hashtable&&>(), __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 855579ee623..7154ec843db 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(declval<_Hashtable&&>(), __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(declval<_Hashtable&&>(), __a)) ) : _M_h(std::move(__umset._M_h), __a) { } 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..8c3103c2614 --- /dev/null +++ b/libstdc++-v3/testsuite/23_containers/unordered_map/allocator/default_init.cc @@ -0,0 +1,69 @@ +// Copyright (C) 2019 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 +// . + +// { dg-do run { target c++11 } } +// { dg-options "-O0" } +// { dg-xfail-run-if "PR c++/65816" { *-*-* } } + +#include +#include +#include + +#include + +using T = int; + +using __gnu_test::default_init_allocator; + +void test01() +{ + typedef default_init_allocator> alloc_type; + typedef std::unordered_map, std::equal_to, + alloc_type> test_type; + + __gnu_cxx::__aligned_buffer 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> alloc_type; + typedef std::unordered_map, std::equal_to, + alloc_type> test_type; + + __gnu_cxx::__aligned_buffer 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..549d0a8d96a --- /dev/null +++ b/libstdc++-v3/testsuite/23_containers/unordered_map/cons/noexcept_default_construct.cc @@ -0,0 +1,68 @@ +// Copyright (C) 2019 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 +// . + +// { dg-do compile { target c++11 } } + +#include + +using type1 = std::unordered_map; + +static_assert(std::is_nothrow_default_constructible::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; + +static_assert( !std::is_nothrow_default_constructible::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, + not_noexcept_dflt_cons_equal_to>; + +static_assert( !std::is_nothrow_default_constructible::value, + "not noexcept default constructible"); + +template + struct not_noexcept_dflt_cons_alloc : std::allocator<_Tp> + { + not_noexcept_dflt_cons_alloc() /* noexcept */; + + template + struct rebind + { typedef not_noexcept_dflt_cons_alloc<_Tp1> other; }; + }; + +using type4 = std::unordered_map, std::equal_to, + not_noexcept_dflt_cons_alloc>>; + +static_assert(!std::is_nothrow_default_constructible::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..1929b6ac66d --- /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) 2019 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 +// . + +#include + +using type1 = std::unordered_map; + +static_assert( std::is_nothrow_move_constructible::value, + "noexcept move constructor" ); +static_assert( std::is_nothrow_constructible::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; + +static_assert( !std::is_nothrow_move_constructible::value, + "noexcept move constructor" ); +static_assert( !std::is_nothrow_constructible::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, + not_noexcept_copy_cons_equal_to>; + +static_assert( !std::is_nothrow_move_constructible::value, + "noexcept move constructor" ); +static_assert( !std::is_nothrow_constructible::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..15d8e8011e6 --- /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) 2019 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 +// . + +#include +#include +#include + +#include +#include +#include + +void test01() +{ + using namespace std; + using __gnu_test::counter_type; + + std::vector> insts { { 0, 0 }, { 1, 1 }, { 2, 2 } }; + typedef unordered_map 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, false> Alloc; + typedef unordered_map, equal_to, + 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..bda8c54dc4c --- /dev/null +++ b/libstdc++-v3/testsuite/23_containers/unordered_multimap/cons/noexcept_default_construct.cc @@ -0,0 +1,68 @@ +// Copyright (C) 2019 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 +// . + +// { dg-do compile { target c++11 } } + +#include + +using type1 = std::unordered_multimap; + +static_assert(std::is_nothrow_default_constructible::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; + +static_assert( !std::is_nothrow_default_constructible::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, + not_noexcept_dflt_cons_equal_to>; + +static_assert( !std::is_nothrow_default_constructible::value, + "not noexcept default constructible"); + +template + struct not_noexcept_dflt_cons_alloc : std::allocator<_Tp> + { + not_noexcept_dflt_cons_alloc() /* noexcept */; + + template + struct rebind + { typedef not_noexcept_dflt_cons_alloc<_Tp1> other; }; + }; + +using type4 = std::unordered_multimap, std::equal_to, + not_noexcept_dflt_cons_alloc>>; + +static_assert(!std::is_nothrow_default_constructible::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..f3b1b908f2f --- /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) 2019 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 +// . + +#include + +using type1 = std::unordered_multimap; + +static_assert( std::is_nothrow_move_constructible::value, + "noexcept move constructor" ); +static_assert( std::is_nothrow_constructible::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; + +static_assert( !std::is_nothrow_move_constructible::value, + "noexcept move constructor" ); +static_assert( !std::is_nothrow_constructible::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, + not_noexcept_copy_cons_equal_to>; + +static_assert( !std::is_nothrow_move_constructible::value, + "noexcept move constructor" ); +static_assert( !std::is_nothrow_constructible::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..5b7ff7ce655 --- /dev/null +++ b/libstdc++-v3/testsuite/23_containers/unordered_multiset/cons/noexcept_default_construct.cc @@ -0,0 +1,68 @@ +// Copyright (C) 2019 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 +// . + +// { dg-do compile { target c++11 } } + +#include + +using type1 = std::unordered_multiset; + +static_assert(std::is_nothrow_default_constructible::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; + +static_assert( !std::is_nothrow_default_constructible::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, + not_noexcept_dflt_cons_equal_to>; + +static_assert( !std::is_nothrow_default_constructible::value, + "not noexcept default constructible"); + +template + struct not_noexcept_dflt_cons_alloc : std::allocator<_Tp> + { + not_noexcept_dflt_cons_alloc() /* noexcept */; + + template + struct rebind + { typedef not_noexcept_dflt_cons_alloc<_Tp1> other; }; + }; + +using type4 = std::unordered_multiset, std::equal_to, + not_noexcept_dflt_cons_alloc>>; + +static_assert(!std::is_nothrow_default_constructible::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..a03f7f8d959 --- /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) 2019 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 +// . + +#include + +using type1 = std::unordered_multiset; + +static_assert( std::is_nothrow_move_constructible::value, + "noexcept move constructor" ); +static_assert( std::is_nothrow_constructible::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; + +static_assert( !std::is_nothrow_move_constructible::value, + "noexcept move constructor" ); +static_assert( !std::is_nothrow_constructible::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, + not_noexcept_copy_cons_equal_to>; + +static_assert( !std::is_nothrow_move_constructible::value, + "noexcept move constructor" ); +static_assert( !std::is_nothrow_constructible::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..51fa5e7094b --- /dev/null +++ b/libstdc++-v3/testsuite/23_containers/unordered_set/allocator/default_init.cc @@ -0,0 +1,69 @@ +// Copyright (C) 2019 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 +// . + +// { dg-do run { target c++11 } } +// { dg-options "-O0" } +// { dg-xfail-run-if "PR c++/65816" { *-*-* } } + +#include +#include +#include + +#include + +using T = int; + +using __gnu_test::default_init_allocator; + +void test01() +{ + typedef default_init_allocator alloc_type; + typedef std::unordered_set, std::equal_to, + alloc_type> test_type; + + __gnu_cxx::__aligned_buffer 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 alloc_type; + typedef std::unordered_set, std::equal_to, + alloc_type> test_type; + + __gnu_cxx::__aligned_buffer 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..2966703461f --- /dev/null +++ b/libstdc++-v3/testsuite/23_containers/unordered_set/cons/noexcept_default_construct.cc @@ -0,0 +1,68 @@ +// Copyright (C) 2019 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 +// . + +// { dg-do compile { target c++11 } } + +#include + +using type1 = std::unordered_set; + +static_assert(std::is_nothrow_default_constructible::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; + +static_assert( !std::is_nothrow_default_constructible::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, + not_noexcept_dflt_cons_equal_to>; + +static_assert( !std::is_nothrow_default_constructible::value, + "not noexcept default constructible"); + +template + struct not_noexcept_dflt_cons_alloc : std::allocator<_Tp> + { + not_noexcept_dflt_cons_alloc() /* noexcept */; + + template + struct rebind + { typedef not_noexcept_dflt_cons_alloc<_Tp1> other; }; + }; + +using type4 = std::unordered_set, std::equal_to, + not_noexcept_dflt_cons_alloc>>; + +static_assert(!std::is_nothrow_default_constructible::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..2470079bc90 --- /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) 2019 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 +// . + +#include + +using type1 = std::unordered_set; + +static_assert( std::is_nothrow_move_constructible::value, + "noexcept move constructor" ); +static_assert( std::is_nothrow_constructible::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; + +static_assert( !std::is_nothrow_move_constructible::value, + "noexcept move constructor" ); +static_assert( !std::is_nothrow_constructible::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, + not_noexcept_copy_cons_equal_to>; + +static_assert( !std::is_nothrow_move_constructible::value, + "noexcept move constructor" ); +static_assert( !std::is_nothrow_constructible::value, + "not noexcept move constructor with allocator" ); --------------8B4544AFB9C755CE853EFF7E--