Index: lld/ELF/CMakeLists.txt
===================================================================
--- lld/ELF/CMakeLists.txt
+++ lld/ELF/CMakeLists.txt
@@ -23,6 +23,7 @@
   Driver.cpp
   DriverUtils.cpp
   EhFrame.cpp
+  EmbedFile.cpp
   Filesystem.cpp
   GdbIndex.cpp
   ICF.cpp
Index: lld/ELF/Config.h
===================================================================
--- lld/ELF/Config.h
+++ lld/ELF/Config.h
@@ -80,6 +80,8 @@
   llvm::StringMap<uint64_t> SectionStartMap;
   llvm::StringRef Chroot;
   llvm::StringRef DynamicLinker;
+  llvm::StringRef Embed;
+  llvm::StringRef EmbedHint;
   llvm::StringRef Entry;
   llvm::StringRef Emulation;
   llvm::StringRef Fini;
@@ -94,6 +96,7 @@
   llvm::StringRef SoName;
   llvm::StringRef Sysroot;
   llvm::StringRef ThinLTOCacheDir;
+  llvm::StringRef WriteEmbedHint;
   std::string Rpath;
   std::vector<VersionDefinition> VersionDefinitions;
   std::vector<llvm::StringRef> AuxiliaryList;
@@ -188,6 +191,7 @@
   llvm::Optional<uint64_t> ImageBase;
   uint64_t MaxPageSize;
   uint64_t ZStackSize;
+  unsigned EmbedReserveBytes;
   unsigned LTOPartitions;
   unsigned LTOO;
   unsigned Optimize;
Index: lld/ELF/Driver.cpp
===================================================================
--- lld/ELF/Driver.cpp
+++ lld/ELF/Driver.cpp
@@ -26,6 +26,7 @@
 #include "Driver.h"
 #include "Config.h"
 #include "Filesystem.h"
+#include "EmbedFile.h"
 #include "ICF.h"
 #include "InputFiles.h"
 #include "InputSection.h"
@@ -688,6 +689,10 @@
   Config->DynamicLinker = getDynamicLinker(Args);
   Config->EhFrameHdr =
       Args.hasFlag(OPT_eh_frame_hdr, OPT_no_eh_frame_hdr, false);
+  Config->Embed = Args.getLastArgValue(OPT_embed);
+  Config->EmbedHint = Args.getLastArgValue(OPT_embed_hint);
+  Config->EmbedReserveBytes =
+      args::getInteger(Args, OPT_embed_reserve_bytes, 0);
   Config->EmitRelocs = Args.hasArg(OPT_emit_relocs);
   Config->EnableNewDtags =
       Args.hasFlag(OPT_enable_new_dtags, OPT_disable_new_dtags, true);
@@ -759,6 +764,7 @@
   Config->WarnCommon = Args.hasFlag(OPT_warn_common, OPT_no_warn_common, false);
   Config->WarnSymbolOrdering =
       Args.hasFlag(OPT_warn_symbol_ordering, OPT_no_warn_symbol_ordering, true);
+  Config->WriteEmbedHint = Args.getLastArgValue(OPT_write_embed_hint);
   Config->ZCombreloc = getZFlag(Args, "combreloc", "nocombreloc", true);
   Config->ZCopyreloc = getZFlag(Args, "copyreloc", "nocopyreloc", true);
   Config->ZExecstack = getZFlag(Args, "execstack", "noexecstack", false);
@@ -1307,6 +1313,7 @@
   splitSections<ELFT>();
   markLive<ELFT>();
   demoteSymbols<ELFT>();
+  findEmbeddedSections();
   mergeSections();
   if (Config->ICF)
     doIcf<ELFT>();
