[ELF] - Redesign of program headers creation code.

[grimar]

Summary

During review of "[ELF] Support PHDRS command" (http://reviews.llvm.org/D15191)
it was mentioned that current code to create a program header it's not easy to read.
And solution could be to have a class or a function that create a list of program header fields,
and associate OutputSections to zero or more program header field. I am agree with that.

So this patch do this. It introduces new method scanHeaders() which builds the program
headers map. This map contains the list of all headers, its flags and output sections lists
associated to each. assignAddresses() was changed to use that.

This prepares code for linker script implementation.

[grimar]

• Last minute fixes

[• rafael]

The idea is that with linker script scanHeaders is not used and instead we use the data from the script to construct a mapping and the rest of the code is not changed? If so, I like the general direction.

ELF/Writer.cpp

122

Why std::list and not std::vector?

125

Thin can be a std::list<Phdr> or a std::vector<std::unique_ptr<Phdr>>, no?

1101–1111

Add a small comment.

1105

Not sure if having this if in here is actually more readable.

1209

Do you really need this flag? Looks like the only special case is that the first load starts at 0, not at the start of its first section.

Is that the same behaviour one gets with linker scripts?

[ruiu]

ELF/Writer.cpp

1188–1196

Do you think you can reduce number of variables and boolean flags used in this function by separating into small functions?

The fundamental reason why the previous code was not easy to read is because too many flags are entangled. If the code makes a decision based on n boolean flags, the possible combination is 2^n, which is exponential. Moreover, some variables are updated in the middle of a process, that made it hard to follow the logic. (If a variable gets a new value in one path but don't in the other, you'll get 2^n combinations, again.) We'd like to use less information. I think it is acceptable to iterate over the same data structure more than once because I don't think this is a performance-critical path.

[grimar]

• Review comments addressed.

[grimar]

In D16575#336638, @rafael wrote:

The idea is that with linker script scanHeaders is not used and instead we use the data from the script to construct a mapping and the rest of the code is not changed? If so, I like the general direction.

Yes, script could use some special version of scanHeaders(), like scanHeadersLinkerScript() which will generate some structure (header map) with all required parameters based on options parsed by LS. And then assignAddresses should be able to handle it without changes in other code.
This is of course initial implemention and things are subject to change during work on LS (assignAddresses will need tweaking I think), but I think that whole approach should work.

ELF/Writer.cpp

122

Because I dont know the amount of sections to be assigned to header. So I cant reserve() and dont want multiple reallocates that can happen when using the vector. Also vector can bring overhead here because of reserving memory upfront.
And I also dont need any indexed access so just see no reasons to use vector here.

125

Changed to std::list<Phdr>.

1105

Changed AddIf -> AddHdr, moved condition check outside.

1188–1196

Was able to get rid of some variables. Also separated TLS adresses asigning logic into another method. Now there are 3 passes logically separated.

1209

assignAddresses() definetely will requre some tweaking for linker script logic I am sure, currently it is the base concept that assigns addresses in according to some pre-generated map.
It seems that first load will be special anyways, just the parameters will be different. That way probably parameters from linkersript will be used for first load. During implementation of linker script it will be more clear what exactly changes required.

I placed that flag to header description and also moved the code from inside the loop. That added few lines but probaby looks more readable now.

[grimar]

I can add that I am working on "[ELF] Support PHDRS command" (http://reviews.llvm.org/D15191) reimplementation now. And it seems that with this patch it is going OK now.

[grimar]

• Introduced PhdrsContext which contains helpfull info found during scanHeaders() call like index of TLS, Relro phdrs.
• Get rid of excess assignAddresses() pass. Now there are two left, which seems reasonable amount.

[grimar]

• bool FirstLoad -> size_t FirstLoadId
• Assign phdr's flags and types only at the very end.
• Cleanup + added comments.

[ruiu]

ELF/Writer.cpp

46

This needs comments.

50

Please do not use std::list unless you have a reason to do so because it is generally slower than std::vector.

52

This needs comments, too. If a purpose of a struct or class is not obvious, please describe.

58

What is this for?

1110

You are not using a return value.

1196

Please do not use auto unless type is obvious by RHS.

1216

Hmm, I'm honestly not sure if this is net positive... This code hasn't changed that much, and this is what I wanted to simplify.

[grimar]

• Addressed Rui's comments.

ELF/Writer.cpp

50

Output section amount that should be attached to each phdr is unknown is the main reason for this.
If there are many possible output sections then multiple reallocations can happen if using vector here. I have no argument for calling reserve().
If in opposite we assume that output sections count is little then there is no any perfomance hit during iterations in this case either, but we win a bit of memory probably that is not forwardly allocated as vector do.

58

Removed using, it was used before but no more needed.

1110

Actually I am. In one place, but it is very useful there:

uint32_t LoadType = (Config->EMachine == EM_AMDGPU) ? getAmdgpuPhdr(Sec)
                                                    : (uint32_t)PT_LOAD;
Load = AddHdr(LoadType, NewFlags);
Flags = NewFlags;

1196

Done.

1216

Generally this patch is not about simplification, main aim to have it is to split address assigning into scanHeaders() and assignAddressed() methods, what is needed to implement initial variant of linker script PHDRS I believe. After some futher tweaks for assignAddressed() it should be possible to use some scanHeadersLinkerScript() to affect output. I thinks it is good that code looks close to initial but at fact have significantly more possible functionality now.

But I cant agree that it was not simplified.
For example initial code has few local variables/flags in one place that affected execution flow in one huge method:

int PhdrIdx = 0;
Elf_Phdr *Interp = nullptr;
Elf_Phdr GnuRelroPhdr = {};
Elf_Phdr TlsPhdr{};
bool RelroAligned = false;
uintX_t ThreadBssOffset = 0;

This code has only one of them left:

bool RelroAligned = false;

And TLS address assigning was moved to separate method, what simplified logic a bit.

[grimar]

Simplified:

• All specific headers (PT_DyNAMIC, PT_INTERP etc) are processed at once in universal way.
• First pass in assignAddressed now handles all PT_LOAD segments and assigns addresses to all sections including TLS ones.

[ruiu]

This does not compile, too.

[grimar]

• Fixed compilation error and warning under linux.
• Rebased.

[grimar]

• Minor refactor: placed some logic from assignAddresses() to newly created setupSecVA() and setupSecFileOff() methods.

[grimar]

• Moved out PT_LOAD header creation from assignAddress() method.
• Resynced with head.

[• rafael]

I have applied this locally and I have some ideas on how to simplify
it. I will upload a proposed change after lunch.

Cheers,
Rafael

[grimar]

In D16575#345054, @rafael wrote:

I have applied this locally and I have some ideas on how to simplify
it. I will upload a proposed change after lunch.

Cheers,
Rafael

Interesting to see. Thanks !

[• rafael]

• t.diff14 KBDownload

[grimar]

This is what I have so far. There is more work to be done, but the idea is that

• scanHeaders does nothing more than map section to program headers.
• We then find out which sections need extra alignment because of page

boundaries.

• We assign address and offset to each *section*, which is now a simple loop
• We use the above info to assign sizes and address to each program header.

Things I want to try before considering this a real patch

• Create dummy sections for the file and program headers. This should

avoid the hacks regarding the first PT_LOAD.

• Store just first and last section. A program header is a contiguous range.
• Have the Phdr structure be just a Elf_Phdr and the first and last section.

Cheers,
Rafael

Ok.
If you don't mind I will try your suggestions and update the patch then ?

George.

[grimar]

Another version of that by Rafael Ávila de Espíndola was commited as r260453 (http://reviews.llvm.org/D16991).

ELF/Writer.cpp

 #include "Target.h"
 
 #include "llvm/ADT/StringMap.h"
 #include "llvm/ADT/StringSwitch.h"
 #include "llvm/Support/FileOutputBuffer.h"
 #include "llvm/Support/raw_ostream.h"
 #include "llvm/Support/StringSaver.h"
 
+#include <list>
+
 using namespace llvm;
 using namespace llvm::ELF;
 using namespace llvm::object;
 
 using namespace lld;
 using namespace lld::elf2;
 
 namespace {
 // The writer writes a SymbolTable result to a file.
 template <class ELFT> class Writer {
 public:
   typedef typename ELFFile<ELFT>::uintX_t uintX_t;
   typedef typename ELFFile<ELFT>::Elf_Shdr Elf_Shdr;
   typedef typename ELFFile<ELFT>::Elf_Ehdr Elf_Ehdr;
   typedef typename ELFFile<ELFT>::Elf_Phdr Elf_Phdr;
   typedef typename ELFFile<ELFT>::Elf_Sym Elf_Sym;
   typedef typename ELFFile<ELFT>::Elf_Sym_Range Elf_Sym_Range;
   typedef typename ELFFile<ELFT>::Elf_Rela Elf_Rela;
   Writer(SymbolTable<ELFT> &S) : Symtab(S) {}
   void run();
 
 private:
+  // This describes the programm header that will be created in output.
+  // Each contains type, access flags and list of output sections that will be
+  // placed in segment.
+  struct Phdr {
+    Phdr(unsigned Type = 0, unsigned Flags = 0) : Type(Type), Flags(Flags) {}
+    unsigned Type;
+    unsigned Flags;
+    std::list<OutputSectionBase<ELFT> *> OutSections;
+  };
+  // Its a headers map which contains list of headers and also some additional
+  // parameters, like prefound IDs of specific headers.
+  struct PhdrMap {
+    std::vector<std::unique_ptr<Phdr>> PhdrList;
+    size_t FirstLoadId = (size_t)-1;
+    size_t TlsPhdrId = (size_t)-1;
+    size_t RelroPhdrId = (size_t)-1;
+  };
+
   void copyLocalSymbols();
   void addReservedSymbols();
   bool createSections();
   void addPredefinedSections();
 
   template <bool isRela>
   void scanRelocs(InputSectionBase<ELFT> &C,
                   iterator_range<const Elf_Rel_Impl<ELFT, isRela> *> Rels);
 
   void scanRelocs(InputSection<ELFT> &C);
   void scanRelocs(InputSectionBase<ELFT> &S, const Elf_Shdr &RelSec);
   void updateRelro(Elf_Phdr *Cur, Elf_Phdr *GnuRelroPhdr, uintX_t VA);
+  PhdrMap scanHeaders();
   void assignAddresses();
+  void finalizeHeaders(Elf_Phdr *PH, const Phdr &Map);
   void buildSectionMap();
   void fixAbsoluteSymbols();
   void openFile(StringRef OutputPath);
   void writeHeader();
   void writeSections();
   bool isDiscarded(InputSectionBase<ELFT> *IS) const;
   StringRef getOutputSectionName(StringRef S) const;
   bool needsInterpSection() const {
     return !Symtab.getSharedFiles().empty() && !Config->DynamicLinker.empty();
   }
   bool isOutputDynamic() const {
     return !Symtab.getSharedFiles().empty() || Config->Shared;
   }
-  int getPhdrsNum() const;
 
   OutputSection<ELFT> *getBss();
   void addCommonSymbols(std::vector<DefinedCommon *> &Syms);
   void addCopyRelSymbols(std::vector<SharedSymbol<ELFT> *> &Syms);
 
   std::unique_ptr<llvm::FileOutputBuffer> Buffer;
 
   BumpPtrAllocator Alloc;
private:
 
   uintX_t FileSize;
   uintX_t SectionHeaderOff;
 
   llvm::StringMap<llvm::StringRef> InputToOutputSection;
 
   // Flag to force GOT to be in output if we have relocations
   // that relies on its address.
   bool HasGotOffRel = false;
 };
 } // anonymous namespace
 
 template <class ELFT> static bool shouldUseRela() { return ELFT::Is64Bits; }
 
 template <class ELFT> void elf2::writeResult(SymbolTable<ELFT> *Symtab) {
   // Initialize output sections that are handled by Writer specially.
   // Don't reorder because the order of initialization matters.
   InterpSection<ELFT> Interp;
   Out<ELFT>::Interp = &Interp;
   StringTableSection<ELFT> ShStrTab(".shstrtab", false);
if ((Flags & SHF_AMDGPU_HSA_GLOBAL) && !(Flags & SHF_AMDGPU_HSA_AGENT))
     return PT_AMDGPU_HSA_LOAD_GLOBAL_PROGRAM;
   return PT_LOAD;
 }
 
 template <class ELFT>
 void Writer<ELFT>::updateRelro(Elf_Phdr *Cur, Elf_Phdr *GnuRelroPhdr,
                                uintX_t VA) {
   if (!GnuRelroPhdr->p_type)
-    setPhdr(GnuRelroPhdr, PT_GNU_RELRO, PF_R, Cur->p_offset, Cur->p_vaddr,
+    setPhdr(GnuRelroPhdr, PT_GNU_RELRO, 0, Cur->p_offset, Cur->p_vaddr,
             VA - Cur->p_vaddr, 1 /*p_align*/);
   GnuRelroPhdr->p_filesz = VA - Cur->p_vaddr;
   GnuRelroPhdr->p_memsz = VA - Cur->p_vaddr;
 }
 
-// Visits all sections to create PHDRs and to assign incremental,
-// non-overlapping addresses to output sections.
-template <class ELFT> void Writer<ELFT>::assignAddresses() {
-  uintX_t VA = Target->getVAStart() + sizeof(Elf_Ehdr);
-  uintX_t FileOff = sizeof(Elf_Ehdr);
-
-  // Calculate and reserve the space for the program header first so that
-  // the first section can start right after the program header.
-  Phdrs.resize(getPhdrsNum());
-  size_t PhdrSize = sizeof(Elf_Phdr) * Phdrs.size();
+// This method generates some kind of map where each phdr
+// is associated with zero or more output sections.
+// Output structure contains final list of phdrs used.
+// assignAddresses() will use this structure to assign addressed to sections.
+template <class ELFT>
+typename Writer<ELFT>::PhdrMap Writer<ELFT>::scanHeaders() {
+  PhdrMap Map;
+  auto AddHdr = [this, &Map](unsigned Type, unsigned Flags = 0) {
+    std::unique_ptr<Phdr> U = std::make_unique<Phdr>(Type, Flags);
+    return Map.PhdrList.emplace(Map.PhdrList.end(), std::move(U))->get();
+  };
 
   // The first phdr entry is PT_PHDR which describes the program header itself.
-  setPhdr(&Phdrs[0], PT_PHDR, PF_R, FileOff, VA, PhdrSize, /*Align=*/8);
-  FileOff += PhdrSize;
-  VA += PhdrSize;
+  AddHdr(PT_PHDR, PF_R);
 
   // PT_INTERP must be the second entry if exists.
-  int PhdrIdx = 0;
-  Elf_Phdr *Interp = nullptr;
-  if (needsInterpSection())
-    Interp = &Phdrs[++PhdrIdx];
+  if (needsInterpSection()) {
+    Phdr *Hdr = AddHdr(PT_INTERP, toPhdrFlags(Out<ELFT>::Interp->getFlags()));
+    Hdr->OutSections.push_back(Out<ELFT>::Interp);
+  }
 
   // Add the first PT_LOAD segment for regular output sections.
-  setPhdr(&Phdrs[++PhdrIdx], PT_LOAD, PF_R, 0, Target->getVAStart(), FileOff,
-          Target->PageSize);
+  uintX_t Flags = PF_R;
+  Map.FirstLoadId = Map.PhdrList.size();
+  Phdr *Load = AddHdr(PT_LOAD, Flags);
 
-  Elf_Phdr GnuRelroPhdr = {};
-  Elf_Phdr TlsPhdr{};
-  bool RelroAligned = false;
-  uintX_t ThreadBssOffset = 0;
-  // Create phdrs as we assign VAs and file offsets to all output sections.
+  std::unique_ptr<Phdr> TlsHdr;
   for (OutputSectionBase<ELFT> *Sec : OutputSections) {
-    Elf_Phdr *PH = &Phdrs[PhdrIdx];
     if (needsPhdr<ELFT>(Sec)) {
-      uintX_t Flags = toPhdrFlags(Sec->getFlags());
-      bool InRelRo = Config->ZRelro && (Flags & PF_W) && isRelroSection(Sec);
-      bool FirstNonRelRo = GnuRelroPhdr.p_type && !InRelRo && !RelroAligned;
-      if (FirstNonRelRo || PH->p_flags != Flags) {
-        VA = alignTo(VA, Target->PageSize);
-        FileOff = alignTo(FileOff, Target->PageSize);
-        if (FirstNonRelRo)
-          RelroAligned = true;
-      }
-
-      if (PH->p_flags != Flags) {
-        // Flags changed. Create a new PT_LOAD.
-        PH = &Phdrs[++PhdrIdx];
-        uint32_t PTType = (Config->EMachine != EM_AMDGPU) ? (uint32_t)PT_LOAD
-                                                          : getAmdgpuPhdr(Sec);
-        setPhdr(PH, PTType, Flags, FileOff, VA, 0, Target->PageSize);
+      // If flags changed then we want new load segment.
+      uintX_t NewFlags = toPhdrFlags(Sec->getFlags());
+      if (Flags != NewFlags) {
+        uint32_t LoadType = (Config->EMachine == EM_AMDGPU) ? getAmdgpuPhdr(Sec)
+                                                            : (uint32_t)PT_LOAD;
+        Load = AddHdr(LoadType, NewFlags);
+        Flags = NewFlags;
+      }
+      // 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) {
+        if (!TlsHdr)
+          TlsHdr = std::make_unique<Phdr>(PT_TLS, PF_R);
+        TlsHdr->OutSections.push_back(Sec);
+      }
+    }
+    Load->OutSections.push_back(Sec);
+  }
+
+  // TLS header.
+  if (TlsHdr) {
+    Map.TlsPhdrId = Map.PhdrList.size();
+    Map.PhdrList.push_back(std::move(TlsHdr));
+  }
+
+  // Add an entry for .dynamic.
+  if (isOutputDynamic()) {
+    Phdr *Hdr = AddHdr(PT_DYNAMIC, toPhdrFlags(Out<ELFT>::Dynamic->getFlags()));
+    Hdr->OutSections.push_back(Out<ELFT>::Dynamic);
+  }
+
+  // PT_GNU_RELRO includes all sections that should be marked as
+  // read-only by dynamic linker after proccessing relocations.
+  if (HasRelro) {
+    Map.RelroPhdrId = Map.PhdrList.size();
+    AddHdr(PT_GNU_RELRO, PF_R);
+  }
+
+  // PT_GNU_EH_FRAME is a special section pointing on .eh_frame_hdr.
+  if (Out<ELFT>::EhFrameHdr->Live) {
+    Phdr *Hdr = AddHdr(PT_GNU_EH_FRAME, toPhdrFlags(Out<ELFT>::EhFrameHdr->getFlags()));
+    Hdr->OutSections.push_back(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);
+
+  return Map;
+}
+
+static bool isLoadPhdr(unsigned H) {
+  return H == PT_LOAD || H == PT_AMDGPU_HSA_LOAD_CODE_AGENT ||
+    H == PT_AMDGPU_HSA_LOAD_GLOBAL_PROGRAM;
+}
+
+// Visits all headers in PhdrMap and assigns the adresses to
+// the output sections. Also creates common and special headers.
+template <class ELFT> void Writer<ELFT>::assignAddresses() {
+  // We know the final amount of program headers here.
+  PhdrMap Map = scanHeaders();
+  Phdrs.resize(Map.PhdrList.size());
+
+  bool RelroAligned = false;
+  uintX_t ThreadBssOffset = 0;
+  size_t PhdrSize = sizeof(Elf_Phdr) * Phdrs.size();
+  uintX_t VA = Target->getVAStart() + sizeof(Elf_Ehdr) + PhdrSize;
+  uintX_t FileOff = sizeof(Elf_Ehdr) + PhdrSize;
+
+  // Set up PT_PHDR right after ELF file header.
+  setPhdr(&Phdrs[0], 0, 0, FileOff - PhdrSize, VA - PhdrSize, PhdrSize, 8);
+
+  // Main pass, here all load segments are processed and
+  // final addresses are assigned to all sections.
+  // Flags and header types are not assigned during pass.
+  // Them are assigned once for all headers at second pass.
+  for (size_t I = 0, E = Map.PhdrList.size(); I != E; ++I) {
+    std::unique_ptr<Phdr> &PHdr = Map.PhdrList[I];
+    if (!isLoadPhdr(PHdr->Type))
+      continue;
+
+    Elf_Phdr *PH = &Phdrs[I];
+    // New PT_LOAD is usually created when access flags were changed.
+    // If it is the very first load then it is special case,
+    // it contains elf header and program headers.
+    // Otherwise we need to align VA and FileOff to new memory page
+    // and create a new load.
+    const bool FirstLoad = (Map.FirstLoadId == I);
+    if (!FirstLoad) {
+    uintX_t Offset = FirstLoad ? 0 : FileOff;
+    uintX_t LoadVA = FirstLoad ? Target->getVAStart() : VA;
+    uintX_t LoadSize = FirstLoad ? FileOff : 0;
+    setPhdr(PH, 0, 0, Offset, LoadVA, LoadSize, Target->PageSize);
+
+    for (OutputSectionBase<ELFT> *Sec : PHdr->OutSections) {
+      bool InRelRo = HasRelro && (PHdr->Flags & PF_W) && isRelroSection(Sec);
+      bool FirstNonRelRo = HasRelro && Phdrs[Map.RelroPhdrId].p_type &&
+                           needsPhdr<ELFT>(Sec) && !RelroAligned && !InRelRo;
+      // If this is a first non relro section after relro sequence then
+      // we want to align to page boundaries. We do this because we dont want
+      // any other sections except relro were marked as read only by dynamic
+      // loader. Them should be placed on a different memory page for that.
+      if (FirstNonRelRo) {
+        VA = alignTo(VA, Target->PageSize);
+        FileOff = alignTo(FileOff, Target->PageSize);
+        RelroAligned = true;
       }
 
-      if (Sec->getFlags() & SHF_TLS) {
-        if (!TlsPhdr.p_vaddr)
-          setPhdr(&TlsPhdr, PT_TLS, PF_R, FileOff, VA, 0, Sec->getAlign());
-        if (Sec->getType() != SHT_NOBITS)
+      if (needsPhdr<ELFT>(Sec)) {
+        bool IsTls = Sec->getFlags() & SHF_TLS;
+        // If we found TLS section we want to fill phdr parameters early
+        // because later we will not have its VA and FileOff.
+        if (IsTls && !Phdrs[Map.TlsPhdrId].p_vaddr)
+          setPhdr(&Phdrs[Map.TlsPhdrId], 0, 0, FileOff, VA, 0, 0);
+
+        // 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 (!IsTls || Sec->getType() != SHT_NOBITS)
           VA = alignTo(VA, Sec->getAlign());
+
         uintX_t TVA = alignTo(VA + ThreadBssOffset, Sec->getAlign());
-        Sec->setVA(TVA);
-        TlsPhdr.p_memsz += Sec->getSize();
-        if (Sec->getType() == SHT_NOBITS) {
+        Sec->setVA(IsTls ? TVA : VA);
+
+        if (IsTls && Sec->getType() == SHT_NOBITS)
           ThreadBssOffset = TVA - VA + Sec->getSize();
-        } else {
-          TlsPhdr.p_filesz += Sec->getSize();
-          VA += Sec->getSize();
-        }
-        TlsPhdr.p_align = std::max<uintX_t>(TlsPhdr.p_align, Sec->getAlign());
-      } else {
-        VA = alignTo(VA, Sec->getAlign());
-        Sec->setVA(VA);
+        else
           VA += Sec->getSize();
+
+        // If we are in relro then we need to update
+        // the GnuRelroPhdr header.
         if (InRelRo)
-          updateRelro(PH, &GnuRelroPhdr, VA);
-      }
+          updateRelro(PH, &Phdrs[Map.RelroPhdrId], VA);
       }
 
       FileOff = alignTo(FileOff, Sec->getAlign());
       Sec->setFileOffset(FileOff);
       if (Sec->getType() != SHT_NOBITS)
         FileOff += Sec->getSize();
       if (needsPhdr<ELFT>(Sec)) {
         PH->p_filesz = FileOff - PH->p_offset;
         PH->p_memsz = VA - PH->p_vaddr;
       }
     }
-
-  if (TlsPhdr.p_vaddr) {
-    // The TLS pointer goes after PT_TLS. At least glibc will align it,
-    // so round up the size to make sure the offsets are correct.
-    TlsPhdr.p_memsz = alignTo(TlsPhdr.p_memsz, TlsPhdr.p_align);
-    Phdrs[++PhdrIdx] = TlsPhdr;
-    Out<ELFT>::TlsPhdr = &Phdrs[PhdrIdx];
   }
 
-  // Add an entry for .dynamic.
-  if (isOutputDynamic()) {
-    Elf_Phdr *PH = &Phdrs[++PhdrIdx];
-    PH->p_type = PT_DYNAMIC;
-    copyPhdr(PH, Out<ELFT>::Dynamic);
-  }
-
-  if (HasRelro) {
-    Elf_Phdr *PH = &Phdrs[++PhdrIdx];
-    *PH = GnuRelroPhdr;
-  }
-
-  if (Out<ELFT>::EhFrameHdr->Live) {
-    Elf_Phdr *PH = &Phdrs[++PhdrIdx];
-    PH->p_type = PT_GNU_EH_FRAME;
-    copyPhdr(PH, 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) {
-    Elf_Phdr *PH = &Phdrs[++PhdrIdx];
-    PH->p_type = PT_GNU_STACK;
-    PH->p_flags = PF_R | PF_W;
-  }
-
-  // Fix up PT_INTERP as we now know the address of .interp section.
-  if (Interp) {
-    Interp->p_type = PT_INTERP;
-    copyPhdr(Interp, Out<ELFT>::Interp);
-  }
+  // Assign phdrs values in according to sections parameters attached.
+  // Each segment can contain zero, one or multiple sections assigned.
+  // Not just load segments but any others as well. That can be achieved usually
+  // with linker script. finalizeHeaders modifies each segment parameters and size
+  // in the way to cover all sections inside.
+  for (size_t I = 0, E = Map.PhdrList.size(); I != E; ++I)
+    finalizeHeaders(&Phdrs[I], *Map.PhdrList[I].get());
 
   // Add space for section headers.
   SectionHeaderOff = alignTo(FileOff, sizeof(uintX_t));
   FileSize = SectionHeaderOff + getNumSections() * sizeof(Elf_Shdr);
 
   // Update "_end" and "end" symbols so that they
   // point to the end of the data segment.
   ElfSym<ELFT>::End.st_value = VA;
 }
 
-// Returns the number of PHDR entries.
-template <class ELFT> int Writer<ELFT>::getPhdrsNum() const {
-  bool Tls = false;
-  int I = 2; // 2 for PT_PHDR and first PT_LOAD
-  if (needsInterpSection())
-    ++I;
-  if (isOutputDynamic())
-    ++I;
-  if (!Config->ZExecStack)
-    ++I;
-  uintX_t Last = PF_R;
-  for (OutputSectionBase<ELFT> *Sec : OutputSections) {
-    if (!needsPhdr<ELFT>(Sec))
+template <class ELFT>
+void Writer<ELFT>::finalizeHeaders(Elf_Phdr *PH, const Phdr &PHdr) {
+  // We already handled PT_LOAD and PT_PHDR and do not proccess them.
+  if (!isLoadPhdr(PHdr.Type) && PHdr.Type != PT_PHDR) {
+    for (OutputSectionBase<ELFT> *Sec : PHdr.OutSections) {
+      // Initially we initialize the header with parameters
+      // of first output section attached.
+      if (PH->p_memsz == 0 && PHdr.Type != PT_TLS) {
+        copyPhdr(PH, Sec);
         continue;
-    if (Sec->getFlags() & SHF_TLS)
-      Tls = true;
-    uintX_t Flags = toPhdrFlags(Sec->getFlags());
-    if (Last != Flags) {
-      Last = Flags;
-      ++I;
       }
+      // Here we extending the header size to cover all sections inside it.
+      if (Sec->getType() != SHT_NOBITS)
+        PH->p_filesz += Sec->getSize();
+      PH->p_memsz += Sec->getSize();
+      PH->p_align = std::max<uintX_t>(PH->p_align, Sec->getAlign());
+    }
+  }
+
+  // Set type and flags.
+  PH->p_type = PHdr.Type;
+  PH->p_flags = PHdr.Flags;
+
+  // The TLS pointer goes after PT_TLS. At least glibc will align it,
+  // so round up the size to make sure the offsets are correct.
+  if (PHdr.Type == PT_TLS) {
+    PH->p_memsz = alignTo(PH->p_memsz, PH->p_align);
+    Out<ELFT>::TlsPhdr = PH;
   }
-  if (Tls)
-    ++I;
-  if (HasRelro)
-    ++I;
-  if (Out<ELFT>::EhFrameHdr->Live)
-    ++I;
-  return I;
 }
 
 static uint32_t getELFFlags() {
   if (Config->EMachine != EM_MIPS)
     return 0;
   // FIXME: In fact ELF flags depends on ELF flags of input object files
   // and selected emulation. For now just use hard coded values.
   uint32_t V = EF_MIPS_ABI_O32 | EF_MIPS_CPIC | EF_MIPS_ARCH_32R2;