[lld] r295923 - Convert InputSectionBase to a class.

Rafael Espindola via llvm-commits llvm-commits at lists.llvm.org
Wed Feb 22 18:28:29 PST 2017


Author: rafael
Date: Wed Feb 22 20:28:28 2017
New Revision: 295923

URL: http://llvm.org/viewvc/llvm-project?rev=295923&view=rev
Log:
Convert InputSectionBase to a class.

Removing this template is not a big win by itself, but opens the way
for removing more templates.

Modified:
    lld/trunk/ELF/Driver.cpp
    lld/trunk/ELF/EhFrame.cpp
    lld/trunk/ELF/EhFrame.h
    lld/trunk/ELF/GdbIndex.cpp
    lld/trunk/ELF/GdbIndex.h
    lld/trunk/ELF/ICF.cpp
    lld/trunk/ELF/InputFiles.cpp
    lld/trunk/ELF/InputFiles.h
    lld/trunk/ELF/InputSection.cpp
    lld/trunk/ELF/InputSection.h
    lld/trunk/ELF/LinkerScript.cpp
    lld/trunk/ELF/LinkerScript.h
    lld/trunk/ELF/MapFile.cpp
    lld/trunk/ELF/MarkLive.cpp
    lld/trunk/ELF/OutputSections.cpp
    lld/trunk/ELF/OutputSections.h
    lld/trunk/ELF/Relocations.cpp
    lld/trunk/ELF/Relocations.h
    lld/trunk/ELF/SymbolTable.cpp
    lld/trunk/ELF/SymbolTable.h
    lld/trunk/ELF/Symbols.cpp
    lld/trunk/ELF/Symbols.h
    lld/trunk/ELF/SyntheticSections.cpp
    lld/trunk/ELF/SyntheticSections.h
    lld/trunk/ELF/Target.cpp
    lld/trunk/ELF/Thunks.cpp
    lld/trunk/ELF/Writer.cpp
    lld/trunk/ELF/Writer.h

Modified: lld/trunk/ELF/Driver.cpp
URL: http://llvm.org/viewvc/llvm-project/lld/trunk/ELF/Driver.cpp?rev=295923&r1=295922&r2=295923&view=diff
==============================================================================
--- lld/trunk/ELF/Driver.cpp (original)
+++ lld/trunk/ELF/Driver.cpp Wed Feb 22 20:28:28 2017
@@ -844,7 +844,7 @@ template <class ELFT> void LinkerDriver:
   // Beyond this point, no new files are added.
   // Aggregate all input sections into one place.
   for (elf::ObjectFile<ELFT> *F : Symtab.getObjectFiles())
-    for (InputSectionBase<ELFT> *S : F->getSections())
+    for (InputSectionBase *S : F->getSections())
       if (S && S != &InputSection<ELFT>::Discarded)
         Symtab.Sections.push_back(S);
   for (BinaryFile *F : Symtab.getBinaryFiles())
@@ -860,11 +860,11 @@ template <class ELFT> void LinkerDriver:
   // MergeInputSection::splitIntoPieces needs to be called before
   // any call of MergeInputSection::getOffset. Do that.
   forEach(Symtab.Sections.begin(), Symtab.Sections.end(),
-          [](InputSectionBase<ELFT> *S) {
+          [](InputSectionBase *S) {
             if (!S->Live)
               return;
             if (Decompressor::isCompressedELFSection(S->Flags, S->Name))
-              S->uncompress();
+              S->uncompress<ELFT>();
             if (auto *MS = dyn_cast<MergeInputSection<ELFT>>(S))
               MS->splitIntoPieces();
           });

Modified: lld/trunk/ELF/EhFrame.cpp
URL: http://llvm.org/viewvc/llvm-project/lld/trunk/ELF/EhFrame.cpp?rev=295923&r1=295922&r2=295923&view=diff
==============================================================================
--- lld/trunk/ELF/EhFrame.cpp (original)
+++ lld/trunk/ELF/EhFrame.cpp Wed Feb 22 20:28:28 2017
@@ -38,13 +38,14 @@ using namespace lld::elf;
 namespace {
 template <class ELFT> class EhReader {
 public:
-  EhReader(InputSectionBase<ELFT> *S, ArrayRef<uint8_t> D) : IS(S), D(D) {}
+  EhReader(InputSectionBase *S, ArrayRef<uint8_t> D) : IS(S), D(D) {}
   size_t readEhRecordSize();
   uint8_t getFdeEncoding();
 
 private:
   template <class P> void failOn(const P *Loc, const Twine &Msg) {
-    fatal(IS->getLocation((const uint8_t *)Loc - IS->Data.data()) + ": " + Msg);
+    fatal(IS->getLocation<ELFT>((const uint8_t *)Loc - IS->Data.data()) + ": " +
+          Msg);
   }
 
   uint8_t readByte();
@@ -53,13 +54,13 @@ private:
   void skipLeb128();
   void skipAugP();
 
-  InputSectionBase<ELFT> *IS;
+  InputSectionBase *IS;
   ArrayRef<uint8_t> D;
 };
 }
 
 template <class ELFT>
-size_t elf::readEhRecordSize(InputSectionBase<ELFT> *S, size_t Off) {
+size_t elf::readEhRecordSize(InputSectionBase *S, size_t Off) {
   return EhReader<ELFT>(S, S->Data.slice(Off)).readEhRecordSize();
 }
 
@@ -153,7 +154,7 @@ template <class ELFT> void EhReader<ELFT
 }
 
 template <class ELFT> uint8_t elf::getFdeEncoding(EhSectionPiece *P) {
-  auto *IS = static_cast<InputSectionBase<ELFT> *>(P->ID);
+  auto *IS = static_cast<InputSectionBase *>(P->ID);
   return EhReader<ELFT>(IS, P->data()).getFdeEncoding();
 }
 
@@ -200,14 +201,10 @@ template <class ELFT> uint8_t EhReader<E
   return DW_EH_PE_absptr;
 }
 
-template size_t elf::readEhRecordSize<ELF32LE>(InputSectionBase<ELF32LE> *S,
-                                               size_t Off);
-template size_t elf::readEhRecordSize<ELF32BE>(InputSectionBase<ELF32BE> *S,
-                                               size_t Off);
-template size_t elf::readEhRecordSize<ELF64LE>(InputSectionBase<ELF64LE> *S,
-                                               size_t Off);
-template size_t elf::readEhRecordSize<ELF64BE>(InputSectionBase<ELF64BE> *S,
-                                               size_t Off);
+template size_t elf::readEhRecordSize<ELF32LE>(InputSectionBase *S, size_t Off);
+template size_t elf::readEhRecordSize<ELF32BE>(InputSectionBase *S, size_t Off);
+template size_t elf::readEhRecordSize<ELF64LE>(InputSectionBase *S, size_t Off);
+template size_t elf::readEhRecordSize<ELF64BE>(InputSectionBase *S, size_t Off);
 
 template uint8_t elf::getFdeEncoding<ELF32LE>(EhSectionPiece *P);
 template uint8_t elf::getFdeEncoding<ELF32BE>(EhSectionPiece *P);

Modified: lld/trunk/ELF/EhFrame.h
URL: http://llvm.org/viewvc/llvm-project/lld/trunk/ELF/EhFrame.h?rev=295923&r1=295922&r2=295923&view=diff
==============================================================================
--- lld/trunk/ELF/EhFrame.h (original)
+++ lld/trunk/ELF/EhFrame.h Wed Feb 22 20:28:28 2017
@@ -14,11 +14,10 @@
 
 namespace lld {
 namespace elf {
-template <class ELFT> class InputSectionBase;
+class InputSectionBase;
 struct EhSectionPiece;
 
-template <class ELFT>
-size_t readEhRecordSize(InputSectionBase<ELFT> *S, size_t Off);
+template <class ELFT> size_t readEhRecordSize(InputSectionBase *S, size_t Off);
 template <class ELFT> uint8_t getFdeEncoding(EhSectionPiece *P);
 }
 }

Modified: lld/trunk/ELF/GdbIndex.cpp
URL: http://llvm.org/viewvc/llvm-project/lld/trunk/ELF/GdbIndex.cpp?rev=295923&r1=295922&r2=295923&view=diff
==============================================================================
--- lld/trunk/ELF/GdbIndex.cpp (original)
+++ lld/trunk/ELF/GdbIndex.cpp Wed Feb 22 20:28:28 2017
@@ -70,10 +70,12 @@ template <class ELFT>
 GdbIndexBuilder<ELFT>::GdbIndexBuilder(InputSection<ELFT> *DebugInfoSec)
     : DebugInfoSec(DebugInfoSec) {
   if (Expected<std::unique_ptr<object::ObjectFile>> Obj =
-          object::ObjectFile::createObjectFile(DebugInfoSec->getFile()->MB))
+          object::ObjectFile::createObjectFile(
+              DebugInfoSec->template getFile<ELFT>()->MB))
     Dwarf.reset(new DWARFContextInMemory(*Obj.get(), this));
   else
-    error(toString(DebugInfoSec->getFile()) + ": error creating DWARF context");
+    error(toString(DebugInfoSec->template getFile<ELFT>()) +
+          ": error creating DWARF context");
 }
 
 template <class ELFT>
@@ -150,11 +152,11 @@ GdbSymbol **GdbHashTab::findSlot(uint32_
 }
 
 template <class ELFT>