Index: lld/ELF/EmbedFile.h
===================================================================
--- /dev/null
+++ lld/ELF/EmbedFile.h
@@ -0,0 +1,14 @@
+#include <vector>
+
+namespace lld {
+namespace elf {
+
+struct PhdrEntry;
+
+void findEmbeddedSections();
+void updateEmbeddedStringPieces();
+void addPtEmbed(std::vector<PhdrEntry *> &Phdrs);
+void writeEmbedHintFile();
+
+}
+}
Index: lld/ELF/EmbedFile.cpp
===================================================================
--- /dev/null
+++ lld/ELF/EmbedFile.cpp
@@ -0,0 +1,231 @@
+#include "EmbedFile.h"
+#include "Config.h"
+#include "InputFiles.h"
+#include "InputSection.h"
+#include "OutputSections.h"
+#include "Symbols.h"
+#include "SyntheticSections.h"
+#include "lld/Common/Memory.h"
+#include "lld/Common/Strings.h"
+#include <set>
+
+using namespace lld;
+using namespace lld::elf;
+using namespace llvm;
+using namespace llvm::ELF;
+using namespace llvm::support;
+
+static InputSection *EmbedFile;
+static std::vector<uint8_t> ReservedBytes;
+
+const uint32_t EmbedHintFileMagic = 0x4648454c;
+const uint32_t EmbedHintFileVersion = 0;
+
+struct EmbedHintFileHeader {
+  ulittle32_t Magic, Version, NumStrings, NumSections;
+};
+
+struct StringHint {
+  ulittle32_t Offset;
+};
+
+struct SectionHint {
+  ulittle32_t Offset, Size;
+};
+
+struct PieceToReplace {
+  MergeInputSection *MIS;
+  SectionPiece *Piece;
+  uint64_t EmbedFileOffset;
+};
+
+static std::vector<PieceToReplace> PiecesToReplace;
+
+void elf::findEmbeddedSections() {
+  if (Config->Embed.empty())
+    return;
+
+  auto EmbedFileBuf = readFile(Config->Embed);
+  if (!EmbedFileBuf)
+    return;
+  if (Config->EmbedReserveBytes) {
+    ReservedBytes.resize(Config->EmbedReserveBytes);
+    InputSection *ReservedBytesSec = make<InputSection>(
+        nullptr, SHF_ALLOC, SHT_PROGBITS, 1, ReservedBytes, ".rodata");
+    ReservedBytesSec->Live = true;
+    InputSections.push_back(ReservedBytesSec);
+  }
+
+  EmbedFile =
+      make<InputSection>(nullptr, SHF_ALLOC, SHT_PROGBITS, 4096,
+                         toArrayRef(EmbedFileBuf->getBuffer()), ".rodata");
+  EmbedFile->Live = true;
+  InputSections.push_back(EmbedFile);
+
+  auto EmbedHintFile = readFile(Config->EmbedHint);
+  if (!EmbedHintFile)
+    return;
+
+  auto *Hdr = reinterpret_cast<const EmbedHintFileHeader *>(
+      EmbedHintFile->getBufferStart());
+  if (EmbedHintFile->getBufferSize() < sizeof(EmbedHintFileHeader) ||
+      Hdr->Magic != EmbedHintFileMagic || Hdr->Version != EmbedHintFileVersion)
+    fatal("--embed-hint: invalid hint file");
+
+  ArrayRef<StringHint> StringHintArr{
+      reinterpret_cast<const StringHint *>(Hdr + 1), Hdr->NumStrings};
+  ArrayRef<SectionHint> SectionHintArr{
+      reinterpret_cast<const SectionHint *>(StringHintArr.end()),
+      Hdr->NumSections};
+
+  DenseMap<StringRef, uint32_t> StringHints;
+  for (const StringHint &H : StringHintArr)
+    StringHints[EmbedFileBuf->getBufferStart() + H.Offset] = H.Offset;
+
+  DenseMap<StringRef, std::set<uint32_t>> SectionHints;
+  for (const SectionHint &H : SectionHintArr)
+    SectionHints[{EmbedFileBuf->getBufferStart() + H.Offset, H.Size}].insert(
+        H.Offset);
+
+  // Mapping from input sections to offsets into embedded file.
+  DenseMap<InputSection *, uint32_t> SectionMap;
+  auto HandleInputSection = [&](InputSection *IS) {
+    if (IS->Type != SHT_PROGBITS || IS->Flags != SHF_ALLOC ||
+        !IS->Name.startswith(".rodata") || IS->NumRelocations != 0)
+      return;
+    auto I = SectionHints.find(toStringRef(IS->Data));
+    if (I == SectionHints.end() || I->second.empty())
+      return;
+    for (auto OI = I->second.begin(), OE = I->second.end(); OI != OE; ++OI) {
+      if (*OI % IS->Alignment == 0) {
+        SectionMap[IS] = *OI;
+        I->second.erase(OI);
+        return;
+      }
+    }
+  };
+
+  auto HandleMergeInputSection = [&](MergeInputSection *MIS) {
+    if (MIS->Type != SHT_PROGBITS || !(MIS->Flags & SHF_ALLOC) ||
+        !(MIS->Flags & SHF_STRINGS) || !MIS->Name.startswith(".rodata") ||
+        MIS->Entsize != 1)
+      return;
+    for (auto &P : MIS->Pieces) {
+      if (!P.Live)
+        continue;
+      auto I = StringHints.find(
+          reinterpret_cast<const char *>(MIS->Data.data() + P.InputOff));
+      if (I == StringHints.end())
+        continue;
+      P.Live = false;
+      P.OutputOff = -I->second;
+      PiecesToReplace.push_back({MIS, &P, I->second});
+    }
+  };
+
+  for (InputSectionBase *ISB : InputSections) {
+    if (!ISB->Live)
+      continue;
+    if (auto *IS = dyn_cast<InputSection>(ISB))
+      HandleInputSection(IS);
+    else if (auto *MS = dyn_cast<MergeInputSection>(ISB))
+      HandleMergeInputSection(MS);
+  }
+
+  for (InputFile *F : ObjectFiles) {
+    for (Symbol *S : F->getSymbols()) {
+      auto *D = dyn_cast<Defined>(S);
+      if (!D)
+        continue;
+      auto *IS = dyn_cast_or_null<InputSection>(D->Section);
+      if (!IS)
+        continue;
+      auto I = SectionMap.find(IS);
+      if (I == SectionMap.end())
+        continue;
+      D->Value += I->second;
+      D->Section = EmbedFile;
+    }
+  }
+
+  for (auto &P : SectionMap)
+    P.first->Live = false;
+}
+
+void elf::updateEmbeddedStringPieces() {
+  for (auto &P : PiecesToReplace) {
+    uint64_t ParentVA = P.MIS->getParent()->getVA();
+    uint64_t StringVA = EmbedFile->getVA() + P.EmbedFileOffset;
+    P.Piece->OutputOff = StringVA - ParentVA;
+  }
+}
+
+void elf::writeEmbedHintFile() {
+  if (Config->WriteEmbedHint.empty())
+    return;
+
+  std::vector<InputSection *> HintSections;
+  std::vector<uint32_t> HintStrings;
+
+  auto HandleInputSection = [&](InputSection *IS) {
+    if (IS->Type != SHT_PROGBITS || IS->Flags != SHF_ALLOC ||
+        !IS->Name.startswith(".rodata"))
+      return;
+    HintSections.push_back(IS);
+  };
+
+  auto HandleMergeInputSection = [&](MergeInputSection *MIS) {
+    if (MIS->Type != SHT_PROGBITS || !(MIS->Flags & SHF_ALLOC) ||
+        !(MIS->Flags & SHF_STRINGS) || !MIS->Name.startswith(".rodata") ||
+        MIS->Entsize != 1)
+      return;
+    for (auto &P : MIS->Pieces) {
+      if (!P.Live)
+        continue;
+      HintStrings.push_back(MIS->getParent()->getParent()->Offset +
+                            MIS->getParent()->OutSecOff + P.OutputOff);
+    }
+  };
+
+  for (InputSectionBase *ISB : InputSections) {
+    if (!ISB->Live)
+      continue;
+    if (auto *MSS = dyn_cast<MergeSyntheticSection>(ISB))
+      for (auto *MIS : MSS->Sections)
+        HandleMergeInputSection(MIS);
+    else if (auto *IS = dyn_cast<InputSection>(ISB))
+      HandleInputSection(IS);
+  }
+
+  std::vector<uint32_t> Data;
+  Data.push_back(EmbedHintFileMagic);
+  Data.push_back(EmbedHintFileVersion);
+  Data.push_back(HintStrings.size());
+  Data.push_back(HintSections.size());
+
+  for (uint32_t Off : HintStrings)
+    Data.push_back(Off);
+
+  for (InputSection *IS : HintSections) {
+    Data.push_back(IS->getParent()->Offset + IS->OutSecOff);
+    Data.push_back(IS->Data.size());
+  }
+
+  std::error_code EC;
+  raw_fd_ostream OS(Config->WriteEmbedHint, EC, sys::fs::F_None);
+  if (EC) {
+    error("cannot open " + Config->WriteEmbedHint + ": " + EC.message());
+    return;
+  }
+
+  OS << StringRef{reinterpret_cast<const char *>(Data.data()), Data.size() * 4};
+}
+
+void elf::addPtEmbed(std::vector<PhdrEntry *> &Phdrs) {
+  if (!EmbedFile)
+    return;
+
+  auto *Phdr = make<PhdrEntry>(PT_LLVM_EMBED, PF_R);
+  Phdr->add(EmbedFile);
+  Phdrs.push_back(Phdr);
+}
Index: lld/ELF/InputSection.h
===================================================================
--- lld/ELF/InputSection.h
+++ lld/ELF/InputSection.h
@@ -38,6 +38,7 @@
 class SectionBase {
 public:
   enum Kind { Regular, EHFrame, Merge, Synthetic, Output };
+  enum SyntheticKind { SNone, SBss, SMerge };
 
   Kind kind() const { return (Kind)SectionKind; }
 
@@ -59,7 +60,7 @@
   // If GC is disabled, all sections are considered live by default.
   unsigned Live : 1;
 
-  unsigned Bss : 1;
+  unsigned SyntheticSectionKind : 2;
 
   // These corresponds to the fields in Elf_Shdr.
   uint32_t Alignment;
@@ -85,8 +86,8 @@
               uint64_t Entsize, uint64_t Alignment, uint32_t Type,
               uint32_t Info, uint32_t Link)
       : Name(Name), Repl(this), SectionKind(SectionKind), Live(false),
