[ELF] Support PHDRS command

[denis-protivensky]

Summary

• match sections to one or more headers
• use NONE header to discard layouting of specific section
• support all available header types (except custom numeric values)
• TLS section layout doesn't work yet
• test cases are provided

[ruiu]

First round of review.

ELF/LinkerScript.cpp

295–298

StringRef Name = next();
uint32_t Type = readPhdrType();
Config->Phdrs.emplace_back({Name, Type});

329

It's better to be a bit more specific, say, read zero or more tokens in the form of :phdr.

330

for (;;) for consistency.

ELF/Writer.cpp

971

This function is already too long and need to be refactored. Please at least factor this new code out from this function.

[denis-protivensky]

Updated:

• style fixes in linker script's PHDRS parsing
• move custom header processing out to a separate method

[ruiu]

ELF/Writer.cpp

860

This function needs a function comment to describe what it is intended to do.

864

This for loop is probably too long. Isn't there any way to split?

[denis-protivensky]

Updated:

• Add method comment
• Simplify custom header layout loop
• Check if no sections assigned to custom headers
• Improve NONE header handling
• Style fixes in the header layout loop

ELF/Writer.cpp

864

Done, thanks. This also allowed me to add one more check with test case when no sections assigned to PHDRS.

[ruiu]

ELF/Writer.cpp

873

I wanted to split this into multiple functions -- this function is 90 lines long which feels too long to me.

[denis-protivensky]

Updated:

• move out some functionality to couple of methods
• improve NONE header handling (it now can be specified with other headers and just ignored)

[denis-protivensky]

Ping

[ruiu]

I'm sorry that this code review was slipped from my inbox.

ELF/Writer.cpp

43

Please use std::vector if there's no strong reason to use SmallVector.

96–97

These fields need a brief comment that they are for the linker script's phdr command.

864

Please add a function comment.

868

Instead of const std::vector<X> &, you want to use ArrayRef<X>.

871–901

This also needs a function comment.

903–925

This needs a comment too. They are all non-trivial, so they need some descriptions to help reader understand what they are supposed to do.

[denis-protivensky]

Updated:

• Use std::vector instead of SmallVector
• Add comments to methods
• Rename fillPhdrs -> fillUnusedPhdrs

ELF/Writer.cpp

868

I can't do that because lookup returns temporary object, and I bind it to const reference to prolong its lifetime to the end of the scope. ArrayRef constructs without copying the vector, so it'll be destroyed before used.

[ruiu]

ELF/Writer.cpp

54

Since IndicesVector is now just a std::vector, I'd write std::vector<size_t> instead of IndicesVector.

98

Ditto

879

Please do not use auto here as the actual type is not obvious in this local context.

883–884

PhdrInds.insert(PhdrIns.end(), std::begin(It->second), std::end(It->second)) is more common?

927–936

Can you please write more details about how you process PHDR command for those who happens to come to this file and read this code (not for me who is reading only the delta), so that they can get the whole picture what you are doing with this function (and the helper functions you added above) without reading all the code?

[denis-protivensky]

Updated:

• Remove IndicesVector typedef
• Replace std::copy with insert into vector
• Add more comments to functions

ELF/Writer.cpp

879

I thought we agreed to use auto for cases when returning iterators from methods like find and similar, no?

[denis-protivensky]

Rebased on top of actual sources.

[denis-protivensky]

Ping

[grimar]

ELF/Writer.cpp

1052

