ELF: Create synthetic sections for loadable partitions.

[pcc]

Summary

We create several types of synthetic sections for loadable partitions, including:

• The dynamic symbol table. This allows code outside of the loadable partitions to find entry points with dlsym.
• Creating a dynamic symbol table also requires the creation of several other synthetic sections for the partition, such as the dynamic table and hash table sections.
• The partition's ELF header is represented as a synthetic section in the combined output file, and will be used by llvm-objcopy to extract partitions.

Depends on D60353

Depends on D62349

[grimar]

lld/ELF/SyntheticSections.h

1127

What about having one more global pointer instead.
i.e. after creating all of the partitions do:

Partition *InM; //global, like `In`

...

InM = &Partitions[0];

And then use InM everywhere instead of mainPartition.
I wonder what others think though.

[ruiu]

lld/ELF/SyntheticSections.h

1127

Yeah. Looks like this function doesn't have to be a function. I thought for a while about what kind of name I'd choose, but I didn't come up with a good idea. Calling Partitions[0] as In might not be a bad idea. It's short, and we don't need to update all Ins with mainPartition() which makes this patch much easier to read.

[pcc]

lld/ELF/SyntheticSections.h

1127

It won't work to name it In because we already have a variable named In. I think that we'll always have a variable for per-file synthetic sections because some sections (such as the static symbol table) will not be duplicated between partitions.

In an earlier version of this change I had a global variable

static Partition &Main = Partitions[0];

but this won't work now that Partitions is a vector and not an array. That's why I introduced the function.

I'm fine with the idea of bringing the variable back (as a pointer rather than a reference) and setting it once all partitions are created. I'll call it Main unless there are any strong objections to that name.

[pcc]

• Replace mainPartition() with a global variable Main

[pcc]

• Write tests, fix bugs found while writing tests

[pcc]

Okay, I *think* I managed to write tests that cover everything that I added here, but let me know if I missed anything.

[grimar]

I'd suggest adding a short description to each test case added.

lld/test/ELF/partition-synthetic-sections.s

17 ↗

(On Diff #203070)

Was issue about that reported? We have a good practice in LLVM tools to add an URL of the issue
for each TODO in the test. That helps to cleanup such things a lot.

23 ↗

(On Diff #203070)

You do not need [ 1] I think.

[pcc]

• Address review comments

[pcc]

lld/test/ELF/partition-synthetic-sections.s

17 ↗

(On Diff #203070)

I looked into this a bit more and filed pr42145 and linked it here. Unfortunately fixing this isn't as simple as I first thought.

23 ↗

(On Diff #203070)

I was using it to make sure that there were no section headers before .dynsym. But I've switched to using CHECK-NEXT here like I was doing elsewhere.

[ruiu]

LGTM

It generally looking good, and I don't have further comments. George, are you happy with this?

[grimar]

Yep, looks fine.

lld/ELF/Arch/X86.cpp

RelExpr X86::adjustRelaxExpr(RelType Type, const uint8_t *Data,
   case R_RELAX_TLS_GD_TO_IE:
     return R_RELAX_TLS_GD_TO_IE_GOTPLT;
   case R_RELAX_TLS_GD_TO_LE:
     return R_RELAX_TLS_GD_TO_LE_NEG;
   }
 }
 
 void X86::writeGotPltHeader(uint8_t *Buf) const {
-  write32le(Buf, In.Dynamic->getVA());
+  write32le(Buf, Main->Dynamic->getVA());
 }
 
 void X86::writeGotPlt(uint8_t *Buf, const Symbol &S) const {
   // Entries in .got.plt initially points back to the corresponding
   // PLT entries with a fixed offset to skip the first instruction.
   write32le(Buf, S.getPltVA() + 6);
 }
 

lld/ELF/Arch/X86_64.cpp

RelExpr X86_64::getRelExpr(RelType Type, const Symbol &S,
   }
 }
 
 void X86_64::writeGotPltHeader(uint8_t *Buf) const {
   // The first entry holds the value of _DYNAMIC. It is not clear why that is
   // required, but it is documented in the psabi and the glibc dynamic linker
   // seems to use it (note that this is relevant for linking ld.so, not any
   // other program).
-  write64le(Buf, In.Dynamic->getVA());
+  write64le(Buf, Main->Dynamic->getVA());
 }
 
 void X86_64::writeGotPlt(uint8_t *Buf, const Symbol &S) const {
   // See comments in X86::writeGotPlt.
   write64le(Buf, S.getPltVA() + 6);
 }
 
 void X86_64::writePltHeader(uint8_t *Buf) const {

lld/ELF/Driver.cpp

llvm::erase_if(InputSections, [](InputSectionBase *S) {
     }
 
     // We do not want to emit debug sections if --strip-all
     // or -strip-debug are given.
     return Config->Strip != StripPolicy::None &&
            (S->Name.startswith(".debug") || S->Name.startswith(".zdebug"));
   });
 
+  // Now that the number of partitions is fixed, save a pointer to the main
+  // partition.
+  Main = &Partitions[0];
+
   // The Target instance handles target-specific stuff, such as applying
   // relocations or writing a PLT section. It also contains target-dependent
   // values such as a default image base address.
   Target = getTarget();
 
   Config->EFlags = Target->calcEFlags();
   // MaxPageSize (sometimes called abi page size) is the maximum page size that
   // the output can be run on. For example if the OS can use 4k or 64k page

lld/ELF/InputSection.h

 
 namespace lld {
 namespace elf {
 
 class Symbol;
 struct SectionPiece;
 
 class Defined;
+struct Partition;
 class SyntheticSection;
 class MergeSyntheticSection;
 template <class ELFT> class ObjFile;
 class OutputSection;
 
+extern std::vector<Partition> Partitions;
+
 // 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 };
 
public:
 
   // Pad the next field to a byte boundary.
   unsigned : 2;
 
   // The 1-indexed partition that this section is assigned to by the garbage
   // collector, or 0 if this section is dead. Normally there is only one
   // partition, so this will either be 0 or 1.
   unsigned Partition : 8;
+  elf::Partition &getPartition() const;
 
   // 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;

lld/ELF/LinkerScript.cpp

for (const SectionPattern &Pat : Cmd->SectionPatterns) {
     sortInputSections(MutableArrayRef<InputSection *>(Ret).slice(SizeBefore),
                       Pat);
   }
   return Ret;
 }
 
 void LinkerScript::discard(ArrayRef<InputSection *> V) {
   for (InputSection *S : V) {
-    if (S == In.ShStrTab || S == In.RelaDyn || S == In.RelrDyn)
+    if (S == In.ShStrTab || S == Main->RelaDyn || S == Main->RelrDyn)
       error("discarding " + S->Name + " section is not allowed");
 
     // You can discard .hash and .gnu.hash sections by linker scripts. Since
     // they are synthesized sections, we need to handle them differently than
     // other regular sections.
-    if (S == In.GnuHashTab)
-      In.GnuHashTab = nullptr;
-    if (S == In.HashTab)
-      In.HashTab = nullptr;
+    if (S == Main->GnuHashTab)
+      Main->GnuHashTab = nullptr;
+    if (S == Main->HashTab)
+      Main->HashTab = nullptr;
 
     S->Assigned = false;
     S->markDead();
     discard(S->DependentSections);
   }
 }
 
 std::vector<InputSection *>
for (BaseCommand *&Cmd : SectionCommands) {
     bool IsEmpty = getInputSections(Sec).empty();
     if (IsEmpty)
       Sec->Flags = Flags & ((Sec->NonAlloc ? 0 : (uint64_t)SHF_ALLOC) |
                             SHF_WRITE | SHF_EXECINSTR);
 
     if (IsEmpty && isDiscardable(*Sec)) {
       Sec->markDead();
       Cmd = nullptr;
+    } else if (!Sec->isLive()) {
+      Sec->markLive();
     }
   }
 
   // It is common practice to use very generic linker scripts. So for any
   // given run some of the output sections in the script will be empty.
   // We could create corresponding empty output sections, but that would
   // clutter the output.
   // We instead remove trivially empty sections. The bfd linker seems even

lld/ELF/Relocations.cpp

static unsigned handleARMTlsRelocation(RelType Type, Symbol &Sym,
   // The Dynamic TLS Module Index Relocation for a symbol defined in an
   // executable is always 1. If the target Symbol is not preemptible then
   // we know the offset into the TLS block at static link time.
   bool NeedDynId = Sym.IsPreemptible || Config->Shared;
   bool NeedDynOff = Sym.IsPreemptible;
 
   auto AddTlsReloc = [&](uint64_t Off, RelType Type, Symbol *Dest, bool Dyn) {
     if (Dyn)
-      In.RelaDyn->addReloc(Type, In.Got, Off, Dest);
+      Main->RelaDyn->addReloc(Type, In.Got, Off, Dest);
     else
       In.Got->Relocations.push_back({R_ABS, Type, Off, 0, Dest});
   };
 
   // Local Dynamic is for access to module local TLS variables, while still
   // being suitable for being dynamically loaded via dlopen.
   // GOT[e0] is the module index, with a special value of 0 for the current
   // module. GOT[e1] is unused. There only needs to be one module index entry.
if (Config->EMachine == EM_ARM)
     return handleARMTlsRelocation(Type, Sym, C, Offset, Addend, Expr);
   if (Config->EMachine == EM_MIPS)
     return handleMipsTlsRelocation(Type, Sym, C, Offset, Addend, Expr);
 
   if (oneof<R_TLSDESC, R_AARCH64_TLSDESC_PAGE, R_TLSDESC_CALL>(Expr) &&
       Config->Shared) {
     if (In.Got->addDynTlsEntry(Sym)) {
       uint64_t Off = In.Got->getGlobalDynOffset(Sym);
-      In.RelaDyn->addReloc(
+      Main->RelaDyn->addReloc(
           {Target->TlsDescRel, In.Got, Off, !Sym.IsPreemptible, &Sym, 0});
     }
     if (Expr != R_TLSDESC_CALL)
       C.Relocations.push_back({Expr, Type, Offset, Addend, &Sym});
     return 1;
   }
 
   if (oneof<R_TLSLD_GOT, R_TLSLD_GOTPLT, R_TLSLD_PC, R_TLSLD_HINT>(
           Expr)) {
     // Local-Dynamic relocs can be relaxed to Local-Exec.
     if (!Config->Shared) {
       C.Relocations.push_back(
           {Target->adjustRelaxExpr(Type, nullptr, R_RELAX_TLS_LD_TO_LE), Type,
            Offset, Addend, &Sym});
       return Target->getTlsGdRelaxSkip(Type);
     }
     if (Expr == R_TLSLD_HINT)
       return 1;
     if (In.Got->addTlsIndex())
-      In.RelaDyn->addReloc(Target->TlsModuleIndexRel, In.Got,
+      Main->RelaDyn->addReloc(Target->TlsModuleIndexRel, In.Got,
                               In.Got->getTlsIndexOff(), nullptr);
     C.Relocations.push_back({Expr, Type, Offset, Addend, &Sym});
     return 1;
   }
 
   // Local-Dynamic relocs can be relaxed to Local-Exec.
   if (Expr == R_DTPREL && !Config->Shared) {
     C.Relocations.push_back(
         {Target->adjustRelaxExpr(Type, nullptr, R_RELAX_TLS_LD_TO_LE), Type,
if (Expr == R_TLSLD_GOT_OFF) {
     return 1;
   }
 
   if (oneof<R_TLSDESC, R_AARCH64_TLSDESC_PAGE, R_TLSDESC_CALL, R_TLSGD_GOT,
             R_TLSGD_GOTPLT, R_TLSGD_PC>(Expr)) {
     if (Config->Shared) {
       if (In.Got->addDynTlsEntry(Sym)) {
         uint64_t Off = In.Got->getGlobalDynOffset(Sym);
-        In.RelaDyn->addReloc(Target->TlsModuleIndexRel, In.Got, Off, &Sym);
+        Main->RelaDyn->addReloc(Target->TlsModuleIndexRel, In.Got, Off, &Sym);
 
         // If the symbol is preemptible we need the dynamic linker to write
         // the offset too.
         uint64_t OffsetOff = Off + Config->Wordsize;
         if (Sym.IsPreemptible)
-          In.RelaDyn->addReloc(Target->TlsOffsetRel, In.Got, OffsetOff, &Sym);
+          Main->RelaDyn->addReloc(Target->TlsOffsetRel, In.Got, OffsetOff,
+                                  &Sym);
         else
           In.Got->Relocations.push_back(
               {R_ABS, Target->TlsOffsetRel, OffsetOff, 0, &Sym});
       }
       C.Relocations.push_back({Expr, Type, Offset, Addend, &Sym});
       return 1;
     }
 
     // Global-Dynamic relocs can be relaxed to Initial-Exec or Local-Exec
     // depending on the symbol being locally defined or not.
     if (Sym.IsPreemptible) {
       C.Relocations.push_back(
           {Target->adjustRelaxExpr(Type, nullptr, R_RELAX_TLS_GD_TO_IE), Type,
            Offset, Addend, &Sym});
       if (!Sym.isInGot()) {
         In.Got->addEntry(Sym);
-        In.RelaDyn->addReloc(Target->TlsGotRel, In.Got, Sym.getGotOffset(),
+        Main->RelaDyn->addReloc(Target->TlsGotRel, In.Got, Sym.getGotOffset(),
                                 &Sym);
       }
     } else {
       C.Relocations.push_back(
           {Target->adjustRelaxExpr(Type, nullptr, R_RELAX_TLS_GD_TO_LE), Type,
            Offset, Addend, &Sym});
     }
     return Target->getTlsGdRelaxSkip(Type);
   }
else
     In.Bss->getParent()->addSection(Sec);
 
   // Look through the DSO's dynamic symbol table for aliases and create a
   // dynamic symbol for each one. This causes the copy relocation to correctly
   // interpose any aliases.
   for (SharedSymbol *Sym : getSymbolsAt<ELFT>(SS))
     replaceWithDefined(*Sym, Sec, 0, Sym->Size);
 
-  In.RelaDyn->addReloc(Target->CopyRel, Sec, 0, &SS);
+  Main->RelaDyn->addReloc(Target->CopyRel, Sec, 0, &SS);
 }
 
 // MIPS has an odd notion of "paired" relocations to calculate addends.
 // For example, if a relocation is of R_MIPS_HI16, there must be a
 // R_MIPS_LO16 relocation after that, and an addend is calculated using
 // the two relocations.
 template <class ELFT, class RelTy>
 static int64_t computeMipsAddend(const RelTy &Rel, const RelTy *End,
private:
   ArrayRef<EhSectionPiece> Pieces;
   size_t I = 0;
 };
 } // namespace
 
 static void addRelativeReloc(InputSectionBase *IS, uint64_t OffsetInSec,
                              Symbol *Sym, int64_t Addend, RelExpr Expr,
                              RelType Type) {
+  Partition &Part = IS->getPartition();
+
   // Add a relative relocation. If RelrDyn section is enabled, and the
   // relocation offset is guaranteed to be even, add the relocation to
   // the RelrDyn section, otherwise add it to the RelaDyn section.
   // RelrDyn sections don't support odd offsets. Also, RelrDyn sections
   // don't store the addend values, so we must write it to the relocated
   // address.
-  if (In.RelrDyn && IS->Alignment >= 2 && OffsetInSec % 2 == 0) {
+  if (Part.RelrDyn && IS->Alignment >= 2 && OffsetInSec % 2 == 0) {
     IS->Relocations.push_back({Expr, Type, OffsetInSec, Addend, Sym});
-    In.RelrDyn->Relocs.push_back({IS, OffsetInSec});
+    Part.RelrDyn->Relocs.push_back({IS, OffsetInSec});
     return;
   }
-  In.RelaDyn->addReloc(Target->RelativeRel, IS, OffsetInSec, Sym, Addend, Expr,
-                       Type);
+  Part.RelaDyn->addReloc(Target->RelativeRel, IS, OffsetInSec, Sym, Addend,
+                         Expr, Type);
 }
 
 template <class ELFT, class GotPltSection>
 static void addPltEntry(PltSection *Plt, GotPltSection *GotPlt,
                         RelocationBaseSection *Rel, RelType Type, Symbol &Sym) {
   Plt->addEntry<ELFT>(Sym);
   GotPlt->addEntry(Sym);
   Rel->addReloc(
static void addGotEntry(Symbol &Sym) {
   }
 
   // Otherwise, we emit a dynamic relocation to .rel[a].dyn so that
   // the GOT slot will be fixed at load-time.
   if (!Sym.isTls() && !Sym.IsPreemptible && Config->Pic && !isAbsolute(Sym)) {
     addRelativeReloc(In.Got, Off, &Sym, 0, R_ABS, Target->GotRel);
     return;
   }
-  In.RelaDyn->addReloc(Sym.isTls() ? Target->TlsGotRel : Target->GotRel, In.Got,
-                       Off, &Sym, 0, Sym.IsPreemptible ? R_ADDEND : R_ABS,
-                       Target->GotRel);
+  Main->RelaDyn->addReloc(Sym.isTls() ? Target->TlsGotRel : Target->GotRel,
+                          In.Got, Off, &Sym, 0,
+                          Sym.IsPreemptible ? R_ADDEND : R_ABS, Target->GotRel);
 }
 
 // Return true if we can define a symbol in the executable that
 // contains the value/function of a symbol defined in a shared
 // library.
 static bool canDefineSymbolInExecutable(Symbol &Sym) {
   // If the symbol has default visibility the symbol defined in the
   // executable will preempt it.
static void processRelocAux(InputSectionBase &Sec, RelExpr Expr, RelType Type,
   if (CanWrite) {
     // R_GOT refers to a position in the got, even if the symbol is preemptible.
     bool IsPreemptibleValue = Sym.IsPreemptible && Expr != R_GOT;
 
     if (!IsPreemptibleValue) {
       addRelativeReloc(&Sec, Offset, &Sym, Addend, Expr, Type);
       return;
     } else if (RelType Rel = Target->getDynRel(Type)) {
-      In.RelaDyn->addReloc(Rel, &Sec, Offset, &Sym, Addend, R_ADDEND, Type);
+      Sec.getPartition().RelaDyn->addReloc(Rel, &Sec, Offset, &Sym, Addend,
+                                           R_ADDEND, Type);
 
       // MIPS ABI turns using of GOT and dynamic relocations inside out.
       // While regular ABI uses dynamic relocations to fill up GOT entries
       // MIPS ABI requires dynamic linker to fills up GOT entries using
       // specially sorted dynamic symbol table. This affects even dynamic
       // relocations against symbols which do not require GOT entries
       // creation explicitly, i.e. do not have any GOT-relocations. So if
       // a preemptible symbol has a dynamic relocation we anyway have
if (unsigned Processed =
     I += (Processed - 1);
     return;
   }
 
   // We were asked not to generate PLT entries for ifuncs. Instead, pass the
   // direct relocation on through.
   if (Sym.isGnuIFunc() && Config->ZIfuncNoplt) {
     Sym.ExportDynamic = true;
-    In.RelaDyn->addReloc(Type, &Sec, Offset, &Sym, Addend, R_ADDEND, Type);
+    Main->RelaDyn->addReloc(Type, &Sec, Offset, &Sym, Addend, R_ADDEND, Type);
     return;
   }
 
   // Non-preemptible ifuncs require special handling. First, handle the usual
   // case where the symbol isn't one of these.
   if (!Sym.isGnuIFunc() || Sym.IsPreemptible) {
     // If a relocation needs PLT, we create PLT and GOTPLT slots for the symbol.
     if (needsPlt(Expr) && !Sym.isInPlt())

lld/ELF/SyntheticSections.h

 #include "llvm/ADT/MapVector.h"
 #include "llvm/MC/StringTableBuilder.h"
 #include "llvm/Support/Endian.h"
 #include <functional>
 
 namespace lld {
 namespace elf {
 class Defined;
-struct Partition;
+struct PhdrEntry;
+class SymbolTableBaseSection;
+class VersionNeedBaseSection;
 
 class SyntheticSection : public InputSection {
 public:
   SyntheticSection(uint64_t Flags, uint32_t Type, uint32_t Alignment,
                    StringRef Name)
       : InputSection(nullptr, Flags, Type, Alignment, {}, Name,
                      InputSectionBase::Synthetic) {
     markLive();
public:
   // lie inside the output section.
   DynamicReloc(RelType Type, const InputSectionBase *InputSec,
                uint64_t OffsetInSec, const OutputSection *OutputSec,
                int64_t Addend)
       : Type(Type), Sym(nullptr), InputSec(InputSec), OffsetInSec(OffsetInSec),
         UseSymVA(false), Addend(Addend), OutputSec(OutputSec) {}
 
   uint64_t getOffset() const;
-  uint32_t getSymIndex() const;
+  uint32_t getSymIndex(SymbolTableBaseSection *SymTab) const;
 
   // Computes the addend of the dynamic relocation. Note that this is not the
   // same as the Addend member variable as it also includes the symbol address
   // if UseSymVA is true.
   int64_t computeAddend() const;
 
   RelType Type;
 
-private:
   Symbol *Sym;
   const InputSectionBase *InputSec = nullptr;
   uint64_t OffsetInSec;
   // If this member is true, the dynamic relocation will not be against the
   // symbol but will instead be a relative relocation that simply adds the
   // load address. This means we need to write the symbol virtual address
   // plus the original addend as the final relocation addend.
   bool UseSymVA;
void addReloc(RelType DynType, InputSectionBase *InputSec,
                 uint64_t OffsetInSec, Symbol *Sym, int64_t Addend, RelExpr Expr,
                 RelType Type);
   void addReloc(const DynamicReloc &Reloc);
   bool isNeeded() const override { return !Relocs.empty(); }
   size_t getSize() const override { return Relocs.size() * this->Entsize; }
   size_t getRelativeRelocCount() const { return NumRelativeRelocs; }
   void finalizeContents() override;
   int32_t DynamicTag, SizeDynamicTag;
+  std::vector<DynamicReloc> Relocs;
 
 protected:
-  std::vector<DynamicReloc> Relocs;
   size_t NumRelativeRelocs = 0;
 };
 
 template <class ELFT>
 class RelocationSection final : public RelocationBaseSection {
   using Elf_Rel = typename ELFT::Rel;
   using Elf_Rela = typename ELFT::Rela;
 
public:
   VersionDefinitionSection();
   void finalizeContents() override;
   size_t getSize() const override;
   void writeTo(uint8_t *Buf) override;
 
 private:
   enum { EntrySize = 28 };
   void writeOne(uint8_t *Buf, uint32_t Index, StringRef Name, size_t NameOff);
+  StringRef getFileDefName();
 
   unsigned FileDefNameOff;
 };
 
 // The .gnu.version section specifies the required version of each symbol in the
 // dynamic symbol table. It contains one Elf_Versym for each dynamic symbol
 // table entry. An Elf_Versym is just a 16-bit integer that refers to a version
 // identifier defined in the either .gnu.version_r or .gnu.version_d section.
public:
   bool isNeeded() const override;
   void finalizeContents() override { Finalized = true; }
 
 private:
   std::vector<const Symbol *> Entries;
   bool Finalized = false;
 };
 
+template <typename ELFT>
+class PartitionElfHeaderSection : public SyntheticSection {
+public:
+  PartitionElfHeaderSection();
+  size_t getSize() const override;
+  void writeTo(uint8_t *Buf) override;
+};
+
+template <typename ELFT>
+class PartitionProgramHeadersSection : public SyntheticSection {
+public:
+  PartitionProgramHeadersSection();
+  size_t getSize() const override;
+  void writeTo(uint8_t *Buf) override;
+};
+
+class PartitionIndexSection : public SyntheticSection {
+public:
+  PartitionIndexSection();
+  size_t getSize() const override;
+  void finalizeContents() override;
+  void writeTo(uint8_t *Buf) override;
+};
+
 InputSection *createInterpSection();
 MergeInputSection *createCommentSection();
 template <class ELFT> void splitSections();
 void mergeSections();
 
+template <typename ELFT> void writeEhdr(uint8_t *Buf, Partition &Part);
+template <typename ELFT> void writePhdrs(uint8_t *Buf, Partition &Part);
+
 Defined *addSyntheticLocal(StringRef Name, uint8_t Type, uint64_t Value,
                            uint64_t Size, InputSectionBase &Section);
 
 void addVerneed(Symbol *SS);
 
-extern std::vector<Partition> Partitions;
-
 // Linker generated per-partition sections.
 struct Partition {
   StringRef Name;
-  unsigned getNumber() const { return this - &Partitions[0] + 1; }
-};
+  uint64_t NameStrTab;
+
+  SyntheticSection *ElfHeader;
+  SyntheticSection *ProgramHeaders;
+  std::vector<PhdrEntry *> Phdrs;
 
-// Linker generated sections which can be used as inputs.
-struct InStruct {
-  InputSection *ARMAttributes;
   ARMExidxSyntheticSection *ARMExidx;
-  BssSection *Bss;
-  BssSection *BssRelRo;
   BuildIdSection *BuildId;
-  EhFrameHeader *EhFrameHdr;
-  EhFrameSection *EhFrame;
   SyntheticSection *Dynamic;
   StringTableSection *DynStrTab;
   SymbolTableBaseSection *DynSymTab;
+  EhFrameHeader *EhFrameHdr;
+  EhFrameSection *EhFrame;
   GnuHashTableSection *GnuHashTab;
   HashTableSection *HashTab;
+  RelocationBaseSection *RelaDyn;
+  RelrBaseSection *RelrDyn;
+  VersionDefinitionSection *VerDef;
+  SyntheticSection *VerNeed;
+  VersionTableSection *VerSym;
+
+  unsigned getNumber() const { return this - &Partitions[0] + 1; }
+};
+
+extern Partition *Main;
+
+inline Partition &SectionBase::getPartition() const {
+  assert(isLive());
+  return Partitions[Partition - 1];
+}
+
+// Linker generated sections which can be used as inputs and are not specific to
+// a partition.
+struct InStruct {
+  InputSection *ARMAttributes;
+  BssSection *Bss;
+  BssSection *BssRelRo;
   GotSection *Got;
   GotPltSection *GotPlt;
   IgotPltSection *IgotPlt;
   PPC64LongBranchTargetSection *PPC64LongBranchTarget;
   MipsGotSection *MipsGot;
   MipsRldMapSection *MipsRldMap;
+  SyntheticSection *PartEnd;
+  SyntheticSection *PartIndex;
   PltSection *Plt;
   PltSection *Iplt;
-  RelocationBaseSection *RelaDyn;
-  RelrBaseSection *RelrDyn;
   RelocationBaseSection *RelaPlt;
   RelocationBaseSection *RelaIplt;
   StringTableSection *ShStrTab;
   StringTableSection *StrTab;
   SymbolTableBaseSection *SymTab;
   SymtabShndxSection *SymTabShndx;
-  VersionDefinitionSection *VerDef;
-  SyntheticSection *VerNeed;
-  VersionTableSection *VerSym;
 };
 
 extern InStruct In;
 
 } // namespace elf
 } // namespace lld
 
 #endif

lld/ELF/SyntheticSections.cpp

bool EhFrameSection::isFdeLive(EhSectionPiece &Fde, ArrayRef<RelTy> Rels) {
   // corresponding FDEs, which results in creating bad .eh_frame sections.
   // To deal with that, we ignore such FDEs.
   if (FirstRelI == (unsigned)-1)
     return false;
 
   const RelTy &Rel = Rels[FirstRelI];
   Symbol &B = Sec->template getFile<ELFT>()->getRelocTargetSym(Rel);
 
-  // FDEs for garbage-collected or merged-by-ICF sections are dead.
+  // FDEs for garbage-collected or merged-by-ICF sections, or sections in
+  // another partition, are dead.
   if (auto *D = dyn_cast<Defined>(&B))
     if (SectionBase *Sec = D->Section)
-      return Sec->isLive();
+      return Sec->Partition == Partition;
   return false;
 }
 
 // .eh_frame is a sequence of CIE or FDE records. In general, there
 // is one CIE record per input object file which is followed by
 // a list of FDEs. This function searches an existing CIE or create a new
 // one and associates FDEs to the CIE.
 template <class ELFT, class RelTy>

 
 // Returns data for .eh_frame_hdr. .eh_frame_hdr is a binary search table
 // to get an FDE from an address to which FDE is applied. This function
 // returns a list of such pairs.
 std::vector<EhFrameSection::FdeData> EhFrameSection::getFdeData() const {
   uint8_t *Buf = Out::BufferStart + getParent()->Offset + OutSecOff;
   std::vector<FdeData> Ret;
 
-  uint64_t VA = In.EhFrameHdr->getVA();
+  uint64_t VA = getPartition().EhFrameHdr->getVA();
   for (CieRecord *Rec : CieRecords) {
     uint8_t Enc = getFdeEncoding(Rec->Cie);
     for (EhSectionPiece *Fde : Rec->Fdes) {
       uint64_t Pc = getFdePc(Buf, Fde->OutputOff, Enc);
       uint64_t FdeVA = getParent()->Addr + Fde->OutputOff;
       if (!isInt<32>(Pc - VA))
         fatal(toString(Fde->Sec) + ": PC offset is too large: 0x" +
               Twine::utohexstr(Pc - VA));
void EhFrameSection::writeTo(uint8_t *Buf) {
   }
 
   // Apply relocations. .eh_frame section contents are not contiguous
   // in the output buffer, but relocateAlloc() still works because
   // getOffset() takes care of discontiguous section pieces.
   for (EhInputSection *S : Sections)
     S->relocateAlloc(Buf, nullptr);
 
-  if (In.EhFrameHdr && In.EhFrameHdr->getParent())
-    In.EhFrameHdr->write();
+  if (getPartition().EhFrameHdr && getPartition().EhFrameHdr->getParent())
+    getPartition().EhFrameHdr->write();
 }
 
 GotSection::GotSection()
     : SyntheticSection(SHF_ALLOC | SHF_WRITE, SHT_PROGBITS,
                        Target->GotEntrySize, ".got") {
   // PPC64 saves the ElfSym::GlobalOffsetTable .TOC. as the first entry in the
   // .got. If there are no references to .TOC. in the symbol table,
   // ElfSym::GlobalOffsetTable will not be defined and we won't need to save
void MipsGotSection::build() {
 
   // Create dynamic relocations.
   for (FileGot &Got : Gots) {
     // Create dynamic relocations for TLS entries.
     for (std::pair<Symbol *, size_t> &P : Got.Tls) {
       Symbol *S = P.first;
       uint64_t Offset = P.second * Config->Wordsize;
       if (S->IsPreemptible)
-        In.RelaDyn->addReloc(Target->TlsGotRel, this, Offset, S);
+        Main->RelaDyn->addReloc(Target->TlsGotRel, this, Offset, S);
     }
     for (std::pair<Symbol *, size_t> &P : Got.DynTlsSymbols) {
       Symbol *S = P.first;
       uint64_t Offset = P.second * Config->Wordsize;
       if (S == nullptr) {
         if (!Config->Pic)
           continue;
-        In.RelaDyn->addReloc(Target->TlsModuleIndexRel, this, Offset, S);
+        Main->RelaDyn->addReloc(Target->TlsModuleIndexRel, this, Offset, S);
       } else {
         // When building a shared library we still need a dynamic relocation
         // for the module index. Therefore only checking for
         // S->IsPreemptible is not sufficient (this happens e.g. for
         // thread-locals that have been marked as local through a linker script)
         if (!S->IsPreemptible && !Config->Pic)
           continue;
-        In.RelaDyn->addReloc(Target->TlsModuleIndexRel, this, Offset, S);
+        Main->RelaDyn->addReloc(Target->TlsModuleIndexRel, this, Offset, S);
         // However, we can skip writing the TLS offset reloc for non-preemptible
         // symbols since it is known even in shared libraries
         if (!S->IsPreemptible)
           continue;
         Offset += Config->Wordsize;
-        In.RelaDyn->addReloc(Target->TlsOffsetRel, this, Offset, S);
+        Main->RelaDyn->addReloc(Target->TlsOffsetRel, this, Offset, S);
       }
     }
 
     // Do not create dynamic relocations for non-TLS
     // entries in the primary GOT.
     if (&Got == PrimGot)
       continue;
 
     // Dynamic relocations for "global" entries.
     for (const std::pair<Symbol *, size_t> &P : Got.Global) {
       uint64_t Offset = P.second * Config->Wordsize;
-      In.RelaDyn->addReloc(Target->RelativeRel, this, Offset, P.first);
+      Main->RelaDyn->addReloc(Target->RelativeRel, this, Offset, P.first);
     }
     if (!Config->Pic)
       continue;
     // Dynamic relocations for "local" entries in case of PIC.
     for (const std::pair<const OutputSection *, FileGot::PageBlock> &L :
          Got.PagesMap) {
       size_t PageCount = L.second.Count;
       for (size_t PI = 0; PI < PageCount; ++PI) {
         uint64_t Offset = (L.second.FirstIndex + PI) * Config->Wordsize;
-        In.RelaDyn->addReloc({Target->RelativeRel, this, Offset, L.first,
+        Main->RelaDyn->addReloc({Target->RelativeRel, this, Offset, L.first,
                                  int64_t(PI * 0x10000)});
       }
     }
     for (const std::pair<GotEntry, size_t> &P : Got.Local16) {
       uint64_t Offset = P.second * Config->Wordsize;
-      In.RelaDyn->addReloc({Target->RelativeRel, this, Offset, true,
+      Main->RelaDyn->addReloc({Target->RelativeRel, this, Offset, true,
                                P.first.first, P.first.second});
     }
   }
 }
 
 bool MipsGotSection::isNeeded() const {
   // We add the .got section to the result for dynamic MIPS target because
   // its address and properties are mentioned in the .dynamic section.
   return !Config->Relocatable;
static uint64_t addPltRelSz() {
   if (In.RelaIplt->getParent() == In.RelaPlt->getParent() &&
       In.RelaIplt->Name == In.RelaPlt->Name)
     Size += In.RelaIplt->getSize();
   return Size;
 }
 
 // Add remaining entries to complete .dynamic contents.
 template <class ELFT> void DynamicSection<ELFT>::finalizeContents() {
+  elf::Partition &Part = getPartition();
+  bool IsMain = Part.Name.empty();
+
   for (StringRef S : Config->FilterList)
-    addInt(DT_FILTER, In.DynStrTab->addString(S));
+    addInt(DT_FILTER, Part.DynStrTab->addString(S));
   for (StringRef S : Config->AuxiliaryList)
-    addInt(DT_AUXILIARY, In.DynStrTab->addString(S));
+    addInt(DT_AUXILIARY, Part.DynStrTab->addString(S));
 
   if (!Config->Rpath.empty())
     addInt(Config->EnableNewDtags ? DT_RUNPATH : DT_RPATH,
-           In.DynStrTab->addString(Config->Rpath));
+           Part.DynStrTab->addString(Config->Rpath));
 
   for (SharedFile *File : SharedFiles)
     if (File->IsNeeded)
-      addInt(DT_NEEDED, In.DynStrTab->addString(File->SoName));
+      addInt(DT_NEEDED, Part.DynStrTab->addString(File->SoName));
+
+  if (IsMain) {
+    if (!Config->SoName.empty())
+      addInt(DT_SONAME, Part.DynStrTab->addString(Config->SoName));
+  } else {
     if (!Config->SoName.empty())
-    addInt(DT_SONAME, In.DynStrTab->addString(Config->SoName));
+      addInt(DT_NEEDED, Part.DynStrTab->addString(Config->SoName));
+    addInt(DT_SONAME, Part.DynStrTab->addString(Part.Name));
+  }
 
   // Set DT_FLAGS and DT_FLAGS_1.
   uint32_t DtFlags = 0;
   uint32_t DtFlags1 = 0;
   if (Config->Bsymbolic)
     DtFlags |= DF_SYMBOLIC;
   if (Config->ZGlobal)
     DtFlags1 |= DF_1_GLOBAL;
template <class ELFT> void DynamicSection<ELFT>::finalizeContents() {
   //
   // DT_DEBUG is the only .dynamic entry that needs to be written to. Some
   // systems (currently only Fuchsia OS) provide other means to give the
   // debugger this information. Such systems may choose make .dynamic read-only.
   // If the target is such a system (used -z rodynamic) don't write DT_DEBUG.
   if (!Config->Shared && !Config->Relocatable && !Config->ZRodynamic)
     addInt(DT_DEBUG, 0);
 
-  if (OutputSection *Sec = In.DynStrTab->getParent())
+  if (OutputSection *Sec = Part.DynStrTab->getParent())
     this->Link = Sec->SectionIndex;
 
-  if (In.RelaDyn->isNeeded()) {
-    addInSec(In.RelaDyn->DynamicTag, In.RelaDyn);
-    addSize(In.RelaDyn->SizeDynamicTag, In.RelaDyn->getParent());
+  if (Part.RelaDyn->isNeeded()) {
+    addInSec(Part.RelaDyn->DynamicTag, Part.RelaDyn);
+    addSize(Part.RelaDyn->SizeDynamicTag, Part.RelaDyn->getParent());
 
     bool IsRela = Config->IsRela;
     addInt(IsRela ? DT_RELAENT : DT_RELENT,
            IsRela ? sizeof(Elf_Rela) : sizeof(Elf_Rel));
 
     // MIPS dynamic loader does not support RELCOUNT tag.
     // The problem is in the tight relation between dynamic
     // relocations and GOT. So do not emit this tag on MIPS.
     if (Config->EMachine != EM_MIPS) {
-      size_t NumRelativeRels = In.RelaDyn->getRelativeRelocCount();
+      size_t NumRelativeRels = Part.RelaDyn->getRelativeRelocCount();
       if (Config->ZCombreloc && NumRelativeRels)
         addInt(IsRela ? DT_RELACOUNT : DT_RELCOUNT, NumRelativeRels);
     }
   }
-  if (In.RelrDyn && !In.RelrDyn->Relocs.empty()) {
+  if (Part.RelrDyn && !Part.RelrDyn->Relocs.empty()) {
     addInSec(Config->UseAndroidRelrTags ? DT_ANDROID_RELR : DT_RELR,
-             In.RelrDyn);
+             Part.RelrDyn);
     addSize(Config->UseAndroidRelrTags ? DT_ANDROID_RELRSZ : DT_RELRSZ,
-            In.RelrDyn->getParent());
+            Part.RelrDyn->getParent());
     addInt(Config->UseAndroidRelrTags ? DT_ANDROID_RELRENT : DT_RELRENT,
            sizeof(Elf_Relr));
   }
   // .rel[a].plt section usually consists of two parts, containing plt and
   // iplt relocations. It is possible to have only iplt relocations in the
   // output. In that case RelaPlt is empty and have zero offset, the same offset
   // as RelaIplt have. And we still want to emit proper dynamic tags for that
   // case, so here we always use RelaPlt as marker for the begining of
   // .rel[a].plt section.
-  if (In.RelaPlt->getParent()->isLive()) {
+  if (IsMain && In.RelaPlt->getParent()->isLive()) {
     addInSec(DT_JMPREL, In.RelaPlt);
     Entries.push_back({DT_PLTRELSZ, addPltRelSz});
     switch (Config->EMachine) {
     case EM_MIPS:
       addInSec(DT_MIPS_PLTGOT, In.GotPlt);
       break;
     case EM_SPARCV9:
       addInSec(DT_PLTGOT, In.Plt);
       break;
     default:
       addInSec(DT_PLTGOT, In.GotPlt);
       break;
     }
     addInt(DT_PLTREL, Config->IsRela ? DT_RELA : DT_REL);
   }
 
-  addInSec(DT_SYMTAB, In.DynSymTab);
+  addInSec(DT_SYMTAB, Part.DynSymTab);
   addInt(DT_SYMENT, sizeof(Elf_Sym));
-  addInSec(DT_STRTAB, In.DynStrTab);
-  addInt(DT_STRSZ, In.DynStrTab->getSize());
+  addInSec(DT_STRTAB, Part.DynStrTab);
+  addInt(DT_STRSZ, Part.DynStrTab->getSize());
   if (!Config->ZText)
     addInt(DT_TEXTREL, 0);
-  if (In.GnuHashTab)
-    addInSec(DT_GNU_HASH, In.GnuHashTab);
-  if (In.HashTab)
-    addInSec(DT_HASH, In.HashTab);
+  if (Part.GnuHashTab)
+    addInSec(DT_GNU_HASH, Part.GnuHashTab);
+  if (Part.HashTab)
+    addInSec(DT_HASH, Part.HashTab);
 
+  if (IsMain) {
     if (Out::PreinitArray) {
       addOutSec(DT_PREINIT_ARRAY, Out::PreinitArray);
       addSize(DT_PREINIT_ARRAYSZ, Out::PreinitArray);
     }
     if (Out::InitArray) {
       addOutSec(DT_INIT_ARRAY, Out::InitArray);
       addSize(DT_INIT_ARRAYSZ, Out::InitArray);
     }
     if (Out::FiniArray) {
       addOutSec(DT_FINI_ARRAY, Out::FiniArray);
       addSize(DT_FINI_ARRAYSZ, Out::FiniArray);
     }
 
     if (Symbol *B = Symtab->find(Config->Init))
       if (B->isDefined())
         addSym(DT_INIT, B);
     if (Symbol *B = Symtab->find(Config->Fini))
       if (B->isDefined())
         addSym(DT_FINI, B);
+  }
 
   bool HasVerNeed = SharedFile::VernauxNum != 0;
-  if (HasVerNeed || In.VerDef)
-    addInSec(DT_VERSYM, In.VerSym);
-  if (In.VerDef) {
-    addInSec(DT_VERDEF, In.VerDef);
+  if (HasVerNeed || Part.VerDef)
+    addInSec(DT_VERSYM, Part.VerSym);
+  if (Part.VerDef) {
+    addInSec(DT_VERDEF, Part.VerDef);
     addInt(DT_VERDEFNUM, getVerDefNum());
   }
   if (HasVerNeed) {
-    addInSec(DT_VERNEED, In.VerNeed);
+    addInSec(DT_VERNEED, Part.VerNeed);
     unsigned NeedNum = 0;
     for (SharedFile *F : SharedFiles)
       if (!F->Vernauxs.empty())
         ++NeedNum;
     addInt(DT_VERNEEDNUM, NeedNum);
   }
 
   if (Config->EMachine == EM_MIPS) {
     addInt(DT_MIPS_RLD_VERSION, 1);
     addInt(DT_MIPS_FLAGS, RHF_NOTPOT);
     addInt(DT_MIPS_BASE_ADDRESS, Target->getImageBase());
-    addInt(DT_MIPS_SYMTABNO, In.DynSymTab->getNumSymbols());
+    addInt(DT_MIPS_SYMTABNO, Part.DynSymTab->getNumSymbols());
 
     add(DT_MIPS_LOCAL_GOTNO, [] { return In.MipsGot->getLocalEntriesNum(); });
 
     if (const Symbol *B = In.MipsGot->getFirstGlobalEntry())
       addInt(DT_MIPS_GOTSYM, B->DynsymIndex);
     else
-      addInt(DT_MIPS_GOTSYM, In.DynSymTab->getNumSymbols());
+      addInt(DT_MIPS_GOTSYM, Part.DynSymTab->getNumSymbols());
     addInSec(DT_PLTGOT, In.MipsGot);
     if (In.MipsRldMap) {
       if (!Config->Pie)
         addInSec(DT_MIPS_RLD_MAP, In.MipsRldMap);
       // Store the offset to the .rld_map section
       // relative to the address of the tag.
       addInSecRelative(DT_MIPS_RLD_MAP_REL, In.MipsRldMap);
     }
int64_t DynamicReloc::computeAddend() const {
   if (UseSymVA)
     return Sym->getVA(Addend);
   if (!OutputSec)
     return Addend;
   // See the comment in the DynamicReloc ctor.
   return getMipsPageAddr(OutputSec->Addr) + Addend;
 }
 
-uint32_t DynamicReloc::getSymIndex() const {
+uint32_t DynamicReloc::getSymIndex(SymbolTableBaseSection *SymTab) const {
   if (Sym && !UseSymVA)
-    return Sym->DynsymIndex;
+    return SymTab->getSymbolIndex(Sym);
   return 0;
 }
 
 RelocationBaseSection::RelocationBaseSection(StringRef Name, uint32_t Type,
                                              int32_t DynamicTag,
                                              int32_t SizeDynamicTag)
     : SyntheticSection(SHF_ALLOC, Type, Config->Wordsize, Name),
       DynamicTag(DynamicTag), SizeDynamicTag(SizeDynamicTag) {}

 
 void RelocationBaseSection::addReloc(const DynamicReloc &Reloc) {
   if (Reloc.Type == Target->RelativeRel)
     ++NumRelativeRelocs;
   Relocs.push_back(Reloc);
 }
 
 void RelocationBaseSection::finalizeContents() {
+  SymbolTableBaseSection *SymTab = getPartition().DynSymTab;
+
   // When linking glibc statically, .rel{,a}.plt contains R_*_IRELATIVE
   // relocations due to IFUNC (e.g. strcpy). sh_link will be set to 0 in that
   // case.
-  if (In.DynSymTab && In.DynSymTab->getParent())
-    getParent()->Link = In.DynSymTab->getParent()->SectionIndex;
+  if (SymTab && SymTab->getParent())
+    getParent()->Link = SymTab->getParent()->SectionIndex;
   else
     getParent()->Link = 0;
 
   if (In.RelaPlt == this)
     getParent()->Info = In.GotPlt->getParent()->SectionIndex;
   if (In.RelaIplt == this)
     getParent()->Info = In.IgotPlt->getParent()->SectionIndex;
 }
 
 RelrBaseSection::RelrBaseSection()
     : SyntheticSection(SHF_ALLOC,
                        Config->UseAndroidRelrTags ? SHT_ANDROID_RELR : SHT_RELR,
                        Config->Wordsize, ".relr.dyn") {}
 
 template <class ELFT>
-static void encodeDynamicReloc(typename ELFT::Rela *P,
+static void encodeDynamicReloc(SymbolTableBaseSection *SymTab,
+                               typename ELFT::Rela *P,
                                const DynamicReloc &Rel) {
   if (Config->IsRela)
     P->r_addend = Rel.computeAddend();
   P->r_offset = Rel.getOffset();
-  P->setSymbolAndType(Rel.getSymIndex(), Rel.Type, Config->IsMips64EL);
+  P->setSymbolAndType(Rel.getSymIndex(SymTab), Rel.Type, Config->IsMips64EL);
 }
 
 template <class ELFT>
 RelocationSection<ELFT>::RelocationSection(StringRef Name, bool Sort)
     : RelocationBaseSection(Name, Config->IsRela ? SHT_RELA : SHT_REL,
                             Config->IsRela ? DT_RELA : DT_REL,
                             Config->IsRela ? DT_RELASZ : DT_RELSZ),
       Sort(Sort) {
   this->Entsize = Config->IsRela ? sizeof(Elf_Rela) : sizeof(Elf_Rel);
 }
 
 template <class ELFT> void RelocationSection<ELFT>::writeTo(uint8_t *Buf) {
+  SymbolTableBaseSection *SymTab = getPartition().DynSymTab;
+
   // Sort by (!IsRelative,SymIndex,r_offset). DT_REL[A]COUNT requires us to
   // place R_*_RELATIVE first. SymIndex is to improve locality, while r_offset
   // is to make results easier to read.
   if (Sort)
-    llvm::stable_sort(Relocs, [](const DynamicReloc &A, const DynamicReloc &B) {
-      return std::make_tuple(A.Type != Target->RelativeRel, A.getSymIndex(),
-                             A.getOffset()) <
-             std::make_tuple(B.Type != Target->RelativeRel, B.getSymIndex(),
-                             B.getOffset());
+    llvm::stable_sort(
+        Relocs, [&](const DynamicReloc &A, const DynamicReloc &B) {
+          return std::make_tuple(A.Type != Target->RelativeRel,
+                                 A.getSymIndex(SymTab), A.getOffset()) <
+                 std::make_tuple(B.Type != Target->RelativeRel,
+                                 B.getSymIndex(SymTab), B.getOffset());
         });
 
   for (const DynamicReloc &Rel : Relocs) {
-    encodeDynamicReloc<ELFT>(reinterpret_cast<Elf_Rela *>(Buf), Rel);
+    encodeDynamicReloc<ELFT>(SymTab, reinterpret_cast<Elf_Rela *>(Buf), Rel);
     Buf += Config->IsRela ? sizeof(Elf_Rela) : sizeof(Elf_Rel);
   }
 }
 
 template <class ELFT>
 AndroidPackedRelocationSection<ELFT>::AndroidPackedRelocationSection(
     StringRef Name)
     : RelocationBaseSection(
bool AndroidPackedRelocationSection<ELFT>::updateAllocSize() {
   // perform the initial adjustment).
   Add(Relocs.size());
   Add(0);
 
   std::vector<Elf_Rela> Relatives, NonRelatives;
 
   for (const DynamicReloc &Rel : Relocs) {
     Elf_Rela R;
-    encodeDynamicReloc<ELFT>(&R, Rel);
+    encodeDynamicReloc<ELFT>(getPartition().DynSymTab, &R, Rel);
 
     if (R.getType(Config->IsMips64EL) == Target->RelativeRel)
       Relatives.push_back(R);
     else
       NonRelatives.push_back(R);
   }
 
   llvm::sort(Relatives, [](const Elf_Rel &A, const Elf_Rel &B) {
void SymbolTableBaseSection::finalizeContents() {
 
   // If it is a .dynsym, there should be no local symbols, but we need
   // to do a few things for the dynamic linker.
 
   // Section's Info field has the index of the first non-local symbol.
   // Because the first symbol entry is a null entry, 1 is the first.
   getParent()->Info = 1;
 
-  if (In.GnuHashTab) {
+  if (getPartition().GnuHashTab) {
     // NB: It also sorts Symbols to meet the GNU hash table requirements.
-    In.GnuHashTab->addSymbols(Symbols);
+    getPartition().GnuHashTab->addSymbols(Symbols);
   } else if (Config->EMachine == EM_MIPS) {
     llvm::stable_sort(Symbols, sortMipsSymbols);
   }
 
+  // Only the main partition's dynsym indexes are stored in the symbols
+  // themselves. All other partitions use a lookup table.
+  if (this == Main->DynSymTab) {
     size_t I = 0;
     for (const SymbolTableEntry &S : Symbols)
       S.Sym->DynsymIndex = ++I;
   }
+}
 
 // The ELF spec requires that all local symbols precede global symbols, so we
 // sort symbol entries in this function. (For .dynsym, we don't do that because
 // symbols for dynamic linking are inherently all globals.)
 //
 // Aside from above, we put local symbols in groups starting with the STT_FILE
 // symbol. That is convenient for purpose of identifying where are local symbols
 // coming from.
void SymbolTableBaseSection::addSymbol(Symbol *B) {
   // Adding a local symbol to a .dynsym is a bug.
   assert(this->Type != SHT_DYNSYM || !B->isLocal());
 
   bool HashIt = B->isLocal();
   Symbols.push_back({B, StrTabSec.addString(B->getName(), HashIt)});
 }
 
 size_t SymbolTableBaseSection::getSymbolIndex(Symbol *Sym) {
-  // Initializes symbol lookup tables lazily. This is used only
-  // for -r or -emit-relocs.
+  if (this == Main->DynSymTab)
+    return Sym->DynsymIndex;
+
+  // Initializes symbol lookup tables lazily. This is used only for -r,
+  // -emit-relocs and dynsyms in partitions other than the main one.
   llvm::call_once(OnceFlag, [&] {
     SymbolIndexMap.reserve(Symbols.size());
     size_t I = 0;
     for (const SymbolTableEntry &E : Symbols) {
       if (E.Sym->Type == STT_SECTION)
         SectionIndexMap[E.Sym->getOutputSection()] = ++I;
       else
         SymbolIndexMap[E.Sym] = ++I;
template <class ELFT> void SymbolTableSection<ELFT>::writeTo(uint8_t *Buf) {
   // The first entry is a null entry as per the ELF spec.
   memset(Buf, 0, sizeof(Elf_Sym));
   Buf += sizeof(Elf_Sym);
 
   auto *ESym = reinterpret_cast<Elf_Sym *>(Buf);
 
   for (SymbolTableEntry &Ent : Symbols) {
     Symbol *Sym = Ent.Sym;
+    bool IsDefinedHere = Type == SHT_SYMTAB || Sym->Partition == Partition;
 
     // Set st_info and st_other.
     ESym->st_other = 0;
     if (Sym->isLocal()) {
       ESym->setBindingAndType(STB_LOCAL, Sym->Type);
     } else {
       ESym->setBindingAndType(Sym->computeBinding(), Sym->Type);
       ESym->setVisibility(Sym->Visibility);
     }
 
     // The 3 most significant bits of st_other are used by OpenPOWER ABI.
     // See getPPC64GlobalEntryToLocalEntryOffset() for more details.
     if (Config->EMachine == EM_PPC64)
       ESym->st_other |= Sym->StOther & 0xe0;
 
     ESym->st_name = Ent.StrTabOffset;
+    if (IsDefinedHere)
       ESym->st_shndx = getSymSectionIndex(Ent.Sym);
+    else
+      ESym->st_shndx = 0;
 
     // Copy symbol size if it is a defined symbol. st_size is not significant
     // for undefined symbols, so whether copying it or not is up to us if that's
     // the case. We'll leave it as zero because by not setting a value, we can
     // get the exact same outputs for two sets of input files that differ only
     // in undefined symbol size in DSOs.
-    if (ESym->st_shndx == SHN_UNDEF)
+    if (ESym->st_shndx == SHN_UNDEF || !IsDefinedHere)
       ESym->st_size = 0;
     else
       ESym->st_size = Sym->getSize();
 
     // st_value is usually an address of a symbol, but that has a
     // special meaining for uninstantiated common symbols (this can
     // occur if -r is given).
     if (BssSection *CommonSec = getCommonSec(Ent.Sym))

 // DSOs very quickly. If you are sure that your dynamic linker knows
 // about .gnu.hash, you want to specify -hash-style=gnu. Otherwise, a
 // safe bet is to specify -hash-style=both for backward compatibilty.
 GnuHashTableSection::GnuHashTableSection()
     : SyntheticSection(SHF_ALLOC, SHT_GNU_HASH, Config->Wordsize, ".gnu.hash") {
 }
 
 void GnuHashTableSection::finalizeContents() {
-  if (OutputSection *Sec = In.DynSymTab->getParent())
+  if (OutputSection *Sec = getPartition().DynSymTab->getParent())
     getParent()->Link = Sec->SectionIndex;
 
   // Computes bloom filter size in word size. We want to allocate 12
   // bits for each symbol. It must be a power of two.
   if (Symbols.empty()) {
     MaskWords = 1;
   } else {
     uint64_t NumBits = Symbols.size() * 12;

 void GnuHashTableSection::writeTo(uint8_t *Buf) {
   // The output buffer is not guaranteed to be zero-cleared because we pre-
   // fill executable sections with trap instructions. This is a precaution
   // for that case, which happens only when -no-rosegment is given.
   memset(Buf, 0, Size);
 
   // Write a header.
   write32(Buf, NBuckets);
-  write32(Buf + 4, In.DynSymTab->getNumSymbols() - Symbols.size());
+  write32(Buf + 4, getPartition().DynSymTab->getNumSymbols() - Symbols.size());
   write32(Buf + 8, MaskWords);
   write32(Buf + 12, Shift2);
   Buf += 16;
 
   // Write a bloom filter and a hash table.
   writeBloomFilter(Buf);
   Buf += Config->Wordsize * MaskWords;
   writeHashTable(Buf);
for (auto I = Symbols.begin(), E = Symbols.end(); I != E; ++I) {
     bool IsLastInChain = (I + 1) == E || I->BucketIdx != (I + 1)->BucketIdx;
     Hash = IsLastInChain ? Hash | 1 : Hash & ~1;
     write32(Values++, Hash);
 
     if (I->BucketIdx == OldBucket)
       continue;
     // Write a hash bucket. Hash buckets contain indices in the following hash
     // value table.
-    write32(Buckets + I->BucketIdx, I->Sym->DynsymIndex);
+    write32(Buckets + I->BucketIdx,
+            getPartition().DynSymTab->getSymbolIndex(I->Sym));
     OldBucket = I->BucketIdx;
   }
 }
 
 static uint32_t hashGnu(StringRef Name) {
   uint32_t H = 5381;
   for (uint8_t C : Name)
     H = (H << 5) + H + C;
   return H;
 }
 
 // Add symbols to this symbol hash table. Note that this function
 // destructively sort a given vector -- which is needed because
 // GNU-style hash table places some sorting requirements.
 void GnuHashTableSection::addSymbols(std::vector<SymbolTableEntry> &V) {
   // We cannot use 'auto' for Mid because GCC 6.1 cannot deduce
   // its type correctly.
   std::vector<SymbolTableEntry>::iterator Mid =
-      std::stable_partition(V.begin(), V.end(), [](const SymbolTableEntry &S) {
-        return !S.Sym->isDefined();
+      std::stable_partition(V.begin(), V.end(), [&](const SymbolTableEntry &S) {
+        return !S.Sym->isDefined() || S.Sym->Partition != Partition;
       });
 
   // We chose load factor 4 for the on-disk hash table. For each hash
   // collision, the dynamic linker will compare a uint32_t hash value.
   // Since the integer comparison is quite fast, we believe we can
   // make the load factor even larger. 4 is just a conservative choice.
   //
   // Note that we don't want to create a zero-sized hash table because

 }
 
 HashTableSection::HashTableSection()
     : SyntheticSection(SHF_ALLOC, SHT_HASH, 4, ".hash") {
   this->Entsize = 4;
 }
 
 void HashTableSection::finalizeContents() {
-  if (OutputSection *Sec = In.DynSymTab->getParent())
+  SymbolTableBaseSection *SymTab = getPartition().DynSymTab;
+
+  if (OutputSection *Sec = SymTab->getParent())
     getParent()->Link = Sec->SectionIndex;
 
-  unsigned NumEntries = 2;                       // nbucket and nchain.
-  NumEntries += In.DynSymTab->getNumSymbols();   // The chain entries.
+  unsigned NumEntries = 2;               // nbucket and nchain.
+  NumEntries += SymTab->getNumSymbols(); // The chain entries.
 
   // Create as many buckets as there are symbols.
-  NumEntries += In.DynSymTab->getNumSymbols();
+  NumEntries += SymTab->getNumSymbols();
   this->Size = NumEntries * 4;
 }
 
 void HashTableSection::writeTo(uint8_t *Buf) {
+  SymbolTableBaseSection *SymTab = getPartition().DynSymTab;
+
   // See comment in GnuHashTableSection::writeTo.
   memset(Buf, 0, Size);
 
-  unsigned NumSymbols = In.DynSymTab->getNumSymbols();
+  unsigned NumSymbols = SymTab->getNumSymbols();
 
   uint32_t *P = reinterpret_cast<uint32_t *>(Buf);
   write32(P++, NumSymbols); // nbucket
   write32(P++, NumSymbols); // nchain
 
   uint32_t *Buckets = P;
   uint32_t *Chains = P + NumSymbols;
 
-  for (const SymbolTableEntry &S : In.DynSymTab->getSymbols()) {
+  for (const SymbolTableEntry &S : SymTab->getSymbols()) {
     Symbol *Sym = S.Sym;
     StringRef Name = Sym->getName();
     unsigned I = Sym->DynsymIndex;
     uint32_t Hash = hashSysV(Name) % NumSymbols;
     Chains[I] = Buckets[Hash];
     write32(Buckets + Hash, I);
   }
 }

 // .eh_frame_hdr contains a binary search table of pointers to FDEs.
 // Each entry of the search table consists of two values,
 // the starting PC from where FDEs covers, and the FDE's address.
 // It is sorted by PC.
 void EhFrameHeader::write() {
   uint8_t *Buf = Out::BufferStart + getParent()->Offset + OutSecOff;
   using FdeData = EhFrameSection::FdeData;
 
-  std::vector<FdeData> Fdes = In.EhFrame->getFdeData();
+  std::vector<FdeData> Fdes = getPartition().EhFrame->getFdeData();
 
   Buf[0] = 1;
   Buf[1] = DW_EH_PE_pcrel | DW_EH_PE_sdata4;
   Buf[2] = DW_EH_PE_udata4;
   Buf[3] = DW_EH_PE_datarel | DW_EH_PE_sdata4;
-  write32(Buf + 4, In.EhFrame->getParent()->Addr - this->getVA() - 4);
+  write32(Buf + 4,
+          getPartition().EhFrame->getParent()->Addr - this->getVA() - 4);
   write32(Buf + 8, Fdes.size());
   Buf += 12;
 
   for (FdeData &Fde : Fdes) {
     write32(Buf, Fde.PcRel);
     write32(Buf + 4, Fde.FdeVARel);
     Buf += 8;
   }
 }
 
 size_t EhFrameHeader::getSize() const {
   // .eh_frame_hdr has a 12 bytes header followed by an array of FDEs.
-  return 12 + In.EhFrame->NumFdes * 8;
+  return 12 + getPartition().EhFrame->NumFdes * 8;
 }
 
-bool EhFrameHeader::isNeeded() const { return In.EhFrame->isNeeded(); }
+bool EhFrameHeader::isNeeded() const {
+  return isLive() && getPartition().EhFrame->isNeeded();
+}
 
 VersionDefinitionSection::VersionDefinitionSection()
     : SyntheticSection(SHF_ALLOC, SHT_GNU_verdef, sizeof(uint32_t),
                        ".gnu.version_d") {}
 
-static StringRef getFileDefName() {
+StringRef VersionDefinitionSection::getFileDefName() {
+  if (!getPartition().Name.empty())
+    return getPartition().Name;
   if (!Config->SoName.empty())
     return Config->SoName;
   return Config->OutputFile;
 }
 
 void VersionDefinitionSection::finalizeContents() {
-  FileDefNameOff = In.DynStrTab->addString(getFileDefName());
+  FileDefNameOff = getPartition().DynStrTab->addString(getFileDefName());
   for (VersionDefinition &V : Config->VersionDefinitions)
-    V.NameOff = In.DynStrTab->addString(V.Name);
+    V.NameOff = getPartition().DynStrTab->addString(V.Name);
 
-  if (OutputSection *Sec = In.DynStrTab->getParent())
+  if (OutputSection *Sec = getPartition().DynStrTab->getParent())
     getParent()->Link = Sec->SectionIndex;
 
   // sh_info should be set to the number of definitions. This fact is missed in
   // documentation, but confirmed by binutils community:
   // https://sourceware.org/ml/binutils/2014-11/msg00355.html
   getParent()->Info = getVerDefNum();
 }
 
VersionTableSection::VersionTableSection()
     : SyntheticSection(SHF_ALLOC, SHT_GNU_versym, sizeof(uint16_t),
                        ".gnu.version") {
   this->Entsize = 2;
 }
 
 void VersionTableSection::finalizeContents() {
   // At the moment of june 2016 GNU docs does not mention that sh_link field
   // should be set, but Sun docs do. Also readelf relies on this field.
-  getParent()->Link = In.DynSymTab->getParent()->SectionIndex;
+  getParent()->Link = getPartition().DynSymTab->getParent()->SectionIndex;
 }
 
 size_t VersionTableSection::getSize() const {
-  return (In.DynSymTab->getSymbols().size() + 1) * 2;
+  return (getPartition().DynSymTab->getSymbols().size() + 1) * 2;
 }
 
 void VersionTableSection::writeTo(uint8_t *Buf) {
   Buf += 2;
-  for (const SymbolTableEntry &S : In.DynSymTab->getSymbols()) {
+  for (const SymbolTableEntry &S : getPartition().DynSymTab->getSymbols()) {
     write16(Buf, S.Sym->VersionId);
     Buf += 2;
   }
 }
 
 bool VersionTableSection::isNeeded() const {
-  return In.VerDef || In.VerNeed->isNeeded();
+  return getPartition().VerDef || getPartition().VerNeed->isNeeded();
 }
 
 void elf::addVerneed(Symbol *SS) {
   auto &File = cast<SharedFile>(*SS->File);
   if (SS->VerdefIndex == VER_NDX_GLOBAL) {
     SS->VersionId = VER_NDX_GLOBAL;
     return;
   }
: SyntheticSection(SHF_ALLOC, SHT_GNU_verneed, sizeof(uint32_t),
                        ".gnu.version_r") {}
 
 template <class ELFT> void VersionNeedSection<ELFT>::finalizeContents() {
   for (SharedFile *F : SharedFiles) {
     if (F->Vernauxs.empty())
       continue;
     Verneeds.emplace_back();
     Verneed &VN = Verneeds.back();
-    VN.NameStrTab = In.DynStrTab->addString(F->SoName);
+    VN.NameStrTab = getPartition().DynStrTab->addString(F->SoName);
     for (unsigned I = 0; I != F->Vernauxs.size(); ++I) {
       if (F->Vernauxs[I] == 0)
         continue;
       auto *Verdef =
           reinterpret_cast<const typename ELFT::Verdef *>(F->Verdefs[I]);
       VN.Vernauxs.push_back(
           {Verdef->vd_hash, F->Vernauxs[I],
-           In.DynStrTab->addString(F->getStringTable().data() +
+           getPartition().DynStrTab->addString(F->getStringTable().data() +
                                                Verdef->getAux()->vda_name)});
     }
   }
 
-  if (OutputSection *Sec = In.DynStrTab->getParent())
+  if (OutputSection *Sec = getPartition().DynStrTab->getParent())
     getParent()->Link = Sec->SectionIndex;
   getParent()->Info = Verneeds.size();
 }
 
 template <class ELFT> void VersionNeedSection<ELFT>::writeTo(uint8_t *Buf) {
   // The Elf_Verneeds need to appear first, followed by the Elf_Vernauxs.
   auto *Verneed = reinterpret_cast<Elf_Verneed *>(Buf);
   auto *Vernaux = reinterpret_cast<Elf_Vernaux *>(Verneed + Verneeds.size());
bool PPC64LongBranchTargetSection::isNeeded() const {
   // is too early to determine if this section will be empty or not. We need
   // Finalized to keep the section alive until after thunk creation. Finalized
   // only gets set to true once `finalizeSections()` is called after thunk
   // creation. Becuase of this, if we don't create any long-branch thunks we end
   // up with an empty .branch_lt section in the binary.
   return !Finalized || !Entries.empty();
 }
 
+static uint8_t getAbiVersion() {
+  // MIPS non-PIC executable gets ABI version 1.
+  if (Config->EMachine == EM_MIPS) {
+    if (!Config->Pic && !Config->Relocatable &&
+        (Config->EFlags & (EF_MIPS_PIC | EF_MIPS_CPIC)) == EF_MIPS_CPIC)
+      return 1;
+    return 0;
+  }
+
+  if (Config->EMachine == EM_AMDGPU) {
+    uint8_t Ver = ObjectFiles[0]->ABIVersion;
+    for (InputFile *File : makeArrayRef(ObjectFiles).slice(1))
+      if (File->ABIVersion != Ver)
+        error("incompatible ABI version: " + toString(File));
+    return Ver;
+  }
+
+  return 0;
+}
+
+template <typename ELFT> void elf::writeEhdr(uint8_t *Buf, Partition &Part) {
+  // For executable segments, the trap instructions are written before writing
+  // the header. Setting Elf header bytes to zero ensures that any unused bytes
+  // in header are zero-cleared, instead of having trap instructions.
+  memset(Buf, 0, sizeof(typename ELFT::Ehdr));
+  memcpy(Buf, "\177ELF", 4);
+
+  auto *EHdr = reinterpret_cast<typename ELFT::Ehdr *>(Buf);
+  EHdr->e_ident[EI_CLASS] = Config->Is64 ? ELFCLASS64 : ELFCLASS32;
+  EHdr->e_ident[EI_DATA] = Config->IsLE ? ELFDATA2LSB : ELFDATA2MSB;
+  EHdr->e_ident[EI_VERSION] = EV_CURRENT;
+  EHdr->e_ident[EI_OSABI] = Config->OSABI;
+  EHdr->e_ident[EI_ABIVERSION] = getAbiVersion();
+  EHdr->e_machine = Config->EMachine;
+  EHdr->e_version = EV_CURRENT;
+  EHdr->e_flags = Config->EFlags;
+  EHdr->e_ehsize = sizeof(typename ELFT::Ehdr);
+  EHdr->e_phnum = Part.Phdrs.size();
+  EHdr->e_shentsize = sizeof(typename ELFT::Shdr);
+
+  if (!Config->Relocatable) {
+    EHdr->e_phoff = sizeof(typename ELFT::Ehdr);
+    EHdr->e_phentsize = sizeof(typename ELFT::Phdr);
+  }
+}
+
+template <typename ELFT> void elf::writePhdrs(uint8_t *Buf, Partition &Part) {
+  // Write the program header table.
+  auto *HBuf = reinterpret_cast<typename ELFT::Phdr *>(Buf);
+  for (PhdrEntry *P : Part.Phdrs) {
+    HBuf->p_type = P->p_type;
+    HBuf->p_flags = P->p_flags;
+    HBuf->p_offset = P->p_offset;
+    HBuf->p_vaddr = P->p_vaddr;
+    HBuf->p_paddr = P->p_paddr;
+    HBuf->p_filesz = P->p_filesz;
+    HBuf->p_memsz = P->p_memsz;
+    HBuf->p_align = P->p_align;
+    ++HBuf;
+  }
+}
+
+template <typename ELFT>
+PartitionElfHeaderSection<ELFT>::PartitionElfHeaderSection()
+    : SyntheticSection(SHF_ALLOC, SHT_LLVM_PART_EHDR, 1, "") {}
+
+template <typename ELFT>
+size_t PartitionElfHeaderSection<ELFT>::getSize() const {
+  return sizeof(typename ELFT::Ehdr);
+}
+
+template <typename ELFT>
+void PartitionElfHeaderSection<ELFT>::writeTo(uint8_t *Buf) {
+  writeEhdr<ELFT>(Buf, getPartition());
+
+  // Loadable partitions are always ET_DYN.
+  auto *EHdr = reinterpret_cast<typename ELFT::Ehdr *>(Buf);
+  EHdr->e_type = ET_DYN;
+}
+
+template <typename ELFT>
+PartitionProgramHeadersSection<ELFT>::PartitionProgramHeadersSection()
+    : SyntheticSection(SHF_ALLOC, SHT_LLVM_PART_PHDR, 1, ".phdrs") {}
+
+template <typename ELFT>
+size_t PartitionProgramHeadersSection<ELFT>::getSize() const {
+  return sizeof(typename ELFT::Phdr) * getPartition().Phdrs.size();
+}
+
+template <typename ELFT>
+void PartitionProgramHeadersSection<ELFT>::writeTo(uint8_t *Buf) {
+  writePhdrs<ELFT>(Buf, getPartition());
+}
+
+PartitionIndexSection::PartitionIndexSection()
+    : SyntheticSection(SHF_ALLOC, SHT_PROGBITS, 4, ".rodata") {}
+
+size_t PartitionIndexSection::getSize() const {
+  return 12 * (Partitions.size() - 1);
+}
+
+void PartitionIndexSection::finalizeContents() {
+  for (size_t I = 1; I != Partitions.size(); ++I)
+    Partitions[I].NameStrTab = Main->DynStrTab->addString(Partitions[I].Name);
+}
+
+void PartitionIndexSection::writeTo(uint8_t *Buf) {
+  uint64_t VA = getVA();
+  for (size_t I = 1; I != Partitions.size(); ++I) {
+    write32(Buf, Main->DynStrTab->getVA() + Partitions[I].NameStrTab - VA);
+    write32(Buf + 4, Partitions[I].ElfHeader->getVA() - (VA + 4));
+
+    SyntheticSection *Next =
+        I == Partitions.size() - 1 ? In.PartEnd : Partitions[I + 1].ElfHeader;
+    write32(Buf + 8, Next->getVA() - Partitions[I].ElfHeader->getVA());
+
+    VA += 12;
+    Buf += 12;
+  }
+}
+
 InStruct elf::In;
 
 std::vector<Partition> elf::Partitions;
+Partition *elf::Main;
 
 template GdbIndexSection *GdbIndexSection::create<ELF32LE>();
 template GdbIndexSection *GdbIndexSection::create<ELF32BE>();
 template GdbIndexSection *GdbIndexSection::create<ELF64LE>();
 template GdbIndexSection *GdbIndexSection::create<ELF64BE>();
 
 template void elf::splitSections<ELF32LE>();
 template void elf::splitSections<ELF32BE>();

 template class elf::SymbolTableSection<ELF32BE>;
 template class elf::SymbolTableSection<ELF64LE>;
 template class elf::SymbolTableSection<ELF64BE>;
 
 template class elf::VersionNeedSection<ELF32LE>;
 template class elf::VersionNeedSection<ELF32BE>;
 template class elf::VersionNeedSection<ELF64LE>;
 template class elf::VersionNeedSection<ELF64BE>;
+
+template void elf::writeEhdr<ELF32LE>(uint8_t *Buf, Partition &Part);
+template void elf::writeEhdr<ELF32BE>(uint8_t *Buf, Partition &Part);
+template void elf::writeEhdr<ELF64LE>(uint8_t *Buf, Partition &Part);
+template void elf::writeEhdr<ELF64BE>(uint8_t *Buf, Partition &Part);
+
+template void elf::writePhdrs<ELF32LE>(uint8_t *Buf, Partition &Part);
+template void elf::writePhdrs<ELF32BE>(uint8_t *Buf, Partition &Part);
+template void elf::writePhdrs<ELF64LE>(uint8_t *Buf, Partition &Part);
+template void elf::writePhdrs<ELF64BE>(uint8_t *Buf, Partition &Part);
+
+template class elf::PartitionElfHeaderSection<ELF32LE>;
+template class elf::PartitionElfHeaderSection<ELF32BE>;
+template class elf::PartitionElfHeaderSection<ELF64LE>;
+template class elf::PartitionElfHeaderSection<ELF64BE>;
+
+template class elf::PartitionProgramHeadersSection<ELF32LE>;
+template class elf::PartitionProgramHeadersSection<ELF32BE>;
+template class elf::PartitionProgramHeadersSection<ELF64LE>;
+template class elf::PartitionProgramHeadersSection<ELF64BE>;

lld/ELF/Thunks.cpp

 class PPC64PILongBranchThunk final : public PPC64LongBranchThunk {
 public:
   PPC64PILongBranchThunk(Symbol &Dest) : PPC64LongBranchThunk(Dest) {
     assert(!Dest.IsPreemptible);
     if (Dest.isInPPC64Branchlt())
       return;
 
     In.PPC64LongBranchTarget->addEntry(Dest);
-    In.RelaDyn->addReloc({Target->RelativeRel, In.PPC64LongBranchTarget,
-                          Dest.getPPC64LongBranchOffset(), true, &Dest,
-                          getPPC64GlobalEntryToLocalEntryOffset(Dest.StOther)});
+    Main->RelaDyn->addReloc(
+        {Target->RelativeRel, In.PPC64LongBranchTarget,
   }
 };
 
 class PPC64PDLongBranchThunk final : public PPC64LongBranchThunk {
 public:
   PPC64PDLongBranchThunk(Symbol &Dest) : PPC64LongBranchThunk(Dest) {
     if (!Dest.isInPPC64Branchlt())
       In.PPC64LongBranchTarget->addEntry(Dest);

lld/ELF/Writer.cpp

private:
   void sortSections();
   void resolveShfLinkOrder();
   void finalizeAddressDependentContent();
   void sortInputSections();
   void finalizeSections();
   void checkExecuteOnly();
   void setReservedSymbolSections();
 
-  std::vector<PhdrEntry *> createPhdrs();
-  void removeEmptyPTLoad();
-  void addPhdrForSection(std::vector<PhdrEntry *> &Phdrs, unsigned ShType,
-                         unsigned PType, unsigned PFlags);
+  std::vector<PhdrEntry *> createPhdrs(Partition &Part);
+  void removeEmptyPTLoad(std::vector<PhdrEntry *> &PhdrEntry);
+  void addPhdrForSection(Partition &Part, unsigned ShType, unsigned PType,
+                         unsigned PFlags);
   void assignFileOffsets();
   void assignFileOffsetsBinary();
-  void setPhdrs();
+  void setPhdrs(Partition &Part);
   void checkSections();
   void fixSectionAlignments();
   void openFile();
   void writeTrapInstr();
   void writeHeader();
   void writeSections();
   void writeSectionsBinary();
   void writeBuildId();
 
   std::unique_ptr<FileOutputBuffer> &Buffer;
 
   void addRelIpltSymbols();
   void addStartEndSymbols();
   void addStartStopSymbols(OutputSection *Sec);
 
-  std::vector<PhdrEntry *> Phdrs;
-
   uint64_t FileSize;
   uint64_t SectionHeaderOff;
 };
 } // anonymous namespace
 
 static bool isSectionPrefix(StringRef Prefix, StringRef Name) {
   return Name.startswith(Prefix) || Name == Prefix.drop_back();
 }

 
 static bool needsInterpSection() {
   return !SharedFiles.empty() && !Config->DynamicLinker.empty() &&
          Script->needsInterpSection();
 }
 
 template <class ELFT> void elf::writeResult() { Writer<ELFT>().run(); }
 
-template <class ELFT> void Writer<ELFT>::removeEmptyPTLoad() {
+template <class ELFT>
+void Writer<ELFT>::removeEmptyPTLoad(std::vector<PhdrEntry *> &Phdrs) {
   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;
     return Size == 0;
   });
 }
 
+template <class ELFT> static void copySectionsIntoPartitions() {
+  std::vector<InputSectionBase *> NewSections;
+  for (unsigned Part = 2; Part != Partitions.size() + 1; ++Part) {
+    for (InputSectionBase *S : InputSections) {
+      if (!(S->Flags & SHF_ALLOC) || !S->isLive())
+        continue;
+      InputSectionBase *Copy;
+      if (S->Type == SHT_NOTE)
+        Copy = make<InputSection>(cast<InputSection>(*S));
+      else if (auto *ES = dyn_cast<EhInputSection>(S))
+        Copy = make<EhInputSection>(*ES);
+      else
+        continue;
+      Copy->Partition = Part;
+      NewSections.push_back(Copy);
+    }
+  }
+
+  InputSections.insert(InputSections.end(), NewSections.begin(),
+                       NewSections.end());
+}
+
 template <class ELFT> static void combineEhSections() {
   for (InputSectionBase *&S : InputSections) {
     if (!S->isLive())
       continue;
 
+    Partition &Part = S->getPartition();
     if (auto *ES = dyn_cast<EhInputSection>(S)) {
-      In.EhFrame->addSection<ELFT>(ES);
+      Part.EhFrame->addSection<ELFT>(ES);
       S = nullptr;
-    } else if (S->kind() == SectionBase::Regular && In.ARMExidx &&
-               In.ARMExidx->addSection(cast<InputSection>(S))) {
+    } else if (S->kind() == SectionBase::Regular && Part.ARMExidx &&
+               Part.ARMExidx->addSection(cast<InputSection>(S))) {
       S = nullptr;
     }
   }
 
   std::vector<InputSectionBase *> &V = InputSections;
   V.erase(std::remove(V.begin(), V.end(), nullptr), V.end());
 }
 
void elf::addReservedSymbols() {
   ElfSym::End1 = Add("end", -1);
   ElfSym::End2 = Add("_end", -1);
   ElfSym::Etext1 = Add("etext", -1);
   ElfSym::Etext2 = Add("_etext", -1);
   ElfSym::Edata1 = Add("edata", -1);
   ElfSym::Edata2 = Add("_edata", -1);
 }
 
-static OutputSection *findSection(StringRef Name) {
+static OutputSection *findSection(StringRef Name, unsigned Partition = 1) {
   for (BaseCommand *Base : Script->SectionCommands)
     if (auto *Sec = dyn_cast<OutputSection>(Base))
-      if (Sec->Name == Name)
+      if (Sec->Name == Name && Sec->Partition == Partition)
         return Sec;
   return nullptr;
 }
 
 // Initialize Out members.
 template <class ELFT> static void createSyntheticSections() {
   // Initialize all pointers with NULL. This is needed because
   // you can call lld::elf::main more than once as a library.
   memset(&Out::First, 0, sizeof(Out));
 
   auto Add = [](InputSectionBase *Sec) { InputSections.push_back(Sec); };
 
-  In.DynStrTab = make<StringTableSection>(".dynstr", true);
-  In.Dynamic = make<DynamicSection<ELFT>>();
-  if (Config->AndroidPackDynRelocs) {
-    In.RelaDyn = make<AndroidPackedRelocationSection<ELFT>>(
-        Config->IsRela ? ".rela.dyn" : ".rel.dyn");
-  } else {
-    In.RelaDyn = make<RelocationSection<ELFT>>(
-        Config->IsRela ? ".rela.dyn" : ".rel.dyn", Config->ZCombreloc);
-  }
   In.ShStrTab = make<StringTableSection>(".shstrtab", false);
 
   Out::ProgramHeaders = make<OutputSection>("", 0, SHF_ALLOC);
   Out::ProgramHeaders->Alignment = Config->Wordsize;
 
-  if (needsInterpSection())
-    Add(createInterpSection());
-
   if (Config->Strip != StripPolicy::All) {
     In.StrTab = make<StringTableSection>(".strtab", false);
     In.SymTab = make<SymbolTableSection<ELFT>>(*In.StrTab);
     In.SymTabShndx = make<SymtabShndxSection>();
   }
 
-  if (Config->BuildId != BuildIdKind::None) {
-    In.BuildId = make<BuildIdSection>();
-    Add(In.BuildId);
-  }
-
   In.Bss = make<BssSection>(".bss", 0, 1);
   Add(In.Bss);
 
   // If there is a SECTIONS command and a .data.rel.ro section name use name
   // .data.rel.ro.bss so that we match in the .data.rel.ro output section.
   // This makes sure our relro is contiguous.
-  bool HasDataRelRo = Script->HasSectionsCommand && findSection(".data.rel.ro");
+  bool HasDataRelRo =
+      Script->HasSectionsCommand && findSection(".data.rel.ro", 0);
   In.BssRelRo =
       make<BssSection>(HasDataRelRo ? ".data.rel.ro.bss" : ".bss.rel.ro", 0, 1);
   Add(In.BssRelRo);
 
   // Add MIPS-specific sections.
   if (Config->EMachine == EM_MIPS) {
     if (!Config->Shared && Config->HasDynSymTab) {
       In.MipsRldMap = make<MipsRldMapSection>();
       Add(In.MipsRldMap);
     }
     if (auto *Sec = MipsAbiFlagsSection<ELFT>::create())
       Add(Sec);
     if (auto *Sec = MipsOptionsSection<ELFT>::create())
       Add(Sec);
     if (auto *Sec = MipsReginfoSection<ELFT>::create())
       Add(Sec);
   }
 
+  for (Partition &Part : Partitions) {
+    auto Add = [&](InputSectionBase *Sec) {
+      Sec->Partition = Part.getNumber();
+      InputSections.push_back(Sec);
+    };
+
+    if (!Part.Name.empty()) {
+      Part.ElfHeader = make<PartitionElfHeaderSection<ELFT>>();
+      Part.ElfHeader->Name = Part.Name;
+      Add(Part.ElfHeader);
+
+      Part.ProgramHeaders = make<PartitionProgramHeadersSection<ELFT>>();
+      Add(Part.ProgramHeaders);
+    }
+
+    if (Config->BuildId != BuildIdKind::None) {
+      Part.BuildId = make<BuildIdSection>();
+      Add(Part.BuildId);
+    }
+
+    Part.DynStrTab = make<StringTableSection>(".dynstr", true);
+    Part.DynSymTab = make<SymbolTableSection<ELFT>>(*Part.DynStrTab);
+    Part.Dynamic = make<DynamicSection<ELFT>>();
+    if (Config->AndroidPackDynRelocs) {
+      Part.RelaDyn = make<AndroidPackedRelocationSection<ELFT>>(
+          Config->IsRela ? ".rela.dyn" : ".rel.dyn");
+    } else {
+      Part.RelaDyn = make<RelocationSection<ELFT>>(
+          Config->IsRela ? ".rela.dyn" : ".rel.dyn", Config->ZCombreloc);
+    }
+
+    if (needsInterpSection())
+      Add(createInterpSection());
+
     if (Config->HasDynSymTab) {
-    In.DynSymTab = make<SymbolTableSection<ELFT>>(*In.DynStrTab);
-    Add(In.DynSymTab);
+      Part.DynSymTab = make<SymbolTableSection<ELFT>>(*Part.DynStrTab);
+      Add(Part.DynSymTab);
 
-    In.VerSym = make<VersionTableSection>();
-    Add(In.VerSym);
+      Part.VerSym = make<VersionTableSection>();
+      Add(Part.VerSym);
 
       if (!Config->VersionDefinitions.empty()) {
-      In.VerDef = make<VersionDefinitionSection>();
-      Add(In.VerDef);
+        Part.VerDef = make<VersionDefinitionSection>();
+        Add(Part.VerDef);
       }
 
-    In.VerNeed = make<VersionNeedSection<ELFT>>();
-    Add(In.VerNeed);
+      Part.VerNeed = make<VersionNeedSection<ELFT>>();
+      Add(Part.VerNeed);
 
       if (Config->GnuHash) {
-      In.GnuHashTab = make<GnuHashTableSection>();
-      Add(In.GnuHashTab);
+        Part.GnuHashTab = make<GnuHashTableSection>();
+        Add(Part.GnuHashTab);
       }
 
       if (Config->SysvHash) {
-      In.HashTab = make<HashTableSection>();
-      Add(In.HashTab);
+        Part.HashTab = make<HashTableSection>();
+        Add(Part.HashTab);
       }
 
-    Add(In.Dynamic);
-    Add(In.DynStrTab);
-    Add(In.RelaDyn);
+      Add(Part.Dynamic);
+      Add(Part.DynStrTab);
+      Add(Part.RelaDyn);
     }
 
     if (Config->RelrPackDynRelocs) {
-    In.RelrDyn = make<RelrSection<ELFT>>();
-    Add(In.RelrDyn);
+      Part.RelrDyn = make<RelrSection<ELFT>>();
+      Add(Part.RelrDyn);
+    }
+
+    if (!Config->Relocatable) {
+      if (Config->EhFrameHdr) {
+        Part.EhFrameHdr = make<EhFrameHeader>();
+        Add(Part.EhFrameHdr);
+      }
+      Part.EhFrame = make<EhFrameSection>();
+      Add(Part.EhFrame);
+    }
+
+    if (Config->EMachine == EM_ARM && !Config->Relocatable) {
+      // The ARMExidxsyntheticsection replaces all the individual .ARM.exidx
+      // InputSections.
+      Part.ARMExidx = make<ARMExidxSyntheticSection>();
+      Add(Part.ARMExidx);
+    }
+  }
+
+  if (Partitions.size() != 1) {
+    // Create the partition end marker. This needs to be in partition number 255
+    // so that it is sorted after all other partitions. It also has other
+    // special handling (see createPhdrs()).
+    In.PartEnd = make<BssSection>(".part.end", Config->MaxPageSize, 1);
+    In.PartEnd->Partition = 255;
+    Add(In.PartEnd);
+
+    In.PartIndex = make<PartitionIndexSection>();
+    addOptionalRegular("__part_index_begin", In.PartIndex, 0);
+    addOptionalRegular("__part_index_end", In.PartIndex,
+                       In.PartIndex->getSize());
+    Add(In.PartIndex);
   }
 
   // Add .got. MIPS' .got is so different from the other archs,
   // it has its own class.
   if (Config->EMachine == EM_MIPS) {
     In.MipsGot = make<MipsGotSection>();
     Add(In.MipsGot);
   } else {
template <class ELFT> static void createSyntheticSections() {
   // .note.GNU-stack is always added when we are creating a re-linkable
   // object file. Other linkers are using the presence of this marker
   // section to control the executable-ness of the stack area, but that
   // is irrelevant these days. Stack area should always be non-executable
   // by default. So we emit this section unconditionally.
   if (Config->Relocatable)
     Add(make<GnuStackSection>());
 
-  if (!Config->Relocatable) {
-    if (Config->EhFrameHdr) {
-      In.EhFrameHdr = make<EhFrameHeader>();
-      Add(In.EhFrameHdr);
-    }
-    In.EhFrame = make<EhFrameSection>();
-    Add(In.EhFrame);
-  }
-
   if (In.SymTab)
     Add(In.SymTab);
   if (In.SymTabShndx)
     Add(In.SymTabShndx);
   Add(In.ShStrTab);
   if (In.StrTab)
     Add(In.StrTab);
-
-  if (Config->EMachine == EM_ARM && !Config->Relocatable) {
-    // The ARMExidxsyntheticsection replaces all the individual .ARM.exidx
-    // InputSections.
-    In.ARMExidx = make<ARMExidxSyntheticSection>();
-    Add(In.ARMExidx);
-  }
 }
 
 // The main function of the writer.
 template <class ELFT> void Writer<ELFT>::run() {
+  // Make copies of any input sections that need to be copied into each
+  // partition.
+  copySectionsIntoPartitions<ELFT>();
+
   // Create linker-synthesized sections such as .got or .plt.
   // Such sections are of type input section.
   createSyntheticSections<ELFT>();
 
   // Some input sections that are used for exception handling need to be moved
   // into synthetic sections. Do that now so that they aren't assigned to
   // output sections in the usual way.
   if (!Config->Relocatable)
template <class ELFT> void Writer<ELFT>::run() {
   Script->assignAddresses();
 
   // If -compressed-debug-sections is specified, we need to compress
   // .debug_* sections. Do it right now because it changes the size of
   // output sections.
   for (OutputSection *Sec : OutputSections)
     Sec->maybeCompress<ELFT>();
 
-  Script->allocateHeaders(Phdrs);
+  Script->allocateHeaders(Main->Phdrs);
 
   // Remove empty PT_LOAD to avoid causing the dynamic linker to try to mmap a
   // 0 sized region. This has to be done late since only after assignAddresses
   // we know the size of the sections.
-  removeEmptyPTLoad();
+  for (Partition &Part : Partitions)
+    removeEmptyPTLoad(Part.Phdrs);
 
   if (!Config->OFormatBinary)
     assignFileOffsets();
   else
     assignFileOffsetsBinary();
 
-  setPhdrs();
+  for (Partition &Part : Partitions)
+    setPhdrs(Part);
 
   if (Config->Relocatable)
     for (OutputSection *Sec : OutputSections)
       Sec->Addr = 0;
 
   if (Config->CheckSections)
     checkSections();
 
static bool isRelroSection(const OutputSection *Sec) {
   // However, if "-z now" is given, the lazy symbol resolution is
   // disabled, which enables us to put it into RELRO.
   if (Sec == In.GotPlt->getParent())
     return Config->ZNow;
 
   // .dynamic section contains data for the dynamic linker, and
   // there's no need to write to it at runtime, so it's better to put
   // it into RELRO.
-  if (Sec == In.Dynamic->getParent())
+  if (Sec->Name == ".dynamic")
     return true;
 
   // Sections with some special names are put into RELRO. This is a
   // bit unfortunate because section names shouldn't be significant in
   // ELF in spirit. But in reality many linker features depend on
   // magic section names.
   StringRef S = Sec->Name;
   return S == ".data.rel.ro" || S == ".bss.rel.ro" || S == ".ctors" ||
          S == ".dtors" || S == ".jcr" || S == ".eh_frame" ||
          S == ".openbsd.randomdata";
 }
 
 // We compute a rank for each section. The rank indicates where the
 // section should be placed in the file.  Instead of using simple
 // numbers (0,1,2...), we use a series of flags. One for each decision
 // point when placing the section.
 // Using flags has two key properties:
 // * It is easy to check if a give branch was taken.
 // * It is easy two see how similar two ranks are (see getRankProximity).
 enum RankFlags {
-  RF_NOT_ADDR_SET = 1 << 25,
-  RF_NOT_ALLOC = 1 << 24,
-  RF_PARTITION = 1 << 16, // Partition number (8 bits)
+  RF_NOT_ADDR_SET = 1 << 27,
+  RF_NOT_ALLOC = 1 << 26,
+  RF_PARTITION = 1 << 18, // Partition number (8 bits)
+  RF_NOT_PART_EHDR = 1 << 17,
+  RF_NOT_PART_PHDR = 1 << 16,
   RF_NOT_INTERP = 1 << 15,
   RF_NOT_NOTE = 1 << 14,
   RF_WRITE = 1 << 13,
   RF_EXEC_WRITE = 1 << 12,
   RF_EXEC = 1 << 11,
   RF_RODATA = 1 << 10,
   RF_NOT_RELRO = 1 << 9,
   RF_NOT_TLS = 1 << 8,
if (Config->SectionStartMap.count(Sec->Name))
     return Rank;
   Rank |= RF_NOT_ADDR_SET;
 
   // Allocatable sections go first to reduce the total PT_LOAD size and
   // so debug info doesn't change addresses in actual code.
   if (!(Sec->Flags & SHF_ALLOC))
     return Rank | RF_NOT_ALLOC;
 
+  if (Sec->Type == SHT_LLVM_PART_EHDR)
+    return Rank;
+  Rank |= RF_NOT_PART_EHDR;
+
+  if (Sec->Type == SHT_LLVM_PART_PHDR)
+    return Rank;
+  Rank |= RF_NOT_PART_PHDR;
+
   // Put .interp first because some loaders want to see that section
   // on the first page of the executable file when loaded into memory.
   if (Sec->Name == ".interp")
     return Rank;
   Rank |= RF_NOT_INTERP;
 
   // Put .note sections (which make up one PT_NOTE) at the beginning so that
   // they are likely to be included in a core file even if core file size is
void Writer<ELFT>::forEachRelSec(
   // Scan all relocations. Each relocation goes through a series
   // of tests to determine if it needs special treatment, such as
   // creating GOT, PLT, copy relocations, etc.
   // Note that relocations for non-alloc sections are directly
   // processed by InputSection::relocateNonAlloc.
   for (InputSectionBase *IS : InputSections)
     if (IS->isLive() && isa<InputSection>(IS) && (IS->Flags & SHF_ALLOC))
       Fn(*IS);
-  for (EhInputSection *ES : In.EhFrame->Sections)
+  for (Partition &Part : Partitions) {
+    for (EhInputSection *ES : Part.EhFrame->Sections)
       Fn(*ES);
-  if (In.ARMExidx && In.ARMExidx->isLive())
-    for (InputSection *Ex : In.ARMExidx->ExidxSections)
+    if (Part.ARMExidx && Part.ARMExidx->isLive())
+      for (InputSection *Ex : Part.ARMExidx->ExidxSections)
         Fn(*Ex);
   }
+}
 
 // This function generates assignments for predefined symbols (e.g. _end or
 // _etext) and inserts them into the commands sequence to be processed at the
 // appropriate time. This ensures that the value is going to be correct by the
 // time any references to these symbols are processed and is equivalent to
 // defining these symbols explicitly in the linker script.
 template <class ELFT> void Writer<ELFT>::setReservedSymbolSections() {
   if (ElfSym::GlobalOffsetTable) {
if (ElfSym::RelaIpltStart && In.RelaIplt->isNeeded()) {
     ElfSym::RelaIpltStart->Section = In.RelaIplt;
     ElfSym::RelaIpltEnd->Section = In.RelaIplt;
     ElfSym::RelaIpltEnd->Value = In.RelaIplt->getSize();
   }
 
   PhdrEntry *Last = nullptr;
   PhdrEntry *LastRO = nullptr;
 
-  for (PhdrEntry *P : Phdrs) {
+  for (Partition &Part : Partitions) {
+    for (PhdrEntry *P : Part.Phdrs) {
       if (P->p_type != PT_LOAD)
         continue;
       Last = P;
       if (!(P->p_flags & PF_W))
         LastRO = P;
     }
+  }
 
   if (LastRO) {
     // _etext is the first location after the last read-only loadable segment.
     if (ElfSym::Etext1)
       ElfSym::Etext1->Section = LastRO->LastSec;
     if (ElfSym::Etext2)
       ElfSym::Etext2->Section = LastRO->LastSec;
   }
if (Config->FixCortexA53Errata843419) {
       if (Changed)
         Script->assignAddresses();
       Changed |= A64P.createFixes();
     }
 
     if (In.MipsGot)
       In.MipsGot->updateAllocSize();
 
-    Changed |= In.RelaDyn->updateAllocSize();
-
-    if (In.RelrDyn)
-      Changed |= In.RelrDyn->updateAllocSize();
+    for (Partition &Part : Partitions) {
+      Changed |= Part.RelaDyn->updateAllocSize();
+      if (Part.RelrDyn)
+        Changed |= Part.RelrDyn->updateAllocSize();
+    }
 
     if (!Changed)
       return;
   }
 }
 
 static void finalizeSynthetic(SyntheticSection *Sec) {
   if (Sec && Sec->isNeeded() && Sec->getParent())
for (BaseCommand *Base : Script->SectionCommands)
       if (auto *Sec = dyn_cast<OutputSection>(Base))
         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 (In.Dynamic->Parent)
+  if (Main->Dynamic->Parent)
     Symtab->addSymbol(Defined{/*File=*/nullptr, "_DYNAMIC", STB_WEAK,
                               STV_HIDDEN, STT_NOTYPE,
-                              /*Value=*/0, /*Size=*/0, In.Dynamic});
+                              /*Value=*/0, /*Size=*/0, Main->Dynamic});
 
   // Define __rel[a]_iplt_{start,end} symbols if needed.
   addRelIpltSymbols();
 
   // RISC-V's gp can address +/- 2 KiB, set it to .sdata + 0x800 if not defined.
   if (Config->EMachine == EM_RISCV)
     if (!dyn_cast_or_null<Defined>(Symtab->find("__global_pointer$")))
       addOptionalRegular("__global_pointer$", findSection(".sdata"), 0x800);
 
   // This responsible for splitting up .eh_frame section into
   // pieces. The relocation scan uses those pieces, so this has to be
   // earlier.
-  finalizeSynthetic(In.EhFrame);
+  for (Partition &Part : Partitions)
+    finalizeSynthetic(Part.EhFrame);
 
   for (Symbol *S : Symtab->getSymbols())
     if (!S->IsPreemptible)
       S->IsPreemptible = computeIsPreemptible(*S);
 
   // Scan relocations. This must be done after every symbol is declared so that
   // we can correctly decide if a dynamic relocation is needed.
   if (!Config->Relocatable)
template <class ELFT> void Writer<ELFT>::finalizeSections() {
   // synthesized ones. Visit all symbols to give the finishing touches.
   for (Symbol *Sym : Symtab->getSymbols()) {
     if (!includeInSymtab(*Sym))
       continue;
     if (In.SymTab)
       In.SymTab->addSymbol(Sym);
 
     if (Sym->includeInDynsym()) {
-      In.DynSymTab->addSymbol(Sym);
+      Partitions[Sym->Partition - 1].DynSymTab->addSymbol(Sym);
       if (auto *File = dyn_cast_or_null<SharedFile>(Sym->File))
         if (File->IsNeeded && !Sym->isUndefined())
           addVerneed(Sym);
     }
   }
 
+  // We also need to scan the dynamic relocation tables of the other partitions
+  // and add any referenced symbols to the partition's dynsym.
+  for (Partition &Part : MutableArrayRef<Partition>(Partitions).slice(1)) {
+    DenseSet<Symbol *> Syms;
+    for (const SymbolTableEntry &E : Part.DynSymTab->getSymbols())
+      Syms.insert(E.Sym);
+    for (DynamicReloc &Reloc : Part.RelaDyn->Relocs)
+      if (Reloc.Sym && !Reloc.UseSymVA && Syms.insert(Reloc.Sym).second)
+        Part.DynSymTab->addSymbol(Reloc.Sym);
+  }
+
   // Do not proceed if there was an undefined symbol.
   if (errorCount())
     return;
 
   if (In.MipsGot)
     In.MipsGot->build();
 
   removeUnusedSyntheticSections();
for (size_t I = 0, E = OutputSections.size(); I != E; ++I) {
     Sec->SectionIndex = I + 1;
     Sec->ShName = In.ShStrTab->addString(Sec->Name);
   }
 
   // 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();
+    for (Partition &Part : Partitions) {
+      Part.Phdrs = Script->hasPhdrsCommands() ? Script->createPhdrs()
+                                              : createPhdrs(Part);
       if (Config->EMachine == EM_ARM) {
         // PT_ARM_EXIDX is the ARM EHABI equivalent of PT_GNU_EH_FRAME
-      addPhdrForSection(Phdrs, SHT_ARM_EXIDX, PT_ARM_EXIDX, PF_R);
+        addPhdrForSection(Part, SHT_ARM_EXIDX, PT_ARM_EXIDX, PF_R);
       }
       if (Config->EMachine == EM_MIPS) {
         // Add separate segments for MIPS-specific sections.
-      addPhdrForSection(Phdrs, SHT_MIPS_REGINFO, PT_MIPS_REGINFO, PF_R);
-      addPhdrForSection(Phdrs, SHT_MIPS_OPTIONS, PT_MIPS_OPTIONS, PF_R);
-      addPhdrForSection(Phdrs, SHT_MIPS_ABIFLAGS, PT_MIPS_ABIFLAGS, PF_R);
+        addPhdrForSection(Part, SHT_MIPS_REGINFO, PT_MIPS_REGINFO, PF_R);
+        addPhdrForSection(Part, SHT_MIPS_OPTIONS, PT_MIPS_OPTIONS, PF_R);
+        addPhdrForSection(Part, SHT_MIPS_ABIFLAGS, PT_MIPS_ABIFLAGS, PF_R);
+      }
     }
-    Out::ProgramHeaders->Size = sizeof(Elf_Phdr) * Phdrs.size();
+    Out::ProgramHeaders->Size = sizeof(Elf_Phdr) * Main->Phdrs.size();
 
     // Find the TLS segment. This happens before the section layout loop so that
-    // Android relocation packing can look up TLS symbol addresses.
-    for (PhdrEntry *P : Phdrs)
+    // Android relocation packing can look up TLS symbol addresses. We only need
+    // to care about the main partition here because all TLS symbols were moved
+    // to the main partition (see MarkLive.cpp).
+    for (PhdrEntry *P : Main->Phdrs)
       if (P->p_type == PT_TLS)
         Out::TlsPhdr = P;
   }
 
   // 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
-  // symbol table section (DynSymTab) must be the first one.
-  finalizeSynthetic(In.DynSymTab);
-  finalizeSynthetic(In.ARMExidx);
   finalizeSynthetic(In.Bss);
   finalizeSynthetic(In.BssRelRo);
-  finalizeSynthetic(In.GnuHashTab);
-  finalizeSynthetic(In.HashTab);
   finalizeSynthetic(In.SymTabShndx);
   finalizeSynthetic(In.ShStrTab);
   finalizeSynthetic(In.StrTab);
-  finalizeSynthetic(In.VerDef);
   finalizeSynthetic(In.Got);
   finalizeSynthetic(In.MipsGot);
   finalizeSynthetic(In.IgotPlt);
   finalizeSynthetic(In.GotPlt);
-  finalizeSynthetic(In.RelaDyn);
-  finalizeSynthetic(In.RelrDyn);
   finalizeSynthetic(In.RelaIplt);
   finalizeSynthetic(In.RelaPlt);
   finalizeSynthetic(In.Plt);
   finalizeSynthetic(In.Iplt);
-  finalizeSynthetic(In.EhFrameHdr);
-  finalizeSynthetic(In.VerSym);
-  finalizeSynthetic(In.VerNeed);
-  finalizeSynthetic(In.Dynamic);
+  finalizeSynthetic(In.PartIndex);
+
+  // Dynamic section must be the last one in this list and dynamic
+  // symbol table section (DynSymTab) must be the first one.
+  for (Partition &Part : Partitions) {
+    finalizeSynthetic(Part.ARMExidx);
+    finalizeSynthetic(Part.DynSymTab);
+    finalizeSynthetic(Part.GnuHashTab);
+    finalizeSynthetic(Part.HashTab);
+    finalizeSynthetic(Part.VerDef);
+    finalizeSynthetic(Part.RelaDyn);
+    finalizeSynthetic(Part.RelrDyn);
+    finalizeSynthetic(Part.EhFrameHdr);
+    finalizeSynthetic(Part.VerSym);
+    finalizeSynthetic(Part.VerNeed);
+    finalizeSynthetic(Part.Dynamic);
+  }
 
   if (!Script->HasSectionsCommand && !Config->Relocatable)
     fixSectionAlignments();
 
   // SHFLinkOrder processing must be processed after relative section placements are
   // known but before addresses are allocated.
   resolveShfLinkOrder();
 
if (Config->ExecuteOnly && (Flags & PF_X))
     return Flags & ~PF_R;
   if (Config->SingleRoRx && !(Flags & PF_W))
     return Flags | PF_X;
   return Flags;
 }
 
 // Decide which program headers to create and which sections to include in each
 // one.
-template <class ELFT> std::vector<PhdrEntry *> Writer<ELFT>::createPhdrs() {
+template <class ELFT>
+std::vector<PhdrEntry *> Writer<ELFT>::createPhdrs(Partition &Part) {
   std::vector<PhdrEntry *> Ret;
   auto AddHdr = [&](unsigned Type, unsigned Flags) -> PhdrEntry * {
     Ret.push_back(make<PhdrEntry>(Type, Flags));
     return Ret.back();
   };
 
+  unsigned PartNo = Part.getNumber();
+  bool IsMain = PartNo == 1;
+
   // The first phdr entry is PT_PHDR which describes the program header itself.
+  if (IsMain)
     AddHdr(PT_PHDR, PF_R)->add(Out::ProgramHeaders);
+  else
+    AddHdr(PT_PHDR, PF_R)->add(Part.ProgramHeaders->getParent());
 
   // PT_INTERP must be the second entry if exists.
-  if (OutputSection *Cmd = findSection(".interp"))
+  if (OutputSection *Cmd = findSection(".interp", PartNo))
     AddHdr(PT_INTERP, Cmd->getPhdrFlags())->add(Cmd);
 
   // Add the first PT_LOAD segment for regular output sections.
   uint64_t Flags = computeFlags(PF_R);
-  PhdrEntry *Load = AddHdr(PT_LOAD, Flags);
+  PhdrEntry *Load = nullptr;
 
   // Add the headers. We will remove them if they don't fit.
+  // In the other partitions the headers are ordinary sections, so they don't
+  // need to be added here.
+  if (IsMain) {
+    Load = AddHdr(PT_LOAD, Flags);
     Load->add(Out::ElfHeader);
     Load->add(Out::ProgramHeaders);
+  }
 
   // PT_GNU_RELRO includes all sections that should be marked as
   // read-only by dynamic linker after proccessing relocations.
   // Current dynamic loaders only support one PT_GNU_RELRO PHDR, give
   // an error message if more than one PT_GNU_RELRO PHDR is required.
   PhdrEntry *RelRo = make<PhdrEntry>(PT_GNU_RELRO, PF_R);
   bool InRelroPhdr = false;
   OutputSection *RelroEnd = nullptr;
   for (OutputSection *Sec : OutputSections) {
-    if (!needsPtLoad(Sec))
+    if (Sec->Partition != PartNo || !needsPtLoad(Sec))
       continue;
     if (isRelroSection(Sec)) {
       InRelroPhdr = true;
       if (!RelroEnd)
         RelRo->add(Sec);
       else
         error("section: " + Sec->Name + " is not contiguous with other relro" +
               " sections");
     } else if (InRelroPhdr) {
       InRelroPhdr = false;
       RelroEnd = Sec;
     }
   }
 
   for (OutputSection *Sec : OutputSections) {
     if (!(Sec->Flags & SHF_ALLOC))
       break;
     if (!needsPtLoad(Sec))
       continue;
 
+    // Normally, sections in partitions other than the current partition are
+    // ignored. But partition number 255 is a special case: it contains the
+    // partition end marker (.part.end). It needs to be added to the main
+    // partition so that a segment is created for it in the main partition,
+    // which will cause the dynamic loader to reserve space for the other
+    // partitions.
+    if (Sec->Partition != PartNo) {
+      if (IsMain && Sec->Partition == 255)
+        AddHdr(PT_LOAD, computeFlags(Sec->getPhdrFlags()))->add(Sec);
+      continue;
+    }
+
     // Segments are contiguous memory regions that has the same attributes
     // (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 or memory
     // region using AT or AT> linker script command, respectively. 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 or AT> attribute.
     uint64_t NewFlags = computeFlags(Sec->getPhdrFlags());
-    if (((Sec->LMAExpr ||
+    if (!Load ||
+        ((Sec->LMAExpr ||
           (Sec->LMARegion && (Sec->LMARegion != Load->FirstSec->LMARegion))) &&
          Load->LastSec != Out::ProgramHeaders) ||
         Sec->MemRegion != Load->FirstSec->MemRegion || Flags != NewFlags ||
         Sec == RelroEnd) {
       Load = AddHdr(PT_LOAD, NewFlags);
       Flags = NewFlags;
     }
 
     Load->add(Sec);
   }
 
   // Add a TLS segment if any.
   PhdrEntry *TlsHdr = make<PhdrEntry>(PT_TLS, PF_R);
   for (OutputSection *Sec : OutputSections)
-    if (Sec->Flags & SHF_TLS)
+    if (Sec->Partition == PartNo && Sec->Flags & SHF_TLS)
       TlsHdr->add(Sec);
   if (TlsHdr->FirstSec)
     Ret.push_back(TlsHdr);
 
   // Add an entry for .dynamic.
-  if (OutputSection *Sec = In.Dynamic->getParent())
+  if (OutputSection *Sec = Part.Dynamic->getParent())
     AddHdr(PT_DYNAMIC, Sec->getPhdrFlags())->add(Sec);
 
   if (RelRo->FirstSec)
     Ret.push_back(RelRo);
 
   // PT_GNU_EH_FRAME is a special section pointing on .eh_frame_hdr.
-  if (In.EhFrame->isNeeded() && In.EhFrameHdr && In.EhFrame->getParent() &&
-      In.EhFrameHdr->getParent())
-    AddHdr(PT_GNU_EH_FRAME, In.EhFrameHdr->getParent()->getPhdrFlags())
-        ->add(In.EhFrameHdr->getParent());
+  if (Part.EhFrame->isNeeded() && Part.EhFrameHdr &&
+      Part.EhFrame->getParent() && Part.EhFrameHdr->getParent())
+    AddHdr(PT_GNU_EH_FRAME, Part.EhFrameHdr->getParent()->getPhdrFlags())
+        ->add(Part.EhFrameHdr->getParent());
 
   // PT_OPENBSD_RANDOMIZE is an OpenBSD-specific feature. That makes
   // the dynamic linker fill the segment with random data.
-  if (OutputSection *Cmd = findSection(".openbsd.randomdata"))
+  if (OutputSection *Cmd = findSection(".openbsd.randomdata", PartNo))
     AddHdr(PT_OPENBSD_RANDOMIZE, Cmd->getPhdrFlags())->add(Cmd);
 
   // PT_GNU_STACK is a special section to tell the loader to make the
   // pages for the stack non-executable. If you really want an executable
   // stack, you can pass -z execstack, but that's not recommended for
   // security reasons.
   unsigned Perm = PF_R | PF_W;
   if (Config->ZExecstack)
     Perm |= PF_X;
   AddHdr(PT_GNU_STACK, Perm)->p_memsz = Config->ZStackSize;
 
   // PT_OPENBSD_WXNEEDED is a OpenBSD-specific header to mark the executable
   // is expected to perform W^X violations, such as calling mprotect(2) or
   // mmap(2) with PROT_WRITE | PROT_EXEC, which is prohibited by default on
   // OpenBSD.
   if (Config->ZWxneeded)
     AddHdr(PT_OPENBSD_WXNEEDED, PF_X);
 
   // Create one PT_NOTE per a group of contiguous SHT_NOTE sections with the
   // same alignment.
   PhdrEntry *Note = nullptr;
   for (OutputSection *Sec : OutputSections) {
+    if (Sec->Partition != PartNo)
+      continue;
     if (Sec->Type == SHT_NOTE && (Sec->Flags & SHF_ALLOC)) {
       if (!Note || Sec->LMAExpr || Note->LastSec->Alignment != Sec->Alignment)
         Note = AddHdr(PT_NOTE, PF_R);
       Note->add(Sec);
     } else {
       Note = nullptr;
     }
   }
   return Ret;
 }
 
 template <class ELFT>
-void Writer<ELFT>::addPhdrForSection(std::vector<PhdrEntry *> &Phdrs,
-                                     unsigned ShType, unsigned PType,
-                                     unsigned PFlags) {
-  auto I = llvm::find_if(
-      OutputSections, [=](OutputSection *Cmd) { return Cmd->Type == ShType; });
+void Writer<ELFT>::addPhdrForSection(Partition &Part, unsigned ShType,
+                                     unsigned PType, unsigned PFlags) {
+  unsigned PartNo = Part.getNumber();
+  auto I = llvm::find_if(OutputSections, [=](OutputSection *Cmd) {
+    return Cmd->Partition == PartNo && Cmd->Type == ShType;
+  });
   if (I == OutputSections.end())
     return;
 
   PhdrEntry *Entry = make<PhdrEntry>(PType, PFlags);
   Entry->add(*I);
-  Phdrs.push_back(Entry);
+  Part.Phdrs.push_back(Entry);
 }
 
 // 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 = [=] {
         return alignTo(Script->getDot(), Config->MaxPageSize);
       };
   };
 
-  for (const PhdrEntry *P : Phdrs)
+  for (Partition &Part : Partitions) {
+    for (const PhdrEntry *P : Part.Phdrs)
       if (P->p_type == PT_LOAD && P->FirstSec)
         PageAlign(P->FirstSec);
 
-  for (const PhdrEntry *P : Phdrs) {
+    for (const PhdrEntry *P : Part.Phdrs) {
       if (P->p_type != PT_GNU_RELRO)
         continue;
 
       if (P->FirstSec)
         PageAlign(P->FirstSec);
 
       // Find the first section after PT_GNU_RELRO. If it is in a PT_LOAD we
       // have to align it to a page.
       auto End = OutputSections.end();
       auto I = llvm::find(OutputSections, P->LastSec);
       if (I == End || (I + 1) == End)
         continue;
 
       OutputSection *Cmd = (*(I + 1));
       if (needsPtLoad(Cmd))
         PageAlign(Cmd);
     }
   }
+}
 
 // Compute an in-file position for a given section. 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 computeFileOffset(OutputSection *OS, uint64_t Off) {
   // File offsets are not significant for .bss sections. By convention, we keep
   // section offsets monotonically increasing rather than setting to zero.
   if (OS->Type == SHT_NOBITS)

 
 // Assign file offsets to output sections.
 template <class ELFT> void Writer<ELFT>::assignFileOffsets() {
   uint64_t Off = 0;
   Off = setFileOffset(Out::ElfHeader, Off);
   Off = setFileOffset(Out::ProgramHeaders, Off);
 
   PhdrEntry *LastRX = nullptr;
-  for (PhdrEntry *P : Phdrs)
+  for (Partition &Part : Partitions)
+    for (PhdrEntry *P : Part.Phdrs)
       if (P->p_type == PT_LOAD && (P->p_flags & PF_X))
         LastRX = P;
 
   for (OutputSection *Sec : OutputSections) {
     Off = setFileOffset(Sec, Off);
     if (Script->HasSectionsCommand)
       continue;
 
     // If this is a last section of the last executable segment and that
     // segment is the last loadable segment, align the offset of the
if ((Sec->Offset > FileSize) || (Sec->Offset + Sec->Size > FileSize))
       error("unable to place section " + Sec->Name + " at file offset " +
             rangeToString(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() {
-  for (PhdrEntry *P : Phdrs) {
+template <class ELFT> void Writer<ELFT>::setPhdrs(Partition &Part) {
+  for (PhdrEntry *P : Part.Phdrs) {
     OutputSection *First = P->FirstSec;
     OutputSection *Last = P->LastSec;
 
     if (First) {
       P->p_filesz = Last->Offset - First->Offset;
       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;
 
+      // File offsets in partitions other than the main partition are relative
+      // to the offset of the ELF headers. Perform that adjustment now.
+      if (Part.ElfHeader)
+        P->p_offset -= Part.ElfHeader->getParent()->Offset;
+
       if (!P->HasLMA)
         P->p_paddr = First->getLMA();
     }
 
     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;

 static uint16_t getELFType() {
   if (Config->Pic)
     return ET_DYN;
   if (Config->Relocatable)
     return ET_REL;
   return ET_EXEC;
 }
 
-static uint8_t getAbiVersion() {
-  // MIPS non-PIC executable gets ABI version 1.
-  if (Config->EMachine == EM_MIPS) {
-    if (getELFType() == ET_EXEC &&
-        (Config->EFlags & (EF_MIPS_PIC | EF_MIPS_CPIC)) == EF_MIPS_CPIC)
-      return 1;
-    return 0;
-  }
-
-  if (Config->EMachine == EM_AMDGPU) {
-    uint8_t Ver = ObjectFiles[0]->ABIVersion;
-    for (InputFile *File : makeArrayRef(ObjectFiles).slice(1))
-      if (File->ABIVersion != Ver)
-        error("incompatible ABI version: " + toString(File));
-    return Ver;
-  }
-
-  return 0;
-}
-
 template <class ELFT> void Writer<ELFT>::writeHeader() {
-  // For executable segments, the trap instructions are written before writing
-  // the header. Setting Elf header bytes to zero ensures that any unused bytes
-  // in header are zero-cleared, instead of having trap instructions.
-  memset(Out::BufferStart, 0, sizeof(Elf_Ehdr));
-  memcpy(Out::BufferStart, "\177ELF", 4);
+  writeEhdr<ELFT>(Out::BufferStart, *Main);
+  writePhdrs<ELFT>(Out::BufferStart + sizeof(Elf_Ehdr), *Main);
 
-  // Write the ELF header.
   auto *EHdr = reinterpret_cast<Elf_Ehdr *>(Out::BufferStart);
-  EHdr->e_ident[EI_CLASS] = Config->Is64 ? ELFCLASS64 : ELFCLASS32;
-  EHdr->e_ident[EI_DATA] = Config->IsLE ? ELFDATA2LSB : ELFDATA2MSB;
-  EHdr->e_ident[EI_VERSION] = EV_CURRENT;
-  EHdr->e_ident[EI_OSABI] = Config->OSABI;
-  EHdr->e_ident[EI_ABIVERSION] = getAbiVersion();
   EHdr->e_type = getELFType();
-  EHdr->e_machine = Config->EMachine;
-  EHdr->e_version = EV_CURRENT;
   EHdr->e_entry = getEntryAddr();
   EHdr->e_shoff = SectionHeaderOff;
-  EHdr->e_flags = Config->EFlags;
-  EHdr->e_ehsize = sizeof(Elf_Ehdr);
-  EHdr->e_phnum = Phdrs.size();
-  EHdr->e_shentsize = sizeof(Elf_Shdr);
-
-  if (!Config->Relocatable) {
-    EHdr->e_phoff = sizeof(Elf_Ehdr);
-    EHdr->e_phentsize = sizeof(Elf_Phdr);
-  }
-
-  // Write the program header table.
-  auto *HBuf = reinterpret_cast<Elf_Phdr *>(Out::BufferStart + EHdr->e_phoff);
-  for (PhdrEntry *P : Phdrs) {
-    HBuf->p_type = P->p_type;
-    HBuf->p_flags = P->p_flags;
-    HBuf->p_offset = P->p_offset;
-    HBuf->p_vaddr = P->p_vaddr;
-    HBuf->p_paddr = P->p_paddr;
-    HBuf->p_filesz = P->p_filesz;
-    HBuf->p_memsz = P->p_memsz;
-    HBuf->p_align = P->p_align;
-    ++HBuf;
-  }
 
   // Write the section header table.
   //
   // The ELF header can only store numbers up to SHN_LORESERVE in the e_shnum
   // and e_shstrndx fields. When the value of one of these fields exceeds
   // SHN_LORESERVE ELF requires us to put sentinel values in the ELF header and
   // use fields in the section header at index 0 to store
   // the value. The sentinel values and fields are:

 // standard, it is in general a good thing to do for security reasons.
 //
 // We'll leave other pages in segments as-is because the rest will be
 // overwritten by output sections.
 template <class ELFT> void Writer<ELFT>::writeTrapInstr() {
   if (Script->HasSectionsCommand)
     return;
 
+  for (Partition &Part : Partitions) {
     // Fill the last page.
-  for (PhdrEntry *P : Phdrs)
+    for (PhdrEntry *P : Part.Phdrs)
       if (P->p_type == PT_LOAD && (P->p_flags & PF_X))
         fillTrap(Out::BufferStart + alignDown(P->p_offset + P->p_filesz,
                                               Config->CommonPageSize),
-               Out::BufferStart +
-                   alignTo(P->p_offset + P->p_filesz, Config->CommonPageSize));
+                 Out::BufferStart + alignTo(P->p_offset + P->p_filesz,
+                                            Config->CommonPageSize));
 
     // Round up the file size of the last segment to the page boundary iff it is
     // an executable segment to ensure that other tools don't accidentally
     // trim the instruction padding (e.g. when stripping the file).
     PhdrEntry *Last = nullptr;
-  for (PhdrEntry *P : Phdrs)
+    for (PhdrEntry *P : Part.Phdrs)
       if (P->p_type == PT_LOAD)
         Last = P;
 
     if (Last && (Last->p_flags & PF_X))
       Last->p_memsz = Last->p_filesz =
           alignTo(Last->p_filesz, Config->CommonPageSize);
   }
+}
 
 // Write section contents to a mmap'ed file.
 template <class ELFT> void Writer<ELFT>::writeSections() {
   // In -r or -emit-relocs mode, write the relocation sections first as in
   // ELf_Rel targets we might find out that we need to modify the relocated
   // section while doing it.
   for (OutputSection *Sec : OutputSections)
     if (Sec->Type == SHT_REL || Sec->Type == SHT_RELA)
parallelForEachN(0, Chunks.size(), [&](size_t I) {
     HashFn(Hashes.data() + I * HashBuf.size(), Chunks[I]);
   });
 
   // Write to the final output buffer.
   HashFn(HashBuf.data(), Hashes);
 }
 
 template <class ELFT> void Writer<ELFT>::writeBuildId() {
-  if (!In.BuildId || !In.BuildId->getParent())
+  if (!Main->BuildId || !Main->BuildId->getParent())
     return;
 
   if (Config->BuildId == BuildIdKind::Hexstring) {
-    In.BuildId->writeBuildId(Config->BuildIdVector);
+    for (Partition &Part : Partitions)
+      Part.BuildId->writeBuildId(Config->BuildIdVector);
     return;
   }
 
   // Compute a hash of all sections of the output file.
-  std::vector<uint8_t> BuildId(In.BuildId->HashSize);
+  size_t HashSize = Main->BuildId->HashSize;
+  std::vector<uint8_t> BuildId(HashSize);
   llvm::ArrayRef<uint8_t> Buf{Out::BufferStart, size_t(FileSize)};
 
   switch (Config->BuildId) {
   case BuildIdKind::Fast:
     computeHash(BuildId, Buf, [](uint8_t *Dest, ArrayRef<uint8_t> Arr) {
       write64le(Dest, xxHash64(Arr));
     });
     break;
   case BuildIdKind::Md5:
     computeHash(BuildId, Buf, [&](uint8_t *Dest, ArrayRef<uint8_t> Arr) {
-      memcpy(Dest, MD5::hash(Arr).data(), In.BuildId->HashSize);
+      memcpy(Dest, MD5::hash(Arr).data(), HashSize);
     });
     break;
   case BuildIdKind::Sha1:
     computeHash(BuildId, Buf, [&](uint8_t *Dest, ArrayRef<uint8_t> Arr) {
-      memcpy(Dest, SHA1::hash(Arr).data(), In.BuildId->HashSize);
+      memcpy(Dest, SHA1::hash(Arr).data(), HashSize);
     });
     break;
   case BuildIdKind::Uuid:
-    if (auto EC = llvm::getRandomBytes(BuildId.data(), In.BuildId->HashSize))
+    if (auto EC = llvm::getRandomBytes(BuildId.data(), HashSize))
       error("entropy source failure: " + EC.message());
     break;
   default:
     llvm_unreachable("unknown BuildIdKind");
   }
-  In.BuildId->writeBuildId(BuildId);
+  for (Partition &Part : Partitions)
+    Part.BuildId->writeBuildId(BuildId);
 }
 
 template void elf::writeResult<ELF32LE>();
 template void elf::writeResult<ELF32BE>();
 template void elf::writeResult<ELF64LE>();
 template void elf::writeResult<ELF64BE>();

lld/test/ELF/linkerscript/orphan-report.s

 # REPORT-NEXT: <internal>:(.dynsym) is being placed in '.dynsym'
 # REPORT-NEXT: <internal>:(.gnu.version) is being placed in '.gnu.version'
 # REPORT-NEXT: <internal>:(.gnu.version_r) is being placed in '.gnu.version_r'
 # REPORT-NEXT: <internal>:(.gnu.hash) is being placed in '.gnu.hash'
 # REPORT-NEXT: <internal>:(.hash) is being placed in '.hash'
 # REPORT-NEXT: <internal>:(.dynamic) is being placed in '.dynamic'
 # REPORT-NEXT: <internal>:(.dynstr) is being placed in '.dynstr'
 # REPORT-NEXT: <internal>:(.rela.dyn) is being placed in '.rela.dyn'
+# REPORT-NEXT: <internal>:(.eh_frame) is being placed in '.eh_frame'
 # REPORT-NEXT: <internal>:(.got) is being placed in '.got'
 # REPORT-NEXT: <internal>:(.got.plt) is being placed in '.got.plt'
 # REPORT-NEXT: <internal>:(.got.plt) is being placed in '.got.plt'
 # REPORT-NEXT: <internal>:(.rela.plt) is being placed in '.rela.plt'
 # REPORT-NEXT: <internal>:(.rela.plt) is being placed in '.rela.plt'
 # REPORT-NEXT: <internal>:(.plt) is being placed in '.plt'
 # REPORT-NEXT: <internal>:(.plt) is being placed in '.plt'
-# REPORT-NEXT: <internal>:(.eh_frame) is being placed in '.eh_frame'
 # REPORT-NEXT: <internal>:(.symtab) is being placed in '.symtab'
 # REPORT-NEXT: <internal>:(.symtab_shndx) is being placed in '.symtab_shndx'
 # REPORT-NEXT: <internal>:(.shstrtab) is being placed in '.shstrtab'
 # REPORT-NEXT: <internal>:(.strtab) is being placed in '.strtab'
 
 ## Check --orphan-handling=warn reports warnings about orphans.
 # RUN: ld.lld -shared --orphan-handling=warn -o %t.out --script %t.script \
 # RUN:   %t.o 2>&1 -verbose | FileCheck %s --check-prefix=REPORT

llvm/include/llvm/BinaryFormat/ELF.h

enum : unsigned {
   SHT_ANDROID_RELA = 0x60000002,
   SHT_LLVM_ODRTAB = 0x6fff4c00,         // LLVM ODR table.
   SHT_LLVM_LINKER_OPTIONS = 0x6fff4c01, // LLVM Linker Options.
   SHT_LLVM_CALL_GRAPH_PROFILE = 0x6fff4c02, // LLVM Call Graph Profile.
   SHT_LLVM_ADDRSIG = 0x6fff4c03,        // List of address-significant symbols
                                         // for safe ICF.
   SHT_LLVM_DEPENDENT_LIBRARIES = 0x6fff4c04, // LLVM Dependent Library Specifiers.
   SHT_LLVM_SYMPART = 0x6fff4c05,        // Symbol partition specification.
+  SHT_LLVM_PART_EHDR = 0x6fff4c05,      // ELF header for loadable partition.
+  SHT_LLVM_PART_PHDR = 0x6fff4c06,      // Phdrs for loadable partition.
   // Android's experimental support for SHT_RELR sections.
   // https://android.googlesource.com/platform/bionic/+/b7feec74547f84559a1467aca02708ff61346d2a/libc/include/elf.h#512
   SHT_ANDROID_RELR = 0x6fffff00,        // Relocation entries; only offsets.
   SHT_GNU_ATTRIBUTES = 0x6ffffff5,      // Object attributes.
   SHT_GNU_HASH = 0x6ffffff6,            // GNU-style hash table.
   SHT_GNU_verdef = 0x6ffffffd,          // GNU version definitions.
   SHT_GNU_verneed = 0x6ffffffe,         // GNU version references.
   SHT_GNU_versym = 0x6fffffff,          // GNU symbol versions table.