De-template parseFile() and SymbolTable's add-family functions.

[ruiu]

Summary

De-template parseFile() and SymbolTable's add-family functions.

[MaskRay]

Nice! This pushes down templates from shallower member functions to deeper function and thus deletes some templates along the path.

[grimar]

LGTM

lld/trunk/ELF/Driver.cpp

static void excludeLibs(opt::InputArgList &Args) {
   for (InputFile *File : ObjectFiles)
     Visit(File);
 
   for (BitcodeFile *File : BitcodeFiles)
     Visit(File);
 }
 
 // Force Sym to be entered in the output. Used for -u or equivalent.
-template <class ELFT> static void handleUndefined(StringRef Name) {
+static void handleUndefined(StringRef Name) {
   Symbol *Sym = Symtab->find(Name);
   if (!Sym)
     return;
 
   // Since symbol S may not be used inside the program, LTO may
   // eliminate it. Mark the symbol as "used" to prevent it.
   Sym->IsUsedInRegularObj = true;
 
   if (Sym->isLazy())
-    Symtab->fetchLazy<ELFT>(Sym);
+    Symtab->fetchLazy(Sym);
 }
 
-template <class ELFT> static void handleLibcall(StringRef Name) {
+static void handleLibcall(StringRef Name) {
   Symbol *Sym = Symtab->find(Name);
   if (!Sym || !Sym->isLazy())
     return;
 
   MemoryBufferRef MB;
   if (auto *LO = dyn_cast<LazyObject>(Sym))
     MB = LO->File->MB;
   else
     MB = cast<LazyArchive>(Sym)->getMemberBuffer();
 
   if (isBitcode(MB))
-    Symtab->fetchLazy<ELFT>(Sym);
+    Symtab->fetchLazy(Sym);
 }
 
 // Replaces common symbols with defined symbols reside in .bss sections.
 // This function is called after all symbol names are resolved. As a
 // result, the passes after the symbol resolution won't see any
 // symbols of type CommonSymbol.
 static void replaceCommonSymbols() {
   for (Symbol *Sym : Symtab->getSymbols()) {
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>(
+  return Symtab->addUndefined(
       Undefined{nullptr, Name, STB_GLOBAL, STV_DEFAULT, 0});
 }
 
 // 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
template <class ELFT> void LinkerDriver::link(opt::InputArgList &Args) {
 
   // Handle --trace-symbol.
   for (auto *Arg : Args.filtered(OPT_trace_symbol))
     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)
-    parseFile<ELFT>(F);
+    parseFile(F);
 
   // Now that we have every file, we can decide if we will need a
   // dynamic symbol table.
   // We need one if we were asked to export dynamic symbols or if we are
   // producing a shared library.
   // We also need one if any shared libraries are used and for pie executables
   // (probably because the dynamic linker needs it).
   Config->HasDynSymTab =
       !SharedFiles.empty() || Config->Pic || Config->ExportDynamic;
 
   // 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 Name : Script->ReferencedSymbols)
     addUndefined<ELFT>(Name);
 
   // Handle the `--undefined <sym>` options.
   for (StringRef S : Config->Undefined)
-    handleUndefined<ELFT>(S);
+    handleUndefined(S);
 
   // If an entry symbol is in a static archive, pull out that file now.
-  handleUndefined<ELFT>(Config->Entry);
+  handleUndefined(Config->Entry);
 
   // If any of our inputs are bitcode files, the LTO code generator may create
   // references to certain library functions that might not be explicit in the
   // bitcode file's symbol table. If any of those library functions are defined
   // in a bitcode file in an archive member, we need to arrange to use LTO to
   // compile those archive members by adding them to the link beforehand.
   //
   // However, adding all libcall symbols to the link can have undesired
   // consequences. For example, the libgcc implementation of
   // __sync_val_compare_and_swap_8 on 32-bit ARM pulls in an .init_array entry
   // that aborts the program if the Linux kernel does not support 64-bit
   // atomics, which would prevent the program from running even if it does not
   // use 64-bit atomics.
   //
   // Therefore, we only add libcall symbols to the link before LTO if we have
   // to, i.e. if the symbol's definition is in bitcode. Any other required
   // libcall symbols will be added to the link after LTO when we add the LTO
   // object file to the link.
   if (!BitcodeFiles.empty())
     for (const char *S : LibcallRoutineNames)
-      handleLibcall<ELFT>(S);
+      handleLibcall(S);
 
   // Return if there were name resolution errors.
   if (errorCount())
     return;
 
   // Now when we read all script files, we want to finalize order of linker
   // script commands, which can be not yet final because of INSERT commands.
   Script->processInsertCommands();

lld/trunk/ELF/InputFiles.h

 // If -reproduce option is given, all input files are written
 // to this tar archive.
 extern std::unique_ptr<llvm::TarWriter> Tar;
 
 // Opens a given file.
 llvm::Optional<MemoryBufferRef> readFile(StringRef Path);
 
 // Add symbols in File to the symbol table.
-template <class ELFT> void parseFile(InputFile *File);
+void parseFile(InputFile *File);
 
 // The root class of input files.
 class InputFile {
 public:
   enum Kind {
     ObjKind,
     SharedKind,
     LazyObjKind,
private:
   uint64_t OffsetInArchive;
 };
 
 // An ArchiveFile object represents a .a file.
 class ArchiveFile : public InputFile {
 public:
   explicit ArchiveFile(std::unique_ptr<Archive> &&File);
   static bool classof(const InputFile *F) { return F->kind() == ArchiveKind; }
-  template <class ELFT> void parse();
+  void parse();
 
   // Pulls out an object file that contains a definition for Sym and
   // returns it. If the same file was instantiated before, this
   // function returns a nullptr (so we don't instantiate the same file
   // more than once.)
   InputFile *fetch(const Archive::Symbol &Sym);
 
 private:

lld/trunk/ELF/InputFiles.cpp

else
       Existing = BitcodeFiles[0];
 
     error(toString(File) + " is incompatible with " + toString(Existing));
   }
 
   return false;
 }
 
-// Add symbols in File to the symbol table.
-template <class ELFT> void elf::parseFile(InputFile *File) {
+template <class ELFT> static void doParseFile(InputFile *File) {
   // 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.
   static llvm::DenseSet<llvm::CachedHashStringRef> ComdatGroups;
 
   if (!isCompatible(File))
     return;
 
   // Binary file
   if (auto *F = dyn_cast<BinaryFile>(File)) {
     BinaryFiles.push_back(F);
     F->parse();
     return;
   }
 
   // .a file
   if (auto *F = dyn_cast<ArchiveFile>(File)) {
-    F->parse<ELFT>();
+    F->parse();
     return;
   }
 
   // Lazy object file
   if (auto *F = dyn_cast<LazyObjFile>(File)) {
     LazyObjFiles.push_back(F);
     F->parse<ELFT>();
     return;
if (auto *F = dyn_cast<BitcodeFile>(File)) {
     return;
   }
 
   // Regular object file
   ObjectFiles.push_back(File);
   cast<ObjFile<ELFT>>(File)->parse(ComdatGroups);
 }
 
+// Add symbols in File to the symbol table.
+void elf::parseFile(InputFile *File) {
+  switch (Config->EKind) {
+  case ELF32LEKind:
+    doParseFile<ELF32LE>(File);
+    return;
+  case ELF32BEKind:
+    doParseFile<ELF32BE>(File);
+    return;
+  case ELF64LEKind:
+    doParseFile<ELF64LE>(File);
+    return;
+  case ELF64BEKind:
+    doParseFile<ELF64BE>(File);
+    return;
+  default:
+    llvm_unreachable("unknown ELFT");
+  }
+}
+
 // Concatenates arguments to construct a string representing an error location.
 static std::string createFileLineMsg(StringRef Path, unsigned Line) {
   std::string Filename = path::filename(Path);
   std::string Lineno = ":" + std::to_string(Line);
   if (Filename == Path)
     return Filename + Lineno;
   return Filename + Lineno + " (" + Path.str() + Lineno + ")";
 }
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>(
-        Undefined{this, Name, Binding, StOther, Type});
+    return Symtab->addUndefined(Undefined{this, Name, Binding, StOther, Type});
   case SHN_COMMON:
     if (Value == 0 || Value >= UINT32_MAX)
       fatal(toString(this) + ": common symbol '" + Name +
             "' has invalid alignment: " + Twine(Value));
     return Symtab->addCommon(
         CommonSymbol{this, Name, Binding, StOther, Type, Value, Size});
   }
 
   switch (Binding) {
   default:
     fatal(toString(this) + ": unexpected binding: " + Twine((int)Binding));
   case STB_GLOBAL:
   case STB_WEAK:
   case STB_GNU_UNIQUE:
     if (Sec == &InputSection::Discarded)
-      return Symtab->addUndefined<ELFT>(
+      return Symtab->addUndefined(
           Undefined{this, Name, Binding, StOther, Type});
     return Symtab->addDefined(
         Defined{this, Name, Binding, StOther, Type, Value, Size, Sec});
   }
 }
 
 ArchiveFile::ArchiveFile(std::unique_ptr<Archive> &&File)
     : InputFile(ArchiveKind, File->getMemoryBufferRef()),
       File(std::move(File)) {}
 
-template <class ELFT> void ArchiveFile::parse() {
+void ArchiveFile::parse() {
   for (const Archive::Symbol &Sym : File->symbols())
-    Symtab->addLazyArchive<ELFT>(LazyArchive{*this, Sym});
+    Symtab->addLazyArchive(LazyArchive{*this, Sym});
 }
 
 // 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>(
+      Symbol *S = Symtab->addUndefined(
           Undefined{this, Name, Sym.getBinding(), Sym.st_other, Sym.getType()});
       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.
static Symbol *createBitcodeSymbol(const std::vector<bool> &KeptComdats,
   uint8_t Visibility = mapVisibility(ObjSym.getVisibility());
   bool CanOmitFromDynSym = ObjSym.canBeOmittedFromSymbolTable();
 
   int C = ObjSym.getComdatIndex();
   if (ObjSym.isUndefined() || (C != -1 && !KeptComdats[C])) {
     Undefined New(&F, Name, Binding, Visibility, Type);
     if (CanOmitFromDynSym)
       New.ExportDynamic = false;
-    return Symtab->addUndefined<ELFT>(New);
+    return Symtab->addUndefined(New);
   }
 
   if (ObjSym.isCommon())
     return Symtab->addCommon(
         CommonSymbol{&F, Name, Binding, Visibility, STT_OBJECT,
                      ObjSym.getCommonAlignment(), ObjSym.getCommonSize()});
 
   Defined New(&F, Name, Binding, Visibility, Type, 0, 0, nullptr);

 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())
         continue;
-      Symtab->addLazyObject<ELFT>(LazyObject{*this, Saver.save(Sym.getName())});
+      Symtab->addLazyObject(LazyObject{*this, Saver.save(Sym.getName())});
     }
     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)
         continue;
-      Symtab->addLazyObject<ELFT>(
+      Symtab->addLazyObject(
           LazyObject{*this, CHECK(Sym.getName(StringTable), this)});
     }
     return;
   }
 }
 
 std::string elf::replaceThinLTOSuffix(StringRef Path) {
   StringRef Suffix = Config->ThinLTOObjectSuffixReplace.first;
   StringRef Repl = Config->ThinLTOObjectSuffixReplace.second;
 
   if (Path.consume_back(Suffix))
     return (Path + Repl).str();
   return Path;
 }
 
-template void elf::parseFile<ELF32LE>(InputFile *);
-template void elf::parseFile<ELF32BE>(InputFile *);
-template void elf::parseFile<ELF64LE>(InputFile *);
-template void elf::parseFile<ELF64BE>(InputFile *);
-
-template void ArchiveFile::parse<ELF32LE>();
-template void ArchiveFile::parse<ELF32BE>();
-template void ArchiveFile::parse<ELF64LE>();
-template void ArchiveFile::parse<ELF64BE>();
-
 template void BitcodeFile::parse<ELF32LE>(DenseSet<CachedHashStringRef> &);
 template void BitcodeFile::parse<ELF32BE>(DenseSet<CachedHashStringRef> &);
 template void BitcodeFile::parse<ELF64LE>(DenseSet<CachedHashStringRef> &);
 template void BitcodeFile::parse<ELF64BE>(DenseSet<CachedHashStringRef> &);
 
 template void LazyObjFile::parse<ELF32LE>();
 template void LazyObjFile::parse<ELF32BE>();
 template void LazyObjFile::parse<ELF64LE>();

lld/trunk/ELF/SymbolTable.h

 // 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(const Undefined &New);
-
+  Symbol *addUndefined(const Undefined &New);
   Symbol *addDefined(const Defined &New);
-
   void addShared(const SharedSymbol &New);
-
-  template <class ELFT> void addLazyArchive(const LazyArchive &New);
-  template <class ELFT> void addLazyObject(const LazyObject &New);
-
+  void addLazyArchive(const LazyArchive &New);
+  void addLazyObject(const LazyObject &New);
   Symbol *addBitcode(const Defined &New);
   Symbol *addCommon(const CommonSymbol &New);
 
   Symbol *insert(const Symbol &New);
   void mergeProperties(Symbol *Old, const Symbol &New);
 
-  template <class ELFT> void fetchLazy(Symbol *Sym);
+  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:
-  template <class ELFT, class LazyT> void addLazy(const LazyT &New);
+  template <class LazyT> void addLazy(const 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/trunk/ELF/SymbolTable.cpp

void SymbolTable::mergeProperties(Symbol *Old, const Symbol &New) {
   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);
 }
 
-template <class ELFT> Symbol *SymbolTable::addUndefined(const Undefined &New) {
+Symbol *SymbolTable::addUndefined(const Undefined &New) {
   Symbol *Old = insert(New);
   mergeProperties(Old, New);
 
   if (Old->isPlaceholder()) {
     replaceSymbol(Old, &New);
     return Old;
   }
 
if (Old->isLazy()) {
     //
     //   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 && New.File &&
                    Old->File->GroupId < New.File->GroupId;
-    fetchLazy<ELFT>(Old);
+    fetchLazy(Old);
 
     // We don't report backward references to weak symbols as they can be
     // overridden later.
     if (Backref && !Old->isWeak())
       warn("backward reference detected: " + New.getName() + " in " +
            toString(New.File) + " refers to " + toString(Old->File));
   }
   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, class LazyT> void SymbolTable::addLazy(const LazyT &New) {
+template <class LazyT> void SymbolTable::addLazy(const LazyT &New) {
   Symbol *Old = insert(New);
   mergeProperties(Old, New);
 
   if (Old->isPlaceholder()) {
     replaceSymbol(Old, &New);
     return;
   }
 
   if (!Old->isUndefined())
     return;
 
   // An undefined weak will not fetch archive members. See comment on Lazy in
   // Symbols.h for the details.
   if (Old->isWeak()) {
     uint8_t Type = Old->Type;
     replaceSymbol(Old, &New);
     Old->Type = Type;
     Old->Binding = STB_WEAK;
     return;
   }
 
   if (InputFile *F = New.fetch())
-    parseFile<ELFT>(F);
+    parseFile(F);
 }
 
-template <class ELFT> void SymbolTable::addLazyArchive(const LazyArchive &New) {
-  addLazy<ELFT>(New);
-}
+void SymbolTable::addLazyArchive(const LazyArchive &New) { addLazy(New); }
 
-template <class ELFT> void SymbolTable::addLazyObject(const LazyObject &New) {
-  addLazy<ELFT>(New);
-}
+void SymbolTable::addLazyObject(const LazyObject &New) { addLazy(New); }
 
-template <class ELFT> void SymbolTable::fetchLazy(Symbol *Sym) {
+void SymbolTable::fetchLazy(Symbol *Sym) {
   if (auto *S = dyn_cast<LazyArchive>(Sym)) {
     if (InputFile *File = S->fetch())
-      parseFile<ELFT>(File);
+      parseFile(File);
     return;
   }
 
   auto *S = cast<LazyObject>(Sym);
   if (InputFile *File = cast<LazyObjFile>(S->File)->fetch())
-    parseFile<ELFT>(File);
+    parseFile(File);
 }
 
 // Initialize DemangledSyms with a map from demangled symbols to symbol
 // objects. Used to handle "extern C++" directive in version scripts.
 //
 // The map will contain all demangled symbols. That can be very large,
 // and in LLD we generally want to avoid do anything for each symbol.
 // Then, why are we doing this? Here's why.
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>(const Undefined &);
-template Symbol *SymbolTable::addUndefined<ELF32BE>(const Undefined &);
-template Symbol *SymbolTable::addUndefined<ELF64LE>(const Undefined &);
-template Symbol *SymbolTable::addUndefined<ELF64BE>(const 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>(const LazyArchive &);
-template void SymbolTable::addLazyArchive<ELF32BE>(const LazyArchive &);
-template void SymbolTable::addLazyArchive<ELF64LE>(const LazyArchive &);
-template void SymbolTable::addLazyArchive<ELF64BE>(const LazyArchive &);
-
-template void SymbolTable::addLazyObject<ELF32LE>(const LazyObject &);
-template void SymbolTable::addLazyObject<ELF32BE>(const LazyObject &);
-template void SymbolTable::addLazyObject<ELF64LE>(const LazyObject &);
-template void SymbolTable::addLazyObject<ELF64BE>(const 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 *);