[ELF] Implement minimal PHDRS parser and section-to-segment assignment

[evgeny777]

Summary

This patch implemts:

a) Very basic support for PHDRS parsing. Only header name, type, FILEHDR and PHDRS attributes are supported
b) Simple section-to-segment assignment algorithm:

• All segments listed inside PHDRS are created, no matter they contain any section or not
• Linker script can assign section to one or more segments
• New PT_LOAD segment is created for orphaned sections with SHF_ALLOC attribute.

[ruiu]

ELF/LinkerScript.cpp

484

As you can see above, our naming scheme in this class is readFoo where Foo is a command name in the linker script. Because this function reads a PHDRS command, it should be named readPhdrs.

670

Likewise, it should be readPhdrsType.

ELF/Writer.cpp

998–999

Can you move this code to LinkerScript.cpp? We don't expose linker script internals to the Writer. For example, SECTIONS commands are hidden behind LinkerScript::assignAddresses function.

[ruiu]

ELF/LinkerScript.cpp

738

Type can be any expression that is evaluated to an integer, but you are handling the case only when there is a literal integer which might be a bit confusing. Can you report an error for now?

ELF/LinkerScript.h

63–64

Rename HasFilehdr and HasPhdrs.

72

PhdrsCommands would be a better name because there are many other header types.

[evgeny777]

ELF/LinkerScript.cpp

738

These three lines are equivalent:

header PT_NULL;
header 0;
header 0x0;

ELF/Writer.cpp

998–999

This requires exposing Phdrs, toPhdrFlags, isRelroSection, needsPtLoad, needsInterpSection and other private Writer stuff (defined in Writer.cpp) to LinkerScript object.

Is this, what really neeeded?

[evgeny777]

ELF/LinkerScript.cpp

738

Sorry, I think I might have misunderstood you.
So you do not want to habdle the case when header type is specified as an integer value (like "header 0x0") for now (may be because it can also be an expression which evaluates to integer) and want to report an error, in case mnemonic name is not matched, right?

[evgeny777]

I have updated review. All issues fixed, except one (moving createPhdrsUsingSpec to LinkerScript.cpp), because I don't understand very well, how this should be done properly
As I wrote earlier, createPhdrsUsingSpec uses a lot of private stuff from Writer:

• Phdrs collection
• Phdr structure definition
• Many helper functions: neetdsPtLoad, needsPtInterp, isOutputDynamic, isRelroSection and others

All of the stuff above is defined in Writer.cpp and is declared private. Writer itself is a template class, so moving part of its definition to header file might not be a good idea.
So, please suggest how this should be done properly? Move all required stuff to Writer.h header file (may be to lld::elf namespace)? Something else?

[ruiu]

I think it's worth to export struct Phdr, toPhdrFlags, isOutputDynamic and so on from Writer.h so that we can move the new code to LinkerScript.cpp. Can you try?

ELF/LinkerScript.cpp

407–408

Indices and ItSect.

414

ItHdr

663

As we name other functions, this should be readPhdrs.

734

it -> It

[evgeny777]

Review updated.
Common stuff moved to Writer.h
createPhdrsUsingSpec moved to LinkerScript as createScriptedPhdrs.
Explicit template instantiation added where needed.

[ruiu]

ELF/LinkerScript.cpp

289

Replace getHeaderSpec() with Opt.PhdrsCommands`.

344–345

} else {

480–484

Sort alphabetically.

663

Move this before readSearchDir.

ELF/LinkerScript.h

97

Since this is LinkerScript class, it is obvious that it is "scripted", so I'd name createPhdrs.

99

Make this a private function.

ELF/Writer.cpp

226–229

We have ScriptConfig->DoLayout in this function, so for consistency it is better to dispatch to a LinkerScript function in this file instead of from createPhdrs.

if (Script<ELFT>::X->hasPhdrsCommand())
  Phdrs = Script<ELFT>::X->createPhdrs();
else
  Phdrs = createPhdrs();

494–497

Move them at end of this file just like other template instantiations.

919

getHeaderSpec() is used only to call size(), so it's overkill. Define bool LinkerScript::hasPhdrsCommand() and use it instead.

922

I'd move this line to setPhdrs.

ELF/Writer.h

24–38

Remove blank lines.

42

Do you need this last line in the comment?

[evgeny777]

ELF/Writer.cpp

922

This won't work, because size of program headers is used in Writer<ELFT>::assignAddresses, which is called before setPhdrs. I've moved it to fixHeaders() instead

[evgeny777]

Review updated

[ruiu]

ELF/LinkerScript.cpp

281–282

Why don't you make it a pure function?

std::vector<Phdr> LinkerScript<ELFT>::createPhdrs(ArrayRef...)

290

Use emplace_back.

399

The term HeaderSpec is used only for this function, so it is not easy to understand what it means at first sight. Why don't you name this hasPhdrsCommands?

403

This function needs a function comment about what it is supposed to do.

405

ELF contains various types of headers such as section headers or program headers. So it is probably better to name this getPhdrIndices.

[evgeny777]

ELF/LinkerScript.cpp

290

Unlike emplace, emplace_back doesn't return iterator (it has void return type). Is it really that better?

[ruiu]

ELF/LinkerScript.cpp

290

Well, then how about using emplace_back and back? Then you are going to have an object of Phdr type rather than an iterator to Phdrs, which I believe improve readability (by replacing auto with Phdr.)

[evgeny777]

Review updated

[grimar]

ELF/LinkerScript.cpp

286

I think we do not use int.
Use what you need instead: int32_t I guess.

317

if (Out<ELFT>::EhFrame->empty() || !Out<ELFT>::EhFrameHdr)
  continue;

ELF/LinkerScript.h

19

We usually put lld headers before others ones. Move it before #include "lld/Core/LLVM.h" please.

ELF/Writer.h

36

I think this comment can be 2 lines (did not check though).

test/ELF/linkerscript-phdrs.s

4

Please format to have max 80 symbols per line (you can refer to other testcases we have for reference)

8

please add few spaces to format accordinly.

17

Usually when we do not need - we dont leave hex flags values check.
I mean we you want write:

# CHECK-NEXT:    Flags [
# CHECK-NEXT:      PF_R
# CHECK-NEXT:      PF_W
# CHECK-NEXT:      PF_X
# CHECK-NEXT:    ]

22

Remove excessive empty line.

[evgeny777]

ELF/LinkerScript.cpp

286

ssize_t is not (definitly) int.
It is normally used to hold either size or error.

ELF/Writer.h

36

It's been clang-format'ted

test/ELF/linkerscript-phdrs.s

18

Hmm. Have you tried this:

grep PF_R test/ELF/*.s

[evgeny777]

Review updated according to comments from grimar

[grimar]

ELF/LinkerScript.cpp

286

#if defined(_WIN64)
typedef signed __int64 ssize_t;
#else
typedef signed int ssize_t;
#endif /* _WIN64 */

It is defined in that way for me.
I think class ErrorOr is used for holding errors in llvm.

We have just a few usings for it in llvm and none in lld at all for that type. I think you want to change it to something different and more consistent with lld code.

ELF/Writer.h

36

I am no doubt it was. But I think it can be 2 lines instead of 3.

test/ELF/linkerscript-phdrs.s

18

Nope. I am windows user I even do not have grep :)
But general rule is not to check something that is not important for the testcase.
We are trying to follow it anyways, even if missed something in previous commits.

[evgeny777]

ELF/LinkerScript.cpp

286

Well, ErrorOr<T> looks a way too heavy to represent valid/invalid array index, doesn't it?

[grimar]

ELF/LinkerScript.cpp

286

Right. That is why I suggested to use int32_t/uint32_t depending on what you need here. It is what we generally use in lld for such cases.
But we do not use int and never used ssize_t yet I think.

[evgeny777]

ELF/LinkerScript.cpp

286

There is plenty of int and plenty of size_t. Unfortunately I don't know any windows analog for 'grep -w', so just beleive me :)
Yes, there isn't any ssize_t, right, but on the other hand - why not use it?

[grimar]

ELF/LinkerScript.cpp

286

Well, I think there should be a reason for using something new, like new type in you code. What is the reason for you ?
We used other types all the way before, so at least there is a reason not to use ssize_t - and that readon is consistency.
At the same time that is just my opinion here, I would not intoduce using of new type, but lets wait for another reviewers comments then.

[ruiu]

ELF/LinkerScript.cpp

286

I have a concern about ssize_t because (unlike size_t) it is not in the C standard. It is defined in POSIX, so it may be unavailable on non-Unix systems. So I'd prefer int32_t or just int. (I don't have a strong preference here because it is unrealistic we have more than 2^31 elements.)

628–633

Can you break as early as possible?

if (Tok == ";")
  break;
if (Tok == "FILEHDR")
  ...

ELF/LinkerScript.h

102

Add a blank line before private:.

ELF/Writer.cpp

1303–1311

* Sec -> * (we usually omit parameter names here)

[Hektve87]

In D21995#481678, @evgeny777 wrote:

Review updated according to comments from grimar

(~~~~)

[Hektve87]

In D21995#477888, @evgeny777 wrote:

Review updated.
Common stuff moved to Writer.h
createPhdrsUsingSpec moved to LinkerScript as createScriptedPhdrs.
Explicit template instantiation added where needed.

(~~~~)

[Hektve87]

In D21995#476580, @evgeny777 wrote:

I have updated review. All issues fixed, except one (moving createPhdrsUsingSpec to LinkerScript.cpp), because I don't understand very well, how this should be done properly
As I wrote earlier, createPhdrsUsingSpec uses a lot of private stuff from Writer:

• Phdrs collection
• Phdr structure definition
• Many helper functions: neetdsPtLoad, needsPtInterp, isOutputDynamic, isRelroSection and others

All of the stuff above is defined in Writer.cpp and is declared private. Writer itself is a template class, so moving part of its definition to header file might not be a good idea.
So, please suggest how this should be done properly? Move all required stuff to Writer.h header file (may be to lld::elf namespace)? Something else?

(~~~~)

[Hektve87]

In D21995#476580, @evgeny777 wrote:

I have updated review. All issues fixed, except one (moving createPhdrsUsingSpec to LinkerScript.cpp), because I don't understand very well, how this should be done properly
As I wrote earlier, createPhdrsUsingSpec uses a lot of private stuff from Writer:

• Phdrs collection
• Phdr structure definition
• Many helper functions: neetdsPtLoad, needsPtInterp, isOutputDynamic, isRelroSection and others

All of the stuff above is defined in Writer.cpp and is declared private. Writer itself is a template class, so moving part of its definition to header file might not be a good idea.
So, please suggest how this should be done properly? Move all required stuff to Writer.h header file (may be to lld::elf namespace)? Something else?

(~~~~)

In D21995#481621, @evgeny777 wrote:

Review updated

(~~~~)

[evgeny777]

Review updated

[evgeny777]

I wonder if it can be pushed to trunk now?

[ruiu]

I'm sorry I didn't notice that you have uploaded a new patch. I'm sorry. I'll take a look today.

[evgeny777]

Thank you.

[ruiu]

LGTM with these changes. Thanks!

ELF/LinkerScript.cpp

290

Again, it is hard to read if you call both ELF program headers and linker script's PHDRS command "headers". Rename Hdr -> Cmd.

306

continue and break are interchangeable in this context, but mixing them is confusing. Please be consistent -- I'd use break here.

321

Ditto

339

You can remove Script<ELFT>::X->.

732

This should be readOutputSectionPhdrs.

739

Return a vector of StringRefs from this function instead of mutating a member.

752

Mutating the last phdrs command here is too subtle. You want to make this function return a phdr type instead of setting it to a member and returning nothing.

ELF/LinkerScript.h

50

We are handling various types of headers, so "Headers" is confusing. Rename Phdrs.

[Hektve87]

(~~~~)

ELF/LinkerScript.cpp

290

(~~~~)

[Hektve87]

In D21995#482705, @evgeny777 wrote:

Review updated

(~~~~)

[Hektve87]

(~~~~)

In D21995#481621, @evgeny777 wrote:

Review updated

(~~~~)

[Hektve87]

(~~~~)

In D21995#481621, @evgeny777 wrote:

Review updated

(~~~~)

In D21995#487820, @ruiu wrote:

LGTM with these changes. Thanks!

(~~~~)

[Hektve87]

(~~~~)

In D21995#481621, @evgeny777 wrote:

Review updated

(~~~~)

In D21995#487820, @ruiu wrote:

LGTM with these changes. Thanks!

(~~~~)

In D21995#477888, @evgeny777 wrote:

Review updated.
Common stuff moved to Writer.h
createPhdrsUsingSpec moved to LinkerScript as createScriptedPhdrs.
Explicit template instantiation added where needed.

(~~~~)

[Hektve87]

In D21995#487820, @ruiu wrote:

LGTM with these changes. Thanks!

[[~~~~]]

ELF/LinkerScript.h

 //===- LinkerScript.h -------------------------------------------*- C++ -*-===//
 //
 //                             The LLVM Linker
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLD_ELF_LINKER_SCRIPT_H
 #define LLD_ELF_LINKER_SCRIPT_H
 
+#include "Writer.h"
 #include "lld/Core/LLVM.h"
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/MapVector.h"
 #include "llvm/Support/Allocator.h"
 #include "llvm/Support/MemoryBuffer.h"
 
 namespace lld {
 namespace elf {
 
 // Parses a linker script. Calling this function updates
 // Config and ScriptConfig.
 void readLinkerScript(MemoryBufferRef MB);
 
 class ScriptParser;

 // ExprKind is a location counter change, like ". = . + 0x1000"
 // SectionKind is a description of output section, like ".data :..."
 enum SectionsCommandKind { ExprKind, SectionKind, SymbolAssignmentKind };
 
 struct SectionsCommand {
   SectionsCommandKind Kind;
   std::vector<StringRef> Expr;
   StringRef Name;
+  std::vector<StringRef> Headers;
+};
+
+struct PhdrsCommand {
+  StringRef HeaderName;
+  unsigned HeaderType;
+  bool HasFilehdr;
+  bool HasPhdrs;
 };
 
 // ScriptConfiguration holds linker script parse results.
 struct ScriptConfiguration {
   // SECTIONS commands.
   std::vector<SectionRule> Sections;
 
   // Section fill attribute for each section.
   llvm::StringMap<std::vector<uint8_t>> Filler;
 
   // Used to assign addresses to sections.
   std::vector<SectionsCommand> Commands;
 
+  // Used to assign sections to headers.
+  std::vector<PhdrsCommand> PhdrsCommands;  
+  
   bool DoLayout = false;
 
   llvm::BumpPtrAllocator Alloc;
 
   // List of section patterns specified with KEEP commands. They will
   // be kept even if they are unused and --gc-sections is specified.
   std::vector<StringRef> KeptSections;
 };
 
 extern ScriptConfiguration *ScriptConfig;
 
 // This is a runner of the linker script.
 template <class ELFT> class LinkerScript {
   typedef typename ELFT::uint uintX_t;
 
 public:
+  typedef Phdr<ELFT> Phdr;
+
   StringRef getOutputSection(InputSectionBase<ELFT> *S);
   ArrayRef<uint8_t> getFiller(StringRef Name);
   bool isDiscarded(InputSectionBase<ELFT> *S);
   bool shouldKeep(InputSectionBase<ELFT> *S);
   void assignAddresses(ArrayRef<OutputSectionBase<ELFT> *> S);
   int compareSections(StringRef A, StringRef B);
   void addScriptedSymbols();
+  std::vector<Phdr> createPhdrs(ArrayRef<OutputSectionBase<ELFT> *> S);
+  bool hasPhdrsCommands();
 
 private:
   // "ScriptConfig" is a bit too long, so define a short name for it.
   ScriptConfiguration &Opt = *ScriptConfig;
 
   int getSectionIndex(StringRef Name);
+  std::vector<size_t> getPhdrIndicesForSection(StringRef Name);
 
   uintX_t Dot;
 };
 
 // Variable template is a C++14 feature, so we can't template
 // a global variable. Use a struct to workaround.
 template <class ELFT> struct Script { static LinkerScript<ELFT> *X; };
 template <class ELFT> LinkerScript<ELFT> *Script<ELFT>::X;
 
 } // namespace elf
 } // namespace lld
 
 #endif

ELF/LinkerScript.cpp

 #include "Driver.h"
 #include "InputSection.h"
 #include "OutputSections.h"
 #include "ScriptParser.h"
 #include "Strings.h"
 #include "Symbols.h"
 #include "SymbolTable.h"
 #include "Target.h"
+#include "Writer.h"
 #include "llvm/ADT/StringSwitch.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;
void LinkerScript<ELFT>::assignAddresses(
   // Orphan sections are sections present in the input files which
   // are not explicitly placed into the output file by the linker script.
   // We place orphan sections at end of file.
   // Other linkers places them using some heuristics as described in
   // https://sourceware.org/binutils/docs/ld/Orphan-Sections.html#Orphan-Sections.
   for (OutputSectionBase<ELFT> *Sec : Sections) {
     StringRef Name = Sec->getName();
     if (getSectionIndex(Name) == INT_MAX)
-      Opt.Commands.push_back({SectionKind, {}, Name});
+      Opt.Commands.push_back({SectionKind, {}, Name, {}});
   }
 
   // Assign addresses as instructed by linker script SECTIONS sub-commands.
   Dot = Out<ELFT>::ElfHeader->getSize() + Out<ELFT>::ProgramHeaders->getSize();
   uintX_t MinVA = std::numeric_limits<uintX_t>::max();
   uintX_t ThreadBssOffset = 0;
 
   for (SectionsCommand &Cmd : Opt.Commands) {
void LinkerScript<ELFT>::assignAddresses(
   MinVA = alignDown(MinVA - Out<ELFT>::ElfHeader->getSize() -
                         Out<ELFT>::ProgramHeaders->getSize(),
                     Target->PageSize);
   Out<ELFT>::ElfHeader->setVA(MinVA);
   Out<ELFT>::ProgramHeaders->setVA(Out<ELFT>::ElfHeader->getSize() + MinVA);
 }
 
 template <class ELFT>
+std::vector<Phdr<ELFT>>
+LinkerScript<ELFT>::createPhdrs(ArrayRef<OutputSectionBase<ELFT> *> Sections) {
+  int TlsNum = -1;
+  int NoteNum = -1;
+  int RelroNum = -1;
+  Phdr *Load = nullptr;
+  uintX_t Flags = PF_R;
+  std::vector<Phdr> Phdrs;
+
+  for (const PhdrsCommand &Hdr : Opt.PhdrsCommands) {
+    Phdrs.emplace_back(Hdr.HeaderType, PF_R);
+    Phdr &Added = Phdrs.back();
+
+    if (Hdr.HasFilehdr)
+      Added.AddSec(Out<ELFT>::ElfHeader);
+    if (Hdr.HasPhdrs)
+      Added.AddSec(Out<ELFT>::ProgramHeaders);
+
+    switch (Hdr.HeaderType) {
+    case PT_INTERP:
+      if (needsInterpSection<ELFT>())
+        Added.AddSec(Out<ELFT>::Interp);
+      break;
+    case PT_DYNAMIC:
+      if (!isOutputDynamic<ELFT>())
+        continue;
+      Added.H.p_flags = toPhdrFlags(Out<ELFT>::Dynamic->getFlags());
+      Added.AddSec(Out<ELFT>::Dynamic);
+      break;
+    case PT_TLS:
+      TlsNum = Phdrs.size() - 1;
+      break;
+    case PT_NOTE:
+      NoteNum = Phdrs.size() - 1;
+      break;
+    case PT_GNU_RELRO:
+      RelroNum = Phdrs.size() - 1;
+      break;
+    case PT_GNU_EH_FRAME:
+      if (Out<ELFT>::EhFrame->empty() || !Out<ELFT>::EhFrameHdr)
+        continue;
+      Added.H.p_flags = toPhdrFlags(Out<ELFT>::EhFrameHdr->getFlags());
+      Added.AddSec(Out<ELFT>::EhFrameHdr);
+      break;
+    }
+  }
+
+  for (OutputSectionBase<ELFT> *Sec : Sections) {
+    if (!(Sec->getFlags() & SHF_ALLOC))
+      break;
+
+    if (TlsNum != -1 && (Sec->getFlags() & SHF_TLS))
+      Phdrs[TlsNum].AddSec(Sec);
+
+    if (!needsPtLoad<ELFT>(Sec))
+      continue;
+
+    std::vector<size_t> HeaderIds =
+        Script<ELFT>::X->getPhdrIndicesForSection(Sec->getName());
+
+    if (!HeaderIds.empty()) {
+      // Assign headers specified by linker script
+      for (size_t HdrId : HeaderIds) {
+        Phdrs[HdrId].AddSec(Sec);
+        Phdrs[HdrId].H.p_flags |= toPhdrFlags(Sec->getFlags());
+      }
+    } else {
+      // If we have no load segment or flags've changed then we want new load
+      // segment.
+      uintX_t NewFlags = toPhdrFlags(Sec->getFlags());
+      if (Load == nullptr || Flags != NewFlags) {
+        Load = &*Phdrs.emplace(Phdrs.end(), PT_LOAD, NewFlags);
+        Flags = NewFlags;
+      }
+      Load->AddSec(Sec);
+    }
+
+    if (RelroNum != -1 && isRelroSection(Sec))
+      Phdrs[RelroNum].AddSec(Sec);
+    if (NoteNum != -1 && Sec->getType() == SHT_NOTE)
+      Phdrs[NoteNum].AddSec(Sec);
+  }
+  return Phdrs;
+}
+
+template <class ELFT>
 ArrayRef<uint8_t> LinkerScript<ELFT>::getFiller(StringRef Name) {
   auto I = Opt.Filler.find(Name);
   if (I == Opt.Filler.end())
     return {};
   return I->second;
 }
 
 // Returns the index of the given section name in linker script

 int LinkerScript<ELFT>::compareSections(StringRef A, StringRef B) {
   int I = getSectionIndex(A);
   int J = getSectionIndex(B);
   if (I == INT_MAX && J == INT_MAX)
     return 0;
   return I < J ? -1 : 1;
 }
 
 template <class ELFT>
 void LinkerScript<ELFT>::addScriptedSymbols() {
   for (SectionsCommand &Cmd : Opt.Commands)
     if (Cmd.Kind == SymbolAssignmentKind)
       Symtab<ELFT>::X->addAbsolute(Cmd.Name, STV_DEFAULT);
 }
 
+template <class ELFT> bool LinkerScript<ELFT>::hasPhdrsCommands() {
+  return !Opt.PhdrsCommands.empty();
+}
+
+// Returns indices ELF headers containing specific section, identified
+// by Name. Each index is a zero based number of ELF header listed within
+// PHDRS {} script block.
+template <class ELFT>
+std::vector<size_t>
+LinkerScript<ELFT>::getPhdrIndicesForSection(StringRef Name) {
+  std::vector<size_t> Indices;
+  auto ItSect = std::find_if(
+      Opt.Commands.begin(), Opt.Commands.end(),
+      [Name](const SectionsCommand &Cmd) { return Cmd.Name == Name; });
+  if (ItSect != Opt.Commands.end()) {
+    SectionsCommand &SecCmd = (*ItSect);
+    for (StringRef HdrName : SecCmd.Headers) {
+      auto ItHdr = std::find_if(
+          Opt.PhdrsCommands.rbegin(), Opt.PhdrsCommands.rend(),
+          [HdrName](PhdrsCommand &Cmd) { return Cmd.HeaderName == HdrName; });
+      if (ItHdr == Opt.PhdrsCommands.rend())
+        error("section header '" + HdrName + "' is not listed in PHDRS");
+      else
+        Indices.push_back(std::distance(ItHdr, Opt.PhdrsCommands.rend()) - 1);
+    }
+  }
+  return Indices;
+}
+
 class elf::ScriptParser : public ScriptParserBase {
   typedef void (ScriptParser::*Handler)();
 
 public:
   ScriptParser(StringRef S, bool B) : ScriptParserBase(S), IsUnderSysroot(B) {}
 
   void run();
 
 private:
   void addFile(StringRef Path);
 
   void readAsNeeded();
   void readEntry();
   void readExtern();
   void readGroup();
   void readInclude();
   void readNothing() {}
   void readOutput();
   void readOutputArch();
   void readOutputFormat();
+  void readPhdrs();
   void readSearchDir();
   void readSections();
 
   void readLocationCounterValue();
   void readOutputSectionDescription(StringRef OutSec);
+  void readOutputSectionHeaders();
+  void readPhdrsType();
   void readSymbolAssignment(StringRef Name);
   std::vector<StringRef> readSectionsCommandExpr();
 
   const static StringMap<Handler> Cmd;
   ScriptConfiguration &Opt = *ScriptConfig;
   StringSaver Saver = {ScriptConfig->Alloc};
   bool IsUnderSysroot;
 };
 
 const StringMap<elf::ScriptParser::Handler> elf::ScriptParser::Cmd = {
     {"ENTRY", &ScriptParser::readEntry},
     {"EXTERN", &ScriptParser::readExtern},
     {"GROUP", &ScriptParser::readGroup},
     {"INCLUDE", &ScriptParser::readInclude},
     {"INPUT", &ScriptParser::readGroup},
     {"OUTPUT", &ScriptParser::readOutput},
     {"OUTPUT_ARCH", &ScriptParser::readOutputArch},
     {"OUTPUT_FORMAT", &ScriptParser::readOutputFormat},
+    {"PHDRS", &ScriptParser::readPhdrs},
     {"SEARCH_DIR", &ScriptParser::readSearchDir},
     {"SECTIONS", &ScriptParser::readSections},
     {";", &ScriptParser::readNothing}};
 
 void ScriptParser::run() {
   while (!atEOF()) {
     StringRef Tok = next();
     if (Handler Fn = Cmd.lookup(Tok))
       (this->*Fn)();
     else
       setError("unknown directive: " + Tok);
if (Tok != ",") {
     return;
   }
   next();
   expect(",");
   next();
   expect(")");
 }
 
+void ScriptParser::readPhdrs() {
+  expect("{");
+  while (!Error && !skip("}")) {
+    StringRef Tok = next();
+    Opt.PhdrsCommands.push_back({Tok, PT_NULL, false, false});
+    PhdrsCommand &PhdrCmd = Opt.PhdrsCommands.back();
+
+    readPhdrsType();
+    do {
+      Tok = next();
+      if (Tok == ";")
+        break;
+      if (Tok == "FILEHDR")
+        PhdrCmd.HasFilehdr = true;
+      else if (Tok == "PHDRS")
+        PhdrCmd.HasPhdrs = true;
+      else
+        setError("unexpected header attribute: " + Tok);
+    } while (!Error);
+  }
+}
+
 void ScriptParser::readSearchDir() {
   expect("(");
   Config->SearchPaths.push_back(next());
   expect(")");
 }
 
 void ScriptParser::readSections() {
   Opt.DoLayout = true;
   expect("{");
   while (!Error && !skip("}")) {
     StringRef Tok = peek();
     if (Tok == ".") {
       readLocationCounterValue();
       continue;
     }
     next();
     if (peek() == "=")
       readSymbolAssignment(Tok);
     else
       readOutputSectionDescription(Tok);
   }
 }
 
 void ScriptParser::readLocationCounterValue() {
   expect(".");
   expect("=");
   std::vector<StringRef> Expr = readSectionsCommandExpr();
   if (Expr.empty())
     error("error in location counter expression");
   else
-    Opt.Commands.push_back({ExprKind, std::move(Expr), ""});
+    Opt.Commands.push_back({ExprKind, std::move(Expr), "", {}});
 }
 
 void ScriptParser::readOutputSectionDescription(StringRef OutSec) {
-  Opt.Commands.push_back({SectionKind, {}, OutSec});
+  Opt.Commands.push_back({SectionKind, {}, OutSec, {}});
   expect(":");
   expect("{");
 
   while (!Error && !skip("}")) {
     StringRef Tok = next();
     if (Tok == "*") {
       expect("(");
       while (!Error && !skip(")"))
         Opt.Sections.emplace_back(OutSec, next());
     } else if (Tok == "KEEP") {
       expect("(");
       expect("*");
       expect("(");
       while (!Error && !skip(")")) {
         StringRef Sec = next();
         Opt.Sections.emplace_back(OutSec, Sec);
         Opt.KeptSections.push_back(Sec);
       }
       expect(")");
     } else {
       setError("unknown command " + Tok);
     }
   }
+  readOutputSectionHeaders();
 
   StringRef Tok = peek();
   if (Tok.startswith("=")) {
     if (!Tok.startswith("=0x")) {
       setError("filler should be a hexadecimal value");
       return;
     }
     Tok = Tok.substr(3);
     Opt.Filler[OutSec] = parseHex(Tok);
     next();
   }
 }
 
 void ScriptParser::readSymbolAssignment(StringRef Name) {
   expect("=");
   std::vector<StringRef> Expr = readSectionsCommandExpr();
   if (Expr.empty())
     error("error in symbol assignment expression");
   else
-    Opt.Commands.push_back({SymbolAssignmentKind, std::move(Expr), Name});
+    Opt.Commands.push_back({SymbolAssignmentKind, std::move(Expr), Name, {}});
 }
 
 std::vector<StringRef> ScriptParser::readSectionsCommandExpr() {
   std::vector<StringRef> Expr;
   while (!Error) {
     StringRef Tok = next();
     if (Tok == ";")
       break;
     Expr.push_back(Tok);
   }
   return Expr;
 }
 
+void ScriptParser::readOutputSectionHeaders() {
+  while (!Error && peek().startswith(":")) {    
+    StringRef Tok = next();
+    Tok = (Tok.size() == 1) ? next() : Tok.substr(1);
+    if (Tok.empty())
+      setError("section header name is empty");
+    else
+      Opt.Commands.back().Headers.push_back(Tok); 
+  } 
+}
+
+void ScriptParser::readPhdrsType() {
+  static const char *typeNames[] = {
+      "PT_NULL",         "PT_LOAD",      "PT_DYNAMIC",  "PT_INTERP",
+      "PT_NOTE",         "PT_SHLIB",     "PT_PHDR",     "PT_TLS",
+      "PT_GNU_EH_FRAME", "PT_GNU_STACK", "PT_GNU_RELRO"};
+  static unsigned typeCodes[] = {
+      PT_NULL, PT_LOAD, PT_DYNAMIC,      PT_INTERP,    PT_NOTE,     PT_SHLIB,
+      PT_PHDR, PT_TLS,  PT_GNU_EH_FRAME, PT_GNU_STACK, PT_GNU_RELRO};
+
+  PhdrsCommand &Cmd = Opt.PhdrsCommands.back();
+  StringRef Tok = next();
+  auto It = std::find(std::begin(typeNames), std::end(typeNames), Tok);
+  if (It != std::end(typeNames))
+    Cmd.HeaderType = typeCodes[std::distance(std::begin(typeNames), It)];
+  else
+    setError("invalid header type");
+}
+
 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;
 }

ELF/Writer.h

 //===- Writer.h -------------------------------------------------*- C++ -*-===//
 //
 //                             The LLVM Linker
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLD_ELF_WRITER_H
 #define LLD_ELF_WRITER_H
 
+#include <cstdint>
 #include <memory>
 
 namespace llvm {
   class StringRef;
 }
 
 namespace lld {
 namespace elf {
+template <class ELFT> class OutputSectionBase;
 template <class ELFT> class InputSectionBase;
 template <class ELFT> class ObjectFile;
 template <class ELFT> class SymbolTable;
-
 template <class ELFT> void writeResult(SymbolTable<ELFT> *Symtab);
-
 template <class ELFT> void markLive();
+template <class ELFT> bool needsInterpSection();
+template <class ELFT> bool isOutputDynamic();
+template <class ELFT> bool isRelroSection(OutputSectionBase<ELFT> *Sec);
+template <class ELFT> bool needsPtLoad(OutputSectionBase<ELFT> *Sec);
+uint32_t toPhdrFlags(uint64_t Flags);
+
+// This describes a program header entry.
+// Each contains type, access flags and range of output sections that will be
+// placed in it.
+template<class ELFT>
+struct Phdr {
+  Phdr(unsigned Type, unsigned Flags);
+  void AddSec(OutputSectionBase<ELFT> *Sec);
+
+  typename ELFT::Phdr H = {};
+  OutputSectionBase<ELFT> *First = nullptr;
+  OutputSectionBase<ELFT> *Last = nullptr;
+};
 
 template <class ELFT>
 llvm::StringRef getOutputSectionName(InputSectionBase<ELFT> *S);
 
 template <class ELFT>
 void reportDiscarded(InputSectionBase<ELFT> *IS,
                      const std::unique_ptr<elf::ObjectFile<ELFT>> &File);
 }
 }
 
 #endif

ELF/Writer.cpp

public:
   typedef typename ELFT::Phdr Elf_Phdr;
   typedef typename ELFT::Sym Elf_Sym;
   typedef typename ELFT::SymRange Elf_Sym_Range;
   typedef typename ELFT::Rela Elf_Rela;
   Writer(SymbolTable<ELFT> &S) : Symtab(S) {}
   void run();
 
 private:
-  // This describes a program header entry.
-  // Each contains type, access flags and range of output sections that will be
-  // placed in it.
-  struct Phdr {
-    Phdr(unsigned Type, unsigned Flags) {
-      H.p_type = Type;
-      H.p_flags = Flags;
-    }
-    Elf_Phdr H = {};
-    OutputSectionBase<ELFT> *First = nullptr;
-    OutputSectionBase<ELFT> *Last = nullptr;
-  };
+  typedef Phdr<ELFT> Phdr;
 
   void copyLocalSymbols();
   void addReservedSymbols();
   void createSections();
   void addPredefinedSections();
   bool needsGot();
 
   void createPhdrs();
   void assignAddresses();
   void assignFileOffsets();
   void setPhdrs();
   void fixHeaders();
   void fixSectionAlignments();
   void fixAbsoluteSymbols();
   void openFile();
   void writeHeader();
   void writeSections();
   void writeBuildId();
-  bool needsInterpSection() const {
-    return !Symtab.getSharedFiles().empty() && !Config->DynamicLinker.empty();
-  }
-  bool isOutputDynamic() const {
-    return !Symtab.getSharedFiles().empty() || Config->Pic;
-  }
 
   void addCommonSymbols(std::vector<DefinedCommon *> &Syms);
 
   std::unique_ptr<llvm::FileOutputBuffer> Buffer;
 
   BumpPtrAllocator Alloc;
   std::vector<OutputSectionBase<ELFT> *> OutputSections;
   std::vector<std::unique_ptr<OutputSectionBase<ELFT>>> OwningSections;
template <class ELFT> void Writer<ELFT>::run() {
   addReservedSymbols();
   createSections();
   if (HasError)
     return;
 
   if (Config->Relocatable) {
     assignFileOffsets();
   } else {
+    if (Script<ELFT>::X->hasPhdrsCommands())
+      Phdrs = Script<ELFT>::X->createPhdrs(OutputSections);
+    else
       createPhdrs();
     fixHeaders();
     if (ScriptConfig->DoLayout) {
       Script<ELFT>::X->assignAddresses(OutputSections);
     } else {
       fixSectionAlignments();
       assignAddresses();
     }
     assignFileOffsets();
return StringSwitch<int>(SectionName)
       .Case(".tocbss", 0)
       .Case(".branch_lt", 2)
       .Case(".toc", 3)
       .Case(".toc1", 4)
       .Case(".opd", 5)
       .Default(1);
 }
 
-template <class ELFT> static bool isRelroSection(OutputSectionBase<ELFT> *Sec) {
+template <class ELFT> bool elf::isRelroSection(OutputSectionBase<ELFT> *Sec) {
   if (!Config->ZRelro)
     return false;
   typename ELFT::uint Flags = Sec->getFlags();
   if (!(Flags & SHF_ALLOC) || !(Flags & SHF_WRITE))
     return false;
   if (Flags & SHF_TLS)
     return true;
   uint32_t Type = Sec->getType();
static bool compareSections(OutputSectionBase<ELFT> *A,
   // within the same PT_LOAD.
   if (Config->EMachine == EM_PPC64)
     return getPPC64SectionRank(A->getName()) <
            getPPC64SectionRank(B->getName());
 
   return false;
 }
 
+uint32_t elf::toPhdrFlags(uint64_t Flags) {
+  uint32_t Ret = PF_R;
+  if (Flags & SHF_WRITE)
+    Ret |= PF_W;
+  if (Flags & SHF_EXECINSTR)
+    Ret |= PF_X;
+  return Ret;
+}
+
+// Various helper functions
+template <class ELFT> bool elf::needsInterpSection() {
+  return !Symtab<ELFT>::X->getSharedFiles().empty() &&
+         !Config->DynamicLinker.empty();
+}
+
+template <class ELFT> bool elf::isOutputDynamic() {
+  return !Symtab<ELFT>::X->getSharedFiles().empty() || Config->Pic;
+}
+
+// Program header entry
+template<class ELFT>
+Phdr<ELFT>::Phdr(unsigned Type, unsigned Flags) {
+  H.p_type = Type;
+  H.p_flags = Flags;
+}
+
+template<class ELFT>
+void Phdr<ELFT>::AddSec(OutputSectionBase<ELFT> *Sec) {
+  Last = Sec;
+  if (!First)
+    First = Sec;
+  H.p_align = std::max<typename ELFT::uint>(H.p_align, Sec->getAlignment());
+}
+
 // Until this function is called, common symbols do not belong to any section.
 // This function adds them to end of BSS section.
 template <class ELFT>
 void Writer<ELFT>::addCommonSymbols(std::vector<DefinedCommon *> &Syms) {
   if (Syms.empty())
     return;
 
   // Sort the common symbols by alignment as an heuristic to pack them better.
   std::stable_sort(Syms.begin(), Syms.end(),
                    [](const DefinedCommon *A, const DefinedCommon *B) {
                      return A->Alignment > B->Alignment;
                    });

 
 // The beginning and the ending of .rel[a].plt section are marked
 // with __rel[a]_iplt_{start,end} symbols if it is a statically linked
 // executable. The runtime needs these symbols in order to resolve
 // all IRELATIVE relocs on startup. For dynamic executables, we don't
 // need these symbols, since IRELATIVE relocs are resolved through GOT
 // and PLT. For details, see http://www.airs.com/blog/archives/403.
 template <class ELFT> void Writer<ELFT>::addRelIpltSymbols() {
-  if (isOutputDynamic() || !Out<ELFT>::RelaPlt)
+  if (isOutputDynamic<ELFT>() || !Out<ELFT>::RelaPlt)
     return;
   StringRef S = Config->Rela ? "__rela_iplt_start" : "__rel_iplt_start";
   addOptionalSynthetic(Symtab, S, Out<ELFT>::RelaPlt, 0);
 
   S = Config->Rela ? "__rela_iplt_end" : "__rel_iplt_end";
   addOptionalSynthetic(Symtab, S, Out<ELFT>::RelaPlt,
                        DefinedSynthetic<ELFT>::SectionEnd);
 }
template <class ELFT> void Writer<ELFT>::addReservedSymbols() {
   // hidden one to avoid the undefined symbol error.
   if (!Config->Relocatable)
     Symtab.addIgnored("_GLOBAL_OFFSET_TABLE_");
 
   // __tls_get_addr is defined by the dynamic linker for dynamic ELFs. For
   // static linking the linker is required to optimize away any references to
   // __tls_get_addr, so it's not defined anywhere. Create a hidden definition
   // to avoid the undefined symbol error.
-  if (!isOutputDynamic())
+  if (!isOutputDynamic<ELFT>())
     Symtab.addIgnored("__tls_get_addr");
 
   auto Define = [this](StringRef S, DefinedRegular<ELFT> *&Sym1,
                        DefinedRegular<ELFT> *&Sym2) {
     Sym1 = Symtab.addIgnored(S, STV_DEFAULT);
 
     // The name without the underscore is not a reserved name,
     // so it is defined only when there is a reference against it.
template <class ELFT> static void sortCtorsDtors(OutputSectionBase<ELFT> *S) {
   if (S)
     reinterpret_cast<OutputSection<ELFT> *>(S)->sortCtorsDtors();
 }
 
 // Create output section objects and add them to OutputSections.
 template <class ELFT> void Writer<ELFT>::createSections() {
   // Add .interp first because some loaders want to see that section
   // on the first page of the executable file when loaded into memory.
-  if (needsInterpSection())
+  if (needsInterpSection<ELFT>())
     OutputSections.push_back(Out<ELFT>::Interp);
 
   // A core file does not usually contain unmodified segments except
   // the first page of the executable. Add the build ID section now
   // so that the section is included in the first page.
   if (Out<ELFT>::BuildId)
     OutputSections.push_back(Out<ELFT>::BuildId);
 
if (!Config->Relocatable) {
     for (OutputSectionBase<ELFT> *Sec : RegularSections)
       addStartStopSymbols(Sec);
   }
 
   // Add _DYNAMIC symbol. Unlike GNU gold, our _DYNAMIC symbol has no type.
   // It should be okay as no one seems to care about the type.
   // Even the author of gold doesn't remember why gold behaves that way.
   // https://sourceware.org/ml/binutils/2002-03/msg00360.html
-  if (isOutputDynamic())
+  if (isOutputDynamic<ELFT>())
     Symtab.addSynthetic("_DYNAMIC", Out<ELFT>::Dynamic, 0);
 
   // Define __rel[a]_iplt_{start,end} symbols if needed.
   addRelIpltSymbols();
 
   // Add scripted symbols with zero values now.
   // Real values will be assigned later
   Script<ELFT>::X->addScriptedSymbols();
for (Symbol *S : Symtab.getSymbols()) {
     if (auto *C = dyn_cast<DefinedCommon>(Body))
       CommonSymbols.push_back(C);
 
     if (!includeInSymtab<ELFT>(*Body))
       continue;
     if (Out<ELFT>::SymTab)
       Out<ELFT>::SymTab->addSymbol(Body);
 
-    if (isOutputDynamic() && S->includeInDynsym()) {
+    if (isOutputDynamic<ELFT>() && S->includeInDynsym()) {
       Out<ELFT>::DynSymTab->addSymbol(Body);
       if (auto *SS = dyn_cast<SharedSymbol<ELFT>>(Body))
         if (SS->File->isNeeded())
           Out<ELFT>::VerNeed->addSymbol(SS);
     }
   }
 
   // Do not proceed if there was an undefined symbol.
template <class ELFT> void Writer<ELFT>::createSections() {
   unsigned I = 1;
   for (OutputSectionBase<ELFT> *Sec : OutputSections) {
     Sec->SectionIndex = I++;
     Sec->setSHName(Out<ELFT>::ShStrTab->addString(Sec->getName()));
   }
 
   // Finalizers fix each section's size.
   // .dynsym is finalized early since that may fill up .gnu.hash.
-  if (isOutputDynamic())
+  if (isOutputDynamic<ELFT>())
     Out<ELFT>::DynSymTab->finalize();
 
   // Fill other section headers. The dynamic table is finalized
   // at the end because some tags like RELSZ depend on result
   // of finalizing other sections. The dynamic string table is
   // finalized once the .dynamic finalizer has added a few last
   // strings. See DynamicSection::finalize()
   for (OutputSectionBase<ELFT> *Sec : OutputSections)
     if (Sec != Out<ELFT>::DynStrTab && Sec != Out<ELFT>::Dynamic)
       Sec->finalize();
 
-  if (isOutputDynamic())
+  if (isOutputDynamic<ELFT>())
     Out<ELFT>::Dynamic->finalize();
 
   // Now that all output offsets are fixed. Finalize mergeable sections
   // to fix their maps from input offsets to output offsets.
   for (OutputSectionBase<ELFT> *Sec : OutputSections)
     Sec->finalizePieces();
 }
 
if (C)
       OutputSections.push_back(C);
   };
 
   // This order is not the same as the final output order
   // because we sort the sections using their attributes below.
   Add(Out<ELFT>::SymTab);
   Add(Out<ELFT>::ShStrTab);
   Add(Out<ELFT>::StrTab);
-  if (isOutputDynamic()) {
+  if (isOutputDynamic<ELFT>()) {
     Add(Out<ELFT>::DynSymTab);
 
     bool HasVerNeed = Out<ELFT>::VerNeed->getNeedNum() != 0;
     if (Out<ELFT>::VerDef || HasVerNeed)
       Add(Out<ELFT>::VerSym);
     Add(Out<ELFT>::VerDef);
     if (HasVerNeed)
       Add(Out<ELFT>::VerNeed);
 
     Add(Out<ELFT>::GnuHashTab);
     Add(Out<ELFT>::HashTab);
     Add(Out<ELFT>::Dynamic);
     Add(Out<ELFT>::DynStrTab);
     if (Out<ELFT>::RelaDyn->hasRelocs())
       Add(Out<ELFT>::RelaDyn);
     Add(Out<ELFT>::MipsRldMap);
   }
 
   // We always need to add rel[a].plt to output if it has entries.
   // Even during static linking it can contain R_[*]_IRELATIVE relocations.
   if (Out<ELFT>::RelaPlt && Out<ELFT>::RelaPlt->hasRelocs()) {
     Add(Out<ELFT>::RelaPlt);
-    Out<ELFT>::RelaPlt->Static = !isOutputDynamic();
+    Out<ELFT>::RelaPlt->Static = !isOutputDynamic<ELFT>();
   }
 
   if (needsGot())
     Add(Out<ELFT>::Got);
   if (Out<ELFT>::GotPlt && !Out<ELFT>::GotPlt->empty())
     Add(Out<ELFT>::GotPlt);
   if (!Out<ELFT>::Plt->empty())
     Add(Out<ELFT>::Plt);
void Writer<ELFT>::addStartStopSymbols(OutputSectionBase<ELFT> *Sec) {
   if (SymbolBody *B = Symtab.find(Start))
     if (B->isUndefined())
       Symtab.addSynthetic(Start, Sec, 0);
   if (SymbolBody *B = Symtab.find(Stop))
     if (B->isUndefined())
       Symtab.addSynthetic(Stop, Sec, DefinedSynthetic<ELFT>::SectionEnd);
 }
 
-template <class ELFT> static bool needsPtLoad(OutputSectionBase<ELFT> *Sec) {
+template <class ELFT> bool elf::needsPtLoad(OutputSectionBase<ELFT> *Sec) {
   if (!(Sec->getFlags() & SHF_ALLOC))
     return false;
 
   // Don't allocate VA space for TLS NOBITS sections. The PT_TLS PHDR is
   // responsible for allocating space for them, not the PT_LOAD that
   // contains the TLS initialization image.
   if (Sec->getFlags() & SHF_TLS && Sec->getType() == SHT_NOBITS)
     return false;
   return true;
 }
 
-static uint32_t toPhdrFlags(uint64_t Flags) {
-  uint32_t Ret = PF_R;
-  if (Flags & SHF_WRITE)
-    Ret |= PF_W;
-  if (Flags & SHF_EXECINSTR)
-    Ret |= PF_X;
-  return Ret;
-}
-
 // Decide which program headers to create and which sections to include in each
 // one.
 template <class ELFT> void Writer<ELFT>::createPhdrs() {
   auto AddHdr = [this](unsigned Type, unsigned Flags) {
     return &*Phdrs.emplace(Phdrs.end(), Type, Flags);
   };
 
-  auto AddSec = [](Phdr &Hdr, OutputSectionBase<ELFT> *Sec) {
-    Hdr.Last = Sec;
-    if (!Hdr.First)
-      Hdr.First = Sec;
-    Hdr.H.p_align = std::max<uintX_t>(Hdr.H.p_align, Sec->getAlignment());
-  };
-
   // The first phdr entry is PT_PHDR which describes the program header itself.
   Phdr &Hdr = *AddHdr(PT_PHDR, PF_R);
-  AddSec(Hdr, Out<ELFT>::ProgramHeaders);
+  Hdr.AddSec(Out<ELFT>::ProgramHeaders);
 
   // PT_INTERP must be the second entry if exists.
-  if (needsInterpSection()) {
+  if (needsInterpSection<ELFT>()) {
     Phdr &Hdr = *AddHdr(PT_INTERP, toPhdrFlags(Out<ELFT>::Interp->getFlags()));
-    AddSec(Hdr, Out<ELFT>::Interp);
+    Hdr.AddSec(Out<ELFT>::Interp);
   }
 
   // Add the first PT_LOAD segment for regular output sections.
   uintX_t Flags = PF_R;
   Phdr *Load = AddHdr(PT_LOAD, Flags);
-  AddSec(*Load, Out<ELFT>::ElfHeader);
-  AddSec(*Load, Out<ELFT>::ProgramHeaders);
+  Load->AddSec(Out<ELFT>::ElfHeader);
+  Load->AddSec(Out<ELFT>::ProgramHeaders);
 
   Phdr TlsHdr(PT_TLS, PF_R);
   Phdr RelRo(PT_GNU_RELRO, PF_R);
   Phdr Note(PT_NOTE, PF_R);
   for (OutputSectionBase<ELFT> *Sec : OutputSections) {
     if (!(Sec->getFlags() & SHF_ALLOC))
       break;
 
     // If we meet TLS section then we create TLS header
     // and put all TLS sections inside for futher use when
     // assign addresses.
     if (Sec->getFlags() & SHF_TLS)
-      AddSec(TlsHdr, Sec);
+      TlsHdr.AddSec(Sec);
 
     if (!needsPtLoad<ELFT>(Sec))
       continue;
 
     // If flags changed then we want new load segment.
     uintX_t NewFlags = toPhdrFlags(Sec->getFlags());
     if (Flags != NewFlags) {
       Load = AddHdr(PT_LOAD, NewFlags);
       Flags = NewFlags;
     }
 
-    AddSec(*Load, Sec);
+    Load->AddSec(Sec);
 
     if (isRelroSection(Sec))
-      AddSec(RelRo, Sec);
+      RelRo.AddSec(Sec);
     if (Sec->getType() == SHT_NOTE)
-      AddSec(Note, Sec);
+      Note.AddSec(Sec);
   }
 
   // Add the TLS segment unless it's empty.
   if (TlsHdr.First)
     Phdrs.push_back(std::move(TlsHdr));
 
   // Add an entry for .dynamic.
-  if (isOutputDynamic()) {
+  if (isOutputDynamic<ELFT>()) {
     Phdr &H = *AddHdr(PT_DYNAMIC, toPhdrFlags(Out<ELFT>::Dynamic->getFlags()));
-    AddSec(H, Out<ELFT>::Dynamic);
+    H.AddSec(Out<ELFT>::Dynamic);
   }
 
   // PT_GNU_RELRO includes all sections that should be marked as
   // read-only by dynamic linker after proccessing relocations.
   if (RelRo.First)
     Phdrs.push_back(std::move(RelRo));
 
   // PT_GNU_EH_FRAME is a special section pointing on .eh_frame_hdr.
   if (!Out<ELFT>::EhFrame->empty() && Out<ELFT>::EhFrameHdr) {
     Phdr &Hdr = *AddHdr(PT_GNU_EH_FRAME,
                         toPhdrFlags(Out<ELFT>::EhFrameHdr->getFlags()));
-    AddSec(Hdr, Out<ELFT>::EhFrameHdr);
+    Hdr.AddSec(Out<ELFT>::EhFrameHdr);
   }
 
   // PT_GNU_STACK is a special section to tell the loader to make the
   // pages for the stack non-executable.
   if (!Config->ZExecStack)
     AddHdr(PT_GNU_STACK, PF_R | PF_W);
 
   if (Note.First)
     Phdrs.push_back(std::move(Note));
-
-  Out<ELFT>::ProgramHeaders->setSize(sizeof(Elf_Phdr) * Phdrs.size());
 }
 
 // The first section of each PT_LOAD and the first section after PT_GNU_RELRO
 // have to be page aligned so that the dynamic linker can set the permissions.
 template <class ELFT> void Writer<ELFT>::fixSectionAlignments() {
   for (const Phdr &P : Phdrs)
     if (P.H.p_type == PT_LOAD)
       P.First->PageAlign = true;
 

 // We should set file offsets and VAs for elf header and program headers
 // sections. These are special, we do not include them into output sections
 // list, but have them to simplify the code.
 template <class ELFT> void Writer<ELFT>::fixHeaders() {
   uintX_t BaseVA = ScriptConfig->DoLayout ? 0 : Config->VAStart;
   Out<ELFT>::ElfHeader->setVA(BaseVA);
   uintX_t Off = Out<ELFT>::ElfHeader->getSize();
   Out<ELFT>::ProgramHeaders->setVA(Off + BaseVA);
+  Out<ELFT>::ProgramHeaders->setSize(sizeof(Elf_Phdr) * Phdrs.size());
 }
 
 // Assign VAs (addresses at run-time) to output sections.
 template <class ELFT> void Writer<ELFT>::assignAddresses() {
   uintX_t VA = Config->VAStart + Out<ELFT>::ElfHeader->getSize() +
                Out<ELFT>::ProgramHeaders->getSize();
 
   uintX_t ThreadBssOffset = 0;
template <class ELFT> void Writer<ELFT>::writeBuildId() {
   Regions.push_back({Last, Start + FileSize});
   S->writeBuildId(Regions);
 }
 
 template void elf::writeResult<ELF32LE>(SymbolTable<ELF32LE> *Symtab);
 template void elf::writeResult<ELF32BE>(SymbolTable<ELF32BE> *Symtab);
 template void elf::writeResult<ELF64LE>(SymbolTable<ELF64LE> *Symtab);
 template void elf::writeResult<ELF64BE>(SymbolTable<ELF64BE> *Symtab);
+
+template struct elf::Phdr<ELF32LE>;
+template struct elf::Phdr<ELF32BE>;
+template struct elf::Phdr<ELF64LE>;
+template struct elf::Phdr<ELF64BE>;
+
+template bool elf::needsInterpSection<ELF32LE>();
+template bool elf::needsInterpSection<ELF32BE>();
+template bool elf::needsInterpSection<ELF64LE>();
+template bool elf::needsInterpSection<ELF64BE>();
+
+template bool elf::isOutputDynamic<ELF32LE>();
+template bool elf::isOutputDynamic<ELF32BE>();
+template bool elf::isOutputDynamic<ELF64LE>();
+template bool elf::isOutputDynamic<ELF64BE>();
+
+template bool elf::isRelroSection<ELF32LE>(OutputSectionBase<ELF32LE> *);
+template bool elf::isRelroSection<ELF32BE>(OutputSectionBase<ELF32BE> *);
+template bool elf::isRelroSection<ELF64LE>(OutputSectionBase<ELF64LE> *);
+template bool elf::isRelroSection<ELF64BE>(OutputSectionBase<ELF64BE> *);
+
+template bool elf::needsPtLoad<ELF32LE>(OutputSectionBase<ELF32LE> *);
+template bool elf::needsPtLoad<ELF32BE>(OutputSectionBase<ELF32BE> *);
+template bool elf::needsPtLoad<ELF64LE>(OutputSectionBase<ELF64LE> *);
+template bool elf::needsPtLoad<ELF64BE>(OutputSectionBase<ELF64BE> *);

test/ELF/linkerscript-phdrs.s

+# REQUIRES: x86
+# RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %s -o %t
+# RUN: echo "PHDRS {all PT_LOAD FILEHDR PHDRS ;} \
+# RUN:       SECTIONS { \
+# RUN:           . = 0x10000200; \
+# RUN:           .text : {*(.text.*)} :all \
+# RUN:           .foo : {*(.foo.*)} :all \
+# RUN:           .data : {*(.data.*)} :all}" > %t.script
+
+# RUN: ld.lld -o %t1 --script %t.script %t
+# RUN: llvm-readobj -program-headers %t1 | FileCheck %s
+# CHECK:     ProgramHeaders [
+# CHECK-NEXT:  ProgramHeader {
+# CHECK-NEXT:    Type: PT_LOAD (0x1)
+# CHECK-NEXT:    Offset: 0x0
+# CHECK-NEXT:    VirtualAddress: 0x10000000
+# CHECK-NEXT:    PhysicalAddress: 0x10000000
+# CHECK-NEXT:    FileSize: 521
+# CHECK-NEXT:    MemSize: 521
+# CHECK-NEXT:    Flags [ (0x7)
+# CHECK-NEXT:      PF_R (0x4)
+# CHECK-NEXT:      PF_W (0x2)
+# CHECK-NEXT:      PF_X (0x1)
+# CHECK-NEXT:    ]
+
+.global _start
+_start:
+ nop
+
+.section .foo.1,"a"
+foo1:
+ .long 0
+
+.section .foo.2,"aw"
+foo2:
+ .long 0