[ELF] Scan .eh_frame sections to prepare a dependency tree before traversing alive sections in markLive().

[ikudrin]

Summary

This patch is only intended to check the approach suggested in https://reviews.llvm.org/D37626#882892. It is not well polished.

ELF/EhFrame.h

 
 namespace lld {
 namespace elf {
 class InputSectionBase;
 struct EhSectionPiece;
 
 template <class ELFT> size_t readEhRecordSize(InputSectionBase *S, size_t Off);
 template <class ELFT> uint8_t getFdeEncoding(EhSectionPiece *P);
+template <class ELFT, class RelTy>
+InputSectionBase *getDescribedSection(EhSectionPiece &Fde,
+                                      ArrayRef<RelTy> Rels);
+template <class ELFT, class RelTy>
+bool isFdeLive(EhSectionPiece &Fde, ArrayRef<RelTy> Rels);
 } // namespace elf
 } // namespace lld
 
 #endif

ELF/EhFrame.cpp

 // That means the linker has to understand the format of the section.
 //
 // This file contains a few utility functions to read .eh_frame contents.
 //
 //===----------------------------------------------------------------------===//
 
 #include "EhFrame.h"
 #include "Error.h"
+#include "InputFiles.h"
 #include "InputSection.h"
 #include "Relocations.h"
 #include "Strings.h"
 
 #include "llvm/BinaryFormat/Dwarf.h"
 #include "llvm/Object/ELF.h"
 #include "llvm/Support/Endian.h"
 
if (C == 'L') {
       readByte();
       continue;
     }
     failOn(Aug.data(), "unknown .eh_frame augmentation string: " + Aug);
   }
   return DW_EH_PE_absptr;
 }
 
+// There is one FDE per function. Returns true if a given FDE
+// points to a live function.
+template <class ELFT, class RelTy>
+InputSectionBase *elf::getDescribedSection(EhSectionPiece &Fde,
+                                           ArrayRef<RelTy> Rels) {
+  auto *Sec = cast<EhInputSection>(Fde.Sec);
+  unsigned FirstRelI = Fde.FirstRelocation;
+
+  // An FDE should point to some function because FDEs are to describe
+  // functions. That's however not always the case due to an issue of
+  // ld.gold with -r. ld.gold may discard only functions and leave their
+  // corresponding FDEs, which results in creating bad .eh_frame sections.
+  // To deal with that, we ignore such FDEs.
+  if (FirstRelI == (unsigned)-1)
+    return nullptr;
+
+  const RelTy &Rel = Rels[FirstRelI];
+  SymbolBody &B = Sec->template getFile<ELFT>()->getRelocTargetSym(Rel);
+  if (auto *D = dyn_cast<DefinedRegular>(&B))
+    if (D->Section)
+      return cast<InputSectionBase>(D->Section)->Repl;
+  return nullptr;
+}
+
+// There is one FDE per function. Returns true if a given FDE
+// points to a live function.
+template <class ELFT, class RelTy>
+bool elf::isFdeLive(EhSectionPiece &Fde, ArrayRef<RelTy> Rels) {
+  InputSectionBase *Sec = getDescribedSection<ELFT>(Fde, Rels);
+  return Sec && Sec->Live;
+}
 template size_t elf::readEhRecordSize<ELF32LE>(InputSectionBase *S, size_t Off);
 template size_t elf::readEhRecordSize<ELF32BE>(InputSectionBase *S, size_t Off);
 template size_t elf::readEhRecordSize<ELF64LE>(InputSectionBase *S, size_t Off);
 template size_t elf::readEhRecordSize<ELF64BE>(InputSectionBase *S, size_t Off);
 
 template uint8_t elf::getFdeEncoding<ELF32LE>(EhSectionPiece *P);
 template uint8_t elf::getFdeEncoding<ELF32BE>(EhSectionPiece *P);
 template uint8_t elf::getFdeEncoding<ELF64LE>(EhSectionPiece *P);
 template uint8_t elf::getFdeEncoding<ELF64BE>(EhSectionPiece *P);
