[Demo] of late creation of mergeable synthetic sections.

[grimar]

Summary

This is WIP demo based on top of D27415's diff2.
This creates synthetic sections later and should solve issues mentioned on D27415 thread.
It is still not ready, so here just for reference.

ELF/InputSection.h

 namespace lld {
 namespace elf {
 
 class DefinedCommon;
 class SymbolBody;
 struct SectionPiece;
 
 template <class ELFT> class DefinedRegular;
+template <class ELFT> class MergeSyntheticSection;
 template <class ELFT> class ObjectFile;
 template <class ELFT> class OutputSection;
 class OutputSectionBase;
 
 // We need non-template input section class to store symbol layout
 // in linker script parser structures, where we do not have ELFT
 // template parameter. For each scripted output section symbol we
 // store pointer to preceding InputSectionData object or nullptr,
 // if symbol should be placed at the very beginning of the output
 // section
 class InputSectionData {
 public:
-  enum Kind { Regular, EHFrame, Merge, Synthetic, };
+  enum Kind { Regular, EHFrame, Merge, Synthetic, MergeSynthetic };
 
   // The garbage collector sets sections' Live bits.
   // If GC is disabled, all sections are considered live by default.
   InputSectionData(Kind SectionKind, StringRef Name, ArrayRef<uint8_t> Data,
                    bool Live)
       : SectionKind(SectionKind), Live(Live), Assigned(false), Name(Name),
         Data(Data) {}
 
llvm::CachedHashStringRef getData(size_t I) const {
     StringRef S = {(const char *)(this->Data.data() + Begin), End - Begin};
     return {S, Hashes[I]};
   }
 
   // Returns the SectionPiece at a given input section offset.
   SectionPiece *getSectionPiece(uintX_t Offset);
   const SectionPiece *getSectionPiece(uintX_t Offset) const;
 
+  // MergeInputSections are aggregated to a synthetic input sections,
+  // and then added to an OutputSection. This pointer points to a
+  // synthetic MergeSyntheticSection which this section belongs to.
+  MergeSyntheticSection<ELFT> *MergeSec = nullptr;
+
 private:
   void splitStrings(ArrayRef<uint8_t> A, size_t Size);
   void splitNonStrings(ArrayRef<uint8_t> A, size_t Size);
 
   std::vector<uint32_t> Hashes;
 
   mutable llvm::DenseMap<uintX_t, uintX_t> OffsetMap;
   mutable std::once_flag InitOffsetMap;

ELF/InputSection.cpp

InputSectionBase<ELFT>::InputSectionBase(elf::ObjectFile<ELFT> *File,
   // We might want to relax this in the future.
   if (V > UINT32_MAX)
     fatal(toString(File) + ": section sh_addralign is too large");
   Alignment = V;
 
   // If it is not a mergeable section, overwrite the flag so that the flag
   // is consistent with the class. This inconsistency could occur when
   // string merging is disabled using -O0 flag.
-  if (!Config->Relocatable && !isa<MergeInputSection<ELFT>>(this))
+  bool IsMergeSec = isa<MergeInputSection<ELFT>>(this) ||
+                    isa<MergeSyntheticSection<ELFT>>(this);
+  if (!Config->Relocatable && !IsMergeSec)
     this->Flags &= ~(SHF_MERGE | SHF_STRINGS);
 }
 
 template <class ELFT>
 InputSectionBase<ELFT>::InputSectionBase(elf::ObjectFile<ELFT> *File,
                                          const Elf_Shdr *Hdr, StringRef Name,
                                          Kind SectionKind)
     : InputSectionBase(File, Hdr->sh_flags & ~SHF_INFO_LINK, Hdr->sh_type,
case Synthetic:
     return cast<InputSection<ELFT>>(this)->OutSecOff +
            (Offset == uintX_t(-1) ? getSize() : Offset);
   case EHFrame:
     // The file crtbeginT.o has relocations pointing to the start of an empty
     // .eh_frame that is known to be the first in the link. It does that to
     // identify the start of the output .eh_frame.
     return Offset;
   case Merge:
-    return cast<MergeInputSection<ELFT>>(this)->getOffset(Offset);
+    const MergeInputSection<ELFT> *MS = cast<MergeInputSection<ELFT>>(this);
+    return (MS->MergeSec ? MS->MergeSec->OutSecOff : 0) + MS->getOffset(Offset);
   }
   llvm_unreachable("invalid section kind");
 }
 
 // Uncompress section contents. Note that this function is called
 // from parallel_for_each, so it must be thread-safe.
 template <class ELFT> void InputSectionBase<ELFT>::uncompress() {
   Decompressor Dec = check(Decompressor::create(

 
 template <class ELFT>
 InputSection<ELFT>::InputSection(elf::ObjectFile<ELFT> *F,
                                  const Elf_Shdr *Header, StringRef Name)
     : InputSectionBase<ELFT>(F, Header, Name, Base::Regular) {}
 
 template <class ELFT>
 bool InputSection<ELFT>::classof(const InputSectionData *S) {
-  return S->kind() == Base::Regular || S->kind() == Base::Synthetic;
+  return S->kind() == Base::Regular || S->kind() == Base::Synthetic ||
+         S->kind() == Base::MergeSynthetic;
 }
 
 template <class ELFT>
 InputSectionBase<ELFT> *InputSection<ELFT>::getRelocatedSection() {
   assert(this->Type == SHT_RELA || this->Type == SHT_REL);
   ArrayRef<InputSectionBase<ELFT> *> Sections = this->File->getSections();
   return Sections[this->Info];
 }

ELF/LinkerScript.cpp

if (auto *Cmd = dyn_cast<OutputSectionCommand>(Base1.get())) {
       // is given, input sections are aligned to that value, whether the
       // given value is larger or smaller than the original section alignment.
       if (Cmd->SubalignExpr) {
         uint32_t Subalign = Cmd->SubalignExpr(0);
         for (InputSectionBase<ELFT> *S : V)
           S->Alignment = Subalign;
       }
 
+      combineMergableSections(V, true);
+
       // Add input sections to an output section.
       for (InputSectionBase<ELFT> *S : V)
         addSection(Factory, S, Cmd->Name);
     }
   }
 }
 
 // Add sections that didn't match any sections command.
 template <class ELFT>
 void LinkerScript<ELFT>::addOrphanSections(
     OutputSectionFactory<ELFT> &Factory) {
-  for (InputSectionBase<ELFT> *S : Symtab<ELFT>::X->Sections)
-    if (S->Live && !S->OutSec)
-      addSection(Factory, S, getOutputSectionName(S->Name));
+  for (InputSectionBase<ELFT> *S : Symtab<ELFT>::X->Sections) {
+    if (S->Live && !S->OutSec) {
+      std::vector<InputSectionBase<ELFT> *> V = {S};
+      combineMergableSections(V);
+      addSection(Factory, V.front(), getOutputSectionName(S->Name));
+    }
+  }
 }
 
 // Sets value of a section-defined symbol. Two kinds of
 // symbols are processed: synthetic symbols, whose value
 // is an offset from beginning of section and regular
 // symbols whose value is absolute.
 template <class ELFT>
 static void assignSectionSymbol(SymbolAssignment *Cmd,
for (InputSectionData *ID : ICmd.Sections) {
     // empty ones afterwards (because there is no way to know whether they were
     // going be empty or not other than actually running linker scripts.)
     // We need to ignore remains of empty sections.
     if (auto *Sec = dyn_cast<SyntheticSection<ELFT>>(ID))
       if (Sec->empty())
         continue;
 
     auto *IB = static_cast<InputSectionBase<ELFT> *>(ID);
-    switchTo(IB->OutSec);
+    OutputSectionBase *OutSec = IB->OutSec;
+    if (auto *MS = dyn_cast<MergeInputSection<ELFT>>(IB))
+      OutSec = MS->MergeSec->OutSec;
+
+    switchTo(OutSec);
     if (auto *I = dyn_cast<InputSection<ELFT>>(IB))
       output(I);
     else
       flush();
   }
 }
 
 template <class ELFT>

ELF/OutputSections.h

static bool classof(const OutputSectionBase *B) {
     return B->getKind() == Regular;
   }
   std::vector<InputSection<ELFT> *> Sections;
 
   // Location in the output buffer.
   uint8_t *Loc = nullptr;
 };
 
-template <class ELFT>
-class MergeOutputSection final : public OutputSectionBase {
-  typedef typename ELFT::uint uintX_t;
-
-public:
-  MergeOutputSection(StringRef Name, uint32_t Type, uintX_t Flags,
-                     uintX_t Alignment);
-  void addSection(InputSectionData *S) override;
-  void writeTo(uint8_t *Buf) override;
-  void finalize() override;
-  bool shouldTailMerge() const;
-  Kind getKind() const override { return Merge; }
-  static bool classof(const OutputSectionBase *B) {
-    return B->getKind() == Merge;
-  }
-
-private:
-  void finalizeTailMerge();
-  void finalizeNoTailMerge();
-
-  llvm::StringTableBuilder Builder;
-  std::vector<MergeInputSection<ELFT> *> Sections;
-};
-
 struct CieRecord {
   EhSectionPiece *Piece = nullptr;
   std::vector<EhSectionPiece *> FdePieces;
 };
 
 // Output section for .eh_frame.
 template <class ELFT> class EhOutputSection final : public OutputSectionBase {
   typedef typename ELFT::uint uintX_t;

ELF/OutputSections.cpp

 
 template <class ELFT>
 void OutputSection<ELFT>::addSection(InputSectionData *C) {
   assert(C->Live);
   auto *S = cast<InputSection<ELFT>>(C);
   Sections.push_back(S);
   S->OutSec = this;
   this->updateAlignment(S->Alignment);
-  // Keep sh_entsize value of the input section to be able to perform merging
-  // later during a final linking using the generated relocatable object.
-  if (Config->Relocatable && (S->Flags & SHF_MERGE))
+  // Keep sh_entsize value of the input section during relocatable output to be
+  // able to perform merging later during a final linking using the generated
+  // relocatable object. Also keep value for mergeable sections.
+  if (isa<MergeSyntheticSection<ELFT>>(C) ||
+      (Config->Relocatable && (S->Flags & SHF_MERGE)))
     this->Entsize = S->Entsize;
 }
 
 template <class ELFT>
 void OutputSection<ELFT>::forEachInputSection(
     std::function<void(InputSectionData *)> F) {
   for (InputSection<ELFT> *S : Sections)
     F(S);
for (CieRecord *Cie : Cies) {
         uintX_t FdeVA = this->Addr + Fde->OutputOff;
         In<ELFT>::EhFrameHdr->addFde(Pc, FdeVA);
       }
     }
   }
 }
 
 template <class ELFT>
-MergeOutputSection<ELFT>::MergeOutputSection(StringRef Name, uint32_t Type,
-                                             uintX_t Flags, uintX_t Alignment)
-    : OutputSectionBase(Name, Type, Flags),
-      Builder(StringTableBuilder::RAW, Alignment) {}
-
-template <class ELFT> void MergeOutputSection<ELFT>::writeTo(uint8_t *Buf) {
-  Builder.write(Buf);
-}
-
-template <class ELFT>
-void MergeOutputSection<ELFT>::addSection(InputSectionData *C) {
-  auto *Sec = cast<MergeInputSection<ELFT>>(C);
-  Sec->OutSec = this;
-  this->updateAlignment(Sec->Alignment);
-  this->Entsize = Sec->Entsize;
-  Sections.push_back(Sec);
-}
-
-template <class ELFT> bool MergeOutputSection<ELFT>::shouldTailMerge() const {
-  return (this->Flags & SHF_STRINGS) && Config->Optimize >= 2;
-}
-
-template <class ELFT> void MergeOutputSection<ELFT>::finalizeTailMerge() {
-  // Add all string pieces to the string table builder to create section
-  // contents.
-  for (MergeInputSection<ELFT> *Sec : Sections)
-    for (size_t I = 0, E = Sec->Pieces.size(); I != E; ++I)
-      if (Sec->Pieces[I].Live)
-        Builder.add(Sec->getData(I));
-
-  // Fix the string table content. After this, the contents will never change.
-  Builder.finalize();
-  this->Size = Builder.getSize();
-
-  // finalize() fixed tail-optimized strings, so we can now get
-  // offsets of strings. Get an offset for each string and save it
-  // to a corresponding StringPiece for easy access.
-  for (MergeInputSection<ELFT> *Sec : Sections)
-    for (size_t I = 0, E = Sec->Pieces.size(); I != E; ++I)
-      if (Sec->Pieces[I].Live)
-        Sec->Pieces[I].OutputOff = Builder.getOffset(Sec->getData(I));
-}
-
-template <class ELFT> void MergeOutputSection<ELFT>::finalizeNoTailMerge() {
-  // Add all string pieces to the string table builder to create section
-  // contents. Because we are not tail-optimizing, offsets of strings are
-  // fixed when they are added to the builder (string table builder contains
-  // a hash table from strings to offsets).
-  for (MergeInputSection<ELFT> *Sec : Sections)
-    for (size_t I = 0, E = Sec->Pieces.size(); I != E; ++I)
-      if (Sec->Pieces[I].Live)
-        Sec->Pieces[I].OutputOff = Builder.add(Sec->getData(I));
-
-  Builder.finalizeInOrder();
-  this->Size = Builder.getSize();
-}
-
-template <class ELFT> void MergeOutputSection<ELFT>::finalize() {
-  if (shouldTailMerge())
-    finalizeTailMerge();
-  else
-    finalizeNoTailMerge();
-}
-
-template <class ELFT>
 static typename ELFT::uint getOutFlags(InputSectionBase<ELFT> *S) {
   return S->Flags & ~SHF_GROUP & ~SHF_COMPRESSED;
 }
 
 namespace llvm {
 template <> struct DenseMapInfo<lld::elf::SectionKey> {
   static lld::elf::SectionKey getEmptyKey();
   static lld::elf::SectionKey getTombstoneKey();
static SectionKey createKey(InputSectionBase<ELFT> *C, StringRef OutsecName) {
   // SHF_MERGE sections as regular ones, but also create different output
   // sections for them to allow merging at final linking stage.
   //
   // Fortunately, creating symbols in the middle of a merge section is not
   // supported by bfd or gold, so the SHF_MERGE exception should not cause
   // problems with most linker scripts.
 
   typedef typename ELFT::uint uintX_t;
-  uintX_t Flags = C->Flags & (SHF_MERGE | SHF_STRINGS);
 
   uintX_t Alignment = 0;
-  if (isa<MergeInputSection<ELFT>>(C) ||
-      (Config->Relocatable && (C->Flags & SHF_MERGE)))
+  uintX_t Flags = 0;
+  if (Config->Relocatable && (C->Flags & SHF_MERGE)) {
     Alignment = std::max<uintX_t>(C->Alignment, C->Entsize);
+    Flags = C->Flags & (SHF_MERGE | SHF_STRINGS);
+  }
 
   return SectionKey{OutsecName, Flags, Alignment};
 }
 
 template <class ELFT> OutputSectionFactory<ELFT>::OutputSectionFactory() {}
 
 template <class ELFT> OutputSectionFactory<ELFT>::~OutputSectionFactory() {}
 
if (!IsScripted && Sec->Type != C->Type &&
         !(Sec->Type == SHT_PROGBITS && C->Type == SHT_NOBITS))
       error("Section has different type from others with the same name " +
             toString(C));
     Sec->Flags |= Flags;
     return {Sec, false};
   }
 
   uint32_t Type = C->Type;
-  switch (C->kind()) {
-  case InputSectionBase<ELFT>::Regular:
-  case InputSectionBase<ELFT>::Synthetic:
-    Sec = make<OutputSection<ELFT>>(Key.Name, Type, Flags);
-    break;
-  case InputSectionBase<ELFT>::EHFrame:
+  if (C->kind() == InputSectionBase<ELFT>::EHFrame)
     return {Out<ELFT>::EhFrame, false};
-  case InputSectionBase<ELFT>::Merge:
-    Sec = make<MergeOutputSection<ELFT>>(Key.Name, Type, Flags, Key.Alignment);
-    break;
-  }
+  Sec = make<OutputSection<ELFT>>(Key.Name, Type, Flags);
   return {Sec, true};
 }
 
 SectionKey DenseMapInfo<SectionKey>::getEmptyKey() {
   return SectionKey{DenseMapInfo<StringRef>::getEmptyKey(), 0, 0};
 }
 
 SectionKey DenseMapInfo<SectionKey>::getTombstoneKey() {

 template class OutputSection<ELF64LE>;
 template class OutputSection<ELF64BE>;
 
 template class EhOutputSection<ELF32LE>;
 template class EhOutputSection<ELF32BE>;
 template class EhOutputSection<ELF64LE>;
 template class EhOutputSection<ELF64BE>;
 
-template class MergeOutputSection<ELF32LE>;
-template class MergeOutputSection<ELF32BE>;
-template class MergeOutputSection<ELF64LE>;
-template class MergeOutputSection<ELF64BE>;
-
 template class OutputSectionFactory<ELF32LE>;
 template class OutputSectionFactory<ELF32BE>;
 template class OutputSectionFactory<ELF64LE>;
 template class OutputSectionFactory<ELF64BE>;
 }
 }

