[WebAssembly] Fix signature mismatches in test code. NFC.

[sbc100]

Summary

Pass --check-signatures to test executions of lld and
fix resulting errors.

[sbc100]

rebase

[sbc100]

• rebase

[ruiu]

I don't have enough knowledge to review this, but do you need a pre-commit code review for this?

[sbc100]

In D42661#992800, @ruiu wrote:

I don't have enough knowledge to review this, but do you need a pre-commit code review for this?

Perhaps no review needed. I tend to prefer pre-commit reviews for pretty much all changes, although I understand llvm is less strict about this than other projects.

I've been adding you you as a reviewer to pretty much all my changes, even these smaller ones, mostly just to keep you in the loop. If you'd like to use other people for the more trivial changes I certainly can. And also feel free to remove yourself from the reviewer list any time.. I won't be offended.

[ncw]

Looks nice and harmless.

I guess I should be adding Rui as reviewer on my changes too? I've just been adding Sam currently as the "code owner" for Wasm LLD, on the basis that Sam can add someone else if he wants to do less reviewing, and the people who need to be notified should all be getting the Phabricator spam via Herald subscriptions.

[sbc100]

rebase

test/wasm/alias.ll

 ; RUN: llc -filetype=obj -o %t.o %s
-; RUN: lld -flavor wasm %t.o -o %t.wasm
+; RUN: lld -flavor wasm --check-signatures %t.o -o %t.wasm
 ; RUN: obj2yaml %t.wasm | FileCheck %s
 
 target triple = "wasm32-unknown-unknown-wasm"
 
-@start_alias = alias i32 (), i32 ()* @_start
+@start_alias = alias void (), void ()* @_start
 
 ; Function Attrs: nounwind uwtable
-define i32 @_start() local_unnamed_addr #1 {
+define void @_start() local_unnamed_addr #1 {
 entry:
-  ret i32 0
+  ret void
 }
 
 ; CHECK:      --- !WASM
 ; CHECK-NEXT: FileHeader:
 ; CHECK-NEXT:   Version:         0x00000001
 ; CHECK-NEXT: Sections:
 ; CHECK-NEXT:   - Type:            TYPE
 ; CHECK-NEXT:     Signatures:
 ; CHECK-NEXT:       - Index:           0
-; CHECK-NEXT:         ReturnType:      I32
-; CHECK-NEXT:         ParamTypes:
-; CHECK-NEXT:      - Index:           1
-; CHECK-NEXT:        ReturnType:      NORESULT
-; CHECK-NEXT:        ParamTypes:
+; CHECK-NEXT:         ReturnType:      NORESULT
+; CHECK-NEXT:         ParamTypes:
 ; CHECK-NEXT:   - Type:            FUNCTION
-; CHECK-NEXT:     FunctionTypes:   [ 0, 1 ]
+; CHECK-NEXT:     FunctionTypes:   [ 0, 0 ]
 ; CHECK-NEXT:   - Type:            TABLE
 ; CHECK-NEXT:     Tables:
 ; CHECK-NEXT:       - ElemType:        ANYFUNC
 ; CHECK-NEXT:         Limits:
 ; CHECK-NEXT:           Flags:           [ HAS_MAX ]
 ; CHECK-NEXT:           Initial:         0x00000001
 ; CHECK-NEXT:           Maximum:         0x00000001
 ; CHECK-NEXT:   - Type:            MEMORY

 ; CHECK-NEXT:         Index:           0
 ; CHECK-NEXT:       - Name:            __heap_base
 ; CHECK-NEXT:         Kind:            GLOBAL
 ; CHECK-NEXT:         Index:           1
 ; CHECK-NEXT:   - Type:            CODE
 ; CHECK-NEXT:     Functions:
 ; CHECK-NEXT:       - Index:           0
 ; CHECK-NEXT:         Locals:
-; CHECK-NEXT:         Body:            41000B
+; CHECK-NEXT:         Body:            0B
 ; CHECK-NEXT:       - Index:           1
 ; CHECK-NEXT:         Locals:
 ; CHECK-NEXT:         Body:            0B
 ; CHECK-NEXT:   - Type:            CUSTOM
 ; CHECK-NEXT:     Name:            linking
 ; CHECK-NEXT:     DataSize:        0
 ; CHECK-NEXT:   - Type:            CUSTOM
 ; CHECK-NEXT:     Name:            name
 ; CHECK-NEXT:     FunctionNames:
 ; CHECK-NEXT:       - Index:           0
 ; CHECK-NEXT:         Name:            _start
 ; CHECK-NEXT:       - Index:           1
 ; CHECK-NEXT:         Name:            __wasm_call_ctors
 ; CHECK-NEXT: ...

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 lld -flavor wasm %t.a %t.o -o %t.wasm 2>&1 | FileCheck -check-prefix=CHECK-UNDEFINED %s
+; RUN: not lld -flavor wasm --check-signatures %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: lld -flavor wasm %t.a %t.o -o %t.wasm
+; RUN: lld -flavor wasm --check-signatures %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
 
-define i32 @_start() local_unnamed_addr #0 {
+define void @_start() local_unnamed_addr #0 {
 entry:
   %call1 = call i32 @foo() #2
   %call2 = call i32 @missing_func() #2
