[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/data-layout.ll

 ; RUN: llc -filetype=obj %p/Inputs/hello.ll -o %t.hello.o
 ; RUN: llc -filetype=obj %s -o %t.o
 
 target triple = "wasm32-unknown-unknown-wasm"
 
 @foo = hidden global i32 1, align 4
 @aligned_bar = hidden global i32 3, align 16
 
 @hello_str = external global i8*
 @external_ref = global i8** @hello_str, align 8
 
 %struct.s = type { i32, i32 }
 @local_struct = hidden global %struct.s zeroinitializer, align 4
 @local_struct_internal_ptr = hidden local_unnamed_addr global i32* getelementptr inbounds (%struct.s, %struct.s* @local_struct, i32 0, i32 1), align 4
 
-; RUN: wasm-ld -no-gc-sections --allow-undefined -o %t.wasm %t.o %t.hello.o
+; RUN: wasm-ld -no-gc-sections --allow-undefined --no-entry -o %t.wasm %t.o %t.hello.o
 ; RUN: obj2yaml %t.wasm | FileCheck %s
 
 ; CHECK:        - Type:            MEMORY
 ; CHECK-NEXT:     Memories:
 ; CHECK-NEXT:       - Initial:         0x00000002
 ; CHECK-NEXT:   - Type:            GLOBAL
 ; CHECK-NEXT:     Globals:
 ; CHECK-NEXT:       - Index:           0

 ; CHECK-NEXT:         MemoryIndex:     0
 ; CHECK-NEXT:         Offset:          
 ; CHECK-NEXT:           Opcode:          I32_CONST
 ; CHECK-NEXT:           Value:           1064
 ; CHECK-NEXT:         Content:         68656C6C6F0A00
 ; CHECK-NEXT:    - Type:            CUSTOM
 
 
-; RUN: wasm-ld -no-gc-sections --allow-undefined \
+; RUN: wasm-ld -no-gc-sections --allow-undefined --no-entry \
 ; RUN:     --initial-memory=131072 --max-memory=131072 -o %t_max.wasm %t.o \
 ; RUN:     %t.hello.o
 ; RUN: obj2yaml %t_max.wasm | FileCheck %s -check-prefix=CHECK-MAX
 
 ; CHECK-MAX:        - Type:            MEMORY
 ; CHECK-MAX-NEXT:     Memories:
 ; CHECK-MAX-NEXT:       - Flags:           [ HAS_MAX ]
 ; CHECK-MAX-NEXT:         Initial:         0x00000002

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

test/wasm/load-undefined.test

 ; CHECK-NEXT:   - Type:
 
 
 ; Verify that referencing a symbol that doesn't exist won't work
 ; RUN: not wasm-ld %t.start.o -o %t.wasm -u symboldoesnotexist 2>&1 | FileCheck -check-prefix=CHECK-UNDEFINED1 %s
 ; CHECK-UNDEFINED1: error: undefined symbol: symboldoesnotexist
 
 ; RUN: not wasm-ld %t.start.o -o %t.wasm --undefined symboldoesnotexist --allow-undefined 2>&1 | FileCheck -check-prefix=CHECK-UNDEFINED2 %s
-; CHECK-UNDEFINED2: function forced with --undefined not found: symboldoesnotexist
+; CHECK-UNDEFINED2: symbol forced with --undefined not found: symboldoesnotexist

test/wasm/undefined-entry.test

 RUN: llc -filetype=obj %p/Inputs/ret32.ll -o %t.ret32.o
 RUN: not wasm-ld -o %t.wasm %t.ret32.o 2>&1 | FileCheck %s
 
 CHECK: error: undefined symbol: _start
 
 RUN: not wasm-ld -entry=foo -o %t.wasm %t.ret32.o 2>&1 | FileCheck %s -check-prefix=CHECK-CUSTOM
 
 CHECK-CUSTOM: error: undefined symbol: foo
 
-RUN: wasm-ld -entry=foo --allow-undefined -o %t.wasm %t.ret32.o
+RUN: wasm-ld --no-entry -o %t.wasm %t.ret32.o

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())
     return;
 
   // Add all files to the symbol table. This will add almost all
   // symbols that we need to the symbol table.
   for (InputFile *F : Files)
     Symtab->addFile(F);
 
   // Add synthetic dummies for weak undefined functions.
   if (!Config->Relocatable)
     handleWeakUndefines();
 
   // Make sure we have resolved all symbols.
   if (!Config->Relocatable && !Config->AllowUndefined) {
     Symtab->reportRemainingUndefines();
   } else {
-    // When we allow undefined symbols we cannot include those defined in
-    // -u/--undefined since these undefined symbols have only names and no
-    // function signature, which means they cannot be written to the final
-    // output.
+    // Even when using --allow-undefined we still want to report the absence of
+    // our initial set of undefined symbols (i.e. the entry point and symbols
+    // specified via --undefined).
+    // Part of the reason for this is that these function don't have signatures
+    // so which means they cannot be written as wasm function imports.
     for (auto *Arg : Args.filtered(OPT_undefined)) {
       Symbol *Sym = Symtab->find(Arg->getValue());
       if (!Sym->isDefined())
-        error("function forced with --undefined not found: " + Sym->getName());
+        error("symbol forced with --undefined not found: " + Sym->getName());
     }
+    if (EntrySym && !EntrySym->isDefined())
+      error("entry symbol not defined: " + EntrySym->getName());
   }
   if (errorCount())
     return;
 
   // Handle --export.
   for (auto *Arg : Args.filtered(OPT_export)) {
     StringRef Name = Arg->getValue();
     Symbol *Sym = Symtab->find(Name);

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.