[ELF] GC: Mark all pieces of non-allocatable mergeable section live.

[evgeny777]

Summary

The .comment section may have multiple pieces. Current revision will only live the very first piece alive

[• rafael]

LGTM, but please add one more test: Test that linking just

.ident "foobar"

into a shared library results in a .so that has that in .comment.

[ruiu]

LGTM

ELF/InputSection.cpp

576

Add a note as a comment that we do not garbage-collect non-allocatable sections that typically contains debug info.

ELF/InputSection.cpp

 template <class ELFT> void MergeInputSection<ELFT>::splitIntoPieces() {
   ArrayRef<uint8_t> Data = this->Data;
   uintX_t EntSize = this->Header->sh_entsize;
   if (this->Header->sh_flags & SHF_STRINGS)
     this->Pieces = splitStrings(Data, EntSize);
   else
     this->Pieces = splitNonStrings(Data, EntSize);
 
-  if (Config->GcSections)
+  if (Config->GcSections) {
+    if (this->getSectionHdr()->sh_flags & SHF_ALLOC) {
       for (uintX_t Off : LiveOffsets)
         this->getSectionPiece(Off)->Live = true;
+      return;
+    }
+
+    for (SectionPiece &Piece : this->Pieces)
+      Piece.Live = true;
+  }
 }
 
 template <class ELFT>
 bool MergeInputSection<ELFT>::classof(const InputSectionBase<ELFT> *S) {
   return S->kind() == InputSectionBase<ELFT>::Merge;
 }
 
 // Do binary search to get a section piece at a given input offset.

ELF/MarkLive.cpp

 }
 
 template <class ELFT>
 static typename ELFT::uint getAddend(InputSectionBase<ELFT> &Sec,
                                      const typename ELFT::Rela &Rel) {
   return Rel.r_addend;
 }
 
-template <class ELFT> static bool IsAlloc(InputSectionBase<ELFT> &Sec) {
-  return (&Sec != &InputSection<ELFT>::Discarded) &&
-         (Sec.getSectionHdr()->sh_flags & SHF_ALLOC);
-}
-
 template <class ELFT, class RelT>
 static ResolvedReloc<ELFT> resolveReloc(InputSectionBase<ELFT> &Sec,
                                         RelT &Rel) {
   SymbolBody &B = Sec.getFile()->getRelocTargetSym(Rel);
   auto *D = dyn_cast<DefinedRegular<ELFT>>(&B);
   if (!D || !D->Section)
     return {nullptr, 0};
-  if (!IsAlloc<ELFT>(Sec) && IsAlloc<ELFT>(*D->Section))
-    return {nullptr, 0};
   typename ELFT::uint Offset = D->Value;
   if (D->isSection())
     Offset += getAddend(Sec, Rel);
   return {D->Section->Repl, Offset};
 }
 
 // Calls Fn for each section that Sec refers to via relocations.
 template <class ELFT>
auto Enqueue = [&](ResolvedReloc<ELFT> R) {
     // So we explicitly tell it which offset is in use.
     if (auto *MS = dyn_cast<MergeInputSection<ELFT>>(R.Sec))
       MS->markLiveAt(R.Offset);
 
     if (R.Sec->Live)
       return;
     R.Sec->Live = true;
     if (InputSection<ELFT> *S = dyn_cast<InputSection<ELFT>>(R.Sec))
+      if (S->getSectionHdr()->sh_flags & SHF_ALLOC)
         Q.push_back(S);
   };
 
   auto MarkSymbol = [&](const SymbolBody *Sym) {
     if (auto *D = dyn_cast_or_null<DefinedRegular<ELFT>>(Sym))
       Enqueue({D->Section, D->Value});
   };
 
   // Add GC root symbols.

test/ELF/debug-gc.s

 # REQUIRES: x86
 # RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %s -o %t.o
 # RUN: ld.lld %t.o -o %t1 --gc-sections
 # RUN: llvm-objdump -s %t1 | FileCheck %s
 
 # CHECK:      Contents of section .debug_str:
-# CHECK-NEXT:  0000 41414100 42424200   AAA.BBB.
+# CHECK-NEXT:  0000 41414100 42424200 43434300           AAA.BBB.CCC.
 # CHECK:      Contents of section .debug_info:
 # CHECK-NEXT:  0000 00000000 04000000
 
 .globl _start
 _start:
 
 .section .debug_str,"MS",@progbits,1
 .Linfo_string0: