[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

664

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

664

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 need or want delay handling
+  // of synthetic sections because them are special.
+  for (InputSectionBase *IS : InputSections)
+    if (isa<SyntheticSection>(IS) ||
+        (IS->Type != SHT_REL && IS->Type != SHT_RELA))
+      Add(IS);
+  for (InputSectionBase *IS : InputSections)
+    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

test/ELF/arm-exidx-relocatable.s

 // CHECK-NEXT:      SHF_LINK_ORDER (0x80)
 // CHECK-NEXT:    ]
 // CHECK-NEXT:    Address
 // CHECK-NEXT:    Offset:
 // CHECK-NEXT:    Size: 24
 // CHECK-NEXT:    Link: 1
 
 
-// CHECK:         Index: 4
-// CHECK-NEXT:    Name: .text.f1
+// CHECK:         Index: 3
+// CHECK:         Name: .text.f1
 
 // CHECK:         Name: .ARM.exidx.text.f1
 // CHECK-NEXT:    Type: SHT_ARM_EXIDX (0x70000001)
 // CHECK-NEXT:    Flags [ (0x82)
 // CHECK-NEXT:      SHF_ALLOC (0x2)
 // CHECK-NEXT:      SHF_LINK_ORDER (0x80)
 // CHECK-NEXT:    ]
 // CHECK-NEXT:    Address
 // CHECK-NEXT:    Offset:
 // CHECK-NEXT:    Size: 8
-// CHECK-NEXT:    Link: 4
+// CHECK-NEXT:    Link: 3
 
 
-// CHECK:         Index: 7
+// CHECK:         Index: 5
 // CHECK-NEXT:    Name: .text.f2
 
 // CHECK:         Name: .ARM.exidx.text.f2
 // CHECK-NEXT:    Type: SHT_ARM_EXIDX (0x70000001)
 // CHECK-NEXT:    Flags [ (0x82)
 // CHECK-NEXT:      SHF_ALLOC (0x2)
 // CHECK-NEXT:      SHF_LINK_ORDER (0x80)
 // CHECK-NEXT:    ]
 // CHECK-NEXT:    Address
 // CHECK-NEXT:    Offset:
 // CHECK-NEXT:    Size: 16
-// CHECK-NEXT:    Link: 7
+// CHECK-NEXT:    Link: 5
 
 
-// CHECK:         Index: 10
+// CHECK:         Index: 7
 // CHECK-NEXT:    Name: .func1
 
 // CHECK:         Name: .ARM.exidx.func1
 // CHECK-NEXT:    Type: SHT_ARM_EXIDX (0x70000001)
 // CHECK-NEXT:    Flags [ (0x82)
 // CHECK-NEXT:      SHF_ALLOC (0x2)
 // CHECK-NEXT:      SHF_LINK_ORDER (0x80)
 // CHECK-NEXT:    ]
 // CHECK-NEXT:    Address
 // CHECK-NEXT:    Offset:
 // CHECK-NEXT:    Size: 8
-// CHECK-NEXT:    Link: 10
+// CHECK-NEXT:    Link: 7
 
 
-// CHECK:         Index: 13
+// CHECK:         Index: 9
 // CHECK-NEXT:    Name: .func2
 
 // CHECK:         Name: .ARM.exidx.func2
 // CHECK-NEXT:    Type: SHT_ARM_EXIDX (0x70000001)
 // CHECK-NEXT:    Flags [ (0x82)
 // CHECK-NEXT:      SHF_ALLOC (0x2)
 // CHECK-NEXT:      SHF_LINK_ORDER (0x80)
 // CHECK-NEXT:    ]
 // CHECK-NEXT:    Address
 // CHECK-NEXT:    Offset:
 // CHECK-NEXT:    Size: 8
-// CHECK-NEXT:    Link: 13
+// CHECK-NEXT:    Link: 9
 
 
-// CHECK:         Index: 16
+// CHECK:         Index: 11
 // CHECK-NEXT:    Name: .func3
 
 // CHECK:         Name: .ARM.exidx.func3
 // CHECK-NEXT:    Type: SHT_ARM_EXIDX (0x70000001)
 // CHECK-NEXT:    Flags [ (0x82)
 // CHECK-NEXT:      SHF_ALLOC (0x2)
 // CHECK-NEXT:      SHF_LINK_ORDER (0x80)
 // CHECK-NEXT:    ]
 // CHECK-NEXT:    Address
 // CHECK-NEXT:    Offset:
 // CHECK-NEXT:    Size: 8
-// CHECK-NEXT:    Link: 16
+// CHECK-NEXT:    Link: 11

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
+ .Lfunc_end0:
+ .size foo, .Lfunc_end0-foo
+ .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

test/ELF/relocatable-sections.s

 # REQUIRES: x86
 # RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %s -o %t1.o
 # RUN: ld.lld -r %t1.o -o %t
 # RUN: llvm-objdump -section-headers %t | FileCheck %s
 
-# CHECK:      .text
-# CHECK-NEXT: .rela.text
+# CHECK:  .text
 # CHECK: .text._init
-# CHECK-NEXT: .rela.text._init
 # CHECK: .text._fini
-# CHECK-NEXT: .rela.text._fini
+# CHECK: .rela.text
+# CHECK: .rela.text._init
+# CHECK: .rela.text._fini
 
 .globl _start
 _start:
  call foo
  nop
 
 .section .xxx,"a"
  .quad 0

test/ELF/relocatable.s

 # CHECK-NEXT:  SectionHeaderOffset:
 # CHECK-NEXT:  Flags [
 # CHECK-NEXT:  ]
 # CHECK-NEXT:  HeaderSize: 64
 # CHECK-NEXT:  ProgramHeaderEntrySize: 0
 # CHECK-NEXT:  ProgramHeaderCount: 0
 # CHECK-NEXT:  SectionHeaderEntrySize: 64
 # CHECK-NEXT:  SectionHeaderCount: 7
-# CHECK-NEXT:  StringTableSectionIndex: 5
+# CHECK-NEXT:  StringTableSectionIndex: 4
 # CHECK-NEXT:  }
 
 # CHECK:       Relocations [
 # CHECK-NEXT:  Section ({{.*}}) .rela.text {
 # CHECK-NEXT:    0x3 R_X86_64_32S x 0x0
 # CHECK-NEXT:    0xE R_X86_64_32S y 0x0
 # CHECK-NEXT:    0x23 R_X86_64_32S xx 0x0
 # CHECK-NEXT:    0x2E R_X86_64_32S yy 0x0