[ELF] - Linkerscript: allow add MergeInputSection to regular OutputSection.

[grimar]

Summary

Before this patch SHF_MERGE sections were always proccessed as regular
ones when script layouting was used.

That was done because we create single output section
for each list of inputsections when have SECTIONS command. Since there was
no way to handle the case when there were mixed section types in that list
(mergeable vs non-mergeable), functionality was temporarily disabled.

This is the case that can be observed in FreeBSD, which has a mix of attributes
for .rodata:

[ 6] .rodata PROGBITS ffffffff80c87c8c 00c86c8c

00000000000e6e4d  0000000000000001 AMS       0     0     1

[ 7] .rodata PROGBITS ffffffff80d6eae0 00d6dae0

0000000000246f00  0000000000000000   A       0     0     32

[ 8] .rodata PROGBITS ffffffff80fb59e0 00fb49e0

00000000000001f0  0000000000000010  AM       0     0     16

[ 9] .rodata PROGBITS ffffffff80fb5bd0 00fb4bd0

00000000000002a0  0000000000000004 AMS       0     0     16

[10] .rodata PROGBITS ffffffff80fb5e70 00fb4e70

0000000000000108  0000000000000008  AM       0     0     8

[11] .rodata PROGBITS ffffffff80fb5f78 00fb4f78

000000000000000c  0000000000000004 AMS       0     0     4

[12] .rodata PROGBITS ffffffff80fb5f88 00fb4f88

0000000000001158  0000000000000001 AMS       0     0     8

Patch adds ability to add MergeInputSections to regular OutputSections.

Patch itself would not be so big, but it is heavily based on D23866 which removes
dependency on OutputSectionFactory for linkerscript. So largest changes belongs to D23866 here.

[grimar]

• Restored OffsetMap variable removed by mistake right before uploading diff.

[grimar]

We are not going to do that.

