ELF2; Make singleton output sections globally accessible

[ruiu]

Summary

Previously, output sections handled specially by the linker (e.g. PLT or GOT)
are created by Writer and passed to other classes that need them. The problem
was that because these special sections are required by so many classes, the
plumbing work became too much burden.

This patch is to simply make them accessible from anywhere in the linker to
eliminate the plumbing work once and for all.

[ruiu]

Rebased on top of current head

[• rafael]

I like where this is going, but would you mind committing the changes moving stuff out of line first and rebase?

Thanks!

ELF/InputSection.cpp

40

Why remove this?

ELF/InputSection.h

78

Independent change. Please commit the rename first.

ELF/OutputSections.h

157–158

Moving it out of line is good, but please do it in a independent cleanup patch first.

[ruiu]

ELF/InputSection.cpp

40

I'll revert this change.

ELF/InputSection.h

78

Out conflicts with the global varaible Out, so we have to rename this. Technically we can use ::Out<ELFT>:: to refer to the global Out and Out for local variable Out, but that's confusing.

ELF/OutputSections.h

157–158

OK, I'll submit a clean up change first. This is needed before this patch because this contains StrTabSec.

[ruiu]

Rebased to the head.

[• rafael]

ELF/Writer.cpp

128

This is a leak, no?

Can the Out struct contain the sections themselves instead of pointers?
Failing that, could these be kept in Writer and have the writer constructor set the pointers in Out:

Out<ELFT>::StrTab = &StrTabSec;
...

[ruiu]

Fixed memory leak

[ruiu]

Please ignore #Driver.cpp# in the patch, that's garbage. Other changes are
real.

[• rafael]

LGTM with a nit.

ELF/Target.cpp

12

Target should still be the first include, no?

[ruiu]

ELF/Target.cpp

12

Done.

[Eugene.Zelenko]

Committed in r249590.

ELF/#Driver.cpp#

+//===- Driver.cpp ---------------------------------------------------------===//
+//
+//                             The LLVM Linker
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "Driver.h"
+#include "Config.h"
+#include "Error.h"
+#include "InputFiles.h"
+#include "SymbolTable.h"
+#include "Writer.h"
+#include "llvm/ADT/STLExtras.h"
+#include "llvm/ADT/StringExtras.h"
+#include "llvm/Support/FileSystem.h"
+#include "llvm/Support/Path.h"
+
+using namespace llvm;
+using namespace llvm::ELF;
+
+using namespace lld;
+using namespace lld::elf2;
+
+Configuration *lld::elf2::Config;
+LinkerDriver *lld::elf2::Driver;
+
+void lld::elf2::link(ArrayRef<const char *> Args) {
+  Configuration C;
+  LinkerDriver D;
+  Config = &C;
+  Driver = &D;
+  Driver->link(Args.slice(1));
+}
+
+static void setELFType(StringRef Emul) {
+  if (Emul == "elf_i386") {
+    Config->ElfKind = ELF32LEKind;
+    Config->EMachine = EM_386;
+    return;
+  }
+  if (Emul == "elf_x86_64") {
+    Config->ElfKind = ELF64LEKind;
+    Config->EMachine = EM_X86_64;
+    return;
+  }
+  if (Emul == "elf32ppc") {
+    Config->ElfKind = ELF32BEKind;
+    Config->EMachine = EM_PPC;
+    return;
+  }
+  if (Emul == "elf64ppc") {
+    Config->ElfKind = ELF64BEKind;
+    Config->EMachine = EM_PPC64;
+    return;
+  }
+  error(Twine("Unknown emulation: ") + Emul);
+}
+
+// Makes a path by concatenating Dir and File.
+// If Dir starts with '=' the result will be preceded by Sysroot,
+// which can be set with --sysroot command line switch.
+static std::string buildSysrootedPath(StringRef Dir, StringRef File) {
+  SmallString<128> Path;
+  if (Dir.startswith("="))
+    sys::path::append(Path, Config->Sysroot, Dir.substr(1), File);
+  else
+    sys::path::append(Path, Dir, File);
+  return Path.str().str();
+}
+
+// Searches a given library from input search paths, which are filled
+// from -L command line switches. Returns a path to an existent library file.
+static std::string searchLibrary(StringRef Path) {
+  std::vector<std::string> Names;
+  if (Path[0] == ':') {
+    Names.push_back(Path.drop_front().str());
+  } else {
+    if (!Config->Static)
+      Names.push_back((Twine("lib") + Path + ".so").str());
+    Names.push_back((Twine("lib") + Path + ".a").str());
+  }
+  for (StringRef Dir : Config->InputSearchPaths) {
+    for (const std::string &Name : Names) {
+      std::string FullPath = buildSysrootedPath(Dir, Name);
+      if (sys::fs::exists(FullPath))
+        return FullPath;
+    }
+  }
+  error(Twine("Unable to find library -l") + Path);
+}
+
+template <template <class> class T>
+std::unique_ptr<ELFFileBase>
+LinkerDriver::createELFInputFile(MemoryBufferRef MB) {
+  std::unique_ptr<ELFFileBase> File = createELFFile<T>(MB);
+  const ELFKind ElfKind = File->getELFKind();
+  const uint16_t EMachine = File->getEMachine();
+
+  // Grab target from the first input file if wasn't set by -m option.
+  if (Config->ElfKind == ELFNoneKind) {
+    Config->ElfKind = ElfKind;
+    Config->EMachine = EMachine;
+    return File;
+  }
+  if (ElfKind == Config->ElfKind && EMachine == Config->EMachine)
+    return File;
+
+  if (const ELFFileBase *First = Symtab.getFirstELF())
+    error(MB.getBufferIdentifier() + " is incompatible with " +
+          First->getName());
+  error(MB.getBufferIdentifier() + " is incompatible with target architecture");
+}
+
+// Opens and parses a file. Path has to be resolved already.
+// Newly created memory buffers are owned by this driver.
+void LinkerDriver::addFile(StringRef Path) {
+  using namespace llvm::sys::fs;
+  auto MBOrErr = MemoryBuffer::getFile(Path);
+  error(MBOrErr, Twine("cannot open ") + Path);
+  std::unique_ptr<MemoryBuffer> &MB = *MBOrErr;
+  MemoryBufferRef MBRef = MB->getMemBufferRef();
+  OwningMBs.push_back(std::move(MB)); // take MB ownership
+
+  switch (identify_magic(MBRef.getBuffer())) {
+  case file_magic::unknown:
+    readLinkerScript(MBRef);
+    return;
+  case file_magic::archive:
+    Symtab.addFile(make_unique<ArchiveFile>(MBRef));
+    return;
+  case file_magic::elf_shared_object:
+    Symtab.addFile(createELFInputFile<SharedFile>(MBRef));
+    return;
+  default:
+    Symtab.addFile(createELFInputFile<ObjectFile>(MBRef));
+  }
+}
+
+void LinkerDriver::link(ArrayRef<const char *> ArgsArr) {
+  // Parse command line options.
+  opt::InputArgList Args = Parser.parse(ArgsArr);
+
+  if (auto *Arg = Args.getLastArg(OPT_output))
+    Config->OutputFile = Arg->getValue();
+
+  if (auto *Arg = Args.getLastArg(OPT_dynamic_linker))
+    Config->DynamicLinker = Arg->getValue();
+
+  if (auto *Arg = Args.getLastArg(OPT_sysroot))
+    Config->Sysroot = Arg->getValue();
+
+  std::vector<StringRef> RPaths;
+  for (auto *Arg : Args.filtered(OPT_rpath))
+    RPaths.push_back(Arg->getValue());
+  if (!RPaths.empty())
+    Config->RPath = llvm::join(RPaths.begin(), RPaths.end(), ":");
+
+  for (auto *Arg : Args.filtered(OPT_L))
+    Config->InputSearchPaths.push_back(Arg->getValue());
+
+  if (auto *Arg = Args.getLastArg(OPT_entry))
+    Config->Entry = Arg->getValue();
+
+  if (auto *Arg = Args.getLastArg(OPT_fini))
+    Config->Fini = Arg->getValue();
+
+  if (auto *Arg = Args.getLastArg(OPT_init))
+    Config->Init = Arg->getValue();
+
+  if (auto *Arg = Args.getLastArg(OPT_soname))
+    Config->SoName = Arg->getValue();
+
+  if (auto *Arg = Args.getLastArg(OPT_m))
+    setELFType(Arg->getValue());
+
+  Config->AllowMultipleDefinition = Args.hasArg(OPT_allow_multiple_definition);
+  Config->DiscardAll = Args.hasArg(OPT_discard_all);
+  Config->DiscardLocals = Args.hasArg(OPT_discard_locals);
+  Config->DiscardNone = Args.hasArg(OPT_discard_none);
+  Config->EnableNewDtags = !Args.hasArg(OPT_disable_new_dtags);
+  Config->ExportDynamic = Args.hasArg(OPT_export_dynamic);
+  Config->NoInhibitExec = Args.hasArg(OPT_noinhibit_exec);
+  Config->NoUndefined = Args.hasArg(OPT_no_undefined);
+  Config->Shared = Args.hasArg(OPT_shared);
+
+  for (auto *Arg : Args.filtered(OPT_z))
+}