-  ret i32 %call2
+  ret void
 }
 
 ; Verify that multually dependant object files in an archive is handled
 ; correctly.
 
 ; CHECK:      00000003 T _start
 ; CHECK-NEXT: 00000001 T bar
 ; CHECK-NEXT: 00000002 T foo
 
 ; Verify that symbols from unused objects don't appear in the symbol table
 ; CHECK-NOT: hello
 
 ; Specifying the same archive twice is allowed.
-; RUN: lld -flavor wasm %t.a %t.a %t.o -o %t.wasm
+; RUN: lld -flavor wasm --check-signatures %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: lld -flavor wasm -no-gc-sections -o %t.wasm %t2.o %t.o
+; RUN: lld -flavor wasm -no-gc-sections --check-signatures -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"
 
 @indirect_func = local_unnamed_addr global i32 ()* @foo, align 4
 
 ; Function Attrs: norecurse nounwind readnone
 define i32 @foo() #0 {
 entry:
   ret i32 2
 }
 
 ; Function Attrs: nounwind
-define i32 @_start() local_unnamed_addr #1 {
+define void @_start() local_unnamed_addr #1 {
 entry:
   %0 = load i32 ()*, i32 ()** @indirect_func, align 4
   %call = call i32 %0() #2
-  ret i32 0
+  ret void
 }
 
 ; Indirect function call where no function actually has this type.
 ; Ensures that the type entry is still created in this case.
 define void @call_ptr(i64 (i64)* %arg) {
   %1 = call i64 %arg(i64 1)
   ret void
 }

 ; CHECK-NEXT:         ReturnType:      NORESULT
 ; CHECK-NEXT:         ParamTypes:
 ; CHECK-NEXT:           - I32
 ; CHECK-NEXT:       - Index:           4
 ; CHECK-NEXT:         ReturnType:      I64
 ; CHECK-NEXT:         ParamTypes:
 ; CHECK-NEXT:           - I64
 ; CHECK-NEXT:   - Type:            FUNCTION
-; CHECK-NEXT:     FunctionTypes:   [ 0, 1, 2, 2, 3, 1 ]
+; CHECK-NEXT:     FunctionTypes:   [ 0, 1, 2, 1, 3, 1 ]
 ; CHECK-NEXT:   - Type:            TABLE
 ; CHECK-NEXT:     Tables:
 ; CHECK-NEXT:       - ElemType:        ANYFUNC
 ; CHECK-NEXT:         Limits:
 ; CHECK-NEXT:           Flags:           [ HAS_MAX ]
 ; CHECK-NEXT:           Initial:         0x00000003
 ; CHECK-NEXT:           Maximum:         0x00000003
 ; CHECK-NEXT:   - Type:            MEMORY

 ; CHECK-NEXT:            - Type:            I32
 ; CHECK-NEXT:              Count:           1
 ; CHECK-NEXT:          Body:            4100280284888080002100410028028088808000118080808000001A2000118280808000001A0B
 ; CHECK-NEXT:       - Index:           2
 ; CHECK-NEXT:         Locals:
 ; CHECK-NEXT:         Body:            41020B
 ; CHECK-NEXT:       - Index:           3
 ; CHECK-NEXT:         Locals:
-; CHECK-NEXT:         Body:            410028028888808000118280808000001A41000B
+; CHECK-NEXT:         Body:            410028028888808000118280808000001A0B
 ; CHECK-NEXT:       - Index:           4
 ; CHECK-NEXT:         Locals:
 ; CHECK-NEXT:         Body:            42012000118480808000001A0B
 ; CHECK-NEXT:       - Index:           5
 ; CHECK-NEXT:         Locals:
 ; CHECK-NEXT:         Body:            0B
 ; CHECK-NEXT:   - Type:            DATA
 ; CHECK-NEXT:     Segments:

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: lld -flavor wasm -no-gc-sections -o %t.wasm %t.o %t1.o %t2.o
+; RUN: lld -flavor wasm -no-gc-sections --check-signatures -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 lld -flavor wasm -o %t.wasm %t.ret32.o %t.ret32.o 2>&1 | FileCheck %s
+# RUN: not lld -flavor wasm --check-signatures -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/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
 
-; RUN: lld -flavor wasm -no-gc-sections --allow-undefined -o %t.wasm %t.o %t.hello.o
+; RUN: lld -flavor wasm -no-gc-sections --check-signatures --allow-undefined -o %t.wasm %t.o %t.hello.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:

 ; CHECK-NEXT:       - SectionOffset:   41
 ; CHECK-NEXT:         MemoryIndex:     0
 ; CHECK-NEXT:         Offset:
 ; CHECK-NEXT:           Opcode:          I32_CONST
 ; CHECK-NEXT:           Value:           1052
 ; CHECK-NEXT:         Content:         68656C6C6F0A00
 
 