-        Bss(false), Alignment(Alignment), Flags(Flags), Entsize(Entsize),
-        Type(Type), Link(Link), Info(Info) {}
+        SyntheticSectionKind(SNone), Alignment(Alignment), Flags(Flags),
+        Entsize(Entsize), Type(Type), Link(Link), Info(Info) {}
 };
 
 // This corresponds to a section of an input file.
Index: lld/ELF/InputSection.cpp
===================================================================
--- lld/ELF/InputSection.cpp
+++ lld/ELF/InputSection.cpp
@@ -459,7 +459,7 @@
   OutputSection *OS = Sym.getOutputSection();
   if (!OS || !OS->PtLoad || !OS->PtLoad->FirstSec)
     fatal("SBREL relocation to " + Sym.getName() + " without static base");
-  return OS->PtLoad->FirstSec->Addr;
+  return cast<OutputSection>(OS->PtLoad->FirstSec)->Addr;
 }
 
 static uint64_t getRelocTargetVA(RelType Type, int64_t A, uint64_t P,
Index: lld/ELF/LinkerScript.cpp
===================================================================
--- lld/ELF/LinkerScript.cpp
+++ lld/ELF/LinkerScript.cpp
@@ -13,6 +13,7 @@
 
 #include "LinkerScript.h"
 #include "Config.h"
+#include "EmbedFile.h"
 #include "InputSection.h"
 #include "OutputSections.h"
 #include "SymbolTable.h"
@@ -1050,6 +1051,8 @@
     assignOffsets(cast<OutputSection>(Base));
   }
   Ctx = nullptr;