ELF/InputSection.h

 #include "lld/Core/LLVM.h"
 #include "llvm/Object/ELF.h"
 
 namespace lld {
 namespace elf2 {
 
 template <class ELFT> class ObjectFile;
 template <class ELFT> class OutputSection;
-template <class ELFT> class PltSection;
-template <class ELFT> class GotSection;
 
 // This corresponds to a section of an input file.
 template <class ELFT> class InputSection {
   typedef typename llvm::object::ELFFile<ELFT>::Elf_Shdr Elf_Shdr;
   typedef typename llvm::object::ELFFile<ELFT>::Elf_Rela Elf_Rela;
   typedef typename llvm::object::ELFFile<ELFT>::Elf_Rel Elf_Rel;
   typedef typename llvm::object::ELFFile<ELFT>::Elf_Sym Elf_Sym;
   typedef typename llvm::object::ELFFile<ELFT>::uintX_t uintX_t;
 
 public:
   InputSection(ObjectFile<ELFT> *F, const Elf_Shdr *Header);
 
   // Returns the size of this section (even if this is a common or BSS.)
   size_t getSize() const { return Header->sh_size; }
 
   // Write this section to a mmap'ed file, assuming Buf is pointing to
   // beginning of the output section.
-  void writeTo(uint8_t *Buf, const OutputSection<ELFT> &BssSec,
-               const PltSection<ELFT> &PltSec, const GotSection<ELFT> &GotSec);
+  void writeTo(uint8_t *Buf);
 
   StringRef getSectionName() const;
   const Elf_Shdr *getSectionHdr() const { return Header; }
   ObjectFile<ELFT> *getFile() const { return File; }
 
   // The writer sets and uses the addresses.
   uintX_t getOutputSectionOff() const { return OutputSectionOff; }
   uintX_t getAlign() {
public:
   // Relocation sections that refer to this one.
   SmallVector<const Elf_Shdr *, 1> RelocSections;
 
 private:
   template <bool isRela>
   void relocate(uint8_t *Buf,
                 llvm::iterator_range<
                     const llvm::object::Elf_Rel_Impl<ELFT, isRela> *> Rels,
-                const ObjectFile<ELFT> &File, uintX_t BaseAddr,
-                const OutputSection<ELFT> &BssSec,
-                const PltSection<ELFT> &PltSec, const GotSection<ELFT> &GotSec);
+                const ObjectFile<ELFT> &File, uintX_t BaseAddr);
 
   // The offset from beginning of the output sections this section was assigned
   // to. The writer sets a value.
   uint64_t OutputSectionOff = 0;
 
   // The file this section is from.
   ObjectFile<ELFT> *File;
 
   OutputSection<ELFT> *OutSec = nullptr;
 
   const Elf_Shdr *Header;
 };
 
 } // namespace elf2
 } // namespace lld
 
 #endif

ELF/InputSection.cpp

 template <class ELFT>
 InputSection<ELFT>::InputSection(ObjectFile<ELFT> *F, const Elf_Shdr *Header)
     : File(F), Header(Header) {}
 
 template <class ELFT>
 template <bool isRela>
 void InputSection<ELFT>::relocate(
     uint8_t *Buf, iterator_range<const Elf_Rel_Impl<ELFT, isRela> *> Rels,
-    const ObjectFile<ELFT> &File, uintX_t BaseAddr,
-    const OutputSection<ELFT> &BssSec, const PltSection<ELFT> &PltSec,
-    const GotSection<ELFT> &GotSec) {
+    const ObjectFile<ELFT> &File, uintX_t BaseAddr) {
   typedef Elf_Rel_Impl<ELFT, isRela> RelType;
   bool IsMips64EL = File.getObj().isMips64EL();
   for (const RelType &RI : Rels) {
     uint32_t SymIndex = RI.getSymbol(IsMips64EL);
     uint32_t Type = RI.getType(IsMips64EL);
-    uintX_t GotVA = GotSec.getVA();
+    uintX_t GotVA = Out<ELFT>::Got->getVA();
     uintX_t SymVA;
 
     // Handle relocations for local symbols -- they never get
     // resolved so we don't allocate a SymbolBody.
     const Elf_Shdr *SymTab = File.getSymbolTable();
     if (SymIndex < SymTab->sh_info) {
       const Elf_Sym *Sym = File.getObj().getRelocationSymbol(&RI, SymTab);
       if (!Sym)
         continue;
       SymVA = getLocalSymVA(Sym, File);
     } else {
       SymbolBody &Body = *File.getSymbolBody(SymIndex);
-      SymVA = getSymVA<ELFT>(Body, BssSec);
+      SymVA = getSymVA<ELFT>(Body);
       if (Target->relocNeedsPlt(Type, Body)) {
-        SymVA = PltSec.getEntryAddr(Body);
+        SymVA = Out<ELFT>::Plt->getEntryAddr(Body);
         Type = Target->getPCRelReloc();
       } else if (Target->relocNeedsGot(Type, Body)) {
-        SymVA = GotSec.getEntryAddr(Body);
+        SymVA = Out<ELFT>::Got->getEntryAddr(Body);
         Type = Target->getGotRefReloc();
       } else if (Target->relocPointsToGot(Type)) {
         SymVA = GotVA;
         Type = Target->getPCRelReloc();
       } else if (isa<SharedSymbol<ELFT>>(Body)) {
         continue;
       }
     }
 
     Target->relocateOne(Buf, reinterpret_cast<const void *>(&RI), Type,
                         BaseAddr, SymVA, GotVA);
   }
 }
 
-template <class ELFT>
-void InputSection<ELFT>::writeTo(uint8_t *Buf,
-                                 const OutputSection<ELFT> &BssSec,
-                                 const PltSection<ELFT> &PltSec,
-                                 const GotSection<ELFT> &GotSec) {
+template <class ELFT> void InputSection<ELFT>::writeTo(uint8_t *Buf) {
   if (Header->sh_type == SHT_NOBITS)
     return;
   // Copy section contents from source object file to output file.
   ArrayRef<uint8_t> Data = *File->getObj().getSectionContents(Header);
   memcpy(Buf + OutputSectionOff, Data.data(), Data.size());
 
   ObjectFile<ELFT> *File = getFile();
   ELFFile<ELFT> &EObj = File->getObj();
   uint8_t *Base = Buf + getOutputSectionOff();
   uintX_t BaseAddr = OutSec->getVA() + getOutputSectionOff();
   // Iterate over all relocation sections that apply to this section.
   for (const Elf_Shdr *RelSec : RelocSections) {
     if (RelSec->sh_type == SHT_RELA)
-      relocate(Base, EObj.relas(RelSec), *File, BaseAddr, BssSec, PltSec,
-               GotSec);
+      relocate(Base, EObj.relas(RelSec), *File, BaseAddr);
     else
-      relocate(Base, EObj.rels(RelSec), *File, BaseAddr, BssSec, PltSec,
-               GotSec);
+      relocate(Base, EObj.rels(RelSec), *File, BaseAddr);
   }
 }
 
 template <class ELFT> StringRef InputSection<ELFT>::getSectionName() const {
   ErrorOr<StringRef> Name = File->getObj().getSectionName(Header);
   error(Name);
   return *Name;
 }

ELF/OutputSections.h

 template <bool Is64Bits> class StringTableSection;
 template <class ELFT> class InputSection;
 template <class ELFT> class OutputSection;
 template <class ELFT> class ObjectFile;
 template <class ELFT> class DefinedRegular;
 template <class ELFT> class ELFSymbolBody;
 
 template <class ELFT>
-typename llvm::object::ELFFile<ELFT>::uintX_t
-getSymVA(const SymbolBody &S, const OutputSection<ELFT> &BssSec);
+typename llvm::object::ELFFile<ELFT>::uintX_t getSymVA(const SymbolBody &S);
 
 template <class ELFT>
 typename llvm::object::ELFFile<ELFT>::uintX_t
 getLocalSymVA(const typename llvm::object::ELFFile<ELFT>::Elf_Sym *Sym,
               const ObjectFile<ELFT> &File);
 bool canBePreempted(const SymbolBody *Body);
 template <class ELFT> bool includeInSymtab(const SymbolBody &B);
 

 };
 
 template <class ELFT>
 class GotSection final : public OutputSectionBase<ELFT::Is64Bits> {
   typedef OutputSectionBase<ELFT::Is64Bits> Base;
   typedef typename Base::uintX_t uintX_t;
 
 public:
-  GotSection(const OutputSection<ELFT> &BssSec);
+  GotSection();
   void finalize() override {
     this->Header.sh_size = Entries.size() * this->getAddrSize();
   }
   void writeTo(uint8_t *Buf) override;
   void addEntry(SymbolBody *Sym);
   bool empty() const { return Entries.empty(); }
   uintX_t getEntryAddr(const SymbolBody &B) const;
 
 private:
   std::vector<const SymbolBody *> Entries;
-  const OutputSection<ELFT> &BssSec;
 };
 
 template <class ELFT>
 class PltSection final : public OutputSectionBase<ELFT::Is64Bits> {
   typedef OutputSectionBase<ELFT::Is64Bits> Base;
   typedef typename Base::uintX_t uintX_t;
 
 public:
-  PltSection(const GotSection<ELFT> &GotSec);
+  PltSection();
   void finalize() override {
     this->Header.sh_size = Entries.size() * EntrySize;
   }
   void writeTo(uint8_t *Buf) override;
   void addEntry(SymbolBody *Sym);
   bool empty() const { return Entries.empty(); }
   uintX_t getEntryAddr(const SymbolBody &B) const;
   static const unsigned EntrySize = 8;
 
 private:
   std::vector<const SymbolBody *> Entries;
-  const GotSection<ELFT> &GotSec;
 };
 
 template <class ELFT> struct DynamicReloc {
   typedef typename llvm::object::ELFFile<ELFT>::Elf_Rel Elf_Rel;
   const InputSection<ELFT> &C;
   const Elf_Rel &RI;
 };
 
 template <class ELFT>
 class SymbolTableSection final : public OutputSectionBase<ELFT::Is64Bits> {
 public:
   typedef typename llvm::object::ELFFile<ELFT>::Elf_Shdr Elf_Shdr;
   typedef typename llvm::object::ELFFile<ELFT>::Elf_Sym Elf_Sym;
   typedef typename llvm::object::ELFFile<ELFT>::Elf_Sym_Range Elf_Sym_Range;
   typedef typename OutputSectionBase<ELFT::Is64Bits>::uintX_t uintX_t;
   SymbolTableSection(SymbolTable &Table,
-                     StringTableSection<ELFT::Is64Bits> &StrTabSec,
-                     const OutputSection<ELFT> &BssSec);
+                     StringTableSection<ELFT::Is64Bits> &StrTabSec);
 
   void finalize() override;
   void writeTo(uint8_t *Buf) override;
   SymbolTable &getSymTable() const { return Table; }
   void addSymbol(StringRef Name, bool isLocal = false);
   StringTableSection<ELFT::Is64Bits> &getStrTabSec() const { return StrTabSec; }
   unsigned getNumSymbols() const { return NumVisible + 1; }
 
 private:
   void writeLocalSymbols(uint8_t *&Buf);
   void writeGlobalSymbols(uint8_t *&Buf);
 
   SymbolTable &Table;
   StringTableSection<ELFT::Is64Bits> &StrTabSec;
   unsigned NumVisible = 0;
   unsigned NumLocals = 0;