-; RUN: lld -flavor wasm --relocatable -o %t_reloc.wasm %t.o %t.hello.o
+; RUN: lld -flavor wasm --check-signatures --relocatable -o %t_reloc.wasm %t.o %t.hello.o
 ; RUN: obj2yaml %t_reloc.wasm | FileCheck %s -check-prefix=RELOC
 
 ; RELOC:        - Type:            GLOBAL
 ; RELOC-NEXT:     Globals:
 ; RELOC-NEXT:       - Index:           0
 ; RELOC-NEXT:         Type:            I32
 ; RELOC-NEXT:         Mutable:         false
 ; RELOC-NEXT:         InitExpr:

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: lld -flavor wasm -e entry -o %t1.wasm %t.o
+; RUN: lld -flavor wasm --check-signatures -e entry -o %t1.wasm %t.o
 ; RUN: obj2yaml %t1.wasm | FileCheck %s
-; RUN: lld -flavor wasm --entry=entry -o %t2.wasm %t.o
+; RUN: lld -flavor wasm --check-signatures --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:            entry
 ; CHECK-NEXT:         Kind:            FUNCTION
 ; CHECK-NEXT:         Index:           0
 
 ; The __wasm_call_ctors is somewhat special.  Make sure we can use it
 ; as the entry point if we choose
-; RUN: lld -flavor wasm --entry=__wasm_call_ctors -o %t3.wasm %t.o
+; RUN: lld -flavor wasm --check-signatures --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
 ; CHECK-CTOR-NEXT:         Kind:            FUNCTION
 ; CHECK-CTOR-NEXT:         Index:           0

test/wasm/export.ll

 ; RUN: llc -filetype=obj %s -o %t.o
-; RUN: not lld -flavor wasm --export=missing -o %t.wasm %t.o 2>&1 | FileCheck -check-prefix=CHECK-ERROR %s
-; RUN: lld -flavor wasm --export=hidden_function -o %t.wasm %t.o
+; RUN: not lld -flavor wasm --check-signatures --export=missing -o %t.wasm %t.o 2>&1 | FileCheck -check-prefix=CHECK-ERROR %s
+; RUN: lld -flavor wasm --check-signatures --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
 }
 
-define i32 @_start() local_unnamed_addr {
+define void @_start() local_unnamed_addr {
 entry:
-  ret i32 0
+  ret void
 }
 
 ; CHECK-ERROR: error: symbol exported via --export not found: missing
 
 ; CHECK:        - Type:            EXPORT
 ; CHECK-NEXT:     Exports:
 ; CHECK-NEXT:       - Name:            memory
 ; CHECK-NEXT:         Kind:            MEMORY

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: lld -flavor wasm -o %t.wasm %t.o %t.ret32.o
+; RUN: lld -flavor wasm --check-signatures -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: lld -flavor wasm -o %t.wasm %t.ret32.o %t.o
+; RUN: lld -flavor wasm --check-signatures -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: lld -flavor wasm -r -o %t.wasm %t.ret32.o %t.ret64.o
+# RUN: lld -flavor wasm --check-signatures -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: lld -flavor wasm --import-memory -o %t.wasm %t.start.o
+# RUN: lld -flavor wasm --check-signatures --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

test/wasm/init-fini.ll

 ]
 
 @llvm.global_dtors = appending global [3 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 }
 ]
 
-; RUN: lld -flavor wasm %t.o %t.global-ctor-dtor.o -o %t.wasm
+; RUN: lld -flavor wasm --check-signatures %t.o %t.global-ctor-dtor.o -o %t.wasm
 ; RUN: obj2yaml %t.wasm | FileCheck %s
 
 ; CHECK:        - Type:            ELEM
 ; CHECK-NEXT:     Segments:
 ; CHECK-NEXT:       - Offset:
 ; CHECK-NEXT:           Opcode:          I32_CONST
 ; CHECK-NEXT:           Value:           1
 ; CHECK-NEXT:         Functions:       [ 6, 9, 13, 15, 17 ]

 ; CHECK-NEXT:         Name:            .Lcall_dtors.2002
 ; CHECK-NEXT:       - Index:           18
 ; CHECK-NEXT:         Name:            .Lregister_call_dtors.2002
 ; CHECK-NEXT:       - Index:           19
 ; CHECK-NEXT:         Name:            __wasm_call_ctors
 ; CHECK-NEXT: ...
 
 
-; RUN: lld -flavor wasm -r %t.o %t.global-ctor-dtor.o -o %t.reloc.wasm
+; RUN: lld -flavor wasm --check-signatures -r %t.o %t.global-ctor-dtor.o -o %t.reloc.wasm
 ; RUN: obj2yaml %t.reloc.wasm | FileCheck -check-prefix=RELOC %s
 
 ; RELOC:          Name:            linking
 ; RELOC-NEXT:     DataSize:        0
 ; RELOC-NEXT:     SymbolInfo:
 ; RELOC-NEXT:       - Name:            __dso_handle
 ; RELOC-NEXT:         Flags:           [ BINDING_WEAK, VISIBILITY_HIDDEN ]
 ; RELOC-NEXT:       - Name:            func1

test/wasm/invalid-stack-size.test

 ; RUN: llc -filetype=obj %p/Inputs/start.ll -o %t.o
