[ELF] - Replace MergeOutputSection with synthetic input section MergeSection.

[grimar]

Summary

Change allows to get rid of MergeOutputSection. As a result now we can
place mergable sections with different attributes into single output section.
What is consistent to what gold/bfd do.

One of problem I faced was sh_entsize field.
Oracle documentations says:

Some sections hold a table of fixed-size entries, such as a symbol table. For such a section, this member gives the size in bytes of each entry. The member contains 0 if the section does not hold a table of fixed-size entries.

Logic implemented in this patch is to make this field to be zero.

[ruiu]

ELF/InputSection.cpp

87

How does this new condition happen?

134–135

Is there a reason to return 0? If you shouldn't call this function until an output section is set, you want to add an assert instead of returning a fake value.

ELF/OutputSections.cpp

133

This is not a right place to add this code. You want to do outside of this function. Instead of hiding this logic inside addSection, make a new function that scans Symtab<ELFT>::X->Sections vector to merge mergeable input sections into synthetic mergeable sections.

ELF/OutputSections.h

75

I do not understand why we need to care about sh_entsize of our output files. Why can't you just leave it 0?

ELF/SyntheticSections.cpp

1844–1849

nit: add a blank line between different code blocks. At first sight this looked like if ~ else if ~ else.

if (Finalize)
  return;
Finalized = true;