-  const OutputSection<ELFT> &BssSec;
 };
 
 template <class ELFT>
 class RelocationSection final : public OutputSectionBase<ELFT::Is64Bits> {
   typedef typename llvm::object::ELFFile<ELFT>::Elf_Rel Elf_Rel;
   typedef typename llvm::object::ELFFile<ELFT>::Elf_Rela Elf_Rela;
   typedef typename llvm::object::ELFFile<ELFT>::uintX_t uintX_t;
 
 public:
-  RelocationSection(SymbolTableSection<ELFT> &DynSymSec,
-                    const GotSection<ELFT> &GotSec,
-                    const OutputSection<ELFT> &BssSec, bool IsRela);
+  RelocationSection(bool IsRela);
   void addReloc(const DynamicReloc<ELFT> &Reloc) { Relocs.push_back(Reloc); }
   void finalize() override;
   void writeTo(uint8_t *Buf) override;
   bool hasRelocs() const { return !Relocs.empty(); }
   bool isRela() const { return IsRela; }
 
 private:
   std::vector<DynamicReloc<ELFT>> Relocs;
-  SymbolTableSection<ELFT> &DynSymSec;
-  const GotSection<ELFT> &GotSec;
-  const OutputSection<ELFT> &BssSec;
   const bool IsRela;
 };
 
 template <class ELFT>
 class OutputSection final : public OutputSectionBase<ELFT::Is64Bits> {
 public:
   typedef typename OutputSectionBase<ELFT::Is64Bits>::uintX_t uintX_t;
   typedef typename llvm::object::ELFFile<ELFT>::Elf_Shdr Elf_Shdr;
   typedef typename llvm::object::ELFFile<ELFT>::Elf_Sym Elf_Sym;
   typedef typename llvm::object::ELFFile<ELFT>::Elf_Rel Elf_Rel;
   typedef typename llvm::object::ELFFile<ELFT>::Elf_Rela Elf_Rela;
-  OutputSection(const PltSection<ELFT> &PltSec, const GotSection<ELFT> &GotSec,
-                const OutputSection<ELFT> &BssSec, StringRef Name,
-                uint32_t sh_type, uintX_t sh_flags);
+  OutputSection(StringRef Name, uint32_t sh_type, uintX_t sh_flags);
   void addSection(InputSection<ELFT> *C);
   void writeTo(uint8_t *Buf) override;
 
 private:
   std::vector<InputSection<ELFT> *> Sections;
-  const PltSection<ELFT> &PltSec;
-  const GotSection<ELFT> &GotSec;
-  const OutputSection<ELFT> &BssSec;
 };
 
 template <bool Is64Bits>
 class InterpSection final : public OutputSectionBase<Is64Bits> {
 public:
   InterpSection();
 
   void writeTo(uint8_t *Buf);
private:
   llvm::StringTableBuilder StrTabBuilder;
 };
 
 template <class ELFT>
 class HashTableSection final : public OutputSectionBase<ELFT::Is64Bits> {
   typedef typename llvm::object::ELFFile<ELFT>::Elf_Word Elf_Word;
 
 public:
-  HashTableSection(SymbolTableSection<ELFT> &DynSymSec);
+  HashTableSection();
   void addSymbol(SymbolBody *S);
   void finalize() override;
   void writeTo(uint8_t *Buf) override;
-  SymbolTableSection<ELFT> &getDynSymSec() { return DynSymSec; }
 
 private:
   uint32_t hash(StringRef Name) {
     uint32_t H = 0;
     for (char C : Name) {
       H = (H << 4) + C;
       uint32_t G = H & 0xf0000000;
       if (G)
         H ^= G >> 24;
       H &= ~G;
     }
     return H;
   }
-  SymbolTableSection<ELFT> &DynSymSec;
   std::vector<uint32_t> Hashes;
 };
 
 template <class ELFT>
 class DynamicSection final : public OutputSectionBase<ELFT::Is64Bits> {
   typedef OutputSectionBase<ELFT::Is64Bits> Base;
   typedef typename Base::HeaderT HeaderT;
   typedef typename llvm::object::ELFFile<ELFT>::Elf_Rel Elf_Rel;
   typedef typename llvm::object::ELFFile<ELFT>::Elf_Rela Elf_Rela;
   typedef typename llvm::object::ELFFile<ELFT>::Elf_Sym Elf_Sym;
   typedef typename llvm::object::ELFFile<ELFT>::Elf_Dyn Elf_Dyn;
 
 public:
-  DynamicSection(SymbolTable &SymTab, HashTableSection<ELFT> &HashSec,
-                 RelocationSection<ELFT> &RelaDynSec,
-                 const OutputSection<ELFT> &BssSec);
+  DynamicSection(SymbolTable &SymTab);
   void finalize() override;
   void writeTo(uint8_t *Buf) override;
 
   OutputSection<ELFT> *PreInitArraySec = nullptr;
   OutputSection<ELFT> *InitArraySec = nullptr;
   OutputSection<ELFT> *FiniArraySec = nullptr;
 
 private:
-  HashTableSection<ELFT> &HashSec;
-  SymbolTableSection<ELFT> &DynSymSec;
-  StringTableSection<ELFT::Is64Bits> &DynStrSec;
-  RelocationSection<ELFT> &RelaDynSec;
-  const OutputSection<ELFT> &BssSec;
   SymbolTable &SymTab;
   const ELFSymbolBody<ELFT> *InitSym = nullptr;
   const ELFSymbolBody<ELFT> *FiniSym = nullptr;
 };
+
+// All output sections that are hadnled by the linker specially are
+// globally accessible. Writer initializes them, so don't use them
+// until Writer is initialized.
+template <class ELFT> struct Out {
+  static DynamicSection<ELFT> *Dynamic;
+  static GotSection<ELFT> *Got;
+  static HashTableSection<ELFT> *HashTab;
+  static InterpSection<ELFT::Is64Bits> *Interp;
+  static OutputSection<ELFT> *Bss;
+  static PltSection<ELFT> *Plt;
+  static RelocationSection<ELFT> *RelaDyn;
+  static StringTableSection<ELFT::Is64Bits> *DynStrTab;
+  static StringTableSection<ELFT::Is64Bits> *StrTab;
+  static SymbolTableSection<ELFT> *DynSymTab;
+  static SymbolTableSection<ELFT> *SymTab;
+};
 }
 }
 #endif

ELF/OutputSections.cpp

 using namespace llvm;
 using namespace llvm::object;
 using namespace llvm::support::endian;
 using namespace llvm::ELF;
 
 using namespace lld;
 using namespace lld::elf2;
 
+template <> DynamicSection<ELF32BE> *Out<ELF32BE>::Dynamic = nullptr;
+template <> DynamicSection<ELF32LE> *Out<ELF32LE>::Dynamic = nullptr;
+template <> DynamicSection<ELF64BE> *Out<ELF64BE>::Dynamic = nullptr;
+template <> DynamicSection<ELF64LE> *Out<ELF64LE>::Dynamic = nullptr;
+template <> GotSection<ELF32BE> *Out<ELF32BE>::Got = nullptr;
+template <> GotSection<ELF32LE> *Out<ELF32LE>::Got = nullptr;
+template <> GotSection<ELF64BE> *Out<ELF64BE>::Got = nullptr;
+template <> GotSection<ELF64LE> *Out<ELF64LE>::Got = nullptr;
+template <> HashTableSection<ELF32BE> *Out<ELF32BE>::HashTab = nullptr;
+template <> HashTableSection<ELF32LE> *Out<ELF32LE>::HashTab = nullptr;
+template <> HashTableSection<ELF64BE> *Out<ELF64BE>::HashTab = nullptr;
+template <> HashTableSection<ELF64LE> *Out<ELF64LE>::HashTab = nullptr;
+template <> InterpSection<false> *Out<ELF32BE>::Interp = nullptr;
+template <> InterpSection<false> *Out<ELF32LE>::Interp = nullptr;
+template <> InterpSection<true> *Out<ELF64BE>::Interp = nullptr;
+template <> InterpSection<true> *Out<ELF64LE>::Interp = nullptr;
+template <> OutputSection<ELF32BE> *Out<ELF32BE>::Bss = nullptr;
+template <> OutputSection<ELF32LE> *Out<ELF32LE>::Bss = nullptr;
+template <> OutputSection<ELF64BE> *Out<ELF64BE>::Bss = nullptr;
+template <> OutputSection<ELF64LE> *Out<ELF64LE>::Bss = nullptr;
+template <> PltSection<ELF32BE> *Out<ELF32BE>::Plt = nullptr;
+template <> PltSection<ELF32LE> *Out<ELF32LE>::Plt = nullptr;
+template <> PltSection<ELF64BE> *Out<ELF64BE>::Plt = nullptr;
+template <> PltSection<ELF64LE> *Out<ELF64LE>::Plt = nullptr;
+template <> RelocationSection<ELF32BE> *Out<ELF32BE>::RelaDyn = nullptr;
+template <> RelocationSection<ELF32LE> *Out<ELF32LE>::RelaDyn = nullptr;
+template <> RelocationSection<ELF64BE> *Out<ELF64BE>::RelaDyn = nullptr;
+template <> RelocationSection<ELF64LE> *Out<ELF64LE>::RelaDyn = nullptr;
+template <> StringTableSection<false> *Out<ELF32BE>::DynStrTab = nullptr;
+template <> StringTableSection<false> *Out<ELF32LE>::DynStrTab = nullptr;
+template <> StringTableSection<true> *Out<ELF64BE>::DynStrTab = nullptr;
+template <> StringTableSection<true> *Out<ELF64LE>::DynStrTab = nullptr;
+template <> StringTableSection<false> *Out<ELF32BE>::StrTab = nullptr;
+template <> StringTableSection<false> *Out<ELF32LE>::StrTab = nullptr;
+template <> StringTableSection<true> *Out<ELF64BE>::StrTab = nullptr;
+template <> StringTableSection<true> *Out<ELF64LE>::StrTab = nullptr;
+template <> SymbolTableSection<ELF32BE> *Out<ELF32BE>::DynSymTab = nullptr;
+template <> SymbolTableSection<ELF32LE> *Out<ELF32LE>::DynSymTab = nullptr;
+template <> SymbolTableSection<ELF64BE> *Out<ELF64BE>::DynSymTab = nullptr;
+template <> SymbolTableSection<ELF64LE> *Out<ELF64LE>::DynSymTab = nullptr;
+template <> SymbolTableSection<ELF32BE> *Out<ELF32BE>::SymTab = nullptr;
+template <> SymbolTableSection<ELF32LE> *Out<ELF32LE>::SymTab = nullptr;
+template <> SymbolTableSection<ELF64BE> *Out<ELF64BE>::SymTab = nullptr;
+template <> SymbolTableSection<ELF64LE> *Out<ELF64LE>::SymTab = nullptr;
+
 template <bool Is64Bits>
 OutputSectionBase<Is64Bits>::OutputSectionBase(StringRef Name, uint32_t sh_type,
                                                uintX_t sh_flags)
     : Name(Name) {
   memset(&Header, 0, sizeof(HeaderT));
   Header.sh_type = sh_type;
   Header.sh_flags = sh_flags;
 }
 