-; RUN: not lld -flavor wasm -o %t.wasm -z stack-size=1 %t.o 2>&1 | FileCheck %s
+; RUN: not lld -flavor wasm --check-signatures -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: lld -flavor wasm %t.start.o %t2.a %t.o -o %t.wasm -u ret32 --undefined ret64
+; RUN: lld -flavor wasm --check-signatures %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:            _start
 ; CHECK-NEXT:         Kind:            FUNCTION
 ; CHECK-NEXT:         Index:           0
 ; CHECK-NEXT:       - Name:            ret32
 ; CHECK-NEXT:         Kind:            FUNCTION
 ; CHECK-NEXT:         Index:           1
 ; CHECK-NEXT:       - Name:            ret64
 ; CHECK-NEXT:         Kind:            FUNCTION
 ; CHECK-NEXT:         Index:           2
 ; CHECK-NEXT:       - Name:            __heap_base
 ; CHECK-NEXT:         Kind:            GLOBAL
 ; CHECK-NEXT:         Index:           1
 ; CHECK-NEXT:   - Type:
 
 
 ; Verify that referencing a symbol that doesn't exist won't work
-; RUN: not lld -flavor wasm %t.start.o -o %t.wasm -u symboldoesnotexist 2>&1 | FileCheck -check-prefix=CHECK-UNDEFINED1 %s
+; RUN: not lld -flavor wasm --check-signatures %t.start.o -o %t.wasm -u symboldoesnotexist 2>&1 | FileCheck -check-prefix=CHECK-UNDEFINED1 %s
 ; CHECK-UNDEFINED1: error: undefined symbol: symboldoesnotexist
 
-; RUN: not lld -flavor wasm %t.start.o -o %t.wasm --undefined symboldoesnotexist --allow-undefined 2>&1 | FileCheck -check-prefix=CHECK-UNDEFINED2 %s
+; RUN: not lld -flavor wasm --check-signatures %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: lld -flavor wasm -o %t.wasm %t.o
+; RUN: lld -flavor wasm --check-signatures -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 {
 entry:
   %0 = load i32, i32* @bar, align 4
   ret i32 %0
 }
 
-define i32 @_start() local_unnamed_addr {
+define void @_start() local_unnamed_addr {
 entry:
   call i32 @baz()
-  ret i32 1
+  ret void
 }
 
 ; CHECK:      --- !WASM
 ; CHECK-NEXT: FileHeader:
 ; CHECK-NEXT:   Version:         0x00000001
 ; CHECK-NEXT: Sections:
 ; CHECK-NEXT:   - Type:            TYPE
 ; CHECK-NEXT:     Signatures:
 ; CHECK-NEXT:       - Index:           0
 ; CHECK-NEXT:         ReturnType:      I32
 ; CHECK-NEXT:         ParamTypes:
 ; CHECK-NEXT:       - Index:           1
 ; CHECK-NEXT:         ReturnType:      NORESULT
 ; CHECK-NEXT:         ParamTypes:
 ; CHECK-NEXT:   - Type:            FUNCTION
-; CHECK-NEXT:     FunctionTypes:   [ 0, 0, 1 ]
+; CHECK-NEXT:     FunctionTypes:   [ 0, 1, 1 ]
 ; CHECK-NEXT:   - Type:            TABLE
 ; CHECK-NEXT:     Tables:
 ; CHECK-NEXT:       - ElemType:        ANYFUNC
 ; CHECK-NEXT:         Limits:
 ; CHECK-NEXT:           Flags:           [ HAS_MAX ]
 ; CHECK-NEXT:           Initial:         0x00000001
 ; CHECK-NEXT:           Maximum:         0x00000001
 ; CHECK-NEXT:   - Type:            MEMORY

 ; CHECK-NEXT:         Index:           1
 ; CHECK-NEXT:   - Type:            CODE
 ; CHECK-NEXT:     Functions:
 ; CHECK-NEXT:       - Index:           0
 ; CHECK-NEXT:         Locals:
 ; CHECK-NEXT:         Body:            4100280284888080000B
 ; CHECK-NEXT:       - Index:           1
 ; CHECK-NEXT:         Locals:
-; CHECK-NEXT:         Body:            1080808080001A41010B
+; CHECK-NEXT:         Body:            1080808080001A0B
 ; CHECK-NEXT:       - Index:           2
 ; CHECK-NEXT:         Locals:
 ; CHECK-NEXT:         Body:            0B
 ; CHECK-NEXT:   - Type:            DATA
 ; CHECK-NEXT:     Segments:
 ; CHECK-NEXT:       - SectionOffset:   7
 ; CHECK-NEXT:         MemoryIndex:     0
 ; CHECK-NEXT:         Offset:

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: lld -flavor wasm --no-entry -o %t.wasm %t1.o %t2.o
+; RUN: lld -flavor wasm --check-signatures --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_func2B
 ; CHECK-NEXT:       - Index:           17
 ; CHECK-NEXT:         Name:            get_func3B
 ; CHECK-NEXT:       - Index:           18
 ; CHECK-NEXT:         Name:            __wasm_call_ctors
 ; CHECK-NEXT: ...
 
 
-; RUN: lld -flavor wasm -r --no-entry -o %t.reloc.wasm %t1.o %t2.o
+; RUN: lld -flavor wasm --check-signatures -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: lld -flavor wasm -r -o %t.wasm %t.many.o %t.o
+; RUN: lld -flavor wasm --check-signatures -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/relocatable.ll

 ; RUN: llc -filetype=obj %p/Inputs/hello.ll -o %t.hello.o
 ; RUN: llc -filetype=obj %s -o %t.o
-; RUN: lld -flavor wasm -r -o %t.wasm %t.hello.o %t.o
+; RUN: lld -flavor wasm --check-signatures -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.ll

 ; RUN: llc -filetype=obj %p/Inputs/ret32.ll -o %t.ret32.o
 ; RUN: llc -filetype=obj %s -o %t.main.o
-; RUN: not lld -flavor wasm --check-signatures -o %t.wasm %t.main.o %t.ret32.o 2>&1 | FileCheck %s
+; RUN: not lld -flavor wasm --check-signatures --check-signatures -o %t.wasm %t.main.o %t.ret32.o 2>&1 | 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(i32 1, i64 2, i32 3) #2
   ret void
 }
 
 declare i32 @ret32(i32, i64, i32) local_unnamed_addr #1
 
 ; CHECK: error: function signature mismatch: ret32
 ; CHECK-NEXT: >>> defined as (I32, I64, I32) -> I32 in {{.*}}.main.o
 ; CHECK-NEXT: >>> defined as (F32) -> I32 in {{.*}}.ret32.o