+
+template InputSectionBase *
+elf::getDescribedSection<ELF32LE>(EhSectionPiece &Fde,
+                                  ArrayRef<ELF32LE::Rel> Rels);
+template InputSectionBase *
+elf::getDescribedSection<ELF32LE>(EhSectionPiece &Fde,
+                                  ArrayRef<ELF32LE::Rela> Rels);
+template InputSectionBase *
+elf::getDescribedSection<ELF32BE>(EhSectionPiece &Fde,
+                                  ArrayRef<ELF32BE::Rel> Rels);
+template InputSectionBase *
+elf::getDescribedSection<ELF32BE>(EhSectionPiece &Fde,
+                                  ArrayRef<ELF32BE::Rela> Rels);
+template InputSectionBase *
+elf::getDescribedSection<ELF64LE>(EhSectionPiece &Fde,
+                                  ArrayRef<ELF64LE::Rel> Rels);
+template InputSectionBase *
+elf::getDescribedSection<ELF64LE>(EhSectionPiece &Fde,
+                                  ArrayRef<ELF64LE::Rela> Rels);
+template InputSectionBase *
+elf::getDescribedSection<ELF64BE>(EhSectionPiece &Fde,
+                                  ArrayRef<ELF64BE::Rel> Rels);
+template InputSectionBase *
+elf::getDescribedSection<ELF64BE>(EhSectionPiece &Fde,
+                                  ArrayRef<ELF64BE::Rela> Rels);
+
+template bool elf::isFdeLive<ELF32LE>(EhSectionPiece &Fde,
+                                      ArrayRef<ELF32LE::Rel> Rels);
+template bool elf::isFdeLive<ELF32LE>(EhSectionPiece &Fde,
+                                      ArrayRef<ELF32LE::Rela> Rels);
+template bool elf::isFdeLive<ELF32BE>(EhSectionPiece &Fde,
+                                      ArrayRef<ELF32BE::Rel> Rels);
+template bool elf::isFdeLive<ELF32BE>(EhSectionPiece &Fde,
+                                      ArrayRef<ELF32BE::Rela> Rels);
+template bool elf::isFdeLive<ELF64LE>(EhSectionPiece &Fde,
+                                      ArrayRef<ELF64LE::Rel> Rels);
+template bool elf::isFdeLive<ELF64LE>(EhSectionPiece &Fde,
+                                      ArrayRef<ELF64LE::Rela> Rels);
+template bool elf::isFdeLive<ELF64BE>(EhSectionPiece &Fde,
+                                      ArrayRef<ELF64BE::Rel> Rels);
+template bool elf::isFdeLive<ELF64BE>(EhSectionPiece &Fde,
+                                      ArrayRef<ELF64BE::Rela> Rels);

ELF/InputSection.h

