ELF2: Implement --gc-sections.

[ruiu]

Summary

Section garbage collection is a feature to remove unused sections
from outputs. Unused sections are sections that cannot be reachable
from known GC-root symbols or sections. Naturally the feature is
implemented as a mark-sweep garbage collector.

In this patch, I added Live bit to InputSectionBase. If and only
if Live bit is on, the section will be written to the output.
Starting from GC-root symbols or sections, a new function, markLive(),
visits all reachable sections and sets their Live bits. Writer then
ignores sections whose Live bit is off, so that such sections are
excluded from the output.

This change has small negative impact on performance if you use
the feature. The time to link Clang changes from 0.356s to 0.386s,
or +8%.

It reduces Clang size from 57,764,984 bytes to 55,296,600 bytes.
That is 4.3% reduction.

[ruiu]

Remove debug code.

[• rafael]

Just applied the patch locally to review it. There are a few
formatting issues. Please git-clang-format.

[• rafael]

I am also getting a test failure:

Command Output (stderr):

<stdin>:178:2: error: GC-NOT: string occurred!
Name: x (3)
^
/home/espindola/llvm/lld/test/elf2/gc-sections.s:24:11: note: GC-NOT:
pattern specified here

1. GC-NOT: Name: x

[ruiu]

• Fix formatting
• Fix test

[• rafael]

ELF/MarkLive.cpp

68

Can you check anything other than the name? The section type or flags maybe?

96

]You only need to do this if you are producing a shared library or --export-dynamic is used.

ELF/Writer.cpp

425

Can you check for "this == &InputSection<ELFT>::Discarded" in isLive?

[ruiu]

ELF/MarkLive.cpp

68

This list may be limited but I don't know what other sections need to be preserved.