test/wasm/stack-pointer.ll

 ; RUN: llc -filetype=obj %s -o %t.o
-; RUN: lld -flavor wasm --relocatable -o %t.wasm %t.o
+; RUN: lld -flavor wasm --check-signatures --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: lld -flavor wasm --strip-debug -o %t.wasm %t.start.o
+RUN: lld -flavor wasm --check-signatures --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 lld -flavor wasm -o %t.wasm %t.o %t.ret32.o 2>&1 | FileCheck %s
+; RUN: not lld -flavor wasm --check-signatures -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 Global 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 lld -flavor wasm -o %t.wasm %t.ret32.o 2>&1 | FileCheck %s
+RUN: not lld -flavor wasm --check-signatures -o %t.wasm %t.ret32.o 2>&1 | FileCheck %s
 
 CHECK: error: undefined symbol: _start
 
-RUN: not lld -flavor wasm -entry=foo -o %t.wasm %t.ret32.o 2>&1 | FileCheck %s -check-prefix=CHECK-CUSTOM
+RUN: not lld -flavor wasm --check-signatures -entry=foo -o %t.wasm %t.ret32.o 2>&1 | FileCheck %s -check-prefix=CHECK-CUSTOM
 
 CHECK-CUSTOM: error: undefined symbol: foo
 
-RUN: lld -flavor wasm -entry=foo --allow-undefined -o %t.wasm %t.ret32.o
+RUN: lld -flavor wasm --check-signatures -entry=foo --allow-undefined -o %t.wasm %t.ret32.o

test/wasm/undefined.ll

 ; RUN: llc -filetype=obj %s -o %t.o
-; RUN: lld -flavor wasm --allow-undefined -o %t.wasm %t.o
+; RUN: lld -flavor wasm --check-signatures --allow-undefined -o %t.wasm %t.o
 
 ; Fails due to undefined 'foo'
-; RUN: not lld -flavor wasm -o %t.wasm %t.o 2>&1 | FileCheck %s
+; RUN: not lld -flavor wasm --check-signatures -o %t.wasm %t.o 2>&1 | FileCheck %s
 ; CHECK: error: {{.*}}.o: undefined symbol: foo
 
 ; But succeeds if we pass a file containing 'foo' as --allow-undefined-file.
 ; RUN: echo 'foo' > %t.txt
-; RUN: lld -flavor wasm --allow-undefined-file=%t.txt -o %t.wasm %t.o
+; RUN: lld -flavor wasm --check-signatures --allow-undefined-file=%t.txt -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: lld -flavor wasm -o %t.wasm %t.o
+; RUN: lld -flavor wasm --check-signatures -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: lld -flavor wasm %t.o %t2.a -o %t.wasm
+; RUN: lld -flavor wasm --check-signatures %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() {
 entry:
     ret i32 0
 }
 
 define i32 @objectDefault() {
 entry:
     ret i32 0
 }
 
 declare i32 @archiveHidden()
 declare i32 @archiveDefault()
 
-define i32 @_start() {
+define void @_start() {
 entry:
   %call1 = call i32 @objectHidden()
   %call2 = call i32 @objectDefault()
   %call3 = call i32 @archiveHidden()
   %call4 = call i32 @archiveDefault()
-  ret i32 0
+  ret void
 }
 
 ; CHECK:        - Type:            EXPORT
 ; CHECK-NEXT:     Exports:
 ; CHECK-NEXT:       - Name:            memory
 ; CHECK-NEXT:         Kind:            MEMORY
 ; CHECK-NEXT:         Index:           0
 ; CHECK-NEXT:       - Name:            objectDefault

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: lld -flavor wasm %t.o %t2.o -o %t.wasm
+; RUN: lld -flavor wasm --check-signatures %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: lld -flavor wasm %t.o %t2.o -o %t.wasm
+; RUN: lld -flavor wasm --check-signatures %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
 
 ; Function Attrs: nounwind uwtable
-define i32 @_start() local_unnamed_addr #1 {
+define void @_start() local_unnamed_addr #1 {
 entry:
   %call = tail call i32 @alias_fn() #2
-  ret i32 %call
+  ret void
 }
 
 ; CHECK:      --- !WASM
 ; CHECK-NEXT: FileHeader:
 ; CHECK-NEXT:   Version:         0x00000001
 ; CHECK-NEXT: Sections:
 ; CHECK-NEXT:   - Type:            TYPE
 ; CHECK-NEXT:     Signatures:
 ; CHECK-NEXT:       - Index:           0