private:
   mutable llvm::once_flag InitOffsetMap;
 
   llvm::DenseSet<uint64_t> LiveOffsets;
 };
 
 struct EhSectionPiece {
   EhSectionPiece(size_t Off, InputSectionBase *Sec, uint32_t Size,
                  unsigned FirstRelocation)
-      : InputOff(Off), Sec(Sec), Size(Size), FirstRelocation(FirstRelocation) {}
+      : InputOff(Off), Sec(Sec), Size(Size), Live(!Config->GcSections),
+        FirstRelocation(FirstRelocation) {}
 
   ArrayRef<uint8_t> data() { return {Sec->Data.data() + this->InputOff, Size}; }
 
   size_t InputOff;
   ssize_t OutputOff = -1;
   InputSectionBase *Sec;
-  uint32_t Size;
+  uint32_t Size : 31;
+  uint32_t Live : 1;
   unsigned FirstRelocation;
 };
 
 // This corresponds to a .eh_frame section of an input file.
 class EhInputSection : public InputSectionBase {
 public:
   template <class ELFT>
   EhInputSection(ObjFile<ELFT> *F, const typename ELFT::Shdr *Header,
public:
   void relocateNonAlloc(uint8_t *Buf, llvm::ArrayRef<RelTy> Rels);
 
   // Used by ICF.
   uint32_t Class[2] = {0, 0};
 
   // Called by ICF to merge two input sections.
   void replace(InputSection *Other);
 
+  std::vector<EhSectionPiece *> EhSectionPieces;
+
 private:
   template <class ELFT, class RelTy>
   void copyRelocations(uint8_t *Buf, llvm::ArrayRef<RelTy> Rels);
 
   template <class ELFT> void copyShtGroup(uint8_t *Buf);
 };
 
 // The list of all input sections.

ELF/MarkLive.cpp

 // Here's how it works. Each InputSectionBase has a "Live" bit. The bit is off
 // by default. Starting with GC-root symbols or sections, markLive function
 // defined in this file visits all reachable sections to set their Live
 // bits. Writer will then ignore sections whose Live bits are off, so that
 // such sections are not included into output.
 //
 //===----------------------------------------------------------------------===//
 
+#include "EhFrame.h"
 #include "InputSection.h"
 #include "LinkerScript.h"
 #include "Memory.h"
 #include "OutputSections.h"
 #include "Strings.h"
 #include "SymbolTable.h"
 #include "Symbols.h"
 #include "Target.h"
 #include "Writer.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/Object/ELF.h"
 #include <functional>
 #include <vector>
 
 using namespace llvm;
 using namespace llvm::ELF;
 using namespace llvm::object;
 using namespace llvm::support::endian;
 
 using namespace lld;
 using namespace lld::elf;
 
+namespace {
+class EhFrameSectionCies {
+  std::vector<EhSectionPiece *> Cies;
+
+public:
+  void add(EhSectionPiece *Cie);
+  EhSectionPiece *get(const EhSectionPiece &Fde, uint32_t ID) const;
+};
+}
+
 template <class ELFT>
 static typename ELFT::uint getAddend(InputSectionBase &Sec,
                                      const typename ELFT::Rel &Rel) {
   return Target->getImplicitAddend(Sec.Data.begin() + Rel.r_offset,
                                    Rel.getType(Config->IsMips64EL));
 }
 
 template <class ELFT>
if (Sec.AreRelocsRela) {
     for (const typename ELFT::Rel &Rel : Sec.template rels<ELFT>())
       resolveReloc<ELFT>(Sec, Rel, Fn);
   }
 
   for (InputSectionBase *IS : Sec.DependentSections)
     Fn(IS, 0);
 }
 
+void EhFrameSectionCies::add(EhSectionPiece *Cie) {
+  assert(Cies.empty() || Cies.back()->InputOff < Cie->InputOff);
+  Cies.push_back(Cie);
+}
+
+EhSectionPiece *EhFrameSectionCies::get(const EhSectionPiece &Fde,
+                                        uint32_t ID) const {
+  if (Cies.empty())
+    return nullptr;
+
+  uint32_t CieOffset = Fde.InputOff + 4 - ID;
+
+  // In most cases, a FDE refers to the most recent CIE.
+  if (Cies.back()->InputOff == CieOffset)
+    return Cies.back();
+
+  auto It = std::lower_bound(Cies.begin(), Cies.end(), CieOffset,
+                             [](EhSectionPiece *Cie, uint32_t Offset) {
+                               return Cie->InputOff < Offset;
+                             });
+  if (It != Cies.end() && (*It)->InputOff == CieOffset)
+    return *It;
+
+  return nullptr;
+}
+
+template <class ELFT, class RelTy>
+static void scanFde(EhInputSection &EH, ArrayRef<RelTy> Rels, InputSection *Sec,
+                    const EhSectionPiece &Fde) {
+  const uint64_t FdeEnd = Fde.InputOff + Fde.Size;
+  // The first relocation is known to point to the described function,
+  // so it is safe to skip it when looking for LSDAs.
+  for (unsigned I = Fde.FirstRelocation + 1, N = Rels.size();
+       I < N && Rels[I].r_offset < FdeEnd; ++I)
+    // In a FDE, the relocations point to the described function or to a LSDA.
+    // The described function is already marked and calling Fn for it is safe.
+    // Although the main intent here is to mark LSDAs, we do not need to
+    // recognize them especially and can process all references the same way.
+    resolveReloc<ELFT>(EH, Rels[I], [&](InputSectionBase *S, uint64_t) {
+      if (S && S != &InputSection::Discarded && !(S->Flags & SHF_EXECINSTR))
+        Sec->DependentSections.push_back(S);
+    });
+}
+
+template <class ELFT, class RelTy>
+static void scanCie(EhInputSection &EH, ArrayRef<RelTy> Rels, InputSection *Sec,
+                    const EhSectionPiece &Cie) {
+  if (Cie.FirstRelocation == (unsigned)-1)
+    return;
+
+  // In a CIE, we only need to worry about the first relocation.
+  // It is known to point to the personality function.
+  resolveReloc<ELFT>(EH, Rels[Cie.FirstRelocation],
+                     [&](InputSectionBase *S, uint64_t) {
+                       Sec->DependentSections.push_back(S);
+                     });
+}
+
 // The .eh_frame section is an unfortunate special case.
