[lld][WebAssembly] Fix spurious signature mismatch warnings

[sbc100]

Summary

This a follow up on: https://reviews.llvm.org/D62153

Handle the case where there are multiple object files that contain
undefined references to the same function. We only generate a function
variant if the existing symbol is directly called.

See: https://github.com/emscripten-core/emscripten/issues/8995

lld/trunk/test/wasm/signature-mismatch-unknown.ll

 ; RUN: llc -filetype=obj %p/Inputs/ret32.ll -o %t.ret32.o
 ; RUN: llc -filetype=obj %s -o %t.main.o
 ; RUN: wasm-ld --fatal-warnings -o %t.wasm %t.ret32.o %t.main.o
 ; RUN: wasm-ld --fatal-warnings -o %t.wasm %t.main.o %t.ret32.o
 
+; Also test the case where there are two different object files that contains
+; referneces ret32:
+; %t.main.o: Does not call ret32 directly; used the wrong signature.
+; %t.call-ret32.o: Calls ret32 directly; uses the correct signature.
+; RUN: llc -filetype=obj %p/Inputs/call-ret32.ll -o %t.call-ret32.o
+; RUN: wasm-ld --export=call_ret32 --fatal-warnings -o %t.wasm %t.main.o %t.call-ret32.o %t.ret32.o
+; RUN: wasm-ld --export=call_ret32 --fatal-warnings -o %t.wasm %t.call-ret32.o %t.main.o %t.ret32.o
+
 target triple = "wasm32-unknown-unknown"
 
 ; Function declartion with incorrect signature.
 declare dso_local void @ret32()
 
 ; Simply taking the address of the function should *not* generate the
 ; the signature mismatch warning.
 @ptr = dso_local global i8* bitcast (void ()* @ret32 to i8*), align 8
 
 define hidden void @_start() local_unnamed_addr {
   %addr = load i32 ()*, i32 ()** bitcast (i8** @ptr to i32 ()**), align 8
   call i32 %addr()
   ret void
 }

lld/trunk/wasm/SymbolTable.cpp

Symbol *SymbolTable::addUndefinedFunction(StringRef name, StringRef importName,
   else {
     auto existingFunction = dyn_cast<FunctionSymbol>(s);
     if (!existingFunction) {
       reportTypeError(s, file, WASM_SYMBOL_TYPE_FUNCTION);
       return s;
     }
     if (!existingFunction->signature && sig)
       existingFunction->signature = sig;
-    if (isCalledDirectly && !signatureMatches(existingFunction, sig))
-      if (getFunctionVariant(s, sig, file, &s))
+    if (isCalledDirectly && !signatureMatches(existingFunction, sig)) {
+      auto* existingUndefined = dyn_cast<UndefinedFunction>(existingFunction);
+      // If the existing undefined functions is not called direcltly then let
+      // this one take precedence.  Otherwise the existing function is either
+      // direclty called or defined, in which case we need a function variant.
+      if (existingUndefined && !existingUndefined->isCalledDirectly)
         replaceSym();
+      else if (getFunctionVariant(s, sig, file, &s))
+        replaceSym();
+    }
   }
 
   return s;
 }
 
 Symbol *SymbolTable::addUndefinedData(StringRef name, uint32_t flags,
                                       InputFile *file) {
   LLVM_DEBUG(dbgs() << "addUndefinedData: " << name << "\n");