[ELF] --gc-sections: collect unused .gcc_except_table in section groups and associated text sections

[MaskRay]

Summary

try ... catch in an inline function produces .gcc_except_table.* in a COMDAT group with GCC or
newer Clang (since D83655). For --gc-sections, currently we scan .eh_frame
pieces and mark liveness of such a .gcc_except_table.* and then the associated
.text.* (if a member in a section group is retained, the others should be
retained as well).

Essentially all .text.* and .gcc_except_table.* compiled from inline
functions with try ... catch cannot be discarded by the imprecise --gc-sections.
Compared with the state before D83655, the output .gcc_except_table is smaller
(non-prevailing copies in COMDAT groups can now be discarded) but .text may be larger,
i.e. size regression.

This patch teaches the .eh_frame piece scanning code to not mark
.gcc_except_table in a section group, thus allow unused .text.* and
.gcc_except_table.* in a section group to be discarded.

Note, non-group .gcc_except_table can still not be discarded. That is the status quo.

[echristo]

I think this is reasonable, if neither George or Peter say anything I think this looks ok to me.

lld/ELF/MarkLive.cpp

115–116

That's an awful lot of ! in that if condition - perhaps that could be rewritten?

[MaskRay]

Reduce the number of !

[grimar]

Looks reasonable to me too.

[psmith]

No objections from me. Although unrelated to the patch, isLSDA might be better called fromFDE, or couldBeLSDA? Maybe one for a later follow up.

[MaskRay]

Rename isLSDA to fromFDE

lld/ELF/MarkLive.cpp

if (auto *d = dyn_cast<Defined>(&sym)) {
     auto *relSec = dyn_cast_or_null<InputSectionBase>(d->section);
     if (!relSec)
       return;
 
     uint64_t offset = d->value;
     if (d->isSection())
       offset += getAddend<ELFT>(sec, rel);
 
-    if (!isLSDA || !(relSec->flags & SHF_EXECINSTR))
+    // isLSDA being true means this is referenced by a FDE in a .eh_frame piece.
+    // The relocation points to the described function or to a LSDA. We only
+    // need to keep the LSDA live, so ignore anything that points to executable
+    // sections. If the LSDA is in a section group, we ignore the relocation as
+    // well because (a) if the associated text section is live, the LSDA will be
+    // retained due to section group rules (b) if the associated text section
+    // should be discarded, marking the LSDA will unnecessarily retain the text
+    // section.
+    if (!(isLSDA &&
+          ((relSec->flags & SHF_EXECINSTR) || relSec->nextInSectionGroup)))
       enqueue(relSec, offset);
     return;
   }
 
   if (auto *ss = dyn_cast<SharedSymbol>(&sym))
     if (!ss->isWeak())
       ss->getFile().isNeeded = true;
 
for (size_t i = 0, end = eh.pieces.size(); i < end; ++i) {
 
     if (read32<ELFT::TargetEndianness>(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(eh, rels[firstRelI], false);
       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.
     uint64_t pieceEnd = piece.inputOff + piece.size;
     for (size_t j = firstRelI, end2 = rels.size();
          j < end2 && rels[j].r_offset < pieceEnd; ++j)
       resolveReloc(eh, rels[j], true);
   }
 }
 
 // Some sections are used directly by the loader, so they should never be

lld/test/ELF/gc-sections-lsda.s

-// REQUIRES: x86
+# REQUIRES: x86
+# RUN: llvm-mc %s -o %t.o -filetype=obj -triple=x86_64-pc-linux
 
-// RUN: llvm-mc %s -o %t.o -filetype=obj -triple=x86_64-pc-linux
-// RUN: ld.lld -shared --gc-sections %t.o -o %t
+## Discard an unused .gcc_except_table in a COMDAT group if the associated text
+## section is discarded.
 
-// 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
+# RUN: ld.lld --gc-sections --print-gc-sections -u _Z3foov %t.o -o /dev/null | \
+# RUN:   FileCheck %s --implicit-check-not=.gcc_except_table
 
-        .cfi_startproc
-        .cfi_lsda 0x1b,zed
-        .cfi_endproc
-        .section        .abc,"a"
-zed:
-        .long   bar-.
-        .section        .foo,"ax"
-bar:
+# CHECK:      removing unused section {{.*}}.o:(.text._Z6comdatv)
+# CHECK-NEXT: removing unused section {{.*}}.o:(.gcc_except_table._Z6comdatv)
+
+## An unused non-group .gcc_except_table is not discarded.
+
+# RUN: ld.lld --gc-sections --print-gc-sections -u _Z6comdatv %t.o -o /dev/null | \
+# RUN:   FileCheck /dev/null --implicit-check-not=.gcc_except_table
+
+## If the text sections are live, the .gcc_except_table sections are retained as
+## well because they are referenced by .eh_frame pieces.
+
+# RUN: ld.lld --gc-sections --print-gc-sections -u _Z3foov -u _Z6comdatv %t.o -o /dev/null | \
+# RUN:   FileCheck %s --check-prefix=KEEP
+
+# KEEP-NOT: .gcc_except_table
+
+.section .text._Z3foov,"ax",@progbits
+.globl _Z3foov
+_Z3foov:
+  ret
+  .cfi_lsda 0x1b,.Lexception0
+
+.section .text._Z6comdatv,"axG",@progbits,_Z6comdatv,comdat
+.globl _Z6comdatv
+_Z6comdatv:
+  .cfi_startproc
+  ret
+  .cfi_lsda 0x1b,.Lexception1
+  .cfi_endproc
+
+.section .gcc_except_table._Z3foov,"a",@progbits
+.Lexception0:
+  .byte 255
+
+.section .gcc_except_table._Z6comdatv,"aG",@progbits,_Z6comdatv,comdat
+.Lexception1:
+  .byte 255