[lld][ELF] Rename SymbolTable::symbols() to SymbolTable::getSymbols(). NFC

[sbc100]

Summary

This change renames this method match its original name and the name
used in the wasm linker.

Back in d8f8abbd4a2823f223bd7bc56445541fb221b512 the ELF SymbolTable
method getSymbols() was replaced with forEachSymbol.

Then in a2fc96441788fba1e4709d63677f34ed8e321dae forEachSymbol was
replaced with a llvm::iterator_range.

Then in e9262edf0d11a907763098d8e101219ccd9c43e9 we came full circle
and the llvm::iterator_range was replaced with a symbols() accessor
that was identical the original getSymbols().

getSymbols also matches the name used elsewhere in the ELF linker as
well as in both COFF and wasm backend (e.g. InputFiles.h and
SyntheticSections.h)

[MaskRay]

I feel that symbols is not a bad name. For two functions: foo and getFoo, if foo can trivially return the member variable (as in this case), I think it's totally fine.

[sbc100]

In D130787#3687939, @MaskRay wrote:

I feel that symbols is not a bad name. For two functions: foo and getFoo, if foo can trivially return the member variable (as in this case), I think it's totally fine.

I'm not really arguing that its a better name, just trying to be consistent with the other uses withing the ELF linker and other other backends (and the historical name).

The alternative would be create change for the wasm linker to make it consistent with the ELF one.. I can do that if you prefer, but then we would also probably want to update the other places where getSymbols() is used in the ELF/COFF and wasm backends already.

[sbc100]

I quite useful to me not keep the various backends in sync.. and normally I do update the wasm linker to match the ELF one... but in this case I think it makes sense to do it the other way around (for the reasons already stated).

[sbc100]

For example, see the existing InputFile::getSymbols which exists in all 3 backends

[sbc100]

• rebase

[sbc100]

In D130787#3687966, @sbc100 wrote:

For example, see the existing InputFile::getSymbols which exists in all 3 backends

Do you feel strongly about .symbols() over .getSymbols()? This change seems like the least intrusive way to consistency, and I would rather land this, but if you feel strongly we can move other methods/backends over to .symbols() instead.

[MaskRay]

I feel that symbols() is a better name. I am not sure the consistency with other ports matters in this case. The data structures are so different. Using symbols for symtab and getSymbols for InputFile has another benefit that we can easily distinguish the two use cases (which are very different).

[sbc100]

In D130787#3703040, @MaskRay wrote:

I feel that symbols() is a better name. I am not sure the consistency with other ports matters in this case. The data structures are so different. Using symbols for symtab and getSymbols for InputFile has another benefit that we can easily distinguish the two use cases (which are very different).

But in the wasm port I have .getSymbols() for both the symbol table and for the InputFile. So I guess I should change my symbol table to use .symbols()? I do care about keeping the ports in sync as best I can, it helps with maintaining the wasm port to be able to compare them.

[sbc100]

Closing in favor of https://reviews.llvm.org/D131284

lld/ELF/Driver.cpp