Wouldn`t it be better to write something like:

if (hasCustomPhdrs()) {
   layoutCustomPhdrs(VA, FileOff);
   return;
}

And just copy a piece of left logic from below to layoutCustomPhdrs() or even to separate it to another method ?

Also in currect variant bracket is missed:

if (hasCustomPhdrs()) {

1056

Change is not relative to this patch (fix of formatting).

1206

There should be brackets I think:

for (const std::pair<StringRef, OutputSectionDescription> &OutSec :
       Config->OutputSections) {
...

[denis-protivensky]

ELF/Writer.cpp

1052

No, it's not better, because there already were cases when the common logic below was extended. This would have caused logical issue in the case you propose.

Concerning the braces - I don't remember us putting them for one-line operator blocks.

1056

It's related, because you don't see that the whole code moved by one tab left (by default, ignore space mode is on). So this is the result of clang-formatting the whole shifted piece.

1206

No, I was told to remove these earlier. We don't use braces for blocks that constitute of one operator.

[grimar]

ELF/Writer.cpp

1052

(About braces):

I found multiple usings for one-line blocks:
std::string elf2::searchLibrary()
void LinkerScript::run()
void LinkerScript::addFile(StringRef S)
And no using in the way you do. I think we dont use them only if there is no else branch. And always do if it is exist.

1056

Yep, I know its moved, I just supposed correct way would be to not format that part here (to format it in separate patch).

1206

Hmm that wierd for me then :) Because quick search shows that sometimes we do:

Writer<ELFT>::copyLocalSymbols();
void Writer<ELFT>::createSections();

[denis-protivensky]

Concerning formatting - let's wait for another reviewer's opinion then.

[ruiu]

I'm sorry for the delay. I was thinking if this is a right design. Will send code review comments soon.

[ruiu]

I don't like the current code to create a program header because it's not easy to read, and this is yet another piece of code that also creates a program header. This also feels a bit too complicated. I think one reason why phdr creation is hard to read is because the functions doing that are members of Writer, and they mutate Writer's fields.

They also do too much stuff once. They are creating program header while assigning addresses to sections.

Abstractly, in order to support PHDRS command, we want 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. Can you model that way?

[denis-protivensky]

I'll think how to rework this.

ELF/Config.h

 enum ELFKind {
   ELFNoneKind,
   ELF32LEKind,
   ELF32BEKind,
   ELF64LEKind,
   ELF64BEKind
 };
 
+struct OutputSectionDescription {
+  llvm::StringRef Name;
+  std::vector<llvm::StringRef> InputSections;
+  std::vector<llvm::StringRef> Phdrs;
+};
+
+struct Phdr {
+  llvm::StringRef Name;
+  uint32_t Type;
+};
+
 struct Configuration {
   SymbolBody *EntrySym = nullptr;
   InputFile *FirstElf = nullptr;
   llvm::StringRef DynamicLinker;
   llvm::StringRef Entry;
   llvm::StringRef Emulation;
   llvm::StringRef Fini;
   llvm::StringRef Init;
   llvm::StringRef OutputFile;
   llvm::StringRef SoName;
   llvm::StringRef Sysroot;
   std::string RPath;
-  llvm::MapVector<llvm::StringRef, std::vector<llvm::StringRef>> OutputSections;
+  llvm::MapVector<llvm::StringRef, OutputSectionDescription> OutputSections;
+  std::vector<Phdr> Phdrs;
   std::vector<llvm::StringRef> SearchPaths;
   std::vector<llvm::StringRef> Undefined;
   bool AllowMultipleDefinition;
   bool AsNeeded = false;
   bool Bsymbolic;
   bool DiscardAll;
   bool DiscardLocals;
   bool DiscardNone;

ELF/LinkerScript.cpp

 // It does not construct an AST but consume linker script directives directly.
 // Results are written to Driver or Config object.
 //
 //===----------------------------------------------------------------------===//
 
 #include "Config.h"
 #include "Driver.h"
 #include "SymbolTable.h"
+#include "llvm/Support/ELF.h"
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/MemoryBuffer.h"
 #include "llvm/Support/Path.h"
 #include "llvm/Support/StringSaver.h"
 
 using namespace llvm;
+using namespace llvm::ELF;
 using namespace lld;
 using namespace lld::elf2;
 
 namespace {
 class LinkerScript {
 public:
   LinkerScript(BumpPtrAllocator *A, StringRef S, bool B)
       : Saver(*A), Tokens(tokenize(S)), IsUnderSysroot(B) {}
   void run();
 
 private:
   static std::vector<StringRef> tokenize(StringRef S);
   static StringRef skipSpace(StringRef S);
   StringRef next();
+  StringRef peek();
   bool skip(StringRef Tok);
   bool atEOF() { return Tokens.size() == Pos; }
   void expect(StringRef Expect);
 
   void addFile(StringRef Path);
 
   void readAsNeeded();
   void readEntry();
   void readExtern();
   void readGroup();
   void readInclude();
   void readOutput();
   void readOutputArch();
   void readOutputFormat();
+  void readPhdrs();
   void readSearchDir();
   void readSections();
 
   void readOutputSectionDescription();
+  uint32_t readPhdrType();
 
   StringSaver Saver;
   std::vector<StringRef> Tokens;
   size_t Pos = 0;
   bool IsUnderSysroot;
 };
 }
 
while (!atEOF()) {
     } else if (Tok == "INCLUDE") {
       readInclude();
     } else if (Tok == "OUTPUT") {
       readOutput();
     } else if (Tok == "OUTPUT_ARCH") {
       readOutputArch();
     } else if (Tok == "OUTPUT_FORMAT") {
       readOutputFormat();
+    } else if (Tok == "PHDRS") {
+      readPhdrs();
     } else if (Tok == "SEARCH_DIR") {
       readSearchDir();
     } else if (Tok == "SECTIONS") {
       readSections();
     } else {
       error("unknown directive: " + Tok);
     }
   }

 }
 
 StringRef LinkerScript::next() {
   if (atEOF())
     error("unexpected EOF");
   return Tokens[Pos++];
 }
 
+StringRef LinkerScript::peek() {
+  if (atEOF())
+    error("unexpected EOF");
+  return Tokens[Pos];
+}
+
 bool LinkerScript::skip(StringRef Tok) {
   if (atEOF())
     error("unexpected EOF");
   if (Tok != Tokens[Pos])
     return false;
   ++Pos;
   return true;
 }
void LinkerScript::readOutputFormat() {
   if (Tok != ",")
     error("unexpected token: " + Tok);
   next();
   expect(",");
   next();
   expect(")");
 }
 
+void LinkerScript::readPhdrs() {
+  expect("{");
+  while (!skip("}")) {
+    Config->Phdrs.emplace_back();
+    Phdr &PH = Config->Phdrs.back();
+    PH.Name = next();
+    PH.Type = readPhdrType();
+    expect(";");
+  }
+}
+
 void LinkerScript::readSearchDir() {
   expect("(");
   Config->SearchPaths.push_back(next());
   expect(")");
 }
 
 void LinkerScript::readSections() {
   expect("{");
   while (!skip("}"))
     readOutputSectionDescription();
 }
 
 void LinkerScript::readOutputSectionDescription() {
   StringRef Name = next();
-  std::vector<StringRef> &InputSections = Config->OutputSections[Name];
+  OutputSectionDescription &OutSec = Config->OutputSections[Name];
+  OutSec.Name = Name;
 
   expect(":");
   expect("{");
   while (!skip("}")) {
     next(); // Skip input file name.
     expect("(");
     while (!skip(")"))
-      InputSections.push_back(next());
+      OutSec.InputSections.push_back(next());
   }
+
+  // Read headers of the section.
+  while (true) {
+    StringRef Tok = peek();
+    if (Tok[0] != ':')
+      break;
+
+    next(); // Swallow peeked token.
+    // If token is of one symbol, it's a separate ':', so go to the next token.
+    // Otherwise, skip starting ':' in header name.
+    if (Tok.size() == 1)
+      Tok = next();
+    else
+      Tok = Tok.substr(1);
+    OutSec.Phdrs.emplace_back(Tok);
+  }
+}
+
+uint32_t LinkerScript::readPhdrType() {
+  StringRef Tok = next();
+  if (Tok == "PT_NULL")
+    return PT_NULL;
+  if (Tok == "PT_LOAD")
+    return PT_LOAD;
+  if (Tok == "PT_DYNAMIC")
+    return PT_DYNAMIC;
+  if (Tok == "PT_INTERP")
+    return PT_INTERP;
+  if (Tok == "PT_NOTE")
+    return PT_NOTE;
+  if (Tok == "PT_SHLIB")
+    return PT_SHLIB;
+  if (Tok == "PT_PHDR")
+    return PT_PHDR;
+  error("Wrong header type " + Tok);
 }
 
 static bool isUnderSysroot(StringRef Path) {
   if (Config->Sysroot == "")
     return false;
   for (; !Path.empty(); Path = sys::path::parent_path(Path))
     if (sys::fs::equivalent(Config->Sysroot, Path))
       return true;
   return false;
 }
 
 // Entry point. The other functions or classes are private to this file.
 void lld::elf2::readLinkerScript(BumpPtrAllocator *A, MemoryBufferRef MB) {
   StringRef Path = MB.getBufferIdentifier();
   LinkerScript(A, MB.getBuffer(), isUnderSysroot(Path)).run();
 }

ELF/Writer.cpp

public:
   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 createSections();
   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,
                    OutputSectionBase<ELFT> *Sec, uintX_t VA);
   void assignAddresses();
   void buildSectionMap();
+  void buildPhdrMap();
   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();
   }
private:
 
   bool HasRelro = false;
   SymbolTable<ELFT> &Symtab;
   std::vector<Elf_Phdr> Phdrs;
 
   uintX_t FileSize;
   uintX_t SectionHeaderOff;
 
+  typedef llvm::SmallVector<size_t, 4> IndicesVector;
   llvm::StringMap<llvm::StringRef> InputToOutputSection;
+  llvm::StringMap<std::vector<llvm::StringRef>> OutputSectionToPhdrs;
+  llvm::SmallMapVector<llvm::StringRef, IndicesVector, 8> PhdrNameToIndices;
 };
 } // anonymous namespace
 
 template <class ELFT> void lld::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);
template <class ELFT> void lld::elf2::writeResult(SymbolTable<ELFT> *Symtab) {
   Out<ELFT>::Dynamic = &Dynamic;
 
   Writer<ELFT>(*Symtab).run();
 }
 
 // The main function of the writer.
 template <class ELFT> void Writer<ELFT>::run() {
   buildSectionMap();
+  buildPhdrMap();
   if (!Config->DiscardAll)
     copyLocalSymbols();
   createSections();
   assignAddresses();
   openFile(Config->OutputFile);
   writeHeader();
   writeSections();
   error(Buffer->commit());
static uint32_t toPhdrFlags(uint64_t Flags) {
   uint32_t Ret = PF_R;
   if (Flags & SHF_WRITE)
     Ret |= PF_W;
   if (Flags & SHF_EXECINSTR)
     Ret |= PF_X;
   return Ret;
 }
 
+static bool hasCustomPhdrs() { return !Config->Phdrs.empty(); }
+
+static bool isNonePhdr(const std::vector<StringRef> &Phdrs) {
+  return Phdrs.size() == 1 && Phdrs[0] == "NONE";
+}
+
+static bool isSubset(const std::vector<StringRef> &Set,
+                     const std::vector<StringRef> &Subset) {
+  for (StringRef Name : Subset) {
+    auto It = std::find(std::begin(Set), std::end(Set), Name);
+    if (It == std::end(Set))
+      return false;
+  }
+  return true;
+}
+
 template <class ELFT>
 void Writer<ELFT>::updateRelro(Elf_Phdr *Cur, Elf_Phdr *GnuRelroPhdr,
                                OutputSectionBase<ELFT> *Sec, uintX_t VA) {
   if (!Config->ZRelro || !(Cur->p_flags & PF_W) || !isRelroSection(Sec))
     return;
   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();
 
-  // The first phdr entry is PT_PHDR which describes the program header itself.
+  if (!hasCustomPhdrs()) {
+    // 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;
 
     // PT_INTERP must be the second entry if exists.
     int PhdrIdx = 0;
     Elf_Phdr *Interp = nullptr;
     if (needsInterpSection())
       Interp = &Phdrs[++PhdrIdx];
 
     // Add the first PT_LOAD segment for regular output sections.
     setPhdr(&Phdrs[++PhdrIdx], PT_LOAD, PF_R, 0, Target->getVAStart(), FileOff,
             Target->getPageSize());
 
     Elf_Phdr GnuRelroPhdr = {};
     Elf_Phdr TlsPhdr{};
     uintX_t ThreadBSSOffset = 0;
     // Create phdrs as we assign VAs and file offsets to all output sections.
     for (OutputSectionBase<ELFT> *Sec : OutputSections) {
       if (needsPhdr<ELFT>(Sec)) {
         uintX_t Flags = toPhdrFlags(Sec->getFlags());
         if (Phdrs[PhdrIdx].p_flags != Flags) {
           // Flags changed. Create a new PT_LOAD.
           VA = RoundUpToAlignment(VA, Target->getPageSize());
           FileOff = RoundUpToAlignment(FileOff, Target->getPageSize());
           Elf_Phdr *PH = &Phdrs[++PhdrIdx];
           setPhdr(PH, PT_LOAD, 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 = RoundUpToAlignment(VA, Sec->getAlign());
-        uintX_t TVA = RoundUpToAlignment(VA + ThreadBSSOffset, Sec->getAlign());
+          uintX_t TVA =
+              RoundUpToAlignment(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 {
           VA = RoundUpToAlignment(VA, Sec->getAlign());
           Sec->setVA(VA);
           VA += Sec->getSize();
           updateRelro(&Phdrs[PhdrIdx], &GnuRelroPhdr, Sec, VA);
         }
       }
 
       FileOff = RoundUpToAlignment(FileOff, Sec->getAlign());
       Sec->setFileOffset(FileOff);
       if (Sec->getType() != SHT_NOBITS)
         FileOff += Sec->getSize();
       if (needsPhdr<ELFT>(Sec)) {
         Elf_Phdr *Cur = &Phdrs[PhdrIdx];
         Cur->p_filesz = FileOff - Cur->p_offset;
         Cur->p_memsz = VA - Cur->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 = RoundUpToAlignment(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;
     }
 
     // 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);
     }
+  } else {
+    SmallMapVector<StringRef, IndicesVector, 8> PhdrsToFill = PhdrNameToIndices;
+    std::vector<StringRef> PhdrNames;
+    for (OutputSectionBase<ELFT> *Sec : OutputSections) {
+      const std::vector<StringRef> &NewPhdrNames =
+          OutputSectionToPhdrs.lookup(Sec->getName());
+      bool PhdrsChanged = false;
+      if (!NewPhdrNames.empty()) {
+        // Headers really changed if they are not a direct subset
+        // of the previous set of headers.
+        PhdrsChanged = !isSubset(PhdrNames, NewPhdrNames);
+        PhdrNames = NewPhdrNames;
+      }
+
+      // Find appropriate headers for the first section if not defined.
+      if (PhdrNames.empty())
+        for (size_t I = 1, Len = OutputSections.size(); I < Len; ++I) {
+          const std::vector<StringRef> &NewPhdrNames =
+              OutputSectionToPhdrs.lookup(OutputSections[I]->getName());
+          if (!NewPhdrNames.empty()) {
+            PhdrsChanged = true;
+            PhdrNames = NewPhdrNames;
+            break;
+          }
+        }
+
+      const bool IsNonePhdr = isNonePhdr(PhdrNames);
+      IndicesVector PhdrInds;
+      if (!IsNonePhdr)
+        for (StringRef Name : PhdrNames) {
+          auto It = PhdrNameToIndices.find(Name);
+          if (It == std::end(PhdrNameToIndices))
+            error("Output section " + Sec->getName() +
+                  " assigned to non-existent header " + Name);
+          std::copy(std::begin(It->second), std::end(It->second),
+                    std::back_inserter(PhdrInds));
+        }
+
+      if (needsPhdr<ELFT>(Sec) && !IsNonePhdr) {
+        if (PhdrsChanged) {
+          VA = RoundUpToAlignment(VA, Target->getPageSize());
+          FileOff = RoundUpToAlignment(FileOff, Target->getPageSize());
+          for (size_t Ind : PhdrInds) {
+            const Phdr &PH = Config->Phdrs[Ind];
+            StringRef Name = PH.Name;
+            // Check that this is the first update of the header.
+            if (!PhdrsToFill.count(Name))
+              continue;
+            PhdrsToFill.erase(Name);
+            // Flags for the header will be updated later.
+            setPhdr(&Phdrs[Ind], PH.Type, 0, FileOff, VA, 0,
+                    Target->getPageSize());
+          }
+        }
+
+        VA = RoundUpToAlignment(VA, Sec->getAlign());
+        Sec->setVA(VA);
+        VA += Sec->getSize();
+      }
+
+      FileOff = RoundUpToAlignment(FileOff, Sec->getAlign());
+      Sec->setFileOffset(FileOff);
+      if (Sec->getType() != SHT_NOBITS)
+        FileOff += Sec->getSize();
+      if (needsPhdr<ELFT>(Sec) && !IsNonePhdr) {
+        uintX_t Flags = toPhdrFlags(Sec->getFlags());
+        for (size_t Ind : PhdrInds) {
+          Elf_Phdr *Cur = &Phdrs[Ind];
+          Cur->p_filesz = FileOff - Cur->p_offset;
+          Cur->p_memsz = VA - Cur->p_vaddr;
+          Cur->p_flags |= Flags;
+        }
+      }
+    }
+
+    // Fixup not used headers from PHDRS command.
+    for (const std::pair<StringRef, IndicesVector> &p : PhdrsToFill)
+      for (size_t Ind : p.second) {
+        const Phdr &PH = Config->Phdrs[Ind];
+
+        uintX_t CurFileOff = 0;
+        if (Ind != 0) {
+          const Elf_Phdr *Prev = &Phdrs[Ind - 1];
+          CurFileOff = Prev->p_offset + Prev->p_filesz;
+        }
+        setPhdr(&Phdrs[Ind], PH.Type, 0, CurFileOff, 0, 0,
+                Target->getPageSize());
+      }
+  }
 
   // Add space for section headers.
   SectionHeaderOff = RoundUpToAlignment(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.
   DefinedAbsolute<ELFT>::End.st_value = VA;
 
   // Update MIPS _gp absolute symbol so that it points to the static data.
   if (Config->EMachine == EM_MIPS)
     DefinedAbsolute<ELFT>::MipsGp.st_value = getMipsGpAddr<ELFT>();
 }
 
 // Returns the number of PHDR entries.
 template <class ELFT> int Writer<ELFT>::getPhdrsNum() const {
+  if (hasCustomPhdrs())
+    return Config->Phdrs.size();
+
   bool Tls = false;
   int I = 2; // 2 for PT_PHDR and first PT_LOAD
   if (needsInterpSection())
     ++I;
   if (isOutputDynamic())
     ++I;
   if (!Config->ZExecStack)
     ++I;
void Writer<ELFT>::copyPhdr(Elf_Phdr *PH, OutputSectionBase<ELFT> *From) {
   PH->p_vaddr = From->getVA();
   PH->p_paddr = From->getVA();
   PH->p_filesz = From->getSize();
   PH->p_memsz = From->getSize();
   PH->p_align = From->getAlign();
 }
 
 template <class ELFT> void Writer<ELFT>::buildSectionMap() {
-  for (const std::pair<StringRef, std::vector<StringRef>> &OutSec :
+  for (const std::pair<StringRef, OutputSectionDescription> &OutSec :
        Config->OutputSections)
-    for (StringRef Name : OutSec.second)
+    for (StringRef Name : OutSec.second.InputSections) {
       InputToOutputSection[Name] = OutSec.first;
+
+      if (!hasCustomPhdrs() || OutSec.second.Phdrs.empty())
+        continue;
+      std::vector<StringRef> &Phdrs = OutputSectionToPhdrs[Name];
+      Phdrs.insert(std::end(Phdrs), std::begin(OutSec.second.Phdrs),
+                   std::end(OutSec.second.Phdrs));
+    }
+}
+
+template <class ELFT> void Writer<ELFT>::buildPhdrMap() {
+  for (size_t I = 0, Len = Config->Phdrs.size(); I < Len; ++I) {
+    const Phdr &PH = Config->Phdrs[I];
+    PhdrNameToIndices[PH.Name].push_back(I);
+  }
 }
 
 template void lld::elf2::writeResult<ELF32LE>(SymbolTable<ELF32LE> *Symtab);
 template void lld::elf2::writeResult<ELF32BE>(SymbolTable<ELF32BE> *Symtab);
 template void lld::elf2::writeResult<ELF64LE>(SymbolTable<ELF64LE> *Symtab);
 template void lld::elf2::writeResult<ELF64BE>(SymbolTable<ELF64BE> *Symtab);

test/ELF/linkerscript-phdrs.s

+# REQUIRES: x86
+# RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %s -o %t
+
+# Empty PHDRS command.
+# RUN: echo "PHDRS {}" > %t.script
+# RUN: ld.lld -o %t1 --script %t.script %t
+# RUN: llvm-readobj -program-headers %t1 | \
+# RUN:   FileCheck -check-prefix=PHDRS-DEFAULT %s
+
+# PHDRS-DEFAULT: ProgramHeaders [
+# PHDRS-DEFAULT:   ProgramHeader {
+# PHDRS-DEFAULT:     Type: PT_PHDR
+# PHDRS-DEFAULT:     Flags [ (0x4)
+# PHDRS-DEFAULT:       PF_R (0x4)
+# PHDRS-DEFAULT:     ]
+# PHDRS-DEFAULT:     Alignment: 8
+# PHDRS-DEFAULT:   }
+# PHDRS-DEFAULT:   ProgramHeader {
+# PHDRS-DEFAULT:     Type: PT_LOAD (0x1)
+# PHDRS-DEFAULT:     Flags [ (0x4)
+# PHDRS-DEFAULT:       PF_R (0x4)
+# PHDRS-DEFAULT:     ]
+# PHDRS-DEFAULT:     Alignment: 4096
+# PHDRS-DEFAULT:   }
+# PHDRS-DEFAULT:   ProgramHeader {
+# PHDRS-DEFAULT:     Type: PT_LOAD
+# PHDRS-DEFAULT:     Flags [ (0x5)
+# PHDRS-DEFAULT:       PF_R (0x4)
+# PHDRS-DEFAULT:       PF_X (0x1)
+# PHDRS-DEFAULT:     ]
+# PHDRS-DEFAULT:     Alignment: 4096
+# PHDRS-DEFAULT:   }
+# PHDRS-DEFAULT:   ProgramHeader {
+# PHDRS-DEFAULT:     Type: PT_LOAD
+# PHDRS-DEFAULT:     Flags [ (0x6)
+# PHDRS-DEFAULT:       PF_R (0x4)
+# PHDRS-DEFAULT:       PF_W (0x2)
+# PHDRS-DEFAULT:     ]
+# PHDRS-DEFAULT:     Alignment: 4096
+# PHDRS-DEFAULT:   }
+# PHDRS-DEFAULT:   ProgramHeader {
+# PHDRS-DEFAULT:     Type: PT_GNU_STACK
+# PHDRS-DEFAULT:     Flags [ (0x6)
+# PHDRS-DEFAULT:       PF_R (0x4)
+# PHDRS-DEFAULT:       PF_W (0x2)
+# PHDRS-DEFAULT:     ]
+# PHDRS-DEFAULT:     Alignment: 0
+# PHDRS-DEFAULT:   }
+# PHDRS-DEFAULT: ]
+
+# Unknown header type causes error.
+# RUN: echo "PHDRS { \
+# RUN:   unknown PT_UNKNOWN; \
+# RUN: }" > %t.script
+# RUN: not ld.lld -o %t1 --script %t.script %t > %t.log 2>&1
+# RUN: FileCheck -check-prefix=PHDRS-ERRTYPE %s < %t.log
+
+# PHDRS-ERRTYPE: Wrong header type PT_UNKNOWN
+
+# Unknown header name causes error.
+# RUN: echo "PHDRS { \
+# RUN:   load PT_LOAD; \
+# RUN: } \
+# RUN: SECTIONS { \
+# RUN:   .text : { *(.text) } :load \
+# RUN:   .data : { *(.data) } :unknown \
+# RUN: }" > %t.script
+# RUN: not ld.lld -o %t1 --script %t.script %t > %t.log 2>&1
+# RUN: FileCheck -check-prefix=PHDRS-ERRNAME %s < %t.log
+
+# PHDRS-ERRNAME: Output section .data assigned to non-existent header unknown
+
+# Map all sections to one header.
+# RUN: echo "PHDRS { \
+# RUN:   load PT_LOAD; \
+# RUN: } \
+# RUN: SECTIONS { \
+# RUN:   .text : { *(.text) } :load \
+# RUN: }" > %t.script
+# RUN: ld.lld -o %t2 --script %t.script %t
+# RUN: llvm-readobj -program-headers %t2 | \
+# RUN:   FileCheck -check-prefix=PHDRS-ONE-ALL %s
+# RUN: llvm-objdump -section-headers %t2 | \
+# RUN:   FileCheck -check-prefix=SEC-ONE-ALL %s
+
+# PHDRS-ONE-ALL:      ProgramHeaders [
+# PHDRS-ONE-ALL-NEXT:   ProgramHeader {
+# PHDRS-ONE-ALL-NEXT:     Type: PT_LOAD
+# PHDRS-ONE-ALL-NEXT:     Offset: 0x1000
+# PHDRS-ONE-ALL-NEXT:     VirtualAddress: 0x11000
+# PHDRS-ONE-ALL-NEXT:     PhysicalAddress: 0x11000
+# PHDRS-ONE-ALL-NEXT:     FileSize: 46
+# PHDRS-ONE-ALL-NEXT:     MemSize: 48
+# PHDRS-ONE-ALL-NEXT:     Flags [ (0x7)
+# PHDRS-ONE-ALL-NEXT:       PF_R (0x4)
+# PHDRS-ONE-ALL-NEXT:       PF_W (0x2)
+# PHDRS-ONE-ALL-NEXT:       PF_X (0x1)
+# PHDRS-ONE-ALL-NEXT:     ]
+# PHDRS-ONE-ALL-NEXT:     Alignment: 4096
+# PHDRS-ONE-ALL-NEXT:   }
+# PHDRS-ONE-ALL-NEXT: ]
+
+#             Idx Name          Size         Address
+# SEC-ONE-ALL: 1 .text         0000000e 0000000000011000
+# SEC-ONE-ALL: 2 .data         00000020 000000000001100e
+# SEC-ONE-ALL: 3 .bss          00000002 000000000001102e
+
+# Map all sections to one header,
+# but separate the header name from the ':' sign.
+# RUN: echo "PHDRS { \
+# RUN:   load PT_LOAD; \
+# RUN: } \
+# RUN: SECTIONS { \
+# RUN:   .text : { *(.text) } : load \
+# RUN: }" > %t.script
+# RUN: ld.lld -o %t2_1 --script %t.script %t
+# RUN: llvm-readobj -program-headers %t2_1 | \
+# RUN:   FileCheck -check-prefix=PHDRS-ONE-ALL %s
+# RUN: llvm-objdump -section-headers %t2_1 | \
+# RUN:   FileCheck -check-prefix=SEC-ONE-ALL %s
+
+# Map all sections to couple of headers.
+# RUN: echo "PHDRS { \
+# RUN:   phdr PT_PHDR; \
+# RUN:   load PT_LOAD; \
+# RUN: } \
+# RUN: SECTIONS { \
+# RUN:   .text : { *(.text) } :load :phdr \
+# RUN: }" > %t.script
+# RUN: ld.lld -o %t3 --script %t.script %t
+# RUN: llvm-readobj -program-headers %t3 | \
+# RUN:   FileCheck -check-prefix=PHDRS-TWO-ALL %s
+# RUN: llvm-objdump -section-headers %t3 | \
+# RUN:   FileCheck -check-prefix=SEC-TWO-ALL %s
+
+# PHDRS-TWO-ALL:      ProgramHeaders [
+# PHDRS-TWO-ALL-NEXT:   ProgramHeader {
+# PHDRS-TWO-ALL-NEXT:     Type: PT_PHDR
+# PHDRS-TWO-ALL-NEXT:     Offset: 0x1000
+# PHDRS-TWO-ALL-NEXT:     VirtualAddress: 0x11000
+# PHDRS-TWO-ALL-NEXT:     PhysicalAddress: 0x11000
+# PHDRS-TWO-ALL-NEXT:     FileSize: 46
+# PHDRS-TWO-ALL-NEXT:     MemSize: 48
+# PHDRS-TWO-ALL-NEXT:     Flags [ (0x7)
+# PHDRS-TWO-ALL-NEXT:       PF_R (0x4)
+# PHDRS-TWO-ALL-NEXT:       PF_W (0x2)
+# PHDRS-TWO-ALL-NEXT:       PF_X (0x1)
+# PHDRS-TWO-ALL-NEXT:     ]
+# PHDRS-TWO-ALL-NEXT:     Alignment: 4096
+# PHDRS-TWO-ALL-NEXT:   }
+# PHDRS-TWO-ALL-NEXT:   ProgramHeader {
+# PHDRS-TWO-ALL-NEXT:     Type: PT_LOAD
+# PHDRS-TWO-ALL-NEXT:     Offset: 0x1000
+# PHDRS-TWO-ALL-NEXT:     VirtualAddress: 0x11000
+# PHDRS-TWO-ALL-NEXT:     PhysicalAddress: 0x11000
+# PHDRS-TWO-ALL-NEXT:     FileSize: 46
+# PHDRS-TWO-ALL-NEXT:     MemSize: 48
+# PHDRS-TWO-ALL-NEXT:     Flags [ (0x7)
+# PHDRS-TWO-ALL-NEXT:       PF_R (0x4)
+# PHDRS-TWO-ALL-NEXT:       PF_W (0x2)
+# PHDRS-TWO-ALL-NEXT:       PF_X (0x1)
+# PHDRS-TWO-ALL-NEXT:     ]
+# PHDRS-TWO-ALL-NEXT:     Alignment: 4096
+# PHDRS-TWO-ALL-NEXT:   }
+# PHDRS-TWO-ALL-NEXT: ]
+
+#             Idx Name          Size         Address
+# SEC-TWO-ALL: 1 .text         0000000e 0000000000011000
+# SEC-TWO-ALL: 2 .data         00000020 000000000001100e
+# SEC-TWO-ALL: 3 .bss          00000002 000000000001102e
+
+# Map sections to different headers explicitly.
+# RUN: echo "PHDRS { \
+# RUN:   load PT_LOAD; \
+# RUN:   load2 PT_LOAD; \
+# RUN: } \
+# RUN: SECTIONS { \
+# RUN:   .text : { *(.text) } :load \
+# RUN:   .data : { *(.data) } :load \
+# RUN:   .bss : { *(.bss) } :load2 \
+# RUN: }" > %t.script
+# RUN: ld.lld -o %t4 --script %t.script %t
+# RUN: llvm-readobj -program-headers %t4 | \
+# RUN:   FileCheck -check-prefix=PHDRS-DIFF %s
+# RUN: llvm-objdump -section-headers %t4 | \
+# RUN:   FileCheck -check-prefix=SEC-DIFF %s
+
+# PHDRS-DIFF:      ProgramHeaders [
+# PHDRS-DIFF-NEXT:   ProgramHeader {
+# PHDRS-DIFF-NEXT:     Type: PT_LOAD
+# PHDRS-DIFF-NEXT:     Offset: 0x1000
+# PHDRS-DIFF-NEXT:     VirtualAddress: 0x11000
+# PHDRS-DIFF-NEXT:     PhysicalAddress: 0x11000
+# PHDRS-DIFF-NEXT:     FileSize: 46
+# PHDRS-DIFF-NEXT:     MemSize: 46
+# PHDRS-DIFF-NEXT:     Flags [ (0x7)
+# PHDRS-DIFF-NEXT:       PF_R (0x4)
+# PHDRS-DIFF-NEXT:       PF_W (0x2)
+# PHDRS-DIFF-NEXT:       PF_X (0x1)
+# PHDRS-DIFF-NEXT:     ]
+# PHDRS-DIFF-NEXT:     Alignment: 4096
+# PHDRS-DIFF-NEXT:   }
+# PHDRS-DIFF-NEXT:   ProgramHeader {
+# PHDRS-DIFF-NEXT:     Type: PT_LOAD
+# PHDRS-DIFF-NEXT:     Offset: 0x2000
+# PHDRS-DIFF-NEXT:     VirtualAddress: 0x12000
+# PHDRS-DIFF-NEXT:     PhysicalAddress: 0x12000
+# PHDRS-DIFF-NEXT:     FileSize: 0
+# PHDRS-DIFF-NEXT:     MemSize: 2
+# PHDRS-DIFF-NEXT:     Flags [ (0x6)
+# PHDRS-DIFF-NEXT:       PF_R (0x4)
+# PHDRS-DIFF-NEXT:       PF_W (0x2)
+# PHDRS-DIFF-NEXT:     ]
+# PHDRS-DIFF-NEXT:     Alignment: 4096
+# PHDRS-DIFF-NEXT:   }
+# PHDRS-DIFF-NEXT: ]
+
+#          Idx Name          Size         Address
+# SEC-DIFF: 1 .text         0000000e 0000000000011000
+# SEC-DIFF: 2 .data         00000020 000000000001100e
+# SEC-DIFF: 3 .bss          00000002 0000000000012000
+
+# Map sections to different headers implicitly.
+# RUN: echo "PHDRS { \
+# RUN:   load PT_LOAD; \
+# RUN:   load2 PT_LOAD; \
+# RUN: } \
+# RUN: SECTIONS { \
+# RUN:   .text : { *(.text) } :load \
+# RUN:   .data : { *(.data) } \
+# RUN:   .bss : { *(.bss) } :load2 \
+# RUN: }" > %t.script
+# RUN: ld.lld -o %t5 --script %t.script %t
+# RUN: llvm-readobj -program-headers %t5 | \
+# RUN:   FileCheck -check-prefix=PHDRS-DIFF %s
+# RUN: llvm-objdump -section-headers %t5 | \
+# RUN:   FileCheck -check-prefix=SEC-DIFF %s
+
+# Map sections appearing before the section with first assigned header
+# to that header (.text is mapped to the 'load' header).
+# RUN: echo "PHDRS { \
+# RUN:   load PT_LOAD; \
+# RUN:   load2 PT_LOAD; \
+# RUN: } \
+# RUN: SECTIONS { \
+# RUN:   .data : { *(.data) } :load \
+# RUN:   .bss : { *(.bss) } :load2 \
+# RUN: }" > %t.script
+# RUN: ld.lld -o %t6 --script %t.script %t
+# RUN: llvm-readobj -program-headers %t6 | \
+# RUN:   FileCheck -check-prefix=PHDRS-DIFF %s
+# RUN: llvm-objdump -section-headers %t6 | \
+# RUN:   FileCheck -check-prefix=SEC-DIFF %s
+
+# Map :NONE header to some sections.
+# RUN: echo "PHDRS { \
+# RUN:   load PT_LOAD; \
+# RUN:   load2 PT_LOAD; \
+# RUN: } \
+# RUN: SECTIONS { \
+# RUN:   .text : { *(.text) } :load \
+# RUN:   .data : { *(.data) } :NONE \
+# RUN:   .bss : { *(.bss) } :load2 \
+# RUN: }" > %t.script
+# RUN: ld.lld -o %t7 --script %t.script %t
+# RUN: llvm-readobj -program-headers %t7 | \
+# RUN:   FileCheck -check-prefix=PHDRS-NONE %s
+# RUN: llvm-objdump -section-headers %t7 | \
+# RUN:   FileCheck -check-prefix=SEC-NONE %s
+
+# PHDRS-NONE:      ProgramHeaders [
+# PHDRS-NONE-NEXT:   ProgramHeader {
+# PHDRS-NONE-NEXT:     Type: PT_LOAD
+# PHDRS-NONE-NEXT:     Offset: 0x1000
+# PHDRS-NONE-NEXT:     VirtualAddress: 0x11000
+# PHDRS-NONE-NEXT:     PhysicalAddress: 0x11000
+# PHDRS-NONE-NEXT:     FileSize: 14
+# PHDRS-NONE-NEXT:     MemSize: 14
+# PHDRS-NONE-NEXT:     Flags [ (0x5)
+# PHDRS-NONE-NEXT:       PF_R (0x4)
+# PHDRS-NONE-NEXT:       PF_X (0x1)
+# PHDRS-NONE-NEXT:     ]
+# PHDRS-NONE-NEXT:     Alignment: 4096
+# PHDRS-NONE-NEXT:   }
+# PHDRS-NONE-NEXT:   ProgramHeader {
+# PHDRS-NONE-NEXT:     Type: PT_LOAD
+# PHDRS-NONE-NEXT:     Offset: 0x2000
+# PHDRS-NONE-NEXT:     VirtualAddress: 0x12000
+# PHDRS-NONE-NEXT:     PhysicalAddress: 0x12000
+# PHDRS-NONE-NEXT:     FileSize: 0
+# PHDRS-NONE-NEXT:     MemSize: 2
+# PHDRS-NONE-NEXT:     Flags [ (0x6)
+# PHDRS-NONE-NEXT:       PF_R (0x4)
+# PHDRS-NONE-NEXT:       PF_W (0x2)
+# PHDRS-NONE-NEXT:     ]
+# PHDRS-NONE-NEXT:     Alignment: 4096
+# PHDRS-NONE-NEXT:   }
+# PHDRS-NONE-NEXT: ]
+
+#          Idx Name          Size         Address
+# SEC-NONE: 1 .text         0000000e 0000000000011000
+# SEC-NONE: 2 .data         00000020 0000000000000000
+# SEC-NONE: 3 .bss          00000002 0000000000012000
+
+# Map sections to multiple headers.
+# RUN: echo "PHDRS { \
+# RUN:   phdr PT_PHDR; \
+# RUN:   load PT_LOAD; \
+# RUN: } \
+# RUN: SECTIONS { \
+# RUN:   .text : { *(.text) } :phdr :load \
+# RUN:   .data : { *(.data) } \
+# RUN:   .bss : { *(.bss) } \
+# RUN: }" > %t.script
+# RUN: ld.lld -o %t8 --script %t.script %t
+# RUN: llvm-readobj -program-headers %t8 | \
+# RUN:   FileCheck -check-prefix=PHDRS-MULT %s
+# RUN: llvm-objdump -section-headers %t8 | \
+# RUN:   FileCheck -check-prefix=SEC-MULT %s
+
+# PHDRS-MULT:      ProgramHeaders [
+# PHDRS-MULT-NEXT:   ProgramHeader {
+# PHDRS-MULT-NEXT:     Type: PT_PHDR
+# PHDRS-MULT-NEXT:     Offset: 0x1000
+# PHDRS-MULT-NEXT:     VirtualAddress: 0x11000
+# PHDRS-MULT-NEXT:     PhysicalAddress: 0x11000
+# PHDRS-MULT-NEXT:     FileSize: 46
+# PHDRS-MULT-NEXT:     MemSize: 48
+# PHDRS-MULT-NEXT:     Flags [ (0x7)
+# PHDRS-MULT-NEXT:       PF_R (0x4)
+# PHDRS-MULT-NEXT:       PF_W (0x2)
+# PHDRS-MULT-NEXT:       PF_X (0x1)
+# PHDRS-MULT-NEXT:     ]
+# PHDRS-MULT-NEXT:     Alignment: 4096
+# PHDRS-MULT-NEXT:   }
+# PHDRS-MULT-NEXT:   ProgramHeader {
+# PHDRS-MULT-NEXT:     Type: PT_LOAD
+# PHDRS-MULT-NEXT:     Offset: 0x1000
+# PHDRS-MULT-NEXT:     VirtualAddress: 0x11000
+# PHDRS-MULT-NEXT:     PhysicalAddress: 0x11000
+# PHDRS-MULT-NEXT:     FileSize: 46
+# PHDRS-MULT-NEXT:     MemSize: 48
+# PHDRS-MULT-NEXT:     Flags [ (0x7)
+# PHDRS-MULT-NEXT:       PF_R (0x4)
+# PHDRS-MULT-NEXT:       PF_W (0x2)
+# PHDRS-MULT-NEXT:       PF_X (0x1)
+# PHDRS-MULT-NEXT:     ]
+# PHDRS-MULT-NEXT:     Alignment: 4096
+# PHDRS-MULT-NEXT:   }
+# PHDRS-MULT-NEXT: ]
+
+#          Idx Name          Size         Address
+# SEC-MULT: 1 .text         0000000e 0000000000011000
+# SEC-MULT: 2 .data         00000020 000000000001100e
+# SEC-MULT: 3 .bss          00000002 000000000001102e
+
+# Map sections initially to multiple headers, then map
+# other sections to the subset of these headers.
+# RUN: echo "PHDRS { \
+# RUN:   phdr PT_PHDR; \
+# RUN:   load PT_LOAD; \
+# RUN: } \
+# RUN: SECTIONS { \
+# RUN:   .text : { *(.text) } :phdr :load \
+# RUN:   .data : { *(.data) } :load \
+# RUN:   .bss : { *(.bss) } \
+# RUN: }" > %t.script
+# RUN: ld.lld -o %t9 --script %t.script %t
+# RUN: llvm-readobj -program-headers %t9 | \
+# RUN:   FileCheck -check-prefix=PHDRS-SUBSET %s
+# RUN: llvm-objdump -section-headers %t9 | \
+# RUN:   FileCheck -check-prefix=SEC-SUBSET %s
+
+# PHDRS-SUBSET:      ProgramHeaders [
+# PHDRS-SUBSET-NEXT:   ProgramHeader {
+# PHDRS-SUBSET-NEXT:     Type: PT_PHDR
+# PHDRS-SUBSET-NEXT:     Offset: 0x1000
+# PHDRS-SUBSET-NEXT:     VirtualAddress: 0x11000
+# PHDRS-SUBSET-NEXT:     PhysicalAddress: 0x11000
+# PHDRS-SUBSET-NEXT:     FileSize: 14
+# PHDRS-SUBSET-NEXT:     MemSize: 14
+# PHDRS-SUBSET-NEXT:     Flags [ (0x5)
+# PHDRS-SUBSET-NEXT:       PF_R (0x4)
+# PHDRS-SUBSET-NEXT:       PF_X (0x1)
+# PHDRS-SUBSET-NEXT:     ]
+# PHDRS-SUBSET-NEXT:     Alignment: 4096
+# PHDRS-SUBSET-NEXT:   }
+# PHDRS-SUBSET-NEXT:   ProgramHeader {
+# PHDRS-SUBSET-NEXT:     Type: PT_LOAD
+# PHDRS-SUBSET-NEXT:     Offset: 0x1000
+# PHDRS-SUBSET-NEXT:     VirtualAddress: 0x11000
+# PHDRS-SUBSET-NEXT:     PhysicalAddress: 0x11000
+# PHDRS-SUBSET-NEXT:     FileSize: 46
+# PHDRS-SUBSET-NEXT:     MemSize: 48
+# PHDRS-SUBSET-NEXT:     Flags [ (0x7)
+# PHDRS-SUBSET-NEXT:       PF_R (0x4)
+# PHDRS-SUBSET-NEXT:       PF_W (0x2)
+# PHDRS-SUBSET-NEXT:       PF_X (0x1)
+# PHDRS-SUBSET-NEXT:     ]
+# PHDRS-SUBSET-NEXT:     Alignment: 4096
+# PHDRS-SUBSET-NEXT:   }
+# PHDRS-SUBSET-NEXT: ]
+
+#            Idx Name          Size         Address
+# SEC-SUBSET: 1 .text         0000000e 0000000000011000
+# SEC-SUBSET: 2 .data         00000020 000000000001100e
+# SEC-SUBSET: 3 .bss          00000002 000000000001102e
+
+# Map sections initially to multiple headers, then map
+# sections to other headers.
+# RUN: echo "PHDRS { \
+# RUN:   phdr PT_PHDR; \
+# RUN:   load PT_LOAD; \
+# RUN:   load2 PT_LOAD; \
+# RUN: } \
+# RUN: SECTIONS { \
+# RUN:   .text : { *(.text) } :phdr :load \
+# RUN:   .data : { *(.data) } \
+# RUN:   .bss : { *(.bss) } :load2 \
+# RUN: }" > %t.script
+# RUN: ld.lld -o %t10 --script %t.script %t
+# RUN: llvm-readobj -program-headers %t10 | \
+# RUN:   FileCheck -check-prefix=PHDRS-NOSUBSET %s
+# RUN: llvm-objdump -section-headers %t10 | \
+# RUN:   FileCheck -check-prefix=SEC-NOSUBSET %s
+
+# PHDRS-NOSUBSET:      ProgramHeaders [
+# PHDRS-NOSUBSET-NEXT:   ProgramHeader {
+# PHDRS-NOSUBSET-NEXT:     Type: PT_PHDR
+# PHDRS-NOSUBSET-NEXT:     Offset: 0x1000
+# PHDRS-NOSUBSET-NEXT:     VirtualAddress: 0x11000
+# PHDRS-NOSUBSET-NEXT:     PhysicalAddress: 0x11000
+# PHDRS-NOSUBSET-NEXT:     FileSize: 46
+# PHDRS-NOSUBSET-NEXT:     MemSize: 46
+# PHDRS-NOSUBSET-NEXT:     Flags [ (0x7)
+# PHDRS-NOSUBSET-NEXT:       PF_R (0x4)
+# PHDRS-NOSUBSET-NEXT:       PF_W (0x2)
+# PHDRS-NOSUBSET-NEXT:       PF_X (0x1)
+# PHDRS-NOSUBSET-NEXT:     ]
+# PHDRS-NOSUBSET-NEXT:     Alignment: 4096
+# PHDRS-NOSUBSET-NEXT:   }
+# PHDRS-NOSUBSET-NEXT:   ProgramHeader {
+# PHDRS-NOSUBSET-NEXT:     Type: PT_LOAD
+# PHDRS-NOSUBSET-NEXT:     Offset: 0x1000
+# PHDRS-NOSUBSET-NEXT:     VirtualAddress: 0x11000
+# PHDRS-NOSUBSET-NEXT:     PhysicalAddress: 0x11000
+# PHDRS-NOSUBSET-NEXT:     FileSize: 46
+# PHDRS-NOSUBSET-NEXT:     MemSize: 46
+# PHDRS-NOSUBSET-NEXT:     Flags [ (0x7)
+# PHDRS-NOSUBSET-NEXT:       PF_R (0x4)
+# PHDRS-NOSUBSET-NEXT:       PF_W (0x2)
+# PHDRS-NOSUBSET-NEXT:       PF_X (0x1)
+# PHDRS-NOSUBSET-NEXT:     ]
+# PHDRS-NOSUBSET-NEXT:     Alignment: 4096
+# PHDRS-NOSUBSET-NEXT:   }
+# PHDRS-NOSUBSET-NEXT:   ProgramHeader {
+# PHDRS-NOSUBSET-NEXT:     Type: PT_LOAD
+# PHDRS-NOSUBSET-NEXT:     Offset: 0x2000
+# PHDRS-NOSUBSET-NEXT:     VirtualAddress: 0x12000
+# PHDRS-NOSUBSET-NEXT:     PhysicalAddress: 0x12000
+# PHDRS-NOSUBSET-NEXT:     FileSize: 0
+# PHDRS-NOSUBSET-NEXT:     MemSize: 2
+# PHDRS-NOSUBSET-NEXT:     Flags [ (0x6)
+# PHDRS-NOSUBSET-NEXT:       PF_R (0x4)
+# PHDRS-NOSUBSET-NEXT:       PF_W (0x2)
+# PHDRS-NOSUBSET-NEXT:     ]
+# PHDRS-NOSUBSET-NEXT:     Alignment: 4096
+# PHDRS-NOSUBSET-NEXT:   }
+# PHDRS-NOSUBSET-NEXT: ]
+
+#              Idx Name          Size         Address
+# SEC-NOSUBSET: 1 .text         0000000e 0000000000011000
+# SEC-NOSUBSET: 2 .data         00000020 000000000001100e
+# SEC-NOSUBSET: 3 .bss          00000002 0000000000012000
+
+# Check unused headers are filled,
+# plus check all header types are allowed.
+# RUN: echo "PHDRS { \
+# RUN:   null PT_NULL; \
+# RUN:   load PT_LOAD; \
+# RUN:   dynamic PT_DYNAMIC; \
+# RUN:   interp PT_INTERP; \
+# RUN:   note PT_NOTE; \
+# RUN:   shlib PT_SHLIB; \
+# RUN:   phdr PT_PHDR; \
+# RUN: } \
+# RUN: SECTIONS { \
+# RUN:   .text : { *(.text) } :load \
+# RUN:   .data : { *(.data) } \
+# RUN:   .bss : { *(.bss) } \
+# RUN: }" > %t.script
+# RUN: ld.lld -o %t11 --script %t.script %t
+# RUN: llvm-readobj -program-headers %t11 | \
+# RUN:   FileCheck -check-prefix=PHDRS-UNUSED %s
+
+# PHDRS-UNUSED:      ProgramHeaders [
+# PHDRS-UNUSED-NEXT:   ProgramHeader {
+# PHDRS-UNUSED-NEXT:     Type: PT_NULL
+# PHDRS-UNUSED-NEXT:     Offset: 0x0
+# PHDRS-UNUSED-NEXT:     VirtualAddress: 0x0
+# PHDRS-UNUSED-NEXT:     PhysicalAddress: 0x0
+# PHDRS-UNUSED-NEXT:     FileSize: 0
+# PHDRS-UNUSED-NEXT:     MemSize: 0
+# PHDRS-UNUSED-NEXT:     Flags [ (0x0)
+# PHDRS-UNUSED-NEXT:     ]
+# PHDRS-UNUSED-NEXT:     Alignment: 4096
+# PHDRS-UNUSED-NEXT:   }
+# PHDRS-UNUSED-NEXT:   ProgramHeader {
+# PHDRS-UNUSED-NEXT:     Type: PT_LOAD
+# PHDRS-UNUSED-NEXT:     Offset: 0x1000
+# PHDRS-UNUSED-NEXT:     VirtualAddress: 0x11000
+# PHDRS-UNUSED-NEXT:     PhysicalAddress: 0x11000
+# PHDRS-UNUSED-NEXT:     FileSize: 46
+# PHDRS-UNUSED-NEXT:     MemSize: 48
+# PHDRS-UNUSED-NEXT:     Flags [ (0x7)
+# PHDRS-UNUSED-NEXT:       PF_R (0x4)
+# PHDRS-UNUSED-NEXT:       PF_W (0x2)
+# PHDRS-UNUSED-NEXT:       PF_X (0x1)
+# PHDRS-UNUSED-NEXT:     ]
+# PHDRS-UNUSED-NEXT:     Alignment: 4096
+# PHDRS-UNUSED-NEXT:   }
+# PHDRS-UNUSED-NEXT:   ProgramHeader {
+# PHDRS-UNUSED-NEXT:     Type: PT_DYNAMIC
+# PHDRS-UNUSED-NEXT:     Offset: 0x102E
+# PHDRS-UNUSED-NEXT:     VirtualAddress: 0x0
+# PHDRS-UNUSED-NEXT:     PhysicalAddress: 0x0
+# PHDRS-UNUSED-NEXT:     FileSize: 0
+# PHDRS-UNUSED-NEXT:     MemSize: 0
+# PHDRS-UNUSED-NEXT:     Flags [ (0x0)
+# PHDRS-UNUSED-NEXT:     ]
+# PHDRS-UNUSED-NEXT:     Alignment: 4096
+# PHDRS-UNUSED-NEXT:   }
+# PHDRS-UNUSED-NEXT:   ProgramHeader {
+# PHDRS-UNUSED-NEXT:     Type: PT_INTERP
+# PHDRS-UNUSED-NEXT:     Offset: 0x102E
+# PHDRS-UNUSED-NEXT:     VirtualAddress: 0x0
+# PHDRS-UNUSED-NEXT:     PhysicalAddress: 0x0
+# PHDRS-UNUSED-NEXT:     FileSize: 0
+# PHDRS-UNUSED-NEXT:     MemSize: 0
+# PHDRS-UNUSED-NEXT:     Flags [ (0x0)
+# PHDRS-UNUSED-NEXT:     ]
+# PHDRS-UNUSED-NEXT:     Alignment: 4096
+# PHDRS-UNUSED-NEXT:   }
+# PHDRS-UNUSED-NEXT:   ProgramHeader {
+# PHDRS-UNUSED-NEXT:     Type: PT_NOTE
+# PHDRS-UNUSED-NEXT:     Offset: 0x102E
+# PHDRS-UNUSED-NEXT:     VirtualAddress: 0x0
+# PHDRS-UNUSED-NEXT:     PhysicalAddress: 0x0
+# PHDRS-UNUSED-NEXT:     FileSize: 0
+# PHDRS-UNUSED-NEXT:     MemSize: 0
+# PHDRS-UNUSED-NEXT:     Flags [ (0x0)
+# PHDRS-UNUSED-NEXT:     ]
+# PHDRS-UNUSED-NEXT:     Alignment: 4096
+# PHDRS-UNUSED-NEXT:   }
+# PHDRS-UNUSED-NEXT:   ProgramHeader {
+# PHDRS-UNUSED-NEXT:     Type: PT_SHLIB
+# PHDRS-UNUSED-NEXT:     Offset: 0x102E
+# PHDRS-UNUSED-NEXT:     VirtualAddress: 0x0
+# PHDRS-UNUSED-NEXT:     PhysicalAddress: 0x0
+# PHDRS-UNUSED-NEXT:     FileSize: 0
+# PHDRS-UNUSED-NEXT:     MemSize: 0
+# PHDRS-UNUSED-NEXT:     Flags [ (0x0)
+# PHDRS-UNUSED-NEXT:     ]
+# PHDRS-UNUSED-NEXT:     Alignment: 4096
+# PHDRS-UNUSED-NEXT:   }
+# PHDRS-UNUSED-NEXT:   ProgramHeader {
+# PHDRS-UNUSED-NEXT:     Type: PT_PHDR
+# PHDRS-UNUSED-NEXT:     Offset: 0x102E
+# PHDRS-UNUSED-NEXT:     VirtualAddress: 0x0
+# PHDRS-UNUSED-NEXT:     PhysicalAddress: 0x0
+# PHDRS-UNUSED-NEXT:     FileSize: 0
+# PHDRS-UNUSED-NEXT:     MemSize: 0
+# PHDRS-UNUSED-NEXT:     Flags [ (0x0)
+# PHDRS-UNUSED-NEXT:     ]
+# PHDRS-UNUSED-NEXT:     Alignment: 4096
+# PHDRS-UNUSED-NEXT:   }
+# PHDRS-UNUSED-NEXT: ]
+
+.globl _start;
+_start:
+    mov $60, %rax
+    mov $42, %rdi
+
+.section .data,"aw"
+.quad 10, 10, 20, 20
+.section .bss,"",@nobits
+.short 0