Index: ELF/InputSection.h
===================================================================
--- ELF/InputSection.h
+++ ELF/InputSection.h
@@ -18,8 +18,6 @@
 
 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 {
@@ -37,8 +35,7 @@
 
   // 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; }
@@ -53,8 +50,8 @@
   }
   void setOutputSectionOff(uint64_t V) { OutputSectionOff = V; }
 
-  void setOutputSection(OutputSection<ELFT> *O) { Out = O; }
-  OutputSection<ELFT> *getOutputSection() const { return Out; }
+  void setOutputSection(OutputSection<ELFT> *O) { OutSec = O; }
+  OutputSection<ELFT> *getOutputSection() const { return OutSec; }
 
   // Relocation sections that refer to this one.
   SmallVector<const Elf_Shdr *, 1> RelocSections;
@@ -64,9 +61,7 @@
   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.
@@ -75,7 +70,7 @@
   // The file this section is from.
   ObjectFile<ELFT> *File;
 
-  OutputSection<ELFT> *Out = nullptr;
+  OutputSection<ELFT> *OutSec = nullptr;
 
   const Elf_Shdr *Header;
 };
Index: ELF/InputSection.cpp
===================================================================
--- ELF/InputSection.cpp
+++ ELF/InputSection.cpp
@@ -29,15 +29,12 @@
 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 SymVA;
 
     // Handle relocations for local symbols -- they never get
@@ -50,15 +47,15 @@
       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;
+        SymVA = Out<ELFT>::Got->getVA();
         Type = Target->getPCRelReloc();
       } else if (isa<SharedSymbol<ELFT>>(Body)) {
         continue;
@@ -66,15 +63,12 @@
     }
 
     Target->relocateOne(Buf, reinterpret_cast<const void *>(&RI), Type,
-                        BaseAddr, SymVA, GotVA);
+                        BaseAddr, SymVA, Out<ELFT>::Got->getVA());
   }
 }
 
 template <class ELFT>
-void InputSection<ELFT>::writeTo(uint8_t *Buf,
-                                 const OutputSection<ELFT> &BssSec,
-                                 const PltSection<ELFT> &PltSec,
-                                 const GotSection<ELFT> &GotSec) {
+void InputSection<ELFT>::writeTo(uint8_t *Buf) {
   if (Header->sh_type == SHT_NOBITS)
     return;
   // Copy section contents from source object file to output file.
@@ -84,15 +78,13 @@
   ObjectFile<ELFT> *File = getFile();
   ELFFile<ELFT> &EObj = File->getObj();
   uint8_t *Base = Buf + getOutputSectionOff();
-  uintX_t BaseAddr = Out->getVA() + 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);
   }
 }
 
Index: ELF/OutputSections.h
===================================================================
--- ELF/OutputSections.h
+++ ELF/OutputSections.h
@@ -34,7 +34,7 @@
 
 template <class ELFT>
 typename llvm::object::ELFFile<ELFT>::uintX_t
-getSymVA(const SymbolBody &S, const OutputSection<ELFT> &BssSec);
+getSymVA(const SymbolBody &S);
 
 template <class ELFT>
 typename llvm::object::ELFFile<ELFT>::uintX_t
@@ -122,7 +122,7 @@
   typedef typename Base::uintX_t uintX_t;
 
 public:
-  PltSection(const GotSection<ELFT> &GotSec);
+  PltSection();
   void finalize() override {
     this->Header.sh_size = Entries.size() * EntrySize;
   }
@@ -134,7 +134,6 @@
 
 private:
   std::vector<const SymbolBody *> Entries;
-  const GotSection<ELFT> &GotSec;
 };
 
 template <class ELFT> struct DynamicReloc {
@@ -151,26 +150,12 @@
   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);
-
-  void finalize() override {
-    this->Header.sh_size = getNumSymbols() * sizeof(Elf_Sym);
-    this->Header.sh_link = StrTabSec.getSectionIndex();
-    this->Header.sh_info = NumLocals + 1;
-  }
+                     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) {
-    StrTabSec.add(Name);
-    ++NumVisible;
-    if (isLocal)
-      ++NumLocals;
-  }
-
+  void addSymbol(StringRef Name, bool isLocal = false);
   StringTableSection<ELFT::Is64Bits> &getStrTabSec() const { return StrTabSec; }
   unsigned getNumSymbols() const { return NumVisible + 1; }
 
@@ -182,7 +167,6 @@
   StringTableSection<ELFT::Is64Bits> &StrTabSec;
   unsigned NumVisible = 0;
   unsigned NumLocals = 0;
-  const OutputSection<ELFT> &BssSec;
 };
 
 template <class ELFT>
@@ -192,9 +176,7 @@
   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;
