Mark non-alloc sections after marking alloc sections

[ruiu]

Summary

Previously, we mark non-alloc sections except debug info sections,
mark alloc sections, and optionally mark debug sections. This patch
simplifies the step by marking alloc sections first.

This patch also updates comments.

[ruiu]

• remove dead code

[rocallahan]

lld/ELF/InputFiles.h

241

This comment seems to get the meaning of the boolean the wrong way around? It's safe to discard debuginfo when this is *false*.

[ruiu]

• address review comment

lld/ELF/InputFiles.h

public:
   // True if the file defines functions compiled with
   // -fsplit-stack. Usually false.
   bool SplitStack = false;
 
   // True if the file defines functions compiled with -fsplit-stack,
   // but had one or more functions with the no_split_stack attribute.
   bool SomeNoSplitStack = false;
 
-  // True if the file has any live Regular or Merge sections that aren't
-  // the LDSA section.
+  // True if the garbage-collector find it safe to discard all debug info
+  // sections from this file. This happens when no code or data sections
+  // in this file are reachable, with an exceptions of .eh_frame which is
+  // handled in a special way by gc.
   bool HasLiveCodeOrData = false;
 
   // Pointer to this input file's .llvm_addrsig section, if it has one.
   const Elf_Shdr *AddrsigSec = nullptr;
 
   // SHT_LLVM_CALL_GRAPH_PROFILE table
   ArrayRef<Elf_CGProfile> CGProfile;
 
 private:

lld/ELF/MarkLive.cpp

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->getSectionPiece(Offset)->Live = true;
 
-  InputSection *S = dyn_cast<InputSection>(Sec);
   // LSDA does not count as "live code or data" in the object file.
   // The section may already have been marked live for LSDA in which
   // case we still need to mark the file.
-  if (S && !IsLSDA && Sec->File)
+  if (Sec->File && !IsLSDA)
     Sec->getFile<ELFT>()->HasLiveCodeOrData = true;
 
   if (Sec->Live)
     return;
 
   Sec->Live = true;
+
   // Add input section to the queue.
-  if (S)
+  if (InputSection *S = dyn_cast<InputSection>(Sec))
     Queue.push_back(S);
 }
 
 template <class ELFT> void MarkLive<ELFT>::markSymbol(Symbol *Sym) {
   if (auto *D = dyn_cast_or_null<Defined>(Sym))
     if (auto *IS = dyn_cast_or_null<InputSectionBase>(D->Section))
       enqueue(IS, D->Value, false);
 }
if (!Config->GcSections) {
     // If a DSO defines a symbol referenced in a regular object, it is needed.
     for (Symbol *Sym : Symtab->getSymbols())
       if (auto *S = dyn_cast<SharedSymbol>(Sym))
         if (S->IsUsedInRegularObj && !S->isWeak())
           S->getFile().IsNeeded = true;
     return;
   }
 
-  // Otheriwse, do mark-sweep GC.
+  // Otheriwse, do mark-sweep GC. Follow the graph to mark all live
+  // sections.
+  MarkLive<ELFT>().run();
+
+  // Usually, non-SHF_ALLOC sections are not garbage-collected even if
+  // they are unreachable. It's because reachability is not a good
+  // signal whether they are garbage or not. Here are a few examples:
   //
-  // The -gc-sections option works only for SHF_ALLOC sections
-  // (sections that are memory-mapped at runtime). So we can
-  // unconditionally make non-SHF_ALLOC sections alive except
-  // SHF_LINK_ORDER and SHT_REL/SHT_RELA sections and .debug sections.
+  //  - A .comment section contains some ASCII text. There is usually no
+  //    section referring from/to a .comment section, but we want to
+  //    keep it to not surprise users.
   //
-  // Usually, SHF_ALLOC sections are not removed even if they are
-  // unreachable through relocations because reachability is not
-  // a good signal whether they are garbage or not (e.g. there is
-  // usually no section referring to a .comment section, but we
-  // want to keep it.).
+  //  - An object file usually contains only one .debug section
+  //    describing all functions and data in the same object file, even
+  //    if the object file is compiled with -f{function,data}-sections.
+  //    There is no relocation from code/ data sections to a debug
+  //    section, but a debug section contains lots of relocations to
+  //    code/data sections (so this is a reverse dependency). If at
+  //    least one code/data is live, we want to keep the entire debug
+  //    info.
   //
-  // Note on SHF_LINK_ORDER: Such sections contain metadata and they
-  // have a reverse dependency on the InputSection they are linked with.
+  // Here, we mark non-SHF_ALLOC sections.
+  for (InputSectionBase *Sec : InputSections) {
+    if (Sec->Flags & SHF_ALLOC)
+      continue;
+
+    // If a file does not contain any live code nor data, we want to
+    // discard debug sections as they are completely useless.
+    if (Sec->File && !Sec->getFile<ELFT>()->HasLiveCodeOrData &&
+        Sec->Debug)
+      continue;
+
+    // SHF_LINK_ORDER sections contain metadata and they have a
+    // reverse dependency on the InputSection they are linked with.
     // We are able to garbage collect them.
-  //
-  // Note on SHF_REL{,A}: Such sections reach here only when -r
-  // or -emit-reloc were given. And they are subject of garbage
+    if (Sec->Flags & SHF_LINK_ORDER)
+      continue;
+
+    // SHT_REL sections sections reach here only when -r or
+    // -emit-reloc were given. And they are subject of garbage
     // collection because, if we remove a text section, we also
     // remove its relocation section.
-  for (InputSectionBase *Sec : InputSections) {
-    bool IsAlloc = (Sec->Flags & SHF_ALLOC);
-    bool IsLinkOrder = (Sec->Flags & SHF_LINK_ORDER);
-    bool IsRel = (Sec->Type == SHT_REL || Sec->Type == SHT_RELA);
+    if (Sec->Type == SHT_REL || Sec->Type == SHT_RELA)
+      continue;
 
-    if (!IsAlloc && !IsLinkOrder && !IsRel && !Sec->Debug)
-      Sec->Live = true;
   }
 
-  // Follow the graph to mark all live sections.
-  MarkLive<ELFT>().run();
-
   // Mark debug sections as live in any object file that has a live
   // Regular or Merge section.
   for (InputSectionBase *Sec : InputSections)
     if (Sec->Debug && Sec->getFile<ELFT>()->HasLiveCodeOrData)
       Sec->Live = true;
 
   // Report garbage-collected sections.
   if (Config->PrintGcSections)