-static InputSectionBase<ELFT> *
-findSection(ArrayRef<InputSectionBase<ELFT> *> Arr, uint64_t Offset) {
-  for (InputSectionBase<ELFT> *S : Arr)
+static InputSectionBase *findSection(ArrayRef<InputSectionBase *> Arr,
+                                     uint64_t Offset) {
+  for (InputSectionBase *S : Arr)
     if (S && S != &InputSection<ELFT>::Discarded)
-      if (Offset >= S->Offset && Offset < S->Offset + S->getSize())
+      if (Offset >= S->Offset && Offset < S->Offset + S->getSize<ELFT>())
         return S;
   return nullptr;
 }
@@ -167,11 +169,11 @@ GdbIndexBuilder<ELFT>::readAddressArea(s
     DWARFAddressRangesVector Ranges;
     CU->collectAddressRanges(Ranges);
 
-    ArrayRef<InputSectionBase<ELFT> *> Sections =
-        DebugInfoSec->getFile()->getSections();
+    ArrayRef<InputSectionBase *> Sections =
+        DebugInfoSec->template getFile<ELFT>()->getSections();
 
     for (std::pair<uint64_t, uint64_t> &R : Ranges)
-      if (InputSectionBase<ELFT> *S = findSection(Sections, R.first))
+      if (InputSectionBase *S = findSection<ELFT>(Sections, R.first))
         Ret.push_back(
             {S, R.first - S->Offset, R.second - S->Offset, CurrentCU});
     ++CurrentCU;

Modified: lld/trunk/ELF/GdbIndex.h
URL: http://llvm.org/viewvc/llvm-project/lld/trunk/ELF/GdbIndex.h?rev=295923&r1=295922&r2=295923&view=diff
==============================================================================
--- lld/trunk/ELF/GdbIndex.h (original)
+++ lld/trunk/ELF/GdbIndex.h Wed Feb 22 20:28:28 2017
@@ -21,7 +21,7 @@ template <class ELFT> class InputSection
 
 // Struct represents single entry of address area of gdb index.
 template <class ELFT> struct AddressEntry {
-  InputSectionBase<ELFT> *Section;
+  InputSectionBase *Section;
   uint64_t LowAddress;
   uint64_t HighAddress;
   size_t CuIndex;

Modified: lld/trunk/ELF/ICF.cpp
URL: http://llvm.org/viewvc/llvm-project/lld/trunk/ELF/ICF.cpp?rev=295923&r1=295922&r2=295923&view=diff
==============================================================================
--- lld/trunk/ELF/ICF.cpp (original)
+++ lld/trunk/ELF/ICF.cpp Wed Feb 22 20:28:28 2017
@@ -155,7 +155,7 @@ private:
 // Returns a hash value for S. Note that the information about
 // relocation targets is not included in the hash value.
 template <class ELFT> static uint32_t getHash(InputSection<ELFT> *S) {
-  return hash_combine(S->Flags, S->getSize(), S->NumRelocations);
+  return hash_combine(S->Flags, S->template getSize<ELFT>(), S->NumRelocations);
 }
 
 // Returns true if section S is subject of ICF.
@@ -224,12 +224,13 @@ template <class ELFT>
 bool ICF<ELFT>::equalsConstant(const InputSection<ELFT> *A,
                                const InputSection<ELFT> *B) {
   if (A->NumRelocations != B->NumRelocations || A->Flags != B->Flags ||
-      A->getSize() != B->getSize() || A->Data != B->Data)
+      A->template getSize<ELFT>() != B->template getSize<ELFT>() ||
+      A->Data != B->Data)
     return false;
 
   if (A->AreRelocsRela)
-    return constantEq(A->relas(), B->relas());
-  return constantEq(A->rels(), B->rels());
+    return constantEq(A->template relas<ELFT>(), B->template relas<ELFT>());
+  return constantEq(A->template rels<ELFT>(), B->template rels<ELFT>());
 }
 
 // Compare two lists of relocations. Returns true if all pairs of
@@ -240,8 +241,8 @@ bool ICF<ELFT>::variableEq(const InputSe
                            const InputSection<ELFT> *B, ArrayRef<RelTy> RelsB) {
   auto Eq = [&](const RelTy &RA, const RelTy &RB) {
     // The two sections must be identical.
-    SymbolBody &SA = A->getFile()->getRelocTargetSym(RA);
-    SymbolBody &SB = B->getFile()->getRelocTargetSym(RB);
+    SymbolBody &SA = A->template getFile<ELFT>()->getRelocTargetSym(RA);
+    SymbolBody &SB = B->template getFile<ELFT>()->getRelocTargetSym(RB);
     if (&SA == &SB)
       return true;
 
@@ -278,8 +279,9 @@ template <class ELFT>
 bool ICF<ELFT>::equalsVariable(const InputSection<ELFT> *A,
                                const InputSection<ELFT> *B) {
   if (A->AreRelocsRela)
-    return variableEq(A, A->relas(), B, B->relas());
-  return variableEq(A, A->rels(), B, B->rels());
+    return variableEq(A, A->template relas<ELFT>(), B,
+                      B->template relas<ELFT>());
+  return variableEq(A, A->template rels<ELFT>(), B, B->template rels<ELFT>());
 }
 
 template <class ELFT> size_t ICF<ELFT>::findBoundary(size_t Begin, size_t End) {
@@ -336,7 +338,7 @@ void ICF<ELFT>::forEachClass(std::functi
 // The main function of ICF.
 template <class ELFT> void ICF<ELFT>::run() {
   // Collect sections to merge.
-  for (InputSectionBase<ELFT> *Sec : Symtab<ELFT>::X->Sections)
+  for (InputSectionBase *Sec : Symtab<ELFT>::X->Sections)
     if (auto *S = dyn_cast<InputSection<ELFT>>(Sec))
       if (isEligible(S))
         Sections.push_back(S);

Modified: lld/trunk/ELF/InputFiles.cpp
URL: http://llvm.org/viewvc/llvm-project/lld/trunk/ELF/InputFiles.cpp?rev=295923&r1=295922&r2=295923&view=diff
==============================================================================
--- lld/trunk/ELF/InputFiles.cpp (original)
+++ lld/trunk/ELF/InputFiles.cpp Wed Feb 22 20:28:28 2017
@@ -93,7 +93,7 @@ template <class ELFT> void elf::ObjectFi
 // Returns source line information for a given offset
 // using DWARF debug info.
 template <class ELFT>
-std::string elf::ObjectFile<ELFT>::getLineInfo(InputSectionBase<ELFT> *S,
+std::string elf::ObjectFile<ELFT>::getLineInfo(InputSectionBase *S,
                                                uintX_t Offset) {
   if (!DwarfLine)
     initializeDwarfLine();
@@ -327,12 +327,11 @@ void elf::ObjectFile<ELFT>::initializeSe
 }
 
 template <class ELFT>
-InputSectionBase<ELFT> *
-elf::ObjectFile<ELFT>::getRelocTarget(const Elf_Shdr &Sec) {
+InputSectionBase *elf::ObjectFile<ELFT>::getRelocTarget(const Elf_Shdr &Sec) {
   uint32_t Idx = Sec.sh_info;
   if (Idx >= Sections.size())
     fatal(toString(this) + ": invalid relocated section index: " + Twine(Idx));
-  InputSectionBase<ELFT> *Target = Sections[Idx];
+  InputSectionBase *Target = Sections[Idx];
 
   // Strictly speaking, a relocation section must be included in the
   // group of the section it relocates. However, LLVM 3.3 and earlier
@@ -346,7 +345,7 @@ elf::ObjectFile<ELFT>::getRelocTarget(co
 }
 
 template <class ELFT>
-InputSectionBase<ELFT> *
+InputSectionBase *
 elf::ObjectFile<ELFT>::createInputSection(const Elf_Shdr &Sec,
                                           StringRef SectionStringTable) {
   StringRef Name =
@@ -369,7 +368,7 @@ elf::ObjectFile<ELFT>::createInputSectio
     // section with it. Target can be discarded, for example
     // if it is a duplicated member of SHT_GROUP section, we
     // do not create or proccess relocatable sections then.
-    InputSectionBase<ELFT> *Target = getRelocTarget(Sec);
+    InputSectionBase *Target = getRelocTarget(Sec);
     if (!Target)
       return nullptr;
 
@@ -456,12 +455,11 @@ template <class ELFT> void elf::ObjectFi
 }
 
 template <class ELFT>
-InputSectionBase<ELFT> *
-elf::ObjectFile<ELFT>::getSection(const Elf_Sym &Sym) const {
+InputSectionBase *elf::ObjectFile<ELFT>::getSection(const Elf_Sym &Sym) const {
   uint32_t Index = this->getSectionIndex(Sym);
   if (Index >= Sections.size())
     fatal(toString(this) + ": invalid section index: " + Twine(Index));
-  InputSectionBase<ELFT> *S = Sections[Index];
+  InputSectionBase *S = Sections[Index];
 
   // We found that GNU assembler 2.17.50 [FreeBSD] 2007-07-03 could
   // generate broken objects. STT_SECTION/STT_NOTYPE symbols can be
@@ -483,7 +481,7 @@ elf::ObjectFile<ELFT>::getSection(const
 template <class ELFT>
 SymbolBody *elf::ObjectFile<ELFT>::createSymbolBody(const Elf_Sym *Sym) {
   int Binding = Sym->getBinding();
-  InputSectionBase<ELFT> *Sec = getSection(*Sym);
+  InputSectionBase *Sec = getSection(*Sym);
 
   uint8_t StOther = Sym->st_other;
   uint8_t Type = Sym->getType();

Modified: lld/trunk/ELF/InputFiles.h
URL: http://llvm.org/viewvc/llvm-project/lld/trunk/ELF/InputFiles.h?rev=295923&r1=295922&r2=295923&view=diff
==============================================================================
--- lld/trunk/ELF/InputFiles.h (original)
+++ lld/trunk/ELF/InputFiles.h Wed Feb 22 20:28:28 2017
@@ -156,8 +156,8 @@ public:
   explicit ObjectFile(MemoryBufferRef M);
   void parse(llvm::DenseSet<llvm::CachedHashStringRef> &ComdatGroups);
 
-  ArrayRef<InputSectionBase<ELFT> *> getSections() const { return Sections; }
-  InputSectionBase<ELFT> *getSection(const Elf_Sym &Sym) const;
+  ArrayRef<InputSectionBase *> getSections() const { return Sections; }
+  InputSectionBase *getSection(const Elf_Sym &Sym) const;
 
   SymbolBody &getSymbolBody(uint32_t SymbolIndex) const {
     if (SymbolIndex >= SymbolBodies.size())
@@ -173,7 +173,7 @@ public:
 
   // Returns source line information for a given offset.
   // If no information is available, returns "".
-  std::string getLineInfo(InputSectionBase<ELFT> *S, uintX_t Offset);
+  std::string getLineInfo(InputSectionBase *S, uintX_t Offset);
 
   // MIPS GP0 value defined by this file. This value represents the gp value
   // used to create the relocatable object and required to support
@@ -190,15 +190,15 @@ private:
   initializeSections(llvm::DenseSet<llvm::CachedHashStringRef> &ComdatGroups);
   void initializeSymbols();
   void initializeDwarfLine();
-  InputSectionBase<ELFT> *getRelocTarget(const Elf_Shdr &Sec);
-  InputSectionBase<ELFT> *createInputSection(const Elf_Shdr &Sec,
-                                             StringRef SectionStringTable);
+  InputSectionBase *getRelocTarget(const Elf_Shdr &Sec);
+  InputSectionBase *createInputSection(const Elf_Shdr &Sec,
+                                       StringRef SectionStringTable);
 
   bool shouldMerge(const Elf_Shdr &Sec);
   SymbolBody *createSymbolBody(const Elf_Sym *Sym);
 
   // List of all sections defined by this file.
-  std::vector<InputSectionBase<ELFT> *> Sections;
+  std::vector<InputSectionBase *> Sections;
 
   // List of all symbols referenced or defined by this file.
   std::vector<SymbolBody *> SymbolBodies;

Modified: lld/trunk/ELF/InputSection.cpp
URL: http://llvm.org/viewvc/llvm-project/lld/trunk/ELF/InputSection.cpp?rev=295923&r1=295922&r2=295923&view=diff
==============================================================================
--- lld/trunk/ELF/InputSection.cpp (original)
+++ lld/trunk/ELF/InputSection.cpp Wed Feb 22 20:28:28 2017
@@ -34,11 +34,9 @@ using namespace lld;
 using namespace lld::elf;
 
 // Returns a string to construct an error message.
-template <class ELFT>
-std::string lld::toString(const InputSectionBase<ELFT> *Sec) {
+std::string lld::toString(const InputSectionBase *Sec) {
   // File can be absent if section is synthetic.
-  std::string FileName =
-      Sec->getFile() ? Sec->getFile()->getName() : "<internal>";
+  std::string FileName = Sec->File ? Sec->File->getName() : "<internal>";
   return (FileName + ":(" + Sec->Name + ")").str();
 }
 
@@ -50,13 +48,11 @@ static ArrayRef<uint8_t> getSectionConte
   return check(File->getObj().getSectionContents(Hdr));
 }
 
-template <class ELFT>
-InputSectionBase<ELFT>::InputSectionBase(elf::ObjectFile<ELFT> *File,
-                                         uintX_t Flags, uint32_t Type,
-                                         uintX_t Entsize, uint32_t Link,
-                                         uint32_t Info, uintX_t Addralign,
-                                         ArrayRef<uint8_t> Data, StringRef Name,
-                                         Kind SectionKind)
+InputSectionBase::InputSectionBase(InputFile *File, uint64_t Flags,
+                                   uint32_t Type, uint64_t Entsize,
+                                   uint32_t Link, uint32_t Info,
+                                   uint64_t Addralign, ArrayRef<uint8_t> Data,
+                                   StringRef Name, Kind SectionKind)
     : InputSectionData(SectionKind, Name, Data,
                        !Config->GcSections || !(Flags & SHF_ALLOC)),
       File(File), Flags(Flags), Entsize(Entsize), Type(Type), Link(Link),
@@ -79,9 +75,9 @@ InputSectionBase<ELFT>::InputSectionBase
 }
 
 template <class ELFT>
-InputSectionBase<ELFT>::InputSectionBase(elf::ObjectFile<ELFT> *File,
-                                         const Elf_Shdr *Hdr, StringRef Name,
-                                         Kind SectionKind)
+InputSectionBase::InputSectionBase(elf::ObjectFile<ELFT> *File,
+                                   const typename ELFT::Shdr *Hdr,
+                                   StringRef Name, Kind SectionKind)
     : InputSectionBase(File, Hdr->sh_flags & ~SHF_INFO_LINK, Hdr->sh_type,
                        Hdr->sh_entsize, Hdr->sh_link, Hdr->sh_info,
                        Hdr->sh_addralign, getSectionContents(File, Hdr), Name,
@@ -89,7 +85,7 @@ InputSectionBase<ELFT>::InputSectionBase
   this->Offset = Hdr->sh_offset;
 }
 
-template <class ELFT> size_t InputSectionBase<ELFT>::getSize() const {
+template <class ELFT> size_t InputSectionBase::getSize() const {
   if (auto *S = dyn_cast<SyntheticSection<ELFT>>(this))
     return S->getSize();
 
@@ -97,7 +93,8 @@ template <class ELFT> size_t InputSectio
 }
 
 template <class ELFT>
-typename ELFT::uint InputSectionBase<ELFT>::getOffset(uintX_t Offset) const {
+uint64_t InputSectionBase::getOffset(uint64_t Offset) const {
+  typedef typename ELFT::uint uintX_t;
   switch (kind()) {
   case Regular:
     return cast<InputSection<ELFT>>(this)->OutSecOff + Offset;
@@ -105,7 +102,7 @@ typename ELFT::uint InputSectionBase<ELF
     // For synthetic sections we treat offset -1 as the end of the section.
     // The same approach is used for synthetic symbols (DefinedSynthetic).
     return cast<InputSection<ELFT>>(this)->OutSecOff +
-           (Offset == uintX_t(-1) ? getSize() : Offset);
+           (Offset == uintX_t(-1) ? getSize<ELFT>() : Offset);
   case EHFrame:
     // The file crtbeginT.o has relocations pointing to the start of an empty
     // .eh_frame that is known to be the first in the link. It does that to
@@ -121,7 +118,7 @@ typename ELFT::uint InputSectionBase<ELF
 }
 
 template <class ELFT>
-OutputSectionBase *InputSectionBase<ELFT>::getOutputSection() const {
+OutputSectionBase *InputSectionBase::getOutputSection() const {
   if (auto *MS = dyn_cast<MergeInputSection<ELFT>>(this))
     return MS->MergeSec ? MS->MergeSec->OutSec : nullptr;
   return OutSec;
@@ -129,7 +126,7 @@ OutputSectionBase *InputSectionBase<ELFT
 
 // Uncompress section contents. Note that this function is called
 // from parallel_for_each, so it must be thread-safe.
-template <class ELFT> void InputSectionBase<ELFT>::uncompress() {
+template <class ELFT> void InputSectionBase::uncompress() {
   Decompressor Dec = check(Decompressor::create(
       Name, toStringRef(Data), ELFT::TargetEndianness == llvm::support::little,
       ELFT::Is64Bits));
@@ -149,34 +146,33 @@ template <class ELFT> void InputSectionB
 }
 
 template <class ELFT>
-typename ELFT::uint
-InputSectionBase<ELFT>::getOffset(const DefinedRegular<ELFT> &Sym) const {
-  return getOffset(Sym.Value);
+uint64_t InputSectionBase::getOffset(const DefinedRegular<ELFT> &Sym) const {
+  return getOffset<ELFT>(Sym.Value);
 }
 
 template <class ELFT>
-InputSectionBase<ELFT> *InputSectionBase<ELFT>::getLinkOrderDep() const {
+InputSectionBase *InputSectionBase::getLinkOrderDep() const {
   if ((Flags & SHF_LINK_ORDER) && Link != 0)
-    return getFile()->getSections()[Link];
+    return getFile<ELFT>()->getSections()[Link];
   return nullptr;
 }
 
 // Returns a source location string. Used to construct an error message.
 template <class ELFT>
-std::string InputSectionBase<ELFT>::getLocation(typename ELFT::uint Offset) {
+std::string InputSectionBase::getLocation(uint64_t Offset) {
   // First check if we can get desired values from debugging information.
-  std::string LineInfo = File->getLineInfo(this, Offset);
+  std::string LineInfo = getFile<ELFT>()->getLineInfo(this, Offset);
   if (!LineInfo.empty())
     return LineInfo;
 
   // File->SourceFile contains STT_FILE symbol that contains a
   // source file name. If it's missing, we use an object file name.
-  std::string SrcFile = File->SourceFile;
+  std::string SrcFile = getFile<ELFT>()->SourceFile;
   if (SrcFile.empty())
     SrcFile = toString(File);
 
   // Find a function symbol that encloses a given location.
-  for (SymbolBody *B : File->getSymbols())
+  for (SymbolBody *B : getFile<ELFT>()->getSymbols())
     if (auto *D = dyn_cast<DefinedRegular<ELFT>>(B))
       if (D->Section == this && D->Type == STT_FUNC)
         if (D->Value <= Offset && Offset < D->Value + D->Size)
@@ -186,31 +182,31 @@ std::string InputSectionBase<ELFT>::getL
   return (SrcFile + ":(" + Name + "+0x" + utohexstr(Offset) + ")").str();
 }
 
-template <class ELFT>
-InputSection<ELFT>::InputSection() : InputSectionBase<ELFT>() {}
+template <class ELFT> InputSection<ELFT>::InputSection() : InputSectionBase() {}
 
 template <class ELFT>
 InputSection<ELFT>::InputSection(uintX_t Flags, uint32_t Type,
                                  uintX_t Addralign, ArrayRef<uint8_t> Data,
                                  StringRef Name, Kind K)
-    : InputSectionBase<ELFT>(nullptr, Flags, Type,
-                             /*Entsize*/ 0, /*Link*/ 0, /*Info*/ 0, Addralign,
-                             Data, Name, K) {}
+    : InputSectionBase(nullptr, Flags, Type,
+                       /*Entsize*/ 0, /*Link*/ 0, /*Info*/ 0, Addralign, Data,
+                       Name, K) {}
 
 template <class ELFT>
 InputSection<ELFT>::InputSection(elf::ObjectFile<ELFT> *F,
                                  const Elf_Shdr *Header, StringRef Name)
-    : InputSectionBase<ELFT>(F, Header, Name, Base::Regular) {}
+    : InputSectionBase(F, Header, Name, InputSectionBase::Regular) {}
 
 template <class ELFT>
 bool InputSection<ELFT>::classof(const InputSectionData *S) {
-  return S->kind() == Base::Regular || S->kind() == Base::Synthetic;
+  return S->kind() == InputSectionBase::Regular ||
+         S->kind() == InputSectionBase::Synthetic;
 }
 
 template <class ELFT>
-InputSectionBase<ELFT> *InputSection<ELFT>::getRelocatedSection() {
+InputSectionBase *InputSection<ELFT>::getRelocatedSection() {
   assert(this->Type == SHT_RELA || this->Type == SHT_REL);
-  ArrayRef<InputSectionBase<ELFT> *> Sections = this->File->getSections();
+  ArrayRef<InputSectionBase *> Sections = this->getFile<ELFT>()->getSections();
   return Sections[this->Info];
 }
 
@@ -220,7 +216,7 @@ InputSectionBase<ELFT> *InputSection<ELF
 template <class ELFT>
 template <class RelTy>
 void InputSection<ELFT>::copyRelocations(uint8_t *Buf, ArrayRef<RelTy> Rels) {
-  InputSectionBase<ELFT> *RelocatedSection = getRelocatedSection();
+  InputSectionBase *RelocatedSection = getRelocatedSection();
 
   // Loop is slow and have complexity O(N*M), where N - amount of
   // relocations and M - amount of symbols in symbol table.
@@ -228,7 +224,7 @@ void InputSection<ELFT>::copyRelocations
   // simple linear search.
   for (const RelTy &Rel : Rels) {
     uint32_t Type = Rel.getType(Config->Mips64EL);
-    SymbolBody &Body = this->File->getRelocTargetSym(Rel);
+    SymbolBody &Body = this->getFile<ELFT>()->getRelocTargetSym(Rel);
 
     Elf_Rela *P = reinterpret_cast<Elf_Rela *>(Buf);
     Buf += sizeof(RelTy);
@@ -239,7 +235,7 @@ void InputSection<ELFT>::copyRelocations
     // Output section VA is zero for -r, so r_offset is an offset within the
     // section, but for --emit-relocs it is an virtual address.
     P->r_offset = RelocatedSection->OutSec->Addr +
-                  RelocatedSection->getOffset(Rel.r_offset);
+                  RelocatedSection->getOffset<ELFT>(Rel.r_offset);
     P->setSymbolAndType(In<ELFT>::SymTab->getSymbolIndex(&Body), Type,
                         Config->Mips64EL);
 
@@ -253,8 +249,7 @@ void InputSection<ELFT>::copyRelocations
       // avoid having to parse and recreate .eh_frame, we just replace any
       // relocation in it pointing to discarded sections with R_*_NONE, which
       // hopefully creates a frame that is ignored at runtime.
-      InputSectionBase<ELFT> *Section =
-          cast<DefinedRegular<ELFT>>(Body).Section;
+      InputSectionBase *Section = cast<DefinedRegular<ELFT>>(Body).Section;
       if (Section == &InputSection<ELFT>::Discarded) {
         P->setSymbolAndType(0, 0, false);
         continue;
@@ -457,15 +452,15 @@ template <class RelTy>
 void InputSection<ELFT>::relocateNonAlloc(uint8_t *Buf, ArrayRef<RelTy> Rels) {
   for (const RelTy &Rel : Rels) {
     uint32_t Type = Rel.getType(Config->Mips64EL);
-    uintX_t Offset = this->getOffset(Rel.r_offset);
+    uintX_t Offset = this->getOffset<ELFT>(Rel.r_offset);
     uint8_t *BufLoc = Buf + Offset;
     int64_t Addend = getAddend<ELFT>(Rel);
     if (!RelTy::IsRela)
       Addend += Target->getImplicitAddend(BufLoc, Type);
 
-    SymbolBody &Sym = this->File->getRelocTargetSym(Rel);
+    SymbolBody &Sym = this->getFile<ELFT>()->getRelocTargetSym(Rel);
     if (Target->getRelExpr(Type, Sym) != R_ABS) {
-      error(this->getLocation(Offset) + ": has non-ABS reloc");
+      error(this->getLocation<ELFT>(Offset) + ": has non-ABS reloc");
       return;
     }
 
@@ -478,23 +473,28 @@ void InputSection<ELFT>::relocateNonAllo
   }
 }
 
+template <class ELFT> ObjectFile<ELFT> *InputSectionBase::getFile() const {
+  return cast_or_null<ObjectFile<ELFT>>(File);
+}
+
 template <class ELFT>
-void InputSectionBase<ELFT>::relocate(uint8_t *Buf, uint8_t *BufEnd) {
+void InputSectionBase::relocate(uint8_t *Buf, uint8_t *BufEnd) {
   // scanReloc function in Writer.cpp constructs Relocations
   // vector only for SHF_ALLOC'ed sections. For other sections,
   // we handle relocations directly here.
   auto *IS = dyn_cast<InputSection<ELFT>>(this);
   if (IS && !(IS->Flags & SHF_ALLOC)) {
     if (IS->AreRelocsRela)
-      IS->relocateNonAlloc(Buf, IS->relas());
+      IS->relocateNonAlloc(Buf, IS->template relas<ELFT>());
     else
-      IS->relocateNonAlloc(Buf, IS->rels());
+      IS->relocateNonAlloc(Buf, IS->template rels<ELFT>());
     return;
   }
 
+  typedef typename ELFT::uint uintX_t;
   const unsigned Bits = sizeof(uintX_t) * 8;
   for (const Relocation &Rel : Relocations) {
-    uintX_t Offset = getOffset(Rel.Offset);
+    uintX_t Offset = getOffset<ELFT>(Rel.Offset);
     uint8_t *BufLoc = Buf + Offset;
     uint32_t Type = Rel.Type;
 
@@ -562,7 +562,7 @@ template <class ELFT> void InputSection<
 
   // Iterate over all relocation sections that apply to this section.
   uint8_t *BufEnd = Buf + OutSecOff + Data.size();
-  this->relocate(Buf, BufEnd);
+  this->relocate<ELFT>(Buf, BufEnd);
 }
 
 template <class ELFT>
@@ -575,7 +575,7 @@ void InputSection<ELFT>::replace(InputSe
 template <class ELFT>
 EhInputSection<ELFT>::EhInputSection(elf::ObjectFile<ELFT> *F,
                                      const Elf_Shdr *Header, StringRef Name)
-    : InputSectionBase<ELFT>(F, Header, Name, InputSectionBase<ELFT>::EHFrame) {
+    : InputSectionBase(F, Header, Name, InputSectionBase::EHFrame) {
   // Mark .eh_frame sections as live by default because there are
   // usually no relocations that point to .eh_frames. Otherwise,
   // the garbage collector would drop all .eh_frame sections.
@@ -584,7 +584,7 @@ EhInputSection<ELFT>::EhInputSection(elf
 
 template <class ELFT>
 bool EhInputSection<ELFT>::classof(const InputSectionData *S) {
-  return S->kind() == InputSectionBase<ELFT>::EHFrame;
+  return S->kind() == InputSectionBase::EHFrame;
 }
 
 // Returns the index of the first relocation that points to a region between
@@ -615,9 +615,9 @@ template <class ELFT> void EhInputSectio
 
   if (this->NumRelocations) {
     if (this->AreRelocsRela)
-      split(this->relas());
+      split(this->relas<ELFT>());
     else
-      split(this->rels());
+      split(this->rels<ELFT>());
     return;
   }
   split(makeArrayRef<typename ELFT::Rela>(nullptr, nullptr));
@@ -689,7 +689,7 @@ template <class ELFT>
 MergeInputSection<ELFT>::MergeInputSection(elf::ObjectFile<ELFT> *F,
                                            const Elf_Shdr *Header,
                                            StringRef Name)
-    : InputSectionBase<ELFT>(F, Header, Name, InputSectionBase<ELFT>::Merge) {}
+    : InputSectionBase(F, Header, Name, InputSectionBase::Merge) {}
 
 // This function is called after we obtain a complete list of input sections
 // that need to be linked. This is responsible to split section contents
@@ -712,7 +712,7 @@ template <class ELFT> void MergeInputSec
 
 template <class ELFT>
 bool MergeInputSection<ELFT>::classof(const InputSectionData *S) {
-  return S->kind() == InputSectionBase<ELFT>::Merge;
+  return S->kind() == InputSectionBase::Merge;
 }
 
 // Do binary search to get a section piece at a given input offset.
@@ -780,11 +780,6 @@ typename ELFT::uint MergeInputSection<EL
   return Piece.OutputOff + Addend;
 }
 
-template class elf::InputSectionBase<ELF32LE>;
-template class elf::InputSectionBase<ELF32BE>;
-template class elf::InputSectionBase<ELF64LE>;
-template class elf::InputSectionBase<ELF64BE>;
-
 template class elf::InputSection<ELF32LE>;
 template class elf::InputSection<ELF32BE>;
 template class elf::InputSection<ELF64LE>;
@@ -800,7 +795,26 @@ template class elf::MergeInputSection<EL
 template class elf::MergeInputSection<ELF64LE>;
 template class elf::MergeInputSection<ELF64BE>;
 
-template std::string lld::toString(const InputSectionBase<ELF32LE> *);
-template std::string lld::toString(const InputSectionBase<ELF32BE> *);
-template std::string lld::toString(const InputSectionBase<ELF64LE> *);
-template std::string lld::toString(const InputSectionBase<ELF64BE> *);
+template void InputSectionBase::uncompress<ELF32LE>();
+template void InputSectionBase::uncompress<ELF32BE>();
+template void InputSectionBase::uncompress<ELF64LE>();
+template void InputSectionBase::uncompress<ELF64BE>();
+
+template InputSectionBase *InputSectionBase::getLinkOrderDep<ELF32LE>() const;
+template InputSectionBase *InputSectionBase::getLinkOrderDep<ELF32BE>() const;
+template InputSectionBase *InputSectionBase::getLinkOrderDep<ELF64LE>() const;
+template InputSectionBase *InputSectionBase::getLinkOrderDep<ELF64BE>() const;
+
+template OutputSectionBase *InputSectionBase::getOutputSection<ELF32LE>() const;
+template OutputSectionBase *InputSectionBase::getOutputSection<ELF32BE>() const;
+template OutputSectionBase *InputSectionBase::getOutputSection<ELF64LE>() const;
+template OutputSectionBase *InputSectionBase::getOutputSection<ELF64BE>() const;
+
+template uint64_t
+InputSectionBase::getOffset(const DefinedRegular<ELF32LE> &Sym) const;
+template uint64_t
+InputSectionBase::getOffset(const DefinedRegular<ELF32BE> &Sym) const;
+template uint64_t
+InputSectionBase::getOffset(const DefinedRegular<ELF64LE> &Sym) const;
+template uint64_t
+InputSectionBase::getOffset(const DefinedRegular<ELF64BE> &Sym) const;

Modified: lld/trunk/ELF/InputSection.h
URL: http://llvm.org/viewvc/llvm-project/lld/trunk/ELF/InputSection.h?rev=295923&r1=295922&r2=295923&view=diff
==============================================================================
--- lld/trunk/ELF/InputSection.h (original)
+++ lld/trunk/ELF/InputSection.h Wed Feb 22 20:28:28 2017
@@ -72,23 +72,15 @@ public:
 };
 
 // This corresponds to a section of an input file.
-template <class ELFT> class InputSectionBase : public InputSectionData {
-protected:
-  typedef typename ELFT::Chdr Elf_Chdr;
-  typedef typename ELFT::Rel Elf_Rel;
-  typedef typename ELFT::Rela Elf_Rela;
-  typedef typename ELFT::Shdr Elf_Shdr;
-  typedef typename ELFT::Sym Elf_Sym;
-  typedef typename ELFT::uint uintX_t;
-
+class InputSectionBase : public InputSectionData {
+public:
   // The file this section is from.
-  ObjectFile<ELFT> *File;
+  InputFile *File;
 
-public:
   // These corresponds to the fields in Elf_Shdr.
-  uintX_t Flags;
-  uintX_t Offset = 0;
-  uintX_t Entsize;
+  uint64_t Flags;
+  uint64_t Offset = 0;
+  uint64_t Entsize;
   uint32_t Type;
   uint32_t Link;
   uint32_t Info;
@@ -99,26 +91,31 @@ public:
     AreRelocsRela = false;
   }
 
-  InputSectionBase(ObjectFile<ELFT> *File, const Elf_Shdr *Header,
+  template <class ELFT>
+  InputSectionBase(ObjectFile<ELFT> *File, const typename ELFT::Shdr *Header,
                    StringRef Name, Kind SectionKind);
-  InputSectionBase(ObjectFile<ELFT> *File, uintX_t Flags, uint32_t Type,
-                   uintX_t Entsize, uint32_t Link, uint32_t Info,
-                   uintX_t Addralign, ArrayRef<uint8_t> Data, StringRef Name,
+
+  InputSectionBase(InputFile *File, uint64_t Flags, uint32_t Type,
+                   uint64_t Entsize, uint32_t Link, uint32_t Info,
+                   uint64_t Addralign, ArrayRef<uint8_t> Data, StringRef Name,
                    Kind SectionKind);
   OutputSectionBase *OutSec = nullptr;
 
   // Relocations that refer to this section.
-  const Elf_Rel *FirstRelocation = nullptr;
+  const void *FirstRelocation = nullptr;
   unsigned NumRelocations : 31;
   unsigned AreRelocsRela : 1;
-  ArrayRef<Elf_Rel> rels() const {
+  template <class ELFT> ArrayRef<typename ELFT::Rel> rels() const {
     assert(!AreRelocsRela);
-    return llvm::makeArrayRef(FirstRelocation, NumRelocations);
+    return llvm::makeArrayRef(
+        static_cast<const typename ELFT::Rel *>(FirstRelocation),
+        NumRelocations);
   }
-  ArrayRef<Elf_Rela> relas() const {
+  template <class ELFT> ArrayRef<typename ELFT::Rela> relas() const {
     assert(AreRelocsRela);
-    return llvm::makeArrayRef(static_cast<const Elf_Rela *>(FirstRelocation),
-                              NumRelocations);
+    return llvm::makeArrayRef(
+        static_cast<const typename ELFT::Rela *>(FirstRelocation),
+        NumRelocations);
   }
 
   // This pointer points to the "real" instance of this instance.
@@ -126,30 +123,36 @@ public:
   // Repl pointer of one section points to another section. So,
   // if you need to get a pointer to this instance, do not use
   // this but instead this->Repl.
-  InputSectionBase<ELFT> *Repl;
+  InputSectionBase *Repl;
 
   // InputSections that are dependent on us (reverse dependency for GC)
-  llvm::TinyPtrVector<InputSectionBase<ELFT> *> DependentSections;
+  llvm::TinyPtrVector<InputSectionBase *> DependentSections;
 
   // Returns the size of this section (even if this is a common or BSS.)
-  size_t getSize() const;
+  template <class ELFT> size_t getSize() const;
 
-  OutputSectionBase *getOutputSection() const;
+  template <class ELFT> OutputSectionBase *getOutputSection() const;
 
-  ObjectFile<ELFT> *getFile() const { return File; }
-  llvm::object::ELFFile<ELFT> getObj() const { return File->getObj(); }
-  uintX_t getOffset(const DefinedRegular<ELFT> &Sym) const;
-  InputSectionBase *getLinkOrderDep() const;
+  template <class ELFT> ObjectFile<ELFT> *getFile() const;
+
+  template <class ELFT> llvm::object::ELFFile<ELFT> getObj() const {
+    return getFile<ELFT>()->getObj();
+  }
+
+  template <class ELFT>
+  uint64_t getOffset(const DefinedRegular<ELFT> &Sym) const;
+
+  template <class ELFT> InputSectionBase *getLinkOrderDep() const;
   // Translate an offset in the input section to an offset in the output
   // section.
-  uintX_t getOffset(uintX_t Offset) const;
+  template <class ELFT> uint64_t getOffset(uint64_t Offset) const;
 
-  void uncompress();
+  template <class ELFT> void uncompress();
 
   // Returns a source location string. Used to construct an error message.
-  std::string getLocation(uintX_t Offset);
+  template <class ELFT> std::string getLocation(uint64_t Offset);
 
-  void relocate(uint8_t *Buf, uint8_t *BufEnd);
+  template <class ELFT> void relocate(uint8_t *Buf, uint8_t *BufEnd);
 };
 
 // SectionPiece represents a piece of splittable section contents.
@@ -168,7 +171,7 @@ static_assert(sizeof(SectionPiece) == 2
               "SectionPiece is too big");
 
 // This corresponds to a SHF_MERGE section of an input file.
-template <class ELFT> class MergeInputSection : public InputSectionBase<ELFT> {
+template <class ELFT> class MergeInputSection : public InputSectionBase {
   typedef typename ELFT::uint uintX_t;
   typedef typename ELFT::Sym Elf_Sym;
   typedef typename ELFT::Shdr Elf_Shdr;
@@ -243,7 +246,7 @@ struct EhSectionPiece : public SectionPi
 };
 
 // This corresponds to a .eh_frame section of an input file.
-template <class ELFT> class EhInputSection : public InputSectionBase<ELFT> {
+template <class ELFT> class EhInputSection : public InputSectionBase {
 public:
   typedef typename ELFT::Shdr Elf_Shdr;
   typedef typename ELFT::uint uintX_t;
@@ -258,8 +261,7 @@ public:
 };
 
 // This corresponds to a non SHF_MERGE section of an input file.
-template <class ELFT> class InputSection : public InputSectionBase<ELFT> {
-  typedef InputSectionBase<ELFT> Base;
+template <class ELFT> class InputSection : public InputSectionBase {
   typedef typename ELFT::Shdr Elf_Shdr;
   typedef typename ELFT::Rela Elf_Rela;
   typedef typename ELFT::Rel Elf_Rel;
@@ -286,7 +288,7 @@ public:
 
   static bool classof(const InputSectionData *S);
 
-  InputSectionBase<ELFT> *getRelocatedSection();
+  InputSectionBase *getRelocatedSection();
 
   template <class RelTy>
   void relocateNonAlloc(uint8_t *Buf, llvm::ArrayRef<RelTy> Rels);
@@ -305,7 +307,7 @@ private:
 template <class ELFT> InputSection<ELFT> InputSection<ELFT>::Discarded;
 } // namespace elf
 
-template <class ELFT> std::string toString(const elf::InputSectionBase<ELFT> *);
+std::string toString(const elf::InputSectionBase *);
 } // namespace lld
 
 #endif

Modified: lld/trunk/ELF/LinkerScript.cpp
URL: http://llvm.org/viewvc/llvm-project/lld/trunk/ELF/LinkerScript.cpp?rev=295923&r1=295922&r2=295923&view=diff
==============================================================================
--- lld/trunk/ELF/LinkerScript.cpp (original)
+++ lld/trunk/ELF/LinkerScript.cpp Wed Feb 22 20:28:28 2017
@@ -181,14 +181,13 @@ bool BytesDataCommand::classof(const Bas
 template <class ELFT> LinkerScript<ELFT>::LinkerScript() = default;
 template <class ELFT> LinkerScript<ELFT>::~LinkerScript() = default;
 
-template <class ELFT> static StringRef basename(InputSectionBase<ELFT> *S) {
-  if (S->getFile())
-    return sys::path::filename(S->getFile()->getName());
+static StringRef basename(InputSectionBase *S) {
+  if (S->File)
+    return sys::path::filename(S->File->getName());
   return "";
 }
 
-template <class ELFT>
-bool LinkerScript<ELFT>::shouldKeep(InputSectionBase<ELFT> *S) {
+template <class ELFT> bool LinkerScript<ELFT>::shouldKeep(InputSectionBase *S) {
   for (InputSectionDescription *ID : Opt.KeptSections)
     if (ID->FilePat.match(basename(S)))
       for (SectionPattern &P : ID->SectionPatterns)
@@ -227,12 +226,12 @@ getComparator(SortSectionPolicy K) {
 }
 
 template <class ELFT>
-static bool matchConstraints(ArrayRef<InputSectionBase<ELFT> *> Sections,
+static bool matchConstraints(ArrayRef<InputSectionBase *> Sections,
                              ConstraintKind Kind) {
   if (Kind == ConstraintKind::NoConstraint)
     return true;
   bool IsRW = llvm::any_of(Sections, [=](InputSectionData *Sec2) {
-    auto *Sec = static_cast<InputSectionBase<ELFT> *>(Sec2);
+    auto *Sec = static_cast<InputSectionBase *>(Sec2);
     return Sec->Flags & SHF_WRITE;
   });
   return (IsRW && Kind == ConstraintKind::ReadWrite) ||
@@ -253,7 +252,7 @@ void LinkerScript<ELFT>::computeInputSec
   for (SectionPattern &Pat : I->SectionPatterns) {
     size_t SizeBefore = I->Sections.size();
 
-    for (InputSectionBase<ELFT> *S : Symtab<ELFT>::X->Sections) {
+    for (InputSectionBase *S : Symtab<ELFT>::X->Sections) {
       if (S->Assigned)
         continue;
       // For -emit-relocs we have to ignore entries like
@@ -295,8 +294,8 @@ void LinkerScript<ELFT>::computeInputSec
 }
 
 template <class ELFT>
-void LinkerScript<ELFT>::discard(ArrayRef<InputSectionBase<ELFT> *> V) {
-  for (InputSectionBase<ELFT> *S : V) {
+void LinkerScript<ELFT>::discard(ArrayRef<InputSectionBase *> V) {
+  for (InputSectionBase *S : V) {
     S->Live = false;
     if (S == In<ELFT>::ShStrTab)
       error("discarding .shstrtab section is not allowed");
@@ -305,9 +304,9 @@ void LinkerScript<ELFT>::discard(ArrayRe
 }
 
 template <class ELFT>
-std::vector<InputSectionBase<ELFT> *>
+std::vector<InputSectionBase *>
 LinkerScript<ELFT>::createInputSectionList(OutputSectionCommand &OutCmd) {
-  std::vector<InputSectionBase<ELFT> *> Ret;
+  std::vector<InputSectionBase *> Ret;
 
   for (const std::unique_ptr<BaseCommand> &Base : OutCmd.Commands) {
     auto *Cmd = dyn_cast<InputSectionDescription>(Base.get());
@@ -315,7 +314,7 @@ LinkerScript<ELFT>::createInputSectionLi
       continue;
     computeInputSections(Cmd);
     for (InputSectionData *S : Cmd->Sections)
-      Ret.push_back(static_cast<InputSectionBase<ELFT> *>(S));
+      Ret.push_back(static_cast<InputSectionBase *>(S));
   }
 
   return Ret;
@@ -343,7 +342,7 @@ void LinkerScript<ELFT>::processCommands
     }
 
     if (auto *Cmd = dyn_cast<OutputSectionCommand>(Base1.get())) {
-      std::vector<InputSectionBase<ELFT> *> V = createInputSectionList(*Cmd);
+      std::vector<InputSectionBase *> V = createInputSectionList(*Cmd);
 
       // The output section name `/DISCARD/' is special.
       // Any input section assigned to it is discarded.
@@ -360,7 +359,7 @@ void LinkerScript<ELFT>::processCommands
       // Because we'll iterate over Commands many more times, the easiest
       // way to "make it as if it wasn't present" is to just remove it.
       if (!matchConstraints<ELFT>(V, Cmd->Constraint)) {
-        for (InputSectionBase<ELFT> *S : V)
+        for (InputSectionBase *S : V)
           S->Assigned = false;
         Opt.Commands.erase(Iter);
         --I;
@@ -378,12 +377,12 @@ void LinkerScript<ELFT>::processCommands
       // given value is larger or smaller than the original section alignment.
       if (Cmd->SubalignExpr) {
         uint32_t Subalign = Cmd->SubalignExpr(0);
-        for (InputSectionBase<ELFT> *S : V)
+        for (InputSectionBase *S : V)
           S->Alignment = Subalign;
       }
 
       // Add input sections to an output section.
-      for (InputSectionBase<ELFT> *S : V)
+      for (InputSectionBase *S : V)
         Factory.addInputSec(S, Cmd->Name);
     }
   }
@@ -393,7 +392,7 @@ void LinkerScript<ELFT>::processCommands
 template <class ELFT>
 void LinkerScript<ELFT>::addOrphanSections(
     OutputSectionFactory<ELFT> &Factory) {
-  for (InputSectionBase<ELFT> *S : Symtab<ELFT>::X->Sections)
+  for (InputSectionBase *S : Symtab<ELFT>::X->Sections)
     if (S->Live && !S->OutSec)
       Factory.addInputSec(S, getOutputSectionName(S->Name));
 }
@@ -410,7 +409,7 @@ template <class ELFT> void LinkerScript<
   uintX_t Pos = IsTbss ? Dot + ThreadBssOffset : Dot;
   Pos = alignTo(Pos, S->Alignment);
   S->OutSecOff = Pos - CurOutSec->Addr;
-  Pos += S->getSize();
+  Pos += S->template getSize<ELFT>();
 
   // Update output section size after adding each section. This is so that
   // SIZEOF works correctly in the case below:
@@ -502,7 +501,7 @@ template <class ELFT> void LinkerScript<
       if (Sec->empty())
         continue;
 
-    auto *IB = static_cast<InputSectionBase<ELFT> *>(ID);
+    auto *IB = static_cast<InputSectionBase *>(ID);
     if (!IB->Live)
       continue;
     switchTo(IB->OutSec);

Modified: lld/trunk/ELF/LinkerScript.h
URL: http://llvm.org/viewvc/llvm-project/lld/trunk/ELF/LinkerScript.h?rev=295923&r1=295922&r2=295923&view=diff
==============================================================================
--- lld/trunk/ELF/LinkerScript.h (original)
+++ lld/trunk/ELF/LinkerScript.h Wed Feb 22 20:28:28 2017
@@ -31,7 +31,7 @@ namespace elf {
 class DefinedCommon;
 class ScriptParser;
 class SymbolBody;
-template <class ELFT> class InputSectionBase;
+class InputSectionBase;
 template <class ELFT> class InputSection;
 class OutputSectionBase;
 template <class ELFT> class OutputSectionFactory;
@@ -259,7 +259,7 @@ public:
   uint32_t getFiller(StringRef Name);
   void writeDataBytes(StringRef Name, uint8_t *Buf);
   bool hasLMA(StringRef Name);
-  bool shouldKeep(InputSectionBase<ELFT> *S);
+  bool shouldKeep(InputSectionBase *S);
   void assignOffsets(OutputSectionCommand *Cmd);
   void placeOrphanSections();
   void assignAddresses(std::vector<PhdrEntry> &Phdrs);
@@ -283,9 +283,9 @@ private:
   void computeInputSections(InputSectionDescription *);
   void setDot(Expr E, const Twine &Loc, bool InSec = false);
 
-  void discard(ArrayRef<InputSectionBase<ELFT> *> V);
+  void discard(ArrayRef<InputSectionBase *> V);
 
-  std::vector<InputSectionBase<ELFT> *>
+  std::vector<InputSectionBase *>
   createInputSectionList(OutputSectionCommand &Cmd);
 
   // "ScriptConfig" is a bit too long, so define a short name for it.

Modified: lld/trunk/ELF/MapFile.cpp
URL: http://llvm.org/viewvc/llvm-project/lld/trunk/ELF/MapFile.cpp?rev=295923&r1=295922&r2=295923&view=diff
==============================================================================
--- lld/trunk/ELF/MapFile.cpp (original)
+++ lld/trunk/ELF/MapFile.cpp Wed Feb 22 20:28:28 2017
@@ -66,17 +66,17 @@ static void writeInputSection(raw_fd_ost
   int Width = ELFT::Is64Bits ? 16 : 8;
   StringRef Name = IS->Name;
   if (Name != PrevName) {
-    writeInSecLine(OS, Width, IS->OutSec->Addr + IS->OutSecOff, IS->getSize(),
-                   IS->Alignment, Name);
+    writeInSecLine(OS, Width, IS->OutSec->Addr + IS->OutSecOff,
+                   IS->template getSize<ELFT>(), IS->Alignment, Name);
     OS << '\n';
     PrevName = Name;
   }
 
-  elf::ObjectFile<ELFT> *File = IS->getFile();
+  elf::ObjectFile<ELFT> *File = IS->template getFile<ELFT>();
   if (!File)
     return;
-  writeFileLine(OS, Width, IS->OutSec->Addr + IS->OutSecOff, IS->getSize(),
-                IS->Alignment, toString(File));
+  writeFileLine(OS, Width, IS->OutSec->Addr + IS->OutSecOff,
+                IS->template getSize<ELFT>(), IS->Alignment, toString(File));
   OS << '\n';
 
   for (SymbolBody *Sym : File->getSymbols()) {

Modified: lld/trunk/ELF/MarkLive.cpp
URL: http://llvm.org/viewvc/llvm-project/lld/trunk/ELF/MarkLive.cpp?rev=295923&r1=295922&r2=295923&view=diff
==============================================================================
--- lld/trunk/ELF/MarkLive.cpp (original)
+++ lld/trunk/ELF/MarkLive.cpp Wed Feb 22 20:28:28 2017
@@ -45,34 +45,33 @@ namespace {
 // A resolved relocation. The Sec and Offset fields are set if the relocation
 // was resolved to an offset within a section.
 template <class ELFT> struct ResolvedReloc {
-  InputSectionBase<ELFT> *Sec;
+  InputSectionBase *Sec;
   typename ELFT::uint Offset;
 };
 } // end anonymous namespace
 
 template <class ELFT>
-static typename ELFT::uint getAddend(InputSectionBase<ELFT> &Sec,
+static typename ELFT::uint getAddend(InputSectionBase &Sec,
                                      const typename ELFT::Rel &Rel) {
   return Target->getImplicitAddend(Sec.Data.begin() + Rel.r_offset,
                                    Rel.getType(Config->Mips64EL));
 }
 
 template <class ELFT>
-static typename ELFT::uint getAddend(InputSectionBase<ELFT> &Sec,
+static typename ELFT::uint getAddend(InputSectionBase &Sec,
                                      const typename ELFT::Rela &Rel) {
   return Rel.r_addend;
 }
 
 template <class ELFT, class RelT>
-static ResolvedReloc<ELFT> resolveReloc(InputSectionBase<ELFT> &Sec,
-                                        RelT &Rel) {
-  SymbolBody &B = Sec.getFile()->getRelocTargetSym(Rel);
+static ResolvedReloc<ELFT> resolveReloc(InputSectionBase &Sec, RelT &Rel) {
+  SymbolBody &B = Sec.getFile<ELFT>()->getRelocTargetSym(Rel);
   auto *D = dyn_cast<DefinedRegular<ELFT>>(&B);
   if (!D || !D->Section)
     return {nullptr, 0};
   typename ELFT::uint Offset = D->Value;
   if (D->isSection())
-    Offset += getAddend(Sec, Rel);
+    Offset += getAddend<ELFT>(Sec, Rel);
   return {D->Section->Repl, Offset};
 }
 
@@ -81,13 +80,13 @@ template <class ELFT>
 static void forEachSuccessor(InputSection<ELFT> &Sec,
                              std::function<void(ResolvedReloc<ELFT>)> Fn) {
   if (Sec.AreRelocsRela) {
-    for (const typename ELFT::Rela &Rel : Sec.relas())
-      Fn(resolveReloc(Sec, Rel));
+    for (const typename ELFT::Rela &Rel : Sec.template relas<ELFT>())
+      Fn(resolveReloc<ELFT>(Sec, Rel));
   } else {
-    for (const typename ELFT::Rel &Rel : Sec.rels())
-      Fn(resolveReloc(Sec, Rel));
+    for (const typename ELFT::Rel &Rel : Sec.template rels<ELFT>())
+      Fn(resolveReloc<ELFT>(Sec, Rel));
   }
-  for (InputSectionBase<ELFT> *IS : Sec.DependentSections)
+  for (InputSectionBase *IS : Sec.DependentSections)
     Fn({IS, 0});
 }
 
@@ -118,7 +117,7 @@ scanEhFrameSection(EhInputSection<ELFT>
     if (read32<E>(Piece.data().data() + 4) == 0) {
       // This is a CIE, we only need to worry about the first relocation. It is
       // known to point to the personality function.
-      Enqueue(resolveReloc(EH, Rels[FirstRelI]));
+      Enqueue(resolveReloc<ELFT>(EH, Rels[FirstRelI]));
       continue;
     }
     // This is a FDE. The relocations point to the described function or to
@@ -129,7 +128,7 @@ scanEhFrameSection(EhInputSection<ELFT>
       const RelTy &Rel = Rels[I2];
       if (Rel.r_offset >= PieceEnd)
         break;
-      ResolvedReloc<ELFT> R = resolveReloc(EH, Rels[I2]);
+      ResolvedReloc<ELFT> R = resolveReloc<ELFT>(EH, Rels[I2]);
       if (!R.Sec || R.Sec == &InputSection<ELFT>::Discarded)
         continue;
       if (R.Sec->Flags & SHF_EXECINSTR)
@@ -151,15 +150,15 @@ scanEhFrameSection(EhInputSection<ELFT>
   EH.split();
 
   if (EH.AreRelocsRela)
-    scanEhFrameSection(EH, EH.relas(), Enqueue);
+    scanEhFrameSection(EH, EH.template relas<ELFT>(), Enqueue);
   else
-    scanEhFrameSection(EH, EH.rels(), Enqueue);
+    scanEhFrameSection(EH, EH.template rels<ELFT>(), Enqueue);
 }
 
 // We do not garbage-collect two types of sections:
 // 1) Sections used by the loader (.init, .fini, .ctors, .dtors or .jcr)
 // 2) Non-allocatable sections which typically contain debugging information
-template <class ELFT> static bool isReserved(InputSectionBase<ELFT> *Sec) {
+template <class ELFT> static bool isReserved(InputSectionBase *Sec) {
   switch (Sec->Type) {
   case SHT_FINI_ARRAY:
   case SHT_INIT_ARRAY:
@@ -237,13 +236,13 @@ template <class ELFT> void elf::markLive
 
   // Preserve special sections and those which are specified in linker
   // script KEEP command.
-  for (InputSectionBase<ELFT> *Sec : Symtab<ELFT>::X->Sections) {
+  for (InputSectionBase *Sec : Symtab<ELFT>::X->Sections) {
     // .eh_frame is always marked as live now, but also it can reference to
     // sections that contain personality. We preserve all non-text sections
     // referred by .eh_frame here.
     if (auto *EH = dyn_cast_or_null<EhInputSection<ELFT>>(Sec))
       scanEhFrameSection<ELFT>(*EH, Enqueue);
-    if (isReserved(Sec) || Script<ELFT>::X->shouldKeep(Sec))
+    if (isReserved<ELFT>(Sec) || Script<ELFT>::X->shouldKeep(Sec))
       Enqueue({Sec, 0});
   }
 

Modified: lld/trunk/ELF/OutputSections.cpp
URL: http://llvm.org/viewvc/llvm-project/lld/trunk/ELF/OutputSections.cpp?rev=295923&r1=295922&r2=295923&view=diff
==============================================================================
--- lld/trunk/ELF/OutputSections.cpp (original)
+++ lld/trunk/ELF/OutputSections.cpp Wed Feb 22 20:28:28 2017
@@ -92,8 +92,8 @@ static bool compareByFilePosition(InputS
   if (A->kind() == InputSectionData::Synthetic ||
       B->kind() == InputSectionData::Synthetic)
     return false;
-  auto *LA = cast<InputSection<ELFT>>(A->getLinkOrderDep());
-  auto *LB = cast<InputSection<ELFT>>(B->getLinkOrderDep());
+  auto *LA = cast<InputSection<ELFT>>(A->template getLinkOrderDep<ELFT>());
+  auto *LB = cast<InputSection<ELFT>>(B->template getLinkOrderDep<ELFT>());
   OutputSectionBase *AOut = LA->OutSec;
   OutputSectionBase *BOut = LB->OutSec;
   if (AOut != BOut)
@@ -111,7 +111,7 @@ template <class ELFT> void OutputSection
     // SHF_LINK_ORDER flag. The dependency is indicated by the sh_link field. We
     // need to translate the InputSection sh_link to the OutputSection sh_link,
     // all InputSections in the OutputSection have the same dependency.
-    if (auto *D = this->Sections.front()->getLinkOrderDep())
+    if (auto *D = this->Sections.front()->template getLinkOrderDep<ELFT>())
       this->Link = D->OutSec->SectionIndex;
   }
 
@@ -126,7 +126,7 @@ template <class ELFT> void OutputSection
   this->Link = In<ELFT>::SymTab->OutSec->SectionIndex;
   // sh_info for SHT_REL[A] sections should contain the section header index of
   // the section to which the relocation applies.
-  InputSectionBase<ELFT> *S = First->getRelocatedSection();
+  InputSectionBase *S = First->getRelocatedSection();
   this->Info = S->OutSec->SectionIndex;
 }
 
@@ -157,7 +157,7 @@ template <class ELFT> void OutputSection
   for (InputSection<ELFT> *S : Sections) {
     Off = alignTo(Off, S->Alignment);
     S->OutSecOff = Off;
-    Off += S->getSize();
+    Off += S->template getSize<ELFT>();
   }
   this->Size = Off;
 }
@@ -221,12 +221,12 @@ static bool isCrtend(StringRef S) { retu
 template <class ELFT>
 static bool compCtors(const InputSection<ELFT> *A,
                       const InputSection<ELFT> *B) {
-  bool BeginA = isCrtbegin(A->getFile()->getName());
-  bool BeginB = isCrtbegin(B->getFile()->getName());
+  bool BeginA = isCrtbegin(A->template getFile<ELFT>()->getName());
+  bool BeginB = isCrtbegin(B->template getFile<ELFT>()->getName());
   if (BeginA != BeginB)
     return BeginA;
-  bool EndA = isCrtend(A->getFile()->getName());
-  bool EndB = isCrtend(B->getFile()->getName());
+  bool EndA = isCrtend(A->template getFile<ELFT>()->getName());
+  bool EndB = isCrtend(B->template getFile<ELFT>()->getName());
   if (EndA != EndB)
     return EndB;
   StringRef X = A->Name;
@@ -297,7 +297,8 @@ CieRecord *EhOutputSection<ELFT>::addCie
   SymbolBody *Personality = nullptr;
   unsigned FirstRelI = Piece.FirstRelocation;
   if (FirstRelI != (unsigned)-1)
-    Personality = &Sec->getFile()->getRelocTargetSym(Rels[FirstRelI]);
+    Personality =
+        &Sec->template getFile<ELFT>()->getRelocTargetSym(Rels[FirstRelI]);
 
   // Search for an existing CIE by CIE contents/relocation target pair.
   CieRecord *Cie = &CieMap[{Piece.data(), Personality}];
@@ -321,11 +322,11 @@ bool EhOutputSection<ELFT>::isFdeLive(Eh
   if (FirstRelI == (unsigned)-1)
     return false;
   const RelTy &Rel = Rels[FirstRelI];
-  SymbolBody &B = Sec->getFile()->getRelocTargetSym(Rel);
+  SymbolBody &B = Sec->template getFile<ELFT>()->getRelocTargetSym(Rel);
   auto *D = dyn_cast<DefinedRegular<ELFT>>(&B);
   if (!D || !D->Section)
     return false;
-  InputSectionBase<ELFT> *Target = D->Section->Repl;
+  InputSectionBase *Target = D->Section->Repl;
   return Target && Target->Live;
 }
 
@@ -380,9 +381,9 @@ void EhOutputSection<ELFT>::addSection(I
 
   if (Sec->NumRelocations) {
     if (Sec->AreRelocsRela)
-      addSectionAux(Sec, Sec->relas());
+      addSectionAux(Sec, Sec->template relas<ELFT>());
     else
-      addSectionAux(Sec, Sec->rels());
+      addSectionAux(Sec, Sec->template rels<ELFT>());
     return;
   }
   addSectionAux(Sec, makeArrayRef<Elf_Rela>(nullptr, nullptr));
@@ -464,7 +465,7 @@ template <class ELFT> void EhOutputSecti
   }
 
   for (EhInputSection<ELFT> *S : Sections)
-    S->relocate(Buf, nullptr);
+    S->template relocate<ELFT>(Buf, nullptr);
 
   // Construct .eh_frame_hdr. .eh_frame_hdr is a binary search table
   // to get a FDE from an address to which FDE is applied. So here
@@ -482,12 +483,12 @@ template <class ELFT> void EhOutputSecti
 }
 
 template <class ELFT>
-static typename ELFT::uint getOutFlags(InputSectionBase<ELFT> *S) {
+static typename ELFT::uint getOutFlags(InputSectionBase *S) {
   return S->Flags & ~SHF_GROUP & ~SHF_COMPRESSED;
 }
 
 template <class ELFT>
-static SectionKey createKey(InputSectionBase<ELFT> *C, StringRef OutsecName) {
+static SectionKey createKey(InputSectionBase *C, StringRef OutsecName) {
   //  The ELF spec just says
   // ----------------------------------------------------------------
   // In the first phase, input sections that match in name, type and
@@ -564,23 +565,23 @@ static bool canMergeToProgbits(unsigned
          Type == SHT_NOTE;
 }
 
-template <class ELFT> static void reportDiscarded(InputSectionBase<ELFT> *IS) {
+template <class ELFT> static void reportDiscarded(InputSectionBase *IS) {
   if (!Config->PrintGcSections)
     return;
   message("removing unused section from '" + IS->Name + "' in file '" +
-          IS->getFile()->getName());
+          IS->getFile<ELFT>()->getName());
 }
 
 template <class ELFT>
-void OutputSectionFactory<ELFT>::addInputSec(InputSectionBase<ELFT> *IS,
+void OutputSectionFactory<ELFT>::addInputSec(InputSectionBase *IS,
                                              StringRef OutsecName) {
   if (!IS->Live) {
-    reportDiscarded(IS);
+    reportDiscarded<ELFT>(IS);
     return;
   }
 
-  SectionKey Key = createKey(IS, OutsecName);
-  uintX_t Flags = getOutFlags(IS);
+  SectionKey Key = createKey<ELFT>(IS, OutsecName);
+  uintX_t Flags = getOutFlags<ELFT>(IS);
   OutputSectionBase *&Sec = Map[Key];
   if (Sec) {
     if (getIncompatibleFlags(Sec->Flags) != getIncompatibleFlags(IS->Flags))
@@ -596,7 +597,7 @@ void OutputSectionFactory<ELFT>::addInpu
     Sec->Flags |= Flags;
   } else {
     uint32_t Type = IS->Type;
-    if (IS->kind() == InputSectionBase<ELFT>::EHFrame) {
+    if (IS->kind() == InputSectionBase::EHFrame) {
       Out<ELFT>::EhFrame->addSection(IS);
       return;
     }

Modified: lld/trunk/ELF/OutputSections.h
URL: http://llvm.org/viewvc/llvm-project/lld/trunk/ELF/OutputSections.h?rev=295923&r1=295922&r2=295923&view=diff
==============================================================================
--- lld/trunk/ELF/OutputSections.h (original)
+++ lld/trunk/ELF/OutputSections.h Wed Feb 22 20:28:28 2017
@@ -25,7 +25,7 @@ class SymbolBody;
 struct EhSectionPiece;
 template <class ELFT> class EhInputSection;
 template <class ELFT> class InputSection;
-template <class ELFT> class InputSectionBase;
+class InputSectionBase;
 template <class ELFT> class MergeInputSection;
 template <class ELFT> class OutputSection;
 template <class ELFT> class ObjectFile;
@@ -227,7 +227,7 @@ template <class ELFT> class OutputSectio
 public:
   OutputSectionFactory(std::vector<OutputSectionBase *> &OutputSections);
   ~OutputSectionFactory();
-  void addInputSec(InputSectionBase<ELFT> *IS, StringRef OutsecName);
+  void addInputSec(InputSectionBase *IS, StringRef OutsecName);
 
 private:
   llvm::SmallDenseMap<SectionKey, OutputSectionBase *> Map;

Modified: lld/trunk/ELF/Relocations.cpp
URL: http://llvm.org/viewvc/llvm-project/lld/trunk/ELF/Relocations.cpp?rev=295923&r1=295922&r2=295923&view=diff
==============================================================================
--- lld/trunk/ELF/Relocations.cpp (original)
+++ lld/trunk/ELF/Relocations.cpp Wed Feb 22 20:28:28 2017
@@ -91,11 +91,10 @@ static bool isPreemptible(const SymbolBo
 // handling in to the separate function we can simplify the code and do not
 // pollute `handleTlsRelocation` by ARM and MIPS `ifs` statements.
 template <class ELFT, class GOT>
-static unsigned handleNoRelaxTlsRelocation(GOT *Got, uint32_t Type,
-                                           SymbolBody &Body,
-                                           InputSectionBase<ELFT> &C,
-                                           typename ELFT::uint Offset,
-                                           int64_t Addend, RelExpr Expr) {
+static unsigned
+handleNoRelaxTlsRelocation(GOT *Got, uint32_t Type, SymbolBody &Body,
+                           InputSectionBase &C, typename ELFT::uint Offset,
+                           int64_t Addend, RelExpr Expr) {
   typedef typename ELFT::uint uintX_t;
   auto addModuleReloc = [](SymbolBody &Body, GOT *Got, uintX_t Off, bool LD) {
     // The Dynamic TLS Module Index Relocation can be statically resolved to 1
@@ -136,7 +135,7 @@ static unsigned handleNoRelaxTlsRelocati
 // Returns the number of relocations processed.
 template <class ELFT>
 static unsigned
-handleTlsRelocation(uint32_t Type, SymbolBody &Body, InputSectionBase<ELFT> &C,
+handleTlsRelocation(uint32_t Type, SymbolBody &Body, InputSectionBase &C,
                     typename ELFT::uint Offset, int64_t Addend, RelExpr Expr) {
   if (!(C.Flags & SHF_ALLOC))
     return 0;
@@ -314,10 +313,9 @@ static bool isRelExpr(RelExpr Expr) {
 }
 
 template <class ELFT>
-static bool isStaticLinkTimeConstant(RelExpr E, uint32_t Type,
-                                     const SymbolBody &Body,
-                                     InputSectionBase<ELFT> &S,
-                                     typename ELFT::uint RelOff) {
+static bool
+isStaticLinkTimeConstant(RelExpr E, uint32_t Type, const SymbolBody &Body,
+                         InputSectionBase &S, typename ELFT::uint RelOff) {
   // These expressions always compute a constant
   if (isRelExprOneOf<R_SIZE, R_GOT_FROM_END, R_GOT_OFF, R_MIPS_GOT_LOCAL_PAGE,
                      R_MIPS_GOT_OFF, R_MIPS_GOT_OFF32, R_MIPS_TLSGD,
@@ -356,7 +354,7 @@ static bool isStaticLinkTimeConstant(Rel
       return true;
     if (&Body == ElfSym<ELFT>::MipsGpDisp)
       return true;
-    error(S.getLocation(RelOff) + ": relocation " + toString(Type) +
+    error(S.getLocation<ELFT>(RelOff) + ": relocation " + toString(Type) +
           " cannot refer to absolute symbol '" + toString(Body) +
           "' defined in " + toString(Body.File));
     return true;
@@ -509,7 +507,7 @@ template <class ELFT> static void addCop
 template <class ELFT>
 static RelExpr adjustExpr(const elf::ObjectFile<ELFT> &File, SymbolBody &Body,
                           bool IsWrite, RelExpr Expr, uint32_t Type,
-                          const uint8_t *Data, InputSectionBase<ELFT> &S,
+                          const uint8_t *Data, InputSectionBase &S,
                           typename ELFT::uint RelOff) {
   bool Preemptible = isPreemptible(Body, Type);
   if (Body.isGnuIFunc()) {
@@ -528,7 +526,7 @@ static RelExpr adjustExpr(const elf::Obj
   // only memory. We can hack around it if we are producing an executable and
   // the refered symbol can be preemepted to refer to the executable.
   if (Config->Shared || (Config->pic() && !isRelExpr(Expr))) {
-    error(S.getLocation(RelOff) + ": can't create dynamic relocation " +
+    error(S.getLocation<ELFT>(RelOff) + ": can't create dynamic relocation " +
           toString(Type) + " against " +
           (Body.getName().empty() ? "local symbol in readonly segment"
                                   : "symbol '" + toString(Body) + "'") +
@@ -536,8 +534,8 @@ static RelExpr adjustExpr(const elf::Obj
     return Expr;
   }
   if (Body.getVisibility() != STV_DEFAULT) {
-    error(S.getLocation(RelOff) + ": cannot preempt symbol '" + toString(Body) +
-          "' defined in " + toString(Body.File));
+    error(S.getLocation<ELFT>(RelOff) + ": cannot preempt symbol '" +
+          toString(Body) + "' defined in " + toString(Body.File));
     return Expr;
   }
   if (Body.isObject()) {
@@ -545,8 +543,8 @@ static RelExpr adjustExpr(const elf::Obj
     auto *B = cast<SharedSymbol<ELFT>>(&Body);
     if (!B->NeedsCopy) {
       if (Config->ZNocopyreloc)
-        error(S.getLocation(RelOff) + ": unresolvable relocation " + toString(Type)
-              + " against symbol '" + toString(*B) +
+        error(S.getLocation<ELFT>(RelOff) + ": unresolvable relocation " +
+              toString(Type) + " against symbol '" + toString(*B) +
               "'; recompile with -fPIC or remove '-z nocopyreloc'");
 
       addCopyRelSymbol(B);
@@ -610,7 +608,7 @@ static int64_t computeAddend(const elf::
 }
 
 template <class ELFT>
-static void reportUndefined(SymbolBody &Sym, InputSectionBase<ELFT> &S,
+static void reportUndefined(SymbolBody &Sym, InputSectionBase &S,
                             typename ELFT::uint Offset) {
   bool CanBeExternal = Sym.symbol()->computeBinding() != STB_LOCAL &&
                        Sym.getVisibility() == STV_DEFAULT;
@@ -618,8 +616,8 @@ static void reportUndefined(SymbolBody &
       (Config->UnresolvedSymbols == UnresolvedPolicy::Ignore && CanBeExternal))
     return;
 
-  std::string Msg =
-      S.getLocation(Offset) + ": undefined symbol '" + toString(Sym) + "'";
+  std::string Msg = S.getLocation<ELFT>(Offset) + ": undefined symbol '" +
+                    toString(Sym) + "'";
 
   if (Config->UnresolvedSymbols == UnresolvedPolicy::WarnAll ||
       (Config->UnresolvedSymbols == UnresolvedPolicy::Warn && CanBeExternal))
@@ -658,7 +656,7 @@ mergeMipsN32RelTypes(uint32_t Type, uint
 // complicates things for the dynamic linker and means we would have to reserve
 // space for the extra PT_LOAD even if we end up not using it.
 template <class ELFT, class RelTy>
-static void scanRelocs(InputSectionBase<ELFT> &C, ArrayRef<RelTy> Rels) {
+static void scanRelocs(InputSectionBase &C, ArrayRef<RelTy> Rels) {
   typedef typename ELFT::uint uintX_t;
 
   bool IsWrite = C.Flags & SHF_WRITE;
@@ -667,7 +665,7 @@ static void scanRelocs(InputSectionBase<
     In<ELFT>::RelaDyn->addReloc(Reloc);
   };
 
-  const elf::ObjectFile<ELFT> *File = C.getFile();
+  const elf::ObjectFile<ELFT> *File = C.getFile<ELFT>();
   ArrayRef<uint8_t> SectionData = C.Data;
   const uint8_t *Buf = SectionData.begin();
 
@@ -693,7 +691,7 @@ static void scanRelocs(InputSectionBase<
     // We only report undefined symbols if they are referenced somewhere in the
     // code.
     if (!Body.isLocal() && Body.isUndefined() && !Body.symbol()->isWeak())
-      reportUndefined(Body, C, RI.r_offset);
+      reportUndefined<ELFT>(Body, C, RI.r_offset);
 
     RelExpr Expr = Target->getRelExpr(Type, Body);
     bool Preemptible = isPreemptible(Body, Type);
@@ -762,7 +760,7 @@ static void scanRelocs(InputSectionBase<
       // We don't know anything about the finaly symbol. Just ask the dynamic
       // linker to handle the relocation for us.
       if (!Target->isPicRel(Type))
-        error(C.getLocation(Offset) + ": relocation " + toString(Type) +
+        error(C.getLocation<ELFT>(Offset) + ": relocation " + toString(Type) +
               " cannot be used against shared object; recompile with -fPIC.");
       AddDyn({Target->getDynRel(Type), &C, Offset, false, &Body, Addend});
 
@@ -853,11 +851,11 @@ static void scanRelocs(InputSectionBase<
   }
 }
 
-template <class ELFT> void scanRelocations(InputSectionBase<ELFT> &S) {
+template <class ELFT> void scanRelocations(InputSectionBase &S) {
   if (S.AreRelocsRela)
-    scanRelocs(S, S.relas());
+    scanRelocs<ELFT>(S, S.relas<ELFT>());
   else
-    scanRelocs(S, S.rels());
+    scanRelocs<ELFT>(S, S.rels<ELFT>());
 }
 
 // Insert the Thunks for OutputSection OS into their designated place
@@ -940,7 +938,7 @@ void createThunks(ArrayRef<OutputSection
     if (TS == nullptr) {
       uint32_t Off = 0;
       for (auto *IS : OS->Sections) {
-        Off = IS->OutSecOff + IS->getSize();
+        Off = IS->OutSecOff + IS->template getSize<ELFT>();
         if ((IS->Flags & SHF_EXECINSTR) == 0)
           break;
       }
@@ -964,7 +962,8 @@ void createThunks(ArrayRef<OutputSection
     for (InputSection<ELFT> *IS : OS->Sections) {
       for (Relocation &Rel : IS->Relocations) {
         SymbolBody &Body = *Rel.Sym;
-        if (Target->needsThunk(Rel.Expr, Rel.Type, IS->getFile(), Body)) {
+        if (Target->needsThunk(Rel.Expr, Rel.Type, IS->template getFile<ELFT>(),
+                               Body)) {
           Thunk<ELFT> *T;
           bool IsNew;
           std::tie(T, IsNew) = GetThunk(Body, Rel.Type);
@@ -990,10 +989,10 @@ void createThunks(ArrayRef<OutputSection
     mergeThunks<ELFT>(KV.first, KV.second);
 }
 
-template void scanRelocations<ELF32LE>(InputSectionBase<ELF32LE> &);
-template void scanRelocations<ELF32BE>(InputSectionBase<ELF32BE> &);
-template void scanRelocations<ELF64LE>(InputSectionBase<ELF64LE> &);
-template void scanRelocations<ELF64BE>(InputSectionBase<ELF64BE> &);
+template void scanRelocations<ELF32LE>(InputSectionBase &);
+template void scanRelocations<ELF32BE>(InputSectionBase &);
+template void scanRelocations<ELF64LE>(InputSectionBase &);
+template void scanRelocations<ELF64BE>(InputSectionBase &);
 
 template void createThunks<ELF32LE>(ArrayRef<OutputSectionBase *>);
 template void createThunks<ELF32BE>(ArrayRef<OutputSectionBase *>);

Modified: lld/trunk/ELF/Relocations.h
URL: http://llvm.org/viewvc/llvm-project/lld/trunk/ELF/Relocations.h?rev=295923&r1=295922&r2=295923&view=diff
==============================================================================
--- lld/trunk/ELF/Relocations.h (original)
+++ lld/trunk/ELF/Relocations.h Wed Feb 22 20:28:28 2017
@@ -17,7 +17,7 @@ namespace elf {
 class SymbolBody;
 class InputSectionData;
 template <class ELFT> class InputSection;
-template <class ELFT> class InputSectionBase;
+class InputSectionBase;
 class OutputSectionBase;
 
 // List of target-independent relocation types. Relocations read
@@ -109,7 +109,7 @@ struct Relocation {
   SymbolBody *Sym;
 };
 
-template <class ELFT> void scanRelocations(InputSectionBase<ELFT> &);
+template <class ELFT> void scanRelocations(InputSectionBase &);
 
 template <class ELFT>
 void createThunks(ArrayRef<OutputSectionBase *> OutputSections);

Modified: lld/trunk/ELF/SymbolTable.cpp
URL: http://llvm.org/viewvc/llvm-project/lld/trunk/ELF/SymbolTable.cpp?rev=295923&r1=295922&r2=295923&view=diff
==============================================================================
--- lld/trunk/ELF/SymbolTable.cpp (original)
+++ lld/trunk/ELF/SymbolTable.cpp Wed Feb 22 20:28:28 2017
@@ -361,28 +361,26 @@ static void reportDuplicate(SymbolBody *
 }
 
 template <class ELFT>
-static void reportDuplicate(SymbolBody *Existing,
-                            InputSectionBase<ELFT> *ErrSec,
+static void reportDuplicate(SymbolBody *Existing, InputSectionBase *ErrSec,
                             typename ELFT::uint ErrOffset) {
   DefinedRegular<ELFT> *D = dyn_cast<DefinedRegular<ELFT>>(Existing);
   if (!D || !D->Section || !ErrSec) {
-    reportDuplicate(Existing, ErrSec ? ErrSec->getFile() : nullptr);
+    reportDuplicate(Existing, ErrSec ? ErrSec->getFile<ELFT>() : nullptr);
     return;
   }
 
-  std::string OldLoc = D->Section->getLocation(D->Value);
-  std::string NewLoc = ErrSec->getLocation(ErrOffset);
+  std::string OldLoc = D->Section->template getLocation<ELFT>(D->Value);
+  std::string NewLoc = ErrSec->getLocation<ELFT>(ErrOffset);
 
   print(NewLoc + ": duplicate symbol '" + toString(*Existing) + "'");
   print(OldLoc + ": previous definition was here");
 }
 
 template <typename ELFT>
-Symbol *SymbolTable<ELFT>::addRegular(StringRef Name, uint8_t StOther,
-                                      uint8_t Type, uintX_t Value, uintX_t Size,
-                                      uint8_t Binding,
-                                      InputSectionBase<ELFT> *Section,
-                                      InputFile *File) {
+Symbol *
+SymbolTable<ELFT>::addRegular(StringRef Name, uint8_t StOther, uint8_t Type,
+                              uintX_t Value, uintX_t Size, uint8_t Binding,
+                              InputSectionBase *Section, InputFile *File) {
   Symbol *S;
   bool WasInserted;
   std::tie(S, WasInserted) = insert(Name, Type, getVisibility(StOther),
@@ -393,7 +391,7 @@ Symbol *SymbolTable<ELFT>::addRegular(St
     replaceBody<DefinedRegular<ELFT>>(S, Name, /*IsLocal=*/false, StOther, Type,
                                       Value, Size, Section, File);
   else if (Cmp == 0)
-    reportDuplicate(S->body(), Section, Value);
+    reportDuplicate<ELFT>(S->body(), Section, Value);
   return S;
 }
 

Modified: lld/trunk/ELF/SymbolTable.h
URL: http://llvm.org/viewvc/llvm-project/lld/trunk/ELF/SymbolTable.h?rev=295923&r1=295922&r2=295923&view=diff
==============================================================================
--- lld/trunk/ELF/SymbolTable.h (original)
+++ lld/trunk/ELF/SymbolTable.h Wed Feb 22 20:28:28 2017
@@ -60,7 +60,7 @@ public:
 
   Symbol *addRegular(StringRef Name, uint8_t StOther, uint8_t Type,
                      uintX_t Value, uintX_t Size, uint8_t Binding,
-                     InputSectionBase<ELFT> *Section, InputFile *File);
+                     InputSectionBase *Section, InputFile *File);
 
   Symbol *addSynthetic(StringRef N, const OutputSectionBase *Section,
                        uintX_t Value, uint8_t StOther);
@@ -92,7 +92,7 @@ public:
   void trace(StringRef Name);
   void wrap(StringRef Name);
 
-  std::vector<InputSectionBase<ELFT> *> Sections;
+  std::vector<InputSectionBase *> Sections;
 
 private:
   std::vector<SymbolBody *> findByVersion(SymbolVersion Ver);

Modified: lld/trunk/ELF/Symbols.cpp
URL: http://llvm.org/viewvc/llvm-project/lld/trunk/ELF/Symbols.cpp?rev=295923&r1=295922&r2=295923&view=diff
==============================================================================
--- lld/trunk/ELF/Symbols.cpp (original)
+++ lld/trunk/ELF/Symbols.cpp Wed Feb 22 20:28:28 2017
@@ -44,7 +44,7 @@ static typename ELFT::uint getSymVA(cons
   }
   case SymbolBody::DefinedRegularKind: {
     auto &D = cast<DefinedRegular<ELFT>>(Body);
-    InputSectionBase<ELFT> *IS = D.Section;
+    InputSectionBase *IS = D.Section;
 
     // According to the ELF spec reference to a local symbol from outside
     // the group are not allowed. Unfortunately .eh_frame breaks that rule
@@ -62,8 +62,8 @@ static typename ELFT::uint getSymVA(cons
       Offset += Addend;
       Addend = 0;
     }
-    const OutputSectionBase *OutSec = IS->getOutputSection();
-    uintX_t VA = (OutSec ? OutSec->Addr : 0) + IS->getOffset(Offset);
+    const OutputSectionBase *OutSec = IS->getOutputSection<ELFT>();
+    uintX_t VA = (OutSec ? OutSec->Addr : 0) + IS->getOffset<ELFT>(Offset);
     if (D.isTls() && !Config->Relocatable) {
       if (!Out<ELFT>::TlsPhdr)
         fatal(toString(D.File) +
@@ -219,7 +219,8 @@ template <class ELFT> bool DefinedRegula
   if (!Section || !isFunc())
     return false;
   return (this->StOther & STO_MIPS_MIPS16) == STO_MIPS_PIC ||
-         (Section->getFile()->getObj().getHeader()->e_flags & EF_MIPS_PIC);
+         (Section->getFile<ELFT>()->getObj().getHeader()->e_flags &
+          EF_MIPS_PIC);
 }
 
 Undefined::Undefined(StringRefZ Name, bool IsLocal, uint8_t StOther,

Modified: lld/trunk/ELF/Symbols.h
URL: http://llvm.org/viewvc/llvm-project/lld/trunk/ELF/Symbols.h?rev=295923&r1=295922&r2=295923&view=diff
==============================================================================
--- lld/trunk/ELF/Symbols.h (original)
+++ lld/trunk/ELF/Symbols.h Wed Feb 22 20:28:28 2017
@@ -180,7 +180,7 @@ template <class ELFT> class DefinedRegul
 
 public:
   DefinedRegular(StringRefZ Name, bool IsLocal, uint8_t StOther, uint8_t Type,
-                 uintX_t Value, uintX_t Size, InputSectionBase<ELFT> *Section,
+                 uintX_t Value, uintX_t Size, InputSectionBase *Section,
                  InputFile *File)
       : Defined(SymbolBody::DefinedRegularKind, Name, IsLocal, StOther, Type),
         Value(Value), Size(Size),
@@ -204,14 +204,13 @@ public:
   // manipulates this Section pointers so that they point to the same
   // section. This is a bit tricky, so be careful to not be confused.
   // If this is null, the symbol is an absolute symbol.
-  InputSectionBase<ELFT> *&Section;
+  InputSectionBase *&Section;
 
 private:
-  static InputSectionBase<ELFT> *NullInputSection;
+  static InputSectionBase *NullInputSection;
 };
 
-template <class ELFT>
-InputSectionBase<ELFT> *DefinedRegular<ELFT>::NullInputSection;
+template <class ELFT> InputSectionBase *DefinedRegular<ELFT>::NullInputSection;
 
 // DefinedSynthetic is a class to represent linker-generated ELF symbols.
 // The difference from the regular symbol is that DefinedSynthetic symbols

Modified: lld/trunk/ELF/SyntheticSections.cpp
URL: http://llvm.org/viewvc/llvm-project/lld/trunk/ELF/SyntheticSections.cpp?rev=295923&r1=295922&r2=295923&view=diff
==============================================================================
--- lld/trunk/ELF/SyntheticSections.cpp (original)
+++ lld/trunk/ELF/SyntheticSections.cpp Wed Feb 22 20:28:28 2017
@@ -130,13 +130,13 @@ MipsAbiFlagsSection<ELFT> *MipsAbiFlagsS
   Elf_Mips_ABIFlags Flags = {};
   bool Create = false;
 
-  for (InputSectionBase<ELFT> *Sec : Symtab<ELFT>::X->Sections) {
+  for (InputSectionBase *Sec : Symtab<ELFT>::X->Sections) {
     if (!Sec->Live || Sec->Type != SHT_MIPS_ABIFLAGS)
       continue;
     Sec->Live = false;
     Create = true;
 
-    std::string Filename = toString(Sec->getFile());
+    std::string Filename = toString(Sec->getFile<ELFT>());
     const size_t Size = Sec->Data.size();
     // Older version of BFD (such as the default FreeBSD linker) concatenate
     // .MIPS.abiflags instead of merging. To allow for this case (or potential
@@ -197,13 +197,13 @@ MipsOptionsSection<ELFT> *MipsOptionsSec
   Elf_Mips_RegInfo Reginfo = {};
   bool Create = false;
 
-  for (InputSectionBase<ELFT> *Sec : Symtab<ELFT>::X->Sections) {
+  for (InputSectionBase *Sec : Symtab<ELFT>::X->Sections) {
     if (!Sec->Live || Sec->Type != SHT_MIPS_OPTIONS)
       continue;
     Sec->Live = false;
     Create = true;
 
-    std::string Filename = toString(Sec->getFile());
+    std::string Filename = toString(Sec->getFile<ELFT>());
     ArrayRef<uint8_t> D = Sec->Data;
 
     while (!D.empty()) {
@@ -217,7 +217,7 @@ MipsOptionsSection<ELFT> *MipsOptionsSec
         if (Config->Relocatable && Opt->getRegInfo().ri_gp_value)
           error(Filename + ": unsupported non-zero ri_gp_value");
         Reginfo.ri_gprmask |= Opt->getRegInfo().ri_gprmask;
-        Sec->getFile()->MipsGp0 = Opt->getRegInfo().ri_gp_value;
+        Sec->getFile<ELFT>()->MipsGp0 = Opt->getRegInfo().ri_gp_value;
         break;
       }
 
@@ -253,22 +253,24 @@ MipsReginfoSection<ELFT> *MipsReginfoSec
   Elf_Mips_RegInfo Reginfo = {};
   bool Create = false;
 
-  for (InputSectionBase<ELFT> *Sec : Symtab<ELFT>::X->Sections) {
+  for (InputSectionBase *Sec : Symtab<ELFT>::X->Sections) {
     if (!Sec->Live || Sec->Type != SHT_MIPS_REGINFO)
       continue;
     Sec->Live = false;
     Create = true;
 
     if (Sec->Data.size() != sizeof(Elf_Mips_RegInfo)) {
-      error(toString(Sec->getFile()) + ": invalid size of .reginfo section");
+      error(toString(Sec->getFile<ELFT>()) +
+            ": invalid size of .reginfo section");
       return nullptr;
     }
     auto *R = reinterpret_cast<const Elf_Mips_RegInfo *>(Sec->Data.data());
     if (Config->Relocatable && R->ri_gp_value)
-      error(toString(Sec->getFile()) + ": unsupported non-zero ri_gp_value");
+      error(toString(Sec->getFile<ELFT>()) +
+            ": unsupported non-zero ri_gp_value");
 
     Reginfo.ri_gprmask |= R->ri_gprmask;
-    Sec->getFile()->MipsGp0 = R->ri_gp_value;
+    Sec->getFile<ELFT>()->MipsGp0 = R->ri_gp_value;
   };
 
   if (Create)
@@ -288,10 +290,9 @@ template <class ELFT> InputSection<ELFT>
 }
 
 template <class ELFT>
-SymbolBody *elf::addSyntheticLocal(StringRef Name, uint8_t Type,
-                                   typename ELFT::uint Value,
-                                   typename ELFT::uint Size,
-                                   InputSectionBase<ELFT> *Section) {
+SymbolBody *
+elf::addSyntheticLocal(StringRef Name, uint8_t Type, typename ELFT::uint Value,
+                       typename ELFT::uint Size, InputSectionBase *Section) {
   auto *S = make<DefinedRegular<ELFT>>(Name, /*IsLocal*/ true, STV_DEFAULT,
                                        Type, Value, Size, Section, nullptr);
   if (In<ELFT>::SymTab)
@@ -452,7 +453,7 @@ template <class ELFT> bool GotSection<EL
 }
 
 template <class ELFT> void GotSection<ELFT>::writeTo(uint8_t *Buf) {
-  this->relocate(Buf, Buf + Size);
+  this->template relocate<ELFT>(Buf, Buf + Size);
 }
 
 template <class ELFT>
@@ -494,7 +495,8 @@ void MipsGotSection<ELFT>::addEntry(Symb
     // method calculate number of "pages" required to cover all saved output
     // section and allocate appropriate number of GOT entries.
     auto *DefSym = cast<DefinedRegular<ELFT>>(&Sym);
-    PageIndexMap.insert({DefSym->Section->getOutputSection(), 0});
+    PageIndexMap.insert(
+        {DefSym->Section->template getOutputSection<ELFT>(), 0});
     return;
   }
   if (Sym.isTls()) {
@@ -565,7 +567,8 @@ typename MipsGotSection<ELFT>::uintX_t
 MipsGotSection<ELFT>::getPageEntryOffset(const SymbolBody &B,
                                          int64_t Addend) const {
   const OutputSectionBase *OutSec =
-      cast<DefinedRegular<ELFT>>(&B)->Section->getOutputSection();
+      cast<DefinedRegular<ELFT>>(&B)
+          ->Section->template getOutputSection<ELFT>();
   uintX_t SecAddr = getMipsPageAddr(OutSec->Addr);
   uintX_t SymAddr = getMipsPageAddr(B.getVA<ELFT>(Addend));
   uintX_t Index = PageIndexMap.lookup(OutSec) + (SymAddr - SecAddr) / 0xffff;
@@ -976,7 +979,7 @@ template <class ELFT> void DynamicSectio
 
 template <class ELFT>
 typename ELFT::uint DynamicReloc<ELFT>::getOffset() const {
-  return InputSec->OutSec->Addr + InputSec->getOffset(OffsetInSec);
+  return InputSec->OutSec->Addr + InputSec->getOffset<ELFT>(OffsetInSec);
 }
 
 template <class ELFT> int64_t DynamicReloc<ELFT>::getAddend() const {
@@ -1168,14 +1171,14 @@ void SymbolTableSection<ELFT>::writeLoca
 
   for (auto I = Symbols.begin(); I != Symbols.begin() + NumLocals; ++I) {
     const DefinedRegular<ELFT> &Body = *cast<DefinedRegular<ELFT>>(I->Symbol);
-    InputSectionBase<ELFT> *Section = Body.Section;
+    InputSectionBase *Section = Body.Section;
     auto *ESym = reinterpret_cast<Elf_Sym *>(Buf);
 
     if (!Section) {
       ESym->st_shndx = SHN_ABS;
       ESym->st_value = Body.Value;
     } else {
-      const OutputSectionBase *OutSec = Section->getOutputSection();
+      const OutputSectionBase *OutSec = Section->getOutputSection<ELFT>();
       ESym->st_shndx = OutSec->SectionIndex;
       ESym->st_value = OutSec->Addr + Section->getOffset(Body);
     }
@@ -1241,7 +1244,7 @@ SymbolTableSection<ELFT>::getOutputSecti
   case SymbolBody::DefinedRegularKind: {
     auto &D = cast<DefinedRegular<ELFT>>(*Sym);
     if (D.Section)
-      return D.Section->getOutputSection();
+      return D.Section->template getOutputSection<ELFT>();
     break;
   }
   case SymbolBody::DefinedCommonKind:
@@ -1512,7 +1515,7 @@ GdbIndexSection<ELFT>::GdbIndexSection()
       StringPool(llvm::StringTableBuilder::ELF) {}
 
 template <class ELFT> void GdbIndexSection<ELFT>::parseDebugSections() {
-  for (InputSectionBase<ELFT> *S : Symtab<ELFT>::X->Sections)
+  for (InputSectionBase *S : Symtab<ELFT>::X->Sections)
     if (InputSection<ELFT> *IS = dyn_cast<InputSection<ELFT>>(S))
       if (IS->OutSec && IS->Name == ".debug_info")
         readDwarf(IS);
@@ -1610,7 +1613,8 @@ template <class ELFT> void GdbIndexSecti
 
   // Write the address area.
   for (AddressEntry<ELFT> &E : AddressArea) {
-    uintX_t BaseAddr = E.Section->OutSec->Addr + E.Section->getOffset(0);
+    uintX_t BaseAddr =
+        E.Section->OutSec->Addr + E.Section->template getOffset<ELFT>(0);
     write64le(Buf, BaseAddr + E.LowAddress);
     write64le(Buf + 8, BaseAddr + E.HighAddress);
     write32le(Buf + 16, E.CuIndex);
@@ -1969,8 +1973,10 @@ void ARMExidxSentinelSection<ELFT>::writ
   // Get the InputSection before us, we are by definition last
   auto RI = cast<OutputSection<ELFT>>(this->OutSec)->Sections.rbegin();
   InputSection<ELFT> *LE = *(++RI);
-  InputSection<ELFT> *LC = cast<InputSection<ELFT>>(LE->getLinkOrderDep());
-  uint64_t S = LC->OutSec->Addr + LC->getOffset(LC->getSize());
+  InputSection<ELFT> *LC =
+      cast<InputSection<ELFT>>(LE->template getLinkOrderDep<ELFT>());
+  uint64_t S = LC->OutSec->Addr +
+               LC->template getOffset<ELFT>(LC->template getSize<ELFT>());
   uint64_t P = this->getVA();
   Target->relocateOne(Buf, R_ARM_PREL31, S - P);
   write32le(Buf + 4, 0x1);
@@ -2018,18 +2024,22 @@ template MergeInputSection<ELF32BE> *elf
 template MergeInputSection<ELF64LE> *elf::createCommentSection();
 template MergeInputSection<ELF64BE> *elf::createCommentSection();
 
-template SymbolBody *
-elf::addSyntheticLocal<ELF32LE>(StringRef, uint8_t, ELF32LE::uint,
-                                ELF32LE::uint, InputSectionBase<ELF32LE> *);
-template SymbolBody *
-elf::addSyntheticLocal<ELF32BE>(StringRef, uint8_t, ELF32BE::uint,
-                                ELF32BE::uint, InputSectionBase<ELF32BE> *);
-template SymbolBody *
-elf::addSyntheticLocal<ELF64LE>(StringRef, uint8_t, ELF64LE::uint,
-                                ELF64LE::uint, InputSectionBase<ELF64LE> *);
-template SymbolBody *
-elf::addSyntheticLocal<ELF64BE>(StringRef, uint8_t, ELF64BE::uint,
-                                ELF64BE::uint, InputSectionBase<ELF64BE> *);
+template SymbolBody *elf::addSyntheticLocal<ELF32LE>(StringRef, uint8_t,
+                                                     ELF32LE::uint,
+                                                     ELF32LE::uint,
+                                                     InputSectionBase *);
+template SymbolBody *elf::addSyntheticLocal<ELF32BE>(StringRef, uint8_t,
+                                                     ELF32BE::uint,
+                                                     ELF32BE::uint,
+                                                     InputSectionBase *);
+template SymbolBody *elf::addSyntheticLocal<ELF64LE>(StringRef, uint8_t,
+                                                     ELF64LE::uint,
+                                                     ELF64LE::uint,
+                                                     InputSectionBase *);
+template SymbolBody *elf::addSyntheticLocal<ELF64BE>(StringRef, uint8_t,
+                                                     ELF64BE::uint,
+                                                     ELF64BE::uint,
+                                                     InputSectionBase *);
 
 template class elf::MipsAbiFlagsSection<ELF32LE>;
 template class elf::MipsAbiFlagsSection<ELF32BE>;

Modified: lld/trunk/ELF/SyntheticSections.h
URL: http://llvm.org/viewvc/llvm-project/lld/trunk/ELF/SyntheticSections.h?rev=295923&r1=295922&r2=295923&view=diff
==============================================================================
--- lld/trunk/ELF/SyntheticSections.h (original)
+++ lld/trunk/ELF/SyntheticSections.h Wed Feb 22 20:28:28 2017
@@ -277,7 +277,7 @@ template <class ELFT> class DynamicReloc
   typedef typename ELFT::uint uintX_t;
 
 public:
-  DynamicReloc(uint32_t Type, const InputSectionBase<ELFT> *InputSec,
+  DynamicReloc(uint32_t Type, const InputSectionBase *InputSec,
                uintX_t OffsetInSec, bool UseSymVA, SymbolBody *Sym,
                int64_t Addend)
       : Type(Type), Sym(Sym), InputSec(InputSec), OffsetInSec(OffsetInSec),
@@ -286,13 +286,13 @@ public:
   uintX_t getOffset() const;
   int64_t getAddend() const;
   uint32_t getSymIndex() const;
-  const InputSectionBase<ELFT> *getInputSec() const { return InputSec; }
+  const InputSectionBase *getInputSec() const { return InputSec; }
 
   uint32_t Type;
 
 private:
   SymbolBody *Sym;
-  const InputSectionBase<ELFT> *InputSec = nullptr;
+  const InputSectionBase *InputSec = nullptr;
   uintX_t OffsetInSec;
   bool UseSymVA;
   int64_t Addend;
@@ -749,7 +749,7 @@ template <class ELFT> MergeInputSection<
 template <class ELFT>
 SymbolBody *
 addSyntheticLocal(StringRef Name, uint8_t Type, typename ELFT::uint Value,
-                  typename ELFT::uint Size, InputSectionBase<ELFT> *Section);
+                  typename ELFT::uint Size, InputSectionBase *Section);
 
 // Linker generated sections which can be used as inputs.
 template <class ELFT> struct In {

Modified: lld/trunk/ELF/Target.cpp
URL: http://llvm.org/viewvc/llvm-project/lld/trunk/ELF/Target.cpp?rev=295923&r1=295922&r2=295923&view=diff
==============================================================================
--- lld/trunk/ELF/Target.cpp (original)
+++ lld/trunk/ELF/Target.cpp Wed Feb 22 20:28:28 2017
@@ -66,8 +66,8 @@ template <class ELFT> static std::string
       continue;
 
     uint8_t *ISLoc = cast<OutputSection<ELFT>>(IS->OutSec)->Loc + IS->OutSecOff;
-    if (ISLoc <= Loc && Loc < ISLoc + IS->getSize())
-      return IS->getLocation(Loc - ISLoc) + ": ";
+    if (ISLoc <= Loc && Loc < ISLoc + IS->template getSize<ELFT>())
+      return IS->template getLocation<ELFT>(Loc - ISLoc) + ": ";
   }
   return "";
 }
@@ -1760,8 +1760,8 @@ void ARMTargetInfo::writePltHeader(uint8
 
 void ARMTargetInfo::addPltHeaderSymbols(InputSectionData *ISD) const {
   auto *IS = cast<InputSection<ELF32LE>>(ISD);
-  addSyntheticLocal("$a", STT_NOTYPE, 0, 0, IS);
-  addSyntheticLocal("$d", STT_NOTYPE, 16, 0, IS);
+  addSyntheticLocal<ELF32LE>("$a", STT_NOTYPE, 0, 0, IS);
+  addSyntheticLocal<ELF32LE>("$d", STT_NOTYPE, 16, 0, IS);
 }
 
 void ARMTargetInfo::writePlt(uint8_t *Buf, uint64_t GotEntryAddr,
@@ -1783,8 +1783,8 @@ void ARMTargetInfo::writePlt(uint8_t *Bu
 
 void ARMTargetInfo::addPltSymbols(InputSectionData *ISD, uint64_t Off) const {
   auto *IS = cast<InputSection<ELF32LE>>(ISD);
-  addSyntheticLocal("$a", STT_NOTYPE, Off, 0, IS);
-  addSyntheticLocal("$d", STT_NOTYPE, Off + 12, 0, IS);
+  addSyntheticLocal<ELF32LE>("$a", STT_NOTYPE, Off, 0, IS);
+  addSyntheticLocal<ELF32LE>("$d", STT_NOTYPE, Off + 12, 0, IS);
 }
 
 bool ARMTargetInfo::needsThunk(RelExpr Expr, uint32_t RelocType,

Modified: lld/trunk/ELF/Thunks.cpp
URL: http://llvm.org/viewvc/llvm-project/lld/trunk/ELF/Thunks.cpp?rev=295923&r1=295922&r2=295923&view=diff
==============================================================================
--- lld/trunk/ELF/Thunks.cpp (original)
+++ lld/trunk/ELF/Thunks.cpp Wed Feb 22 20:28:28 2017
@@ -127,10 +127,10 @@ void ARMToThumbV7ABSLongThunk<ELFT>::wri
 
 template <class ELFT>
 void ARMToThumbV7ABSLongThunk<ELFT>::addSymbols(ThunkSection<ELFT> &IS) {
-  this->ThunkSym = addSyntheticLocal(
+  this->ThunkSym = addSyntheticLocal<ELFT>(
       Saver.save("__ARMToThumbv7ABSLongThunk_" + this->Destination.getName()),
       STT_FUNC, this->Offset, size(), &IS);
-  addSyntheticLocal("$a", STT_NOTYPE, this->Offset, 0, &IS);
+  addSyntheticLocal<ELFT>("$a", STT_NOTYPE, this->Offset, 0, &IS);
 }
 
 template <class ELFT>
@@ -149,10 +149,10 @@ void ThumbToARMV7ABSLongThunk<ELFT>::wri
 
 template <class ELFT>
 void ThumbToARMV7ABSLongThunk<ELFT>::addSymbols(ThunkSection<ELFT> &IS) {
-  this->ThunkSym = addSyntheticLocal(
+  this->ThunkSym = addSyntheticLocal<ELFT>(
       Saver.save("__ThumbToARMv7ABSLongThunk_" + this->Destination.getName()),
       STT_FUNC, this->Offset, size(), &IS);
-  addSyntheticLocal("$t", STT_NOTYPE, this->Offset, 0, &IS);
+  addSyntheticLocal<ELFT>("$t", STT_NOTYPE, this->Offset, 0, &IS);
 }
 
 template <class ELFT>
@@ -173,10 +173,10 @@ void ARMToThumbV7PILongThunk<ELFT>::writ
 
 template <class ELFT>
 void ARMToThumbV7PILongThunk<ELFT>::addSymbols(ThunkSection<ELFT> &IS) {
-  this->ThunkSym = addSyntheticLocal(
+  this->ThunkSym = addSyntheticLocal<ELFT>(
       Saver.save("__ARMToThumbV7PILongThunk_" + this->Destination.getName()),
       STT_FUNC, this->Offset, size(), &IS);
-  addSyntheticLocal("$a", STT_NOTYPE, this->Offset, 0, &IS);
+  addSyntheticLocal<ELFT>("$a", STT_NOTYPE, this->Offset, 0, &IS);
 }
 
 template <class ELFT>
@@ -197,10 +197,10 @@ void ThumbToARMV7PILongThunk<ELFT>::writ
 
 template <class ELFT>
 void ThumbToARMV7PILongThunk<ELFT>::addSymbols(ThunkSection<ELFT> &IS) {
-  this->ThunkSym = addSyntheticLocal(
+  this->ThunkSym = addSyntheticLocal<ELFT>(
       Saver.save("__ThumbToARMV7PILongThunk_" + this->Destination.getName()),
       STT_FUNC, this->Offset, size(), &IS);
-  addSyntheticLocal("$t", STT_NOTYPE, this->Offset, 0, &IS);
+  addSyntheticLocal<ELFT>("$t", STT_NOTYPE, this->Offset, 0, &IS);
 }
 
 // Write MIPS LA25 thunk code to call PIC function from the non-PIC one.
@@ -218,7 +218,7 @@ void MipsThunk<ELFT>::writeTo(uint8_t *B
 }
 
 template <class ELFT> void MipsThunk<ELFT>::addSymbols(ThunkSection<ELFT> &IS) {
-  this->ThunkSym = addSyntheticLocal(
+  this->ThunkSym = addSyntheticLocal<ELFT>(
       Saver.save("__LA25Thunk_" + this->Destination.getName()), STT_FUNC,
       this->Offset, size(), &IS);
 }

Modified: lld/trunk/ELF/Writer.cpp
URL: http://llvm.org/viewvc/llvm-project/lld/trunk/ELF/Writer.cpp?rev=295923&r1=295922&r2=295923&view=diff
==============================================================================
--- lld/trunk/ELF/Writer.cpp (original)
+++ lld/trunk/ELF/Writer.cpp Wed Feb 22 20:28:28 2017
@@ -54,7 +54,7 @@ private:
   void addSectionSymbols();
   void addReservedSymbols();
   void createSections();
-  void forEachRelSec(std::function<void(InputSectionBase<ELFT> &)> Fn);
+  void forEachRelSec(std::function<void(InputSectionBase &)> Fn);
   void sortSections();
   void finalizeSections();
   void addPredefinedSections();
@@ -152,7 +152,7 @@ template <class ELFT> void Writer<ELFT>:
 }
 
 template <class ELFT>
-static typename ELFT::uint getOutFlags(InputSectionBase<ELFT> *S) {
+static typename ELFT::uint getOutFlags(InputSectionBase *S) {
   return S->Flags & ~(typename ELFT::uint)(SHF_GROUP | SHF_COMPRESSED);
 }
 
@@ -164,7 +164,7 @@ template <class ELFT> static void combin
   typedef typename ELFT::uint uintX_t;
 
   std::vector<MergeSyntheticSection<ELFT> *> MergeSections;
-  for (InputSectionBase<ELFT> *&S : Symtab<ELFT>::X->Sections) {
+  for (InputSectionBase *&S : Symtab<ELFT>::X->Sections) {
     MergeInputSection<ELFT> *MS = dyn_cast<MergeInputSection<ELFT>>(S);
     if (!MS)
       continue;
@@ -175,7 +175,7 @@ template <class ELFT> static void combin
       continue;
 
     StringRef OutsecName = getOutputSectionName(MS->Name);
-    uintX_t Flags = getOutFlags(MS);
+    uintX_t Flags = getOutFlags<ELFT>(MS);
     uintX_t Alignment = std::max<uintX_t>(MS->Alignment, MS->Entsize);
 
     auto I =
@@ -195,7 +195,7 @@ template <class ELFT> static void combin
     (*I)->addSection(MS);
   }
 
-  std::vector<InputSectionBase<ELFT> *> &V = Symtab<ELFT>::X->Sections;
+  std::vector<InputSectionBase *> &V = Symtab<ELFT>::X->Sections;
   V.erase(std::remove(V.begin(), V.end(), nullptr), V.end());
 }
 
@@ -307,7 +307,7 @@ template <class ELFT> void Writer<ELFT>:
   // you can call lld::elf::main more than once as a library.
   memset(&Out<ELFT>::First, 0, sizeof(Out<ELFT>));
 
-  auto Add = [](InputSectionBase<ELFT> *Sec) {
+  auto Add = [](InputSectionBase *Sec) {
     Symtab<ELFT>::X->Sections.push_back(Sec);
   };
 
@@ -452,7 +452,7 @@ template <class ELFT> void Writer<ELFT>:
 }
 
 template <class ELFT>
-static bool shouldKeepInSymtab(InputSectionBase<ELFT> *Sec, StringRef SymName,
+static bool shouldKeepInSymtab(InputSectionBase *Sec, StringRef SymName,
                                const SymbolBody &B) {
   if (B.isFile() || B.isSection())
     return false;
@@ -514,7 +514,7 @@ template <class ELFT> void Writer<ELFT>:
       if (!includeInSymtab<ELFT>(*B))
         continue;
 
-      InputSectionBase<ELFT> *Sec = DR->Section;
+      InputSectionBase *Sec = DR->Section;
       if (!shouldKeepInSymtab<ELFT>(Sec, B->getName(), *B))
         continue;
       In<ELFT>::SymTab->addLocal(B);
@@ -747,7 +747,7 @@ addOptionalSynthetic(StringRef Name, Out
 }
 
 template <class ELFT>
-static Symbol *addRegular(StringRef Name, InputSectionBase<ELFT> *Sec,
+static Symbol *addRegular(StringRef Name, InputSectionBase *Sec,
                           typename ELFT::uint Value) {
   // The linker generated symbols are added as STB_WEAK to allow user defined
   // ones to override them.
@@ -757,14 +757,14 @@ static Symbol *addRegular(StringRef Name
 }
 
 template <class ELFT>
-static Symbol *addOptionalRegular(StringRef Name, InputSectionBase<ELFT> *IS,
+static Symbol *addOptionalRegular(StringRef Name, InputSectionBase *IS,
                                   typename ELFT::uint Value) {
   SymbolBody *S = Symtab<ELFT>::X->find(Name);
   if (!S)
     return nullptr;
   if (S->isInCurrentDSO())
     return S->symbol();
-  return addRegular(Name, IS, Value);
+  return addRegular<ELFT>(Name, IS, Value);
 }
 
 // The beginning and the ending of .rel[a].plt section are marked
@@ -903,9 +903,8 @@ static void sortBySymbolsOrder(ArrayRef<
 }
 
 template <class ELFT>
-void Writer<ELFT>::forEachRelSec(
-    std::function<void(InputSectionBase<ELFT> &)> Fn) {
-  for (InputSectionBase<ELFT> *IS : Symtab<ELFT>::X->Sections) {
+void Writer<ELFT>::forEachRelSec(std::function<void(InputSectionBase &)> Fn) {
+  for (InputSectionBase *IS : Symtab<ELFT>::X->Sections) {
     if (!IS->Live)
       continue;
     // Scan all relocations. Each relocation goes through a series
@@ -921,7 +920,7 @@ void Writer<ELFT>::forEachRelSec(
 }
 
 template <class ELFT> void Writer<ELFT>::createSections() {
-  for (InputSectionBase<ELFT> *IS : Symtab<ELFT>::X->Sections)
+  for (InputSectionBase *IS : Symtab<ELFT>::X->Sections)
     if (IS)
       Factory.addInputSec(IS, getOutputSectionName(IS->Name));
 
@@ -1047,7 +1046,7 @@ static void removeUnusedSyntheticSection
   // All input synthetic sections that can be empty are placed after
   // all regular ones. We iterate over them all and exit at first
   // non-synthetic.
-  for (InputSectionBase<ELFT> *S : llvm::reverse(Symtab<ELFT>::X->Sections)) {
+  for (InputSectionBase *S : llvm::reverse(Symtab<ELFT>::X->Sections)) {
     SyntheticSection<ELFT> *SS = dyn_cast<SyntheticSection<ELFT>>(S);
     if (!SS)
       return;
@@ -1084,7 +1083,7 @@ template <class ELFT> void Writer<ELFT>:
   // Even the author of gold doesn't remember why gold behaves that way.
   // https://sourceware.org/ml/binutils/2002-03/msg00360.html
   if (In<ELFT>::DynSymTab)
-    addRegular("_DYNAMIC", In<ELFT>::Dynamic, 0);
+    addRegular<ELFT>("_DYNAMIC", In<ELFT>::Dynamic, 0);
 
   // Define __rel[a]_iplt_{start,end} symbols if needed.
   addRelIpltSymbols();

Modified: lld/trunk/ELF/Writer.h
URL: http://llvm.org/viewvc/llvm-project/lld/trunk/ELF/Writer.h?rev=295923&r1=295922&r2=295923&view=diff
==============================================================================
--- lld/trunk/ELF/Writer.h (original)
+++ lld/trunk/ELF/Writer.h Wed Feb 22 20:28:28 2017
@@ -19,7 +19,7 @@ namespace lld {
 namespace elf {
 class InputFile;
 class OutputSectionBase;
-template <class ELFT> class InputSectionBase;
+class InputSectionBase;
 template <class ELFT> class ObjectFile;
 template <class ELFT> class SymbolTable;
 template <class ELFT> void writeResult();




More information about the llvm-commits mailing list