ELF: Add basic partition data structures and behaviours.

[pcc]

Summary

This change causes us to read partition specifications from partition
specification sections and split output sections into partitions according
to their reachability from partition entry points.

This is only the first step towards a full implementation of partitions. Later
changes will add additional synthetic sections to each partition so that
they can be loaded independently.

Depends on D60242

[grimar]

lld/ELF/Driver.cpp

1386

Seems you can use toStringRef (from llvm\ADT\StringExtras.h)?

1395

Should it be error?

1665

Will it be better to report errors somewhere here, so you could
include the file name to error text?

lld/ELF/SyntheticSections.cpp

3259

Why not std::vector<Partition> Partitions?

lld/ELF/SyntheticSections.h

1065

Perhaps just inline the body?

[pcc]

• Use std::vector

[pcc]

lld/ELF/Driver.cpp

1386

Doesn't look like it, we need to stop at the null terminator here.

1395

With fatal we can avoid needing to worry about what happens in case of overflow. Since I'd expect this error to be uncommon I don't think we need to provide a great experience here.

[pcc]

lld/ELF/Driver.cpp

1665

The file name is accessible in readSymbolPartitionSection via S->File if we wanted to print it there, though I'm not sure if it would be useful since a user hitting this limit would probably want to see the names of all partitions, not just the one that overflowed. I'd probably punt on giving a more useful error message here for now unless/until there's evidence that people are hitting this case frequently.

lld/ELF/SyntheticSections.cpp

3259

Yes, I think that would be better, done. I'm not sure why I originally wrote it this way.

lld/ELF/SyntheticSections.h

1065

We previously couldn't have inlined the body because it depended on the definition of Partitions below (and Partitions depends on the definition of Partition). But now that Partitions is a vector we can inline it.

[grimar]

lld/ELF/Driver.cpp

1386

Ah, right.

1395

Ok, but now after Partitions became a vector, I guess you can just remove this 254 limitation?

1665

I meant you could report here errors from below like

"filename1: partitions cannot be used with the SECTIONS command"
"filename2: partitions cannot be used with the PHDRS command"

i.e.:

llvm::erase_if(InputSections, [](InputSectionBase *S) {
  if (S->Type == SHT_LLVM_SYMPART) {
    <report such errors here>

    readSymbolPartitionSection<ELFT>(S);
    return true;
   }

So that you'd be able to report the file names of the objects which have the SHT_LLVM_SYMPART sections.
Does it make sense?

[pcc]

• Adjust error message format

lld/ELF/Driver.cpp

1395

The Partition fields in Symbol and InputSectionBase are 8 bits wide, so we can't remove the limitation without making the fields wider. I'm not sure if we should do that because I don't think we should devote too much space in these common data structures to this feature without a good reason (e.g. users need >254 partitions).

1665

Makes sense now, but that means that we'd get the error even for files with SHT_LLVM_SYMPART sections that end up being ignored due to not being in dynsym. It would probably be better to print these errors in readSymbolPartitionSection once we know that we're going to create a partition.

[grimar]

I have no more comments/questions, thanks! (last suggestion/question is inlined)

lld/ELF/Driver.cpp

1395

Ok, thanks for the explanation! Perhaps it worst to add this information to the documentation in D60242 then? It wasn't obvious for me where this limitation technically comes from.

[MaskRay]

lld/ELF/InputSection.h

78

unsigned : 1;

lld/ELF/Writer.cpp

763

The comment 8 bits may be elaborated a bit.

lld/test/ELF/partitions.s

5

-symbols -> -dyn-syms?

e.g. llvm-readelf -S -dyn-syms %t

33

Indent instructions?

[MaskRay]

lld/ELF/InputSection.cpp

1094

This probably needs a comment.

lld/ELF/MarkLive.cpp

202–205

minimum -> meet?

[pcc]

• Rebase
• Address review comments

[pcc]

lld/ELF/Driver.cpp

1395

I added a note to the documentation as well as a comment here.

lld/ELF/InputSection.cpp

1094

Done. Also realised that I don't have a test for this code, so I added one.

lld/ELF/MarkLive.cpp

202–205

Hmm, that's the correct set theoretical term, but "minimum" seems more intuitive to me. I decided to reword it as meet (i.e. the "minimum")

lld/test/ELF/partitions.s

5

That would not be sufficient to test the property that we're interested in here because f[3-6] are not exported.

33

I don't think we have a consistent style for whether or not to indent, so I left things as is.

[MaskRay]

lld/test/ELF/partitions.s

5

Then use either llvm-readobj or llvm-readelf, but not -elf-output-style=GNU.

( llvm-readobj -elf-output-style=GNU has a peculiarity: it supports llvm-readobj specific options but not llvm-readelf options. In any case, I've done something to improve their compatibility.) If you decide to go with llvm-readelf, --long-option will be better than -long-option :)

[pcc]

• Switch to using llvm-readelf

[grimar]

This looks good to me, but I do not think I am a proper person to give a final accept.
Minor nits/suggestions are inline.

lld/ELF/Driver.cpp

101

nit: I am not sure how much Partitions = {{}}; is readable,
so I would replace with Partitions = {Partition()};
Though IMO any of these lines looks probably a bit better than these two lines.

1418

It seems to me this is an overoptimization for such place.

What do you think about the following?

Partition P = {PartName};
Sym->Partition = P.getNumber();

[grimar]

lld/ELF/Driver.cpp

1418

Oops. My version was wrong. But anyways something like:

Partitions.push_back({PartName});
Sym->Partition = Partitions.back().getNumber();

[pcc]

• Use a one-liner to initialize Partitions

[pcc]

lld/ELF/Driver.cpp

101

Partitions = {Partition()}; works for me.

1418

Agreed that optimization isn't a consideration at all here.

I don't think your suggested code will continue to work once we start adding more fields (for synthetic sections etc.) to the Partition data structure, unless we add a constructor that takes a name. See: https://github.com/pcc/llvm-project/blob/d40cc2e48b560445c4c741cc72a8c6bab47fb2eb/lld/ELF/SyntheticSections.h#L1040

I think I'd argue that it is sightly clearer to let the object be default constructed here and then initialize the field by name.

[ruiu]

Do you have another change for adding synthetic sections for partitioning? This change looks pretty straightforward to me, although I'd like to somehow continue using the term "Live" instead of Partition is zero" to explain liveness in code and comments, though.

lld/ELF/Driver.cpp

1378

Could you add a brief comment as to what this Sym is? I think this is a "root" symbol for each partition.

1400

I first thought that we may want to completely ban linker scripts when this feature is in use, but no, we can't do that, because on Linux libc.so is actually a linker script...

lld/ELF/InputSection.h

78

It's not clear to me why you needed a one bit padding here.

[MaskRay]

although I'd like to somehow continue using the term "Live" instead of Partition is zero" to explain liveness in code and comments, though.

I think this is fine... After all all S->Live uses have been changed to S->isLive()

[ruiu]

In D60353#1506522, @MaskRay wrote:

although I'd like to somehow continue using the term "Live" instead of Partition is zero" to explain liveness in code and comments, though.

I think this is fine... After all all S->Live uses have been changed to S->isLive()

Yeah, but killing it is S->Partition = 0 which isn't very intuitive.

[pcc]

• Address review comments
• Rebase

[pcc]

In D60353#1506498, @ruiu wrote:

Do you have another change for adding synthetic sections for partitioning?

Yes, I was going to send it out once it was ready, but I'll try to send it out as soon as I can so you can see what it looks like. In the meantime you could look at https://github.com/pcc/llvm-project/tree/lld-part-symbols which is essentially the same code as I'm going to upstream.

This change looks pretty straightforward to me, although I'd like to somehow continue using the term "Live" instead of Partition is zero" to explain liveness in code and comments, though.

I added a couple of accessors markLive and markDead for the places where we were setting Partition directly before.

lld/ELF/Driver.cpp

1378

Yes, pretty much. I've added a comment saying that this is the entry point symbol. Following the link above will lead to an explanation (once D60242 lands) of what an "entry point symbol" is.

1400

Right.

lld/ELF/InputSection.h

78

I added a comment explaining why.

[MaskRay]

Looks quite good to me. Some nits.

lld/ELF/Driver.cpp

1389

Early continue doesn't seem to help readability here. How about

if (Part.Name == PartName) {
  Sym->Partition = Part.getNumber();
  return;
}

lld/ELF/SyntheticSections.h

42

Is this-> redundant?

[pcc]

lld/ELF/SyntheticSections.h

42

Yes, removed.

[pcc]

• Relax tests so that they continue to pass once a future change lands
• Address review comments

[pcc]

In D60353#1512977, @pcc wrote:

In D60353#1506498, @ruiu wrote:

Do you have another change for adding synthetic sections for partitioning?

Yes, I was going to send it out once it was ready, but I'll try to send it out as soon as I can so you can see what it looks like. In the meantime you could look at https://github.com/pcc/llvm-project/tree/lld-part-symbols which is essentially the same code as I'm going to upstream.

I've now sent out D62350. The only remaining changes that I need to send out are the change to llvm-objcopy for extracting partitions, as well as a change to prevent the linker from sharing range extension thunks between partitions. That should be enough for a usable implementation of partitions.

[MaskRay]

I think the code below perfectly abstracts out the deleted unsigned Live : 1;.

bool isLive() const { return Partition != 0; }
void markLive() { Partition = 1; }
void markDead() { Partition = 0; }

This looks quite good to me, but I am not the proper person to give a final accept.

[MaskRay]

lld/ELF/Driver.cpp

1678

Delete Target = getTarget();

This has been moved just below inferMachineType(). in a previous change.

[MaskRay]

lld/ELF/MarkLive.cpp

360–367

I'm concerned with the performance.

Shall we just do one MarkLive<ELFT>().run(); with all roots and one MarkLive<ELFT>(1).moveToMain();?

Before, we have npart+1 runs of DFS, now we have just 2 DFS.

[MaskRay]

lld/ELF/MarkLive.cpp

360–367

Or 1, if you can merge moveToMain() into run().

[pcc]

• Address review comments

[pcc]

lld/ELF/MarkLive.cpp

360–367

I don't really see how that could lead to better performance, and the current approach is simpler anyway IMHO.

The important thing isn't how many runs of DFS we do but how many nodes we visit. With that approach we'd still be visiting the same number of nodes, just in a different order. In fact, it could lead to worse performance. Say we happen to visit a root for a loadable partition before visiting the roots of the main partition, and the loadable partition uses mostly the same code as the main partition. So we mark most of the main partition's code as belonging to the loadable partition. Now we move on to the main partition's roots. That will cause us to visit most of the main partition's code again to mark it as being in the main partition. With the current approach we would visit the main partition's code once and we don't visit it again while handling the loadable partition because of the code on lines 197-198. We only visit sections twice if code is used by multiple loadable partitions but not by the main partition, which is something that we'd need to do anyway.

[MaskRay]

lld/ELF/MarkLive.cpp

360–367

You can still have if (Sec->Partition == 1 || Sec->Partition == Partition) code in that one single DFS.

The time complexity of one DFS is not just O(|edges of visited sections |), but O(|symbols| + |edges of visited sections|):

for (Symbol *S : Symtab->getSymbols())
  if (S->includeInDynsym() && S->Partition == Partition)
    markSymbol(S);

[ruiu]

LGTM

lld/ELF/InputSection.h

78

Why do you have to use a bitfield? Looks like you can use uint8_t instead.

[pcc]

• Address review comments

lld/ELF/InputSection.h

78

Yeah, that works. For some reason I thought that the series of bitfields would consume sizeof(unsigned) bytes, but that doesn't appear to be the case.

lld/ELF/MarkLive.cpp

360–367

You can still have if (Sec->Partition == 1 || Sec->Partition == Partition) code in that one single DFS.

It wouldn't help with the problem I mentioned. Here's a concrete example:

 A <- root of partition 2
 |
 B <- root of partition 1
/ \
C D

If we visit A first we mark A, B, C, D as partition 2. Then when we visit B we visit B, C, D again to mark them as partition 1. But if we visit B first we mark B, C, D as partition 1 and then when we visit A we only mark A as partition 2 and we don't visit B because we'd take the if (Sec->Partition == 1 || Sec->Partition == Partition) branch for the A -> B edge. So by visiting partitions in order we avoid visiting B, C, D twice by construction.

The time complexity of one DFS is not just O(|edges of visited sections |), but O(|symbols| + |edges of visited sections|)

That could easily be addressed with a single pass over the symbol table that groups symbols by partition. I'd still prefer not to do that though, since it seems like a premature optimization that wouldn't be worth the added complexity.

lld/ELF/Driver.cpp

bool elf::link(ArrayRef<const char *> Args, bool CanExitEarly,
   Config = make<Configuration>();
   Driver = make<LinkerDriver>();
   Script = make<LinkerScript>();
   Symtab = make<SymbolTable>();
 
   Tar = nullptr;
   memset(&In, 0, sizeof(In));
 
+  Partitions = {Partition()};
+
   SharedFile::VernauxNum = 0;
 
   Config->ProgName = Args[0];
 
   Driver->main(Args);
 
   // Exit immediately if we don't need to return to the caller.
   // This saves time because the overhead of calling destructors
if (Obj->AddrsigSec) {
       // If an object file does not have an address-significance table,
       // conservatively mark all of its symbols as address-significant.
       for (Symbol *S : Syms)
         markAddrsig(S);
     }
   }
 }
 
+// This function reads a symbol partition specification section. These sections
+// are used to control which partition a symbol is allocated to. See
+// https://lld.llvm.org/Partitions.html for more details on partitions.
+template <typename ELFT>
+static void readSymbolPartitionSection(InputSectionBase *S) {
+  Symbol *Sym;
+  if (S->AreRelocsRela)
+    Sym = &S->getFile<ELFT>()->getRelocTargetSym(S->template relas<ELFT>()[0]);
+  else
+    Sym = &S->getFile<ELFT>()->getRelocTargetSym(S->template rels<ELFT>()[0]);
+  if (!isa<Defined>(Sym) || !Sym->includeInDynsym())
+    return;
+
+  StringRef PartName = reinterpret_cast<const char *>(S->data().data());
+  for (Partition &Part : Partitions) {
+    if (Part.Name != PartName)
+      continue;
+    Sym->Partition = Part.getNumber();
+    return;
+  }
+
+  // Forbid partitions from being used on incompatible targets, and forbid them
+  // from being used together with various linker features that assume a single
+  // set of output sections.
+  if (Script->HasSectionsCommand)
+    error(toString(S->File) +
+          ": partitions cannot be used with the SECTIONS command");
+  if (Script->hasPhdrsCommands())
+    error(toString(S->File) +
+          ": partitions cannot be used with the PHDRS command");
+  if (!Config->SectionStartMap.empty())
+    error(toString(S->File) + ": partitions cannot be used with "
+                              "--section-start, -Ttext, -Tdata or -Tbss");
+  if (Config->EMachine == EM_MIPS)
+    error(toString(S->File) + ": partitions cannot be used on this target");
+
+  // Impose a limit of no more than 254 partitions. This limit comes from the
+  // sizes of the Partition fields in InputSectionBase and Symbol, as well as
+  // the amount of space devoted to the partition number in RankFlags.
+  if (Partitions.size() == 254)
+    fatal("may not have more than 254 partitions");
+
+  Partitions.emplace_back();
+  Partition &NewPart = Partitions.back();
+  NewPart.Name = PartName;
+  Sym->Partition = NewPart.getNumber();
+}
+
 template <class ELFT> static Symbol *addUndefined(StringRef Name) {
   return Symtab->addUndefined<ELFT>(Name, STB_GLOBAL, STV_DEFAULT, 0, false,
                                     nullptr);
 }
 
 // The --wrap option is a feature to rename symbols so that you can write
 // wrappers for existing functions. If you pass `-wrap=foo`, all
 // occurrences of symbol `foo` are resolved to `wrap_foo` (so, you are
template <class ELFT> void LinkerDriver::link(opt::InputArgList &Args) {
   for (InputFile *F : ObjectFiles)
     for (InputSectionBase *S : F->getSections())
       if (S && S != &InputSection::Discarded)
         InputSections.push_back(S);
   for (BinaryFile *F : BinaryFiles)
     for (InputSectionBase *S : F->getSections())
       InputSections.push_back(cast<InputSection>(S));
 
+  llvm::erase_if(InputSections, [](InputSectionBase *S) {
+    if (S->Type == SHT_LLVM_SYMPART) {
+      readSymbolPartitionSection<ELFT>(S);
+      return true;
+    }
+
     // We do not want to emit debug sections if --strip-all
     // or -strip-debug are given.
-  if (Config->Strip != StripPolicy::None)
-    llvm::erase_if(InputSections, [](InputSectionBase *S) { return S->Debug; });
+    return Config->Strip != StripPolicy::None && S->Debug;
+  });
 
   // 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();
   Config->MaxPageSize = getMaxPageSize(Args);
   Config->ImageBase = getImageBase(Args);
 
   if (Config->EMachine == EM_ARM) {
     // FIXME: These warnings can be removed when lld only uses these features
     // when the input objects have been compiled with an architecture that

lld/ELF/ICF.cpp

private:
   // faster because it uses results of the same iteration earlier.
   int Current = 0;
   int Next = 0;
 };
 }
 
 // Returns true if section S is subject of ICF.
 static bool isEligible(InputSection *S) {
-  if (!S->Live || S->KeepUnique || !(S->Flags & SHF_ALLOC))
+  if (!S->isLive() || S->KeepUnique || !(S->Flags & SHF_ALLOC))
     return false;
 
   // Don't merge writable sections. .data.rel.ro sections are marked as writable
   // but are semantically read-only.
   if ((S->Flags & SHF_WRITE) && S->Name != ".data.rel.ro" &&
       !S->Name.startswith(".data.rel.ro."))
     return false;
 
forEachClassRange(0, Sections.size(), [&](size_t Begin, size_t End) {
     for (size_t I = Begin + 1; I < End; ++I) {
       print("  removing identical section " + toString(Sections[I]));
       Sections[Begin]->replace(Sections[I]);
 
       // At this point we know sections merged are fully identical and hence
       // we want to remove duplicate implicit dependencies such as link order
       // and relocation sections.
       for (InputSection *IS : Sections[I]->DependentSections)
-        IS->Live = false;
+        IS->Partition = 0;
     }
   });
 }
 
 // ICF entry point function.
 template <class ELFT> void elf::doIcf() { ICF<ELFT>().run(); }
 
 template void elf::doIcf<ELF32LE>();
 template void elf::doIcf<ELF32BE>();
 template void elf::doIcf<ELF64LE>();
 template void elf::doIcf<ELF64BE>();

lld/ELF/InputSection.h

public:
   // Usually Repl == this. However, if ICF merges two sections,
   // Repl pointer of one section points to another section. So,
   // if you need to get a pointer to this instance, do not use
   // this but instead this->Repl.
   SectionBase *Repl;
 
   unsigned SectionKind : 3;
 
-  // The next four bit fields are only used by InputSectionBase, but we
+  // The next three bit fields are only used by InputSectionBase, but we
   // put them here so the struct packs better.
 
-  // The garbage collector sets sections' Live bits.
-  // If GC is disabled, all sections are considered live by default.
-  unsigned Live : 1;
-
   // True if this section has already been placed to a linker script
   // output section. This is needed because, in a linker script, you
   // can refer to the same section more than once. For example, in
   // the following linker script,
   //
   //   .foo : { *(.text) }
   //   .bar : { *(.text) }
   //
   // .foo takes all .text sections, and .bar becomes empty. To achieve
   // this, we need to memorize whether a section has been placed or
   // not for each input section.
   unsigned Assigned : 1;
 
   unsigned Bss : 1;
 
   // True if this is a debuginfo section.
   unsigned Debug : 1;
 
   // Set for sections that should not be folded by ICF.
   unsigned KeepUnique : 1;
 
+  unsigned : 1;
+
+  // 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;
+
   // 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;
 
   OutputSection *getOutputSection();
   const OutputSection *getOutputSection() const {
     return const_cast<SectionBase *>(this)->getOutputSection();
   }
 
   // Translate an offset in the input section to an offset in the output
   // section.
   uint64_t getOffset(uint64_t Offset) const;
 
   uint64_t getVA(uint64_t Offset = 0) const;
 
+  bool isLive() const { return Partition != 0; }
+
 protected:
   SectionBase(Kind SectionKind, StringRef Name, uint64_t Flags,
               uint64_t Entsize, uint64_t Alignment, uint32_t Type,
               uint32_t Info, uint32_t Link)
-      : Name(Name), Repl(this), SectionKind(SectionKind), Live(false),
-        Assigned(false), Bss(false), Debug(false), KeepUnique(false),
+      : Name(Name), Repl(this), SectionKind(SectionKind), Assigned(false),
+        Bss(false), Debug(false), KeepUnique(false), Partition(0),
         Alignment(Alignment), Flags(Flags), Entsize(Entsize), Type(Type),
         Link(Link), Info(Info) {}
 };
 
 // This corresponds to a section of an input file.
 class InputSectionBase : public SectionBase {
 public:
   template <class ELFT>

lld/ELF/InputSection.cpp

if (Sym.Type == STT_SECTION) {
       // relocation in it pointing to discarded sections with R_*_NONE, which
       // hopefully creates a frame that is ignored at runtime.
       auto *D = dyn_cast<Defined>(&Sym);
       if (!D) {
         error("STT_SECTION symbol should be defined");
         continue;
       }
       SectionBase *Section = D->Section->Repl;
-      if (!Section->Live) {
+      if (!Section->isLive()) {
         P->setSymbolAndType(0, 0, false);
         continue;
       }
 
       int64_t Addend = getAddend<ELFT>(Rel);
       const uint8_t *BufLoc = Sec->data().begin() + Rel.r_offset;
       if (!RelTy::IsRela)
         Addend = Target->getImplicitAddend(BufLoc, Type);
template <class ELFT> void InputSection::writeTo(uint8_t *Buf) {
   // and then apply relocations.
   memcpy(Buf + OutSecOff, data().data(), data().size());
   uint8_t *BufEnd = Buf + OutSecOff + data().size();
   relocate<ELFT>(Buf, BufEnd);
 }
 
 void InputSection::replace(InputSection *Other) {
   Alignment = std::max(Alignment, Other->Alignment);
+
+  // When a section is replaced with another section that was allocated to
+  // another partition, the replacement section (and its associated sections)
+  // need to be placed in the main partition so that both partitions will be
+  // able to access it.
+  if (Partition != Other->Partition) {
+    Partition = 1;
+    for (InputSection *IS : DependentSections)
+      IS->Partition = 1;
+  }
+
   Other->Repl = Repl;
-  Other->Live = false;
+  Other->Partition = 0;
 }
 
 template <class ELFT>
 EhInputSection::EhInputSection(ObjFile<ELFT> &F,
                                const typename ELFT::Shdr &Header,
                                StringRef Name)
     : InputSectionBase(F, Header, Name, InputSectionBase::EHFrame) {}
 

lld/ELF/LinkerScript.cpp

 LinkerScript::computeInputSections(const InputSectionDescription *Cmd) {
   std::vector<InputSection *> Ret;
 
   // Collects all sections that satisfy constraints of Cmd.
   for (const SectionPattern &Pat : Cmd->SectionPatterns) {
     size_t SizeBefore = Ret.size();
 
     for (InputSectionBase *Sec : InputSections) {
-      if (!Sec->Live || Sec->Assigned)
+      if (!Sec->isLive() || Sec->Assigned)
         continue;
 
       // For -emit-relocs we have to ignore entries like
       //   .rela.dyn : { *(.rela.data) }
       // which are common because they are in the default bfd script.
       // We do not ignore SHT_REL[A] linker-synthesized sections here because
       // want to support scripts that do custom layout for them.
       if (auto *IS = dyn_cast<InputSection>(Sec))
for (InputSection *S : V) {
     // 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;
 
     S->Assigned = false;
-    S->Live = false;
+    S->Partition = 0;
     discard(S->DependentSections);
   }
 }
 
 std::vector<InputSection *>
 LinkerScript::createInputSectionList(OutputSection &OutCmd) {
   std::vector<InputSection *> Ret;
 

 
 static OutputSection *createSection(InputSectionBase *IS,
                                     StringRef OutsecName) {
   OutputSection *Sec = Script->createOutputSection(OutsecName, "<internal>");
   Sec->addSection(cast<InputSection>(IS));
   return Sec;
 }
 
-static OutputSection *addInputSec(StringMap<OutputSection *> &Map,
-                                  InputSectionBase *IS, StringRef OutsecName) {
+static OutputSection *
+addInputSec(StringMap<TinyPtrVector<OutputSection *>> &Map,
   // Sections with SHT_GROUP or SHF_GROUP attributes reach here only when the -r
   // option is given. A section with SHT_GROUP defines a "section group", and
   // its members have SHF_GROUP attribute. Usually these flags have already been
   // stripped by InputFiles.cpp as section groups are processed and uniquified.
   // However, for the -r option, we want to pass through all section groups
   // as-is because adding/removing members or merging them with other groups
   // change their semantics.
   if (IS->Type == SHT_GROUP || (IS->Flags & SHF_GROUP))
addInputSec(StringMap<TinyPtrVector<OutputSection *>> &Map,
   //
   // and a mapping of .foo1 and .bar1 to one section and .foo2 and .bar2 to
   // another. The problem is that there is no way to layout those output
   // sections such that the .foo sections are the only thing between the start
   // and end symbols.
   //
   // Given the above issues, we instead merge sections by name and error on
   // incompatible types and flags.
-  OutputSection *&Sec = Map[OutsecName];
-  if (Sec) {
+  TinyPtrVector<OutputSection *> &V = Map[OutsecName];
+  for (OutputSection *Sec : V) {
+    if (Sec->Partition != IS->Partition)
+      continue;
     Sec->addSection(cast<InputSection>(IS));
     return nullptr;
   }
 
-  Sec = createSection(IS, OutsecName);
+  OutputSection *Sec = createSection(IS, OutsecName);
+  V.push_back(Sec);
   return Sec;
 }
 
 // Add sections that didn't match any sections command.
 void LinkerScript::addOrphanSections() {
-  StringMap<OutputSection *> Map;
+  StringMap<TinyPtrVector<OutputSection *>> Map;
   std::vector<OutputSection *> V;
 
   auto Add = [&](InputSectionBase *S) {
-    if (!S->Live || S->Parent)
+    if (!S->isLive() || S->Parent)
       return;
 
     StringRef Name = getOutputSectionName(S);
 
     if (Config->OrphanHandling == OrphanHandlingPolicy::Error)
       error(toString(S) + " is being placed in '" + Name + "'");
     else if (Config->OrphanHandling == OrphanHandlingPolicy::Warn)
       warn(toString(S) + " is being placed in '" + Name + "'");
for (BaseCommand *&Cmd : SectionCommands) {
     // Handle align (e.g. ".foo : ALIGN(16) { ... }").
     if (Sec->AlignExpr)
       Sec->Alignment =
           std::max<uint32_t>(Sec->Alignment, Sec->AlignExpr().getValue());
 
     // A live output section means that some input section was added to it. It
     // might have been removed (if it was empty synthetic section), but we at
     // least know the flags.
-    if (Sec->Live)
+    if (Sec->isLive())
       Flags = Sec->Flags;
 
     // We do not want to keep any special flags for output section
     // in case it is empty.
     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->Live = false;
+      Sec->Partition = 0;
       Cmd = nullptr;
     }
   }
 
   // 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.

lld/ELF/MapFile.cpp

 }
 
 // Returns a list of all symbols that we want to print out.
 static std::vector<Defined *> getSymbols() {
   std::vector<Defined *> V;
   for (InputFile *File : ObjectFiles)
     for (Symbol *B : File->getSymbols())
       if (auto *DR = dyn_cast<Defined>(B))
-        if (!DR->isSection() && DR->Section && DR->Section->Live &&
+        if (!DR->isSection() && DR->Section && DR->Section->isLive() &&
             (DR->File == File || DR->NeedsPltAddr || DR->Section->Bss))
           V.push_back(DR);
   return V;
 }
 
 // Returns a map from sections to their symbols.
 static SymbolMapTy getSectionSyms(ArrayRef<Defined *> Syms) {
   SymbolMapTy Ret;
void elf::writeCrossReferenceTable() {
 
   // Collect symbols and files.
   MapVector<Symbol *, SetVector<InputFile *>> Map;
   for (InputFile *File : ObjectFiles) {
     for (Symbol *Sym : File->getSymbols()) {
       if (isa<SharedSymbol>(Sym))
         Map[Sym].insert(File);
       if (auto *D = dyn_cast<Defined>(Sym))
-        if (!D->isLocal() && (!D->Section || D->Section->Live))
+        if (!D->isLocal() && (!D->Section || D->Section->isLive()))
           Map[D].insert(File);
     }
   }
 
   // Print out a header.
   outs() << "Cross Reference Table\n\n";
   print("Symbol", "File");
 

lld/ELF/MarkLive.cpp

 //===----------------------------------------------------------------------===//
 
 #include "MarkLive.h"
 #include "InputSection.h"
 #include "LinkerScript.h"
 #include "OutputSections.h"
 #include "SymbolTable.h"
 #include "Symbols.h"
+#include "SyntheticSections.h"
 #include "Target.h"
 #include "lld/Common/Memory.h"
 #include "lld/Common/Strings.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/Object/ELF.h"
 #include <functional>
 #include <vector>
 
 using namespace llvm;
 using namespace llvm::ELF;
 using namespace llvm::object;
 using namespace llvm::support::endian;
 
 using namespace lld;
 using namespace lld::elf;
 
 namespace {
 template <class ELFT> class MarkLive {
 public:
+  MarkLive(unsigned Partition) : Partition(Partition) {}
+
   void run();
+  void moveToMain();
 
 private:
   void enqueue(InputSectionBase *Sec, uint64_t Offset, bool IsLSDA);
   void markSymbol(Symbol *Sym);
+  void mark();
 
   template <class RelTy>
   void resolveReloc(InputSectionBase &Sec, RelTy &Rel, bool IsLSDA);
 
   template <class RelTy>
   void scanEhFrameSection(EhInputSection &EH, ArrayRef<RelTy> Rels);
 
+  // The index of the partition that we are currently processing.
+  unsigned Partition;
+
   // A list of sections to visit.
   SmallVector<InputSection *, 256> Queue;
 
   // There are normally few input sections whose names are valid C
   // identifiers, so we just store a std::vector instead of a multimap.
   DenseMap<StringRef, std::vector<InputSectionBase *>> CNamedSections;
 };
 } // namespace
void MarkLive<ELFT>::enqueue(InputSectionBase *Sec, uint64_t Offset,
 
   InputSection *S = dyn_cast<InputSection>(Sec);
   // LSDA does not count as "live code or data" in the object file.
   // The section may already have been marked live for LSDA in which
   // case we still need to mark the file.
   if (S && !IsLSDA && Sec->File)
     Sec->getFile<ELFT>()->HasLiveCodeOrData = true;
 
-  if (Sec->Live)
+  // Set Sec->Partition to the meet (i.e. the "minimum") of Partition and
+  // Sec->Partition in the following lattice: 1 < other < 0. If Sec->Partition
+  // doesn't change, we don't need to do anything.
+  if (Sec->Partition == 1 || Sec->Partition == Partition)
     return;
+  Sec->Partition = Sec->Partition ? 1 : Partition;
 
-  Sec->Live = true;
   // Add input section to the queue.
   if (S)
     Queue.push_back(S);
 }
 
 template <class ELFT> void MarkLive<ELFT>::markSymbol(Symbol *Sym) {
   if (auto *D = dyn_cast_or_null<Defined>(Sym))
     if (auto *IS = dyn_cast_or_null<InputSectionBase>(D->Section))
       enqueue(IS, D->Value, false);
 }
 
 // This is the main function of the garbage collector.
 // Starting from GC-root sections, this function visits all reachable
 // sections to set their "Live" bits.
 template <class ELFT> void MarkLive<ELFT>::run() {
   // Add GC root symbols.
+
+  // Preserve externally-visible symbols if the symbols defined by this
+  // file can interrupt other ELF file's symbols at runtime.
+  for (Symbol *S : Symtab->getSymbols())
+    if (S->includeInDynsym() && S->Partition == Partition)
+      markSymbol(S);
+
+  // If this isn't the main partition, that's all that we need to preserve.
+  if (Partition != 1) {
+    mark();
+    return;
+  }
+
   markSymbol(Symtab->find(Config->Entry));
   markSymbol(Symtab->find(Config->Init));
   markSymbol(Symtab->find(Config->Fini));
   for (StringRef S : Config->Undefined)
     markSymbol(Symtab->find(S));
   for (StringRef S : Script->ReferencedSymbols)
     markSymbol(Symtab->find(S));
 
-  // Preserve externally-visible symbols if the symbols defined by this
-  // file can interrupt other ELF file's symbols at runtime.
-  for (Symbol *S : Symtab->getSymbols())
-    if (S->includeInDynsym())
-      markSymbol(S);
-
   // Preserve special sections and those which are specified in linker
   // script KEEP command.
   for (InputSectionBase *Sec : InputSections) {
     // Mark .eh_frame sections as live because there are usually no relocations
     // that point to .eh_frames. Otherwise, the garbage collector would drop
     // all of them. We also want to preserve personality routines and LSDA
     // referenced by .eh_frame sections, so we scan them for that here.
     if (auto *EH = dyn_cast<EhInputSection>(Sec)) {
-      EH->Live = true;
+      EH->Partition = 1;
       if (!EH->NumRelocations)
         continue;
 
       if (EH->AreRelocsRela)
         scanEhFrameSection(*EH, EH->template relas<ELFT>());
       else
         scanEhFrameSection(*EH, EH->template rels<ELFT>());
     }
 
     if (Sec->Flags & SHF_LINK_ORDER)
       continue;
 
     if (isReserved(Sec) || Script->shouldKeep(Sec)) {
       enqueue(Sec, 0, false);
     } else if (isValidCIdentifier(Sec->Name)) {
       CNamedSections[Saver.save("__start_" + Sec->Name)].push_back(Sec);
       CNamedSections[Saver.save("__stop_" + Sec->Name)].push_back(Sec);
     }
   }
 
+  mark();
+}
+
+template <class ELFT> void MarkLive<ELFT>::mark() {
   // Mark all reachable sections.
   while (!Queue.empty()) {
     InputSectionBase &Sec = *Queue.pop_back_val();
 
     if (Sec.AreRelocsRela) {
       for (const typename ELFT::Rela &Rel : Sec.template relas<ELFT>())
         resolveReloc(Sec, Rel, false);
     } else {
       for (const typename ELFT::Rel &Rel : Sec.template rels<ELFT>())
         resolveReloc(Sec, Rel, false);
     }
 
     for (InputSectionBase *IS : Sec.DependentSections)
       enqueue(IS, 0, false);
   }
 }
 
+// Move the sections for some symbols to the main partition, specifically ifuncs
+// (because they can result in an IRELATIVE being added to the main partition's
+// GOT, which means that the ifunc must be available when the main partition is
+// loaded) and TLS symbols (because we only know how to correctly process TLS
+// relocations for the main partition).
+template <class ELFT> void MarkLive<ELFT>::moveToMain() {
+  for (InputFile *File : ObjectFiles)
+    for (Symbol *S : File->getSymbols())
+      if (auto *D = dyn_cast<Defined>(S))
+        if ((D->Type == STT_GNU_IFUNC || D->Type == STT_TLS) && D->Section &&
+            D->Section->isLive())
+          markSymbol(S);
+
+  mark();
+}
+
 // Before calling this function, Live bits are off for all
 // input sections. This function make some or all of them on
 // so that they are emitted to the output file.
 template <class ELFT> void elf::markLive() {
   // If -gc-sections is not given, no sections are removed.
   if (!Config->GcSections) {
     for (InputSectionBase *Sec : InputSections)
-      Sec->Live = true;
+      Sec->Partition = 1;
 
     // If a DSO defines a symbol referenced in a regular object, it is needed.
     for (Symbol *Sym : Symtab->getSymbols())
       if (auto *S = dyn_cast<SharedSymbol>(Sym))
         if (S->IsUsedInRegularObj && !S->isWeak())
           S->getFile().IsNeeded = true;
     return;
   }
template <class ELFT> void elf::markLive() {
   // collection because, if we remove a text section, we also
   // remove its relocation section.
   for (InputSectionBase *Sec : InputSections) {
     bool IsAlloc = (Sec->Flags & SHF_ALLOC);
     bool IsLinkOrder = (Sec->Flags & SHF_LINK_ORDER);
     bool IsRel = (Sec->Type == SHT_REL || Sec->Type == SHT_RELA);
 
     if (!IsAlloc && !IsLinkOrder && !IsRel && !Sec->Debug)
-      Sec->Live = true;
+      Sec->Partition = 1;
   }
 
   // Follow the graph to mark all live sections.
-  MarkLive<ELFT>().run();
+  for (unsigned CurPart = 1; CurPart <= Partitions.size(); ++CurPart)
+    MarkLive<ELFT>(CurPart).run();
+
+  // If we have multiple partitions, some sections need to live in the main
+  // partition even if they were allocated to a loadable partition. Move them
+  // there now.
+  if (Partitions.size() != 1)
+    MarkLive<ELFT>(1).moveToMain();
 
   // Mark debug sections as live in any object file that has a live
   // Regular or Merge section.
   for (InputSectionBase *Sec : InputSections)
     if (Sec->Debug && Sec->getFile<ELFT>()->HasLiveCodeOrData)
-      Sec->Live = true;
+      Sec->Partition = 1;
 
   // Report garbage-collected sections.
   if (Config->PrintGcSections)
     for (InputSectionBase *Sec : InputSections)
-      if (!Sec->Live)
+      if (!Sec->isLive())
         message("removing unused section " + toString(Sec));
 }
 
 template void elf::markLive<ELF32LE>();
 template void elf::markLive<ELF32BE>();
 template void elf::markLive<ELF64LE>();
 template void elf::markLive<ELF64BE>();

lld/ELF/OutputSections.cpp

 // seem to be a harm in merging them.
 static bool canMergeToProgbits(unsigned Type) {
   return Type == SHT_NOBITS || Type == SHT_PROGBITS || Type == SHT_INIT_ARRAY ||
          Type == SHT_PREINIT_ARRAY || Type == SHT_FINI_ARRAY ||
          Type == SHT_NOTE;
 }
 
 void OutputSection::addSection(InputSection *IS) {
-  if (!Live) {
+  if (!isLive()) {
     // If IS is the first section to be added to this section,
-    // initialize Type, Entsize and flags from IS.
-    Live = true;
+    // initialize Partition, Type, Entsize and flags from IS.
+    Partition = IS->Partition;
     Type = IS->Type;
     Entsize = IS->Entsize;
     Flags = IS->Flags;
   } else {
     // Otherwise, check if new type or flags are compatible with existing ones.
     unsigned Mask = SHF_TLS | SHF_LINK_ORDER;
     if ((Flags & Mask) != (IS->Flags & Mask))
       error("incompatible section flags for " + Name + "\n>>> " + toString(IS) +
uint64_t elf::getHeaderSize() {
   return Out::ElfHeader->Size + Out::ProgramHeaders->Size;
 }
 
 bool OutputSection::classof(const BaseCommand *C) {
   return C->Kind == OutputSectionKind;
 }
 
 void OutputSection::sort(llvm::function_ref<int(InputSectionBase *S)> Order) {
-  assert(Live);
+  assert(isLive());
   for (BaseCommand *B : SectionCommands)
     if (auto *ISD = dyn_cast<InputSectionDescription>(B))
       sortByOrder(ISD->Sections, Order);
 }
 
 // Fill [Buf, Buf + Size) with Filler.
 // This is used for linker script "=fillexp" command.
 static void fill(uint8_t *Buf, size_t Size,

lld/ELF/SymbolTable.cpp

std::pair<Symbol *, bool> SymbolTable::insertName(StringRef Name) {
   auto *Sym = reinterpret_cast<Symbol *>(make<SymbolUnion>());
   Sym->SymbolKind = Symbol::PlaceholderKind;
   Sym->Visibility = STV_DEFAULT;
   Sym->IsUsedInRegularObj = false;
   Sym->ExportDynamic = false;
   Sym->CanInline = true;
   Sym->Traced = Traced;
   Sym->VersionId = Config->DefaultSymbolVersion;
+  Sym->Partition = 1;
   SymVector.push_back(Sym);
   return {Sym, true};
 }
 
 // Find an existing symbol or create and insert a new one, then apply the given
 // attributes.
 std::pair<Symbol *, bool> SymbolTable::insert(StringRef Name,
                                               uint8_t Visibility,
Symbol *SymbolTable::addCommon(StringRef N, uint64_t Size, uint32_t Alignment,
 
   int Cmp = compareDefined(S, WasInserted, Binding, N);
   if (Cmp < 0)
     return S;
 
   if (Cmp > 0) {
     auto *Bss = make<BssSection>("COMMON", Size, Alignment);
     Bss->File = &File;
-    Bss->Live = !Config->GcSections;
+    Bss->Partition = 0;
     InputSections.push_back(Bss);
 
     replaceSymbol<Defined>(S, &File, N, Binding, StOther, Type, 0, Size, Bss);
     return S;
   }
 
   auto *D = cast<Defined>(S);
   auto *Bss = dyn_cast_or_null<BssSection>(D->Section);

lld/ELF/Symbols.h

public:
 
   // True if a call to this symbol needs to be followed by a restore of the
   // PPC64 toc pointer.
   unsigned NeedsTocRestore : 1;
 
   // True if this symbol is defined by a linker script.
   unsigned ScriptDefined : 1;
 
+  // The partition whose dynamic symbol table contains this symbol's definition.
+  uint8_t Partition = 1;
+
   bool isSection() const { return Type == llvm::ELF::STT_SECTION; }
   bool isTls() const { return Type == llvm::ELF::STT_TLS; }
   bool isFunc() const { return Type == llvm::ELF::STT_FUNC; }
   bool isGnuIFunc() const { return Type == llvm::ELF::STT_GNU_IFUNC; }
   bool isObject() const { return Type == llvm::ELF::STT_OBJECT; }
   bool isFile() const { return Type == llvm::ELF::STT_FILE; }
 };
 
void replaceSymbol(Symbol *S, ArgT &&... Arg) {
 
   S->VersionId = Sym.VersionId;
   S->Visibility = Sym.Visibility;
   S->IsUsedInRegularObj = Sym.IsUsedInRegularObj;
   S->ExportDynamic = Sym.ExportDynamic;
   S->CanInline = Sym.CanInline;
   S->Traced = Sym.Traced;
   S->ScriptDefined = Sym.ScriptDefined;
+  S->Partition = Sym.Partition;
 
   // Symbols representing thread-local variables must be referenced by
   // TLS-aware relocations, and non-TLS symbols must be reference by
   // non-TLS relocations, so there's a clear distinction between TLS
   // and non-TLS symbols. It is an error if the same symbol is defined
   // as a TLS symbol in one file and as a non-TLS symbol in other file.
   bool TlsMismatch = (Sym.Type == STT_TLS && S->Type != STT_TLS) ||
                      (Sym.Type != STT_TLS && S->Type == STT_TLS);

lld/ELF/Symbols.cpp

void elf::maybeWarnUnorderableSymbol(const Symbol *Sym) {
   if (Sym->isUndefined())
     Warn(": unable to order undefined symbol: ");
   else if (Sym->isShared())
     Warn(": unable to order shared symbol: ");
   else if (D && !D->Section)
     Warn(": unable to order absolute symbol: ");
   else if (D && isa<OutputSection>(D->Section))
     Warn(": unable to order synthetic symbol: ");
-  else if (D && !D->Section->Repl->Live)
+  else if (D && !D->Section->Repl->isLive())
     Warn(": unable to order discarded symbol: ");
 }
 
 // Returns a symbol for an error message.
 std::string lld::toString(const Symbol &B) {
   if (Config->Demangle)
     if (Optional<std::string> S = demangleItanium(B.getName()))
       return *S;
   return B.getName();
 }

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;
 
 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) {
-    this->Live = true;
+    this->Partition = 1;
   }
 
   virtual ~SyntheticSection() = default;
   virtual void writeTo(uint8_t *Buf) = 0;
   virtual size_t getSize() const = 0;
   virtual void finalizeContents() {}
   // If the section has the SHF_ALLOC flag and the size may be changed if
   // thunks are added, update the section size.

 template <class ELFT> void splitSections();
 void mergeSections();
 
 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; }
+};
+
 // Linker generated sections which can be used as inputs.
 struct InStruct {
   InputSection *ARMAttributes;
   ARMExidxSyntheticSection *ARMExidx;
   BssSection *Bss;
   BssSection *BssRelRo;
   BuildIdSection *BuildId;
   EhFrameHeader *EhFrameHdr;

lld/ELF/SyntheticSections.cpp

 template <class ELFT>
 MipsAbiFlagsSection<ELFT> *MipsAbiFlagsSection<ELFT>::create() {
   Elf_Mips_ABIFlags Flags = {};
   bool Create = false;
 
   for (InputSectionBase *Sec : InputSections) {
     if (Sec->Type != SHT_MIPS_ABIFLAGS)
       continue;
-    Sec->Live = false;
+    Sec->Partition = 0;
     Create = true;
 
     std::string Filename = toString(Sec->File);
     const size_t Size = Sec->data().size();
     // Older version of BFD (such as the default FreeBSD linker) concatenate
     // .MIPS.abiflags instead of merging. To allow for this case (or potential
     // zero padding) we ignore everything after the first Elf_Mips_ABIFlags
     if (Size < sizeof(Elf_Mips_ABIFlags)) {
for (InputSectionBase *Sec : InputSections)
     if (Sec->Type == SHT_MIPS_OPTIONS)
       Sections.push_back(Sec);
 
   if (Sections.empty())
     return nullptr;
 
   Elf_Mips_RegInfo Reginfo = {};
   for (InputSectionBase *Sec : Sections) {
-    Sec->Live = false;
+    Sec->Partition = 0;
 
     std::string Filename = toString(Sec->File);
     ArrayRef<uint8_t> D = Sec->data();
 
     while (!D.empty()) {
       if (D.size() < sizeof(Elf_Mips_Options)) {
         error(Filename + ": invalid size of .MIPS.options section");
         break;
for (InputSectionBase *Sec : InputSections)
     if (Sec->Type == SHT_MIPS_REGINFO)
       Sections.push_back(Sec);
 
   if (Sections.empty())
     return nullptr;
 
   Elf_Mips_RegInfo Reginfo = {};
   for (InputSectionBase *Sec : Sections) {
-    Sec->Live = false;
+    Sec->Partition = 0;
 
     if (Sec->data().size() != sizeof(Elf_Mips_RegInfo)) {
       error(toString(Sec->File) + ": invalid size of .reginfo section");
       return nullptr;
     }
 
     auto *R = reinterpret_cast<const Elf_Mips_RegInfo *>(Sec->data().data());
     Reginfo.ri_gprmask |= R->ri_gprmask;
     Sec->getFile<ELFT>()->MipsGp0 = R->ri_gp_value;
   };
 
   return make<MipsReginfoSection<ELFT>>(Reginfo);
 }
 
 InputSection *elf::createInterpSection() {
   // StringSaver guarantees that the returned string ends with '\0'.
   StringRef S = Saver.save(Config->DynamicLinker);
   ArrayRef<uint8_t> Contents = {(const uint8_t *)S.data(), S.size() + 1};
 
   auto *Sec = make<InputSection>(nullptr, SHF_ALLOC, SHT_PROGBITS, 1, Contents,
                                  ".interp");
-  Sec->Live = true;
+  Sec->Partition = 1;
   return Sec;
 }
 
 Defined *elf::addSyntheticLocal(StringRef Name, uint8_t Type, uint64_t Value,
                                 uint64_t Size, InputSectionBase &Section) {
   auto *S = make<Defined>(Section.File, Name, STB_LOCAL, STV_DEFAULT, Type,
                           Value, Size, &Section);
   if (In.SymTab)
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.
   if (auto *D = dyn_cast<Defined>(&B))
     if (SectionBase *Sec = D->Section)
-      return Sec->Live;
+      return Sec->isLive();
   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>
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()->Live) {
+  if (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);
for (std::unique_ptr<DWARFUnit> &Cu : Dwarf.compile_units()) {
     if (!Ranges) {
       error(toString(Sec) + ": " + toString(Ranges.takeError()));
       return {};
     }
 
     ArrayRef<InputSectionBase *> Sections = Sec->File->getSections();
     for (DWARFAddressRange &R : *Ranges) {
       InputSectionBase *S = Sections[R.SectionIndex];
-      if (!S || S == &InputSection::Discarded || !S->Live)
+      if (!S || S == &InputSection::Discarded || !S->isLive())
         continue;
       // Range list with zero size has no effect.
       if (R.LowPC == R.HighPC)
         continue;
       auto *IS = cast<InputSection>(S);
       uint64_t Offset = IS->getOffsetInFile();
       Ret.push_back({IS, R.LowPC - Offset, R.HighPC - Offset, CuIdx});
     }

 template <class ELFT> GdbIndexSection *GdbIndexSection::create() {
   std::vector<InputSection *> Sections = getDebugInfoSections();
 
   // .debug_gnu_pub{names,types} are useless in executables.
   // They are present in input object files solely for creating
   // a .gdb_index. So we can remove them from the output.
   for (InputSectionBase *S : InputSections)
     if (S->Name == ".debug_gnu_pubnames" || S->Name == ".debug_gnu_pubtypes")
-      S->Live = false;
+      S->Partition = 0;
 
   std::vector<GdbChunk> Chunks(Sections.size());
   std::vector<std::vector<NameAttrEntry>> NameAttrs(Sections.size());
 
   parallelForEachN(0, Sections.size(), [&](size_t I) {
     ObjFile<ELFT> *File = Sections[I]->getFile<ELFT>();
     DWARFContext Dwarf(make_unique<LLDDwarfObj<ELFT>>(File));
 
void elf::mergeSections() {
   std::vector<MergeSyntheticSection *> MergeSections;
   for (InputSectionBase *&S : InputSections) {
     MergeInputSection *MS = dyn_cast<MergeInputSection>(S);
     if (!MS)
       continue;
 
     // We do not want to handle sections that are not alive, so just remove
     // them instead of trying to merge.
-    if (!MS->Live) {
+    if (!MS->isLive()) {
       S = nullptr;
       continue;
     }
 
     StringRef OutsecName = getOutputSectionName(MS);
 
     auto I = llvm::find_if(MergeSections, [=](MergeSyntheticSection *Sec) {
       // While we could create a single synthetic section for two different
bool PPC64LongBranchTargetSection::isNeeded() const {
   // 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();
 }
 
 InStruct elf::In;
 
+std::vector<Partition> elf::Partitions;
+
 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 void elf::splitSections<ELF64LE>();

lld/ELF/Writer.cpp

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 combineEhSections() {
   for (InputSectionBase *&S : InputSections) {
-    if (!S->Live)
+    if (!S->isLive())
       continue;
 
     if (auto *ES = dyn_cast<EhInputSection>(S)) {
       In.EhFrame->addSection<ELFT>(ES);
       S = nullptr;
     } else if (S->kind() == SectionBase::Regular && In.ARMExidx &&
                In.ARMExidx->addSection(cast<InputSection>(S))) {
       S = nullptr;
static bool includeInSymtab(const Symbol &B) {
   if (auto *D = dyn_cast<Defined>(&B)) {
     // Always include absolute symbols.
     SectionBase *Sec = D->Section;
     if (!Sec)
       return true;
     Sec = Sec->Repl;
 
     // Exclude symbols pointing to garbage-collected sections.
-    if (isa<InputSectionBase>(Sec) && !Sec->Live)
+    if (isa<InputSectionBase>(Sec) && !Sec->isLive())
       return false;
 
     if (auto *S = dyn_cast<MergeInputSection>(Sec))
       if (!S->getSectionPiece(D->Value)->Live)
         return false;
     return true;
   }
   return B.Used;

 // 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 << 17,
-  RF_NOT_ALLOC = 1 << 16,
+  RF_NOT_ADDR_SET = 1 << 25,
+  RF_NOT_ALLOC = 1 << 24,
+  RF_PARTITION = 1 << 16, // Partition number (8 bits)
   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,
   RF_BSS = 1 << 7,
   RF_PPC_NOT_TOCBSS = 1 << 6,
   RF_PPC_TOCL = 1 << 5,
   RF_PPC_TOC = 1 << 4,
   RF_PPC_GOT = 1 << 3,
   RF_PPC_BRANCH_LT = 1 << 2,
   RF_MIPS_GPREL = 1 << 1,
   RF_MIPS_NOT_GOT = 1 << 0
 };
 
 static unsigned getSectionRank(const OutputSection *Sec) {
-  unsigned Rank = 0;
+  unsigned Rank = Sec->Partition * RF_PARTITION;
 
   // We want to put section specified by -T option first, so we
   // can start assigning VA starting from them later.
   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

 void Writer<ELFT>::forEachRelSec(
     llvm::function_ref<void(InputSectionBase &)> Fn) {
   // 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->Live && isa<InputSection>(IS) && (IS->Flags & SHF_ALLOC))
+    if (IS->isLive() && isa<InputSection>(IS) && (IS->Flags & SHF_ALLOC))
       Fn(*IS);
   for (EhInputSection *ES : In.EhFrame->Sections)
     Fn(*ES);
-  if (In.ARMExidx && In.ARMExidx->Live)
+  if (In.ARMExidx && In.ARMExidx->isLive())
     for (InputSection *Ex : In.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

 // Since each branch corresponds to a bit flag, we can just use
 // countLeadingZeros.
 static int getRankProximityAux(OutputSection *A, OutputSection *B) {
   return countLeadingZeros(A->SortRank ^ B->SortRank);
 }
 
 static int getRankProximity(OutputSection *A, BaseCommand *B) {
   auto *Sec = dyn_cast<OutputSection>(B);
-  return (Sec && Sec->Live) ? getRankProximityAux(A, Sec) : -1;
+  return (Sec && Sec->isLive()) ? getRankProximityAux(A, Sec) : -1;
 }
 
 // When placing orphan sections, we want to place them after symbol assignments
 // so that an orphan after
 //   begin_foo = .;
 //   foo : { *(foo) }
 //   end_foo = .;
 // doesn't break the intended meaning of the begin/end symbols.
findOrphanPos(std::vector<BaseCommand *>::iterator B,
   });
   if (I == E)
     return E;
 
   // Consider all existing sections with the same proximity.
   int Proximity = getRankProximity(Sec, *I);
   for (; I != E; ++I) {
     auto *CurSec = dyn_cast<OutputSection>(*I);
-    if (!CurSec || !CurSec->Live)
+    if (!CurSec || !CurSec->isLive())
       continue;
     if (getRankProximity(Sec, CurSec) != Proximity ||
         Sec->SortRank < CurSec->SortRank)
       break;
   }
 
   auto IsLiveOutputSec = [](BaseCommand *Cmd) {
     auto *OS = dyn_cast<OutputSection>(Cmd);
-    return OS && OS->Live;
+    return OS && OS->isLive();
   };
   auto J = std::find_if(llvm::make_reverse_iterator(I),
                         llvm::make_reverse_iterator(B), IsLiveOutputSec);
   I = J.base();
 
   // As a special case, if the orphan section is the last section, put
   // it at the very end, past any other commands.
   // This matches bfd's behavior and is convenient when the linker script fully

lld/test/ELF/partition-errors.s

+// REQUIRES: x86, mips
+// RUN: llvm-mc -triple=x86_64-unknown-linux -filetype=obj -o %t.o %s
+// RUN: echo "SECTIONS {}" > %t.script
+// RUN: not ld.lld --export-dynamic %t.o %t.script 2>&1 | FileCheck %s
+// RUN: echo "PHDRS { text PT_LOAD; }" > %t2.script
+// RUN: not ld.lld --export-dynamic %t.o %t2.script 2>&1 | FileCheck %s
+// RUN: not ld.lld --export-dynamic %t.o --section-start .text=0 2>&1 | FileCheck %s
+// RUN: not ld.lld --export-dynamic %t.o -Ttext=0 2>&1 | FileCheck %s
+// RUN: not ld.lld --export-dynamic %t.o -Tdata=0 2>&1 | FileCheck %s
+// RUN: not ld.lld --export-dynamic %t.o -Tbss=0 2>&1 | FileCheck %s
+
+// RUN: llvm-mc -triple=mipsel-unknown-linux -filetype=obj -o %t2.o %s
+// RUN: not ld.lld --export-dynamic %t2.o 2>&1 | FileCheck %s
+
+// CHECK: error: {{.*}}.o: partitions cannot be used
+
+.section .llvm_sympart.f1,"",@llvm_sympart
+.asciz "part1"
+.quad f1
+
+.text
+.globl f1
+f1:

lld/test/ELF/partition-icf.s

+// REQUIRES: x86
+// RUN: llvm-mc %s -o %t.o -filetype=obj --triple=x86_64-unknown-linux
+// RUN: ld.lld %t.o -o %t --export-dynamic --gc-sections --icf=all
+// RUN: llvm-readelf -S -s %t | FileCheck %s
+
+// CHECK: [ [[MAIN:[0-9]+]]] .text
+// CHECK: [ [[P1:[0-9]+]]] .text
+// CHECK: [ [[P2:[0-9]+]]] .text
+
+// CHECK:   [[P1]] f1
+// CHECK:   [[P2]] f2
+// CHECK: [[MAIN]] g1
+// CHECK: [[MAIN]] g2
+
+.section .llvm_sympart.f1,"",@llvm_sympart
+.asciz "part1"
+.quad f1
+
+.section .llvm_sympart.f2,"",@llvm_sympart
+.asciz "part2"
+.quad f2
+
+.section .llvm_sympart.g1,"",@llvm_sympart
+.asciz "part1"
+.quad g1
+
+.section .llvm_sympart.g2,"",@llvm_sympart
+.asciz "part2"
+.quad g2
+
+.section .text.f1,"ax",@progbits
+.globl f1
+f1:
+.byte 1
+
+.section .text.f2,"ax",@progbits
+.globl f2
+f2:
+.byte 2
+
+.section .text.g1,"ax",@progbits
+.globl g1
+g1:
+.byte 3
+
+.section .text.g2,"ax",@progbits
+.globl g2
+g2:
+.byte 3

lld/test/ELF/partition-move-to-main.s

+// REQUIRES: x86
+// RUN: llvm-mc %s -o %t.o -filetype=obj --triple=x86_64-unknown-linux
+// RUN: ld.lld %t.o -o %t --export-dynamic --gc-sections
+// RUN: llvm-readelf -S -s %t | FileCheck %s
+
+// Ordinarily, the TLS and IFUNC sections would be split into partitions.
+// Make sure that that didn't happen by checking that there is only one
+// of each section.
+
+// CHECK: .ifunc
+// CHECK: .tdata
+
+// CHECK-NOT: .ifunc
+// CHECK-NOT: .tdata
+
+.section .llvm_sympart.f1,"",@llvm_sympart
+.asciz "part1"
+.quad f1
+
+.section .text._start,"ax",@progbits
+.globl _start
+_start:
+call tls1
+call ifunc1
+
+.section .text.f1,"ax",@progbits
+.globl f1
+f1:
+call tls2
+call ifunc2
+
+.section .ifunc,"ax",@progbits,unique,1
+.type ifunc1 STT_GNU_IFUNC
+ifunc1:
+
+.section .ifunc,"ax",@progbits,unique,2
+.type ifunc2 STT_GNU_IFUNC
+ifunc2:
+
+.section .tdata,"awT",@progbits,unique,1
+tls1:
+
+.section .tdata,"awT",@progbits,unique,2
+tls2:

lld/test/ELF/partitions.s

+// REQUIRES: x86
+// RUN: llvm-mc %s -o %t.o -filetype=obj --triple=x86_64-unknown-linux
+// RUN: ld.lld %t.o -o %t --export-dynamic --gc-sections
+// RUN: llvm-readelf -S -s %t | FileCheck %s
+
+// This is basically lld/docs/partitions.dot in object file form.
+// Test that the sections are correctly allocated to partitions.
+
+// CHECK: [ [[MAIN:[0-9]+]]] .text
+// CHECK: [ [[P1:[0-9]+]]] .text
+// CHECK: [ [[P2:[0-9]+]]] .text
+
+// CHECK: [[MAIN]] _start
+// CHECK:   [[P1]] f1
+// CHECK:   [[P2]] f2
+// CHECK: [[MAIN]] f3
+// CHECK:   [[P1]] f4
+// CHECK: [[MAIN]] f5
+// CHECK:   [[P2]] f6
+
+.section .llvm_sympart.f1,"",@llvm_sympart
+.asciz "part1"
+.quad f1
+
+.section .llvm_sympart.f2,"",@llvm_sympart
+.asciz "part2"
+.quad f2
+
+.section .text._start,"ax",@progbits
+.globl _start
+_start:
+call f3
+
+.section .text.f1,"ax",@progbits
+.globl f1
+f1:
+call f3
+call f4
+call f5
+
+.section .text.f2,"ax",@progbits
+.globl f2
+f2:
+call f3
+call f5
+call f6
+
+.section .text.f3,"ax",@progbits
+f3:
+ret
+
+.section .text.f4,"ax",@progbits
+f4:
+ret
+
+.section .text.f5,"ax",@progbits
+f5:
+ret
+
+.section .text.f6,"ax",@progbits
+f6:
+ret