-; CHECK-NEXT:         ReturnType:      I32
+; CHECK-NEXT:         ReturnType:      NORESULT
 ; CHECK-NEXT:         ParamTypes:
 ; CHECK-NEXT:       - Index:           1
-; CHECK-NEXT:         ReturnType:      NORESULT
+; CHECK-NEXT:         ReturnType:      I32
 ; CHECK-NEXT:         ParamTypes:
 ; CHECK-NEXT:   - Type:            FUNCTION
-; CHECK-NEXT:     FunctionTypes:   [ 0, 0, 0, 0, 0, 0, 1 ]
+; CHECK-NEXT:     FunctionTypes:   [ 0, 1, 1, 1, 1, 1, 0 ]
 ; CHECK-NEXT:   - Type:            TABLE
 ; CHECK-NEXT:     Tables:
 ; CHECK-NEXT:       - ElemType:        ANYFUNC
 ; CHECK-NEXT:         Limits:
 ; CHECK-NEXT:           Flags:           [ HAS_MAX ]
 ; CHECK-NEXT:           Initial:         0x00000002
 ; CHECK-NEXT:           Maximum:         0x00000002
 ; CHECK-NEXT:   - Type:            MEMORY

 ; CHECK-NEXT:       - Offset:
 ; CHECK-NEXT:           Opcode:          I32_CONST
 ; CHECK-NEXT:           Value:           1
 ; CHECK-NEXT:         Functions:       [ 1 ]
 ; CHECK-NEXT:   - Type:            CODE
 ; CHECK-NEXT:     Functions:
 ; CHECK-NEXT:       - Index:           0
 ; CHECK-NEXT:         Locals:
-; CHECK-NEXT:         Body:            1081808080000B
+; CHECK-NEXT:         Body:            1081808080001A0B
 ; CHECK-NEXT:       - Index:           1
 ; CHECK-NEXT:         Locals:
 ; CHECK-NEXT:         Body:            41000B
 ; CHECK-NEXT:       - Index:           2
 ; CHECK-NEXT:         Locals:
 ; CHECK-NEXT:         Body:            1081808080000B
 ; CHECK-NEXT:       - Index:           3
 ; CHECK-NEXT:         Locals:

 ; CHECK-NEXT:       - Index:           4
 ; CHECK-NEXT:         Name:            call_alias_ptr
 ; CHECK-NEXT:       - Index:           5
 ; CHECK-NEXT:         Name:            call_direct_ptr
 ; CHECK-NEXT:       - Index:           6
 ; CHECK-NEXT:         Name:            __wasm_call_ctors
 ; CHECK-NEXT: ...
 
-; RUN: lld -flavor wasm --relocatable %t.o %t2.o -o %t.reloc.o
+; RUN: lld -flavor wasm --check-signatures --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:
 ; RELOC-NEXT:       - Index:           0
+; RELOC-NEXT:         ReturnType:      NORESULT
+; RELOC-NEXT:         ParamTypes:
+; RELOC-NEXT:       - Index:           1
 ; RELOC-NEXT:         ReturnType:      I32
 ; RELOC-NEXT:         ParamTypes:
 ; RELOC-NEXT:   - Type:            IMPORT
 ; RELOC-NEXT:     Imports:
 ; RELOC-NEXT:       - Module:          env
 ; RELOC-NEXT:         Field:           __stack_pointer
 ; RELOC-NEXT:         Kind:            GLOBAL
 ; RELOC-NEXT:         GlobalType:      I32
 ; RELOC-NEXT:         GlobalMutable:   false
 ; RELOC-NEXT:   - Type:            FUNCTION
-; RELOC-NEXT:     FunctionTypes:   [ 0, 0, 0, 0, 0, 0 ]
+; RELOC-NEXT:     FunctionTypes:   [ 0, 1, 1, 1, 1, 1 ]
 ; RELOC-NEXT:   - Type:            TABLE
 ; RELOC-NEXT:     Tables:
 ; RELOC-NEXT:       - ElemType:        ANYFUNC
 ; RELOC-NEXT:         Limits:
 ; RELOC-NEXT:           Flags:           [ HAS_MAX ]
 ; RELOC-NEXT:           Initial:         0x00000002
 ; RELOC-NEXT:           Maximum:         0x00000002
 ; RELOC-NEXT:   - Type:            MEMORY

 ; RELOC-NEXT:         Functions:       [ 1 ]
 ; RELOC-NEXT:   - Type:            CODE
 ; RELOC-NEXT:     Relocations:
 ; RELOC-NEXT:       - Type:            R_WEBASSEMBLY_FUNCTION_INDEX_LEB
 ; RELOC-NEXT:         Index:           1
 ; RELOC-NEXT:         Offset:          0x00000004
 ; RELOC-NEXT:       - Type:            R_WEBASSEMBLY_FUNCTION_INDEX_LEB
 ; RELOC-NEXT:         Index:           1
