[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

88

How does this new condition happen?

135–136

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

139

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

1691–1696

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

88

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;
}

135–136

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

139

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

139

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

135–136

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

204–206

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 ↗

(On Diff #80743)

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.

366 ↗

(On Diff #80743)

This is odd too.

ELF/OutputSections.cpp

139

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

143

You don't need this, no?

[grimar]

ELF/LinkerScript.cpp

351 ↗

(On Diff #80743)

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.

366 ↗

(On Diff #80743)

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

[ruiu]

ELF/LinkerScript.cpp

351 ↗

(On Diff #80743)

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

[grimar]

ELF/LinkerScript.cpp

351 ↗

(On Diff #80743)

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 ↗

(On Diff #80743)

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 ↗

(On Diff #80743)

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

[ruiu]

ELF/LinkerScript.cpp

366 ↗

(On Diff #80743)

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

[grimar]

• Addressed review comments.

ELF/InputSection.cpp

135–136

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

204–206

Done.

ELF/OutputSections.h

143

Yep, removed.

[ruiu]

ELF/InputSection.cpp

135–136

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

135–136

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

135–136

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

135

Use auto.

ELF/OutputSections.cpp

139

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)
    ...;

141

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

ELF/Writer.cpp

1728 ↗

(On Diff #80897)

Remove V.

[grimar]

• Addressed review comments.

ELF/InputSection.cpp

135

Done.

ELF/OutputSections.cpp

139

Ok, done.

141

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

141

You don't need a static_cast.

ELF/Writer.cpp

212 ↗

(On Diff #81574)

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 ↗

(On Diff #81574)

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

141

Done.

ELF/Writer.cpp

212 ↗

(On Diff #81574)

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 ↗

(On Diff #81574)

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

140

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 ↗

(On Diff #81727)

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

140

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 ↗

(On Diff #81727)

Fixed.

[grimar]

ELF/SyntheticSections.cpp

103

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 MergeSection;
 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, };
 
   // 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) {}
 
public:
   // rather than a single large blob of data.
   std::vector<SectionPiece> Pieces;
   llvm::CachedHashStringRef getData(size_t Idx) const;
 
   // Returns the SectionPiece at a given input section offset.
   SectionPiece *getSectionPiece(uintX_t Offset);
   const SectionPiece *getSectionPiece(uintX_t Offset) const;
 
+  // Mergeable input sections with different attributes are placed to
+  // synthetic sections which are parts of regular output section.
+  // That way we can emit a single output section at the end.
+  MergeSection<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<MergeSection<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: {
+    const MergeInputSection<ELFT> *MS = cast<MergeInputSection<ELFT>>(this);
+    return MS->MergeSec ? MS->MergeSec->OutSecOff + MS->getOffset(Offset) : 0;
+  }
   }
   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) {

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 MergeSection;
 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
public:
 
   uint32_t getPhdrFlags() const;
 
   void updateAlignment(uint64_t Alignment) {
     if (Alignment > Addralign)
       Addralign = Alignment;
   }
 
+  // Some sections hold a table of fixed-size entries, though we
+  // can merge sections with different sh_entsize. In this way we set
+  // sh_entsize to 0 in the output because in this case section does
+  // not hold a table of fixed-size entries.
+  void updateEntsize(uint64_t Size) {
+    if (!Size || Entsize == (uint64_t)-1)
+      return;
+    if (Entsize && Entsize != Size)
+      Entsize = (uint64_t)-1;
+    else
+      Entsize = Size;
+  }
+
   // 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
public:
   Kind getKind() const override { return Regular; }
   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;
+  std::vector<MergeSection<ELFT> *> MergeSections;
 };
 
 struct CieRecord {
   EhSectionPiece *Piece = nullptr;
   std::vector<EhSectionPiece *> FdePieces;
 };
 
 // Output section for .eh_frame.

ELF/OutputSections.cpp

if ((this->Flags & SHF_LINK_ORDER) && !this->Sections.empty()) {
     // We must preserve the link order dependency of sections with the
     // SHF_LINK_ORDER flag. The dependency is indicated by the sh_link field. We
     // need to translate the InputSection sh_link to the OutputSection sh_link,
     // all InputSections in the OutputSection have the same dependency.
     if (auto *D = this->Sections.front()->getLinkOrderDep())
       this->Link = D->OutSec->SectionIndex;
   }
 
+  // This can happen if we join several mergeable sections with different
+  // sh_entsize. In this case output section does not hold a table of
+  // fixed-size enties and we set sh_entsize to zero.
+  if (this->Entsize == (uint64_t)-1)
+    this->Entsize = 0;
+
   uint32_t Type = this->Type;
   if (!Config->Relocatable || (Type != SHT_RELA && Type != SHT_REL))
     return;
 
   this->Link = In<ELFT>::SymTab->OutSec->SectionIndex;
   // sh_info for SHT_REL[A] sections should contain the section header index of
   // the section to which the relocation applies.
   InputSectionBase<ELFT> *S = Sections[0]->getRelocatedSection();
   this->Info = S->OutSec->SectionIndex;
 }
 
 template <class ELFT>
 void OutputSection<ELFT>::addSection(InputSectionData *C) {
   assert(C->Live);
+
+  // If we add mergable input section we might want to create or
+  // use existing synthetic MergeSection for each input section group.
+  // Sections are grouped by attributes.
+  if (isa<MergeInputSection<ELFT>>(C)) {
+    auto *MS = cast<MergeInputSection<ELFT>>(C);
+    uintX_t Flags = getOutFlags(MS);
+    uintX_t Alignment = std::max<uintX_t>(MS->Alignment, MS->Entsize);
+
+    auto I = llvm::find_if(MergeSections, [=](MergeSection<ELFT> *MS) {
+      return MS->Flags == Flags && MS->Alignment == Alignment;
+    });
+    if (I == MergeSections.end()) {
+      MergeSection<ELFT> *Syn =
+          make<MergeSection<ELFT>>(MS->Name, MS->Type, Flags, Alignment);
+      Sections.push_back(Syn);
+      MergeSections.push_back(Syn);
+      I = std::prev(MergeSections.end());
+    }
+    (*I)->addSection(MS, this);
+    this->updateAlignment(Alignment);
+    this->updateEntsize(MS->Entsize);
+    return;
+  }
+
   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

 //===- SyntheticSection.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_SYNTHETIC_SECTION_H
 #define LLD_ELF_SYNTHETIC_SECTION_H
 
 #include "GdbIndex.h"
 #include "InputSection.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;
 
 public:
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;
 };
 
+// MergeSection 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 MergeSection synthetic input sections which are
+// attached to regular output sections.
+template <class ELFT> class MergeSection final : public SyntheticSection<ELFT> {
+  typedef typename ELFT::uint uintX_t;
+
+public:
+  MergeSection(StringRef Name, uint32_t Type, uintX_t Flags, uintX_t Alignment);
+  void addSection(MergeInputSection<ELFT> *MS, OutputSection<ELFT> *OutSec);
+  void writeTo(uint8_t *Buf) override;
+  void finalize() override;
+  bool shouldTailMerge() const;
+  size_t getSize() const override;
+
+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>
+MergeSection<ELFT>::MergeSection(StringRef Name, uint32_t Type, uintX_t Flags,
+                                 uintX_t Alignment)
+    : SyntheticSection<ELFT>(Flags, Type, Alignment, Name),
+      Builder(StringTableBuilder::RAW, Alignment) {}
+
+template <class ELFT>
+void MergeSection<ELFT>::addSection(MergeInputSection<ELFT> *MS,
+                                    OutputSection<ELFT> *OutSec) {
+  assert(!Finalized);
+  MS->OutSec = OutSec;
+  MS->MergeSec = this;
+  Sections.push_back(MS);
+}
+
+template <class ELFT> void MergeSection<ELFT>::writeTo(uint8_t *Buf) {
+  Builder.write(Buf);
+}
+
+template <class ELFT> void MergeSection<ELFT>::finalize() {
+  if (Finalized)
+    return;
+  if (shouldTailMerge())
+    finalizeTailMerge();
+  else
+    finalizeNoTailMerge();
+  Finalized = true;
+}
+
+template <class ELFT> bool MergeSection<ELFT>::shouldTailMerge() const {
+  return (this->Flags & SHF_STRINGS) && Config->Optimize >= 2;
+}
+
+template <class ELFT> void MergeSection<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 MergeSection<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 MergeSection<ELFT>::getSize() const {
+  // We should finalize string builder to know the size.
+  const_cast<MergeSection<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 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::MergeSection<ELF32LE>;
+template class elf::MergeSection<ELF32BE>;
+template class elf::MergeSection<ELF64LE>;
+template class elf::MergeSection<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>;

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-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: 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: 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:      Name:    foo
 // CHECK-NEXT: Value:   0x1C8
 
 // CHECK:      Name: zed
 // CHECK-NEXT: Value: 0x1CC
 // CHECK-NEXT: Size: 0