Detemplate SymbolTable

[• rafael]

Summary

This should make it possible to access the symbol list from non-templated code.

I wanted something like this to handle start_/end_ symbols in lto.

[ruiu]

I think we can detemplate this class without creating a class hierarchy. Most part of the class does not use ELFT, so I think we can template member functions and then detemplate the class.

[ruiu]

Yeah, but I think the reason why we are using a SymbolTable as a bag to store input files is mostly historic. We can store it to global variables, and it shouldn't decrease the quality of code because they are already available globally through Symtab<ELFT>::X.

[• rafael]

Detemplate the rest of the class.

[ruiu]

Generally looking good.

ELF/Driver.cpp

952–953

Now you can move this to elf::link as it doesn't require ELFT.

1039

Maybe adding Instances or something to each class is better? I mean, if you do, you can do this without ELFT like this.

for (BinaryFile *F : BinaryFile::Instances)

(This is just an idea, so I'm not really sure if this is a good one, though.)

[• rafael]

Address review comments

[ruiu]

LGTM

ELF/Driver.cpp

83–84

Use make for consistency.

[• espindola]

309152

ELF/Arch/MipsArchTree.cpp

for (const FileFlags &F : Files.slice(1)) {
     }
     Ret = New;
   }
   return Ret;
 }
 
 template <class ELFT> uint32_t elf::getMipsEFlags() {
   std::vector<FileFlags> V;
-  for (elf::ObjectFile<ELFT> *F : Symtab<ELFT>::X->getObjectFiles())
+  for (elf::ObjectFile<ELFT> *F : ObjectFile<ELFT>::Instances)
     V.push_back({F->getName(), F->getObj().getHeader()->e_flags});
   if (V.empty())
     return 0;
   checkFlags(V);
   return getMiscFlags(V) | getPicFlags(V) | getArchFlags(V);
 }
 
 static int compareMipsFpAbi(uint8_t FpA, uint8_t FpB) {

ELF/Driver.cpp

bool elf::link(ArrayRef<const char *> Args, bool CanExitEarly,
   ErrorCount = 0;
   ErrorOS = &Error;
   InputSections.clear();
   Tar = nullptr;
 
   Config = make<Configuration>();
   Driver = make<LinkerDriver>();
   Script = make<LinkerScript>();
+  SymbolTable Symtab;
+  elf::Symtab = &Symtab;
   Config->Argv = {Args.begin(), Args.end()};
 
   Driver->main(Args, CanExitEarly);
   freeArena();
   return !ErrorCount;
 }
 
 // Parses a linker -m option.
for (InputFile *File : Files)
     if (auto *F = dyn_cast<ArchiveFile>(File))
       if (All || Libs.count(path::filename(F->getName())))
         for (Symbol *Sym : F->getSymbols())
           Sym->VersionId = VER_NDX_LOCAL;
 }
 
 // Do actual linking. Note that when this function is called,
 // all linker scripts have already been parsed.
 template <class ELFT> void LinkerDriver::link(opt::InputArgList &Args) {
-  SymbolTable<ELFT> Symtab;
-  elf::Symtab<ELFT>::X = &Symtab;
   Target = getTarget();
 
   Config->MaxPageSize = getMaxPageSize(Args);
   Config->ImageBase = getImageBase(Args);
 
   // Default output filename is "a.out" by the Unix tradition.
   if (Config->OutputFile.empty())
     Config->OutputFile = "a.out";
 
template <class ELFT> void LinkerDriver::link(opt::InputArgList &Args) {
   // different from others.
   Config->WarnMissingEntry =
       (!Config->Entry.empty() || (!Config->Shared && !Config->Relocatable));
   if (Config->Entry.empty() && !Config->Relocatable)
     Config->Entry = (Config->EMachine == EM_MIPS) ? "__start" : "_start";
 
   // Handle --trace-symbol.
   for (auto *Arg : Args.filtered(OPT_trace_symbol))
-    Symtab.trace(Arg->getValue());
+    Symtab->trace(Arg->getValue());
 
   // Add all files to the symbol table. This will add almost all
   // symbols that we need to the symbol table.
   for (InputFile *F : Files)
-    Symtab.addFile(F);
+    Symtab->addFile<ELFT>(F);
 
   // If an entry symbol is in a static archive, pull out that file now
   // to complete the symbol table. After this, no new names except a
   // few linker-synthesized ones will be added to the symbol table.
-  if (Symtab.find(Config->Entry))
-    Symtab.addUndefined(Config->Entry);
+  if (Symtab->find(Config->Entry))
+    Symtab->addUndefined<ELFT>(Config->Entry);
 
   // Return if there were name resolution errors.
   if (ErrorCount)
     return;
 
   // Handle the `--undefined <sym>` options.
-  Symtab.scanUndefinedFlags();
+  Symtab->scanUndefinedFlags<ELFT>();
 
   // Handle undefined symbols in DSOs.
-  Symtab.scanShlibUndefined();
+  Symtab->scanShlibUndefined<ELFT>();
 
   // Handle the -exclude-libs option.
   if (Args.hasArg(OPT_exclude_libs))
     excludeLibs(Args, Files);
 
   // Apply version scripts.
-  Symtab.scanVersionScript();
+  Symtab->scanVersionScript();
 
   // Create wrapped symbols for -wrap option.
   for (auto *Arg : Args.filtered(OPT_wrap))
-    Symtab.addSymbolWrap(Arg->getValue());
+    Symtab->addSymbolWrap<ELFT>(Arg->getValue());
 
   // Create alias symbols for -defsym option.
   for (std::pair<StringRef, StringRef> &Def : getDefsym(Args))
-    Symtab.addSymbolAlias(Def.first, Def.second);
+    Symtab->addSymbolAlias<ELFT>(Def.first, Def.second);
 
-  Symtab.addCombinedLTOObject();
+  Symtab->addCombinedLTOObject<ELFT>();
   if (ErrorCount)
     return;
 
   // Some symbols (such as __ehdr_start) are defined lazily only when there
   // are undefined symbols for them, so we add these to trigger that logic.
   for (StringRef Sym : Script->Opt.ReferencedSymbols)
-    Symtab.addUndefined(Sym);
+    Symtab->addUndefined<ELFT>(Sym);
 
   // Apply symbol renames for -wrap and -defsym
-  Symtab.applySymbolRenames();
+  Symtab->applySymbolRenames();
 
   // Now that we have a complete list of input files.
   // Beyond this point, no new files are added.
   // Aggregate all input sections into one place.
-  for (elf::ObjectFile<ELFT> *F : Symtab.getObjectFiles())
+  for (elf::ObjectFile<ELFT> *F : ObjectFile<ELFT>::Instances)
     for (InputSectionBase *S : F->getSections())
       if (S && S != &InputSection::Discarded)
         InputSections.push_back(S);
-  for (BinaryFile *F : Symtab.getBinaryFiles())
+  for (BinaryFile *F : BinaryFile::Instances)
     for (InputSectionBase *S : F->getSections())
       InputSections.push_back(cast<InputSection>(S));
 
   // This adds a .comment section containing a version string. We have to add it
   // before decompressAndMergeSections because the .comment section is a
   // mergeable section.
   if (!Config->Relocatable)
     InputSections.push_back(createCommentSection<ELFT>());

ELF/InputFiles.h

StringRef getShtGroupSignature(ArrayRef<Elf_Shdr> Sections,
                                  const Elf_Shdr &Sec);
   ArrayRef<Elf_Word> getShtGroupEntries(const Elf_Shdr &Sec);
 
 public:
   static bool classof(const InputFile *F) {
     return F->kind() == Base::ObjectKind;
   }
 
+  static std::vector<ObjectFile<ELFT> *> Instances;
+
   ArrayRef<SymbolBody *> getSymbols();
   ArrayRef<SymbolBody *> getLocalSymbols();
 
   ObjectFile(MemoryBufferRef M, StringRef ArchiveName);
   void parse(llvm::DenseSet<llvm::CachedHashStringRef> &ComdatGroups);
 
   InputSectionBase *getSection(const Elf_Sym &Sym) const;
 
private:
   // Debugging information to retrieve source file and line for error
   // reporting. Linker may find reasonable number of errors in a
   // single object file, so we cache debugging information in order to
   // parse it only once for each object file we link.
   std::unique_ptr<llvm::DWARFDebugLine> DwarfLine;
   llvm::once_flag InitDwarfLine;
 };
 
+template <class ELFT>
+std::vector<ObjectFile<ELFT> *> ObjectFile<ELFT>::Instances;
+
 // LazyObjectFile is analogous to ArchiveFile in the sense that
 // the file contains lazy symbols. The difference is that
 // LazyObjectFile wraps a single file instead of multiple files.
 //
 // This class is used for --start-lib and --end-lib options which
 // instruct the linker to link object files between them with the
 // archive file semantics.
 class LazyObjectFile : public InputFile {

 public:
   BitcodeFile(MemoryBufferRef M, StringRef ArchiveName,
               uint64_t OffsetInArchive);
   static bool classof(const InputFile *F) { return F->kind() == BitcodeKind; }
   template <class ELFT>
   void parse(llvm::DenseSet<llvm::CachedHashStringRef> &ComdatGroups);
   ArrayRef<Symbol *> getSymbols() { return Symbols; }
   std::unique_ptr<llvm::lto::InputFile> Obj;
+  static std::vector<BitcodeFile *> Instances;
 
 private:
   std::vector<Symbol *> Symbols;
 };
 
 // .so file.
 template <class ELFT> class SharedFile : public ELFFileBase<ELFT> {
   typedef ELFFileBase<ELFT> Base;
   typedef typename ELFT::Dyn Elf_Dyn;
   typedef typename ELFT::Shdr Elf_Shdr;
   typedef typename ELFT::Sym Elf_Sym;
   typedef typename ELFT::SymRange Elf_Sym_Range;
   typedef typename ELFT::Verdef Elf_Verdef;
   typedef typename ELFT::Versym Elf_Versym;
 
   std::vector<StringRef> Undefs;
   const Elf_Shdr *VersymSec = nullptr;
   const Elf_Shdr *VerdefSec = nullptr;
 
 public:
   std::string SoName;
 
+  static std::vector<SharedFile<ELFT> *> Instances;
+
   const Elf_Shdr *getSection(const Elf_Sym &Sym) const;
   llvm::ArrayRef<StringRef> getUndefinedSymbols() { return Undefs; }
 
   static bool classof(const InputFile *F) {
     return F->kind() == Base::SharedKind;
   }
 
   SharedFile(MemoryBufferRef M, StringRef DefaultSoName);
public:
   std::map<const Elf_Verdef *, NeededVer> VerdefMap;
 
   // Used for --as-needed
   bool AsNeeded = false;
   bool IsUsed = false;
   bool isNeeded() const { return !AsNeeded || IsUsed; }
 };
 
+template <class ELFT>
+std::vector<SharedFile<ELFT> *> SharedFile<ELFT>::Instances;
+
 class BinaryFile : public InputFile {
 public:
   explicit BinaryFile(MemoryBufferRef M) : InputFile(BinaryKind, M) {}
   static bool classof(const InputFile *F) { return F->kind() == BinaryKind; }
   template <class ELFT> void parse();
+  static std::vector<BinaryFile *> Instances;
 };
 
 InputFile *createObjectFile(MemoryBufferRef MB, StringRef ArchiveName = "",
                             uint64_t OffsetInArchive = 0);
 InputFile *createSharedFile(MemoryBufferRef MB, StringRef DefaultSoName);
 
 } // namespace elf
 } // namespace lld
 
 #endif

