[ELF] - Remove ObjFile<ELFT>::Instances and introduce std::vector<InputFIle*> ObjFiles instead.

[grimar]

Summary

I suggect this change as it allows to detemplate code.
Intented to be used together with
D35936 ("[ELF] - Move getSymbols() method to InputFile")
in D35843 ("[ELF] - Fix "--symbol-ordering-file doesn't work with linker scripts") patch,
more details is in description for D35936 patch.

[ruiu]

This patch sacrifices consistency for removing template, which I don't think a good idea.

[grimar]

In D35938#822934, @ruiu wrote:

This patch sacrifices consistency for removing template, which I don't think a good idea.

What about D35987 ? It should address your comment.

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 (ObjFile<ELFT> *F : ObjFile<ELFT>::Instances)
+  for (InputFile *Obj : ObjFiles) {
+    ObjFile<ELFT> *F = cast<ObjFile<ELFT>>(Obj);
     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) {
   if (FpA == FpB)

ELF/Driver.cpp

for (StringRef Sym : Script->Opt.ReferencedSymbols)
     Symtab->addUndefined<ELFT>(Sym);
 
   // Apply symbol renames for -wrap and -defsym
   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 (ObjFile<ELFT> *F : ObjFile<ELFT>::Instances)
+  for (InputFile *F : ObjFiles)
     for (InputSectionBase *S : F->getSections())
       if (S && S != &InputSection::Discarded)
         InputSections.push_back(S);
   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

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<ObjFile<ELFT> *> Instances;
-
   ArrayRef<SymbolBody *> getSymbols();
   ArrayRef<SymbolBody *> getLocalSymbols();
 
   ObjFile(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<ObjFile<ELFT> *> ObjFile<ELFT>::Instances;
-
 // LazyObjFile is analogous to ArchiveFile in the sense that
 // the file contains lazy symbols. The difference is that
 // LazyObjFile 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 LazyObjFile : public InputFile {
public:
   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);
 
+// The list of all ObjFile instances.
+extern std::vector<InputFile *> ObjFiles;
+
 } // namespace elf
 } // namespace lld
 
 #endif

ELF/InputFiles.cpp

 using namespace llvm;
 using namespace llvm::ELF;
 using namespace llvm::object;
 using namespace llvm::sys::fs;
 
 using namespace lld;
 using namespace lld::elf;
 
+std::vector<InputFile *> elf::ObjFiles;
+
 TarWriter *elf::Tar;
 
 InputFile::InputFile(Kind K, MemoryBufferRef M) : MB(M), FileKind(K) {}
 
 Optional<MemoryBufferRef> elf::readFile(StringRef Path) {
   // The --chroot option changes our virtual root directory.
   // This is useful when you are dealing with files created by --reproduce.
   if (!Config->Chroot.empty() && Path.startswith("/"))

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 (ObjFile<ELFT> *File : ObjFile<ELFT>::Instances)
+  for (InputFile *Obj : ObjFiles) {
+    ObjFile<ELFT> *File = cast<ObjFile<ELFT>>(Obj);
     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;
 }
 
 // Returns a map from sections to their symbols.
 template <class ELFT>
 SymbolMapTy getSectionSyms(ArrayRef<DefinedRegular *> Syms) {
   SymbolMapTy Ret;
   for (DefinedRegular *S : Syms)

ELF/SymbolTable.cpp

template <class ELFT> void SymbolTable::addFile(InputFile *File) {
   // LLVM bitcode file
   if (auto *F = dyn_cast<BitcodeFile>(File)) {
     BitcodeFile::Instances.push_back(F);
     F->parse<ELFT>(ComdatGroups);
     return;
   }
 
   // Regular object file
-  auto *F = cast<ObjFile<ELFT>>(File);
-  ObjFile<ELFT>::Instances.push_back(F);
-  F->parse(ComdatGroups);
+  ObjFiles.push_back(File);
+  cast<ObjFile<ELFT>>(File)->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::addCombinedLTOObject() {
   if (BitcodeFile::Instances.empty())
     return;
 
   // Compile bitcode files and replace bitcode symbols.
   LTO.reset(new BitcodeCompiler);
   for (BitcodeFile *F : BitcodeFile::Instances)
     LTO->add(*F);
 
   for (InputFile *File : LTO->compile()) {
     ObjFile<ELFT> *Obj = cast<ObjFile<ELFT>>(File);
     DenseSet<CachedHashStringRef> DummyGroups;
     Obj->parse(DummyGroups);
-    ObjFile<ELFT>::Instances.push_back(Obj);
+    ObjFiles.push_back(Obj);
   }
 }
 
 template <class ELFT>
 DefinedRegular *SymbolTable::addAbsolute(StringRef Name, uint8_t Visibility,
                                          uint8_t Binding) {
   Symbol *Sym = addRegular<ELFT>(Name, Visibility, STT_NOTYPE, 0, 0, Binding,
                                  nullptr, nullptr);

ELF/Writer.cpp

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 (ObjFile<ELFT> *F : ObjFile<ELFT>::Instances) {
+  for (InputFile *Obj : ObjFiles) {
+    ObjFile<ELFT> *F = cast<ObjFile<ELFT>>(Obj);
     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 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 (ObjFile<ELFT> *File : ObjFile<ELFT>::Instances) {
+  for (InputFile *Obj : ObjFiles) {
+    ObjFile<ELFT> *File = cast<ObjFile<ELFT>>(Obj);
     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()));
     }
   }