[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

103

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

106

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

1052

Add a small comment.

1056

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

1143

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

1122–1130

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

103

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.

106

Changed to std::list<Phdr>.

1056

Changed AddIf -> AddHdr, moved condition check outside.

1122–1130

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

1143

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?

1061

You are not using a return value.

1130

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

1150

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.

1061

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;

1130

Done.

1150

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:
   void copyLocalSymbols();
   void addReservedSymbols();
   void 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);
   void assignAddresses();
   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 {
private:
 
   bool HasRelro = false;
   SymbolTable<ELFT> &Symtab;
   std::vector<Elf_Phdr> Phdrs;
 
   uintX_t FileSize;
   uintX_t SectionHeaderOff;
 
+  struct Phdr {
+    Phdr(unsigned Type, unsigned Flags) : Type(Type), Flags(Flags) {}
+    unsigned Type;
+    unsigned Flags;
+    std::list<OutputSectionBase<ELFT> *> OutSections;
+  };
+
+  using PhdrMap = std::list<std::unique_ptr<Phdr>>;
+  PhdrMap scanHeaders();
+
   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
 
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,
             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();
+template <class ELFT>
+typename Writer<ELFT>::PhdrMap Writer<ELFT>::scanHeaders() {
+  PhdrMap Phdrs;
+  auto AddIf = [this, &Phdrs](unsigned Type, bool C, unsigned Flags = 0) {
+    if (!C)
+      return (Phdr *)nullptr;
+    std::unique_ptr<Phdr> U = std::make_unique<Phdr>(Type, Flags);
+    return Phdrs.emplace(Phdrs.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;
+  AddIf(PT_PHDR, true, PF_R);
 
   // PT_INTERP must be the second entry if exists.
-  int PhdrIdx = 0;
-  Elf_Phdr *Interp = nullptr;
-  if (needsInterpSection())
-    Interp = &Phdrs[++PhdrIdx];
+  AddIf(PT_INTERP, needsInterpSection());
 
   // Add the first PT_LOAD segment for regular output sections.
-  setPhdr(&Phdrs[++PhdrIdx], PT_LOAD, PF_R, 0, Target->getVAStart(), FileOff,
-          Target->getPageSize());
+  uintX_t Flags = PF_R;
+  Phdr *Load = AddIf(PT_LOAD, true, Flags);
+  std::unique_ptr<Phdr> TlsHdr;
+  for (OutputSectionBase<ELFT> *Sec : OutputSections) {
+    if (needsPhdr<ELFT>(Sec)) {
+      // 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 = AddIf(LoadType, true, 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)
+    Phdrs.push_back(std::move(TlsHdr));
+
+  // Add an entry for .dynamic.
+  AddIf(PT_DYNAMIC, isOutputDynamic());
+
+  // PT_GNU_RELRO includes all sections that should be marked as
+  // read-only by dynamic linker after proccessing relocations.
+  AddIf(PT_GNU_RELRO, HasRelro);
 
+  // PT_GNU_EH_FRAME is a special section pointing on .eh_frame_hdr.
+  AddIf(PT_GNU_EH_FRAME, Out<ELFT>::EhFrameHdr->Live);
+
+  // PT_GNU_STACK is a special section to tell the loader to make the
+  // pages for the stack non-executable.
+  AddIf(PT_GNU_STACK, !Config->ZExecStack, PF_R | PF_W);
+
+  return Phdrs;
+}
+
+// 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.size());
+
+  uintX_t VA = Target->getVAStart() + sizeof(Elf_Ehdr);
+  uintX_t FileOff = sizeof(Elf_Ehdr);
+  uintX_t TlsVA = 0;
+  uintX_t TlsFileOff = 0;
+  Elf_Phdr *InterpHdr = nullptr;
   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.
-  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) {
+  bool FirstLoad = true;
+  uintX_t I = 0;
+  for (auto &PHdr : Map) {
+    Elf_Phdr *PH = &Phdrs[I++];
+    PH->p_type = PHdr->Type;
+    switch (PHdr->Type) {
+    case PT_LOAD:
+    case PT_AMDGPU_HSA_LOAD_CODE_AGENT:
+    case PT_AMDGPU_HSA_LOAD_GLOBAL_PROGRAM: {
+      // Add the first load segment for regular output sections.
+      if (FirstLoad)
+        setPhdr(PH, PHdr->Type, PHdr->Flags, 0, Target->getVAStart(), FileOff,
+                Target->getPageSize());
+
+      bool CreateLoad = !FirstLoad;
+      bool isW = PHdr->Flags & PF_W;
+      for (OutputSectionBase<ELFT> *Sec : PHdr->OutSections) {
+        bool InRelRo = Config->ZRelro && isW && isRelroSection(Sec);
+        bool FirstNonRelRo = needsPhdr<ELFT>(Sec) && !RelroAligned &&
+                             GnuRelroPhdr.p_type && !InRelRo;
+        // There are two situations when we want to align to page boundaries.
+        // 1) If this is a first non relro section after relro sequence.
+        //    We do this because we dont want any other sections except relro
+        //    were marked as read only. And that is why them should be placed on
+        //    a different memory page.
+        // 2) CreateLoad flag is set for all PT_LOADs except first one.
+        //    New PT_LOAD is usually created when access flags were changed.
+        //    So for each next PT_LOAD we create the new load header.
+        //    For first one it is created separately above.
+        if (FirstNonRelRo || CreateLoad) {
           VA = alignTo(VA, Target->getPageSize());
           FileOff = alignTo(FileOff, Target->getPageSize());
+          if (CreateLoad) {
+            setPhdr(PH, PHdr->Type, PHdr->Flags, FileOff, VA, 0,
+                    Target->getPageSize());
+            CreateLoad = false;
+          }
           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->getPageSize());
-      }
-
-      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)
-          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) {
-          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 {
+        if (needsPhdr<ELFT>(Sec)) {
+          // If we found TLS section we want to remember
+          // its VA and FileOff because we know that TLS block
+          // is continuos and we need that values for creating
+          // PT_TLS header below.
+          bool IsTls = Sec->getFlags() & SHF_TLS;
+          if (IsTls && !TlsVA) {
+            TlsVA = VA;
+            TlsFileOff = FileOff;
+          }
+          // 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());
             Sec->setVA(VA);
             VA += Sec->getSize();
+          }
+          // If we are in relro then we need to update
+          // the GnuRelroPhdr header.
           if (InRelRo)
             updateRelro(PH, &GnuRelroPhdr, 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];
+      FirstLoad = false;
+      break;
     }
+    case PT_TLS: {
+      // We want to create PT_TLS header and assign proper
+      // addresses for all sections it includes.
+      uintX_t ThreadBssOffset = 0;
+      setPhdr(PH, PT_TLS, PHdr->Flags, TlsFileOff, TlsVA, 0, 0);
+      for (OutputSectionBase<ELFT> *Sec : PHdr->OutSections) {
+        if (Sec->getType() != SHT_NOBITS)
+          TlsVA = alignTo(TlsVA, Sec->getAlign());
+        uintX_t TVA = alignTo(TlsVA + ThreadBssOffset, Sec->getAlign());
+        Sec->setVA(TVA);
 
-  // Add an entry for .dynamic.
-  if (isOutputDynamic()) {
-    Elf_Phdr *PH = &Phdrs[++PhdrIdx];
-    PH->p_type = PT_DYNAMIC;
-    copyPhdr(PH, Out<ELFT>::Dynamic);
+        if (Sec->getType() == SHT_NOBITS) {
+          ThreadBssOffset = TVA - TlsVA + Sec->getSize();
+        } else {
+          TlsVA += Sec->getSize();
+          PH->p_filesz += Sec->getSize();
         }
 
-  if (HasRelro) {
-    Elf_Phdr *PH = &Phdrs[++PhdrIdx];
-    *PH = GnuRelroPhdr;
+        PH->p_memsz += Sec->getSize();
+        PH->p_align = std::max<uintX_t>(PH->p_align, Sec->getAlign());
       }
-
-  if (Out<ELFT>::EhFrameHdr->Live) {
-    Elf_Phdr *PH = &Phdrs[++PhdrIdx];
-    PH->p_type = PT_GNU_EH_FRAME;
+      // 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.
+      PH->p_memsz = alignTo(PH->p_memsz, PH->p_align);
+      Out<ELFT>::TlsPhdr = PH;
+      break;
+    }
+    case PT_PHDR: {
+      size_t PhdrSize = sizeof(Elf_Phdr) * Phdrs.size();
+      setPhdr(PH, PT_PHDR, PF_R, FileOff, VA, PhdrSize, /*Align=*/8);
+      FileOff += PhdrSize;
+      VA += PhdrSize;
+      break;
+    }
+    case PT_INTERP:
+      InterpHdr = PH;
+      break;
+    case PT_DYNAMIC:
+      copyPhdr(PH, Out<ELFT>::Dynamic);
+      break;
+    case PT_GNU_EH_FRAME:
       copyPhdr(PH, Out<ELFT>::EhFrameHdr);
+      break;
+    case PT_GNU_RELRO:
+      *PH = GnuRelroPhdr;
+      break;
+    case PT_GNU_STACK:
+      PH->p_flags = PHdr->Flags;
+      break;
+    default:
+      assert("Unknown header type");
     }
-
-  // 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);
-  }
+  if (InterpHdr)
+    copyPhdr(InterpHdr, Out<ELFT>::Interp);
 
   // Add space for section headers.
   SectionHeaderOff = alignTo(FileOff, ELFT::Is64Bits ? 8 : 4);
   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))
-      continue;
-    if (Sec->getFlags() & SHF_TLS)
-      Tls = true;
-    uintX_t Flags = toPhdrFlags(Sec->getFlags());
-    if (Last != Flags) {
-      Last = Flags;
-      ++I;
-    }
-  }
-  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;
   if (Config->Shared)
     V |= EF_MIPS_PIC;