1//===- StringMap.h - String Hash table map interface ------------*- C++ -*-===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8//
9// This file defines the StringMap class.
10//
11//===----------------------------------------------------------------------===//
12
13#ifndef LLVM_ADT_STRINGMAP_H
14#define LLVM_ADT_STRINGMAP_H
15
16#include "llvm/ADT/StringMapEntry.h"
17#include "llvm/Support/AllocatorBase.h"
18#include "llvm/Support/PointerLikeTypeTraits.h"
19#include <initializer_list>
20#include <iterator>
21
22namespace llvm {
23
24template <typename ValueTy> class StringMapConstIterator;
25template <typename ValueTy> class StringMapIterator;
26template <typename ValueTy> class StringMapKeyIterator;
27
28/// StringMapImpl - This is the base class of StringMap that is shared among
29/// all of its instantiations.
30class StringMapImpl {
31protected:
32 // Array of NumBuckets pointers to entries, null pointers are holes.
33 // TheTable[NumBuckets] contains a sentinel value for easy iteration. Followed
34 // by an array of the actual hash values as unsigned integers.
35 StringMapEntryBase **TheTable = nullptr;
36 unsigned NumBuckets = 0;
37 unsigned NumItems = 0;
38 unsigned NumTombstones = 0;
39 unsigned ItemSize;
40
41protected:
42 explicit StringMapImpl(unsigned itemSize) : ItemSize(itemSize) {}
43 StringMapImpl(StringMapImpl &&RHS)
44 : TheTable(RHS.TheTable), NumBuckets(RHS.NumBuckets),
45 NumItems(RHS.NumItems), NumTombstones(RHS.NumTombstones),
46 ItemSize(RHS.ItemSize) {
47 RHS.TheTable = nullptr;
48 RHS.NumBuckets = 0;
49 RHS.NumItems = 0;
50 RHS.NumTombstones = 0;
51 }
52
53 StringMapImpl(unsigned InitSize, unsigned ItemSize);
54 unsigned RehashTable(unsigned BucketNo = 0);
55
56 /// LookupBucketFor - Look up the bucket that the specified string should end
57 /// up in. If it already exists as a key in the map, the Item pointer for the
58 /// specified bucket will be non-null. Otherwise, it will be null. In either
59 /// case, the FullHashValue field of the bucket will be set to the hash value
60 /// of the string.
61 unsigned LookupBucketFor(StringRef Key);
62
63 /// FindKey - Look up the bucket that contains the specified key. If it exists
64 /// in the map, return the bucket number of the key. Otherwise return -1.
65 /// This does not modify the map.
66 int FindKey(StringRef Key) const;
67
68 /// RemoveKey - Remove the specified StringMapEntry from the table, but do not
69 /// delete it. This aborts if the value isn't in the table.
70 void RemoveKey(StringMapEntryBase *V);
71
72 /// RemoveKey - Remove the StringMapEntry for the specified key from the
73 /// table, returning it. If the key is not in the table, this returns null.
74 StringMapEntryBase *RemoveKey(StringRef Key);
75
76 /// Allocate the table with the specified number of buckets and otherwise
77 /// setup the map as empty.
78 void init(unsigned Size);
79
80public:
81 static constexpr uintptr_t TombstoneIntVal =
82 static_cast<uintptr_t>(-1)
83 << PointerLikeTypeTraits<StringMapEntryBase *>::NumLowBitsAvailable;
84
85 static StringMapEntryBase *getTombstoneVal() {
86 return reinterpret_cast<StringMapEntryBase *>(TombstoneIntVal);
87 }
88
89 unsigned getNumBuckets() const { return NumBuckets; }
90 unsigned getNumItems() const { return NumItems; }
91
92 bool empty() const { return NumItems == 0; }
93 unsigned size() const { return NumItems; }
94
95 void swap(StringMapImpl &Other) {
96 std::swap(TheTable, Other.TheTable);
97 std::swap(NumBuckets, Other.NumBuckets);
98 std::swap(NumItems, Other.NumItems);
99 std::swap(NumTombstones, Other.NumTombstones);
100 }
101};
102
103/// StringMap - This is an unconventional map that is specialized for handling
104/// keys that are "strings", which are basically ranges of bytes. This does some
105/// funky memory allocation and hashing things to make it extremely efficient,
106/// storing the string data *after* the value in the map.
107template <typename ValueTy, typename AllocatorTy = MallocAllocator>
108class StringMap : public StringMapImpl {
109 AllocatorTy Allocator;
110
111public:
112 using MapEntryTy = StringMapEntry<ValueTy>;
113
114 StringMap() : StringMapImpl(static_cast<unsigned>(sizeof(MapEntryTy))) {}
115
116 explicit StringMap(unsigned InitialSize)
117 : StringMapImpl(InitialSize, static_cast<unsigned>(sizeof(MapEntryTy))) {}
118
119 explicit StringMap(AllocatorTy A)
120 : StringMapImpl(static_cast<unsigned>(sizeof(MapEntryTy))), Allocator(A) {
121 }
122
123 StringMap(unsigned InitialSize, AllocatorTy A)
124 : StringMapImpl(InitialSize, static_cast<unsigned>(sizeof(MapEntryTy))),
125 Allocator(A) {}
126
127 StringMap(std::initializer_list<std::pair<StringRef, ValueTy>> List)
128 : StringMapImpl(List.size(), static_cast<unsigned>(sizeof(MapEntryTy))) {
129 for (const auto &P : List) {
130 insert(P);
131 }
132 }
133
134 StringMap(StringMap &&RHS)
135 : StringMapImpl(std::move(RHS)), Allocator(std::move(RHS.Allocator)) {}
136
137 StringMap(const StringMap &RHS)
138 : StringMapImpl(static_cast<unsigned>(sizeof(MapEntryTy))),
139 Allocator(RHS.Allocator) {
140 if (RHS.empty())
141 return;
142
143 // Allocate TheTable of the same size as RHS's TheTable, and set the
144 // sentinel appropriately (and NumBuckets).
145 init(RHS.NumBuckets);
146 unsigned *HashTable = (unsigned *)(TheTable + NumBuckets + 1),
147 *RHSHashTable = (unsigned *)(RHS.TheTable + NumBuckets + 1);
148
149 NumItems = RHS.NumItems;
150 NumTombstones = RHS.NumTombstones;
151 for (unsigned I = 0, E = NumBuckets; I != E; ++I) {
152 StringMapEntryBase *Bucket = RHS.TheTable[I];
153 if (!Bucket || Bucket == getTombstoneVal()) {
154 TheTable[I] = Bucket;
155 continue;
156 }
157
158 TheTable[I] = MapEntryTy::Create(
159 static_cast<MapEntryTy *>(Bucket)->getKey(), Allocator,
160 static_cast<MapEntryTy *>(Bucket)->getValue());
161 HashTable[I] = RHSHashTable[I];
162 }
163
164 // Note that here we've copied everything from the RHS into this object,
165 // tombstones included. We could, instead, have re-probed for each key to
166 // instantiate this new object without any tombstone buckets. The
167 // assumption here is that items are rarely deleted from most StringMaps,
168 // and so tombstones are rare, so the cost of re-probing for all inputs is
169 // not worthwhile.
170 }
171
172 StringMap &operator=(StringMap RHS) {
173 StringMapImpl::swap(RHS);
174 std::swap(Allocator, RHS.Allocator);
175 return *this;
176 }
177
178 ~StringMap() {
179 // Delete all the elements in the map, but don't reset the elements
180 // to default values. This is a copy of clear(), but avoids unnecessary
181 // work not required in the destructor.
182 if (!empty()) {
183 for (unsigned I = 0, E = NumBuckets; I != E; ++I) {
184 StringMapEntryBase *Bucket = TheTable[I];
185 if (Bucket && Bucket != getTombstoneVal()) {
186 static_cast<MapEntryTy *>(Bucket)->Destroy(Allocator);
187 }
188 }
189 }
190 free(TheTable);
191 }
192
193 AllocatorTy &getAllocator() { return Allocator; }
194 const AllocatorTy &getAllocator() const { return Allocator; }
195
196 using key_type = const char *;
197 using mapped_type = ValueTy;
198 using value_type = StringMapEntry<ValueTy>;
199 using size_type = size_t;
200
201 using const_iterator = StringMapConstIterator<ValueTy>;
202 using iterator = StringMapIterator<ValueTy>;
203
204 iterator begin() { return iterator(TheTable, NumBuckets == 0); }
205 iterator end() { return iterator(TheTable + NumBuckets, true); }
206 const_iterator begin() const {
207 return const_iterator(TheTable, NumBuckets == 0);
208 }
209 const_iterator end() const {
210 return const_iterator(TheTable + NumBuckets, true);
211 }
212
213 iterator_range<StringMapKeyIterator<ValueTy>> keys() const {
214 return make_range(StringMapKeyIterator<ValueTy>(begin()),
215 StringMapKeyIterator<ValueTy>(end()));
216 }
217
218 iterator find(StringRef Key) {
219 int Bucket = FindKey(Key);
220 if (Bucket == -1)
221 return end();
222 return iterator(TheTable + Bucket, true);
223 }
224
225 const_iterator find(StringRef Key) const {
226 int Bucket = FindKey(Key);
227 if (Bucket == -1)
228 return end();
229 return const_iterator(TheTable + Bucket, true);
230 }
231
232 /// lookup - Return the entry for the specified key, or a default
233 /// constructed value if no such entry exists.
234 ValueTy lookup(StringRef Key) const {
235 const_iterator it = find(Key);
236 if (it != end())
237 return it->second;
238 return ValueTy();
239 }
240
241 /// Lookup the ValueTy for the \p Key, or create a default constructed value
242 /// if the key is not in the map.
243 ValueTy &operator[](StringRef Key) { return try_emplace(Key).first->second; }
244
245 /// count - Return 1 if the element is in the map, 0 otherwise.
246 size_type count(StringRef Key) const { return find(Key) == end() ? 0 : 1; }
247
248 template <typename InputTy>
249 size_type count(const StringMapEntry<InputTy> &MapEntry) const {
250 return count(MapEntry.getKey());
251 }
252
253 /// equal - check whether both of the containers are equal.
254 bool operator==(const StringMap &RHS) const {
255 if (size() != RHS.size())
256 return false;
257
258 for (const auto &KeyValue : *this) {
259 auto FindInRHS = RHS.find(KeyValue.getKey());
260
261 if (FindInRHS == RHS.end())
262 return false;
263
264 if (!(KeyValue.getValue() == FindInRHS->getValue()))
265 return false;
266 }
267
268 return true;
269 }
270
271 bool operator!=(const StringMap &RHS) const { return !(*this == RHS); }
272
273 /// insert - Insert the specified key/value pair into the map. If the key
274 /// already exists in the map, return false and ignore the request, otherwise
275 /// insert it and return true.
276 bool insert(MapEntryTy *KeyValue) {
277 unsigned BucketNo = LookupBucketFor(KeyValue->getKey());
278 StringMapEntryBase *&Bucket = TheTable[BucketNo];
279 if (Bucket && Bucket != getTombstoneVal())
280 return false; // Already exists in map.
281
282 if (Bucket == getTombstoneVal())
283 --NumTombstones;
284 Bucket = KeyValue;
285 ++NumItems;
286 assert(NumItems + NumTombstones <= NumBuckets);
287
288 RehashTable();
289 return true;
290 }
291
292 /// insert - Inserts the specified key/value pair into the map if the key
293 /// isn't already in the map. The bool component of the returned pair is true
294 /// if and only if the insertion takes place, and the iterator component of
295 /// the pair points to the element with key equivalent to the key of the pair.
296 std::pair<iterator, bool> insert(std::pair<StringRef, ValueTy> KV) {
297 return try_emplace(KV.first, std::move(KV.second));
298 }
299
300 /// Inserts an element or assigns to the current element if the key already
301 /// exists. The return type is the same as try_emplace.
302 template <typename V>
303 std::pair<iterator, bool> insert_or_assign(StringRef Key, V &&Val) {
304 auto Ret = try_emplace(Key, std::forward<V>(Val));
305 if (!Ret.second)
306 Ret.first->second = std::forward<V>(Val);
307 return Ret;
308 }
309
310 /// Emplace a new element for the specified key into the map if the key isn't
311 /// already in the map. The bool component of the returned pair is true
312 /// if and only if the insertion takes place, and the iterator component of
313 /// the pair points to the element with key equivalent to the key of the pair.
314 template <typename... ArgsTy>
315 std::pair<iterator, bool> try_emplace(StringRef Key, ArgsTy &&... Args) {
316 unsigned BucketNo = LookupBucketFor(Key);
317 StringMapEntryBase *&Bucket = TheTable[BucketNo];
318 if (Bucket && Bucket != getTombstoneVal())
319 return std::make_pair(iterator(TheTable + BucketNo, false),
320 false); // Already exists in map.
321
322 if (Bucket == getTombstoneVal())
323 --NumTombstones;
324 Bucket = MapEntryTy::Create(Key, Allocator, std::forward<ArgsTy>(Args)...);
325 ++NumItems;
326 assert(NumItems + NumTombstones <= NumBuckets);
327
328 BucketNo = RehashTable(BucketNo);
329 return std::make_pair(iterator(TheTable + BucketNo, false), true);
330 }
331
332 // clear - Empties out the StringMap
333 void clear() {
334 if (empty())
335 return;
336
337 // Zap all values, resetting the keys back to non-present (not tombstone),
338 // which is safe because we're removing all elements.
339 for (unsigned I = 0, E = NumBuckets; I != E; ++I) {
340 StringMapEntryBase *&Bucket = TheTable[I];
341 if (Bucket && Bucket != getTombstoneVal()) {
342 static_cast<MapEntryTy *>(Bucket)->Destroy(Allocator);
343 }
344 Bucket = nullptr;
345 }
346
347 NumItems = 0;
348 NumTombstones = 0;
349 }
350
351 /// remove - Remove the specified key/value pair from the map, but do not
352 /// erase it. This aborts if the key is not in the map.
353 void remove(MapEntryTy *KeyValue) { RemoveKey(KeyValue); }
354
355 void erase(iterator I) {
356 MapEntryTy &V = *I;
357 remove(&V);
358 V.Destroy(Allocator);
359 }
360
361 bool erase(StringRef Key) {
362 iterator I = find(Key);
363 if (I == end())
364 return false;
365 erase(I);
366 return true;
367 }
368};
369
370template <typename DerivedTy, typename ValueTy>
371class StringMapIterBase
372 : public iterator_facade_base<DerivedTy, std::forward_iterator_tag,
373 ValueTy> {
374protected:
375 StringMapEntryBase **Ptr = nullptr;
376
377public:
378 StringMapIterBase() = default;
379
380 explicit StringMapIterBase(StringMapEntryBase **Bucket,
381 bool NoAdvance = false)
382 : Ptr(Bucket) {
383 if (!NoAdvance)
384 AdvancePastEmptyBuckets();
385 }
386
387 DerivedTy &operator=(const DerivedTy &Other) {
388 Ptr = Other.Ptr;
389 return static_cast<DerivedTy &>(*this);
390 }
391
392 friend bool operator==(const DerivedTy &LHS, const DerivedTy &RHS) {
393 return LHS.Ptr == RHS.Ptr;
394 }
395
396 DerivedTy &operator++() { // Preincrement
397 ++Ptr;
398 AdvancePastEmptyBuckets();
399 return static_cast<DerivedTy &>(*this);
400 }
401
402 DerivedTy operator++(int) { // Post-increment
403 DerivedTy Tmp(Ptr);
404 ++*this;
405 return Tmp;
406 }
407
408private:
409 void AdvancePastEmptyBuckets() {
410 while (*Ptr == nullptr || *Ptr == StringMapImpl::getTombstoneVal())
411 ++Ptr;
412 }
413};
414
415template <typename ValueTy>
416class StringMapConstIterator
417 : public StringMapIterBase<StringMapConstIterator<ValueTy>,
418 const StringMapEntry<ValueTy>> {
419 using base = StringMapIterBase<StringMapConstIterator<ValueTy>,
420 const StringMapEntry<ValueTy>>;
421
422public:
423 StringMapConstIterator() = default;
424 explicit StringMapConstIterator(StringMapEntryBase **Bucket,
425 bool NoAdvance = false)
426 : base(Bucket, NoAdvance) {}
427
428 const StringMapEntry<ValueTy> &operator*() const {
429 return *static_cast<const StringMapEntry<ValueTy> *>(*this->Ptr);
430 }
431};
432
433template <typename ValueTy>
434class StringMapIterator : public StringMapIterBase<StringMapIterator<ValueTy>,
435 StringMapEntry<ValueTy>> {
436 using base =
437 StringMapIterBase<StringMapIterator<ValueTy>, StringMapEntry<ValueTy>>;
438
439public:
440 StringMapIterator() = default;
441 explicit StringMapIterator(StringMapEntryBase **Bucket,
442 bool NoAdvance = false)
443 : base(Bucket, NoAdvance) {}
444
445 StringMapEntry<ValueTy> &operator*() const {
446 return *static_cast<StringMapEntry<ValueTy> *>(*this->Ptr);
447 }
448
449 operator StringMapConstIterator<ValueTy>() const {
450 return StringMapConstIterator<ValueTy>(this->Ptr, true);
451 }
452};
453
454template <typename ValueTy>
455class StringMapKeyIterator
456 : public iterator_adaptor_base<StringMapKeyIterator<ValueTy>,
457 StringMapConstIterator<ValueTy>,
458 std::forward_iterator_tag, StringRef> {
459 using base = iterator_adaptor_base<StringMapKeyIterator<ValueTy>,
460 StringMapConstIterator<ValueTy>,
461 std::forward_iterator_tag, StringRef>;
462
463public:
464 StringMapKeyIterator() = default;
465 explicit StringMapKeyIterator(StringMapConstIterator<ValueTy> Iter)
466 : base(std::move(Iter)) {}
467
468 StringRef &operator*() {
469 Key = this->wrapped()->getKey();
470 return Key;
471 }
472
473private:
474 StringRef Key;
475};
476
477} // end namespace llvm
478
479#endif // LLVM_ADT_STRINGMAP_H
480