@@ -203,9 +185,6 @@
 
 private:
   std::vector<DynamicReloc<ELFT>> Relocs;
-  SymbolTableSection<ELFT> &DynSymSec;
-  const GotSection<ELFT> &GotSec;
-  const OutputSection<ELFT> &BssSec;
   const bool IsRela;
 };
 
@@ -217,17 +196,12 @@
   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>
@@ -265,40 +239,10 @@
   typedef typename llvm::object::ELFFile<ELFT>::Elf_Word Elf_Word;
 
 public:
-  HashTableSection(SymbolTableSection<ELFT> &DynSymSec);
+  HashTableSection();
   void addSymbol(SymbolBody *S);
-
-  void finalize() override {
-    this->Header.sh_link = DynSymSec.getSectionIndex();
-
-    assert(DynSymSec.getNumSymbols() == Hashes.size() + 1);
-    unsigned NumEntries = 2;                 // nbucket and nchain.
-    NumEntries += DynSymSec.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();
-    this->Header.sh_size = NumEntries * sizeof(Elf_Word);
-  }
-
-  void writeTo(uint8_t *Buf) override {
-    unsigned NumSymbols = DynSymSec.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;
-    }
-  }
-
-  SymbolTableSection<ELFT> &getDynSymSec() { return DynSymSec; }
+  void finalize() override;
+  void writeTo(uint8_t *Buf) override;
 
 private:
   uint32_t hash(StringRef Name) {
@@ -312,7 +256,6 @@
     }
     return H;
   }
-  SymbolTableSection<ELFT> &DynSymSec;
   std::vector<uint32_t> Hashes;
 };
 
@@ -326,9 +269,7 @@
   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;
 
@@ -337,15 +278,29 @@
   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 that, 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
Index: ELF/OutputSections.cpp
===================================================================
--- ELF/OutputSections.cpp
+++ ELF/OutputSections.cpp
@@ -19,6 +19,51 @@
 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)
@@ -48,18 +93,17 @@
 }
 
 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);
@@ -79,15 +123,12 @@
 }
 
 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;
 }
@@ -107,7 +148,7 @@
 
     const InputSection<ELFT> &C = Rel.C;
     const Elf_Rel &RI = Rel.RI;
-    OutputSection<ELFT> *Out = C.getOutputSection();
+    OutputSection<ELFT> *OutSec = C.getOutputSection();
     uint32_t SymIndex = RI.getSymbol(IsMips64EL);
     const ObjectFile<ELFT> &File = *C.getFile();
     const SymbolBody *Body = File.getSymbolBody(SymIndex);
@@ -115,11 +156,11 @@
 
     uint32_t Type = RI.getType(IsMips64EL);
     if (Body && Target->relocNeedsGot(Type, *Body)) {
-      P->r_offset = GotSec.getEntryAddr(*Body);
+      P->r_offset = Out<ELFT>::Got->getEntryAddr(*Body);
       P->setSymbolAndType(Body->getDynamicSymbolTableIndex(),
                           Target->getGotReloc(), IsMips64EL);
     } else {
-      P->r_offset = RI.r_offset + C.getOutputSectionOff() + Out->getVA();
+      P->r_offset = RI.r_offset + C.getOutputSectionOff() + OutSec->getVA();
       uintX_t Addent = 0;
       if (IsRela)
         Addent = static_cast<const Elf_Rela &>(RI).r_addend;
@@ -131,7 +172,7 @@
         P->setSymbolAndType(0, Target->getRelativeReloc(), IsMips64EL);
         if (IsRela) {
           if (Body)
-            Addent += getSymVA(cast<ELFSymbolBody<ELFT>>(*Body), BssSec);
+            Addent += getSymVA<ELFT>(cast<ELFSymbolBody<ELFT>>(*Body));
           else
             Addent += getLocalSymVA(
                 Obj.getRelocationSymbol(&RI, File.getSymbolTable()), File);
@@ -144,7 +185,7 @@
 }
 
 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;
 }
 
@@ -177,32 +218,56 @@
 }
 
 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 = Out<ELFT>::DynSymTab->getSectionIndex();
+
+  assert(Out<ELFT>::DynSymTab->getNumSymbols() == Hashes.size() + 1);
+  unsigned NumEntries = 2;                 // nbucket and nchain.
+  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 += Out<ELFT>::DynSymTab->getNumSymbols();
+  this->Header.sh_size = NumEntries * sizeof(Elf_Word);
+}
+
+template <class ELFT> void HashTableSection<ELFT>::writeTo(uint8_t *Buf) {
+  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;
@@ -213,10 +278,10 @@
     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
@@ -229,12 +294,12 @@
 
   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)
@@ -247,7 +312,7 @@
   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))
@@ -279,19 +344,19 @@
     ++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())
 