if (should...

[grimar]

ELF/InputSection.cpp

87

I am creating MergeSection:

MergeSection<ELFT> *Syn = 
  make<MergeSection<ELFT>>(MS->Name, MS->Type, Flags, Alignment);

And should not drop flags for it, because otherwise next condition works wrong later:

template <class ELFT> bool MergeSection<ELFT>::shouldTailMerge() const {
  return (this->Flags & SHF_STRINGS) && Config->Optimize >= 2;
}

134–135

Reason is that this lines can be called when doing rellocateNonAlloc.
When a merge section was only referenced from
non-alloca sections. Like gc-sections-non-alloc-to-merge.s test shows.

In this case MS was not Live so could not have section MergeSec.
getOffset by the way contains inside the next code to handle this:

if (!this->Live)
  return 0;

ELF/OutputSections.cpp

133

This can work for non-script case, but how would you handle linkerscript then ?

This patch already relies on fact that script calls addSection() with merge input sections.
It still creates multiple output sections for different attributes because script has own createKey(),
but OutputSection::addSection is responsible for merging all what I give it.

I tried to do the suggested change and need to fix script logic too because
it still passes MergeInputSections.

Script code for creating the list of sections is next:

std::vector<InputSectionBase<ELFT> *> V = createInputSectionList(*Cmd);

// The output section name `/DISCARD/' is special.
// Any input section assigned to it is discarded.
if (Cmd->Name == "/DISCARD/") {
  discard(V);
  continue;
}

// This is for ONLY_IF_RO and ONLY_IF_RW. An output section directive
// ".foo : ONLY_IF_R[OW] { ... }" is handled only if all member input
// sections satisfy a given constraint. If not, a directive is handled
// as if it wasn't present from the beginning.
//
// Because we'll iterate over Commands many more times, the easiest
// way to "make it as if it wasn't present" is to just remove it.
if (!matchConstraints<ELFT>(V, Cmd->Constraint)) {
  for (InputSectionBase<ELFT> *S : V)
    S->Assigned = false;
  Opt.Commands.erase(Iter);
  --I;
  continue;
}

So looks after the last block of code I can take V, create synthetic mergeable sections for sections in V if any
and update V and Symtab<ELFT>::X->Sections.

There is no way to do that once outside like for non-scripted case. And that will complicate the logic.
Do you think it is correct direction ?

ELF/OutputSections.h

75

Well, that is actually the question I wish to find answer and mentioned in description of patch.
We set sh_entsize and checked it in testcases before, when each different mergeable section was a single output.
If we can ignore it and set to 0, that makes patch a bit easier. Looking on gold output which is inconsistent,
looks that value makes no sence (if not -r elocatable).

[grimar]

ELF/OutputSections.cpp

133

So generally I do not see benefits from doing that outside of OutputSection.
Logic of "scan all sections, create new synthetic sections, remove regular mergable sections from array and do something more on a linker script side" looks more complicated that do everything incapsulated in OutputSection in a short method.

[grimar]

Rui, I applied your suggestion and now patch implements both script/non-script case. Could you look ?

• Addressed comments.

[ruiu]

ELF/InputSection.cpp

134–135

Do you mean that sections which is not marked as live are copied to the result? If so, that sounds like a bug. Anyways, adding this obscure code is not a good thing.

ELF/InputSection.h

218–220

This comment needs refinement. So, MergeInputSections are aggregated to a synthetic input section, MergeSections, and then added to an OutputSection. This pointer points to a MergeSection which this section belongs to.

ELF/LinkerScript.cpp

351

Why do you have to do this in LinkerScript.cpp? It feels something is not right. Section aggregation should happen before the control is passed to the linker script.

367

This is odd too.

ELF/OutputSections.cpp

133

I disagree. This patch adds small piece of code to many different places, and in total it is not clear how mergeable sections are handled. What we want to do to mergeable sections is, well, merging. Just merge them at one place and rest should be processed normally.

ELF/OutputSections.h

129–130

You don't need this, no?

[grimar]

ELF/LinkerScript.cpp

351

How it can be possible ?

Imagine script has:

.mergeable : { *(.aaa) *(.bbb) EXCLUDE_FILE (*file1.o) *(.ccc) }

I am able to merge them only after I have some result from createInputSectionList(), no ? Until that I don't know which sections should I combine.

367

The same. We do not know what sections are orphans until we proccess the script.

[ruiu]

ELF/LinkerScript.cpp

351

I don't think you need to handle that case.

[grimar]

ELF/LinkerScript.cpp

351

If so, do you think using elf::getOutputSectionName() for naming synthetic merge inputs for script case is ok ?

That way if .data.xxx and .data.yyy are mergeable and script has:
.data : { *(.data*) }
.only_data_xxx : { *(.data.xxx) }
.only_data_yyy : { *(.data.yyy) }
.data.xxx and .data.yyy will be combined into mergeable .data and placed into .data output section.

But according to above, we dont want to handle such cases ?
I am just asking, because see no other appropriate method except use of getOutputSectionName() on early stages then.
As leaving input sections names as is probably not an option as this kills the possible merging cases.

[ruiu]

ELF/LinkerScript.cpp

351

Essentially all input section names are mapped to output section names using getOutputSectionName, so this shouldn't be an exception.

[grimar]

ELF/LinkerScript.cpp

351

For case when we use linkerscript they dont. So doing that will break the example in my previous message.

[ruiu]

ELF/LinkerScript.cpp

367

Is that a real usage? If not, we shouldn't overthink.

[grimar]

• Addressed review comments.

ELF/InputSection.cpp

134–135

No. I mean that non-allocatable sections can have relocations against sections that are not LIve.
That happens for .debug sections often I thing.
Just please look at the gc-sections-alloc.s. or gc-sections-non-alloc-to-merge.s.

And actually we have similar pieces of code around to handle that, examples:

static typename ELFT::uint getSymVA(const SymbolBody &Body,
                                    typename ELFT::uint &Addend) {
..
uintX_t VA = (SC->OutSec ? SC->OutSec->Addr : 0) + SC->getOffset(Offset);

typename ELFT::uint MergeInputSection<ELFT>::getOffset(uintX_t Offset) const {
...
  if (!this->Live)
    return 0;

I changed that place to be more obious.

ELF/InputSection.h

218–220

Done.

ELF/OutputSections.h

129–130

Yep, removed.

[ruiu]

ELF/InputSection.cpp

134–135

But that is a bug of LLD, no? The invariant is that all relocations from live sections points to live sections. I think handling non-live sections like this is wrong -- you should fix the bug that live sections are marked as non-live instead.

[grimar]

ELF/InputSection.cpp

134–135

I do not think it is a bug. This was implemented in r282444 by Rafael.
It is fine that non-alloc debug sections can point to non-live allocatable sections I think.

[ruiu]

ELF/InputSection.cpp

134–135

I think that my point is, if a section is written to output, it should be marked as "live" whatever its type is. If non-alloc sections are copied to output unconditionally, they should be marked as "live" by default from the beginning.

Doing something "non-live sections are sometimes actually live under some condition, so handle that special case here" is not a good idea.

[ruiu]

ELF/InputSection.cpp

134

Use auto.

ELF/OutputSections.cpp

133

Can you keep the scope as narrow as possible? SS has unnecessarily large scope here. If you do this, it'll be much narrower.

if (auto *Sec = dyn_cast<...>())
  if (Sec->Mergeable)
    ...;

135

You seems to be reinventing dynamic class dispatching. Please define dyn_cast<> for MergeSection<ELFT>.

ELF/Writer.cpp

1737

Remove V.

[grimar]

• Addressed review comments.

ELF/InputSection.cpp

134

Done.

ELF/OutputSections.cpp

133

Ok, done.

135

Done.

[ruiu]

ELF/InputSection.h

43

The naming of native merge section and synthetic merge section is confusing. Here, you name synthetic merge section SyntheticMerge, but you name an instance of it MergeSection at other place. On the other hand, the section named Merge here has an instance of MergeInputSection. Naming needs to be consistent. Here is my suggestion.

Kinds:
enum Kind { Regular, EHFrame, Merge, Synthetic, MergeSynthetic };

Classes:
MergeInputSection (native)
MergeSyntheticSection (synthetic)

ELF/OutputSections.cpp

135

You don't need a static_cast.

ELF/Writer.cpp

214

Isn't this too late? I don't see a reason why we can't do this just after createSyntheticSections.

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

18

What is this change?

[grimar]

• Addressed review comments.

ELF/InputSection.h

43

Ok. Naming things was always hard for me, thanks for suggestions, I applied it.

ELF/OutputSections.cpp

135

Done.

ELF/Writer.cpp

214

Well. It not "late" but also nothing stops us to do that earlier in a single place too, did that.

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

18

Previously we had next code:

template <class ELFT>
void MergeOutputSection<ELFT>::addSection(InputSectionData *C) {
...
  this->Entsize = Sec->Entsize;
...
}

Now we dont as handle merge sections via regular.

Actually I wrote about that situation earlier :) Please look at patch description and my comment (and "fix") for one of first diff,
which was:
"Well, that is actually the question I wish to find answer and mentioned in description of patch.
We set sh_entsize and checked it in testcases before, when each different mergeable section was a single output.
If we can ignore it and set to 0, that makes patch a bit easier. Looking on gold output which is inconsistent,
looks that value makes no sence (if not -r elocatable)."

I leaved it "just 0" as was suggested by you, though I believe you supposed it was already "0" before, but it was not.
I think it is unclear what value to leave in the output. gold as far I remember just takes the first value by order when combines sections.
So it easy to face inconsistency for its output, what IMO proves that value makes no sense for output sections.
I believe we can put zero here, like this patch do.

[ruiu]

ELF/OutputSections.cpp

134

Do you really need this? This looks odd because you are handling MergeInputSection in a special way. Generally you want to avoid that as possible. If you really need this, this may be a sign that we need to fix something else.

ELF/Writer.cpp

200

As you know we usually do not pass around Symtab<ELFT>::X->Sections.

[grimar]

I found next script in linux kernel:

.rodata : {
 *(.rodata)
 *(.rodata.*)
 . = ALIGN(16);
 video_cards = .;
 *(.videocards)
 video_cards_end = .;
}

We generate video_cards == video_cards_end here, what is wrong and happens because we generate multiple .rodata*.
That what this patch had to fix, seems it is very good now justification about that we need this logic.
And I worked on a new patch basing on this one today (to have a cleaner version and to refresh it in mind).

I had a problem though:
Latest diff of this patch creates all mergeable sections early:

template <class ELFT> void Writer<ELFT>::run() {
  // Create linker-synthesized sections such as .got or .plt.
  // Such sections are of type input section.
  createSyntheticSections();
  combineMergableSections(Symtab<ELFT>::X->Sections);

So on latter steps both linkerscripted case and regular case had mergeable synthetic sections instead of regular mergable input sections.
Diff 2 of that patch did that in a different way, it did the same much later, what was more flexible.

It seems that approach of latest diff will not work. It was simple, but it is too simple to work enough good I think now.
Problem is merge-sections.s for example, which has:

.section        .foo.1a,"aMS",@progbits,1
.asciz "foo"

.section        .foo.1b,"aMS",@progbits,1
.asciz "foo"

and script:

# RUN:   .foo : { begin = .; *(.foo.*) end = .;}

Latest diff creates syntetic sections .foo.1s and .foo.1b. Then script basing on rules combines them into single .foo later.

Problem is that first and second section contain exactly one regular mergeable input section section per each.
So they keep "foo" strings separatelly. What gives us 8 bytes .foo instead of 4.
Issue is that until we parse linkerscripts we unable to create syntetic section .foo with proper name early, because we do not know
that for ".foo.1a" we should create synthetic section ".foo".

And then when we already have 2 synthetic mergeable sections .foo.1a and .foo.1b created suring script run, all we can do is place them to output,

but we can not merge them together on that step.

Diff2 on opposite created synthetic mergeable sections on linkerscript side later. What was a bit more complicated, but solved
that problem. So it took a list of regular sections, grouped mergeable together and created synthetic inputs for them. Which were added to output finally.
I think we want to have this optimization, does not ?

So I think we should return to Diff 2 approach. I am going to use it as a base, rework and upload fresh patch probably.

What do you think, Rui ?

[ruiu]

I probably do not understand what you are trying to solve.

Currently, LLD merges two mergeable input sections if they have the same name, types and section flags. But, you are saying that that is not always correct, right?

Can you briefly describe the exact semantics this patch is trying to implement, and then why you think that is the better behavior?

[grimar]

In D27415#657878, @ruiu wrote:

I probably do not understand what you are trying to solve.

Currently, LLD merges two mergeable input sections if they have the same name, types and section flags. But, you are saying that that is not always correct, right?

Can you briefly describe the exact semantics this patch is trying to implement, and then why you think that is the better behavior?

I am trying to solve issue I am demonstrating at D29217 page.
It has:

.section .aaa.1,"a"
.byte 11
.section .aaa.2,"a"
.byte 22

.section .bbb.1,"aMS",@progbits,1
.asciz "foo"
.section .bbb.2,"aMS",@progbits,1
.asciz "foo"

.section .ccc.1,"a"
.byte 33
.section .ccc.2,"a"
.byte 44

It has also symbols assignments to A and B that should mark the start/end of .ccc :

.rodata : { *(.aaa.*) *(.bbb.*) A = .; *(.ccc.*) B = .; }

1. LLD currently (clean head revision) do:

It creates 2 output .rodata sections:
.rodata (.aaa.1 .aaa.2 .ccc.1 .ccc.2)
.rodata (.bbb.1 .bbb.2)

And because of that it assigns values of A and B wrong currently. I think the cleanest way to fix is implement synthetic merge section instead of MergeOutputSection.
(this is what this patch was about, right ?)
That way output should be single .rodata section which consist of [ .aaa.1 .aaa.2, synthetic section holding <.bbb.1 and .bbb.2>, .ccc.1, .ccc.2]. And symbols will be assigned correctly then.
Output will probably be equal to bfd/gold, btw.

2. Latest diff of this patch do:

It creates synthetic sections for mergeable sections early now. Before passing them to script. After that we have next input sections available to work with on linerscript side:

[.aaa.1 .aaa.2 SynteticMergeSection(.bbb.1) SynteticMergeSection(.bbb.2) .ccc.1 .ccc.2]

Since synthetic merge sections are already created, script just places all above in a single .rodata section. We loose string merging optimization here, because have 2 pre-created SynteticMergeSections.
There is no way to merge 2 synthetic mergable sections together on this step (I do not think we want to implement this too).
And we can not create single .bbb section for holding .bbb.1 and .bbb.2 early before proccessing linkerscript commands, because we do not know it will want to put them together.

3. Patch I want to do basing on what diff2 of this patch already did:

I want to create synthetic merge sections later. For linkerscript step it should be done after script prepares input sections list to create output sections. That was done in diff2.
That way we have inputs:
[.aaa.1 .aaa.2 MergeInputSection(.bbb.1) MergeInputSection(.bbb.2) .ccc.1 .ccc.2]

Script will create single SynteticMergeSection for mergable input sections ind convert inputs to:
[.aaa.1 .aaa.2 SynteticMergeSection(.bbb.1, .bbb.2) .ccc.1 .ccc.2]

And we will end up with single .rodata with all optimizations working.

[grimar]

To be more clear D29217 show 2 different issues.

1. The main issue I am trying to solve - wrong symbols values generated in scripts like:

.rodata : {
 *(.rodata)
 *(.rodata.*)
 . = ALIGN(16);
 video_cards = .;
 *(.videocards)
 video_cards_end = .;

}

For fixing just only that case, probably latest diff of that patch should work.
Because section getOutputSectionName() returns ".rodata" name for all ".rodata*" sections. That way we will correctly apply merging
optimization because all ".rodata.aaa .rodata.bbb .rodata.ccc" will be just mapped to ".rodata". And we create single synthetic merge section.

2. Another issue is that if sections names are not those from "getOutputSectionName()". That way for example if we have 2 SHF_MERGE sections

.rodata : { *(foo.1 foo.2) } we are not able to know we should create single mergeable output section if we create them early. And that way we lose possible optimization.

I'll rebase this and probably submit alternative patch based on diff2 soon that solves second problem too.

[grimar]

• Addressed review comments.
• Rebased and performed cleanup.

This continues the review flow.

Patch that do different way (based on diff 2) is not ready yet, but available as demo here D29223.
It has very close source base, the major difference is when combineMergableSections is called.

I suggest the next thing for now: land this first as this it should help to fix the issue with script found in linux kernel.
Then we can discuss if we should fix the rest problem I mentioned earlier, which does not affect kernel for now,
but still probably worth to fix. I'll be able to update D29223 and minimize the amount of changes as well then.

ELF/OutputSections.cpp

134

When symbols are created they refer to MergeInputSection and not to synthetic merge section, created later.
I think that is fine. That piece of code simplified things a bit, though I was able to get rid of.

ELF/Writer.cpp

200

Fixed.

[grimar]

ELF/SyntheticSections.cpp

102

I did the change here to reduce amount of testcases failed.
Since comment section is converted to MergeSyntheticSection later, it is changes it's order
and brokes many testcases. To avoid that - I am creating it as merge synthetic section initially.

I know that probably not the best idea, though it is relative to what this patch do, is it ok to do ?

[grimar]

This version also does not allow .abc : { .rodata.foo .rodata.bar} .def : { .rodata.zed} to work correctly,
because .rodata created early will contain all 3 sections.

And D29223 is free of that problem as well. That is argument for switching to something like D29223,
though I think we can still land this one first as a base.

[grimar]

D29330 posted instead.

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 Compressed, bool Live)
       : SectionKind(SectionKind), Live(Live), Assigned(false),
         Compressed(Compressed), 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))