gold seems to preserve more sections (https://sourceware.org/git/gitweb.cgi?p=binutils-gdb.git;a=blob;f=gold/object.cc;h=76d4630d16a8cfbe445f421250798c3438aa48e4;hb=HEAD#l353). I didn't copy that as I don't know the rational for some sections listed there.

96

Externally visible symbols might be used later at runtime to interpose symbols provided by DSOs, no?

[ruiu]

ELF/Writer.cpp

425

We can, but I'm not sure if that's the right thing to do. Section merging and garbage collection are basically orthogonal, so hiding one thing behind the other's predicate may be confusing.

[ruiu]

By the way, do you think there's a better way to visit all successors than the way I did in MarkLive? I think the code is not bad (forEachSuccessor and doForEachSuccessor are about 40 lines in total), but I feel that the code is a bit awkward. Is there any way to iterate over both REL and RELA relocations without using templates? Is there a better way to visit both non-local and local symbols?

[joerg]

ELF/MarkLive.cpp

68

Note sections are rather obvious, you shouldn't be getting a working binary on many platforms otherwise. Exceptions and JCR are similar. Preinit is a variant of the existing init theme.

I'm not sure why personality functions and nptl_version are special cased. The latter sounds like a glibc specific hack and personality functions should normally be referenced from the exception table. ARM issue perhaps?

[• rafael]

Can you check anything other than the name? The section type or flags maybe?

This list may be limited but I don't know what other sections need to be preserved.

I don't mean to preserve less sections. Just how we check them. Of your list:

• .ctors, .dtors: I think we have to use the name.
• .fini: Check SHT_INIT_ARRAY
• .init: Check SHT_FINI_ARRAY
• .note: Check SHT_NOTE

You also need a check for SHT_PREINIT_ARRAY.

Externally visible symbols might be used later at runtime to interpose symbols provided by DSOs, no?

You can't interpose if it is already in the main binary, and if a
shared library wants symbols from the binary, the binary must be
linked with --export-dynamic.

Cheers,
Rafael

[ruiu]

USE sh_type instead of section name.

[• rafael]

LGTM with the "Preserve externally-visible symbols." part changed to only do it for -shared and -export-dynamic.

[Eugene.Zelenko]

Committed in r251043.

ELF/CMakeLists.txt

 set(LLVM_TARGET_DEFINITIONS Options.td)
 tablegen(LLVM Options.inc -gen-opt-parser-defs)
 add_public_tablegen_target(ELFOptionsTableGen)
 
 add_llvm_library(lldELF2
   Driver.cpp
   DriverUtils.cpp
   Error.cpp
   InputFiles.cpp
   InputSection.cpp
   LinkerScript.cpp
+  MarkLive.cpp
   OutputSections.cpp
   SymbolTable.cpp
   Symbols.cpp
   Target.cpp
   Writer.cpp
 
   LINK_COMPONENTS
   Object
   Option
   MC
   Support
   )
 
 add_dependencies(lldELF2 ELFOptionsTableGen)

ELF/Config.h

struct Configuration {
   bool AllowMultipleDefinition;
   bool AsNeeded = false;
   bool Bsymbolic;
   bool DiscardAll;
   bool DiscardLocals;
   bool DiscardNone;
   bool EnableNewDtags;
   bool ExportDynamic;
+  bool GcSections;
   bool Mips64EL = false;
   bool NoInhibitExec;
   bool NoUndefined;
   bool Shared;
   bool Static = false;
   bool Verbose;
   bool ZNodelete = false;
   bool ZNow = false;

ELF/Driver.cpp

void LinkerDriver::createFiles(opt::InputArgList &Args) {
 
   Config->AllowMultipleDefinition = Args.hasArg(OPT_allow_multiple_definition);
   Config->Bsymbolic = Args.hasArg(OPT_Bsymbolic);
   Config->DiscardAll = Args.hasArg(OPT_discard_all);
   Config->DiscardLocals = Args.hasArg(OPT_discard_locals);
   Config->DiscardNone = Args.hasArg(OPT_discard_none);
   Config->EnableNewDtags = !Args.hasArg(OPT_disable_new_dtags);
   Config->ExportDynamic = Args.hasArg(OPT_export_dynamic);
+  Config->GcSections = Args.hasArg(OPT_gc_sections);
   Config->NoInhibitExec = Args.hasArg(OPT_noinhibit_exec);
   Config->NoUndefined = Args.hasArg(OPT_no_undefined);
   Config->Shared = Args.hasArg(OPT_shared);
   Config->Verbose = Args.hasArg(OPT_verbose);
 
   Config->DynamicLinker = getString(Args, OPT_dynamic_linker);
   Config->Entry = getString(Args, OPT_entry);
   Config->Fini = getString(Args, OPT_fini, "_fini");
template <class ELFT> void LinkerDriver::link(opt::InputArgList &Args) {
   for (StringRef S : Config->Undefined)
     Symtab.addUndefinedOpt(S);
 
   if (Config->OutputFile.empty())
     Config->OutputFile = "a.out";
 
   // Write the result to the file.
   Symtab.scanShlibUndefined();
+  if (Config->GcSections)
+    markLive<ELFT>(&Symtab);
   writeResult<ELFT>(&Symtab);
 }

ELF/InputFiles.h

public:
   SymbolBody *getSymbolBody(uint32_t SymbolIndex) const {
     uint32_t FirstNonLocal = this->Symtab->sh_info;
     if (SymbolIndex < FirstNonLocal)
       return nullptr;
     return this->SymbolBodies[SymbolIndex - FirstNonLocal];
   }
 
   Elf_Sym_Range getLocalSymbols();
+  const Elf_Sym *getLocalSymbol(uintX_t SymIndex);
 
   const Elf_Shdr *getSymbolTable() const { return this->Symtab; };
   ArrayRef<Elf_Word> getSymbolTableShndx() const { return SymtabSHNDX; };
 
 private:
   void initializeSections(llvm::DenseSet<StringRef> &Comdats);
   void initializeSymbols();
 

ELF/InputFiles.cpp

ObjectFile<ELFT>::ObjectFile(MemoryBufferRef M)
     : ELFFileBase<ELFT>(Base::ObjectKind, M) {}
 
 template <class ELFT>
 typename ObjectFile<ELFT>::Elf_Sym_Range ObjectFile<ELFT>::getLocalSymbols() {
   return this->getSymbolsHelper(true);
 }
 
 template <class ELFT>
+const typename ObjectFile<ELFT>::Elf_Sym *
+ObjectFile<ELFT>::getLocalSymbol(uintX_t SymIndex) {
+  uint32_t FirstNonLocal = this->Symtab->sh_info;
+  if (SymIndex >= FirstNonLocal)
+    return nullptr;
+  Elf_Sym_Range Syms = this->ELFObj.symbols(this->Symtab);
+  return Syms.begin() + SymIndex;
+}
+
+template <class ELFT>
 void elf2::ObjectFile<ELFT>::parse(DenseSet<StringRef> &Comdats) {
   // Read section and symbol tables.
   initializeSections(Comdats);
   initializeSymbols();
 }
 
 template <class ELFT>
 StringRef ObjectFile<ELFT>::getShtGroupSignature(const Elf_Shdr &Sec) {

ELF/InputSection.h

 //===- InputSection.h -------------------------------------------*- C++ -*-===//
 //
 //                             The LLVM Linker
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLD_ELF_INPUT_SECTION_H
 #define LLD_ELF_INPUT_SECTION_H
 
+#include "Config.h"
 #include "lld/Core/LLVM.h"
 #include "llvm/Object/ELF.h"
 
 namespace lld {
 namespace elf2 {
 
 template <class ELFT> class ObjectFile;
 template <class ELFT> class OutputSection;

 public:
   enum Kind { Regular, Merge };
   Kind SectionKind;
 
   InputSectionBase(ObjectFile<ELFT> *File, const Elf_Shdr *Header,
                    Kind SectionKind);
   OutputSectionBase<ELFT> *OutSec = nullptr;
 
+  // Used for garbage collection.
+  // Live bit makes sense only when Config->GcSections is true.
+  bool isLive() const { return !Config->GcSections || Live; }
+  bool Live = false;
+
   // Returns the size of this section (even if this is a common or BSS.)
   size_t getSize() const { return Header->sh_size; }
 
   static InputSectionBase<ELFT> Discarded;
 
   StringRef getSectionName() const;
   const Elf_Shdr *getSectionHdr() const { return Header; }
   ObjectFile<ELFT> *getFile() const { return File; }

ELF/MarkLive.cpp

+//===- MarkLive.cpp -------------------------------------------------------===//
+//
+//                             The LLVM Linker
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "InputSection.h"
+#include "OutputSections.h"
+#include "SymbolTable.h"
+#include "Symbols.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 lld;
+using namespace lld::elf2;
+
+template <class ELFT, bool isRela>
+static void
+doForEachSuccessor(InputSectionBase<ELFT> *Sec,
+                   std::function<void(InputSectionBase<ELFT> *)> Fn,
+                   iterator_range<const Elf_Rel_Impl<ELFT, isRela> *> Rels) {
+  typedef typename ELFFile<ELFT>::Elf_Sym Elf_Sym;
+  typedef Elf_Rel_Impl<ELFT, isRela> RelType;
+
+  ObjectFile<ELFT> *File = Sec->getFile();
+  for (const RelType &RI : Rels) {
+    // Global symbol
+    uint32_t SymIndex = RI.getSymbol(Config->Mips64EL);
+    if (SymbolBody *B = File->getSymbolBody(SymIndex)) {
+      if (auto *D = dyn_cast<DefinedRegular<ELFT>>(B->repl()))
+        Fn(&D->Section);
+      continue;
+    }
+    // Local symbol
+    if (const Elf_Sym *Sym = File->getLocalSymbol(SymIndex))
+      if (InputSectionBase<ELFT> *Sec = File->getSection(*Sym))
+        Fn(Sec);
+  }
+}
+
+// Calls Fn for each section that Sec refers to.
+template <class ELFT>
+static void forEachSuccessor(InputSection<ELFT> *Sec,
+                             std::function<void(InputSectionBase<ELFT> *)> Fn) {
+  typedef typename ELFFile<ELFT>::Elf_Shdr Elf_Shdr;
+  for (const Elf_Shdr *RelSec : Sec->RelocSections) {
+    if (RelSec->sh_type == SHT_RELA)
+      doForEachSuccessor(Sec, Fn, Sec->getFile()->getObj().relas(RelSec));
+    else
+      doForEachSuccessor(Sec, Fn, Sec->getFile()->getObj().rels(RelSec));
+  }
+}
+
+// Sections listed below are special because they are used by the loader
+// just by being in an ELF file. They should not be garbage-collected.
+template <class ELFT> static bool isReserved(InputSectionBase<ELFT> *Sec) {
+  switch (Sec->getSectionHdr()->sh_type) {
+  case SHT_FINI_ARRAY:
+  case SHT_INIT_ARRAY:
+  case SHT_NOTE:
+  case SHT_PREINIT_ARRAY:
+    return true;
+  default:
+    StringRef S = Sec->getSectionName();
+    return S.startswith(".ctors") || S.startswith(".dtors");
+  }
+}
+
+template <class ELFT> void lld::elf2::markLive(SymbolTable<ELFT> *Symtab) {
+  SmallVector<InputSectionBase<ELFT> *, 256> Q;
+
+  auto Enqueue = [&](InputSectionBase<ELFT> *Sec) {
+    if (!Sec || Sec->Live)
+      return;
+    Sec->Live = true;
+    Q.push_back(Sec);
+  };
+
+  auto MarkSymbol = [&](SymbolBody *Sym) {
+    if (Sym)
+      if (auto *D = dyn_cast_or_null<DefinedRegular<ELFT>>(Sym->repl()))
+        Enqueue(&D->Section);
+  };
+
+  // Add GC root symbols.
+  MarkSymbol(Config->EntrySym);
+  MarkSymbol(Symtab->find(Config->Init));
+  MarkSymbol(Symtab->find(Config->Fini));
+  for (StringRef S : Config->Undefined)
+    MarkSymbol(Symtab->find(S));
+
+  // Preserve externally-visible symbols.
+  for (const std::pair<StringRef, Symbol *> &P : Symtab->getSymbols()) {
+    SymbolBody *B = P.second->Body;
+    if (B->getVisibility() == STV_DEFAULT)
+      MarkSymbol(B);
+  }
+
+  // Sections with special names should not be removed by GC.
+  for (const std::unique_ptr<ObjectFile<ELFT>> &F : Symtab->getObjectFiles())
+    for (InputSectionBase<ELFT> *Sec : F->getSections())
+      if (Sec && Sec != &InputSection<ELFT>::Discarded)
+        if (isReserved(Sec))
+          Enqueue(Sec);
+
+  // Mark all reachable sections.
+  while (!Q.empty())
+    if (auto *Sec = dyn_cast<InputSection<ELFT>>(Q.pop_back_val()))
+      forEachSuccessor<ELFT>(Sec, Enqueue);
+}
+
+template void lld::elf2::markLive<ELF32LE>(SymbolTable<ELF32LE> *);
+template void lld::elf2::markLive<ELF32BE>(SymbolTable<ELF32BE> *);
+template void lld::elf2::markLive<ELF64LE>(SymbolTable<ELF64LE> *);
+template void lld::elf2::markLive<ELF64BE>(SymbolTable<ELF64BE> *);

ELF/Options.td

def entry : Separate<["--", "-"], "entry">, MetaVarName<"<entry>">,
   HelpText<"Name of entry point symbol">;
 
 def export_dynamic : Flag<["--", "-"], "export-dynamic">,
   HelpText<"Put symbols in the dynamic symbol table">;
 
 def fini : Separate<["-"], "fini">, MetaVarName<"<symbol>">,
   HelpText<"Specify a finalizer function">;
 
+def gc_sections : Flag<["--"], "gc-sections">,
+  HelpText<"Enable garbage collection of unused sections">;
+
 def init : Separate<["-"], "init">, MetaVarName<"<symbol>">,
   HelpText<"Specify an initializer function">;
 
 def l : JoinedOrSeparate<["-"], "l">, MetaVarName<"<libName>">,
   HelpText<"Root name of library to use">;
 
 def m : Separate<["-"], "m">,
   HelpText<"Set target emulation">;

 def alias_undefined_u : Separate<["-"], "u">, Alias<undefined>;
 
 // Options listed below are silently ignored now.
 def O3 : Flag<["-"], "O3">;
 def build_id : Flag<["--"], "build-id">;
 def eh_frame_hdr : Flag<["--"], "eh-frame-hdr">;
 def end_group : Flag<["--"], "end-group">;
 def fatal_warnings : Flag<["--"], "fatal-warnings">;
-def gc_sections : Flag<["--"], "gc-sections">;
 def hash_style : Joined<["--"], "hash-style=">;
 def no_add_needed : Flag<["--"], "no-add-needed">;
 def no_fatal_warnings : Flag<["--"], "no-fatal-warnings">;
 def no_warn_mismatch : Flag<["--"], "no-warn-mismatch">;
 def start_group : Flag<["--"], "start-group">;
 def strip_all : Flag<["--"], "strip-all">;
 def version_script : Separate<["--"], "version-script">;
 def warn_common : Flag<["--"], "warn-common">;
 def warn_shared_textrel : Flag<["--"], "warn-shared-textrel">;

ELF/OutputSections.cpp

for (const std::unique_ptr<ObjectFile<ELFT>> &File : Table.getObjectFiles()) {
     for (const Elf_Sym &Sym : Syms) {
       ErrorOr<StringRef> SymNameOrErr = Sym.getName(File->getStringTable());
       error(SymNameOrErr);
       StringRef SymName = *SymNameOrErr;
       if (!shouldKeepInSymtab<ELFT>(*File, SymName, Sym))
         continue;
 
       auto *ESym = reinterpret_cast<Elf_Sym *>(Buf);
-      Buf += sizeof(*ESym);
-      ESym->st_name = StrTabSec.getFileOff(SymName);
-      ESym->st_size = Sym.st_size;
-      ESym->setBindingAndType(Sym.getBinding(), Sym.getType());
       uintX_t VA = 0;
       if (Sym.st_shndx == SHN_ABS) {
         ESym->st_shndx = SHN_ABS;
         VA = Sym.st_value;
       } else {
         const InputSectionBase<ELFT> *Section = File->getSection(Sym);
+        if (!Section->isLive())
+          continue;
         const OutputSectionBase<ELFT> *OutSec = Section->OutSec;
         ESym->st_shndx = OutSec->SectionIndex;
         VA += OutSec->getVA() + Section->getOffset(Sym);
       }
+      ESym->st_name = StrTabSec.getFileOff(SymName);
+      ESym->st_size = Sym.st_size;
+      ESym->setBindingAndType(Sym.getBinding(), Sym.getType());
       ESym->st_value = VA;
+      Buf += sizeof(*ESym);
     }
   }
 }
 
 template <class ELFT>
 void SymbolTableSection<ELFT>::writeGlobalSymbols(uint8_t *Buf) {
   // Write the internal symbol table contents to the output symbol table
   // pointed by Buf.
   auto *ESym = reinterpret_cast<Elf_Sym *>(Buf);
   for (SymbolBody *Body : Symbols) {
-    StringRef Name = Body->getName();
-
-    ESym->st_name = StrTabSec.getFileOff(Name);
-
     const OutputSectionBase<ELFT> *OutSec = nullptr;
-    const InputSectionBase<ELFT> *Section = nullptr;
 
     switch (Body->kind()) {
     case SymbolBody::DefinedSyntheticKind:
       OutSec = &cast<DefinedSynthetic<ELFT>>(Body)->Section;
       break;
-    case SymbolBody::DefinedRegularKind:
-      Section = &cast<DefinedRegular<ELFT>>(Body)->Section;
+    case SymbolBody::DefinedRegularKind: {
+      auto *Sym = cast<DefinedRegular<ELFT>>(Body->repl());
+      if (!Sym->Section.isLive())
+        continue;
+      OutSec = Sym->Section.OutSec;
       break;
+    }
     case SymbolBody::DefinedCommonKind:
       OutSec = Out<ELFT>::Bss;
       break;
     case SymbolBody::UndefinedKind:
     case SymbolBody::DefinedAbsoluteKind:
     case SymbolBody::SharedKind:
     case SymbolBody::LazyKind:
       break;
     }
 
+    StringRef Name = Body->getName();
+    ESym->st_name = StrTabSec.getFileOff(Name);
+
     unsigned char Type = STT_NOTYPE;
     uintX_t Size = 0;
     if (const auto *EBody = dyn_cast<ELFSymbolBody<ELFT>>(Body)) {
       const Elf_Sym &InputSym = EBody->Sym;
       Type = InputSym.getType();
       Size = InputSym.st_size;
     }
 
     ESym->setBindingAndType(getSymbolBinding(Body), Type);
     ESym->st_size = Size;
     ESym->setVisibility(Body->getVisibility());
     ESym->st_value = getSymVA<ELFT>(*Body);
 
-    if (Section)
-      OutSec = Section->OutSec;
-
     if (isa<DefinedAbsolute<ELFT>>(Body))
       ESym->st_shndx = SHN_ABS;
     else if (OutSec)
       ESym->st_shndx = OutSec->SectionIndex;
 
     ++ESym;
   }
 }

ELF/SymbolTable.h

public:
 
   SymbolBody *addUndefined(StringRef Name);
   SymbolBody *addUndefinedOpt(StringRef Name);
   void addSyntheticSym(StringRef Name, OutputSectionBase<ELFT> &Section,
                        typename llvm::object::ELFFile<ELFT>::uintX_t Value);
   void addIgnoredSym(StringRef Name);
   bool isUndefined(StringRef Name);
   void scanShlibUndefined();
+  SymbolBody *find(StringRef Name);
 
 private:
   Symbol *insert(SymbolBody *New);
   void addELFFile(ELFFileBase<ELFT> *File);
   void addLazy(Lazy *New);
   void addMemberFile(Lazy *Body);
   void checkCompatibility(std::unique_ptr<InputFile> &File);
   void resolve(SymbolBody *Body);
-  SymbolBody *find(StringRef Name);
   void reportConflict(const Twine &Message, const SymbolBody &Old,
                       const SymbolBody &New, bool Warning);
 
   std::vector<std::unique_ptr<InputFile>> ArchiveFiles;
 
   // The order the global symbols are in is not defined. We can use an arbitrary
   // order, but it has to be reproducible. That is true even when cross linking.
   // The default hashing of StringRef produces different results on 32 and 64

ELF/Symbols.h

public:
   DefinedRegular(StringRef N, const Elf_Sym &Sym,
                  InputSectionBase<ELFT> &Section)
       : Defined<ELFT>(Base::DefinedRegularKind, N, Sym), Section(Section) {}
 
   static bool classof(const SymbolBody *S) {
     return S->kind() == Base::DefinedRegularKind;
   }
 
-  const InputSectionBase<ELFT> &Section;
+  InputSectionBase<ELFT> &Section;
 };
 
 template <class ELFT> class DefinedSynthetic : public Defined<ELFT> {
   typedef Defined<ELFT> Base;
 
 public:
   typedef typename Base::Elf_Sym Elf_Sym;
   DefinedSynthetic(StringRef N, const Elf_Sym &Sym,

ELF/Writer.h

 #define LLD_ELF_WRITER_H
 
 namespace lld {
 namespace elf2 {
 
 template <class ELFT> class SymbolTable;
 
 template <class ELFT> void writeResult(SymbolTable<ELFT> *Symtab);
+
+template <class ELFT> void markLive(SymbolTable<ELFT> *Symtab);
 }
 }
 
 #endif

ELF/Writer.cpp

template <class ELFT> void Writer<ELFT>::createSections() {
   OutputSections.push_back(Out<ELFT>::Bss);
   Map[{Out<ELFT>::Bss->getName(), Out<ELFT>::Bss->getType(),
        Out<ELFT>::Bss->getFlags(), 0}] = Out<ELFT>::Bss;
 
   std::vector<OutputSectionBase<ELFT> *> RegularSections;
 
   for (const std::unique_ptr<ObjectFile<ELFT>> &F : Symtab.getObjectFiles()) {
     for (InputSectionBase<ELFT> *C : F->getSections()) {
-      if (!C || C == &InputSection<ELFT>::Discarded)
+      if (!C || !C->isLive() || C == &InputSection<ELFT>::Discarded)
         continue;
       const Elf_Shdr *H = C->getSectionHdr();
       uintX_t OutFlags = H->sh_flags & ~SHF_GROUP;
       // For SHF_MERGE we create different output sections for each sh_entsize.
       // This makes each output section simple and keeps a single level
       // mapping from input to output.
       auto *IS = dyn_cast<InputSection<ELFT>>(C);
       uintX_t EntSize = IS ? 0 : H->sh_entsize;
if (!isOutputDynamic())
     Symtab.addIgnoredSym("__tls_get_addr");
 
   // Scan relocations. This must be done after every symbol is declared so that
   // we can correctly decide if a dynamic relocation is needed.
   for (const std::unique_ptr<ObjectFile<ELFT>> &F : Symtab.getObjectFiles())
     for (InputSectionBase<ELFT> *B : F->getSections())
       if (auto *S = dyn_cast_or_null<InputSection<ELFT>>(B))
         if (S != &InputSection<ELFT>::Discarded)
+          if (S->isLive())
             scanRelocs(*S);
 
   // FIXME: Try to avoid the extra walk over all global symbols.
   std::vector<DefinedCommon<ELFT> *> CommonSymbols;
   for (auto &P : Symtab.getSymbols()) {
     SymbolBody *Body = P.second->Body;
     if (auto *U = dyn_cast<Undefined<ELFT>>(Body))
       if (!U->isWeak() && !U->canKeepUndefined())
         reportUndefined<ELFT>(Symtab, *Body);

test/elf2/gc-sections.s

+# REQUIRES: x86
+
+# RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %s -o %t
+# RUN: ld.lld2 %t -o %t2
+# RUN: llvm-readobj -sections -symbols %t2 | FileCheck -check-prefix=NOGC %s
+# RUN: ld.lld2 --gc-sections %t -o %t2
+# RUN: llvm-readobj -sections -symbols %t2 | FileCheck -check-prefix=GC %s
+
+# NOGC: Name: .text
+# NOGC: Name: .init
+# NOGC: Name: .fini
+# NOGC: Name: a
+# NOGC: Name: b
+# NOGC: Name: c
+# NOGC: Name: x
+# NOGC: Name: y
+# NOGC: Name: __preinit_array_start
+# NOGC: Name: __preinit_array_end
+# NOGC: Name: d
+
+# GC:     Name: .text
+# GC:     Name: .init
+# GC:     Name: .fini
+# GC:     Name: a
+# GC:     Name: b
+# GC:     Name: c
+# GC-NOT: Name: x
+# GC-NOT: Name: y
+# GC:     Name: __preinit_array_start
+# GC:     Name: __preinit_array_end
+# GC:     Name: d
+
+.globl _start, d
+.protected a, b, c, x, y
+_start:
+  call a
+
+.section .text.a,"ax",@progbits
+a:
+  call _start
+  call b
+
+.section .text.b,"ax",@progbits
+b:
+  call c
+
+.section .text.c,"ax",@progbits
+c:
+  nop
+
+.section .text.d,"ax",@progbits
+d:
+  nop
+
+.section .text.x,"ax",@progbits
+x:
+  call y
+
+.section .text.y,"ax",@progbits
+y:
+  call x
+
+.section .init,"aw",@init_array
+  .quad 0
+
+.section .fini,"aw",@fini_array
+  .quad 0
+
+.section .preinit_array,"aw",@preinit_array
+  .quad 0