[WebAssembly] Don't mark lazy symbols as `IsUsedInRegularObj`

[sbc100]

Summary

This matches the ELF does. Update the comment in ELF/Symbols.h and
duplicate it in wasm/Symbols.h

This a followup on rL355580 and rL355577.

[sbc100]

• revert

[sbc100]

ping..

[pcc]

LGTM

lld/trunk/ELF/Symbols.h

public:
   uint8_t SymbolKind;
 
   // Symbol visibility. This is the computed minimum visibility of all
   // observed non-DSO symbols.
   unsigned Visibility : 2;
 
   // True if the symbol was used for linking and thus need to be added to the
   // output file's symbol table. This is true for all symbols except for
-  // unreferenced DSO symbols and bitcode symbols that are unreferenced except
-  // by other bitcode objects.
+  // unreferenced DSO symbols, lazy (archive) symbols, and bitcode symbols that
+  // are unreferenced except by other bitcode objects.
   unsigned IsUsedInRegularObj : 1;
 
   // If this flag is true and the symbol has protected or default visibility, it
   // will appear in .dynsym. This flag is set by interposable DSO symbols in
   // executables, by most symbols in DSOs and executables built with
   // --export-dynamic, and by dynamic lists.
   unsigned ExportDynamic : 1;
 

lld/trunk/wasm/SymbolTable.cpp

 }
 
 DefinedFunction *SymbolTable::addSyntheticFunction(StringRef Name,
                                                    uint32_t Flags,
                                                    InputFunction *Function) {
   LLVM_DEBUG(dbgs() << "addSyntheticFunction: " << Name << "\n");
   assert(!find(Name));
   SyntheticFunctions.emplace_back(Function);
-  return replaceSymbol<DefinedFunction>(insert(Name, nullptr).first, Name,
+  return replaceSymbol<DefinedFunction>(insertName(Name).first, Name,
                                         Flags, nullptr, Function);
 }
 
 DefinedData *SymbolTable::addSyntheticDataSymbol(StringRef Name,
                                                  uint32_t Flags) {
   LLVM_DEBUG(dbgs() << "addSyntheticDataSymbol: " << Name << "\n");
   assert(!find(Name));
-  return replaceSymbol<DefinedData>(insert(Name, nullptr).first, Name, Flags);
+  return replaceSymbol<DefinedData>(insertName(Name).first, Name, Flags);
 }
 
 DefinedGlobal *SymbolTable::addSyntheticGlobal(StringRef Name, uint32_t Flags,
                                                InputGlobal *Global) {
   LLVM_DEBUG(dbgs() << "addSyntheticGlobal: " << Name << " -> " << Global
                     << "\n");
   assert(!find(Name));
   SyntheticGlobals.emplace_back(Global);
-  return replaceSymbol<DefinedGlobal>(insert(Name, nullptr).first, Name, Flags,
+  return replaceSymbol<DefinedGlobal>(insertName(Name).first, Name, Flags,
                                       nullptr, Global);
 }
 
 static bool shouldReplace(const Symbol *Existing, InputFile *NewFile,
                           uint32_t NewFlags) {
   // If existing symbol is undefined, replace it.
   if (!Existing->isDefined()) {
     LLVM_DEBUG(dbgs() << "resolving existing undefined symbol: "

 }
 
 void SymbolTable::addLazy(ArchiveFile *File, const Archive::Symbol *Sym) {
   LLVM_DEBUG(dbgs() << "addLazy: " << Sym->getName() << "\n");
   StringRef Name = Sym->getName();
 
   Symbol *S;
   bool WasInserted;
-  std::tie(S, WasInserted) = insert(Name, nullptr);
+  std::tie(S, WasInserted) = insertName(Name);
 
   if (WasInserted) {
     replaceSymbol<LazySymbol>(S, Name, 0, File, *Sym);
     return;
   }
 
   if (!S->isUndefined())
     return;

lld/trunk/wasm/Symbols.h

public:
   // Get/set the index in the output symbol table.  This is only used for
   // relocatable output.
   uint32_t getOutputSymbolIndex() const;
   void setOutputSymbolIndex(uint32_t Index);
 
   WasmSymbolType getWasmType() const;
   bool isExported() const;
 
-  // True if this symbol was referenced by a regular (non-bitcode) object.
+  // True if the symbol was used for linking and thus need to be added to the
+  // output file's symbol table. This is true for all symbols except for
+  // unreferenced DSO symbols, lazy (archive) symbols, and bitcode symbols that
+  // are unreferenced except by other bitcode objects.
   unsigned IsUsedInRegularObj : 1;
+
+  // True if ths symbol is explicity marked for export (i.e. via the -e/--export
+  // command line flag)
   unsigned ForceExport : 1;
 
   // True if this symbol is specified by --trace-symbol option.
   unsigned Traced : 1;
 
   const WasmSignature* getSignature() const;
 
 protected:

lld/trunk/wasm/Writer.cpp

auto AddSymbol = [&](Symbol *Sym) {
     // (Since this is relocatable output, GC is not performed so symbols must
     // be live.)
     assert(Sym->isLive());
     Sym->setOutputSymbolIndex(SymbolIndex++);
     SymtabEntries.emplace_back(Sym);
   };
 
   for (Symbol *Sym : Symtab->getSymbols())
-    if (!Sym->isLazy() && Sym->IsUsedInRegularObj)
+    if (Sym->IsUsedInRegularObj)
       AddSymbol(Sym);
 
   for (ObjFile *File : Symtab->ObjectFiles) {
     LLVM_DEBUG(dbgs() << "Local symtab entries: " << File->getName() << "\n");
     for (Symbol *Sym : File->getSymbols())
       if (Sym->isLocal())
         AddSymbol(Sym);
   }