+
+  updateEmbeddedStringPieces();
 }
 
 // Creates program headers as instructed by PHDRS linker script command.
Index: lld/ELF/MapFile.cpp
===================================================================
--- lld/ELF/MapFile.cpp
+++ lld/ELF/MapFile.cpp
@@ -59,7 +59,8 @@
     for (Symbol *B : File->getSymbols())
       if (auto *DR = dyn_cast<Defined>(B))
         if (!DR->isSection() && DR->Section && DR->Section->Live &&
-            (DR->File == File || DR->NeedsPltAddr || DR->Section->Bss))
+            (DR->File == File || DR->NeedsPltAddr ||
+             isa<BssSection>(DR->Section)))
           V.push_back(DR);
   return V;
 }
Index: lld/ELF/Options.td
===================================================================
--- lld/ELF/Options.td
+++ lld/ELF/Options.td
@@ -111,6 +111,13 @@
     "Request creation of .eh_frame_hdr section and PT_GNU_EH_FRAME segment header",
     "Do not create .eh_frame_hdr section">;
 
+defm embed: Eq<"embed">, HelpText<"Path to file to embed for content reuse">;
+
+defm embed_hint: Eq<"embed-hint">, HelpText<"Path to content reuse embedding hint file">;
+
+defm embed_reserve_bytes: Eq<"embed-reserve-bytes">,
+  HelpText<"Number of bytes to reserve before the start of the embedded file (default 0)">;
+
 def emit_relocs: F<"emit-relocs">, HelpText<"Generate relocations in output">;
 
 def enable_new_dtags: F<"enable-new-dtags">,