@@ -304,10 +369,10 @@
     // 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) {
@@ -323,24 +388,20 @@
   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));
 
   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) {
@@ -359,7 +420,7 @@
 
 template <class ELFT>
 typename ELFFile<ELFT>::uintX_t
-lld::elf2::getSymVA(const SymbolBody &S, const OutputSection<ELFT> &BssSec) {
+lld::elf2::getSymVA(const SymbolBody &S) {
   switch (S.kind()) {
   case SymbolBody::DefinedSyntheticKind: {
     auto &D = cast<DefinedSynthetic<ELFT>>(S);
@@ -374,7 +435,7 @@
     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;
@@ -401,7 +462,7 @@
 
 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>
@@ -456,13 +517,12 @@
 
 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;
 
@@ -470,6 +530,20 @@
   Header.sh_addralign = ELFT::Is64Bits ? 8 : 4;
 }
 
+template <class ELFT> void SymbolTableSection<ELFT>::finalize() {
+  this->Header.sh_size = getNumSymbols() * sizeof(Elf_Sym);
+  this->Header.sh_link = StrTabSec.getSectionIndex();
+  this->Header.sh_info = NumLocals + 1;
+}
+
+template <class ELFT>
+void SymbolTableSection<ELFT>::addSymbol(StringRef Name, bool isLocal) {
+  StrTabSec.add(Name);
+  ++NumVisible;
+  if (isLocal)
+    ++NumLocals;
+}
+
 template <class ELFT> void SymbolTableSection<ELFT>::writeTo(uint8_t *Buf) {
   Buf += sizeof(Elf_Sym);
 
@@ -535,18 +609,18 @@
 
     ESym->st_name = StrTabSec.getFileOff(Name);
 
-    const OutputSection<ELFT> *Out = nullptr;
+    const OutputSection<ELFT> *OutSec = nullptr;
     const InputSection<ELFT> *Section = nullptr;
 
     switch (Body->kind()) {
     case SymbolBody::DefinedSyntheticKind:
-      Out = &cast<DefinedSynthetic<ELFT>>(Body)->Section;
+      OutSec = &cast<DefinedSynthetic<ELFT>>(Body)->Section;
       break;
     case SymbolBody::DefinedRegularKind:
       Section = &cast<DefinedRegular<ELFT>>(Body)->Section;
       break;
     case SymbolBody::DefinedCommonKind:
-      Out = &BssSec;
+      OutSec = Out<ELFT>::Bss;
       break;
     case SymbolBody::UndefinedKind:
     case SymbolBody::DefinedAbsoluteKind:
@@ -572,15 +646,15 @@
     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)
-      Out = Section->getOutputSection();
+      OutSec = Section->getOutputSection();
 
     if (isa<DefinedAbsolute<ELFT>>(Body))
       ESym->st_shndx = SHN_ABS;
-    else if (Out)
-      ESym->st_shndx = Out->getSectionIndex();
+    else if (OutSec)
+      ESym->st_shndx = OutSec->getSectionIndex();
   }
   if (!StrTabSec.isDynamic())
     std::stable_sort(
@@ -645,14 +719,10 @@
 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> &);
@@ -679,5 +749,6 @@
                                           const ELFFile<ELF64LE>::Elf_Sym &);
 template bool shouldKeepInSymtab<ELF64BE>(StringRef,
                                           const ELFFile<ELF64BE>::Elf_Sym &);
+
 }
 }
Index: ELF/Target.cpp
===================================================================
--- ELF/Target.cpp
+++ ELF/Target.cpp
@@ -7,9 +7,9 @@
 //
 //===----------------------------------------------------------------------===//
 
-#include "Target.h"
 #include "Error.h"
 #include "Symbols.h"
+#include "Target.h"
 
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/Object/ELF.h"
Index: ELF/Writer.cpp
===================================================================
--- ELF/Writer.cpp
+++ ELF/Writer.cpp
@@ -58,14 +58,14 @@
     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;
@@ -82,13 +82,6 @@
   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()),
-        PltSec(GotSec), HashSec(DynSymSec),
-        DynamicSec(*T, HashSec, RelaDynSec, BssSec),
-        BssSec(PltSec, GotSec, BssSec, ".bss", SHT_NOBITS,
-               SHF_ALLOC | SHF_WRITE) {}
   void run();
 
 private:
@@ -102,11 +95,11 @@
   void writeHeader();
   void writeSections();
   bool needsInterpSection() const {
-    return !SymTabSec.getSymTable().getSharedFiles().empty() &&
+    return !Out<ELFT>::SymTab->getSymTable().getSharedFiles().empty() &&
            !Config->DynamicLinker.empty();
   }
   bool needsDynamicSections() const {
-    return !SymTabSec.getSymTable().getSharedFiles().empty() || Config->Shared;
+    return !Out<ELFT>::SymTab->getSymTable().getSharedFiles().empty() || Config->Shared;
   }
   unsigned getVAStart() const { return Config->Shared ? 0 : VAStart; }
 
