[ELF] - Detemplate code relative to OutputSectionFactory

[grimar]

Summary

This cleanup removes some redundant templating.

[grimar]

Consumed by commits:
[ELF] - Remove unnecessary template. NFC. (https://reviews.llvm.org/rL297717)
[ELF] - Remove unnecessary template #2. NFC. (https://reviews.llvm.org/rL297718).
[ELF] - Remove unnecessary template #3. NFC. (https://reviews.llvm.org/rL297719).
[ELF] - Remove unnecessary template #4. NFC. (https://reviews.llvm.org/rL297720).

ELF/LinkerScript.cpp

if (auto *Cmd = dyn_cast<OutputSectionCommand>(Base1.get())) {
       if (Cmd->SubalignExpr) {
         uint32_t Subalign = Cmd->SubalignExpr();
         for (InputSectionBase *S : V)
           S->Alignment = Subalign;
       }
 
       // Add input sections to an output section.
       for (InputSectionBase *S : V)
-        Factory.addInputSec<ELFT>(S, Cmd->Name);
+        Factory.addInputSec(S, Cmd->Name);
     }
   }
   CurOutSec = nullptr;
 }
 
 // Add sections that didn't match any sections command.
 template <class ELFT>
 void LinkerScript<ELFT>::addOrphanSections(OutputSectionFactory &Factory) {
   for (InputSectionBase *S : InputSections)
     if (S->Live && !S->OutSec)
-      Factory.addInputSec<ELFT>(S, getOutputSectionName(S->Name));
+      Factory.addInputSec(S, getOutputSectionName(S->Name));
 }
 
 template <class ELFT> static bool isTbss(OutputSection *Sec) {
   return (Sec->Flags & SHF_TLS) && Sec->Type == SHT_NOBITS;
 }
 
 template <class ELFT> void LinkerScript<ELFT>::output(InputSection *S) {
   if (!AlreadyOutputIS.insert(S).second)

ELF/OutputSections.h

 // input section. Output section type is determined by various
 // factors, including input section's sh_flags, sh_type and
 // linker scripts.
 class OutputSectionFactory {
 public:
   OutputSectionFactory(std::vector<OutputSection *> &OutputSections);
   ~OutputSectionFactory();
 
-  template <class ELFT>
   void addInputSec(InputSectionBase *IS, StringRef OutsecName);
 
 private:
   llvm::SmallDenseMap<SectionKey, OutputSection *> Map;
   std::vector<OutputSection *> &OutputSections;
 };
 
 template <class ELFT> uint64_t getHeaderSize() {

ELF/OutputSections.cpp

template <class ELFT> void OutputSection::writeTo(uint8_t *Buf) {
   auto Fn = [=](InputSection *IS) { IS->writeTo<ELFT>(Buf); };
   forEach(Sections.begin(), Sections.end(), Fn);
 
   // Linker scripts may have BYTE()-family commands with which you
   // can write arbitrary bytes to the output. Process them if any.
   Script<ELFT>::X->writeDataBytes(this->Name, Buf);
 }
 
-template <class ELFT>
-static typename ELFT::uint getOutFlags(InputSectionBase *S) {
+static uint64_t getOutFlags(InputSectionBase *S) {
   return S->Flags & ~SHF_GROUP & ~SHF_COMPRESSED;
 }
 
-template <class ELFT>
 static SectionKey createKey(InputSectionBase *C, StringRef OutsecName) {
   //  The ELF spec just says
   // ----------------------------------------------------------------
   // In the first phase, input sections that match in name, type and
   // attribute flags should be concatenated into single sections.
   // ----------------------------------------------------------------
   //
   // However, it is clear that at least some flags have to be ignored for
static SectionKey createKey(InputSectionBase *C, StringRef OutsecName) {
   // and a mapping of .foo1 and .bar1 to one section and .foo2 and .bar2 to
   // another. The problem is that there is no way to layout those output
   // sections such that the .foo sections are the only thing between the start
   // and end symbols.
   //
   // Given the above issues, we instead merge sections by name and error on
   // incompatible types and flags.
 
-  typedef typename ELFT::uint uintX_t;
-
   uint32_t Alignment = 0;
-  uintX_t Flags = 0;
+  uint64_t Flags = 0;
   if (Config->Relocatable && (C->Flags & SHF_MERGE)) {
-    Alignment = std::max<uintX_t>(C->Alignment, C->Entsize);
+    Alignment = std::max<uint64_t>(C->Alignment, C->Entsize);
     Flags = C->Flags & (SHF_MERGE | SHF_STRINGS);
   }
 
   return SectionKey{OutsecName, Flags, Alignment};
 }
 
 OutputSectionFactory::OutputSectionFactory(
     std::vector<OutputSection *> &OutputSections)

 // any special treatment on top of progbits, so there doesn't
 // seem to be a harm in merging them.
 static bool canMergeToProgbits(unsigned Type) {
   return Type == SHT_NOBITS || Type == SHT_PROGBITS || Type == SHT_INIT_ARRAY ||
          Type == SHT_PREINIT_ARRAY || Type == SHT_FINI_ARRAY ||
          Type == SHT_NOTE;
 }
 
-template <class ELFT> static void reportDiscarded(InputSectionBase *IS) {
+static void reportDiscarded(InputSectionBase *IS) {
   if (!Config->PrintGcSections)
     return;
   message("removing unused section from '" + IS->Name + "' in file '" +
-          IS->getFile<ELFT>()->getName());
+          IS->File->getName());
 }
 
-template <class ELFT>
 void OutputSectionFactory::addInputSec(InputSectionBase *IS,
                                        StringRef OutsecName) {
   if (!IS->Live) {
-    reportDiscarded<ELFT>(IS);
+    reportDiscarded(IS);
     return;
   }
 
-  SectionKey Key = createKey<ELFT>(IS, OutsecName);
-  uint64_t Flags = getOutFlags<ELFT>(IS);
+  SectionKey Key = createKey(IS, OutsecName);
+  uint64_t Flags = getOutFlags(IS);
   OutputSection *&Sec = Map[Key];
   if (Sec) {
     if (getIncompatibleFlags(Sec->Flags) != getIncompatibleFlags(IS->Flags))
       error("Section has flags incompatible with others with the same name " +
             toString(IS));
     if (Sec->Type != IS->Type) {
       if (canMergeToProgbits(Sec->Type) && canMergeToProgbits(IS->Type))
         Sec->Type = SHT_PROGBITS;

 template void OutputSection::finalize<ELF64LE>();
 template void OutputSection::finalize<ELF64BE>();
 
 template void OutputSection::writeTo<ELF32LE>(uint8_t *Buf);
 template void OutputSection::writeTo<ELF32BE>(uint8_t *Buf);
 template void OutputSection::writeTo<ELF64LE>(uint8_t *Buf);
 template void OutputSection::writeTo<ELF64BE>(uint8_t *Buf);
 
-template void OutputSectionFactory::addInputSec<ELF32LE>(InputSectionBase *,
-                                                         StringRef);
-template void OutputSectionFactory::addInputSec<ELF32BE>(InputSectionBase *,
-                                                         StringRef);
-template void OutputSectionFactory::addInputSec<ELF64LE>(InputSectionBase *,
-                                                         StringRef);
-template void OutputSectionFactory::addInputSec<ELF64BE>(InputSectionBase *,
-                                                         StringRef);
 }
 }

ELF/Writer.cpp

if (!Config->Relocatable) {
     for (EhInputSection *ES : In<ELFT>::EhFrame->Sections)
       Fn(*ES);
   }
 }
 
 template <class ELFT> void Writer<ELFT>::createSections() {
   for (InputSectionBase *IS : InputSections)
     if (IS)
-      Factory.addInputSec<ELFT>(IS, getOutputSectionName(IS->Name));
+      Factory.addInputSec(IS, getOutputSectionName(IS->Name));
 
   sortBySymbolsOrder<ELFT>(OutputSections);
   sortInitFini<ELFT>(findSection(".init_array"));
   sortInitFini<ELFT>(findSection(".fini_array"));
   sortCtorsDtors<ELFT>(findSection(".ctors"));
   sortCtorsDtors<ELFT>(findSection(".dtors"));
 
   for (OutputSection *Sec : OutputSections)