[DEMO]

[grimar]

Summary

For demonstration purposes only.

ELF/InputSection.cpp

void InputSection::replace(InputSection *Other) {
   Other->Repl = this->Repl;
   Other->Live = false;
 }
 
 template <class ELFT>
 EhInputSection::EhInputSection(ObjFile<ELFT> *F,
                                const typename ELFT::Shdr *Header,
                                StringRef Name)
-    : InputSectionBase(F, Header, Name, InputSectionBase::EHFrame) {
-  // Mark .eh_frame sections as live by default because there are
-  // usually no relocations that point to .eh_frames. Otherwise,
-  // the garbage collector would drop all .eh_frame sections.
-  this->Live = true;
-}
+    : InputSectionBase(F, Header, Name, InputSectionBase::EHFrame) {}
 
 SyntheticSection *EhInputSection::getParent() const {
   return cast_or_null<SyntheticSection>(Parent);
 }
 
 // Returns the index of the first relocation that points to a region between
 // Begin and Begin+Size.
 template <class IntTy, class RelTy>

ELF/MarkLive.cpp

static void resolveReloc(InputSectionBase &Sec, RelT &Rel,
   if (!B.isDefined())
     for (InputSectionBase *Sec : CNamedSections.lookup(B.getName()))
       Fn(Sec, 0);
 }
 
 // Calls Fn for each section that Sec refers to via relocations.
 template <class ELFT>
 static void