@@ -125,41 +118,31 @@
   uintX_t FileSize;
   uintX_t ProgramHeaderOff;
   uintX_t SectionHeaderOff;
-
-  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;
-
-  OutputSection<ELFT> BssSec;
 };
 } // anonymous namespace
 
-namespace lld {
-namespace elf2 {
-
 template <class ELFT>
-void writeResult(SymbolTable *Symtab) { Writer<ELFT>(Symtab).run(); }
-
-template void writeResult<ELF32LE>(SymbolTable *);
-template void writeResult<ELF32BE>(SymbolTable *);
-template void writeResult<ELF64LE>(SymbolTable *);
-template void writeResult<ELF64BE>(SymbolTable *);
+void lld::elf2::writeResult(SymbolTable *Symtab) {
+  // Initialize output sections that are handled by Writer specially.
+  Out<ELFT>::Interp = new InterpSection<ELFT::Is64Bits>();
+  Out<ELFT>::StrTab = new StringTableSection<ELFT::Is64Bits>(/*dynamic=*/false);
+  Out<ELFT>::DynStrTab = new StringTableSection<ELFT::Is64Bits>(/*dynamic=*/true);
+  Out<ELFT>::Bss = new OutputSection<ELFT>(".bss", SHT_NOBITS, SHF_ALLOC | SHF_WRITE);
+  Out<ELFT>::Got = new GotSection<ELFT>();
+  Out<ELFT>::Plt = new PltSection<ELFT>();
+  Out<ELFT>::SymTab = new SymbolTableSection<ELFT>(*Symtab, *Out<ELFT>::StrTab);
+  Out<ELFT>::DynSymTab = new SymbolTableSection<ELFT>(*Symtab, *Out<ELFT>::DynStrTab);
+  Out<ELFT>::HashTab = new HashTableSection<ELFT>();
+  Out<ELFT>::RelaDyn = new RelocationSection<ELFT>(Symtab->shouldUseRela());
+  Out<ELFT>::Dynamic = new DynamicSection<ELFT>(*Symtab);
+
+  Writer<ELFT>().run();
+}
 
-} // namespace elf2
-} // namespace lld
+template void lld::elf2::writeResult<ELF32LE>(SymbolTable *);
+template void lld::elf2::writeResult<ELF32BE>(SymbolTable *);
+template void lld::elf2::writeResult<ELF64LE>(SymbolTable *);
+template void lld::elf2::writeResult<ELF64BE>(SymbolTable *);
 
 // The main function of the writer.
 template <class ELFT> void Writer<ELFT>::run() {
@@ -223,24 +206,24 @@
       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);
         Body->setUsedInDynamicReloc();
-        RelaDynSec.addReloc({C, RI});
+        Out<ELFT>::RelaDyn->addReloc({C, RI});
         continue;
       }
       if (Body->isShared()) {
         Body->setUsedInDynamicReloc();
-        RelaDynSec.addReloc({C, RI});
+        Out<ELFT>::RelaDyn->addReloc({C, RI});
         continue;
       }
     }
     if (Config->Shared && !Target->isRelRelative(Type))
-      RelaDynSec.addReloc({C, RI});
+      Out<ELFT>::RelaDyn->addReloc({C, RI});
   }
 }
 
@@ -291,10 +274,10 @@
 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();
   for (const std::unique_ptr<ObjectFileBase> &FileB : Symtab.getObjectFiles()) {
     auto &File = cast<ObjectFile<ELFT>>(*FileB);
     if (!Config->DiscardAll) {
@@ -302,7 +285,7 @@
       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()) {
@@ -313,8 +296,7 @@
                                      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);
@@ -322,11 +304,11 @@
     }
   }
 
-  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,
@@ -341,11 +323,11 @@
   };
 
   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;
@@ -361,10 +343,10 @@
       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.
@@ -374,7 +356,7 @@
         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;
@@ -383,24 +365,24 @@
     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);
+      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 (!GotSec.empty())
-    OutputSections.push_back(&GotSec);
-  if (!PltSec.empty())
-    OutputSections.push_back(&PltSec);
+  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(),
@@ -446,13 +428,13 @@
 
   // 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>
@@ -485,7 +467,7 @@
   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()) {
@@ -546,7 +528,7 @@
                                : 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();
 
@@ -557,8 +539,7 @@
   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);
@@ -566,7 +547,7 @@
   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) {
@@ -576,9 +557,9 @@
   }
 
   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)
@@ -588,7 +569,7 @@
   // 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++);
   }
 }