[ELF] Allow placing non-string SHF_MERGE sections with different alig…

…nments into the same MergeSyntheticSection

The difference from D63432/r365015 is that this patch does not place
SHF_STRINGS sections with different alignments into the same
MergeSyntheticSection. Doing that would:

(1) create unnecessary padding and thus waste space.
  Add a test tail-merge-string-align2.s to check no extra padding is created.
(2) make some input sections unaligned when tail merge (-O2) is enabled.
  The alignment of MergeTailAlignment::Builder was out of sync in D63432.
  MOVAPS on such unaligned strings can raise SIGSEGV.

This should fix PR42289: the Linux kernel has a use case that input
files have .rodata.cst32 sections with different alignments. The
expectation (and what ld.bfd and gold do) is that in the -r link, there
is only one .rodata.cst32 (SHF_MERGE sections with different alignments
can be combined), but lld currently creates one for each different
alignment.

The current merging strategy:

1) Group SHF_MERGE sections by (name, sh_flags, sh_entsize and
   sh_addralign). Merging is performed among a group, even if -O0 is specified.
2) Create one output section for each group. This is a special case in
   addInputSec().

This patch changes 1) to:

1) Group SHF_MERGE sections by (name, sh_flags, sh_entsize).
   Merging is performed among a group, even if -O0 is specified.

We will thus create just one .rodata.cst32 . This also improves merging
efficiency when sections with the same name but different alignments are
combined.

Reviewed By: peter.smith

Differential Revision: https://reviews.llvm.org/D64200

llvm-svn: 365139

lld/ELF/SyntheticSections.cpp

