Handle .eh_frame pointing to discarded section in -r

[pcc]

Unfortunately this isn't enough to fix the Go bindings tests, it causes the final link to fail with a different error:

bin/ld.lld: error: /tmp/lit_tmp_Sxmw_u/go-link-243494992/000000.o:(.eh_frame): FDE doesn't reference another section

You can reproduce it with your test case like this:

$ ra/bin/ld.lld ra/tools/lld/test/ELF/Output/relocatable-eh-frame.s.tmp
ra/bin/ld.lld: error: ra/tools/lld/test/ELF/Output/relocatable-eh-frame.s.tmp:(.eh_frame): FDE doesn't reference another section

or just pass in the _all.o from the reproducer I posted earlier.

Perhaps the simplest thing to do would be to relax the FDE checking during regular links? That doesn't sound very appealing though.

[pcc]

This does seem reasonable on its own though if we wanted to go the route of stripping FDEs without function relocations during regular links. If we did that we could accept object files produced using "ld.gold -r" as well.

[• espindola]

295133

ELF/InputSection.cpp

for (const RelTy &Rel : Rels) {
     if (Config->Rela)
       P->r_addend = getAddend<ELFT>(Rel);
 
     if (Body.Type == STT_SECTION) {
       // We combine multiple section symbols into only one per
       // section. This means we have to update the addend. That is
       // trivial for Elf_Rela, but for Elf_Rel we have to write to the
       // section data. We do that by adding to the Relocation vector.
+
+      // .eh_frame is horribly special and can reference discarded sections. To
+      // avoid having to parse and recreate .eh_frame, we just replace any
+      // relocation in it pointing to discarded sections with R_*_NONE, which
+      // hopefully creates a frame that is ignored at runtime.
+      InputSectionBase<ELFT> *Section =
+          cast<DefinedRegular<ELFT>>(Body).Section;
+      if (Section == &InputSection<ELFT>::Discarded) {
+        P->setSymbolAndType(0, 0, false);
+        continue;
+      }
+
       if (Config->Rela) {
-        P->r_addend += Body.getVA<ELFT>() -
-                       cast<DefinedRegular<ELFT>>(Body).Section->OutSec->Addr;
+        P->r_addend += Body.getVA<ELFT>() - Section->OutSec->Addr;
       } else if (Config->Relocatable) {
         const uint8_t *BufLoc = RelocatedSection->Data.begin() + Rel.r_offset;
         uint64_t Implicit = Target->getImplicitAddend(BufLoc, Type);
         RelocatedSection->Relocations.push_back(
             {R_ABS, Type, Rel.r_offset, Implicit, &Body});
       }
     }
 

test/ELF/relocatable-eh-frame.s

+# REQUIRES: x86
+# RUN: llvm-mc -filetype=obj -triple=x86_64-pc-linux %s -o %t.o
+# RUN: ld.lld -r %t.o %t.o -o %t
+# RUN: llvm-readobj -r %t | FileCheck %s
+
+# CHECK:      Relocations [
+# CHECK-NEXT:   Section ({{.*}}) .rela.eh_frame {
+# CHECK-NEXT:     0x20 R_X86_64_PC32 .foo 0x0
+# CHECK-NEXT:     0x0 R_X86_64_NONE - 0x0
+# CHECK-NEXT:   }
+# CHECK-NEXT: ]
+
+.section .foo,"aG",@progbits,bar,comdat
+.cfi_startproc
+.cfi_endproc