[WebAssembly] Allow signature of entry function to be flexible

[sbc100]

Summary

Since we a no longer using this function for the wasm start
section we don't actually care what its signature is.

Currently we expect to be (void) -> (void) which causes linker
warnings for people trying to do things like --entry=main.

This means that the entry point now joins the list of undefined
functions that are not effected by the --allow-undefined
flag. If you want an undefined entry you now need to pass
--no-entry.

[sbc100]

• don't allow undefined entry

[sbc100]

• cleanup

[sbc100]

Ping.

[ruiu]

LGTM

test/wasm/Inputs/comdat2.ll

 target triple = "wasm32-unknown-unknown-wasm"
 
 $inlineFn = comdat any
 @constantData = weak_odr constant [3 x i8] c"abc", comdat($inlineFn)
 define linkonce_odr i32 @inlineFn() comdat {
 entry:
   ret i32 ptrtoint ([3 x i8]* @constantData to i32)
 }
 
 define i32 @callInline2() {
 entry:
-    ret i32 ptrtoint (i32 ()* @inlineFn to i32)
 }

test/wasm/entry-signature.ll

+; Verify that the entry point signauture can be flexible.
+; RUN: llc -filetype=obj %s -o %t.o
+; RUN: wasm-ld -o %t1.wasm %t.o
+
+target triple = "wasm32-unknown-unknown-wasm"
+
+define hidden i32 @_start(i32, i64) local_unnamed_addr #0 {
+entry:
+  ret i32 0
+}
+

test/wasm/entry.ll

 ; CHECK-NEXT:       - Name:            __data_end
 ; CHECK-NEXT:         Kind:            GLOBAL
 ; CHECK-NEXT:         Index:           2
 ; CHECK-NEXT:       - Name:            entry
 ; CHECK-NEXT:         Kind:            FUNCTION
 ; CHECK-NEXT:         Index:           1
 ; CHECK-NEXT:   - Type:
 
-; The __wasm_call_ctors is somewhat special.  Make sure we can use it
-; as the entry point if we choose
+; The __wasm_call_ctors is somewhat special since its created by the linker.
+; Make sure we can use it as the entry point if we choose
 ; RUN: wasm-ld --entry=__wasm_call_ctors -o %t3.wasm %t.o
 ; RUN: obj2yaml %t3.wasm | FileCheck %s -check-prefix=CHECK-CTOR
 
 ; CHECK-CTOR:        - Type:            EXPORT
 ; CHECK-CTOR-NEXT:     Exports:
 ; CHECK-CTOR-NEXT:       - Name:            memory
 ; CHECK-CTOR-NEXT:         Kind:            MEMORY
 ; CHECK-CTOR-NEXT:         Index:           0

test/wasm/fatal-warnings.ll

 ; RUN: llc -filetype=obj %s -o %t.main.o
-; RUN: lld -flavor wasm -o %t.wasm %t.main.o 2>&1 | FileCheck %s -check-prefix=CHECK-WARN
-; RUN: not lld -flavor wasm --fatal-warnings -o %t.wasm %t.main.o 2>&1 | FileCheck %s -check-prefix=CHECK-FATAL
+; RUN: llc -filetype=obj %p/Inputs/ret32.ll -o %t.ret32.o
+; RUN: lld -flavor wasm -o %t.wasm %t.main.o %t.ret32.o 2>&1 | FileCheck %s -check-prefix=CHECK-WARN
+; RUN: not lld -flavor wasm --fatal-warnings -o %t.wasm %t.main.o %t.ret32.o 2>&1 | FileCheck %s -check-prefix=CHECK-FATAL
 
-; CHECK-WARN: warning: Function type mismatch: _start
-; CHECK-FATAL: error: Function type mismatch: _start
+; CHECK-WARN: warning: Function type mismatch: ret32
+; CHECK-FATAL: error: Function type mismatch: ret32
 
 target triple = "wasm32-unknown-unknown-wasm"
 
-define hidden i32 @_start(i32 %arg) local_unnamed_addr {
+define hidden void @_start() local_unnamed_addr #0 {
 entry:
-  ret i32 %arg
+  %call = tail call i32 @ret32(i32 1, i64 2, i32 3) #2
+  ret void
 }
 
