2007-02-08 19:20:57 +00:00
|
|
|
//===--- StringMap.cpp - String Hash table map implementation -------------===//
|
2006-10-29 23:42:03 +00:00
|
|
|
//
|
|
|
|
// The LLVM Compiler Infrastructure
|
|
|
|
//
|
2007-12-29 20:36:04 +00:00
|
|
|
// This file is distributed under the University of Illinois Open Source
|
|
|
|
// License. See LICENSE.TXT for details.
|
2006-10-29 23:42:03 +00:00
|
|
|
//
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
//
|
2007-02-08 19:20:57 +00:00
|
|
|
// This file implements the StringMap class.
|
2006-10-29 23:42:03 +00:00
|
|
|
//
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
2007-02-08 19:20:57 +00:00
|
|
|
#include "llvm/ADT/StringMap.h"
|
2009-10-17 18:21:06 +00:00
|
|
|
#include "llvm/ADT/StringExtras.h"
|
2012-08-29 22:57:04 +00:00
|
|
|
#include "llvm/Support/Compiler.h"
|
2006-10-29 23:42:03 +00:00
|
|
|
#include <cassert>
|
|
|
|
using namespace llvm;
|
|
|
|
|
2007-02-08 19:20:57 +00:00
|
|
|
StringMapImpl::StringMapImpl(unsigned InitSize, unsigned itemSize) {
|
2007-04-04 00:29:37 +00:00
|
|
|
ItemSize = itemSize;
|
|
|
|
|
|
|
|
// If a size is specified, initialize the table with that many buckets.
|
|
|
|
if (InitSize) {
|
|
|
|
init(InitSize);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Otherwise, initialize it with zero buckets to avoid the allocation.
|
2014-04-07 04:17:22 +00:00
|
|
|
TheTable = nullptr;
|
2007-04-04 00:29:37 +00:00
|
|
|
NumBuckets = 0;
|
|
|
|
NumItems = 0;
|
|
|
|
NumTombstones = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
void StringMapImpl::init(unsigned InitSize) {
|
2006-10-29 23:42:03 +00:00
|
|
|
assert((InitSize & (InitSize-1)) == 0 &&
|
|
|
|
"Init Size must be a power of 2 or zero!");
|
2007-04-03 22:15:38 +00:00
|
|
|
NumBuckets = InitSize ? InitSize : 16;
|
2006-10-29 23:42:03 +00:00
|
|
|
NumItems = 0;
|
2007-02-11 20:58:00 +00:00
|
|
|
NumTombstones = 0;
|
2006-10-29 23:42:03 +00:00
|
|
|
|
2011-12-27 20:35:07 +00:00
|
|
|
TheTable = (StringMapEntryBase **)calloc(NumBuckets+1,
|
|
|
|
sizeof(StringMapEntryBase **) +
|
|
|
|
sizeof(unsigned));
|
|
|
|
|
2007-02-11 08:20:35 +00:00
|
|
|
// Allocate one extra bucket, set it to look filled so the iterators stop at
|
|
|
|
// end.
|
2011-12-27 20:35:07 +00:00
|
|
|
TheTable[NumBuckets] = (StringMapEntryBase*)2;
|
2006-10-29 23:42:03 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/// LookupBucketFor - Look up the bucket that the specified string should end
|
|
|
|
/// up in. If it already exists as a key in the map, the Item pointer for the
|
|
|
|
/// specified bucket will be non-null. Otherwise, it will be null. In either
|
|
|
|
/// case, the FullHashValue field of the bucket will be set to the hash value
|
|
|
|
/// of the string.
|
2009-11-06 10:58:06 +00:00
|
|
|
unsigned StringMapImpl::LookupBucketFor(StringRef Name) {
|
2006-10-29 23:42:03 +00:00
|
|
|
unsigned HTSize = NumBuckets;
|
2007-04-04 00:29:37 +00:00
|
|
|
if (HTSize == 0) { // Hash table unallocated so far?
|
|
|
|
init(16);
|
|
|
|
HTSize = NumBuckets;
|
|
|
|
}
|
2009-10-17 18:21:06 +00:00
|
|
|
unsigned FullHashValue = HashString(Name);
|
2006-10-29 23:42:03 +00:00
|
|
|
unsigned BucketNo = FullHashValue & (HTSize-1);
|
2011-12-27 20:35:07 +00:00
|
|
|
unsigned *HashTable = (unsigned *)(TheTable + NumBuckets + 1);
|
|
|
|
|
2006-10-29 23:42:03 +00:00
|
|
|
unsigned ProbeAmt = 1;
|
2007-02-11 20:58:00 +00:00
|
|
|
int FirstTombstone = -1;
|
2006-10-29 23:42:03 +00:00
|
|
|
while (1) {
|
2011-12-27 20:35:07 +00:00
|
|
|
StringMapEntryBase *BucketItem = TheTable[BucketNo];
|
2006-10-29 23:42:03 +00:00
|
|
|
// If we found an empty bucket, this key isn't in the table yet, return it.
|
2014-04-09 04:20:00 +00:00
|
|
|
if (LLVM_LIKELY(!BucketItem)) {
|
2007-02-11 20:58:00 +00:00
|
|
|
// If we found a tombstone, we want to reuse the tombstone instead of an
|
|
|
|
// empty bucket. This reduces probing.
|
|
|
|
if (FirstTombstone != -1) {
|
2011-12-27 20:35:07 +00:00
|
|
|
HashTable[FirstTombstone] = FullHashValue;
|
2007-02-11 20:58:00 +00:00
|
|
|
return FirstTombstone;
|
|
|
|
}
|
|
|
|
|
2011-12-27 20:35:07 +00:00
|
|
|
HashTable[BucketNo] = FullHashValue;
|
2006-10-29 23:42:03 +00:00
|
|
|
return BucketNo;
|
|
|
|
}
|
|
|
|
|
2007-02-11 20:58:00 +00:00
|
|
|
if (BucketItem == getTombstoneVal()) {
|
|
|
|
// Skip over tombstones. However, remember the first one we see.
|
|
|
|
if (FirstTombstone == -1) FirstTombstone = BucketNo;
|
2012-08-29 22:57:04 +00:00
|
|
|
} else if (LLVM_LIKELY(HashTable[BucketNo] == FullHashValue)) {
|
2007-02-11 20:58:00 +00:00
|
|
|
// If the full hash value matches, check deeply for a match. The common
|
|
|
|
// case here is that we are only looking at the buckets (for item info
|
|
|
|
// being non-null and for the full hash value) not at the items. This
|
|
|
|
// is important for cache locality.
|
|
|
|
|
2009-07-23 18:17:34 +00:00
|
|
|
// Do the comparison like this because Name isn't necessarily
|
2006-10-29 23:42:03 +00:00
|
|
|
// null-terminated!
|
|
|
|
char *ItemStr = (char*)BucketItem+ItemSize;
|
2009-07-23 18:17:34 +00:00
|
|
|
if (Name == StringRef(ItemStr, BucketItem->getKeyLength())) {
|
2006-10-29 23:42:03 +00:00
|
|
|
// We found a match!
|
|
|
|
return BucketNo;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// Okay, we didn't find the item. Probe to the next bucket.
|
|
|
|
BucketNo = (BucketNo+ProbeAmt) & (HTSize-1);
|
|
|
|
|
|
|
|
// Use quadratic probing, it has fewer clumping artifacts than linear
|
|
|
|
// probing and has good cache behavior in the common case.
|
|
|
|
++ProbeAmt;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2007-02-11 19:49:41 +00:00
|
|
|
|
|
|
|
/// FindKey - Look up the bucket that contains the specified key. If it exists
|
|
|
|
/// in the map, return the bucket number of the key. Otherwise return -1.
|
|
|
|
/// This does not modify the map.
|
2009-11-06 10:58:06 +00:00
|
|
|
int StringMapImpl::FindKey(StringRef Key) const {
|
2007-02-11 19:49:41 +00:00
|
|
|
unsigned HTSize = NumBuckets;
|
2007-04-04 00:29:37 +00:00
|
|
|
if (HTSize == 0) return -1; // Really empty table?
|
2009-10-17 18:21:06 +00:00
|
|
|
unsigned FullHashValue = HashString(Key);
|
2007-02-11 19:49:41 +00:00
|
|
|
unsigned BucketNo = FullHashValue & (HTSize-1);
|
2011-12-27 20:35:07 +00:00
|
|
|
unsigned *HashTable = (unsigned *)(TheTable + NumBuckets + 1);
|
|
|
|
|
2007-02-11 19:49:41 +00:00
|
|
|
unsigned ProbeAmt = 1;
|
|
|
|
while (1) {
|
2011-12-27 20:35:07 +00:00
|
|
|
StringMapEntryBase *BucketItem = TheTable[BucketNo];
|
2007-02-11 19:49:41 +00:00
|
|
|
// If we found an empty bucket, this key isn't in the table yet, return.
|
2014-04-09 04:20:00 +00:00
|
|
|
if (LLVM_LIKELY(!BucketItem))
|
2007-02-11 19:49:41 +00:00
|
|
|
return -1;
|
|
|
|
|
2007-02-11 20:58:00 +00:00
|
|
|
if (BucketItem == getTombstoneVal()) {
|
|
|
|
// Ignore tombstones.
|
2012-08-29 22:57:04 +00:00
|
|
|
} else if (LLVM_LIKELY(HashTable[BucketNo] == FullHashValue)) {
|
2007-02-11 20:58:00 +00:00
|
|
|
// If the full hash value matches, check deeply for a match. The common
|
|
|
|
// case here is that we are only looking at the buckets (for item info
|
|
|
|
// being non-null and for the full hash value) not at the items. This
|
|
|
|
// is important for cache locality.
|
|
|
|
|
2007-02-11 19:49:41 +00:00
|
|
|
// Do the comparison like this because NameStart isn't necessarily
|
|
|
|
// null-terminated!
|
|
|
|
char *ItemStr = (char*)BucketItem+ItemSize;
|
2009-07-23 18:17:34 +00:00
|
|
|
if (Key == StringRef(ItemStr, BucketItem->getKeyLength())) {
|
2007-02-11 19:49:41 +00:00
|
|
|
// We found a match!
|
|
|
|
return BucketNo;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// Okay, we didn't find the item. Probe to the next bucket.
|
|
|
|
BucketNo = (BucketNo+ProbeAmt) & (HTSize-1);
|
|
|
|
|
|
|
|
// Use quadratic probing, it has fewer clumping artifacts than linear
|
|
|
|
// probing and has good cache behavior in the common case.
|
|
|
|
++ProbeAmt;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2007-02-11 20:58:00 +00:00
|
|
|
/// RemoveKey - Remove the specified StringMapEntry from the table, but do not
|
|
|
|
/// delete it. This aborts if the value isn't in the table.
|
|
|
|
void StringMapImpl::RemoveKey(StringMapEntryBase *V) {
|
|
|
|
const char *VStr = (char*)V + ItemSize;
|
2009-07-23 18:17:34 +00:00
|
|
|
StringMapEntryBase *V2 = RemoveKey(StringRef(VStr, V->getKeyLength()));
|
2010-12-23 00:58:24 +00:00
|
|
|
(void)V2;
|
2007-02-11 20:58:00 +00:00
|
|
|
assert(V == V2 && "Didn't find key?");
|
|
|
|
}
|
|
|
|
|
|
|
|
/// RemoveKey - Remove the StringMapEntry for the specified key from the
|
|
|
|
/// table, returning it. If the key is not in the table, this returns null.
|
2009-11-06 10:58:06 +00:00
|
|
|
StringMapEntryBase *StringMapImpl::RemoveKey(StringRef Key) {
|
2009-07-23 18:17:34 +00:00
|
|
|
int Bucket = FindKey(Key);
|
2014-04-07 04:17:22 +00:00
|
|
|
if (Bucket == -1) return nullptr;
|
2007-02-11 20:58:00 +00:00
|
|
|
|
2011-12-27 20:35:07 +00:00
|
|
|
StringMapEntryBase *Result = TheTable[Bucket];
|
|
|
|
TheTable[Bucket] = getTombstoneVal();
|
2007-02-11 20:58:00 +00:00
|
|
|
--NumItems;
|
|
|
|
++NumTombstones;
|
2011-03-30 18:32:51 +00:00
|
|
|
assert(NumItems + NumTombstones <= NumBuckets);
|
|
|
|
|
2007-02-11 20:58:00 +00:00
|
|
|
return Result;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2007-02-11 19:49:41 +00:00
|
|
|
|
2006-10-29 23:42:03 +00:00
|
|
|
/// RehashTable - Grow the table, redistributing values into the buckets with
|
|
|
|
/// the appropriate mod-of-hashtable-size.
|
2014-06-23 18:28:53 +00:00
|
|
|
unsigned StringMapImpl::RehashTable(unsigned BucketNo) {
|
2011-03-30 18:32:44 +00:00
|
|
|
unsigned NewSize;
|
2011-12-27 20:35:07 +00:00
|
|
|
unsigned *HashTable = (unsigned *)(TheTable + NumBuckets + 1);
|
2011-03-30 18:32:44 +00:00
|
|
|
|
|
|
|
// If the hash table is now more than 3/4 full, or if fewer than 1/8 of
|
|
|
|
// the buckets are empty (meaning that many are filled with tombstones),
|
|
|
|
// grow/rehash the table.
|
|
|
|
if (NumItems*4 > NumBuckets*3) {
|
|
|
|
NewSize = NumBuckets*2;
|
2012-06-19 17:40:35 +00:00
|
|
|
} else if (NumBuckets-(NumItems+NumTombstones) <= NumBuckets/8) {
|
2011-03-30 18:32:44 +00:00
|
|
|
NewSize = NumBuckets;
|
|
|
|
} else {
|
2014-06-23 18:28:53 +00:00
|
|
|
return BucketNo;
|
2011-03-30 18:32:44 +00:00
|
|
|
}
|
|
|
|
|
2014-06-23 18:28:53 +00:00
|
|
|
unsigned NewBucketNo = BucketNo;
|
2007-02-11 08:20:35 +00:00
|
|
|
// Allocate one extra bucket which will always be non-empty. This allows the
|
|
|
|
// iterators to stop at end.
|
2011-12-27 20:35:07 +00:00
|
|
|
StringMapEntryBase **NewTableArray =
|
|
|
|
(StringMapEntryBase **)calloc(NewSize+1, sizeof(StringMapEntryBase *) +
|
|
|
|
sizeof(unsigned));
|
|
|
|
unsigned *NewHashArray = (unsigned *)(NewTableArray + NewSize + 1);
|
|
|
|
NewTableArray[NewSize] = (StringMapEntryBase*)2;
|
|
|
|
|
2006-10-29 23:42:03 +00:00
|
|
|
// Rehash all the items into their new buckets. Luckily :) we already have
|
|
|
|
// the hash values available, so we don't have to rehash any strings.
|
2011-12-27 20:35:07 +00:00
|
|
|
for (unsigned I = 0, E = NumBuckets; I != E; ++I) {
|
|
|
|
StringMapEntryBase *Bucket = TheTable[I];
|
|
|
|
if (Bucket && Bucket != getTombstoneVal()) {
|
2006-10-29 23:42:03 +00:00
|
|
|
// Fast case, bucket available.
|
2011-12-27 20:35:07 +00:00
|
|
|
unsigned FullHash = HashTable[I];
|
2006-10-29 23:42:03 +00:00
|
|
|
unsigned NewBucket = FullHash & (NewSize-1);
|
2014-04-09 04:20:00 +00:00
|
|
|
if (!NewTableArray[NewBucket]) {
|
2011-12-27 20:35:07 +00:00
|
|
|
NewTableArray[FullHash & (NewSize-1)] = Bucket;
|
|
|
|
NewHashArray[FullHash & (NewSize-1)] = FullHash;
|
2014-06-23 18:28:53 +00:00
|
|
|
if (I == BucketNo)
|
|
|
|
NewBucketNo = NewBucket;
|
2006-10-29 23:42:03 +00:00
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
2007-02-11 20:58:00 +00:00
|
|
|
// Otherwise probe for a spot.
|
2006-10-29 23:42:03 +00:00
|
|
|
unsigned ProbeSize = 1;
|
|
|
|
do {
|
|
|
|
NewBucket = (NewBucket + ProbeSize++) & (NewSize-1);
|
2011-12-27 20:35:07 +00:00
|
|
|
} while (NewTableArray[NewBucket]);
|
2006-10-29 23:42:03 +00:00
|
|
|
|
|
|
|
// Finally found a slot. Fill it in.
|
2011-12-27 20:35:07 +00:00
|
|
|
NewTableArray[NewBucket] = Bucket;
|
|
|
|
NewHashArray[NewBucket] = FullHash;
|
2014-06-23 18:28:53 +00:00
|
|
|
if (I == BucketNo)
|
|
|
|
NewBucketNo = NewBucket;
|
2006-10-29 23:42:03 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2007-04-04 17:24:28 +00:00
|
|
|
free(TheTable);
|
2006-10-29 23:42:03 +00:00
|
|
|
|
|
|
|
TheTable = NewTableArray;
|
|
|
|
NumBuckets = NewSize;
|
2011-03-30 18:32:51 +00:00
|
|
|
NumTombstones = 0;
|
2014-06-23 18:28:53 +00:00
|
|
|
return NewBucketNo;
|
2006-10-29 23:42:03 +00:00
|
|
|
}
|