ELF/Symbols.cpp

case SymbolBody::DefinedRegularKind: {
     if (!IS)
       return D.Value;
 
     uintX_t Offset = D.Value;
     if (D.isSection()) {
       Offset += Addend;
       Addend = 0;
     }
-    uintX_t VA = (IS->OutSec ? IS->OutSec->Addr : 0) + IS->getOffset(Offset);
+
+    const OutputSectionBase *OutSec =
+        SymbolTableSection<ELFT>::getOutputSection(&Body);
+    uintX_t VA = (OutSec ? OutSec->Addr : 0) + IS->getOffset(Offset);
     if (D.isTls() && !Config->Relocatable) {
       if (!Out<ELFT>::TlsPhdr)
         fatal(toString(D.File) +
               " has a STT_TLS symbol but doesn't have a PT_TLS section");
       return VA - Out<ELFT>::TlsPhdr->p_vaddr;
     }
     return VA;
   }

ELF/SyntheticSections.h

 #include "llvm/ADT/MapVector.h"
 #include "llvm/MC/StringTableBuilder.h"
 
 namespace lld {
 namespace elf {
 
 template <class ELFT> class SyntheticSection : public InputSection<ELFT> {
   typedef typename ELFT::uint uintX_t;
+  typedef InputSectionData::Kind Kind;
 
 public:
   SyntheticSection(uintX_t Flags, uint32_t Type, uintX_t Addralign,
-                   StringRef Name)
-      : InputSection<ELFT>(Flags, Type, Addralign, ArrayRef<uint8_t>(), Name,
-                           InputSectionData::Synthetic) {
+                   StringRef Name, Kind Kind = InputSectionData::Synthetic)
+      : InputSection<ELFT>(Flags, Type, Addralign, {}, Name, Kind) {
     this->Live = true;
   }
 
   virtual ~SyntheticSection() = default;
   virtual void writeTo(uint8_t *Buf) = 0;
   virtual size_t getSize() const = 0;
   virtual void finalize() {}
   virtual bool empty() const { return false; }
 
   uintX_t getVA() const {
     return this->OutSec ? this->OutSec->Addr + this->OutSecOff : 0;
   }
 
   static bool classof(const InputSectionData *D) {
-    return D->kind() == InputSectionData::Synthetic;
+    return D->kind() == InputSectionData::Synthetic ||
+           D->kind() == InputSectionData::MergeSynthetic;
   }
 };
 
 template <class ELFT> class GotSection final : public SyntheticSection<ELFT> {
   typedef typename ELFT::uint uintX_t;
 
 public:
   GotSection();
public:
   void addGlobal(SymbolBody *Body);
   void addLocal(SymbolBody *Body);
   StringTableSection<ELFT> &getStrTabSec() const { return StrTabSec; }
   unsigned getNumSymbols() const { return Symbols.size() + 1; }
   size_t getSymbolIndex(SymbolBody *Body);
 
   ArrayRef<SymbolTableEntry> getSymbols() const { return Symbols; }
 
-  static const OutputSectionBase *getOutputSection(SymbolBody *Sym);
+  static const OutputSectionBase *getOutputSection(const SymbolBody *Sym);
 
 private:
   void writeLocalSymbols(uint8_t *&Buf);
   void writeGlobalSymbols(uint8_t *Buf);
 
   // A vector of symbols and their string table offsets.
   std::vector<SymbolTableEntry> Symbols;
 
public:
   void addSymbol(SharedSymbol<ELFT> *SS);
   void finalize() override;
   void writeTo(uint8_t *Buf) override;
   size_t getSize() const override;
   size_t getNeedNum() const { return Needed.size(); }
   bool empty() const override;
 };
 
+// MergeSyntheticSection is a class that allows us to put mergeable sections
+// with different attributes in a single output sections. To do that
+// we put them into MergeSyntheticSection synthetic input sections which are
+// attached to regular output sections.
+template <class ELFT>
+class MergeSyntheticSection final : public SyntheticSection<ELFT> {
+  typedef typename ELFT::uint uintX_t;
+
+public:
+  MergeSyntheticSection(StringRef Name, uint32_t Type, uintX_t Flags,
+                        uintX_t Alignment);
+  void addSection(MergeInputSection<ELFT> *MS);
+  void writeTo(uint8_t *Buf) override;
+  void finalize() override;
+  bool shouldTailMerge() const;
+  size_t getSize() const override;
+
+  static bool classof(const InputSectionData *D) {
+    return D->kind() == InputSectionData::MergeSynthetic;
+  }
+
+private:
+  void finalizeTailMerge();
+  void finalizeNoTailMerge();
+
+  bool Finalized = false;
+  llvm::StringTableBuilder Builder;
+  std::vector<MergeInputSection<ELFT> *> Sections;
+};
+
 // .MIPS.abiflags section.
 template <class ELFT>
 class MipsAbiFlagsSection final : public SyntheticSection<ELFT> {
   typedef llvm::object::Elf_Mips_ABIFlags<ELFT> Elf_Mips_ABIFlags;
 
 public:
   static MipsAbiFlagsSection *create();
 

 public:
   ARMExidxSentinelSection();
   size_t getSize() const override { return 8; }
   void writeTo(uint8_t *Buf) override;
 };
 
 template <class ELFT> InputSection<ELFT> *createCommonSection();
 template <class ELFT> InputSection<ELFT> *createInterpSection();
-template <class ELFT> MergeInputSection<ELFT> *createCommentSection();
+template <class ELFT> MergeSyntheticSection<ELFT> *createCommentSection();
 template <class ELFT>
 SymbolBody *
 addSyntheticLocal(StringRef Name, uint8_t Type, typename ELFT::uint Value,
                   typename ELFT::uint Size, InputSectionBase<ELFT> *Section);
 
 // Linker generated sections which can be used as inputs.
 template <class ELFT> struct In {
   static InputSection<ELFT> *ARMAttributes;

ELF/SyntheticSections.cpp

static ArrayRef<uint8_t> getVersion() {
   // +1 to include the terminating '\0'.
   return {(const uint8_t *)S.data(), S.size() + 1};
 }
 
 // Creates a .comment section containing LLD version info.
 // With this feature, you can identify LLD-generated binaries easily
 // by "objdump -s -j .comment <file>".
 // The returned object is a mergeable string section.
-template <class ELFT> MergeInputSection<ELFT> *elf::createCommentSection() {
+template <class ELFT> MergeSyntheticSection<ELFT> *elf::createCommentSection() {
   typename ELFT::Shdr Hdr = {};
   Hdr.sh_flags = SHF_MERGE | SHF_STRINGS;
   Hdr.sh_type = SHT_PROGBITS;
   Hdr.sh_entsize = 1;
   Hdr.sh_addralign = 1;
 
-  auto *Ret = make<MergeInputSection<ELFT>>(/*file=*/nullptr, &Hdr, ".comment");
-  Ret->Data = getVersion();
-  Ret->splitIntoPieces();
+  auto *MS = make<MergeInputSection<ELFT>>(/*file=*/nullptr, &Hdr, ".comment");
+  MS->Data = getVersion();
+  MS->splitIntoPieces();
+
+  auto *Ret = make<MergeSyntheticSection<ELFT>>(".comment", Hdr.sh_type,
+                                                Hdr.sh_flags, Hdr.sh_addralign);
+  Ret->addSection(MS);
   return Ret;
 }
 
 // .MIPS.abiflags section.
 template <class ELFT>
 MipsAbiFlagsSection<ELFT>::MipsAbiFlagsSection(Elf_Mips_ABIFlags Flags)
     : SyntheticSection<ELFT>(SHF_ALLOC, SHT_MIPS_ABIFLAGS, 8, ".MIPS.abiflags"),
       Flags(Flags) {}
for (auto I = Symbols.begin(); I != Symbols.begin() + NumLocals; ++I) {
     const DefinedRegular<ELFT> &Body = *cast<DefinedRegular<ELFT>>(I->Symbol);
     InputSectionBase<ELFT> *Section = Body.Section;
     auto *ESym = reinterpret_cast<Elf_Sym *>(Buf);
 
     if (!Section) {
       ESym->st_shndx = SHN_ABS;
       ESym->st_value = Body.Value;
     } else {
-      const OutputSectionBase *OutSec = Section->OutSec;
+      const OutputSectionBase *OutSec =
+          SymbolTableSection<ELFT>::getOutputSection(I->Symbol);
       ESym->st_shndx = OutSec->SectionIndex;
       ESym->st_value = OutSec->Addr + Section->getOffset(Body);
     }
     ESym->st_name = I->StrTabOffset;
     ESym->st_size = Body.template getSize<ELFT>();
     ESym->setBindingAndType(STB_LOCAL, Body.Type);
     Buf += sizeof(*ESym);
   }
if (Config->EMachine == EM_MIPS) {
       }
     }
     ++ESym;
   }
 }
 
 template <class ELFT>
 const OutputSectionBase *
-SymbolTableSection<ELFT>::getOutputSection(SymbolBody *Sym) {
+SymbolTableSection<ELFT>::getOutputSection(const SymbolBody *Sym) {
   switch (Sym->kind()) {
   case SymbolBody::DefinedSyntheticKind:
     return cast<DefinedSynthetic>(Sym)->Section;
   case SymbolBody::DefinedRegularKind: {
     auto &D = cast<DefinedRegular<ELFT>>(*Sym);
-    if (D.Section)
-      return D.Section->OutSec;
+    if (D.Section) {
+      // MergeInputSections were merged into synthetic merge sections.
+      OutputSectionBase *OutSec = D.Section->OutSec;
+      if (auto *MS = dyn_cast<MergeInputSection<ELFT>>(D.Section))
+        OutSec = MS->MergeSec ? MS->MergeSec->OutSec : nullptr;
+      return OutSec;
+    }
     break;
   }
   case SymbolBody::DefinedCommonKind:
     if (!Config->DefineCommon)
       return nullptr;
     return In<ELFT>::Common->OutSec;
   case SymbolBody::SharedKind: {
     auto &SS = cast<SharedSymbol<ELFT>>(*Sym);
template <class ELFT> size_t VersionNeedSection<ELFT>::getSize() const {
   return Size;
 }
 
 template <class ELFT> bool VersionNeedSection<ELFT>::empty() const {
   return getNeedNum() == 0;
 }
 
 template <class ELFT>
+MergeSyntheticSection<ELFT>::MergeSyntheticSection(StringRef Name,
+                                                   uint32_t Type, uintX_t Flags,
+                                                   uintX_t Alignment)
+    : SyntheticSection<ELFT>(Flags, Type, Alignment, Name,
+                             InputSectionData::MergeSynthetic),
+      Builder(StringTableBuilder::RAW, Alignment) {}
+
+template <class ELFT>
+void MergeSyntheticSection<ELFT>::addSection(MergeInputSection<ELFT> *MS) {
+  assert(!Finalized);
+  MS->MergeSec = this;
+  Sections.push_back(MS);
+  this->Entsize = MS->Entsize;
+}
+
+template <class ELFT> void MergeSyntheticSection<ELFT>::writeTo(uint8_t *Buf) {
+  Builder.write(Buf);
+}
+
+template <class ELFT>
+bool MergeSyntheticSection<ELFT>::shouldTailMerge() const {
+  return (this->Flags & SHF_STRINGS) && Config->Optimize >= 2;
+}
+
+template <class ELFT> void MergeSyntheticSection<ELFT>::finalizeTailMerge() {
+  // Add all string pieces to the string table builder to create section
+  // contents.
+  for (MergeInputSection<ELFT> *Sec : Sections)
+    for (size_t I = 0, E = Sec->Pieces.size(); I != E; ++I)
+      if (Sec->Pieces[I].Live)
+        Builder.add(Sec->getData(I));
+
+  // Fix the string table content. After this, the contents will never change.
+  Builder.finalize();
+
+  // finalize() fixed tail-optimized strings, so we can now get
+  // offsets of strings. Get an offset for each string and save it
+  // to a corresponding StringPiece for easy access.
+  for (MergeInputSection<ELFT> *Sec : Sections)
+    for (size_t I = 0, E = Sec->Pieces.size(); I != E; ++I)
+      if (Sec->Pieces[I].Live)
+        Sec->Pieces[I].OutputOff = Builder.getOffset(Sec->getData(I));
+}
+
+template <class ELFT> void MergeSyntheticSection<ELFT>::finalizeNoTailMerge() {
+  // Add all string pieces to the string table builder to create section
+  // contents. Because we are not tail-optimizing, offsets of strings are
+  // fixed when they are added to the builder (string table builder contains
+  // a hash table from strings to offsets).
+  for (MergeInputSection<ELFT> *Sec : Sections)
+    for (size_t I = 0, E = Sec->Pieces.size(); I != E; ++I)
+      if (Sec->Pieces[I].Live)
+        Sec->Pieces[I].OutputOff = Builder.add(Sec->getData(I));
+
+  Builder.finalizeInOrder();
+}
+
+template <class ELFT> void MergeSyntheticSection<ELFT>::finalize() {
+  if (Finalized)
+    return;
+  Finalized = true;
+  if (shouldTailMerge())
+    finalizeTailMerge();
+  else
+    finalizeNoTailMerge();
+}
+
+template <class ELFT> size_t MergeSyntheticSection<ELFT>::getSize() const {
+  // We should finalize string builder to know the size.
+  const_cast<MergeSyntheticSection<ELFT> *>(this)->finalize();
+  return Builder.getSize();
+}
+
+template <class ELFT>
 MipsRldMapSection<ELFT>::MipsRldMapSection()
     : SyntheticSection<ELFT>(SHF_ALLOC | SHF_WRITE, SHT_PROGBITS,
                              sizeof(typename ELFT::uint), ".rld_map") {}
 
 template <class ELFT> void MipsRldMapSection<ELFT>::writeTo(uint8_t *Buf) {
   // Apply filler from linker script.
   uint64_t Filler = Script<ELFT>::X->getFiller(this->Name);
   Filler = (Filler << 32) | Filler;

 template InputSection<ELF64LE> *elf::createCommonSection();
 template InputSection<ELF64BE> *elf::createCommonSection();
 
 template InputSection<ELF32LE> *elf::createInterpSection();
 template InputSection<ELF32BE> *elf::createInterpSection();
 template InputSection<ELF64LE> *elf::createInterpSection();
 template InputSection<ELF64BE> *elf::createInterpSection();
 
-template MergeInputSection<ELF32LE> *elf::createCommentSection();
-template MergeInputSection<ELF32BE> *elf::createCommentSection();
-template MergeInputSection<ELF64LE> *elf::createCommentSection();
-template MergeInputSection<ELF64BE> *elf::createCommentSection();
+template MergeSyntheticSection<ELF32LE> *elf::createCommentSection();
+template MergeSyntheticSection<ELF32BE> *elf::createCommentSection();
+template MergeSyntheticSection<ELF64LE> *elf::createCommentSection();
+template MergeSyntheticSection<ELF64BE> *elf::createCommentSection();
 
 template SymbolBody *
 elf::addSyntheticLocal<ELF32LE>(StringRef, uint8_t, ELF32LE::uint,
                                 ELF32LE::uint, InputSectionBase<ELF32LE> *);
 template SymbolBody *
 elf::addSyntheticLocal<ELF32BE>(StringRef, uint8_t, ELF32BE::uint,
                                 ELF32BE::uint, InputSectionBase<ELF32BE> *);
 template SymbolBody *

 template class elf::VersionNeedSection<ELF64LE>;
 template class elf::VersionNeedSection<ELF64BE>;
 
 template class elf::VersionDefinitionSection<ELF32LE>;
 template class elf::VersionDefinitionSection<ELF32BE>;
 template class elf::VersionDefinitionSection<ELF64LE>;
 template class elf::VersionDefinitionSection<ELF64BE>;
 
+template class elf::MergeSyntheticSection<ELF32LE>;
+template class elf::MergeSyntheticSection<ELF32BE>;
+template class elf::MergeSyntheticSection<ELF64LE>;
+template class elf::MergeSyntheticSection<ELF64BE>;
+
 template class elf::MipsRldMapSection<ELF32LE>;
 template class elf::MipsRldMapSection<ELF32BE>;
 template class elf::MipsRldMapSection<ELF64LE>;
 template class elf::MipsRldMapSection<ELF64BE>;
 
 template class elf::ARMExidxSentinelSection<ELF32LE>;
 template class elf::ARMExidxSentinelSection<ELF32BE>;
 template class elf::ARMExidxSentinelSection<ELF64LE>;
 template class elf::ARMExidxSentinelSection<ELF64BE>;

ELF/Writer.h

 
 llvm::StringRef getOutputSectionName(llvm::StringRef Name);
 
 template <class ELFT>
 bool allocateHeaders(std::vector<PhdrEntry> &,
                      llvm::ArrayRef<OutputSectionBase *>, uint64_t Min);
 template <class ELFT> void reportDiscarded(InputSectionBase<ELFT> *IS);
 
+template <class ELFT>
+void combineMergableSections(std::vector<InputSectionBase<ELFT> *> &V,
+                             bool IgnoreName = false);
+
 template <class ELFT> uint32_t getMipsEFlags();
 
 uint8_t getMipsFpAbiFlag(uint8_t OldFlag, uint8_t NewFlag,
                          llvm::StringRef FileName);
 
 bool isMipsN32Abi(const InputFile *F);
 }
 }
 
 #endif

ELF/Writer.cpp

auto I = std::remove_if(Phdrs.begin(), Phdrs.end(), [&](const PhdrEntry &P) {
     if (!P.First)
       return true;
     uintX_t Size = P.Last->Addr + P.Last->Size - P.First->Addr;
     return Size == 0;
   });
   Phdrs.erase(I, Phdrs.end());
 }
 
+template <class ELFT>
+static typename ELFT::uint getOutFlags(InputSectionBase<ELFT> *S) {
+  return S->Flags & ~SHF_GROUP & ~SHF_COMPRESSED;
+}
+
+// This function scans over V and creates mergeable synthetic sections. It
+// removes MergeInputSections from V and adds created synthetics to the end.
+// If IgnoreName is set, sections are created without taking Name search key in
+// account. That allows linkerscript like .foo : { *(.xxx.*) *(.yyy.*) }
+// to combine all .xxx and .yyy sections into single mergeable .foo section.
+template <class ELFT>
+void elf::combineMergableSections(std::vector<InputSectionBase<ELFT> *> &V,
+                                  bool IgnoreName) {
+  typedef typename ELFT::uint uintX_t;
+
+  std::vector<MergeSyntheticSection<ELFT> *> MergeSections;
+  auto DoMerge = [&](InputSectionBase<ELFT> *S) {
+    MergeInputSection<ELFT> *MS = dyn_cast<MergeInputSection<ELFT>>(S);
+    if (!MS)
+      return false;
+
+    // We do not want to handle sections that are not alive, so just remove
+    // them instead of trying to merge.
+    if (!MS->Live)
+      return true;
+
+    StringRef OutsecName = getOutputSectionName(MS->Name);
+    uintX_t Flags = getOutFlags(MS);
+    uintX_t Alignment = std::max<uintX_t>(MS->Alignment, MS->Entsize);
+
+    auto I =
+        llvm::find_if(MergeSections, [=](MergeSyntheticSection<ELFT> *Sec) {
+          if (!IgnoreName && Sec->Name != OutsecName)
+            return false;
+          return Sec->Flags == Flags && Sec->Alignment == Alignment;
+        });
+    if (I == MergeSections.end()) {
+      MergeSyntheticSection<ELFT> *Syn = make<MergeSyntheticSection<ELFT>>(
+          OutsecName, MS->Type, Flags, Alignment);
+      MergeSections.push_back(Syn);
+      I = std::prev(MergeSections.end());
+    }
+    (*I)->addSection(MS);
+
+    return true;
+  };
+
+  V.erase(llvm::remove_if(V, DoMerge), V.end());
+  V.insert(V.end(), MergeSections.begin(), MergeSections.end());
+}
+
 // The main function of the writer.
 template <class ELFT> void Writer<ELFT>::run() {
   // Create linker-synthesized sections such as .got or .plt.
   // Such sections are of type input section.
   createSyntheticSections();
 
   // We need to create some reserved symbols such as _end. Create them.
   if (!Config->Relocatable)
     addReservedSymbols();
 
   // Create output sections.
   Script<ELFT>::X->OutputSections = &OutputSections;
   if (ScriptConfig->HasSections) {
     // If linker script contains SECTIONS commands, let it create sections.
     Script<ELFT>::X->processCommands(Factory);
 
     // Linker scripts may have left some input sections unassigned.
     // Assign such sections using the default rule.
     Script<ELFT>::X->addOrphanSections(Factory);
   } else {
+    combineMergableSections<ELFT>(Symtab<ELFT>::X->Sections);
     // If linker script does not contain SECTIONS commands, create
     // output sections by default rules. We still need to give the
     // linker script a chance to run, because it might contain
     // non-SECTIONS commands such as ASSERT.
     createSections();
     Script<ELFT>::X->processCommands(Factory);
   }
 

 template bool elf::isRelroSection<ELF32BE>(const OutputSectionBase *);
 template bool elf::isRelroSection<ELF64LE>(const OutputSectionBase *);
 template bool elf::isRelroSection<ELF64BE>(const OutputSectionBase *);
 
 template void elf::reportDiscarded<ELF32LE>(InputSectionBase<ELF32LE> *);
 template void elf::reportDiscarded<ELF32BE>(InputSectionBase<ELF32BE> *);
 template void elf::reportDiscarded<ELF64LE>(InputSectionBase<ELF64LE> *);
 template void elf::reportDiscarded<ELF64BE>(InputSectionBase<ELF64BE> *);
+
+template void
+elf::combineMergableSections(std::vector<InputSectionBase<ELF32LE> *> &, bool);
+template void
+elf::combineMergableSections(std::vector<InputSectionBase<ELF32BE> *> &, bool);
+template void
+elf::combineMergableSections(std::vector<InputSectionBase<ELF64LE> *> &, bool);
+template void
+elf::combineMergableSections(std::vector<InputSectionBase<ELF64BE> *> &, bool);

test/ELF/comment-gc.s

 # REQUIRES: x86
 # RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %s -o %t.o
 # RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %p/Inputs/comment-gc.s -o %t2.o
 # RUN: ld.lld %t.o %t2.o -o %t1 --gc-sections -shared
 # RUN: llvm-objdump -s %t1 | FileCheck %s
 
 # CHECK:      Contents of section .comment:
-# CHECK-NEXT:  0000 00666f6f 00626172 004c4c44 20312e30 .foo.bar.LLD 1.0
+# CHECK-NEXT:  0000 4c4c4420 312e3000 00666f6f 00626172 LLD 1.0..foo.bar
 # CHECK-NEXT:  0010 00 .
 
 .ident "foo"
 
 .globl _start
 _start:
   nop

test/ELF/debug-gc.s

 # REQUIRES: x86
 # RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %s -o %t.o
 # RUN: ld.lld %t.o -o %t1 --gc-sections
 # RUN: llvm-objdump -s %t1 | FileCheck %s
 
+# CHECK:      Contents of section .debug_info:
+# CHECK-NEXT:  0000 00000000 04000000
 # CHECK:      Contents of section .debug_str:
 # CHECK-NEXT:  0000 41414100 42424200 43434300           AAA.BBB.CCC.
 # CHECK:      Contents of section .foo:
 # CHECK-NEXT:  0000 2a000000
-# CHECK:      Contents of section .debug_info:
-# CHECK-NEXT:  0000 00000000 04000000
 
 .globl _start
 _start:
 
 .section .debug_str,"MS",@progbits,1
 .Linfo_string0:
   .asciz "AAA"
 .Linfo_string1:

test/ELF/gc-merge-local-sym.s

 // RUN: llvm-mc %s -o %t.o -filetype=obj -triple=x86_64-pc-linux
 // RUN: ld.lld %t.o -o %t.so -shared -O3 --gc-sections
 // RUN: llvm-readobj -s -section-data -t %t.so | FileCheck %s
 
 // CHECK:      Name: .rodata
 // CHECK-NEXT: Type: SHT_PROGBITS
 // CHECK-NEXT: Flags [
 // CHECK-NEXT:   SHF_ALLOC
 // CHECK-NEXT:   SHF_MERGE
 // CHECK-NEXT:   SHF_STRINGS
 // CHECK-NEXT: ]
-// CHECK-NEXT: Address: 0x1C8
+// CHECK-NEXT: Address: 0x215
 // CHECK-NEXT: Offset:
 // CHECK-NEXT: Size: 4
 // CHECK-NEXT: Link: 0
 // CHECK-NEXT: Info: 0
 // CHECK-NEXT: AddressAlignment: 1
 // CHECK-NEXT: EntrySize: 1
 // CHECK-NEXT: SectionData (
 // CHECK-NEXT:   0000: 61626300 |abc.|

test/ELF/i386-merge.s

 // REQUIRES: x86
 // RUN: llvm-mc -filetype=obj -triple=i386-pc-linux %s -o %t.o
 // RUN: ld.lld %t.o -o %t -shared
 // RUN: llvm-readobj -s -section-data %t | FileCheck %s
 
 // CHECK:      Name: .mysec
 // CHECK-NEXT: Type:
 // CHECK-NEXT: Flags [
 // CHECK-NEXT:   SHF_ALLOC
 // CHECK-NEXT:   SHF_MERGE
 // CHECK-NEXT: ]
-// CHECK-NEXT: Address: 0x114
+// CHECK-NEXT: Address: 0x140
 // CHECK-NEXT: Offset:
 // CHECK-NEXT: Size:
 // CHECK-NEXT: Link:
 // CHECK-NEXT: Info:
 // CHECK-NEXT: AddressAlignment:
 // CHECK-NEXT: EntrySize:
 // CHECK-NEXT: SectionData (
 // CHECK-NEXT:   0000: 42000000 |

 // CHECK-NEXT: Address: 0x1000
 // CHECK-NEXT: Offset: 0x1000
 // CHECK-NEXT: Size: 4
 // CHECK-NEXT: Link: 0
 // CHECK-NEXT: Info: 0
 // CHECK-NEXT: AddressAlignment: 1
 // CHECK-NEXT: EntrySize: 0
 // CHECK-NEXT: SectionData (
-// CHECK-NEXT:   0000: 14010000 |
+// CHECK-NEXT:   0000: 40010000 |
 // CHECK-NEXT: )
 
-// The content of .data should be the address of .mysec. 14010000 is 0x114 in
+// The content of .data should be the address of .mysec. 40010000 is 0x140 in
 // little endian.
 
         .data
         .long .mysec+4
 
         .section        .mysec,"aM",@progbits,4
         .align  4
         .long   0x42
         .long   0x42

test/ELF/linkerscript/merge-sections.s

 # REQUIRES: x86
 # RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %s -o %t
 
 # RUN: echo "SECTIONS { \
 # RUN:   . = SIZEOF_HEADERS; \
 # RUN:   .foo : { begin = .; *(.foo.*) end = .;} \
 # RUN: }" > %t.script
 # RUN: ld.lld -o %t1 --script %t.script %t -shared
-# RUN: llvm-readobj -s -t %t1 | FileCheck %s
+# RUN: llvm-readobj -s -t %t1 | FileCheck %s --check-prefix=xxx
 
 # CHECK:        Name: .foo
 # CHECK-NEXT:   Type: SHT_PROGBITS
 # CHECK-NEXT:   Flags [
 # CHECK-NEXT:     SHF_ALLOC
 # CHECK-NEXT:     SHF_MERGE
 # CHECK-NEXT:     SHF_STRINGS
 # CHECK-NEXT:   ]

test/ELF/map-file.s

 // CHECK-NEXT: 0000000000201014 0000000000000000     4         .text
 // CHECK-NEXT: 0000000000201014 0000000000000000     4                 {{.*}}{{/|\\}}map-file.s.tmp3.o
 // CHECK-NEXT: 0000000000201014 0000000000000000     0                         bah
 // CHECK-NEXT: 0000000000201014 0000000000000001     4                 {{.*}}{{/|\\}}map-file.s.tmp4.a(map-file.s.tmp4.o)
 // CHECK-NEXT: 0000000000201014 0000000000000000     0                         baz
 // CHECK-NEXT: 0000000000202000 0000000000000004     4 .bss
 // CHECK-NEXT: 0000000000202000 0000000000000004     4         COMMON
 // CHECK-NEXT: 0000000000000000 0000000000000008     1 .comment
+// CHECK-NEXT: 0000000000000000 0000000000000008     1         .comment
 // CHECK-NEXT: 0000000000000000 00000000000000f0     8 .symtab
 // CHECK-NEXT: 0000000000000000 00000000000000f0     8         .symtab
 // CHECK-NEXT: 0000000000000000 0000000000000039     1 .shstrtab
 // CHECK-NEXT: 0000000000000000 0000000000000039     1         .shstrtab
 // CHECK-NEXT: 0000000000000000 000000000000002f     1 .strtab
 // CHECK-NEXT: 0000000000000000 000000000000002f     1         .strtab
 
 // RUN: not ld.lld %t1.o %t2.o %t3.o %t4.a -o %t -Map=/ 2>&1 \
 // RUN:  | FileCheck -check-prefix=FAIL %s
 // FAIL: cannot open /

test/ELF/merge-shared-str.s

 
 // CHECK:      Name: foo
 // CHECK-NEXT: Type: SHT_PROGBITS
 // CHECK-NEXT: Flags [
 // CHECK-NEXT:   SHF_ALLOC
 // CHECK-NEXT:   SHF_MERGE
 // CHECK-NEXT:   SHF_STRINGS
 // CHECK-NEXT: ]
-// CHECK-NEXT: Address: 0x1C8
+// CHECK-NEXT: Address: 0x210
 
 // CHECK:      Relocations [
 // CHECK-NEXT:   Section ({{.*}}) .rela.dyn {
-// CHECK-NEXT:     0x{{.*}} R_X86_64_RELATIVE - 0x1C9
+// CHECK-NEXT:     0x{{.*}} R_X86_64_RELATIVE - 0x211
 // CHECK-NEXT:   }
 // CHECK-NEXT: ]

test/ELF/merge-shared.s

 
 
 // CHECK:      Name: foo
 // CHECK-NEXT: Type: SHT_PROGBITS
 // CHECK-NEXT: Flags [
 // CHECK-NEXT:   SHF_ALLOC
 // CHECK-NEXT:   SHF_MERGE
 // CHECK-NEXT: ]
-// CHECK-NEXT: Address: 0x1C8
+// CHECK-NEXT: Address: 0x210
 
 // CHECK:      Relocations [
 // CHECK-NEXT:   Section ({{.*}}) .rela.dyn {
-// CHECK-NEXT:     0x{{.*}} R_X86_64_RELATIVE - 0x1CA
+// CHECK-NEXT:     0x{{.*}} R_X86_64_RELATIVE - 0x212
 // CHECK-NEXT:   }
 // CHECK-NEXT: ]

test/ELF/merge-string-align.s

 // CHECK-NEXT: Type: SHT_PROGBITS
 // CHECK-NEXT: Flags [
 // CHECK-NEXT:   SHF_ALLOC
 // CHECK-NEXT:   SHF_MERGE
 // CHECK-NEXT:   SHF_STRINGS
 // CHECK-NEXT: ]
 // CHECK-NEXT: Address:
 // CHECK-NEXT: Offset:
-// CHECK-NEXT: Size: 20
+// CHECK-NEXT: Size: 24
 // CHECK-NEXT: Link: 0
 // CHECK-NEXT: Info: 0
 // CHECK-NEXT: AddressAlignment: 16
 // CHECK-NEXT: EntrySize:
 // CHECK-NEXT: SectionData (
 // CHECK-NEXT:   0000:  666F6F00 00000000 00000000 00000000  |foo.............|
-// CHECK-NEXT:   0010:  62617200                             |bar.|
+// CHECK-NEXT:   0010:  62617200 666F6F00                    |bar.foo.|
 // CHECK-NEXT: )
 
         .section        .rodata.str1.1,"aMS",@progbits,1
         .asciz "foo"
-
-// CHECK:      Name: .rodata
-// CHECK-NEXT: Type: SHT_PROGBITS
-// CHECK-NEXT: Flags [
-// CHECK-NEXT:   SHF_ALLOC
-// CHECK-NEXT:   SHF_MERGE
-// CHECK-NEXT:   SHF_STRINGS
-// CHECK-NEXT: ]
-// CHECK-NEXT: Address:
-// CHECK-NEXT: Offset:
-// CHECK-NEXT: Size: 4
-// CHECK-NEXT: Link: 0
-// CHECK-NEXT: Info: 0
-// CHECK-NEXT: AddressAlignment: 1
-// CHECK-NEXT: EntrySize:
-// CHECK-NEXT: SectionData (
-// CHECK-NEXT:   0000:  666F6F00 |foo.|
-// CHECK-NEXT: )

test/ELF/merge-string.s

 
 // CHECK:      Name:    .rodata
 // CHECK-NEXT: Type:    SHT_PROGBITS
 // CHECK-NEXT: Flags [
 // CHECK-NEXT:   SHF_ALLOC
 // CHECK-NEXT:   SHF_MERGE
 // CHECK-NEXT:   SHF_STRINGS
 // CHECK-NEXT: ]
-// CHECK-NEXT: Address:         0x1C8
-// CHECK-NEXT: Offset:  0x1C8
-// CHECK-NEXT: Size:    4
+// CHECK-NEXT: Address:         0x1F2
+// CHECK-NEXT: Offset:  0x1F2
+// CHECK-NEXT: Size:    8
 // CHECK-NEXT: Link: 0
 // CHECK-NEXT: Info: 0
-// CHECK-NEXT: AddressAlignment: 1
-// CHECK-NEXT: EntrySize: 1
+// CHECK-NEXT: AddressAlignment: 2
+// CHECK-NEXT: EntrySize: 2
 // CHECK-NEXT: SectionData (
-// CHECK-NEXT:   0000: 61626300                             |abc.|
+// CHECK-NEXT:   0000: 61626300 14000000                    |abc.....|
 // CHECK-NEXT: )
 
 // NOTAIL:      Name:    .rodata
 // NOTAIL-NEXT: Type:    SHT_PROGBITS
 // NOTAIL-NEXT: Flags [
 // NOTAIL-NEXT:   SHF_ALLOC
 // NOTAIL-NEXT:   SHF_MERGE
 // NOTAIL-NEXT:   SHF_STRINGS
 // NOTAIL-NEXT: ]
-// NOTAIL-NEXT: Address:         0x1C8
-// NOTAIL-NEXT: Offset:  0x1C8
-// NOTAIL-NEXT: Size:    7
+// NOTAIL-NEXT: Address:         0x1F2
+// NOTAIL-NEXT: Offset:  0x1F2
+// NOTAIL-NEXT: Size:    12
 // NOTAIL-NEXT: Link: 0
 // NOTAIL-NEXT: Info: 0
-// NOTAIL-NEXT: AddressAlignment: 1
-// NOTAIL-NEXT: EntrySize: 1
+// NOTAIL-NEXT: AddressAlignment: 2
+// NOTAIL-NEXT: EntrySize: 2
 // NOTAIL-NEXT: SectionData (
-// NOTAIL-NEXT:   0000: 61626300 626300                     |abc.bc.|
+// NOTAIL-NEXT:   0000: 61626300 62630000 14000000           |abc.bc......|
 // NOTAIL-NEXT: )
 
 // NOMERGE:      Name:    .rodata
 // NOMERGE-NEXT: Type:    SHT_PROGBITS
 // NOMERGE-NEXT: Flags [
 // NOMERGE-NEXT:   SHF_ALLOC
 // NOMERGE-NEXT: ]
 // NOMERGE-NEXT: Address:         0x1C8
 // NOMERGE-NEXT: Offset:  0x1C8
 // NOMERGE-NEXT: Size:    16
 // NOMERGE-NEXT: Link: 0
 // NOMERGE-NEXT: Info: 0
 // NOMERGE-NEXT: AddressAlignment: 2
 // NOMERGE-NEXT: EntrySize: 0
 // NOMERGE-NEXT: SectionData (
 // NOMERGE-NEXT:   0000: 61626300 61626300 62630000 14000000  |abc.abc.bc......|
 // NOMERGE-NEXT: )
 
-// CHECK:      Name: .rodata
-// CHECK-NEXT: Type: SHT_PROGBITS
-// CHECK-NEXT: Flags [
-// CHECK-NEXT:   SHF_ALLOC
-// CHECK-NEXT:   SHF_MERGE
-// CHECK-NEXT:   SHF_STRINGS
-// CHECK-NEXT: ]
-// CHECK-NEXT: Address: 0x1CC
-// CHECK-NEXT: Offset: 0x1CC
-// CHECK-NEXT: Size: 4
-// CHECK-NEXT: Link: 0
-// CHECK-NEXT: Info: 0
-// CHECK-NEXT: AddressAlignment: 2
-// CHECK-NEXT: EntrySize: 2
-// CHECK-NEXT: SectionData (
-// CHECK-NEXT:   0000: 14000000                             |....|
-// CHECK-NEXT: )
-
-
 // CHECK:      Name:    bar
-// CHECK-NEXT: Value:   0x1C9
+// CHECK-NEXT: Value:   0x1F3
 
 // CHECK:      Name:    foo
-// CHECK-NEXT: Value:   0x1C8
+// CHECK-NEXT: Value:   0x1F2
 
 // CHECK:      Name: zed
-// CHECK-NEXT: Value: 0x1CC
+// CHECK-NEXT: Value: 0x1F6
 // CHECK-NEXT: Size: 0

test/ELF/merge-sym.s

 
 
 // CHECK:      Name: .rodata
 // CHECK-NEXT: Type: SHT_PROGBITS
 // CHECK-NEXT: Flags [
 // CHECK-NEXT:   SHF_ALLOC
 // CHECK-NEXT:   SHF_MERGE
 // CHECK-NEXT: ]
-// CHECK-NEXT: Address: 0x1C8
+// CHECK-NEXT: Address: 0x1F4
 
 // CHECK:      Name: foo
-// CHECK-NEXT: Value: 0x1CA
+// CHECK-NEXT: Value: 0x1F6

test/ELF/no-merge.s

 # REQUIRES: x86
 # RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %s -o %t.o
 # RUN: echo "SECTIONS { .data : {*(.data.*)} }" > %t0.script
 # RUN: ld.lld %t.o -o %t0.out --script %t0.script
-# RUN: llvm-objdump -s %t0.out | FileCheck %s --check-prefix=OPT
+# RUN: llvm-objdump -s %t0.out | FileCheck %s --check-prefix=OPT1
 # OPT:      Contents of section .data:
-# OPT-NEXT:   0000 01
-# OPT-NEXT: Contents of section .data:
-# OPT-NEXT:   0001 6100
-# OPT-NEXT: Contents of section .data:
-# OPT-NEXT:   0003 03
+# OPT-NEXT:   0000 61626300 abc.
 
 # RUN: ld.lld -O0 %t.o -o %t1.out --script %t0.script
-# RUN: llvm-objdump -s %t1.out | FileCheck %s --check-prefix=NOOPT
+# RUN: llvm-objdump -s %t1.out | FileCheck %s --check-prefix=NOOPT1
 # NOOPT:      Contents of section .data:
-# NOOPT-NEXT:   0000 01610003
+# NOOPT-NEXT:   0000 61626300 61626300 61626300 abc.abc.abc.
 
-.section .data.aw,"aw",@progbits
-.byte 1
+.section .data.ams1,"aMS",@progbits,1
+.asciz "abc"
 
-.section .data.ams,"aMS",@progbits,1
-.asciz "a"
+.section .data.ams2,"aMS",@progbits,1
+.asciz "abc"
 
-.section .data.am,"aM",@progbits,1
-.byte 3
+.section .data.ams3,"aMS",@progbits,1
+.asciz "abc"