Rename `Symtab` private memory to avoid confusion with global `Symtab`

[sbc100]

Summary

This is also consistent with SymVector that exists in COFF port and soon to
be added to the wasm port.

Split off as part of https://reviews.llvm.org/D40371

[ruiu]

LGTM

lld/trunk/COFF/SymbolTable.h

public:
 
   void reportDuplicate(Symbol *Existing, InputFile *NewFile);
 
   // A list of chunks which to be added to .rdata.
   std::vector<Chunk *> LocalImportChunks;
 
   // Iterates symbols in non-determinstic hash table order.
   template <typename T> void forEachSymbol(T Callback) {
-    for (auto &Pair : Symtab)
+    for (auto &Pair : SymMap)
       Callback(Pair.second);
   }
 
 private:
   std::pair<Symbol *, bool> insert(StringRef Name);
   StringRef findByPrefix(StringRef Prefix);
 
-  llvm::DenseMap<llvm::CachedHashStringRef, Symbol *> Symtab;
+  llvm::DenseMap<llvm::CachedHashStringRef, Symbol *> SymMap;
   std::unique_ptr<BitcodeCompiler> LTO;
 };
 
 extern SymbolTable *Symtab;
 
 } // namespace coff
 } // namespace lld
 
 #endif

lld/trunk/COFF/SymbolTable.cpp

