[ELF] - Detemplate BuildIdSection section.

[grimar]

Summary

Does not introduce anything new,
just performs detemplate, using methods we
already have.

[ruiu]

We are using ELFT::TargetEndianness everywhere, and this patch will change that. Doesn't this just add a different way of doing a thing that we are currently able to do? If you are going to use this in more places, please do that in this patch to demonstrate that.

[grimar]

• Changed patch to show that Config->getEndian() helps to detemplate BuildIdSection. In the same way it can be used for detemplating other places.

[grimar]

Also using getEndian for detemplating GdbIndexSection (D30976).

[ruiu]

I'm not still convinced that this is heading to the right direction. You removed a few templates in https://reviews.llvm.org/D30976, but some of them don't actually depend on this change, so they don't demonstrate how useful this change is. Can you refactor D30976 so that the patch doesn't contain unrelated de-template changes?

[grimar]

• Rebase.

[ruiu]

LGTM

ELF/Config.h

 #ifndef LLD_ELF_CONFIG_H
 #define LLD_ELF_CONFIG_H
 
 #include "llvm/ADT/MapVector.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/ADT/StringSet.h"
 #include "llvm/Support/CodeGen.h"
 #include "llvm/Support/ELF.h"
+#include "llvm/Support/Endian.h"
 
 #include <vector>
 
 namespace lld {
 namespace elf {
 
 class InputFile;
 struct Symbol;
struct Configuration {
   //
   // (Note that MIPS64EL is not a typo for MIPS64LE. This is the official
   // name whatever that means. A fun hypothesis is that "EL" is short for
   // little-endian written in the little-endian order, but I don't know
   // if that's true.)
   bool isMips64EL() const {
     return EMachine == llvm::ELF::EM_MIPS && EKind == ELF64LEKind;
   }
+
+  llvm::support::endianness getEndian() const {
+    return (EKind == ELF32LEKind || EKind == ELF64LEKind)
+               ? llvm::support::endianness::little
+               : llvm::support::endianness::big;
+  }
 };
 
 // The only instance of Configuration struct.
 extern Configuration *Config;
 
 } // namespace elf
 } // namespace lld
 
 #endif

ELF/LinkerScript.h

protected:
   llvm::DenseSet<OutputSection *> AlreadyOutputOS;
   llvm::DenseSet<InputSectionBase *> AlreadyOutputIS;
 
 public:
   bool hasPhdrsCommands() { return !Opt.PhdrsCommands.empty(); }
   uint64_t getDot() { return Dot; }
   OutputSection *getOutputSection(const Twine &Loc, StringRef S);
   uint64_t getOutputSectionSize(StringRef S);
+  void writeDataBytes(StringRef Name, uint8_t *Buf);
 
   virtual uint64_t getSymbolValue(const Twine &Loc, StringRef S) = 0;
   virtual bool isDefined(StringRef S) = 0;
   virtual bool isAbsolute(StringRef S) = 0;
   virtual OutputSection *getSymbolSection(StringRef S) = 0;
 
   std::vector<OutputSection *> *OutputSections;
   void addOrphanSections(OutputSectionFactory &Factory);

 };
 
 // This is a runner of the linker script.
 template <class ELFT> class LinkerScript final : public LinkerScriptBase {
 public:
   LinkerScript();
   ~LinkerScript();
 
-  void writeDataBytes(StringRef Name, uint8_t *Buf);
   void addSymbol(SymbolAssignment *Cmd);
   void discard(ArrayRef<InputSectionBase *> V);
   void processCommands(OutputSectionFactory &Factory);
 
   uint64_t getSymbolValue(const Twine &Loc, StringRef S) override;
   bool isDefined(StringRef S) override;
   bool isAbsolute(StringRef S) override;
   OutputSection *getSymbolSection(StringRef S) override;

ELF/LinkerScript.cpp

 uint32_t LinkerScriptBase::getFiller(StringRef Name) {
   for (const std::unique_ptr<BaseCommand> &Base : Opt.Commands)
     if (auto *Cmd = dyn_cast<OutputSectionCommand>(Base.get()))
       if (Cmd->Name == Name)
         return Cmd->Filler;
   return 0;
 }
 
-template <class ELFT>
 static void writeInt(uint8_t *Buf, uint64_t Data, uint64_t Size) {
-  const endianness E = ELFT::TargetEndianness;
+  const endianness E = Config->getEndian();
 
   switch (Size) {
   case 1:
     *Buf = (uint8_t)Data;
     break;
   case 2:
-    write16<E>(Buf, Data);
+    write16(Buf, Data, E);
     break;
   case 4:
-    write32<E>(Buf, Data);
+    write32(Buf, Data, E);
     break;
   case 8:
-    write64<E>(Buf, Data);
+    write64(Buf, Data, E);
     break;
   default:
     llvm_unreachable("unsupported Size argument");
   }
 }
 
-template <class ELFT>
-void LinkerScript<ELFT>::writeDataBytes(StringRef Name, uint8_t *Buf) {
+void LinkerScriptBase::writeDataBytes(StringRef Name, uint8_t *Buf) {
   int I = getSectionIndex(Name);
   if (I == INT_MAX)
     return;
 
   auto *Cmd = dyn_cast<OutputSectionCommand>(Opt.Commands[I].get());
   for (const std::unique_ptr<BaseCommand> &Base : Cmd->Commands)
     if (auto *Data = dyn_cast<BytesDataCommand>(Base.get()))
-      writeInt<ELFT>(Buf + Data->Offset, Data->Expression(), Data->Size);
+      writeInt(Buf + Data->Offset, Data->Expression(), Data->Size);
 }
 
 bool LinkerScriptBase::hasLMA(StringRef Name) {
   for (const std::unique_ptr<BaseCommand> &Base : Opt.Commands)
     if (auto *Cmd = dyn_cast<OutputSectionCommand>(Base.get()))
       if (Cmd->LMAExpr && Cmd->Name == Name)
         return true;
   return false;