[ELF] - Another fix for "LLD crashes with --emit-relocs when trying to proccess .eh_frame"

[grimar]

Summary

This fixes PR36367 which is about segfault when --emit-relocs is
used together with .eh_frame sections which happens because
of reordering of regular and .rel[a] sections.

Path changes loop that iterates over input sections to create
relocation target sections first.

[grimar]

• Simplify test case.

[• espindola]

ELF/LinkerScript.cpp

677

It turns out that we can do this with just one loop.

The requirement that we have is that relocated sections are added before the corresponding section. We can implement that with

+ if ((IS->Type == SHT_REL || IS->Type == SHT_RELA) && !isa<SyntheticSection>(IS))
+ if (auto *Rel = cast<InputSection>(IS)->getRelocatedSection())
+ if (auto *RelIS = dyn_cast_or_null<InputSectionBase>(Rel->Parent))
+ Add(RelIS);
+ Add(IS);

[grimar]

• Addressed review comment.

ELF/LinkerScript.cpp

677

Such approach is much more test case friendly, thanks.

We use/can use (IS->Type == SHT_REL || IS->Type == SHT_RELA) && !isa<SyntheticSection>(IS)
condition so many times in code that I even think about some kind of helper for that.

[• espindola]

LGTM

ELF/LinkerScript.cpp

static OutputSection *addInputSec(StringMap<OutputSection *> &Map,
   Sec = createSection(IS, OutsecName);
   return Sec;
 }
 
 // Add sections that didn't match any sections command.
 void LinkerScript::addOrphanSections() {
   unsigned End = SectionCommands.size();
   StringMap<OutputSection *> Map;
-
   std::vector<OutputSection *> V;
-  for (InputSectionBase *S : InputSections) {
+
+  auto Add = [&](InputSectionBase *S) {
     if (!S->Live || S->Parent)
-      continue;
+      return;
 
     StringRef Name = getOutputSectionName(S);
 
     if (Config->OrphanHandling == OrphanHandlingPolicy::Error)
       error(toString(S) + " is being placed in '" + Name + "'");
     else if (Config->OrphanHandling == OrphanHandlingPolicy::Warn)
       warn(toString(S) + " is being placed in '" + Name + "'");
 
     if (OutputSection *Sec =
             findByName(makeArrayRef(SectionCommands).slice(0, End), Name)) {
       Sec->addSection(cast<InputSection>(S));
-      continue;
+      return;
     }
 
     if (OutputSection *OS = addInputSec(Map, S, Name))
       V.push_back(OS);
     assert(S->getOutputSection()->SectionIndex == UINT32_MAX);
+  };
+
+  // For futher --emit-reloc handling code we need target output section
+  // to be created before we create relocation output section, so we want
+  // to create target sections first. We do not want priority handling
+  // for synthetic sections because them are special.
+  for (InputSectionBase *IS : InputSections) {
+    if ((IS->Type == SHT_REL || IS->Type == SHT_RELA) &&
+        !isa<SyntheticSection>(IS))
+      if (auto *Rel = cast<InputSection>(IS)->getRelocatedSection())
+        if (auto *RelIS = dyn_cast_or_null<InputSectionBase>(Rel->Parent))
+          Add(RelIS);
+    Add(IS);
   }
 
   // If no SECTIONS command was given, we should insert sections commands
   // before others, so that we can handle scripts which refers them,
   // for example: "foo = ABSOLUTE(ADDR(.text)));".
   // When SECTIONS command is present we just add all orphans to the end.
   if (HasSectionsCommand)
     SectionCommands.insert(SectionCommands.end(), V.begin(), V.end());
   else
     SectionCommands.insert(SectionCommands.begin(), V.begin(), V.end());
 }
 
 uint64_t LinkerScript::advance(uint64_t Size, unsigned Alignment) {
   bool IsTbss =
       (Ctx->OutSec->Flags & SHF_TLS) && Ctx->OutSec->Type == SHT_NOBITS;
   uint64_t Start = IsTbss ? Dot + Ctx->ThreadBssOffset : Dot;
   Start = alignTo(Start, Alignment);
   uint64_t End = Start + Size;
 

test/ELF/emit-relocs-eh-frame.s

+# REQUIRES: x86
+# RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %s -o %t1.o
+# RUN: ld.lld --emit-relocs %t1.o -o %t
+# RUN: llvm-readobj -r %t | FileCheck %s
+
+# CHECK:      Relocations [
+# CHECK-NEXT:   Section {{.*}} .rela.eh_frame {
+# CHECK-NEXT:     0x{{.*}} R_X86_64_PC32 .text 0x0
+# CHECK-NEXT:   }
+# CHECK-NEXT: ]
+
+.text
+.globl foo
+foo:
+ .cfi_startproc
+ .cfi_endproc

test/ELF/emit-relocs-shared.s

 # REQUIRES: x86
 # RUN: llvm-mc -filetype=obj -triple=x86_64-pc-linux %s -o %t.o
 # RUN: ld.lld --hash-style=sysv --emit-relocs %t.o -o %t.so -shared
 # RUN: llvm-readobj -r %t.so | FileCheck %s
 
 .data
 .quad foo
 
 # CHECK:      Relocations [
-# CHECK-NEXT:   Section (4) .rela.dyn {
+# CHECK-NEXT:   Section {{.*}} .rela.dyn {
 # CHECK-NEXT:     0x1000 R_X86_64_64 foo 0x0
 # CHECK-NEXT:   }
-# CHECK-NEXT:   Section (8) .rela.data {
+# CHECK-NEXT:   Section {{.*}} .rela.data {
 # CHECK-NEXT:     0x1000 R_X86_64_64 foo 0x0
 # CHECK-NEXT:   }
 # CHECK-NEXT: ]

test/ELF/emit-relocs.s

 # REQUIRES: x86
 # RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %s -o %t1.o
 # RUN: ld.lld --emit-relocs %t1.o -o %t
 # RUN: llvm-readobj -t -r -s %t | FileCheck %s
 
 ## Check single dash form.
 # RUN: ld.lld -emit-relocs %t1.o -o %t1
 # RUN: llvm-readobj -t -r -s %t1 | FileCheck %s
 
 ## Check alias.
 # RUN: ld.lld -q %t1.o -o %t2
 # RUN: llvm-readobj -t -r -s %t2 | FileCheck %s
 
 # CHECK:      Section {
 # CHECK:        Index: 2
-# CHECK-NEXT:   Name: .rela.text
+# CHECK:        Name: .rela.text
 # CHECK-NEXT:   Type: SHT_RELA
 # CHECK-NEXT:   Flags [
 # CHECK-NEXT:     SHF_INFO_LINK
 # CHECK-NEXT:   ]
 # CHECK:      Relocations [
 # CHECK-NEXT:   Section ({{.*}}) .rela.text {
 # CHECK-NEXT:     0x201002 R_X86_64_32 .text 0x1
 # CHECK-NEXT:     0x201007 R_X86_64_PLT32 fn 0xFFFFFFFFFFFFFFFC

test/ELF/linkerscript/eh-frame-emit-relocs.s

+# REQUIRES: x86
+# RUN: echo "SECTIONS { .foo : { *(.eh_frame) } }" > %t.script
+# RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %s -o %t.o
+# RUN: ld.lld --emit-relocs %t.o -T %t.script -o %t
+# RUN: llvm-objdump -section-headers %t | FileCheck %s
+
+# CHECK-NOT: eh_frame
+# CHECK:     .rela.foo
+# CHECK-NOT: eh_frame
+
+.text
+ .cfi_startproc
+ .cfi_endproc