if (Config->Force)
     warn(S);
   else
     error(S);
 }
 
 void SymbolTable::reportRemainingUndefines() {
   SmallPtrSet<Symbol *, 8> Undefs;
 
-  for (auto &I : Symtab) {
+  for (auto &I : SymMap) {
     Symbol *Sym = I.second;
     auto *Undef = dyn_cast<Undefined>(Sym);
     if (!Undef)
       continue;
     if (!Sym->IsUsedInRegularObj)
       continue;
 
     StringRef Name = Undef->getName();
void SymbolTable::reportRemainingUndefines() {
 
   for (ObjFile *File : ObjFile::Instances)
     for (Symbol *Sym : File->getSymbols())
       if (Sym && Undefs.count(Sym))
         errorOrWarn(toString(File) + ": undefined symbol: " + Sym->getName());
 }
 
 std::pair<Symbol *, bool> SymbolTable::insert(StringRef Name) {
-  Symbol *&Sym = Symtab[CachedHashStringRef(Name)];
+  Symbol *&Sym = SymMap[CachedHashStringRef(Name)];
   if (Sym)
     return {Sym, false};
   Sym = (Symbol *)make<SymbolUnion>();
   Sym->IsUsedInRegularObj = false;
   Sym->PendingArchiveLoad = false;
   return {Sym, true};
 }
 
std::vector<Chunk *> SymbolTable::getChunks() {
   for (ObjFile *File : ObjFile::Instances) {
     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(CachedHashStringRef(Name));
-  if (It == Symtab.end())
+  auto It = SymMap.find(CachedHashStringRef(Name));
+  if (It == SymMap.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) {
+  for (auto Pair : SymMap) {
     StringRef Name = Pair.first.val();
     if (Name.startswith(Prefix))
       return Name;
   }
   return "";
 }
 
 StringRef SymbolTable::findMangle(StringRef Name) {

lld/trunk/ELF/SymbolTable.h

private:
 
   // The order the global symbols are in is not defined. We can use an arbitrary
   // order, but it has to be reproducible. That is true even when cross linking.
   // The default hashing of StringRef produces different results on 32 and 64
   // bit systems so we use a map to a vector. That is arbitrary, deterministic
   // but a bit inefficient.
   // FIXME: Experiment with passing in a custom hashing or sorting the symbols
   // once symbol resolution is finished.
-  llvm::DenseMap<llvm::CachedHashStringRef, int> Symtab;
+  llvm::DenseMap<llvm::CachedHashStringRef, int> SymMap;
   std::vector<Symbol *> SymVector;
 
   // Comdat groups define "link once" sections. If two comdat groups have the
   // same name, only one of them is linked, and the other is ignored. This set
   // is used to uniquify them.
   llvm::DenseSet<llvm::CachedHashStringRef> ComdatGroups;
 
   // Set of .so files to not link the same shared object file more than once.

lld/trunk/ELF/SymbolTable.cpp

Defined *SymbolTable::addAbsolute(StringRef Name, uint8_t Visibility,
   Symbol *Sym = addRegular<ELFT>(Name, Visibility, STT_NOTYPE, 0, 0, Binding,
                                  nullptr, nullptr);
   return cast<Defined>(Sym);
 }
 
 // Set a flag for --trace-symbol so that we can print out a log message
 // if a new symbol with the same name is inserted into the symbol table.
 void SymbolTable::trace(StringRef Name) {
-  Symtab.insert({CachedHashStringRef(Name), -1});
+  SymMap.insert({CachedHashStringRef(Name), -1});
 }
 
 // Rename SYM as __wrap_SYM. The original symbol is preserved as __real_SYM.
 // Used to implement --wrap.
 template <class ELFT> void SymbolTable::addSymbolWrap(StringRef Name) {
   Symbol *Sym = find(Name);
   if (!Sym)
     return;
std::pair<Symbol *, bool> SymbolTable::insert(StringRef Name) {
   //
   // Since this is a hot path, the following string search code is
   // optimized for speed. StringRef::find(char) is much faster than
   // StringRef::find(StringRef).
   size_t Pos = Name.find('@');
   if (Pos != StringRef::npos && Pos + 1 < Name.size() && Name[Pos + 1] == '@')
     Name = Name.take_front(Pos);
 
-  auto P = Symtab.insert({CachedHashStringRef(Name), (int)SymVector.size()});
+  auto P = SymMap.insert({CachedHashStringRef(Name), (int)SymVector.size()});
   int &SymIndex = P.first->second;
   bool IsNew = P.second;
   bool Traced = false;
 
   if (SymIndex == -1) {
     SymIndex = SymVector.size();
     IsNew = Traced = true;
   }
Symbol *SymbolTable::addBitcode(StringRef Name, uint8_t Binding,
   if (Cmp > 0)
     replaceSymbol<Defined>(S, F, Name, Binding, StOther, Type, 0, 0, nullptr);
   else if (Cmp == 0)
     reportDuplicate(S, F);
   return S;
 }
 
 Symbol *SymbolTable::find(StringRef Name) {
-  auto It = Symtab.find(CachedHashStringRef(Name));
-  if (It == Symtab.end())
+  auto It = SymMap.find(CachedHashStringRef(Name));
+  if (It == SymMap.end())
     return nullptr;
   if (It->second == -1)
     return nullptr;
   return SymVector[It->second];
 }
 
 template <class ELFT>
 Symbol *SymbolTable::addLazyArchive(StringRef Name, ArchiveFile *F,

lld/trunk/wasm/SymbolTable.h

public:
   Symbol *addUndefined(InputFile *F, const WasmSymbol *Sym);
   Symbol *addUndefinedFunction(StringRef Name);
   Symbol *addDefinedGlobal(StringRef Name);
   void addLazy(ArchiveFile *F, const Archive::Symbol *Sym);
 
 private:
   std::pair<Symbol *, bool> insert(StringRef Name);
 
-  llvm::DenseMap<llvm::CachedHashStringRef, Symbol *> Symtab;
+  llvm::DenseMap<llvm::CachedHashStringRef, Symbol *> SymMap;
 };
 
 extern SymbolTable *Symtab;
 
 } // namespace wasm
 } // namespace lld
 
 #endif

lld/trunk/wasm/SymbolTable.cpp

void SymbolTable::addFile(InputFile *File) {
   File->parse();
 
   if (auto *F = dyn_cast<ObjFile>(File))
     ObjectFiles.push_back(F);
 }
 
 void SymbolTable::reportRemainingUndefines() {
   std::unordered_set<Symbol *> Undefs;
-  for (auto &I : Symtab) {
+  for (auto &I : SymMap) {
     Symbol *Sym = I.second;
     if (Sym->isUndefined() && !Sym->isWeak() &&
         Config->AllowUndefinedSymbols.count(Sym->getName()) == 0) {
       Undefs.insert(Sym);
     }
   }
 
   if (Undefs.empty())
     return;
 
   for (ObjFile *File : ObjectFiles)
     for (Symbol *Sym : File->getSymbols())
       if (Undefs.count(Sym))
         error(toString(File) + ": undefined symbol: " + toString(*Sym));
 
   for (Symbol *Sym : Undefs)
     if (!Sym->getFile())
       error("undefined symbol: " + toString(*Sym));
 }
 
 Symbol *SymbolTable::find(StringRef Name) {
-  auto It = Symtab.find(CachedHashStringRef(Name));
-  if (It == Symtab.end())
+  auto It = SymMap.find(CachedHashStringRef(Name));
+  if (It == SymMap.end())
     return nullptr;
   return It->second;
 }
 
 std::pair<Symbol *, bool> SymbolTable::insert(StringRef Name) {
-  Symbol *&Sym = Symtab[CachedHashStringRef(Name)];
+  Symbol *&Sym = SymMap[CachedHashStringRef(Name)];
   if (Sym)
     return {Sym, false};
   Sym = make<Symbol>(Name, false);
   return {Sym, true};
 }
 
 void SymbolTable::reportDuplicate(Symbol *Existing, InputFile *NewFile) {
   error("duplicate symbol: " + toString(*Existing) + "\n>>> defined in " +