-; RELOC-NEXT:         Offset:          0x00000012
+; RELOC-NEXT:         Offset:          0x00000013
 ; RELOC-NEXT:       - Type:            R_WEBASSEMBLY_FUNCTION_INDEX_LEB
 ; RELOC-NEXT:         Index:           1
-; RELOC-NEXT:         Offset:          0x0000001B
+; RELOC-NEXT:         Offset:          0x0000001C
 ; RELOC-NEXT:       - Type:            R_WEBASSEMBLY_GLOBAL_INDEX_LEB
 ; RELOC-NEXT:         Index:           0
-; RELOC-NEXT:         Offset:          0x00000026
+; RELOC-NEXT:         Offset:          0x00000027
 ; RELOC-NEXT:       - Type:            R_WEBASSEMBLY_GLOBAL_INDEX_LEB
 ; RELOC-NEXT:         Index:           0
-; RELOC-NEXT:         Offset:          0x00000031
+; RELOC-NEXT:         Offset:          0x00000032
 ; RELOC-NEXT:       - Type:            R_WEBASSEMBLY_TABLE_INDEX_SLEB
 ; RELOC-NEXT:         Index:           1
-; RELOC-NEXT:         Offset:          0x00000039
+; RELOC-NEXT:         Offset:          0x0000003A
 ; RELOC-NEXT:       - Type:            R_WEBASSEMBLY_FUNCTION_INDEX_LEB
 ; RELOC-NEXT:         Index:           1
-; RELOC-NEXT:         Offset:          0x00000042
+; RELOC-NEXT:         Offset:          0x00000043
 ; RELOC-NEXT:       - Type:            R_WEBASSEMBLY_GLOBAL_INDEX_LEB
 ; RELOC-NEXT:         Index:           0
-; RELOC-NEXT:         Offset:          0x0000004F
+; RELOC-NEXT:         Offset:          0x00000050
 ; RELOC-NEXT:       - Type:            R_WEBASSEMBLY_GLOBAL_INDEX_LEB
 ; RELOC-NEXT:         Index:           0
-; RELOC-NEXT:         Offset:          0x0000005C
+; RELOC-NEXT:         Offset:          0x0000005D
 ; RELOC-NEXT:       - Type:            R_WEBASSEMBLY_GLOBAL_INDEX_LEB
 ; RELOC-NEXT:         Index:           0
-; RELOC-NEXT:         Offset:          0x00000067
+; RELOC-NEXT:         Offset:          0x00000068
 ; RELOC-NEXT:       - Type:            R_WEBASSEMBLY_TABLE_INDEX_SLEB
 ; RELOC-NEXT:         Index:           1
-; RELOC-NEXT:         Offset:          0x0000006F
+; RELOC-NEXT:         Offset:          0x00000070
 ; RELOC-NEXT:       - Type:            R_WEBASSEMBLY_FUNCTION_INDEX_LEB
 ; RELOC-NEXT:         Index:           1
-; RELOC-NEXT:         Offset:          0x00000078
+; RELOC-NEXT:         Offset:          0x00000079
 ; RELOC-NEXT:       - Type:            R_WEBASSEMBLY_GLOBAL_INDEX_LEB
 ; RELOC-NEXT:         Index:           0
-; RELOC-NEXT:         Offset:          0x00000085
+; RELOC-NEXT:         Offset:          0x00000086
 ; RELOC-NEXT:     Functions:
 ; RELOC-NEXT:       - Index:           0
 ; RELOC-NEXT:         Locals:
