From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: by sourceware.org (Postfix, from userid 2181) id E61C03889A65; Fri, 10 Jun 2022 14:09:43 +0000 (GMT) DKIM-Filter: OpenDKIM Filter v2.11.0 sourceware.org E61C03889A65 MIME-Version: 1.0 Content-Transfer-Encoding: 7bit Content-Type: text/plain; charset="utf-8" From: Jonathan Wakely To: gcc-cvs@gcc.gnu.org, libstdc++-cvs@gcc.gnu.org Subject: [gcc r13-1037] libstdc++: Make std::hash> allocator-agnostic (LWG 3705) X-Act-Checkin: gcc X-Git-Author: Jonathan Wakely X-Git-Refname: refs/heads/master X-Git-Oldrev: 5940b4e59f8e198dbf7e8b733561ef72a9ba2cbc X-Git-Newrev: b370ed0bf93ecf0ff51d29e7fc132c433b2aa1be Message-Id: <20220610140943.E61C03889A65@sourceware.org> Date: Fri, 10 Jun 2022 14:09:43 +0000 (GMT) X-BeenThere: libstdc++-cvs@gcc.gnu.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: Libstdc++-cvs mailing list List-Unsubscribe: , List-Archive: List-Help: List-Subscribe: , X-List-Received-Date: Fri, 10 Jun 2022 14:09:44 -0000 https://gcc.gnu.org/g:b370ed0bf93ecf0ff51d29e7fc132c433b2aa1be commit r13-1037-gb370ed0bf93ecf0ff51d29e7fc132c433b2aa1be Author: Jonathan Wakely Date: Thu Jun 9 12:07:15 2022 +0100 libstdc++: Make std::hash> allocator-agnostic (LWG 3705) This new library issue was recently moved to Tentatively Ready by an LWG poll, so I'm making the change on trunk. As noted in PR libstc++/105907 the std::hash specializations for PMR strings were not treated as slow hashes by the unordered containers, so this change preserves that. The new specializations for custom allocators are also not treated as slow, for the same reason. For the versioned namespace (i.e. unstable ABI) we don't have to worry about that, so can enable hash code caching for all basic_string specializations. libstdc++-v3/ChangeLog: * include/bits/basic_string.h (__hash_str_base): New class template. (hash, A>>): Define partial specialization for each of the standard character types. (hash, hash, hash, hash) (hash): Remove explicit specializations. * include/std/string (__hash_string_base): Remove class template. (hash, hash, hash) (hash, hash): Remove explicit specializations. * testsuite/21_strings/basic_string/hash/hash.cc: Test with custom allocators. * testsuite/21_strings/basic_string/hash/hash_char8_t.cc: Likewise. Diff: --- libstdc++-v3/include/bits/basic_string.h | 102 ++++++++++----------- libstdc++-v3/include/std/string | 33 ------- .../testsuite/21_strings/basic_string/hash/hash.cc | 16 ++++ .../21_strings/basic_string/hash/hash_char8_t.cc | 12 +++ 4 files changed, 74 insertions(+), 89 deletions(-) diff --git a/libstdc++-v3/include/bits/basic_string.h b/libstdc++-v3/include/bits/basic_string.h index 6041d05815b..f76ddf970c6 100644 --- a/libstdc++-v3/include/bits/basic_string.h +++ b/libstdc++-v3/include/bits/basic_string.h @@ -4226,85 +4226,75 @@ namespace std _GLIBCXX_VISIBILITY(default) { _GLIBCXX_BEGIN_NAMESPACE_VERSION - // DR 1182. + // _GLIBCXX_RESOLVE_LIB_DEFECTS + // 3705. Hashability shouldn't depend on basic_string's allocator -#ifndef _GLIBCXX_COMPATIBILITY_CXX0X - /// std::hash specialization for string. - template<> - struct hash - : public __hash_base + template, _Alloc>> + struct __str_hash_base + : public __hash_base { size_t - operator()(const string& __s) const noexcept - { return std::_Hash_impl::hash(__s.data(), __s.length()); } + operator()(const _StrT& __s) const noexcept + { return _Hash_impl::hash(__s.data(), __s.length() * sizeof(_CharT)); } }; - template<> - struct __is_fast_hash> : std::false_type +#ifndef _GLIBCXX_COMPATIBILITY_CXX0X + /// std::hash specialization for string. + template + struct hash, _Alloc>> + : public __str_hash_base { }; /// std::hash specialization for wstring. - template<> - struct hash - : public __hash_base - { - size_t - operator()(const wstring& __s) const noexcept - { return std::_Hash_impl::hash(__s.data(), - __s.length() * sizeof(wchar_t)); } - }; + template + struct hash, _Alloc>> + : public __str_hash_base + { }; - template<> - struct __is_fast_hash> : std::false_type + template + struct __is_fast_hash, + _Alloc>>> + : std::false_type { }; #endif /* _GLIBCXX_COMPATIBILITY_CXX0X */ #ifdef _GLIBCXX_USE_CHAR8_T /// std::hash specialization for u8string. - template<> - struct hash - : public __hash_base - { - size_t - operator()(const u8string& __s) const noexcept - { return std::_Hash_impl::hash(__s.data(), - __s.length() * sizeof(char8_t)); } - }; - - template<> - struct __is_fast_hash> : std::false_type + template + struct hash, _Alloc>> + : public __str_hash_base { }; #endif /// std::hash specialization for u16string. - template<> - struct hash - : public __hash_base - { - size_t - operator()(const u16string& __s) const noexcept - { return std::_Hash_impl::hash(__s.data(), - __s.length() * sizeof(char16_t)); } - }; - - template<> - struct __is_fast_hash> : std::false_type + template + struct hash, _Alloc>> + : public __str_hash_base { }; /// std::hash specialization for u32string. - template<> - struct hash - : public __hash_base - { - size_t - operator()(const u32string& __s) const noexcept - { return std::_Hash_impl::hash(__s.data(), - __s.length() * sizeof(char32_t)); } - }; + template + struct hash, _Alloc>> + : public __str_hash_base + { }; - template<> - struct __is_fast_hash> : std::false_type +#if ! _GLIBCXX_INLINE_VERSION + // PR libstdc++/105907 - __is_fast_hash affects unordered container ABI. + template<> struct __is_fast_hash> : std::false_type { }; + template<> struct __is_fast_hash> : std::false_type { }; + template<> struct __is_fast_hash> : std::false_type { }; + template<> struct __is_fast_hash> : std::false_type { }; +#ifdef _GLIBCXX_USE_CHAR8_T + template<> struct __is_fast_hash> : std::false_type { }; +#endif +#else + // For versioned namespace, assume every std::hash> is slow. + template + struct __is_fast_hash>> + : std::false_type { }; +#endif #if __cplusplus >= 201402L diff --git a/libstdc++-v3/include/std/string b/libstdc++-v3/include/std/string index 4a0633067bd..37a4aaba9cd 100644 --- a/libstdc++-v3/include/std/string +++ b/libstdc++-v3/include/std/string @@ -69,39 +69,6 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION using u32string = basic_string; using wstring = basic_string; } // namespace pmr - - template - struct __hash_string_base - : public __hash_base - { - size_t - operator()(const _Str& __s) const noexcept - { return hash>{}(__s); } - }; - - template<> - struct hash - : public __hash_string_base - { }; -#ifdef _GLIBCXX_USE_CHAR8_T - template<> - struct hash - : public __hash_string_base - { }; -#endif - template<> - struct hash - : public __hash_string_base - { }; - template<> - struct hash - : public __hash_string_base - { }; - template<> - struct hash - : public __hash_string_base - { }; - _GLIBCXX_END_NAMESPACE_VERSION } // namespace std #endif // C++17 diff --git a/libstdc++-v3/testsuite/21_strings/basic_string/hash/hash.cc b/libstdc++-v3/testsuite/21_strings/basic_string/hash/hash.cc index 4c16f0e6f40..7f3809926e5 100644 --- a/libstdc++-v3/testsuite/21_strings/basic_string/hash/hash.cc +++ b/libstdc++-v3/testsuite/21_strings/basic_string/hash/hash.cc @@ -20,6 +20,7 @@ #include #include #include +#include // C++17 24.3.5 [basic.string.hash] // If S is one of these string types, SV is the corresponding string view type, @@ -54,9 +55,24 @@ test02() #endif } +template +using String + = std::basic_string, __gnu_test::SimpleAllocator>; + +void +test03() +{ + // LWG 3705. Hashability shouldn't depend on basic_string's allocator + VERIFY( test(String("a narrow string")) ); + VERIFY( test(String(u"a utf-16 string")) ); + VERIFY( test(String(U"a utf-32 string")) ); + VERIFY( test(String(L"a wide string")) ); +} + int main() { test01(); test02(); + test03(); } diff --git a/libstdc++-v3/testsuite/21_strings/basic_string/hash/hash_char8_t.cc b/libstdc++-v3/testsuite/21_strings/basic_string/hash/hash_char8_t.cc index 217fe15c7fe..0ff98ad1caa 100644 --- a/libstdc++-v3/testsuite/21_strings/basic_string/hash/hash_char8_t.cc +++ b/libstdc++-v3/testsuite/21_strings/basic_string/hash/hash_char8_t.cc @@ -21,6 +21,7 @@ #include #include #include +#include // C++2a N4810 21.3.5 [basic.string.hash] // If S is one of these string types, SV is the corresponding string view type, @@ -55,9 +56,20 @@ test02() VERIFY( hash()(native) == hash()(utf8) ); } +void +test03() +{ + using Alloc = __gnu_test::SimpleAllocator; + using Stringu8 = std::basic_string, Alloc>; + + // LWG 3705. Hashability shouldn't depend on basic_string's allocator + VERIFY( test(Stringu8(u8"a utf-8 string, with custom allocator")) ); +} + int main() { test01(); test02(); + test03(); }