-template <class ELFT>
-GotSection<ELFT>::GotSection(const OutputSection<ELFT> &BssSec)
+template <class ELFT> GotSection<ELFT>::GotSection()
     : OutputSectionBase<ELFT::Is64Bits>(".got", llvm::ELF::SHT_PROGBITS,
                                         llvm::ELF::SHF_ALLOC |
-                                            llvm::ELF::SHF_WRITE),
-      BssSec(BssSec) {
+                                            llvm::ELF::SHF_WRITE) {
   this->Header.sh_addralign = this->getAddrSize();
 }
 
 template <class ELFT> void GotSection<ELFT>::addEntry(SymbolBody *Sym) {
   Sym->setGotIndex(Entries.size());
   Entries.push_back(Sym);
 }
 
 template <class ELFT>
 typename GotSection<ELFT>::uintX_t
 GotSection<ELFT>::getEntryAddr(const SymbolBody &B) const {
   return this->getVA() + B.getGotIndex() * this->getAddrSize();
 }
 
 template <class ELFT> void GotSection<ELFT>::writeTo(uint8_t *Buf) {
   for (const SymbolBody *B : Entries) {
     uint8_t *Entry = Buf;
     Buf += sizeof(uintX_t);
     if (canBePreempted(B))
       continue; // The dynamic linker will take care of it.
-    uintX_t VA = getSymVA(*B, BssSec);
+    uintX_t VA = getSymVA<ELFT>(*B);
     write<uintX_t, ELFT::TargetEndianness, sizeof(uintX_t)>(Entry, VA);
   }
 }
 
 template <class ELFT>
-PltSection<ELFT>::PltSection(const GotSection<ELFT> &GotSec)
+PltSection<ELFT>::PltSection()
     : OutputSectionBase<ELFT::Is64Bits>(".plt", llvm::ELF::SHT_PROGBITS,
                                         llvm::ELF::SHF_ALLOC |
-                                            llvm::ELF::SHF_EXECINSTR),
-      GotSec(GotSec) {
+                                            llvm::ELF::SHF_EXECINSTR) {
   this->Header.sh_addralign = 16;
 }
 
 template <class ELFT> void PltSection<ELFT>::writeTo(uint8_t *Buf) {
   uintptr_t Start = reinterpret_cast<uintptr_t>(Buf);
   for (const SymbolBody *E : Entries) {
-    uint64_t GotEntryAddr = GotSec.getEntryAddr(*E);
+    uint64_t GotEntryAddr = Out<ELFT>::Got->getEntryAddr(*E);
     uintptr_t InstPos = reinterpret_cast<uintptr_t>(Buf);
     uint64_t PltEntryAddr = (InstPos - Start) + this->getVA();
     Target->writePltEntry(Buf, GotEntryAddr, PltEntryAddr);
     Buf += 8;
   }
 }
 
 template <class ELFT> void PltSection<ELFT>::addEntry(SymbolBody *Sym) {
   Sym->setPltIndex(Entries.size());
   Entries.push_back(Sym);
 }
 
 template <class ELFT>
 typename PltSection<ELFT>::uintX_t
 PltSection<ELFT>::getEntryAddr(const SymbolBody &B) const {
   return this->getVA() + B.getPltIndex() * EntrySize;
 }
 
 template <class ELFT>
-RelocationSection<ELFT>::RelocationSection(SymbolTableSection<ELFT> &DynSymSec,
-                                           const GotSection<ELFT> &GotSec,
-                                           const OutputSection<ELFT> &BssSec,
-                                           bool IsRela)
+RelocationSection<ELFT>::RelocationSection(bool IsRela)
     : OutputSectionBase<ELFT::Is64Bits>(IsRela ? ".rela.dyn" : ".rel.dyn",
                                         IsRela ? llvm::ELF::SHT_RELA
                                                : llvm::ELF::SHT_REL,
                                         llvm::ELF::SHF_ALLOC),
