Parallelize tail-merge string table construction.

[ruiu]

Summary

This patch parallelizes MergeTailSection just like I did to
MergeNoTailSection in r314588.

On my 2-socket 20-core 40-threads Xeon E5-2680 @ 2.8 GHz machine,
this patch shortens the clang debug build link time with -O2 from
11.35s to 5.72s. Without -O2, it's 5.23s, so the overhead of -O2 is
now about a half second in this test environment.

[ruiu]

• Embed TailHash into SectionPiece

[ruiu]

Ping. What do you think of this?

[ruiu]

I forgot this patch, but I'd like to get this in. Can you review?

[inglorion]

lld/ELF/SyntheticSections.cpp

2988

What if you did the equivalent of:

size_t N = std::min(4, S.size());
uint32_t X = 0;
memcpy(&X, S.data() + S.size() - N, N);
return hash_value(X);

That would allow you to handle strings of any length and should be super efficient.

If you need the hash to not depend on the endianness of the host you could use ulittle32_t, but I think in this case you don't need to care what the actual values produced by the hash function are so ignoring endianness seems fine.

[ruiu]

• rebased

[grimar]

It is a bit unclear to me which test you want to change to show the effect of this patch.
I.e. I would expect either adding one new test or modifying one of the
existent, but you change the 3 tests here and it is a bit confusing IMO.

Also, since this patch really has an old base (you posted it in 2017),
do you think it is worth to update its description with fresh numbers?

lld/ELF/SyntheticSections.cpp

3001

nit: I might be mistaken, but I think here you need a comma: "Currently" -> "Currently, "

lld/ELF/SyntheticSections.h

848

nit: no full stop at the end of the comment.

[ruiu]

This patch naturally changes the order how strings are placed in a merged string section. In addition to that, with this change, strings equal to or shorter than 4 bytes long are not merged. This is why.

Assume we have two string, "cd" and "abcd". They have the same tail.

Since we use a hash value of the last 4 characters of each string as a shard ID, we compute two hashes, H1=hash_vaule("cd") and H2=hash_value("abcd"). It is unlikely that H1==H2 because they are just different strings. Therefore, it is likely that "cd" and "abcd" are added to different shards, and they are not merged.

Due to the above behavior, I needed to make the strings used in the test little longer, as otherwise they wouldn't have been merged at all.

[ruiu]

• address review comments
• simplify

[ruiu]

lld/ELF/SyntheticSections.cpp

2988

After simplifying this function it became too short, so I inlined the function.

[ruiu]

• 80 columns

[grimar]

Thanks for the explanation! Two more comments/questions below.

lld/ELF/InputSection.h

238

Seems you could store ShardID : 5 here instead of TailHash.
That would save a few bits for OutputOff and you can get rid of computations in the code.
Does it make sense?

lld/ELF/SyntheticSections.cpp

2997

Not only when -O2, but actually -On, where n >= 2.

[ruiu]

• rebased
• instead of storing a tail hash, directly store shard-id to SectionPieces

lld/ELF/InputSection.h

 // We allocate a lot of these and binary search on them. This means that they
 // have to be as compact as possible, which is why we don't store the size (can
 // be found by looking at the next one).
 struct SectionPiece {
   SectionPiece(size_t Off, uint32_t Hash, bool Live)
       : InputOff(Off), Live(Live || !Config->GcSections), Hash(Hash >> 1) {}
 
   uint32_t InputOff;
   uint32_t Live : 1;
-  uint32_t Hash : 31;
+  uint32_t ShardId : 5;
+  uint32_t Hash : 26;
   uint64_t OutputOff = 0;
 };
 
 static_assert(sizeof(SectionPiece) == 16, "SectionPiece is too big");
 
 // This corresponds to a SHF_MERGE section of an input file.
 class MergeInputSection : public InputSectionBase {
 public:

lld/ELF/SyntheticSections.h

 
 // 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.
 class MergeSyntheticSection : public SyntheticSection {
 public:
   void addSection(MergeInputSection *MS);
+  size_t getSize() const override { return Size; }
+  void writeTo(uint8_t *Buf) override;
+
   std::vector<MergeInputSection *> Sections;
 
 protected:
   MergeSyntheticSection(StringRef Name, uint32_t Type, uint64_t Flags,
-                        uint32_t Alignment)
-      : SyntheticSection(Flags, Type, Alignment, Name) {}
+                        uint32_t Alignment);
+
+  // Section size
+  size_t Size;
+
+  // Concurrency level.
+  size_t Concurrency;
+
+  // String table contents
+  constexpr static size_t NumShards = 32;
+  std::vector<llvm::StringTableBuilder> Shards;
+  size_t ShardOffsets[NumShards];
 };
 
 class MergeTailSection final : public MergeSyntheticSection {
 public:
   MergeTailSection(StringRef Name, uint32_t Type, uint64_t Flags,
-                   uint32_t Alignment);
+                   uint32_t Alignment)
+      : MergeSyntheticSection(Name, Type, Flags, Alignment) {}
 