+  if (!Config->Relocatable && !isa<MergeInputSection<ELFT>>(this) &&
+      !isa<MergeSyntheticSection<ELFT>>(this))
     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:
     // The same approach is used for synthetic symbols (DefinedSynthetic).
     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);
+  case Merge: {
+    auto *MS = cast<MergeInputSection<ELFT>>(this);
+    if (!MS->Live)
+      return 0;
+    return MS->MergeSec->OutSecOff + MS->getOffset(Offset);
+  }
   }
   llvm_unreachable("invalid section kind");
 }
 
 // Returns compressed data and its size when uncompressed.
 template <class ELFT>
 std::pair<ArrayRef<uint8_t>, uint64_t>
 InputSectionBase<ELFT>::getElfCompressedData(ArrayRef<uint8_t> Data) {

 
 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

LinkerScript<ELFT>::createInputSectionList(OutputSectionCommand &OutCmd) {
   }
 
   return Ret;
 }
 
 template <class ELFT>
 static SectionKey<ELFT::Is64Bits> createKey(InputSectionBase<ELFT> *C,
                                             StringRef OutsecName) {
-  // When using linker script the merge rules are different.
-  // Unfortunately, linker scripts are name based. This means that expressions
-  // like *(.foo*) can refer to multiple input sections that would normally be
-  // placed in different output sections. We cannot put them in different
-  // output sections or we would produce wrong results for
-  // start = .; *(.foo.*) end = .; *(.bar)
-  // 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.
-
-  // An extra annoyance is that we cannot simply disable merging of the contents
-  // of SHF_MERGE sections, but our implementation requires one output section
-  // per "kind" (string or not, which size/aligment).
-  // Fortunately, creating symbols in the middle of a merge section is not
-  // supported by bfd or gold, so we can just create multiple section in that
-  // case.
   typedef typename ELFT::uint uintX_t;
-  uintX_t Flags = C->Flags & (SHF_MERGE | SHF_STRINGS);
-
+  uintX_t Flags = 0;
   uintX_t Alignment = 0;
-  if (isa<MergeInputSection<ELFT>>(C))
-    Alignment = std::max<uintX_t>(C->Alignment, C->Entsize);
-
   return SectionKey<ELFT::Is64Bits>{OutsecName, /*Type*/ 0, Flags, Alignment};
 }
 
 template <class ELFT>
 void LinkerScript<ELFT>::addSection(OutputSectionFactory<ELFT> &Factory,
                                     InputSectionBase<ELFT> *Sec,
                                     StringRef Name) {
   OutputSectionBase *OutSec;
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;
       }
 
       // 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));
 }
 
 // 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,
                                 typename ELFT::uint Value) {
   if (!Cmd->Sym)
     return;

ELF/OutputSections.h

 namespace elf {
 
 class SymbolBody;
 struct EhSectionPiece;
 template <class ELFT> class EhInputSection;
 template <class ELFT> class InputSection;
 template <class ELFT> class InputSectionBase;
 template <class ELFT> class MergeInputSection;
+template <class ELFT> class MergeSyntheticSection;
 template <class ELFT> class OutputSection;
 template <class ELFT> class ObjectFile;
 template <class ELFT> class SharedFile;
 template <class ELFT> class SharedSymbol;
 template <class ELFT> class DefinedRegular;
 
 // This represents a section in an output file.
 // Different sub classes represent different types of sections. Some contain
void updateAlignment(uint64_t Alignment) {
     if (Alignment > Addralign)
       Addralign = Alignment;
   }
 
   // If true, this section will be page aligned on disk.
   // Typically the first section of each PT_LOAD segment has this flag.
   bool PageAlign = false;
 
   // Pointer to the first section in PT_LOAD segment, which this section
   // also resides in. This field is used to correctly compute file offset
   // of a section. When two sections share the same load segment, difference
   // between their file offsets should be equal to difference between their
   // virtual addresses. To compute some section offset we use the following
   // formula: Off = Off_first + VA - VA_first.
   OutputSectionBase *FirstInPtLoad = nullptr;
 
   virtual void finalize() {}
public:
   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;
   typedef typename ELFT::Shdr Elf_Shdr;

ELF/OutputSections.cpp

template <class ELFT> void OutputSection<ELFT>::finalize() {
   // the section to which the relocation applies.
   InputSectionBase<ELFT> *S = Sections[0]->getRelocatedSection();
   this->Info = S->OutSec->SectionIndex;
 }
 
 template <class ELFT>
 void OutputSection<ELFT>::addSection(InputSectionData *C) {
   assert(C->Live);
+
+  if (auto *Sec = dyn_cast<MergeSyntheticSection<ELFT>>(C))
+    Sec->setOutputSection(this);
+
   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))
     this->Entsize = S->Entsize;
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;
 }
 
 template <class ELFT>
 static SectionKey<ELFT::Is64Bits> createKey(InputSectionBase<ELFT> *C,
                                             StringRef OutsecName) {
   typedef typename ELFT::uint uintX_t;
   uintX_t Flags = getOutFlags(C);
 
-  // For SHF_MERGE we create different output sections for each alignment.
-  // This makes each output section simple and keeps a single level mapping from
-  // input to output.
   // In case of relocatable object generation we do not try to perform merging
   // and treat SHF_MERGE sections as regular ones, but also create different
   // output sections for them to allow merging at final linking stage.
   uintX_t Alignment = 0;
-  if (isa<MergeInputSection<ELFT>>(C) ||
-      (Config->Relocatable && (C->Flags & SHF_MERGE)))
+  if (Config->Relocatable && (C->Flags & SHF_MERGE))
     Alignment = std::max<uintX_t>(C->Alignment, C->Entsize);
+  else
+    Flags &= ~(SHF_MERGE | SHF_STRINGS);
 
   return SectionKey<ELFT::Is64Bits>{OutsecName, C->Type, Flags, Alignment};
 }
 
 template <class ELFT>
 std::pair<OutputSectionBase *, bool>
 OutputSectionFactory<ELFT>::create(InputSectionBase<ELFT> *C,
                                    StringRef OutsecName) {
   SectionKey<ELFT::Is64Bits> Key = createKey(C, OutsecName);
   return create(Key, C);
 }
 
 template <class ELFT>
 std::pair<OutputSectionBase *, bool>
 OutputSectionFactory<ELFT>::create(const SectionKey<ELFT::Is64Bits> &Key,
                                    InputSectionBase<ELFT> *C) {
   uintX_t Flags = getOutFlags(C);
   OutputSectionBase *&Sec = Map[Key];
   if (Sec) {
     Sec->Flags |= Flags;
     return {Sec, false};
   }
 
+  if (C->kind() == InputSectionBase<ELFT>::EHFrame)
+    return {Out<ELFT>::EhFrame, 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:
-    return {Out<ELFT>::EhFrame, false};
-  case InputSectionBase<ELFT>::Merge:
-    Sec = make<MergeOutputSection<ELFT>>(Key.Name, Type, Flags, Key.Alignment);
-    break;
-  }
   return {Sec, true};
 }
 
 template <bool Is64Bits>
 typename lld::elf::SectionKey<Is64Bits>
 DenseMapInfo<lld::elf::SectionKey<Is64Bits>>::getEmptyKey() {
   return SectionKey<Is64Bits>{DenseMapInfo<StringRef>::getEmptyKey(), 0, 0, 0};
 }

 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/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 K = InputSectionData::Synthetic)
