Replace GAlloc with a template function.

[ruiu]

Summary

This patch replaces GAlloc<ELFT>::<sometype>.Allocate() with
alloc<sometype<ELFT>>().

[ruiu]

• also manage InputFile::Pool with the arena allocator.

[ruiu]

• remove InputFile's virtual dtor.

[• rafael]

LGTM with nit

ELF/Memory.cpp

23

Do we still need to free this at a specific point in time? If not just letting the destructors take care of it should simplify the code.

[ruiu]

ELF/Memory.cpp

23

This is for the use case in which you directly call lld::elf::link from your program. In that use case, we want to free all memories before returning from link().

ELF/Driver.cpp

bool elf::link(ArrayRef<const char *> Args, bool CanExitEarly,
   Configuration C;
   LinkerDriver D;
   ScriptConfiguration SC;
   Config = &C;
   Driver = &D;
   ScriptConfig = &SC;
 
   Driver->main(Args, CanExitEarly);
-  InputFile::freePool();
   freeArena();
   return !HasError;
 }
 
 // Parses a linker -m option.
 static std::tuple<ELFKind, uint16_t, uint8_t> parseEmulation(StringRef Emul) {
   uint8_t OSABI = 0;
   StringRef S = Emul;
void LinkerDriver::addFile(StringRef Path) {
   using namespace sys::fs;
 
   Optional<MemoryBufferRef> Buffer = readFile(Path);
   if (!Buffer.hasValue())
     return;
   MemoryBufferRef MBRef = *Buffer;
 
   if (InBinary) {
-    Files.push_back(new BinaryFile(MBRef));
+    Files.push_back(new (alloc<BinaryFile>()) BinaryFile(MBRef));
     return;
   }
 
   switch (identify_magic(MBRef.getBuffer())) {
   case file_magic::unknown:
     readLinkerScript(MBRef);
     return;
   case file_magic::archive:
     if (InWholeArchive) {
       for (MemoryBufferRef MB : getArchiveMembers(MBRef))
         Files.push_back(createObjectFile(MB, Path));
       return;
     }
-    Files.push_back(new ArchiveFile(MBRef));
+    Files.push_back(new (alloc<ArchiveFile>()) ArchiveFile(MBRef));
     return;
   case file_magic::elf_shared_object:
     if (Config->Relocatable) {
       error("attempted static link of dynamic object " + Path);
       return;
     }
     Files.push_back(createSharedFile(MBRef));
     return;
   default:
     if (InLib)
-      Files.push_back(new LazyObjectFile(MBRef));
+      Files.push_back(new (alloc<LazyObjectFile>()) LazyObjectFile(MBRef));
     else
       Files.push_back(createObjectFile(MBRef));
   }
 }
 
 Optional<MemoryBufferRef> LinkerDriver::readFile(StringRef Path) {
   if (Config->Verbose)
     outs() << Path << "\n";

ELF/InputFiles.h

 namespace lto {
 class InputFile;
 }
 }
 
 namespace lld {
 namespace elf {
 
-template <class ELFT> struct GAlloc {
-  static llvm::SpecificBumpPtrAllocator<InputSection<ELFT>> IAlloc;
-  static llvm::SpecificBumpPtrAllocator<MergeInputSection<ELFT>> MAlloc;
-  static llvm::SpecificBumpPtrAllocator<EhInputSection<ELFT>> EHAlloc;
-};
-
-template <class ELFT>
-llvm::SpecificBumpPtrAllocator<InputSection<ELFT>> GAlloc<ELFT>::IAlloc;
-
-template <class ELFT>
-llvm::SpecificBumpPtrAllocator<MergeInputSection<ELFT>> GAlloc<ELFT>::MAlloc;
-
-template <class ELFT>
-llvm::SpecificBumpPtrAllocator<EhInputSection<ELFT>> GAlloc<ELFT>::EHAlloc;
-
 using llvm::object::Archive;
 
 class InputFile;
 class Lazy;
 class SymbolBody;
 
 // Debugging information helper class. The main purpose is 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.
 template <class ELFT> class DIHelper {
 public:
   typedef typename ELFT::uint uintX_t;
 
   DIHelper(InputFile *F);
   std::string getLineInfo(uintX_t Offset);
 private:
   std::unique_ptr<llvm::DWARFDebugLine> DwarfLine;
 };
 
 // The root class of input files.
 class InputFile {
 public:
-  virtual ~InputFile() = default;
-
   enum Kind {
     ObjectKind,
     SharedKind,
     LazyObjectKind,
     ArchiveKind,
     BitcodeKind,
     BinaryKind,
   };
public:
   uint64_t OffsetInArchive;
 
   // If this is an architecture-specific file, the following members
   // have ELF type (i.e. ELF{32,64}{LE,BE}) and target machine type.
   ELFKind EKind = ELFNoneKind;
   uint16_t EMachine = llvm::ELF::EM_NONE;
   uint8_t OSABI = 0;
 
-  static void freePool();
-
 protected:
-  InputFile(Kind K, MemoryBufferRef M) : MB(M), FileKind(K) {
-    Pool.push_back(this);
-  }
+  InputFile(Kind K, MemoryBufferRef M) : MB(M), FileKind(K) {}
 
 private:
   const Kind FileKind;
-
-  // All InputFile instances are added to the pool
-  // and freed all at once on exit by freePool().
-  static std::vector<InputFile *> Pool;
 };
 
 // Returns "(internal)", "foo.a(bar.o)" or "baz.o".
 std::string getFilename(const InputFile *F);
 
 template <typename ELFT> class ELFFileBase : public InputFile {
 public:
   typedef typename ELFT::Shdr Elf_Shdr;

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 *> InputFile::Pool;
-
 template <class ELFT> DIHelper<ELFT>::DIHelper(elf::InputFile *F) {
   Expected<std::unique_ptr<object::ObjectFile>> Obj =
       object::ObjectFile::createObjectFile(F->MB);
   if (!Obj)
     return;
 
   DWARFContextInMemory Dwarf(*Obj.get());
   DwarfLine.reset(new DWARFDebugLine(&Dwarf.getLineSection().Relocs));
template <class ELFT> std::string DIHelper<ELFT>::getLineInfo(uintX_t Offset) {
   if (!LineTbl)
     return "";
   LineTbl->getFileLineInfoForAddress(Offset, nullptr, Spec.FLIKind, LineInfo);
   return LineInfo.Line != 0
              ? LineInfo.FileName + " (" + std::to_string(LineInfo.Line) + ")"
              : "";
 }
 
-// Deletes all InputFile instances created so far.
-void InputFile::freePool() {
-  // Files are freed in reverse order so that files created
-  // from other files (e.g. object files extracted from archives)
-  // are freed in the proper order.
-  for (int I = Pool.size() - 1; I >= 0; --I)
-    delete Pool[I];
-}
-
 // Returns "(internal)", "foo.a(bar.o)" or "baz.o".
 std::string elf::getFilename(const InputFile *F) {
   if (!F)
     return "(internal)";
   if (!F->ArchiveName.empty())
     return (F->ArchiveName + "(" + F->getName() + ")").str();
   return F->getName();
 }
case SHT_MIPS_ABIFLAGS:
     MipsAbiFlags.reset(new MipsAbiFlagsInputSection<ELFT>(this, &Sec, Name));
     return MipsAbiFlags.get();
   case SHT_RELA:
   case SHT_REL: {
     // This section contains relocation information.
     // If -r is given, we do not interpret or apply relocation
     // but just copy relocation sections to output.
     if (Config->Relocatable)
-      return new (GAlloc<ELFT>::IAlloc.Allocate())
+      return new (alloc<InputSection<ELFT>>())
           InputSection<ELFT>(this, &Sec, Name);
 
     // Find the relocation target section and associate this
     // section with it.
     InputSectionBase<ELFT> *Target = getRelocTarget(Sec);
     if (!Target)
       return nullptr;
     if (auto *S = dyn_cast<InputSection<ELFT>>(Target)) {
elf::ObjectFile<ELFT>::createInputSection(const Elf_Shdr &Sec) {
 
   if (Config->Strip != StripPolicy::None && Name.startswith(".debug"))
     return &InputSection<ELFT>::Discarded;
 
   // The linker merges EH (exception handling) frames and creates a
   // .eh_frame_hdr section for runtime. So we handle them with a special
   // class. For relocatable outputs, they are just passed through.
   if (Name == ".eh_frame" && !Config->Relocatable)
-    return new (GAlloc<ELFT>::EHAlloc.Allocate())
+    return new (alloc<EhInputSection<ELFT>>())
         EhInputSection<ELFT>(this, &Sec, Name);
 
   if (shouldMerge(Sec))
-    return new (GAlloc<ELFT>::MAlloc.Allocate())
+    return new (alloc<MergeInputSection<ELFT>>())
         MergeInputSection<ELFT>(this, &Sec, Name);
-  return new (GAlloc<ELFT>::IAlloc.Allocate())
-      InputSection<ELFT>(this, &Sec, Name);
+  return new (alloc<InputSection<ELFT>>()) InputSection<ELFT>(this, &Sec, Name);
 }
 
 template <class ELFT> void elf::ObjectFile<ELFT>::initializeSymbols() {
   this->initStringTable();
   Elf_Sym_Range Syms = this->getElfSymbols(false);
   uint32_t NumSymbols = std::distance(Syms.begin(), Syms.end());
   SymbolBodies.reserve(NumSymbols);
   for (const Elf_Sym &Sym : Syms)
static InputFile *createELFFile(MemoryBufferRef MB) {
   unsigned char Size;
   unsigned char Endian;
   std::tie(Size, Endian) = getElfArchType(MB.getBuffer());
   if (Endian != ELFDATA2LSB && Endian != ELFDATA2MSB)
     fatal("invalid data encoding: " + MB.getBufferIdentifier());
 
   InputFile *Obj;
   if (Size == ELFCLASS32 && Endian == ELFDATA2LSB)
-    Obj = new T<ELF32LE>(MB);
+    Obj = new (alloc<T<ELF32LE>>()) T<ELF32LE>(MB);
   else if (Size == ELFCLASS32 && Endian == ELFDATA2MSB)
-    Obj = new T<ELF32BE>(MB);
+    Obj = new (alloc<T<ELF32BE>>()) T<ELF32BE>(MB);
   else if (Size == ELFCLASS64 && Endian == ELFDATA2LSB)
-    Obj = new T<ELF64LE>(MB);
+    Obj = new (alloc<T<ELF64LE>>()) T<ELF64LE>(MB);
   else if (Size == ELFCLASS64 && Endian == ELFDATA2MSB)
-    Obj = new T<ELF64BE>(MB);
+    Obj = new (alloc<T<ELF64BE>>()) T<ELF64BE>(MB);
   else
     fatal("invalid file class: " + MB.getBufferIdentifier());
 
   if (!Config->FirstElf)
     Config->FirstElf = Obj;
   return Obj;
 }
 

ELF/Memory.h

 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLD_ELF_MEMORY_H
 #define LLD_ELF_MEMORY_H
 
 #include "llvm/Support/Allocator.h"
 #include "llvm/Support/StringSaver.h"
+#include <vector>
 
 namespace lld {
 namespace elf {
+
+// Use this arena if your object doesn't have a destructor.
 extern llvm::BumpPtrAllocator BAlloc;
 extern llvm::StringSaver Saver;
 
+// These two classes are hack to keep track of all
+// SpecificBumpPtrAllocator instances.
+struct SpecificAllocBase {
+  SpecificAllocBase();
+  virtual ~SpecificAllocBase() = default;
+  virtual void reset() = 0;
+  static std::vector<SpecificAllocBase *> Instances;
+};
+
+template <class T> struct SpecificAlloc : public SpecificAllocBase {
+  void reset() override { Alloc.DestroyAll(); }
+  llvm::SpecificBumpPtrAllocator<T> Alloc;
+};
+
+// Use this arean if your object have a destructor.
+// Your destructor will be invoked from freeArena().
+template <class T> static T *alloc() {
+  static SpecificAlloc<T> Alloc;
+  return Alloc.Alloc.Allocate();
+}
+
 void freeArena();
 }
 }
 
 #endif

ELF/Memory.cpp

 //===- Memory.cpp -----------------------------------------------*- C++ -*-===//
 //
 //                             The LLVM Linker
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "Memory.h"
 
-llvm::BumpPtrAllocator lld::elf::BAlloc;
-llvm::StringSaver lld::elf::Saver{BAlloc};
+using namespace llvm;
+using namespace lld;
+using namespace lld::elf;
 
-void lld::elf::freeArena() { BAlloc.Reset(); }
+BumpPtrAllocator elf::BAlloc;
+StringSaver elf::Saver{BAlloc};
+
+SpecificAllocBase::SpecificAllocBase() { Instances.push_back(this); }
+
+std::vector<SpecificAllocBase *> SpecificAllocBase::Instances;
+
+void elf::freeArena() {
+  for (SpecificAllocBase *Alloc : SpecificAllocBase::Instances)
+    Alloc->reset();
+  BAlloc.Reset();
+}