[WebAssembly] Check function signatures by default

[sbc100]

Summary

But only produce a warning for now unless --fatal-warnings
is passed

[ruiu]

LGTM

test/wasm/alias.ll

 ; RUN: llc -filetype=obj -o %t.o %s
-; RUN: wasm-ld --check-signatures %t.o -o %t.wasm
+; RUN: wasm-ld %t.o -o %t.wasm
 ; RUN: obj2yaml %t.wasm | FileCheck %s
 
 target triple = "wasm32-unknown-unknown-wasm"
 
 @start_alias = alias void (), void ()* @_start
 
 ; Function Attrs: nounwind uwtable
 define void @_start() local_unnamed_addr #1 {

test/wasm/archive.ll

 ; RUN: llc -filetype=obj %s -o %t.o
 ; RUN: llc -filetype=obj %S/Inputs/archive1.ll -o %t.a1.o
 ; RUN: llc -filetype=obj %S/Inputs/archive2.ll -o %t.a2.o
 ; RUN: llc -filetype=obj %S/Inputs/hello.ll -o %t.a3.o
 ; RUN: llvm-ar rcs %t.a %t.a1.o %t.a2.o %t.a3.o
 ; RUN: rm -f %t.imports
-; RUN: not wasm-ld --check-signatures %t.a %t.o -o %t.wasm 2>&1 | FileCheck -check-prefix=CHECK-UNDEFINED %s
+; RUN: not wasm-ld %t.a %t.o -o %t.wasm 2>&1 | FileCheck -check-prefix=CHECK-UNDEFINED %s
 
 ; CHECK-UNDEFINED: undefined symbol: missing_func
 
 ; RUN: echo 'missing_func' > %t.imports
-; RUN: wasm-ld --check-signatures -r %t.a %t.o -o %t.wasm
+; RUN: wasm-ld -r %t.a %t.o -o %t.wasm
 
 ; RUN: llvm-nm -a %t.wasm | FileCheck %s
 
 target triple = "wasm32-unknown-unknown-wasm"
 
 declare i32 @foo() local_unnamed_addr #1
 declare i32 @missing_func() local_unnamed_addr #1
 

 ; CHECK-NEXT: 00000001 T bar
 ; CHECK-NEXT: 00000002 T foo
 ; CHECK-NEXT:          U missing_func
 
 ; Verify that symbols from unused objects don't appear in the symbol table
 ; CHECK-NOT: hello
 
 ; Specifying the same archive twice is allowed.
-; RUN: wasm-ld --check-signatures %t.a %t.a %t.o -o %t.wasm
+; RUN: wasm-ld %t.a %t.a %t.o -o %t.wasm

test/wasm/call-indirect.ll

 ; RUN: llc -filetype=obj %p/Inputs/call-indirect.ll -o %t2.o
 ; RUN: llc -filetype=obj %s -o %t.o
-; RUN: wasm-ld --check-signatures -o %t.wasm %t2.o %t.o
+; RUN: wasm-ld -o %t.wasm %t2.o %t.o
 ; RUN: obj2yaml %t.wasm | FileCheck %s
 
 ; bitcode generated from the following C code:
 ; int foo(void) { return 1; }
 ; int (*indirect_func)(void) = &foo;
 ; void _start(void) { indirect_func(); }
 
 target triple = "wasm32-unknown-unknown-wasm"

test/wasm/comdats.ll

 ; RUN: llc -filetype=obj -mtriple=wasm32-unknown-uknown-wasm %p/Inputs/comdat1.ll -o %t1.o
 ; RUN: llc -filetype=obj -mtriple=wasm32-unknown-uknown-wasm %p/Inputs/comdat2.ll -o %t2.o
 ; RUN: llc -filetype=obj -mtriple=wasm32-unknown-uknown-wasm %s -o %t.o
