[wip] ELF: Add a feature for sharing rodata with an embedded binary.

[pcc]

Summary

There is sometimes a need to distribute a binary that is compatible
with two or more architectures -- this is commonly known as a "fat
binary".

This patch allows you to create a fat binary with rodata sections
that are shared between architectures, in order to reduce overall
binary size. The way that it works is that you link one binary in the
usual way with a flag requesting that a hint file be written with the
locations of the rodata sections and strings, and then link another
binary with flags requesting that the first binary is embedded into
the second one and giving the path to the hint file.

Using the hint file, the linker removes rodata sections and strings
from the second binary whose content matches a section or string in the
first binary, and redirects any references to that section or string
to the matching one in the first binary, which is then embedded in
the rodata section in the second binary.

How can the embedded binary be loaded? Some dynamic loaders have a
feature that allows libraries to be loaded from an offset within a
file (such as Android's ANDROID_DLEXT_USE_LIBRARY_FD_OFFSET [1]),
so a program could arrange to use that, provided that it knows the
location of the embedded file. The location can be found using a
new program header, PT_LLVM_EMBED, which could also potentially be
used by a dynamic loader to load the embedded binary for the correct
architecture automatically.

The program header could also be used by another program to create
an appropriate container in another fat binary format, such as FatELF
[2], or the APK format used on Android [3], which is based on ZIP. A
flag allows you to specify a minimum amount of padding before the
embedded file, in case the container format requires a header to
appear immediately before the file (as ZIP does).

I'm mostly sharing this for feedback on the overall idea and design.
TODO:

• Write documentation. We probably need documentation for the ELF extension (i.e. the program header) as well as user documentation for the feature.
• Write tests.
• Clean up the code.

[1] https://android.googlesource.com/platform/bionic/+/da1994ced6fd870a9ad198c0435d3e5ebbf65636/libc/include/android/dlext.h#88
[2] https://icculus.org/fatelf/
[3] https://en.wikipedia.org/wiki/Android_application_package

lld/ELF/CMakeLists.txt

add_lld_library(lldELF
   Arch/PPC64.cpp
   Arch/SPARCV9.cpp
   Arch/X86.cpp
   Arch/X86_64.cpp
   CallGraphSort.cpp
   Driver.cpp
   DriverUtils.cpp
   EhFrame.cpp
+  EmbedFile.cpp
   Filesystem.cpp
   GdbIndex.cpp
   ICF.cpp
   InputFiles.cpp
   InputSection.cpp
   LTO.cpp
   LinkerScript.cpp
   MapFile.cpp

lld/ELF/Config.h

 // and such fields have the same name as the corresponding options.
 // Most fields are initialized by the driver.
 struct Configuration {
   uint8_t OSABI = 0;
   llvm::CachePruningPolicy ThinLTOCachePolicy;
   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;
   llvm::StringRef Init;
   llvm::StringRef LTOAAPipeline;
   llvm::StringRef LTONewPmPasses;
   llvm::StringRef LTOSampleProfile;
   llvm::StringRef MapFile;
   llvm::StringRef OutputFile;
   llvm::StringRef OptRemarksFilename;
   llvm::StringRef ProgName;
   llvm::StringRef SoName;
   llvm::StringRef Sysroot;
   llvm::StringRef ThinLTOCacheDir;
+  llvm::StringRef WriteEmbedHint;
   std::string Rpath;
   std::vector<VersionDefinition> VersionDefinitions;
   std::vector<llvm::StringRef> AuxiliaryList;
   std::vector<llvm::StringRef> FilterList;
   std::vector<llvm::StringRef> SearchPaths;
   std::vector<llvm::StringRef> SymbolOrderingFile;
   std::vector<llvm::StringRef> Undefined;
   std::vector<SymbolVersion> DynamicList;
struct Configuration {
   Target2Policy Target2;
   BuildIdKind BuildId = BuildIdKind::None;
   ELFKind EKind = ELFNoneKind;
   uint16_t DefaultSymbolVersion = llvm::ELF::VER_NDX_GLOBAL;
   uint16_t EMachine = llvm::ELF::EM_NONE;
   llvm::Optional<uint64_t> ImageBase;
   uint64_t MaxPageSize;
   uint64_t ZStackSize;
+  unsigned EmbedReserveBytes;
   unsigned LTOPartitions;
   unsigned LTOO;
   unsigned Optimize;
   unsigned ThinLTOJobs;
 
   // The following config options do not directly correspond to any
   // particualr command line options.
 

lld/ELF/Driver.cpp

 // simply trust the compiler driver to pass all required options and
 // don't try to make effort on our side.
 //
 //===----------------------------------------------------------------------===//
 
 #include "Driver.h"
 #include "Config.h"
 #include "Filesystem.h"
+#include "EmbedFile.h"
 #include "ICF.h"
 #include "InputFiles.h"
 #include "InputSection.h"
 #include "LinkerScript.h"
 #include "MarkLive.h"
 #include "OutputSections.h"
 #include "ScriptParser.h"
 #include "SymbolTable.h"
void LinkerDriver::readConfigs(opt::InputArgList &Args) {
   Config->DefineCommon = Args.hasFlag(OPT_define_common, OPT_no_define_common,
                                       !Args.hasArg(OPT_relocatable));
   Config->Demangle = Args.hasFlag(OPT_demangle, OPT_no_demangle, true);
   Config->DisableVerify = Args.hasArg(OPT_disable_verify);
   Config->Discard = getDiscard(Args);
   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);
   Config->Entry = Args.getLastArgValue(OPT_entry);
   Config->ExportDynamic =
       Args.hasFlag(OPT_export_dynamic, OPT_no_export_dynamic, false);
   Config->FilterList = args::getStrings(Args, OPT_filter);
   Config->Fini = Args.getLastArgValue(OPT_fini, "_fini");
void LinkerDriver::readConfigs(opt::InputArgList &Args) {
   Config->UndefinedVersion =
       Args.hasFlag(OPT_undefined_version, OPT_no_undefined_version, true);
   Config->UnresolvedSymbols = getUnresolvedSymbolPolicy(Args);
   Config->WarnBackrefs =
       Args.hasFlag(OPT_warn_backrefs, OPT_no_warn_backrefs, false);
   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);
   Config->ZHazardplt = hasZOption(Args, "hazardplt");
   Config->ZNodelete = hasZOption(Args, "nodelete");
   Config->ZNodlopen = hasZOption(Args, "nodlopen");
   Config->ZNow = getZFlag(Args, "now", "lazy", false);
   Config->ZOrigin = hasZOption(Args, "origin");
if (!Config->Relocatable)
     InputSections.push_back(createCommentSection());
 
   // Do size optimizations: garbage collection, merging of SHF_MERGE sections
   // and identical code folding.
   decompressSections();
   splitSections<ELFT>();
   markLive<ELFT>();
   demoteSymbols<ELFT>();
+  findEmbeddedSections();
   mergeSections();
   if (Config->ICF)
     doIcf<ELFT>();
 
   // Read the callgraph now that we know what was gced or icfed
   if (auto *Arg = Args.getLastArg(OPT_call_graph_ordering_file))
     if (Optional<MemoryBufferRef> Buffer = readFile(Arg->getValue()))
       readCallGraph(*Buffer);
 
   // Write the result to the file.
   writeResult<ELFT>();
 }

lld/ELF/EmbedFile.h

+#include <vector>
+
+namespace lld {
+namespace elf {
+
+struct PhdrEntry;
+
+void findEmbeddedSections();
+void updateEmbeddedStringPieces();
+void addPtEmbed(std::vector<PhdrEntry *> &Phdrs);
+void writeEmbedHintFile();
+
+}
+}

lld/ELF/EmbedFile.cpp

+#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);
+}

lld/ELF/InputSection.h

 
 // This is the base class of all sections that lld handles. Some are sections in
 // input files, some are sections in the produced output file and some exist
 // just as a convenience for implementing special ways of combining some
 // sections.
 class SectionBase {
 public:
   enum Kind { Regular, EHFrame, Merge, Synthetic, Output };
+  enum SyntheticKind { SNone, SBss, SMerge };
 
   Kind kind() const { return (Kind)SectionKind; }
 
   StringRef Name;
 
   // This pointer points to the "real" instance of this instance.
   // Usually Repl == this. However, if ICF merges two sections,
   // Repl pointer of one section points to another section. So,
   // if you need to get a pointer to this instance, do not use
   // this but instead this->Repl.
   SectionBase *Repl;
 
   unsigned SectionKind : 3;
 
   // The next two bit fields are only used by InputSectionBase, but we
   // put them here so the struct packs better.
 
   // The garbage collector sets sections' Live bits.
   // 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;
   uint64_t Flags;
   uint64_t Entsize;
   uint32_t Type;
   uint32_t Link;
   uint32_t Info;
public:
 
   uint64_t getVA(uint64_t Offset = 0) const;
 
 protected:
   SectionBase(Kind SectionKind, StringRef Name, uint64_t Flags,
               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.
 class InputSectionBase : public SectionBase {
 public:
   template <class ELFT>
   InputSectionBase(ObjFile<ELFT> &File, const typename ELFT::Shdr &Header,
                    StringRef Name, Kind SectionKind);

lld/ELF/InputSection.cpp

 // the base of the PT_LOAD segment containing the Sym.
 // The procedure call standard only defines a Read Write Position Independent
 // RWPI variant so in practice we should expect the static base to be the base
 // of the RW segment.
 static uint64_t getARMStaticBase(const Symbol &Sym) {
   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,
                                  const Symbol &Sym, RelExpr Expr) {
   switch (Expr) {
   case R_INVALID:
     return 0;
   case R_ABS:

lld/ELF/LinkerScript.cpp

 //===- LinkerScript.cpp ---------------------------------------------------===//
 //
 //                             The LLVM Linker
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // This file contains the parser/evaluator of the linker script.
 //
 //===----------------------------------------------------------------------===//
 
 #include "LinkerScript.h"
 #include "Config.h"
+#include "EmbedFile.h"
 #include "InputSection.h"
 #include "OutputSections.h"
 #include "SymbolTable.h"
 #include "Symbols.h"
 #include "SyntheticSections.h"
 #include "Target.h"
 #include "Writer.h"
 #include "lld/Common/Memory.h"
if (auto *Cmd = dyn_cast<SymbolAssignment>(Base)) {
       Cmd->Addr = Dot;
       assignSymbol(Cmd, false);
       Cmd->Size = Dot - Cmd->Addr;
       continue;
     }
     assignOffsets(cast<OutputSection>(Base));
   }
   Ctx = nullptr;
+
+  updateEmbeddedStringPieces();
 }
 
 // Creates program headers as instructed by PHDRS linker script command.
 std::vector<PhdrEntry *> LinkerScript::createPhdrs() {
   std::vector<PhdrEntry *> Ret;
 
   // Process PHDRS and FILEHDR keywords because they are not
   // real output sections and cannot be added in the following loop.

lld/ELF/MapFile.cpp

 
 // Returns a list of all symbols that we want to print out.
 static std::vector<Defined *> getSymbols() {
   std::vector<Defined *> V;
   for (InputFile *File : ObjectFiles)
     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;
 }
 
 // Returns a map from sections to their symbols.
 static SymbolMapTy getSectionSyms(ArrayRef<Defined *> Syms) {
   SymbolMapTy Ret;
   for (Defined *DR : Syms)

lld/ELF/Options.td

 
 defm dynamic_list: Eq<"dynamic-list">,
   HelpText<"Read a list of dynamic symbols">;
 
 defm eh_frame_hdr: B<"eh-frame-hdr",
     "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">,
   HelpText<"Enable new dynamic tags">;
 
 def end_group: F<"end-group">,
   HelpText<"Ignored for compatibility with GNU unless you pass --warn-backrefs">;
 

 
 defm whole_archive: B<"whole-archive",
     "Force load of all members in a static library",
     "Do not force load of all members in a static library">;
 
 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">;
 
 // Aliases
 def alias_auxiliary: Separate<["-"], "f">, Alias<auxiliary>;
 def alias_Bdynamic_call_shared: F<"call_shared">, Alias<Bdynamic>;
 def alias_Bdynamic_dy: F<"dy">, Alias<Bdynamic>;
 def alias_Bstatic_dn: F<"dn">, Alias<Bstatic>;

lld/ELF/SyntheticSections.h

 // respectively.
 class BssSection final : public SyntheticSection {
 public:
   BssSection(StringRef Name, uint64_t Size, uint32_t Alignment);
   void writeTo(uint8_t *) override {}
   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;
 };
 
 class MipsGotSection final : public SyntheticSection {
 public:
   MipsGotSection();
   void writeTo(uint8_t *Buf) override;
   size_t getSize() const override { return Size; }

 // with different attributes in a single output sections. To do that
 // we put them into MergeSyntheticSection synthetic input sections which are
 // attached to regular output sections.
 class MergeSyntheticSection : public SyntheticSection {
 public:
   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 {
 public:
   MergeTailSection(StringRef Name, uint32_t Type, uint64_t Flags,
                    uint32_t Alignment);
 
   size_t getSize() const override;

lld/ELF/SyntheticSections.cpp

void BuildIdSection::computeHash(
   });
 
   // Write to the final output buffer.
   HashFn(HashBuf, Hashes);
 }
 
 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;
 }
 
 void BuildIdSection::writeBuildId(ArrayRef<uint8_t> Buf) {
   switch (Config->BuildId) {
   case BuildIdKind::Fast:

lld/ELF/Writer.h

 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/StringRef.h"
 #include <cstdint>
 #include <memory>
 
 namespace lld {
 namespace elf {
 class InputFile;
-class OutputSection;
 class InputSectionBase;
 template <class ELFT> class ObjFile;
+class SectionBase;
 class SymbolTable;
 template <class ELFT> void writeResult();
 
 // This describes a program header entry.
 // Each contains type, access flags and range of output sections that will be
 // 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;
   uint64_t p_memsz = 0;
   uint64_t p_filesz = 0;
   uint64_t p_offset = 0;
   uint32_t p_align = 0;
   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;
 };
 
 void addReservedSymbols();
 llvm::StringRef getOutputSectionName(InputSectionBase *S);
 

lld/ELF/Writer.cpp

 //===- Writer.cpp ---------------------------------------------------------===//
 //
 //                             The LLVM Linker
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "Writer.h"
 #include "AArch64ErrataFix.h"
 #include "CallGraphSort.h"
 #include "Config.h"
+#include "EmbedFile.h"
 #include "Filesystem.h"
 #include "LinkerScript.h"
 #include "MapFile.h"
 #include "OutputSections.h"
 #include "Relocations.h"
 #include "SymbolTable.h"
 #include "Symbols.h"
 #include "SyntheticSections.h"

 template <class ELFT> void elf::writeResult() { Writer<ELFT>().run(); }
 
 template <class ELFT> void Writer<ELFT>::removeEmptyPTLoad() {
   llvm::erase_if(Phdrs, [&](const PhdrEntry *P) {
     if (P->p_type != PT_LOAD)
       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;
   });
 }
 
 template <class ELFT> static void combineEhFrameSections() {
   for (InputSectionBase *&S : InputSections) {
     EhInputSection *ES = dyn_cast<EhInputSection>(S);
     if (!ES || !ES->Live)
if (errorCount())
     return;
 
   // Handle -Map and -cref options.
   writeMapFile();
   writeCrossReferenceTable();
   if (errorCount())
     return;
 
+  writeEmbedHintFile();
+
   if (auto E = Buffer->commit())
     error("failed to write to the output file: " + toString(std::move(E)));
 }
 
 static bool shouldKeepInSymtab(SectionBase *Sec, StringRef SymName,
                                const Symbol &B) {
   if (B.isSection())
     return false;
static bool compareSections(const BaseCommand *ACmd, const BaseCommand *BCmd) {
   if (A->SortRank != B->SortRank)
     return A->SortRank < B->SortRank;
   if (!(A->SortRank & RF_NOT_ADDR_SET))
     return Config->SectionStartMap.lookup(A->Name) <
            Config->SectionStartMap.lookup(B->Name);
   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
 // 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>::finalizeSections() {
   }
 
   // Binary and relocatable output does not have PHDRS.
   // The headers have to be created before finalize as that can influence the
   // image base and the dynamic section on mips includes the image base.
   if (!Config->Relocatable && !Config->OFormatBinary) {
     Phdrs = Script->hasPhdrsCommands() ? Script->createPhdrs() : createPhdrs();
     addPtArmExid(Phdrs);
+    addPtEmbed(Phdrs);
     Out::ProgramHeaders->Size = sizeof(Elf_Phdr) * Phdrs.size();
   }
 
   // Some symbols are defined in term of program headers. Now that we
   // have the headers, we can find out which sections they point to.
   setReservedSymbolSections();
 
   // Dynamic section must be the last one in this list and dynamic
for (OutputSection *Sec : OutputSections) {
     // (e.g. executable or writable). There is one phdr for each segment.
     // Therefore, we need to create a new phdr when the next section has
     // different flags or is loaded at a discontiguous address using AT linker
     // script command. At the same time, we don't want to create a separate
     // load segment for the headers, even if the first output section has
     // 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;
     }
 
     Load->add(Sec);
   }
 
void Writer<ELFT>::addPtArmExid(std::vector<PhdrEntry *> &Phdrs) {
   ARMExidx->add(*I);
   Phdrs.push_back(ARMExidx);
 }
 
 // The first section of each PT_LOAD, the first section in PT_GNU_RELRO 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() {
-  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);
       };
   };
 
   for (const PhdrEntry *P : Phdrs)
     if (P->p_type == PT_LOAD && P->FirstSec)
       PageAlign(P->FirstSec);
 
template <class ELFT> void Writer<ELFT>::fixSectionAlignments() {
   }
 }
 
 // Adjusts the file alignment for a given output section and returns
 // its new file offset. The file offset must be the same with its
 // 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)
     return alignTo(Off, std::max<uint64_t>(Cmd->Alignment, Config->MaxPageSize),
                    Cmd->Addr);
 
   // For SHT_NOBITS we don't want the alignment of the section to impact the
   // offset of the sections that follow. Since nothing seems to care about the
if ((Sec->Offset > FileSize) || (Sec->Offset + Sec->Size > FileSize))
             rangeToString(Sec->Offset, Sec->Offset + Sec->Size) +
             "; check your linker script for overflows");
   }
 }
 
 // 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);
     else if (P->p_type == PT_GNU_RELRO) {
       P->p_align = 1;
       // The glibc dynamic loader rounds the size down, so we need to round up
       // to protect the last page. This is a no-op on FreeBSD which always
       // rounds up.

llvm/include/llvm/BinaryFormat/ELF.h

enum {
 
   PT_GNU_STACK = 0x6474e551, // Indicates stack executability.
   PT_GNU_RELRO = 0x6474e552, // Read-only after relocation.
 
   PT_OPENBSD_RANDOMIZE = 0x65a3dbe6, // Fill with random data.
   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.
   PT_ARM_EXIDX = 0x70000001,
   PT_ARM_UNWIND = 0x70000001,
 
   // MIPS program header types.
   PT_MIPS_REGINFO = 0x70000000,  // Register usage information.