6502/llvm-6502
1
0
Fork 0
mirror of https://github.com/c64scene-ar/llvm-6502.git synced 2025-07-25 13:24:46 +00:00
Code Issues Projects Releases Wiki Activity

Convert StringMap to using StringRef for its APIs.

Browse Source 
- Yay for '-'s and simplifications!

 - I kept StringMap::GetOrCreateValue for compatibility purposes, this can
   eventually go away. Likewise the StringMapEntry Create functions still follow
   the old style.

 - NIFC.


git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@76888 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Daniel Dunbar
2009-07-23 18:17:34 +00:00
parent b53cc014d0
commit 6316fbcb04
12 changed files with 91 additions and 128 deletions
Download Patch File Download Diff File Expand all files Collapse all files

96
include/llvm/ADT/StringMap.h
View File

@@ -14,6 +14,7 @@
#ifndef LLVM_ADT_STRINGMAP_H #ifndef LLVM_ADT_STRINGMAP_H
#define LLVM_ADT_STRINGMAP_H #define LLVM_ADT_STRINGMAP_H
#include "llvm/ADT/StringRef.h"
#include "llvm/Support/Allocator.h" #include "llvm/Support/Allocator.h"
#include <cstring> #include <cstring>
#include <string> #include <string>
@@ -95,12 +96,12 @@ protected:
/// specified bucket will be non-null. Otherwise, it will be null. In either /// 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 /// case, the FullHashValue field of the bucket will be set to the hash value
/// of the string. /// of the string.
unsigned LookupBucketFor(const char *KeyStart, const char *KeyEnd); unsigned LookupBucketFor(const StringRef &Key);
/// FindKey - Look up the bucket that contains the specified key. If it exists /// 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. /// in the map, return the bucket number of the key. Otherwise return -1.
/// This does not modify the map. /// This does not modify the map.
int FindKey(const char *KeyStart, const char *KeyEnd) const; int FindKey(const StringRef &Key) const;
/// RemoveKey - Remove the specified StringMapEntry from the table, but do not /// RemoveKey - Remove the specified StringMapEntry from the table, but do not
/// delete it. This aborts if the value isn't in the table. /// delete it. This aborts if the value isn't in the table.
@@ -108,7 +109,7 @@ protected:
/// RemoveKey - Remove the StringMapEntry for the specified key from the /// RemoveKey - Remove the StringMapEntry for the specified key from the
/// table, returning it. If the key is not in the table, this returns null. /// table, returning it. If the key is not in the table, this returns null.
StringMapEntryBase *RemoveKey(const char *KeyStart, const char *KeyEnd); StringMapEntryBase *RemoveKey(const StringRef &Key);
private: private:
void init(unsigned Size); void init(unsigned Size);
public: public:
@@ -136,6 +137,10 @@ public:
StringMapEntry(unsigned strLen, const ValueTy &V) StringMapEntry(unsigned strLen, const ValueTy &V)
: StringMapEntryBase(strLen), second(V) {} : StringMapEntryBase(strLen), second(V) {}
StringRef getKey() const {
return StringRef(getKeyData(), getKeyLength());
}
const ValueTy &getValue() const { return second; } const ValueTy &getValue() const { return second; }
ValueTy &getValue() { return second; } ValueTy &getValue() { return second; }
@@ -277,75 +282,40 @@ public:
return const_iterator(TheTable+NumBuckets, true); return const_iterator(TheTable+NumBuckets, true);
} }
iterator find(const char *KeyStart, const char *KeyEnd) { iterator find(const StringRef &Key) {
int Bucket = FindKey(KeyStart, KeyEnd); int Bucket = FindKey(Key);
if (Bucket == -1) return end(); if (Bucket == -1) return end();
return iterator(TheTable+Bucket); return iterator(TheTable+Bucket);
} }
iterator find(const char *Key) {
return find(Key, Key + strlen(Key));
}
iterator find(const std::string &Key) {
return find(Key.data(), Key.data() + Key.size());
}
const_iterator find(const char *KeyStart, const char *KeyEnd) const { const_iterator find(const StringRef &Key) const {
int Bucket = FindKey(KeyStart, KeyEnd); int Bucket = FindKey(Key);
if (Bucket == -1) return end(); if (Bucket == -1) return end();
return const_iterator(TheTable+Bucket); return const_iterator(TheTable+Bucket);
} }
const_iterator find(const char *Key) const {
return find(Key, Key + strlen(Key));
}
const_iterator find(const std::string &Key) const {
return find(Key.data(), Key.data() + Key.size());
}
/// lookup - Return the entry for the specified key, or a default /// lookup - Return the entry for the specified key, or a default
/// constructed value if no such entry exists. /// constructed value if no such entry exists.
ValueTy lookup(const char *KeyStart, const char *KeyEnd) const { ValueTy lookup(const StringRef &Key) const {
const_iterator it = find(KeyStart, KeyEnd);
if (it != end())
return it->second;
return ValueTy();
}
ValueTy lookup(const char *Key) const {
const_iterator it = find(Key);
if (it != end())
return it->second;
return ValueTy();
}
ValueTy lookup(const std::string &Key) const {
const_iterator it = find(Key); const_iterator it = find(Key);
if (it != end()) if (it != end())
return it->second; return it->second;
return ValueTy(); return ValueTy();
} }
ValueTy& operator[](const char *Key) { ValueTy& operator[](const StringRef &Key) {
return GetOrCreateValue(Key, Key + strlen(Key)).getValue(); return GetOrCreateValue(Key).getValue();
}
ValueTy& operator[](const std::string &Key) {
return GetOrCreateValue(Key.data(), Key.data() + Key.size()).getValue();
} }
size_type count(const char *KeyStart, const char *KeyEnd) const { size_type count(const StringRef &Key) const {
return find(KeyStart, KeyEnd) == end() ? 0 : 1; return find(Key) == end() ? 0 : 1;
}
size_type count(const char *Key) const {
return count(Key, Key + strlen(Key));
}
size_type count(const std::string &Key) const {
return count(Key.data(), Key.data() + Key.size());
} }
/// insert - Insert the specified key/value pair into the map. If the key /// insert - Insert the specified key/value pair into the map. If the key
/// already exists in the map, return false and ignore the request, otherwise /// already exists in the map, return false and ignore the request, otherwise
/// insert it and return true. /// insert it and return true.
bool insert(MapEntryTy *KeyValue) { bool insert(MapEntryTy *KeyValue) {
unsigned BucketNo = unsigned BucketNo = LookupBucketFor(KeyValue->getKey());
LookupBucketFor(KeyValue->getKeyData(),
KeyValue->getKeyData()+KeyValue->getKeyLength());
ItemBucket &Bucket = TheTable[BucketNo]; ItemBucket &Bucket = TheTable[BucketNo];
if (Bucket.Item && Bucket.Item != getTombstoneVal()) if (Bucket.Item && Bucket.Item != getTombstoneVal())
return false; // Already exists in map. return false; // Already exists in map.
@@ -380,15 +350,15 @@ public:
/// exists, return it. Otherwise, default construct a value, insert it, and /// exists, return it. Otherwise, default construct a value, insert it, and
/// return. /// return.
template <typename InitTy> template <typename InitTy>
StringMapEntry<ValueTy> &GetOrCreateValue(const char *KeyStart, StringMapEntry<ValueTy> &GetOrCreateValue(const StringRef &Key,
const char *KeyEnd,
InitTy Val) { InitTy Val) {
unsigned BucketNo = LookupBucketFor(KeyStart, KeyEnd); unsigned BucketNo = LookupBucketFor(Key);
ItemBucket &Bucket = TheTable[BucketNo]; ItemBucket &Bucket = TheTable[BucketNo];
if (Bucket.Item && Bucket.Item != getTombstoneVal()) if (Bucket.Item && Bucket.Item != getTombstoneVal())
return *static_cast<MapEntryTy*>(Bucket.Item); return *static_cast<MapEntryTy*>(Bucket.Item);
MapEntryTy *NewItem = MapEntryTy::Create(KeyStart, KeyEnd, Allocator, Val); MapEntryTy *NewItem =
MapEntryTy::Create(Key.begin(), Key.end(), Allocator, Val);
if (Bucket.Item == getTombstoneVal()) if (Bucket.Item == getTombstoneVal())
--NumTombstones; --NumTombstones;
@@ -403,9 +373,20 @@ public:
return *NewItem; return *NewItem;
} }
StringMapEntry<ValueTy> &GetOrCreateValue(const StringRef &Key) {
return GetOrCreateValue(Key, ValueTy());
}
template <typename InitTy>
StringMapEntry<ValueTy> &GetOrCreateValue(const char *KeyStart,
const char *KeyEnd,
InitTy Val) {
return GetOrCreateValue(StringRef(KeyStart, KeyEnd - KeyStart), Val);
}
StringMapEntry<ValueTy> &GetOrCreateValue(const char *KeyStart, StringMapEntry<ValueTy> &GetOrCreateValue(const char *KeyStart,
const char *KeyEnd) { const char *KeyEnd) {
return GetOrCreateValue(KeyStart, KeyEnd, ValueTy()); return GetOrCreateValue(StringRef(KeyStart, KeyEnd - KeyStart));
} }
/// remove - Remove the specified key/value pair from the map, but do not /// remove - Remove the specified key/value pair from the map, but do not
@@ -420,14 +401,7 @@ public:
V.Destroy(Allocator); V.Destroy(Allocator);
} }
bool erase(const char *Key) { bool erase(const StringRef &Key) {
iterator I = find(Key);
if (I == end()) return false;
erase(I);
return true;
}
bool erase(const std::string &Key) {
iterator I = find(Key); iterator I = find(Key);
if (I == end()) return false; if (I == end()) return false;
erase(I); erase(I);

13
include/llvm/Support/StringPool.h
View File

@@ -1,4 +1,4 @@
//===-- StringPool.h - Interned string pool -------------------------------===// //===-- StringPool.h - Interned string pool ---------------------*- C++ -*-===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
@@ -64,12 +64,7 @@ namespace llvm {
/// intern - Adds a string to the pool and returns a reference-counted /// intern - Adds a string to the pool and returns a reference-counted
/// pointer to it. No additional memory is allocated if the string already /// pointer to it. No additional memory is allocated if the string already
/// exists in the pool. /// exists in the pool.
PooledStringPtr intern(const char *Begin, const char *End); PooledStringPtr intern(const StringRef &Str);
/// intern - Adds a null-terminated string to the pool and returns a
/// reference-counted pointer to it. No additional memory is allocated if
/// the string already exists in the pool.
inline PooledStringPtr intern(const char *Str);
/// empty - Checks whether the pool is empty. Returns true if so. /// empty - Checks whether the pool is empty. Returns true if so.
/// ///
@@ -139,10 +134,6 @@ namespace llvm {
inline bool operator!=(const PooledStringPtr &That) { return S != That.S; } inline bool operator!=(const PooledStringPtr &That) { return S != That.S; }
}; };
PooledStringPtr StringPool::intern(const char *Str) {
return intern(Str, Str + strlen(Str));
}
} // End llvm namespace } // End llvm namespace
#endif #endif

2
lib/Analysis/LibCallSemantics.cpp
View File

@@ -59,7 +59,7 @@ const LibCallFunctionInfo *LibCallInfo::getFunctionInfo(Function *F) const {
// Look up this function in the string map. // Look up this function in the string map.
const char *ValueName = F->getNameStart(); const char *ValueName = F->getNameStart();
StringMap<const LibCallFunctionInfo*>::iterator I = StringMap<const LibCallFunctionInfo*>::iterator I =
Map->find(ValueName, ValueName+F->getNameLen()); Map->find(StringRef(ValueName, F->getNameLen()));
return I != Map->end() ? I->second : 0; return I != Map->end() ? I->second : 0;
} }