+declare i32 @ret32(i32, i64, i32) local_unnamed_addr #1

wasm/Driver.cpp

WasmSym::CallCtors = Symtab->addSyntheticFunction(
         make<SyntheticFunction>(NullSignature, "__wasm_call_ctors"));
     WasmSym::StackPointer = Symtab->addSyntheticGlobal(
         "__stack_pointer", WASM_SYMBOL_VISIBILITY_HIDDEN, StackPointer);
     WasmSym::HeapBase = Symtab->addSyntheticDataSymbol("__heap_base", 0);
     WasmSym::DsoHandle = Symtab->addSyntheticDataSymbol(
         "__dso_handle", WASM_SYMBOL_VISIBILITY_HIDDEN);
     WasmSym::DataEnd = Symtab->addSyntheticDataSymbol("__data_end", 0);
 
+    // For now, since we don't actually use the start function as the
+    // wasm start symbol, we don't need to care about it signature.
     if (!Config->Entry.empty())
-      EntrySym = Symtab->addUndefinedFunction(Config->Entry, 0, nullptr,
-                                              &NullSignature);
+      EntrySym =
+          Symtab->addUndefinedFunction(Config->Entry, 0, nullptr, nullptr);
 
     // Handle the `--undefined <sym>` options.
     for (auto *Arg : Args.filtered(OPT_undefined))
       Symtab->addUndefinedFunction(Arg->getValue(), 0, nullptr, nullptr);
   }
 
   createFiles(Args);
   if (errorCount())

wasm/SymbolTable.cpp

static void reportTypeError(const Symbol *Existing, const InputFile *File,
   error("symbol type mismatch: " + toString(*Existing) + "\n>>> defined as " +
         toString(Existing->getWasmType()) + " in " +
         toString(Existing->getFile()) + "\n>>> defined as " + Type + " in " +
         toString(File));
 }
 
 static void checkFunctionType(const Symbol *Existing, const InputFile *File,
                               const WasmSignature *NewSig) {
-  if (!isa<FunctionSymbol>(Existing)) {
+  auto ExistingFunction = dyn_cast<FunctionSymbol>(Existing);
+  if (!ExistingFunction) {
     reportTypeError(Existing, File, "Function");
     return;
   }
 
-  const WasmSignature *OldSig =
-      cast<FunctionSymbol>(Existing)->getFunctionType();
-  if (OldSig && *NewSig != *OldSig) {
+  const WasmSignature *OldSig = ExistingFunction->getFunctionType();
+  if (OldSig && NewSig && *NewSig != *OldSig) {
     warn("Function type mismatch: " + Existing->getName() +
          "\n>>> defined as " + toString(*OldSig) + " in " +
          toString(Existing->getFile()) + "\n>>> defined as " +
          toString(*NewSig) + " in " + toString(File));
   }
 }
 
 // Check the type of new symbol matches that of the symbol is replacing.

wasm/Writer.cpp

if (!Sym->isUndefined())
       continue;
     if (isa<DataSymbol>(Sym))
       continue;
     if (Sym->isWeak() && !Config->Relocatable)
       continue;
     if (!Sym->isLive())
       continue;
 
-    DEBUG(dbgs() << "import: " << Sym->getName() << "\n");
-    ImportedSymbols.emplace_back(Sym);
-    if (auto *F = dyn_cast<FunctionSymbol>(Sym))
+    if (auto *F = dyn_cast<FunctionSymbol>(Sym)) {
+      if (F->getFunctionType() == nullptr) {
+        assert(Config->AllowUndefined);
+        continue;
+      }
       F->setFunctionIndex(NumImportedFunctions++);
-    else
+    } else {
       cast<GlobalSymbol>(Sym)->setGlobalIndex(NumImportedGlobals++);
     }
+
+    ImportedSymbols.emplace_back(Sym);
+    DEBUG(dbgs() << "import: " << Sym->getName() << "\n");
+  }
 }
 
 void Writer::calculateExports() {
   if (Config->Relocatable)
     return;
 
   for (Symbol *Sym : Symtab->getSymbols()) {
     if (!Sym->isDefined())