ELF/InputFiles.cpp

if (Binding == STB_LOCAL) {
     return make<DefinedRegular>(Name, /*IsLocal=*/true, StOther, Type, Value,
                                 Size, Sec, this);
   }
 
   StringRef Name = check(Sym->getName(this->StringTable), toString(this));
 
   switch (Sym->st_shndx) {
   case SHN_UNDEF:
-    return elf::Symtab<ELFT>::X
-        ->addUndefined(Name, /*IsLocal=*/false, Binding, StOther, Type,
+    return elf::Symtab
+        ->addUndefined<ELFT>(Name, /*IsLocal=*/false, Binding, StOther, Type,
                              /*CanOmitFromDynSym=*/false, this)
         ->body();
   case SHN_COMMON:
     if (Value == 0 || Value >= UINT32_MAX)
       fatal(toString(this) + ": common symbol '" + Name +
             "' has invalid alignment: " + Twine(Value));
-    return elf::Symtab<ELFT>::X
+    return elf::Symtab
         ->addCommon(Name, Size, Value, Binding, StOther, Type, this)
         ->body();
   }
 
   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 elf::Symtab<ELFT>::X
-          ->addUndefined(Name, /*IsLocal=*/false, Binding, StOther, Type,
+      return elf::Symtab
+          ->addUndefined<ELFT>(Name, /*IsLocal=*/false, Binding, StOther, Type,
                                /*CanOmitFromDynSym=*/false, this)
           ->body();
-    return elf::Symtab<ELFT>::X
-        ->addRegular(Name, StOther, Type, Value, Size, Binding, Sec, this)
+    return elf::Symtab
+        ->addRegular<ELFT>(Name, StOther, Type, Value, Size, Binding, Sec, this)
         ->body();
   }
 }
 
 ArchiveFile::ArchiveFile(std::unique_ptr<Archive> &&File)
     : InputFile(ArchiveKind, File->getMemoryBufferRef()),
       File(std::move(File)) {}
 
 template <class ELFT> void ArchiveFile::parse() {
   Symbols.reserve(File->getNumberOfSymbols());
   for (const Archive::Symbol &Sym : File->symbols())
-    Symbols.push_back(Symtab<ELFT>::X->addLazyArchive(this, Sym));
+    Symbols.push_back(Symtab->addLazyArchive<ELFT>(this, Sym));
 }
 
 // Returns a buffer pointing to a member file containing a given symbol.
 std::pair<MemoryBufferRef, uint64_t>
 ArchiveFile::getMember(const Archive::Symbol *Sym) {
   Archive::Child C =
       check(Sym->getMember(), toString(this) +
                                   ": could not get the member for symbol " +
for (const Elf_Sym &Sym : Syms) {
     // Ignore local symbols.
     if (Versym && VersymIndex == VER_NDX_LOCAL)
       continue;
 
     const Elf_Verdef *V =
         VersymIndex == VER_NDX_GLOBAL ? nullptr : Verdefs[VersymIndex];
 
     if (!Hidden)
-      elf::Symtab<ELFT>::X->addShared(this, Name, Sym, V);
+      elf::Symtab->addShared(this, Name, Sym, V);
 
     // Also add the symbol with the versioned name to handle undefined symbols
     // with explicit versions.
     if (V) {
       StringRef VerName = this->StringTable.data() + V->getAux()->vda_name;
       Name = Saver.save(Name + "@" + VerName);
-      elf::Symtab<ELFT>::X->addShared(this, Name, Sym, V);
+      elf::Symtab->addShared(this, Name, Sym, V);
     }
   }
 }
 
 static ELFKind getBitcodeELFKind(const Triple &T) {
   if (T.isLittleEndian())
     return T.isArch64Bit() ? ELF64LEKind : ELF32LEKind;
   return T.isArch64Bit() ? ELF64BEKind : ELF32BEKind;
static uint8_t getBitcodeMachineKind(StringRef Path, const Triple &T) {
   case Triple::x86_64:
     return EM_X86_64;
   default:
     fatal(Path + ": could not infer e_machine from bitcode target triple " +
           T.str());
   }
 }
 
+std::vector<BitcodeFile *> BitcodeFile::Instances;
+
 BitcodeFile::BitcodeFile(MemoryBufferRef MB, StringRef ArchiveName,
                          uint64_t OffsetInArchive)
     : InputFile(BitcodeKind, MB) {
   this->ArchiveName = ArchiveName;
 
   // Here we pass a new MemoryBufferRef which is identified by ArchiveName
   // (the fully resolved path of the archive) + member name + offset of the
   // member in the archive.
static Symbol *createBitcodeSymbol(const std::vector<bool> &KeptComdats,
   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<ELFT>::X->addUndefined(NameRef, /*IsLocal=*/false, Binding,
-                                         Visibility, Type, CanOmitFromDynSym,
-                                         F);
+    return Symtab->addUndefined<ELFT>(NameRef, /*IsLocal=*/false, Binding,
+                                      Visibility, Type, CanOmitFromDynSym, F);
 
   if (ObjSym.isUndefined())
-    return Symtab<ELFT>::X->addUndefined(NameRef, /*IsLocal=*/false, Binding,
-                                         Visibility, Type, CanOmitFromDynSym,
-                                         F);
+    return Symtab->addUndefined<ELFT>(NameRef, /*IsLocal=*/false, Binding,
+                                      Visibility, Type, CanOmitFromDynSym, F);
 
   if (ObjSym.isCommon())
-    return Symtab<ELFT>::X->addCommon(NameRef, ObjSym.getCommonSize(),
-                                      ObjSym.getCommonAlignment(), Binding,
-                                      Visibility, STT_OBJECT, F);
+    return Symtab->addCommon(NameRef, ObjSym.getCommonSize(),
+                             ObjSym.getCommonAlignment(), Binding, Visibility,
+                             STT_OBJECT, F);
 
-  return Symtab<ELFT>::X->addBitcode(NameRef, Binding, Visibility, Type,
-                                     CanOmitFromDynSym, F);
+  return Symtab->addBitcode(NameRef, Binding, Visibility, Type,
 }
 
 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);
 
if ((Size == ELFCLASS32 && BufSize < sizeof(Elf32_Ehdr)) ||
       (Size == ELFCLASS64 && BufSize < sizeof(Elf64_Ehdr)))
     fatal(MB.getBufferIdentifier() + ": file is too short");
 
   if (Size == ELFCLASS32)
     return (Endian == ELFDATA2LSB) ? ELF32LEKind : ELF32BEKind;
   return (Endian == ELFDATA2LSB) ? ELF64LEKind : ELF64BEKind;
 }
 
+std::vector<BinaryFile *> BinaryFile::Instances;
+
 template <class ELFT> void BinaryFile::parse() {
   ArrayRef<uint8_t> Data = toArrayRef(MB.getBuffer());
   auto *Section =
       make<InputSection>(SHF_ALLOC | SHF_WRITE, SHT_PROGBITS, 8, Data, ".data");
   Sections.push_back(Section);
 
   // For each input file foo that is embedded to a result as a binary
   // 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] = '_';
 
-  elf::Symtab<ELFT>::X->addRegular(Saver.save(S + "_start"), STV_DEFAULT,
-                                   STT_OBJECT, 0, 0, STB_GLOBAL, Section,
-                                   nullptr);
-  elf::Symtab<ELFT>::X->addRegular(Saver.save(S + "_end"), STV_DEFAULT,
-                                   STT_OBJECT, Data.size(), 0, STB_GLOBAL,
-                                   Section, nullptr);
-  elf::Symtab<ELFT>::X->addRegular(Saver.save(S + "_size"), STV_DEFAULT,
-                                   STT_OBJECT, Data.size(), 0, STB_GLOBAL,
-                                   nullptr, nullptr);
+  elf::Symtab->addRegular<ELFT>(Saver.save(S + "_start"), STV_DEFAULT,
+                                STT_OBJECT, 0, 0, STB_GLOBAL, Section, nullptr);
+  elf::Symtab->addRegular<ELFT>(Saver.save(S + "_end"), STV_DEFAULT, STT_OBJECT,
+                                Data.size(), 0, STB_GLOBAL, Section, nullptr);
+  elf::Symtab->addRegular<ELFT>(Saver.save(S + "_size"), STV_DEFAULT,
+                                STT_OBJECT, Data.size(), 0, STB_GLOBAL, nullptr,
 }
 
 static bool isBitcode(MemoryBufferRef MB) {
   using namespace sys::fs;
   return identify_magic(MB.getBuffer()) == file_magic::bitcode;
 }
 
 InputFile *elf::createObjectFile(MemoryBufferRef MB, StringRef ArchiveName,
InputFile *LazyObjectFile::fetch() {
   MemoryBufferRef MBRef = getBuffer();
   if (MBRef.getBuffer().empty())
     return nullptr;
   return createObjectFile(MBRef, ArchiveName, OffsetInArchive);
 }
 
 template <class ELFT> void LazyObjectFile::parse() {
   for (StringRef Sym : getSymbols())
-    Symtab<ELFT>::X->addLazyObject(Sym, *this);
+    Symtab->addLazyObject<ELFT>(Sym, *this);
 }
 
 template <class ELFT> std::vector<StringRef> LazyObjectFile::getElfSymbols() {
   typedef typename ELFT::Shdr Elf_Shdr;
   typedef typename ELFT::Sym Elf_Sym;
   typedef typename ELFT::SymRange Elf_Sym_Range;
 
   const ELFFile<ELFT> Obj(this->MB.getBuffer());

ELF/LinkerScript.cpp

uint64_t ExprValue::getSecAddr() const {
   if (Sec)
     return Sec->getOffset(0) + Sec->getOutputSection()->Addr;
   return 0;
 }
 
 template <class ELFT> static SymbolBody *addRegular(SymbolAssignment *Cmd) {
   Symbol *Sym;
   uint8_t Visibility = Cmd->Hidden ? STV_HIDDEN : STV_DEFAULT;
-  std::tie(Sym, std::ignore) = Symtab<ELFT>::X->insert(
-      Cmd->Name, /*Type*/ 0, Visibility, /*CanOmitFromDynSym*/ false,
+  std::tie(Sym, std::ignore) = Symtab->insert(Cmd->Name, /*Type*/ 0, Visibility,
+                                              /*CanOmitFromDynSym*/ false,
                                               /*File*/ nullptr);
   Sym->Binding = STB_GLOBAL;
   ExprValue Value = Cmd->Expression();
   SectionBase *Sec = Value.isAbsolute() ? nullptr : Value.Sec;
 
   // 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.isAbsolute() ? Value.getValue() : 0;
void LinkerScript::assignSymbol(SymbolAssignment *Cmd, bool InSec) {
   if (V.isAbsolute()) {
     Sym->Value = V.getValue();
   } else {
     Sym->Section = V.Sec;
     Sym->Value = alignTo(V.Val, V.Alignment);
   }
 }
 
-static SymbolBody *findSymbol(StringRef S) {
-  switch (Config->EKind) {
-  case ELF32LEKind:
-    return Symtab<ELF32LE>::X->find(S);
-  case ELF32BEKind:
-    return Symtab<ELF32BE>::X->find(S);
-  case ELF64LEKind:
-    return Symtab<ELF64LE>::X->find(S);
-  case ELF64BEKind:
-    return Symtab<ELF64BE>::X->find(S);
-  default:
-    llvm_unreachable("unknown Config->EKind");
-  }
-}
-
 static SymbolBody *addRegularSymbol(SymbolAssignment *Cmd) {
   switch (Config->EKind) {
   case ELF32LEKind:
     return addRegular<ELF32LE>(Cmd);
   case ELF32BEKind:
     return addRegular<ELF32BE>(Cmd);
   case ELF64LEKind:
     return addRegular<ELF64LE>(Cmd);
   case ELF64BEKind:
     return addRegular<ELF64BE>(Cmd);
   default:
     llvm_unreachable("unknown Config->EKind");
   }
 }
 
 void LinkerScript::addSymbol(SymbolAssignment *Cmd) {
   if (Cmd->Name == ".")
     return;
 
   // If a symbol was in PROVIDE(), we need to define it only when
   // it is a referenced undefined symbol.
-  SymbolBody *B = findSymbol(Cmd->Name);
+  SymbolBody *B = Symtab->find(Cmd->Name);
   if (Cmd->Provide && (!B || B->isDefined()))
     return;
 
   Cmd->Sym = addRegularSymbol(Cmd);
 }
 
 bool SymbolAssignment::classof(const BaseCommand *C) {
   return C->Kind == AssignmentKind;
template <class ELFT> void OutputSectionCommand::writeTo(uint8_t *Buf) {
   for (BaseCommand *Base : Commands)
     if (auto *Data = dyn_cast<BytesDataCommand>(Base))
       writeInt(Buf + Data->Offset, Data->Expression().getValue(), Data->Size);
 }
 
 ExprValue LinkerScript::getSymbolValue(const Twine &Loc, StringRef S) {
   if (S == ".")
     return {CurAddressState->OutSec, Dot - CurAddressState->OutSec->Addr, Loc};
-  if (SymbolBody *B = findSymbol(S)) {
+  if (SymbolBody *B = Symtab->find(S)) {
     if (auto *D = dyn_cast<DefinedRegular>(B))
       return {D->Section, D->Value, Loc};
     if (auto *C = dyn_cast<DefinedCommon>(B))
       return {InX::Common, C->Offset, Loc};
   }
   error(Loc + ": symbol not found: " + S);
   return 0;
 }
 
-bool LinkerScript::isDefined(StringRef S) { return findSymbol(S) != nullptr; }
+bool LinkerScript::isDefined(StringRef S) { return Symtab->find(S) != nullptr; }
 
 static const size_t NoPhdr = -1;
 
 // Returns indices of ELF headers containing specific section. Each index is a
 // zero based number of ELF header listed within PHDRS {} script block.
 std::vector<size_t> LinkerScript::getPhdrIndices(OutputSectionCommand *Cmd) {
   std::vector<size_t> Ret;
   for (StringRef PhdrName : Cmd->Phdrs) {

ELF/MapFile.cpp

static void writeHeader(raw_ostream &OS, uint64_t Addr, uint64_t Size,
   OS << format("%0*llx %0*llx %5lld ", W, Addr, W, Size, Align);
 }
 
 static std::string indent(int Depth) { return std::string(Depth * 8, ' '); }
 
 // Returns a list of all symbols that we want to print out.
 template <class ELFT> std::vector<DefinedRegular *> getSymbols() {
   std::vector<DefinedRegular *> V;
-  for (elf::ObjectFile<ELFT> *File : Symtab<ELFT>::X->getObjectFiles())
+  for (elf::ObjectFile<ELFT> *File : ObjectFile<ELFT>::Instances)
     for (SymbolBody *B : File->getSymbols())
       if (B->File == File && !B->isSection())
         if (auto *Sym = dyn_cast<DefinedRegular>(B))
           if (Sym->Section && Sym->Section->Live)
             V.push_back(Sym);
   return V;
 }
 

ELF/MarkLive.cpp

template <class ELFT> void elf::markLive() {
 
   auto MarkSymbol = [&](const SymbolBody *Sym) {
     if (auto *D = dyn_cast_or_null<DefinedRegular>(Sym))
       if (auto *IS = cast_or_null<InputSectionBase>(D->Section))
         Enqueue({IS, D->Value});
   };
 
   // Add GC root symbols.
-  MarkSymbol(Symtab<ELFT>::X->find(Config->Entry));
-  MarkSymbol(Symtab<ELFT>::X->find(Config->Init));
-  MarkSymbol(Symtab<ELFT>::X->find(Config->Fini));
+  MarkSymbol(Symtab->find(Config->Entry));
+  MarkSymbol(Symtab->find(Config->Init));
+  MarkSymbol(Symtab->find(Config->Fini));
   for (StringRef S : Config->Undefined)
-    MarkSymbol(Symtab<ELFT>::X->find(S));
+    MarkSymbol(Symtab->find(S));
   for (StringRef S : Script->Opt.ReferencedSymbols)
-    MarkSymbol(Symtab<ELFT>::X->find(S));
+    MarkSymbol(Symtab->find(S));
 
   // Preserve externally-visible symbols if the symbols defined by this
   // file can interrupt other ELF file's symbols at runtime.
-  for (const Symbol *S : Symtab<ELFT>::X->getSymbols())
+  for (const Symbol *S : Symtab->getSymbols())
     if (S->includeInDynsym())
       MarkSymbol(S->body());
 
   // Preserve special sections and those which are specified in linker
   // script KEEP command.
   for (InputSectionBase *Sec : InputSections) {
     // .eh_frame is always marked as live now, but also it can reference to
     // sections that contain personality. We preserve all non-text sections

ELF/Relocations.cpp

static std::vector<SharedSymbol *> getSymbolsAt(SharedSymbol *SS) {
   uint64_t Shndx = SS->getShndx<ELFT>();
   uint64_t Value = SS->getValue<ELFT>();
 
   std::vector<SharedSymbol *> Ret;
   for (const Elf_Sym &S : File->getGlobalSymbols()) {
     if (S.st_shndx != Shndx || S.st_value != Value)
       continue;
     StringRef Name = check(S.getName(File->getStringTable()));
-    SymbolBody *Sym = Symtab<ELFT>::X->find(Name);
+    SymbolBody *Sym = Symtab->find(Name);
     if (auto *Alias = dyn_cast_or_null<SharedSymbol>(Sym))
       Ret.push_back(Alias);
   }
   return Ret;
 }
 
 // Reserve space in .bss or .bss.rel.ro for copy relocation.
 //

ELF/SymbolTable.h

 // 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.
-template <class ELFT> class SymbolTable {
-  typedef typename ELFT::Sym Elf_Sym;
-
+class SymbolTable {
 public:
-  void addFile(InputFile *File);
-  void addCombinedLTOObject();
-  void addSymbolAlias(StringRef Alias, StringRef Name);
-  void addSymbolWrap(StringRef Name);
+  template <class ELFT> void addFile(InputFile *File);
+  template <class ELFT> void addCombinedLTOObject();
+  template <class ELFT> void addSymbolAlias(StringRef Alias, StringRef Name);
+  template <class ELFT> void addSymbolWrap(StringRef Name);
   void applySymbolRenames();
 
   ArrayRef<Symbol *> getSymbols() const { return SymVector; }
-  ArrayRef<ObjectFile<ELFT> *> getObjectFiles() const { return ObjectFiles; }
-  ArrayRef<BinaryFile *> getBinaryFiles() const { return BinaryFiles; }
-  ArrayRef<SharedFile<ELFT> *> getSharedFiles() const { return SharedFiles; }
 
+  template <class ELFT>
   DefinedRegular *addAbsolute(StringRef Name,
                               uint8_t Visibility = llvm::ELF::STV_HIDDEN,
                               uint8_t Binding = llvm::ELF::STB_GLOBAL);
+  template <class ELFT>
   DefinedRegular *addIgnored(StringRef Name,
                              uint8_t Visibility = llvm::ELF::STV_HIDDEN);
 
-  Symbol *addUndefined(StringRef Name);
+  template <class ELFT> Symbol *addUndefined(StringRef Name);
+  template <class ELFT>
   Symbol *addUndefined(StringRef Name, bool IsLocal, uint8_t Binding,
                        uint8_t StOther, uint8_t Type, bool CanOmitFromDynSym,
                        InputFile *File);
-
+  template <class ELFT>
   Symbol *addRegular(StringRef Name, uint8_t StOther, uint8_t Type,
                      uint64_t Value, uint64_t Size, uint8_t Binding,
                      SectionBase *Section, InputFile *File);
 
-  void addShared(SharedFile<ELFT> *F, StringRef Name, const Elf_Sym &Sym,
+  template <class ELFT>
+  void addShared(SharedFile<ELFT> *F, StringRef Name,
+                 const typename ELFT::Sym &Sym,
                  const typename ELFT::Verdef *Verdef);
 
+  template <class ELFT>
   Symbol *addLazyArchive(ArchiveFile *F, const llvm::object::Archive::Symbol S);
-  void addLazyObject(StringRef Name, LazyObjectFile &Obj);
+  template <class ELFT> void addLazyObject(StringRef Name, LazyObjectFile &Obj);
+
   Symbol *addBitcode(StringRef Name, uint8_t Binding, uint8_t StOther,
                      uint8_t Type, bool CanOmitFromDynSym, BitcodeFile *File);
 
   Symbol *addCommon(StringRef N, uint64_t Size, uint32_t Alignment,
                     uint8_t Binding, uint8_t StOther, uint8_t Type,
                     InputFile *File);
 
   std::pair<Symbol *, bool> insert(StringRef Name);
   std::pair<Symbol *, bool> insert(StringRef Name, uint8_t Type,
                                    uint8_t Visibility, bool CanOmitFromDynSym,
                                    InputFile *File);
 
-  void scanUndefinedFlags();
-  void scanShlibUndefined();
+  template <class ELFT> void scanUndefinedFlags();
+  template <class ELFT> void scanShlibUndefined();
   void scanVersionScript();
 
   SymbolBody *find(StringRef Name);
   SymbolBody *findInCurrentDSO(StringRef Name);
 
   void trace(StringRef Name);
 
 private:
private:
   llvm::DenseMap<llvm::CachedHashStringRef, SymIndex> 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;
 
-  std::vector<ObjectFile<ELFT> *> ObjectFiles;
-  std::vector<SharedFile<ELFT> *> SharedFiles;
-  std::vector<BitcodeFile *> BitcodeFiles;
-  std::vector<BinaryFile *> BinaryFiles;
-
   // Set of .so files to not link the same shared object file more than once.
   llvm::DenseSet<StringRef> SoNames;
 
   // A map from demangled symbol names to their symbol objects.
   // This mapping is 1:N because two symbols with different versions
   // can have the same name. We use this map to handle "extern C++ {}"
   // directive in version scripts.
   llvm::Optional<llvm::StringMap<std::vector<SymbolBody *>>> DemangledSyms;
 
   // For LTO.
   std::unique_ptr<BitcodeCompiler> LTO;
 };
 
-template <class ELFT> struct Symtab { static SymbolTable<ELFT> *X; };
-template <class ELFT> SymbolTable<ELFT> *Symtab<ELFT>::X;
-
+extern SymbolTable *Symtab;
 } // namespace elf
 } // namespace lld
 
 #endif

ELF/SymbolTable.cpp

 
 using namespace llvm;
 using namespace llvm::object;
 using namespace llvm::ELF;
 
 using namespace lld;
 using namespace lld::elf;
 
+SymbolTable *elf::Symtab;
+
 // All input object files must be for the same architecture
 // (e.g. it does not make sense to link x86 object files with
 // MIPS object files.) This function checks for that error.
 template <class ELFT> static bool isCompatible(InputFile *F) {
   if (!isa<ELFFileBase<ELFT>>(F) && !isa<BitcodeFile>(F))
     return true;
 
   if (F->EKind == Config->EKind && F->EMachine == Config->EMachine) {
     if (Config->EMachine != EM_MIPS)
       return true;
     if (isMipsN32Abi(F) == Config->MipsN32Abi)
       return true;
   }
 
   if (!Config->Emulation.empty())
     error(toString(F) + " is incompatible with " + Config->Emulation);
   else
     error(toString(F) + " is incompatible with " + toString(Config->FirstElf));
   return false;
 }
 
 // Add symbols in File to the symbol table.
-template <class ELFT> void SymbolTable<ELFT>::addFile(InputFile *File) {
+template <class ELFT> void SymbolTable::addFile(InputFile *File) {
   if (!Config->FirstElf && isa<ELFFileBase<ELFT>>(File))
     Config->FirstElf = File;
 
   if (!isCompatible<ELFT>(File))
     return;
 
   // Binary file
   if (auto *F = dyn_cast<BinaryFile>(File)) {
-    BinaryFiles.push_back(F);
+    BinaryFile::Instances.push_back(F);
     F->parse<ELFT>();
     return;
   }
 
   // .a file
   if (auto *F = dyn_cast<ArchiveFile>(File)) {
     F->parse<ELFT>();
     return;
if (Config->Trace)
     message(toString(File));
 
   // .so file
   if (auto *F = dyn_cast<SharedFile<ELFT>>(File)) {
     // DSOs are uniquified not by filename but by soname.
     F->parseSoName();
     if (ErrorCount || !SoNames.insert(F->SoName).second)
       return;
-    SharedFiles.push_back(F);
+    SharedFile<ELFT>::Instances.push_back(F);
     F->parseRest();
     return;
   }
 
   // LLVM bitcode file
   if (auto *F = dyn_cast<BitcodeFile>(File)) {
-    BitcodeFiles.push_back(F);
+    BitcodeFile::Instances.push_back(F);
     F->parse<ELFT>(ComdatGroups);
     return;
   }
 
   // Regular object file
   auto *F = cast<ObjectFile<ELFT>>(File);
-  ObjectFiles.push_back(F);
+  ObjectFile<ELFT>::Instances.push_back(F);
   F->parse(ComdatGroups);
 }
 
 // This function is where all the optimizations of link-time
 // optimization happens. When LTO is in use, some input files are
 // not in native object file format but in the LLVM bitcode format.
 // This function compiles bitcode files into a few big native files
 // using LLVM functions and replaces bitcode symbols with the results.
 // Because all bitcode files that consist of a program are passed
 // to the compiler at once, it can do whole-program optimization.
-template <class ELFT> void SymbolTable<ELFT>::addCombinedLTOObject() {
-  if (BitcodeFiles.empty())
+template <class ELFT> void SymbolTable::addCombinedLTOObject() {
+  if (BitcodeFile::Instances.empty())
     return;
 
   // Compile bitcode files and replace bitcode symbols.
   LTO.reset(new BitcodeCompiler);
-  for (BitcodeFile *F : BitcodeFiles)
+  for (BitcodeFile *F : BitcodeFile::Instances)
     LTO->add(*F);
 
   for (InputFile *File : LTO->compile()) {
     ObjectFile<ELFT> *Obj = cast<ObjectFile<ELFT>>(File);
     DenseSet<CachedHashStringRef> DummyGroups;
     Obj->parse(DummyGroups);
-    ObjectFiles.push_back(Obj);
+    ObjectFile<ELFT>::Instances.push_back(Obj);
   }
 }
 
 template <class ELFT>
-DefinedRegular *SymbolTable<ELFT>::addAbsolute(StringRef Name,
-                                               uint8_t Visibility,
-                                               uint8_t Binding) {
-  Symbol *Sym =
-      addRegular(Name, Visibility, STT_NOTYPE, 0, 0, Binding, nullptr, nullptr);
+DefinedRegular *SymbolTable::addAbsolute(StringRef Name, uint8_t Visibility,
+  Symbol *Sym = addRegular<ELFT>(Name, Visibility, STT_NOTYPE, 0, 0, Binding,
+                                 nullptr, nullptr);
   return cast<DefinedRegular>(Sym->body());
 }
 
 // Add Name as an "ignored" symbol. An ignored symbol is a regular
 // linker-synthesized defined symbol, but is only defined if needed.
 template <class ELFT>
-DefinedRegular *SymbolTable<ELFT>::addIgnored(StringRef Name,
-                                              uint8_t Visibility) {
+DefinedRegular *SymbolTable::addIgnored(StringRef Name, uint8_t Visibility) {
   SymbolBody *S = find(Name);
   if (!S || S->isInCurrentDSO())
     return nullptr;
-  return addAbsolute(Name, Visibility);
+  return addAbsolute<ELFT>(Name, Visibility);
 }
 
 // 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.
-template <class ELFT> void SymbolTable<ELFT>::trace(StringRef Name) {
+void SymbolTable::trace(StringRef Name) {
   Symtab.insert({CachedHashStringRef(Name), {-1, true}});
 }
 
 // Rename SYM as __wrap_SYM. The original symbol is preserved as __real_SYM.
 // Used to implement --wrap.
-template <class ELFT> void SymbolTable<ELFT>::addSymbolWrap(StringRef Name) {
+template <class ELFT> void SymbolTable::addSymbolWrap(StringRef Name) {
   SymbolBody *B = find(Name);
   if (!B)
     return;
   Symbol *Sym = B->symbol();
-  Symbol *Real = addUndefined(Saver.save("__real_" + Name));
-  Symbol *Wrap = addUndefined(Saver.save("__wrap_" + Name));
+  Symbol *Real = addUndefined<ELFT>(Saver.save("__real_" + Name));
+  Symbol *Wrap = addUndefined<ELFT>(Saver.save("__wrap_" + Name));
 
   // Tell LTO not to eliminate this symbol
   Wrap->IsUsedInRegularObj = true;
 
   Config->RenamedSymbols[Real] = {Sym, Real->Binding};
   Config->RenamedSymbols[Sym] = {Wrap, Sym->Binding};
 }
 
 // Creates alias for symbol. Used to implement --defsym=ALIAS=SYM.
 template <class ELFT>
-void SymbolTable<ELFT>::addSymbolAlias(StringRef Alias, StringRef Name) {
+void SymbolTable::addSymbolAlias(StringRef Alias, StringRef Name) {
   SymbolBody *B = find(Name);
   if (!B) {
     error("-defsym: undefined symbol: " + Name);
     return;
   }
   Symbol *Sym = B->symbol();
-  Symbol *AliasSym = addUndefined(Alias);
+  Symbol *AliasSym = addUndefined<ELFT>(Alias);
 
   // Tell LTO not to eliminate this symbol
   Sym->IsUsedInRegularObj = true;
   Config->RenamedSymbols[AliasSym] = {Sym, AliasSym->Binding};
 }
 
 // Apply symbol renames created by -wrap and -defsym. The renames are created
 // before LTO in addSymbolWrap() and addSymbolAlias() to have a chance to inform
 // LTO (if LTO is running) not to include these symbols in IPO. Now that the
 // symbols are finalized, we can perform the replacement.
-template <class ELFT> void SymbolTable<ELFT>::applySymbolRenames() {
+void SymbolTable::applySymbolRenames() {
   for (auto &KV : Config->RenamedSymbols) {
     Symbol *Dst = KV.first;
     Symbol *Src = KV.second.Target;
     Dst->body()->copy(Src->body());
     Dst->Binding = KV.second.OriginalBinding;
   }
 }
 
 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.
-template <class ELFT>
-std::pair<Symbol *, bool> SymbolTable<ELFT>::insert(StringRef Name) {
+std::pair<Symbol *, bool> SymbolTable::insert(StringRef Name) {
   // <name>@@<version> means the symbol is the default version. In that
   // case <name>@@<version> will be used to resolve references to <name>.
   size_t Pos = Name.find("@@");
   if (Pos != StringRef::npos)
     Name = Name.take_front(Pos);
 
   auto P = Symtab.insert(
       {CachedHashStringRef(Name), SymIndex((int)SymVector.size(), false)});
std::pair<Symbol *, bool> SymbolTable::insert(StringRef Name) {
   } else {
     Sym = SymVector[V.Idx];
   }
   return {Sym, IsNew};
 }
 
 // Find an existing symbol or create and insert a new one, then apply the given
 // attributes.
-template <class ELFT>
-std::pair<Symbol *, bool>
-SymbolTable<ELFT>::insert(StringRef Name, uint8_t Type, uint8_t Visibility,
-                          bool CanOmitFromDynSym, InputFile *File) {
+std::pair<Symbol *, bool> SymbolTable::insert(StringRef Name, uint8_t Type,
+                                              uint8_t Visibility,
+                                              bool CanOmitFromDynSym,
+                                              InputFile *File) {
   bool IsUsedInRegularObj = !File || File->kind() == InputFile::ObjectKind;
   Symbol *S;
   bool WasInserted;
   std::tie(S, WasInserted) = insert(Name);
 
   // Merge in the new symbol's visibility.
   S->Visibility = getMinVisibility(S->Visibility, Visibility);
 
   if (!CanOmitFromDynSym && (Config->Shared || Config->ExportDynamic))
     S->ExportDynamic = true;
 
   if (IsUsedInRegularObj)
     S->IsUsedInRegularObj = true;
 
   if (!WasInserted && S->body()->Type != SymbolBody::UnknownType &&
       ((Type == STT_TLS) != S->body()->isTls())) {
     error("TLS attribute mismatch: " + toString(*S->body()) +
           "\n>>> defined in " + toString(S->body()->File) +
           "\n>>> defined in " + toString(File));
   }
 
   return {S, WasInserted};
 }
 
-template <class ELFT> Symbol *SymbolTable<ELFT>::addUndefined(StringRef Name) {
-  return addUndefined(Name, /*IsLocal=*/false, STB_GLOBAL, STV_DEFAULT,
+template <class ELFT> Symbol *SymbolTable::addUndefined(StringRef Name) {
+  return addUndefined<ELFT>(Name, /*IsLocal=*/false, STB_GLOBAL, STV_DEFAULT,
                             /*Type*/ 0,
                             /*CanOmitFromDynSym*/ false, /*File*/ nullptr);
 }
 
 static uint8_t getVisibility(uint8_t StOther) { return StOther & 3; }
 
 template <class ELFT>
-Symbol *SymbolTable<ELFT>::addUndefined(StringRef Name, bool IsLocal,
-                                        uint8_t Binding, uint8_t StOther,
-                                        uint8_t Type, bool CanOmitFromDynSym,
-                                        InputFile *File) {
+Symbol *SymbolTable::addUndefined(StringRef Name, bool IsLocal, 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, Type, Visibility, CanOmitFromDynSym, File);
   // An undefined symbol with non default visibility must be satisfied
   // in the same DSO.
   if (WasInserted ||
if (auto *SS = dyn_cast<SharedSymbol>(B))
       cast<SharedFile<ELFT>>(SS->File)->IsUsed = true;
   }
   if (auto *L = dyn_cast<Lazy>(S->body())) {
     // An undefined weak will not fetch archive members, but we have to remember
     // its type. See also comment in addLazyArchive.
     if (S->isWeak())
       L->Type = Type;
     else if (InputFile *F = L->fetch())
-      addFile(F);
+      addFile<ELFT>(F);
   }
   return S;
 }
 
 // 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
static int compareDefinedNonCommon(Symbol *S, bool WasInserted, uint8_t Binding,
   } else if (auto *R = dyn_cast<DefinedRegular>(B)) {
     if (R->Section == nullptr && Binding == STB_GLOBAL && IsAbsolute &&
         R->Value == Value)
       return -1;
   }
   return 0;
 }
 
-template <class ELFT>
-Symbol *SymbolTable<ELFT>::addCommon(StringRef N, uint64_t Size,
-                                     uint32_t Alignment, uint8_t Binding,
-                                     uint8_t StOther, uint8_t Type,
-                                     InputFile *File) {
+Symbol *SymbolTable::addCommon(StringRef N, uint64_t Size, uint32_t Alignment,
+                               uint8_t Binding, uint8_t StOther, uint8_t Type,
   Symbol *S;
   bool WasInserted;
   std::tie(S, WasInserted) = insert(N, Type, getVisibility(StOther),
                                     /*CanOmitFromDynSym*/ false, File);
   int Cmp = compareDefined(S, WasInserted, Binding, N);
   if (Cmp > 0) {
     S->Binding = Binding;
     replaceBody<DefinedCommon>(S, N, Size, Alignment, StOther, Type, File);
static void reportDuplicate(SymbolBody *Sym, InputSectionBase *ErrSec,
   Msg += Obj1 + "\n>>> defined at ";
   if (!Src2.empty())
     Msg += Src2 + "\n>>>            ";
   Msg += Obj2;
   warnOrError(Msg);
 }
 
 template <typename ELFT>
-Symbol *SymbolTable<ELFT>::addRegular(StringRef Name, uint8_t StOther,
-                                      uint8_t Type, uint64_t Value,
-                                      uint64_t Size, uint8_t Binding,
-                                      SectionBase *Section, InputFile *File) {
+Symbol *SymbolTable::addRegular(StringRef Name, uint8_t StOther, uint8_t Type,
+                                uint64_t Value, uint64_t Size, uint8_t Binding,
   Symbol *S;
   bool WasInserted;
   std::tie(S, WasInserted) = insert(Name, Type, getVisibility(StOther),
                                     /*CanOmitFromDynSym*/ false, File);
   int Cmp = compareDefinedNonCommon(S, WasInserted, Binding, Section == nullptr,
                                     Value, Name);
   if (Cmp > 0)
     replaceBody<DefinedRegular>(S, Name, /*IsLocal=*/false, StOther, Type,
                                 Value, Size, Section, File);
   else if (Cmp == 0)
     reportDuplicate<ELFT>(S->body(),
                           dyn_cast_or_null<InputSectionBase>(Section), Value);
   return S;
 }
 
 template <typename ELFT>
-void SymbolTable<ELFT>::addShared(SharedFile<ELFT> *File, StringRef Name,
-                                  const Elf_Sym &Sym,
-                                  const typename ELFT::Verdef *Verdef) {
+void SymbolTable::addShared(SharedFile<ELFT> *File, StringRef Name,
+                            const typename ELFT::Sym &Sym,
   // 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;
   bool WasInserted;
   std::tie(S, WasInserted) = insert(Name, Sym.getType(), STV_DEFAULT,
                                     /*CanOmitFromDynSym*/ true, File);
   // Make sure we preempt DSO symbols with default visibility.
   if (Sym.getVisibility() == STV_DEFAULT)
     S->ExportDynamic = true;
 
   SymbolBody *Body = S->body();
   // An undefined symbol with non default visibility must be satisfied
   // in the same DSO.
   if (WasInserted ||
       (isa<Undefined>(Body) && Body->getVisibility() == STV_DEFAULT)) {
     replaceBody<SharedSymbol>(S, File, Name, Sym.st_other, Sym.getType(), &Sym,
                               Verdef);
     if (!S->isWeak())
       File->IsUsed = true;
   }
 }
 
-template <class ELFT>
-Symbol *SymbolTable<ELFT>::addBitcode(StringRef Name, uint8_t Binding,
-                                      uint8_t StOther, uint8_t Type,
-                                      bool CanOmitFromDynSym, BitcodeFile *F) {
+Symbol *SymbolTable::addBitcode(StringRef Name, uint8_t Binding,
   Symbol *S;
   bool WasInserted;
   std::tie(S, WasInserted) =
       insert(Name, Type, getVisibility(StOther), CanOmitFromDynSym, F);
   int Cmp = compareDefinedNonCommon(S, WasInserted, Binding,
                                     /*IsAbs*/ false, /*Value*/ 0, Name);
   if (Cmp > 0)
     replaceBody<DefinedRegular>(S, Name, /*IsLocal=*/false, StOther, Type, 0, 0,
                                 nullptr, F);
   else if (Cmp == 0)
     reportDuplicate(S->body(), F);
   return S;
 }
 
-template <class ELFT> SymbolBody *SymbolTable<ELFT>::find(StringRef Name) {
+SymbolBody *SymbolTable::find(StringRef Name) {
   auto It = Symtab.find(CachedHashStringRef(Name));
   if (It == Symtab.end())
     return nullptr;
   SymIndex V = It->second;
   if (V.Idx == -1)
     return nullptr;
   return SymVector[V.Idx]->body();
 }
 
-template <class ELFT>
-SymbolBody *SymbolTable<ELFT>::findInCurrentDSO(StringRef Name) {
+SymbolBody *SymbolTable::findInCurrentDSO(StringRef Name) {
   if (SymbolBody *S = find(Name))
     if (S->isInCurrentDSO())
       return S;
   return nullptr;
 }
 
 template <class ELFT>
-Symbol *SymbolTable<ELFT>::addLazyArchive(ArchiveFile *F,
-                                          const object::Archive::Symbol Sym) {
+Symbol *SymbolTable::addLazyArchive(ArchiveFile *F,
   Symbol *S;
   bool WasInserted;
   StringRef Name = Sym.getName();
   std::tie(S, WasInserted) = insert(Name);
   if (WasInserted) {
     replaceBody<LazyArchive>(S, *F, Sym, SymbolBody::UnknownType);
     return S;
   }
   if (!S->body()->isUndefined())
     return S;
 
   // Weak undefined symbols should not fetch members from archives. If we were
   // to keep old symbol we would not know that an archive member was available
   // if a strong undefined symbol shows up afterwards in the link. If a strong
   // undefined symbol never shows up, this lazy symbol will get to the end of
   // the link and must be treated as the weak undefined one. We already marked
   // this symbol as used when we added it to the symbol table, but we also need
   // to preserve its type. FIXME: Move the Type field to Symbol.
   if (S->isWeak()) {
     replaceBody<LazyArchive>(S, *F, Sym, S->body()->Type);
     return S;
   }
   std::pair<MemoryBufferRef, uint64_t> MBInfo = F->getMember(&Sym);
   if (!MBInfo.first.getBuffer().empty())
-    addFile(createObjectFile(MBInfo.first, F->getName(), MBInfo.second));
+    addFile<ELFT>(createObjectFile(MBInfo.first, F->getName(), MBInfo.second));
   return S;
 }
 
 template <class ELFT>
-void SymbolTable<ELFT>::addLazyObject(StringRef Name, LazyObjectFile &Obj) {
+void SymbolTable::addLazyObject(StringRef Name, LazyObjectFile &Obj) {
   Symbol *S;
   bool WasInserted;
   std::tie(S, WasInserted) = insert(Name);
   if (WasInserted) {
     replaceBody<LazyObject>(S, Name, Obj, SymbolBody::UnknownType);
     return;
   }
   if (!S->body()->isUndefined())
     return;
 
   // See comment for addLazyArchive above.
   if (S->isWeak())
     replaceBody<LazyObject>(S, Name, Obj, S->body()->Type);
   else if (InputFile *F = Obj.fetch())
-    addFile(F);
+    addFile<ELFT>(F);
 }
 
 // Process undefined (-u) flags by loading lazy symbols named by those flags.
-template <class ELFT> void SymbolTable<ELFT>::scanUndefinedFlags() {
+template <class ELFT> void SymbolTable::scanUndefinedFlags() {
   for (StringRef S : Config->Undefined)
     if (auto *L = dyn_cast_or_null<Lazy>(find(S)))
       if (InputFile *File = L->fetch())
-        addFile(File);
+        addFile<ELFT>(File);
 }
 
 // This function takes care of the case in which shared libraries depend on
 // the user program (not the other way, which is usual). Shared libraries
 // may have undefined symbols, expecting that the user program provides
 // the definitions for them. An example is BSD's __progname symbol.
 // We need to put such symbols to the main program's .dynsym so that
 // shared libraries can find them.
 // Except this, we ignore undefined symbols in DSOs.
-template <class ELFT> void SymbolTable<ELFT>::scanShlibUndefined() {
-  for (SharedFile<ELFT> *File : SharedFiles) {
+template <class ELFT> void SymbolTable::scanShlibUndefined() {
+  for (SharedFile<ELFT> *File : SharedFile<ELFT>::Instances) {
     for (StringRef U : File->getUndefinedSymbols()) {
       SymbolBody *Sym = find(U);
       if (!Sym || !Sym->isDefined())
         continue;
       Sym->symbol()->ExportDynamic = true;
 
       // If -dynamic-list is given, the default version is set to
       // VER_NDX_LOCAL, which prevents a symbol to be exported via .dynsym.

 // Then, why are we doing this? Here's why.
 //
 // Users can use "extern C++ {}" directive to match against demangled
 // C++ symbols. For example, you can write a pattern such as
 // "llvm::*::foo(int, ?)". Obviously, there's no way to handle this
 // other than trying to match a pattern against all demangled symbols.
 // So, if "extern C++" feature is used, we need to demangle all known
 // symbols.
-template <class ELFT>
-StringMap<std::vector<SymbolBody *>> &SymbolTable<ELFT>::getDemangledSyms() {
+StringMap<std::vector<SymbolBody *>> &SymbolTable::getDemangledSyms() {
   if (!DemangledSyms) {
     DemangledSyms.emplace();
     for (Symbol *Sym : SymVector) {
       SymbolBody *B = Sym->body();
       if (B->isUndefined())
         continue;
       if (Optional<std::string> S = demangle(B->getName()))
         (*DemangledSyms)[*S].push_back(B);
       else
         (*DemangledSyms)[B->getName()].push_back(B);
     }
   }
   return *DemangledSyms;
 }
 
-template <class ELFT>
-std::vector<SymbolBody *> SymbolTable<ELFT>::findByVersion(SymbolVersion Ver) {
+std::vector<SymbolBody *> SymbolTable::findByVersion(SymbolVersion Ver) {
   if (Ver.IsExternCpp)
     return getDemangledSyms().lookup(Ver.Name);
   if (SymbolBody *B = find(Ver.Name))
     if (!B->isUndefined())
       return {B};
   return {};
 }
 
-template <class ELFT>
-std::vector<SymbolBody *>
-SymbolTable<ELFT>::findAllByVersion(SymbolVersion Ver) {
+std::vector<SymbolBody *> SymbolTable::findAllByVersion(SymbolVersion Ver) {
   std::vector<SymbolBody *> Res;
   StringMatcher M(Ver.Name);
 
   if (Ver.IsExternCpp) {
     for (auto &P : getDemangledSyms())
       if (M.match(P.first()))
         Res.insert(Res.end(), P.second.begin(), P.second.end());
     return Res;
   }
 
   for (Symbol *Sym : SymVector) {
     SymbolBody *B = Sym->body();
     if (!B->isUndefined() && M.match(B->getName()))
       Res.push_back(B);
   }
   return Res;
 }
 
 // If there's only one anonymous version definition in a version
 // script file, the script does not actually define any symbol version,
 // but just specifies symbols visibilities.
-template <class ELFT> void SymbolTable<ELFT>::handleAnonymousVersion() {
+void SymbolTable::handleAnonymousVersion() {
   for (SymbolVersion &Ver : Config->VersionScriptGlobals)
     assignExactVersion(Ver, VER_NDX_GLOBAL, "global");
   for (SymbolVersion &Ver : Config->VersionScriptGlobals)
     assignWildcardVersion(Ver, VER_NDX_GLOBAL);
   for (SymbolVersion &Ver : Config->VersionScriptLocals)
     assignExactVersion(Ver, VER_NDX_LOCAL, "local");
   for (SymbolVersion &Ver : Config->VersionScriptLocals)
     assignWildcardVersion(Ver, VER_NDX_LOCAL);
 }
 
 // Set symbol versions to symbols. This function handles patterns
 // containing no wildcard characters.
-template <class ELFT>
-void SymbolTable<ELFT>::assignExactVersion(SymbolVersion Ver,
-                                           uint16_t VersionId,
-                                           StringRef VersionName) {
+void SymbolTable::assignExactVersion(SymbolVersion Ver, uint16_t VersionId,
   if (Ver.HasWildcard)
     return;
 
   // Get a list of symbols which we need to assign the version to.
   std::vector<SymbolBody *> Syms = findByVersion(Ver);
   if (Syms.empty()) {
     if (Config->NoUndefinedVersion)
       error("version script assignment of '" + VersionName + "' to symbol '" +
for (SymbolBody *B : Syms) {
     Symbol *Sym = B->symbol();
     if (Sym->InVersionScript)
       warn("duplicate symbol '" + Ver.Name + "' in version script");
     Sym->VersionId = VersionId;
     Sym->InVersionScript = true;
   }
 }
 
-template <class ELFT>
-void SymbolTable<ELFT>::assignWildcardVersion(SymbolVersion Ver,
-                                              uint16_t VersionId) {
+void SymbolTable::assignWildcardVersion(SymbolVersion Ver, uint16_t VersionId) {
   if (!Ver.HasWildcard)
     return;
 
   // Exact matching takes precendence over fuzzy matching,
   // so we set a version to a symbol only if no version has been assigned
   // to the symbol. This behavior is compatible with GNU.
   for (SymbolBody *B : findAllByVersion(Ver))
     if (B->symbol()->VersionId == Config->DefaultSymbolVersion)
       B->symbol()->VersionId = VersionId;
 }
 
 // This function processes version scripts by updating VersionId
 // member of symbols.
-template <class ELFT> void SymbolTable<ELFT>::scanVersionScript() {
+void SymbolTable::scanVersionScript() {
   // Handle edge cases first.
   handleAnonymousVersion();
 
   // Now we have version definitions, so we need to set version ids to symbols.
   // Each version definition has a glob pattern, and all symbols that match
   // with the pattern get that version.
 
   // First, we assign versions to exact matching symbols,
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->body()->parseSymbolVersion();
 }
 
-template class elf::SymbolTable<ELF32LE>;
-template class elf::SymbolTable<ELF32BE>;
-template class elf::SymbolTable<ELF64LE>;
-template class elf::SymbolTable<ELF64BE>;
+template void SymbolTable::addSymbolWrap<ELF32LE>(StringRef);
+template void SymbolTable::addSymbolWrap<ELF32BE>(StringRef);
+template void SymbolTable::addSymbolWrap<ELF64LE>(StringRef);
+template void SymbolTable::addSymbolWrap<ELF64BE>(StringRef);
+
+template Symbol *SymbolTable::addUndefined<ELF32LE>(StringRef);
+template Symbol *SymbolTable::addUndefined<ELF32BE>(StringRef);
+template Symbol *SymbolTable::addUndefined<ELF64LE>(StringRef);
+template Symbol *SymbolTable::addUndefined<ELF64BE>(StringRef);
+
+template void SymbolTable::addSymbolAlias<ELF32LE>(StringRef, StringRef);
+template void SymbolTable::addSymbolAlias<ELF32BE>(StringRef, StringRef);
+template void SymbolTable::addSymbolAlias<ELF64LE>(StringRef, StringRef);
+template void SymbolTable::addSymbolAlias<ELF64BE>(StringRef, StringRef);
+
+template void SymbolTable::addCombinedLTOObject<ELF32LE>();
+template void SymbolTable::addCombinedLTOObject<ELF32BE>();
+template void SymbolTable::addCombinedLTOObject<ELF64LE>();
+template void SymbolTable::addCombinedLTOObject<ELF64BE>();
+
+template Symbol *SymbolTable::addRegular<ELF32LE>(StringRef, uint8_t, uint8_t,
+                                                  uint64_t, uint64_t, uint8_t,
+                                                  SectionBase *, InputFile *);
+template Symbol *SymbolTable::addRegular<ELF32BE>(StringRef, uint8_t, uint8_t,
+                                                  uint64_t, uint64_t, uint8_t,
+                                                  SectionBase *, InputFile *);
+template Symbol *SymbolTable::addRegular<ELF64LE>(StringRef, uint8_t, uint8_t,
+                                                  uint64_t, uint64_t, uint8_t,
+                                                  SectionBase *, InputFile *);
+template Symbol *SymbolTable::addRegular<ELF64BE>(StringRef, uint8_t, uint8_t,
+                                                  uint64_t, uint64_t, uint8_t,
+                                                  SectionBase *, InputFile *);
+
+template DefinedRegular *SymbolTable::addAbsolute<ELF32LE>(StringRef, uint8_t,
+                                                           uint8_t);
+template DefinedRegular *SymbolTable::addAbsolute<ELF32BE>(StringRef, uint8_t,
+                                                           uint8_t);
+template DefinedRegular *SymbolTable::addAbsolute<ELF64LE>(StringRef, uint8_t,
+                                                           uint8_t);
+template DefinedRegular *SymbolTable::addAbsolute<ELF64BE>(StringRef, uint8_t,
+                                                           uint8_t);
+
+template DefinedRegular *SymbolTable::addIgnored<ELF32LE>(StringRef, uint8_t);
+template DefinedRegular *SymbolTable::addIgnored<ELF32BE>(StringRef, uint8_t);
+template DefinedRegular *SymbolTable::addIgnored<ELF64LE>(StringRef, uint8_t);
+template DefinedRegular *SymbolTable::addIgnored<ELF64BE>(StringRef, uint8_t);
+
+template Symbol *
+SymbolTable::addLazyArchive<ELF32LE>(ArchiveFile *,
+                                     const object::Archive::Symbol);
+template Symbol *
+SymbolTable::addLazyArchive<ELF32BE>(ArchiveFile *,
+                                     const object::Archive::Symbol);
+template Symbol *
+SymbolTable::addLazyArchive<ELF64LE>(ArchiveFile *,
+                                     const object::Archive::Symbol);
+template Symbol *
+SymbolTable::addLazyArchive<ELF64BE>(ArchiveFile *,
+                                     const object::Archive::Symbol);
+
+template void SymbolTable::addLazyObject<ELF32LE>(StringRef, LazyObjectFile &);
+template void SymbolTable::addLazyObject<ELF32BE>(StringRef, LazyObjectFile &);
+template void SymbolTable::addLazyObject<ELF64LE>(StringRef, LazyObjectFile &);
+template void SymbolTable::addLazyObject<ELF64BE>(StringRef, LazyObjectFile &);
+
+template void SymbolTable::addShared<ELF32LE>(SharedFile<ELF32LE> *, StringRef,
+                                              const typename ELF32LE::Sym &,
+                                              const typename ELF32LE::Verdef *);
+template void SymbolTable::addShared<ELF32BE>(SharedFile<ELF32BE> *, StringRef,
+                                              const typename ELF32BE::Sym &,
+                                              const typename ELF32BE::Verdef *);
+template void SymbolTable::addShared<ELF64LE>(SharedFile<ELF64LE> *, StringRef,
+                                              const typename ELF64LE::Sym &,
+                                              const typename ELF64LE::Verdef *);
+template void SymbolTable::addShared<ELF64BE>(SharedFile<ELF64BE> *, StringRef,
+                                              const typename ELF64BE::Sym &,
+                                              const typename ELF64BE::Verdef *);
+
+template void SymbolTable::scanUndefinedFlags<ELF32LE>();
+template void SymbolTable::scanUndefinedFlags<ELF32BE>();
+template void SymbolTable::scanUndefinedFlags<ELF64LE>();
+template void SymbolTable::scanUndefinedFlags<ELF64BE>();
+
+template void SymbolTable::scanShlibUndefined<ELF32LE>();
+template void SymbolTable::scanShlibUndefined<ELF32BE>();
+template void SymbolTable::scanShlibUndefined<ELF64LE>();
+template void SymbolTable::scanShlibUndefined<ELF64BE>();

ELF/SyntheticSections.cpp

 uint64_t SyntheticSection::getVA() const {
   if (OutputSection *Sec = getParent())
     return Sec->Addr + OutSecOff;
   return 0;
 }
 
 template <class ELFT> static std::vector<DefinedCommon *> getCommonSymbols() {
   std::vector<DefinedCommon *> V;
-  for (Symbol *S : Symtab<ELFT>::X->getSymbols())
+  for (Symbol *S : Symtab->getSymbols())
     if (auto *B = dyn_cast<DefinedCommon>(S->body()))
       V.push_back(B);
   return V;
 }
 
 // Find all common symbols and allocate space for them.
 template <class ELFT> InputSection *elf::createCommonSection() {
   if (!Config->DefineCommon)
template <class ELFT> void DynamicSection<ELFT>::addEntries() {
   // fixed early.
   for (StringRef S : Config->FilterList)
     add({DT_FILTER, InX::DynStrTab->addString(S)});
   for (StringRef S : Config->AuxiliaryList)
     add({DT_AUXILIARY, InX::DynStrTab->addString(S)});
   if (!Config->Rpath.empty())
     add({Config->EnableNewDtags ? DT_RUNPATH : DT_RPATH,
          InX::DynStrTab->addString(Config->Rpath)});
-  for (SharedFile<ELFT> *F : Symtab<ELFT>::X->getSharedFiles())
+  for (SharedFile<ELFT> *F : SharedFile<ELFT>::Instances)
     if (F->isNeeded())
       add({DT_NEEDED, InX::DynStrTab->addString(F->SoName)});
   if (!Config->SoName.empty())
     add({DT_SONAME, InX::DynStrTab->addString(Config->SoName)});
 
   // Set DT_FLAGS and DT_FLAGS_1.
   uint32_t DtFlags = 0;
   uint32_t DtFlags1 = 0;
if (Out::InitArray) {
     add({DT_INIT_ARRAY, Out::InitArray});
     add({DT_INIT_ARRAYSZ, Out::InitArray, Entry::SecSize});
   }
   if (Out::FiniArray) {
     add({DT_FINI_ARRAY, Out::FiniArray});
     add({DT_FINI_ARRAYSZ, Out::FiniArray, Entry::SecSize});
   }
 
-  if (SymbolBody *B = Symtab<ELFT>::X->findInCurrentDSO(Config->Init))
+  if (SymbolBody *B = Symtab->findInCurrentDSO(Config->Init))
     add({DT_INIT, B});
-  if (SymbolBody *B = Symtab<ELFT>::X->findInCurrentDSO(Config->Fini))
+  if (SymbolBody *B = Symtab->findInCurrentDSO(Config->Fini))
     add({DT_FINI, B});
 
   bool HasVerNeed = In<ELFT>::VerNeed->getNeedNum() != 0;
   if (HasVerNeed || In<ELFT>::VerDef)
     add({DT_VERSYM, In<ELFT>::VerSym});
   if (In<ELFT>::VerDef) {
     add({DT_VERDEF, In<ELFT>::VerDef});
     add({DT_VERDEFNUM, getVerDefNum()});

ELF/Writer.h

 #include <memory>
 
 namespace lld {
 namespace elf {
 class InputFile;
 class OutputSection;
 class InputSectionBase;
 template <class ELFT> class ObjectFile;
-template <class ELFT> class SymbolTable;
+class SymbolTable;
 template <class ELFT> void writeResult();
 template <class ELFT> void markLive();
 
 // This describes a program header entry.
 // Each contains type, access flags and range of output sections that will be
 // placed in it.
 struct PhdrEntry {
   PhdrEntry(unsigned Type, unsigned Flags) : p_type(Type), p_flags(Flags) {}

ELF/Writer.cpp

StringRef elf::getOutputSectionName(StringRef Name) {
   // By default, it should go to .bss section.
   if (Name == "COMMON")
     return ".bss";
 
   return Name;
 }
 
 template <class ELFT> static bool needsInterpSection() {
-  return !Symtab<ELFT>::X->getSharedFiles().empty() &&
+  return !SharedFile<ELFT>::Instances.empty() &&
          !Config->DynamicLinker.empty() && !Script->ignoreInterpSection();
 }
 
 template <class ELFT> void elf::writeResult() { Writer<ELFT>().run(); }
 
 template <class ELFT> void Writer<ELFT>::removeEmptyPTLoad() {
   auto I = std::remove_if(Phdrs.begin(), Phdrs.end(), [&](const PhdrEntry &P) {
     if (P.p_type != PT_LOAD)
if (InX::Common)
     Add(InX::Common);
 
   InX::Bss = make<BssSection>(".bss");
   Add(InX::Bss);
   InX::BssRelRo = make<BssSection>(".bss.rel.ro");
   Add(InX::BssRelRo);
 
   // Add MIPS-specific sections.
-  bool HasDynSymTab = !Symtab<ELFT>::X->getSharedFiles().empty() ||
-                      Config->Pic || Config->ExportDynamic;
+  bool HasDynSymTab = !SharedFile<ELFT>::Instances.empty() || Config->Pic ||
+                      Config->ExportDynamic;
   if (Config->EMachine == EM_MIPS) {
     if (!Config->Shared && HasDynSymTab) {
       InX::MipsRldMap = make<MipsRldMapSection>();
       Add(InX::MipsRldMap);
     }
     if (auto *Sec = MipsAbiFlagsSection<ELFT>::create())
       Add(Sec);
     if (auto *Sec = MipsOptionsSection<ELFT>::create())
static bool includeInSymtab(const SymbolBody &B) {
   return true;
 }
 
 // Local symbols are not in the linker's symbol table. This function scans
 // each object file's symbol table to copy local symbols to the output.
 template <class ELFT> void Writer<ELFT>::copyLocalSymbols() {
   if (!InX::SymTab)
     return;
-  for (elf::ObjectFile<ELFT> *F : Symtab<ELFT>::X->getObjectFiles()) {
+  for (elf::ObjectFile<ELFT> *F : ObjectFile<ELFT>::Instances) {
     for (SymbolBody *B : F->getLocalSymbols()) {
       if (!B->IsLocal)
         fatal(toString(F) +
               ": broken object: getLocalSymbols returns a non-local symbol");
       auto *DR = dyn_cast<DefinedRegular>(B);
 
       // No reason to keep local undefined symbol in symtab.
       if (!DR)

 }
 
 template <class ELFT>
 static Symbol *addRegular(StringRef Name, SectionBase *Sec, uint64_t Value,
                           uint8_t StOther = STV_HIDDEN,
                           uint8_t Binding = STB_WEAK) {
   // The linker generated symbols are added as STB_WEAK to allow user defined
   // ones to override them.
-  return Symtab<ELFT>::X->addRegular(Name, StOther, STT_NOTYPE, Value,
-                                     /*Size=*/0, Binding, Sec,
-                                     /*File=*/nullptr);
+  return Symtab->addRegular<ELFT>(Name, StOther, STT_NOTYPE, Value,
 }
 
 template <class ELFT>
 static DefinedRegular *
 addOptionalRegular(StringRef Name, SectionBase *Sec, uint64_t Val,
                    uint8_t StOther = STV_HIDDEN, uint8_t Binding = STB_GLOBAL) {
-  SymbolBody *S = Symtab<ELFT>::X->find(Name);
+  SymbolBody *S = Symtab->find(Name);
   if (!S)
     return nullptr;
   if (S->isInCurrentDSO())
     return nullptr;
   return cast<DefinedRegular>(
       addRegular<ELFT>(Name, Sec, Val, StOther, Binding)->body());
 }
 

 // the linking result. This function defines such symbols.
 template <class ELFT> void Writer<ELFT>::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
     // to GOT. Default offset is 0x7ff0.
     // See "Global Data Symbols" in Chapter 6 in the following document:
     // ftp://www.linux-mips.org/pub/linux/mips/doc/ABI/mipsabi.pdf
-    ElfSym::MipsGp = Symtab<ELFT>::X->addAbsolute("_gp", STV_HIDDEN, STB_LOCAL);
+    ElfSym::MipsGp = Symtab->addAbsolute<ELFT>("_gp", STV_HIDDEN, STB_LOCAL);
 
     // On MIPS O32 ABI, _gp_disp is a magic symbol designates offset between
     // start of function and 'gp' pointer into GOT.
-    if (Symtab<ELFT>::X->find("_gp_disp"))
+    if (Symtab->find("_gp_disp"))
       ElfSym::MipsGpDisp =
-          Symtab<ELFT>::X->addAbsolute("_gp_disp", STV_HIDDEN, STB_LOCAL);
+          Symtab->addAbsolute<ELFT>("_gp_disp", STV_HIDDEN, STB_LOCAL);
 
     // The __gnu_local_gp is a magic symbol equal to the current value of 'gp'
     // pointer. This symbol is used in the code generated by .cpload pseudo-op
     // in case of using -mno-shared option.
     // https://sourceware.org/ml/binutils/2004-12/msg00094.html
-    if (Symtab<ELFT>::X->find("__gnu_local_gp"))
+    if (Symtab->find("__gnu_local_gp"))
       ElfSym::MipsLocalGp =
-          Symtab<ELFT>::X->addAbsolute("__gnu_local_gp", STV_HIDDEN, STB_LOCAL);
+          Symtab->addAbsolute<ELFT>("__gnu_local_gp", STV_HIDDEN, STB_LOCAL);
   }
 
   // The _GLOBAL_OFFSET_TABLE_ symbol is defined by target convention to
   // be at some offset from the base of the .got section, usually 0 or the end
   // of the .got
   InputSection *GotSection = InX::MipsGot ? cast<InputSection>(InX::MipsGot)
                                           : cast<InputSection>(InX::Got);
   ElfSym::GlobalOffsetTable = addOptionalRegular<ELFT>(
       "_GLOBAL_OFFSET_TABLE_", GotSection, Target->GotBaseSymOff);
 
   // __tls_get_addr is defined by the dynamic linker for dynamic ELFs. For
   // static linking the linker is required to optimize away any references to
   // __tls_get_addr, so it's not defined anywhere. Create a hidden definition
   // to avoid the undefined symbol error.
   if (!InX::DynSymTab)
-    Symtab<ELFT>::X->addIgnored("__tls_get_addr");
+    Symtab->addIgnored<ELFT>("__tls_get_addr");
 
   // __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.
   // __executable_start is not documented, but the expectation of at
   // least the android libc is that it points to the elf header too.
   // __dso_handle symbol is passed to cxa_finalize as a marker to identify
template <class ELFT> static void sortBySymbolsOrder() {
   // All explicitly mentioned symbols have negative (higher) priorities.
   DenseMap<StringRef, int> SymbolOrder;
   int Priority = -Config->SymbolOrderingFile.size();
   for (StringRef S : Config->SymbolOrderingFile)
     SymbolOrder.insert({S, Priority++});
 
   // Build a map from sections to their priorities.
   DenseMap<SectionBase *, int> SectionOrder;
-  for (elf::ObjectFile<ELFT> *File : Symtab<ELFT>::X->getObjectFiles()) {
+  for (elf::ObjectFile<ELFT> *File : ObjectFile<ELFT>::Instances) {
     for (SymbolBody *Body : File->getSymbols()) {
       auto *D = dyn_cast<DefinedRegular>(Body);
       if (!D || !D->Section)
         continue;
       int &Priority = SectionOrder[D->Section];
       Priority = std::min(Priority, SymbolOrder.lookup(D->getName()));
     }
   }
template <class ELFT> void Writer<ELFT>::finalizeSections() {
 
   if (InX::Plt && !InX::Plt->empty())
     InX::Plt->addSymbols();
   if (InX::Iplt && !InX::Iplt->empty())
     InX::Iplt->addSymbols();
 
   // Now that we have defined all possible global symbols including linker-
   // synthesized ones. Visit all symbols to give the finishing touches.
-  for (Symbol *S : Symtab<ELFT>::X->getSymbols()) {
+  for (Symbol *S : Symtab->getSymbols()) {
     SymbolBody *Body = S->body();
 
     if (!includeInSymtab(*Body))
       continue;
     if (InX::SymTab)
       InX::SymTab->addSymbol(Body);
 
     if (InX::DynSymTab && S->includeInDynsym()) {

 // 1. the '-e' entry command-line option;
 // 2. the ENTRY(symbol) command in a linker control script;
 // 3. the value of the symbol start, if present;
 // 4. the address of the first byte of the .text section, if present;
 // 5. the address 0.
 template <class ELFT> uint64_t Writer<ELFT>::getEntryAddr() {
   // Case 1, 2 or 3. As a special case, if the symbol is actually
   // a number, we'll use that number as an address.
-  if (SymbolBody *B = Symtab<ELFT>::X->find(Config->Entry))
+  if (SymbolBody *B = Symtab->find(Config->Entry))
     return B->getVA();
   uint64_t Addr;
   if (to_integer(Config->Entry, Addr))
     return Addr;
 
   // Case 4
   if (OutputSection *Sec = findSectionInScript(".text")) {
     if (Config->WarnMissingEntry)