[ELF] Allow customization of OutputELFWriter class

[atanasyan]

Summary

Now target specific code inherits writer classes from ExecutableWriter and DynamicLibraryWriter. It is OK unitil we need to add some target specific functionality which is common to both executable and dynamic library writers. We have to either duplicate such code or move it to utility routine.

The patch tries to solve this problem using some sort of template trick. Both ExecutableWriter and DynamicLibraryWriter classes get one more template argument BaseWriter and use it as a base class. By default this argument has OutputELFWriter<ELFT> so we get the same code as now. If we need to share some code amont executable and dynamic library writers we create new class (for example MipsOutputWriter) inherited from OutputWriter and put common code to this class. Then we create writer as in example below:

template <class ELFT>
class MipsExecutableWriter
    : public ExecutableWriter<ELFT, MipsOutputWriter<ELFT>> {
...
};

template <class ELFT>
using MipsDynamicLibraryWriter =
    DynamicLibraryWriter<ELFT, MipsOutputWriter<ELFT>>;

The patch makes some part of code more complicated but reduces code size and prevent code duplication.

Any objections and / or comments?

[ruiu]

Hm. So this patch apparently solves the issue you described but with a (non-obvious) template magic to insert a class to a class hierarchy. This complexity made me a bit nervous, so I thought about alternatives for a while.

The first thing that came up to my mind is to use utility functions you described, but with that you cannot purge duplicates. The other way would be to use multiple inheritance, but that's worse than the template magic. After all, this patch removes 170 lines, so maybe it's a good hack.

[shankarke]

Prior to this change, the target executable writer's used to contain the TargetLinkingContexts and their TargetLayout's. The Target writers do a static cast and return their layout's which i feel is not a nice design, IMO. I think you could safely derive from OutputELFWriter and create MipsOutputELFWriter. This would save the same amount of duplicated code too. Thoughts ?

[• shankar.easwaran]

You could have a helper class that contains common code that the MIPS executable / dynamic writer can.contain? No?? This was how it used to be right?

I don't prefer the design here especially the static casts.

[atanasyan]

In D8882#153204, @shankar.easwaran wrote:

You could have a helper class that contains common code that the MIPS executable / dynamic writer can.contain? No?? This was how it used to be right?

This approach is not so bad and used right now. Both MipsDynamicLibraryWriter and MipsExecutableWriter contains an instance of MipsELFWriter which provides helper methods. But I am annoyed a bit that almost all methods of MipsXXXWriter classes just call the same methods of MipsELFWriter class. Besides that it would be nice to escape code duplication in methods like MipsXXXWriter::createSymbolTable(), MipsXXXWriter::createDynamicTable() etc. But if I pass this code to the MipsELFWriter class I in fact increase number of code lines.

By the way, why don't you use a helper class to keep common code used by HexagonXXXWriter classes in the single place? As far as I can see such code has been spread among HexagonLinkingContext.h and HexagonTargetHandler.h since rL233718.

[• shankar.easwaran]

I do plan to clean those up in future. It's currently a very rudimentary solution.

[ruiu]

This is a bit tricky, but I don't think this is a bad solution. I'd support
this patch. The other way would be to use multiple inheritance to mix-in
architecture-specific member functions to the writers, but that's what I
really don't want to see.

lib/ReaderWriter/ELF/AArch64/AArch64DynamicLibraryWriter.h

-//===- lib/ReaderWriter/ELF/AArch64/AArch64DynamicLibraryWriter.h ---------===//
-//
-//                             The LLVM Linker
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-#ifndef AARCH64_DYNAMIC_LIBRARY_WRITER_H
-#define AARCH64_DYNAMIC_LIBRARY_WRITER_H
-
-#include "AArch64LinkingContext.h"
-#include "AArch64TargetHandler.h"
-#include "DynamicLibraryWriter.h"
-
-namespace lld {
-namespace elf {
-
-template <class ELFT>
-class AArch64DynamicLibraryWriter : public DynamicLibraryWriter<ELFT> {
-public:
-  AArch64DynamicLibraryWriter(AArch64LinkingContext &ctx,
-                              TargetLayout<ELFT> &layout);
-
-protected:
-  // Add any runtime files and their atoms to the output
-  void createImplicitFiles(std::vector<std::unique_ptr<File>> &) override;
-
-private:
-  class GOTFile : public SimpleFile {
-  public:
-    GOTFile(const ELFLinkingContext &eti) : SimpleFile("GOTFile") {}
-    llvm::BumpPtrAllocator _alloc;
-  };
-
-  std::unique_ptr<GOTFile> _gotFile;
-};
-
-template <class ELFT>
-AArch64DynamicLibraryWriter<ELFT>::AArch64DynamicLibraryWriter(
-    AArch64LinkingContext &ctx, TargetLayout<ELFT> &layout)
-    : DynamicLibraryWriter<ELFT>(ctx, layout), _gotFile(new GOTFile(ctx)) {}
-
-template <class ELFT>
-void AArch64DynamicLibraryWriter<ELFT>::createImplicitFiles(
-    std::vector<std::unique_ptr<File>> &result) {
-  DynamicLibraryWriter<ELFT>::createImplicitFiles(result);
-  _gotFile->addAtom(*new (_gotFile->_alloc) GlobalOffsetTableAtom(*_gotFile));
-  _gotFile->addAtom(*new (_gotFile->_alloc) DynamicAtom(*_gotFile));
-  result.push_back(std::move(_gotFile));
-}
-
-} // namespace elf
-} // namespace lld
-
-#endif

lib/ReaderWriter/ELF/AArch64/AArch64ExecutableWriter.h

 //===- lib/ReaderWriter/ELF/AArch64/AArch64ExecutableWriter.h -------------===//
 //
 //                             The LLVM Linker
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 #ifndef AARCH64_EXECUTABLE_WRITER_H
 #define AARCH64_EXECUTABLE_WRITER_H
 
