ELF: Add .interp synthetic sections first in createSyntheticSections().

[pcc]

Summary

Our .interp section is not a SyntheticSection. As a result, it terminates the
loop in removeUnusedSyntheticSections(). This has at least two consequences:

• The synthetic .bss and .bss.rel.ro sections are always present in dynamically linked executables, even when they are not needed.
• The synthetic .ARM.exidx (and possibly other) sections are always present in partitions other than the last one, even when not needed. .ARM.exidx in particular is problematic because it assumes that its list of code sections is non-empty in getLinkOrderDep(), which can lead to a crash if the partition does not have any code sections.

Fix these problems by moving the creation of the .interp sections to the
top of createSyntheticSections(). While here, make the code a little less
error-prone by changing the add() lambdas to take a SyntheticSection instead
of an InputSectionBase.

[MaskRay]

Looks good. Thanks for catching the issues.

lld/ELF/Writer.cpp

321 ↗

(On Diff #222536)

i = 1; i <= partitions.size(); ++i to use i instead of i + 1 below.

lld/test/ELF/dynamic-linker.s

7 ↗

(On Diff #222536)

While here, use double-dash form for llvm-readelf: --program-headers --section-headers

lld/test/ELF/partition-dynamic-linker.s

9 ↗

(On Diff #222536)

--section-headers

[ruiu]

LGTM

[grimar]

LGTM with a minor nit.

lld/test/ELF/dynamic-linker.s

10 ↗

(On Diff #222536)

Perhaps a bit better would be to use FileCheck %s --implicit-check-not=.bss here and above.
That removes a dependency on the order of program/sections headers printed (recently there were patches that changed the output order back and forth to be more GNU-output compatible).

lld/trunk/ELF/SyntheticSections.cpp

MipsReginfoSection<ELFT> *MipsReginfoSection<ELFT>::create() {
   return make<MipsReginfoSection<ELFT>>(reginfo);
 }
 
 InputSection *elf::createInterpSection() {
   // StringSaver guarantees that the returned string ends with '\0'.
   StringRef s = saver.save(config->dynamicLinker);
   ArrayRef<uint8_t> contents = {(const uint8_t *)s.data(), s.size() + 1};
 
-  auto *sec = make<InputSection>(nullptr, SHF_ALLOC, SHT_PROGBITS, 1, contents,
-                                 ".interp");
-  sec->markLive();
-  return sec;
+  return make<InputSection>(nullptr, SHF_ALLOC, SHT_PROGBITS, 1, contents,
 }
 
 Defined *elf::addSyntheticLocal(StringRef name, uint8_t type, uint64_t value,
                                 uint64_t size, InputSectionBase &section) {
   auto *s = make<Defined>(section.file, name, STB_LOCAL, STV_DEFAULT, type,
                           value, size, &section);
   if (in.symTab)
     in.symTab->addSymbol(s);

lld/trunk/ELF/Writer.cpp

static OutputSection *findSection(StringRef name, unsigned partition = 1) {
   return nullptr;
 }
 
 template <class ELFT> void elf::createSyntheticSections() {
   // Initialize all pointers with NULL. This is needed because
   // you can call lld::elf::main more than once as a library.
   memset(&Out::first, 0, sizeof(Out));
 
-  auto add = [](InputSectionBase *sec) { inputSections.push_back(sec); };
+  // Add the .interp section first because it is not a SyntheticSection.
+  // The removeUnusedSyntheticSections() function relies on the
+  // SyntheticSections coming last.
+  if (needsInterpSection()) {
+    for (size_t i = 1; i <= partitions.size(); ++i) {
+      InputSection *sec = createInterpSection();
+      sec->partition = i;
+      inputSections.push_back(sec);
+    }
+  }
+
+  auto add = [](SyntheticSection *sec) { inputSections.push_back(sec); };
 
   in.shStrTab = make<StringTableSection>(".shstrtab", false);
 
   Out::programHeaders = make<OutputSection>("", 0, SHF_ALLOC);
   Out::programHeaders->alignment = config->wordsize;
 
   if (config->strip != StripPolicy::All) {
     in.strTab = make<StringTableSection>(".strtab", false);
if (auto *sec = MipsOptionsSection<ELFT>::create())
       add(sec);
     if (auto *sec = MipsReginfoSection<ELFT>::create())
       add(sec);
   }
 
   StringRef relaDynName = config->isRela ? ".rela.dyn" : ".rel.dyn";
 
   for (Partition &part : partitions) {
-    auto add = [&](InputSectionBase *sec) {
+    auto add = [&](SyntheticSection *sec) {
       sec->partition = part.getNumber();
       inputSections.push_back(sec);
     };
 
     if (!part.name.empty()) {
       part.elfHeader = make<PartitionElfHeaderSection<ELFT>>();
       part.elfHeader->name = part.name;
       add(part.elfHeader);
for (Partition &part : partitions) {
     part.dynSymTab = make<SymbolTableSection<ELFT>>(*part.dynStrTab);
     part.dynamic = make<DynamicSection<ELFT>>();
     if (config->androidPackDynRelocs)
       part.relaDyn = make<AndroidPackedRelocationSection<ELFT>>(relaDynName);
     else
       part.relaDyn =
           make<RelocationSection<ELFT>>(relaDynName, config->zCombreloc);
 
-    if (needsInterpSection())
-      add(createInterpSection());
-
     if (config->hasDynSymTab) {
       part.dynSymTab = make<SymbolTableSection<ELFT>>(*part.dynStrTab);
       add(part.dynSymTab);
 
       part.verSym = make<VersionTableSection>();
       add(part.verSym);
 
       if (!namedVersionDefs().empty()) {

lld/trunk/test/ELF/Inputs/shared.s

 .global bar
-.type bar, @function
+.type bar, %function
 bar:
 
 .global bar2
-.type bar2, @function
+.type bar2, %function
 bar2:
 
 .global zed
 zed:

lld/trunk/test/ELF/dynamic-linker.s

 # REQUIRES: x86
 # RUN: llvm-mc -filetype=obj -triple=x86_64-pc-linux %p/Inputs/shared.s -o %t1.o
 # RUN: ld.lld -shared %t1.o -o %t.so
 # RUN: llvm-mc -filetype=obj -triple=x86_64-pc-linux %s -o %t.o
 
 # RUN: ld.lld --dynamic-linker foo %t.o %t.so -o %t
-# RUN: llvm-readelf -program-headers %t | FileCheck %s
+# RUN: llvm-readelf --program-headers --section-headers %t | FileCheck --implicit-check-not=.bss %s
 
 # RUN: ld.lld --dynamic-linker=foo %t.o %t.so -o %t
-# RUN: llvm-readelf -program-headers %t | FileCheck %s
+# RUN: llvm-readelf --program-headers --section-headers %t | FileCheck --implicit-check-not=.bss %s
 
 # CHECK: [Requesting program interpreter: foo]
 
 # RUN: ld.lld %t.o %t.so -o %t
 # RUN: llvm-readelf -program-headers %t | FileCheck --check-prefix=NO %s
 
 # RUN: ld.lld --dynamic-linker foo --no-dynamic-linker %t.o %t.so -o %t
 # RUN: llvm-readelf -program-headers %t | FileCheck --check-prefix=NO %s
 
 # NO-NOT: PT_INTERP
 
 .globl _start
 _start:
   nop

lld/trunk/test/ELF/partition-dynamic-linker.s

+## Test that we don't create a .ARM.exidx for the main partition.
+## Previously we were doing so, which is unnecessary and led to a crash.
+
+# RUN: llvm-mc -filetype=obj -triple=armv7a-none-linux-gnueabi %p/Inputs/shared.s -o %t1.o
+# RUN: ld.lld -shared %t1.o -o %t.so
+# RUN: llvm-mc -filetype=obj -triple=armv7a-none-linux-gnueabi %s -o %t.o
+
+# RUN: ld.lld -shared --gc-sections --dynamic-linker foo %t.o %t.so -o %t
+# RUN: llvm-readelf --section-headers %t | FileCheck %s
+
+# CHECK: .ARM.exidx
+# CHECK-NOT: .ARM.exidx
+
+.section .llvm_sympart,"",%llvm_sympart
+.asciz "part1"
+.4byte p1
+
+.section .text.p1,"ax",%progbits
+.globl p1
+p1:
+.fnstart
+bx lr
+.cantunwind
+.fnend