+      : InputSection<ELFT>(Flags, Type, Addralign, {}, Name, K) {
     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 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;
+  void setOutputSection(OutputSection<ELFT>* S);
+
+  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();
 

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() {
   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();
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);
+}
+
+template <class ELFT> void MergeSyntheticSection<ELFT>::writeTo(uint8_t *Buf) {
+  Builder.write(Buf);
+}
+
+template <class ELFT> void MergeSyntheticSection<ELFT>::finalize() {
+  if (Finalized)
+    return;
+  Finalized = true;
+
+  if (shouldTailMerge())
+    finalizeTailMerge();
+  else
+    finalizeNoTailMerge();
+}
+
+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> 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>
+void MergeSyntheticSection<ELFT>::setOutputSection(OutputSection<ELFT> *S) {
+  for (MergeInputSection<ELFT> *MS : Sections)
+    MS->OutSec = S;
+}
+
+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 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

 //===- Writer.h -------------------------------------------------*- C++ -*-===//
 //
 //                             The LLVM Linker
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLD_ELF_WRITER_H
 #define LLD_ELF_WRITER_H
 
 #include "llvm/ADT/StringRef.h"
 #include <cstdint>
 #include <memory>
+#include <vector>
 
 namespace lld {
 namespace elf {
 class InputFile;
 class OutputSectionBase;
 template <class ELFT> class InputSectionBase;
 template <class ELFT> class ObjectFile;
 template <class ELFT> class SymbolTable;
template <class ELFT> struct PhdrEntry {
   OutputSectionBase *Last = nullptr;
   bool HasLMA = false;
 };
 
 llvm::StringRef getOutputSectionName(llvm::StringRef Name);
 
 template <class ELFT> void reportDiscarded(InputSectionBase<ELFT> *IS);
 
+template <class ELFT>
+void combineMergableSections(std::vector<InputSectionBase<ELFT> *> &V);
+
 template <class ELFT> uint32_t getMipsEFlags();
 
 uint8_t getMipsFpAbiFlag(uint8_t OldFlag, uint8_t NewFlag,
                          llvm::StringRef FileName);
 
 bool isMipsN32Abi(const InputFile *F);
 std::string getErrorLocation(uint8_t *Loc);
 }
 }
 
 #endif

