[WebAssembly] Remove redundant function: addSyntheticUndefinedFunction. NFC.

[sbc100]

• revert part of this change to keep it tiny

wasm/Driver.cpp

 static Optional<std::string> findFile(StringRef Path1, const Twine &Path2) {
   SmallString<128> S;
   path::append(S, Path1, Path2);
   if (fs::exists(S))
     return S.str().str();
   return None;
 }
 
-// Inject a new undefined symbol into the link.  This will cause the link to
-// fail unless this symbol can be found.
-static void addSyntheticUndefinedFunction(StringRef Name,
-                                          const WasmSignature *Type) {
-  log("injecting undefined func: " + Name);
-  Symtab->addUndefinedFunction(Name, Type);
-}
-
 static void printHelp(const char *Argv0) {
   WasmOptTable().PrintHelp(outs(), Argv0, "LLVM Linker", false);
 }
 
 WasmOptTable::WasmOptTable() : OptTable(OptInfo) {}
 
 opt::InputArgList WasmOptTable::parse(ArrayRef<const char *> Argv) {
   SmallVector<const char *, 256> Vec(Argv.data(), Argv.data() + Argv.size());
void LinkerDriver::link(ArrayRef<const char *> ArgsArr) {
   if (Config->Relocatable && !Config->Entry.empty())
     error("entry point specified for relocatable output file");
   if (Config->Relocatable && Args.hasArg(OPT_undefined))
     error("undefined symbols specified for relocatable output file");
 
   if (!Config->Relocatable) {
     static WasmSignature Signature = {{}, WASM_TYPE_NORESULT};
     if (!Config->Entry.empty())
-      addSyntheticUndefinedFunction(Config->Entry, &Signature);
+      Symtab->addUndefinedFunction(Config->Entry, &Signature);
 
     // Handle the `--undefined <sym>` options.
     for (auto* Arg : Args.filtered(OPT_undefined))
-      addSyntheticUndefinedFunction(Arg->getValue(), nullptr);
+      Symtab->addUndefinedFunction(Arg->getValue(), nullptr);
 
     // Create linker-synthetic symbols
     // __wasm_call_ctors:
     //    Function that directly calls all ctors in priority order.
     // __stack_pointer:
     //    Wasm global that holds the address of the top of the explict
     //    value stack in linear memory.
     // __dso_handle;

wasm/SymbolTable.cpp

Symbol *SymbolTable::addDefinedFunction(StringRef Name,
   Symbol *S;
   bool WasInserted;
   std::tie(S, WasInserted) = insert(Name);
   if (WasInserted) {
     S->update(Symbol::DefinedFunctionKind, nullptr, Flags);
     S->setFunctionType(Type);
   } else if (!S->isFunction()) {
     error("symbol type mismatch: " + Name);
+  } else if (!S->isDefined()) {
+    DEBUG(dbgs() << "resolving existing undefined function: " << Name << "\n");
+    S->update(Symbol::DefinedFunctionKind, nullptr, Flags);
   }
   return S;
 }
 
 Symbol *SymbolTable::addDefinedGlobal(StringRef Name) {
   DEBUG(dbgs() << "addDefinedGlobal: " << Name << "\n");
   Symbol *S;
   bool WasInserted;
   std::tie(S, WasInserted) = insert(Name);
-  if (WasInserted)
+  if (WasInserted) {
     S->update(Symbol::DefinedGlobalKind);
-  else if (!S->isGlobal())
+  } else if (!S->isGlobal()) {
     error("symbol type mismatch: " + Name);
+  } else {
+    DEBUG(dbgs() << "resolving existing undefined global: " << Name << "\n");
+    S->update(Symbol::DefinedGlobalKind);
+  }
   return S;
 }
 
 Symbol *SymbolTable::addDefined(StringRef Name, Symbol::Kind Kind,
                                 uint32_t Flags, InputFile *F,
                                 const InputSegment *Segment,
                                 InputFunction *Function, uint32_t Address) {
   DEBUG(dbgs() << "addDefined: " << Name << " addr:" << Address << "\n");
if (WasInserted) {
     // neither symbol is week. They conflict.
     reportDuplicate(S, F);
   }
   return S;
 }
 
 Symbol *SymbolTable::addUndefinedFunction(StringRef Name,
                                           const WasmSignature *Type) {
+  DEBUG(dbgs() << "addUndefinedFunction: " << Name << "\n");
   Symbol *S;
   bool WasInserted;
   std::tie(S, WasInserted) = insert(Name);
   if (WasInserted) {
     S->update(Symbol::UndefinedFunctionKind);
     S->setFunctionType(Type);
   } else if (!S->isFunction()) {
     error("symbol type mismatch: " + Name);