[ELF] - Move PT_LOADs creation logic to Writer::createLoads()

[grimar]

Summary

Logic of PT_LOADS segments creation can be different depending on
was linkerscript used or not.
Patch separates logic in the way to give ability to easy overide it with linker
specific logic of PT_LOADS creation.

[evgeny777]

We have separate implementation for createPhrs() in Writer and LinkerScript, so I wonder why do you need this?

[grimar]

In D23504#515209, @evgeny777 wrote:

We have separate implementation for createPhrs() in Writer and LinkerScript, so I wonder why do you need this?

It is used when there are PHDRS commands. That is not this case.

[grimar]

We are not going to separate logic for segments creation now.

ELF/Writer.cpp

private:
   void createSections();
   void forEachRelSec(
       std::function<void(InputSectionBase<ELFT> &, const typename ELFT::Shdr &)>
           Fn);
   void finalizeSections();
   void addPredefinedSections();
   bool needsGot();
 
+  void createLoads(std::vector<Phdr>& Dest);
   std::vector<Phdr> createPhdrs();
   void assignAddresses();
   void assignFileOffsets();
   void setPhdrs();
   void fixHeaders();
   void fixSectionAlignments();
   void fixAbsoluteSymbols();
   void openFile();
template <class ELFT> static bool needsPtLoad(OutputSectionBase<ELFT> *Sec) {
   // Don't allocate VA space for TLS NOBITS sections. The PT_TLS PHDR is
   // responsible for allocating space for them, not the PT_LOAD that
   // contains the TLS initialization image.
   if (Sec->getFlags() & SHF_TLS && Sec->getType() == SHT_NOBITS)
     return false;
   return true;
 }
 
+template <class ELFT>
+static PhdrEntry<ELFT> *addHdr(std::vector<PhdrEntry<ELFT>> &Dest,
+                               unsigned Type, unsigned Flags) {
+  Dest.emplace_back(Type, Flags);
+  return &Dest.back();
+}
+
+template <class ELFT> void Writer<ELFT>::createLoads(std::vector<Phdr> &Dest) {
+  // Add the first PT_LOAD segment for regular output sections.
+  uintX_t Flags = PF_R;
+  Phdr *Load = addHdr(Dest, PT_LOAD, Flags);
+  Load->add(Out<ELFT>::ElfHeader);
+  Load->add(Out<ELFT>::ProgramHeaders);
+
+  for (OutputSectionBase<ELFT> *Sec : OutputSections) {
+    if (!needsPtLoad(Sec))
+      continue;
+
+    // If flags changed then we want new load segment.
+    uintX_t NewFlags = Sec->getPhdrFlags();
+    if (Flags != NewFlags) {
+      Load = addHdr(Dest, PT_LOAD, NewFlags);
+      Flags = NewFlags;
+    }
+
+    Load->add(Sec);
+  }
+}
+
 // Decide which program headers to create and which sections to include in each
 // one.
-template <class ELFT>
-std::vector<PhdrEntry<ELFT>> Writer<ELFT>::createPhdrs() {
+template <class ELFT> std::vector<PhdrEntry<ELFT>> Writer<ELFT>::createPhdrs() {
   std::vector<Phdr> Ret;
 
-  auto AddHdr = [&](unsigned Type, unsigned Flags) -> Phdr * {
-    Ret.emplace_back(Type, Flags);
-    return &Ret.back();
-  };
-
   // The first phdr entry is PT_PHDR which describes the program header itself.
-  Phdr &Hdr = *AddHdr(PT_PHDR, PF_R);
+  Phdr &Hdr = *addHdr(Ret, 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());
+    Phdr &Hdr = *addHdr(Ret, PT_INTERP, Out<ELFT>::Interp->getPhdrFlags());
     Hdr.add(Out<ELFT>::Interp);
   }
 
-  // Add the first PT_LOAD segment for regular output sections.
-  uintX_t Flags = PF_R;
-  Phdr *Load = AddHdr(PT_LOAD, Flags);
-  Load->add(Out<ELFT>::ElfHeader);
-  Load->add(Out<ELFT>::ProgramHeaders);
+  createLoads(Ret);
 
   Phdr TlsHdr(PT_TLS, PF_R);
   Phdr RelRo(PT_GNU_RELRO, PF_R);
   Phdr Note(PT_NOTE, PF_R);
   for (OutputSectionBase<ELFT> *Sec : OutputSections) {
     if (!(Sec->getFlags() & SHF_ALLOC))
       break;
 
     // If we meet TLS section then we create TLS header
     // and put all TLS sections inside for futher use when
     // assign addresses.
     if (Sec->getFlags() & SHF_TLS)
       TlsHdr.add(Sec);
 
     if (!needsPtLoad(Sec))
       continue;
 
-    // If flags changed then we want new load segment.
-    uintX_t NewFlags = Sec->getPhdrFlags();
-    if (Flags != NewFlags) {
-      Load = AddHdr(PT_LOAD, NewFlags);
-      Flags = NewFlags;
-    }
-
-    Load->add(Sec);
-
     if (isRelroSection(Sec))
       RelRo.add(Sec);
     if (Sec->getType() == SHT_NOTE)
       Note.add(Sec);
   }
 
   // Add the TLS segment unless it's empty.
   if (TlsHdr.First)
     Ret.push_back(std::move(TlsHdr));
 
   // Add an entry for .dynamic.
   if (Out<ELFT>::DynSymTab) {
-    Phdr &H = *AddHdr(PT_DYNAMIC, Out<ELFT>::Dynamic->getPhdrFlags());
+    Phdr &H = *addHdr(Ret, PT_DYNAMIC, Out<ELFT>::Dynamic->getPhdrFlags());
     H.add(Out<ELFT>::Dynamic);
   }
 
   // PT_GNU_RELRO includes all sections that should be marked as
   // read-only by dynamic linker after proccessing relocations.
   if (RelRo.First)
     Ret.push_back(std::move(RelRo));
 
   // PT_GNU_EH_FRAME is a special section pointing on .eh_frame_hdr.
   if (!Out<ELFT>::EhFrame->empty() && Out<ELFT>::EhFrameHdr) {
-    Phdr &Hdr = *AddHdr(PT_GNU_EH_FRAME, Out<ELFT>::EhFrameHdr->getPhdrFlags());
+    Phdr &Hdr =
+        *addHdr(Ret, PT_GNU_EH_FRAME, Out<ELFT>::EhFrameHdr->getPhdrFlags());
     Hdr.add(Out<ELFT>::EhFrameHdr);
   }
 
   // PT_GNU_STACK is a special section to tell the loader to make the
   // pages for the stack non-executable.
   if (!Config->ZExecStack)
-    AddHdr(PT_GNU_STACK, PF_R | PF_W);
+    addHdr(Ret, PT_GNU_STACK, PF_R | PF_W);
 
   if (Note.First)
     Ret.push_back(std::move(Note));
   return Ret;
 }
 
 // The first section of each PT_LOAD and the first section after PT_GNU_RELRO
 // have to be page aligned so that the dynamic linker can set the permissions.