COFF: Use CachedHashStringRef in the symbol table.

[pcc]

Summary

This resulted in about a 1% perf improvement linking chrome_child.dll.

[ruiu]

LGTM

lld/COFF/SymbolTable.h

 //===- SymbolTable.h --------------------------------------------*- C++ -*-===//
 //
 //                             The LLVM Linker
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLD_COFF_SYMBOL_TABLE_H
 #define LLD_COFF_SYMBOL_TABLE_H
 
 #include "InputFiles.h"
+#include "llvm/ADT/CachedHashString.h"
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/DenseMapInfo.h"
 #include "llvm/Support/Allocator.h"
 #include "llvm/Support/raw_ostream.h"
 
 #ifdef _MSC_VER
 // <future> depends on <eh.h> for __uncaught_exception.
 #include <eh.h>
private:
 
   std::pair<Symbol *, bool> insert(StringRef Name);
   StringRef findByPrefix(StringRef Prefix);
 
   void addMemberFile(ArchiveFile *F, const Archive::Symbol Sym);
   void addCombinedLTOObject(ObjectFile *Obj);
   std::vector<ObjectFile *> createLTOObjects(llvm::LTOCodeGenerator *CG);
 
-  llvm::DenseMap<StringRef, Symbol *> Symtab;
+  llvm::DenseMap<llvm::CachedHashStringRef, Symbol *> Symtab;
 
   std::vector<BitcodeFile *> BitcodeFiles;
   std::vector<SmallString<0>> Objs;
 };
 
 extern SymbolTable *Symtab;
 
 } // namespace coff
 } // namespace lld
 
 #endif

lld/COFF/SymbolTable.cpp

for (SymbolBody *Sym : File->getSymbols())
       if (Undefs.count(Sym))
         errs() << toString(File) << ": undefined symbol: " << Sym->getName()
                << "\n";
   if (!Config->Force)
     fatal("link failed");
 }
 
 std::pair<Symbol *, bool> SymbolTable::insert(StringRef Name) {
-  Symbol *&Sym = Symtab[Name];
+  Symbol *&Sym = Symtab[CachedHashStringRef(Name)];
   if (Sym)
     return {Sym, false};
   Sym = make<Symbol>();
   Sym->IsUsedInRegularObj = false;
   return {Sym, true};
 }
 
 Symbol *SymbolTable::addUndefined(StringRef Name, InputFile *F,
std::vector<Chunk *> SymbolTable::getChunks() {
   for (ObjectFile *File : ObjectFiles) {
     std::vector<Chunk *> &V = File->getChunks();
     Res.insert(Res.end(), V.begin(), V.end());
   }
   return Res;
 }
 
 Symbol *SymbolTable::find(StringRef Name) {
-  auto It = Symtab.find(Name);
+  auto It = Symtab.find(CachedHashStringRef(Name));
   if (It == Symtab.end())
     return nullptr;
   return It->second;
 }
 
 Symbol *SymbolTable::findUnderscore(StringRef Name) {
   if (Config->Machine == I386)
     return find(("_" + Name).str());
   return find(Name);
 }
 
 StringRef SymbolTable::findByPrefix(StringRef Prefix) {
   for (auto Pair : Symtab) {
-    StringRef Name = Pair.first;
+    StringRef Name = Pair.first.val();
     if (Name.startswith(Prefix))
       return Name;
   }
   return "";
 }
 
 StringRef SymbolTable::findMangle(StringRef Name) {
   if (Symbol *Sym = find(Name))