ELF: Use less templates for ELF types.

These classes are templated but actually instantiated for only
one ELF type.

llvm-svn: 234830

9 files changed, 61 insertions, 83 deletions

diff --git a/lld/lib/ReaderWriter/ELF/AArch64/AArch64DynamicLibraryWriter.h b/lld/lib/ReaderWriter/ELF/AArch64/AArch64DynamicLibraryWriter.h
index d1585e7412a..2323530d6ef 100644
--- a/lld/lib/ReaderWriter/ELF/AArch64/AArch64DynamicLibraryWriter.h
+++ b/lld/lib/ReaderWriter/ELF/AArch64/AArch64DynamicLibraryWriter.h
@@ -16,26 +16,23 @@
 namespace lld {
 namespace elf {
 
-template <class ELFT>
-class AArch64DynamicLibraryWriter : public DynamicLibraryWriter<ELFT> {
+class AArch64DynamicLibraryWriter : public DynamicLibraryWriter<ELF64LE> {
 public:
   AArch64DynamicLibraryWriter(AArch64LinkingContext &ctx,
-                              TargetLayout<ELFT> &layout);
+                              TargetLayout<ELF64LE> &layout);
 
 protected:
   // Add any runtime files and their atoms to the output
   void createImplicitFiles(std::vector<std::unique_ptr<File>> &) override;
 };
 
-template <class ELFT>
-AArch64DynamicLibraryWriter<ELFT>::AArch64DynamicLibraryWriter(
-    AArch64LinkingContext &ctx, TargetLayout<ELFT> &layout)
-    : DynamicLibraryWriter<ELFT>(ctx, layout) {}
+AArch64DynamicLibraryWriter::AArch64DynamicLibraryWriter(
+    AArch64LinkingContext &ctx, TargetLayout<ELF64LE> &layout)
+    : DynamicLibraryWriter<ELF64LE>(ctx, layout) {}
 
-template <class ELFT>
-void AArch64DynamicLibraryWriter<ELFT>::createImplicitFiles(
+void AArch64DynamicLibraryWriter::createImplicitFiles(
     std::vector<std::unique_ptr<File>> &result) {
-  DynamicLibraryWriter<ELFT>::createImplicitFiles(result);
+  DynamicLibraryWriter<ELF64LE>::createImplicitFiles(result);
   auto gotFile = llvm::make_unique<SimpleFile>("GOTFile");
   gotFile->addAtom(*new (gotFile->allocator()) GlobalOffsetTableAtom(*gotFile));
   gotFile->addAtom(*new (gotFile->allocator()) DynamicAtom(*gotFile));
diff --git a/lld/lib/ReaderWriter/ELF/AArch64/AArch64ExecutableWriter.h b/lld/lib/ReaderWriter/ELF/AArch64/AArch64ExecutableWriter.h
index f9eaa3bd5a9..0ebdfa57753 100644
--- a/lld/lib/ReaderWriter/ELF/AArch64/AArch64ExecutableWriter.h
+++ b/lld/lib/ReaderWriter/ELF/AArch64/AArch64ExecutableWriter.h
@@ -15,26 +15,23 @@
 namespace lld {
 namespace elf {
 
-template <class ELFT>
-class AArch64ExecutableWriter : public ExecutableWriter<ELFT> {
+class AArch64ExecutableWriter : public ExecutableWriter<ELF64LE> {
 public:
   AArch64ExecutableWriter(AArch64LinkingContext &ctx,
-                          TargetLayout<ELFT> &layout);
+                          TargetLayout<ELF64LE> &layout);
 
 protected:
   // Add any runtime files and their atoms to the output
   void createImplicitFiles(std::vector<std::unique_ptr<File>> &) override;
 };
 
-template <class ELFT>
-AArch64ExecutableWriter<ELFT>::AArch64ExecutableWriter(
-    AArch64LinkingContext &ctx, TargetLayout<ELFT> &layout)
-    : ExecutableWriter<ELFT>(ctx, layout) {}
+AArch64ExecutableWriter::AArch64ExecutableWriter(AArch64LinkingContext &ctx,
+                                                 TargetLayout<ELF64LE> &layout)
+    : ExecutableWriter<ELF64LE>(ctx, layout) {}
 
-template <class ELFT>
-void AArch64ExecutableWriter<ELFT>::createImplicitFiles(
+void AArch64ExecutableWriter::createImplicitFiles(
     std::vector<std::unique_ptr<File>> &result) {
-  ExecutableWriter<ELFT>::createImplicitFiles(result);
+  ExecutableWriter<ELF64LE>::createImplicitFiles(result);
   auto gotFile = llvm::make_unique<SimpleFile>("GOTFile");
   gotFile->addAtom(*new (gotFile->allocator()) GlobalOffsetTableAtom(*gotFile));
   if (this->_ctx.isDynamic())
diff --git a/lld/lib/ReaderWriter/ELF/AArch64/AArch64TargetHandler.cpp b/lld/lib/ReaderWriter/ELF/AArch64/AArch64TargetHandler.cpp
index de265100845..e5bb5ef16dc 100644
--- a/lld/lib/ReaderWriter/ELF/AArch64/AArch64TargetHandler.cpp
+++ b/lld/lib/ReaderWriter/ELF/AArch64/AArch64TargetHandler.cpp
@@ -23,11 +23,9 @@ AArch64TargetHandler::AArch64TargetHandler(AArch64LinkingContext &ctx)
 std::unique_ptr<Writer> AArch64TargetHandler::getWriter() {
   switch (this->_ctx.getOutputELFType()) {
   case llvm::ELF::ET_EXEC:
-    return llvm::make_unique<AArch64ExecutableWriter<ELF64LE>>(_ctx,
-                                                               *_targetLayout);
+    return llvm::make_unique<AArch64ExecutableWriter>(_ctx, *_targetLayout);
   case llvm::ELF::ET_DYN:
-    return llvm::make_unique<AArch64DynamicLibraryWriter<ELF64LE>>(
-        _ctx, *_targetLayout);
+    return llvm::make_unique<AArch64DynamicLibraryWriter>(_ctx, *_targetLayout);
   case llvm::ELF::ET_REL:
     llvm_unreachable("TODO: support -r mode");
   default:
diff --git a/lld/lib/ReaderWriter/ELF/ARM/ARMExecutableWriter.h b/lld/lib/ReaderWriter/ELF/ARM/ARMExecutableWriter.h
index 7374a5365c2..fd8d89986b8 100644
--- a/lld/lib/ReaderWriter/ELF/ARM/ARMExecutableWriter.h
+++ b/lld/lib/ReaderWriter/ELF/ARM/ARMExecutableWriter.h
@@ -22,10 +22,9 @@ const char *gotSymbol = "_GLOBAL_OFFSET_TABLE_";
 namespace lld {
 namespace elf {
 
-template <class ELFT>
-class ARMExecutableWriter : public ExecutableWriter<ELFT> {
+class ARMExecutableWriter : public ExecutableWriter<ELF32LE> {
 public:
-  ARMExecutableWriter(ARMLinkingContext &ctx, ARMTargetLayout<ELFT> &layout);
+  ARMExecutableWriter(ARMLinkingContext &ctx, ARMTargetLayout &layout);
 
 protected:
   // Add any runtime files and their atoms to the output
@@ -34,34 +33,31 @@ protected:
   void finalizeDefaultAtomValues() override;
 
   /// \brief Create symbol table.
-  unique_bump_ptr<SymbolTable<ELFT>> createSymbolTable() override;
+  unique_bump_ptr<SymbolTable<ELF32LE>> createSymbolTable() override;
 
   void processUndefinedSymbol(StringRef symName,
-                              RuntimeFile<ELFT> &file) const override;
+                              RuntimeFile<ELF32LE> &file) const override;
 
   // Setup the ELF header.
   std::error_code setELFHeader() override;
 
 private:
   ARMLinkingContext &_ctx;
-  ARMTargetLayout<ELFT> &_armLayout;
+  ARMTargetLayout &_armLayout;
 };
 
-template <class ELFT>
-ARMExecutableWriter<ELFT>::ARMExecutableWriter(ARMLinkingContext &ctx,
-                                               ARMTargetLayout<ELFT> &layout)
-    : ExecutableWriter<ELFT>(ctx, layout), _ctx(ctx), _armLayout(layout) {}
+ARMExecutableWriter::ARMExecutableWriter(ARMLinkingContext &ctx,
+                                         ARMTargetLayout &layout)
+    : ExecutableWriter<ELF32LE>(ctx, layout), _ctx(ctx), _armLayout(layout) {}
 
-template <class ELFT>
-void ARMExecutableWriter<ELFT>::createImplicitFiles(
+void ARMExecutableWriter::createImplicitFiles(
     std::vector<std::unique_ptr<File>> &result) {
-  ExecutableWriter<ELFT>::createImplicitFiles(result);
+  ExecutableWriter<ELF32LE>::createImplicitFiles(result);
 }
 
-template <class ELFT>
-void ARMExecutableWriter<ELFT>::finalizeDefaultAtomValues() {
+void ARMExecutableWriter::finalizeDefaultAtomValues() {
   // Finalize the atom values that are part of the parent.
-  ExecutableWriter<ELFT>::finalizeDefaultAtomValues();
+  ExecutableWriter<ELF32LE>::finalizeDefaultAtomValues();
   AtomLayout *gotAtom = _armLayout.findAbsoluteAtom(gotSymbol);
   if (gotAtom) {
     if (auto gotpltSection = _armLayout.findOutputSection(".got.plt"))
@@ -74,16 +70,13 @@ void ARMExecutableWriter<ELFT>::finalizeDefaultAtomValues() {
   // TODO: resolve addresses of __exidx_start/_end atoms
 }
 
-template <class ELFT>
-unique_bump_ptr<SymbolTable<ELFT>>
-ARMExecutableWriter<ELFT>::createSymbolTable() {
-  return unique_bump_ptr<SymbolTable<ELFT>>(
-      new (this->_alloc) ARMSymbolTable<ELFT>(this->_ctx));
+unique_bump_ptr<SymbolTable<ELF32LE>> ARMExecutableWriter::createSymbolTable() {
+  return unique_bump_ptr<SymbolTable<ELF32LE>>(new (this->_alloc)
+                                                   ARMSymbolTable(this->_ctx));
 }
 
-template <class ELFT>
-void ARMExecutableWriter<ELFT>::processUndefinedSymbol(
-    StringRef symName, RuntimeFile<ELFT> &file) const {
+void ARMExecutableWriter::processUndefinedSymbol(
+    StringRef symName, RuntimeFile<ELF32LE> &file) const {
   if (symName == gotSymbol) {
     file.addAbsoluteAtom(gotSymbol);
   } else if (symName.startswith("__exidx")) {
@@ -92,9 +85,8 @@ void ARMExecutableWriter<ELFT>::processUndefinedSymbol(
   }
 }
 
-template <class ELFT>
-std::error_code ARMExecutableWriter<ELFT>::setELFHeader() {
-  if (std::error_code ec = ExecutableWriter<ELFT>::setELFHeader())
+std::error_code ARMExecutableWriter::setELFHeader() {
+  if (std::error_code ec = ExecutableWriter<ELF32LE>::setELFHeader())
     return ec;
 
   // Set ARM-specific flags.
diff --git a/lld/lib/ReaderWriter/ELF/ARM/ARMRelocationHandler.h b/lld/lib/ReaderWriter/ELF/ARM/ARMRelocationHandler.h
index 6ba53017c60..80a2f3d4850 100644
--- a/lld/lib/ReaderWriter/ELF/ARM/ARMRelocationHandler.h
+++ b/lld/lib/ReaderWriter/ELF/ARM/ARMRelocationHandler.h
@@ -15,19 +15,18 @@
 namespace lld {
 namespace elf {
 
-template <class ELFT> class ARMTargetLayout;
+class ARMTargetLayout;
 
 class ARMTargetRelocationHandler final : public TargetRelocationHandler {
 public:
-  ARMTargetRelocationHandler(ARMTargetLayout<ELF32LE> &layout)
-      : _armLayout(layout) {}
+  ARMTargetRelocationHandler(ARMTargetLayout &layout) : _armLayout(layout) {}
 
   std::error_code applyRelocation(ELFWriter &, llvm::FileOutputBuffer &,
                                   const lld::AtomLayout &,
                                   const Reference &) const override;
 
 private:
-  ARMTargetLayout<ELF32LE> &_armLayout;
+  ARMTargetLayout &_armLayout;
 };
 
 } // end namespace elf
diff --git a/lld/lib/ReaderWriter/ELF/ARM/ARMSymbolTable.h b/lld/lib/ReaderWriter/ELF/ARM/ARMSymbolTable.h
index b0cc49b02d0..f31449d55ee 100644
--- a/lld/lib/ReaderWriter/ELF/ARM/ARMSymbolTable.h
+++ b/lld/lib/ReaderWriter/ELF/ARM/ARMSymbolTable.h
@@ -14,10 +14,9 @@ namespace lld {
 namespace elf {
 
 /// \brief The SymbolTable class represents the symbol table in a ELF file
-template<class ELFT>
-class ARMSymbolTable : public SymbolTable<ELFT> {
+class ARMSymbolTable : public SymbolTable<ELF32LE> {
 public:
-  typedef llvm::object::Elf_Sym_Impl<ELFT> Elf_Sym;
+  typedef llvm::object::Elf_Sym_Impl<ELF32LE> Elf_Sym;
 
   ARMSymbolTable(const ELFLinkingContext &ctx);
 
@@ -25,15 +24,13 @@ public:
                       int64_t addr) override;
 };
 
-template <class ELFT>
-ARMSymbolTable<ELFT>::ARMSymbolTable(const ELFLinkingContext &ctx)
-    : SymbolTable<ELFT>(ctx, ".symtab",
-                        TargetLayout<ELFT>::ORDER_SYMBOL_TABLE) {}
+ARMSymbolTable::ARMSymbolTable(const ELFLinkingContext &ctx)
+    : SymbolTable<ELF32LE>(ctx, ".symtab",
+                           TargetLayout<ELF32LE>::ORDER_SYMBOL_TABLE) {}
 
-template <class ELFT>
-void ARMSymbolTable<ELFT>::addDefinedAtom(Elf_Sym &sym, const DefinedAtom *da,
-                                          int64_t addr) {
-  SymbolTable<ELFT>::addDefinedAtom(sym, da, addr);
+void ARMSymbolTable::addDefinedAtom(Elf_Sym &sym, const DefinedAtom *da,
+                                    int64_t addr) {
+  SymbolTable<ELF32LE>::addDefinedAtom(sym, da, addr);
 
   // Set zero bit to distinguish real symbols addressing Thumb instructions.
   // Don't care about mapping symbols like $t and others.
diff --git a/lld/lib/ReaderWriter/ELF/ARM/ARMTargetHandler.cpp b/lld/lib/ReaderWriter/ELF/ARM/ARMTargetHandler.cpp
index 1cbbf8cf8c9..2b928fb1eba 100644
--- a/lld/lib/ReaderWriter/ELF/ARM/ARMTargetHandler.cpp
+++ b/lld/lib/ReaderWriter/ELF/ARM/ARMTargetHandler.cpp
@@ -16,14 +16,13 @@ using namespace lld;
 using namespace elf;
 
 ARMTargetHandler::ARMTargetHandler(ARMLinkingContext &ctx)
-    : _ctx(ctx), _targetLayout(new ARMTargetLayout<ELF32LE>(ctx)),
+    : _ctx(ctx), _targetLayout(new ARMTargetLayout(ctx)),
       _relocationHandler(new ARMTargetRelocationHandler(*_targetLayout)) {}
 
 std::unique_ptr<Writer> ARMTargetHandler::getWriter() {
   switch (this->_ctx.getOutputELFType()) {
   case llvm::ELF::ET_EXEC:
-    return llvm::make_unique<ARMExecutableWriter<ELF32LE>>(_ctx,
-                                                           *_targetLayout);
+    return llvm::make_unique<ARMExecutableWriter>(_ctx, *_targetLayout);
   default:
     llvm_unreachable("unsupported output type");
   }
diff --git a/lld/lib/ReaderWriter/ELF/ARM/ARMTargetHandler.h b/lld/lib/ReaderWriter/ELF/ARM/ARMTargetHandler.h
index cf74af1e7c3..63a9aeaf70f 100644
--- a/lld/lib/ReaderWriter/ELF/ARM/ARMTargetHandler.h
+++ b/lld/lib/ReaderWriter/ELF/ARM/ARMTargetHandler.h
@@ -16,12 +16,13 @@
 #include "TargetLayout.h"
 
 namespace lld {
+class ELFLinkingContext;
+
 namespace elf {
-class ARMLinkingContext;
 
-template <class ELFT> class ARMTargetLayout : public TargetLayout<ELFT> {
+class ARMTargetLayout : public TargetLayout<ELF32LE> {
 public:
-  ARMTargetLayout(ARMLinkingContext &ctx) : TargetLayout<ELFT>(ctx) {}
+  ARMTargetLayout(ELFLinkingContext &ctx) : TargetLayout<ELF32LE>(ctx) {}
 
   uint64_t getGOTSymAddr() {
     std::call_once(_gotSymOnce, [this]() {
@@ -80,7 +81,7 @@ public:
 
 private:
   ARMLinkingContext &_ctx;
-  std::unique_ptr<ARMTargetLayout<ELF32LE>> _targetLayout;
+  std::unique_ptr<ARMTargetLayout> _targetLayout;
   std::unique_ptr<ARMTargetRelocationHandler> _relocationHandler;
 };
 
diff --git a/lld/lib/ReaderWriter/ELF/Hexagon/HexagonTargetHandler.h b/lld/lib/ReaderWriter/ELF/Hexagon/HexagonTargetHandler.h
index 63dc8f5bee9..645c2db8b95 100644
--- a/lld/lib/ReaderWriter/ELF/Hexagon/HexagonTargetHandler.h
+++ b/lld/lib/ReaderWriter/ELF/Hexagon/HexagonTargetHandler.h
@@ -21,7 +21,7 @@ namespace elf {
 class HexagonLinkingContext;
 
 /// \brief Handle Hexagon SData section
-template <class ELFT> class SDataSection : public AtomSection<ELFT> {
+class SDataSection : public AtomSection<ELF32LE> {
 public:
   SDataSection(const HexagonLinkingContext &ctx);
 
@@ -43,7 +43,7 @@ public:
 
   HexagonTargetLayout(HexagonLinkingContext &hti)
       : TargetLayout<ELF32LE>(hti), _sdataSection() {
-    _sdataSection = new (_alloc) SDataSection<ELF32LE>(hti);
+    _sdataSection = new (_alloc) SDataSection(hti);
   }
 
   /// \brief Return the section order for a input section
@@ -103,7 +103,7 @@ public:
 
 private:
   llvm::BumpPtrAllocator _alloc;
-  SDataSection<ELF32LE> *_sdataSection = nullptr;
+  SDataSection *_sdataSection = nullptr;
   uint64_t _gotAddr = 0;
   std::once_flag _gotOnce;
 };
@@ -137,7 +137,7 @@ private:
   std::unique_ptr<HexagonTargetRelocationHandler> _relocationHandler;
 };
 
-template <class ELFT> void SDataSection<ELFT>::doPreFlight() {
+inline void SDataSection::doPreFlight() {
   // sort the atoms on the alignments they have been set
   std::stable_sort(this->_atoms.begin(), this->_atoms.end(),
                                              [](const lld::AtomLayout * A,
@@ -167,17 +167,15 @@ template <class ELFT> void SDataSection<ELFT>::doPreFlight() {
   }
 } // finalize
 
-template <class ELFT>
-SDataSection<ELFT>::SDataSection(const HexagonLinkingContext &ctx)
-    : AtomSection<ELFT>(ctx, ".sdata", DefinedAtom::typeDataFast, 0,
-                        HexagonTargetLayout::ORDER_SDATA) {
+inline SDataSection::SDataSection(const HexagonLinkingContext &ctx)
+    : AtomSection<ELF32LE>(ctx, ".sdata", DefinedAtom::typeDataFast, 0,
+                           HexagonTargetLayout::ORDER_SDATA) {
   this->_type = SHT_PROGBITS;
   this->_flags = SHF_ALLOC | SHF_WRITE;
   this->_alignment = 4096;
 }
 
-template <class ELFT>
-const lld::AtomLayout *SDataSection<ELFT>::appendAtom(const Atom *atom) {
+inline const lld::AtomLayout *SDataSection::appendAtom(const Atom *atom) {
   const DefinedAtom *definedAtom = cast<DefinedAtom>(atom);
   DefinedAtom::Alignment atomAlign = definedAtom->alignment();
   uint64_t alignment = atomAlign.value;