static void handleUndefinedGlob(StringRef arg) {
   if (!pat) {
     error("--undefined-glob: " + toString(pat.takeError()));
     return;
   }
 
   // Calling sym->extract() in the loop is not safe because it may add new
   // symbols to the symbol table, invalidating the current iterator.
   SmallVector<Symbol *, 0> syms;
-  for (Symbol *sym : symtab->symbols())
+  for (Symbol *sym : symtab->getSymbols())
     if (!sym->isPlaceholder() && pat->match(sym->getName()))
       syms.push_back(sym);
 
   for (Symbol *sym : syms)
     handleUndefined(sym, "--undefined-glob");
 }
 
 static void handleLibcall(StringRef name) {

 }
 
 // If all references to a DSO happen to be weak, the DSO is not added to
 // DT_NEEDED. If that happens, replace ShardSymbol with Undefined to avoid
 // dangling references to an unneeded DSO. Use a weak binding to avoid
 // --no-allow-shlib-undefined diagnostics. Similarly, demote lazy symbols.
 static void demoteSharedAndLazySymbols() {
   llvm::TimeTraceScope timeScope("Demote shared and lazy symbols");
-  for (Symbol *sym : symtab->symbols()) {
+  for (Symbol *sym : symtab->getSymbols()) {
     auto *s = dyn_cast<SharedSymbol>(sym);
     if (!(s && !cast<SharedFile>(s->file)->isNeeded) && !sym->isLazy())
       continue;
 
     bool used = sym->used;
     uint8_t binding = sym->isLazy() ? sym->binding : uint8_t(STB_WEAK);
     sym->replace(
         Undefined{nullptr, sym->getName(), binding, sym->stOther, sym->type});
static void findKeepUniqueSections(opt::InputArgList &args) {
 
   // --icf=all --ignore-data-address-equality means that we can ignore
   // the dynsym and address-significance tables entirely.
   if (config->icf == ICFLevel::All && config->ignoreDataAddressEquality)
     return;
 
   // Symbols in the dynsym could be address-significant in other executables
   // or DSOs, so we conservatively mark them as address-significant.
-  for (Symbol *sym : symtab->symbols())
+  for (Symbol *sym : symtab->getSymbols())
     if (sym->includeInDynsym())
       markAddrsig(sym);
 
   // Visit the address-significance table in each object file and mark each
   // referenced symbol as address-significant.
   for (InputFile *f : ctx->objectFiles) {
     auto *obj = cast<ObjFile<ELFT>>(f);
     ArrayRef<Symbol *> syms = obj->getSymbols();
for (const WrappedSymbol &w : wrapped) {
     map[w.sym] = w.wrap;
     map[w.real] = w.sym;
   }
 
   // If there are version definitions (versionDefinitions.size() > 2), enumerate
   // symbols with a non-default version (foo@v1) and check whether it should be
   // combined with foo or foo@@v1.
   if (config->versionDefinitions.size() > 2)
-    for (Symbol *sym : symtab->symbols())
+    for (Symbol *sym : symtab->getSymbols())
       if (sym->hasVersionSuffix)
         combineVersionedSymbol(*sym, map);
 
   if (map.empty())
     return;
 
   // Update pointers in input files.
   parallelForEach(ctx->objectFiles, [&](ELFFileBase *file) {

lld/ELF/ICF.cpp

 }
 
 // The main function of ICF.
 template <class ELFT> void ICF<ELFT>::run() {
   // Compute isPreemptible early. We may add more symbols later, so this loop
   // cannot be merged with the later computeIsPreemptible() pass which is used
   // by scanRelocations().
   if (config->hasDynSymTab)
-    for (Symbol *sym : symtab->symbols())
+    for (Symbol *sym : symtab->getSymbols())
       sym->isPreemptible = computeIsPreemptible(*sym);
 
   // Two text sections may have identical content and relocations but different
   // LSDA, e.g. the two functions may have catch blocks of different types. If a
   // text section is referenced by a .eh_frame FDE with LSDA, it is not
   // eligible. This is implemented by iterating over CIE/FDE and setting
   // eqClass[0] to the referenced text section from a live FDE.
   //
template <class ELFT> void ICF<ELFT>::run() {
   auto fold = [](Symbol *sym) {
     if (auto *d = dyn_cast<Defined>(sym))
       if (auto *sec = dyn_cast_or_null<InputSection>(d->section))
         if (sec->repl != d->section) {
           d->section = sec->repl;
           d->folded = true;
         }
   };
-  for (Symbol *sym : symtab->symbols())
+  for (Symbol *sym : symtab->getSymbols())
     fold(sym);
   parallelForEach(ctx->objectFiles, [&](ELFFileBase *file) {
     for (Symbol *sym : file->getLocalSymbols())
       fold(sym);
   });
 
   // InputSectionDescription::sections is populated by processSectionCommands().
   // ICF may fold some input sections assigned to output sections. Remove them.

lld/ELF/LTO.cpp

BitcodeCompiler::BitcodeCompiler() {
   }
 
   ltoObj = std::make_unique<lto::LTO>(createConfig(), backend,
                                        config->ltoPartitions);
 
   // Initialize usedStartStop.
   if (ctx->bitcodeFiles.empty())
     return;
-  for (Symbol *sym : symtab->symbols()) {
+  for (Symbol *sym : symtab->getSymbols()) {
     if (sym->isPlaceholder())
       continue;
     StringRef s = sym->getName();
     for (StringRef prefix : {"__start_", "__stop_"})
       if (s.startswith(prefix))
         usedStartStop.insert(s.substr(prefix.size()));
   }
 }

lld/ELF/MarkLive.cpp

 // This is the main function of the garbage collector.
 // Starting from GC-root sections, this function visits all reachable
 // sections to set their "Live" bits.
 template <class ELFT> void MarkLive<ELFT>::run() {
   // Add GC root symbols.
 
   // Preserve externally-visible symbols if the symbols defined by this
   // file can interrupt other ELF file's symbols at runtime.
-  for (Symbol *sym : symtab->symbols())
+  for (Symbol *sym : symtab->getSymbols())
     if (sym->includeInDynsym() && sym->partition == partition)
       markSymbol(sym);
 
   // If this isn't the main partition, that's all that we need to preserve.
   if (partition != 1) {
     mark();
     return;
   }

 // Before calling this function, Live bits are off for all
 // input sections. This function make some or all of them on
 // so that they are emitted to the output file.
 template <class ELFT> void elf::markLive() {
   llvm::TimeTraceScope timeScope("markLive");
   // If --gc-sections is not given, retain all input sections.
   if (!config->gcSections) {
     // If a DSO defines a symbol referenced in a regular object, it is needed.
-    for (Symbol *sym : symtab->symbols())
+    for (Symbol *sym : symtab->getSymbols())
       if (auto *s = dyn_cast<SharedSymbol>(sym))
         if (s->isUsedInRegularObj && !s->isWeak())
           cast<SharedFile>(s->file)->isNeeded = true;
     return;
   }
 
   for (InputSectionBase *sec : inputSections)
     sec->markDead();

lld/ELF/Relocations.cpp

for (size_t i = 0, e = name.size(); i != e + 1; ++i) {
     if (const Symbol *s = suggest(newName))
       return s;
   }
 
   // Case mismatch, e.g. Foo vs FOO.
   for (auto &it : map)
     if (name.equals_insensitive(it.first))
       return it.second;
-  for (Symbol *sym : symtab->symbols())
+  for (Symbol *sym : symtab->getSymbols())
     if (!sym->isUndefined() && name.equals_insensitive(sym->getName()))
       return sym;
 
   // The reference may be a mangled name while the definition is not. Suggest a
   // missing extern "C".
   if (name.startswith("_Z")) {
     std::string buf = name.str();
     llvm::ItaniumPartialDemangler d;
static const Symbol *getAlternativeSpelling(const Undefined &sym,
   } else {
     const Symbol *s = nullptr;
     for (auto &it : map)
       if (canSuggestExternCForCXX(name, it.first)) {
         s = it.second;
         break;
       }
     if (!s)
-      for (Symbol *sym : symtab->symbols())
+      for (Symbol *sym : symtab->getSymbols())
         if (canSuggestExternCForCXX(name, sym->getName())) {
           s = sym;
           break;
         }
     if (s) {
       pre_hint = " to declare ";
       post_hint = " as extern \"C\"?";
       return s;
if (config->shared)
       mainPart->relaDyn->addReloc(
           {target->tlsModuleIndexRel, in.got.get(), in.got->getTlsIndexOff()});
     else
       in.got->relocations.push_back(
           {R_ADDEND, target->symbolicRel, in.got->getTlsIndexOff(), 1, &dummy});
   }
 
   assert(symAux.empty());
-  for (Symbol *sym : symtab->symbols())
+  for (Symbol *sym : symtab->getSymbols())
     fn(*sym);
 
   // Local symbols may need the aforementioned non-preemptible ifunc and GOT
   // handling. They don't need regular PLT.
   for (ELFFileBase *file : ctx->objectFiles)
     for (Symbol *sym : file->getLocalSymbols())
       fn(*sym);
 }

lld/ELF/SymbolTable.h

 // conflicts. For example, obviously, a defined symbol is better than
 // an undefined symbol. Or, if there's a conflict between a lazy and a
 // undefined, it'll read an archive member to read a real definition
 // to replace the lazy symbol. The logic is implemented in the
 // add*() functions, which are called by input files as they are parsed. There
 // is one add* function per symbol type.
 class SymbolTable {
 public:
-  ArrayRef<Symbol *> symbols() const { return symVector; }
+  ArrayRef<Symbol *> getSymbols() const { return symVector; }
 
   void wrap(Symbol *sym, Symbol *real, Symbol *wrap);
 
   Symbol *insert(StringRef name);
 
   Symbol *addSymbol(const Symbol &newSym);
   Symbol *addAndCheckDuplicate(const Defined &newSym);
 

lld/ELF/Writer.cpp

if (auto *d = dyn_cast<Defined>(&sym)) {
         int &priority = sectionOrder[cast<InputSectionBase>(sec)];
         priority = std::min(priority, ent.priority);
       }
     }
   };
 
   // We want both global and local symbols. We get the global ones from the
   // symbol table and iterate the object files for the local ones.
-  for (Symbol *sym : symtab->symbols())
+  for (Symbol *sym : symtab->getSymbols())
     addSym(*sym);
 
   for (ELFFileBase *file : ctx->objectFiles)
     for (Symbol *sym : file->getLocalSymbols())
       addSym(*sym);
 
   if (config->warnSymbolOrdering)
     for (auto orderEntry : symbolOrder)
if (config->emachine == EM_386 || config->emachine == EM_X86_64) {
     // This responsible for splitting up .eh_frame section into
     // pieces. The relocation scan uses those pieces, so this has to be
     // earlier.
     for (Partition &part : partitions)
       finalizeSynthetic(part.ehFrame.get());
   }
 
   if (config->hasDynSymTab) {
-    parallelForEach(symtab->symbols(), [](Symbol *sym) {
+    parallelForEach(symtab->getSymbols(), [](Symbol *sym) {
       sym->isPreemptible = computeIsPreemptible(*sym);
     });
   }
 
   // Change values of linker-script-defined symbols from placeholders (assigned
   // by declareSymbols) to actual definitions.
   script->processSymbolAssignments();
 
for (SharedFile *file : ctx->sharedFiles) {
                    toString(*sym) + "\n>>> referenced by " + toString(file));
     }
   }
 
   {
     llvm::TimeTraceScope timeScope("Add symbols to symtabs");
     // Now that we have defined all possible global symbols including linker-
     // synthesized ones. Visit all symbols to give the finishing touches.
-    for (Symbol *sym : symtab->symbols()) {
+    for (Symbol *sym : symtab->getSymbols()) {
       if (!sym->isUsedInRegularObj || !includeInSymtab(*sym))
         continue;
       if (!config->relocatable)
         sym->binding = sym->computeBinding();
       if (in.symTab)
         in.symTab->addSymbol(sym);
 
       if (sym->includeInDynsym()) {