[ELF] - Implemented --print-gc-sections command line argument.

[grimar]

Summary

List all sections removed by garbage collection. This option is only effective if garbage collection has been enabled via the `--gc-sections' option.

[ruiu]

ELF/Writer.cpp

536

If a function does not refer any member variable of a class, non-member function is preferred over member function.

540–541

Since this is not a warning, don't use warning(). Instead, write the message out to llvm::errs().

578–581

if (isDiscarded(C)) {
  reportDiscarded(C, F);
  continue;
}

[grimar]

Addressed review comments.

ELF/Writer.cpp

536

Done.

540–541

Done.
I thought about adding message() method to error.h/cpp for such cases.
But then file name would not be consistent with content, since message is not an error.

578–581

Done.

[ruiu]

LGTM with nits.

ELF/Writer.cpp

538

Let's invert this condition to return early.

if (!Config->PrintGcSections || !IS || Is->isLive())
  return;

539–541

llvm::errs() << "removing unused section from '" << IS->getSectionName()
             << "' in file '" << File->getName() << "'\n";

[grimar]

ELF/Writer.cpp

538

Done.

539–541

Done.

ELF/Config.h

struct Configuration {
   bool DiscardNone;
   bool EnableNewDtags;
   bool ExportDynamic;
   bool GcSections;
   bool GnuHash = false;
   bool Mips64EL = false;
   bool NoInhibitExec;
   bool NoUndefined;
+  bool PrintGcSections;
   bool Shared;
   bool Static = false;
   bool StripAll;
   bool SysvHash = true;
   bool Verbose;
   bool ZExecStack;
   bool ZNodelete;
   bool ZNow;

ELF/Driver.cpp

void LinkerDriver::createFiles(opt::InputArgList &Args) {
   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->PrintGcSections = Args.hasArg(OPT_print_gc_sections);
   Config->Shared = Args.hasArg(OPT_shared);
   Config->StripAll = Args.hasArg(OPT_strip_all);
   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");
   Config->Init = getString(Args, OPT_init, "_init");

ELF/Options.td

def noinhibit_exec : Flag<["--"], "noinhibit-exec">,
   HelpText<"Retain the executable output file whenever it is still usable">;
 
 def no_undefined : Flag<["--"], "no-undefined">,
   HelpText<"Report unresolved symbols even if the linker is creating a shared library">;
 
 def o : Separate<["-"], "o">, MetaVarName<"<path>">,
   HelpText<"Path to file to write output">;
 
+def print_gc_sections: Flag<["--"], "print-gc-sections">,
+  HelpText<"List removed unused sections">;
+
 def rpath : Separate<["-"], "rpath">,
   HelpText<"Add a DT_RUNPATH to the output">;
 
 def relocatable : Flag<["--"], "relocatable">;
 
 def script : Separate<["--"], "script">, HelpText<"Read linker script">;
 
 def shared : Flag<["-"], "shared">,

ELF/Writer.cpp

 #include "Config.h"
 #include "OutputSections.h"
 #include "SymbolTable.h"
 #include "Target.h"
 
 #include "llvm/ADT/StringMap.h"
 #include "llvm/ADT/StringSwitch.h"
 #include "llvm/Support/FileOutputBuffer.h"
+#include "llvm/Support/raw_ostream.h"
 #include "llvm/Support/StringSaver.h"
 
 using namespace llvm;
 using namespace llvm::ELF;
 using namespace llvm::object;
 
 using namespace lld;
 using namespace lld::elf2;
StringRef Writer<ELFT>::getOutputSectionName(StringRef S) const {
   if (S.startswith(".data."))
     return ".data";
   if (S.startswith(".bss."))
     return ".bss";
   return S;
 }
 
 template <class ELFT>
+void reportDiscarded(InputSectionBase<ELFT> *IS,
+                     const std::unique_ptr<ObjectFile<ELFT>> &File) {
+  if (Config->PrintGcSections && IS && !IS->isLive())
+    llvm::errs() << Twine("removing unused section from '") +
+                        IS->getSectionName() + "' in file '" + File->getName() +
+                        "'"
+                 << "\n";
+}
+
+template <class ELFT>
 bool Writer<ELFT>::isDiscarded(InputSectionBase<ELFT> *IS) const {
   if (!IS || !IS->isLive() || IS == &InputSection<ELFT>::Discarded)
     return true;
   return InputToOutputSection.lookup(IS->getSectionName()) == "/DISCARD/";
 }
 
 template <class ELFT>
 static bool compareSections(OutputSectionBase<ELFT> *A,
if (needsInterpSection())
     OutputSections.push_back(Out<ELFT>::Interp);
 
   SmallDenseMap<SectionKey<ELFT::Is64Bits>, OutputSectionBase<ELFT> *> Map;
 
   std::vector<OutputSectionBase<ELFT> *> RegularSections;
 
   for (const std::unique_ptr<ObjectFile<ELFT>> &F : Symtab.getObjectFiles()) {
     for (InputSectionBase<ELFT> *C : F->getSections()) {
-      if (isDiscarded(C))
+      if (isDiscarded(C)) {
+        reportDiscarded(C, F);
         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.
       typename InputSectionBase<ELFT>::Kind K = C->SectionKind;
       uintX_t EntSize = K != InputSectionBase<ELFT>::Merge ? 0 : H->sh_entsize;
       uint32_t OutType = H->sh_type;

test/ELF/gc-sections-print.s

+# REQUIRES: x86
+# RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %s -o %t
+# RUN: ld.lld %t --gc-sections --print-gc-sections -o %t2 2>&1 | FileCheck -check-prefix=PRINT %s
+
+# PRINT:      removing unused section from '.text.x' in file
+# PRINT-NEXT: removing unused section from '.text.y' in file
+
+.globl _start
+.protected a, x, y
+_start:
+ call a
+
+.section .text.a,"ax",@progbits
+a:
+ nop
+
+.section .text.x,"ax",@progbits
+x:
+ nop
+
+.section .text.y,"ax",@progbits
+y:
+ nop