@@ -354,6 +361,9 @@
 defm wrap: Eq<"wrap">, HelpText<"Use wrapper functions for symbol">,
   MetaVarName<"<symbol>">;
 
+defm write_embed_hint: Eq<"write-embed-hint">,
+  HelpText<"Write content embedding hints to the specified file">;
+
 def z: JoinedOrSeparate<["-"], "z">, MetaVarName<"<option>">,
   HelpText<"Linker option extensions">;
 
Index: lld/ELF/SyntheticSections.h
===================================================================
--- lld/ELF/SyntheticSections.h
+++ lld/ELF/SyntheticSections.h
@@ -162,7 +162,9 @@
   bool empty() const override { return getSize() == 0; }
   size_t getSize() const override { return Size; }
 
-  static bool classof(const SectionBase *S) { return S->Bss; }
+  static bool classof(const SectionBase *S) {
+    return S->SyntheticSectionKind == SBss;
+  }
   uint64_t Size;
 };
 
@@ -687,10 +689,16 @@
   void addSection(MergeInputSection *MS);
   std::vector<MergeInputSection *> Sections;
 
+  static bool classof(const SectionBase *S) {
+    return S->SyntheticSectionKind == SMerge;
+  }
+
 protected:
   MergeSyntheticSection(StringRef Name, uint32_t Type, uint64_t Flags,
                         uint32_t Alignment)