-; RELOC-NEXT:         Body:            1081808080000B
+; RELOC-NEXT:         Body:            1081808080001A0B
 ; RELOC-NEXT:       - Index:           1
 ; RELOC-NEXT:         Locals:
 ; RELOC-NEXT:         Body:            41000B
 ; RELOC-NEXT:       - Index:           2
 ; RELOC-NEXT:         Locals:
 ; RELOC-NEXT:         Body:            1081808080000B
 ; RELOC-NEXT:       - Index:           3
 ; RELOC-NEXT:         Locals:

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: lld -flavor wasm -no-gc-sections -o %t.wasm %t.o %t1.o %t2.o
+; RUN: lld -flavor wasm -no-gc-sections --check-signatures -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 i32 @_start() local_unnamed_addr {
+define void @_start() local_unnamed_addr {
 entry:
   %call = call i32 @weakFn()
   %val = load i32, i32* @weakGlobal, align 4
-  ret i32 %val
+  ret void
 }
 
 ; CHECK:      --- !WASM
 ; CHECK-NEXT: FileHeader:
 ; CHECK-NEXT:   Version:         0x00000001
 ; CHECK-NEXT: Sections:
 ; CHECK-NEXT:   - Type:            TYPE
 ; CHECK-NEXT:     Signatures:
 ; CHECK-NEXT:       - Index:           0
-; CHECK-NEXT:         ReturnType:      I32
+; CHECK-NEXT:         ReturnType:      NORESULT
 ; CHECK-NEXT:         ParamTypes:
 ; CHECK-NEXT:       - Index:           1
-; CHECK-NEXT:         ReturnType:      NORESULT
+; CHECK-NEXT:         ReturnType:      I32
 ; CHECK-NEXT:         ParamTypes:
 ; CHECK-NEXT:   - Type:            FUNCTION
-; CHECK-NEXT:     FunctionTypes:   [ 0, 0, 0, 0, 0, 1 ]
+; CHECK-NEXT:     FunctionTypes:   [ 0, 1, 1, 1, 1, 0 ]
 ; CHECK-NEXT:   - Type:            TABLE
 ; CHECK-NEXT:     Tables:
 ; CHECK-NEXT:       - ElemType:        ANYFUNC
 ; CHECK-NEXT:         Limits:
 ; CHECK-NEXT:           Flags:           [ HAS_MAX ]
 ; CHECK-NEXT:           Initial:         0x00000002
 ; CHECK-NEXT:           Maximum:         0x00000002
 ; CHECK-NEXT:   - Type:            MEMORY

 ; CHECK-NEXT:       - Offset:
 ; CHECK-NEXT:           Opcode:          I32_CONST
 ; CHECK-NEXT:           Value:           1
 ; CHECK-NEXT:         Functions:       [ 1 ]
 ; CHECK-NEXT:   - Type:            CODE
 ; CHECK-NEXT:     Functions:
 ; CHECK-NEXT:       - Index:           0
 ; CHECK-NEXT:         Locals:
-; CHECK-NEXT:         Body:            1081808080001A4100280280888080000B
+; CHECK-NEXT:         Body:            1081808080001A0B
 ; CHECK-NEXT:       - Index:           1
 ; CHECK-NEXT:         Locals:
 ; CHECK-NEXT:         Body:            41010B
 ; CHECK-NEXT:       - Index:           2
 ; CHECK-NEXT:         Locals:
 ; CHECK-NEXT:         Body:            4181808080000B
 ; CHECK-NEXT:       - Index:           3
 ; CHECK-NEXT:         Locals:

test/wasm/weak-undefined.ll

 ; RUN: llc -filetype=obj -o %t.o %s
-; RUN: lld -flavor wasm -strip-debug %t.o -o %t.wasm
+; RUN: lld -flavor wasm --check-signatures -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
 
 declare extern_weak i32 @foo()
 
 define i8* @get_address_of_foo() #0 {
 entry:
   ret i8* bitcast (i32 ()* @foo to i8*)
 }
 
 define i32* @get_address_of_global_var() #0 {
   ret i32* @global_var
 }
 
-define i32 @_start() #0 {
+define void @_start() #0 {
 entry:
-    %0 = load i32, i32* @global_var, align 4
-    ret i32 %0
+    %call = call i32* @get_address_of_global_var()
+    ret void
 }
 
 ; CHECK:      --- !WASM
 ; CHECK-NEXT: FileHeader:
 ; CHECK-NEXT:   Version:         0x00000001
 ; CHECK-NEXT: Sections:
 ; CHECK-NEXT:   - Type:            TYPE
 ; CHECK-NEXT:     Signatures:
 ; CHECK-NEXT:       - Index:           0
 ; CHECK-NEXT:         ReturnType:      I32
 ; CHECK-NEXT:         ParamTypes:
 ; CHECK-NEXT:       - Index:           1
 ; CHECK-NEXT:         ReturnType:      NORESULT
 ; CHECK-NEXT:         ParamTypes:
 ; CHECK-NEXT:   - Type:            FUNCTION
-; CHECK-NEXT:     FunctionTypes:   [ 0, 0, 0, 1 ]
+; CHECK-NEXT:     FunctionTypes:   [ 0, 0, 1, 1 ]
 ; CHECK-NEXT:   - Type:            TABLE
 ; CHECK-NEXT:     Tables:
 ; CHECK-NEXT:       - ElemType:        ANYFUNC
 ; CHECK-NEXT:         Limits:
 ; CHECK-NEXT:           Flags:           [ HAS_MAX ]
 ; CHECK-NEXT:           Initial:         0x00000001
 ; CHECK-NEXT:           Maximum:         0x00000001
 ; CHECK-NEXT:   - Type:            MEMORY

 ; CHECK-NEXT:       - Index:           0
 ; CHECK-NEXT:         Locals:
 ; CHECK-NEXT:         Body:            4180808080000B
 ; CHECK-NEXT:       - Index:           1
 ; CHECK-NEXT:         Locals:
 ; CHECK-NEXT:         Body:            4180808080000B
 ; CHECK-NEXT:       - Index:           2
 ; CHECK-NEXT:         Locals:
-; CHECK-NEXT:         Body:            4100280280808080000B
+; CHECK-NEXT:         Body:            1081808080001A0B
 ; CHECK-NEXT:       - Index:           3
 ; CHECK-NEXT:         Locals:
 ; CHECK-NEXT:         Body:            0B
 ; CHECK-NEXT:   - Type:            CUSTOM
 ; CHECK-NEXT:     Name:            linking
 ; CHECK-NEXT:     DataSize:        0
 ; CHECK-NEXT: ...