-// The section is divided in CIEs and FDEs and the relocations it can have are
+// The section is divided in CIEs (Common Information Entries) and FDEs
+// (Frame Description Entries). Each FDE references to a corresponding
+// CIE via ID field, where a relative offset is stored.
+// The relocations the section 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.
+// * FDEs can refer to a LSDA.
+// * FDEs refer to the function they contain information about.
+// The last kind of relocation is used to keep a FDE alive if the section
+// it refers to is alive. In that case, everything which is referenced from
+// that FDE should be marked, including a LSDA, a CIE and a personality
+// function. These sections might reference to other sections, so they
+// are added to the GC queue.
 template <class ELFT, class RelTy>
-static void
-scanEhFrameSection(EhInputSection &EH, ArrayRef<RelTy> Rels,
-                   std::function<void(InputSectionBase *, uint64_t)> Fn) {
+static void scanEhFrameSection(EhInputSection &EH, ArrayRef<RelTy> Rels) {
   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);
+  EhFrameSectionCies Cies;
+  for (EhSectionPiece &Piece : EH.Pieces) {
+    // The empty record is the end marker.
+    if (Piece.Size == 4)
+      return;
+
+    const uint32_t ID = read32<E>(Piece.data().data() + 4);
+    if (ID == 0) {
+      Cies.add(&Piece);
       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);
-                         });
-    }
+
+    InputSection *Sec = dyn_cast_or_null<InputSection>(
+        elf::getDescribedSection<ELFT>(Piece, Rels));
+    if (!Sec || Sec == &InputSection::Discarded)
+      continue;
+    Sec->EhSectionPieces.push_back(&Piece);
+    scanFde<ELFT>(EH, Rels, Sec, Piece);
+
+    // Find the corresponding CIE
+    EhSectionPiece *Cie = Cies.get(Piece, ID);
+    if (!Cie)
+      fatal(toString(&EH) + ": invalid CIE reference");
+    Sec->EhSectionPieces.push_back(Cie);
+    scanCie<ELFT>(EH, Rels, Sec, *Cie);
   }
 }
 
