[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});

328

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

329

for (;;) for consistency.

ELF/Writer.cpp

1157

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

1038

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

1042

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

1042

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

[ruiu]

ELF/Writer.cpp

1061

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

44

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

105–106

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

1038–1055

Please add a function comment.

1042

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

1060–1076

This also needs a function comment.

1078–1091

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

1042

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

58

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

107

Ditto

1068

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

1072–1073

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

1093–1104

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

1068

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

1176

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()) {

1217

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

1469

There should be brackets I think:

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

[denis-protivensky]

ELF/Writer.cpp

1176

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.

1217

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.

1469

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

[grimar]

ELF/Writer.cpp

1176

(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.

1217

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

1469

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;
+};
+
 // This struct contains the global configuration for the linker.
 // Most fields are direct mapping from the command line options
 // and such fields have the same name as the corresponding options.
 // Most fields are initialized by the driver.
 struct Configuration {
   SymbolBody *EntrySym = nullptr;
   SymbolBody *MipsGpDisp = 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("}")) {
+    StringRef Name = next();
+    uint32_t Type = readPhdrType();
+    Config->Phdrs.emplace_back(Phdr{Name, Type});
+    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 as zero or more tokens in the form of ':phdr'.
+  for (;;) {
+    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 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 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);
+  bool updatePhdrsForSection(std::vector<StringRef> &PhdrNames,
+                             StringRef SecName) const;
+  std::vector<size_t> getIndicesForPhdrs(const std::vector<StringRef> &Phdrs,
+                                         StringRef SecName) const;
+  void fillUnusedPhdrs(const std::vector<size_t> &PhdrInds);
+  void layoutCustomPhdrs(uintX_t &VA, uintX_t &FileOff);
   void assignAddresses();
   void buildSectionMap();
+  void buildPhdrMap();
   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();
private:
   bool HasRelro = false;
   SymbolTable<ELFT> &Symtab;
   std::vector<Elf_Phdr> Phdrs;
 
   uintX_t FileSize;
   uintX_t SectionHeaderOff;
 
   llvm::StringMap<llvm::StringRef> InputToOutputSection;
+  // Mappings to support linker script's PHDRS command.
+  llvm::StringMap<std::vector<llvm::StringRef>> OutputSectionToPhdrs;
+  llvm::SmallMapVector<llvm::StringRef, std::vector<size_t>, 8>
+      PhdrNameToIndices;
 };
 } // 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.
template <class ELFT> void 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();
   addReservedSymbols();
   createSections();
   assignAddresses();
   fixAbsoluteSymbols();
   openFile(Config->OutputFile);
   writeHeader();
static uint32_t getAmdgpuPhdr(OutputSectionBase<ELFT> *Sec) {
   uint32_t Flags = Sec->getFlags();
   if (Flags & SHF_AMDGPU_HSA_CODE)
     return PT_AMDGPU_HSA_LOAD_CODE_AGENT;
   if ((Flags & SHF_AMDGPU_HSA_GLOBAL) && !(Flags & SHF_AMDGPU_HSA_AGENT))
     return PT_AMDGPU_HSA_LOAD_GLOBAL_PROGRAM;
   return PT_LOAD;
 }
 
+// Returns true if PHDRS command with headers is defined in linker script.
+static bool hasCustomPhdrs() { return !Config->Phdrs.empty(); }
+
+// Filter all occasions of 'NONE' header out of the list of headers.
+static void filterNonePhdr(std::vector<StringRef> &Phdrs) {
+  Phdrs.erase(std::remove(std::begin(Phdrs), std::end(Phdrs), "NONE"),
+              std::end(Phdrs));
+}
+
+// Check if set of names is a subset of another set.
+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,
                                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;
 }
 
+// Update headers for given output section and return true if headers
+// have changed. It also filters out 'NONE' header from the list.
+template <class ELFT>
+bool Writer<ELFT>::updatePhdrsForSection(std::vector<StringRef> &PhdrNames,
+                                         StringRef SecName) const {
+  bool NewPhdrs = false;
+  const std::vector<StringRef> &NewPhdrNames =
+      OutputSectionToPhdrs.lookup(SecName);
+  if (!NewPhdrNames.empty()) {
+    // Headers really changed if they are not a direct subset
+    // of the previous set of headers.
+    NewPhdrs = !isSubset(PhdrNames, NewPhdrNames);
+    PhdrNames = NewPhdrNames;
+  }
+  // Filter out 'NONE' header and check if something left.
+  filterNonePhdr(PhdrNames);
+  if (PhdrNames.empty())
+    NewPhdrs = false;
+
+  return NewPhdrs;
+}
+
+// Form the list of indices for given header names to simplify future access.
+// Check for non-existent header names and issue error in such a case.
+template <class ELFT>
+std::vector<size_t>
+Writer<ELFT>::getIndicesForPhdrs(const std::vector<StringRef> &Phdrs,
+                                 StringRef SecName) const {
+  std::vector<size_t> PhdrInds;
+  for (StringRef Name : Phdrs) {
+    auto It = PhdrNameToIndices.find(Name);
+    if (It == std::end(PhdrNameToIndices))
+      error("Output section " + SecName + " assigned to non-existent header " +
+            Name);
+    PhdrInds.insert(std::end(PhdrInds), std::begin(It->second),
+                    std::end(It->second));
+  }
+  return PhdrInds;
+}
+
+// Fill in not used headers with reasonable default values.
+template <class ELFT>
+void Writer<ELFT>::fillUnusedPhdrs(const std::vector<size_t> &PhdrInds) {
+  for (size_t Ind : PhdrInds) {
+    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());
+  }
+}
+
+// Assign output sections to headers specified in linker script's PHDRS command.
+// For each output section find headers to assign to.
+// Set parameters for each header and for sections that are assigned to these
+// headers.
+// Fill unused headers with default values setting only proper file offset
+// and type.
+template <class ELFT>
+void Writer<ELFT>::layoutCustomPhdrs(uintX_t &VA, uintX_t &FileOff) {
+  SmallMapVector<StringRef, std::vector<size_t>, 8> PhdrsToFill =
+      PhdrNameToIndices;
+  std::vector<StringRef> PhdrNames;
+  bool NewPhdrs = false;
+
+  // Find appropriate headers for the first output section.
+  for (OutputSectionBase<ELFT> *Sec : OutputSections) {
+    NewPhdrs = updatePhdrsForSection(PhdrNames, Sec->getName());
+    if (NewPhdrs)
+      break;
+  }
+  if (!NewPhdrs)
+    error("No sections assigned to PHDRS");
+
+  for (OutputSectionBase<ELFT> *Sec : OutputSections) {
+    if (!NewPhdrs)
+      NewPhdrs = updatePhdrsForSection(PhdrNames, Sec->getName());
+
+    std::vector<size_t> PhdrInds =
+        getIndicesForPhdrs(PhdrNames, Sec->getName());
+    if (needsPhdr<ELFT>(Sec)) {
+      if (NewPhdrs) {
+        VA = align(VA, Target->getPageSize());
+        FileOff = align(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 = align(VA, Sec->getAlign());
+      Sec->setVA(VA);
+      VA += Sec->getSize();
+    }
+
+    NewPhdrs = false;
+    FileOff = align(FileOff, Sec->getAlign());
+    Sec->setFileOffset(FileOff);
+    if (Sec->getType() != SHT_NOBITS)
+      FileOff += Sec->getSize();
+    if (needsPhdr<ELFT>(Sec)) {
+      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, std::vector<size_t>> &p : PhdrsToFill)
+    fillUnusedPhdrs(p.second);
+}
+
 // 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())
+    layoutCustomPhdrs(VA, FileOff);
+  else {
+    // The first phdr entry is PT_PHDR which describes the program header
+    // itself.
+    size_t PhdrSize = sizeof(Elf_Phdr) * Phdrs.size();
     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{};
     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) {
           VA = align(VA, Target->getPageSize());
           FileOff = align(FileOff, Target->getPageSize());
           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);
+          uint32_t PTType = (Config->EMachine != EM_AMDGPU)
+                                ? (uint32_t)PT_LOAD
           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 = align(VA, Sec->getAlign());
           uintX_t TVA = align(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 = align(VA, Sec->getAlign());
           Sec->setVA(VA);
           VA += Sec->getSize();
           if (InRelRo)
             updateRelro(PH, &GnuRelroPhdr, VA);
         }
       }
 
       FileOff = align(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 = align(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);
     }
+  }
 
   // Add space for section headers.
   SectionHeaderOff = align(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 {
+  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 elf2::writeResult<ELF32LE>(SymbolTable<ELF32LE> *Symtab);
 template void elf2::writeResult<ELF32BE>(SymbolTable<ELF32BE> *Symtab);
 template void elf2::writeResult<ELF64LE>(SymbolTable<ELF64LE> *Symtab);
 template void 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
+
+# Error if sections are not assigned to any headers.
+# RUN: echo "PHDRS { \
+# RUN:   load PT_LOAD; \
+# RUN: } \
+# RUN: SECTIONS { \
+# RUN:   .text : { *(.text) } \
+# RUN: }" > %t.script
+# RUN: not ld.lld -o %t1 --script %t.script %t > %t.log 2>&1
+# RUN: FileCheck -check-prefix=PHDRS-NOTASSIGNED %s < %t.log
+
+# PHDRS-NOTASSIGNED: No sections assigned to PHDRS
+
+# Error if sections are assigned to only 'NONE' header.
+# RUN: echo "PHDRS { \
+# RUN:   load PT_LOAD; \
+# RUN: } \
+# RUN: SECTIONS { \
+# RUN:   .text : { *(.text) } :NONE \
+# RUN: }" > %t.script
+# RUN: not ld.lld -o %t1 --script %t.script %t > %t.log 2>&1
+# RUN: FileCheck -check-prefix=PHDRS-NOTASSIGNED %s < %t.log
+
+# 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 one header skipping 'NONE' header
+# if it's not the only available.
+# RUN: echo "PHDRS { \
+# RUN:   load PT_LOAD; \
+# RUN: } \
+# RUN: SECTIONS { \
+# RUN:   .text : { *(.text) } :load :NONE \
+# RUN: }" > %t.script
+# RUN: ld.lld -o %t2_2 --script %t.script %t
+# RUN: llvm-readobj -program-headers %t2_2 | \
+# RUN:   FileCheck -check-prefix=PHDRS-ONE-ALL %s
+# RUN: llvm-objdump -section-headers %t2_2 | \
+# 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 000000000001100e
+# 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