Mere SHF_STRING

[• rafael]

Summary

This as another early patch FYI.

The main issues with this one is the use of llvm::StringTableBuilder. It assumes a specific string format and we have to hack around it. It is also fairly slow.

With this patch the size of clang goes from 87499552 to 77160296, but the link time goes from 0.527103515 to 1.072978416.

Gold produces a binary that is 64589560 bytes long in 1.099916754 seconds.

I will try to code a more efficient StringTableBuilder and optimize offset lookups.

[ruiu]

Do we have a balance tree or trie in LLVM? Is there any other good data structure to find common string prefix quickly?

Adding strings to the merge section in string length order (insert longer strings first) would help?

ELF/InputSection.cpp

181

I think we really don't have to support SHF_MERGE string section whose entry size is not 1 because almost all string literals are in ASCII or in UTF-8.

[• rafael]

Implemented some optimizations:

• Implements in llvm (git pull)
• Store the start point of each string in the input section.
• Cache the output offset.

Since the string case with this also works for regular merge data, use it there too.

I am doing a new clang build with this and will post the results shortly.

[• rafael]

I am doing a new clang build with this and will post the results shortly.

This time including --gc-sections (since it is already on master):

• gold 77092528 bytes, 1.591897178 seconds
• master 84991536 bytes, 0.501578306 seconds
• patch 74723056 bytes, 0.734235534 seconds

Cheers,
Rafael

[ruiu]

ELF/InputSection.h

83

Do we need this class? This class seems to provide only this member function, getOffset(). I'd be tempted to squash the class hierarchy by removing this.

ELF/OutputSections.cpp

760–763

You can use std::all_of if you like.

ELF/OutputSections.h

255

Do you really need this cache? StringTableBuilder now provides a map from stringRef to its offset in the section, so this seems to be redundant.

[• rafael]

ELF/OutputSections.h

255

Good question.

This is in MergeOutputSection, which handles non string cases, so it is currently not a cache.

It might be possible to view non string merging as a special case of string merging since strings are what take most of the time. Let me give that a try.

[• rafael]

Do you really need this cache? StringTableBuilder now provides a map from stringRef to its offset in the section, so this seems to be redundant.

Good question.

This is in MergeOutputSection, which handles non string cases, so it is currently not a cache.

It might be possible to view non string merging as a special case of string merging since strings are what take most of the time. Let me give that a try.

Unfortunately the existing StringTableBuilder assumes null
termination, so we can't use it as a general case. I did implement a
more general solution when trying to optimize it. I will give it a
try.

On your question on needing MergeInputSectionBase: I think I need it.
It holds the Offsets vector on which we binary search.

Cheers,
Rafael

[• rafael]

Rebased and use std::all_of

[• rafael]