@@ -2919,6 +2919,8 @@ template <class ELFT> bool VersionNeedSection<ELFT>::isNeeded() const {
 void MergeSyntheticSection::addSection(MergeInputSection *MS) {
   MS->Parent = this;
   Sections.push_back(MS);
+  assert(Alignment == MS->Alignment || !(MS->Flags & SHF_STRINGS));
+  Alignment = std::max(Alignment, MS->Alignment);
 }
 
 MergeTailSection::MergeTailSection(StringRef Name, uint32_t Type,
@@ -3062,8 +3064,11 @@ void elf::mergeSections() {
       //
       // Using Entsize in here also allows us to propagate it to the synthetic
       // section.
+      //
+      // SHF_STRINGS section with different alignments should not be merged.
       return Sec->Name == OutsecName && Sec->Flags == MS->Flags &&
-             Sec->Entsize == MS->Entsize && Sec->Alignment == MS->Alignment;
+             Sec->Entsize == MS->Entsize &&
+             (Sec->Alignment == MS->Alignment || !(Sec->Flags & SHF_STRINGS));
     });
     if (I == MergeSections.end()) {
       MergeSyntheticSection *Syn =

lld/test/ELF/merge-align2.s

@@ -0,0 +1,35 @@
+# REQUIRES: x86
+# RUN: llvm-mc -filetype=obj -triple=x86_64 %s -o %t.o
+
+# RUN: ld.lld %t.o -o %t
+# RUN: llvm-readelf -S %t | FileCheck --check-prefix=SEC %s
+# RUN: llvm-readelf -x .cst8 %t | FileCheck %s
+
+# RUN: ld.lld -O0 -r %t.o -o %t1.o
+# RUN: llvm-readelf -S %t1.o | FileCheck --check-prefix=SEC %s
+# RUN: llvm-readelf -x .cst8 %t1.o | FileCheck %s
+
+## Check that if we have SHF_MERGE sections with the same name, flags and
+## entsize, but different alignments, we combine them with the maximum input
+## alignment as the output alignment.
+
+# SEC: Name  Type     {{.*}} Size   ES Flg Lk Inf Al
+# SEC: .cst8 PROGBITS {{.*}} 000018 08  AM  0   0  8
+
+# CHECK:      0x{{[0-9a-f]+}} 02000000 00000000 01000000 00000000
+# CHECK-NEXT: 0x{{[0-9a-f]+}} 03000000 00000000
+
+.section .cst8,"aM",@progbits,8,unique,0
+.align 4
+.quad 1
+.quad 1
+
+.section .cst8,"aM",@progbits,8,unique,1
+.align 4
+.quad 1
+.quad 2
+
+.section .cst8,"aM",@progbits,8,unique,2
+.align 8
+.quad 1
+.quad 3

lld/test/ELF/merge-entsize2.s

@@ -0,0 +1,49 @@
+# REQUIRES: x86
+# RUN: llvm-mc -filetype=obj -triple=x86_64 %s -o %t.o
+
+# RUN: ld.lld %t.o -o %t
+# RUN: llvm-readelf -S %t | FileCheck --check-prefix=SEC %s
+# RUN: llvm-readelf -x .cst %t | FileCheck --check-prefix=HEX %s
+
+# RUN: ld.lld -O0 -r %t.o -o %t1.o
+# RUN: llvm-readelf -S %t1.o | FileCheck --check-prefix=SEC-R %s
+# RUN: llvm-readelf -x .cst %t1.o | FileCheck --check-prefix=HEX-R %s
+
+## Check that SHF_MERGE sections with the same name, sh_flags and sh_entsize
+## are grouped together and can be merged within the group.
+
+## .cst 0 and .cst 1 are merged (sh_entsize=4). The result and .cst 2 and
+## combined (sh_entsize=8). The output sh_entsize is 0.
+# SEC:   Name  Type     {{.*}} Size   ES Flg Lk Inf Al
+# SEC:   .cst  PROGBITS {{.*}} 000020 00  AM  0   0  8
+
+## .cst 0 and .cst 1 are merged, but emitted as a separate output section.
+# SEC-R: .cst  PROGBITS {{.*}} 00000c 04  AM  0   0  4
+# SEC-R: .cst  PROGBITS {{.*}} 000010 08  AM  0   0  8
+
+# HEX:      Hex dump of section '.cst':
+# HEX-NEXT: 0x{{[0-9a-f]+}} 01000000 00000000 02000000 00000000
+# HEX-NEXT: 0x{{[0-9a-f]+}} 01000000 00000000 03000000 00000000
+
+# HEX-R:      Hex dump of section '.cst':
+# HEX-R-NEXT: 0x00000000 01000000 00000000 02000000
+# HEX-R-EMPTY:
+# HEX-R-NEXT: Hex dump of section '.cst':
+# HEX-R-NEXT: 0x00000000 01000000 00000000 03000000 00000000
+
+.section .cst,"aM",@progbits,4,unique,0
+.align 2
+.long 1
+.long 0
+.long 2
+
+.section .cst,"aM",@progbits,4,unique,1
+.align 4
+.long 1
+.long 0
+.long 2
+
+.section .cst,"aM",@progbits,8,unique,2
+.align 8
+.quad 1
+.quad 3

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

@@ -0,0 +1,25 @@
+# REQUIRES: x86
+# RUN: llvm-mc -filetype=obj -triple=x86_64 %s -o %t.o
+
+# RUN: ld.lld %t.o -o %t
+# RUN: llvm-readelf -S %t | FileCheck --check-prefix=SEC %s
+# RUN: llvm-readelf -x .rodata %t | FileCheck %s
+
+# SEC: Name    Type     {{.*}} Size   ES Flg Lk Inf Al
+# SEC: .rodata PROGBITS {{.*}} 000006 01 AMS  0   0  8
+
+## Check there is no extra padding.
+
+# CHECK: a.b.c.
+
+.section .rodata.str1.8,"aMS",@progbits,1
+.align 8
+.asciz "a"
+
+.section .rodata.str1.2,"aMS",@progbits,1
+.align 2
+.asciz "b"
+
+.section .rodata.str1.1,"aMS",@progbits,1
+.align 1
+.asciz "c"