Don't print DISCARD sections as gced

[• rafael]

Summary

This is a small difference I noticed to gold and bfd. When given --print-gc-sections, we print sections a linkerscript marks DISCARD. The other linkers don't.

[grimar]

LGTM with a nit, looks reasonable behavior for me.

btw, currently (with or without this patch)
we do not report sections as discarded when linkerscript is used with -gc-sections at all (when there is no /DISCARD/):

# REQUIRES: x86
# RUN: echo "SECTIONS { }" > %t.script
# RUN: llvm-mc -triple x86_64-pc-linux %s -o %t.o -filetype=obj
# RUN: ld.lld -o %t -T %t.script %t.o --print-gc-sections --gc-sections 2>&1 | \
# RUN:   FileCheck -check-prefix=NOREPORT --allow-empty %s
# NOREPORT-NOT: removing unused section

.section .foo,"a"
.quad 0

test/ELF/linkerscript/discard-print-gc.s

4

Do you need -shared ? We link fine when do not have _start I think, if that was the case.

[ruiu]

ELF/LinkerScript.cpp

279–280

Can this happen? It seems more like an ASSERT rather than an error().

[ruiu]

LGTM

[grimar]

r295467

ELF/LinkerScript.cpp

for (SectionPattern &Pat : I->SectionPatterns) {
     }
   }
 }
 
 template <class ELFT>
 void LinkerScript<ELFT>::discard(ArrayRef<InputSectionBase<ELFT> *> V) {
   for (InputSectionBase<ELFT> *S : V) {
     S->Live = false;
-    reportDiscarded(S);
+    if (S == In<ELFT>::ShStrTab)
+      error("discarding .shstrtab section is not allowed");
 
     InputSection<ELFT> *IS = dyn_cast<InputSection<ELFT>>(S);
     if (!IS || IS->DependentSections.empty())
       continue;
     discard(IS->DependentSections);
   }
 }
 

ELF/OutputSections.cpp

 // any special treatment on top of progbits, so there doesn't
 // seem to be a harm in merging them.
 static bool canMergeToProgbits(unsigned Type) {
   return Type == SHT_NOBITS || Type == SHT_PROGBITS || Type == SHT_INIT_ARRAY ||
          Type == SHT_PREINIT_ARRAY || Type == SHT_FINI_ARRAY ||
          Type == SHT_NOTE;
 }
 
+template <class ELFT> static void reportDiscarded(InputSectionBase<ELFT> *IS) {
+  if (!Config->PrintGcSections)
+    return;
+  errs() << "removing unused section from '" << IS->Name << "' in file '"
+         << IS->getFile()->getName() << "'\n";
+}
+
 template <class ELFT>
 void OutputSectionFactory<ELFT>::addInputSec(InputSectionBase<ELFT> *IS,
                                              StringRef OutsecName) {
   if (!IS->Live) {
     reportDiscarded(IS);
     return;
   }
 

ELF/Writer.h

struct PhdrEntry {
   bool HasLMA = false;
 };
 
 llvm::StringRef getOutputSectionName(llvm::StringRef Name);
 
 template <class ELFT>
 bool allocateHeaders(std::vector<PhdrEntry> &,
                      llvm::ArrayRef<OutputSectionBase *>, uint64_t Min);
-template <class ELFT> void reportDiscarded(InputSectionBase<ELFT> *IS);
 
 template <class ELFT> uint32_t getMipsEFlags();
 
 uint8_t getMipsFpAbiFlag(uint8_t OldFlag, uint8_t NewFlag,
                          llvm::StringRef FileName);
 
 bool isMipsN32Abi(const InputFile *F);
 }
 }
 
 #endif

ELF/Writer.cpp

StringRef elf::getOutputSectionName(StringRef Name) {
 
   // ".zdebug_" is a prefix for ZLIB-compressed sections.
   // Because we decompressed input sections, we want to remove 'z'.
   if (Name.startswith(".zdebug_"))
     return Saver.save(Twine(".") + Name.substr(2));
   return Name;
 }
 
-template <class ELFT> void elf::reportDiscarded(InputSectionBase<ELFT> *IS) {
-  if (IS == In<ELFT>::ShStrTab)
-    error("discarding .shstrtab section is not allowed");
-  if (!Config->PrintGcSections)
-    return;
-  errs() << "removing unused section from '" << IS->Name << "' in file '"
-         << IS->getFile()->getName() << "'\n";
-}
-
 template <class ELFT> static bool needsInterpSection() {
   return !Symtab<ELFT>::X->getSharedFiles().empty() &&
          !Config->DynamicLinker.empty() &&
          !Script<ELFT>::X->ignoreInterpSection();
 }
 
 template <class ELFT> void elf::writeResult() { Writer<ELFT>().run(); }
 

 template bool elf::allocateHeaders<ELF64BE>(std::vector<PhdrEntry> &,
                                             ArrayRef<OutputSectionBase *>,
                                             uint64_t);
 
 template bool elf::isRelroSection<ELF32LE>(const OutputSectionBase *);
 template bool elf::isRelroSection<ELF32BE>(const OutputSectionBase *);
 template bool elf::isRelroSection<ELF64LE>(const OutputSectionBase *);
 template bool elf::isRelroSection<ELF64BE>(const OutputSectionBase *);
-
-template void elf::reportDiscarded<ELF32LE>(InputSectionBase<ELF32LE> *);
-template void elf::reportDiscarded<ELF32BE>(InputSectionBase<ELF32BE> *);
-template void elf::reportDiscarded<ELF64LE>(InputSectionBase<ELF64LE> *);
-template void elf::reportDiscarded<ELF64BE>(InputSectionBase<ELF64BE> *);

test/ELF/linkerscript/discard-print-gc.s

+# REQUIRES: x86
+# RUN: echo "SECTIONS { /DISCARD/ : { *(.foo) } }" > %t.script
+# RUN: llvm-mc -triple x86_64-pc-linux %s -o %t.o -filetype=obj
+# RUN: ld.lld -o %t.so --gc-sections %t.o --print-gc-sections -shared 2>&1 | \
+# RUN:   FileCheck -check-prefix=CHECK %s
+# RUN: ld.lld -o %t.so -T %t.script %t.o --print-gc-sections -shared 2>&1 | \
+# RUN:   FileCheck -check-prefix=QUIET --allow-empty %s
+
+.section .foo,"a"
+.quad 0
+
+# CHECK: removing unused section from '.foo'
+# QUIET-NOT: removing unused section from '.foo'