ELF/InputFiles.cpp

 
 template <class ELFT>
 bool elf::ObjectFile<ELFT>::shouldMerge(const Elf_Shdr &Sec) {
   // We don't merge sections if -O0 (default is -O1). This makes sometimes
   // the linker significantly faster, although the output will be bigger.
   if (Config->Optimize == 0)
     return false;
 
-  // We don't merge if linker script has SECTIONS command. When script
-  // do layout it can merge several sections with different attributes
-  // into single output sections. We currently do not support adding
-  // mergeable input sections to regular output ones as well as adding
-  // regular input sections to mergeable output.
-  if (ScriptConfig->HasContents)
-    return false;
-
   // A mergeable section with size 0 is useless because they don't have
   // any data to merge. A mergeable string section with size 0 can be
   // argued as invalid because it doesn't end with a null character.
   // We'll avoid a mess by handling them as if they were non-mergeable.
   if (Sec.sh_size == 0)
     return false;
 
   uintX_t Flags = Sec.sh_flags;

ELF/InputSection.h

template <class ELFT> class MergeInputSection : public InputSectionBase<ELFT> {
   typedef typename ELFT::Sym Elf_Sym;
   typedef typename ELFT::Shdr Elf_Shdr;
 
 public:
   MergeInputSection(ObjectFile<ELFT> *F, const Elf_Shdr *Header);
   static bool classof(const InputSectionBase<ELFT> *S);
   void splitIntoPieces();
 
+  void writeTo(uint8_t *Buf);
+
   // Mark the piece at a given offset live. Used by GC.
   void markLiveAt(uintX_t Offset) { LiveOffsets.insert(Offset); }
 
   // Translate an offset in the input section to an offset
   // in the output section.
   uintX_t getOffset(uintX_t Offset) const;
 
-  void finalizePieces();
+  uintX_t finalizePieces(uintX_t Offset = (uintX_t )-1);
 
   // Splittable sections are handled as a sequence of data
   // rather than a single large blob of data.
   std::vector<SectionPiece> Pieces;
 
   // Returns the SectionPiece at a given input section offset.
   SectionPiece *getSectionPiece(uintX_t Offset);
   const SectionPiece *getSectionPiece(uintX_t Offset) const;
 
 private:
   std::vector<SectionPiece> splitStrings(ArrayRef<uint8_t> A, size_t Size);
   std::vector<SectionPiece> splitNonStrings(ArrayRef<uint8_t> A, size_t Size);
 
-  llvm::DenseMap<uintX_t, uintX_t> OffsetMap;
   llvm::DenseSet<uintX_t> LiveOffsets;
 };
 
 struct EhSectionPiece : public SectionPiece {
   EhSectionPiece(size_t Off, ArrayRef<uint8_t> Data, unsigned FirstRelocation)
       : SectionPiece(Off, Data), FirstRelocation(FirstRelocation) {}
   unsigned FirstRelocation;
 };

ELF/InputSection.cpp

typename ELFT::uint MergeInputSection<ELFT>::getOffset(uintX_t Offset) const {
   const SectionPiece &Piece = *this->getSectionPiece(Offset);
   assert(Piece.Live);
   uintX_t Addend = Offset - Piece.InputOff;
   return Piece.OutputOff + Addend;
 }
 
 // Create a map from input offsets to output offsets for all section pieces.
 // It is called after finalize().
-template <class ELFT> void  MergeInputSection<ELFT>::finalizePieces() {
+template <class ELFT>
+typename ELFT::uint MergeInputSection<ELFT>::finalizePieces(uintX_t Offset) {
   OffsetMap.grow(this->Pieces.size());
+  uintX_t Size = 0;
   for (SectionPiece &Piece : this->Pieces) {
     if (!Piece.Live)
       continue;
-    if (Piece.OutputOff == size_t(-1)) {
-      // Offsets of tail-merged strings are computed lazily.
-      auto *OutSec = static_cast<MergeOutputSection<ELFT> *>(this->OutSec);
+
+    // The other case is when using linkerscript and have combination
+    // of mergeable and non-mergeable input sections in regular output section.
+    if (Piece.OutputOff == size_t(-1)) {
       ArrayRef<uint8_t> D = Piece.data();
       StringRef S((const char *)D.data(), D.size());
-      Piece.OutputOff = OutSec->getOffset(S);
+      uintX_t Off;
+      if (Offset == (uintX_t)-1)
+        Off = static_cast<MergeOutputSection<ELFT> *>(this->OutSec)->getOffset(S);
+      else
+        Off = Offset + Size;
+      Piece.OutputOff = Off;
+      Size += Piece.size();
     }
     OffsetMap[Piece.InputOff] = Piece.OutputOff;
   }
+  return Size;
+}
+
+template <class ELFT> void MergeInputSection<ELFT>::writeTo(uint8_t *Buf) {
+  for (SectionPiece &Piece : Pieces) {
+    if (Piece.OutputOff == (uintX_t)-1)
+      continue;
+    ArrayRef<uint8_t> Data = Piece.data();
+    memcpy(Buf + Piece.OutputOff, Data.data(), Data.size());
+  }
 }
 
 template <class ELFT>
 MipsReginfoInputSection<ELFT>::MipsReginfoInputSection(elf::ObjectFile<ELFT> *F,
                                                        const Elf_Shdr *Hdr)
     : InputSectionBase<ELFT>(F, Hdr, InputSectionBase<ELFT>::MipsReginfo) {
   // Initialize this->Reginfo.
   ArrayRef<uint8_t> D = this->getSectionData();

ELF/LinkerScript.h

 
 // This is a runner of the linker script.
 template <class ELFT> class LinkerScript {
   typedef typename ELFT::uint uintX_t;
 
 public:
   LinkerScript();
   ~LinkerScript();
-  void createSections(OutputSectionFactory<ELFT> &Factory);
+  void createSections();
 
   std::vector<PhdrEntry<ELFT>> createPhdrs();
   bool ignoreInterpSection();
 
   ArrayRef<uint8_t> getFiller(StringRef Name);
   Expr getLma(StringRef Name);
   bool shouldKeep(InputSectionBase<ELFT> *S);
   void assignAddresses();
   int compareSections(StringRef A, StringRef B);
   bool hasPhdrsCommands();
   uintX_t getOutputSectionSize(StringRef Name);
   uintX_t getHeaderSize();
 
   std::vector<OutputSectionBase<ELFT> *> *OutputSections;
 
 private:
   std::vector<InputSectionBase<ELFT> *>
   getInputSections(const InputSectionDescription *);
 
   void discard(OutputSectionCommand &Cmd);
 
   std::vector<InputSectionBase<ELFT> *>
   createInputSectionList(OutputSectionCommand &Cmd);
 
+  std::pair<OutputSectionBase<ELFT> *, bool>
+  createOutputSection(InputSectionBase<ELFT> *C, StringRef Name,
+                      bool AllowMergeable);
+
   // "ScriptConfig" is a bit too long, so define a short name for it.
   ScriptConfiguration &Opt = *ScriptConfig;
 
   int getSectionIndex(StringRef Name);
   std::vector<size_t> getPhdrIndices(StringRef SectionName);
   size_t getPhdrIndex(StringRef PhdrName);
 
   llvm::SpecificBumpPtrAllocator<LayoutInputSection<ELFT>> LAlloc;
 
+  std::vector<std::unique_ptr<OutputSectionBase<ELFT>>> OwningSections;
+
   uintX_t Dot;
 };
 
 // Variable template is a C++14 feature, so we can't template
 // a global variable. Use a struct to workaround.
 template <class ELFT> struct Script { static LinkerScript<ELFT> *X; };
 template <class ELFT> LinkerScript<ELFT> *Script<ELFT>::X;
 
 } // namespace elf
 } // namespace lld
 
 #endif

ELF/LinkerScript.cpp

for (const std::unique_ptr<BaseCommand> &Base : OutCmd.Commands) {
     if (Cmd->SortOuter)
       std::stable_sort(V.begin(), V.end(), getComparator<ELFT>(Cmd->SortOuter));
     Ret.insert(Ret.end(), V.begin(), V.end());
   }
   return Ret;
 }
 
 template <class ELFT>
-void LinkerScript<ELFT>::createSections(OutputSectionFactory<ELFT> &Factory) {
+std::pair<OutputSectionBase<ELFT> *, bool>
+LinkerScript<ELFT>::createOutputSection(InputSectionBase<ELFT> *C,
+                                        StringRef Name, bool AllowMergeable) {
+  typedef typename ELFT::Shdr Elf_Shdr;
+
+  OutputSectionBase<ELFT> *Sec = nullptr;
+  for (std::unique_ptr<OutputSectionBase<ELFT>> &S : OwningSections) {
+    if (S->getName() == Name)
+      return {S.get(), false};
+  }
+
+  const Elf_Shdr *H = C->getSectionHdr();
+  uintX_t Flags = H->sh_flags & ~SHF_GROUP & ~SHF_COMPRESSED;
+  uintX_t Alignment = 0;
+  unsigned Kind = C->SectionKind;
+  if (Kind == InputSectionBase<ELFT>::Merge) {
+    if (!AllowMergeable)
+      Kind = InputSectionBase<ELFT>::Regular;
+    Alignment = std::max(H->sh_addralign, H->sh_entsize);
+  }
+  uint32_t Type = H->sh_type;
+
+  bool IsNew;
+  std::tie(Sec, IsNew) =
+      allocSection<ELFT>(Kind, Name, Flags, Alignment, Type);
+  if (IsNew)
+    OwningSections.emplace_back(Sec);
+  return {Sec, IsNew};
+}
+
+template <class ELFT>
+static bool hasIncompatibles(InputSectionBase<ELFT> *Head,
+                             std::vector<InputSectionBase<ELFT> *> &Vec) {
+  uint64_t Flags = Head->getSectionHdr()->sh_flags;
+  for (InputSectionBase<ELFT> *S : Vec) {
+    if (isa<LayoutInputSection<ELFT>>(S))
+      continue;
+    if ((Flags & SHF_MERGE) != (S->getSectionHdr()->sh_flags & SHF_MERGE))
+      return true;
+  }
+  return false;
+}
+
+template <class ELFT>
+void LinkerScript<ELFT>::createSections() {
   for (const std::unique_ptr<BaseCommand> &Base1 : Opt.Commands) {
     if (auto *Cmd = dyn_cast<SymbolAssignment>(Base1.get())) {
       if (shouldDefine<ELFT>(Cmd))
         addRegular<ELFT>(Cmd);
       continue;
     }
 
     if (auto *Cmd = dyn_cast<OutputSectionCommand>(Base1.get())) {
       if (Cmd->Name == "/DISCARD/") {
         discard(*Cmd);
         continue;
       }
 
       std::vector<InputSectionBase<ELFT> *> V = createInputSectionList(*Cmd);
       InputSectionBase<ELFT> *Head = getNonLayoutSection<ELFT>(V);
       if (!Head)
         continue;
 
       OutputSectionBase<ELFT> *OutSec;
+      bool AllowMergeable = !hasIncompatibles(Head, V);
+      if (!AllowMergeable)
+        warning("SHF_MERGE flags will be ignored for " + Cmd->Name);
       bool IsNew;
-      std::tie(OutSec, IsNew) = Factory.create(Head, Cmd->Name);
+      std::tie(OutSec, IsNew) =
+          createOutputSection(Head, Cmd->Name, AllowMergeable);
       if (IsNew)
         OutputSections->push_back(OutSec);
 
       uint32_t Subalign = Cmd->SubalignExpr ? Cmd->SubalignExpr(0) : 0;
       for (InputSectionBase<ELFT> *Sec : V) {
         if (Subalign)
           Sec->Alignment = Subalign;
         if (!Sec->OutSec)
           OutSec->addSection(Sec);
       }
     }
   }
 
   // Add orphan sections.
   for (const std::unique_ptr<ObjectFile<ELFT>> &F :
        Symtab<ELFT>::X->getObjectFiles()) {
     for (InputSectionBase<ELFT> *S : F->getSections()) {
       if (isDiscarded(S) || S->OutSec)
         continue;
       OutputSectionBase<ELFT> *OutSec;
       bool IsNew;
-      std::tie(OutSec, IsNew) = Factory.create(S, getOutputSectionName(S));
+      std::tie(OutSec, IsNew) =
+          createOutputSection(S, getOutputSectionName(S), true);
       if (IsNew)
         OutputSections->push_back(OutSec);
       OutSec->addSection(S);
     }
   }
 }
 
 template <class ELFT> void assignOffsets(OutputSectionBase<ELFT> *Sec) {
   auto *OutSec = dyn_cast<OutputSection<ELFT>>(Sec);
   if (!OutSec) {
     Sec->assignOffsets();
     return;
   }
 
   typedef typename ELFT::uint uintX_t;
   uintX_t Off = 0;
 
-  for (InputSection<ELFT> *I : OutSec->Sections) {
-    if (auto *L = dyn_cast<LayoutInputSection<ELFT>>(I)) {
+  for (InputSectionBase<ELFT> *B : OutSec->Sections) {
+    if (auto *L = dyn_cast<LayoutInputSection<ELFT>>(B)) {
       uintX_t Value = L->Cmd->Expression(Sec->getVA() + Off) - Sec->getVA();
       if (L->Cmd->Name == ".") {
         Off = Value;
       } else if (auto *Sym =
                      cast_or_null<DefinedSynthetic<ELFT>>(L->Cmd->Sym)) {
         // shouldDefine could have returned false, so we need to check Sym,
         // for non-null value.
         Sym->Section = OutSec;
         Sym->Value = Value;
       }
-    } else {
+    } else if (auto *I = dyn_cast<InputSection<ELFT>>(B)) {
       Off = alignTo(Off, I->Alignment);
       I->OutSecOff = Off;
       Off += I->getSize();
+    } else {
+      Off += dyn_cast<MergeInputSection<ELFT>>(B)->finalizePieces(Off);
     }
     // Update section size inside for-loop, so that SIZEOF
     // works correctly in the case below:
     // .foo { *(.aaa) a = SIZEOF(.foo); *(.bbb) }
     Sec->setSize(Off);
   }
 }
 

ELF/OutputSections.h

 template <class ELFT> class SymbolTableSection;
 template <class ELFT> class StringTableSection;
 template <class ELFT> class EhInputSection;
 template <class ELFT> class InputSection;
 template <class ELFT> class InputSectionBase;
 template <class ELFT> class MergeInputSection;
 template <class ELFT> class MipsReginfoInputSection;
 template <class ELFT> class OutputSection;
+template <class ELFT> class OutputSectionBase;
 template <class ELFT> class ObjectFile;
 template <class ELFT> class SharedFile;
 template <class ELFT> class SharedSymbol;
 template <class ELFT> class DefinedRegular;
 
+template <class ELFT>
+std::pair<OutputSectionBase<ELFT> *, bool>
+allocSection(unsigned Kind, StringRef Name, typename ELFT::uint Flags,
+             typename ELFT::uint Alignment, uint32_t Type);
+
 // This represents a section in an output file.
 // Different sub classes represent different types of sections. Some contain
 // input sections, others are created by the linker.
 // The writer creates multiple OutputSections and assign them unique,
 // non-overlapping file offsets and VAs.
 template <class ELFT> class OutputSectionBase {
 public:
   typedef typename ELFT::uint uintX_t;
public:
   void addSection(InputSectionBase<ELFT> *C) override;
   void sortInitFini();
   void sortCtorsDtors();
   void writeTo(uint8_t *Buf) override;
   void finalize() override;
   void assignOffsets() override;
   typename Base::Kind getKind() const override { return Base::Regular; }
   static bool classof(const Base *B) { return B->getKind() == Base::Regular; }
-  std::vector<InputSection<ELFT> *> Sections;
+  std::vector<InputSectionBase<ELFT> *> Sections;
 };
 
 template <class ELFT>
 class MergeOutputSection final : public OutputSectionBase<ELFT> {
   typedef typename ELFT::uint uintX_t;
   typedef OutputSectionBase<ELFT> Base;
 
 public:

ELF/OutputSections.cpp

 
 template <class ELFT> void OutputSection<ELFT>::finalize() {
   uint32_t Type = this->Header.sh_type;
   if (Type != SHT_RELA && Type != SHT_REL)
     return;
   this->Header.sh_link = Out<ELFT>::SymTab->SectionIndex;
   // sh_info for SHT_REL[A] sections should contain the section header index of
   // the section to which the relocation applies.
-  InputSectionBase<ELFT> *S = Sections[0]->getRelocatedSection();
+  InputSectionBase<ELFT> *S =
+      dyn_cast<InputSection<ELFT>>(Sections[0])->getRelocatedSection();
   this->Header.sh_info = S->OutSec->SectionIndex;
 }
 
 template <class ELFT>
-void OutputSection<ELFT>::addSection(InputSectionBase<ELFT> *C) {
-  assert(C->Live);
-  auto *S = cast<InputSection<ELFT>>(C);
+void OutputSection<ELFT>::addSection(InputSectionBase<ELFT> *S) {
+  assert(S->Live);
   Sections.push_back(S);
   S->OutSec = this;
   this->updateAlignment(S->Alignment);
 }
 
 // If an input string is in the form of "foo.N" where N is a number,
 // return N. Otherwise, returns 65536, which is one greater than the
 // lowest priority.
 static int getPriority(StringRef S) {
   size_t Pos = S.rfind('.');
   if (Pos == StringRef::npos)
     return 65536;
   int V;
   if (S.substr(Pos + 1).getAsInteger(10, V))
     return 65536;
   return V;
 }
 
 // This function is called after we sort input sections
 // and scan relocations to setup sections' offsets.
 template <class ELFT> void OutputSection<ELFT>::assignOffsets() {
   uintX_t Off = this->Header.sh_size;
-  for (InputSection<ELFT> *S : Sections) {
+  for (InputSectionBase<ELFT> *C : Sections) {
+    InputSection<ELFT> *S = dyn_cast<InputSection<ELFT>>(C);
     Off = alignTo(Off, S->Alignment);
     S->OutSecOff = Off;
     Off += S->getSize();
   }
   this->Header.sh_size = Off;
 }
 
 // Sorts input sections by section name suffixes, so that .foo.N comes
 // before .foo.M if N < M. Used to sort .{init,fini}_array.N sections.
 // We want to keep the original order if the priorities are the same
 // because the compiler keeps the original initialization order in a
 // translation unit and we need to respect that.
 // For more detail, read the section of the GCC's manual about init_priority.
 template <class ELFT> void OutputSection<ELFT>::sortInitFini() {
   // Sort sections by priority.
   typedef std::pair<int, InputSection<ELFT> *> Pair;
   auto Comp = [](const Pair &A, const Pair &B) { return A.first < B.first; };
 
   std::vector<Pair> V;
-  for (InputSection<ELFT> *S : Sections)
+  for (InputSectionBase<ELFT> *B : Sections) {
+    auto S = dyn_cast<InputSection<ELFT>>(B);
     V.push_back({getPriority(S->getSectionName()), S});
+  }
   std::stable_sort(V.begin(), V.end(), Comp);
   Sections.clear();
   for (Pair &P : V)
     Sections.push_back(P.second);
 }
 
 // Returns true if S matches /Filename.?\.o$/.
 static bool isCrtBeginEnd(StringRef S, StringRef Filename) {

 //
 //  4. The section was contained in crtend, which contains an end marker.
 //
 // In an ideal world, we don't need this function because .init_array and
 // .ctors are duplicate features (and .init_array is newer.) However, there
 // are too many real-world use cases of .ctors, so we had no choice to
 // support that with this rather ad-hoc semantics.
 template <class ELFT>
-static bool compCtors(const InputSection<ELFT> *A,
-                      const InputSection<ELFT> *B) {
+static bool compCtors(const InputSectionBase<ELFT> *L,
+                      const InputSectionBase<ELFT> *R) {
+  auto A = dyn_cast<InputSection<ELFT>>(L);
+  auto B = dyn_cast<InputSection<ELFT>>(R);
   bool BeginA = isCrtbegin(A->getFile()->getName());
   bool BeginB = isCrtbegin(B->getFile()->getName());
   if (BeginA != BeginB)
     return BeginA;
   bool EndA = isCrtend(A->getFile()->getName());
   bool EndB = isCrtend(B->getFile()->getName());
   if (EndA != EndB)
     return EndB;

 static void fill(uint8_t *Buf, size_t Size, ArrayRef<uint8_t> A) {
   size_t I = 0;
   for (; I + A.size() < Size; I += A.size())
     memcpy(Buf + I, A.data(), A.size());
   memcpy(Buf + I, A.data(), Size - I);
 }
 
 template <class ELFT> void OutputSection<ELFT>::writeTo(uint8_t *Buf) {
+  auto WriteOne = [&](InputSectionBase<ELFT> *B) {
+    if (auto C = dyn_cast<InputSection<ELFT>>(B))
+      C->writeTo(Buf);
+    else
+      dyn_cast<MergeInputSection<ELFT>>(B)->writeTo(Buf);
+  };
+
   ArrayRef<uint8_t> Filler = Script<ELFT>::X->getFiller(this->Name);
   if (!Filler.empty())
     fill(Buf, this->getSize(), Filler);
   if (Config->Threads) {
     parallel_for_each(Sections.begin(), Sections.end(),
-                      [=](InputSection<ELFT> *C) { C->writeTo(Buf); });
+                      [=](InputSectionBase<ELFT> *B) { WriteOne(B); });
   } else {
-    for (InputSection<ELFT> *C : Sections)
-      C->writeTo(Buf);
+    for (InputSectionBase<ELFT> *B : Sections)
+      WriteOne(B);
   }
 }
 
 template <class ELFT>
 EhOutputSection<ELFT>::EhOutputSection()
     : OutputSectionBase<ELFT>(".eh_frame", SHT_PROGBITS, SHF_ALLOC) {}
 
 // Search for an existing CIE record or create a new one.
void MipsAbiFlagsOutputSection<ELFT>::addSection(InputSectionBase<ELFT> *C) {
   Flags.flags1 |= S->Flags->flags1;
   Flags.flags2 |= S->Flags->flags2;
   Flags.fp_abi = elf::getMipsFpAbiFlag(Flags.fp_abi, S->Flags->fp_abi,
                                        getFilename(S->getFile()));
 }
 
 template <class ELFT>
 std::pair<OutputSectionBase<ELFT> *, bool>
-OutputSectionFactory<ELFT>::create(InputSectionBase<ELFT> *C,
-                                   StringRef OutsecName) {
-  SectionKey<ELFT::Is64Bits> Key = createKey(C, OutsecName);
-  OutputSectionBase<ELFT> *&Sec = Map[Key];
-  if (Sec)
-    return {Sec, false};
-
-  switch (C->SectionKind) {
+elf::allocSection(unsigned Kind, StringRef Name, typename ELFT::uint Flags,
+                  typename ELFT::uint Alignment, uint32_t Type) {
+  OutputSectionBase<ELFT> *Sec;
+  switch (Kind) {
   case InputSectionBase<ELFT>::Regular:
-    Sec = new OutputSection<ELFT>(Key.Name, Key.Type, Key.Flags);
+    Sec = new OutputSection<ELFT>(Name, Type, Flags);
     break;
   case InputSectionBase<ELFT>::EHFrame:
     return {Out<ELFT>::EhFrame, false};
   case InputSectionBase<ELFT>::Merge:
-    Sec = new MergeOutputSection<ELFT>(Key.Name, Key.Type, Key.Flags,
-                                       Key.Alignment);
+    Sec = new MergeOutputSection<ELFT>(Name, Type, Flags, Alignment);
     break;
   case InputSectionBase<ELFT>::MipsReginfo:
     Sec = new MipsReginfoOutputSection<ELFT>();
     break;
   case InputSectionBase<ELFT>::MipsOptions:
     Sec = new MipsOptionsOutputSection<ELFT>();
     break;
   case InputSectionBase<ELFT>::MipsAbiFlags:
     Sec = new MipsAbiFlagsOutputSection<ELFT>();
     break;
   case InputSectionBase<ELFT>::Layout:
     llvm_unreachable("Invalid section type");
   }
-  Out<ELFT>::Pool.emplace_back(Sec);
   return {Sec, true};
 }
 
 template <class ELFT>
+std::pair<OutputSectionBase<ELFT> *, bool>
+OutputSectionFactory<ELFT>::create(InputSectionBase<ELFT> *C,
+                                   StringRef OutsecName) {
+  SectionKey<ELFT::Is64Bits> Key = createKey(C, OutsecName);
+  OutputSectionBase<ELFT> *&Sec = Map[Key];
+  if (Sec)
+    return {Sec, false};
+
+  bool Allocated;
+  std::tie(Sec, Allocated) = allocSection<ELFT>(
+      C->SectionKind, Key.Name, Key.Flags, Key.Alignment, Key.Type);
+  if (Allocated)
+    Out<ELFT>::Pool.emplace_back(Sec);
+  return {Sec, Allocated};
+}
+
+template <class ELFT>
 SectionKey<ELFT::Is64Bits>
 OutputSectionFactory<ELFT>::createKey(InputSectionBase<ELFT> *C,
                                       StringRef OutsecName) {
   const Elf_Shdr *H = C->getSectionHdr();
   uintX_t Flags = H->sh_flags & ~SHF_GROUP & ~SHF_COMPRESSED;
 
   // For SHF_MERGE we create different output sections for each alignment.
   // This makes each output section simple and keeps a single level mapping from

 template class BuildIdHexstring<ELF64BE>;
 
 template class OutputSectionFactory<ELF32LE>;
 template class OutputSectionFactory<ELF32BE>;
 template class OutputSectionFactory<ELF64LE>;
 template class OutputSectionFactory<ELF64BE>;
 }
 }
+
+template std::pair<OutputSectionBase<ELF32LE> *, bool>
+elf::allocSection(unsigned Kind, StringRef Name, ELF32LE::uint Flags,
+                  ELF32LE::uint Alignment, uint32_t Type);
+template std::pair<OutputSectionBase<ELF32BE> *, bool>
+elf::allocSection(unsigned Kind, StringRef Name, ELF32BE::uint Flags,
+                  ELF32BE::uint Alignment, uint32_t Type);
+template std::pair<OutputSectionBase<ELF64LE> *, bool>
+elf::allocSection(unsigned Kind, StringRef Name, ELF64LE::uint Flags,
+                  ELF64LE::uint Alignment, uint32_t Type);
+template std::pair<OutputSectionBase<ELF64BE> *, bool>
+elf::allocSection(unsigned Kind, StringRef Name, ELF64BE::uint Flags,
+                  ELF64BE::uint Alignment, uint32_t Type);

ELF/Writer.cpp

template <class ELFT> void Writer<ELFT>::run() {
   if (Target->NeedsThunks)
     forEachRelSec(createThunks<ELFT>);
 
   CommonInputSection<ELFT> Common(getCommonSymbols<ELFT>());
   CommonInputSection<ELFT>::X = &Common;
 
   Script<ELFT>::X->OutputSections = &OutputSections;
   if (ScriptConfig->HasContents)
-    Script<ELFT>::X->createSections(Factory);
+    Script<ELFT>::X->createSections();
   else
     createSections();
 
   finalizeSections();
   if (HasError)
     return;
 
   if (Config->Relocatable) {

test/ELF/linkerscript/linkerscript-mix-sections-gc.s

+# REQUIRES: x86
+# RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %s -o %t
+
+# RUN: echo "SECTIONS { .foo : { *(.foo.*) } }" > %t.script
+# RUN: ld.lld --gc-sections -o %t1 --script %t.script %t
+# RUN: llvm-objdump -s %t1 | FileCheck %s
+# CHECK:      Contents of section .foo:
+# CHECK-NEXT:  {{.*}} fzzzzz.
+
+.text
+.globl _start
+_start:
+ movl $s0, %eax
+ movl $s2, %eax
+
+.hidden s0
+.type s0,@object
+.section .foo.0,"aM",@progbits,1
+.globl s0
+s0:
+.asciz "foo"
+
+.hidden s1
+.type s1,@object
+.section .foo.1,"aMS",@progbits,1
+.globl s1
+s1:
+.asciz "boo"
+
+.hidden s2
+.type s2,@object
+.section .foo.2,"a"
+.globl s2
+s2:
+.asciz "zzzzz"

test/ELF/linkerscript/linkerscript-mix-sections.s

+# REQUIRES: x86
+# RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %s -o %t
+
+# RUN: echo "SECTIONS { .foo : { *(.foo.*) } }" > %t.script
+# RUN: ld.lld -o %t1 --script %t.script %t
+# RUN: llvm-objdump -s %t1 | FileCheck %s
+# CHECK:      Contents of section .foo:
+# CHECK-NEXT:  {{.*}} foo.boo.zzzzz.
+
+.text
+.globl _start
+_start:
+ nop
+
+.hidden s0
+.type s0,@object
+.section .foo.0,"aM",@progbits,1
+.globl s0
+s0:
+.asciz "foo"
+
+.hidden s1
+.type s1,@object
+.section .foo.1,"aMS",@progbits,1
+.globl s1
+s1:
+.asciz "boo"
+
+.hidden s2
+.type s2,@object
+.section .foo.2,"a"
+.globl s2
+s2:
+.asciz "zzzzz"