ELF/Writer.cpp

auto I = std::remove_if(Phdrs.begin(), Phdrs.end(), [&](const Phdr &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 array and adds new synthetic ones to the end.
+template <class ELFT>
+void elf::combineMergableSections(std::vector<InputSectionBase<ELFT> *> &V) {
+  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) {
+          return Sec->Name == OutsecName && 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();
+  combineMergableSections(Symtab<ELFT>::X->Sections);
 
   // We need to create some reserved symbols such as _end. Create them.
   if (!Config->Relocatable)
     addReservedSymbols();
 
   // Some architectures use small displacements for jump instructions.
   // It is linker's responsibility to create thunks containing long
   // jump instructions if jump targets are too far. Create thunks.
   if (Target->NeedsThunks)
     forEachRelSec(createThunks<ELFT>);
 
   // 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 {
     // If linker script does not contain SECTIONS commands, create

 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> *> &);
+template void
+elf::combineMergableSections(std::vector<InputSectionBase<ELF32BE> *> &);
+template void
+elf::combineMergableSections(std::vector<InputSectionBase<ELF64LE> *> &);
+template void
+elf::combineMergableSections(std::vector<InputSectionBase<ELF64BE> *> &);

test/ELF/basic-aarch64.s

 # CHECK-NEXT:       SHF_STRINGS (0x20)
 # CHECK-NEXT:     ]
 # CHECK-NEXT:     Address: 0x0
 # CHECK-NEXT:     Offset: 0x1000C
 # CHECK-NEXT:     Size: 8
 # CHECK-NEXT:     Link: 0
 # CHECK-NEXT:     Info: 0
 # CHECK-NEXT:     AddressAlignment: 1
-# CHECK-NEXT:     EntrySize: 1
+# CHECK-NEXT:     EntrySize:
 # CHECK-NEXT:   }
 # CHECK-NEXT:   Section {
 # CHECK-NEXT:     Index: 3
 # CHECK-NEXT:     Name: .symtab
 # CHECK-NEXT:     Type: SHT_SYMTAB (0x2)
 # CHECK-NEXT:     Flags [ (0x0)
 # CHECK-NEXT:     ]
 # CHECK-NEXT:     Address: 0x0

test/ELF/basic-mips.s

 # CHECK-NEXT:       SHF_STRINGS (0x20)
 # CHECK-NEXT:     ]
 # CHECK-NEXT:     Address: 0x0
 # CHECK-NEXT:     Offset: 0x30000
 # CHECK-NEXT:     Size: 8
 # CHECK-NEXT:     Link: 0
 # CHECK-NEXT:     Info: 0
 # CHECK-NEXT:     AddressAlignment: 1
-# CHECK-NEXT:     EntrySize: 1
+# CHECK-NEXT:     EntrySize: 0
 # CHECK-NEXT:   }
 # CHECK-NEXT:   Section {
 # CHECK-NEXT:     Index: 8
 # CHECK-NEXT:     Name: .symtab
 # CHECK-NEXT:     Type: SHT_SYMTAB (0x2)
 # CHECK-NEXT:     Flags [ (0x0)
 # CHECK-NEXT:     ]
 # CHECK-NEXT:     Address: 0x0

test/ELF/basic-ppc.s

 // CHECK-NEXT:       SHF_STRINGS (0x20)
 // CHECK-NEXT:     ]
 // CHECK-NEXT:     Address: 0x0
 // CHECK-NEXT:     Offset: 0x2030
 // CHECK-NEXT:     Size: 8
 // CHECK-NEXT:     Link: 0
 // CHECK-NEXT:     Info: 0
 // CHECK-NEXT:     AddressAlignment: 1
-// CHECK-NEXT:     EntrySize: 1
+// CHECK-NEXT:     EntrySize: 0
 // CHECK-NEXT:     SectionData (
 // CHECK-NEXT:       0000: 4C4C4420 312E3000 |LLD 1.0.|
 // CHECK-NEXT:     )
 // CHECK-NEXT:   }
 // CHECK-NEXT:   Section {
 // CHECK-NEXT:     Index: 7
 // CHECK-NEXT:     Name: .symtab
 // CHECK-NEXT:     Type: SHT_SYMTAB (0x2)

test/ELF/basic.s

 # CHECK-NEXT:       SHF_STRINGS (0x20)
 # CHECK-NEXT:     ]
 # CHECK-NEXT:     Address: 0x0
 # CHECK-NEXT:     Offset: 0x1010
 # CHECK-NEXT:     Size: 8
 # CHECK-NEXT:     Link: 0
 # CHECK-NEXT:     Info: 0
 # CHECK-NEXT:     AddressAlignment: 1
-# CHECK-NEXT:     EntrySize: 1
+# CHECK-NEXT:     EntrySize: 0
 # CHECK-NEXT:   }
 # CHECK-NEXT:   Section {
 # CHECK-NEXT:     Index: 3
 # CHECK-NEXT:     Name: .symtab
 # CHECK-NEXT:     Type: SHT_SYMTAB (0x2)
 # CHECK-NEXT:     Flags [ (0x0)
 # CHECK-NEXT:     ]
 # CHECK-NEXT:     Address: 0x0

test/ELF/basic32.s

 # CHECK-NEXT:       SHF_STRINGS (0x20)
 # CHECK-NEXT:     ]
 # CHECK-NEXT:     Address: 0x0
 # CHECK-NEXT:     Offset: 0x100C
 # CHECK-NEXT:     Size: 8
 # CHECK-NEXT:     Link: 0
 # CHECK-NEXT:     Info: 0
 # CHECK-NEXT:     AddressAlignment: 1
-# CHECK-NEXT:     EntrySize: 1
+# CHECK-NEXT:     EntrySize: 0
 # CHECK-NEXT:   }
 # CHECK-NEXT:   Section {
 # CHECK-NEXT:     Index: 3
 # CHECK-NEXT:     Name: .symtab
 # CHECK-NEXT:     Type: SHT_SYMTAB
 # CHECK-NEXT:     Flags [
 # CHECK-NEXT:     ]
 # CHECK-NEXT:     Address: 0x0

test/ELF/basic64be.s

 # CHECK-NEXT:       SHF_STRINGS (0x20)
 # CHECK-NEXT:     ]
 # CHECK-NEXT:     Address: 0x0
 # CHECK-NEXT:     Offset: 0x20058
 # CHECK-NEXT:     Size: 8
 # CHECK-NEXT:     Link: 0
 # CHECK-NEXT:     Info: 0
 # CHECK-NEXT:     AddressAlignment: 1
-# CHECK-NEXT:     EntrySize: 1
+# CHECK-NEXT:     EntrySize: 0
 # CHECK-NEXT:     SectionData (
 # CHECK-NEXT:         0000: 4C4C4420 312E3000 |LLD 1.0.|
 # CHECK-NEXT:     )
 # CHECK-NEXT:   }
 # CHECK-NEXT:   Section {
 # CHECK-NEXT:     Index: 7
 # CHECK-NEXT:     Name: .symtab
 # CHECK-NEXT:     Type: SHT_SYMTAB (0x2)

test/ELF/build-id.s

_start:
   nop
 
 .section .note.test, "a", @note
    .quad 42
 
 # DEFAULT:      Contents of section .note.test:
 # DEFAULT:      Contents of section .note.gnu.build-id:
 # DEFAULT-NEXT: 04000000 08000000 03000000 474e5500  ............GNU.
-# DEFAULT-NEXT: d08dafb4 e6294b62
+# DEFAULT-NEXT: fd36edb1 f6ff02af
 
 # MD5:      Contents of section .note.gnu.build-id:
 # MD5-NEXT: 04000000 10000000 03000000 474e5500  ............GNU.
-# MD5-NEXT: 37
+# MD5-NEXT: fc
 
 # SHA1:      Contents of section .note.gnu.build-id:
 # SHA1-NEXT: 04000000 14000000 03000000 474e5500  ............GNU.
-# SHA1-NEXT: 7a4f4eaf 69ceb948 4a7d6e51 2225e87c
+# SHA1-NEXT: 55b1eedb 03b588e1 09987d1d e9a79be7
 
 # UUID:      Contents of section .note.gnu.build-id:
 # UUID-NEXT: 04000000 10000000 03000000 474e5500  ............GNU.
 
 # HEX:      Contents of section .note.gnu.build-id:
 # HEX-NEXT: 04000000 04000000 03000000 474e5500  ............GNU.
 # HEX-NEXT: 12345678
 
 # NONE-NOT: Contents of section .note.gnu.build-id:

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: EntrySize: 0
 // CHECK-NEXT: SectionData (
 // CHECK-NEXT:   0000: 61626300 |abc.|
 // CHECK-NEXT: )
 
 // CHECK:      Symbols [
 // CHECK:        Symbol {
 // CHECK-NOT:          Name: bar
 
         .global foo
 foo:
         leaq    .L.str(%rip), %rsi
         .section        .rodata.str1.1,"aMS",@progbits,1
 .L.str:
         .asciz  "abc"
 bar:
         .asciz  "def"

test/ELF/gc-sections-merge-addend.s

 // 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: 1
+// CHECK-NEXT: EntrySize: 0
 // CHECK-NEXT: SectionData (
 // CHECK-NEXT:   0000: 62617200                    |bar.|
 // CHECK-NEXT: )
 
         .section        .data.f,"aw",@progbits
         .globl  f
 f:
         .quad .rodata.str1.1 + 4

test/ELF/gc-sections-merge-implicit-addend.s

 // 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: 1
+// CHECK-NEXT: EntrySize: 0
 // CHECK-NEXT: SectionData (
 // CHECK-NEXT:   0000: 62617200                    |bar.|
 // CHECK-NEXT: )
 
         .section        .data.f,"aw",@progbits
         .globl  f
 f:
         .long .rodata.str1.1 + 4

test/ELF/gc-sections-merge.s

 // CHECK-NEXT:   SHF_STRINGS
 // CHECK-NEXT: ]
 // CHECK-NEXT: Address:
 // CHECK-NEXT: Offset:
 // CHECK-NEXT: Size: 8
 // CHECK-NEXT: Link: 0
 // CHECK-NEXT: Info: 0
 // CHECK-NEXT: AddressAlignment: 1
-// CHECK-NEXT: EntrySize: 1
+// CHECK-NEXT: EntrySize: 0
 // CHECK-NEXT: SectionData (
 // CHECK-NEXT:   0000: 666F6F00 62617200                    |foo.bar.|
 // CHECK-NEXT: )
 
 // GC:      Name: .rodata
 // GC-NEXT: Type: SHT_PROGBITS
 // GC-NEXT: Flags [
 // GC-NEXT:   SHF_ALLOC
 // GC-NEXT:   SHF_MERGE
 // GC-NEXT:   SHF_STRINGS
 // GC-NEXT: ]
 // GC-NEXT: Address:
 // GC-NEXT: Offset:
 // GC-NEXT: Size: 4
 // GC-NEXT: Link: 0
 // GC-NEXT: Info: 0
 // GC-NEXT: AddressAlignment: 1
-// GC-NEXT: EntrySize: 1
+// GC-NEXT: EntrySize: 0
 // GC-NEXT: SectionData (
 // GC-NEXT:   0000: 666F6F00                                |foo.|
 // GC-NEXT: )
 
         .section        .text.f,"ax",@progbits
         .globl  f
 f:
         leaq    .L.str(%rip), %rax

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: 0x2000
 // CHECK-NEXT: Offset: 0x2000
 // 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/alternate-sections.s

 # REQUIRES: x86
 # RUN: llvm-mc -filetype=obj -triple=x86_64-pc-linux %s -o %t.o
 # RUN: echo "SECTIONS { abc : { *(foo) *(bar) *(zed) } }" > %t.script
 # RUN: ld.lld -o %t --script %t.script %t.o -shared
 # RUN: llvm-readobj -s -section-data %t | FileCheck %s
 
-# This test shows an oddity in lld. When a linker script alternates among
-# different types of output section in the same command, the sections are
-# reordered.
-# In this test we go from regular, to merge and back to regular. The reason
-# for the reordering is that we need two create two output sections and
-# one cannot be in the middle of another.
-# If this ever becomes a problem, some options would be:
-# * Adding an extra layer in between input section and output sections (Chunk).
-#   With that this example would have 3 chunks, but only one output section.
-#   This would unfortunately complicate the non-script case too.
-# * Just create three output sections.
-# * If having three output sections causes problem, have linkerscript specific
-#   code to write the section table and section indexes. That way we could
-#   keep 3 sections internally but not expose that.
-
-# CHECK: Name: abc
-# CHECK: 0000: 01000000 00000000 02000000 00000000  |
-# CHECK: Name: abc
-# CHECK: 0000: 61626331 323300                      |abc123.|
+# CHECK:       Section {
+# CHECK:        Index:
+# CHECK:        Name: abc
+# CHECK-NEXT:   Type: SHT_PROGBIT
+# 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:
+# CHECK-NEXT:   Link:
+# CHECK-NEXT:   Info:
+# CHECK-NEXT:   AddressAlignment:
+# CHECK-NEXT:   EntrySize:
+# CHECK-NEXT:   SectionData (
+# CHECK-NEXT:     0000: 01000000 00000000 61626331 32330002  |........abc123..|
+# CHECK-NEXT:     0010: 00000000 000000                      |.......|
+# CHECK-NEXT:   )
+# CHECK-NEXT: }
 
         .section foo, "a"
         .quad 1
 
         .section bar,"aMS",@progbits,1
         .asciz  "abc123"
 
         .section zed, "a"
         .quad 2

test/ELF/linkerscript/merge-sections.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: 0x[[ADDR1:.*]]
 # CHECK-NEXT:   Offset: 0x[[ADDR1]]
-# CHECK-NEXT:   Size: 4
-# CHECK-NEXT:   Link: 0
-# CHECK-NEXT:   Info: 0
-# CHECK-NEXT:   AddressAlignment: 1
-# CHECK-NEXT:   EntrySize: 1
-# CHECK-NEXT: }
-# CHECK-NEXT: Section {
-# CHECK-NEXT:   Index:
-# CHECK-NEXT:   Name: .foo
-# CHECK-NEXT:   Type: SHT_PROGBITS
-# CHECK-NEXT:   Flags [
-# CHECK-NEXT:     SHF_ALLOC
-# CHECK-NEXT:     SHF_MERGE
-# CHECK-NEXT:   ]
-# CHECK-NEXT:   Address: 0x
-# CHECK-NEXT:   Offset: 0x
-# CHECK-NEXT:   Size: 1
-# CHECK-NEXT:   Link: 0
-# CHECK-NEXT:   Info: 0
-# CHECK-NEXT:   AddressAlignment: 1
-# CHECK-NEXT:   EntrySize: 1
-# CHECK-NEXT: }
-# CHECK-NEXT: Section {
-# CHECK-NEXT:   Index:
-# CHECK-NEXT:   Name: .foo
-# CHECK-NEXT:   Type: SHT_PROGBITS
-# CHECK-NEXT:   Flags [
-# CHECK-NEXT:     SHF_ALLOC
-# CHECK-NEXT:     SHF_MERGE
-# CHECK-NEXT:   ]
-# CHECK-NEXT:   Address: 0x
-# CHECK-NEXT:   Offset: 0x
-# CHECK-NEXT:   Size: 2
+# CHECK-NEXT:   Size: 14
 # CHECK-NEXT:   Link: 0
 # CHECK-NEXT:   Info: 0
 # CHECK-NEXT:   AddressAlignment: 2
-# CHECK-NEXT:   EntrySize: 2
+# CHECK-NEXT:   EntrySize: 0
 # CHECK-NEXT: }
-# CHECK-NEXT: Section {
-# CHECK-NEXT:   Index:
-# CHECK-NEXT:   Name:
-# CHECK-NEXT:   Type:
-# CHECK-NEXT:   Flags [
-# CHECK-NEXT:     SHF_ALLOC
-# CHECK-NEXT:     SHF_EXECINSTR
-# CHECK-NEXT:   ]
-# CHECK-NEXT:   Address: 0x[[ADDR2:.*]]
-# CHECK-NEXT:   Offset: 0x[[ADDR2]]
-
 
 # CHECK:      Name: begin
 # CHECK-NEXT: Value: 0x[[ADDR1]]
 
 # CHECK:      Name: end
-# CHECK-NEXT: Value: 0x[[ADDR2]]
+# 0x19E = begin + sizeof(.foo) = 0x190 + 0xE
+# CHECK-NEXT: Value: 0x19E
 
 .section        .foo.1a,"aMS",@progbits,1
 .asciz "foo"
 
 .section        .foo.1b,"aMS",@progbits,1
 .asciz "foo"
 
 .section        .foo.2a,"aM",@progbits,1

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: )
+// CHECK-NOT:      Name: .rodata
+

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: 0
 // 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: 0
 // 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/merge.s

 // CHECK-NEXT:      SHF_MERGE
 // CHECK-NEXT:    ]
 // CHECK-NEXT:    Address: 0x200120
 // CHECK-NEXT:    Offset: 0x120
 // CHECK-NEXT:    Size: 8
 // CHECK-NEXT:    Link: 0
 // CHECK-NEXT:    Info: 0
 // CHECK-NEXT:    AddressAlignment: 4
-// CHECK-NEXT:    EntrySize: 4
+// CHECK-NEXT:    EntrySize: 0
 // CHECK-NEXT:    SectionData (
 // CHECK-NEXT:      0000: 10000000 42000000
 // CHECK-NEXT:    )
 
 
 // Address of the constant 0x10 = 0x200120 = 2097440
 // Address of the constant 0x42 = 0x200124 = 2097444
 

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
 # 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
 # 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"