[ELF2] Implement -discard-none

[• rafael]

LGTM

In addition to symbols starting with .L, we should also drop symbols with no names (st_name = 0), but that can go in another patch.

lld/trunk/ELF/Config.h

 
 struct Configuration {
   llvm::StringRef OutputFile;
   llvm::StringRef DynamicLinker;
   std::string RPath;
   bool Shared = false;
   bool DiscardAll = false;
   bool DiscardLocals = false;
+  bool DiscardNone = false;
   bool ExportDynamic = false;
 };
 
 extern Configuration *Config;
 
 } // namespace elf2
 } // namespace lld
 
 #endif

lld/trunk/ELF/Driver.cpp

if (Args.hasArg(OPT_shared))
     Config->Shared = true;
 
   if (Args.hasArg(OPT_discard_all))
     Config->DiscardAll = true;
 
   if (Args.hasArg(OPT_discard_locals))
     Config->DiscardLocals = true;
 
+  if (Args.hasArg(OPT_discard_none))
+    Config->DiscardNone = true;
+
   if (Args.hasArg(OPT_export_dynamic))
     Config->ExportDynamic = true;
 
   // Create a list of input files.
   std::vector<MemoryBufferRef> Inputs;
 
   for (auto *Arg : Args.filtered(OPT_INPUT)) {
     StringRef Path = Arg->getValue();

lld/trunk/ELF/Options.td

def alias_discard_all: Flag<["-"], "x">,
      Alias<discard_all>;
 
 def discard_locals : Flag<["-"], "discard-locals">,
      HelpText<"Delete temporary local symbols">;
 
 def alias_discard_locals: Flag<["-"], "X">,
      Alias<discard_locals>;
 
+def discard_none : Flag<["-"], "discard-none">,
+     HelpText<"Keep all symbols in the symbol table">;
+
 //===----------------------------------------------------------------------===//
 /// Ignored options
 //===----------------------------------------------------------------------===//
 
 def dashg : Flag<["-"], "g">,
      HelpText<"Ignored.">;
 
 def Qy : Flag<["-"], "Qy">,

lld/trunk/ELF/OutputSections.h

public:
 
   void addSymbol(StringRef Name, bool isLocal = false) {
     StrTabSec.add(Name);
     ++NumVisible;
     if (isLocal)
       ++NumLocals;
   }
 
+  bool shouldKeepInSymtab(StringRef Name);
+
   StringTableSection<ELFT::Is64Bits> &getStrTabSec() const { return StrTabSec; }
   unsigned getNumSymbols() const { return NumVisible + 1; }
 
 private:
   SymbolTable &Table;
   StringTableSection<ELFT::Is64Bits> &StrTabSec;
   unsigned NumVisible = 0;
   unsigned NumLocals = 0;

lld/trunk/ELF/OutputSections.cpp

bool lld::elf2::includeInSymtab(const SymbolBody &B) {
   if (!B.isUsedInRegularObj())
     return false;
   uint8_t V = B.getMostConstrainingVisibility();
   if (V != STV_DEFAULT && V != STV_PROTECTED)
     return false;
   return true;
 }
 
+template <class ELFT>
+bool SymbolTableSection<ELFT>::shouldKeepInSymtab(StringRef SymName) {
+  if (Config->DiscardNone)
+    return true;
+
+  // ELF defines dynamic locals as symbols which name starts with ".L".
+  return !(Config->DiscardLocals && SymName.startswith(".L"));
+}
+
 bool lld::elf2::includeInDynamicSymtab(const SymbolBody &B) {
   if (Config->ExportDynamic || Config->Shared)
     return true;
   return B.isUsedInDynamicReloc();
 }
 
 template <class ELFT> void SymbolTableSection<ELFT>::writeTo(uint8_t *Buf) {
   const OutputSection<ELFT> *Out = nullptr;
   const InputSection<ELFT> *Section = nullptr;
   Buf += sizeof(Elf_Sym);
 
   // All symbols with STB_LOCAL binding precede the weak and global symbols.
   // .dynsym only contains global symbols.
   if (!Config->DiscardAll && !StrTabSec.isDynamic()) {
     for (const std::unique_ptr<ObjectFileBase> &FileB :
          Table.getObjectFiles()) {
       auto &File = cast<ObjectFile<ELFT>>(*FileB);
       Elf_Sym_Range Syms = File.getLocalSymbols();
       for (const Elf_Sym &Sym : Syms) {
         auto *ESym = reinterpret_cast<Elf_Sym *>(Buf);
         uint32_t SecIndex = Sym.st_shndx;
         ErrorOr<StringRef> SymName = Sym.getName(File.getStringTable());
-        if (Config->DiscardLocals && SymName->startswith(".L"))
+        if (SymName && !shouldKeepInSymtab(*SymName))
           continue;
         ESym->st_name = (SymName) ? StrTabSec.getFileOff(*SymName) : 0;
         ESym->st_size = Sym.st_size;
         ESym->setBindingAndType(Sym.getBinding(), Sym.getType());
         if (SecIndex == SHN_XINDEX)
           SecIndex = File.getObj()->getExtendedSymbolTableIndex(
               &Sym, File.getSymbolTable(), File.getSymbolTableShndx());
         ArrayRef<InputSection<ELFT> *> Sections = File.getSections();

lld/trunk/ELF/Writer.cpp

template <class ELFT> void Writer<ELFT>::createSections() {
 
   const SymbolTable &Symtab = SymTabSec.getSymTable();
   for (const std::unique_ptr<ObjectFileBase> &FileB : Symtab.getObjectFiles()) {
     auto &File = cast<ObjectFile<ELFT>>(*FileB);
     if (!Config->DiscardAll) {
       Elf_Sym_Range Syms = File.getLocalSymbols();
       for (const Elf_Sym &Sym : Syms) {
         ErrorOr<StringRef> SymName = Sym.getName(File.getStringTable());
-        if (SymName && !(Config->DiscardLocals && SymName->startswith(".L")))
+        if (SymName && SymTabSec.shouldKeepInSymtab(*SymName))
           SymTabSec.addSymbol(*SymName, true);
       }
     }
     for (InputSection<ELFT> *C : File.getSections()) {
       if (!C)
         continue;
       const Elf_Shdr *H = C->getSectionHdr();
       OutputSection<ELFT> *Sec =

lld/trunk/test/elf2/discard-none.s

+// RUN: llvm-mc -filetype=obj -triple=x86_64-pc-linux -save-temp-labels %s -o %t
+// RUN: lld -flavor gnu2 -discard-none -shared %t -o %t2
+// RUN: llvm-readobj -s -sd -t %t2 | FileCheck %s
+// REQUIRES: x86
+
+.text
+.Lmyvar:
+.Lmyothervar:
+
+// CHECK:   Section {
+// CHECK:     Name: .strtab
+// CHECK-NEXT:     Type: SHT_STRTAB
+// CHECK-NEXT:     Flags [
+// CHECK-NEXT:     ]
+// CHECK-NEXT:     Address:
+// CHECK-NEXT:     Offset:
+// CHECK-NEXT:     Size:
+// CHECK-NEXT:     Link:
+// CHECK-NEXT:     Info:
+// CHECK-NEXT:     AddressAlignment:
+// CHECK-NEXT:     EntrySize:
+// CHECK-NEXT:     SectionData (
+// CHECK-NEXT:       0000: 002E7465 7874002E 62737300 2E64796E  |..text..bss..dyn|
+// CHECK-NEXT:       0010: 73747200 2E4C6D79 76617200 2E4C6D79  |str..Lmyvar..Lmy|
+// CHECK-NEXT:       0020: 6F746865 72766172 002E6479 6E73796D  |othervar..dynsym|
+// CHECK-NEXT:       0030: 002E6861 7368002E 64796E61 6D696300  |..hash..dynamic.|
+// CHECK-NEXT:       0040: 2E737472 74616200 2E73796D 74616200  |.strtab..symtab.|
+// CHECK-NEXT:       0050: 2E646174 6100                        |.data.|
+// CHECK-NEXT:     )
+// CHECK-NEXT:   }
+
+// CHECK:   Symbol {
+// CHECK-NEXT:     Name:
+// CHECK-NEXT:     Value: 0x0
+// CHECK-NEXT:     Size: 0
+// CHECK-NEXT:     Binding: Local
+// CHECK-NEXT:     Type: None
+// CHECK-NEXT:     Other: 0
+// CHECK-NEXT:     Section: Undefined
+// CHECK-NEXT:   }
+// CHECK-NEXT:   Symbol {
+// CHECK-NEXT:     Name: .Lmyothervar
+// CHECK-NEXT:     Value: 0x1000
+// CHECK-NEXT:     Size: 0
+// CHECK-NEXT:     Binding: Local
+// CHECK-NEXT:     Type: None
+// CHECK-NEXT:     Other: 0
+// CHECK-NEXT:     Section: .text
+// CHECK-NEXT:   }
+// CHECK-NEXT:   Symbol {
+// CHECK-NEXT:     Name: .Lmyvar
+// CHECK-NEXT:     Value: 0x1000
+// CHECK-NEXT:     Size: 0
+// CHECK-NEXT:     Binding: Local
+// CHECK-NEXT:     Type: None
+// CHECK-NEXT:     Other: 0
+// CHECK-NEXT:     Section: .text
+// CHECK-NEXT:   }