-; RUN: wasm-ld --check-signatures -o %t.wasm %t.o %t1.o %t2.o
+; RUN: wasm-ld -o %t.wasm %t.o %t1.o %t2.o
 ; RUN: obj2yaml %t.wasm | FileCheck %s
 
 target triple = "wasm32-unknown-unknown-wasm"
 
 declare i32 @inlineFn()
 
 define void @_start() local_unnamed_addr {
 entry:

test/wasm/conflict.test

 # RUN: llc -filetype=obj %p/Inputs/ret32.ll -o %t.ret32.o
-# RUN: not wasm-ld --check-signatures -o %t.wasm %t.ret32.o %t.ret32.o 2>&1 | FileCheck %s
+# RUN: not wasm-ld -o %t.wasm %t.ret32.o %t.ret32.o 2>&1 | FileCheck %s
 
 # CHECK:      duplicate symbol: ret32
 # CHECK-NEXT: >>> defined in {{.*}}conflict.test.tmp.ret32.o
 # CHECK-NEXT: >>> defined in {{.*}}conflict.test.tmp.ret32.o

test/wasm/custom-sections.ll

 ; RUN: llc -filetype=obj %s -o %t1.o
 ; RUN: llc -filetype=obj  %S/Inputs/custom.ll -o %t2.o
-; RUN: wasm-ld --check-signatures --relocatable -o %t.wasm %t1.o %t2.o
+; RUN: wasm-ld --relocatable -o %t.wasm %t1.o %t2.o
 ; RUN: obj2yaml %t.wasm | FileCheck %s
 
 target triple = "wasm32-unknown-unknown-wasm"
 
 define i32 @_start() local_unnamed_addr {
 entry:
   %retval = alloca i32, align 4
   ret i32 0

test/wasm/cxx-mangling.ll

 ; RUN: llc -filetype=obj %s -o %t.o
-; RUN: wasm-ld --demangle --check-signatures -o %t_demangle.wasm %t.o
+; RUN: wasm-ld --demangle -o %t_demangle.wasm %t.o
 ; RUN: obj2yaml %t_demangle.wasm | FileCheck %s
-; RUN: wasm-ld --no-demangle --check-signatures -o %t_nodemangle.wasm %t.o
+; RUN: wasm-ld --no-demangle -o %t_nodemangle.wasm %t.o
 ; RUN: obj2yaml %t_nodemangle.wasm | FileCheck %s
 
 target triple = "wasm32-unknown-unknown-wasm"
 
 ; Check that the EXPORT name is still mangled, but that the "name" custom
 ; section contains the unmangled name.
 
 define void @_Z3fooi(i32 %arg) {

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 --check-signatures --allow-undefined -o %t.wasm %t.o %t.hello.o
+; RUN: wasm-ld -no-gc-sections --allow-undefined -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 --check-signatures --allow-undefined \
+; RUN: wasm-ld -no-gc-sections --allow-undefined \
 ; 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
 ; CHECK-MAX-NEXT:         Maximum:         0x00000002
 
 
-; RUN: wasm-ld --check-signatures --relocatable -o %t_reloc.wasm %t.o %t.hello.o
+; RUN: wasm-ld --relocatable -o %t_reloc.wasm %t.o %t.hello.o
 ; RUN: obj2yaml %t_reloc.wasm | FileCheck %s -check-prefix=RELOC
 
 ; RELOC:       - Type:            DATA
 ; RELOC-NEXT:     Relocations:
 ; RELOC-NEXT:       - Type:            R_WEBASSEMBLY_MEMORY_ADDR_I32
 ; RELOC-NEXT:         Index:           6
 ; RELOC-NEXT:         Offset:          0x00000018
 ; RELOC-NEXT:       - Type:            R_WEBASSEMBLY_MEMORY_ADDR_I32

test/wasm/demangle.ll

 ; RUN: llc -filetype=obj %s -o %t.o
-; RUN: not wasm-ld --check-signatures --undefined _Z3fooi \
+; RUN: not wasm-ld --undefined _Z3fooi \
 ; RUN:     -o %t.wasm %t.o 2>&1 | FileCheck %s
 
 ; CHECK: error: undefined symbol: foo(int)
 
-; RUN: not wasm-ld --check-signatures --no-demangle --undefined _Z3fooi \
+; RUN: not wasm-ld --no-demangle --undefined _Z3fooi \
 ; RUN:     -o %t.wasm %t.o 2>&1 |  FileCheck -check-prefix=CHECK-NODEMANGLE %s
 
 ; CHECK-NODEMANGLE: error: undefined symbol: _Z3fooi
 
 target triple = "wasm32-unknown-unknown-wasm"
 
 define hidden void @_start() local_unnamed_addr {
 entry:
     ret void
 }

test/wasm/entry.ll

 ; RUN: llc -filetype=obj %s -o %t.o
 
 target triple = "wasm32-unknown-unknown-wasm"
 
 define hidden void @entry() local_unnamed_addr #0 {
 entry:
   ret void
 }
 
-; RUN: wasm-ld --check-signatures -e entry -o %t1.wasm %t.o
+; RUN: wasm-ld -e entry -o %t1.wasm %t.o
 ; RUN: obj2yaml %t1.wasm | FileCheck %s
-; RUN: wasm-ld --check-signatures --entry=entry -o %t2.wasm %t.o
+; RUN: wasm-ld --entry=entry -o %t2.wasm %t.o
 ; RUN: obj2yaml %t2.wasm | FileCheck %s
 
 ; CHECK:        - Type:            EXPORT
 ; CHECK-NEXT:     Exports:
 ; CHECK-NEXT:       - Name:            memory
 ; CHECK-NEXT:         Kind:            MEMORY
 ; CHECK-NEXT:         Index:           0
 ; CHECK-NEXT:       - Name:            __heap_base
 ; CHECK-NEXT:         Kind:            GLOBAL
 ; CHECK-NEXT:         Index:           1
 ; 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
-; RUN: wasm-ld --check-signatures --entry=__wasm_call_ctors -o %t3.wasm %t.o
+; 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
 ; CHECK-CTOR-NEXT:       - Name:            __wasm_call_ctors

test/wasm/export-table.test

 # RUN: llc -filetype=obj %p/Inputs/start.ll -o %t.start.o
-# RUN: wasm-ld --check-signatures --export-table -o %t.wasm %t.start.o
+# RUN: wasm-ld --export-table -o %t.wasm %t.start.o
 # RUN: obj2yaml %t.wasm | FileCheck %s
 
 # Verify the --export-table flag creates a table export
 
 # CHECK:        - Type:            TABLE
 # CHECK-NEXT:     Tables:
 # CHECK-NEXT:       - ElemType:        ANYFUNC
 # CHECK-NEXT:         Limits:

test/wasm/export.ll

 ; RUN: llc -filetype=obj %s -o %t.o
-; RUN: not wasm-ld --check-signatures --export=missing -o %t.wasm %t.o 2>&1 | FileCheck -check-prefix=CHECK-ERROR %s
-; RUN: wasm-ld --check-signatures --export=hidden_function -o %t.wasm %t.o
+; RUN: not wasm-ld --export=missing -o %t.wasm %t.o 2>&1 | FileCheck -check-prefix=CHECK-ERROR %s
+; RUN: wasm-ld --export=hidden_function -o %t.wasm %t.o
 ; RUN: obj2yaml %t.wasm | FileCheck %s
 
 target triple = "wasm32-unknown-unknown-wasm"
 
 define hidden i32 @hidden_function() local_unnamed_addr {
 entry:
   ret i32 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
+
+; CHECK-WARN: warning: Function type mismatch: _start
+; CHECK-FATAL: error: Function type mismatch: _start
+
+target triple = "wasm32-unknown-unknown-wasm"
+
+define hidden i32 @_start(i32 %arg) local_unnamed_addr {
+entry:
+  ret i32 %arg
+}
+

test/wasm/function-imports-first.ll

 ; RUN: llc -filetype=obj %p/Inputs/ret32.ll -o %t.ret32.o
 ; RUN: llc -filetype=obj %s -o %t.o
-; RUN: wasm-ld --check-signatures -o %t.wasm %t.o %t.ret32.o
+; RUN: wasm-ld -o %t.wasm %t.o %t.ret32.o
 ; RUN: obj2yaml %t.wasm | FileCheck %s
 
 target triple = "wasm32-unknown-unknown-wasm"
 
 ; Function Attrs: nounwind
 define hidden void @_start() local_unnamed_addr #0 {
 entry:
   %call = tail call i32 @ret32(float 0.000000e+00) #2

test/wasm/function-imports.ll

 ; RUN: llc -filetype=obj %p/Inputs/ret32.ll -o %t.ret32.o
 ; RUN: llc -filetype=obj %s -o %t.o
-; RUN: wasm-ld --check-signatures -o %t.wasm %t.ret32.o %t.o
+; RUN: wasm-ld -o %t.wasm %t.ret32.o %t.o
 ; RUN: obj2yaml %t.wasm | FileCheck %s
 
 target triple = "wasm32-unknown-unknown-wasm"
 
 ; Function Attrs: nounwind
 define hidden void @_start() local_unnamed_addr #0 {
 entry:
   %call = tail call i32 @ret32(float 0.000000e+00) #2

test/wasm/function-index.test

 # RUN: llc -filetype=obj %p/Inputs/ret32.ll -o %t.ret32.o
 # RUN: llc -filetype=obj %p/Inputs/ret64.ll -o %t.ret64.o
-# RUN: wasm-ld --check-signatures -r -o %t.wasm %t.ret32.o %t.ret64.o
+# RUN: wasm-ld -r -o %t.wasm %t.ret32.o %t.ret64.o
 # RUN: obj2yaml %t.wasm | FileCheck %s
 
 CHECK: Sections:
 CHECK:   - Type:            TYPE
 CHECK:     Signatures:
 CHECK:       - Index:           0
 CHECK:         ReturnType:      I32
 CHECK:         ParamTypes:
 CHECK:           - F32
 CHECK:       - Index:           1
 CHECK:         ReturnType:      I64
 CHECK:         ParamTypes:
 CHECK:           - F64
 CHECK: - Type:            FUNCTION
 CHECK:   FunctionTypes: [ 0, 1 ]

test/wasm/import-memory.test

 # RUN: llc -filetype=obj %p/Inputs/start.ll -o %t.start.o
-# RUN: wasm-ld --check-signatures --import-memory -o %t.wasm %t.start.o
+# RUN: wasm-ld --import-memory -o %t.wasm %t.start.o
 # RUN: obj2yaml %t.wasm | FileCheck %s
 
 # Verify the --import-memory flag creates a memory import
 
 # CHECK:       - Type:            IMPORT
 # CHECK-NEXT:    Imports:
 # CHECK-NEXT:      - Module:          env
 # CHECK-NEXT:        Field:           memory
 # CHECK-NEXT:        Kind:            MEMORY
 # CHECK-NEXT:        Memory:
 # CHECK-NEXT:          Initial:         0x00000002
 # CHECK-NEXT:  - Type:
 
 
 
-# RUN: wasm-ld --check-signatures --import-memory --initial-memory=262144 \
+# RUN: wasm-ld --import-memory --initial-memory=262144 \
 # RUN:     --max-memory=327680 -o %t.max.wasm %t.start.o
 # RUN: obj2yaml %t.max.wasm | FileCheck -check-prefix=CHECK-MAX %s
 
 # Verify the --initial-memory and --max-memory arguments work with imports
 
 # CHECK-MAX:       - Type:            IMPORT
 # CHECK-MAX-NEXT:    Imports:
 # CHECK-MAX-NEXT:      - Module:          env
 # CHECK-MAX-NEXT:        Field:           memory
 # CHECK-MAX-NEXT:        Kind:            MEMORY
 # CHECK-MAX-NEXT:        Memory:
 # CHECK-MAX-NEXT:          Flags:           [ HAS_MAX ]
 # CHECK-MAX-NEXT:          Initial:         0x00000004
 # CHECK-MAX-NEXT:          Maximum:         0x00000005
 # CHECK-MAX-NEXT:  - Type:

test/wasm/import-table.test

 # RUN: llc -filetype=obj %p/Inputs/start.ll -o %t.start.o
-# RUN: wasm-ld --check-signatures --import-table -o %t.wasm %t.start.o
+# RUN: wasm-ld --import-table -o %t.wasm %t.start.o
 # RUN: obj2yaml %t.wasm | FileCheck %s
 
 # Verify the --import-table flag creates a table import
 
 # CHECK:       - Type:            IMPORT
 # CHECK-NEXT:    Imports:
 # CHECK-NEXT:      - Module:          env
 # CHECK-NEXT:        Field:           __indirect_function_table
 # CHECK-NEXT:        Kind:            TABLE
 # CHECK-NEXT:        Table:
 # CHECK-NEXT:          ElemType:        ANYFUNC
 # CHECK-NEXT:          Limits:
 # CHECK-NEXT:            Flags:           [ HAS_MAX ]
 # CHECK-NEXT:            Initial:         0x00000001
 # CHECK-NEXT:            Maximum:         0x00000001
 

test/wasm/init-fini.ll

 
 @llvm.global_dtors = appending global [4 x { i32, void ()*, i8* }] [
   { i32, void ()*, i8* } { i32 1001, void ()* @func3, i8* null },
   { i32, void ()*, i8* } { i32 101, void ()* @func3, i8* null },
   { i32, void ()*, i8* } { i32 101, void ()* @func4, i8* null },
   { i32, void ()*, i8* } { i32 4000, void ()* @externDtor, i8* null }
 ]
 
-; RUN: wasm-ld --check-signatures --allow-undefined %t.o %t.global-ctor-dtor.o -o %t.wasm
+; RUN: wasm-ld --allow-undefined %t.o %t.global-ctor-dtor.o -o %t.wasm
 ; RUN: obj2yaml %t.wasm | FileCheck %s
 
 ; CHECK:        - Type:            IMPORT
 ; CHECK-NEXT:     Imports:
 ; CHECK-NEXT:       - Module:          env
 ; CHECK-NEXT:         Field:           externDtor
 ; CHECK-NEXT:         Kind:            FUNCTION
 ; CHECK-NEXT:         SigIndex:        0

 ; CHECK-NEXT:         Name:            .Lregister_call_dtors.202
 ; CHECK-NEXT:       - Index:           21
 ; CHECK-NEXT:         Name:            .Lcall_dtors.2002
 ; CHECK-NEXT:       - Index:           22
 ; CHECK-NEXT:         Name:            .Lregister_call_dtors.2002
 ; CHECK-NEXT: ...
 
 
-; RUN: wasm-ld --check-signatures -r %t.o %t.global-ctor-dtor.o -o %t.reloc.wasm
+; RUN: wasm-ld -r %t.o %t.global-ctor-dtor.o -o %t.reloc.wasm
 ; RUN: obj2yaml %t.reloc.wasm | FileCheck -check-prefix=RELOC %s
 
 ; RELOC:          SymbolTable:
 ; RELOC-NEXT:       - Index:           0
 ; RELOC-NEXT:         Kind:            FUNCTION
 ; RELOC-NEXT:         Name:            func1
 ; RELOC-NEXT:         Flags:           [ VISIBILITY_HIDDEN ]
 ; RELOC-NEXT:         Function:        2

test/wasm/invalid-stack-size.test

 ; RUN: llc -filetype=obj %p/Inputs/start.ll -o %t.o
-; RUN: not wasm-ld --check-signatures -o %t.wasm -z stack-size=1 %t.o 2>&1 | FileCheck %s
+; RUN: not wasm-ld -o %t.wasm -z stack-size=1 %t.o 2>&1 | FileCheck %s
 
 ; CHECK: error: stack size must be 16-byte aligned

test/wasm/load-undefined.test

 ; Verify that the -u / --undefined option is able to pull in symbols from
 ; an archive, and doesn't error when uses to pull in a symbol already loaded.
 ;
 ; RUN: llc -filetype=obj %S/Inputs/ret64.ll -o %t.o
 ; RUN: llc -filetype=obj %S/Inputs/ret32.ll -o %t2.o
 ; RUN: llc -filetype=obj %S/Inputs/start.ll -o %t.start.o
 ; RUN: llvm-ar rcs %t2.a %t2.o
-; RUN: wasm-ld --check-signatures %t.start.o %t2.a %t.o -o %t.wasm -u ret32 --undefined ret64
+; RUN: wasm-ld %t.start.o %t2.a %t.o -o %t.wasm -u ret32 --undefined ret64
 ; RUN: obj2yaml %t.wasm | FileCheck %s
 
 ; CHECK:        - Type:            EXPORT
 ; CHECK-NEXT:     Exports:
 ; CHECK-NEXT:       - Name:            memory
 ; CHECK-NEXT:         Kind:            MEMORY
 ; CHECK-NEXT:         Index:           0
 ; CHECK-NEXT:       - Name:            __heap_base

 ; CHECK-NEXT:         Index:           2
 ; CHECK-NEXT:       - Name:            ret64
 ; CHECK-NEXT:         Kind:            FUNCTION
 ; CHECK-NEXT:         Index:           3
 ; CHECK-NEXT:   - Type:
 
 
 ; Verify that referencing a symbol that doesn't exist won't work
-; RUN: not wasm-ld --check-signatures %t.start.o -o %t.wasm -u symboldoesnotexist 2>&1 | FileCheck -check-prefix=CHECK-UNDEFINED1 %s
+; 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 --check-signatures %t.start.o -o %t.wasm --undefined symboldoesnotexist --allow-undefined 2>&1 | FileCheck -check-prefix=CHECK-UNDEFINED2 %s
+; 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

test/wasm/local-symbols.ll

 ; RUN: llc -filetype=obj %s -o %t.o
-; RUN: wasm-ld --check-signatures -o %t.wasm %t.o
+; RUN: wasm-ld -o %t.wasm %t.o
 ; RUN: obj2yaml %t.wasm | FileCheck %s
 
 target triple = "wasm32-unknown-unknown-wasm"
 
 @foo = default global i32 1, align 4
 @bar = internal default global i32 3, align 4
 
 define internal i32 @baz() local_unnamed_addr {

test/wasm/locals-duplicate.test

 ; RUN: llc -filetype=obj %p/Inputs/locals-duplicate1.ll -o %t1.o
 ; RUN: llc -filetype=obj %p/Inputs/locals-duplicate2.ll -o %t2.o
-; RUN: wasm-ld --check-signatures --no-entry -o %t.wasm %t1.o %t2.o
+; RUN: wasm-ld --no-entry -o %t.wasm %t1.o %t2.o
 ; RUN: obj2yaml %t.wasm | FileCheck %s
 
 ; CHECK:      --- !WASM
 ; CHECK-NEXT: FileHeader:
 ; CHECK-NEXT:   Version:         0x00000001
 ; CHECK-NEXT: Sections:
 ; CHECK-NEXT:   - Type:            TYPE
 ; CHECK-NEXT:     Signatures:

 ; CHECK-NEXT:         Name:            get_func1B
 ; CHECK-NEXT:       - Index:           17
 ; CHECK-NEXT:         Name:            get_func2B
 ; CHECK-NEXT:       - Index:           18
 ; CHECK-NEXT:         Name:            get_func3B
 ; CHECK-NEXT: ...
 
 
-; RUN: wasm-ld --check-signatures -r --no-entry -o %t.reloc.wasm %t1.o %t2.o
+; RUN: wasm-ld -r --no-entry -o %t.reloc.wasm %t1.o %t2.o
 ; RUN: obj2yaml %t.reloc.wasm | FileCheck -check-prefix=RELOC %s
 
 ; RELOC:      --- !WASM
 ; RELOC-NEXT: FileHeader:
 ; RELOC-NEXT:   Version:         0x00000001
 ; RELOC-NEXT: Sections:
 ; RELOC-NEXT:   - Type:            TYPE
 ; RELOC-NEXT:     Signatures:

test/wasm/many-functions.ll

 ; RUN: llc -filetype=obj %p/Inputs/many-funcs.ll -o %t.many.o
 ; RUN: llc -filetype=obj %s -o %t.o
-; RUN: wasm-ld --check-signatures -r -o %t.wasm %t.many.o %t.o
+; RUN: wasm-ld -r -o %t.wasm %t.many.o %t.o
 ; RUN: obj2yaml %t.wasm | FileCheck %s
 
 ; Test that relocations within the CODE section correctly handle
 ; linking object with different header sizes.  many-funcs.ll has
 ; 128 function and so the final output requires a 2-byte LEB in
 ; the CODE section header to store the function count.
 
 target triple = "wasm32-unknown-unknown-wasm"

test/wasm/reloc-addend.ll

 ; RUN: llc -filetype=obj %s -o %t.o
-; RUN: wasm-ld --check-signatures -r -o %t.wasm %t.o
+; RUN: wasm-ld -r -o %t.wasm %t.o
 ; RUN: obj2yaml %t.wasm | FileCheck %s
 
 target triple = "wasm32-unknown-unknown-wasm"
 
 @foo = hidden global [76 x i32] zeroinitializer, align 16
 
 ; bar points to the 16th element, which happens to be 64 bytes
 ; This generates an addend of 64 which, is the value at which

test/wasm/relocatable.ll

 ; RUN: llc -filetype=obj %p/Inputs/hello.ll -o %t.hello.o
 ; RUN: llc -filetype=obj %s -o %t.o
-; RUN: wasm-ld --check-signatures -r -o %t.wasm %t.hello.o %t.o
+; RUN: wasm-ld -r -o %t.wasm %t.hello.o %t.o
 ; RUN: obj2yaml %t.wasm | FileCheck %s
 
 target triple = "wasm32-unknown-unknown-wasm"
 
 ; Function Attrs: nounwind
 define hidden i32 @my_func() local_unnamed_addr {
 entry:
   %call = tail call i32 @foo_import()

test/wasm/signature-mismatch-weak.ll

 ; RUN: llc -filetype=obj %p/Inputs/weak-symbol1.ll -o %t.weak.o
 ; RUN: llc -filetype=obj %p/Inputs/strong-symbol.ll -o %t.strong.o
 ; RUN: llc -filetype=obj %s -o %t.o
-; RUN: not wasm-ld --check-signatures -o %t.wasm %t.o %t.strong.o %t.weak.o 2>&1 | FileCheck %s
-; RUN: wasm-ld -o %t.wasm %t.o %t.strong.o %t.weak.o
+; RUN: wasm-ld -o %t.wasm %t.o %t.strong.o %t.weak.o 2>&1 | FileCheck %s
 
 target triple = "wasm32-unknown-unknown-wasm"
 
 declare i32 @weakFn() local_unnamed_addr
 
 define void @_start() local_unnamed_addr {
 entry:
   %call = call i32 @weakFn()
   ret void
 }
 
-; CHECK: error: Function type mismatch: weakFn
+; CHECK: warning: Function type mismatch: weakFn
 ; CHECK-NEXT: >>> defined as () -> I32 in {{.*}}signature-mismatch-weak.ll.tmp.o
 ; CHECK-NEXT: >>> defined as () -> I64 in {{.*}}signature-mismatch-weak.ll.tmp.strong.o

test/wasm/signature-mismatch.ll

 ; RUN: llc -filetype=obj %p/Inputs/ret32.ll -o %t.ret32.o
 ; RUN: llc -filetype=obj %s -o %t.main.o
-; RUN: not wasm-ld --check-signatures -o %t.wasm %t.main.o %t.ret32.o 2>&1 | FileCheck %s
+; RUN: not wasm-ld --fatal-warnings -o %t.wasm %t.main.o %t.ret32.o 2>&1 | FileCheck %s
 ; Run the test again by with the object files in the other order to verify
 ; the check works when the undefined symbol is resolved by an existing defined
 ; one.
-; RUN: not wasm-ld --check-signatures -o %t.wasm %t.ret32.o %t.main.o 2>&1 | FileCheck %s -check-prefix=REVERSE
+; RUN: not wasm-ld --fatal-warnings -o %t.wasm %t.ret32.o %t.main.o 2>&1 | FileCheck %s -check-prefix=REVERSE
 
 target triple = "wasm32-unknown-unknown-wasm"
 
 ; Function Attrs: nounwind
 define hidden void @_start() local_unnamed_addr #0 {
 entry:
   %call = tail call i32 @ret32(i32 1, i64 2, i32 3) #2
   ret void

test/wasm/stack-first.test

 ; Test that the --stack-first option places the stack at the start of linear
 ; memory.  In this case the --stack-first option is being passed along with a
 ; stack size of 512.  This means (since the stack grows down) the stack pointer
 ; global should be initialized to 512.
 
 RUN: llc -filetype=obj %p/Inputs/start.ll -o %t.o
 
-RUN: wasm-ld --check-signatures -z stack-size=512 --stack-first --allow-undefined -o %t.wasm %t.o
+RUN: wasm-ld -z stack-size=512 --stack-first --allow-undefined -o %t.wasm %t.o
 RUN: obj2yaml %t.wasm | FileCheck %s
 
 CHECK:        - Type:            GLOBAL
 CHECK-NEXT:     Globals:         
 CHECK-NEXT:       - Index:           0
 CHECK-NEXT:         Type:            I32
 CHECK-NEXT:         Mutable:         true
 CHECK-NEXT:         InitExpr:        

test/wasm/stack-pointer.ll

 ; RUN: llc -filetype=obj %s -o %t.o
-; RUN: wasm-ld --check-signatures --relocatable -o %t.wasm %t.o
+; RUN: wasm-ld --relocatable -o %t.wasm %t.o
 ; RUN: obj2yaml %t.wasm | FileCheck %s
 
 target triple = "wasm32-unknown-unknown-wasm"
 
 ; Function Attrs: nounwind
 define i32 @_start() local_unnamed_addr {
 entry:
   %retval = alloca i32, align 4

test/wasm/strip-debug.test

 RUN: llc -filetype=obj %p/Inputs/start.ll -o %t.start.o
-RUN: wasm-ld --check-signatures --strip-debug -o %t.wasm %t.start.o
+RUN: wasm-ld --strip-debug -o %t.wasm %t.start.o
 RUN: obj2yaml %t.wasm | FileCheck %s
 
 # Check that there is no name section
 CHECK-NOT:   Name:    name

test/wasm/symbol-type-mismatch.ll

 ; RUN: llc -filetype=obj %s -o %t.o
 ; RUN: llc -filetype=obj %p/Inputs/ret32.ll -o %t.ret32.o
-; RUN: not wasm-ld --check-signatures -o %t.wasm %t.o %t.ret32.o 2>&1 | FileCheck %s
+; RUN: not wasm-ld -o %t.wasm %t.o %t.ret32.o 2>&1 | FileCheck %s
 
 target triple = "wasm32-unknown-unknown-wasm"
 
 @ret32 = extern_weak global i32, align 4
 
 ; CHECK: error: symbol type mismatch: ret32
 ; CHECK: >>> defined as Data in {{.*}}symbol-type-mismatch.ll.tmp.o
 ; CHECK: >>> defined as Function in {{.*}}.ret32.o

test/wasm/undefined-entry.test

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

test/wasm/undefined-weak-call.ll

 ; RUN: llc -filetype=obj %s -o %t.o
-; RUN: wasm-ld --check-signatures --no-entry --print-gc-sections %t.o \
+; RUN: wasm-ld --no-entry --print-gc-sections %t.o \
 ; RUN:     -o %t.wasm 2>&1 | FileCheck -check-prefix=CHECK-GC %s
 ; RUN: obj2yaml %t.wasm | FileCheck %s
 
 ; Check that calling an undefined weak function generates an appropriate stub
 ; that will fail at runtime with "unreachable".
 
 target triple = "wasm32-unknown-unknown-wasm"
 

test/wasm/undefined.ll

 ; RUN: llc -filetype=obj %s -o %t.o
-; RUN: wasm-ld --check-signatures --allow-undefined -o %t.wasm %t.o
+; RUN: wasm-ld --allow-undefined -o %t.wasm %t.o
 
 ; Fails due to undefined 'foo' and also 'baz'
-; RUN: not wasm-ld --check-signatures --undefined=baz -o %t.wasm %t.o 2>&1 | FileCheck %s
+; RUN: not wasm-ld --undefined=baz -o %t.wasm %t.o 2>&1 | FileCheck %s
 ; CHECK: error: {{.*}}.o: undefined symbol: foo
 ; CHECK: error: undefined symbol: baz
 
 ; Succeeds if we pass a file containing 'foo' as --allow-undefined-file.
 ; RUN: echo 'foo' > %t.txt
-; RUN: wasm-ld --check-signatures --allow-undefined-file=%t.txt -o %t.wasm %t.o
+; RUN: wasm-ld --allow-undefined-file=%t.txt -o %t.wasm %t.o
 
 ; Succeeds even if a missing symbol is added via --export
-; RUN: wasm-ld --check-signatures --allow-undefined --export=xxx -o %t.wasm %t.o
+; RUN: wasm-ld --allow-undefined --export=xxx -o %t.wasm %t.o
 
 target triple = "wasm32-unknown-unknown-wasm"
 
 ; Takes the address of the external foo() resulting in undefined external
 @bar = hidden local_unnamed_addr global i8* bitcast (i32 ()* @foo to i8*), align 4
 
 declare i32 @foo() #0
 
 define hidden void @_start() local_unnamed_addr #0 {
 entry:
     ret void
 }

test/wasm/version.ll

 ; RUN: llc -filetype=obj %s -o %t.o
-; RUN: wasm-ld --check-signatures -o %t.wasm %t.o
+; RUN: wasm-ld -o %t.wasm %t.o
 ; RUN: llvm-readobj -file-headers %t.wasm | FileCheck %s
 
 target triple = "wasm32-unknown-unknown-wasm"
 
 define hidden void @_start() local_unnamed_addr #0 {
 entry:
     ret void
 }
 
 ; CHECK: Format: WASM
 ; CHECK: Arch: wasm32
 ; CHECK: AddressSize: 32bit
 ; CHECK: Version: 0x1

test/wasm/visibility-hidden.ll

 ; RUN: llc -filetype=obj -o %t.o %s
 ; RUN: llc -filetype=obj %S/Inputs/hidden.ll -o %t2.o
 ; RUN: llvm-ar rcs %t2.a %t2.o
-; RUN: wasm-ld --check-signatures %t.o %t2.a -o %t.wasm
+; RUN: wasm-ld %t.o %t2.a -o %t.wasm
 ; RUN: obj2yaml %t.wasm | FileCheck %s
 
 ; Test that hidden symbols are not exported, whether pulled in from an archive
 ; or directly.
 
 target triple = "wasm32-unknown-unknown-wasm"
 
 define hidden i32 @objectHidden() {

test/wasm/weak-alias-overide.ll

 ; RUN: llc -filetype=obj -o %t.o %s
 ; RUN: llc -filetype=obj %S/Inputs/weak-alias.ll -o %t2.o
-; RUN: wasm-ld --check-signatures %t.o %t2.o -o %t.wasm
+; RUN: wasm-ld %t.o %t2.o -o %t.wasm
 ; RUN: obj2yaml %t.wasm | FileCheck %s
 
 ; Test that the strongly defined alias_fn from this file is used both here
 ; and in call_alias.
 
 target triple = "wasm32-unknown-unknown-wasm"
 
 define i32 @alias_fn() local_unnamed_addr #1 {

test/wasm/weak-alias.ll

 ; RUN: llc -filetype=obj -o %t.o %s
 ; RUN: llc -filetype=obj %S/Inputs/weak-alias.ll -o %t2.o
-; RUN: wasm-ld --check-signatures %t.o %t2.o -o %t.wasm
+; RUN: wasm-ld %t.o %t2.o -o %t.wasm
 ; RUN: obj2yaml %t.wasm | FileCheck %s
 
 ; Test that weak aliases (alias_fn is a weak alias of direct_fn) are linked correctly
 
 target triple = "wasm32-unknown-unknown-wasm"
 
 declare i32 @alias_fn() local_unnamed_addr #1
 

 ; CHECK-NEXT:       - Index:           4
 ; CHECK-NEXT:         Name:            call_alias
 ; CHECK-NEXT:       - Index:           5
 ; CHECK-NEXT:         Name:            call_alias_ptr
 ; CHECK-NEXT:       - Index:           6
 ; CHECK-NEXT:         Name:            call_direct_ptr
 ; CHECK-NEXT: ...
 
-; RUN: wasm-ld --check-signatures --relocatable %t.o %t2.o -o %t.reloc.o
+; RUN: wasm-ld --relocatable %t.o %t2.o -o %t.reloc.o
 ; RUN: obj2yaml %t.reloc.o | FileCheck %s -check-prefix=RELOC
 
 ; RELOC:      --- !WASM
 ; RELOC-NEXT: FileHeader:
 ; RELOC-NEXT:   Version:         0x00000001
 ; RELOC-NEXT: Sections:
 ; RELOC-NEXT:   - Type:            TYPE
 ; RELOC-NEXT:     Signatures:

test/wasm/weak-symbols.ll

 ; RUN: llc -filetype=obj %p/Inputs/weak-symbol1.ll -o %t1.o
 ; RUN: llc -filetype=obj %p/Inputs/weak-symbol2.ll -o %t2.o
 ; RUN: llc -filetype=obj %s -o %t.o
-; RUN: wasm-ld -no-gc-sections --check-signatures -o %t.wasm %t.o %t1.o %t2.o
+; RUN: wasm-ld -no-gc-sections -o %t.wasm %t.o %t1.o %t2.o
 ; RUN: obj2yaml %t.wasm | FileCheck %s
 
 target triple = "wasm32-unknown-unknown-wasm"
 
 declare i32 @weakFn() local_unnamed_addr
 @weakGlobal = external global i32
 
 define void @_start() local_unnamed_addr {

test/wasm/weak-undefined.ll

 ; RUN: llc -filetype=obj -o %t.o %s
-; RUN: wasm-ld --check-signatures -strip-debug %t.o -o %t.wasm
+; RUN: wasm-ld -strip-debug %t.o -o %t.wasm
 ; RUN: obj2yaml %t.wasm | FileCheck %s
 
 ; Test that undefined weak externals (global_var) and (foo) don't cause
 ; link failures and resolve to zero.
 
 target triple = "wasm32-unknown-unknown-wasm"
 
 @global_var = extern_weak global i32, align 4

wasm/Config.h

 #include "llvm/ADT/StringSet.h"
 #include "llvm/BinaryFormat/Wasm.h"
 
 namespace lld {
 namespace wasm {
 
 struct Configuration {
   bool AllowUndefined;
-  bool CheckSignatures;
   bool Demangle;
   bool ExportTable;
   bool GcSections;
   bool ImportMemory;
   bool ImportTable;
   bool PrintGcSections;
   bool Relocatable;
   bool StripAll;

wasm/Driver.cpp

void LinkerDriver::link(ArrayRef<const char *> ArgsArr) {
   V.push_back("wasm-ld (LLVM option parsing)");
   for (auto *Arg : Args.filtered(OPT_mllvm))
     V.push_back(Arg->getValue());
   cl::ParseCommandLineOptions(V.size(), V.data());
 
   errorHandler().ErrorLimit = args::getInteger(Args, OPT_error_limit, 20);
 
   Config->AllowUndefined = Args.hasArg(OPT_allow_undefined);
-  Config->CheckSignatures =
-      Args.hasFlag(OPT_check_signatures, OPT_no_check_signatures, false);
   Config->Demangle = Args.hasFlag(OPT_demangle, OPT_no_demangle, true);
   Config->Entry = getEntry(Args, Args.hasArg(OPT_relocatable) ? "" : "_start");
   Config->ExportTable = Args.hasArg(OPT_export_table);
+  errorHandler().FatalWarnings =
+      Args.hasFlag(OPT_fatal_warnings, OPT_no_fatal_warnings, false);
   Config->ImportMemory = Args.hasArg(OPT_import_memory);
   Config->ImportTable = Args.hasArg(OPT_import_table);
   Config->OutputFile = Args.getLastArgValue(OPT_o);
   Config->Relocatable = Args.hasArg(OPT_relocatable);
   Config->GcSections =
       Args.hasFlag(OPT_gc_sections, OPT_no_gc_sections, !Config->Relocatable);
   Config->PrintGcSections =
       Args.hasFlag(OPT_print_gc_sections, OPT_no_print_gc_sections, false);

wasm/Options.td

def allow_undefined: F<"allow-undefined">,
   HelpText<"Allow undefined symbols in linked binary">;
 
 def allow_undefined_file: J<"allow-undefined-file=">,
   HelpText<"Allow symbols listed in <file> to be undefined in linked binary">;
 
 def allow_undefined_file_s: Separate<["-"], "allow-undefined-file">,
   Alias<allow_undefined_file>;
 
-defm check_signatures: B<"check-signatures",
-    "Check function signatures",
-    "Don't check function signatures">;
-
 defm export: Eq<"export">,
   HelpText<"Force a symbol to be exported">;
 
 def export_table: F<"export-table">,
   HelpText<"Export function table to the environment">;
 
 def global_base: J<"global-base=">,
   HelpText<"Where to start to place global data">;

wasm/SymbolTable.cpp

 
 static void checkFunctionType(const Symbol *Existing, const InputFile *File,
                               const WasmSignature *NewSig) {
   if (!isa<FunctionSymbol>(Existing)) {
     reportTypeError(Existing, File, "Function");
     return;
   }
 
-  if (!Config->CheckSignatures)
-    return;
-
   const WasmSignature *OldSig =
       cast<FunctionSymbol>(Existing)->getFunctionType();
   if (OldSig && *NewSig != *OldSig) {
-    error("Function type mismatch: " + Existing->getName() +
-          "\n>>> defined as " + toString(*OldSig) + " in " +
-          toString(Existing->getFile()) + "\n>>> defined as " +
-          toString(*NewSig) + " in " + toString(File));
+    warn("Function type mismatch: " + Existing->getName() +
   }
 }
 
 // Check the type of new symbol matches that of the symbol is replacing.
 // For functions this can also involve verifying that the signatures match.
 static void checkGlobalType(const Symbol *Existing, const InputFile *File,
                             const WasmGlobalType *NewType) {
   if (!isa<GlobalSymbol>(Existing)) {