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

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

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/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() {
     // The ELF spec states that a value of 0 means the section has no alignment
     // constraits.
     return std::max<uintX_t>(Header->sh_addralign, 1);
   }
   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;
 
 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> *Out = nullptr;
+  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 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;
+        SymVA = Out<ELFT>::Got->getVA();
         Type = Target->getPCRelReloc();
       } else if (isa<SharedSymbol<ELFT>>(Body)) {
         continue;
       }
     }
 
     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.
   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 = 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);
   }
 }
 
 template <class ELFT> StringRef InputSection<ELFT>::getSectionName() const {
   ErrorOr<StringRef> Name = File->getObj().getSectionName(Header);
   error(Name);
   return *Name;
 }

ELF/OutputSections.h

 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);
+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);
 
 template <class ELFT> bool includeInSymtab(const SymbolBody &B);
 

 };
 
 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);
-
-  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; }
 
 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 {
-    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) {
     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 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

ELF/OutputSections.cpp

 
 using namespace llvm;
 using namespace llvm::object;
 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>
 typename GotSection<ELFT>::uintX_t
 GotSection<ELFT>::getEntryAddr(const SymbolBody &B) const {
   return this->getVA() + B.getGotIndex() * this->getAddrSize();
 }
 
 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;
 }
 
 static bool isLocalDefinition(const SymbolBody *Body) {
   if (!Body)
     return true;
   return !Body->isShared() && !Body->isUndefined();
 }
 
 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) {
     auto *P = reinterpret_cast<Elf_Rel *>(Buf);
     Buf += EntrySize;
 
     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);
     const ELFFile<ELFT> &Obj = File.getObj();
 
     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;
 
       if (!isLocalDefinition(Body)) {
         P->setSymbolAndType(Body->getDynamicSymbolTableIndex(), Type,
                             IsMips64EL);
       } else {
         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);
         }
       }
       if (IsRela)
         static_cast<Elf_Rela *>(P)->r_addend = Addent;
     }
   }
 }
 
 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 = 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;
 }
 
 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));
 
   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) {
+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;
   }
 }
lld::elf2::getLocalSymVA(const typename ELFFile<ELFT>::Elf_Sym *Sym,
   ArrayRef<InputSection<ELFT> *> Sections = File.getSections();
   InputSection<ELFT> *Section = Sections[SecIndex];
   OutputSection<ELFT> *Out = Section->getOutputSection();
   return Out->getVA() + Section->getOutputSectionOff() + Sym->st_value;
 }
 
 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() {
+  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);
 
   // All symbols with STB_LOCAL binding precede the weak and global symbols.
   // .dynsym only contains global symbols.
   if (!Config->DiscardAll && !StrTabSec.isDynamic())
     writeLocalSymbols(Buf);
 
for (const std::pair<StringRef, Symbol *> &P : Table.getSymbols()) {
     if (StrTabSec.isDynamic() && !includeInDynamicSymtab(*Body))
       continue;
 
     auto *ESym = reinterpret_cast<Elf_Sym *>(Buf);
     Buf += sizeof(*ESym);
 
     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:
     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)
-      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(
         reinterpret_cast<Elf_Sym *>(Start), reinterpret_cast<Elf_Sym *>(Buf),
         [](const Elf_Sym &A, const Elf_Sym &B) -> bool {
           return A.getBinding() == STB_LOCAL && B.getBinding() != STB_LOCAL;
         });
 }

 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

 template bool shouldKeepInSymtab<ELF32LE>(StringRef,
                                           const ELFFile<ELF32LE>::Elf_Sym &);
 template bool shouldKeepInSymtab<ELF32BE>(StringRef,
                                           const ELFFile<ELF32BE>::Elf_Sym &);
 template bool shouldKeepInSymtab<ELF64LE>(StringRef,
                                           const ELFFile<ELF64LE>::Elf_Sym &);
 template bool shouldKeepInSymtab<ELF64BE>(StringRef,
                                           const ELFFile<ELF64BE>::Elf_Sym &);
+
 }
 }

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()),
-        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 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; }
 
   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;
-
-  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 *);
-
-} // namespace elf2
-} // namespace lld
+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();
+}
+
+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() {
   createSections();
   assignAddresses();
   openFile(Config->OutputFile);
   writeHeader();
   writeSections();
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);
         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});
   }
 }
 
 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();
   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());
     } else {
       Symtab.addIgnoredSym<ELFT>(Start);
       Symtab.addIgnoredSym<ELFT>(End);
     }
   };
 
   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);