Comment at: ELF/InputSection.cpp:166
@@ +165,3 @@
+
+static size_t findNull(StringRef S, unsigned EntSize) {

+ for (unsigned I = 0, N = S.size(); I != N; I += EntSize) {

I think we really don't have to support SHF_MERGE string section whose entry size is not 1 because almost all string literals are in ASCII or in UTF-8.

They do show up. When linking clang the sizes/times I get now are

gold: 77092512 1.584946846
master: 87482424 0.491110448
merge str 1: 77213816 0.658822729
merge all str: 77209848 0.656403298

All I had to do to get good performance when merging all strings was
add one special case. Uploading the patch.

Cheers,
Rafael

[• rafael]

Optimize the common case of strings of size 1.

[ruiu]

ELF/InputSection.cpp

134

Please add a comment saying that this function translates an offset in this input merged section to an offset in an output section.

142

It's nice to write a comment here to describe what this code is doing. As I understand, Offsets is a sorted list of starting offsets of all entries, so we first do binary search on that list to find the start and end positions of an entry that contains a given Offset, and then find that entry from the output section. Result is cached.

158

Why don't you use dyn_cast here?

162

and cast<>?

[• rafael]

This uses fewer classes and makes tail merging optional, controlled by -O2 or higher (this is the same option that gold uses).

The flip side is that this depends on a new llvm class (I will upload it to another code review).

[• rafael]

The new numbers are

gold -O1: 78213512 bytes, 1.454525942 seconds
gold -O2: 77092512 bytes, 1.583773470 seconds
master: 87482424 bytes, 0.494621872 seconds
patch -O1: 77295864 bytes, 0.563764220 seconds
patch -O2: 77209848 bytes, 0.657637513 seconds

[hfinkel]

Hi Rafael,

In my experience, people rarely use linker optimizations that are not on by default. As I recall, nether GCC nor Clang pass -O<n> through to the linker. Is it time to change that?

Thanks again,
Hal

• Original Message -----

From: "Rafael Ávila de Espíndola via llvm-commits" <[e-mail]>
To: [e-mail]
Cc: [e-mail]
Sent: Friday, October 23, 2015 3:52:15 PM
Subject: Re: [PATCH] D13958: Mere SHF_STRING

rafael updated this revision to Diff 38260.
rafael added a comment.

This uses fewer classes and makes tail merging optional, controlled
by -O2 or higher (this is the same option that gold uses).

The flip side is that this depends on a new llvm class (I will upload
it to another code review).

http://reviews.llvm.org/D13958

Files:

ELF/InputFiles.cpp
ELF/InputSection.cpp
ELF/InputSection.h
ELF/OutputSections.cpp
ELF/OutputSections.h
test/elf2/merge-string-align.s
test/elf2/merge-string-error.s
test/elf2/merge-string-no-null.s
test/elf2/merge-string.s

---

llvm-commits mailing list
[e-mail]
http://lists.llvm.org/cgi-bin/mailman/listinfo/llvm-commits

[• rafael]

OK, I think this version finally has it all:

• Shares code for the string and non string case, reducing the patch and code size.
• Tail merging is optional, using the same flag (-O2) as gold.
• Work with llvm trunk.
• More comments.

[ruiu]

Generally looks good, but can you add a few comments as I pointed out in the previous review?

ELF/OutputSections.cpp

720–728

This path should work for !shouldTailMerge() too, no?

[Bigcheese]

ELF/InputFiles.cpp

125

I dislike the name of this function. SectionType seems to indicate the SHT_* values. getSectionKind would be fine.

[• rafael]

ELF/OutputSections.cpp

720–728

No, the buffer is only created during finalize.

[• rafael]

More comments, change getSectionType to return a bool and rename it.

I think this covers all the requests.

[ruiu]

LGTM

[Eugene.Zelenko]

Committed in r251212.

ELF/InputFiles.cpp

ObjectFile<ELFT>::getShtGroupEntries(const Elf_Shdr &Sec) {
   error(EntriesOrErr.getError());
   ArrayRef<GroupEntryType> Entries = *EntriesOrErr;
   if (Entries.empty() || Entries[0] != GRP_COMDAT)
     error("Unsupported SHT_GROUP format");
   return Entries.slice(1);
 }
 
 template <class ELFT>
+static bool shouldMerge(const typename ELFFile<ELFT>::Elf_Shdr &Sec) {
+  typedef typename ELFFile<ELFT>::uintX_t uintX_t;
+  uintX_t Flags = Sec.sh_flags;
+  if (!(Flags & SHF_MERGE))
+    return false;
+  if (Flags & SHF_WRITE)
+    error("Writable SHF_MERGE sections are not supported");
+  uintX_t EntSize = Sec.sh_entsize;
+  if (Sec.sh_size % EntSize)
+    error("SHF_MERGE section size must be a multiple of sh_entsize");
+
+  // Don't try to merge if the aligment is larger than the sh_entsize.
+  //
+  // If this is not a SHF_STRINGS, we would need to pad after every entity. It
+  // would be equivalent for the producer of the .o to just set a larger
+  // sh_entsize.
+  //
+  // If this is a SHF_STRINGS, the larger alignment makes sense. Unfortunately
+  // it would complicate tail merging. This doesn't seem that common to
+  // justify the effort.
+  if (Sec.sh_addralign > EntSize)
+    return false;
+
+  return true;
+}
+
+template <class ELFT>
 void elf2::ObjectFile<ELFT>::initializeSections(DenseSet<StringRef> &Comdats) {
   uint64_t Size = this->ELFObj.getNumSections();
   Sections.resize(Size);
   unsigned I = -1;
   const ELFFile<ELFT> &Obj = this->ELFObj;
   for (const Elf_Shdr &Sec : Obj.sections()) {
     ++I;
     if (Sections[I] == &InputSection<ELFT>::Discarded)
case SHT_REL: {
       if (!RelocatedSection)
         error("Unsupported relocation reference");
       if (auto *S = dyn_cast<InputSection<ELFT>>(RelocatedSection))
         S->RelocSections.push_back(&Sec);
       else
         error("Relocations pointing to SHF_MERGE are not supported");
       break;
     }
-    default: {
-      uintX_t Flags = Sec.sh_flags;
-      if (Flags & SHF_MERGE && !(Flags & SHF_STRINGS)) {
-        if (Flags & SHF_WRITE)
-          error("Writable SHF_MERGE sections are not supported");
+    default:
+      if (shouldMerge<ELFT>(Sec))
         Sections[I] = new (this->Alloc) MergeInputSection<ELFT>(this, &Sec);
-      } else {
+      else
         Sections[I] = new (this->Alloc) InputSection<ELFT>(this, &Sec);
-      }
       break;
     }
-    }
-  }
-}
 
 template <class ELFT> void elf2::ObjectFile<ELFT>::initializeSymbols() {
   this->initStringTable();
   Elf_Sym_Range Syms = this->getNonLocalSymbols();
   uint32_t NumSymbols = std::distance(Syms.begin(), Syms.end());
   this->SymbolBodies.reserve(NumSymbols);
   for (const Elf_Sym &Sym : Syms)
     this->SymbolBodies.push_back(createSymbolBody(this->StringTable, &Sym));

ELF/InputSection.h

 // This corresponds to a SHF_MERGE section of an input file.
 template <class ELFT> class MergeInputSection : public InputSectionBase<ELFT> {
   typedef InputSectionBase<ELFT> Base;
   typedef typename llvm::object::ELFFile<ELFT>::uintX_t uintX_t;
   typedef typename llvm::object::ELFFile<ELFT>::Elf_Sym Elf_Sym;
   typedef typename llvm::object::ELFFile<ELFT>::Elf_Shdr Elf_Shdr;
 
 public:
+  std::vector<std::pair<uintX_t, uintX_t>> Offsets;
   MergeInputSection(ObjectFile<ELFT> *F, const Elf_Shdr *Header);
   static bool classof(const InputSectionBase<ELFT> *S);
+  // Translate an offset in the input section to an offset in the output
+  // section.
   uintX_t getOffset(uintX_t Offset);
 };
 
 // This corresponds to a non SHF_MERGE section of an input file.
 template <class ELFT> class InputSection : public InputSectionBase<ELFT> {
   typedef InputSectionBase<ELFT> Base;
   typedef typename llvm::object::ELFFile<ELFT>::Elf_Shdr Elf_Shdr;
   typedef typename llvm::object::ELFFile<ELFT>::Elf_Rela Elf_Rela;

ELF/InputSection.cpp

MergeInputSection<ELFT>::MergeInputSection(ObjectFile<ELFT> *F,
                                            const Elf_Shdr *Header)
     : InputSectionBase<ELFT>(F, Header, Base::Merge) {}
 
 template <class ELFT>
 bool MergeInputSection<ELFT>::classof(const InputSectionBase<ELFT> *S) {
   return S->SectionKind == Base::Merge;
 }
 
-// FIXME: Optimize this by keeping an offset for each element.
 template <class ELFT>
 typename MergeInputSection<ELFT>::uintX_t
 MergeInputSection<ELFT>::getOffset(uintX_t Offset) {
-  ArrayRef<uint8_t> Data = this->getSectionData();
-  uintX_t EntSize = this->Header->sh_entsize;
-  uintX_t Addend = Offset % EntSize;
-  Offset -= Addend;
-  if (Offset + EntSize > Data.size())
+  ArrayRef<uint8_t> D = this->getSectionData();
+  StringRef Data((char *)D.data(), D.size());
+  uintX_t Size = Data.size();
+  if (Offset >= Size)
     error("Entry is past the end of the section");
-  Data = Data.slice(Offset, EntSize);
-  return static_cast<MergeOutputSection<ELFT> *>(this->OutSec)
-             ->getOffset(Data) +
-         Addend;
+
+  // Find the element this offset points to.
+  auto I = std::upper_bound(
+      this->Offsets.begin(), this->Offsets.end(), Offset,
+      [](const uintX_t &A, const std::pair<uintX_t, uintX_t> &B) {
+        return A < B.first;
+      });
+  size_t End = I == this->Offsets.end() ? Data.size() : I->first;
+  --I;
+  uintX_t Start = I->first;
+
+  // Compute the Addend and if the Base is cached, return.
+  uintX_t Addend = Offset - Start;
+  uintX_t &Base = I->second;
+  if (Base != uintX_t(-1))
+    return Base + Addend;
+
+  // Map the base to the offset in the output section and cashe it.
+  StringRef Entry = Data.substr(Start, End - Start);
+  Base =
+      static_cast<MergeOutputSection<ELFT> *>(this->OutSec)->getOffset(Entry);
+  return Base + Addend;
 }
 
 namespace lld {
 namespace elf2 {
 template class InputSectionBase<object::ELF32LE>;
 template class InputSectionBase<object::ELF32BE>;
 template class InputSectionBase<object::ELF64LE>;
 template class InputSectionBase<object::ELF64BE>;
 
 template class InputSection<object::ELF32LE>;
 template class InputSection<object::ELF32BE>;
 template class InputSection<object::ELF64LE>;
 template class InputSection<object::ELF64BE>;
 
 template class MergeInputSection<object::ELF32LE>;
 template class MergeInputSection<object::ELF32BE>;
 template class MergeInputSection<object::ELF64LE>;
 template class MergeInputSection<object::ELF64BE>;
 }
 }

ELF/OutputSections.h

 private:
   std::vector<InputSection<ELFT> *> Sections;
 };
 
 template <class ELFT>
 class MergeOutputSection final : public OutputSectionBase<ELFT> {
   typedef typename OutputSectionBase<ELFT>::uintX_t uintX_t;
 
+  bool shouldTailMerge() const;
+
 public:
   MergeOutputSection(StringRef Name, uint32_t sh_type, uintX_t sh_flags);
   void addSection(MergeInputSection<ELFT> *S);
   void writeTo(uint8_t *Buf) override;
-
-  unsigned getOffset(ArrayRef<uint8_t> Val);
+  unsigned getOffset(StringRef Val);
+  void finalize() override;
 
 private:
-  // This map is used to find if we already have an entry for a given value and,
-  // if so, at what offset it is.
-  llvm::MapVector<ArrayRef<uint8_t>, uintX_t> Offsets;
+  llvm::StringTableBuilder Builder{llvm::StringTableBuilder::RAW};
 };
 
 template <class ELFT>
 class InterpSection final : public OutputSectionBase<ELFT> {
 public:
   InterpSection();
   void writeTo(uint8_t *Buf);
 };
 

ELF/OutputSections.cpp

 }
 
 template <class ELFT>
 MergeOutputSection<ELFT>::MergeOutputSection(StringRef Name, uint32_t sh_type,
                                              uintX_t sh_flags)
     : OutputSectionBase<ELFT>(Name, sh_type, sh_flags) {}
 
 template <class ELFT> void MergeOutputSection<ELFT>::writeTo(uint8_t *Buf) {
-  for (const std::pair<ArrayRef<uint8_t>, uintX_t> &P : Offsets) {
-    ArrayRef<uint8_t> Data = P.first;
+  if (shouldTailMerge()) {
+    StringRef Data = Builder.data();
     memcpy(Buf, Data.data(), Data.size());
-    Buf += Data.size();
+    return;
+  }
+  for (const std::pair<StringRef, size_t> &P : Builder.getMap()) {
+    StringRef Data = P.first;
+    memcpy(Buf + P.second, Data.data(), Data.size());
+  }
+}
+
+static size_t findNull(StringRef S, size_t EntSize) {
+  // Optimize the common case.
+  if (EntSize == 1)
+    return S.find(0);
+
+  for (unsigned I = 0, N = S.size(); I != N; I += EntSize) {
+    const char *B = S.begin() + I;
+    if (std::all_of(B, B + EntSize, [](char C) { return C == 0; }))
+      return I;
   }
+  return StringRef::npos;
 }
 
 template <class ELFT>
 void MergeOutputSection<ELFT>::addSection(MergeInputSection<ELFT> *S) {
   S->OutSec = this;
   uint32_t Align = S->getAlign();
   if (Align > this->Header.sh_addralign)
     this->Header.sh_addralign = Align;
 
-  uintX_t Off = this->Header.sh_size;
-  ArrayRef<uint8_t> Data = S->getSectionData();
+  ArrayRef<uint8_t> D = S->getSectionData();
+  StringRef Data((char *)D.data(), D.size());
   uintX_t EntSize = S->getSectionHdr()->sh_entsize;
-  if (Data.size() % EntSize)
-    error("SHF_MERGE section size must be a multiple of sh_entsize");
+  uintX_t Offset = 0;
+
+  if (this->Header.sh_flags & SHF_STRINGS) {
+    while (!Data.empty()) {
+      size_t End = findNull(Data, EntSize);
+      if (End == StringRef::npos)
+        error("String is not null terminated");
+      StringRef Entry = Data.substr(0, End + EntSize);
+      size_t OutputOffset = Builder.add(Entry);
+      if (shouldTailMerge())
+        OutputOffset = -1;
+      S->Offsets.push_back(std::make_pair(Offset, OutputOffset));
+      uintX_t Size = End + EntSize;
+      Data = Data.substr(Size);
+      Offset += Size;
+    }
+  } else {
     for (unsigned I = 0, N = Data.size(); I != N; I += EntSize) {
-    auto P = Offsets.insert(std::make_pair(Data.slice(I, EntSize), Off));
-    if (P.second)
-      Off += EntSize;
+      StringRef Entry = Data.substr(I, EntSize);
+      size_t OutputOffset = Builder.add(Entry);
+      S->Offsets.push_back(std::make_pair(Offset, OutputOffset));
+      Offset += EntSize;
+    }
   }
-  this->Header.sh_size = Off;
 }
 
 template <class ELFT>
-unsigned MergeOutputSection<ELFT>::getOffset(ArrayRef<uint8_t> Val) {
-  return Offsets.find(Val)->second;
+unsigned MergeOutputSection<ELFT>::getOffset(StringRef Val) {
+  return Builder.getOffset(Val);
+}
+
+template <class ELFT> bool MergeOutputSection<ELFT>::shouldTailMerge() const {
+  return Config->Optimize >= 2 && this->Header.sh_flags & SHF_STRINGS;
+}
+
+template <class ELFT> void MergeOutputSection<ELFT>::finalize() {
+  if (shouldTailMerge())
+    Builder.finalize();
+  this->Header.sh_size = Builder.getSize();
 }
 
 template <class ELFT>
 StringTableSection<ELFT>::StringTableSection(StringRef Name, bool Dynamic)
     : OutputSectionBase<ELFT>(Name, llvm::ELF::SHT_STRTAB,
                               Dynamic ? (uintX_t)llvm::ELF::SHF_ALLOC : 0),
       Dynamic(Dynamic) {
   this->Header.sh_addralign = 1;

test/elf2/merge-string-align.s

+// REQUIRES: x86
+// RUN: llvm-mc -filetype=obj -triple=x86_64-pc-linux %s -o %t.o
+// RUN: ld.lld2 %t.o -o %t.so -shared
+// RUN: llvm-readobj -s %t.so | FileCheck %s
+
+        .section        .rodata.str1.16,"aMS",@progbits,1
+        .align  16
+        .asciz "foo"
+
+        .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: 0x120
+// CHECK-NEXT: Offset: 0x120
+// CHECK-NEXT: Size: 4
+// CHECK-NEXT: Link: 0
+// CHECK-NEXT: Info: 0
+// CHECK-NEXT: AddressAlignment: 16
+
+// 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: 0x124
+// CHECK-NEXT: Offset: 0x124
+// CHECK-NEXT: Size: 4
+// CHECK-NEXT: Link: 0
+// CHECK-NEXT: Info: 0
+// CHECK-NEXT: AddressAlignment: 1

test/elf2/merge-string-error.s

+// REQUIRES: x86
+// RUN: llvm-mc -filetype=obj -triple=x86_64-pc-linux %s -o %t.o
+// RUN: not ld.lld2 %t.o -o %t.so -shared 2>&1 | FileCheck %s
+
+        .section  .rodata.str1.1,"aMS",@progbits,1
+  .asciz  "abc"
+
+        .text
+        .long .rodata.str1.1 + 4
+
+// CHECK: Entry is past the end of the section

test/elf2/merge-string-no-null.s

+// REQUIRES: x86
+// RUN: llvm-mc -filetype=obj -triple=x86_64-pc-linux %s -o %t.o
+// RUN: not ld.lld2 %t.o -o %t.so -shared 2>&1 | FileCheck %s
+
+  .section  .rodata.str1.1,"aMS",@progbits,1
+  .ascii  "abc"
+
+// CHECK: String is not null terminated

test/elf2/merge-string.s

+// REQUIRES: x86
+// RUN: llvm-mc -filetype=obj -triple=x86_64-pc-linux %s -o %t.o
+// RUN: ld.lld2 -O2 %t.o -o %t.so -shared
+// RUN: llvm-readobj -s -section-data -t %t.so | FileCheck %s
+// RUN: ld.lld2 -O1 %t.o -o %t.so -shared
+// RUN: llvm-readobj -s -section-data -t %t.so | FileCheck --check-prefix=NOTAIL %s
+
+        .section  .rodata.str1.1,"aMS",@progbits,1
+  .asciz  "abc"
+foo:
+  .ascii  "a"
+bar:
+        .asciz  "bc"
+        .asciz  "bc"
+
+        .section        .rodata.str2.2,"aMS",@progbits,2
+        .align  2
+zed:
+        .short  20
+        .short  0
+
+// 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:         0x120
+// CHECK-NEXT: Offset:  0x120
+// 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: 61626300                             |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:         0x120
+// NOTAIL-NEXT: Offset:  0x120
+// NOTAIL-NEXT: Size:    7
+// NOTAIL-NEXT: Link: 0
+// NOTAIL-NEXT: Info: 0
+// NOTAIL-NEXT: AddressAlignment: 1
+// NOTAIL-NEXT: EntrySize: 0
+// NOTAIL-NEXT: SectionData (
+// NOTAIL-NEXT:   0000: 61626300 626300                     |abc.bc.|
+// NOTAIL-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: 0x124
+// CHECK-NEXT: Offset: 0x124
+// CHECK-NEXT: Size: 4
+// CHECK-NEXT: Link: 0
+// CHECK-NEXT: Info: 0
+// CHECK-NEXT: AddressAlignment: 2
+// CHECK-NEXT: EntrySize: 0
+// CHECK-NEXT: SectionData (
+// CHECK-NEXT:   0000: 14000000                             |....|
+// CHECK-NEXT: )
+
+
+// CHECK:      Name:    bar
+// CHECK-NEXT: Value:   0x121
+
+// CHECK:      Name:    foo
+// CHECK-NEXT: Value:   0x120
+
+// CHECK:      Name: zed
+// CHECK-NEXT: Value: 0x124
+// CHECK-NEXT: Size: 0