-#include "AArch64LinkingContext.h"
+#include "DynamicLibraryWriter.h"
 #include "ExecutableWriter.h"
 
 namespace lld {
 namespace elf {
 
-template <class ELFT>
-class AArch64ExecutableWriter : public ExecutableWriter<ELFT> {
+template <typename ELFT>
+class AArch64OutputWriter : public OutputELFWriter<ELFT> {
 public:
-  AArch64ExecutableWriter(AArch64LinkingContext &ctx,
-                          TargetLayout<ELFT> &layout);
+  AArch64OutputWriter(ELFLinkingContext &ctx, TargetLayout<ELFT> &layout)
+      : OutputELFWriter<ELFT>(ctx, layout) {}
 
 protected:
   // Add any runtime files and their atoms to the output
   void createImplicitFiles(std::vector<std::unique_ptr<File>> &) override;
 
 private:
   class GOTFile : public SimpleFile {
   public:
     GOTFile(const ELFLinkingContext &eti) : SimpleFile("GOTFile") {}
     llvm::BumpPtrAllocator _alloc;
   };
-
-  std::unique_ptr<GOTFile> _gotFile;
 };
 
 template <class ELFT>
-AArch64ExecutableWriter<ELFT>::AArch64ExecutableWriter(
-    AArch64LinkingContext &ctx, TargetLayout<ELFT> &layout)
-    : ExecutableWriter<ELFT>(ctx, layout), _gotFile(new GOTFile(ctx)) {}
-
-template <class ELFT>
-void AArch64ExecutableWriter<ELFT>::createImplicitFiles(
+void AArch64OutputWriter<ELFT>::createImplicitFiles(
     std::vector<std::unique_ptr<File>> &result) {
-  ExecutableWriter<ELFT>::createImplicitFiles(result);
-  _gotFile->addAtom(*new (_gotFile->_alloc) GlobalOffsetTableAtom(*_gotFile));
+  OutputELFWriter<ELFT>::createImplicitFiles(result);
+  auto gotFile = llvm::make_unique<GOTFile>(this->_ctx);
+  gotFile->addAtom(*new (gotFile->_alloc) GlobalOffsetTableAtom(*gotFile));
   if (this->_ctx.isDynamic())
-    _gotFile->addAtom(*new (_gotFile->_alloc) DynamicAtom(*_gotFile));
-  result.push_back(std::move(_gotFile));
+    gotFile->addAtom(*new (gotFile->_alloc) DynamicAtom(*gotFile));
+  result.push_back(gotFile);
 }
 
+template <class ELFT>
+using AArch64DynamicLibraryWriter =
+    DynamicLibraryWriter<ELFT, AArch64OutputWriter<ELFT>>;
+
+template <class ELFT>
+using AArch64ExecutableWriter =
+    ExecutableWriter<ELFT, AArch64OutputWriter<ELFT>>;
+
 } // namespace elf
 } // namespace lld
 
 #endif

lib/ReaderWriter/ELF/AArch64/AArch64TargetHandler.cpp

 //===- lib/ReaderWriter/ELF/AArch64/AArch64TargetHandler.cpp --------------===//
 //
 //                             The LLVM Linker
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "Atoms.h"
-#include "AArch64DynamicLibraryWriter.h"
 #include "AArch64ExecutableWriter.h"
 #include "AArch64LinkingContext.h"
 #include "AArch64TargetHandler.h"
 
 using namespace lld;
 using namespace elf;
 
 AArch64TargetHandler::AArch64TargetHandler(AArch64LinkingContext &ctx)

lib/ReaderWriter/ELF/DynamicLibraryWriter.h

 namespace lld {
 namespace elf {
 using namespace llvm;
 using namespace llvm::object;
 
 //===----------------------------------------------------------------------===//
 //  DynamicLibraryWriter Class
 //===----------------------------------------------------------------------===//
-template<class ELFT>
-class DynamicLibraryWriter : public OutputELFWriter<ELFT> {
+template <class ELFT, class BaseWriter = OutputELFWriter<ELFT>>
+class DynamicLibraryWriter : public BaseWriter {
 public:
   DynamicLibraryWriter(ELFLinkingContext &ctx, TargetLayout<ELFT> &layout)
-      : OutputELFWriter<ELFT>(ctx, layout) {}
+      : BaseWriter(ctx, layout) {}
 
 protected:
   void buildDynamicSymbolTable(const File &file) override;
   void createImplicitFiles(std::vector<std::unique_ptr<File>> &) override;
   void finalizeDefaultAtomValues() override;
 };
 
 //===----------------------------------------------------------------------===//
 //  DynamicLibraryWriter
 //===----------------------------------------------------------------------===//
-template <class ELFT>
-void DynamicLibraryWriter<ELFT>::buildDynamicSymbolTable(const File &file) {
+template <class ELFT, class BaseWriter>
+void DynamicLibraryWriter<ELFT, BaseWriter>::buildDynamicSymbolTable(
+    const File &file) {
   // Add all the defined symbols to the dynamic symbol table
   // we need hooks into the Atom to find out which atoms need
   // to be exported
   for (auto sec : this->_layout.sections())
     if (auto section = dyn_cast<AtomSection<ELFT>>(sec))
       for (const auto &atom : section->atoms()) {
         const DefinedAtom *da = dyn_cast<const DefinedAtom>(atom->_atom);
         if (da && (da->scope() == DefinedAtom::scopeGlobal))
           this->_dynamicSymbolTable->addSymbol(atom->_atom, section->ordinal(),
                                                atom->_virtualAddr, atom);
       }
 
   for (const UndefinedAtom *a : file.undefined())
     this->_dynamicSymbolTable->addSymbol(a, ELF::SHN_UNDEF);
 
-  OutputELFWriter<ELFT>::buildDynamicSymbolTable(file);
+  BaseWriter::buildDynamicSymbolTable(file);
 }
 
 /// \brief Hook in lld to add CRuntime file
-template <class ELFT>
-void DynamicLibraryWriter<ELFT>::createImplicitFiles(
-    std::vector<std::unique_ptr<File> > &result) {
-  OutputELFWriter<ELFT>::createImplicitFiles(result);
+template <class ELFT, class BaseWriter>
+void DynamicLibraryWriter<ELFT, BaseWriter>::createImplicitFiles(
+    std::vector<std::unique_ptr<File>> &result) {
+  BaseWriter::createImplicitFiles(result);
   // Add the default atoms as defined by executables
   auto file = llvm::make_unique<RuntimeFile<ELFT>>(this->_ctx, "C runtime");
   file->addAbsoluteAtom("_end");
   result.push_back(std::move(file));
 }
 
-template <class ELFT>
-void DynamicLibraryWriter<ELFT>::finalizeDefaultAtomValues() {
-  OutputELFWriter<ELFT>::finalizeDefaultAtomValues();
+template <class ELFT, class BaseWriter>
+void DynamicLibraryWriter<ELFT, BaseWriter>::finalizeDefaultAtomValues() {
+  BaseWriter::finalizeDefaultAtomValues();
   lld::AtomLayout *underScoreEndAtom = this->_layout.findAbsoluteAtom("_end");
   assert(underScoreEndAtom);
 
   if (auto bssSection = this->_layout.findOutputSection(".bss")) {
     underScoreEndAtom->_virtualAddr =
         bssSection->virtualAddr() + bssSection->memSize();
   } else if (auto dataSection = this->_layout.findOutputSection(".data")) {
     underScoreEndAtom->_virtualAddr =
         dataSection->virtualAddr() + dataSection->memSize();
   }
 }
 
 } // namespace elf
 } // namespace lld
 
 #endif // LLD_READER_WRITER_ELF_DYNAMIC_LIBRARY_WRITER_H

lib/ReaderWriter/ELF/ExecutableWriter.h

 namespace lld {
 namespace elf {
 using namespace llvm;
 using namespace llvm::object;
 
 //===----------------------------------------------------------------------===//
 //  ExecutableWriter Class
 //===----------------------------------------------------------------------===//
-template<class ELFT>
-class ExecutableWriter : public OutputELFWriter<ELFT> {
+template <class ELFT, class BaseWriter = OutputELFWriter<ELFT>>
+class ExecutableWriter : public BaseWriter {
 public:
   ExecutableWriter(ELFLinkingContext &ctx, TargetLayout<ELFT> &layout)
-      : OutputELFWriter<ELFT>(ctx, layout) {}
+      : BaseWriter(ctx, layout) {}
 
 protected:
   void buildDynamicSymbolTable(const File &file) override;
   void createImplicitFiles(std::vector<std::unique_ptr<File>> &) override;
   void finalizeDefaultAtomValues() override;
   void createDefaultSections() override;
 
   bool isNeededTagRequired(const SharedLibraryAtom *sla) const override {
     return this->_layout.isCopied(sla);
   }
 
   unique_bump_ptr<InterpSection<ELFT>> _interpSection;
-
-private:
-  std::unique_ptr<RuntimeFile<ELFT>> createRuntimeFile();
 };
 
 //===----------------------------------------------------------------------===//
 //  ExecutableWriter
 //===----------------------------------------------------------------------===//
-template<class ELFT>
-void ExecutableWriter<ELFT>::buildDynamicSymbolTable(const File &file) {
+template <class ELFT, class BaseWriter>
+void ExecutableWriter<ELFT, BaseWriter>::buildDynamicSymbolTable(
+    const File &file) {
   for (auto sec : this->_layout.sections())
     if (auto section = dyn_cast<AtomSection<ELFT>>(sec))
       for (const auto &atom : section->atoms()) {
         const DefinedAtom *da = dyn_cast<const DefinedAtom>(atom->_atom);
         if (!da)
           continue;
         if (da->dynamicExport() != DefinedAtom::dynamicExportAlways &&
             !this->_ctx.isDynamicallyExportedSymbol(da->name()) &&
             !(this->_ctx.shouldExportDynamic() &&
               da->scope() == Atom::Scope::scopeGlobal))
           continue;
         this->_dynamicSymbolTable->addSymbol(atom->_atom, section->ordinal(),
                                              atom->_virtualAddr, atom);
       }
 
   // Put weak symbols in the dynamic symbol table.
   if (this->_ctx.isDynamic()) {
     for (const UndefinedAtom *a : file.undefined()) {
       if (this->_layout.isReferencedByDefinedAtom(a) &&
           a->canBeNull() != UndefinedAtom::canBeNullNever)
         this->_dynamicSymbolTable->addSymbol(a, ELF::SHN_UNDEF);
     }
   }
 
-  OutputELFWriter<ELFT>::buildDynamicSymbolTable(file);
+  BaseWriter::buildDynamicSymbolTable(file);
 }
 
-template<class ELFT>
-std::unique_ptr<RuntimeFile<ELFT>> ExecutableWriter<ELFT>::createRuntimeFile() {
+/// \brief Hook in lld to add CRuntime file
+template <class ELFT, class BaseWriter>
+void ExecutableWriter<ELFT, BaseWriter>::createImplicitFiles(
+    std::vector<std::unique_ptr<File>> &result) {
+  BaseWriter::createImplicitFiles(result);
   auto file = llvm::make_unique<RuntimeFile<ELFT>>(this->_ctx, "C runtime");
   file->addUndefinedAtom(this->_ctx.entrySymbolName());
   file->addAbsoluteAtom("__bss_start");
   file->addAbsoluteAtom("__bss_end");
   file->addAbsoluteAtom("_end");
   file->addAbsoluteAtom("end");
   file->addAbsoluteAtom("__preinit_array_start");
   file->addAbsoluteAtom("__preinit_array_end");
   file->addAbsoluteAtom("__init_array_start");
   file->addAbsoluteAtom("__init_array_end");
   if (this->_ctx.isRelaOutputFormat()) {
     file->addAbsoluteAtom("__rela_iplt_start");
     file->addAbsoluteAtom("__rela_iplt_end");
   } else {
     file->addAbsoluteAtom("__rel_iplt_start");
     file->addAbsoluteAtom("__rel_iplt_end");
   }
   file->addAbsoluteAtom("__fini_array_start");
   file->addAbsoluteAtom("__fini_array_end");
-  return file;
-}
-
-/// \brief Hook in lld to add CRuntime file
-template <class ELFT>
-void ExecutableWriter<ELFT>::createImplicitFiles(
-    std::vector<std::unique_ptr<File> > &result) {
-  OutputELFWriter<ELFT>::createImplicitFiles(result);
-  result.push_back(createRuntimeFile());
+  result.push_back(std::move(file));
 }
 
-template <class ELFT> void ExecutableWriter<ELFT>::createDefaultSections() {
-  OutputELFWriter<ELFT>::createDefaultSections();
+template <class ELFT, class BaseWriter>
+void ExecutableWriter<ELFT, BaseWriter>::createDefaultSections() {
+  BaseWriter::createDefaultSections();
   if (this->_ctx.isDynamic()) {
     _interpSection.reset(new (this->_alloc) InterpSection<ELFT>(
         this->_ctx, ".interp", TargetLayout<ELFT>::ORDER_INTERP,
         this->_ctx.getInterpreter()));
     this->_layout.addSection(_interpSection.get());
   }
 }
 
 /// Finalize the value of all the absolute symbols that we
 /// created
-template <class ELFT> void ExecutableWriter<ELFT>::finalizeDefaultAtomValues() {
-  OutputELFWriter<ELFT>::finalizeDefaultAtomValues();
+template <class ELFT, class BaseWriter>
+void ExecutableWriter<ELFT, BaseWriter>::finalizeDefaultAtomValues() {
+  BaseWriter::finalizeDefaultAtomValues();
   AtomLayout *bssStartAtom = this->_layout.findAbsoluteAtom("__bss_start");
   AtomLayout *bssEndAtom = this->_layout.findAbsoluteAtom("__bss_end");
   AtomLayout *underScoreEndAtom = this->_layout.findAbsoluteAtom("_end");
   AtomLayout *endAtom = this->_layout.findAbsoluteAtom("end");
 
   assert((bssStartAtom || bssEndAtom || underScoreEndAtom || endAtom) &&
          "Unable to find the absolute atoms that have been added by lld");
 

lib/ReaderWriter/ELF/Hexagon/HexagonDynamicLibraryWriter.h

-//===- lib/ReaderWriter/ELF/Hexagon/HexagonDynamicLibraryWriter.h ---------===//
-//
-//                             The LLVM Linker
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-#ifndef HEXAGON_DYNAMIC_LIBRARY_WRITER_H
-#define HEXAGON_DYNAMIC_LIBRARY_WRITER_H
-
-#include "DynamicLibraryWriter.h"
-#include "HexagonExecutableAtoms.h"
-#include "HexagonLinkingContext.h"
-
-namespace lld {
-namespace elf {
-
-template <typename ELFT> class HexagonTargetLayout;
-
-template <class ELFT>
-class HexagonDynamicLibraryWriter : public DynamicLibraryWriter<ELFT> {
-public:
-  HexagonDynamicLibraryWriter(HexagonLinkingContext &ctx,
-                              HexagonTargetLayout<ELFT> &layout);
-
-protected:
-  // Add any runtime files and their atoms to the output
-  void createImplicitFiles(std::vector<std::unique_ptr<File>> &) override;
-
-  void finalizeDefaultAtomValues() override;
-
-  std::error_code setELFHeader() override {
-    DynamicLibraryWriter<ELFT>::setELFHeader();
-    setHexagonELFHeader(*this->_elfHeader);
-    return std::error_code();
-  }
-
-private:
-  HexagonLinkingContext &_ctx;
-  HexagonTargetLayout<ELFT> &_targetLayout;
-};
-
-template <class ELFT>
-HexagonDynamicLibraryWriter<ELFT>::HexagonDynamicLibraryWriter(
-    HexagonLinkingContext &ctx, HexagonTargetLayout<ELFT> &layout)
-    : DynamicLibraryWriter<ELFT>(ctx, layout), _ctx(ctx),
-      _targetLayout(layout) {}
-
-template <class ELFT>
-void HexagonDynamicLibraryWriter<ELFT>::createImplicitFiles(
-    std::vector<std::unique_ptr<File>> &result) {
-  DynamicLibraryWriter<ELFT>::createImplicitFiles(result);
-  // Add the default atoms as defined for hexagon
-  auto file = llvm::make_unique<HexagonRuntimeFile<ELFT>>(_ctx);
-  file->addAbsoluteAtom("_GLOBAL_OFFSET_TABLE_");
-  file->addAbsoluteAtom("_DYNAMIC");
-  result.push_back(std::move(file));
-}
-
-template <class ELFT>
-void HexagonDynamicLibraryWriter<ELFT>::finalizeDefaultAtomValues() {
-  // Finalize the atom values that are part of the parent.
-  DynamicLibraryWriter<ELFT>::finalizeDefaultAtomValues();
-  if (_ctx.isDynamic())
-    finalizeHexagonRuntimeAtomValues(_targetLayout);
-}
-
-} // namespace elf
-} // namespace lld
-
-#endif // HEXAGON_DYNAMIC_LIBRARY_WRITER_H

lib/ReaderWriter/ELF/Hexagon/HexagonExecutableWriter.h

 //===- lib/ReaderWriter/ELF/Hexagon/HexagonExecutableWriter.h -------------===//
 //
 //                             The LLVM Linker
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 #ifndef HEXAGON_EXECUTABLE_WRITER_H
 #define HEXAGON_EXECUTABLE_WRITER_H
 
+#include "DynamicLibraryWriter.h"
 #include "ExecutableWriter.h"
 #include "HexagonExecutableAtoms.h"
 #include "HexagonLinkingContext.h"
 
 namespace lld {
 namespace elf {
 
 template <typename ELFT> class HexagonTargetLayout;
 
-template <class ELFT>
-class HexagonExecutableWriter : public ExecutableWriter<ELFT> {
+template <typename ELFT>
+class HexagonOutputWriter : public OutputELFWriter<ELFT> {
 public:
-  HexagonExecutableWriter(HexagonLinkingContext &ctx,
-                          HexagonTargetLayout<ELFT> &layout);
+  HexagonOutputWriter(ELFLinkingContext &ctx, TargetLayout<ELFT> &layout)
+      : OutputELFWriter<ELFT>(ctx, layout) {}
 
 protected:
-  // Add any runtime files and their atoms to the output
-  void createImplicitFiles(std::vector<std::unique_ptr<File>> &) override;
+  virtual std::unique_ptr<HexagonRuntimeFile<ELFT>> createRuntimeFile();
 
+  void createImplicitFiles(std::vector<std::unique_ptr<File>> &) override;
   void finalizeDefaultAtomValues() override;
+  std::error_code setELFHeader() override;
+};
 
-  std::error_code setELFHeader() override {
-    ExecutableWriter<ELFT>::setELFHeader();
-    setHexagonELFHeader(*this->_elfHeader);
-    return std::error_code();
-  }
+template <class ELFT>
+std::unique_ptr<HexagonRuntimeFile<ELFT>>
+HexagonOutputWriter<ELFT>::createRuntimeFile() {
+  auto &ctx = static_cast<HexagonLinkingContext &>(this->_ctx);
+  auto file = llvm::make_unique<HexagonRuntimeFile<ELFT>>(ctx);
+  if (this->_ctx.isDynamic()) {
+    file->addAbsoluteAtom("_GLOBAL_OFFSET_TABLE_");
+    file->addAbsoluteAtom("_DYNAMIC");
+  }
+  return file;
 
-private:
-  HexagonLinkingContext &_ctx;
-  HexagonTargetLayout<ELFT> &_targetLayout;
-};
+template <class ELFT>
+void HexagonOutputWriter<ELFT>::createImplicitFiles(
+    std::vector<std::unique_ptr<File>> &result) {
+  OutputELFWriter<ELFT>::createImplicitFiles(result);
+  result.push_back(createRuntimeFile());
+}
+
+template <class ELFT>
+void HexagonOutputWriter<ELFT>::finalizeDefaultAtomValues() {
+  OutputELFWriter<ELFT>::finalizeDefaultAtomValues();
+  if (!this->_ctx.isDynamic())
+    return;
+  AtomLayout *gotAtom = this->_layout.findAbsoluteAtom("_GLOBAL_OFFSET_TABLE_");
+  OutputSection<ELFT> *gotpltSection =
+      this->_layout.findOutputSection(".got.plt");
+  if (gotpltSection)
+    gotAtom->_virtualAddr = gotpltSection->virtualAddr();
+  else
+    gotAtom->_virtualAddr = 0;
+  AtomLayout *dynamicAtom = this->_layout.findAbsoluteAtom("_DYNAMIC");
+  OutputSection<ELFT> *dynamicSection =
+      this->_layout.findOutputSection(".dynamic");
+  if (dynamicSection)
+    dynamicAtom->_virtualAddr = dynamicSection->virtualAddr();
+  else
+    dynamicAtom->_virtualAddr = 0;
+}
 
 template <class ELFT>
-HexagonExecutableWriter<ELFT>::HexagonExecutableWriter(
-    HexagonLinkingContext &ctx, HexagonTargetLayout<ELFT> &layout)
-    : ExecutableWriter<ELFT>(ctx, layout), _ctx(ctx), _targetLayout(layout) {}
+std::error_code HexagonOutputWriter<ELFT>::setELFHeader() {
+  if (std::error_code ec = OutputELFWriter<ELFT>::setELFHeader())
+    return ec;
+  this->_elfHeader->e_ident(llvm::ELF::EI_VERSION, 1);
+  this->_elfHeader->e_ident(llvm::ELF::EI_OSABI, 0);
+  this->_elfHeader->e_version(1);
+  this->_elfHeader->e_flags(0x3);
+  return std::error_code();
+}
 
 template <class ELFT>
-void HexagonExecutableWriter<ELFT>::createImplicitFiles(
-    std::vector<std::unique_ptr<File>> &result) {
-  ExecutableWriter<ELFT>::createImplicitFiles(result);
-  // Add the default atoms as defined for hexagon
-  auto file = llvm::make_unique<HexagonRuntimeFile<ELFT>>(_ctx);
+class HexagonExecutableWriter
+    : public ExecutableWriter<ELFT, HexagonOutputWriter<ELFT>> {
+  typedef ExecutableWriter<ELFT, HexagonOutputWriter<ELFT>> BaseWriter;
+
+public:
+  HexagonExecutableWriter(ELFLinkingContext &ctx, TargetLayout<ELFT> &layout)
+      : BaseWriter(ctx, layout) {}
+
+protected:
+  std::unique_ptr<HexagonRuntimeFile<ELFT>> createRuntimeFile() override {
+    auto file = BaseWriter::createRuntimeFile();
     file->addAbsoluteAtom("_SDA_BASE_");
-  if (this->_ctx.isDynamic()) {
-    file->addAbsoluteAtom("_GLOBAL_OFFSET_TABLE_");
-    file->addAbsoluteAtom("_DYNAMIC");
+    return file;
   }
-  result.push_back(std::move(file));
+
+  void finalizeDefaultAtomValues() override {
+    BaseWriter::finalizeDefaultAtomValues();
+    auto &layout = static_cast<HexagonTargetLayout<ELFT> &>(this->_layout);
+    AtomLayout *sdabaseAtom = layout.findAbsoluteAtom("_SDA_BASE_");
+    sdabaseAtom->_virtualAddr = layout.getSDataSection()->virtualAddr();
   }
+};
 
 template <class ELFT>
-void HexagonExecutableWriter<ELFT>::finalizeDefaultAtomValues() {
-  // Finalize the atom values that are part of the parent.
-  ExecutableWriter<ELFT>::finalizeDefaultAtomValues();
-  AtomLayout *sdabaseAtom = _targetLayout.findAbsoluteAtom("_SDA_BASE_");
-  sdabaseAtom->_virtualAddr = _targetLayout.getSDataSection()->virtualAddr();
-  if (_ctx.isDynamic())
-    finalizeHexagonRuntimeAtomValues(_targetLayout);
-}
+using HexagonDynamicLibraryWriter =
+    DynamicLibraryWriter<ELFT, HexagonOutputWriter<ELFT>>;
 
 } // namespace elf
 } // namespace lld
 
 #endif // HEXAGON_EXECUTABLE_WRITER_H

lib/ReaderWriter/ELF/Hexagon/HexagonLinkingContext.h

bool isRelativeReloc(const Reference &r) const override {
     case llvm::ELF::R_HEX_RELATIVE:
       return true;
     default:
       return false;
     }
   }
 };
 
-template <class ELFT> void setHexagonELFHeader(ELFHeader<ELFT> &elfHeader) {
-  elfHeader.e_ident(llvm::ELF::EI_VERSION, 1);
-  elfHeader.e_ident(llvm::ELF::EI_OSABI, 0);
-  elfHeader.e_version(1);
-  elfHeader.e_flags(0x3);
-}
-
 } // elf
 } // lld
 
 #endif // LLD_READER_WRITER_ELF_HEXAGON_HEXAGON_LINKING_CONTEXT_H

lib/ReaderWriter/ELF/Hexagon/HexagonTargetHandler.h

 
 private:
   HexagonLinkingContext &_ctx;
   std::unique_ptr<HexagonRuntimeFile<ELFTy>> _runtimeFile;
   std::unique_ptr<HexagonTargetLayout<ELFTy>> _targetLayout;
   std::unique_ptr<HexagonTargetRelocationHandler> _relocationHandler;
 };
 
-template <class ELFT>
-void finalizeHexagonRuntimeAtomValues(HexagonTargetLayout<ELFT> &layout) {
-  AtomLayout *gotAtom = layout.findAbsoluteAtom("_GLOBAL_OFFSET_TABLE_");
-  OutputSection<ELFT> *gotpltSection = layout.findOutputSection(".got.plt");
-  if (gotpltSection)
-    gotAtom->_virtualAddr = gotpltSection->virtualAddr();
-  else
-    gotAtom->_virtualAddr = 0;
-  AtomLayout *dynamicAtom = layout.findAbsoluteAtom("_DYNAMIC");
-  OutputSection<ELFT> *dynamicSection = layout.findOutputSection(".dynamic");
-  if (dynamicSection)
-    dynamicAtom->_virtualAddr = dynamicSection->virtualAddr();
-  else
-    dynamicAtom->_virtualAddr = 0;
-}
-
 } // end namespace elf
 } // end namespace lld
 
 #endif

lib/ReaderWriter/ELF/Hexagon/HexagonTargetHandler.cpp

 //===- lib/ReaderWriter/ELF/Hexagon/HexagonTargetHandler.cpp --------------===//
 //
 //                             The LLVM Linker
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "HexagonExecutableWriter.h"
-#include "HexagonDynamicLibraryWriter.h"
 #include "HexagonLinkingContext.h"
 #include "HexagonTargetHandler.h"
 
 using namespace lld;
 using namespace elf;
 using namespace llvm::ELF;
 
 using llvm::makeArrayRef;

lib/ReaderWriter/ELF/Mips/MipsDynamicLibraryWriter.h

 //===- lib/ReaderWriter/ELF/Mips/MipsDynamicLibraryWriter.h ---------------===//
 //
 //                             The LLVM Linker
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 #ifndef LLD_READER_WRITER_ELF_MIPS_MIPS_DYNAMIC_LIBRARY_WRITER_H
 #define LLD_READER_WRITER_ELF_MIPS_MIPS_DYNAMIC_LIBRARY_WRITER_H
 
 #include "DynamicLibraryWriter.h"
-#include "MipsDynamicTable.h"
 #include "MipsELFWriters.h"
-#include "MipsLinkingContext.h"
-#include "MipsSectionChunks.h"
 
 namespace lld {
 namespace elf {
 
-template <typename ELFT> class MipsSymbolTable;
-template <typename ELFT> class MipsDynamicSymbolTable;
-template <typename ELFT> class MipsTargetLayout;
-
-template <class ELFT>
-class MipsDynamicLibraryWriter : public DynamicLibraryWriter<ELFT> {
-public:
-  MipsDynamicLibraryWriter(MipsLinkingContext &ctx,
-                           MipsTargetLayout<ELFT> &layout);
-
-protected:
-  // Add any runtime files and their atoms to the output
-  void createImplicitFiles(std::vector<std::unique_ptr<File>> &) override;
-
-  void finalizeDefaultAtomValues() override;
-  void createDefaultSections() override;
-
-  std::error_code setELFHeader() override {
-    DynamicLibraryWriter<ELFT>::setELFHeader();
-    _writeHelper.setELFHeader(*this->_elfHeader);
-    return std::error_code();
-  }
-
-  unique_bump_ptr<SymbolTable<ELFT>> createSymbolTable() override;
-  unique_bump_ptr<DynamicTable<ELFT>> createDynamicTable() override;
-  unique_bump_ptr<DynamicSymbolTable<ELFT>> createDynamicSymbolTable() override;
-
-private:
-  MipsELFWriter<ELFT> _writeHelper;
-  MipsTargetLayout<ELFT> &_targetLayout;
-  unique_bump_ptr<Section<ELFT>> _reginfo;
-};
-
-template <class ELFT>
-MipsDynamicLibraryWriter<ELFT>::MipsDynamicLibraryWriter(
-    MipsLinkingContext &ctx, MipsTargetLayout<ELFT> &layout)
-    : DynamicLibraryWriter<ELFT>(ctx, layout), _writeHelper(ctx, layout),
-      _targetLayout(layout) {}
-
-template <class ELFT>
-void MipsDynamicLibraryWriter<ELFT>::createImplicitFiles(
-    std::vector<std::unique_ptr<File>> &result) {
-  DynamicLibraryWriter<ELFT>::createImplicitFiles(result);
-  result.push_back(std::move(_writeHelper.createRuntimeFile()));
-}
-
-template <class ELFT>
-void MipsDynamicLibraryWriter<ELFT>::finalizeDefaultAtomValues() {
-  // Finalize the atom values that are part of the parent.
-  DynamicLibraryWriter<ELFT>::finalizeDefaultAtomValues();
-  _writeHelper.finalizeMipsRuntimeAtomValues();
-}
-
-template <class ELFT>
-void MipsDynamicLibraryWriter<ELFT>::createDefaultSections() {
-  DynamicLibraryWriter<ELFT>::createDefaultSections();
-  const auto &ctx = static_cast<const MipsLinkingContext &>(this->_ctx);
-  const auto &mask = ctx.getMergedReginfoMask();
-  if (!mask.hasValue())
-    return;
-  if (ELFT::Is64Bits)
-    _reginfo = unique_bump_ptr<Section<ELFT>>(
-        new (this->_alloc) MipsOptionsSection<ELFT>(ctx, _targetLayout, *mask));
-  else
-    _reginfo = unique_bump_ptr<Section<ELFT>>(
-        new (this->_alloc) MipsReginfoSection<ELFT>(ctx, _targetLayout, *mask));
-  this->_layout.addSection(_reginfo.get());
-}
-
-template <class ELFT>
-unique_bump_ptr<SymbolTable<ELFT>>
-    MipsDynamicLibraryWriter<ELFT>::createSymbolTable() {
-  return unique_bump_ptr<SymbolTable<ELFT>>(
-      new (this->_alloc) MipsSymbolTable<ELFT>(this->_ctx));
-}
-
-/// \brief create dynamic table
-template <class ELFT>
-unique_bump_ptr<DynamicTable<ELFT>>
-    MipsDynamicLibraryWriter<ELFT>::createDynamicTable() {
-  return unique_bump_ptr<DynamicTable<ELFT>>(
-      new (this->_alloc) MipsDynamicTable<ELFT>(this->_ctx, _targetLayout));
-}
-
-/// \brief create dynamic symbol table
 template <class ELFT>
-unique_bump_ptr<DynamicSymbolTable<ELFT>>
-    MipsDynamicLibraryWriter<ELFT>::createDynamicSymbolTable() {
-  return unique_bump_ptr<DynamicSymbolTable<ELFT>>(
-      new (this->_alloc)
-          MipsDynamicSymbolTable<ELFT>(this->_ctx, _targetLayout));
-}
+using MipsDynamicLibraryWriter =
+    DynamicLibraryWriter<ELFT, MipsOutputWriter<ELFT>>;
 
 } // namespace elf
 } // namespace lld
 
 #endif

lib/ReaderWriter/ELF/Mips/MipsELFWriters.h

 //===- lib/ReaderWriter/ELF/Mips/MipsELFWriters.h -------------------------===//
 //
 //                             The LLVM Linker
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 #ifndef LLD_READER_WRITER_ELF_MIPS_MIPS_ELF_WRITERS_H
 #define LLD_READER_WRITER_ELF_MIPS_MIPS_ELF_WRITERS_H
 
 #include "MipsLinkingContext.h"
+#include "MipsSectionChunks.h"
+#include "OutputELFWriter.h"
 
 namespace lld {
 namespace elf {
 
+template <class ELFT> class MipsDynamicSymbolTable;
+template <class ELFT> class MipsDynamicTable;
+template <class ELFT> class MipsSymbolTable;
 template <class ELFT> class MipsTargetLayout;
 
-template <typename ELFT> class MipsELFWriter {
+template <typename ELFT> class MipsOutputWriter : public OutputELFWriter<ELFT> {
 public:
-  MipsELFWriter(MipsLinkingContext &ctx, MipsTargetLayout<ELFT> &targetLayout)
-      : _ctx(ctx), _targetLayout(targetLayout) {}
+  MipsOutputWriter(ELFLinkingContext &ctx, TargetLayout<ELFT> &layout)
+      : OutputELFWriter<ELFT>(ctx, layout) {}
 
-  void setELFHeader(ELFHeader<ELFT> &elfHeader) {
-    elfHeader.e_version(1);
-    elfHeader.e_ident(llvm::ELF::EI_VERSION, llvm::ELF::EV_CURRENT);
-    elfHeader.e_ident(llvm::ELF::EI_OSABI, llvm::ELF::ELFOSABI_NONE);
-    if (_targetLayout.findOutputSection(".got.plt"))
-      elfHeader.e_ident(llvm::ELF::EI_ABIVERSION, 1);
+protected:
+  std::error_code setELFHeader() override {
+    if (std::error_code ec = OutputELFWriter<ELFT>::setELFHeader())
+      return ec;
+
+    this->_elfHeader->e_version(1);
+    this->_elfHeader->e_ident(llvm::ELF::EI_VERSION, llvm::ELF::EV_CURRENT);
+    this->_elfHeader->e_ident(llvm::ELF::EI_OSABI, llvm::ELF::ELFOSABI_NONE);
+    if (this->_layout.findOutputSection(".got.plt"))
+      this->_elfHeader->e_ident(llvm::ELF::EI_ABIVERSION, 1);
     else
-      elfHeader.e_ident(llvm::ELF::EI_ABIVERSION, 0);
+      this->_elfHeader->e_ident(llvm::ELF::EI_ABIVERSION, 0);
 
-    elfHeader.e_flags(_ctx.getMergedELFFlags());
+    this->_elfHeader->e_flags(getCtx().getMergedELFFlags());
+    return std::error_code();
   }
 
-  void finalizeMipsRuntimeAtomValues() {
-    if (!_ctx.isDynamic())
+  void finalizeDefaultAtomValues() override {
+    OutputELFWriter<ELFT>::finalizeDefaultAtomValues();
+    if (!this->_ctx.isDynamic())
       return;
 
-    auto gotSection = _targetLayout.findOutputSection(".got");
+    auto gotSection = this->_layout.findOutputSection(".got");
     auto got = gotSection ? gotSection->virtualAddr() : 0;
-    auto gp = gotSection ? got + _targetLayout.getGPOffset() : 0;
+    auto gp = gotSection ? got + getLayout().getGPOffset() : 0;
 
     setAtomValue("_GLOBAL_OFFSET_TABLE_", got);
     setAtomValue("_gp", gp);
     setAtomValue("_gp_disp", gp);
     setAtomValue("__gnu_local_gp", gp);
   }
 
-  std::unique_ptr<RuntimeFile<ELFT>> createRuntimeFile() {
-    auto file = llvm::make_unique<RuntimeFile<ELFT>>(_ctx, "Mips runtime file");
-    if (_ctx.isDynamic()) {
-      file->addAbsoluteAtom("_GLOBAL_OFFSET_TABLE_");
-      file->addAbsoluteAtom("_gp");
-      file->addAbsoluteAtom("_gp_disp");
-      file->addAbsoluteAtom("__gnu_local_gp");
-    }
-    return file;
+  void
+  createImplicitFiles(std::vector<std::unique_ptr<File>> &result) override {
+    OutputELFWriter<ELFT>::createImplicitFiles(result);
+    if (!this->_ctx.isDynamic())
+      return;
+    auto file =
+        llvm::make_unique<RuntimeFile<ELFT>>(this->_ctx, "Mips runtime file");
+    result.push_back(std::move(file));
+  }
+
+  void createDefaultSections() override {
+    OutputELFWriter<ELFT>::createDefaultSections();
+    const auto &mask = getCtx().getMergedReginfoMask();
+    if (!mask.hasValue())
+      return;
+    if (ELFT::Is64Bits)
+      _reginfo = unique_bump_ptr<Section<ELFT>>(new (
+          this->_alloc) MipsOptionsSection<ELFT>(getCtx(), getLayout(), *mask));
+    else
+      _reginfo = unique_bump_ptr<Section<ELFT>>(new (
+          this->_alloc) MipsReginfoSection<ELFT>(getCtx(), getLayout(), *mask));
+    this->_layout.addSection(_reginfo.get());
+  }
+
+  unique_bump_ptr<SymbolTable<ELFT>> createSymbolTable() override {
+    return unique_bump_ptr<SymbolTable<ELFT>>(
+        new (this->_alloc) MipsSymbolTable<ELFT>(this->_ctx));
+
+  unique_bump_ptr<DynamicTable<ELFT>> createDynamicTable() override {
+    return unique_bump_ptr<DynamicTable<ELFT>>(
+        new (this->_alloc) MipsDynamicTable<ELFT>(this->_ctx, getLayout()));
+  }
+
+  unique_bump_ptr<DynamicSymbolTable<ELFT>>
+  createDynamicSymbolTable() override {
+    return unique_bump_ptr<DynamicSymbolTable<ELFT>>(new (
+        this->_alloc) MipsDynamicSymbolTable<ELFT>(this->_ctx, getLayout()));
   }
 
 private:
-  MipsLinkingContext &_ctx;
-  MipsTargetLayout<ELFT> &_targetLayout;
+  unique_bump_ptr<Section<ELFT>> _reginfo;
 
   void setAtomValue(StringRef name, uint64_t value) {
-    AtomLayout *atom = _targetLayout.findAbsoluteAtom(name);
+    AtomLayout *atom = this->_layout.findAbsoluteAtom(name);
     assert(atom);
     atom->_virtualAddr = value;
   }
+
+  const MipsLinkingContext &getCtx() const {
+    return static_cast<const MipsLinkingContext &>(this->_ctx);
+  }
+
+  MipsTargetLayout<ELFT> &getLayout() {
+    return static_cast<MipsTargetLayout<ELFT> &>(this->_layout);
+  }
 };
 
 } // elf
 } // lld
 
 #endif

lib/ReaderWriter/ELF/Mips/MipsExecutableWriter.h

 #include "MipsLinkingContext.h"
 
 namespace lld {
 namespace elf {
 
 template <typename ELFT> class MipsTargetLayout;
 
 template <class ELFT>
-class MipsExecutableWriter : public ExecutableWriter<ELFT> {
+class MipsExecutableWriter
+    : public ExecutableWriter<ELFT, MipsOutputWriter<ELFT>> {
+  typedef ExecutableWriter<ELFT, MipsOutputWriter<ELFT>> BaseWriter;
+
 public:
   MipsExecutableWriter(MipsLinkingContext &ctx, MipsTargetLayout<ELFT> &layout);
 
 protected:
   void buildDynamicSymbolTable(const File &file) override;
-
-  // Add any runtime files and their atoms to the output
-  void createImplicitFiles(std::vector<std::unique_ptr<File>> &) override;
-
-  void finalizeDefaultAtomValues() override;
-  void createDefaultSections() override;
   std::error_code setELFHeader() override;
-
-  unique_bump_ptr<SymbolTable<ELFT>> createSymbolTable() override;
-  unique_bump_ptr<DynamicTable<ELFT>> createDynamicTable() override;
-  unique_bump_ptr<DynamicSymbolTable<ELFT>> createDynamicSymbolTable() override;
-
-private:
-  MipsELFWriter<ELFT> _writeHelper;
-  MipsTargetLayout<ELFT> &_targetLayout;
-  unique_bump_ptr<Section<ELFT>> _reginfo;
 };
 
 template <class ELFT>
 MipsExecutableWriter<ELFT>::MipsExecutableWriter(MipsLinkingContext &ctx,
                                                  MipsTargetLayout<ELFT> &layout)
-    : ExecutableWriter<ELFT>(ctx, layout), _writeHelper(ctx, layout),
-      _targetLayout(layout) {}
+    : BaseWriter(ctx, layout) {}
 
 template <class ELFT>
 std::error_code MipsExecutableWriter<ELFT>::setELFHeader() {
-  std::error_code ec = ExecutableWriter<ELFT>::setELFHeader();
+  std::error_code ec = BaseWriter::setELFHeader();
   if (ec)
     return ec;
 
   StringRef entryName = this->_ctx.entrySymbolName();
   if (const AtomLayout *al = this->_layout.findAtomLayoutByName(entryName)) {
     const auto *ea = cast<DefinedAtom>(al->_atom);
     if (ea->codeModel() == DefinedAtom::codeMipsMicro ||
         ea->codeModel() == DefinedAtom::codeMipsMicroPIC)
       // Adjust entry symbol value if this symbol is microMIPS encoded.
       this->_elfHeader->e_entry(al->_virtualAddr | 1);
   }
-
-  _writeHelper.setELFHeader(*this->_elfHeader);
   return std::error_code();
 }
 
 template <class ELFT>
 void MipsExecutableWriter<ELFT>::buildDynamicSymbolTable(const File &file) {
+  auto &layout = static_cast<MipsTargetLayout<ELFT> &>(this->_layout);
   // MIPS ABI requires to add to dynsym even undefined symbols
   // if they have a corresponding entries in a global part of GOT.
   for (auto sec : this->_layout.sections())
     if (auto section = dyn_cast<AtomSection<ELFT>>(sec))
       for (const auto &atom : section->atoms()) {
-        if (_targetLayout.getGOTSection().hasGlobalGOTEntry(atom->_atom)) {
+        if (layout.getGOTSection().hasGlobalGOTEntry(atom->_atom)) {
           this->_dynamicSymbolTable->addSymbol(atom->_atom, section->ordinal(),
                                                atom->_virtualAddr, atom);
           continue;
         }
 
         const DefinedAtom *da = dyn_cast<const DefinedAtom>(atom->_atom);
         if (!da)
           continue;
 
         if (da->dynamicExport() != DefinedAtom::dynamicExportAlways &&
             !this->_ctx.isDynamicallyExportedSymbol(da->name()) &&
             !(this->_ctx.shouldExportDynamic() &&
               da->scope() == Atom::Scope::scopeGlobal))
           continue;
 
         this->_dynamicSymbolTable->addSymbol(atom->_atom, section->ordinal(),
                                              atom->_virtualAddr, atom);
       }
 
   for (const UndefinedAtom *a : file.undefined())
     // FIXME (simon): Consider to move this check to the
     // MipsELFUndefinedAtom class method. That allows to
     // handle more complex coditions in the future.
-    if (_targetLayout.getGOTSection().hasGlobalGOTEntry(a))
+    if (layout.getGOTSection().hasGlobalGOTEntry(a))
       this->_dynamicSymbolTable->addSymbol(a, ELF::SHN_UNDEF);
 
   // Skip our immediate parent class method
   // ExecutableWriter<ELFT>::buildDynamicSymbolTable because we replaced it
-  // with our own version. Call OutputELFWriter directly.
-  OutputELFWriter<ELFT>::buildDynamicSymbolTable(file);
-}
-
-template <class ELFT>
-void MipsExecutableWriter<ELFT>::createImplicitFiles(
-    std::vector<std::unique_ptr<File>> &result) {
-  ExecutableWriter<ELFT>::createImplicitFiles(result);
-  result.push_back(std::move(_writeHelper.createRuntimeFile()));
-}
-
-template <class ELFT>
-void MipsExecutableWriter<ELFT>::finalizeDefaultAtomValues() {
-  // Finalize the atom values that are part of the parent.
-  ExecutableWriter<ELFT>::finalizeDefaultAtomValues();
-  _writeHelper.finalizeMipsRuntimeAtomValues();
-}
-
-template <class ELFT> void MipsExecutableWriter<ELFT>::createDefaultSections() {
-  ExecutableWriter<ELFT>::createDefaultSections();
-  const auto &ctx = static_cast<const MipsLinkingContext &>(this->_ctx);
-  const auto &mask = ctx.getMergedReginfoMask();
-  if (!mask.hasValue())
-    return;
-  if (ELFT::Is64Bits)
-    _reginfo = unique_bump_ptr<Section<ELFT>>(
-        new (this->_alloc) MipsOptionsSection<ELFT>(ctx, _targetLayout, *mask));
-  else
-    _reginfo = unique_bump_ptr<Section<ELFT>>(
-        new (this->_alloc) MipsReginfoSection<ELFT>(ctx, _targetLayout, *mask));
-  this->_layout.addSection(_reginfo.get());
-}
-
-template <class ELFT>
-unique_bump_ptr<SymbolTable<ELFT>>
-    MipsExecutableWriter<ELFT>::createSymbolTable() {
-  return unique_bump_ptr<SymbolTable<ELFT>>(
-      new (this->_alloc) MipsSymbolTable<ELFT>(this->_ctx));
-}
-
-/// \brief create dynamic table
-template <class ELFT>
-unique_bump_ptr<DynamicTable<ELFT>>
-    MipsExecutableWriter<ELFT>::createDynamicTable() {
-  return unique_bump_ptr<DynamicTable<ELFT>>(
-      new (this->_alloc) MipsDynamicTable<ELFT>(this->_ctx, _targetLayout));
-}
-
-/// \brief create dynamic symbol table
-template <class ELFT>
-unique_bump_ptr<DynamicSymbolTable<ELFT>>
-    MipsExecutableWriter<ELFT>::createDynamicSymbolTable() {
-  return unique_bump_ptr<DynamicSymbolTable<ELFT>>(
-      new (this->_alloc)
-          MipsDynamicSymbolTable<ELFT>(this->_ctx, _targetLayout));
+  // with our own version. Call MipsOutputWriter directly.
+  MipsOutputWriter<ELFT>::buildDynamicSymbolTable(file);
 }
 
 } // namespace elf
 } // namespace lld
 
 #endif

lib/ReaderWriter/ELF/X86/X86DynamicLibraryWriter.h

 #include "X86LinkingContext.h"
 
 namespace lld {
 namespace elf {
 
 template <class ELFT>
 class X86DynamicLibraryWriter : public DynamicLibraryWriter<ELFT> {
 public:
-  X86DynamicLibraryWriter(X86LinkingContext &ctx, TargetLayout<ELFT> &layout);
+  X86DynamicLibraryWriter(X86LinkingContext &ctx, TargetLayout<ELFT> &layout)
+      : DynamicLibraryWriter<ELFT>(ctx, layout) {}
 
 protected:
   // Add any runtime files and their atoms to the output
   void createImplicitFiles(std::vector<std::unique_ptr<File>> &) override;
 
 private:
   class GOTFile : public SimpleFile {
   public:
     GOTFile(const ELFLinkingContext &eti) : SimpleFile("GOTFile") {}
     llvm::BumpPtrAllocator _alloc;
   };
-
-  std::unique_ptr<GOTFile> _gotFile;
 };
 
 template <class ELFT>
-X86DynamicLibraryWriter<ELFT>::X86DynamicLibraryWriter(
-    X86LinkingContext &ctx, TargetLayout<ELFT> &layout)
-    : DynamicLibraryWriter<ELFT>(ctx, layout), _gotFile(new GOTFile(ctx)) {}
-
-template <class ELFT>
 void X86DynamicLibraryWriter<ELFT>::createImplicitFiles(
     std::vector<std::unique_ptr<File>> &result) {
   DynamicLibraryWriter<ELFT>::createImplicitFiles(result);
-  _gotFile->addAtom(*new (_gotFile->_alloc) GlobalOffsetTableAtom(*_gotFile));
-  _gotFile->addAtom(*new (_gotFile->_alloc) DynamicAtom(*_gotFile));
-  result.push_back(std::move(_gotFile));
+  auto gotFile = llvm::make_unique<GOTFile>(this->_ctx);
+  gotFile->addAtom(*new (gotFile->_alloc) GlobalOffsetTableAtom(*gotFile));
+  gotFile->addAtom(*new (gotFile->_alloc) DynamicAtom(*gotFile));
+  result.push_back(gotFile);
 }
 
 } // namespace elf
 } // namespace lld
 
 #endif

lib/ReaderWriter/ELF/X86_64/X86_64DynamicLibraryWriter.h

-//===- lib/ReaderWriter/ELF/X86/X86_64DynamicLibraryWriter.h ---------------===//
-//
-//                             The LLVM Linker
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-#ifndef X86_64_DYNAMIC_LIBRARY_WRITER_H
-#define X86_64_DYNAMIC_LIBRARY_WRITER_H
-
-#include "DynamicLibraryWriter.h"
-#include "X86_64ElfType.h"
-#include "X86_64LinkingContext.h"
-#include "X86_64TargetHandler.h"
-
-namespace lld {
-namespace elf {
-
-class X86_64DynamicLibraryWriter : public DynamicLibraryWriter<X86_64ELFType> {
-public:
-  X86_64DynamicLibraryWriter(X86_64LinkingContext &ctx,
-                             X86_64TargetLayout &layout);
-
-protected:
-  // Add any runtime files and their atoms to the output
-  void createImplicitFiles(std::vector<std::unique_ptr<File>> &) override;
-
-private:
-  class GOTFile : public SimpleFile {
-  public:
-    GOTFile(const ELFLinkingContext &eti) : SimpleFile("GOTFile") {}
-    llvm::BumpPtrAllocator _alloc;
-  };
-
-  std::unique_ptr<GOTFile> _gotFile;
-};
-
-X86_64DynamicLibraryWriter::X86_64DynamicLibraryWriter(
-    X86_64LinkingContext &ctx, X86_64TargetLayout &layout)
-    : DynamicLibraryWriter(ctx, layout), _gotFile(new GOTFile(ctx)) {}
-
-void X86_64DynamicLibraryWriter::createImplicitFiles(
-    std::vector<std::unique_ptr<File>> &result) {
-  DynamicLibraryWriter::createImplicitFiles(result);
-  _gotFile->addAtom(*new (_gotFile->_alloc) GlobalOffsetTableAtom(*_gotFile));
-  _gotFile->addAtom(*new (_gotFile->_alloc) DynamicAtom(*_gotFile));
-  result.push_back(std::move(_gotFile));
-}
-
-} // namespace elf
-} // namespace lld
-
-#endif

lib/ReaderWriter/ELF/X86_64/X86_64ExecutableWriter.h

 //===- lib/ReaderWriter/ELF/X86/X86_64ExecutableWriter.h ------------------===//
 //
 //                             The LLVM Linker
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 #ifndef X86_64_EXECUTABLE_WRITER_H
 #define X86_64_EXECUTABLE_WRITER_H
 
+#include "DynamicLibraryWriter.h"
 #include "ExecutableWriter.h"
 #include "X86_64ElfType.h"
-#include "X86_64LinkingContext.h"
 
 namespace lld {
 namespace elf {
 
-class X86_64ExecutableWriter : public ExecutableWriter<X86_64ELFType> {
+template <typename ELFT>
+class X86_64OutputWriter : public OutputELFWriter<ELFT> {
 public:
-  X86_64ExecutableWriter(X86_64LinkingContext &ctx, X86_64TargetLayout &layout)
-      : ExecutableWriter(ctx, layout), _gotFile(new GOTFile(ctx)) {}
+  X86_64OutputWriter(ELFLinkingContext &ctx, TargetLayout<ELFT> &layout)
+      : OutputELFWriter<ELFT>(ctx, layout) {}
 
 protected:
   // Add any runtime files and their atoms to the output
   void
   createImplicitFiles(std::vector<std::unique_ptr<File>> &result) override {
-    ExecutableWriter::createImplicitFiles(result);
-    _gotFile->addAtom(*new (_gotFile->_alloc)
-                      GlobalOffsetTableAtom(*_gotFile));
+    OutputELFWriter<ELFT>::createImplicitFiles(result);
+    auto gotFile = llvm::make_unique<GOTFile>(this->_ctx);
+    gotFile->addAtom(*new (gotFile->_alloc) GlobalOffsetTableAtom(*gotFile));
     if (this->_ctx.isDynamic())
-      _gotFile->addAtom(*new (_gotFile->_alloc) DynamicAtom(*_gotFile));
-    result.push_back(std::move(_gotFile));
+      gotFile->addAtom(*new (gotFile->_alloc) DynamicAtom(*gotFile));
+    result.push_back(gotFile);
   }
 
 private:
   class GOTFile : public SimpleFile {
   public:
     GOTFile(const ELFLinkingContext &eti) : SimpleFile("GOTFile") {}
     llvm::BumpPtrAllocator _alloc;
   };
-
-  std::unique_ptr<GOTFile> _gotFile;
 };
 
+typedef DynamicLibraryWriter<X86_64ELFType, X86_64OutputWriter<X86_64ELFType>>
+    X86_64DynamicLibraryWriter;
+
+typedef ExecutableWriter<X86_64ELFType, X86_64OutputWriter<X86_64ELFType>>
+    X86_64ExecutableWriter;
+
 } // namespace elf
 } // namespace lld
 
 #endif

lib/ReaderWriter/ELF/X86_64/X86_64TargetHandler.cpp

 //===- lib/ReaderWriter/ELF/X86_64/X86_64TargetHandler.cpp ----------------===//
 //
 //                             The LLVM Linker
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "Atoms.h"
-#include "X86_64DynamicLibraryWriter.h"
 #include "X86_64ExecutableWriter.h"
 #include "X86_64LinkingContext.h"
 #include "X86_64TargetHandler.h"
 
 using namespace lld;
 using namespace elf;
 
 X86_64TargetHandler::X86_64TargetHandler(X86_64LinkingContext &ctx)

test/elf/Mips/gp-sym-1-micro.test

 # Check that microMIPS relocations against __gnu_local_gp
 # use "gp" value as target.
 
 # RUN: yaml2obj -format=elf -docnum 1 %s > %t-so.o
 # RUN: lld -flavor gnu -target mipsel -shared -o %t.so %t-so.o
 # RUN: yaml2obj -format=elf -docnum 2 %s > %t-o.o
 # RUN: lld -flavor gnu -target mipsel -e T0 -o %t.exe %t-o.o %t.so
 # RUN: llvm-readobj -symbols %t.exe | FileCheck -check-prefix=SYM %s
 # RUN: llvm-objdump -s %t.exe | FileCheck -check-prefix=SEC %s
 
-# SYM:      Name: _gp (203)
+# SYM:      Name: _gp (26)
 # SYM-NEXT: Value: 0x408FF0
 
 # SEC:      Contents of section .text:
 # SEC-NEXT:  400184 00004100 0000f08f 2000bc00  ..A..... ...
 # SEC:      Contents of section .got:
 # SEC-NEXT:  401000 00000000 00000080           ........
 
 # so.o

test/elf/Mips/gp-sym-1.test

 # Check that relocations against __gnu_local_gp use "gp" value as target.
 
 # RUN: yaml2obj -format=elf -docnum 1 %s > %t-so.o
 # RUN: lld -flavor gnu -target mipsel -shared -o %t.so %t-so.o
 # RUN: yaml2obj -format=elf -docnum 2 %s > %t-o.o
 # RUN: lld -flavor gnu -target mipsel -e T0 -o %t.exe %t-o.o %t.so
 # RUN: llvm-readobj -symbols %t.exe | FileCheck -check-prefix=SYM %s
 # RUN: llvm-objdump -s %t.exe | FileCheck -check-prefix=SEC %s
 
-# SYM:      Name: _gp (203)
+# SYM:      Name: _gp (26)
 # SYM-NEXT: Value: 0x408FF0
 
 # SEC:      Contents of section .text:
 # SEC-NEXT:  400190 41000000 f08f0000 60001000
 # SEC:      Contents of section .got:
 # SEC-NEXT:  401000 00000000 00000080
 
 # so.o

test/elf/Mips/mips-options-gp0.test

 # Check reading GP0 value from .MIPS.options section
 #
 # RUN: yaml2obj -format=elf %s > %t.o
 # RUN: lld -flavor gnu -target mips64el -e G1 -shared -o %t.so %t.o
 # RUN: llvm-readobj -symbols %t.so | FileCheck -check-prefix=SYM %s
 # RUN: llvm-objdump -s %t.so | FileCheck -check-prefix=SEC %s
 
 # SYM:      Name: L1 (1)
 # SYM-NEXT: Value: 0x1A4
 # SYM-NEXT: Size: 4
 # SYM-NEXT: Binding: Local (0x0)
 # SYM-NEXT: Type: Function (0x2)
 # SYM-NEXT: Other: 0
 # SYM-NEXT: Section: .text (0x5)
 
-# SYM:      Name: _gp (34)
+# SYM:      Name: _gp (29)
 # SYM-NEXT: Value: 0x9FF0
 # SYM-NEXT: Size: 0
 # SYM-NEXT: Binding: Global (0x1)
 # SYM-NEXT: Type: Object (0x1)
 # SYM-NEXT: Other: 0
 # SYM-NEXT: Section: Absolute (0xFFF1)
 
 # 0xffff71b4 == 0x0 (addend) + 0x01A4 (L1) + 0x1000 (GP0) - 0x9ff0 (_gp)

test/elf/Mips/rel-gprel16.test

 # SYM:      Name: G1 (4)
 # SYM-NEXT: Value: 0x108
 # SYM-NEXT: Size: 4
 # SYM-NEXT: Binding: Global (0x1)
 # SYM-NEXT: Type: Function (0x2)
 # SYM-NEXT: Other: 0
 # SYM-NEXT: Section: .text (0x5)
 
-# SYM:      Name: _gp (34)
+# SYM:      Name: _gp (29)
 # SYM-NEXT: Value: 0x8FF0
 # SYM-NEXT: Size: 0
 # SYM-NEXT: Binding: Global (0x1)
 # SYM-NEXT: Type: Object (0x1)
 # SYM-NEXT: Other: 0
 # SYM-NEXT: Section: Absolute (0xFFF1)
 
 # 0x6113 == 0xffff (addend) + 0x0104 (L1) + 0x01f000 (GP0) - 0x8ff0 (_gp)

test/elf/Mips/rel-gprel32.test

 # Check R_MIPS_GPREL32 relocation handling.
 #
 # RUN: yaml2obj -format=elf %s > %t-obj
 # RUN: lld -flavor gnu -target mipsel -o %t-exe %t-obj
 # RUN: llvm-readobj -symbols %t-exe | FileCheck -check-prefix=SYM %s
 # RUN: llvm-objdump -s %t-exe | FileCheck -check-prefix=SEC %s
 
 # SYM:      Name: $L1 (1)
 # SYM-NEXT: Value: 0x400140
 # SYM-NEXT: Size: 4
 # SYM-NEXT: Binding: Local (0x0)
 # SYM-NEXT: Type: Function (0x2)
 # SYM-NEXT: Other: 0
 # SYM-NEXT: Section: .text (0x6)
 #
-# SYM:      Name: _gp (212)
+# SYM:      Name: _gp (35)
 # SYM-NEXT: Value: 0x408FF0
 # SYM-NEXT: Size: 0
 # SYM-NEXT: Binding: Global (0x1)
 # SYM-NEXT: Type: Object (0x1)
 # SYM-NEXT: Other: 0
 # SYM-NEXT: Section: Absolute (0xFFF1)
 
 # 0x08ff7153 == 0x8000001 (addend) + 0x400140 ($L1) +