-      DynSymSec(DynSymSec), GotSec(GotSec), BssSec(BssSec), IsRela(IsRela) {
+      IsRela(IsRela) {
   this->Header.sh_entsize = IsRela ? sizeof(Elf_Rela) : sizeof(Elf_Rel);
   this->Header.sh_addralign = ELFT::Is64Bits ? 8 : 4;
 }
 
 template <class ELFT> void RelocationSection<ELFT>::writeTo(uint8_t *Buf) {
   const unsigned EntrySize = IsRela ? sizeof(Elf_Rela) : sizeof(Elf_Rel);
   bool IsMips64EL = Relocs[0].C.getFile()->getObj().isMips64EL();
   for (const DynamicReloc<ELFT> &Rel : Relocs) {
for (const DynamicReloc<ELFT> &Rel : Relocs) {
 
     uint32_t Type = RI.getType(IsMips64EL);
 
     bool CanBePreempted = canBePreempted(Body);
     uintX_t Addend = 0;
     if (!CanBePreempted) {
       if (IsRela) {
         if (Body)
-          Addend += getSymVA(cast<ELFSymbolBody<ELFT>>(*Body), BssSec);
+          Addend += getSymVA<ELFT>(cast<ELFSymbolBody<ELFT>>(*Body));
         else
           Addend += getLocalSymVA(
               Obj.getRelocationSymbol(&RI, File.getSymbolTable()), File);
       }
       P->setSymbolAndType(0, Target->getRelativeReloc(), IsMips64EL);
     }
 
     if (Body && Target->relocNeedsGot(Type, *Body)) {
-      P->r_offset = GotSec.getEntryAddr(*Body);
+        P->r_offset = Out<ELFT>::Got->getEntryAddr(*Body);
       if (CanBePreempted)
         P->setSymbolAndType(Body->getDynamicSymbolTableIndex(),
                             Target->getGotReloc(), IsMips64EL);
     } else {
       if (IsRela)
         Addend += static_cast<const Elf_Rela &>(RI).r_addend;
       P->r_offset = RI.r_offset + C.getOutputSectionOff() + OutSec->getVA();
       if (CanBePreempted)
         P->setSymbolAndType(Body->getDynamicSymbolTableIndex(), Type,
                             IsMips64EL);
     }
 
     if (IsRela)
       static_cast<Elf_Rela *>(P)->r_addend = Addend;
   }
 }
 
 template <class ELFT> void RelocationSection<ELFT>::finalize() {
-  this->Header.sh_link = DynSymSec.getSectionIndex();
+  this->Header.sh_link = Out<ELFT>::DynSymTab->getSectionIndex();
   this->Header.sh_size = Relocs.size() * this->Header.sh_entsize;
 }
 
 template <bool Is64Bits>
 InterpSection<Is64Bits>::InterpSection()
     : OutputSectionBase<Is64Bits>(".interp", llvm::ELF::SHT_PROGBITS,
                                   llvm::ELF::SHF_ALLOC) {
   this->Header.sh_size = Config->DynamicLinker.size() + 1;
void OutputSectionBase<Is64Bits>::writeHeaderTo(
   SHdr->sh_entsize = Header.sh_entsize;
 }
 
 template <bool Is64Bits> void InterpSection<Is64Bits>::writeTo(uint8_t *Buf) {
   memcpy(Buf, Config->DynamicLinker.data(), Config->DynamicLinker.size());
 }
 
 template <class ELFT>
-HashTableSection<ELFT>::HashTableSection(SymbolTableSection<ELFT> &DynSymSec)
+HashTableSection<ELFT>::HashTableSection()
     : OutputSectionBase<ELFT::Is64Bits>(".hash", llvm::ELF::SHT_HASH,
-                                        llvm::ELF::SHF_ALLOC),
-      DynSymSec(DynSymSec) {
+                                        llvm::ELF::SHF_ALLOC) {
   this->Header.sh_entsize = sizeof(Elf_Word);
   this->Header.sh_addralign = sizeof(Elf_Word);
 }
 
 template <class ELFT> void HashTableSection<ELFT>::addSymbol(SymbolBody *S) {
   StringRef Name = S->getName();
-  DynSymSec.addSymbol(Name);
+  Out<ELFT>::DynSymTab->addSymbol(Name);
   Hashes.push_back(hash(Name));
   S->setDynamicSymbolTableIndex(Hashes.size());
 }
 
 template <class ELFT> void HashTableSection<ELFT>::finalize() {
-  this->Header.sh_link = DynSymSec.getSectionIndex();
+  this->Header.sh_link = Out<ELFT>::DynSymTab->getSectionIndex();
 
-  assert(DynSymSec.getNumSymbols() == Hashes.size() + 1);
+  assert(Out<ELFT>::DynSymTab->getNumSymbols() == Hashes.size() + 1);
   unsigned NumEntries = 2;                 // nbucket and nchain.
-  NumEntries += DynSymSec.getNumSymbols(); // The chain entries.
+  NumEntries += Out<ELFT>::DynSymTab->getNumSymbols(); // The chain entries.
 
   // Create as many buckets as there are symbols.
   // FIXME: This is simplistic. We can try to optimize it, but implementing
   // support for SHT_GNU_HASH is probably even more profitable.
-  NumEntries += DynSymSec.getNumSymbols();
+  NumEntries += Out<ELFT>::DynSymTab->getNumSymbols();
   this->Header.sh_size = NumEntries * sizeof(Elf_Word);
 }
 
 template <class ELFT> void HashTableSection<ELFT>::writeTo(uint8_t *Buf) {
-  unsigned NumSymbols = DynSymSec.getNumSymbols();
+  unsigned NumSymbols = Out<ELFT>::DynSymTab->getNumSymbols();
   auto *P = reinterpret_cast<Elf_Word *>(Buf);
   *P++ = NumSymbols; // nbucket
   *P++ = NumSymbols; // nchain
 
   Elf_Word *Buckets = P;
   Elf_Word *Chains = P + NumSymbols;
 
   for (unsigned I = 1; I < NumSymbols; ++I) {
     uint32_t Hash = Hashes[I - 1] % NumSymbols;
     Chains[I] = Buckets[Hash];
     Buckets[Hash] = I;
   }
 }
 
 template <class ELFT>
-DynamicSection<ELFT>::DynamicSection(SymbolTable &SymTab,
-                                     HashTableSection<ELFT> &HashSec,
-                                     RelocationSection<ELFT> &RelaDynSec,
-                                     const OutputSection<ELFT> &BssSec)
+DynamicSection<ELFT>::DynamicSection(SymbolTable &SymTab)
     : OutputSectionBase<ELFT::Is64Bits>(".dynamic", llvm::ELF::SHT_DYNAMIC,
                                         llvm::ELF::SHF_ALLOC |
                                             llvm::ELF::SHF_WRITE),
-      HashSec(HashSec), DynSymSec(HashSec.getDynSymSec()),
-      DynStrSec(DynSymSec.getStrTabSec()), RelaDynSec(RelaDynSec),
-      BssSec(BssSec), SymTab(SymTab) {
+      SymTab(SymTab) {
   typename Base::HeaderT &Header = this->Header;
   Header.sh_addralign = ELFT::Is64Bits ? 8 : 4;
   Header.sh_entsize = ELFT::Is64Bits ? 16 : 8;
 }
 
 template <class ELFT> void DynamicSection<ELFT>::finalize() {
   if (this->Header.sh_size)
     return; // Already finalized.
 
   typename Base::HeaderT &Header = this->Header;
-  Header.sh_link = DynStrSec.getSectionIndex();
+  Header.sh_link = Out<ELFT>::DynStrTab->getSectionIndex();
 
   unsigned NumEntries = 0;
-  if (RelaDynSec.hasRelocs()) {
+  if (Out<ELFT>::RelaDyn->hasRelocs()) {
     ++NumEntries; // DT_RELA / DT_REL
     ++NumEntries; // DT_RELASZ / DT_RELSZ
     ++NumEntries; // DT_RELAENT / DT_RELENT
   }
   ++NumEntries; // DT_SYMTAB
   ++NumEntries; // DT_SYMENT
   ++NumEntries; // DT_STRTAB
   ++NumEntries; // DT_STRSZ
   ++NumEntries; // DT_HASH
 
   if (!Config->RPath.empty()) {
     ++NumEntries; // DT_RUNPATH / DT_RPATH
-    DynStrSec.add(Config->RPath);
+    Out<ELFT>::DynStrTab->add(Config->RPath);
   }
 
   if (!Config->SoName.empty()) {
     ++NumEntries; // DT_SONAME
-    DynStrSec.add(Config->SoName);
+    Out<ELFT>::DynStrTab->add(Config->SoName);
   }
 
   if (PreInitArraySec)
     NumEntries += 2;
   if (InitArraySec)
     NumEntries += 2;
   if (FiniArraySec)
     NumEntries += 2;
 
   const std::vector<std::unique_ptr<SharedFileBase>> &SharedFiles =
       SymTab.getSharedFiles();
   for (const std::unique_ptr<SharedFileBase> &File : SharedFiles)
-    DynStrSec.add(File->getSoName());
+    Out<ELFT>::DynStrTab->add(File->getSoName());
   NumEntries += SharedFiles.size();
 
   if (Symbol *S = SymTab.getSymbols().lookup(Config->Init))
     InitSym = dyn_cast<ELFSymbolBody<ELFT>>(S->Body);
   if (Symbol *S = SymTab.getSymbols().lookup(Config->Fini))
     FiniSym = dyn_cast<ELFSymbolBody<ELFT>>(S->Body);
   if (InitSym)
     ++NumEntries; // DT_INIT
template <class ELFT> void DynamicSection<ELFT>::writeTo(uint8_t *Buf) {
   };
 
   auto WriteVal = [&](int32_t Tag, uint32_t Val) {
     P->d_tag = Tag;
     P->d_un.d_val = Val;
     ++P;
   };
 
-  if (RelaDynSec.hasRelocs()) {
-    bool IsRela = RelaDynSec.isRela();
-    WritePtr(IsRela ? DT_RELA : DT_REL, RelaDynSec.getVA());
-    WriteVal(IsRela ? DT_RELASZ : DT_RELSZ, RelaDynSec.getSize());
+  if (Out<ELFT>::RelaDyn->hasRelocs()) {
+    bool IsRela = Out<ELFT>::RelaDyn->isRela();
+    WritePtr(IsRela ? DT_RELA : DT_REL, Out<ELFT>::RelaDyn->getVA());
+    WriteVal(IsRela ? DT_RELASZ : DT_RELSZ, Out<ELFT>::RelaDyn->getSize());
     WriteVal(IsRela ? DT_RELAENT : DT_RELENT,
              IsRela ? sizeof(Elf_Rela) : sizeof(Elf_Rel));
   }
 
-  WritePtr(DT_SYMTAB, DynSymSec.getVA());
+  WritePtr(DT_SYMTAB, Out<ELFT>::DynSymTab->getVA());
   WritePtr(DT_SYMENT, sizeof(Elf_Sym));
-  WritePtr(DT_STRTAB, DynStrSec.getVA());
-  WriteVal(DT_STRSZ, DynStrSec.data().size());
-  WritePtr(DT_HASH, HashSec.getVA());
+  WritePtr(DT_STRTAB, Out<ELFT>::DynStrTab->getVA());
+  WriteVal(DT_STRSZ, Out<ELFT>::DynStrTab->data().size());
+  WritePtr(DT_HASH, Out<ELFT>::HashTab->getVA());
 
   if (!Config->RPath.empty())
 
     // If --enable-new-dtags is set lld emits DT_RUNPATH
     // instead of DT_RPATH. The two tags are functionally
     // equivalent except for the following:
     // - DT_RUNPATH is searched after LD_LIBRARY_PATH, while
     // DT_RPATH is searched before.
     // - DT_RUNPATH is used only to search for direct
     // dependencies of the object it's contained in, while
     // DT_RPATH is used for indirect dependencies as well.
     WriteVal(Config->EnableNewDtags ? DT_RUNPATH : DT_RPATH,
-             DynStrSec.getFileOff(Config->RPath));
+             Out<ELFT>::DynStrTab->getFileOff(Config->RPath));
 
   if (!Config->SoName.empty())
-    WriteVal(DT_SONAME, DynStrSec.getFileOff(Config->SoName));
+    WriteVal(DT_SONAME, Out<ELFT>::DynStrTab->getFileOff(Config->SoName));
 
   auto WriteArray = [&](int32_t T1, int32_t T2,
                         const OutputSection<ELFT> *Sec) {
     if (!Sec)
       return;
     WritePtr(T1, Sec->getVA());
     WriteVal(T2, Sec->getSize());
   };
   WriteArray(DT_PREINIT_ARRAY, DT_PREINIT_ARRAYSZ, PreInitArraySec);
   WriteArray(DT_INIT_ARRAY, DT_INIT_ARRAYSZ, InitArraySec);
   WriteArray(DT_FINI_ARRAY, DT_FINI_ARRAYSZ, FiniArraySec);
 
   const std::vector<std::unique_ptr<SharedFileBase>> &SharedFiles =
       SymTab.getSharedFiles();
   for (const std::unique_ptr<SharedFileBase> &File : SharedFiles)
-    WriteVal(DT_NEEDED, DynStrSec.getFileOff(File->getSoName()));
+    WriteVal(DT_NEEDED, Out<ELFT>::DynStrTab->getFileOff(File->getSoName()));
 
   if (InitSym)
-    WritePtr(DT_INIT, getSymVA(*InitSym, BssSec));
+    WritePtr(DT_INIT, getSymVA<ELFT>(*InitSym));
   if (FiniSym)
-    WritePtr(DT_FINI, getSymVA(*FiniSym, BssSec));
+    WritePtr(DT_FINI, getSymVA<ELFT>(*FiniSym));
 
   if (Config->ZNow)
     WriteVal(DT_FLAGS_1, DF_1_NOW);
 
   WriteVal(DT_NULL, 0);
 }
 
 template <class ELFT>
-OutputSection<ELFT>::OutputSection(const PltSection<ELFT> &PltSec,
-                                   const GotSection<ELFT> &GotSec,
-                                   const OutputSection<ELFT> &BssSec,
-                                   StringRef Name, uint32_t sh_type,
+OutputSection<ELFT>::OutputSection(StringRef Name, uint32_t sh_type,
                                    uintX_t sh_flags)
-    : OutputSectionBase<ELFT::Is64Bits>(Name, sh_type, sh_flags),
-      PltSec(PltSec), GotSec(GotSec), BssSec(BssSec) {}
+    : OutputSectionBase<ELFT::Is64Bits>(Name, sh_type, sh_flags) {}
 
 template <class ELFT>
 void OutputSection<ELFT>::addSection(InputSection<ELFT> *C) {
   Sections.push_back(C);
   C->setOutputSection(this);
   uint32_t Align = C->getAlign();
   if (Align > this->Header.sh_addralign)
     this->Header.sh_addralign = Align;
 
   uintX_t Off = this->Header.sh_size;
   Off = RoundUpToAlignment(Off, Align);
   C->setOutputSectionOff(Off);
   Off += C->getSize();
   this->Header.sh_size = Off;
 }
 
 template <class ELFT>
-typename ELFFile<ELFT>::uintX_t
-lld::elf2::getSymVA(const SymbolBody &S, const OutputSection<ELFT> &BssSec) {
+typename ELFFile<ELFT>::uintX_t lld::elf2::getSymVA(const SymbolBody &S) {
   switch (S.kind()) {
   case SymbolBody::DefinedSyntheticKind: {
     auto &D = cast<DefinedSynthetic<ELFT>>(S);
     return D.Section.getVA() + D.Sym.st_value;
   }
   case SymbolBody::DefinedAbsoluteKind:
     return cast<DefinedAbsolute<ELFT>>(S).Sym.st_value;
   case SymbolBody::DefinedRegularKind: {
     const auto &DR = cast<DefinedRegular<ELFT>>(S);
     const InputSection<ELFT> *SC = &DR.Section;
     OutputSection<ELFT> *OS = SC->getOutputSection();
     return OS->getVA() + SC->getOutputSectionOff() + DR.Sym.st_value;
   }
   case SymbolBody::DefinedCommonKind:
-    return BssSec.getVA() + cast<DefinedCommon<ELFT>>(S).OffsetInBSS;
+    return Out<ELFT>::Bss->getVA() + cast<DefinedCommon<ELFT>>(S).OffsetInBSS;
   case SymbolBody::SharedKind:
   case SymbolBody::UndefinedKind:
     return 0;
   case SymbolBody::LazyKind:
     assert(S.isUsedInRegularObj() && "Lazy symbol reached writer");
     return 0;
   }
   llvm_unreachable("Invalid symbol kind");
if (Body->isUndefined() && !Body->isWeak())
     return true;
   if (!Config->Shared)
     return false;
   return Body->getMostConstrainingVisibility() == STV_DEFAULT;
 }
 
 template <class ELFT> void OutputSection<ELFT>::writeTo(uint8_t *Buf) {
   for (InputSection<ELFT> *C : Sections)
-    C->writeTo(Buf, BssSec, PltSec, GotSec);
+    C->writeTo(Buf);
 }
 
 template <bool Is64Bits>
 StringTableSection<Is64Bits>::StringTableSection(bool Dynamic)
     : OutputSectionBase<Is64Bits>(Dynamic ? ".dynstr" : ".strtab",
                                   llvm::ELF::SHT_STRTAB,
                                   Dynamic ? (uintX_t)llvm::ELF::SHF_ALLOC : 0),
       Dynamic(Dynamic) {
if (Config->DiscardNone)
     return true;
 
   // ELF defines dynamic locals as symbols which name starts with ".L".
   return !(Config->DiscardLocals && SymName.startswith(".L"));
 }
 
 template <class ELFT>
 SymbolTableSection<ELFT>::SymbolTableSection(
-    SymbolTable &Table, StringTableSection<ELFT::Is64Bits> &StrTabSec,
-    const OutputSection<ELFT> &BssSec)
+    SymbolTable &Table, StringTableSection<ELFT::Is64Bits> &StrTabSec)
     : OutputSectionBase<ELFT::Is64Bits>(
           StrTabSec.isDynamic() ? ".dynsym" : ".symtab",
           StrTabSec.isDynamic() ? llvm::ELF::SHT_DYNSYM : llvm::ELF::SHT_SYMTAB,
           StrTabSec.isDynamic() ? (uintX_t)llvm::ELF::SHF_ALLOC : 0),
-      Table(Table), StrTabSec(StrTabSec), BssSec(BssSec) {
+      Table(Table), StrTabSec(StrTabSec) {
   typedef OutputSectionBase<ELFT::Is64Bits> Base;
   typename Base::HeaderT &Header = this->Header;
 
   Header.sh_entsize = sizeof(Elf_Sym);
   Header.sh_addralign = ELFT::Is64Bits ? 8 : 4;
 }
 
 template <class ELFT> void SymbolTableSection<ELFT>::finalize() {
for (const std::pair<StringRef, Symbol *> &P : Table.getSymbols()) {
     switch (Body->kind()) {
     case SymbolBody::DefinedSyntheticKind:
       OutSec = &cast<DefinedSynthetic<ELFT>>(Body)->Section;
       break;
     case SymbolBody::DefinedRegularKind:
       Section = &cast<DefinedRegular<ELFT>>(Body)->Section;
       break;
     case SymbolBody::DefinedCommonKind:
-      OutSec = &BssSec;
+      OutSec = Out<ELFT>::Bss;
       break;
     case SymbolBody::UndefinedKind:
     case SymbolBody::DefinedAbsoluteKind:
     case SymbolBody::SharedKind:
     case SymbolBody::LazyKind:
       break;
     }
 
for (const std::pair<StringRef, Symbol *> &P : Table.getSymbols()) {
 
     unsigned char Visibility = Body->getMostConstrainingVisibility();
     if (Visibility != STV_DEFAULT && Visibility != STV_PROTECTED)
       Binding = STB_LOCAL;
 
     ESym->setBindingAndType(Binding, Type);
     ESym->st_size = Size;
     ESym->setVisibility(Visibility);
-    ESym->st_value = getSymVA(*Body, BssSec);
+    ESym->st_value = getSymVA<ELFT>(*Body);
 
     if (Section)
       OutSec = Section->getOutputSection();
 
     if (isa<DefinedAbsolute<ELFT>>(Body))
       ESym->st_shndx = SHN_ABS;
     else if (OutSec)
       ESym->st_shndx = OutSec->getSectionIndex();

 template class StringTableSection<false>;
 template class StringTableSection<true>;
 
 template class SymbolTableSection<ELF32LE>;
 template class SymbolTableSection<ELF32BE>;
 template class SymbolTableSection<ELF64LE>;
 template class SymbolTableSection<ELF64BE>;
 
-template ELFFile<ELF32LE>::uintX_t getSymVA(const SymbolBody &,
-                                            const OutputSection<ELF32LE> &);
-template ELFFile<ELF32BE>::uintX_t getSymVA(const SymbolBody &,
-                                            const OutputSection<ELF32BE> &);
-template ELFFile<ELF64LE>::uintX_t getSymVA(const SymbolBody &,
-                                            const OutputSection<ELF64LE> &);
-template ELFFile<ELF64BE>::uintX_t getSymVA(const SymbolBody &,
-                                            const OutputSection<ELF64BE> &);
+template ELFFile<ELF32LE>::uintX_t getSymVA<ELF32LE>(const SymbolBody &);
+template ELFFile<ELF32BE>::uintX_t getSymVA<ELF32BE>(const SymbolBody &);
+template ELFFile<ELF64LE>::uintX_t getSymVA<ELF64LE>(const SymbolBody &);
+template ELFFile<ELF64BE>::uintX_t getSymVA<ELF64BE>(const SymbolBody &);
 
 template ELFFile<ELF32LE>::uintX_t
 getLocalSymVA(const ELFFile<ELF32LE>::Elf_Sym *, const ObjectFile<ELF32LE> &);
 
 template ELFFile<ELF32BE>::uintX_t
 getLocalSymVA(const ELFFile<ELF32BE>::Elf_Sym *, const ObjectFile<ELF32BE> &);
 
 template ELFFile<ELF64LE>::uintX_t

ELF/Target.cpp

 //===- Target.cpp ---------------------------------------------------------===//
 //
 //                             The LLVM Linker
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
-#include "Target.h"
 #include "Error.h"
 #include "Symbols.h"
+#include "Target.h"
 
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/Object/ELF.h"
 #include "llvm/Support/Endian.h"
 #include "llvm/Support/ELF.h"
 
 using namespace llvm;
 using namespace llvm::object;

ELF/Writer.cpp

ProgramHeader(uintX_t Type, uintX_t Flags, uintX_t FileOff, uintX_t VA) {
     Header.p_type = Type;
     Header.p_flags = Flags;
     Header.p_align = PageSize;
     Header.p_offset = FileOff;
     Header.p_vaddr = VA;
     Header.p_paddr = VA;
   }
 
-  void setValuesFromSection(OutputSectionBase<ELFT::Is64Bits> &Sec) {
-    Header.p_flags = toPHDRFlags(Sec.getFlags());
-    Header.p_offset = Sec.getFileOff();
-    Header.p_vaddr = Sec.getVA();
+  void setValuesFromSection(OutputSectionBase<ELFT::Is64Bits> *Sec) {
+    Header.p_flags = toPHDRFlags(Sec->getFlags());
+    Header.p_offset = Sec->getFileOff();
+    Header.p_vaddr = Sec->getVA();
     Header.p_paddr = Header.p_vaddr;
-    Header.p_filesz = Sec.getSize();
+    Header.p_filesz = Sec->getSize();
     Header.p_memsz = Header.p_filesz;
-    Header.p_align = Sec.getAlign();
+    Header.p_align = Sec->getAlign();
   }
 
   Elf_Phdr Header;
   bool Closed = false;
 };
 
 // The writer writes a SymbolTable result to a file.
 template <class ELFT> class Writer {
 public:
   typedef typename ELFFile<ELFT>::uintX_t uintX_t;
   typedef typename ELFFile<ELFT>::Elf_Shdr Elf_Shdr;
   typedef typename ELFFile<ELFT>::Elf_Ehdr Elf_Ehdr;
   typedef typename ELFFile<ELFT>::Elf_Phdr Elf_Phdr;
   typedef typename ELFFile<ELFT>::Elf_Sym Elf_Sym;
   typedef typename ELFFile<ELFT>::Elf_Sym_Range Elf_Sym_Range;
   typedef typename ELFFile<ELFT>::Elf_Rela Elf_Rela;
-  Writer(SymbolTable *T)
-      : SymTabSec(*T, StrTabSec, BssSec), DynSymSec(*T, DynStrSec, BssSec),
-        RelaDynSec(DynSymSec, GotSec, BssSec, T->shouldUseRela()),
-        GotSec(BssSec), PltSec(GotSec), HashSec(DynSymSec),
-        DynamicSec(*T, HashSec, RelaDynSec, BssSec),
-        BssSec(PltSec, GotSec, BssSec, ".bss", SHT_NOBITS,
-               SHF_ALLOC | SHF_WRITE) {}
   void run();
 
 private:
   void createSections();
   template <bool isRela>
   void scanRelocs(const InputSection<ELFT> &C,
                   iterator_range<const Elf_Rel_Impl<ELFT, isRela> *> Rels);
   void scanRelocs(const InputSection<ELFT> &C);
   void assignAddresses();
   void openFile(StringRef OutputPath);
   void writeHeader();
   void writeSections();
   bool needsInterpSection() const {
-    return !SymTabSec.getSymTable().getSharedFiles().empty() &&
+    return !Out<ELFT>::SymTab->getSymTable().getSharedFiles().empty() &&
            !Config->DynamicLinker.empty();
   }
   bool isOutputDynamic() const {
-    return !SymTabSec.getSymTable().getSharedFiles().empty() || Config->Shared;
+    return !Out<ELFT>::SymTab->getSymTable().getSharedFiles().empty() ||
+           Config->Shared;
   }
   bool needsDynamicSections() const { return isOutputDynamic(); }
   unsigned getVAStart() const { return Config->Shared ? 0 : VAStart; }
 
   std::unique_ptr<llvm::FileOutputBuffer> Buffer;
 
   llvm::SpecificBumpPtrAllocator<OutputSection<ELFT>> CAlloc;
   std::vector<OutputSectionBase<ELFT::Is64Bits> *> OutputSections;
   unsigned getNumSections() const { return OutputSections.size() + 1; }
 
   llvm::BumpPtrAllocator PAlloc;
   std::vector<ProgramHeader<ELFT> *> PHDRs;
   ProgramHeader<ELFT> FileHeaderPHDR{PT_LOAD, PF_R, 0, 0};
   ProgramHeader<ELFT> InterpPHDR{PT_INTERP, 0, 0, 0};
   ProgramHeader<ELFT> DynamicPHDR{PT_DYNAMIC, 0, 0, 0};
 
   uintX_t FileSize;
   uintX_t ProgramHeaderOff;
   uintX_t SectionHeaderOff;
+};
+} // anonymous namespace
 
-  StringTableSection<ELFT::Is64Bits> StrTabSec = { /*dynamic=*/false };
-  StringTableSection<ELFT::Is64Bits> DynStrSec = { /*dynamic=*/true };
-
-  lld::elf2::SymbolTableSection<ELFT> SymTabSec;
-  lld::elf2::SymbolTableSection<ELFT> DynSymSec;
-
-  RelocationSection<ELFT> RelaDynSec;
-
-  GotSection<ELFT> GotSec;
-  PltSection<ELFT> PltSec;
-
-  HashTableSection<ELFT> HashSec;
-
-  DynamicSection<ELFT> DynamicSec;
 
-  InterpSection<ELFT::Is64Bits> InterpSec;
+template <class ELFT>
+static void doWriteResult(SymbolTable *Symtab) {
+  // Initialize output sections that are handled by Writer specially.
+  // Don't reorder because the order of initialization matters.
+  InterpSection<ELFT::Is64Bits> Interp;
+  Out<ELFT>::Interp = &Interp;
+  StringTableSection<ELFT::Is64Bits> StrTab(false);
+  Out<ELFT>::StrTab = &StrTab;
+  StringTableSection<ELFT::Is64Bits> DynStrTab(true);
+  Out<ELFT>::DynStrTab = &DynStrTab;
+  OutputSection<ELFT> Bss(".bss", SHT_NOBITS, SHF_ALLOC | SHF_WRITE);
+  Out<ELFT>::Bss = &Bss;
+  GotSection<ELFT> Got;
+  Out<ELFT>::Got = &Got;
+  PltSection<ELFT> Plt;
+  Out<ELFT>::Plt = &Plt;
+  SymbolTableSection<ELFT> SymTab(*Symtab, *Out<ELFT>::StrTab);
+  Out<ELFT>::SymTab = &SymTab;
+  SymbolTableSection<ELFT> DynSymTab(*Symtab, *Out<ELFT>::DynStrTab);
+  Out<ELFT>::DynSymTab = &DynSymTab;
+  HashTableSection<ELFT> HashTab;
+  Out<ELFT>::HashTab = &HashTab;
+  RelocationSection<ELFT> RelaDyn(Symtab->shouldUseRela());
+  Out<ELFT>::RelaDyn = &RelaDyn;
+  DynamicSection<ELFT> Dynamic(*Symtab);
+  Out<ELFT>::Dynamic = &Dynamic;
 
-  OutputSection<ELFT> BssSec;
-};
-} // anonymous namespace
+  Writer<ELFT>().run();
+}
 
 void lld::elf2::writeResult(SymbolTable *Symtab) {
   switch (Symtab->getFirstELF()->getELFKind()) {
   case ELF32LEKind:
-    Writer<object::ELF32LE>(Symtab).run();
+    doWriteResult<object::ELF32LE>(Symtab);
     return;
   case ELF32BEKind:
-    Writer<object::ELF32BE>(Symtab).run();
+    doWriteResult<object::ELF32BE>(Symtab);
     return;
   case ELF64LEKind:
-    Writer<object::ELF64LE>(Symtab).run();
+    doWriteResult<object::ELF64LE>(Symtab);
     return;
   case ELF64BEKind:
-    Writer<object::ELF64BE>(Symtab).run();
+    doWriteResult<object::ELF64BE>(Symtab);
     return;
   default:
     llvm_unreachable("Invalid kind");
   }
 }
 
 // The main function of the writer.
 template <class ELFT> void Writer<ELFT>::run() {
void Writer<ELFT>::scanRelocs(
   for (const RelType &RI : Rels) {
     uint32_t SymIndex = RI.getSymbol(IsMips64EL);
     SymbolBody *Body = File.getSymbolBody(SymIndex);
     uint32_t Type = RI.getType(IsMips64EL);
     if (Body) {
       if (Target->relocNeedsPlt(Type, *Body)) {
         if (Body->isInPlt())
           continue;
-        PltSec.addEntry(Body);
+        Out<ELFT>::Plt->addEntry(Body);
       }
       if (Target->relocNeedsGot(Type, *Body)) {
         if (Body->isInGot())
           continue;
-        GotSec.addEntry(Body);
+        Out<ELFT>::Got->addEntry(Body);
       }
     }
     if (canBePreempted(Body)) {
       Body->setUsedInDynamicReloc();
-      RelaDynSec.addReloc({C, RI});
+      Out<ELFT>::RelaDyn->addReloc({C, RI});
     } else if (Config->Shared && !Target->isRelRelative(Type)) {
-      RelaDynSec.addReloc({C, RI});
+      Out<ELFT>::RelaDyn->addReloc({C, RI});
     }
   }
 }
 
 template <class ELFT>
 void Writer<ELFT>::scanRelocs(const InputSection<ELFT> &C) {
   ObjectFile<ELFT> *File = C.getFile();
   ELFFile<ELFT> &EObj = File->getObj();
static void reportUndefined(const SymbolTable &S, const SymbolBody &Sym) {
   else
     error(Message);
 }
 
 // Create output section objects and add them to OutputSections.
 template <class ELFT> void Writer<ELFT>::createSections() {
   SmallDenseMap<SectionKey<ELFT::Is64Bits>, OutputSection<ELFT> *> Map;
 
-  OutputSections.push_back(&BssSec);
-  Map[{BssSec.getName(), BssSec.getType(), BssSec.getFlags()}] = &BssSec;
+  OutputSections.push_back(Out<ELFT>::Bss);
+  Map[{Out<ELFT>::Bss->getName(), Out<ELFT>::Bss->getType(),
+       Out<ELFT>::Bss->getFlags()}] = Out<ELFT>::Bss;
 
-  SymbolTable &Symtab = SymTabSec.getSymTable();
+  SymbolTable &Symtab = Out<ELFT>::SymTab->getSymTable();
 
   // Declare linker generated symbols.
   // This must be done before the relocation scan to make sure we can correctly
   // decide if a dynamic relocation is needed or not.
   // FIXME: Make this more declarative.
   for (StringRef Name :
        {"__preinit_array_start", "__preinit_array_end", "__init_array_start",
         "__init_array_end", "__fini_array_start", "__fini_array_end"})
     Symtab.addIgnoredSym<ELFT>(Name);
 
   // __tls_get_addr is defined by the dynamic linker for dynamic ELFs. For
   // static linking the linker is required to optimize away any references to
   // __tls_get_addr, so it's not defined anywhere. Create a hidden definition
   // to avoid the undefined symbol error.
   if (!isOutputDynamic())
     Symtab.addIgnoredSym<ELFT>("__tls_get_addr");
 
   for (const std::unique_ptr<ObjectFileBase> &FileB : Symtab.getObjectFiles()) {
     auto &File = cast<ObjectFile<ELFT>>(*FileB);
     if (!Config->DiscardAll) {
       Elf_Sym_Range Syms = File.getLocalSymbols();
       for (const Elf_Sym &Sym : Syms) {
         ErrorOr<StringRef> SymName = Sym.getName(File.getStringTable());
         if (SymName && shouldKeepInSymtab<ELFT>(*SymName, Sym))
-          SymTabSec.addSymbol(*SymName, true);
+          Out<ELFT>::SymTab->addSymbol(*SymName, true);
       }
     }
     for (InputSection<ELFT> *C : File.getSections()) {
       if (!C)
         continue;
       const Elf_Shdr *H = C->getSectionHdr();
       SectionKey<ELFT::Is64Bits> Key{C->getSectionName(), H->sh_type,
                                      H->sh_flags};
       OutputSection<ELFT> *&Sec = Map[Key];
       if (!Sec) {
-        Sec = new (CAlloc.Allocate()) OutputSection<ELFT>(
-            PltSec, GotSec, BssSec, Key.Name, Key.Type, Key.Flags);
+        Sec = new (CAlloc.Allocate())
+            OutputSection<ELFT>(Key.Name, Key.Type, Key.Flags);
         OutputSections.push_back(Sec);
       }
       Sec->addSection(C);
       scanRelocs(*C);
     }
   }
 
-  DynamicSec.PreInitArraySec =
+  Out<ELFT>::Dynamic->PreInitArraySec =
       Map.lookup({".preinit_array", SHT_PREINIT_ARRAY, SHF_WRITE | SHF_ALLOC});
-  DynamicSec.InitArraySec =
+  Out<ELFT>::Dynamic->InitArraySec =
       Map.lookup({".init_array", SHT_INIT_ARRAY, SHF_WRITE | SHF_ALLOC});
-  DynamicSec.FiniArraySec =
+  Out<ELFT>::Dynamic->FiniArraySec =
       Map.lookup({".fini_array", SHT_FINI_ARRAY, SHF_WRITE | SHF_ALLOC});
 
   auto AddStartEnd = [&Symtab](StringRef Start, StringRef End,
                                OutputSection<ELFT> *OS) {
     if (OS) {
       Symtab.addSyntheticSym<ELFT>(Start, *OS, 0);
       Symtab.addSyntheticSym<ELFT>(End, *OS, OS->getSize());
     }
   };
 
   AddStartEnd("__preinit_array_start", "__preinit_array_end",
-              DynamicSec.PreInitArraySec);
+              Out<ELFT>::Dynamic->PreInitArraySec);
   AddStartEnd("__init_array_start", "__init_array_end",
-              DynamicSec.InitArraySec);
+              Out<ELFT>::Dynamic->InitArraySec);
   AddStartEnd("__fini_array_start", "__fini_array_end",
-              DynamicSec.FiniArraySec);
+              Out<ELFT>::Dynamic->FiniArraySec);
 
   // FIXME: Try to avoid the extra walk over all global symbols.
   std::vector<DefinedCommon<ELFT> *> CommonSymbols;
   for (auto &P : Symtab.getSymbols()) {
     StringRef Name = P.first;
     SymbolBody *Body = P.second->Body;
     if (auto *U = dyn_cast<Undefined<ELFT>>(Body)) {
       if (!U->isWeak() && !U->canKeepUndefined())
         reportUndefined<ELFT>(Symtab, *Body);
     }
 
     if (auto *C = dyn_cast<DefinedCommon<ELFT>>(Body))
       CommonSymbols.push_back(C);
     if (!includeInSymtab<ELFT>(*Body))
       continue;
-    SymTabSec.addSymbol(Name);
+    Out<ELFT>::SymTab->addSymbol(Name);
 
     if (needsDynamicSections() && includeInDynamicSymtab(*Body))
-      HashSec.addSymbol(Body);
+      Out<ELFT>::HashTab->addSymbol(Body);
   }
 
   // Sort the common symbols by alignment as an heuristic to pack them better.
   std::stable_sort(
       CommonSymbols.begin(), CommonSymbols.end(),
       [](const DefinedCommon<ELFT> *A, const DefinedCommon<ELFT> *B) {
         return A->MaxAlignment > B->MaxAlignment;
       });
 
-  uintX_t Off = BssSec.getSize();
+  uintX_t Off = Out<ELFT>::Bss->getSize();
   for (DefinedCommon<ELFT> *C : CommonSymbols) {
     const Elf_Sym &Sym = C->Sym;
     uintX_t Align = C->MaxAlignment;
     Off = RoundUpToAlignment(Off, Align);
     C->OffsetInBSS = Off;
     Off += Sym.st_size;
   }
 
-  BssSec.setSize(Off);
+  Out<ELFT>::Bss->setSize(Off);
 
-  OutputSections.push_back(&SymTabSec);
+  OutputSections.push_back(Out<ELFT>::SymTab);
 
   if (needsDynamicSections()) {
     if (needsInterpSection())
-      OutputSections.push_back(&InterpSec);
-    OutputSections.push_back(&DynSymSec);
-    OutputSections.push_back(&HashSec);
-    OutputSections.push_back(&DynamicSec);
-    OutputSections.push_back(&DynStrSec);
-    if (RelaDynSec.hasRelocs())
-      OutputSections.push_back(&RelaDynSec);
-  }
-  if (!GotSec.empty())
-    OutputSections.push_back(&GotSec);
-  if (!PltSec.empty())
-    OutputSections.push_back(&PltSec);
+      OutputSections.push_back(Out<ELFT>::Interp);
+    OutputSections.push_back(Out<ELFT>::DynSymTab);
+    OutputSections.push_back(Out<ELFT>::HashTab);
+    OutputSections.push_back(Out<ELFT>::Dynamic);
+    OutputSections.push_back(Out<ELFT>::DynStrTab);
+    if (Out<ELFT>::RelaDyn->hasRelocs())
+      OutputSections.push_back(Out<ELFT>::RelaDyn);
+  }
+  if (!Out<ELFT>::Got->empty())
+    OutputSections.push_back(Out<ELFT>::Got);
+  if (!Out<ELFT>::Plt->empty())
+    OutputSections.push_back(Out<ELFT>::Plt);
 
   std::stable_sort(
       OutputSections.begin(), OutputSections.end(),
       [](OutputSectionBase<ELFT::Is64Bits> *A,
          OutputSectionBase<ELFT::Is64Bits> *B) {
         uintX_t AFlags = A->getFlags();
         uintX_t BFlags = B->getFlags();
 
std::stable_sort(
         // them is a p_memsz that is larger than p_filesz. Seeing that it
         // zeros the end of the PT_LOAD, so that has to correspond to the
         // nobits sections.
         return A->getType() != SHT_NOBITS && B->getType() == SHT_NOBITS;
       });
 
   // Always put StrTabSec last so that no section names are added to it after
   // it's finalized.
-  OutputSections.push_back(&StrTabSec);
+  OutputSections.push_back(Out<ELFT>::StrTab);
 
   for (unsigned I = 0, N = OutputSections.size(); I < N; ++I)
     OutputSections[I]->setSectionIndex(I + 1);
 
-  // Fill the DynStrSec early.
-  DynamicSec.finalize();
+  // Fill the DynStrTab early.
+  Out<ELFT>::Dynamic->finalize();
 }
 
 template <class ELFT>
 static bool needsPHDR(OutputSectionBase<ELFT::Is64Bits> *Sec) {
   return Sec->getFlags() & SHF_ALLOC;
 }
 
 // Visits all sections to assign incremental, non-overlapping RVAs and
template <class ELFT> void Writer<ELFT>::assignAddresses() {
 
   // Create a PHDR for the file header.
   PHDRs.push_back(&FileHeaderPHDR);
   FileHeaderPHDR.Header.p_vaddr = getVAStart();
   FileHeaderPHDR.Header.p_paddr = getVAStart();
   FileHeaderPHDR.Header.p_align = PageSize;
 
   for (OutputSectionBase<ELFT::Is64Bits> *Sec : OutputSections) {
-    StrTabSec.add(Sec->getName());
+    Out<ELFT>::StrTab->add(Sec->getName());
     Sec->finalize();
 
     if (Sec->getSize()) {
       uintX_t Flags = toPHDRFlags(Sec->getFlags());
       ProgramHeader<ELFT> *Last = PHDRs.back();
       if (Last->Header.p_flags != Flags || !needsPHDR<ELFT>(Sec)) {
         // Flags changed. End current PHDR and potentially create a new one.
         if (!Last->Closed) {
template <class ELFT> void Writer<ELFT>::writeHeader() {
   EHdr->e_ident[EI_MAG2] = 0x4C;
   EHdr->e_ident[EI_MAG3] = 0x46;
   EHdr->e_ident[EI_CLASS] = ELFT::Is64Bits ? ELFCLASS64 : ELFCLASS32;
   EHdr->e_ident[EI_DATA] = ELFT::TargetEndianness == llvm::support::little
                                ? ELFDATA2LSB
                                : ELFDATA2MSB;
   EHdr->e_ident[EI_VERSION] = EV_CURRENT;
 
-  const SymbolTable &Symtab = SymTabSec.getSymTable();
+  const SymbolTable &Symtab = Out<ELFT>::SymTab->getSymTable();
   auto &FirstObj = cast<ObjectFile<ELFT>>(*Symtab.getFirstELF());
   EHdr->e_ident[EI_OSABI] = FirstObj.getOSABI();
 
   // FIXME: Generalize the segment construction similar to how we create
   // output sections.
 
   EHdr->e_type = Config->Shared ? ET_DYN : ET_EXEC;
   EHdr->e_machine = FirstObj.getEMachine();
   EHdr->e_version = EV_CURRENT;
   SymbolBody *Entry = Symtab.getEntrySym();
-  EHdr->e_entry =
-      Entry ? getSymVA(cast<ELFSymbolBody<ELFT>>(*Entry), BssSec) : 0;
+  EHdr->e_entry = Entry ? getSymVA<ELFT>(cast<ELFSymbolBody<ELFT>>(*Entry)) : 0;
   EHdr->e_phoff = ProgramHeaderOff;
   EHdr->e_shoff = SectionHeaderOff;
   EHdr->e_ehsize = sizeof(Elf_Ehdr);
   EHdr->e_phentsize = sizeof(Elf_Phdr);
   EHdr->e_phnum = PHDRs.size();
   EHdr->e_shentsize = sizeof(Elf_Shdr);
   EHdr->e_shnum = getNumSections();
-  EHdr->e_shstrndx = StrTabSec.getSectionIndex();
+  EHdr->e_shstrndx = Out<ELFT>::StrTab->getSectionIndex();
 
   // If nothing was merged into the file header PT_LOAD, set the size correctly.
   if (FileHeaderPHDR.Header.p_filesz == PageSize) {
     uint64_t Size = sizeof(Elf_Ehdr) + sizeof(Elf_Phdr) * PHDRs.size();
     FileHeaderPHDR.Header.p_filesz = Size;
     FileHeaderPHDR.Header.p_memsz = Size;
   }
 
   if (needsInterpSection())
-    InterpPHDR.setValuesFromSection(InterpSec);
+    InterpPHDR.setValuesFromSection(Out<ELFT>::Interp);
   if (needsDynamicSections())
-    DynamicPHDR.setValuesFromSection(DynamicSec);
+    DynamicPHDR.setValuesFromSection(Out<ELFT>::Dynamic);
 
   auto PHdrs = reinterpret_cast<Elf_Phdr *>(Buf + EHdr->e_phoff);
   for (ProgramHeader<ELFT> *PHDR : PHDRs)
     *PHdrs++ = PHDR->Header;
 
   auto SHdrs = reinterpret_cast<Elf_Shdr *>(Buf + EHdr->e_shoff);
   // First entry is null.
   ++SHdrs;
   for (OutputSectionBase<ELFT::Is64Bits> *Sec : OutputSections) {
-    Sec->setNameOffset(StrTabSec.getFileOff(Sec->getName()));
+    Sec->setNameOffset(Out<ELFT>::StrTab->getFileOff(Sec->getName()));
     Sec->template writeHeaderTo<ELFT::TargetEndianness>(SHdrs++);
   }
 }
 
 template <class ELFT> void Writer<ELFT>::openFile(StringRef Path) {
   ErrorOr<std::unique_ptr<FileOutputBuffer>> BufferOrErr =
       FileOutputBuffer::create(Path, FileSize, FileOutputBuffer::F_executable);
   error(BufferOrErr, Twine("failed to open ") + Path);