[lld][LinkerScript] Consider order of headers in PHDRS command

[denis-protivensky]

Summary

Sort segments according to their order in PHDRS command.
Handle first load segment containing ELF and program headers.
Discard ELF and program headers if not set by PT_PHDR or first PT_LOAD segment in PHDRS command.

Test cases are included.

[rafaelauler]

Is it an error in gnu ld to have two output sections with the same name? I'm not sure if it is. IIRC, I remember Rafael specifically relying on the ability to have multiple sections with the same name in order to reduce the final binary size.

[denis-protivensky]

Rafael, you're right. There may be more than one output section description with the same name. But headers in PHDRS command should have unique names, so I'll leave only check for duplicate header names.

[denis-protivensky]

Updated:

• Remove check for duplicate names of output sections.

[rafaelauler]

LGTM

[denis-protivensky]

Rafael, thanks for the effort, but I have to abandon this one since the implemented logic is partially wrong. I might re-implement it, but it's more likely to appear in the new linker some time later.

include/lld/Core/Error.h

enum class LinkerScriptReaderError {
   success = 0,
   parse_error,
   unknown_symbol_in_expr,
   unrecognized_function_in_expr,
   unknown_phdr_ids,
   extra_program_phdr,
   misplaced_program_phdr,
   program_phdr_wrong_phdrs,
+  load_phdr_wrong_attr,
+  duplicate_name,
 };
 
 inline std::error_code make_error_code(LinkerScriptReaderError e) {
   return std::error_code(static_cast<int>(e), LinkerScriptReaderCategory());
 }
 
 /// Creates an error_code object that has associated with it an arbitrary
 /// error messsage.  The value() of the error_code will always be non-zero

include/lld/ReaderWriter/LinkerScript.h

 #ifndef LLD_READER_WRITER_LINKER_SCRIPT_H
 #define LLD_READER_WRITER_LINKER_SCRIPT_H
 
 #include "lld/Core/Error.h"
 #include "lld/Core/LLVM.h"
 #include "lld/Core/range.h"
 #include "llvm/ADT/DenseSet.h"
 #include "llvm/ADT/DenseMap.h"
+#include "llvm/ADT/MapVector.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/StringMap.h"
 #include "llvm/ADT/StringSet.h"
 #include "llvm/ADT/StringSwitch.h"
 #include "llvm/Support/Allocator.h"
 #include "llvm/Support/MemoryBuffer.h"
 #include "llvm/Support/SourceMgr.h"
 #include "llvm/Support/raw_ostream.h"
public:
   uint64_t getLinkerScriptExprValue(StringRef name) const;
 
   /// Check if there are custom headers available.
   bool hasPHDRs() const;
 
   /// Retrieve all the headers the given output section is assigned to.
   std::vector<const PHDR *> getPHDRsForOutputSection(StringRef name) const;
 
+  /// Get the index of given header as it is in the PHDRS command.
+  int getIndexOfPHDR(const PHDR *phdr) const;
+
   /// Retrieve program header if available.
   const PHDR *getProgramPHDR() const;
 
   void dump() const;
 
 private:
   /// A custom hash operator to teach the STL how to handle our custom keys.
   /// This will be used in our hash table mapping Sections to a Layout Order
private:
   /// Compare two sections that have the same mapping rule (i.e., are matched
   /// by the same InputSectionsCmd).
   /// Determine if lhs < rhs by analyzing the InputSectionsCmd structure.
   bool localCompare(int order, const SectionKey &lhs,
                     const SectionKey &rhs) const;
 
   /// Convert the PHDRS command into map of names to headers.
   /// Determine program header during processing.
-  std::error_code collectPHDRs(const PHDRS *ph,
-                               llvm::StringMap<const PHDR *> &phdrs);
+  std::error_code collectPHDRs(const PHDRS *ph);
 
   /// Build map that matches output section names to segments they should be
   /// put into.
-  std::error_code buildSectionToPHDR(llvm::StringMap<const PHDR *> &phdrs);
+  std::error_code buildSectionToPHDR();
 
   /// Our goal with all linearizeAST overloaded functions is to
   /// traverse the linker script AST while putting nodes in a vector and
   /// thus enforcing order among nodes (which comes first).
   ///
   /// The order among nodes is determined by their indexes in this vector
   /// (_layoutCommands). This index allows us to solve the problem of
   /// establishing the order among two different input sections: we match each
private:
   std::vector<const Command *> _layoutCommands;
   std::unordered_multimap<std::string, int> _memberToLayoutOrder;
   std::vector<std::pair<StringRef, int>> _memberNameWildcards;
   mutable std::unordered_map<SectionKey, int, SectionKeyHash, SectionKeyEq>
       _cacheSectionOrder, _cacheExpressionOrder;
   llvm::DenseSet<int> _deliveredExprs;
   mutable llvm::StringSet<> _definedSymbols;
 
+  llvm::MapVector<StringRef, const PHDR *, llvm::StringMap<unsigned>,
+                  llvm::SmallVector<std::pair<StringRef, const PHDR *>, 8>>
+      _phdrs;
   llvm::StringMap<llvm::SmallVector<const PHDR *, 2>> _sectionToPHDR;
   const PHDR *_programPHDR;
 
   Expression::SymbolTableTy _symbolTable;
 };
 
 llvm::BumpPtrAllocator &Command::getAllocator() const {
   return _ctx.getAllocator();
 }
 llvm::BumpPtrAllocator &Expression::getAllocator() const {
   return _ctx.getAllocator();
 }
 } // end namespace script
 } // end namespace lld
 
 #endif

lib/Core/Error.cpp

std::string message(int ev) const override {
     case LinkerScriptReaderError::unknown_phdr_ids:
       return "Unknown header identifiers (missing in PHDRS command) are used";
     case LinkerScriptReaderError::extra_program_phdr:
       return "Extra program header is found";
     case LinkerScriptReaderError::misplaced_program_phdr:
       return "Program header must precede load segments";
     case LinkerScriptReaderError::program_phdr_wrong_phdrs:
       return "Program header has invalid PHDRS attribute";
+    case LinkerScriptReaderError::load_phdr_wrong_attr:
+      return "Load header has wrong attributes";
+    case LinkerScriptReaderError::duplicate_name:
+      return "Duplicate name is found";
     }
     llvm_unreachable("An enumerator of LinkerScriptReaderError does not have a "
                      "message defined.");
   }
 };
 
 const std::error_category &lld::LinkerScriptReaderCategory() {
   static _LinkerScriptReaderErrorCategory o;

lib/ReaderWriter/ELF/HeaderChunks.h

int getContentType() const override {
     return Chunk<ELFT>::ContentType::Header;
   }
 
   void write(ELFWriter *writer, TargetLayout<ELFT> &layout,
              llvm::FileOutputBuffer &buffer) override;
 
   void finalize() override;
 
+  bool isDiscarded() const { return _discard; }
+  void setDiscarded(bool discard) { _discard = discard; }
+
 private:
   Elf_Ehdr _eh;
+  bool _discard = true;
 };
 
 /// \brief An ProgramHeader represents the Elf[32/64]_Phdr structure at the
 ///        start of an ELF executable file.
 template<class ELFT>
 class ProgramHeader : public Chunk<ELFT> {
 public:
   typedef llvm::object::Elf_Phdr_Impl<ELFT> Elf_Phdr;
public:
 
   int64_t entsize() { return sizeof(Elf_Phdr); }
   int64_t numHeaders() { return _ph.size();  }
 
   int getContentType() const override {
     return Chunk<ELFT>::ContentType::Header;
   }
 
+  bool isDiscarded() const { return _discard; }
+  void setDiscarded(bool discard) { _discard = discard; }
+
 private:
   Elf_Phdr *allocateProgramHeader(bool &allocatedNew);
 
   std::vector<Elf_Phdr *> _ph;
   PhIterT _phi;
   llvm::BumpPtrAllocator _allocator;
+  bool _discard = true;
 };
 
 /// \brief An SectionHeader represents the Elf[32/64]_Shdr structure
 /// at the end of the file
 template<class ELFT>
 class SectionHeader : public Chunk<ELFT> {
 public:
   typedef llvm::object::Elf_Shdr_Impl<ELFT> Elf_Shdr;

lib/ReaderWriter/ELF/OutputELFWriter.cpp

std::error_code OutputELFWriter<ELFT>::writeOutput(const File &file,
   // HACK: We have to write out the header and program header here even though
   // they are a member of a segment because only sections are written in the
   // following loop.
 
   // Finalize ELF Header / Program Headers.
   _elfHeader->finalize();
   _programHeader->finalize();
 
+  if (!_elfHeader->isDiscarded())
     _elfHeader->write(this, _layout, *buffer);
+  if (!_programHeader->isDiscarded())
     _programHeader->write(this, _layout, *buffer);
 
   auto sections = _layout.sections();
   parallel_for_each(
       sections.begin(), sections.end(),
       [&](Chunk<ELFT> *section) { section->write(this, _layout, *buffer); });
   writeTask.end();
 
   ScopedTask commitTask(getDefaultDomain(), "ELF Writer commit to disk");

lib/ReaderWriter/ELF/TargetLayout.h

struct SectionKeyEq {
     }
   };
 
   typedef typename std::vector<Chunk<ELFT> *>::iterator ChunkIter;
   typedef typename std::vector<Segment<ELFT> *>::iterator SegmentIter;
 
   // Properties used during segment creation
   struct SegmentKey {
-    SegmentKey(StringRef name, int64_t type, uint64_t flags, bool segFlags)
-        : _name(name), _type(type), _flags(flags),
-          _segmentFlags(segFlags && flags != 0) {}
+    SegmentKey(StringRef name, int64_t type, uint64_t flags,
+               const script::PHDR *phdr = nullptr)
+        : _name(name), _type(type), _flags(flags), _phdr(phdr) {
+      assert((!_phdr || _phdr->flags() == _flags) &&
+             "Flags should equal segment flags if PHDR is set");
+    }
+    bool hasSegmentFlags() const { return _phdr != nullptr && _flags != 0; }
+
     StringRef _name = "";
     int64_t _type = 0;
     uint64_t _flags = 0;
-    bool _segmentFlags = false;
+    const script::PHDR *_phdr = nullptr;
   };
 
   struct SegmentKeyHash {
     int64_t operator()(const SegmentKey &k) const {
       return llvm::hash_combine(k._name, k._type, k._flags);
     }
   };
 

lib/ReaderWriter/ELF/TargetLayout.cpp

 template <class ELFT>
 std::vector<typename TargetLayout<ELFT>::SegmentKey>
 TargetLayout<ELFT>::getSegmentsForSection(const OutputSection<ELFT> *os,
                                           const Section<ELFT> *sec) const {
   std::vector<SegmentKey> segKeys;
   auto phdrs = _linkerScriptSema.getPHDRsForOutputSection(os->name());
   if (!phdrs.empty()) {
     if (phdrs.size() == 1 && phdrs[0]->isNone()) {
-      segKeys.emplace_back("NONE", llvm::ELF::PT_NULL, 0, false);
+      segKeys.emplace_back("NONE", llvm::ELF::PT_NULL, 0, phdrs[0]);
       return segKeys;
     }
 
     for (auto phdr : phdrs) {
-      segKeys.emplace_back(phdr->name(), phdr->type(), phdr->flags(), true);
+      segKeys.emplace_back(phdr->name(), phdr->type(), phdr->flags(), phdr);
     }
     return segKeys;
   }
 
   uint64_t flags = getLookupSectionFlags(os);
   int64_t segmentType = getSegmentType(sec);
   StringRef segmentName = sec->segmentKindToStr();
 
   // We need a separate segment for sections that don't have
   // the segment type to be PT_LOAD
   if (segmentType != llvm::ELF::PT_LOAD)
-    segKeys.emplace_back(segmentName, segmentType, flags, false);
+    segKeys.emplace_back(segmentName, segmentType, flags);
 
   if (segmentType == llvm::ELF::PT_NULL)
     return segKeys;
 
   // If the output magic is set to OutputMagic::NMAGIC or
   // OutputMagic::OMAGIC, Place the data alongside text in one single
   // segment
   ELFLinkingContext::OutputMagic outputMagic = _ctx.getOutputMagic();
   if (outputMagic == ELFLinkingContext::OutputMagic::NMAGIC ||
       outputMagic == ELFLinkingContext::OutputMagic::OMAGIC)
     flags =
         llvm::ELF::SHF_EXECINSTR | llvm::ELF::SHF_ALLOC | llvm::ELF::SHF_WRITE;
 
-  segKeys.emplace_back("LOAD", llvm::ELF::PT_LOAD, flags, false);
+  segKeys.emplace_back("LOAD", llvm::ELF::PT_LOAD, flags);
   return segKeys;
 }
 
 template <class ELFT>
 uint64_t
 TargetLayout<ELFT>::getLookupSectionFlags(const OutputSection<ELFT> *os) const {
   uint64_t flags = os->flags();
   if (!(flags & llvm::ELF::SHF_WRITE) && _ctx.mergeRODataToTextSegment())
for (auto section : osi->sections()) {
                                                                     nullptr);
         std::pair<typename SegmentMapT::iterator, bool> segmentInsert(
             _segmentMap.insert(currentSegment));
         Segment<ELFT> *segment;
         if (!segmentInsert.second) {
           segment = segmentInsert.first->second;
         } else {
           segment = new (_allocator) Segment<ELFT>(_ctx, key._name, key._type);
-          if (key._segmentFlags)
+          if (key.hasSegmentFlags())
             segment->setSegmentFlags(key._flags);
           segmentInsert.first->second = segment;
           _segments.push_back(segment);
         }
         if (key._type == llvm::ELF::PT_LOAD) {
           // Insert chunks with linker script expressions that occur at this
           // point, just before appending a new input section
           addExtraChunksToSegment(segment, section->archivePath(),
                                   section->memberPath(),
                                   section->inputSectionName());
         }
         segment->append(section);
       }
     }
   }
 
   // Default values if no linker script is available
   bool hasProgramSegment = _ctx.isDynamic() && !_ctx.isDynamicLibrary();
   bool hasElfHeader = true;
   bool hasProgramHeader = true;
   uint64_t segmentFlags = 0;
+  SegmentKey phdrKey("PHDR", llvm::ELF::PT_PHDR,
+                     llvm::ELF::PF_R | llvm::ELF::PF_X);
 
   // Check if linker script has PHDRS and program segment defined
   if (_linkerScriptSema.hasPHDRs()) {
     if (auto p = _linkerScriptSema.getProgramPHDR()) {
       hasProgramSegment = true;
       hasElfHeader = p->hasFileHdr();
       hasProgramHeader = p->hasPHDRs();
       segmentFlags = p->flags();
+      phdrKey = SegmentKey(p->name(), p->type(), p->flags(), p);
     } else {
       hasProgramSegment = false;
       hasElfHeader = false;
       hasProgramHeader = false;
     }
   }
 
   if (hasProgramSegment) {
     Segment<ELFT> *segment = new (_allocator) ProgramHeaderSegment<ELFT>(_ctx);
+    _segmentMap.insert(std::make_pair(phdrKey, segment));
     _segments.push_back(segment);
     if (segmentFlags)
       segment->setSegmentFlags(segmentFlags);
-    if (hasElfHeader)
+    if (hasElfHeader) {
       segment->append(_elfHeader);
-    if (hasProgramHeader)
+      _elfHeader->setDiscarded(false);
+    }
+    if (hasProgramHeader) {
       segment->append(_programHeader);
+      _programHeader->setDiscarded(false);
+    }
   }
 }
 
 template <class ELFT> void TargetLayout<ELFT>::sortSegments() {
   std::sort(_segments.begin(), _segments.end(), Segment<ELFT>::compareSegments);
 }
 
 template <class ELFT> void TargetLayout<ELFT>::assignVirtualAddress() {
   if (_segments.empty())
     return;
 
+  // Build map of segments to PHDRs for lookup
+  std::map<Segment<ELFT> *, const script::PHDR *> segmToPHDR;
+  if (_linkerScriptSema.hasPHDRs()) {
+    std::transform(_segmentMap.begin(), _segmentMap.end(),
+                   std::inserter(segmToPHDR, segmToPHDR.begin()),
+                   [](const std::pair<SegmentKey, Segment<ELFT> *> &p) {
+                     return std::make_pair(p.second, p.first._phdr);
+                   });
+    std::sort(_segments.begin(), _segments.end(),
+              [this, &segmToPHDR](Segment<ELFT> *a, Segment<ELFT> *b) {
+                const int ind_a =
+                    _linkerScriptSema.getIndexOfPHDR(segmToPHDR[a]);
+                const int ind_b =
+                    _linkerScriptSema.getIndexOfPHDR(segmToPHDR[b]);
+
+                // Compare missing segments in a usual way
+                if (ind_a < 0 || ind_b < 0)
+                  return Segment<ELFT>::compareSegments(a, b);
+
+                return ind_a < ind_b;
+              });
+  } else {
     sortSegments();
+  }
 
   uint64_t baseAddress = _ctx.getBaseAddress();
 
   // HACK: This is a super dirty hack. The elf header and program header are
   // not part of a section, but we need them to be loaded at the base address
   // so that AT_PHDR is set correctly by the loader and so they are accessible
   // at runtime. To do this we simply prepend them to the first loadable Segment
   // and let the layout logic take care of it.
   Segment<ELFT> *firstLoadSegment = nullptr;
   for (auto si : _segments) {
     if (si->segmentType() == llvm::ELF::PT_LOAD) {
       firstLoadSegment = si;
-      si->firstSection()->setAlign(si->alignment());
       break;
     }
   }
-  assert(firstLoadSegment != nullptr && "No loadable segment!");
+
+  // Default values if no linker script is available
+  bool hasElfHeader = true;
+  bool hasProgramHeader = true;
+  if (_linkerScriptSema.hasPHDRs()) {
+    if (auto loadSegment = segmToPHDR[firstLoadSegment]) {
+      hasElfHeader = loadSegment->hasFileHdr();
+      hasProgramHeader = loadSegment->hasPHDRs();
+    }
+  }
+
+  if (firstLoadSegment) {
+    firstLoadSegment->firstSection()->setAlign(firstLoadSegment->alignment());
+    if (hasProgramHeader) {
       firstLoadSegment->prepend(_programHeader);
+      _programHeader->setDiscarded(false);
+    }
+    if (hasElfHeader) {
       firstLoadSegment->prepend(_elfHeader);
+      _elfHeader->setDiscarded(false);
+    }
+  }
   bool newSegmentHeaderAdded = true;
   bool virtualAddressAssigned = false;
   bool fileOffsetAssigned = false;
   while (true) {
     for (auto si : _segments) {
       si->finalize();
       // Don't add PT_NULL segments into the program header
       if (si->segmentType() != llvm::ELF::PT_NULL)

lib/ReaderWriter/LinkerScript.cpp

Extern *Parser::parseExtern() {
 
   return new (_alloc) Extern(*this, symbols);
 }
 
 // Sema member functions
 Sema::Sema() : _programPHDR(nullptr) {}
 
 std::error_code Sema::perform() {
-  llvm::StringMap<const PHDR *> phdrs;
-
   for (auto &parser : _scripts) {
     for (const Command *c : parser->get()->_commands) {
       if (const auto *sec = dyn_cast<Sections>(c)) {
         linearizeAST(sec);
       } else if (const auto *ph = dyn_cast<PHDRS>(c)) {
-        if (auto ec = collectPHDRs(ph, phdrs))
+        if (auto ec = collectPHDRs(ph))
           return ec;
       }
     }
   }
-  return buildSectionToPHDR(phdrs);
+  return buildSectionToPHDR();
 }
 
 bool Sema::less(const SectionKey &lhs, const SectionKey &rhs) const {
   int a = getLayoutOrder(lhs, true);
   int b = getLayoutOrder(rhs, true);
 
   if (a != b) {
     if (a < 0)

 
 bool Sema::hasPHDRs() const { return !_sectionToPHDR.empty(); }
 
 std::vector<const PHDR *> Sema::getPHDRsForOutputSection(StringRef name) const {
   auto vec = _sectionToPHDR.lookup(name);
   return std::vector<const PHDR *>(std::begin(vec), std::end(vec));
 }
 
+int Sema::getIndexOfPHDR(const PHDR *phdr) const {
+  if (!phdr || phdr->isNone())
+    return -1;
+  auto it = _phdrs.find(phdr->name());
+  return it == std::end(_phdrs) ? -1
+                                : (int)std::distance(std::begin(_phdrs), it);
+}
+
 const PHDR *Sema::getProgramPHDR() const { return _programPHDR; }
 
 void Sema::dump() const {
   raw_ostream &os = llvm::outs();
   os << "Linker script semantics dump\n";
   int num = 0;
   for (auto &parser : _scripts) {
     os << "Dumping script #" << ++num << ":\n";
for (const InputSection *inputSection : *cmd) {
     return compareSortedNames(sortedGroup->sortMode(), lhs.sectionName,
                               rhs.sectionName);
   }
 
   llvm_unreachable("");
   return false;
 }
 
-std::error_code Sema::collectPHDRs(const PHDRS *ph,
-                                   llvm::StringMap<const PHDR *> &phdrs) {
+std::error_code Sema::collectPHDRs(const PHDRS *ph) {
   bool loadFound = false;
   for (auto *p : *ph) {
-    phdrs[p->name()] = p;
+    if (_phdrs.count(p->name()))
+      return LinkerScriptReaderError::duplicate_name;
+    _phdrs[p->name()] = p;
 
     switch (p->type()) {
     case llvm::ELF::PT_PHDR:
       if (_programPHDR != nullptr)
         return LinkerScriptReaderError::extra_program_phdr;
       if (loadFound)
         return LinkerScriptReaderError::misplaced_program_phdr;
       if (!p->hasPHDRs())
         return LinkerScriptReaderError::program_phdr_wrong_phdrs;
       _programPHDR = p;
       break;
     case llvm::ELF::PT_LOAD:
       // Program header, if available, should have program header table
       // mapped in the first loadable segment.
       if (!loadFound && _programPHDR && !p->hasPHDRs())
         return LinkerScriptReaderError::program_phdr_wrong_phdrs;
+      // Only first load PHDR may have ELF and/or program headers defined
+      if (loadFound && (p->hasFileHdr() || p->hasPHDRs()))
+        return LinkerScriptReaderError::load_phdr_wrong_attr;
       loadFound = true;
       break;
     }
   }
   return std::error_code();
 }
 
-std::error_code Sema::buildSectionToPHDR(llvm::StringMap<const PHDR *> &phdrs) {
-  const bool noPhdrs = phdrs.empty();
+std::error_code Sema::buildSectionToPHDR() {
+  const bool noPhdrs = _phdrs.empty();
 
   // Add NONE header to the map provided there's no user-defined
   // header with the same name.
-  if (!phdrs.count(PHDR_NONE.name()))
-    phdrs[PHDR_NONE.name()] = &PHDR_NONE;
+  if (!_phdrs.count(PHDR_NONE.name()))
+    _phdrs[PHDR_NONE.name()] = &PHDR_NONE;
 
   // Match output sections to available headers.
   llvm::SmallVector<const PHDR *, 2> phdrsCur, phdrsLast { &PHDR_NONE };
   for (const Command *cmd : _layoutCommands) {
     auto osd = dyn_cast<OutputSectionDescription>(cmd);
     if (!osd || osd->isDiscarded())
       continue;
 
     phdrsCur.clear();
     for (StringRef name : osd->PHDRs()) {
-      auto it = phdrs.find(name);
-      if (it == phdrs.end()) {
+      auto it = _phdrs.find(name);
+      if (it == _phdrs.end()) {
         return LinkerScriptReaderError::unknown_phdr_ids;
       }
       phdrsCur.push_back(it->second);
     }
 
     // If no headers and no errors - insert empty headers set.
     // If the current set of headers is empty, then use the last non-empty
     // set. Otherwise mark the current set to be the last non-empty set for
     // successors.
     if (noPhdrs)
       phdrsCur.clear();
     else if (phdrsCur.empty())
       phdrsCur = phdrsLast;
     else
       phdrsLast = phdrsCur;
 
+    if (_sectionToPHDR.count(osd->name()))
+      return LinkerScriptReaderError::duplicate_name;
     _sectionToPHDR[osd->name()] = phdrsCur;
   }
   return std::error_code();
 }
 
 static bool hasWildcard(StringRef name) {
   for (auto ch : name)
     if (ch == '*' || ch == '?' || ch == '[' || ch == '\\')

test/elf/linkerscript/phdrs-all-none.test

 /*
 Test when all segments are marked as NONE.
 
 RUN: yaml2obj -format=elf %p/Inputs/simple.o.yaml -o=%t.o
 
 RUN: lld -flavor gnu -target x86_64 -T %s %t.o -static -o %t1
 RUN: llvm-objdump -section-headers %t1 | FileCheck -check-prefix NONE-ALL-PHDRS %s
 */
 
 ENTRY(_start)
 
 PHDRS
 {
-    text PT_LOAD;
+    text PT_LOAD FILEHDR PHDRS;
 }
 
 SECTIONS
 {
   .text : { *(.text) } :NONE
   .data : { *(.data) }
 }
 
 /*
 NONE-ALL-PHDRS: .text {{[0-9a-f]+}} 0000000000000000
 NONE-ALL-PHDRS: .data {{[0-9a-f]+}} 000000000000002c
 */

test/elf/linkerscript/phdrs-custom-none.test

 /*
 Test when PHDRS contains custom NONE segment.
 
 RUN: yaml2obj -format=elf %p/Inputs/simple.o.yaml -o=%t.o
 
 RUN: lld -flavor gnu -target x86_64 -T %s %t.o -static -o %t1
 RUN: llvm-objdump -section-headers %t1 | FileCheck -check-prefix CUSTOM-NONE-SECS %s
 RUN: llvm-readobj -program-headers %t1 | FileCheck -check-prefix CUSTOM-NONE-HDRS %s
 */
 
 ENTRY(_start)
 
 PHDRS
 {
-    NONE PT_LOAD;
+    NONE PT_LOAD FILEHDR PHDRS;
 }
 
 SECTIONS
 {
   .text : { *(.text) } :NONE
   .data : { *(.data) }
 }
 

test/elf/linkerscript/phdrs-custom-order.test

+/*
+Test segments put in order defined by PHDRS command.
+
+RUN: yaml2obj -format=elf %p/Inputs/simple.o.yaml -o=%t.o
+
+RUN: lld -flavor gnu -target x86_64 -T %s %t.o -static -o %t1
+RUN: llvm-objdump -section-headers %t1 | FileCheck -check-prefix ORDER-PHDRS-SECS %s
+RUN: llvm-readobj -program-headers %t1 | FileCheck -check-prefix ORDER-PHDRS-HDRS %s
+*/
+
+ENTRY(_start)
+
+PHDRS
+{
+    data PT_LOAD FILEHDR PHDRS;
+    text PT_LOAD;
+}
+
+SECTIONS
+{
+  .text : { *(.text) } :text
+  .data : { *(.data) } :data
+}
+
+/*
+ORDER-PHDRS-SECS: .text {{[0-9a-f]+}} 0000000000401000
+ORDER-PHDRS-SECS: .data {{[0-9a-f]+}} 00000000004000e8
+
+ORDER-PHDRS-HDRS: ProgramHeader {
+ORDER-PHDRS-HDRS: Type: PT_LOAD (0x1)
+ORDER-PHDRS-HDRS: VirtualAddress: 0x400000
+ORDER-PHDRS-HDRS: Flags [ (0x6)
+ORDER-PHDRS-HDRS: PF_R (0x4)
+ORDER-PHDRS-HDRS: PF_W (0x2)
+ORDER-PHDRS-HDRS: ]
+ORDER-PHDRS-HDRS: }
+ORDER-PHDRS-HDRS: ProgramHeader {
+ORDER-PHDRS-HDRS: Type: PT_LOAD (0x1)
+ORDER-PHDRS-HDRS: VirtualAddress: 0x401000
+ORDER-PHDRS-HDRS: Flags [ (0x5)
+ORDER-PHDRS-HDRS: PF_R (0x4)
+ORDER-PHDRS-HDRS: PF_X (0x1)
+ORDER-PHDRS-HDRS: ]
+ORDER-PHDRS-HDRS: }
+*/

test/elf/linkerscript/phdrs-different.test

 /*
 Test sections put to different segments.
 
 RUN: yaml2obj -format=elf %p/Inputs/simple.o.yaml -o=%t.o
 
 RUN: lld -flavor gnu -target x86_64 -T %s %t.o -static -o %t1
 RUN: llvm-objdump -section-headers %t1 | FileCheck -check-prefix DIFF-PHDRS-SECS %s
 RUN: llvm-readobj -program-headers %t1 | FileCheck -check-prefix DIFF-PHDRS-HDRS %s
 */
 
 ENTRY(_start)
 
 PHDRS
 {
-  text PT_LOAD;
+  text PT_LOAD FILEHDR PHDRS;
   data PT_LOAD;
 }
 
 SECTIONS
 {
   .text : { *(.text) } :text
   .data : { *(.data) } :data
 }

test/elf/linkerscript/phdrs-dup-name.test

+/*
+Test duplicate header generates error.
+
+RUN: yaml2obj -format=elf %p/Inputs/simple.o.yaml -o=%t.o
+
+RUN: not lld -flavor gnu -target x86_64 -T %s %t.o -static -o %t1 &> %t1-error
+RUN: FileCheck -check-prefix DUPLICATE-PHDR %s < %t1-error
+*/
+
+ENTRY(_start)
+
+PHDRS
+{
+    header PT_PHDR PHDRS;
+    header PT_PHDR PHDRS;
+    text PT_LOAD FILEHDR PHDRS;
+}
+
+SECTIONS
+{
+  .text : { *(.text) } :NONE
+  .data : { *(.data) }
+}
+
+/*
+DUPLICATE-PHDR: Duplicate name is found
+*/

test/elf/linkerscript/phdrs-extra-program.test

 /*
 Test extra program header generates error.
 
 RUN: yaml2obj -format=elf %p/Inputs/simple.o.yaml -o=%t.o
 
 RUN: not lld -flavor gnu -target x86_64 -T %s %t.o -static -o %t1 &> %t1-error
 RUN: FileCheck -check-prefix EXTRA-PROGRAM-PHDR %s < %t1-error
 */
 
 ENTRY(_start)
 
 PHDRS
 {
     header PT_PHDR PHDRS;
     header2 PT_PHDR PHDRS;
-    text PT_LOAD;
+    text PT_LOAD FILEHDR PHDRS;
 }
 
 SECTIONS
 {
   .text : { *(.text) } :NONE
   .data : { *(.data) }
 }
 
 /*
 EXTRA-PROGRAM-PHDR: Extra program header is found
 */

test/elf/linkerscript/phdrs-flags.test

 /*
 Test sections put to different segments with FLAGS attribute set.
 
 RUN: yaml2obj -format=elf %p/Inputs/simple.o.yaml -o=%t.o
 
 RUN: lld -flavor gnu -target x86_64 -T %s %t.o -static -o %t1
 RUN: llvm-objdump -section-headers %t1 | FileCheck -check-prefix FLAGS-PHDRS-SECS %s
 RUN: llvm-readobj -program-headers %t1 | FileCheck -check-prefix FLAGS-PHDRS-HDRS %s
 */
 
 ENTRY(_start)
 
 PHDRS
 {
-    text PT_LOAD FLAGS(0x5);
+    text PT_LOAD FILEHDR PHDRS FLAGS(0x5);
     data PT_LOAD FLAGS(0x7);
 }
 
 SECTIONS
 {
   .text : { *(.text) } :text
   .data : { *(.data) } :data
 }
 
 /*
-FLAGS-PHDRS-SECS: .text {{[0-9a-f]+}} 0000000000401000
-FLAGS-PHDRS-SECS: .data {{[0-9a-f]+}} 00000000004000e8
+FLAGS-PHDRS-SECS: .text {{[0-9a-f]+}} 00000000004000e8
+FLAGS-PHDRS-SECS: .data {{[0-9a-f]+}} 0000000000401000
 
 FLAGS-PHDRS-HDRS: ProgramHeader {
 FLAGS-PHDRS-HDRS: Type: PT_LOAD (0x1)
 FLAGS-PHDRS-HDRS: VirtualAddress: 0x400000
-FLAGS-PHDRS-HDRS: Flags [ (0x7)
+FLAGS-PHDRS-HDRS: Flags [ (0x5)
 FLAGS-PHDRS-HDRS: PF_R (0x4)
-FLAGS-PHDRS-HDRS: PF_W (0x2)
 FLAGS-PHDRS-HDRS: PF_X (0x1)
 FLAGS-PHDRS-HDRS: ]
 FLAGS-PHDRS-HDRS: }
 FLAGS-PHDRS-HDRS: ProgramHeader {
 FLAGS-PHDRS-HDRS: Type: PT_LOAD (0x1)
 FLAGS-PHDRS-HDRS: VirtualAddress: 0x401000
-FLAGS-PHDRS-HDRS: Flags [ (0x5)
+FLAGS-PHDRS-HDRS: Flags [ (0x7)
 FLAGS-PHDRS-HDRS: PF_R (0x4)
+FLAGS-PHDRS-HDRS: PF_W (0x2)
 FLAGS-PHDRS-HDRS: PF_X (0x1)
 FLAGS-PHDRS-HDRS: ]
 FLAGS-PHDRS-HDRS: }
 */

test/elf/linkerscript/phdrs-has-program.test

 /*
 Test when program segment is set it's generated.
 
 RUN: yaml2obj -format=elf %p/Inputs/simple.o.yaml -o=%t.o
 
 RUN: lld -flavor gnu -target x86_64 -T %s %t.o -static -o %t1
 RUN: llvm-readobj -program-headers %t1 | FileCheck -check-prefix PROGRAM-PHDR %s
 */
 
 ENTRY(_start)
 
 PHDRS
 {
     header PT_PHDR FILEHDR PHDRS;
-    text PT_LOAD PHDRS;
+    text PT_LOAD FILEHDR PHDRS;
 }
 
 SECTIONS
 {
   .text : { *(.text) } :text
   .data : { *(.data) }
 }
 

test/elf/linkerscript/phdrs-load-empty.test

+/*
+Test when load segment doesn't contain any attributes and generates wrong binary.
+
+RUN: yaml2obj -format=elf %p/Inputs/simple.o.yaml -o=%t.o
+
+RUN: lld -flavor gnu -target x86_64 -T %s %t.o -static -o %t1
+RUN: not llvm-readobj -program-headers %t1 &> %t1-error
+RUN: FileCheck -check-prefix LOAD-EMPTY-PHDR %s < %t1-error
+*/
+
+ENTRY(_start)
+
+PHDRS
+{
+    text PT_LOAD;
+}
+
+SECTIONS
+{
+  .text : { *(.text) } :text
+  .data : { *(.data) }
+}
+
+/*
+LOAD-EMPTY-PHDR: The file was not recognized as a valid object file
+*/

test/elf/linkerscript/phdrs-load-filehdr.test

+/*
+Test when load segment contains only FILEHDR attribute and provides no header information.
+
+RUN: yaml2obj -format=elf %p/Inputs/simple.o.yaml -o=%t.o
+
+RUN: lld -flavor gnu -target x86_64 -T %s %t.o -static -o %t1
+RUN: llvm-readobj -program-headers %t1 | FileCheck -check-prefix LOAD-FILEHDR-PHDR %s
+*/
+
+ENTRY(_start)
+
+PHDRS
+{
+    text PT_LOAD FILEHDR;
+}
+
+SECTIONS
+{
+  .text : { *(.text) } :text
+  .data : { *(.data) }
+}
+
+/*
+LOAD-FILEHDR-PHDR-NOT: Type: PT_LOAD (0x1)
+LOAD-FILEHDR-PHDR-NOT: VirtualAddress: 0x400000
+*/

test/elf/linkerscript/phdrs-load-phdrs.test

+/*
+Test when load segment contains only PHDRS attribute and generates wrong binary.
+
+RUN: yaml2obj -format=elf %p/Inputs/simple.o.yaml -o=%t.o
+
+RUN: lld -flavor gnu -target x86_64 -T %s %t.o -static -o %t1
+RUN: not llvm-readobj -program-headers %t1 &> %t1-error
+RUN: FileCheck -check-prefix LOAD-PHDRS-PHDR %s < %t1-error
+*/
+
+ENTRY(_start)
+
+PHDRS
+{
+    text PT_LOAD PHDRS;
+}
+
+SECTIONS
+{
+  .text : { *(.text) } :text
+  .data : { *(.data) }
+}
+
+/*
+LOAD-PHDRS-PHDR: The file was not recognized as a valid object file
+*/

test/elf/linkerscript/phdrs-misplaced-program.test

 /*
 Test misplaced program header generates error.
 
 RUN: yaml2obj -format=elf %p/Inputs/simple.o.yaml -o=%t.o
 
 RUN: not lld -flavor gnu -target x86_64 -T %s %t.o -static -o %t1 &> %t1-error
 RUN: FileCheck -check-prefix MISPLACED-PROGRAM-PHDR %s < %t1-error
 */
 
 ENTRY(_start)
 
 PHDRS
 {
-    text PT_LOAD;
+    text PT_LOAD FILEHDR PHDRS;
     header PT_PHDR PHDRS;
 }
 
 SECTIONS
 {
   .text : { *(.text) } :NONE
   .data : { *(.data) }
 }
 
 /*
 MISPLACED-PROGRAM-PHDR: Program header must precede load segments
 */

test/elf/linkerscript/phdrs-no-program.test

 /*
 Test when no program segment set it's not generated.
 
 RUN: yaml2obj -format=elf %p/Inputs/simple.o.yaml -o=%t.o
 
 RUN: lld -flavor gnu -target x86_64 -T %s %t.o -static -o %t1
 RUN: llvm-readobj -program-headers %t1 | FileCheck -check-prefix PROGRAM-PHDR %s
 */
 
 ENTRY(_start)
 
 PHDRS
 {
-    text PT_LOAD;
+    text PT_LOAD FILEHDR PHDRS;
 }
 
 SECTIONS
 {
   .text : { *(.text) } :text
   .data : { *(.data) }
 }
 
 /*
 PROGRAM-PHDR-NOT: Type: PT_PHDR (0x6)
 */

test/elf/linkerscript/phdrs-one-none.test

 /*
 Test when one segment is marked as NONE.
 
 RUN: yaml2obj -format=elf %p/Inputs/simple.o.yaml -o=%t.o
 
 RUN: lld -flavor gnu -target x86_64 -T %s %t.o -static -o %t1
 RUN: llvm-objdump -section-headers %t1 | FileCheck -check-prefix NONE-PHDRS-SECS %s
 RUN: llvm-readobj -program-headers %t1 | FileCheck -check-prefix NONE-PHDRS-HDRS %s
 */
 
 ENTRY(_start)
 
 PHDRS
 {
-  text PT_LOAD;
+  text PT_LOAD FILEHDR PHDRS;
 }
 
 SECTIONS
 {
   .text : { *(.text) } :text
   .data : { *(.data) } :NONE
 }
 

test/elf/linkerscript/phdrs-program-good-phdrs.test

 /*
 Test when program segment contains only PHDRS attribute.
 
 RUN: yaml2obj -format=elf %p/Inputs/simple.o.yaml -o=%t.o
 
 RUN: lld -flavor gnu -target x86_64 -T %s %t.o -static -o %t1
 RUN: llvm-readobj -program-headers %t1 | FileCheck -check-prefix PROGRAM-PHDRS-PHDR %s
 */
 
 ENTRY(_start)
 
 PHDRS
 {
     header PT_PHDR PHDRS;
-    text PT_LOAD PHDRS;
+    text PT_LOAD FILEHDR PHDRS;
 }
 
 SECTIONS
 {
   .text : { *(.text) } :text
   .data : { *(.data) }
 }
 

test/elf/linkerscript/phdrs-same-flags.test

 /*
 Test sections put to same segment with FLAGS attribute set.
 
 RUN: yaml2obj -format=elf %p/Inputs/simple.o.yaml -o=%t.o
 
 RUN: lld -flavor gnu -target x86_64 -T %s %t.o -static -o %t1
 RUN: llvm-objdump -section-headers %t1 | FileCheck -check-prefix FLAGS-PHDRS-SECS %s
 RUN: llvm-readobj -program-headers %t1 | FileCheck -check-prefix FLAGS-PHDRS-HDRS %s
 */
 
 ENTRY(_start)
 
 PHDRS
 {
-    text PT_LOAD FLAGS(0x4);
+    text PT_LOAD FILEHDR PHDRS FLAGS(0x4);
 }
 
 SECTIONS
 {
   .text : { *(.text) } :text
   .data : { *(.data) }
 }
 

test/elf/linkerscript/phdrs-same.test

 /*
 Test sections put to same segment.
 
 RUN: yaml2obj -format=elf %p/Inputs/simple.o.yaml -o=%t.o
 
 RUN: lld -flavor gnu -target x86_64 -T %s %t.o -static -o %t1
 RUN: llvm-objdump -section-headers %t1 | FileCheck -check-prefix SAME-PHDRS-SECS %s
 RUN: llvm-readobj -program-headers %t1 | FileCheck -check-prefix SAME-PHDRS-HDRS %s
 */
 
 ENTRY(_start)
 
 PHDRS
 {
-  text PT_LOAD;
+  text PT_LOAD FILEHDR PHDRS;
 }
 
 SECTIONS
 {
   .text : { *(.text) } :text
   .data : { *(.data) }
 }
 

test/elf/linkerscript/sections-dup-name.test

+/*
+Test duplicate output section name generates error.
+
+RUN: yaml2obj -format=elf %p/Inputs/simple.o.yaml -o=%t.o
+
+RUN: not lld -flavor gnu -target x86_64 -T %s %t.o -static -o %t1 &> %t1-error
+RUN: FileCheck -check-prefix DUPLICATE-SECTION %s < %t1-error
+*/
+
+ENTRY(_start)
+
+SECTIONS
+{
+  .text : { *(.text) }
+  .data : { *(.data) }
+  .text : { *(.text) }
+}
+
+/*
+DUPLICATE-SECTION: Duplicate name is found
+*/