Convert Out::InterpSection to In::InterpSection.

[ruiu]

Summary

Convert Out::InterpSection to In::InterpSection.

[evgeny777]

LGTM

lld/trunk/ELF/OutputSections.h

enum Kind {
     Base,
     Dynamic,
     EHFrame,
     EHFrameHdr,
     GnuHashTable,
     Got,
     GotPlt,
     HashTable,
-    Interp,
     Merge,
     MipsReginfo,
     MipsOptions,
     MipsAbiFlags,
     Plt,
     Regular,
     Reloc,
     StrTable,
private:
   std::vector<EhInputSection<ELFT> *> Sections;
   std::vector<CieRecord *> Cies;
 
   // CIE records are uniquified by their contents and personality functions.
   llvm::DenseMap<std::pair<ArrayRef<uint8_t>, SymbolBody *>, CieRecord> CieMap;
 };
 
 template <class ELFT>
-class InterpSection final : public OutputSectionBase<ELFT> {
-  typedef OutputSectionBase<ELFT> Base;
-
-public:
-  InterpSection();
-  void writeTo(uint8_t *Buf) override;
-  typename Base::Kind getKind() const override { return Base::Interp; }
-  static bool classof(const Base *B) { return B->getKind() == Base::Interp; }
-};
-
-template <class ELFT>
 class StringTableSection final : public OutputSectionBase<ELFT> {
   typedef OutputSectionBase<ELFT> Base;
 
 public:
   typedef typename ELFT::uint uintX_t;
   StringTableSection(StringRef Name, bool Dynamic);
   unsigned addString(StringRef S, bool HashIt = true);
   void writeTo(uint8_t *Buf) override;
template <class ELFT> struct Out {
   static DynamicSection<ELFT> *Dynamic;
   static EhFrameHeader<ELFT> *EhFrameHdr;
   static EhOutputSection<ELFT> *EhFrame;
   static GdbIndexSection<ELFT> *GdbIndex;
   static GnuHashTableSection<ELFT> *GnuHashTab;
   static GotPltSection<ELFT> *GotPlt;
   static GotSection<ELFT> *Got;
   static HashTableSection<ELFT> *HashTab;
-  static InterpSection<ELFT> *Interp;
   static OutputSection<ELFT> *Bss;
   static OutputSection<ELFT> *MipsRldMap;
   static OutputSectionBase<ELFT> *Opd;
   static uint8_t *OpdBuf;
   static PltSection<ELFT> *Plt;
   static RelocationSection<ELFT> *RelaDyn;
   static RelocationSection<ELFT> *RelaPlt;
   static StringTableSection<ELFT> *DynStrTab;

 template <class ELFT> DynamicSection<ELFT> *Out<ELFT>::Dynamic;
 template <class ELFT> EhFrameHeader<ELFT> *Out<ELFT>::EhFrameHdr;
 template <class ELFT> EhOutputSection<ELFT> *Out<ELFT>::EhFrame;
 template <class ELFT> GdbIndexSection<ELFT> *Out<ELFT>::GdbIndex;
 template <class ELFT> GnuHashTableSection<ELFT> *Out<ELFT>::GnuHashTab;
 template <class ELFT> GotPltSection<ELFT> *Out<ELFT>::GotPlt;
 template <class ELFT> GotSection<ELFT> *Out<ELFT>::Got;
 template <class ELFT> HashTableSection<ELFT> *Out<ELFT>::HashTab;
-template <class ELFT> InterpSection<ELFT> *Out<ELFT>::Interp;
 template <class ELFT> OutputSection<ELFT> *Out<ELFT>::Bss;
 template <class ELFT> OutputSection<ELFT> *Out<ELFT>::MipsRldMap;
 template <class ELFT> OutputSectionBase<ELFT> *Out<ELFT>::Opd;
 template <class ELFT> uint8_t *Out<ELFT>::OpdBuf;
 template <class ELFT> PltSection<ELFT> *Out<ELFT>::Plt;
 template <class ELFT> RelocationSection<ELFT> *Out<ELFT>::RelaDyn;
 template <class ELFT> RelocationSection<ELFT> *Out<ELFT>::RelaPlt;
 template <class ELFT> StringTableSection<ELFT> *Out<ELFT>::DynStrTab;

lld/trunk/ELF/OutputSections.cpp

 template <class ELFT> void RelocationSection<ELFT>::finalize() {
   this->Header.sh_link = Out<ELFT>::DynSymTab
                              ? Out<ELFT>::DynSymTab->SectionIndex
                              : Out<ELFT>::SymTab->SectionIndex;
   this->Header.sh_size = Relocs.size() * this->Header.sh_entsize;
 }
 
 template <class ELFT>
-InterpSection<ELFT>::InterpSection()
-    : OutputSectionBase<ELFT>(".interp", SHT_PROGBITS, SHF_ALLOC) {
-  this->Header.sh_size = Config->DynamicLinker.size() + 1;
-}
-
-template <class ELFT> void InterpSection<ELFT>::writeTo(uint8_t *Buf) {
-  StringRef S = Config->DynamicLinker;
-  memcpy(Buf, S.data(), S.size());
-}
-
-template <class ELFT>
 HashTableSection<ELFT>::HashTableSection()
     : OutputSectionBase<ELFT>(".hash", SHT_HASH, SHF_ALLOC) {
   this->Header.sh_entsize = sizeof(Elf_Word);
   this->Header.sh_addralign = sizeof(Elf_Word);
 }
 
 static uint32_t hashSysv(StringRef Name) {
   uint32_t H = 0;

 template class PltSection<ELF64LE>;
 template class PltSection<ELF64BE>;
 
 template class RelocationSection<ELF32LE>;
 template class RelocationSection<ELF32BE>;
 template class RelocationSection<ELF64LE>;
 template class RelocationSection<ELF64BE>;
 
-template class InterpSection<ELF32LE>;
-template class InterpSection<ELF32BE>;
-template class InterpSection<ELF64LE>;
-template class InterpSection<ELF64BE>;
-
 template class GnuHashTableSection<ELF32LE>;
 template class GnuHashTableSection<ELF32BE>;
 template class GnuHashTableSection<ELF64LE>;
 template class GnuHashTableSection<ELF64BE>;
 
 template class HashTableSection<ELF32LE>;
 template class HashTableSection<ELF32BE>;
 template class HashTableSection<ELF64LE>;

lld/trunk/ELF/SyntheticSections.h

 #ifndef LLD_ELF_SYNTHETIC_SECTION_H
 #define LLD_ELF_SYNTHETIC_SECTION_H
 
 #include "InputSection.h"
 
 namespace lld {
 namespace elf {
 
+template <class ELFT> class InterpSection final : public InputSection<ELFT> {
+public:
+  InterpSection();
+};
+
 template <class ELFT> class BuildIdSection : public InputSection<ELFT> {
 public:
   virtual void writeBuildId(llvm::MutableArrayRef<uint8_t> Buf) = 0;
   virtual ~BuildIdSection() = default;
 
   uint8_t *getOutputLoc(uint8_t *Start) const;
 
 protected:

 public:
   BuildIdHexstring();
   void writeBuildId(llvm::MutableArrayRef<uint8_t>) override;
 };
 
 // Linker generated sections which can be used as inputs.
 template <class ELFT> struct In {
   static BuildIdSection<ELFT> *BuildId;
+  static InterpSection<ELFT> *Interp;
   static std::vector<InputSection<ELFT> *> Sections;
 };
 
 template <class ELFT> BuildIdSection<ELFT> *In<ELFT>::BuildId;
+template <class ELFT> InterpSection<ELFT> *In<ELFT>::Interp;
 template <class ELFT> std::vector<InputSection<ELFT> *> In<ELFT>::Sections;
 
 } // namespace elf
 } // namespace lld
 
 #endif

lld/trunk/ELF/SyntheticSections.cpp

 // input sections.
 //
 //===----------------------------------------------------------------------===//
 
 #include "SyntheticSections.h"
 #include "Config.h"
 #include "Error.h"
 #include "InputFiles.h"
+#include "Memory.h"
 #include "OutputSections.h"
 #include "Strings.h"
 
 #include "llvm/Support/Endian.h"
 #include "llvm/Support/MD5.h"
 #include "llvm/Support/RandomNumberGenerator.h"
 #include "llvm/Support/SHA1.h"
 #include "llvm/Support/xxhash.h"
 
 using namespace llvm;
 using namespace llvm::ELF;
 using namespace llvm::object;
 using namespace llvm::support;
 using namespace llvm::support::endian;
 
 using namespace lld;
 using namespace lld::elf;
 
+static ArrayRef<uint8_t> createInterp() {
+  // StringSaver guarantees that the returned string ends with '\0'.
+  StringRef S = Saver.save(Config->DynamicLinker);
+  return {(uint8_t *)S.data(), S.size() + 1};
+}
+
+template <class ELFT>
+InterpSection<ELFT>::InterpSection()
+    : InputSection<ELFT>(SHF_ALLOC, SHT_PROGBITS, 1, createInterp(),
+                         ".interp") {}
+
 template <class ELFT>
 BuildIdSection<ELFT>::BuildIdSection(size_t HashSize)
     : InputSection<ELFT>(SHF_ALLOC, SHT_NOTE, 1, ArrayRef<uint8_t>(),
                          ".note.gnu.build-id") {
   Buf.resize(16 + HashSize);
   const endianness E = ELFT::TargetEndianness;
   write32<E>(Buf.data(), 4);                   // Name size
   write32<E>(Buf.data() + 4, HashSize);        // Content size
BuildIdHexstring<ELFT>::BuildIdHexstring()
     : BuildIdSection<ELFT>(Config->BuildIdVector.size()) {}
 
 template <class ELFT>
 void BuildIdHexstring<ELFT>::writeBuildId(MutableArrayRef<uint8_t> Buf) {
   memcpy(this->getOutputLoc(Buf.begin()) + 16, Config->BuildIdVector.data(),
          Config->BuildIdVector.size());
 }
 
+template class elf::InterpSection<ELF32LE>;
+template class elf::InterpSection<ELF32BE>;
+template class elf::InterpSection<ELF64LE>;
+template class elf::InterpSection<ELF64BE>;
+
 template class elf::BuildIdSection<ELF32LE>;
 template class elf::BuildIdSection<ELF32BE>;
 template class elf::BuildIdSection<ELF64LE>;
 template class elf::BuildIdSection<ELF64BE>;
 
 template class elf::BuildIdFastHash<ELF32LE>;
 template class elf::BuildIdFastHash<ELF32BE>;
 template class elf::BuildIdFastHash<ELF64LE>;

lld/trunk/ELF/Writer.cpp

template <class ELFT> void Writer<ELFT>::createSyntheticSections() {
   Out<ELFT>::VerNeed = make<VersionNeedSection<ELFT>>();
 
   Out<ELFT>::ElfHeader = make<OutputSectionBase<ELFT>>("", 0, SHF_ALLOC);
   Out<ELFT>::ElfHeader->setSize(sizeof(Elf_Ehdr));
   Out<ELFT>::ProgramHeaders = make<OutputSectionBase<ELFT>>("", 0, SHF_ALLOC);
   Out<ELFT>::ProgramHeaders->updateAlignment(sizeof(uintX_t));
 
   if (needsInterpSection<ELFT>())
-    Out<ELFT>::Interp = make<InterpSection<ELFT>>();
+    In<ELFT>::Interp = make<InterpSection<ELFT>>();
 
   if (!Symtab<ELFT>::X->getSharedFiles().empty() || Config->Pic) {
     Out<ELFT>::DynSymTab =
         make<SymbolTableSection<ELFT>>(*Out<ELFT>::DynStrTab);
   }
 
   if (Config->EhFrameHdr)
     Out<ELFT>::EhFrameHdr = make<EhFrameHeader<ELFT>>();
template <class ELFT> void Writer<ELFT>::createSyntheticSections() {
   else if (Config->BuildId == BuildIdKind::Md5)
     In<ELFT>::BuildId = make<BuildIdMd5<ELFT>>();
   else if (Config->BuildId == BuildIdKind::Sha1)
     In<ELFT>::BuildId = make<BuildIdSha1<ELFT>>();
   else if (Config->BuildId == BuildIdKind::Uuid)
     In<ELFT>::BuildId = make<BuildIdUuid<ELFT>>();
   else if (Config->BuildId == BuildIdKind::Hexstring)
     In<ELFT>::BuildId = make<BuildIdHexstring<ELFT>>();
-  In<ELFT>::Sections = {In<ELFT>::BuildId};
+
+  In<ELFT>::Sections = {In<ELFT>::BuildId, In<ELFT>::Interp};
 }
 
 template <class ELFT>
 static bool shouldKeepInSymtab(InputSectionBase<ELFT> *Sec, StringRef SymName,
                                const SymbolBody &B) {
   if (B.isFile())
     return false;
 
template <class ELFT> bool elf::isRelroSection(OutputSectionBase<ELFT> *Sec) {
   StringRef S = Sec->getName();
   return S == ".data.rel.ro" || S == ".ctors" || S == ".dtors" || S == ".jcr" ||
          S == ".eh_frame";
 }
 
 template <class ELFT>
 static bool compareSectionsNonScript(OutputSectionBase<ELFT> *A,
                                      OutputSectionBase<ELFT> *B) {
+  // Put .interp first because some loaders want to see that section
+  // on the first page of the executable file when loaded into memory.
+  bool AIsInterp = A->getName() == ".interp";
+  bool BIsInterp = B->getName() == ".interp";
+  if (AIsInterp != BIsInterp)
+    return AIsInterp;
+
   typedef typename ELFT::uint uintX_t;
   uintX_t AFlags = A->getFlags();
   uintX_t BFlags = B->getFlags();
 
   // Allocatable sections go first to reduce the total PT_LOAD size and
   // so debug info doesn't change addresses in actual code.
   bool AIsAlloc = AFlags & SHF_ALLOC;
   bool BIsAlloc = BFlags & SHF_ALLOC;

 
 // This function add Out<ELFT>::* sections to OutputSections.
 template <class ELFT> void Writer<ELFT>::addPredefinedSections() {
   auto Add = [&](OutputSectionBase<ELFT> *OS) {
     if (OS)
       OutputSections.push_back(OS);
   };
 
-  // Add .interp at first because some loaders want to see that section
-  // on the first page of the executable file when loaded into memory.
-  if (Out<ELFT>::Interp)
-    OutputSections.insert(OutputSections.begin(), Out<ELFT>::Interp);
-
   // This order is not the same as the final output order
   // because we sort the sections using their attributes below.
   if (Out<ELFT>::GdbIndex && Out<ELFT>::DebugInfo)
     Add(Out<ELFT>::GdbIndex);
   Add(Out<ELFT>::SymTab);
   Add(Out<ELFT>::ShStrTab);
   Add(Out<ELFT>::StrTab);
   if (Out<ELFT>::DynSymTab) {
auto AddHdr = [&](unsigned Type, unsigned Flags) -> Phdr * {
     return &Ret.back();
   };
 
   // The first phdr entry is PT_PHDR which describes the program header itself.
   Phdr &Hdr = *AddHdr(PT_PHDR, PF_R);
   Hdr.add(Out<ELFT>::ProgramHeaders);
 
   // PT_INTERP must be the second entry if exists.
-  if (Out<ELFT>::Interp) {
-    Phdr &Hdr = *AddHdr(PT_INTERP, Out<ELFT>::Interp->getPhdrFlags());
-    Hdr.add(Out<ELFT>::Interp);
+  if (OutputSectionBase<ELFT> *Sec = findSection(".interp")) {
+    Phdr &Hdr = *AddHdr(PT_INTERP, Sec->getPhdrFlags());
+    Hdr.add(Sec);
   }
 
   // Add the first PT_LOAD segment for regular output sections.
   uintX_t Flags = computeFlags<ELFT>(PF_R);
   Phdr *Load = AddHdr(PT_LOAD, Flags);
   if (!ScriptConfig->HasSections) {
     Load->add(Out<ELFT>::ElfHeader);
     Load->add(Out<ELFT>::ProgramHeaders);