-  size_t getSize() const override;
-  void writeTo(uint8_t *Buf) override;
   void finalizeContents() override;
-
-private:
-  llvm::StringTableBuilder Builder;
 };
 
 class MergeNoTailSection final : public MergeSyntheticSection {
 public:
   MergeNoTailSection(StringRef Name, uint32_t Type, uint64_t Flags,
                      uint32_t Alignment)
       : MergeSyntheticSection(Name, Type, Flags, Alignment) {}
 
-  size_t getSize() const override { return Size; }
-  void writeTo(uint8_t *Buf) override;
   void finalizeContents() override;
 
 private:
   // We use the most significant bits of a hash as a shard ID.
   // The reason why we don't want to use the least significant bits is
   // because DenseMap also uses lower bits to determine a bucket ID.
   // If we use lower bits, it significantly increases the probability of
   // hash collisons.
   size_t getShardId(uint32_t Hash) {
     assert((Hash >> 31) == 0);
     return Hash >> (31 - llvm::countTrailingZeros(NumShards));
   }
-
-  // Section size
-  size_t Size;
-
-  // String table contents
-  constexpr static size_t NumShards = 32;
-  std::vector<llvm::StringTableBuilder> Shards;
-  size_t ShardOffsets[NumShards];
 };
 
 // .MIPS.abiflags section.
 template <class ELFT>
 class MipsAbiFlagsSection final : public SyntheticSection {
   using Elf_Mips_ABIFlags = llvm::object::Elf_Mips_ABIFlags<ELFT>;
 
 public:

lld/ELF/SyntheticSections.cpp

 
 using namespace lld;
 using namespace lld::elf;
 
 using llvm::support::endian::read32le;
 using llvm::support::endian::write32le;
 using llvm::support::endian::write64le;
 
-constexpr size_t MergeNoTailSection::NumShards;
+constexpr size_t MergeSyntheticSection::NumShards;
 
 static uint64_t readUint(uint8_t *Buf) {
   return Config->Is64 ? read64(Buf) : read32(Buf);
 }
 
 static void writeUint(uint8_t *Buf, uint64_t Val) {
   if (Config->Is64)
     write64(Buf, Val);
template <class ELFT> size_t VersionNeedSection<ELFT>::getSize() const {
   return Verneeds.size() * sizeof(Elf_Verneed) +
          SharedFile::VernauxNum * sizeof(Elf_Vernaux);
 }
 
 template <class ELFT> bool VersionNeedSection<ELFT>::isNeeded() const {
   return SharedFile::VernauxNum != 0;
 }
 
-void MergeSyntheticSection::addSection(MergeInputSection *MS) {
-  MS->Parent = this;
-  Sections.push_back(MS);
-}
-
-MergeTailSection::MergeTailSection(StringRef Name, uint32_t Type,
+MergeSyntheticSection::MergeSyntheticSection(StringRef Name, uint32_t Type,
                                              uint64_t Flags, uint32_t Alignment)
-    : MergeSyntheticSection(Name, Type, Flags, Alignment),
-      Builder(StringTableBuilder::RAW, Alignment) {}
-
-size_t MergeTailSection::getSize() const { return Builder.getSize(); }
-
-void MergeTailSection::writeTo(uint8_t *Buf) { Builder.write(Buf); }
-
-void MergeTailSection::finalizeContents() {
-  // Add all string pieces to the string table builder to create section
-  // contents.
-  for (MergeInputSection *Sec : Sections)
-    for (size_t I = 0, E = Sec->Pieces.size(); I != E; ++I)
-      if (Sec->Pieces[I].Live)
-        Builder.add(Sec->getData(I));
+    : SyntheticSection(Flags, Type, Alignment, Name) {
+  // Initialize string builders.
+  for (size_t I = 0; I < NumShards; ++I)
+    Shards.emplace_back(StringTableBuilder::RAW, Alignment);
 
-  // Fix the string table content. After this, the contents will never change.
-  Builder.finalize();
+  // Initializes concurrency level. Must be a power of 2 to avoid
+  // the expensive modulo operation when dividing with this value.
+  if (ThreadsEnabled)
+    Concurrency =
+        std::min<size_t>(PowerOf2Floor(hardware_concurrency()), NumShards);
+  else
+    Concurrency = 1;
+}
 
-  // 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 *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));
+void MergeSyntheticSection::addSection(MergeInputSection *MS) {
+  MS->Parent = this;
+  Sections.push_back(MS);
 }
 
-void MergeNoTailSection::writeTo(uint8_t *Buf) {
+void MergeSyntheticSection::writeTo(uint8_t *Buf) {
   for (size_t I = 0; I < NumShards; ++I)
     Shards[I].write(Buf + ShardOffsets[I]);
 }
 
 // This function is very hot (i.e. it can take several seconds to finish)
 // because sometimes the number of inputs is in an order of magnitude of
 // millions. So, we use multi-threading.
 //
 // For any strings S and T, we know S is not mergeable with T if S's hash
 // value is different from T's. If that's the case, we can safely put S and
 // T into different string builders without worrying about merge misses.
 // We do it in parallel.
 void MergeNoTailSection::finalizeContents() {
-  // Initializes string table builders.
-  for (size_t I = 0; I < NumShards; ++I)
-    Shards.emplace_back(StringTableBuilder::RAW, Alignment);
-
-  // Concurrency level. Must be a power of 2 to avoid expensive modulo
-  // operations in the following tight loop.
-  size_t Concurrency = 1;
-  if (ThreadsEnabled)
-    Concurrency =
-        std::min<size_t>(PowerOf2Floor(hardware_concurrency()), NumShards);
-
   // Add section pieces to the builders.
   parallelForEachN(0, Concurrency, [&](size_t ThreadId) {
     for (MergeInputSection *Sec : Sections) {
       for (size_t I = 0, E = Sec->Pieces.size(); I != E; ++I) {
         if (!Sec->Pieces[I].Live)
           continue;
         size_t ShardId = getShardId(Sec->Pieces[I].Hash);
         if ((ShardId & (Concurrency - 1)) == ThreadId)
void MergeNoTailSection::finalizeContents() {
   parallelForEach(Sections, [&](MergeInputSection *Sec) {
     for (size_t I = 0, E = Sec->Pieces.size(); I != E; ++I)
       if (Sec->Pieces[I].Live)
         Sec->Pieces[I].OutputOff +=
             ShardOffsets[getShardId(Sec->Pieces[I].Hash)];
   });
 }
 
+// This function basically does the same thing as MergeNoTailSection
+// does but creates a tail-merged string table. E.g. "def\0" is merged
+// with "abcdef\0". This is enabled only when -O2 is given.
+//
+// Input strings are sharded based on their very last few characters.
+// This works because, if strings S and T can be tail-merged, S and T
+// must have the same tail substring. Currently, we use the last 4
+// characters for sharding.
+//
+// Note that strings shorter than 4 characters may not be tail-merged.
+// That is okay because the loss seems negligible. My observation is
+// that a loss is 8 KiB when we create a 1.7 GiB clang executable.
+void MergeTailSection::finalizeContents() {
+  // Initializes TailHashes by hash values of last few characters.
+  parallelForEach(Sections, [&](MergeInputSection *Sec) {
+    for (size_t I = 0, E = Sec->Pieces.size(); I != E; ++I)
+      if (Sec->Pieces[I].Live)
+        Sec->Pieces[I].ShardId =
+          hash_value(Sec->getData(I).val().take_back(4));
+  });
+
+  // Add section pieces to the builders.
+  parallelForEachN(0, Concurrency, [&](size_t ThreadId) {
+    for (MergeInputSection *Sec : Sections) {
+      for (size_t I = 0, E = Sec->Pieces.size(); I != E; ++I) {
+        if (!Sec->Pieces[I].Live)
+          continue;
+        size_t ShardId = Sec->Pieces[I].ShardId;
+        assert(ShardId < (1UL << NumShards));
+        if ((ShardId & (Concurrency - 1)) == ThreadId)
+          Shards[ShardId].add(Sec->getData(I));
+      }
+    }
+  });
+
+  parallelForEach(Shards, [](StringTableBuilder &S) { S.finalize(); });
+
+  // Compute an in-section offset for each shard.
+  size_t Off = 0;
+  for (size_t I = 0; I < NumShards; ++I) {
+    if (Shards[I].getSize() > 0)
+      Off = alignTo(Off, Alignment);
+    ShardOffsets[I] = Off;
+    Off += Shards[I].getSize();
+  }
+  Size = Off;
+
+  // Set to section piece offsets.
+  parallelForEach(Sections, [&](MergeInputSection *Sec) {
+    for (size_t I = 0, E = Sec->Pieces.size(); I != E; ++I) {
+      if (!Sec->Pieces[I].Live)
+        continue;
+      size_t ShardId = Sec->Pieces[I].ShardId;
+      Sec->Pieces[I].OutputOff =
+          ShardOffsets[ShardId] + Shards[ShardId].getOffset(Sec->getData(I));
+    }
+  });
+}
+
 static MergeSyntheticSection *createMergeSynthetic(StringRef Name,
                                                    uint32_t Type,
                                                    uint64_t Flags,
                                                    uint32_t Alignment) {
   bool ShouldTailMerge = (Flags & SHF_STRINGS) && Config->Optimize >= 2;
   if (ShouldTailMerge)
     return make<MergeTailSection>(Name, Type, Flags, Alignment);
   return make<MergeNoTailSection>(Name, Type, Flags, Alignment);

lld/test/ELF/comment-gc.s

 # REQUIRES: x86
 # RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %s -o %t.o
 # RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %p/Inputs/comment-gc.s -o %t2.o
 # RUN: ld.lld %t.o %t2.o -o %t1 --gc-sections -shared
 # RUN: llvm-objdump -s %t1 | FileCheck %s
 
 # CHECK:      Contents of section .comment:
-# CHECK-NEXT: foo..LLD 1.0.bar
+# CHECK-NEXT: foo.bar.LLD 1.0
 
 .ident "foo"
 
 .globl _start
 _start:
   nop

lld/test/ELF/compressed-debug-input.s

 # DATA-NEXT:   Address: 0x0
 # DATA-NEXT:   Offset: 0x1060
 # DATA-NEXT:   Size: 69
 # DATA-NEXT:   Link: 0
 # DATA-NEXT:   Info: 0
 # DATA-NEXT:   AddressAlignment: 1
 # DATA-NEXT:   EntrySize: 1
 # DATA-NEXT:   SectionData (
-# DATA-NEXT:     0000: 6C6F6E67 20756E73 69676E65 6420696E  |long unsigned in|
-# DATA-NEXT:     0010: 7400756E 7369676E 65642063 68617200  |t.unsigned char.|
-# DATA-NEXT:     0020: 756E7369 676E6564 20696E74 00636861  |unsigned int.cha|
-# DATA-NEXT:     0030: 72007368 6F727420 756E7369 676E6564  |r.short unsigned|
-# DATA-NEXT:     0040: 20696E74 00                          | int.|
+# DATA-NEXT:     0000: 73686F72 7420756E 7369676E 65642069  |short unsigned i|
+# DATA-NEXT:     0010: 6E740075 6E736967 6E656420 696E7400  |nt.unsigned int.|
+# DATA-NEXT:     0020: 6C6F6E67 20756E73 69676E65 6420696E  |long unsigned in|
+# DATA-NEXT:     0030: 74006368 61720075 6E736967 6E656420  |t.char.unsigned |
+# DATA-NEXT:     0040: 63686172 00                          |char.|
 # DATA-NEXT:   )
 # DATA-NEXT: }
 
 .section .debug_str,"MS",@progbits,1
 .LASF2:
  .string "short unsigned int"
 .LASF3:
  .string "unsigned int"
 .LASF0:
  .string "long unsigned int"
 .LASF8:
  .string "char"
 .LASF1:
  .string "unsigned char"

lld/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_str:
-# CHECK-NEXT:  0000 41414100 43434300 42424200           AAA.CCC.BBB.
+# 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 08000000
+# CHECK-NEXT:  0000 00000000 04000000
 
 .globl _start
 _start:
 
 .section .debug_str,"MS",@progbits,1
 .Linfo_string0:
   .asciz "AAA"
 .Linfo_string1:

lld/test/ELF/emit-relocs-mergeable-i386.s

 # 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: 00000000 08000000 08000000 04000000
+# CHECK-NEXT:     0000: 00000000 04000000 04000000 08000000
 # CHECK-NEXT:   )
 # CHECK-NEXT: }
 
 ## Check that offsets for AAA is 0x0, for BBB is 0x8 and CCC has offset 0x4.
 # CHECK:      Section {
 # CHECK:        Index:
 # CHECK:        Name: .strings
 # CHECK-NEXT:   Type: SHT_PROGBITS
 # CHECK-NEXT:   Flags [
 # 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:     |AAA.CCC.BBB.|
+# CHECK-NEXT:     |AAA.BBB.CCC.|
 # CHECK-NEXT:   )
 # CHECK-NEXT: }
 
 .section .strings,"MS",@progbits,1,unique,10
 .Linfo_string0:
   .asciz "AAA"
 .Linfo_string1:
   .asciz "BBB"

lld/test/ELF/emit-relocs-mergeable.s

 # CHECK-NEXT:   Address:
 # CHECK-NEXT:   Offset:
 # CHECK-NEXT:   Size: 12
 # CHECK-NEXT:   Link:
 # CHECK-NEXT:   Info:
 # CHECK-NEXT:   AddressAlignment:
 # CHECK-NEXT:   EntrySize:
 # CHECK-NEXT:   SectionData (
-# CHECK-NEXT:     0000: 41414100 43434300 42424200 |AAA.CCC.BBB.|
+# CHECK-NEXT:     0000: 41414100 42424200 43434300 |AAA.BBB.CCC.|
 # CHECK-NEXT:   )
 # CHECK-NEXT: }
 
 # CHECK:      Relocations [
 # CHECK-NEXT:   Section {{.*}} .rela.foo {
 # CHECK-NEXT:     0x201000 R_X86_64_64 .strings 0x0
-# CHECK-NEXT:     0x201008 R_X86_64_64 .strings 0x8
-# CHECK-NEXT:     0x201010 R_X86_64_64 .strings 0x8
-# CHECK-NEXT:     0x201018 R_X86_64_64 .strings 0x4
+# CHECK-NEXT:     0x201008 R_X86_64_64 .strings 0x4
+# CHECK-NEXT:     0x201010 R_X86_64_64 .strings 0x4
+# CHECK-NEXT:     0x201018 R_X86_64_64 .strings 0x8
 # CHECK-NEXT:   }
 # CHECK-NEXT: ]
 
 .section .strings,"MS",@progbits,1,unique,10
 .Linfo_string0:
   .asciz "AAA"
 .Linfo_string1:
   .asciz "BBB"

lld/test/ELF/merge-shared-str.s

 // REQUIRES: x86
 // RUN: llvm-mc -filetype=obj -triple=x86_64-pc-linux %s -o %t.o
-// RUN: ld.lld %t.o -o %t.so -shared -O3
-// RUN: llvm-readobj -r -S %t.so | FileCheck %s
-
+// RUN: ld.lld %t.o -o %t.so -shared -O2
+// RUN: llvm-readobj -r -s %t.so | FileCheck %s
 
-        .section        foo,"aMS",@progbits,1
-        .asciz "bar"
-        .asciz "ar"
+.section foo,"aMS",@progbits,1
+.asciz "foobarbaz"
+.asciz "barbaz"
 
-        .data
-        .quad foo + 4
 
-
 // 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: 0x260
 
 // CHECK:      Relocations [
 // CHECK-NEXT:   Section ({{.*}}) .rela.dyn {
-// CHECK-NEXT:     0x{{.*}} R_X86_64_RELATIVE - 0x261
+// CHECK-NEXT:     0x{{.*}} R_X86_64_RELATIVE - 0x264
 // CHECK-NEXT:   }
 // CHECK-NEXT: ]

lld/test/ELF/merge-string.s

 // REQUIRES: x86
 // RUN: llvm-mc -filetype=obj -triple=x86_64-pc-linux %s -o %t.o
 // RUN: ld.lld -O 2 %t.o -o %t.so -shared
 // RUN: llvm-readobj -S --section-data --symbols %t.so | FileCheck %s
 // RUN: ld.lld -O 1 %t.o -o %t.so -shared
 // RUN: llvm-readobj -S --section-data --symbols %t.so | FileCheck --check-prefix=NOTAIL %s
 // RUN: ld.lld -O 0 %t.o -o %t.so -shared
 // RUN: llvm-readobj -S --section-data --symbols %t.so | FileCheck --check-prefix=NOMERGE %s
 
         .section  .rodata1,"aMS",@progbits,1
-  .asciz  "abc"
+  .asciz  "abcdef"
 foo:
-  .ascii  "a"
+  .ascii  "abcd"
 bar:
-        .asciz  "bc"
-        .asciz  "bc"
+        .asciz  "ef"
+        .asciz  "cdef"
 
         .section        .rodata2,"aMS",@progbits,2
         .align  2
 zed:
         .short  20
         .short  0
 
 // CHECK:      Name:    .rodata1
 // 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: 0x20D
 // CHECK-NEXT: Offset: 0x20D
-// CHECK-NEXT: Size:    4
+// CHECK-NEXT: Size:
 // CHECK-NEXT: Link: 0
 // CHECK-NEXT: Info: 0
 // CHECK-NEXT: AddressAlignment: 1
 // CHECK-NEXT: EntrySize: 1
 // CHECK-NEXT: SectionData (
-// CHECK-NEXT:   0000: 61626300                             |abc.|
+// CHECK-NEXT:   |abcdef.|
 // CHECK-NEXT: )
 
 // NOTAIL:      Name:    .rodata1
 // 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: 0x20D
 // NOTAIL-NEXT: Offset: 0x20D
-// NOTAIL-NEXT: Size:    7
+// NOTAIL-NEXT: Size:
 // NOTAIL-NEXT: Link: 0
 // NOTAIL-NEXT: Info: 0
 // NOTAIL-NEXT: AddressAlignment: 1
 // NOTAIL-NEXT: EntrySize: 1
 // NOTAIL-NEXT: SectionData (
-// NOTAIL-NEXT:   0000: 62630061 626300                     |bc.abc.|
+// NOTAIL-NEXT:   |abcdef.cdef.|
 // NOTAIL-NEXT: )
 
 // NOMERGE:      Name:    .rodata1
 // NOMERGE-NEXT: Type:    SHT_PROGBITS
 // NOMERGE-NEXT: Flags [
 // NOMERGE-NEXT:   SHF_ALLOC
 // NOMERGE-NEXT:   SHF_MERGE
 // NOMERGE-NEXT:   SHF_STRINGS
 // NOMERGE-NEXT: ]
 // NOMERGE-NEXT: Address: 0x20D
 // NOMERGE-NEXT: Offset: 0x20D
-// NOMERGE-NEXT: Size:    11
+// NOMERGE-NEXT: Size:
 // NOMERGE-NEXT: Link: 0
 // NOMERGE-NEXT: Info: 0
 // NOMERGE-NEXT: AddressAlignment: 1
 // NOMERGE-NEXT: EntrySize: 1
 // NOMERGE-NEXT: SectionData (
-// NOMERGE-NEXT:   0000: 61626300 61626300 626300 |abc.abc.bc.|
+// NOMERGE-NEXT:   |abcdef.abcdef.cd|
+// NOMERGE-NEXT:   |ef.|
 // NOMERGE-NEXT: )
 
 // CHECK:      Name: .rodata2
 // 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: 0x212
-// CHECK-NEXT: Offset: 0x212
-// CHECK-NEXT: Size: 4
+// CHECK-NEXT: Address: 0x214
+// CHECK-NEXT: Offset: 0x214
+// CHECK-NEXT: Size:
 // 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-NEXT: )
 
 
 // CHECK:      Name:    bar
-// CHECK-NEXT: Value: 0x20E
+// CHECK-NEXT: Value: 0x211
 
 // CHECK:      Name:    foo
 // CHECK-NEXT: Value: 0x20D
 
 // CHECK:      Name: zed
-// CHECK-NEXT: Value: 0x212
+// CHECK-NEXT: Value: 0x214
 // CHECK-NEXT: Size: 0

lld/test/ELF/relocatable-compressed-input.s

 # CHECK-NEXT:   Address:
 # CHECK-NEXT:   Offset:
 # CHECK-NEXT:   Size:
 # CHECK-NEXT:   Link:
 # CHECK-NEXT:   Info:
 # CHECK-NEXT:   AddressAlignment: 1
 # CHECK-NEXT:   EntrySize: 1
 # CHECK-NEXT:   SectionData (
-# CHECK-NEXT:     0000: {{.*}}  |long unsigned in|
-# CHECK-NEXT:     0010: {{.*}}  |t.unsigned char.|
-# CHECK-NEXT:     0020: {{.*}}  |unsigned int.cha|
-# CHECK-NEXT:     0030: {{.*}}  |r.short unsigned|
-# CHECK-NEXT:     0040: {{.*}}  | int.|
+# CHECK-NEXT:     0000: {{.*}}  |short unsigned i|
+# CHECK-NEXT:     0010: {{.*}}  |nt.unsigned int.|
+# CHECK-NEXT:     0020: {{.*}}  |long unsigned in|
+# CHECK-NEXT:     0030: {{.*}}  |t.char.unsigned |
+# CHECK-NEXT:     0040: {{.*}}  |char.|
 # CHECK-NEXT:   )
 # CHECK-NEXT: }
 
 .section .debug_str,"MS",@progbits,1
 .LASF2:
  .string "short unsigned int"
 .LASF3:
  .string "unsigned int"
 .LASF0:
  .string "long unsigned int"
 .LASF8:
  .string "char"
 .LASF1:
  .string "unsigned char"

lld/test/ELF/string-gc.s

 // CHECK-NEXT:     Size: 0
 // CHECK-NEXT:     Binding: Local (0x0)
 // CHECK-NEXT:     Type: None (0x0)
 // CHECK-NEXT:     Other: 0
 // CHECK-NEXT:     Section: Undefined (0x0)
 // CHECK-NEXT:   }
 // CHECK-NEXT:   Symbol {
 // CHECK-NEXT:     Name: s3
-// CHECK-NEXT:     Value: 0x200120
+// CHECK-NEXT:     Value: 0x200125
 // CHECK-NEXT:     Size: 0
 // CHECK-NEXT:     Binding: Local (0x0)
 // CHECK-NEXT:     Type: Object (0x1)
 // CHECK-NEXT:     Other: 0
 // CHECK-NEXT:     Section: .rodata (0x1)
 // CHECK-NEXT:   }
 // CHECK-NEXT:   Symbol {
 // CHECK-NEXT:     Name: s1
-// CHECK-NEXT:     Value: 0x200125
+// CHECK-NEXT:     Value: 0x200120
 // CHECK-NEXT:     Size: 0
 // CHECK-NEXT:     Binding: Local (0x0)
 // CHECK-NEXT:     Type: Object (0x1)
 // CHECK-NEXT:     Other [ (0x2)
 // CHECK-NEXT:       STV_HIDDEN (0x2)
 // CHECK-NEXT:     ]
 // CHECK-NEXT:     Section: .rodata (0x1)
 // CHECK-NEXT:   }

lld/test/ELF/tail-merge-string-align.s

 // REQUIRES: x86
 // RUN: llvm-mc -filetype=obj -triple=x86_64-pc-linux %s -o %t.o
-// RUN: ld.lld %t.o -o %t.so -shared -O3
-// RUN: llvm-readobj -S --section-data %t.so | FileCheck %s
+// RUN: ld.lld %t.o -o %t.so -shared -O2
+// RUN: llvm-readobj -s -section-data %t.so | FileCheck %s
 
-        .section        .rodata.4a,"aMS",@progbits,1
-        .align 4
-        .asciz "abcdef"
+.asciz "abcdefg"
 
-        .section        .rodata.4b,"aMS",@progbits,1
-        .align 4
-        .asciz "ef"
+.asciz "efg"
 
-        .section        .rodata.4c,"aMS",@progbits,1
-        .align 4
-        .asciz "f"
-
+.asciz "defgh"
 
 // 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: 1
+// CHECK-NEXT: Size:
 // CHECK-NEXT: Link: 0
 // CHECK-NEXT: Info: 0
 // CHECK-NEXT: AddressAlignment: 4
 // CHECK-NEXT: EntrySize:
 // CHECK-NEXT: SectionData (
-// CHECK-NEXT:   0000:    61626364 65660000 6600               |abcdef..f.|
+// CHECK-NEXT:   |defgh...abcdefg.|
 // CHECK-NEXT: )