9
lib/CodeGen/GCMetadata.cpp
View File

@@ -75,20 +75,17 @@ GCModuleInfo::~GCModuleInfo() {
GCStrategy *GCModuleInfo::getOrCreateStrategy(const Module *M, GCStrategy *GCModuleInfo::getOrCreateStrategy(const Module *M,
const std::string &Name) { const std::string &Name) {
const char *Start = Name.c_str(); strategy_map_type::iterator NMI = StrategyMap.find(Name);
strategy_map_type::iterator NMI =
StrategyMap.find(Start, Start + Name.size());
if (NMI != StrategyMap.end()) if (NMI != StrategyMap.end())
return NMI->getValue(); return NMI->getValue();
for (GCRegistry::iterator I = GCRegistry::begin(), for (GCRegistry::iterator I = GCRegistry::begin(),
E = GCRegistry::end(); I != E; ++I) { E = GCRegistry::end(); I != E; ++I) {
if (strcmp(Start, I->getName()) == 0) { if (Name == I->getName()) {
GCStrategy *S = I->instantiate(); GCStrategy *S = I->instantiate();
S->M = M; S->M = M;
S->Name = Name; S->Name = Name;
StrategyMap.GetOrCreateValue(Start, Start + Name.size()).setValue(S); StrategyMap.GetOrCreateValue(Name).setValue(S);
StrategyList.push_back(S); StrategyList.push_back(S);
return S; return S;
} }

26
lib/Support/StringMap.cpp
View File

@@ -65,14 +65,13 @@ static unsigned HashString(const char *Start, const char *End) {
/// specified bucket will be non-null. Otherwise, it will be null. In either /// 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 /// case, the FullHashValue field of the bucket will be set to the hash value
/// of the string. /// of the string.
unsigned StringMapImpl::LookupBucketFor(const char *NameStart, unsigned StringMapImpl::LookupBucketFor(const StringRef &Name) {
const char *NameEnd) {
unsigned HTSize = NumBuckets; unsigned HTSize = NumBuckets;
if (HTSize == 0) { // Hash table unallocated so far? if (HTSize == 0) { // Hash table unallocated so far?
init(16); init(16);
HTSize = NumBuckets; HTSize = NumBuckets;
} }
unsigned FullHashValue = HashString(NameStart, NameEnd); unsigned FullHashValue = HashString(Name.begin(), Name.end());
unsigned BucketNo = FullHashValue & (HTSize-1); unsigned BucketNo = FullHashValue & (HTSize-1);
unsigned ProbeAmt = 1; unsigned ProbeAmt = 1;
@@ -102,12 +101,10 @@ unsigned StringMapImpl::LookupBucketFor(const char *NameStart,
// being non-null and for the full hash value) not at the items. This // being non-null and for the full hash value) not at the items. This
// is important for cache locality. // is important for cache locality.
// Do the comparison like this because NameStart isn't necessarily // Do the comparison like this because Name isn't necessarily
// null-terminated! // null-terminated!
char *ItemStr = (char*)BucketItem+ItemSize; char *ItemStr = (char*)BucketItem+ItemSize;
unsigned ItemStrLen = BucketItem->getKeyLength(); if (Name == StringRef(ItemStr, BucketItem->getKeyLength())) {
if (unsigned(NameEnd-NameStart) == ItemStrLen &&
memcmp(ItemStr, NameStart, ItemStrLen) == 0) {
// We found a match! // We found a match!
return BucketNo; return BucketNo;
} }
@@ -126,10 +123,10 @@ unsigned StringMapImpl::LookupBucketFor(const char *NameStart,
/// FindKey - Look up the bucket that contains the specified key. If it exists /// 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. /// in the map, return the bucket number of the key. Otherwise return -1.
/// This does not modify the map. /// This does not modify the map.
int StringMapImpl::FindKey(const char *KeyStart, const char *KeyEnd) const { int StringMapImpl::FindKey(const StringRef &Key) const {
unsigned HTSize = NumBuckets; unsigned HTSize = NumBuckets;
if (HTSize == 0) return -1; // Really empty table? if (HTSize == 0) return -1; // Really empty table?
unsigned FullHashValue = HashString(KeyStart, KeyEnd); unsigned FullHashValue = HashString(Key.begin(), Key.end());
unsigned BucketNo = FullHashValue & (HTSize-1); unsigned BucketNo = FullHashValue & (HTSize-1);
unsigned ProbeAmt = 1; unsigned ProbeAmt = 1;
@@ -151,9 +148,7 @@ int StringMapImpl::FindKey(const char *KeyStart, const char *KeyEnd) const {
// Do the comparison like this because NameStart isn't necessarily // Do the comparison like this because NameStart isn't necessarily
// null-terminated! // null-terminated!
char *ItemStr = (char*)BucketItem+ItemSize; char *ItemStr = (char*)BucketItem+ItemSize;
unsigned ItemStrLen = BucketItem->getKeyLength(); if (Key == StringRef(ItemStr, BucketItem->getKeyLength())) {
if (unsigned(KeyEnd-KeyStart) == ItemStrLen &&
memcmp(ItemStr, KeyStart, ItemStrLen) == 0) {
// We found a match! // We found a match!
return BucketNo; return BucketNo;
} }
@@ -172,16 +167,15 @@ int StringMapImpl::FindKey(const char *KeyStart, const char *KeyEnd) const {
/// delete it. This aborts if the value isn't in the table. /// delete it. This aborts if the value isn't in the table.
void StringMapImpl::RemoveKey(StringMapEntryBase *V) { void StringMapImpl::RemoveKey(StringMapEntryBase *V) {
const char *VStr = (char*)V + ItemSize; const char *VStr = (char*)V + ItemSize;
StringMapEntryBase *V2 = RemoveKey(VStr, VStr+V->getKeyLength()); StringMapEntryBase *V2 = RemoveKey(StringRef(VStr, V->getKeyLength()));
V2 = V2; V2 = V2;
assert(V == V2 && "Didn't find key?"); assert(V == V2 && "Didn't find key?");
} }
/// RemoveKey - Remove the StringMapEntry for the specified key from the /// RemoveKey - Remove the StringMapEntry for the specified key from the
/// table, returning it. If the key is not in the table, this returns null. /// table, returning it. If the key is not in the table, this returns null.
StringMapEntryBase *StringMapImpl::RemoveKey(const char *KeyStart, StringMapEntryBase *StringMapImpl::RemoveKey(const StringRef &Key) {
const char *KeyEnd) { int Bucket = FindKey(Key);
int Bucket = FindKey(KeyStart, KeyEnd);
if (Bucket == -1) return 0; if (Bucket == -1) return 0;
StringMapEntryBase *Result = TheTable[Bucket].Item; StringMapEntryBase *Result = TheTable[Bucket].Item;

7
lib/Support/StringPool.cpp
View File

@@ -13,6 +13,7 @@
#include "llvm/Support/StringPool.h" #include "llvm/Support/StringPool.h"
#include "llvm/Support/Streams.h" #include "llvm/Support/Streams.h"
#include "llvm/ADT/StringRef.h"
using namespace llvm; using namespace llvm;
@@ -22,12 +23,12 @@ StringPool::~StringPool() {
assert(InternTable.empty() && "PooledStringPtr leaked!"); assert(InternTable.empty() && "PooledStringPtr leaked!");
} }
PooledStringPtr StringPool::intern(const char *Begin, const char *End) { PooledStringPtr StringPool::intern(const StringRef &Key) {
table_t::iterator I = InternTable.find(Begin, End); table_t::iterator I = InternTable.find(Key);
if (I != InternTable.end()) if (I != InternTable.end())
return PooledStringPtr(&*I); return PooledStringPtr(&*I);
entry_t *S = entry_t::Create(Begin, End); entry_t *S = entry_t::Create(Key.begin(), Key.end());
S->getValue().Pool = this; S->getValue().Pool = this;
InternTable.insert(S); InternTable.insert(S);

2
lib/Transforms/Scalar/SimplifyLibCalls.cpp
View File

@@ -1657,7 +1657,7 @@ bool SimplifyLibCalls::runOnFunction(Function &F) {
// Ignore unknown calls. // Ignore unknown calls.
const char *CalleeName = Callee->getNameStart(); const char *CalleeName = Callee->getNameStart();
StringMap<LibCallOptimization*>::iterator OMI = StringMap<LibCallOptimization*>::iterator OMI =
Optimizations.find(CalleeName, CalleeName+Callee->getNameLen()); Optimizations.find(StringRef(CalleeName, Callee->getNameLen()));
if (OMI == Optimizations.end()) continue; if (OMI == Optimizations.end()) continue;
// Set the builder to the instruction after the call. // Set the builder to the instruction after the call.

6
lib/VMCore/LLVMContextImpl.cpp
View File

@@ -397,7 +397,7 @@ MDString *LLVMContextImpl::getMDString(const char *StrBegin,
unsigned StrLength) { unsigned StrLength) {
sys::SmartScopedWriter<true> Writer(ConstantsLock); sys::SmartScopedWriter<true> Writer(ConstantsLock);
StringMapEntry<MDString *> &Entry = StringMapEntry<MDString *> &Entry =
MDStringCache.GetOrCreateValue(StrBegin, StrBegin + StrLength); MDStringCache.GetOrCreateValue(StringRef(StrBegin, StrLength));
MDString *&S = Entry.getValue(); MDString *&S = Entry.getValue();
if (!S) S = new MDString(Entry.getKeyData(), if (!S) S = new MDString(Entry.getKeyData(),
Entry.getKeyLength()); Entry.getKeyLength());
@@ -460,8 +460,8 @@ Constant *LLVMContextImpl::getConstantArray(const ArrayType *Ty,
void LLVMContextImpl::erase(MDString *M) { void LLVMContextImpl::erase(MDString *M) {
sys::SmartScopedWriter<true> Writer(ConstantsLock); sys::SmartScopedWriter<true> Writer(ConstantsLock);
MDStringCache.erase(MDStringCache.find(M->StrBegin, MDStringCache.erase(MDStringCache.find(StringRef(M->StrBegin,
M->StrBegin + M->length())); M->length())));
} }
void LLVMContextImpl::erase(MDNode *M) { void LLVMContextImpl::erase(MDNode *M) {

15
lib/VMCore/ValueSymbolTable.cpp
View File

@@ -33,7 +33,7 @@ ValueSymbolTable::~ValueSymbolTable() {
// lookup a value - Returns null on failure... // lookup a value - Returns null on failure...
// //
Value *ValueSymbolTable::lookup(const std::string &Name) const { Value *ValueSymbolTable::lookup(const std::string &Name) const {
const_iterator VI = vmap.find(Name.data(), Name.data() + Name.size()); const_iterator VI = vmap.find(Name);
if (VI != vmap.end()) // We found the symbol if (VI != vmap.end()) // We found the symbol
return VI->getValue(); return VI->getValue();
return 0; return 0;
@@ -41,7 +41,8 @@ Value *ValueSymbolTable::lookup(const std::string &Name) const {
Value *ValueSymbolTable::lookup(const char *NameBegin, Value *ValueSymbolTable::lookup(const char *NameBegin,
const char *NameEnd) const { const char *NameEnd) const {
const_iterator VI = vmap.find(NameBegin, NameEnd); // FIXME: ValueSymbolTable should move to a StringRef based API.
const_iterator VI = vmap.find(StringRef(NameBegin, NameEnd - NameBegin));
if (VI != vmap.end()) // We found the symbol if (VI != vmap.end()) // We found the symbol
return VI->getValue(); return VI->getValue();
return 0; return 0;
@@ -71,8 +72,8 @@ void ValueSymbolTable::reinsertValue(Value* V) {
UniqueName.append_uint_32(++LastUnique); UniqueName.append_uint_32(++LastUnique);
// Try insert the vmap entry with this suffix. // Try insert the vmap entry with this suffix.
ValueName &NewName = ValueName &NewName =
vmap.GetOrCreateValue(UniqueName.data(), vmap.GetOrCreateValue(StringRef(UniqueName.data(),
UniqueName.data() + UniqueName.size()); UniqueName.size()));
if (NewName.getValue() == 0) { if (NewName.getValue() == 0) {
// Newly inserted name. Success! // Newly inserted name. Success!
NewName.setValue(V); NewName.setValue(V);
@@ -95,7 +96,7 @@ void ValueSymbolTable::removeValueName(ValueName *V) {
ValueName *ValueSymbolTable::createValueName(const char *NameStart, ValueName *ValueSymbolTable::createValueName(const char *NameStart,
unsigned NameLen, Value *V) { unsigned NameLen, Value *V) {
// In the common case, the name is not already in the symbol table. // In the common case, the name is not already in the symbol table.
ValueName &Entry = vmap.GetOrCreateValue(NameStart, NameStart+NameLen); ValueName &Entry = vmap.GetOrCreateValue(StringRef(NameStart, NameLen));
if (Entry.getValue() == 0) { if (Entry.getValue() == 0) {
Entry.setValue(V); Entry.setValue(V);
//DEBUG(DOUT << " Inserted value: " << Entry.getKeyData() << ": " //DEBUG(DOUT << " Inserted value: " << Entry.getKeyData() << ": "
@@ -113,8 +114,8 @@ ValueName *ValueSymbolTable::createValueName(const char *NameStart,
// Try insert the vmap entry with this suffix. // Try insert the vmap entry with this suffix.
ValueName &NewName = ValueName &NewName =
vmap.GetOrCreateValue(UniqueName.data(), vmap.GetOrCreateValue(StringRef(UniqueName.data(),
UniqueName.data() + UniqueName.size()); UniqueName.size()));
if (NewName.getValue() == 0) { if (NewName.getValue() == 0) {
// Newly inserted name. Success! // Newly inserted name. Success!
NewName.setValue(V); NewName.setValue(V);

15
tools/llvm-mc/AsmLexer.cpp
View File

@@ -107,8 +107,9 @@ asmtok::TokKind AsmLexer::LexIdentifier() {
*CurPtr == '.' || *CurPtr == '@') *CurPtr == '.' || *CurPtr == '@')
++CurPtr; ++CurPtr;
// Unique string. // Unique string.
CurStrVal = CurStrVal = getSS(TheStringSet).GetOrCreateValue(StringRef(TokStart,
getSS(TheStringSet).GetOrCreateValue(TokStart, CurPtr, 0).getKeyData(); CurPtr - TokStart),
0).getKeyData();
return asmtok::Identifier; return asmtok::Identifier;
} }
@@ -121,8 +122,9 @@ asmtok::TokKind AsmLexer::LexPercent() {
++CurPtr; ++CurPtr;
// Unique string. // Unique string.
CurStrVal = CurStrVal = getSS(TheStringSet).GetOrCreateValue(StringRef(TokStart,
getSS(TheStringSet).GetOrCreateValue(TokStart, CurPtr, 0).getKeyData(); CurPtr - TokStart),
0).getKeyData();
return asmtok::Register; return asmtok::Register;
} }
@@ -249,8 +251,9 @@ asmtok::TokKind AsmLexer::LexQuote() {
} }
// Unique string, include quotes for now. // Unique string, include quotes for now.
CurStrVal = CurStrVal = getSS(TheStringSet).GetOrCreateValue(StringRef(TokStart,
getSS(TheStringSet).GetOrCreateValue(TokStart, CurPtr, 0).getKeyData(); CurPtr - TokStart),
0).getKeyData();
return asmtok::String; return asmtok::String;
} }

5
tools/lto/LTOModule.cpp
View File

@@ -379,7 +379,7 @@ void LTOModule::addDefinedSymbol(GlobalValue* def, Mangler &mangler,
void LTOModule::addAsmGlobalSymbol(const char *name) { void LTOModule::addAsmGlobalSymbol(const char *name) {
// only add new define if not already defined // only add new define if not already defined
if ( _defines.count(name, &name[strlen(name)+1]) == 0 ) if ( _defines.count(name) == 0 )
return; return;
// string is owned by _defines // string is owned by _defines
@@ -507,8 +507,7 @@ void LTOModule::lazyParseSymbols()
it != _undefines.end(); ++it) { it != _undefines.end(); ++it) {
// if this symbol also has a definition, then don't make an undefine // if this symbol also has a definition, then don't make an undefine
// because it is a tentative definition // because it is a tentative definition
if ( _defines.count(it->getKeyData(), it->getKeyData()+ if ( _defines.count(it->getKey())) {
it->getKeyLength()) == 0 ) {
NameAndAttributes info = it->getValue(); NameAndAttributes info = it->getValue();
_symbols.push_back(info); _symbols.push_back(info);
} }

23
unittests/ADT/StringMapTest.cpp
View File

@@ -22,7 +22,7 @@ protected:
static const char testKey[]; static const char testKey[];
static const uint32_t testValue; static const uint32_t testValue;
static const char* testKeyFirst; static const char* testKeyFirst;
static const char* testKeyLast; static size_t testKeyLength;
static const std::string testKeyStr; static const std::string testKeyStr;
void assertEmptyMap() { void assertEmptyMap() {
@@ -35,10 +35,11 @@ protected:
// Lookup tests // Lookup tests
EXPECT_EQ(0u, testMap.count(testKey)); EXPECT_EQ(0u, testMap.count(testKey));
EXPECT_EQ(0u, testMap.count(testKeyFirst, testKeyLast)); EXPECT_EQ(0u, testMap.count(StringRef(testKeyFirst, testKeyLength)));
EXPECT_EQ(0u, testMap.count(testKeyStr)); EXPECT_EQ(0u, testMap.count(testKeyStr));
EXPECT_TRUE(testMap.find(testKey) == testMap.end()); EXPECT_TRUE(testMap.find(testKey) == testMap.end());
EXPECT_TRUE(testMap.find(testKeyFirst, testKeyLast) == testMap.end()); EXPECT_TRUE(testMap.find(StringRef(testKeyFirst, testKeyLength)) ==
testMap.end());
EXPECT_TRUE(testMap.find(testKeyStr) == testMap.end()); EXPECT_TRUE(testMap.find(testKeyStr) == testMap.end());
} }
@@ -57,10 +58,11 @@ protected:
// Lookup tests // Lookup tests
EXPECT_EQ(1u, testMap.count(testKey)); EXPECT_EQ(1u, testMap.count(testKey));
EXPECT_EQ(1u, testMap.count(testKeyFirst, testKeyLast)); EXPECT_EQ(1u, testMap.count(StringRef(testKeyFirst, testKeyLength)));
EXPECT_EQ(1u, testMap.count(testKeyStr)); EXPECT_EQ(1u, testMap.count(testKeyStr));
EXPECT_TRUE(testMap.find(testKey) == testMap.begin()); EXPECT_TRUE(testMap.find(testKey) == testMap.begin());
EXPECT_TRUE(testMap.find(testKeyFirst, testKeyLast) == testMap.begin()); EXPECT_TRUE(testMap.find(StringRef(testKeyFirst, testKeyLength)) ==
testMap.begin());
EXPECT_TRUE(testMap.find(testKeyStr) == testMap.begin()); EXPECT_TRUE(testMap.find(testKeyStr) == testMap.begin());
} }
}; };
@@ -68,7 +70,7 @@ protected:
const char StringMapTest::testKey[] = "key"; const char StringMapTest::testKey[] = "key";
const uint32_t StringMapTest::testValue = 1u; const uint32_t StringMapTest::testValue = 1u;
const char* StringMapTest::testKeyFirst = testKey; const char* StringMapTest::testKeyFirst = testKey;
const char* StringMapTest::testKeyLast = testKey + sizeof(testKey) - 1; size_t StringMapTest::testKeyLength = sizeof(testKey) - 1;
const std::string StringMapTest::testKeyStr(testKey); const std::string StringMapTest::testKeyStr(testKey);
// Empty map tests. // Empty map tests.
@@ -90,10 +92,10 @@ TEST_F(StringMapTest, ConstEmptyMapTest) {
// Lookup tests // Lookup tests
EXPECT_EQ(0u, constTestMap.count(testKey)); EXPECT_EQ(0u, constTestMap.count(testKey));
EXPECT_EQ(0u, constTestMap.count(testKeyFirst, testKeyLast)); EXPECT_EQ(0u, constTestMap.count(StringRef(testKeyFirst, testKeyLength)));
EXPECT_EQ(0u, constTestMap.count(testKeyStr)); EXPECT_EQ(0u, constTestMap.count(testKeyStr));
EXPECT_TRUE(constTestMap.find(testKey) == constTestMap.end()); EXPECT_TRUE(constTestMap.find(testKey) == constTestMap.end());
EXPECT_TRUE(constTestMap.find(testKeyFirst, testKeyLast) == EXPECT_TRUE(constTestMap.find(StringRef(testKeyFirst, testKeyLength)) ==
constTestMap.end()); constTestMap.end());
EXPECT_TRUE(constTestMap.find(testKeyStr) == constTestMap.end()); EXPECT_TRUE(constTestMap.find(testKeyStr) == constTestMap.end());
} }
@@ -186,7 +188,7 @@ namespace {
TEST_F(StringMapTest, StringMapEntryTest) { TEST_F(StringMapTest, StringMapEntryTest) {
StringMap<uint32_t>::value_type* entry = StringMap<uint32_t>::value_type* entry =
StringMap<uint32_t>::value_type::Create( StringMap<uint32_t>::value_type::Create(
testKeyFirst, testKeyLast, 1u); testKeyFirst, testKeyFirst + testKeyLength, 1u);
EXPECT_STREQ(testKey, entry->first()); EXPECT_STREQ(testKey, entry->first());
EXPECT_EQ(1u, entry->second); EXPECT_EQ(1u, entry->second);
} }
@@ -196,7 +198,8 @@ TEST_F(StringMapTest, InsertTest) {
SCOPED_TRACE("InsertTest"); SCOPED_TRACE("InsertTest");
testMap.insert( testMap.insert(
StringMap<uint32_t>::value_type::Create( StringMap<uint32_t>::value_type::Create(
testKeyFirst, testKeyLast, testMap.getAllocator(), 1u)); testKeyFirst, testKeyFirst + testKeyLength,
testMap.getAllocator(), 1u));
assertSingleItemMap(); assertSingleItemMap();
} }