-forEachSuccessor(InputSection &Sec,
+forEachSuccessor(InputSectionBase &Sec,
                  std::function<void(InputSectionBase *, uint64_t)> Fn) {
   if (Sec.AreRelocsRela) {
     for (const typename ELFT::Rela &Rel : Sec.template relas<ELFT>())
       resolveReloc<ELFT>(Sec, Rel, Fn);
   } else {
     for (const typename ELFT::Rel &Rel : Sec.template rels<ELFT>())
       resolveReloc<ELFT>(Sec, Rel, Fn);
   }
 
   for (InputSectionBase *IS : Sec.DependentSections)
     Fn(IS, 0);
 }
 
-// The .eh_frame section is an unfortunate special case.
-// The section is divided in CIEs and FDEs and the relocations it can have are
-// * CIEs can refer to a personality function.
-// * FDEs can refer to a LSDA
-// * FDEs refer to the function they contain information about
-// The last kind of relocation cannot keep the referred section alive, or they
-// would keep everything alive in a common object file. In fact, each FDE is
-// alive if the section it refers to is alive.
-// To keep things simple, in here we just ignore the last relocation kind. The
-// other two keep the referred section alive.
-//
-// A possible improvement would be to fully process .eh_frame in the middle of
-// the gc pass. With that we would be able to also gc some sections holding
-// LSDAs and personality functions if we found that they were unused.
-template <class ELFT, class RelTy>
-static void
-scanEhFrameSection(EhInputSection &EH, ArrayRef<RelTy> Rels,
-                   std::function<void(InputSectionBase *, uint64_t)> Fn) {
-  const endianness E = ELFT::TargetEndianness;
-
-  for (unsigned I = 0, N = EH.Pieces.size(); I < N; ++I) {
-    EhSectionPiece &Piece = EH.Pieces[I];
-    unsigned FirstRelI = Piece.FirstRelocation;
-    if (FirstRelI == (unsigned)-1)
-      continue;
-    if (read32<E>(Piece.data().data() + 4) == 0) {
-      // This is a CIE, we only need to worry about the first relocation. It is
-      // known to point to the personality function.
-      resolveReloc<ELFT>(EH, Rels[FirstRelI], Fn);
-      continue;
-    }
-    // This is a FDE. The relocations point to the described function or to
-    // a LSDA. We only need to keep the LSDA alive, so ignore anything that
-    // points to executable sections.
-    typename ELFT::uint PieceEnd = Piece.InputOff + Piece.Size;
-    for (unsigned I2 = FirstRelI, N2 = Rels.size(); I2 < N2; ++I2) {
-      const RelTy &Rel = Rels[I2];
-      if (Rel.r_offset >= PieceEnd)
-        break;
-      resolveReloc<ELFT>(EH, Rels[I2],
-                         [&](InputSectionBase *Sec, uint64_t Offset) {
-                           if (Sec && Sec != &InputSection::Discarded &&
-                               !(Sec->Flags & SHF_EXECINSTR))
-                             Fn(Sec, 0);
-                         });
-    }
-  }
-}
-
-template <class ELFT>
-static void
-scanEhFrameSection(EhInputSection &EH,
-                   std::function<void(InputSectionBase *, uint64_t)> Fn) {
-  if (!EH.NumRelocations)
-    return;
-
-  // Unfortunately we need to split .eh_frame early since some relocations in
-  // .eh_frame keep other section alive and some don't.
-  EH.split<ELFT>();
-
-  if (EH.AreRelocsRela)
-    scanEhFrameSection<ELFT>(EH, EH.template relas<ELFT>(), Fn);
-  else
-    scanEhFrameSection<ELFT>(EH, EH.template rels<ELFT>(), Fn);
-}
-
 // Some sections are used directly by the loader, so they should never be
 // garbage-collected. This function returns true if a given section is such
 // section.
 template <class ELFT> static bool isReserved(InputSectionBase *Sec) {
   switch (Sec->Type) {
   case SHT_FINI_ARRAY:
   case SHT_INIT_ARRAY:
   case SHT_NOTE:
   case SHT_PREINIT_ARRAY:
     return true;
   default:
     StringRef S = Sec->Name;
     return S.startswith(".ctors") || S.startswith(".dtors") ||
            S.startswith(".init") || S.startswith(".fini") ||
            S.startswith(".jcr");
   }
 }
 
 // This is the main function of the garbage collector.
 // Starting from GC-root sections, this function visits all reachable
 // sections to set their "Live" bits.
 template <class ELFT> static void doGcSections() {
-  SmallVector<InputSection *, 256> Q;
+  SmallVector<InputSectionBase *, 256> Q;
   CNamedSections.clear();
 
+  DenseMap<InputSectionBase *, EhInputSection *> EhFrameMap;
+  for (InputSectionBase *Sec : InputSections) {
+    EhInputSection *EH = dyn_cast_or_null<EhInputSection>(Sec);
+    if (!EH || !EH->Link)
+      continue;
+    InputSectionBase *TextSec = Sec->getFile<ELFT>()->getSection(EH->Link);
+    EhFrameMap.insert({TextSec, EH});
+  }
+
   auto Enqueue = [&](InputSectionBase *Sec, uint64_t Offset) {
     // Skip over discarded sections. This in theory shouldn't happen, because
     // the ELF spec doesn't allow a relocation to point to a deduplicated
     // COMDAT section directly. Unfortunately this happens in practice (e.g.
     // .eh_frame) so we need to add a check.
     if (Sec == &InputSection::Discarded)
       return;
 
 
     // Usually, a whole section is marked as live or dead, but in mergeable
     // (splittable) sections, each piece of data has independent liveness bit.
     // So we explicitly tell it which offset is in use.
     if (auto *MS = dyn_cast<MergeInputSection>(Sec))
       MS->markLiveAt(Offset);
 
     if (Sec->Live)
       return;
     Sec->Live = true;
 
+    // If text section is live we want to mark as live .eh_frame section it
+    // linked with. We also want to mark LDSA and pesonality routine and
+    // possible depenencies live, so adding .eh_frame to proccessing queue.
+    if (Sec->Flags & SHF_EXECINSTR) {
+      if (InputSectionBase *EH = EhFrameMap.lookup(Sec)) {
+        EH->Live = true;
+        Q.push_back(EH);
+      }
+    }
+
     // Add input section to the queue.
-    if (InputSection *S = dyn_cast<InputSection>(Sec))
-      Q.push_back(S);
+    if (isa<EhInputSection>(Sec) || isa<InputSection>(Sec))
+      Q.push_back(Sec);
   };
 
   auto MarkSymbol = [&](Symbol *Sym) {
     if (auto *D = dyn_cast_or_null<Defined>(Sym))
       if (auto *IS = cast_or_null<InputSectionBase>(D->Section))
         Enqueue(IS, D->Value);
   };
 
template <class ELFT> static void doGcSections() {
   // file can interrupt other ELF file's symbols at runtime.
   for (Symbol *S : Symtab->getSymbols())
     if (S->includeInDynsym())
       MarkSymbol(S);
 
   // Preserve special sections and those which are specified in linker
   // script KEEP command.
   for (InputSectionBase *Sec : InputSections) {
-    // .eh_frame is always marked as live now, but also it can reference to
-    // sections that contain personality. We preserve all non-text sections
-    // referred by .eh_frame here.
+    // We expect .eh_frame sections are linked with correspondent .text sections
+    // and handle such case eariler. Though in real world it can be not true. We
+    // want to keep alive unlinked sections with all dependencies. That is not
+    // ideal as might revive dead code, but allows to avoid scaning of .eh_frame
+    // content and makes implementation simpler.
     if (auto *EH = dyn_cast_or_null<EhInputSection>(Sec))
-      scanEhFrameSection<ELFT>(*EH, Enqueue);
+      if (!EH->Link)
+        Enqueue(EH, 0);
+
     if (Sec->Flags & SHF_LINK_ORDER)
       continue;
     if (isReserved<ELFT>(Sec) || Script->shouldKeep(Sec))
       Enqueue(Sec, 0);
     else if (isValidCIdentifier(Sec->Name)) {
       CNamedSections[Saver.save("__start_" + Sec->Name)].push_back(Sec);
       CNamedSections[Saver.save("__stop_" + Sec->Name)].push_back(Sec);
     }

test/ELF/eh-frame-hdr-icf-fde.s

 # REQUIRES: x86
 
 ## Testcase checks that we correctly deduplicate FDEs when ICF
 ## merges two sections.
 
 # RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %s -o %t
 # RUN: ld.lld %t -o %t2 --icf=all --eh-frame-hdr
 # RUN: llvm-readobj -r %t | FileCheck %s --check-prefix=OBJ
 # RUN: llvm-readobj -s -section-data %t2 | FileCheck %s
 
 # OBJ:      Relocations [
 # OBJ-NEXT:   Section {{.*}} .rela.eh_frame {
 # OBJ-NEXT:     0x20 R_X86_64_PC32 .text.f1 0x0
 # OBJ-NEXT:     0x34 R_X86_64_PC32 .text.f1 0x2
-# OBJ-NEXT:     0x48 R_X86_64_PC32 .text.f2 0x0
-# OBJ-NEXT:     0x5C R_X86_64_PC32 .text.f2 0x2
+# OBJ-NEXT:   }
+# OBJ-NEXT:   Section {{.*}} .rela.eh_frame {
+# OBJ-NEXT:     0x20 R_X86_64_PC32 .text.f2 0x0
+# OBJ-NEXT:     0x34 R_X86_64_PC32 .text.f2 0x2
 # OBJ-NEXT:   }
 # OBJ-NEXT: ]
 
 # CHECK:      Section {
 # CHECK:        Index: 1
 # CHECK:        Name: .eh_frame_hdr
 # CHECK-NEXT:   Type: SHT_PROGBITS
 # CHECK-NEXT:   Flags [

test/ELF/gc-sections-lsda.s

 // REQUIRES: x86
 
 // RUN: llvm-mc %s -o %t.o -filetype=obj -triple=x86_64-pc-linux
 // RUN: ld.lld -shared --gc-sections %t.o -o %t
 
-// Test that we handle .eh_frame keeping sections alive. We could be more
-// precise and gc the entire contents of this file, but test that at least
-// we are consistent: if we keep .abc, we have to keep .foo
+// Test that we keep used LSDA and its references alive and at the same time
+// unused LSDA is dropped and does not keep any sections it uses alive.
 
 // RUN: llvm-readobj -s %t | FileCheck %s
-// CHECK:  Name: .abc
-// CHECK: Name: .foo
+// CHECK-NOT: baz
+// CHECK-NOT: qux
+// CHECK:     foo
+// CHECK:     bar
+// CHECK-NOT: baz
+// CHECK-NOT: qux
 
-        .cfi_startproc
-        .cfi_lsda 0x1b,zed
-        .cfi_endproc
-        .section        .abc,"a"
-zed:
-        .long   bar-.
-        .section        .foo,"ax"
+.section .text.foo,"ax"
+.globl _start
+_start:
+  .cfi_lsda 0x1b,foo
+
+.section .foo,"a"
+foo:
+  .long  bar-.
+
+.section .bar,"ax"
 bar:
+ nop
+
+.section .text.baz,"ax"
+  .cfi_startproc
+  .cfi_lsda 0x1b,baz
+  .cfi_endproc
+
+.section .baz,"a"
+baz:
+  .long  qux-.
+
+.section .qux,"ax"
+qux:
+ nop

test/ELF/relocatable-ehframe.s

 # CHECK-NEXT: EntrySize: 0
 # CHECK-NEXT: SectionData (
 # CHECK-NEXT:   0000: 005F7374 61727400                 |._start.|
 # CHECK-NEXT: )
 
 # CHECK:      Relocations [
 # CHECK-NEXT:   Section {{.*}} .rela.eh_frame {
 # CHECK-NEXT:     0x20 R_X86_64_PC32 foo 0x0
-# CHECK-NEXT:     0x34 R_X86_64_PC32 bar 0x0
-# CHECK-NEXT:     0x48 R_X86_64_PC32 dah 0x0
-# CHECK-NEXT:     0x78 R_X86_64_PC32 foo1 0x0
-# CHECK-NEXT:     0x8C R_X86_64_PC32 bar1 0x0
-# CHECK-NEXT:     0xA0 R_X86_64_PC32 dah1 0x0
+# CHECK-NEXT:     0x50 R_X86_64_PC32 bar 0x0
+# CHECK-NEXT:     0x80 R_X86_64_PC32 dah 0x0
+# CHECK-NEXT:     0xB0 R_X86_64_PC32 foo1 0x0
+# CHECK-NEXT:     0xE0 R_X86_64_PC32 bar1 0x0
+# CHECK-NEXT:     0x110 R_X86_64_PC32 dah1 0x0
 # CHECK-NEXT:   }
 # CHECK-NEXT: ]
 
 .section foo,"ax",@progbits
 .cfi_startproc
  nop
 .cfi_endproc