[lld][WebAssembly] Rename SymbolTable::getSymbols to match ELF backend. NFC

[sbc100]

Summary

The ELF backend originally used getSymbols() but went though a
sequence of changes that resulted in this method being called
symbols().

d8f8abbd4a2823f223bd7bc56445541fb221b512 replaced getSymbols() with
forEachSymbol.

a2fc96441788fba1e4709d63677f34ed8e321dae replaced forEachSymbol with
llvm::iterator_range.

e9262edf0d11a907763098d8e101219ccd9c43e9 replaced llvm::iterator_range
with symbols().

lld/wasm/Driver.cpp

if (auto *lazySym = dyn_cast<LazySymbol>(sym)) {
     MemoryBufferRef mb = lazySym->getMemberBuffer();
     if (isBitcode(mb))
       lazySym->fetch();
   }
 }
 
 // Equivalent of demote demoteSharedAndLazySymbols() in the ELF linker
 static void demoteLazySymbols() {
-  for (Symbol *sym : symtab->getSymbols()) {
+  for (Symbol *sym : symtab->symbols()) {
     if (auto* s = dyn_cast<LazySymbol>(sym)) {
       if (s->signature) {
         LLVM_DEBUG(llvm::dbgs()
                    << "demoting lazy func: " << s->getName() << "\n");
         replaceSymbol<UndefinedFunction>(s, s->getName(), None, None,
                                          WASM_SYMBOL_BINDING_WEAK, s->getFile(),
                                          s->signature);
       }

lld/wasm/MarkLive.cpp

 }
 
 void MarkLive::run() {
   // Add GC root symbols.
   if (!config->entry.empty())
     enqueue(symtab->find(config->entry));
 
   // We need to preserve any no-strip or exported symbol
-  for (Symbol *sym : symtab->getSymbols())
+  for (Symbol *sym : symtab->symbols())
     if (sym->isNoStrip() || sym->isExported())
       enqueue(sym);
 
   if (WasmSym::callDtors)
     enqueue(WasmSym::callDtors);
 
   // Enqueue constructors in objects explicitly live from the command-line.
   for (const ObjFile *obj : symtab->objectFiles)

lld/wasm/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; }
+
   void wrap(Symbol *sym, Symbol *real, Symbol *wrap);
 
   void addFile(InputFile *file);
 
   void compileBitcodeFiles();
 
-  ArrayRef<Symbol *> getSymbols() const { return symVector; }
-
   Symbol *find(StringRef name);
 
   void replace(StringRef name, Symbol* sym);
 
   void trace(StringRef name);
 
   Symbol *addDefinedFunction(StringRef name, uint32_t flags, InputFile *file,
                              InputFunction *function);

lld/wasm/SymbolTable.cpp

void SymbolTable::replaceWithUndefined(Symbol *sym) {
   sym->setHidden(true);
 }
 
 // For weak undefined functions, there may be "call" instructions that reference
 // the symbol. In this case, we need to synthesise a dummy/stub function that
 // will abort at runtime, so that relocations can still provided an operand to
 // the call instruction that passes Wasm validation.
 void SymbolTable::handleWeakUndefines() {
-  for (Symbol *sym : getSymbols()) {
+  for (Symbol *sym : symbols()) {
     if (sym->isUndefWeak() && sym->isUsedInRegularObj) {
       if (sym->getSignature()) {
         replaceWithUndefined(sym);
       } else {
         // It is possible for undefined functions not to have a signature (eg.
         // if added via "--undefined"), but weak undefined ones do have a
         // signature.  Lazy symbols may not be functions and therefore Sig can
         // still be null in some circumstance.

lld/wasm/SyntheticSections.cpp

void DylinkSection::writeBody() {
   // Under certain circumstances we need to include extra information about our
   // exports and/or imports to the dynamic linker.
   // For exports we need to notify the linker when an export is TLS since the
   // exported value is relative to __tls_base rather than __memory_base.
   // For imports we need to notify the dynamic linker when an import is weak
   // so that knows not to report an error for such symbols.
   std::vector<const Symbol *> importInfo;
   std::vector<const Symbol *> exportInfo;
-  for (const Symbol *sym : symtab->getSymbols()) {
+  for (const Symbol *sym : symtab->symbols()) {
     if (sym->isLive()) {
       if (sym->isExported() && sym->isTLS() && isa<DefinedData>(sym)) {
         exportInfo.push_back(sym);
       }
       if (sym->isUndefWeak()) {
         importInfo.push_back(sym);
       }
     }

lld/wasm/Writer.cpp

 void Writer::calculateImports() {
   // Some inputs require that the indirect function table be assigned to table
   // number 0, so if it is present and is an import, allocate it before any
   // other tables.
   if (WasmSym::indirectFunctionTable &&
       shouldImport(WasmSym::indirectFunctionTable))
     out.importSec->addImport(WasmSym::indirectFunctionTable);
 
-  for (Symbol *sym : symtab->getSymbols()) {
+  for (Symbol *sym : symtab->symbols()) {
     if (!shouldImport(sym))
       continue;
     if (sym == WasmSym::indirectFunctionTable)
       continue;
     LLVM_DEBUG(dbgs() << "import: " << sym->getName() << "\n");
     out.importSec->addImport(sym);
   }
 }
 
 void Writer::calculateExports() {
   if (config->relocatable)
     return;
 
   if (!config->relocatable && !config->importMemory)
     out.exportSec->exports.push_back(
         WasmExport{"memory", WASM_EXTERNAL_MEMORY, 0});
 
   unsigned globalIndex =
       out.importSec->getNumImportedGlobals() + out.globalSec->numGlobals();
 
-  for (Symbol *sym : symtab->getSymbols()) {
+  for (Symbol *sym : symtab->symbols()) {
     if (!sym->isExported())
       continue;
     if (!sym->isLive())
       continue;
 
     StringRef name = sym->getName();
     WasmExport export_;
     if (auto *f = dyn_cast<DefinedFunction>(sym)) {
for (Symbol *sym : symtab->symbols()) {
     out.exportSec->exportedSymbols.push_back(sym);
   }
 }
 
 void Writer::populateSymtab() {
   if (!config->relocatable && !config->emitRelocs)
     return;
 
-  for (Symbol *sym : symtab->getSymbols())
+  for (Symbol *sym : symtab->symbols())
     if (sym->isUsedInRegularObj && sym->isLive())
       out.linkingSec->addToSymtab(sym);
 
   for (ObjFile *file : symtab->objectFiles) {
     LLVM_DEBUG(dbgs() << "Local symtab entries: " << file->getName() << "\n");
     for (Symbol *sym : file->getSymbols())
       if (sym->isLocal() && !isa<SectionSymbol>(sym) && sym->isLive())
         out.linkingSec->addToSymtab(sym);
void Writer::createCommandExportWrappers() {
 
   // If there are no ctors and there's no libc `__wasm_call_dtors` to
   // call, don't wrap the exports.
   if (initFunctions.empty() && WasmSym::callDtors == nullptr)
     return;
 
   std::vector<DefinedFunction *> toWrap;
 
-  for (Symbol *sym : symtab->getSymbols())
+  for (Symbol *sym : symtab->symbols())
     if (sym->isExported())
       if (auto *f = dyn_cast<DefinedFunction>(sym))
         toWrap.push_back(f);
 
   for (auto *f : toWrap) {
     auto funcNameStr = (f->getName() + ".command_export").str();
     commandExportWrapperNames.push_back(funcNameStr);
     const std::string &funcName = commandExportWrapperNames.back();