Simplify SymbolTable::add{Defined,Undefined,...} functions.

[ruiu]

Summary

SymbolTable's add-family functions have lots of parameters because
when they have to create a new symbol, they forward given arguments
to Symbol's constructors. Therefore, the functions take at least as
many arguments as their corresponding constructors.

This patch simplifies the add-family functions. Now, the functions
take a symbol instead of arguments to construct a symbol. If there's
no existing symbol, a given symbol is memcpy'ed to the symbol table.
Otherwise, the functions attempt to merge the existing and a given
new symbol.

I also eliminated CanOmitFromDynSym parameter, so that the functions
take really one argument.

Symbol classes are trivially constructible, so looks like constructing
them to pass to add-family functions is as cheap as passing a lot of
arguments to the functions. A quick benchmark showed that this patch
seems performance-neutral.

This is a preparation for
http://lists.llvm.org/pipermail/llvm-dev/2019-April/131902.html

[grimar]

lld/ELF/Driver.cpp

1379

What was confusing for me when I saw this in your patch is that Sym is a pointer.
I.e. I was wondering can addUndefined store it somewhere inside or not. Should it be a reference may be?

And then you should be able to:

return Symtab->addUndefined<ELFT>({nullptr, Name, STB_GLOBAL, STV_DEFAULT, 0)});

[MaskRay]

lld/ELF/Symbols.h

368

Agree with George. T *New -> const T &New

[MaskRay]

lld/ELF/Symbols.h

384

Sym->isLazy() can be deleted because an isLazy() symbol is STT_NOTYPE.

[MaskRay]

lld/ELF/SymbolTable.cpp

121

It seems after every insert() call, if the IsNew branch is taken, these member variables are initialized then get overridden by replaceSymbol(Old, New). Is there some way to prevent repeated assignments?

[ruiu]

This is the same as the previous patch. If there's no big issue in this patch, I'd like to commit after making changes as you guys pointed out.

lld/ELF/Driver.cpp

1379

I could indeed make it a const reference. That's perhaps a matter of personal taste, but since I don't feel strongly about . that, I'll change the parameter type as you suggested.

lld/ELF/SymbolTable.cpp

121

Good point, and I tried that before submitting this patch for review. It turned out that doing that isn't as easy as it seems. There may be some good way to do that, though. I'd want to keep it as-is for now.

lld/ELF/Symbols.h

368

Will do.

384

We actually need this because if we delete Sym->isLazy() and if we have a lazy symbol and a TLS symbol, we'll end up comparing STT_NOTYPE and STT_TLS.

[MaskRay]

LGTM after the const reference change (void replaceSymbol(Symbol *Sym, const T &New) {).

lld/ELF/Driver.cpp

 }
 
 // If all references to a DSO happen to be weak, the DSO is not added
 // to DT_NEEDED. If that happens, we need to eliminate shared symbols
 // created from the DSO. Otherwise, they become dangling references
 // that point to a non-existent DSO.
 static void demoteSharedSymbols() {
   for (Symbol *Sym : Symtab->getSymbols()) {
-    if (auto *S = dyn_cast<SharedSymbol>(Sym)) {
-      if (!S->getFile().IsNeeded) {
-        bool Used = S->Used;
-        replaceSymbol<Undefined>(S, nullptr, S->getName(), STB_WEAK, S->StOther,
-                                 S->Type);
-        S->Used = Used;
-      }
-    }
-  }
-}
+    auto *S = dyn_cast<SharedSymbol>(Sym);
+    if (!S || S->getFile().IsNeeded)
+      continue;
+
+    Undefined New(nullptr, S->getName(), STB_WEAK, S->StOther, S->Type);
+    replaceSymbol(S, &New);
 
 // The section referred to by S is considered address-significant. Set the
 // KeepUnique flag on the section if appropriate.
 static void markAddrsig(Symbol *S) {
   if (auto *D = dyn_cast_or_null<Defined>(S))
     if (D->Section)
       // We don't need to keep text sections unique under --icf=all even if they
       // are address-significant.
if (Obj->AddrsigSec) {
       // conservatively mark all of its symbols as address-significant.
       for (Symbol *S : Syms)
         markAddrsig(S);
     }
   }
 }
 
 template <class ELFT> static Symbol *addUndefined(StringRef Name) {
-  return Symtab->addUndefined<ELFT>(Name, STB_GLOBAL, STV_DEFAULT, 0, false,
-                                    nullptr);
+  Undefined Sym(nullptr, Name, STB_GLOBAL, STV_DEFAULT, 0);
+  return Symtab->addUndefined<ELFT>(&Sym);
 }
 
 // The --wrap option is a feature to rename symbols so that you can write
 // wrappers for existing functions. If you pass `-wrap=foo`, all
 // occurrences of symbol `foo` are resolved to `wrap_foo` (so, you are
 // expected to write `wrap_foo` function as a wrapper). The original
 // symbol becomes accessible as `real_foo`, so you can call that from your
 // wrapper.

lld/ELF/InputFiles.cpp

if (Sym->st_shndx == SHN_UNDEF)
       return make<Undefined>(this, Name, Binding, StOther, Type);
 
     return make<Defined>(this, Name, Binding, StOther, Type, Value, Size, Sec);
   }
 
   StringRef Name = CHECK(Sym->getName(this->StringTable), this);
 
   switch (Sym->st_shndx) {
-  case SHN_UNDEF:
-    return Symtab->addUndefined<ELFT>(Name, Binding, StOther, Type,
-                                      /*CanOmitFromDynSym=*/false, this);
+  case SHN_UNDEF: {
+    Undefined S(this, Name, Binding, StOther, Type);
+    return Symtab->addUndefined<ELFT>(&S);
+  }
   case SHN_COMMON:
     if (Value == 0 || Value >= UINT32_MAX)
       fatal(toString(this) + ": common symbol '" + Name +
             "' has invalid alignment: " + Twine(Value));
-    return Symtab->addCommon(Name, Size, Value, Binding, StOther, Type, *this);
+    Defined New(this, Name, Binding, StOther, Type, Value, Size, nullptr);
+    return Symtab->addCommon(&New);
   }
 
   switch (Binding) {
   default:
     fatal(toString(this) + ": unexpected binding: " + Twine(Binding));
   case STB_GLOBAL:
   case STB_WEAK:
   case STB_GNU_UNIQUE:
-    if (Sec == &InputSection::Discarded)
-      return Symtab->addUndefined<ELFT>(Name, Binding, StOther, Type,
-                                        /*CanOmitFromDynSym=*/false, this);
-    return Symtab->addDefined(Name, StOther, Type, Value, Size, Binding, Sec,
-                              this);
+    if (Sec == &InputSection::Discarded) {
+      Undefined S(this, Name, Binding, StOther, Type);
+      return Symtab->addUndefined<ELFT>(&S);
+    }
+
+    Defined New(this, Name, Binding, StOther, Type, Value, Size, Sec);
+    return Symtab->addDefined(&New);
   }
 }
 
 ArchiveFile::ArchiveFile(std::unique_ptr<Archive> &&File)
     : InputFile(ArchiveKind, File->getMemoryBufferRef()),
       File(std::move(File)) {}
 
 template <class ELFT> void ArchiveFile::parse() {
-  for (const Archive::Symbol &Sym : File->symbols())
-    Symtab->addLazyArchive<ELFT>(Sym.getName(), *this, Sym);
+  for (const Archive::Symbol &Sym : File->symbols()) {
+    LazyArchive New(*this, Sym);
+    Symtab->addLazyArchive<ELFT>(&New);
+  }
 }
 
 // Returns a buffer pointing to a member file containing a given symbol.
 InputFile *ArchiveFile::fetch(const Archive::Symbol &Sym) {
   Archive::Child C =
       CHECK(Sym.getMember(), toString(this) +
                                  ": could not get the member for symbol " +
                                  Sym.getName());
for (size_t I = 0; I < Syms.size(); ++I) {
     StringRef Name = CHECK(Sym.getName(this->StringTable), this);
     if (Sym.getBinding() == STB_LOCAL) {
       warn("found local symbol '" + Name +
            "' in global part of symbol table in file " + toString(this));
       continue;
     }
 
     if (Sym.isUndefined()) {
-      Symbol *S = Symtab->addUndefined<ELFT>(Name, Sym.getBinding(),
-                                             Sym.st_other, Sym.getType(),
-                                             /*CanOmitFromDynSym=*/false, this);
+      Undefined New(this, Name, Sym.getBinding(), Sym.st_other, Sym.getType());
+      Symbol *S = Symtab->addUndefined<ELFT>(&New);
       S->ExportDynamic = true;
       continue;
     }
 
     // MIPS BFD linker puts _gp_disp symbol into DSO files and incorrectly
     // assigns VER_NDX_LOCAL to this section global symbol. Here is a
     // workaround for this bug.
     uint32_t Idx = Versyms[I] & ~VERSYM_HIDDEN;
     if (Config->EMachine == EM_MIPS && Idx == VER_NDX_LOCAL &&
         Name == "_gp_disp")
       continue;
 
     uint64_t Alignment = getAlignment<ELFT>(Sections, Sym);
-    if (!(Versyms[I] & VERSYM_HIDDEN))
-      Symtab->addShared(Name, Sym.getBinding(), Sym.st_other, Sym.getType(),
-                        Sym.st_value, Sym.st_size, Alignment, Idx, this);
+    if (!(Versyms[I] & VERSYM_HIDDEN)) {
+      SharedSymbol S(*this, Name, Sym.getBinding(), Sym.st_other, Sym.getType(),
+                     Sym.st_value, Sym.st_size, Alignment, Idx);
+      Symtab->addShared(&S);
+    }
 
     // Also add the symbol with the versioned name to handle undefined symbols
     // with explicit versions.
     if (Idx == VER_NDX_GLOBAL)
       continue;
 
     if (Idx >= Verdefs.size() || Idx == VER_NDX_LOCAL) {
       error("corrupt input file: version definition index " + Twine(Idx) +
             " for symbol " + Name + " is out of bounds\n>>> defined in " +
             toString(this));
       continue;
     }
 
     StringRef VerName =
         this->StringTable.data() +
         reinterpret_cast<const Elf_Verdef *>(Verdefs[Idx])->getAux()->vda_name;
     VersionedNameBuffer.clear();
     Name = (Name + "@" + VerName).toStringRef(VersionedNameBuffer);
-    Symtab->addShared(Saver.save(Name), Sym.getBinding(), Sym.st_other,
-                      Sym.getType(), Sym.st_value, Sym.st_size, Alignment, Idx,
-                      this);
+
+    SharedSymbol S(*this, Saver.save(Name), Sym.getBinding(), Sym.st_other,
+                   Sym.getType(), Sym.st_value, Sym.st_size, Alignment, Idx);
+    Symtab->addShared(&S);
   }
 }
 
 static ELFKind getBitcodeELFKind(const Triple &T) {
   if (T.isLittleEndian())
     return T.isArch64Bit() ? ELF64LEKind : ELF32LEKind;
   return T.isArch64Bit() ? ELF64BEKind : ELF32BEKind;
 }
static Symbol *createBitcodeSymbol(const std::vector<bool> &KeptComdats,
   StringRef Name = Saver.save(ObjSym.getName());
   uint32_t Binding = ObjSym.isWeak() ? STB_WEAK : STB_GLOBAL;
 
   uint8_t Type = ObjSym.isTLS() ? STT_TLS : STT_NOTYPE;
   uint8_t Visibility = mapVisibility(ObjSym.getVisibility());
   bool CanOmitFromDynSym = ObjSym.canBeOmittedFromSymbolTable();
 
   int C = ObjSym.getComdatIndex();
-  if (C != -1 && !KeptComdats[C])
-    return Symtab->addUndefined<ELFT>(Name, Binding, Visibility, Type,
-                                      CanOmitFromDynSym, &F);
-
-  if (ObjSym.isUndefined())
-    return Symtab->addUndefined<ELFT>(Name, Binding, Visibility, Type,
-                                      CanOmitFromDynSym, &F);
-
-  if (ObjSym.isCommon())
-    return Symtab->addCommon(Name, ObjSym.getCommonSize(),
-                             ObjSym.getCommonAlignment(), Binding, Visibility,
-                             STT_OBJECT, F);
-
-  return Symtab->addBitcode(Name, Binding, Visibility, Type, CanOmitFromDynSym,
-                            F);
+  if (ObjSym.isUndefined() || (C != -1 && !KeptComdats[C])) {
+    Undefined New(&F, Name, Binding, Visibility, Type);
+    if (CanOmitFromDynSym)
+      New.ExportDynamic = false;
+    return Symtab->addUndefined<ELFT>(&New);
+  }
+
+  if (ObjSym.isCommon()) {
+    Defined New(&F, Name, Binding, Visibility, STT_OBJECT,
+                ObjSym.getCommonAlignment(), ObjSym.getCommonSize(), nullptr);
+    return Symtab->addCommon(&New);
+  }
+
+  Defined New(&F, Name, Binding, Visibility, Type, 0, 0, nullptr);
+  if (CanOmitFromDynSym)
+    New.ExportDynamic = false;
+  return Symtab->addBitcode(&New);
 }
 
 template <class ELFT>
 void BitcodeFile::parse(DenseSet<CachedHashStringRef> &ComdatGroups) {
   std::vector<bool> KeptComdats;
   for (StringRef S : Obj->getComdatTable())
     KeptComdats.push_back(ComdatGroups.insert(CachedHashStringRef(S)).second);
 
void BinaryFile::parse() {
   // blob, we define _binary_foo_{start,end,size} symbols, so that
   // user programs can access blobs by name. Non-alphanumeric
   // characters in a filename are replaced with underscore.
   std::string S = "_binary_" + MB.getBufferIdentifier().str();
   for (size_t I = 0; I < S.size(); ++I)
     if (!isAlnum(S[I]))
       S[I] = '_';
 
-  Symtab->addDefined(Saver.save(S + "_start"), STV_DEFAULT, STT_OBJECT, 0, 0,
-                     STB_GLOBAL, Section, nullptr);
-  Symtab->addDefined(Saver.save(S + "_end"), STV_DEFAULT, STT_OBJECT,
-                     Data.size(), 0, STB_GLOBAL, Section, nullptr);
-  Symtab->addDefined(Saver.save(S + "_size"), STV_DEFAULT, STT_OBJECT,
-                     Data.size(), 0, STB_GLOBAL, nullptr, nullptr);
+  Defined Sym1(nullptr, Saver.save(S + "_start"), STB_GLOBAL, STV_DEFAULT,
+               STT_OBJECT, 0, 0, Section);
+  Defined Sym2(nullptr, Saver.save(S + "_end"), STB_GLOBAL, STV_DEFAULT,
+               STT_OBJECT, Data.size(), 0, Section);
+  Defined Sym3(nullptr, Saver.save(S + "_size"), STB_GLOBAL, STV_DEFAULT,
+               STT_OBJECT, Data.size(), 0, nullptr);
+
+  Symtab->addDefined(&Sym1);
+  Symtab->addDefined(&Sym2);
+  Symtab->addDefined(&Sym3);
 }
 
 InputFile *elf::createObjectFile(MemoryBufferRef MB, StringRef ArchiveName,
                                  uint64_t OffsetInArchive) {
   if (isBitcode(MB))
     return make<BitcodeFile>(MB, ArchiveName, OffsetInArchive);
 
   switch (getELFKind(MB, ArchiveName)) {
InputFile *LazyObjFile::fetch() {
   return File;
 }
 
 template <class ELFT> void LazyObjFile::parse() {
   // A lazy object file wraps either a bitcode file or an ELF file.
   if (isBitcode(this->MB)) {
     std::unique_ptr<lto::InputFile> Obj =
         CHECK(lto::InputFile::create(this->MB), this);
-    for (const lto::InputFile::Symbol &Sym : Obj->symbols())
-      if (!Sym.isUndefined())
-        Symtab->addLazyObject<ELFT>(Saver.save(Sym.getName()), *this);
+    for (const lto::InputFile::Symbol &Sym : Obj->symbols()) {
+      if (Sym.isUndefined())
+        continue;
+      LazyObject New(*this, Saver.save(Sym.getName()));
+      Symtab->addLazyObject<ELFT>(&New);
+    }
     return;
   }
 
   if (getELFKind(this->MB, ArchiveName) != Config->EKind) {
     error("incompatible file: " + this->MB.getBufferIdentifier());
     return;
   }
 
   ELFFile<ELFT> Obj = check(ELFFile<ELFT>::create(MB.getBuffer()));
   ArrayRef<typename ELFT::Shdr> Sections = CHECK(Obj.sections(), this);
 
   for (const typename ELFT::Shdr &Sec : Sections) {
     if (Sec.sh_type != SHT_SYMTAB)
       continue;
 
     typename ELFT::SymRange Syms = CHECK(Obj.symbols(&Sec), this);
     uint32_t FirstGlobal = Sec.sh_info;
     StringRef StringTable =
         CHECK(Obj.getStringTableForSymtab(Sec, Sections), this);
 
-    for (const typename ELFT::Sym &Sym : Syms.slice(FirstGlobal))
-      if (Sym.st_shndx != SHN_UNDEF)
-        Symtab->addLazyObject<ELFT>(CHECK(Sym.getName(StringTable), this),
-                                    *this);
+    for (const typename ELFT::Sym &Sym : Syms.slice(FirstGlobal)) {
+      if (Sym.st_shndx == SHN_UNDEF)
+        continue;
+      LazyObject New(*this, CHECK(Sym.getName(StringTable), this));
+      Symtab->addLazyObject<ELFT>(&New);
+    }
     return;
   }
 }
 
 std::string elf::replaceThinLTOSuffix(StringRef Path) {
   StringRef Suffix = Config->ThinLTOObjectSuffixReplace.first;
   StringRef Repl = Config->ThinLTOObjectSuffixReplace.second;
 

lld/ELF/LTO.cpp

for (StringRef Prefix : {"__start_", "__stop_"})
       if (S.startswith(Prefix))
         UsedStartStop.insert(S.substr(Prefix.size()));
   }
 }
 
 BitcodeCompiler::~BitcodeCompiler() = default;
 
 static void undefine(Symbol *S) {
-  replaceSymbol<Undefined>(S, nullptr, S->getName(), STB_GLOBAL, STV_DEFAULT,
-                           S->Type);
+  Undefined New(nullptr, S->getName(), STB_GLOBAL, STV_DEFAULT, S->Type);
+  replaceSymbol(S, &New);
 }
 
 void BitcodeCompiler::add(BitcodeFile &F) {
   lto::InputFile &Obj = *F.Obj;
   bool IsExec = !Config->Shared && !Config->Relocatable;
 
   if (Config->ThinLTOIndexOnly)
     ThinIndices.insert(Obj.getName());

lld/ELF/LinkerScript.cpp

 
 // This function is called from processSectionCommands,
 // while we are fixing the output section layout.
 void LinkerScript::addSymbol(SymbolAssignment *Cmd) {
   if (!shouldDefineSym(Cmd))
     return;
 
   // Define a symbol.
-  Symbol *Sym;
-  uint8_t Visibility = Cmd->Hidden ? STV_HIDDEN : STV_DEFAULT;
-  std::tie(Sym, std::ignore) = Symtab->insert(Cmd->Name, Visibility,
-                                              /*CanOmitFromDynSym*/ false,
-                                              /*File*/ nullptr);
   ExprValue Value = Cmd->Expression();
   SectionBase *Sec = Value.isAbsolute() ? nullptr : Value.Sec;
+  uint8_t Visibility = Cmd->Hidden ? STV_HIDDEN : STV_DEFAULT;
 
   // When this function is called, section addresses have not been
   // fixed yet. So, we may or may not know the value of the RHS
   // expression.
   //
   // For example, if an expression is `x = 42`, we know x is always 42.
   // However, if an expression is `x = .`, there's no way to know its
   // value at the moment.
   //
   // We want to set symbol values early if we can. This allows us to
   // use symbols as variables in linker scripts. Doing so allows us to
   // write expressions like this: `alignment = 16; . = ALIGN(., alignment)`.
   uint64_t SymValue = Value.Sec ? 0 : Value.getValue();
 
-  replaceSymbol<Defined>(Sym, nullptr, Cmd->Name, STB_GLOBAL, Visibility,
-                         STT_NOTYPE, SymValue, 0, Sec);
+  Defined New(nullptr, Cmd->Name, STB_GLOBAL, Visibility, STT_NOTYPE, SymValue,
+              0, Sec);
+
+  Symbol *Sym;
+  std::tie(Sym, std::ignore) = Symtab->insert(&New);
+  replaceSymbol(Sym, &New);
   Cmd->Sym = cast<Defined>(Sym);
 }
 
 // This function is called from LinkerScript::declareSymbols.
 // It creates a placeholder symbol if needed.
 static void declareSymbol(SymbolAssignment *Cmd) {
   if (!shouldDefineSym(Cmd))
     return;
 
+  uint8_t Visibility = Cmd->Hidden ? STV_HIDDEN : STV_DEFAULT;
+  Defined New(nullptr, Cmd->Name, STB_GLOBAL, Visibility, STT_NOTYPE, 0, 0,
+              nullptr);
+
   // We can't calculate final value right now.
   Symbol *Sym;
-  uint8_t Visibility = Cmd->Hidden ? STV_HIDDEN : STV_DEFAULT;
-  std::tie(Sym, std::ignore) = Symtab->insert(Cmd->Name, Visibility,
-                                              /*CanOmitFromDynSym*/ false,
-                                              /*File*/ nullptr);
-  replaceSymbol<Defined>(Sym, nullptr, Cmd->Name, STB_GLOBAL, Visibility,
-                         STT_NOTYPE, 0, 0, nullptr);
+  std::tie(Sym, std::ignore) = Symtab->insert(&New);
+  replaceSymbol(Sym, &New);
+
   Cmd->Sym = cast<Defined>(Sym);
   Cmd->Provide = false;
   Sym->ScriptDefined = true;
 }
 
 // This method is used to handle INSERT AFTER statement. Here we rebuild
 // the list of script commands to mix sections inserted into.
 void LinkerScript::processInsertCommands() {

lld/ELF/Relocations.cpp

 // When a symbol is copy relocated or we create a canonical plt entry, it is
 // effectively a defined symbol. In the case of copy relocation the symbol is
 // in .bss and in the case of a canonical plt entry it is in .plt. This function
 // replaces the existing symbol with a Defined pointing to the appropriate
 // location.
 static void replaceWithDefined(Symbol &Sym, SectionBase *Sec, uint64_t Value,
                                uint64_t Size) {
   Symbol Old = Sym;
-  replaceSymbol<Defined>(&Sym, Sym.File, Sym.getName(), Sym.Binding,
-                         Sym.StOther, Sym.Type, Value, Size, Sec);
+
+  Defined New(Sym.File, Sym.getName(), Sym.Binding, Sym.StOther, Sym.Type,
+              Value, Size, Sec);
+  replaceSymbol(&Sym, &New);
+
   Sym.PltIndex = Old.PltIndex;
   Sym.GotIndex = Old.GotIndex;
   Sym.VerdefIndex = Old.VerdefIndex;
   Sym.PPC64BranchltIndex = Old.PPC64BranchltIndex;
   Sym.IsPreemptible = true;
   Sym.ExportDynamic = true;
   Sym.IsUsedInRegularObj = true;
   Sym.Used = true;

lld/ELF/SymbolTable.h

 #include "InputFiles.h"
 #include "LTO.h"
 #include "lld/Common/Strings.h"
 #include "llvm/ADT/CachedHashString.h"
 #include "llvm/ADT/DenseMap.h"
 
 namespace lld {
 namespace elf {
+
 class Defined;
+class LazyArchive;
+class LazyObject;
 class SectionBase;
+class SharedSymbol;
+class Undefined;
 
 // SymbolTable is a bucket of all known symbols, including defined,
 // undefined, or lazy symbols (the last one is symbols in archive
 // files whose archive members are not yet loaded).
 //
 // We put all symbols of all files to a SymbolTable, and the
 // SymbolTable selects the "best" symbols if there are name
 // conflicts. For example, obviously, a defined symbol is better than
 // an undefined symbol. Or, if there's a conflict between a lazy and a
 // undefined, it'll read an archive member to read a real definition
 // to replace the lazy symbol. The logic is implemented in the
 // add*() functions, which are called by input files as they are parsed. There
 // is one add* function per symbol type.
 class SymbolTable {
 public:
   template <class ELFT> void addCombinedLTOObject();
   void wrap(Symbol *Sym, Symbol *Real, Symbol *Wrap);
 
   ArrayRef<Symbol *> getSymbols() const { return SymVector; }
 
-  template <class ELFT>
-  Symbol *addUndefined(StringRef Name, uint8_t Binding, uint8_t StOther,
-                       uint8_t Type, bool CanOmitFromDynSym, InputFile *File);
-
-  Defined *addDefined(StringRef Name, uint8_t StOther, uint8_t Type,
-                      uint64_t Value, uint64_t Size, uint8_t Binding,
-                      SectionBase *Section, InputFile *File);
-
-  void addShared(StringRef Name, uint8_t Binding, uint8_t StOther, uint8_t Type,
-                 uint64_t Value, uint64_t Size, uint32_t Alignment,
-                 uint32_t VerdefIndex, InputFile *File);
+  template <class ELFT> Symbol *addUndefined(Undefined *New);
 
-  template <class ELFT>
-  void addLazyArchive(StringRef Name, ArchiveFile &F,
-                      const llvm::object::Archive::Symbol S);
+  Defined *addDefined(Defined *New);
 
-  template <class ELFT> void addLazyObject(StringRef Name, LazyObjFile &Obj);
+  void addShared(SharedSymbol *New);
 
-  Symbol *addBitcode(StringRef Name, uint8_t Binding, uint8_t StOther,
-                     uint8_t Type, bool CanOmitFromDynSym, BitcodeFile &File);
+  template <class ELFT> void addLazyArchive(LazyArchive *New);
+  template <class ELFT> void addLazyObject(LazyObject *New);
 
-  Symbol *addCommon(StringRef Name, uint64_t Size, uint32_t Alignment,
-                    uint8_t Binding, uint8_t StOther, uint8_t Type,
-                    InputFile &File);
+  Symbol *addBitcode(Defined *New);
+  Symbol *addCommon(Defined *New);
 
-  std::pair<Symbol *, bool> insert(StringRef Name, uint8_t Visibility,
-                                   bool CanOmitFromDynSym, InputFile *File);
+  std::pair<Symbol *, bool> insert(Symbol *New);
 
   template <class ELFT> void fetchLazy(Symbol *Sym);
 
   void scanVersionScript();
 
   Symbol *find(StringRef Name);
 
   void trace(StringRef Name);
 
   void handleDynamicList();
 
   // Set of .so files to not link the same shared object file more than once.
   llvm::DenseMap<StringRef, SharedFile *> SoNames;
 
 private:
-  std::pair<Symbol *, bool> insertName(StringRef Name);
+  template <class ELFT, class LazyT> void addLazy(LazyT *New);
 
   std::vector<Symbol *> findByVersion(SymbolVersion Ver);
   std::vector<Symbol *> findAllByVersion(SymbolVersion Ver);
 
   llvm::StringMap<std::vector<Symbol *>> &getDemangledSyms();
   void handleAnonymousVersion();
   void assignExactVersion(SymbolVersion Ver, uint16_t VersionId,
                           StringRef VersionName);

lld/ELF/SymbolTable.cpp

 static uint8_t getMinVisibility(uint8_t VA, uint8_t VB) {
   if (VA == STV_DEFAULT)
     return VB;
   if (VB == STV_DEFAULT)
     return VA;
   return std::min(VA, VB);
 }
 
+// Find an existing symbol or create and insert a new one, then apply the given
+// attributes.
+std::pair<Symbol *, bool> SymbolTable::insert(Symbol *New) {
   // Find an existing symbol or create and insert a new one.
-std::pair<Symbol *, bool> SymbolTable::insertName(StringRef Name) {
+
   // <name>@@<version> means the symbol is the default version. In that
   // case <name>@@<version> will be used to resolve references to <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).
+  StringRef Name = New->getName();
   size_t Pos = Name.find('@');
   if (Pos != StringRef::npos && Pos + 1 < Name.size() && Name[Pos + 1] == '@')
     Name = Name.take_front(Pos);
 
   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 = true;
     Traced = true;
   }
 
-  if (!IsNew)
-    return {SymVector[SymIndex], false};
+  Symbol *Old;
+  if (IsNew) {
+    Old = reinterpret_cast<Symbol *>(make<SymbolUnion>());
+    SymVector.push_back(Old);
+
+    Old->SymbolKind = Symbol::PlaceholderKind;
+    Old->VersionId = Config->DefaultSymbolVersion;
+    Old->Visibility = STV_DEFAULT;
+    Old->IsUsedInRegularObj = false;
+    Old->ExportDynamic = false;
+    Old->CanInline = true;
+    Old->Traced = Traced;
+    Old->ScriptDefined = false;
+  } else {
+    Old = SymVector[SymIndex];
+  }
+
+  // Merge symbol properties.
+  Old->ExportDynamic = Old->ExportDynamic || New->ExportDynamic;
+  Old->IsUsedInRegularObj = Old->IsUsedInRegularObj || New->IsUsedInRegularObj;
+
+  // DSO symbols do not affect visibility in the output.
+  if (!isa<SharedSymbol>(New))
+    Old->Visibility = getMinVisibility(Old->Visibility, New->Visibility);
 
-  auto *Sym = reinterpret_cast<Symbol *>(make<SymbolUnion>());
-  Sym->SymbolKind = Symbol::PlaceholderKind;
-  Sym->Visibility = STV_DEFAULT;
-  Sym->IsUsedInRegularObj = false;
-  Sym->ExportDynamic = false;
-  Sym->CanInline = true;
-  Sym->Traced = Traced;
-  Sym->VersionId = Config->DefaultSymbolVersion;
-  SymVector.push_back(Sym);
-  return {Sym, true};
+  return {Old, 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 Visibility,
-                                              bool CanOmitFromDynSym,
-                                              InputFile *File) {
-  Symbol *S;
+template <class ELFT> Symbol *SymbolTable::addUndefined(Undefined *New) {
+  Symbol *Old;
   bool WasInserted;
-  std::tie(S, WasInserted) = insertName(Name);
-
-  // Merge in the new symbol's visibility.
-  S->Visibility = getMinVisibility(S->Visibility, Visibility);
-
-  if (!CanOmitFromDynSym && (Config->Shared || Config->ExportDynamic))
-    S->ExportDynamic = true;
-
-  if (!File || File->kind() == InputFile::ObjKind)
-    S->IsUsedInRegularObj = true;
-
-  return {S, WasInserted};
-}
-
-static uint8_t getVisibility(uint8_t StOther) { return StOther & 3; }
-
-template <class ELFT>
-Symbol *SymbolTable::addUndefined(StringRef Name, uint8_t Binding,
-                                  uint8_t StOther, uint8_t Type,
-                                  bool CanOmitFromDynSym, InputFile *File) {
-  Symbol *S;
-  bool WasInserted;
-  uint8_t Visibility = getVisibility(StOther);
-  std::tie(S, WasInserted) = insert(Name, Visibility, CanOmitFromDynSym, File);
+  std::tie(Old, WasInserted) = insert(New);
 
   // An undefined symbol with non default visibility must be satisfied
   // in the same DSO.
-  if (WasInserted || (isa<SharedSymbol>(S) && Visibility != STV_DEFAULT)) {
-    replaceSymbol<Undefined>(S, File, Name, Binding, StOther, Type);
-    return S;
+  if (WasInserted ||
+      (isa<SharedSymbol>(Old) && New->Visibility != STV_DEFAULT)) {
+    replaceSymbol(Old, New);
+    return Old;
   }
 
-  if (S->isShared() || S->isLazy() || (S->isUndefined() && Binding != STB_WEAK))
-    S->Binding = Binding;
+  if (Old->isShared() || Old->isLazy() ||
+      (Old->isUndefined() && New->Binding != STB_WEAK))
+    Old->Binding = New->Binding;
 
-  if (S->isLazy()) {
+  if (Old->isLazy()) {
     // An undefined weak will not fetch archive members. See comment on Lazy in
     // Symbols.h for the details.
-    if (Binding == STB_WEAK) {
-      S->Type = Type;
-      return S;
+    if (New->Binding == STB_WEAK) {
+      Old->Type = New->Type;
+      return Old;
     }
 
     // Do extra check for --warn-backrefs.
     //
     // --warn-backrefs is an option to prevent an undefined reference from
     // fetching an archive member written earlier in the command line. It can be
     // used to keep compatibility with GNU linkers to some degree.
     // I'll explain the feature and why you may find it useful in this comment.
if (Old->isLazy()) {
     // A file outside --{start,end}-group gets a fresh ID when instantiated. All
     // files within the same --{start,end}-group get the same group ID. E.g.
     //
     //   ld.lld A B --start-group C D --end-group E
     //
     // A forms group 0. B form group 1. C and D (including their member object
     // files) form group 2. E forms group 3. I think that you can see how this
     // group assignment rule simulates the traditional linker's semantics.
-    bool Backref =
-        Config->WarnBackrefs && File && S->File->GroupId < File->GroupId;
-    fetchLazy<ELFT>(S);
+    bool Backref = Config->WarnBackrefs && New->File &&
+                   Old->File->GroupId < New->File->GroupId;
+    fetchLazy<ELFT>(Old);
 
     // We don't report backward references to weak symbols as they can be
     // overridden later.
-    if (Backref && !S->isWeak())
-      warn("backward reference detected: " + Name + " in " + toString(File) +
-           " refers to " + toString(S->File));
+    if (Backref && !Old->isWeak())
+      warn("backward reference detected: " + New->getName() + " in " +
+           toString(New->File) + " refers to " + toString(Old->File));
   }
-  return S;
+  return Old;
 }
 
 // Using .symver foo,foo@@VER unfortunately creates two symbols: foo and
 // foo@@VER. We want to effectively ignore foo, so give precedence to
 // foo@@VER.
 // FIXME: If users can transition to using
 // .symver foo,foo@@@VER
 // we can delete this hack.
-static int compareVersion(Symbol *S, StringRef Name) {
-  bool A = Name.contains("@@");
-  bool B = S->getName().contains("@@");
-  if (A && !B)
-    return 1;
+static int compareVersion(StringRef OldName, StringRef NewName) {
+  bool A = OldName.contains("@@");
+  bool B = NewName.contains("@@");
   if (!A && B)
+    return 1;
+  if (A && !B)
     return -1;
   return 0;
 }
 
 // We have a new defined symbol with the specified binding. Return 1 if the new
 // symbol should win, -1 if the new symbol should lose, or 0 if both symbols are
 // strong defined symbols.
-static int compareDefined(Symbol *S, bool WasInserted, uint8_t Binding,
-                          StringRef Name) {
-  if (WasInserted)
+static int compareDefined(Symbol *Old, Symbol *New) {
+  if (!Old->isDefined())
     return 1;
-  if (!S->isDefined())
-    return 1;
-  if (int R = compareVersion(S, Name))
-    return R;
-  if (Binding == STB_WEAK)
+  if (int Cmp = compareVersion(Old->getName(), New->getName()))
+    return Cmp;
+  if (New->Binding == STB_WEAK)
     return -1;
-  if (S->isWeak())
+  if (Old->isWeak())
     return 1;
   return 0;
 }
 
 // We have a new non-common defined symbol with the specified binding. Return 1
 // if the new symbol should win, -1 if the new symbol should lose, or 0 if there
 // is a conflict. If the new symbol wins, also update the binding.
-static int compareDefinedNonCommon(Symbol *S, bool WasInserted, uint8_t Binding,
-                                   bool IsAbsolute, uint64_t Value,
-                                   StringRef Name) {
-  if (int Cmp = compareDefined(S, WasInserted, Binding, Name))
+static int compareDefinedNonCommon(Symbol *OldSym, Defined *New) {
+  if (int Cmp = compareDefined(OldSym, New))
     return Cmp;
-  if (auto *R = dyn_cast<Defined>(S)) {
-    if (R->Section && isa<BssSection>(R->Section)) {
+
+  if (auto *Old = dyn_cast<Defined>(OldSym)) {
+    if (Old->Section && isa<BssSection>(Old->Section)) {
       // Non-common symbols take precedence over common symbols.
       if (Config->WarnCommon)
-        warn("common " + S->getName() + " is overridden");
+        warn("common " + Old->getName() + " is overridden");
       return 1;
     }
-    if (R->Section == nullptr && Binding == STB_GLOBAL && IsAbsolute &&
-        R->Value == Value)
+
+    if (New->File && isa<BitcodeFile>(New->File))
+      return 0;
+
+    if (Old->Section == nullptr && New->Section == nullptr &&
+        Old->Value == New->Value && New->Binding == STB_GLOBAL)
       return -1;
   }
   return 0;
 }
 
-Symbol *SymbolTable::addCommon(StringRef N, uint64_t Size, uint32_t Alignment,
-                               uint8_t Binding, uint8_t StOther, uint8_t Type,
-                               InputFile &File) {
-  Symbol *S;
+Symbol *SymbolTable::addCommon(Defined *New) {
+  Symbol *Old;
   bool WasInserted;
-  std::tie(S, WasInserted) = insert(N, getVisibility(StOther),
-                                    /*CanOmitFromDynSym*/ false, &File);
+  std::tie(Old, WasInserted) = insert(New);
 
-  int Cmp = compareDefined(S, WasInserted, Binding, N);
-  if (Cmp < 0)
-    return S;
-
-  if (Cmp > 0) {
-    auto *Bss = make<BssSection>("COMMON", Size, Alignment);
-    Bss->File = &File;
+  auto Replace = [&] {
+    auto *Bss = make<BssSection>("COMMON", New->Size, New->Value);
+    Bss->File = New->File;
     Bss->Live = !Config->GcSections;
     InputSections.push_back(Bss);
 
-    replaceSymbol<Defined>(S, &File, N, Binding, StOther, Type, 0, Size, Bss);
-    return S;
+    New->Value = 0;
+    New->Section = Bss;
+    replaceSymbol(Old, New);
+  };
+
+  if (WasInserted) {
+    Replace();
+    return Old;
   }
 
-  auto *D = cast<Defined>(S);
+  int Cmp = compareDefined(Old, New);
+  if (Cmp < 0)
+    return Old;
+
+  if (Cmp > 0) {
+    Replace();
+    return Old;
+  }
+
+  auto *D = cast<Defined>(Old);
   auto *Bss = dyn_cast_or_null<BssSection>(D->Section);
   if (!Bss) {
     // Non-common symbols take precedence over common symbols.
     if (Config->WarnCommon)
-      warn("common " + S->getName() + " is overridden");
-    return S;
+      warn("common " + Old->getName() + " is overridden");
+    return Old;
   }
 
   if (Config->WarnCommon)
     warn("multiple common of " + D->getName());
 
-  Bss->Alignment = std::max(Bss->Alignment, Alignment);
-  if (Size > Bss->Size) {
-    D->File = Bss->File = &File;
-    D->Size = Bss->Size = Size;
+  Bss->Alignment = std::max<uint32_t>(Bss->Alignment, New->Value);
+  if (New->Size > Bss->Size) {
+    D->File = Bss->File = New->File;
+    D->Size = Bss->Size = New->Size;
   }
-  return S;
+  return Old;
 }
 
 static void reportDuplicate(Symbol *Sym, InputFile *NewFile,
                             InputSectionBase *ErrSec, uint64_t ErrOffset) {
   if (Config->AllowMultipleDefinition)
     return;
 
   Defined *D = cast<Defined>(Sym);
if (!Src1.empty())
     Msg += Src1 + "\n>>>            ";
   Msg += Obj1 + "\n>>> defined at ";
   if (!Src2.empty())
     Msg += Src2 + "\n>>>            ";
   Msg += Obj2;
   error(Msg);
 }
 
-Defined *SymbolTable::addDefined(StringRef Name, uint8_t StOther, uint8_t Type,
-                                 uint64_t Value, uint64_t Size, uint8_t Binding,
-                                 SectionBase *Section, InputFile *File) {
-  Symbol *S;
+Defined *SymbolTable::addDefined(Defined *New) {
+  Symbol *Old;
   bool WasInserted;
-  std::tie(S, WasInserted) = insert(Name, getVisibility(StOther),
-                                    /*CanOmitFromDynSym*/ false, File);
-  int Cmp = compareDefinedNonCommon(S, WasInserted, Binding, Section == nullptr,
-                                    Value, Name);
+  std::tie(Old, WasInserted) = insert(New);
+
+  if (WasInserted) {
+    replaceSymbol(Old, New);
+    return cast<Defined>(Old);
+  }
+
+  int Cmp = compareDefinedNonCommon(Old, New);
   if (Cmp > 0)
-    replaceSymbol<Defined>(S, File, Name, Binding, StOther, Type, Value, Size,
-                           Section);
+    replaceSymbol(Old, New);
   else if (Cmp == 0)
-    reportDuplicate(S, File, dyn_cast_or_null<InputSectionBase>(Section),
-                    Value);
-  return cast<Defined>(S);
+    reportDuplicate(Old, New->File,
+                    dyn_cast_or_null<InputSectionBase>(New->Section),
+                    New->Value);
+  return cast<Defined>(Old);
 }
 
-void SymbolTable::addShared(StringRef Name, uint8_t Binding, uint8_t StOther,
-                            uint8_t Type, uint64_t Value, uint64_t Size,
-                            uint32_t Alignment, uint32_t VerdefIndex,
-                            InputFile *File) {
-  // DSO symbols do not affect visibility in the output, so we pass STV_DEFAULT
-  // as the visibility, which will leave the visibility in the symbol table
-  // unchanged.
-  Symbol *S;
+void SymbolTable::addShared(SharedSymbol *New) {
+  Symbol *Old;
   bool WasInserted;
-  std::tie(S, WasInserted) = insert(Name, STV_DEFAULT,
-                                    /*CanOmitFromDynSym*/ true, File);
+  std::tie(Old, WasInserted) = insert(New);
+
   // Make sure we preempt DSO symbols with default visibility.
-  if (getVisibility(StOther) == STV_DEFAULT)
-    S->ExportDynamic = true;
+  if (New->Visibility == STV_DEFAULT)
+    Old->ExportDynamic = true;
 
+  if (WasInserted) {
+    replaceSymbol(Old, New);
+  } else if (Old->Visibility == STV_DEFAULT &&
+             (Old->isUndefined() || Old->isLazy())) {
     // An undefined symbol with non default visibility must be satisfied
     // in the same DSO.
-  auto Replace = [&](uint8_t Binding) {
-    replaceSymbol<SharedSymbol>(S, *File, Name, Binding, StOther, Type, Value,
-                                Size, Alignment, VerdefIndex);
-  };
-
-  if (WasInserted)
-    Replace(Binding);
-  else if (S->Visibility == STV_DEFAULT && (S->isUndefined() || S->isLazy()))
-    Replace(S->Binding);
+    uint8_t Binding = Old->Binding;
+    replaceSymbol(Old, New);
+    Old->Binding = Binding;
+  }
 }
 
-Symbol *SymbolTable::addBitcode(StringRef Name, uint8_t Binding,
-                                uint8_t StOther, uint8_t Type,
-                                bool CanOmitFromDynSym, BitcodeFile &F) {
-  Symbol *S;
+Symbol *SymbolTable::addBitcode(Defined *New) {
+  Symbol *Old;
   bool WasInserted;
-  std::tie(S, WasInserted) =
-      insert(Name, getVisibility(StOther), CanOmitFromDynSym, &F);
-  int Cmp = compareDefinedNonCommon(S, WasInserted, Binding,
-                                    /*IsAbs*/ false, /*Value*/ 0, Name);
+  std::tie(Old, WasInserted) = insert(New);
+
+  if (WasInserted) {
+    replaceSymbol(Old, New);
+    return Old;
+  }
+
+  int Cmp = compareDefinedNonCommon(Old, New);
   if (Cmp > 0)
-    replaceSymbol<Defined>(S, &F, Name, Binding, StOther, Type, 0, 0, nullptr);
+    replaceSymbol(Old, New);
   else if (Cmp == 0)
-    reportDuplicate(S, &F, nullptr, 0);
-  return S;
+    reportDuplicate(Old, New->File, nullptr, 0);
+  return Old;
 }
 
 Symbol *SymbolTable::find(StringRef Name) {
   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>
-void SymbolTable::addLazyArchive(StringRef Name, ArchiveFile &File,
-                                 const object::Archive::Symbol Sym) {
-  Symbol *S;
+template <class ELFT, class LazyT> void SymbolTable::addLazy(LazyT *New) {
+  Symbol *Old;
   bool WasInserted;
-  std::tie(S, WasInserted) = insertName(Name);
+  std::tie(Old, WasInserted) = insert(New);
+
   if (WasInserted) {
-    replaceSymbol<LazyArchive>(S, File, STT_NOTYPE, Sym);
+    replaceSymbol(Old, New);
     return;
   }
-  if (!S->isUndefined())
+
+  if (!Old->isUndefined())
     return;
 
   // An undefined weak will not fetch archive members. See comment on Lazy in
   // Symbols.h for the details.
-  if (S->isWeak()) {
-    replaceSymbol<LazyArchive>(S, File, S->Type, Sym);
-    S->Binding = STB_WEAK;
+  if (Old->isWeak()) {
+    uint8_t Type = Old->Type;
+    replaceSymbol(Old, New);
+    Old->Type = Type;
+    Old->Binding = STB_WEAK;
     return;
   }
 
-  if (InputFile *F = File.fetch(Sym))
+  if (InputFile *F = New->fetch())
     parseFile<ELFT>(F);
 }
 
-template <class ELFT>
-void SymbolTable::addLazyObject(StringRef Name, LazyObjFile &File) {
-  Symbol *S;
-  bool WasInserted;
-  std::tie(S, WasInserted) = insertName(Name);
-  if (WasInserted) {
-    replaceSymbol<LazyObject>(S, File, STT_NOTYPE, Name);
-    return;
-  }
-  if (!S->isUndefined())
-    return;
-
-  // An undefined weak will not fetch archive members. See comment on Lazy in
-  // Symbols.h for the details.
-  if (S->isWeak()) {
-    replaceSymbol<LazyObject>(S, File, S->Type, Name);
-    S->Binding = STB_WEAK;
-    return;
-  }
+template <class ELFT> void SymbolTable::addLazyArchive(LazyArchive *New) {
+  addLazy<ELFT>(New);
 
-  if (InputFile *F = File.fetch())
-    parseFile<ELFT>(F);
+template <class ELFT> void SymbolTable::addLazyObject(LazyObject *New) {
+  addLazy<ELFT>(New);
 }
 
 template <class ELFT> void SymbolTable::fetchLazy(Symbol *Sym) {
   if (auto *S = dyn_cast<LazyArchive>(Sym)) {
     if (InputFile *File = S->fetch())
       parseFile<ELFT>(File);
     return;
   }
void SymbolTable::scanVersionScript() {
 
   // Symbol themselves might know their versions because symbols
   // can contain versions in the form of <name>@<version>.
   // Let them parse and update their names to exclude version suffix.
   for (Symbol *Sym : SymVector)
     Sym->parseSymbolVersion();
 }
 
-template Symbol *SymbolTable::addUndefined<ELF32LE>(StringRef, uint8_t, uint8_t,
-                                                    uint8_t, bool, InputFile *);
-template Symbol *SymbolTable::addUndefined<ELF32BE>(StringRef, uint8_t, uint8_t,
-                                                    uint8_t, bool, InputFile *);
-template Symbol *SymbolTable::addUndefined<ELF64LE>(StringRef, uint8_t, uint8_t,
-                                                    uint8_t, bool, InputFile *);
-template Symbol *SymbolTable::addUndefined<ELF64BE>(StringRef, uint8_t, uint8_t,
-                                                    uint8_t, bool, InputFile *);
+template Symbol *SymbolTable::addUndefined<ELF32LE>(Undefined *);
+template Symbol *SymbolTable::addUndefined<ELF32BE>(Undefined *);
+template Symbol *SymbolTable::addUndefined<ELF64LE>(Undefined *);
+template Symbol *SymbolTable::addUndefined<ELF64BE>(Undefined *);
 
 template void SymbolTable::addCombinedLTOObject<ELF32LE>();
 template void SymbolTable::addCombinedLTOObject<ELF32BE>();
 template void SymbolTable::addCombinedLTOObject<ELF64LE>();
 template void SymbolTable::addCombinedLTOObject<ELF64BE>();
 
-template void
-SymbolTable::addLazyArchive<ELF32LE>(StringRef, ArchiveFile &,
-                                     const object::Archive::Symbol);
-template void
-SymbolTable::addLazyArchive<ELF32BE>(StringRef, ArchiveFile &,
-                                     const object::Archive::Symbol);
-template void
-SymbolTable::addLazyArchive<ELF64LE>(StringRef, ArchiveFile &,
-                                     const object::Archive::Symbol);
-template void
-SymbolTable::addLazyArchive<ELF64BE>(StringRef, ArchiveFile &,
-                                     const object::Archive::Symbol);
-
-template void SymbolTable::addLazyObject<ELF32LE>(StringRef, LazyObjFile &);
-template void SymbolTable::addLazyObject<ELF32BE>(StringRef, LazyObjFile &);
-template void SymbolTable::addLazyObject<ELF64LE>(StringRef, LazyObjFile &);
-template void SymbolTable::addLazyObject<ELF64BE>(StringRef, LazyObjFile &);
+template void SymbolTable::addLazyArchive<ELF32LE>(LazyArchive *);
+template void SymbolTable::addLazyArchive<ELF32BE>(LazyArchive *);
+template void SymbolTable::addLazyArchive<ELF64LE>(LazyArchive *);
+template void SymbolTable::addLazyArchive<ELF64BE>(LazyArchive *);
+
+template void SymbolTable::addLazyObject<ELF32LE>(LazyObject *);
+template void SymbolTable::addLazyObject<ELF32BE>(LazyObject *);
+template void SymbolTable::addLazyObject<ELF64LE>(LazyObject *);
+template void SymbolTable::addLazyObject<ELF64BE>(LazyObject *);
 
 template void SymbolTable::fetchLazy<ELF32LE>(Symbol *);
 template void SymbolTable::fetchLazy<ELF32BE>(Symbol *);
 template void SymbolTable::fetchLazy<ELF64LE>(Symbol *);
 template void SymbolTable::fetchLazy<ELF64BE>(Symbol *);

lld/ELF/Symbols.h

public:
   uint64_t getPPC64LongBranchOffset() const;
   uint64_t getSize() const;
   OutputSection *getOutputSection() const;
 
 protected:
   Symbol(Kind K, InputFile *File, StringRefZ Name, uint8_t Binding,
          uint8_t StOther, uint8_t Type)
       : File(File), NameData(Name.Data), NameSize(Name.Size), Binding(Binding),
-        Type(Type), StOther(StOther), SymbolKind(K), NeedsPltAddr(false),
-        IsInIplt(false), GotInIgot(false), IsPreemptible(false),
-        Used(!Config->GcSections), NeedsTocRestore(false),
-        ScriptDefined(false) {}
+        Type(Type), StOther(StOther), SymbolKind(K), Visibility(StOther & 3),
+        IsUsedInRegularObj(!File || File->kind() == InputFile::ObjKind),
+        ExportDynamic(K != SharedKind &&
+                      (Config->Shared || Config->ExportDynamic)),
+        CanInline(false), Traced(false), NeedsPltAddr(false), IsInIplt(false),
+        GotInIgot(false), IsPreemptible(false), Used(!Config->GcSections),
+        NeedsTocRestore(false), ScriptDefined(false) {}
 
 public:
   // True the symbol should point to its PLT entry.
   // For SharedSymbol only.
   unsigned NeedsPltAddr : 1;
 
   // True if this symbol is in the Iplt sub-section of the Plt and the Igot
   // sub-section of the .got.plt or .got.

 // symbols into consideration.
 
 // This class represents a symbol defined in an archive file. It is
 // created from an archive file header, and it knows how to load an
 // object file from an archive to replace itself with a defined
 // symbol.
 class LazyArchive : public Symbol {
 public:
-  LazyArchive(InputFile &File, uint8_t Type,
-              const llvm::object::Archive::Symbol S)
+  LazyArchive(InputFile &File, const llvm::object::Archive::Symbol S)
       : Symbol(LazyArchiveKind, &File, S.getName(), llvm::ELF::STB_GLOBAL,
-               llvm::ELF::STV_DEFAULT, Type),
+               llvm::ELF::STV_DEFAULT, llvm::ELF::STT_NOTYPE),
         Sym(S) {}
 
   static bool classof(const Symbol *S) { return S->kind() == LazyArchiveKind; }
 
   InputFile *fetch();
   MemoryBufferRef getMemberBuffer();
 
 private:
   const llvm::object::Archive::Symbol Sym;
 };
 
 // LazyObject symbols represents symbols in object files between
 // --start-lib and --end-lib options.
 class LazyObject : public Symbol {
 public:
-  LazyObject(InputFile &File, uint8_t Type, StringRef Name)
+  LazyObject(InputFile &File, StringRef Name)
       : Symbol(LazyObjectKind, &File, Name, llvm::ELF::STB_GLOBAL,
-               llvm::ELF::STV_DEFAULT, Type) {}
+               llvm::ELF::STV_DEFAULT, llvm::ELF::STT_NOTYPE) {}
 
   static bool classof(const Symbol *S) { return S->kind() == LazyObjectKind; }
+
+  InputFile *fetch();
 };
 
 // Some linker-generated symbols need to be created as
 // Defined symbols.
 struct ElfSym {
   // __bss_start
   static Defined *Bss;
 
union SymbolUnion {
   alignas(Undefined) char C[sizeof(Undefined)];
   alignas(SharedSymbol) char D[sizeof(SharedSymbol)];
   alignas(LazyArchive) char E[sizeof(LazyArchive)];
   alignas(LazyObject) char F[sizeof(LazyObject)];
 };
 
 void printTraceSymbol(Symbol *Sym);
 
-template <typename T, typename... ArgT>
-void replaceSymbol(Symbol *S, ArgT &&... Arg) {
+template <typename T> void replaceSymbol(Symbol *Sym, T *New) {
   using llvm::ELF::STT_TLS;
 
   static_assert(std::is_trivially_destructible<T>(),
                 "Symbol types must be trivially destructible");
   static_assert(sizeof(T) <= sizeof(SymbolUnion), "SymbolUnion too small");
   static_assert(alignof(T) <= alignof(SymbolUnion),
                 "SymbolUnion not aligned enough");
   assert(static_cast<Symbol *>(static_cast<T *>(nullptr)) == nullptr &&
          "Not a Symbol");
 
-  Symbol Sym = *S;
-
-  new (S) T(std::forward<ArgT>(Arg)...);
-
-  S->VersionId = Sym.VersionId;
-  S->Visibility = Sym.Visibility;
-  S->IsUsedInRegularObj = Sym.IsUsedInRegularObj;
-  S->ExportDynamic = Sym.ExportDynamic;
-  S->CanInline = Sym.CanInline;
-  S->Traced = Sym.Traced;
-  S->ScriptDefined = Sym.ScriptDefined;
-
   // Symbols representing thread-local variables must be referenced by
   // TLS-aware relocations, and non-TLS symbols must be reference by
   // non-TLS relocations, so there's a clear distinction between TLS
   // and non-TLS symbols. It is an error if the same symbol is defined
   // as a TLS symbol in one file and as a non-TLS symbol in other file.
-  bool TlsMismatch = (Sym.Type == STT_TLS && S->Type != STT_TLS) ||
-                     (Sym.Type != STT_TLS && S->Type == STT_TLS);
+  if (Sym->SymbolKind != Symbol::PlaceholderKind && !Sym->isLazy() &&
+      !New->isLazy()) {
+    bool TlsMismatch = (Sym->Type == STT_TLS && New->Type != STT_TLS) ||
+                       (Sym->Type != STT_TLS && New->Type == STT_TLS);
+    if (TlsMismatch)
+      error("TLS attribute mismatch: " + toString(*Sym) + "\n>>> defined in " +
+            toString(New->File) + "\n>>> defined in " + toString(Sym->File));
+  }
+
+  Symbol Old = *Sym;
+  memcpy(Sym, New, sizeof(T));
 
-  if (Sym.SymbolKind != Symbol::PlaceholderKind && TlsMismatch && !Sym.isLazy())
-    error("TLS attribute mismatch: " + toString(Sym) + "\n>>> defined in " +
-          toString(Sym.File) + "\n>>> defined in " + toString(S->File));
+  Sym->VersionId = Old.VersionId;
+  Sym->Visibility = Old.Visibility;
+  Sym->IsUsedInRegularObj = Old.IsUsedInRegularObj;
+  Sym->ExportDynamic = Old.ExportDynamic;
+  Sym->CanInline = Old.CanInline;
+  Sym->Traced = Old.Traced;
+  Sym->ScriptDefined = Old.ScriptDefined;
 
   // Print out a log message if --trace-symbol was specified.
   // This is for debugging.
-  if (S->Traced)
-    printTraceSymbol(S);
+  if (Sym->Traced)
+    printTraceSymbol(Sym);
 }
 
 void maybeWarnUnorderableSymbol(const Symbol *Sym);
 } // namespace elf
 } // namespace lld
 
 #endif

lld/ELF/Symbols.cpp

MemoryBufferRef LazyArchive::getMemberBuffer() {
   Archive::Child C = CHECK(
       Sym.getMember(), "could not get the member for symbol " + Sym.getName());
 
   return CHECK(C.getMemoryBufferRef(),
                "could not get the buffer for the member defining symbol " +
                    Sym.getName());
 }
 
+InputFile *LazyObject::fetch() { return cast<LazyObjFile>(File)->fetch(); }
+
 uint8_t Symbol::computeBinding() const {
   if (Config->Relocatable)
     return Binding;
   if (Visibility != STV_DEFAULT && Visibility != STV_PROTECTED)
     return STB_LOCAL;
   if (VersionId == VER_NDX_LOCAL && isDefined() && !IsPreemptible)
     return STB_LOCAL;
   if (!Config->GnuUnique && Binding == STB_GNU_UNIQUE)

lld/ELF/Writer.cpp

 }
 
 static Defined *addOptionalRegular(StringRef Name, SectionBase *Sec,
                                    uint64_t Val, uint8_t StOther = STV_HIDDEN,
                                    uint8_t Binding = STB_GLOBAL) {
   Symbol *S = Symtab->find(Name);
   if (!S || S->isDefined())
     return nullptr;
-  return Symtab->addDefined(Name, StOther, STT_NOTYPE, Val,
-                            /*Size=*/0, Binding, Sec,
-                            /*File=*/nullptr);
+
+  Defined New(/*File=*/nullptr, Name, Binding, StOther, STT_NOTYPE, Val,
+              /*Size=*/0, Sec);
+  return Symtab->addDefined(&New);
 }
 
 static Defined *addAbsolute(StringRef Name) {
-  return Symtab->addDefined(Name, STV_HIDDEN, STT_NOTYPE, 0, 0, STB_GLOBAL,
-                            nullptr, nullptr);
+  Defined New(nullptr, Name, STB_GLOBAL, STV_HIDDEN, STT_NOTYPE, 0, 0, nullptr);
+  return Symtab->addDefined(&New);
 }
 
 // The linker is expected to define some symbols depending on
 // the linking result. This function defines such symbols.
 void elf::addReservedSymbols() {
   if (Config->EMachine == EM_MIPS) {
     // Define _gp for MIPS. st_value of _gp symbol will be updated by Writer
     // so that it points to an absolute address which by default is relative
if (S->isDefined()) {
             GotSymName + "'");
       return;
     }
 
     uint64_t GotOff = 0;
     if (Config->EMachine == EM_PPC || Config->EMachine == EM_PPC64)
       GotOff = 0x8000;
 
-    ElfSym::GlobalOffsetTable =
-        Symtab->addDefined(GotSymName, STV_HIDDEN, STT_NOTYPE, GotOff,
-                           /*Size=*/0, STB_GLOBAL, Out::ElfHeader,
-                           /*File=*/nullptr);
+    Defined New(/*File=*/nullptr, GotSymName, STB_GLOBAL, STV_HIDDEN,
+                STT_NOTYPE, GotOff,
+                /*Size=*/0, Out::ElfHeader);
+    ElfSym::GlobalOffsetTable = Symtab->addDefined(&New);
   }
 
   // __ehdr_start is the location of ELF file headers. Note that we define
   // this symbol unconditionally even when using a linker script, which
   // differs from the behavior implemented by GNU linker which only define
   // this symbol if ELF headers are in the memory mapped segment.
   addOptionalRegular("__ehdr_start", Out::ElfHeader, 0, STV_HIDDEN);
 
for (BaseCommand *Base : Script->SectionCommands)
       if (auto *Sec = dyn_cast<OutputSection>(Base))
         addStartStopSymbols(Sec);
   }
 
   // Add _DYNAMIC symbol. Unlike GNU gold, our _DYNAMIC symbol has no type.
   // It should be okay as no one seems to care about the type.
   // Even the author of gold doesn't remember why gold behaves that way.
   // https://sourceware.org/ml/binutils/2002-03/msg00360.html
-  if (In.Dynamic->Parent)
-    Symtab->addDefined("_DYNAMIC", STV_HIDDEN, STT_NOTYPE, 0 /*Value*/,
-                       /*Size=*/0, STB_WEAK, In.Dynamic,
-                       /*File=*/nullptr);
+  if (In.Dynamic->Parent) {
+    Defined New(/*File=*/nullptr, "_DYNAMIC", STB_WEAK, STV_HIDDEN, STT_NOTYPE,
+                /*Value=*/0, /*Size=*/0, In.Dynamic);
+    Symtab->addDefined(&New);
+  }
 
   // Define __rel[a]_iplt_{start,end} symbols if needed.
   addRelIpltSymbols();
 
   // RISC-V's gp can address +/- 2 KiB, set it to .sdata + 0x800 if not defined.
   if (Config->EMachine == EM_RISCV)
     if (!dyn_cast_or_null<Defined>(Symtab->find("__global_pointer$")))
       addOptionalRegular("__global_pointer$", findSection(".sdata"), 0x800);