-      : SyntheticSection(Flags, Type, Alignment, Name) {}
+      : SyntheticSection(Flags, Type, Alignment, Name) {
+    SyntheticSectionKind = SMerge;
+  }
 };
 
 class MergeTailSection final : public MergeSyntheticSection {
Index: lld/ELF/SyntheticSections.cpp
===================================================================
--- lld/ELF/SyntheticSections.cpp
+++ lld/ELF/SyntheticSections.cpp
@@ -329,7 +329,7 @@
 
 BssSection::BssSection(StringRef Name, uint64_t Size, uint32_t Alignment)
     : SyntheticSection(SHF_ALLOC | SHF_WRITE, SHT_NOBITS, Alignment, Name) {
-  this->Bss = true;
+  this->SyntheticSectionKind = SBss;
   if (OutputSection *Sec = getParent())
     Sec->Alignment = std::max(Sec->Alignment, Alignment);
   this->Size = Size;
Index: lld/ELF/Writer.h
===================================================================
--- lld/ELF/Writer.h
+++ lld/ELF/Writer.h
@@ -18,9 +18,9 @@
 namespace lld {
 namespace elf {
 class InputFile;
-class OutputSection;
 class InputSectionBase;
 template <class ELFT> class ObjFile;
+class SectionBase;
 class SymbolTable;
 template <class ELFT> void writeResult();
 
@@ -29,7 +29,7 @@
 // placed in it.
 struct PhdrEntry {
   PhdrEntry(unsigned Type, unsigned Flags) : p_type(Type), p_flags(Flags) {}
-  void add(OutputSection *Sec);
+  void add(SectionBase *Sec);
 
   uint64_t p_paddr = 0;
   uint64_t p_vaddr = 0;
@@ -40,8 +40,8 @@
   uint32_t p_type = 0;
   uint32_t p_flags = 0;
 
-  OutputSection *FirstSec = nullptr;
-  OutputSection *LastSec = nullptr;
+  SectionBase *FirstSec = nullptr;
+  SectionBase *LastSec = nullptr;
   bool HasLMA = false;
 
   uint64_t LMAOffset = 0;
Index: lld/ELF/Writer.cpp
===================================================================
--- lld/ELF/Writer.cpp
+++ lld/ELF/Writer.cpp
@@ -11,6 +11,7 @@
 #include "AArch64ErrataFix.h"
 #include "CallGraphSort.h"
 #include "Config.h"
+#include "EmbedFile.h"
 #include "Filesystem.h"
 #include "LinkerScript.h"
 #include "MapFile.h"
@@ -134,7 +135,9 @@
       return false;
     if (!P->FirstSec)
       return true;
-    uint64_t Size = P->LastSec->Addr + P->LastSec->Size - P->FirstSec->Addr;
+    uint64_t Size = cast<OutputSection>(P->LastSec)->Addr +
+                    cast<OutputSection>(P->LastSec)->Size -
+                    cast<OutputSection>(P->FirstSec)->Addr;
     return Size == 0;
   });
 }
@@ -489,6 +492,8 @@
   if (errorCount())
     return;
 
+  writeEmbedHintFile();
+
   if (auto E = Buffer->commit())
     error("failed to write to the output file: " + toString(std::move(E)));
 }
@@ -831,13 +836,13 @@
   return false;
 }
 
-void PhdrEntry::add(OutputSection *Sec) {
+void PhdrEntry::add(SectionBase *Sec) {
   LastSec = Sec;
   if (!FirstSec)
     FirstSec = Sec;
   p_align = std::max(p_align, Sec->Alignment);
   if (p_type == PT_LOAD)
-    Sec->PtLoad = this;
+    cast<OutputSection>(Sec)->PtLoad = this;
 }
 
 // The beginning and the ending of .rel[a].plt section are marked
@@ -1614,6 +1619,7 @@
   if (!Config->Relocatable && !Config->OFormatBinary) {
     Phdrs = Script->hasPhdrsCommands() ? Script->createPhdrs() : createPhdrs();
     addPtArmExid(Phdrs);
+    addPtEmbed(Phdrs);
     Out::ProgramHeaders->Size = sizeof(Elf_Phdr) * Phdrs.size();
   }
 
@@ -1777,7 +1783,8 @@
     // an AT attribute.
     uint64_t NewFlags = computeFlags(Sec->getPhdrFlags());
     if ((Sec->LMAExpr && Load->LastSec != Out::ProgramHeaders) ||
-        Sec->MemRegion != Load->FirstSec->MemRegion || Flags != NewFlags) {
+        Sec->MemRegion != cast<OutputSection>(Load->FirstSec)->MemRegion ||
+        Flags != NewFlags) {
 
       Load = AddHdr(PT_LOAD, NewFlags);
       Flags = NewFlags;
@@ -1885,9 +1892,10 @@
 // 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() {
-  auto PageAlign = [](OutputSection *Cmd) {
-    if (Cmd && !Cmd->AddrExpr)
-      Cmd->AddrExpr = [=] {
+  auto PageAlign = [](SectionBase *S) {
+    auto *OS = cast<OutputSection>(S);
+    if (OS && !OS->AddrExpr)
+      OS->AddrExpr = [=] {
         return alignTo(Script->getDot(), Config->MaxPageSize);
       };
   };
@@ -1918,7 +1926,8 @@
 // virtual address (modulo the page size) so that the loader can load
 // executables without any address adjustment.
 static uint64_t getFileAlignment(uint64_t Off, OutputSection *Cmd) {
-  OutputSection *First = Cmd->PtLoad ? Cmd->PtLoad->FirstSec : nullptr;
+  OutputSection *First =
+      Cmd->PtLoad ? cast<OutputSection>(Cmd->PtLoad->FirstSec) : nullptr;
   // The first section in a PT_LOAD has to have congruent offset and address
   // module the page size.
   if (Cmd == First)
@@ -2012,18 +2021,41 @@
 // Finalize the program headers. We call this function after we assign
 // file offsets and VAs to all sections.
 template <class ELFT> void Writer<ELFT>::setPhdrs() {
+  auto Offset = [](SectionBase *S) {
+    if (auto *OS = dyn_cast<OutputSection>(S))
+      return OS->Offset;
+    auto *IS = cast<InputSection>(S);
+    return IS->getParent()->Offset + IS->OutSecOff;
+  };
+  auto Size = [](SectionBase *S) {
+    if (auto *OS = dyn_cast<OutputSection>(S))
+      return OS->Size;
+    return cast<InputSection>(S)->getSize();
+  };
+  auto VA = [](SectionBase *S) {
+    if (auto *OS = dyn_cast<OutputSection>(S))
+      return OS->Addr;
+    return cast<InputSection>(S)->getVA();
+  };
+  auto LMA = [](SectionBase *S) {
+    if (auto *OS = dyn_cast<OutputSection>(S))
+      return OS->getLMA();
+    auto *IS = cast<InputSection>(S);
+    return IS->getParent()->getLMA() + IS->OutSecOff;
+  };
+
   for (PhdrEntry *P : Phdrs) {
-    OutputSection *First = P->FirstSec;
-    OutputSection *Last = P->LastSec;
+    SectionBase *First = P->FirstSec;
+    SectionBase *Last = P->LastSec;
     if (First) {
-      P->p_filesz = Last->Offset - First->Offset;
+      P->p_filesz = Offset(Last) - Offset(First);
       if (Last->Type != SHT_NOBITS)
-        P->p_filesz += Last->Size;
-      P->p_memsz = Last->Addr + Last->Size - First->Addr;
-      P->p_offset = First->Offset;
-      P->p_vaddr = First->Addr;
+        P->p_filesz += Size(Last);
+      P->p_memsz = VA(Last) + Size(Last) - VA(First);
+      P->p_offset = Offset(First);
+      P->p_vaddr = VA(First);
       if (!P->HasLMA)
-        P->p_paddr = First->getLMA();
+        P->p_paddr = LMA(First);
     }
     if (P->p_type == PT_LOAD)
       P->p_align = std::max<uint64_t>(P->p_align, Config->MaxPageSize);
Index: llvm/include/llvm/BinaryFormat/ELF.h
===================================================================
--- llvm/include/llvm/BinaryFormat/ELF.h
+++ llvm/include/llvm/BinaryFormat/ELF.h
@@ -1145,6 +1145,8 @@
   PT_OPENBSD_WXNEEDED = 0x65a3dbe7,  // Program does W^X violations.
   PT_OPENBSD_BOOTDATA = 0x65a41be6,  // Section for boot arguments.
 
+  PT_LLVM_EMBED = 0x6fff4c00,
+
   // ARM program header types.
   PT_ARM_ARCHEXT = 0x70000000, // Platform architecture compatibility info
   // These all contain stack unwind tables.