ELF: Remove SymbolTable::SymIndex class.

[pcc]

Summary

The Traced flag is unnecessary because we only need to set the index
to -1 to mark a symbol for tracing.

[ruiu]

LGTM

lld/trunk/ELF/SymbolTable.h

private:
   void defsym(Symbol *Dst, Symbol *Src);
 
   llvm::StringMap<std::vector<Symbol *>> &getDemangledSyms();
   void handleAnonymousVersion();
   void assignExactVersion(SymbolVersion Ver, uint16_t VersionId,
                           StringRef VersionName);
   void assignWildcardVersion(SymbolVersion Ver, uint16_t VersionId);
 
-  struct SymIndex {
-    SymIndex(int Idx, bool Traced) : Idx(Idx), Traced(Traced) {}
-    int Idx : 31;
-    unsigned Traced : 1;
-  };
-
   // 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, SymIndex> Symtab;
+  llvm::DenseMap<llvm::CachedHashStringRef, int> Symtab;
   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, true}});
+  Symtab.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), SymIndex((int)SymVector.size(), false)});
-  SymIndex &V = P.first->second;
+  auto P = Symtab.insert({CachedHashStringRef(Name), (int)SymVector.size()});
+  int &SymIndex = P.first->second;
   bool IsNew = P.second;
+  bool Traced = false;
 
-  if (V.Idx == -1) {
-    IsNew = true;
-    V = SymIndex((int)SymVector.size(), true);
+  if (SymIndex == -1) {
+    SymIndex = SymVector.size();
+    IsNew = Traced = true;
   }
 
   Symbol *Sym;
   if (IsNew) {
     Sym = (Symbol *)make<SymbolUnion>();
     Sym->InVersionScript = false;
     Sym->Binding = STB_WEAK;
     Sym->Visibility = STV_DEFAULT;
     Sym->IsUsedInRegularObj = false;
     Sym->ExportDynamic = false;
     Sym->CanInline = true;
-    Sym->Traced = V.Traced;
+    Sym->Traced = Traced;
     Sym->VersionId = Config->DefaultSymbolVersion;
     SymVector.push_back(Sym);
   } else {
-    Sym = SymVector[V.Idx];
+    Sym = SymVector[SymIndex];
   }
   return {Sym, IsNew};
 }
 
 // Find an existing symbol or create and insert a new one, then apply the given
 // attributes.
 std::pair<Symbol *, bool> SymbolTable::insert(StringRef Name, uint8_t Type,
                                               uint8_t Visibility,
else if (Cmp == 0)
     reportDuplicate(S, F);
   return S;
 }
 
 Symbol *SymbolTable::find(StringRef Name) {
   auto It = Symtab.find(CachedHashStringRef(Name));
   if (It == Symtab.end())
     return nullptr;
-  SymIndex V = It->second;
-  if (V.Idx == -1)
+  if (It->second == -1)
     return nullptr;
-  return SymVector[V.Idx];
+  return SymVector[It->second];
 }
 
 template <class ELFT>
 Symbol *SymbolTable::addLazyArchive(StringRef Name, ArchiveFile *F,
                                     const object::Archive::Symbol Sym) {
   Symbol *S;
   bool WasInserted;
   std::tie(S, WasInserted) = insert(Name);