1 /* A hash map traits.
2 Copyright (C) 2015-2023 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 simple_hashmap_traits <H, Value>::hash (const key_type &h)
49 {
50 return H::hash (h);
51 }
52
53 template <typename H, typename Value>
54 inline bool
55 simple_hashmap_traits <H, Value>::equal_keys (const key_type &k1,
56 const key_type &k2)
57 {
58 return H::equal (k1, k2);
59 }
60
61 template <typename H, typename Value>
62 template <typename T>
63 inline void
64 simple_hashmap_traits <H, Value>::remove (T &entry)
65 {
66 H::remove (entry.m_key);
67 entry.m_value.~Value ();
68 }
69
70 template <typename H, typename Value>
71 template <typename T>
72 inline bool
73 simple_hashmap_traits <H, Value>::is_empty (const T &entry)
74 {
75 return H::is_empty (entry.m_key);
76 }
77
78 template <typename H, typename Value>
79 template <typename T>
80 inline bool
81 simple_hashmap_traits <H, Value>::is_deleted (const T &entry)
82 {
83 return H::is_deleted (entry.m_key);
84 }
85
86 template <typename H, typename Value>
87 template <typename T>
88 inline void
89 simple_hashmap_traits <H, Value>::mark_empty (T &entry)
90 {
91 H::mark_empty (entry.m_key);
92 }
93
94 template <typename H, typename Value>
95 template <typename T>
96 inline void
97 simple_hashmap_traits <H, Value>::mark_deleted (T &entry)
98 {
99 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 unbounded_hashmap_traits <Key, Value>
132 ::hash (const typename Key::value_type &key)
133 {
134 return Key::hash (key);
135 }
136
137 template <typename Key, typename Value>
138 inline bool
139 unbounded_hashmap_traits <Key, Value>
140 ::equal_keys (const typename Key::value_type &x,
141 const typename Key::compare_type &y)
142 {
143 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 unbounded_hashmap_traits <Key, Value>::is_empty (const T &entry)
158 {
159 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 unbounded_hashmap_traits <Key, Value>::is_deleted (const T &entry)
166 {
167 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 unbounded_hashmap_traits <Key, Value>::mark_empty (T &entry)
174 {
175 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