[WebAssembly] Warn but don't error on conflicting uses of prototype-less functions

[sbc100]

Summary

When we can't determine with certainty the signature of a function
import we pick the fist one we find rather than error'ing out.

The resulting program might not do what is expected since we might pick
the wrong signature. However since its behaviour in C to use the same
function with different signatures this seems beter than refusing to
compile such programs.

Fixes PR40472

[dschuff]

By "pick one at random" you mean we are rewriting one of the calls to drop or add parameters, right? And the one we pick is just the first one we happen to encounter?

[sbc100]

In D58304#1400010, @dschuff wrote:

By "pick one at random" you mean we are rewriting one of the calls to drop or add parameters, right? And the one we pick is just the first one we happen to encounter?

Basically yes. Although the rewriting is don't in FixFunctionBitcasts, this pass simply assigned a prototype where there was none.

[sbc100]

llvm/lib/Target/WebAssembly/WebAssemblyAddMissingPrototypes.cpp

105 ↗

(On Diff #187080)

Is there some better way to generate a warning in an llvm pass?

[sbc100]

• fix warning

llvm/trunk/lib/Target/WebAssembly/WebAssemblyAddMissingPrototypes.cpp

if (F.getFunctionType()->getNumParams() != 0)
           F.getName());
 
     // Create a function prototype based on the first call site (first bitcast)
     // that we find.
     FunctionType *NewType = nullptr;
     Function *NewF = nullptr;
     for (Use &U : F.uses()) {
       LLVM_DEBUG(dbgs() << "prototype-less use: " << F.getName() << "\n");
+      LLVM_DEBUG(dbgs() << *U.getUser() << "\n");
       if (auto *BC = dyn_cast<BitCastOperator>(U.getUser())) {
         if (auto *DestType = dyn_cast<FunctionType>(
                 BC->getDestTy()->getPointerElementType())) {
           if (!NewType) {
             // Create a new function with the correct type
             NewType = DestType;
+            LLVM_DEBUG(dbgs() << "found function type: " << *NewType << "\n");
             NewF = Function::Create(NewType, F.getLinkage(), F.getName() + ".fixed_sig");
             NewF->setAttributes(F.getAttributes());
             NewF->removeFnAttr("no-prototype");
             Replacements.emplace_back(&F, NewF);
-          } else {
-            if (NewType != DestType) {
-              report_fatal_error("Prototypeless function used with "
-                                 "conflicting signatures: " +
-                                 F.getName());
-            }
+          } else if (NewType != DestType) {
+            errs() << "warning: prototype-less function used with "
+                      "conflicting signatures: "
+                   << F.getName() << "\n";
+            LLVM_DEBUG(dbgs() << "  " << *DestType << "\n");
+            LLVM_DEBUG(dbgs() << "  "<<  *NewType << "\n");
           }
         }
       }
     }
 
     if (!NewType) {
       LLVM_DEBUG(
           dbgs() << "could not derive a function prototype from usage: " +

llvm/trunk/test/CodeGen/WebAssembly/add-prototypes-conflit.ll

+; RUN: opt -S -wasm-add-missing-prototypes -o %t.ll %s 2>&1 | FileCheck %s -check-prefix=WARNING
+; RUN: cat %t.ll | FileCheck %s
+
+target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128"
+target triple = "wasm32-unknown-unknown"
+
+; WARNING: warning: prototype-less function used with conflicting signatures: foo
+
+; CHECK-LABEL: @call_with_conflicting_prototypes
+; CHECK: %call1 = call i64 bitcast (i64 (i32, i32)* @foo to i64 (i32)*)(i32 42)
+; CHECK: %call2 = call i64 @foo(i32 42, i32 43)
+define void @call_with_conflicting_prototypes() {
+  %call1 = call i64 bitcast (i64 (...)* @foo to i64 (i32)*)(i32 42)
+  %call2 = call i64 bitcast (i64 (...)* @foo to i64 (i32, i32)*)(i32 42, i32 43)
+  ret void
+}
+
+; CHECK: declare extern_weak i64 @foo(i32, i32)
+declare extern_weak i64 @foo(...) #1
+
+; CHECK-NOT: attributes {{.*}} = { {{.*}}"no-prototype"{{.*}} }
+attributes #1 = { "no-prototype" }