-template <class ELFT>
-static void
-scanEhFrameSection(EhInputSection &EH,
-                   std::function<void(InputSectionBase *, uint64_t)> Fn) {
+template <class ELFT> static void scanEhFrameSection(EhInputSection &EH) {
   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);
+    scanEhFrameSection<ELFT>(EH, EH.template relas<ELFT>());
   else
-    scanEhFrameSection<ELFT>(EH, EH.template rels<ELFT>(), Fn);
+    scanEhFrameSection<ELFT>(EH, EH.template rels<ELFT>());
 }
 
 // We do not garbage-collect two types of sections:
 // 1) Sections used by the loader (.init, .fini, .ctors, .dtors or .jcr)
 // 2) Non-allocatable sections which typically contain debugging information
 template <class ELFT> static bool isReserved(InputSectionBase *Sec) {
   switch (Sec->Type) {
   case SHT_FINI_ARRAY:
auto Enqueue = [&](InputSectionBase *Sec, uint64_t Offset) {
     if (auto *MS = dyn_cast<MergeInputSection>(Sec))
       MS->markLiveAt(Offset);
 
     if (Sec->Live)
       return;
     Sec->Live = true;
 
     // Add input section to the queue.
-    if (InputSection *S = dyn_cast<InputSection>(Sec))
+    if (InputSection *S = dyn_cast<InputSection>(Sec)) {
       Q.push_back(S);
+      for (EhSectionPiece *Piece : S->EhSectionPieces)
+        Piece->Live = true;
+    }
   };
 
   auto MarkSymbol = [&](SymbolBody *Sym) {
     if (auto *D = dyn_cast_or_null<DefinedRegular>(Sym)) {
       if (auto *IS = cast_or_null<InputSectionBase>(D->Section))
         Enqueue(IS, D->Value);
       return;
     }
     if (auto *S = dyn_cast_or_null<DefinedCommon>(Sym))
       S->Live = true;
   };
 
+  for (InputSectionBase *Sec : InputSections) {
+    if (auto *EH = dyn_cast_or_null<EhInputSection>(Sec))
+      scanEhFrameSection<ELFT>(*EH);
+  }
+
   // Add GC root symbols.
   MarkSymbol(Symtab->find(Config->Entry));
   MarkSymbol(Symtab->find(Config->Init));
   MarkSymbol(Symtab->find(Config->Fini));
   for (StringRef S : Config->Undefined)
     MarkSymbol(Symtab->find(S));
   for (StringRef S : Script->Opt.ReferencedSymbols)
     MarkSymbol(Symtab->find(S));
 
   // Preserve externally-visible symbols if the symbols defined by this
   // file can interrupt other ELF file's symbols at runtime.
   for (Symbol *S : Symtab->getSymbols())
     if (S->includeInDynsym())
       MarkSymbol(S->body());
 
   // 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.
-    if (auto *EH = dyn_cast_or_null<EhInputSection>(Sec))
-      scanEhFrameSection<ELFT>(*EH, Enqueue);
     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);
     }

ELF/SyntheticSections.h

 private:
   uint64_t Size = 0;
   template <class RelTy>
   void addSectionAux(EhInputSection *S, llvm::ArrayRef<RelTy> Rels);
 
   template <class RelTy>
   CieRecord *addCie(EhSectionPiece &Piece, ArrayRef<RelTy> Rels);
 
-  template <class RelTy>
-  bool isFdeLive(EhSectionPiece &Piece, ArrayRef<RelTy> Rels);
-
   uint64_t getFdePc(uint8_t *Buf, size_t Off, uint8_t Enc);
 
   std::vector<CieRecord *> CieRecords;
 
   // CIE records are uniquified by their contents and personality functions.
   llvm::DenseMap<std::pair<ArrayRef<uint8_t>, SymbolBody *>, CieRecord *>
       CieMap;
 };

ELF/SyntheticSections.cpp

 // synthetic sections are created either output sections or input sections,
 // but we are rewriting code so that all synthetic sections are created as
 // input sections.
 //
 //===----------------------------------------------------------------------===//
 
 #include "SyntheticSections.h"
 #include "Config.h"
+#include "EhFrame.h"
 #include "Error.h"
 #include "InputFiles.h"
 #include "LinkerScript.h"
 #include "Memory.h"
 #include "OutputSections.h"
 #include "Strings.h"
 #include "SymbolTable.h"
 #include "Target.h"
CieRecord *EhFrameSection<ELFT>::addCie(EhSectionPiece &Cie,
   if (!Rec) {
     Rec = make<CieRecord>();
     Rec->Cie = &Cie;
     CieRecords.push_back(Rec);
   }
   return Rec;
 }
 
