Branch data Line data Source code
1 : : /* A hash map traits.
2 : : Copyright (C) 2015-2025 Free Software Foundation, Inc.
3 : :
4 : : This file is part of GCC.
5 : :
6 : : GCC is free software; you can redistribute it and/or modify it under
7 : : the terms of the GNU General Public License as published by the Free
8 : : Software Foundation; either version 3, or (at your option) any later
9 : : version.
10 : :
11 : : GCC is distributed in the hope that it will be useful, but WITHOUT ANY
12 : : WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 : : FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
14 : : for more details.
15 : :
16 : : You should have received a copy of the GNU General Public License
17 : : along with GCC; see the file COPYING3. If not see
18 : : <http://www.gnu.org/licenses/>. */
19 : :
20 : : #ifndef HASH_MAP_TRAITS_H
21 : : #define HASH_MAP_TRAITS_H
22 : :
23 : : /* Bacause mem-stats.h uses default hashmap traits, we have to
24 : : put the class to this separate header file. */
25 : :
26 : : #include "hash-traits.h"
27 : :
28 : : /* Implement hash_map traits for a key with hash traits H. Empty and
29 : : deleted map entries are represented as empty and deleted keys. */
30 : :
31 : : template <typename H, typename Value>
32 : : struct simple_hashmap_traits
33 : : {
34 : : typedef typename H::value_type key_type;
35 : : static const bool maybe_mx = true;
36 : : static inline hashval_t hash (const key_type &);
37 : : static inline bool equal_keys (const key_type &, const key_type &);
38 : : template <typename T> static inline void remove (T &);
39 : : static const bool empty_zero_p = H::empty_zero_p;
40 : : template <typename T> static inline bool is_empty (const T &);
41 : : template <typename T> static inline bool is_deleted (const T &);
42 : : template <typename T> static inline void mark_empty (T &);
43 : : template <typename T> static inline void mark_deleted (T &);
44 : : };
45 : :
46 : : template <typename H, typename Value>
47 : : inline hashval_t
48 : >10259*10^7 : simple_hashmap_traits <H, Value>::hash (const key_type &h)
49 : : {
50 : >10484*10^7 : return H::hash (h);
51 : : }
52 : :
53 : : template <typename H, typename Value>
54 : : inline bool
55 : 92966348549 : simple_hashmap_traits <H, Value>::equal_keys (const key_type &k1,
56 : : const key_type &k2)
57 : : {
58 : 94013909055 : return H::equal (k1, k2);
59 : : }
60 : :
61 : : template <typename H, typename Value>
62 : : template <typename T>
63 : : inline void
64 : 525039131 : simple_hashmap_traits <H, Value>::remove (T &entry)
65 : : {
66 : 102475644 : H::remove (entry.m_key);
67 : 524949480 : entry.m_value.~Value ();
68 : 2774665 : }
69 : :
70 : : template <typename H, typename Value>
71 : : template <typename T>
72 : : inline bool
73 : >46931*10^7 : simple_hashmap_traits <H, Value>::is_empty (const T &entry)
74 : : {
75 : >48222*10^7 : return H::is_empty (entry.m_key);
76 : : }
77 : :
78 : : template <typename H, typename Value>
79 : : template <typename T>
80 : : inline bool
81 : >12750*10^7 : simple_hashmap_traits <H, Value>::is_deleted (const T &entry)
82 : : {
83 : 6223518381 : return H::is_deleted (entry.m_key);
84 : : }
85 : :
86 : : template <typename H, typename Value>
87 : : template <typename T>
88 : : inline void
89 : 1584159580 : simple_hashmap_traits <H, Value>::mark_empty (T &entry)
90 : : {
91 : 1584159580 : H::mark_empty (entry.m_key);
92 : : }
93 : :
94 : : template <typename H, typename Value>
95 : : template <typename T>
96 : : inline void
97 : 16902804 : simple_hashmap_traits <H, Value>::mark_deleted (T &entry)
98 : : {
99 : 16813153 : H::mark_deleted (entry.m_key);
100 : : }
101 : :
102 : : template <typename H, typename Value>
103 : : struct simple_cache_map_traits: public simple_hashmap_traits<H,Value>
104 : : {
105 : : static const bool maybe_mx = false;
106 : : };
107 : :
108 : : /* Implement traits for a hash_map with keys of type Key and values of
109 : : type Value for cases in which the key cannot represent empty and
110 : : deleted slots. Instead record empty and deleted entries in Value. */
111 : :
112 : : template <typename Key, typename Value>
113 : : struct unbounded_hashmap_traits
114 : : {
115 : : typedef typename Key::value_type key_type;
116 : :
117 : : static hashval_t hash (const typename Key::value_type &);
118 : : static bool equal_keys (const typename Key::value_type &,
119 : : const typename Key::compare_type &);
120 : :
121 : : template <typename T> static inline void remove (T &);
122 : : static const bool empty_zero_p = default_hash_traits <Value>::empty_zero_p;
123 : : template <typename T> static inline bool is_empty (const T &);
124 : : template <typename T> static inline bool is_deleted (const T &);
125 : : template <typename T> static inline void mark_empty (T &);
126 : : template <typename T> static inline void mark_deleted (T &);
127 : : };
128 : :
129 : : template <typename Key, typename Value>
130 : : inline hashval_t
131 : 4367798 : unbounded_hashmap_traits <Key, Value>
132 : : ::hash (const typename Key::value_type &key)
133 : : {
134 : 4367798 : return Key::hash (key);
135 : : }
136 : :
137 : : template <typename Key, typename Value>
138 : : inline bool
139 : 3847554 : unbounded_hashmap_traits <Key, Value>
140 : : ::equal_keys (const typename Key::value_type &x,
141 : : const typename Key::compare_type &y)
142 : : {
143 : 3847554 : return Key::equal (x, y);
144 : : }
145 : :
146 : : template <typename Key, typename Value>
147 : : template <typename T>
148 : : inline void
149 : : unbounded_hashmap_traits <Key, Value>::remove (T &entry)
150 : : {
151 : : default_hash_traits <Value>::remove (entry.m_value);
152 : : }
153 : :
154 : : template <typename Key, typename Value>
155 : : template <typename T>
156 : : inline bool
157 : 26203163 : unbounded_hashmap_traits <Key, Value>::is_empty (const T &entry)
158 : : {
159 : 26203163 : return default_hash_traits <Value>::is_empty (entry.m_value);
160 : : }
161 : :
162 : : template <typename Key, typename Value>
163 : : template <typename T>
164 : : inline bool
165 : 4467466 : unbounded_hashmap_traits <Key, Value>::is_deleted (const T &entry)
166 : : {
167 : 317828 : return default_hash_traits <Value>::is_deleted (entry.m_value);
168 : : }
169 : :
170 : : template <typename Key, typename Value>
171 : : template <typename T>
172 : : inline void
173 : 8496488 : unbounded_hashmap_traits <Key, Value>::mark_empty (T &entry)
174 : : {
175 : 8496488 : default_hash_traits <Value>::mark_empty (entry.m_value);
176 : : }
177 : :
178 : : template <typename Key, typename Value>
179 : : template <typename T>
180 : : inline void
181 : : unbounded_hashmap_traits <Key, Value>::mark_deleted (T &entry)
182 : : {
183 : : default_hash_traits <Value>::mark_deleted (entry.m_value);
184 : : }
185 : :
186 : : /* Implement traits for a hash_map from integer type Key to Value in
187 : : cases where Key has no spare values for recording empty and deleted
188 : : slots. */
189 : :
190 : : template <typename Key, typename Value>
191 : : using unbounded_int_hashmap_traits
192 : : = unbounded_hashmap_traits <int_hash_base <Key>, Value>;
193 : :
194 : : #endif // HASH_MAP_TRAITS_H
|
