[ELF2] Use static non-member function when it suffices

[davide]

Summary

Try to address Rui's comment on my previous commit.

[ruiu]

LGTM

[shankare]

ELF/Writer.cpp

339–340

what if discard all and discard none is used ? Do we plan to print any warning of what option was chosen ?

ELF/OutputSections.h

 #ifndef LLD_ELF_OUTPUT_SECTIONS_H
 #define LLD_ELF_OUTPUT_SECTIONS_H
 
 #include "lld/Core/LLVM.h"
 
 #include "llvm/MC/StringTableBuilder.h"
 #include "llvm/Object/ELF.h"
 
+#include "Config.h"
+
 #include <type_traits>
 
 namespace lld {
 namespace elf2 {
 
 class SymbolBody;
 class SymbolTable;
 template <class ELFT> class SymbolTableSection;

 template <class ELFT>
 typename llvm::object::ELFFile<ELFT>::uintX_t
 getLocalSymVA(const typename llvm::object::ELFFile<ELFT>::Elf_Sym *Sym,
               const ObjectFile<ELFT> &File);
 
 bool includeInSymtab(const SymbolBody &B);
 bool includeInDynamicSymtab(const SymbolBody &B);
 
+static bool 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"));
+}
+
 // This represents a section in an output file.
 // Different sub classes represent different types of sections. Some contain
 // input sections, others are created by the linker.
 // The writer creates multiple OutputSections and assign them unique,
 // non-overlapping file offsets and VAs.
 template <bool Is64Bits> class OutputSectionBase {
 public:
   typedef typename std::conditional<Is64Bits, uint64_t, uint32_t>::type uintX_t;
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;

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;

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 && SymTabSec.shouldKeepInSymtab(*SymName))
+        if (SymName && shouldKeepInSymtab(*SymName))
           SymTabSec.addSymbol(*SymName, true);
       }
     }
     for (InputSection<ELFT> *C : File.getSections()) {
       if (!C)
         continue;
       const Elf_Shdr *H = C->getSectionHdr();
       OutputSection<ELFT> *Sec =
           getSection(C->getSectionName(), H->sh_type, H->sh_flags);