-// There is one FDE per function. Returns true if a given FDE
-// points to a live function.
-template <class ELFT>
-template <class RelTy>
-bool EhFrameSection<ELFT>::isFdeLive(EhSectionPiece &Fde,
-                                     ArrayRef<RelTy> Rels) {
-  auto *Sec = cast<EhInputSection>(Fde.Sec);
-  unsigned FirstRelI = Fde.FirstRelocation;
-
-  // An FDE should point to some function because FDEs are to describe
-  // functions. That's however not always the case due to an issue of
-  // ld.gold with -r. ld.gold may discard only functions and leave their
-  // corresponding FDEs, which results in creating bad .eh_frame sections.
-  // To deal with that, we ignore such FDEs.
-  if (FirstRelI == (unsigned)-1)
-    return false;
-
-  const RelTy &Rel = Rels[FirstRelI];
-  SymbolBody &B = Sec->template getFile<ELFT>()->getRelocTargetSym(Rel);
-  if (auto *D = dyn_cast<DefinedRegular>(&B))
-    if (D->Section)
-      return cast<InputSectionBase>(D->Section)->Repl->Live;
-  return false;
-}
-
 // .eh_frame is a sequence of CIE or FDE records. In general, there
 // is one CIE record per input object file which is followed by
 // a list of FDEs. This function searches an existing CIE or create a new
 // one and associates FDEs to the CIE.
 template <class ELFT>
 template <class RelTy>
 void EhFrameSection<ELFT>::addSectionAux(EhInputSection *Sec,
                                          ArrayRef<RelTy> Rels) {
   const endianness E = ELFT::TargetEndianness;
 
   DenseMap<size_t, CieRecord *> OffsetToCie;
   for (EhSectionPiece &Piece : Sec->Pieces) {
     // The empty record is the end marker.
     if (Piece.Size == 4)
       return;
 
+    if (!Piece.Live)
+      continue;
+
     size_t Offset = Piece.InputOff;
     uint32_t ID = read32<E>(Piece.data().data() + 4);
     if (ID == 0) {
       OffsetToCie[Offset] = addCie(Piece, Rels);
       continue;
     }
 
     uint32_t CieOffset = Offset + 4 - ID;
     CieRecord *Rec = OffsetToCie[CieOffset];
     if (!Rec)
       fatal(toString(Sec) + ": invalid CIE reference");
 
-    if (!isFdeLive(Piece, Rels))
+    if (!Config->GcSections && !elf::isFdeLive<ELFT>(Piece, Rels))
       continue;
     Rec->Fdes.push_back(&Piece);
     NumFdes++;
   }
 }
 
 template <class ELFT>
 void EhFrameSection<ELFT>::addSection(InputSectionBase *C) {

test/ELF/eh-frame-gc3.s

+// REQUIRES: x86
+// RUN: llvm-mc -filetype=obj -triple=i686-pc-linux %s -o %t.o
+// RUN: ld.lld %t.o --gc-sections -o %tout
+// RUN: llvm-nm %tout | FileCheck %s
+
+// CHECK:     _start
+// CHECK-NOT: foo
+// CHECK-NOT: lsda
+// CHECK-NOT: personality
+
+        .global _start, foo, lsda, personality
+        .text
+_start:
+        .cfi_startproc
+        nop
+        .cfi_endproc
+
+        .section ".text.foo","ax"
+foo:
+        .cfi_startproc
+        .cfi_personality 0, personality
+        .cfi_lsda 0, .Lexception0
+        nop
+        .cfi_endproc
+
+        .section ".lsda","a"
+        .p2align 2
+.Lexception0:
+lsda:
+        .byte 0
+
+        .section ".text.personality","ax"
+personality:
+        nop

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
 
 // RUN: llvm-readobj -s %t | FileCheck %s
-// CHECK:  Name: .abc
-// CHECK: Name: .foo
+// CHECK:     Name: .abc
+// CHECK-NOT: Name: .abc2
+// CHECK:     Name: .foo
+// CHECK-NOT: Name: .foo2
 
+        .section        .text.func,"ax"
+        .global func
+func:
         .cfi_startproc
         .cfi_lsda 0x1b,zed
         .cfi_endproc
         .section        .abc,"a"
 zed:
         .long   bar-.
         .section        .foo,"ax"
 bar:
+
+// This section is similar to .text.func except that the symbol is local
+// and should be eliminated as such with all dependent sections.
+        .section        .text.func2,"ax"
+func2:
+        .cfi_startproc
+        .cfi_lsda 0x1b,zed2
+        .cfi_endproc
+        .section        .abc2,"a"
+zed2:
+        .long   bar2-.
+        .section        .foo2,"ax"
+bar2: