[lld][LinkerScript] Process program header of linker script

[denis-protivensky]

Summary

Add PT_PHDR segment depending on its availability in linker script's PHDRS command, fallback if no linker script is given.
Handle FILEHDR, PHDRS and FLAGS attributes of program header.
Test cases are included.

[rafaelauler]

This LGTM.

[Bigcheese]

This looks fine.

Not needed for this patch, but we should do clang style diagnostics here.

include/lld/Core/Error.h

 const std::error_category &LinkerScriptReaderCategory();
 
 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,
 };
 
 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

enum Kind {
     kw_align,
     kw_align_with_input,
     kw_as_needed,
     kw_at,
     kw_discard,
     kw_entry,
     kw_exclude_file,
     kw_extern,
+    kw_filehdr,
     kw_fill,
+    kw_flags,
     kw_group,
     kw_hidden,
     kw_input,
     kw_keep,
     kw_length,
     kw_memory,
     kw_origin,
     kw_phdrs,

 public:
   PHDR(StringRef name, uint64_t type, bool includeFileHdr, bool includePHDRs,
        const Expression *at, uint64_t flags)
       : _name(name), _type(type), _includeFileHdr(includeFileHdr),
         _includePHDRs(includePHDRs), _at(at), _flags(flags) {}
 
   StringRef name() const { return _name; }
   uint64_t type() const { return _type; }
+  bool hasFileHdr() const { return _includeFileHdr; }
+  bool hasPHDRs() const { return _includePHDRs; }
   uint64_t flags() const { return _flags; }
   bool isNone() const;
 
   void dump(raw_ostream &os) const;
 
 private:
   StringRef _name;
   uint64_t _type;
public:
 
   const std::vector<std::unique_ptr<Parser>> &getLinkerScripts() {
     return _scripts;
   }
 
   /// Prepare our data structures according to the linker scripts currently in
   /// our control (control given via addLinkerScript()). Called once all linker
   /// scripts have been parsed.
-  void perform();
+  std::error_code perform();
 
   /// Answer if we have layout commands (section mapping rules). If we don't,
   /// the output file writer can assume there is no linker script special rule
   /// to handle.
   bool hasLayoutCommands() const { return _layoutCommands.size() > 0; }
 
   /// Return true if this section has a mapping rule in the linker script
   bool hasMapping(const SectionKey &key) const {
public:
   /// Retrieve the set of symbols defined in linker script expressions.
   const llvm::StringSet<> &getScriptDefinedSymbols() const;
 
   /// Queries the linker script symbol table for the value of a given symbol.
   /// This function must be called after linker script expressions evaluation
   /// has been performed (by calling evalExpr() for all expressions).
   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.
-  /// Error is returned if the output section is assigned to headers with
-  /// missing declarations.
-  std::error_code
-  getPHDRsForOutputSection(StringRef name,
-                           std::vector<const PHDR *> &phdrs) const;
+  std::vector<const PHDR *> getPHDRsForOutputSection(StringRef name) 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
   /// number (caching results).
   struct SectionKeyHash {
private:
   int getLayoutOrder(const SectionKey &key, bool coarse) const;
 
   /// 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);
+
   /// Build map that matches output section names to segments they should be
   /// put into.
-  std::error_code buildSectionToPHDR();
+  std::error_code buildSectionToPHDR(llvm::StringMap<const PHDR *> &phdrs);
 
   /// 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:
   ///   * InputSectionSortedName, a group of input section names
   ///   * SymbolAssignment, containing an expression that may
   ///     change the address where the linker is outputting data
   ///
   void linearizeAST(const Sections *sections);
   void linearizeAST(const InputSectionsCmd *inputSections);
   void linearizeAST(const InputSection *inputSection);
 
-  void perform(const LinkerScript *ls);
-
   std::vector<std::unique_ptr<Parser>> _scripts;
   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;
 
-  bool _parsedPHDRS;
   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

case LinkerScriptReaderError::parse_error:
       return "Error parsing linker script";
     case LinkerScriptReaderError::unknown_symbol_in_expr:
       return "Unknown symbol found when evaluating linker script expression";
     case LinkerScriptReaderError::unrecognized_function_in_expr:
       return "Unrecognized function call when evaluating linker script "
              "expression";
     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";
     }
     llvm_unreachable("An enumerator of LinkerScriptReaderError does not have a "
                      "message defined.");
   }
 };
 
 const std::error_category &lld::LinkerScriptReaderCategory() {
   static _LinkerScriptReaderErrorCategory o;

lib/Driver/GnuLdDriver.cpp

if (ctx->outputPath().empty()) {
     }
   }
 
   // Validate the combination of options used.
   if (!ctx->validate(diag))
     return false;
 
   // Perform linker script semantic actions
-  ctx->linkerScriptSema().perform();
+  if (auto ec = ctx->linkerScriptSema().perform()) {
+    diag << "Error in the linker script's semantics: " << ec.message() << "\n";
+    return false;
+  }
 
   context.swap(ctx);
   return true;
 }
 
 /// Get the default target triple based on either the program name
 /// (e.g. "x86-ibm-linux-lld") or the primary target llvm was configured for.
 llvm::Triple GnuLdDriver::getDefaultTarget(const char *progName) {

lib/ReaderWriter/ELF/SegmentChunks.cpp

template <class ELFT> int64_t Segment<ELFT>::flags() const {
   if (_flags & llvm::ELF::SHF_WRITE)
     fl |= llvm::ELF::PF_W;
   if (_flags & llvm::ELF::SHF_EXECINSTR)
     fl |= llvm::ELF::PF_X;
   return fl;
 }
 
 template <class ELFT> void Segment<ELFT>::setSegmentFlags(uint64_t flags) {
-  assert(!_segmentFlags && !_flags && "Flags has already been set");
+  assert(!_segmentFlags && "Segment flags have already been set");
   _segmentFlags = true;
   _flags = flags;
   _atomflags = toAtomPermsSegment(flags);
 }
 
 template <class ELFT> void Segment<ELFT>::finalize() {
   // We want to finalize the segment values for now only for non loadable
   // segments, since those values are not set in the Layout

lib/ReaderWriter/ELF/TargetLayout.cpp

for (auto &si : _sections) {
     }
     outputSection->appendSection(section);
   }
 }
 
 template <class ELFT>
 std::vector<const script::PHDR *>
 TargetLayout<ELFT>::getCustomSegments(const OutputSection<ELFT> *sec) const {
-  std::vector<const script::PHDR *> phdrs;
-  if (_linkerScriptSema.getPHDRsForOutputSection(sec->name(), phdrs)) {
-    llvm::report_fatal_error(
-        "Linker script has wrong segments set for output sections");
-  }
-  return phdrs;
+  return _linkerScriptSema.getPHDRsForOutputSection(sec->name());
 }
 
 template <class ELFT>
 std::vector<const script::PHDR *>
 TargetLayout<ELFT>::getCustomSegments(const Section<ELFT> *section) const {
   auto sec = section->getOutputSection();
   assert(sec && "Output section should be already set for input section");
   return getCustomSegments(sec);
for (auto section : osi->sections()) {
           addExtraChunksToSegment(segment, section->archivePath(),
                                   section->memberPath(),
                                   section->inputSectionName());
         }
         segment->append(section);
       }
     }
   }
-  if (_ctx.isDynamic() && !_ctx.isDynamicLibrary()) {
+
+  // Default values if no linker script is available
+  bool hasProgramSegment = _ctx.isDynamic() && !_ctx.isDynamicLibrary();
+  bool hasElfHeader = true;
+  bool hasProgramHeader = true;
+  uint64_t segmentFlags = 0;
+
+  // 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();
+    } else {
+      hasProgramSegment = false;
+      hasElfHeader = false;
+      hasProgramHeader = false;
+    }
+  }
+
+  if (hasProgramSegment) {
     Segment<ELFT> *segment = new (_allocator) ProgramHeaderSegment<ELFT>(_ctx);
     _segments.push_back(segment);
+    if (segmentFlags)
+      segment->setSegmentFlags(segmentFlags);
+    if (hasElfHeader)
       segment->append(_elfHeader);
+    if (hasProgramHeader)
       segment->append(_programHeader);
   }
 }
 
 template <class ELFT> void TargetLayout<ELFT>::sortSegments() {
   std::sort(_segments.begin(), _segments.end(), Segment<ELFT>::compareSegments);
 }
 
 template <class ELFT> void TargetLayout<ELFT>::assignVirtualAddress() {

lib/ReaderWriter/LinkerScript.cpp

case Token::name:                                                            \
     CASE(kw_align)
     CASE(kw_align_with_input)
     CASE(kw_as_needed)
     CASE(kw_at)
     CASE(kw_discard)
     CASE(kw_entry)
     CASE(kw_exclude_file)
     CASE(kw_extern)
+    CASE(kw_filehdr)
     CASE(kw_fill)
+    CASE(kw_flags)
     CASE(kw_group)
     CASE(kw_hidden)
     CASE(kw_input)
     CASE(kw_keep)
     CASE(kw_length)
     CASE(kw_memory)
     CASE(kw_origin)
     CASE(kw_phdrs)
Token::Kind kind =
         llvm::StringSwitch<Token::Kind>(word)
             .Case("ALIGN", Token::kw_align)
             .Case("ALIGN_WITH_INPUT", Token::kw_align_with_input)
             .Case("AS_NEEDED", Token::kw_as_needed)
             .Case("AT", Token::kw_at)
             .Case("ENTRY", Token::kw_entry)
             .Case("EXCLUDE_FILE", Token::kw_exclude_file)
             .Case("EXTERN", Token::kw_extern)
+            .Case("FILEHDR", Token::kw_filehdr)
             .Case("FILL", Token::kw_fill)
+            .Case("FLAGS", Token::kw_flags)
             .Case("GROUP", Token::kw_group)
             .Case("HIDDEN", Token::kw_hidden)
             .Case("INPUT", Token::kw_input)
             .Case("KEEP", Token::kw_keep)
             .Case("LENGTH", Token::kw_length)
             .Case("l", Token::kw_length)
             .Case("len", Token::kw_length)
             .Case("MEMORY", Token::kw_memory)
#undef PHDR_INSERT
     break;
   }
   default:
     error(_tok, "expected identifier or expression");
     return nullptr;
   }
 
   uint64_t flags = 0;
+  const Expression *flagsExpr = nullptr;
+  bool includeFileHdr = false;
+  bool includePHDRs = false;
 
-  if (_tok._kind == Token::identifier && _tok._range == "FLAGS") {
+  while (_tok._kind != Token::semicolon) {
+    switch (_tok._kind) {
+    case Token::kw_filehdr:
+      if (includeFileHdr) {
+        error(_tok, "Duplicate FILEHDR attribute");
+        return nullptr;
+      }
+      includeFileHdr = true;
+      consumeToken();
+      break;
+    case Token::kw_phdrs:
+      if (includePHDRs) {
+        error(_tok, "Duplicate PHDRS attribute");
+        return nullptr;
+      }
+      includePHDRs = true;
+      consumeToken();
+      break;
+    case Token::kw_flags: {
+      if (flagsExpr) {
+        error(_tok, "Duplicate FLAGS attribute");
+        return nullptr;
+      }
       consumeToken();
       if (!expectAndConsume(Token::l_paren, "Expected ("))
         return nullptr;
-    const Expression *flagsExpr = parseExpression();
+      flagsExpr = parseExpression();
       if (!flagsExpr)
         return nullptr;
       auto f = flagsExpr->evalExpr();
       if (!f)
         return nullptr;
       flags = *f;
       if (!expectAndConsume(Token::r_paren, "Expected )"))
         return nullptr;
+    } break;
+    default:
+      error(_tok, "Unexpected token");
+      return nullptr;
+    }
   }
   
   if (!expectAndConsume(Token::semicolon, "Expected ;"))
     return nullptr;
 
-  return new (getAllocator()) PHDR(name, type, false, false, nullptr, flags);
+  return new (getAllocator())
+      PHDR(name, type, includeFileHdr, includePHDRs, nullptr, flags);
 }
 
 PHDRS *Parser::parsePHDRS() {
   assert(_tok._kind == Token::kw_phdrs && "Expected PHDRS!");
   consumeToken();
   if (!expectAndConsume(Token::l_brace, "expected {"))
     return nullptr;
 
Extern *Parser::parseExtern() {
 
   if (!expectAndConsume(Token::r_paren, "expected symbol in EXTERN."))
     return nullptr;
 
   return new (_alloc) Extern(*this, symbols);
 }
 
 // Sema member functions
-Sema::Sema() : _parsedPHDRS(false) {}
+Sema::Sema() : _programPHDR(nullptr) {}
+
+std::error_code Sema::perform() {
+  llvm::StringMap<const PHDR *> phdrs;
 
-void Sema::perform() {
-  for (auto &parser : _scripts)
-    perform(parser->get());
+  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))
+          return ec;
+      }
+    }
+  }
+  return buildSectionToPHDR(phdrs);
 }
 
 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)

 }
 
 uint64_t Sema::getLinkerScriptExprValue(StringRef name) const {
   auto it = _symbolTable.find(name);
   assert (it != _symbolTable.end() && "Invalid symbol name!");
   return it->second;
 }
 
-std::error_code
-Sema::getPHDRsForOutputSection(StringRef name,
-                               std::vector<const PHDR *> &phdrs) const {
-  // Cache results if not done yet.
-  if (auto ec = const_cast<Sema *>(this)->buildSectionToPHDR())
-    return ec;
+bool Sema::hasPHDRs() const { return !_sectionToPHDR.empty(); }
 
+std::vector<const PHDR *> Sema::getPHDRsForOutputSection(StringRef name) const {
   auto vec = _sectionToPHDR.lookup(name);
-  std::copy(std::begin(vec), std::end(vec), std::back_inserter(phdrs));
-  return std::error_code();
+  return std::vector<const PHDR *>(std::begin(vec), std::end(vec));
 }
 
+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";
     parser->get()->dump(os);
     os << "\n";
for (const InputSection *inputSection : *cmd) {
     return compareSortedNames(sortedGroup->sortMode(), lhs.sectionName,
                               rhs.sectionName);
   }
 
   llvm_unreachable("");
   return false;
 }
 
-std::error_code Sema::buildSectionToPHDR() {
-  if (_parsedPHDRS)
-    return std::error_code();
-  _parsedPHDRS = true;
-
-  // No scripts - nothing to do.
-  if (_scripts.empty() || _layoutCommands.empty())
-    return std::error_code();
-
-  // Collect all header declarations.
-  llvm::StringMap<const PHDR *> phdrs;
-  for (auto &parser : _scripts) {
-    for (auto *cmd : parser->get()->_commands) {
-      if (auto *ph = dyn_cast<PHDRS>(cmd)) {
-        for (auto *p : *ph)
-          phdrs[p->name()] = p;
-      }
-    }
-  }
+std::error_code Sema::collectPHDRs(const PHDRS *ph,
+                                   llvm::StringMap<const PHDR *> &phdrs) {
+  bool loadFound = false;
+  for (auto *p : *ph) {
+
+    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;
+      loadFound = true;
+      break;
+  return std::error_code();
+
+std::error_code Sema::buildSectionToPHDR(llvm::StringMap<const PHDR *> &phdrs) {
   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;
 
   // Match output sections to available headers.
for (const Command *outSecCommand : *outSection) {
       if (!isa<InputSectionsCmd>(outSecCommand))
         continue;
 
       linearizeAST(dyn_cast<InputSectionsCmd>(outSecCommand));
     }
   }
 }
 
-void Sema::perform(const LinkerScript *ls) {
-  for (const Command *c : ls->_commands) {
-    if (const Sections *sec = dyn_cast<Sections>(c))
-      linearizeAST(sec);
-  }
-}
-
 } // End namespace script
 } // end namespace lld

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;
+}
+
+SECTIONS
+{
+  .text : { *(.text) } :NONE
+  .data : { *(.data) }
+}
+
+/*
+EXTRA-PROGRAM-PHDR: Extra program header is found
+*/

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;
+}
+
+SECTIONS
+{
+  .text : { *(.text) } :text
+  .data : { *(.data) }
+}
+
+/*
+PROGRAM-PHDR: ProgramHeader {
+PROGRAM-PHDR: Type: PT_PHDR (0x6)
+PROGRAM-PHDR: VirtualAddress: 0x400040
+PROGRAM-PHDR: Flags [ (0x5)
+PROGRAM-PHDR: PF_R (0x4)
+PROGRAM-PHDR: PF_X (0x1)
+PROGRAM-PHDR: ]
+PROGRAM-PHDR: }
+*/

test/elf/linkerscript/phdrs-invalid.test

 */
 
 /*
 Test undefined header used when no PHDRS defined.
 
 RUN: not lld -flavor gnu -target x86_64 -T %p/phdrs/undef-no-phdrs.script %t.o -static -o %t1 &> %t1-error
 RUN: FileCheck -check-prefix UNDEF-NO-PHDRS %s < %t1-error
 
-UNDEF-NO-PHDRS: Linker script has wrong segments set for output sections
+UNDEF-NO-PHDRS: Unknown header identifiers (missing in PHDRS command) are used
 */
 
 /*
 Test undefined header used when PHDRS is empty.
 
 RUN: not lld -flavor gnu -target x86_64 -T %p/phdrs/undef-empty-phdrs.script %t.o -static -o %t2 &> %t2-error
 RUN: FileCheck -check-prefix UNDEF-EMPTY-PHDRS %s < %t2-error
 
-UNDEF-EMPTY-PHDRS: Linker script has wrong segments set for output sections
+UNDEF-EMPTY-PHDRS: Unknown header identifiers (missing in PHDRS command) are used
 */
 
 /*
 Test undefined header used when PHDRS contains definitions.
 
 RUN: not lld -flavor gnu -target x86_64 -T %p/phdrs/undef-id-phdrs.script %t.o -static -o %t3 &> %t3-error
 RUN: FileCheck -check-prefix UNDEF-ID-PHDRS %s < %t3-error
 
-UNDEF-ID-PHDRS: Linker script has wrong segments set for output sections
+UNDEF-ID-PHDRS: Unknown header identifiers (missing in PHDRS command) are used
 */

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;
+    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;
+}
+
+SECTIONS
+{
+  .text : { *(.text) } :text
+  .data : { *(.data) }
+}
+
+/*
+PROGRAM-PHDR-NOT: Type: PT_PHDR (0x6)
+*/

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

+/*
+Test when program segment contains only FLAGS 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-FLAGS-PHDR %s
+*/
+
+ENTRY(_start)
+
+PHDRS
+{
+    header PT_PHDR PHDRS FLAGS(0x7);
+    text PT_LOAD FILEHDR PHDRS;
+}
+
+SECTIONS
+{
+  .text : { *(.text) } :text
+  .data : { *(.data) }
+}
+
+/*
+PROGRAM-FLAGS-PHDR: ProgramHeader {
+PROGRAM-FLAGS-PHDR: Type: PT_PHDR (0x6)
+PROGRAM-FLAGS-PHDR: Flags [ (0x7)
+PROGRAM-FLAGS-PHDR: PF_R (0x4)
+PROGRAM-FLAGS-PHDR: PF_W (0x2)
+PROGRAM-FLAGS-PHDR: PF_X (0x1)
+PROGRAM-FLAGS-PHDR: ]
+PROGRAM-FLAGS-PHDR: }
+*/

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;
+}
+
+SECTIONS
+{
+  .text : { *(.text) } :text
+  .data : { *(.data) }
+}
+
+/*
+PROGRAM-PHDRS-PHDR: ProgramHeader {
+PROGRAM-PHDRS-PHDR: Type: PT_PHDR (0x6)
+PROGRAM-PHDRS-PHDR: VirtualAddress: 0x400040
+PROGRAM-PHDRS-PHDR: MemSize: 168
+PROGRAM-PHDRS-PHDR: Flags [ (0x5)
+PROGRAM-PHDRS-PHDR: PF_R (0x4)
+PROGRAM-PHDRS-PHDR: PF_X (0x1)
+PROGRAM-PHDRS-PHDR: ]
+PROGRAM-PHDRS-PHDR: }
+*/

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

+/*
+Test when program segment doesn't contain PHDRS attribute.
+
+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 PROGRAM-PHDR-NO-PHDRS %s < %t1-error
+*/
+
+ENTRY(_start)
+
+PHDRS
+{
+    header PT_PHDR;
+    text PT_LOAD;
+}
+
+SECTIONS
+{
+  .text : { *(.text) } :text
+  .data : { *(.data) }
+}
+
+/*
+PROGRAM-PHDR-NO-PHDRS: Program header has invalid PHDRS attribute
+*/

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

+/*
+Test when program segment contains PHDRS attribute not mapped to load segment.
+
+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 PROGRAM-PHDR-WRONG-PHDRS %s < %t1-error
+*/
+
+ENTRY(_start)
+
+PHDRS
+{
+    header PT_PHDR PHDRS;
+    text PT_LOAD;
+}
+
+SECTIONS
+{
+  .text : { *(.text) } :text
+  .data : { *(.data) }
+}
+
+/*
+PROGRAM-PHDR-WRONG-PHDRS: Program header has invalid PHDRS attribute
+*/