mirror of
https://github.com/gcc-mirror/gcc.git
synced 2024-11-21 13:40:47 +00:00
01ba02caa9
This attempts to simplify and clean up our std::hash code. The primary benefit is improved diagnostics for users when they do something wrong involving std::hash or unordered containers. An additional benefit is that for the unstable ABI (--enable-symvers=gnu-versioned-namespace) we can reduce the memory footprint of several std::hash specializations. In the current design, __hash_enum is a base class of the std::hash primary template, but the partial specialization of __hash_enum for non-enum types is disabled. This means that if a user forgets to specialize std::hash for their class type (or forgets to use a custom hash function for unordered containers) they get error messages about std::__hash_enum not being constructible. This is confusing when there is no enum type involved: why should users care about __hash_enum not being constructible if they're not trying to hash enums? This change makes the std::hash primary template only derive from __hash_enum when the template argument type is an enum. Otherwise, it derives directly from a new class template, __hash_not_enabled. This new class template defines the deleted members that cause a given std::hash specialization to be a disabled specialization (as per P0513R0). Now when users try to use a disabled specialization, they get more descriptive errors that mention __hash_not_enabled instead of __hash_enum. Additionally, adjust __hash_base to remove the deprecated result_type and argument_type typedefs for C++20 and later. In the current code we use a __poison_hash base class in the std::hash specializations for std::unique_ptr, std::optional, and std::variant. The primary template of __poison_hash has deleted special members, which is used to conditionally disable the derived std::hash specialization. This can also result in confusing diagnostics, because seeing "poison" in an enabled specialization is misleading. Only some uses of __poison_hash actually "poison" anything, i.e. cause a specialization to be disabled. In other cases it's just an empty base class that does nothing. This change removes __poison_hash and changes the std::hash specializations that were using it to conditionally derive from __hash_not_enabled instead. When the std::hash specialization is enabled, there is no more __poison_hash base class. However, to preserve the ABI properties of those std::hash specializations, we need to replace __poison_hash with some other empty base class. This is needed because in the current code std::hash<std::variant<int, const int>> has two __poison_hash<int> base classes, which must have unique addresses, so sizeof(std::hash<std::variant<int, const int>>) == 2. To preserve this unfortunate property, a new __hash_empty_base class is used as a base class to re-introduce du0plicate base classes that increase the class size. For the unstable ABI we don't use __hash_empty_base so the std::hash<std::variant<T...>> specializations are always size 1, and the class hierarchy is much simpler so will compile faster. Additionally, remove the result_type and argument_type typedefs from all disabled specializations of std::hash for std::unique_ptr, std::optional, and std::variant. Those typedefs are useless for disabled specializations, and although the standard doesn't say they must *not* be present for disabled specializations, it certainly only requires them for enabled specializations. Finally, for C++20 the typedefs are also removed from enabled specializations of std::hash for std::unique_ptr, std::optional, and std::variant. libstdc++-v3/ChangeLog: * doc/xml/manual/evolution.xml: Document removal of nested types from std::hash specializations. * doc/html/manual/api.html: Regenerate. * include/bits/functional_hash.h (__hash_base): Remove deprecated nested types for C++20. (__hash_empty_base): Define new class template. (__is_hash_enabled_for): Define new variable template. (__poison_hash): Remove. (__hash_not_enabled): Define new class template. (__hash_enum): Remove partial specialization for non-enums. (hash): Derive from __hash_not_enabled for non-enums, instead of __hash_enum. * include/bits/unique_ptr.h (__uniq_ptr_hash): Derive from __hash_base. Conditionally derive from __hash_empty_base. (__uniq_ptr_hash<>): Remove disabled specialization. (hash): Do not derive from __hash_base unconditionally. Conditionally derive from either __uniq_ptr_hash or __hash_not_enabled. * include/std/optional (__optional_hash_call_base): Remove. (__optional_hash): Define new class template. (hash): Derive from either (hash): Conditionally derive from either __optional_hash or __hash_not_enabled. Remove nested typedefs. * include/std/variant (_Base_dedup): Replace __poison_hash with __hash_empty_base. (__variant_hash_call_base_impl): Remove. (__variant_hash): Define new class template. (hash): Conditionally derive from either __variant_hash or __hash_not_enabled. Remove nested typedefs. * testsuite/20_util/optional/hash.cc: Check whether nested types are present. * testsuite/20_util/variant/hash.cc: Likewise. * testsuite/20_util/optional/hash_abi.cc: New test. * testsuite/20_util/unique_ptr/hash/abi.cc: New test. * testsuite/20_util/unique_ptr/hash/types.cc: New test. * testsuite/20_util/variant/hash_abi.cc: New test. |
||
|---|---|---|
| .. | ||
| add_const | ||
| add_cv | ||
| add_lvalue_reference | ||
| add_pointer | ||
| add_rvalue_reference | ||
| add_volatile | ||
| addressof | ||
| align | ||
| aligned_storage | ||
| aligned_union | ||
| alignment_of | ||
| allocator | ||
| allocator_traits | ||
| any | ||
| as_const | ||
| assume_aligned | ||
| auto_ptr | ||
| bad_function_call | ||
| bind | ||
| bitset | ||
| bool_constant | ||
| common_reference | ||
| common_type/requirements | ||
| conditional/requirements | ||
| decay/requirements | ||
| declval/requirements | ||
| default_delete | ||
| duration | ||
| duration_cast | ||
| enable_if/requirements | ||
| enable_shared_from_this | ||
| exchange | ||
| expected | ||
| extent | ||
| forward | ||
| forward_like | ||
| from_chars | ||
| function | ||
| function_objects | ||
| has_unique_object_representations | ||
| has_virtual_destructor | ||
| hash | ||
| headers | ||
| in_place | ||
| integer_comparisons | ||
| integer_sequence | ||
| integral_constant | ||
| invoke_result | ||
| is_abstract | ||
| is_aggregate | ||
| is_arithmetic | ||
| is_array | ||
| is_assignable | ||
| is_base_of | ||
| is_bounded_array | ||
| is_class | ||
| is_complete_or_unbounded | ||
| is_compound | ||
| is_const | ||
| is_constant_evaluated | ||
| is_constructible | ||
| is_convertible | ||
| is_copy_assignable | ||
| is_copy_constructible | ||
| is_default_constructible | ||
| is_destructible | ||
| is_empty | ||
| is_enum | ||
| is_final | ||
| is_floating_point | ||
| is_function | ||
| is_fundamental | ||
| is_implicitly_default_constructible | ||
| is_integral | ||
| is_invocable | ||
| is_layout_compatible | ||
| is_literal_type | ||
| is_lvalue_reference | ||
| is_member_function_pointer | ||
| is_member_object_pointer | ||
| is_member_pointer | ||
| is_move_assignable | ||
| is_move_constructible | ||
| is_nothrow_assignable | ||
| is_nothrow_constructible | ||
| is_nothrow_convertible | ||
| is_nothrow_copy_assignable | ||
| is_nothrow_copy_constructible | ||
| is_nothrow_default_constructible | ||
| is_nothrow_destructible | ||
| is_nothrow_invocable | ||
| is_nothrow_move_assignable | ||
| is_nothrow_move_constructible | ||
| is_nothrow_swappable | ||
| is_nothrow_swappable_with | ||
| is_null_pointer | ||
| is_object | ||
| is_pod | ||
| is_pointer | ||
| is_pointer_interconvertible | ||
| is_polymorphic | ||
| is_reference | ||
| is_rvalue_reference | ||
| is_same | ||
| is_scalar | ||
| is_scoped_enum | ||
| is_signed | ||
| is_standard_layout | ||
| is_swappable | ||
| is_swappable_with | ||
| is_trivial | ||
| is_trivially_assignable | ||
| is_trivially_constructible | ||
| is_trivially_copy_assignable | ||
| is_trivially_copy_constructible | ||
| is_trivially_copyable | ||
| is_trivially_default_constructible | ||
| is_trivially_destructible | ||
| is_trivially_move_assignable | ||
| is_trivially_move_constructible | ||
| is_unbounded_array | ||
| is_union | ||
| is_unsigned | ||
| is_virtual_base_of | ||
| is_void | ||
| is_volatile | ||
| logical_traits | ||
| make_signed/requirements | ||
| make_unsigned/requirements | ||
| memory_resource | ||
| monotonic_buffer_resource | ||
| move | ||
| move_if_noexcept | ||
| move_only_function | ||
| nonesuch | ||
| optional | ||
| owner_less | ||
| pair | ||
| pointer_safety | ||
| pointer_traits | ||
| polymorphic_allocator | ||
| rank | ||
| ratio | ||
| raw_storage_iterator | ||
| reference_from_temporary | ||
| reference_wrapper | ||
| remove_all_extents | ||
| remove_const | ||
| remove_cv | ||
| remove_cvref | ||
| remove_extent | ||
| remove_pointer | ||
| remove_reference | ||
| remove_volatile | ||
| result_of | ||
| scoped_allocator | ||
| shared_ptr | ||
| smartptr.adapt | ||
| specialized_algorithms | ||
| steady_clock | ||
| synchronized_pool_resource | ||
| system_clock | ||
| time_point | ||
| time_point_cast | ||
| to_address | ||
| to_chars | ||
| to_underlying | ||
| tuple | ||
| type_identity/requirements | ||
| typeindex | ||
| underlying_type/requirements | ||
| unique_ptr | ||
| unreachable | ||
| unsynchronized_pool_resource | ||
| unwrap_reference | ||
| uses_allocator | ||
| variant | ||
| void_t | ||
| weak_ptr | ||
| rel_ops.cc | ||
| temporary_buffer.cc | ||
| variable_templates_for_traits.cc | ||