[WebAssembly] Added initial type checker to MC Assembler

[aardappel]

Summary

This to protect against non-sensical instruction sequences being assembled,
which would either cause asserts/crashes further down, or a Wasm module being output that doesn't validate.

Unlike a validator, this type checker is able to give type-errors as part of the parsing process, which makes the assembler much friendlier to be used by humans writing manual input.

Because the MC system is single pass (instructions aren't even stored in MC format, they are directly output) the type checker has to be single pass as well, which means that from now on .globaltype and .functype decls must come before their use. An extra pass is added to Codegen to collect information for this purpose, since AsmPrinter is normally single pass / streaming as well, and would otherwise generate this information on the fly.

A -no-type-check flag was added to llvm-mc (and any other tools that take asm input) that surpresses type errors, as a quick escape hatch for tests that were not intended to be type correct.

This is a first version of the type checker that ignores control flow, i.e. it checks that types are correct along the linear path, but not the branch path. This will still catch most errors. Branch checking could be added in the future.

[aardappel]

This is a first version that passes all (modified) tests. There is still a few things wrong with this, but I thought I'd get some feedback on this direction as it stands.

[sbc100]

lld/test/wasm/Inputs/call-ret32.s

16

Remove extra newline too?

lld/test/wasm/bsymbolic.s

102

Is this change needed here or just for consistency? If its needed why does declaring the linkage type as global up front help the validator?

lld/test/wasm/gc-imports.s

18

Probably best to leave _start void->void as that is in some sense part of the ABI

lld/test/wasm/relocatable-comdat.s

11

Ditto, leave sig alone and just add drop maybe?

lld/test/wasm/relocation-bad-tls.s

6

Ditto

lld/test/wasm/shared64.s

82

Yup.. good catch.

lld/test/wasm/signature-mismatch-relocatable.s

15

Ditto.

llvm/test/CodeGen/WebAssembly/global-get.ll

76

This seems like i32_external_used should have some kind of type, no? I guess we should look at the FIXME here before landing.

llvm/test/MC/WebAssembly/basic-assembly.s

59

Did we not loose coverage of these different block types here?

114

Why this? Why not just drop?

llvm/test/MC/WebAssembly/globals.s

26

Nice!

[sbc100]

Just an initial review of the test output.. Looks pretty great in general. Nice to see some glaring errors in the tests get fixed.

Do you feel like landing the lld tests up front as an NFC maybe? (I could go either way on that since maybe landing together is nice too).

[aardappel]

lld/test/wasm/bsymbolic.s

102

not needed, probably part of an earlier refactor I changed later. reverted.

llvm/test/CodeGen/WebAssembly/global-get.ll

76

Yes, this is the case I mentioned I couldn't figure out. This seems like the only place where we are declaring custom globals and they are handled differently from the standard ones it seems..

llvm/test/MC/WebAssembly/basic-assembly.s

59

This file is really a random collection of wasm features, meant to test the assembler more than the features in question. This file does not promise to be complete in any way.. I simply made the changes in a way to require as few changes to the original as possible while type-checking.

114

I guess I was testing global.set as to how its handled in the type checker? drop would allow any type from global.get, so not a great test. Again, this file is a grab-bag of tests.

[aardappel]

Addressed most of sbc code review

[sbc100]

lgtm

We should probably wait for @dschuff input before landing.

llvm/include/llvm/CodeGen/MachineModuleInfoImpls.h

113

The classes above seem to track sets of MCSymbol* (see SymbolListTy). Would that make sense here too (rather than StringRef)?

llvm/lib/Target/WebAssembly/AsmParser/WebAssemblyAsmParser.cpp

248

Why not SmallVector like above?

257

Can we do SkipTypeCheck(Options.MCNoTypeCheck) here in the member initializer? (same with is64(STI.getTargetTriple().isArch64Bit())?

Then the don't need to inline = false above either I guess?

269

Is this a permanent caveat or should we have a TODO here?

1195

All this new code here makes me wonder if the typechecker should be its own class with its own state. Maybe not worth it?

1361

I surprised this functionality doesn't exist somewhere else already..

llvm/lib/Target/WebAssembly/WebAssemblyAsmPrinter.cpp

212

Is this function called maybe times with the same name? Can/shouldSetWasmSymType we avoid re-doing the work herein?

I just saw you have a FIXME for that already below. Maybe we can tell if this symbols has already had its type set and early out?

366

The old HasAddressTakenFunction was only set if !F.isIntrinsic() too.. is this change OK/indended?

375

Left over debugging?

528

So other AsmPrinters use this print the linkage of a single symbol, but we are co-opting to print the all signatures?

531

Is this just const cast? Why not use const_cast?

llvm/lib/Target/WebAssembly/WebAssemblyAsmPrinter.h

86

I think the direction is towards lowerSnakeCase in this API. Also it would match better with getMCSymbolForFunction above to call this setWasmSymType.

llvm/lib/Target/WebAssembly/WebAssemblyInstrTable.td

16

I don't really grok this part of the change. @pmatos will know more. Can we split part out since it feels like its own bugfix. How was it not breaking stuff? (Or was it?)

llvm/lib/Target/WebAssembly/WebAssemblyMCInstLower.cpp

94

Actually maybe we should just call this method something like getOrCreateWasmSymbol? (don't feel strongly about this).

[aardappel]

llvm/include/llvm/CodeGen/MachineModuleInfoImpls.h

113

The pass that uses this runs before AsmPrinter/MCLower, thus MCContext etc is not available yet.

llvm/lib/Target/WebAssembly/AsmParser/WebAssemblyAsmParser.cpp

248

There's only ever 1 instance of these per assembler, so there is no allocation cost. But will change them to SmallVector anyway.

269

This is intended to be fairly permanent. The assembler is run on the inline asm contents without any context of a function, or globals, or anything, which breaks everything this type checker does. We'd need to somehow recover all that information. I made inline asm "work" in the past because, why not, but I am not sure there's any legit uses for it in Wasm.

1195

Yup, that could probably be done? Lemme give that a go..

1361

Nope.. I definitely looked.

This stuff is really ugly though, it does a linear search thru the table, and then the type checker above does linear if-checks against the resulting string.

Would be awesome to not do this.

We could check directly against the opcode, but there's one opcode per type (8 or so of them), and then of course occasionally we make new types. So this would make for a very fast but very fragile switch-case above.

3rd option is to generate some new table thru tablegen that has the exact mapping we need.

Opinions?

llvm/lib/Target/WebAssembly/WebAssemblyAsmPrinter.cpp

366

not intended, good catch!

528

Yes, it was difficult to find a point where to emit this, since the constructor is executed way before anything is run, there's no onStartOfFile or similar, so this is the earliest part of emitting the first function which seemed most suitable.

llvm/lib/Target/WebAssembly/WebAssemblyInstrTable.td

16

It wasn't breaking much, since this was so far only used in asm. I'd rather keep this all in one place, showing the things the type-checker found.

[dschuff]

llvm/lib/Target/WebAssembly/AsmParser/WebAssemblyAsmParser.cpp

243

why is Stack wrapped inside another struct (instead of a typedef or using)? I don't see any other uses of TypeStack anywhere other than just via TS.

1012

I think you can use LLVM_DUMP_METHOD rather than wrapping this whole method in LLVM_DEBUG. I forget exactly what that does (it's not exactly the same as LLVM_DEBUG) but might still do what you want.

edit: based on how it's used below, I think you'd still need to wrap calls in LLVM_DEBUG() which might be what you're trying to avoid now. So I'll leave it up to you to decide whether you want to do that, but leave this comment here in case you weren't aware of LLVM_DUMP_METHOD

1156

Is this right? function signatures for indirect calls aren't checked until runtime?

1361

This method is really only used by DumpStack, which is only used under LLVM_DEBUG, right? linear search might not be so bad in that case.

llvm/lib/Target/WebAssembly/WebAssemblyAsmPrinter.cpp

357

I guess this only needs to run here in the case that there were no linkages to emit? Can that ever happen (a module with no functions and no globals?)

[aardappel]

llvm/lib/Target/WebAssembly/AsmParser/WebAssemblyAsmParser.cpp

243

That was to prepare for having copies of this stack in TypedLabels, but that so far isn't implemented. I can remove it for now.

1012

Yes, wasn't aware of it.. LLVM_DUMP_METHOD by itself doesn't do anything, but there is the practice to create dump methods on types rather than what I did here.. I could do that on TypeStack that I am about the remove :) But in all, the existing code is simpler.

1156

I'm not sure what you're asking. For the assembler, the instruction specifies a signature inline, so it is checked against the stack at.. assembly time. For Wasm in general, the i32 on the stack can be any old integer, and thus, any function with any signature, so that is checked at runtime.

1361

No, it is used by the big long if-else chain of the main type checker above, so it is definitely a possible performance issue.

llvm/lib/Target/WebAssembly/WebAssemblyAsmPrinter.cpp

357

yes, this was the location where the code was originally run from, so I put it here to make sure it runs at least once. It may well be that it can never happen, but I'd rather protect against that.

[aardappel]

Addressed code review.

Also moved all of the type checking functionality to its own files, which will mess up past code comment locations, sorry. But it does look a whole lot neater :)

[dschuff]

llvm/lib/Target/WebAssembly/AsmParser/WebAssemblyAsmParser.cpp

1156

oh right, this checks the function as called, not as declared.

[aardappel]

Ok, I can land this as-is, with the few warts it has. Might be easier to address things in followups given the size.

[dschuff]

Yeah, I think that makes sense.

[thakis]

Thanks for updating the .gn files, but that's not necessary: A bot syncs them from the cmake files.

lld/test/wasm/Inputs/call-ret32.s

+.functype ret32 (f32) -> (i32)
+
   .globl  call_ret32
 call_ret32:
   .functype call_ret32 () -> (i32)
   f32.const 0x0p0
   call  ret32
   drop
   i32.const ret32_address
   end_function
 
   .section  .data.ret32_address,"",@
   .globl ret32_address
 ret32_address:
   .int32  ret32
   .size ret32_address, 4
-
-  .functype ret32 (f32) -> (i32)

lld/test/wasm/Inputs/ctor-lib.s

+  .functype def () -> ()
+
   .section  .text.lib_func,"",@
   .globl  lib_func
 lib_func:
   .functype lib_func () -> ()
   end_function
 
   .section  .text.unused_lib_func,"",@
   .globl unused_lib_func
 unused_lib_func:
   .functype unused_lib_func () -> ()
   call def
   end_function
 
   .functype def () -> ()

lld/test/wasm/Inputs/ctor-setup-call-def.s

 # Like Inputs/ctor-setup.s, except it calls `def` instead of `lib_func`,
 # so it pulls in the .o file containing `ctor`.
 
+.functype       def () -> ()
+
   .section  .text._start,"",@
   .globl  _start
 _start:
   .functype _start () -> ()
   end_function
 
   .section  .text.setup,"",@
   .globl setup
 setup:
   .functype setup () -> ()
   call def
   end_function
 
   .section  .init_array,"",@
   .p2align  2
   .int32 setup
-
-.functype       def () -> ()

lld/test/wasm/Inputs/ctor-setup.s

 # Like Inputs/ctor-start.s, except it calls `lib_func` from a ctor
 # instead of from `_start`.
 
+.functype       lib_func () -> ()
+
   .globl  _start
 _start:
   .functype _start () -> ()
   end_function
 
   .globl  setup
 setup:
   .functype setup () -> ()
   call  lib_func
   end_function
 
   .section  .init_array,"",@
   .p2align  2
   .int32  setup
 
-        .functype       lib_func () -> ()

lld/test/wasm/Inputs/ctor-start.s

+.functype lib_func () -> ()
+
   .globl _start
 _start:
   .functype _start () -> ()
   call lib_func
   end_function
 
-  .functype lib_func () -> ()

lld/test/wasm/Inputs/hello.s

 # asm generated by clang from the following C code:
 #   void puts(const char*);
 #   void hello() { puts("hello\n"); }
 
+  .functype puts (i32) -> ()
+
   .globl  hello
 hello:
   .functype hello () -> ()
   i32.const hello_str
   call  puts
   end_function
 
   .section  .rodata.hello_str,"",@
   .globl  hello_str
 hello_str:
   .asciz  "hello\n"
   .size hello_str, 7
-
-  .functype puts (i32) -> ()

lld/test/wasm/Inputs/import-attributes.s

+.functype foo () -> ()
+
   .globl  call_foo
 call_foo:
   .functype call_foo () -> ()
   call  foo
   end_function
 
-  .functype foo () -> ()
   .import_module  foo, baz

lld/test/wasm/Inputs/sig_mismatch.s

 .globl foo
 foo:
    .functype foo (f32) -> (i32)
    i32.const 0
    end_function
 
 
 .globl call_foo
 call_foo:
    .functype call_foo () -> (i32)
+   f32.const 0.0
    call foo
    end_function

lld/test/wasm/Inputs/undefined-globals.s

 .globl use_undef_global
 .globl unused_undef_global
 .globl used_undef_global
 
+.globaltype unused_undef_global, i64, immutable
+.globaltype used_undef_global, i64, immutable
+
 use_undef_global:
   .functype use_undef_global () -> (i64)
   global.get used_undef_global
   end_function
-
-.globaltype unused_undef_global, i64, immutable
-.globaltype used_undef_global, i64, immutable

lld/test/wasm/bsymbolic.s

 // SYMBOLIC-NEXT:      - Index:           4
 // SYMBOLIC-NEXT:        Type:            I32
 // SYMBOLIC-NEXT:        Mutable:         false
 // SYMBOLIC-NEXT:        InitExpr:
 // SYMBOLIC-NEXT:          Opcode:          I32_CONST
 // SYMBOLIC-NEXT:          Value:           0
 // SYMBOLIC-NEXT:  - Type:            EXPORT
 
 .globl foo
+
 foo:
   .functype foo () -> ()
   end_function
 
 .globl get_foo_address
 get_foo_address:
   .functype get_foo_address () -> (i32)
   global.get foo@GOT

lld/test/wasm/comdat-sections.s

 # RUN: llvm-mc -triple=wasm32 -filetype=obj %p/Inputs/comdat1.s -o %t1.o
 # RUN: llvm-mc -triple=wasm32 -filetype=obj %p/Inputs/comdat2.s -o %t2.o
 # RUN: llvm-mc -triple=wasm32 -filetype=obj %s -o %t.o
 # RUN: wasm-ld  -o %t.wasm %t.o %t1.o %t2.o
 # RUN: obj2yaml %t.wasm | FileCheck %s
 
+        .functype foo () -> ()
 
         .globl  _start
         .type  _start,@function
 _start:
         .functype _start () -> ()
         call foo
         end_function
 
-        .functype foo () -> ()
-
 
 # Check that we got 1 copy of each of the .debug_foo sections from the 2 object
 # files, and that they came from the same object.
 # CHECK:  - Type:            CUSTOM
 # CHECK-NEXT:    Name:            .debug_foo
 # CHECK-NEXT:    Payload:         010000007B00000000000000

lld/test/wasm/ctor_return_value.s

 # RUN: llvm-mc -filetype=obj -triple=wasm32-unknown-unknown -o %t.o %s
 # RUN: wasm-ld %t.o -o %t.wasm
 # RUN: obj2yaml %t.wasm | FileCheck %s
 
+  .functype __wasm_call_ctors () -> ()
+
   .globl  myctor
 myctor:
   .functype myctor () -> (i32)
   i32.const 1
 
   end_function
 
   .globl  _start

lld/test/wasm/debuginfo-undefined-global.s

 # RUN: llvm-mc -filetype=obj -triple=wasm32-unknown-unknown -o %t.o %s
 # RUN: wasm-ld -o %t.wasm %t.o
 # RUN: obj2yaml %t.wasm | FileCheck %s
 
 # Debug sections are allowed to contains references to non-live symbols that
 # then get GC'd.  In this test the .debug_info seciton contains a reference to
 # foo which is not otherwise used and will not be marked a live in the output.
 # Verify the tombstone value is written to debug_info section.
 
+.globaltype foo, i32
+
 .globl  _start
 _start:
   .functype _start () -> ()
   end_function
 
 .section .debug_info,"",@
   .int32 foo
 
-.globaltype foo, i32
 foo:
 
 # CHECK:       - Type:            CUSTOM
 # CHECK-NEXT:    Name:            .debug_info
 # CHECK-NEXT:    Payload:         FFFFFFFF

lld/test/wasm/demangle.s

 # RUN: llvm-mc -filetype=obj -triple=wasm32-unknown-unknown -o %t.o %s
 # RUN: not wasm-ld -o %t.wasm %t.o 2>&1 | FileCheck %s
 
 # CHECK: error: {{.*}}.o: undefined symbol: foo(int)
 
 # RUN: not wasm-ld --no-demangle \
 # RUN:     -o %t.wasm %t.o 2>&1 | FileCheck -check-prefix=CHECK-NODEMANGLE %s
 
 # CHECK-NODEMANGLE: error: {{.*}}.o: undefined symbol: _Z3fooi
 
+.functype _Z3fooi (i32) -> ()
+
   .globl  _start
 _start:
   .functype _start () -> ()
   i32.const 1
   call  _Z3fooi
   end_function
 
-.functype _Z3fooi (i32) -> ()

lld/test/wasm/early-exit-for-bad-paths.s

 
 # We should exit before doing the actual link. If an undefined symbol error is
 # discovered we haven't bailed out early as expected.
 # CHECK-NOT: undefined_symbol
 
 # RUN: not wasm-ld %t.o -o / 2>&1 | FileCheck %s -check-prefixes=ROOT,CHECK
 # ROOT: error: cannot open output file /
 
+.functype undefined_symbol () -> ()
+
 _start:
     .functype _start () -> ()
     call undefined_symbol
     end_function

lld/test/wasm/entry-signature.s

 # Verify that the entry point signature can be flexible.
 # RUN: llvm-mc -filetype=obj -triple=wasm32-unknown-unknown -o %t.o %s
 # RUN: wasm-ld -o %t1.wasm %t.o
 
   .globl  _start
 _start:
   .functype _start (i64) -> (f32)
+  f32.const 0.0
   end_function

lld/test/wasm/export-all.s

 # RUN: llvm-mc -filetype=obj -triple=wasm32-unknown-unknown -o %t.o %s
 # RUN: wasm-ld --export-all -o %t.wasm %t.o
 # RUN: obj2yaml %t.wasm | FileCheck %s
 
+.globaltype __stack_pointer, i32
+
 .globl _start
 
 _start:
   .functype _start () -> ()
   i32.const 3
   global.set __stack_pointer
   end_function
 
 foo:
   .functype foo () -> (i32)
   i32.const 42
   end_function
 
-.globaltype __stack_pointer, i32
-
 #      CHECK:   - Type:            EXPORT
 # CHECK-NEXT:     Exports:
 # CHECK-NEXT:       - Name:            memory
 # CHECK-NEXT:         Kind:            MEMORY
 # CHECK-NEXT:         Index:           0
 # CHECK-NEXT:       - Name:            __wasm_call_ctors
 # CHECK-NEXT:         Kind:            FUNCTION
 # CHECK-NEXT:         Index:           0

lld/test/wasm/export-optional.s

 # Test the --export of optional linker-synthetic symbols works.
 # Specifically the __start_xxx and __end_xx symbols.
 
 # RUN: llvm-mc -filetype=obj -triple=wasm32-unknown-unknown %s -o %t.o
 # RUN: wasm-ld --export=__start_foo %t.o -o %t.wasm
 # RUN: obj2yaml %t.wasm | FileCheck %s
 
   .globl  _start
 _start:
   .functype _start () -> ()
+  i32.const 0
   i32.load foo
   drop
   end_function
 
   .globl  foo
   .section    foo,"",@
 foo:
   .int32 42

lld/test/wasm/gc-imports.s

 # RUN: llvm-mc -filetype=obj -triple=wasm32-unknown-unknown %s -o %t.o
 # RUN: llvm-mc -filetype=obj -triple=wasm32-unknown-unknown %S/Inputs/undefined-globals.s -o %t_globals.o
 # RUN: wasm-ld --allow-undefined -o %t1.wasm %t.o %t_globals.o
 
 .functype unused_undef_function (i64) -> (i64)
 .functype used_undef_function () -> (i32)
 .functype use_undef_global () -> (i64)
 
 foo:
-  .functype foo () -> ()
+  .functype foo (i64) -> (i64)
+  local.get 0
   call unused_undef_function
   end_function
 
 .globl _start
 
 _start:
   .functype _start () -> ()
   call used_undef_function
+  drop
   call use_undef_global
+  drop
   end_function
 
 # RUN: obj2yaml %t1.wasm | FileCheck %s
 
 # CHECK:        - Type:            IMPORT
 # CHECK-NEXT:     Imports:
 # CHECK-NEXT:       - Module:          env
 # CHECK-NEXT:         Field:           used_undef_function

lld/test/wasm/import-attribute-mismatch.s

 # RUN: llvm-mc -filetype=obj -triple=wasm32-unknown-unknown -o %t1.o %s
 # RUN: llvm-mc -filetype=obj -triple=wasm32-unknown-unknown %S/Inputs/import-attributes.s -o %t2.o
 # RUN: not wasm-ld --export call_foo --allow-undefined -o %t.wasm %t1.o %t2.o 2>&1 | FileCheck %s
 
+.functype foo () -> ()
+
   .globl  _start
 _start:
   .functype _start () -> ()
   call  foo
   end_function
 
-.functype foo () -> ()
 .import_module  foo, bar
 
 # CHECK: wasm-ld: error: import module mismatch for symbol: foo
 # CHECK: >>> defined as bar in {{.*}}1.o
 # CHECK: >>> defined as baz in {{.*}}2.o

lld/test/wasm/map-file.s

 # RUN: llvm-mc -filetype=obj -triple=wasm32-unknown-unknown %s -o %t1.o
 # RUN: wasm-ld %t1.o -o %t -M | FileCheck --match-full-lines --strict-whitespace %s
 # RUN: wasm-ld %t1.o -o %t -print-map | FileCheck --match-full-lines --strict-whitespace %s
 # RUN: wasm-ld %t1.o -o %t -Map=%t.map
 # RUN: FileCheck --match-full-lines --strict-whitespace %s < %t.map
 
 .globaltype wasm_global, i32, immutable
 wasm_global:
 
 bar:
-    .functype bar () -> ()
+    .functype bar () -> (i32)
     i32.const   somedata
     end_function
 
 write_global:
     .functype write_global (i32) -> ()
     local.get 0
     global.set wasm_global
     end_function

 somedata:
     .int32 123
 .size somedata, 4
 
 .section .debug_info,"",@
     .int32 bar
 
 #      CHECK:    Addr      Off     Size Out     In      Symbol
-# CHECK-NEXT:       -        8        a TYPE
-# CHECK-NEXT:       -       12        6 FUNCTION
-# CHECK-NEXT:       -       18        7 TABLE
-# CHECK-NEXT:       -       1f        5 MEMORY
-# CHECK-NEXT:       -       24        f GLOBAL
+# CHECK-NEXT:       -        8        e TYPE
+# CHECK-NEXT:       -       16        6 FUNCTION
+# CHECK-NEXT:       -       1c        7 TABLE
+# CHECK-NEXT:       -       23        5 MEMORY
+# CHECK-NEXT:       -       28        f GLOBAL
 # CHECK-NEXT:       0        0        0         __stack_pointer
 # CHECK-NEXT:       1        0        0         wasm_global
-# CHECK-NEXT:       -       33       15 EXPORT
-# CHECK-NEXT:       -       48       26 CODE
-# CHECK-NEXT:       -       49        9         {{.*}}{{/|\\}}map-file.s.tmp1.o:(bar)
-# CHECK-NEXT:       -       49        9                 bar
-# CHECK-NEXT:       -       52        b         {{.*}}{{/|\\}}map-file.s.tmp1.o:(write_global)
-# CHECK-NEXT:       -       52        b                 write_global
-# CHECK-NEXT:       -       5d        f         {{.*}}{{/|\\}}map-file.s.tmp1.o:(_start)
-# CHECK-NEXT:       -       5d        f                 _start
-# CHECK-NEXT:       -       6e        d DATA
-# CHECK-NEXT:     400       6f        4 .data
-# CHECK-NEXT:     400       75        4         {{.*}}{{/|\\}}map-file.s.tmp1.o:(.data.somedata)
-# CHECK-NEXT:     400       75        4                 somedata
-# CHECK-NEXT:       -       7b       12 CUSTOM(.debug_info)
-# CHECK-NEXT:       -       8d       50 CUSTOM(name)
+# CHECK-NEXT:       -       37       15 EXPORT
+# CHECK-NEXT:       -       4c       26 CODE
+# CHECK-NEXT:       -       4d        9         {{.*}}{{/|\\}}map-file.s.tmp1.o:(bar)
+# CHECK-NEXT:       -       4d        9                 bar
+# CHECK-NEXT:       -       56        b         {{.*}}{{/|\\}}map-file.s.tmp1.o:(write_global)
+# CHECK-NEXT:       -       56        b                 write_global
+# CHECK-NEXT:       -       61        f         {{.*}}{{/|\\}}map-file.s.tmp1.o:(_start)
+# CHECK-NEXT:       -       61        f                 _start
+# CHECK-NEXT:       -       72        d DATA
+# CHECK-NEXT:     400       73        4 .data
+# CHECK-NEXT:     400       79        4         {{.*}}{{/|\\}}map-file.s.tmp1.o:(.data.somedata)
+# CHECK-NEXT:     400       79        4                 somedata
+# CHECK-NEXT:       -       7f       12 CUSTOM(.debug_info)
+# CHECK-NEXT:       -       91       50 CUSTOM(name)
 
 # RUN: not wasm-ld %t1.o -o /dev/null -Map=/ 2>&1 \
 # RUN:  | FileCheck -check-prefix=FAIL %s
 # FAIL: wasm-ld: error: cannot open map file /

lld/test/wasm/multivalue-return-func-types.s

 # RUN: llvm-mc -filetype=obj -triple=wasm32-unknown-unknown -o %t.o %s
 # RUN: wasm-ld %t.o -o %t.wasm
 # RUN: obj2yaml %t.wasm | FileCheck %s
 
 .globl _start
 .globl fn_i32
 .globl fn_i32_i32
 .globl fn_i32_i64
 .globl fn_i64_f64_i32_f32
 
 
-_start:
-  .functype _start () -> ()
-  call fn_i32
-  drop
-  call fn_i32_i32
-  drop
-  drop
-  call fn_i32_i64
-  drop
-  drop
-  call fn_i64_f64_i32_f32
-  drop
-  drop
-  drop
-  drop
-  end_function
-
 fn_i32:
   .functype fn_i32 () -> (i32)
   i32.const 1
   end_function
 
 fn_i32_i32:
   .functype fn_i32_i32 () -> (i32, i32)
   i32.const 1

 fn_i64_f64_i32_f32:
   .functype fn_i64_f64_i32_f32 () -> (i64, f64, i32, f32)
   i64.const 1
   f64.const 1.0
   i32.const 1
   f32.const 1.0
   end_function
 
+_start:
+  .functype _start () -> ()
+  call fn_i32
+  drop
+  call fn_i32_i32
+  drop
+  drop
+  call fn_i32_i64
+  drop
+  drop
+  call fn_i64_f64_i32_f32
+  drop
+  drop
+  drop
+  drop
+  end_function
+
 
 # CHECK:       - Type:            TYPE
 # CHECK-NEXT:    Signatures:
 # CHECK-NEXT:      - Index:           0
 # CHECK-NEXT:        ParamTypes:      []
 # CHECK-NEXT:        ReturnTypes:     []
 # CHECK-NEXT:      - Index:           1
 # CHECK-NEXT:        ParamTypes:      []

lld/test/wasm/mutable-globals.s

 # RUN: llvm-mc -filetype=obj -triple=wasm32-unknown-unknown -o %t.o %s
 # RUN: not wasm-ld %t.o -o %t.wasm 2>&1 | FileCheck %s
 # RUN: wasm-ld --features=mutable-globals %t.o -o %t.wasm
 
+.globaltype foo, i32
+
 .globl _start
 _start:
   .functype _start () -> ()
   i32.const 1
   global.set foo
   end_function
 
-.globaltype foo, i32
 .import_module foo, env
 .import_name foo, foo
 
 # CHECK: error: mutable global imported but 'mutable-globals' feature not present in inputs: `foo`. Use --no-check-features to suppress.

lld/test/wasm/name-section-mangling.s

 # RUN: llvm-mc -filetype=obj -triple=wasm32-unknown-unknown -o %t.o %s
 # RUN: wasm-ld --export=_Z3fooi --demangle -o %t_demangle.wasm %t.o
 # RUN: obj2yaml %t_demangle.wasm | FileCheck --check-prefixes=CHECK,DEMANGLE %s
 # RUN: wasm-ld --export=_Z3fooi --no-demangle -o %t_nodemangle.wasm %t.o
 # RUN: obj2yaml %t_nodemangle.wasm | FileCheck --check-prefixes=CHECK,MANGLE %s
 
 # Check that the EXPORT name is still mangled, but that the "name" custom
 # section contains the unmangled name.
 
 .globl _start
 .globl _Z3fooi
 .weak _Z3bari
 
+.functype _Z3bari (i32) -> ()
+
+_Z3fooi:
+  .functype _Z3fooi (i32) -> ()
+  end_function
+
 _start:
   .functype _start () -> ()
   i32.const 1
   call _Z3fooi
   i32.const 1
   call _Z3bari
   end_function
 
-_Z3fooi:
-  .functype _Z3fooi (i32) -> ()
-  end_function
-
-.functype _Z3bari (i32) -> ()
-
 # 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:           1

lld/test/wasm/relocatable-comdat.s

 # RUN: llvm-mc -triple=wasm32 -filetype=obj %p/Inputs/comdat-data.s -o %t1.o
 # RUN: llvm-mc -triple=wasm32 -filetype=obj %s -o %t.o
 # RUN: wasm-ld --relocatable -o %t.wasm %t.o %t1.o
 # RUN: obj2yaml %t.wasm | FileCheck %s
 
 
         .globl  _start
         .type  _start,@function
 _start:
         .functype _start () -> ()
+        i32.const 0
         i32.load foo
+        drop
         end_function
 
 
 .section  .data.foo,"",@
 foo:
         .int32 42
         .size foo, 4
 

lld/test/wasm/relocation-bad-tls.s

 # RUN: llvm-mc -filetype=obj -triple=wasm32-unknown-unknown -o %t.o %s
 # RUN: not wasm-ld %t.o -o %t.wasm 2>&1 | FileCheck %s
 
 .globl _start
 _start:
   .functype _start () -> ()
   i32.const foo@TLSREL
   i32.const bar@TLSREL
+  drop
+  drop
   end_function
 
 .section  .data,"",@
 .globl  foo
 foo:
   .int32  0
   .size foo, 4
 
 .section  .bss,"",@
 .globl  bar
 bar:
   .int32  0
   .size bar, 4
 
 # CHECK: relocation R_WASM_MEMORY_ADDR_TLS_SLEB cannot be used against `foo` in non-TLS section: .data
 # CHECK: relocation R_WASM_MEMORY_ADDR_TLS_SLEB cannot be used against `bar` in non-TLS section: .bss

lld/test/wasm/shared.s

 # RUN: llvm-mc -filetype=obj -triple=wasm32-unknown-unknown -o %t.o %s
 # RUN: wasm-ld --experimental-pic -shared -o %t.wasm %t.o
 # RUN: obj2yaml %t.wasm | FileCheck %s
 
+.functype func_external () -> ()
+
+# Linker-synthesized globals
+.globaltype __stack_pointer, i32
+.globaltype __table_base, i32, immutable
+.globaltype __memory_base, i32, immutable
+
 .section .data.data,"",@
 data:
   .p2align 2
   .int32 2
   .size data, 4
 
 .section .data.indirect_func_external,"",@
 indirect_func_external:

 # TODO(sbc): We probably want a nicer way to specify target_features section
 # in assembly.
 .section .custom_section.target_features,"",@
 .int8 1
 .int8 43
 .int8 15
 .ascii "mutable-globals"
 
-.functype func_external () -> ()
-
-# Linker-synthesized globals
-.globaltype __stack_pointer, i32
-.globaltype __table_base, i32, immutable
-.globaltype __memory_base, i32, immutable
-
 # check for dylink section at start
 
 # CHECK:      Sections:
 # CHECK-NEXT:   - Type:            CUSTOM
 # CHECK-NEXT:     Name:            dylink
 # CHECK-NEXT:     MemorySize:      24
 # CHECK-NEXT:     MemoryAlignment: 2
 # CHECK-NEXT:     TableSize:       2

lld/test/wasm/shared64.s

 # RUN: llvm-mc -filetype=obj -triple=wasm64-unknown-unknown -o %t.o %s
 # RUN: wasm-ld -mwasm64 --experimental-pic -shared -o %t.wasm %t.o
 # RUN: obj2yaml %t.wasm | FileCheck %s
 
+.functype func_external () -> ()
+
+# Linker-synthesized globals
+.globaltype __stack_pointer, i64
+.globaltype __table_base, i64, immutable
+.globaltype __memory_base, i64, immutable
+
 .section .data.data,"",@
 data:
   .p2align 2
   .int32 2
   .size data, 4
 
 .section .data.indirect_func_external,"",@
 indirect_func_external:

 data_addr:
   .int32 data
   .size data_addr, 4
 
 # .. against external symbols
 
 .section .data.data_addr_external,"",@
 data_addr_external:
-  .int32 data_external
-  .size data_addr_external, 4
+  .int64 data_external
+  .size data_addr_external, 8
 
 # .. including addends
 
 .section .data.extern_struct_internal_ptr,"",@
 extern_struct_internal_ptr:
   .int32 extern_struct + 4
   .size extern_struct_internal_ptr, 4
 
foo:
   local.get 0
   i64.const 16
   i64.add
   global.set  __stack_pointer
   local.get 1
   end_function
 
 get_func_address:
-  .functype get_func_address () -> (i32)
+  .functype get_func_address () -> (i64)
   global.get func_external@GOT
   end_function
 
 get_data_address:
-  .functype get_data_address () -> (i32)
+  .functype get_data_address () -> (i64)
   global.get  data_external@GOT
   end_function
 
 get_local_func_address:
   # Verify that a function which is otherwise not address taken *is* added to
   # the wasm table with referenced via R_WASM_TABLE_INDEX_REL_SLEB64
   .functype get_local_func_address () -> (i64)
   global.get  __table_base

 # TODO(sbc): We probably want a nicer way to specify target_features section
 # in assembly.
 .section .custom_section.target_features,"",@
 .int8 1
 .int8 43
 .int8 15
 .ascii "mutable-globals"
 
-.functype func_external () -> ()
-
-# Linker-synthesized globals
-.globaltype __stack_pointer, i64
-.globaltype __table_base, i64, immutable
-.globaltype __memory_base, i64, immutable
-
 # check for dylink section at start
 
 # CHECK:      Sections:
 # CHECK-NEXT:   - Type:            CUSTOM
 # CHECK-NEXT:     Name:            dylink
-# CHECK-NEXT:     MemorySize:      24
+# CHECK-NEXT:     MemorySize:      28
 # CHECK-NEXT:     MemoryAlignment: 2
 # CHECK-NEXT:     TableSize:       2
 # CHECK-NEXT:     TableAlignment:  0
 # CHECK-NEXT:     Needed:          []
 # CHECK-NEXT:   - Type:            TYPE
 
 # check for import of __table_base and __memory_base globals
 

 
 # CHECK:        - Type:            CODE
 # CHECK-NEXT:     Functions:
 # CHECK-NEXT:       - Index:           1
 # CHECK-NEXT:         Locals:          []
 # CHECK-NEXT:         Body:            10020B
 # CHECK-NEXT:       - Index:           2
 # CHECK-NEXT:         Locals:          []
-# CHECK-NEXT:         Body:            230142047C2305360200230142087C230241016A3602002301420C7C230141006A360200230142107C2306360200230142147C230741046A3602000B
+# CHECK-NEXT:         Body:            230142047C2305360200230142087C230241016A3602002301420C7C230141006A360200230142107C2306370200230142187C230741046A3602000B
 
 # check the data segment initialized with __memory_base global as offset
 
 # CHECK:        - Type:            DATA
 # CHECK-NEXT:     Segments:
 # CHECK-NEXT:       - SectionOffset:   6
 # CHECK-NEXT:         InitFlags:       0
 # CHECK-NEXT:         Offset:
 # CHECK-NEXT:           Opcode:          GLOBAL_GET
 # CHECK-NEXT:           Index:           1
-# CHECK-NEXT:         Content:         '020000000000000001000000000000000000000000000000'
+# CHECK-NEXT:         Content:         '02000000000000000100000000000000000000000000000000000000'

lld/test/wasm/signature-mismatch-relocatable.s

 # RUN: llvm-mc -filetype=obj -triple=wasm32-unknown-unknown -o %t.o %s
 # RUN: llvm-mc -filetype=obj -triple=wasm32-unknown-unknown -o %t2.o %S/Inputs/sig_mismatch.s
 # RUN: wasm-ld --relocatable %t.o %t2.o -o %t.wasm
 # RUN: obj2yaml %t.wasm | FileCheck %s
 
 # Regression test for handling of signature mismatches (variant function
 # symbols) and relocatable output.  This issue only occurred when the undefined
 # function was seen first and the defined function was referenced within the
 # the defining file (see %S/Inputs/sig_mismatch.s).
 
+.functype foo (i32, i64, i32) -> (i32)
+
 .globl _start
 _start:
   .functype _start () -> ()
   i32.const 1
   i64.const 2
   i32.const 3
   call foo
+  drop
   end_function
 
-.functype foo (i32, i64, i32) -> (i32)
-
 #      CHECK:  - Type:            CUSTOM
 # CHECK-NEXT:    Name:            linking
 # CHECK-NEXT:    Version:         2
 # CHECK-NEXT:    SymbolTable:
 # CHECK-NEXT:      - Index:           0
 # CHECK-NEXT:        Kind:            FUNCTION
 # CHECK-NEXT:        Name:            _start
 # CHECK-NEXT:        Flags:           [  ]

lld/test/wasm/undefined-data.s

 # RUN: llvm-mc -filetype=obj -triple=wasm32-unknown-unknown -o %t.o %s
 # RUN: not wasm-ld -o %t.wasm %t.o 2>&1 | FileCheck %s -check-prefix=UNDEF
 # RUN: wasm-ld --allow-undefined -o %t.wasm %t.o
 # RUN: not wasm-ld --shared -o %t.wasm %t.o 2>&1 | FileCheck %s -check-prefix=SHARED
 
 .globl  _start
 _start:
   .functype _start () -> (i32)
+  i32.const 0
   i32.load  data_external
   end_function
 
 .size data_external, 4
 
 # UNDEF: error: {{.*}}undefined-data.s.tmp.o: undefined symbol: data_external
 # SHARED: error: {{.*}}undefined-data.s.tmp.o: relocation R_WASM_MEMORY_ADDR_LEB cannot be used against symbol data_external; recompile with -fPIC

lld/test/wasm/undefined-weak-call.s

 # RUN: llvm-mc -filetype=obj -triple=wasm32-unknown-unknown -o %t.o %s
 # RUN: wasm-ld --entry=callWeakFuncs --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".
 
+.functype weakFunc1 () -> ()
+.functype weakFunc2 () -> ()
+.functype weakFunc3 (i32) -> ()
+.functype weakFunc4 () -> ()
+
 .globl  callWeakFuncs
 
 callWeakFuncs:
   .functype callWeakFuncs () -> (i32)
   call  weakFunc1
   call  weakFunc2
   i32.const 2
   call  weakFunc3
   i32.const weakFunc1
   i32.const weakFunc4
   i32.add
   end_function
 
 .weak weakFunc1
 .weak weakFunc2
 .weak weakFunc3
 .weak weakFunc4
-.functype weakFunc1 () -> ()
-.functype weakFunc2 () -> ()
-.functype weakFunc3 (i32) -> ()
-.functype weakFunc4 () -> ()
 
 # CHECK-GC: removing unused section {{.*}}:(weakFunc4)
 
 # CHECK:      --- !WASM
 # CHECK-NEXT: FileHeader:
 # CHECK-NEXT:   Version:         0x1
 # CHECK-NEXT: Sections:
 # CHECK-NEXT:   - Type:            TYPE

lld/test/wasm/unresolved-symbols.s

 #
 #      IGNORE:  - Type:            CODE
 # IGNORE-NEXT:    Functions:
 # IGNORE-NEXT:      - Index:           0
 # IGNORE-NEXT:        Locals:          []
 # IGNORE-NEXT:        Body:            000B
 # IGNORE-NEXT:      - Index:           1
 # IGNORE-NEXT:        Locals:          []
-# IGNORE-NEXT:        Body:            1080808080001082808080001083808080000B
+# IGNORE-NEXT:        Body:            1080808080001082808080001083808080001A1A0B
 # IGNORE-NEXT:      - Index:           2
 # IGNORE-NEXT:        Locals:          []
 # IGNORE-NEXT:        Body:            4180808080000F0B
 # IGNORE-NEXT:      - Index:           3
 # IGNORE-NEXT:        Locals:          []
 # IGNORE-NEXT:        Body:            4180808080000F0B
 #
 #      IGNORE:  - Type:            CUSTOM

 # IMPORT-NEXT:        Kind:            FUNCTION
 # IMPORT-NEXT:        SigIndex:        0
 # IMPORT-NEXT:  - Type:            FUNCTION
 
 ## Do not report undefines if linking relocatable.
 # RUN: wasm-ld -r %t1.o -o %t4.wasm --unresolved-symbols=report-all
 # RUN: llvm-readobj %t4.wasm > /dev/null 2>&1
 
+.functype undef () -> ()
+.functype get_data_addr () -> (i32)
+.functype get_func_addr () -> (i32)
+
 .globl _start
 _start:
     .functype _start () -> ()
     call undef
     call get_data_addr
     call get_func_addr
+    drop
+    drop
     end_function
 
 .globl get_data_addr
 get_data_addr:
     .functype get_data_addr () -> (i32)
     i32.const undef_data
     return
     end_function
 
 .globl get_func_addr
 get_func_addr:
     .functype get_func_addr () -> (i32)
     i32.const undef
     return
     end_function
-
-.functype undef () -> ()

lld/test/wasm/weak-and-strong-undef.s

 # Test that when a symbol (foo) is both weakly and strongly referenced
 # the strong undefined symbol always generates an error, whichever object
 # file is seen first.
 
 # RUN: llvm-mc -filetype=obj -triple=wasm32-unknown-unknown %s -o %t1.o
 # RUN: llvm-mc -filetype=obj -triple=wasm32-unknown-unknown %S/Inputs/weak-undefined.s -o %t2.o
 # RUN: not wasm-ld %t1.o %t2.o -o /dev/null 2>&1 | FileCheck %s
 # RUN: not wasm-ld %t2.o %t1.o -o /dev/null 2>&1 | FileCheck %s
 
 # CHECK: undefined symbol: foo
 
+.functype foo () -> ()
+
 _start:
     .globl _start
     .functype _start () -> ()
     call foo
     end_function
-
-.functype foo () -> ()

lld/test/wasm/weak-symbols.s

 # RUN: llvm-mc -filetype=obj -triple=wasm32-unknown-unknown %p/Inputs/weak-symbol1.s -o %t1.o
 # RUN: llvm-mc -filetype=obj -triple=wasm32-unknown-unknown %p/Inputs/weak-symbol2.s -o %t2.o
 # RUN: llvm-mc -filetype=obj -triple=wasm32-unknown-unknown %s -o %t.o
 # RUN: wasm-ld --export-dynamic -o %t.wasm %t.o %t1.o %t2.o
 # RUN: obj2yaml %t.wasm | FileCheck %s
 
+.functype weakFn () -> (i32)
+
 .globl  _start
 _start:
   .functype _start () -> ()
   call  weakFn
   drop
   end_function
 
-.functype weakFn () -> (i32)
 .size weakGlobal, 4
 
 # CHECK:      --- !WASM
 # CHECK-NEXT: FileHeader:
 # CHECK-NEXT:   Version:         0x1
 # CHECK-NEXT: Sections:
 # CHECK-NEXT:   - Type:            TYPE
 # CHECK-NEXT:     Signatures:

lld/test/wasm/weak-undefined-pic.s

 # Checks handling of undefined weak external functions.  When the
 # static linker decides they are undefined, check GOT relocations
 # resolve to zero (i.e. a global that contains zero.).
 #
 # RUN: llvm-mc -filetype=obj -triple=wasm32-unknown-unknown -o %t.o %s
 # RUN: wasm-ld %t.o -o %t1.wasm
 # RUN: obj2yaml %t1.wasm | FileCheck %s
 #
 # With `--unresolved-symbols=ignore-all` the behaviour should be the same
 # as the default.>
 #
 # RUN: wasm-ld --unresolved-symbols=ignore-all %t.o -o %t2.wasm
 # RUN: obj2yaml %t2.wasm | FileCheck %s
 
+.functype foo () -> (i32)
+
 .globl get_foo_addr
 get_foo_addr:
   .functype get_foo_addr () -> (i32)
   global.get foo@GOT
   end_function
 
 .globl _start
 _start:
-  .functype _start () -> ()
+  .functype _start () -> (i32)
   call get_foo_addr
   end_function
 
 .weak foo
-.functype foo () -> (i32)
 
 # Verify that we do not generate dynamic relocations for the GOT entry.
 
 # CHECK-NOT: __wasm_apply_global_relocs
 
 # Verify that we do not generate an import for foo
 
 # CHECK-NOT:  - Type:            IMPORT

lld/test/wasm/weak-undefined.s

 # RUN: llvm-mc -filetype=obj -triple=wasm32-unknown-unknown -o %t.o %s
 # 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.
 
+.functype foo () -> (i32)
+
 .globl  get_address_of_foo
 get_address_of_foo:
   .functype get_address_of_foo () -> (i32)
   i32.const foo
   end_function
 
 .globl  get_address_of_global_var
 get_address_of_global_var:
_start:
   call  get_address_of_foo
   drop
   call  foo
   drop
   end_function
 
 .weak foo
 .weak global_var
-.functype foo () -> (i32)
 
 
 # CHECK:      --- !WASM
 # CHECK-NEXT: FileHeader:
 # CHECK-NEXT:   Version:         0x1
 # CHECK-NEXT: Sections:
 # CHECK-NEXT:   - Type:            TYPE
 # CHECK-NEXT:     Signatures:

llvm/include/llvm/CodeGen/MachineModuleInfo.h

public:
   /// \brief Returns the MachineFunction associated to IR function \p F if there
   /// is one, otherwise nullptr.
   MachineFunction *getMachineFunction(const Function &F) const;
 
   /// Delete the MachineFunction \p MF and reset the link in the IR Function to
   /// Machine Function map.
   void deleteMachineFunctionFor(Function &F);
 
-  /// Keep track of various per-function pieces of information for backends
+  /// Keep track of various per-module pieces of information for backends
   /// that would like to do so.
   template<typename Ty>
   Ty &getObjFileInfo() {
     if (ObjFileMMI == nullptr)
       ObjFileMMI = new Ty(*this);
     return *static_cast<Ty*>(ObjFileMMI);
   }
 

llvm/include/llvm/CodeGen/MachineModuleInfoImpls.h

 // MachineModuleInfoImpl.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_CODEGEN_MACHINEMODULEINFOIMPLS_H
 #define LLVM_CODEGEN_MACHINEMODULEINFOIMPLS_H
 
 #include "llvm/ADT/DenseMap.h"
+#include "llvm/ADT/StringSet.h"
 #include "llvm/CodeGen/MachineModuleInfo.h"
 #include <cassert>
 
 namespace llvm {
 
 class MCSymbol;
 
 /// MachineModuleInfoMachO - This is a MachineModuleInfoImpl implementation
StubValueTy &getGVStubEntry(MCSymbol *Sym) {
     return GVStubs[Sym];
   }
 
   /// Accessor methods to return the set of stubs in sorted order.
 
   SymbolListTy GetGVStubList() { return getSortedStubs(GVStubs); }
 };
 
+/// MachineModuleInfoWasm - This is a MachineModuleInfoImpl implementation
+/// for Wasm targets.
+class MachineModuleInfoWasm : public MachineModuleInfoImpl {
+  virtual void anchor(); // Out of line virtual method.
+
+public:
+  MachineModuleInfoWasm(const MachineModuleInfo &) {}
+
+  StringSet<> MachineSymbolsUsed;
+};
+
 } // end namespace llvm
 
 #endif // LLVM_CODEGEN_MACHINEMODULEINFOIMPLS_H

llvm/include/llvm/MC/MCTargetOptions.h

enum AsmInstrumentation {
     AsmInstrumentationAddress
   };
 
   bool MCRelaxAll : 1;
   bool MCNoExecStack : 1;
   bool MCFatalWarnings : 1;
   bool MCNoWarn : 1;
   bool MCNoDeprecatedWarn : 1;
+  bool MCNoTypeCheck : 1;
   bool MCSaveTempLabels : 1;
   bool MCUseDwarfDirectory : 1;
   bool MCIncrementalLinkerCompatible : 1;
   bool ShowMCEncoding : 1;
   bool ShowMCInst : 1;
   bool AsmVerbose : 1;
 
   /// Preserve Comments in Assembly.

llvm/include/llvm/MC/MCTargetOptionsCommandFlags.h

 bool getShowMCInst();
 
 bool getFatalWarnings();
 
 bool getNoWarn();
 
 bool getNoDeprecatedWarn();
 
+bool getNoTypeCheck();
+
 std::string getABIName();
 
 /// Create this object with static storage to register mc-related command
 /// line options.
 struct RegisterMCTargetOptionsFlags {
   RegisterMCTargetOptionsFlags();
 };
 
 MCTargetOptions InitMCTargetOptionsFromFlags();
 
 } // namespace mc
 
 } // namespace llvm
 
 #endif

llvm/lib/CodeGen/MachineModuleInfoImpls.cpp

 //===----------------------------------------------------------------------===//
 // MachineModuleInfoMachO
 //===----------------------------------------------------------------------===//
 
 // Out of line virtual method.
 void MachineModuleInfoMachO::anchor() {}
 void MachineModuleInfoELF::anchor() {}
 void MachineModuleInfoCOFF::anchor() {}
+void MachineModuleInfoWasm::anchor() {}
 
 using PairTy = std::pair<MCSymbol *, MachineModuleInfoImpl::StubValueTy>;
 static int SortSymbolPair(const PairTy *LHS, const PairTy *RHS) {
   return LHS->first->getName().compare(RHS->first->getName());
 }
 
 MachineModuleInfoImpl::SymbolListTy MachineModuleInfoImpl::getSortedStubs(
     DenseMap<MCSymbol *, MachineModuleInfoImpl::StubValueTy> &Map) {
   MachineModuleInfoImpl::SymbolListTy List(Map.begin(), Map.end());
 
   array_pod_sort(List.begin(), List.end(), SortSymbolPair);
 
   Map.clear();
   return List;
 }

llvm/lib/MC/MCTargetOptions.cpp

 //===- lib/MC/MCTargetOptions.cpp - MC Target Options ---------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/MC/MCTargetOptions.h"
 #include "llvm/ADT/StringRef.h"
 
 using namespace llvm;
 
 MCTargetOptions::MCTargetOptions()
     : MCRelaxAll(false), MCNoExecStack(false), MCFatalWarnings(false),
-      MCNoWarn(false), MCNoDeprecatedWarn(false), MCSaveTempLabels(false),
+      MCNoWarn(false), MCNoDeprecatedWarn(false),
+      MCNoTypeCheck(false), MCSaveTempLabels(false),
       MCUseDwarfDirectory(false), MCIncrementalLinkerCompatible(false),
       ShowMCEncoding(false), ShowMCInst(false), AsmVerbose(false),
       PreserveAsmComments(true), Dwarf64(false) {}
 
 StringRef MCTargetOptions::getABIName() const {
   return ABIName;
 }
 
 StringRef MCTargetOptions::getAssemblyLanguage() const {
   return AssemblyLanguage;
 }

llvm/lib/MC/MCTargetOptionsCommandFlags.cpp

 MCOPT_EXP(bool, RelaxAll)
 MCOPT(bool, IncrementalLinkerCompatible)
 MCOPT(int, DwarfVersion)
 MCOPT(bool, Dwarf64)
 MCOPT(bool, ShowMCInst)
 MCOPT(bool, FatalWarnings)
 MCOPT(bool, NoWarn)
 MCOPT(bool, NoDeprecatedWarn)
+MCOPT(bool, NoTypeCheck)
 MCOPT(std::string, ABIName)
 
 llvm::mc::RegisterMCTargetOptionsFlags::RegisterMCTargetOptionsFlags() {
 #define MCBINDOPT(NAME)                                                        \
   do {                                                                         \
     NAME##View = std::addressof(NAME);                                         \
   } while (0)
 
#define MCBINDOPT(NAME)                                                        \
   static cl::alias NoWarnW("W", cl::desc("Alias for --no-warn"),
                            cl::aliasopt(NoWarn));
   MCBINDOPT(NoWarn);
 
   static cl::opt<bool> NoDeprecatedWarn(
       "no-deprecated-warn", cl::desc("Suppress all deprecated warnings"));
   MCBINDOPT(NoDeprecatedWarn);
 
+  static cl::opt<bool> NoTypeCheck(
+      "no-type-check", cl::desc("Suppress type errors (Wasm)"));
+  MCBINDOPT(NoTypeCheck);
+
   static cl::opt<std::string> ABIName(
       "target-abi", cl::Hidden,
       cl::desc("The name of the ABI to be targeted from the backend."),
       cl::init(""));
   MCBINDOPT(ABIName);
 
 #undef MCBINDOPT
 }
 
 MCTargetOptions llvm::mc::InitMCTargetOptionsFromFlags() {
   MCTargetOptions Options;
   Options.MCRelaxAll = getRelaxAll();
   Options.MCIncrementalLinkerCompatible = getIncrementalLinkerCompatible();
   Options.Dwarf64 = getDwarf64();
   Options.DwarfVersion = getDwarfVersion();
   Options.ShowMCInst = getShowMCInst();
   Options.ABIName = getABIName();
   Options.MCFatalWarnings = getFatalWarnings();
   Options.MCNoWarn = getNoWarn();
   Options.MCNoDeprecatedWarn = getNoDeprecatedWarn();
+  Options.MCNoTypeCheck = getNoTypeCheck();
   return Options;
 }

llvm/lib/Target/WebAssembly/AsmParser/WebAssemblyAsmParser.cpp

 #include "llvm/MC/MCParser/MCParsedAsmOperand.h"
 #include "llvm/MC/MCParser/MCTargetAsmParser.h"
 #include "llvm/MC/MCSectionWasm.h"
 #include "llvm/MC/MCStreamer.h"
 #include "llvm/MC/MCSubtargetInfo.h"
 #include "llvm/MC/MCSymbol.h"
 #include "llvm/MC/MCSymbolWasm.h"
 #include "llvm/Support/Endian.h"
+#include "llvm/Support/SourceMgr.h"
 #include "llvm/Support/TargetRegistry.h"
 
 using namespace llvm;
 
 #define DEBUG_TYPE "wasm-asm-parser"
 
 static const char *getSubtargetFeatureName(uint64_t Val);
+static StringRef GetMnemonic(unsigned Opc);
 
 namespace {
 
 /// WebAssemblyOperand - Instances of this class represent the operands in a
 /// parsed Wasm machine instruction.
 struct WebAssemblyOperand : public MCParsedAsmOperand {
   enum KindTy { Token, Integer, Float, Symbol, BrList } Kind;
 
enum NestingType {
     Block,
     Loop,
     Try,
     CatchAll,
     If,
     Else,
     Undefined,
   };
-  std::vector<NestingType> NestingStack;
+  struct Nested {
+    NestingType NT;
+    wasm::WasmSignature Sig;
+  };
+  std::vector<Nested> NestingStack;
+  wasm::WasmSignature LastSig;
 
   MCSymbolWasm *DefaultFunctionTable = nullptr;
   MCSymbol *LastFunctionLabel = nullptr;
 
+  bool is64 = false;
+
+  // Type Checker:
+  struct TypeStack {
+    SmallVector<wasm::ValType, 8> Stack;
+  };
+  TypeStack TS;
+  std::map<unsigned, TypeStack> TypedLabels;
+  std::vector<wasm::ValType> LocalTypes;
+  std::vector<wasm::ValType> ReturnTypes;
+  bool TypeErrorThisFunction = false;
+  bool SkipTypeCheck = false;
+
 public:
   WebAssemblyAsmParser(const MCSubtargetInfo &STI, MCAsmParser &Parser,
                        const MCInstrInfo &MII, const MCTargetOptions &Options)
       : MCTargetAsmParser(Options, STI, MII), Parser(Parser),
         Lexer(Parser.getLexer()) {
     setAvailableFeatures(ComputeAvailableFeatures(STI.getFeatureBits()));
+    is64 = getSTI().getTargetTriple().isArch64Bit();
+    // Don't type check if -no-type-check was set.
+    if (Options.MCNoTypeCheck)
+      SkipTypeCheck = true;
+    // Don't type check if this is inline asm, since that is a naked sequence of
+    // instructions without a function/locals decl.
+    auto &SM = Parser.getSourceManager();
+    auto BufferName =
+      SM.getBufferInfo(SM.getMainFileID()).Buffer->getBufferIdentifier();
+    if (BufferName == "<inline asm>")
+      SkipTypeCheck = true;
   }
 
   void Initialize(MCAsmParser &Parser) override {
     MCAsmParserExtension::Initialize(Parser);
 
     DefaultFunctionTable = GetOrCreateFunctionTableSymbol(
         getContext(), "__indirect_function_table");
     if (!STI->checkFeatures("+reference-types"))
case If:
       return {"if", "end_if"};
     case Else:
       return {"else", "end_if"};
     default:
       llvm_unreachable("unknown NestingType");
     }
   }
 
-  void push(NestingType NT) { NestingStack.push_back(NT); }
+  void push(NestingType NT) { NestingStack.push_back({NT}); }
 
   bool pop(StringRef Ins, NestingType NT1, NestingType NT2 = Undefined) {
     if (NestingStack.empty())
       return error(Twine("End of block construct with no start: ") + Ins);
     auto Top = NestingStack.back();
-    if (Top != NT1 && Top != NT2)
+    if (Top.NT != NT1 && Top.NT != NT2)
       return error(Twine("Block construct type mismatch, expected: ") +
-                   nestingString(Top).second + ", instead got: " + Ins);
+                   nestingString(Top.NT).second + ", instead got: " + Ins);
+    LastSig = Top.Sig;
     NestingStack.pop_back();
     return false;
   }
 
   bool ensureEmptyNestingStack() {
     auto Err = !NestingStack.empty();
     while (!NestingStack.empty()) {
       error(Twine("Unmatched block construct(s) at function end: ") +
-            nestingString(NestingStack.back()).first);
+            nestingString(NestingStack.back().NT).first);
       NestingStack.pop_back();
     }
     return Err;
   }
 
   bool isNext(AsmToken::TokenKind Kind) {
     auto Ok = Lexer.is(Kind);
     if (Ok)
if (IsLoadStore || IsAtomic) {
             WebAssemblyOperand::IntOp{-1}));
       }
     }
     return false;
   }
 
   void addBlockTypeOperand(OperandVector &Operands, SMLoc NameLoc,
                            WebAssembly::BlockType BT) {
+    if (BT != WebAssembly::BlockType::Void) {
+      wasm::WasmSignature Sig({static_cast<wasm::ValType>(BT)}, {});
+      LastSig = Sig;
+      NestingStack.back().Sig = Sig;
+    }
     Operands.push_back(std::make_unique<WebAssemblyOperand>(
         WebAssemblyOperand::Integer, NameLoc, NameLoc,
         WebAssemblyOperand::IntOp{static_cast<int64_t>(BT)}));
   }
 
   bool parseLimits(wasm::WasmLimits *Limits) {
     auto Tok = Lexer.getTok();
     if (!Tok.is(AsmToken::Integer))
if (ExpectFuncType || (ExpectBlockType && Lexer.is(AsmToken::LParen))) {
       // attach it to an anonymous symbol, which is what WasmObjectWriter
       // expects to be able to recreate the actual unique-ified type indices.
       auto Loc = Parser.getTok();
       auto Signature = std::make_unique<wasm::WasmSignature>();
       if (parseSignature(Signature.get()))
         return true;
       // Got signature as block type, don't need more
       ExpectBlockType = false;
+      LastSig = *Signature.get();
+      if (ExpectBlockType) NestingStack.back().Sig = LastSig;
       auto &Ctx = getContext();
       // The "true" here will cause this to be a nameless symbol.
       MCSymbol *Sym = Ctx.createTempSymbol("typeindex", true);
       auto *WasmSym = cast<MCSymbolWasm>(Sym);
       WasmSym->setSignature(Signature.get());
       addSignature(std::move(Signature));
       WasmSym->setType(wasm::WASM_SYMBOL_TYPE_FUNCTION);
       const MCExpr *Expr = MCSymbolRefExpr::create(
if (DirectiveID.getString() == ".functype") {
           return true;
         CurrentState = FunctionStart;
         LastFunctionLabel = WasmSym;
         push(Function);
       }
       auto Signature = std::make_unique<wasm::WasmSignature>();
       if (parseSignature(Signature.get()))
         return true;
+      LocalTypes.assign(Signature->Params.begin(), Signature->Params.end());
+      ReturnTypes.assign(Signature->Returns.begin(), Signature->Returns.end());
       WasmSym->setSignature(Signature.get());
       addSignature(std::move(Signature));
       WasmSym->setType(wasm::WASM_SYMBOL_TYPE_FUNCTION);
       TOut.emitFunctionType(WasmSym);
       // TODO: backend also calls TOut.emitIndIdx, but that is not implemented.
       return expect(AsmToken::EndOfStatement, "EOL");
     }
 
bool ParseDirective(AsmToken DirectiveID) override {
 
     if (DirectiveID.getString() == ".local") {
       if (CurrentState != FunctionStart)
         return error(".local directive should follow the start of a function: ",
                      Lexer.getTok());
       SmallVector<wasm::ValType, 4> Locals;
       if (parseRegTypeList(Locals))
         return true;
+      LocalTypes.insert(LocalTypes.end(), Locals.begin(), Locals.end());
       TOut.emitLocal(Locals);
       CurrentState = FunctionLocals;
       return expect(AsmToken::EndOfStatement, "EOL");
     }
 
     if (DirectiveID.getString() == ".int8" ||
         DirectiveID.getString() == ".int16" ||
         DirectiveID.getString() == ".int32" ||
if (CurrentState == FunctionStart) {
       // locals here.
       auto &TOut = reinterpret_cast<WebAssemblyTargetStreamer &>(
           *Out.getTargetStreamer());
       TOut.emitLocal(SmallVector<wasm::ValType, 0>());
       CurrentState = FunctionLocals;
     }
   }
 
+  void DumpTypeStack(Twine Msg) {
+    LLVM_DEBUG({
+      std::string s;
+      for (auto VT : TS.Stack) {
+        s += WebAssembly::typeToString(VT);
+        s += " ";
+      }
+      dbgs() << Msg << s << '\n';
+    });
+  }
+
+  bool TypeError(SMLoc ErrorLoc, const Twine &Msg) {
+    // Once you get one type error in a function, it will likely trigger more
+    // which are mostly not helpful.
+    if (TypeErrorThisFunction)
+      return true;
+    TypeErrorThisFunction = true;
+    DumpTypeStack("current stack: ");
+    return Parser.Error(ErrorLoc, Msg);
+  }
+
+  bool PopType(SMLoc ErrorLoc, Optional<wasm::ValType> EVT) {
+    if (TS.Stack.empty()) {
+      return TypeError(ErrorLoc,
+                       EVT.hasValue()
+                           ? StringRef("empty stack while popping ") +
+                                 WebAssembly::typeToString(EVT.getValue())
+                           : StringRef(
+                                     "empty stack while popping value"));
+    }
+    auto PVT = TS.Stack.back();
+    TS.Stack.pop_back();
+    if (EVT.hasValue() && EVT.getValue() != PVT) {
+      return TypeError(
+          ErrorLoc, StringRef("popped ") + WebAssembly::typeToString(PVT) +
+                                     ", expected " +
+                                     WebAssembly::typeToString(EVT.getValue()));
+    }
+    return false;
+  }
+
+  bool GetLocal(SMLoc ErrorLoc, const MCInst &Inst, wasm::ValType &Type) {
+    auto Local = Inst.getOperand(0).getImm();
+    if (static_cast<size_t>(Local) > LocalTypes.size())
+      return TypeError(ErrorLoc, StringRef("no local type specified for index ") +
+                           std::to_string(Local));
+    Type = LocalTypes[Local];
+    return false;
+  }
+
+  bool CheckEnd(SMLoc ErrorLoc) {
+    if (LastSig.Returns.size() > TS.Stack.size())
+      return TypeError(ErrorLoc, "end: insufficient values on the type stack");
+    for (size_t i = 0; i < LastSig.Returns.size(); i++) {
+      auto EVT = LastSig.Returns[i];
+      auto PVT = TS.Stack[TS.Stack.size() - LastSig.Returns.size() + i];
+      if (PVT != EVT)
+        return TypeError(
+            ErrorLoc, StringRef("end got ") + WebAssembly::typeToString(PVT) +
+                          ", expected " + WebAssembly::typeToString(EVT));
+    }
+    return false;
+  }
+
+  bool CheckSig(SMLoc ErrorLoc, const wasm::WasmSignature& Sig) {
+    for (auto VT : llvm::reverse(Sig.Params))
+      if (PopType(ErrorLoc, VT)) return true;
+    TS.Stack.insert(TS.Stack.end(), Sig.Returns.begin(), Sig.Returns.end());
+    return false;
+  }
+
+  bool GetSymRef(SMLoc ErrorLoc, const MCInst &Inst,
+                  const MCSymbolRefExpr *&SymRef) {
+    auto Op = Inst.getOperand(0);
+    if (!Op.isExpr())
+      return TypeError(ErrorLoc, StringRef("expected expression operand"));
+    SymRef = dyn_cast<MCSymbolRefExpr>(Op.getExpr());
+    if (!SymRef)
+      return TypeError(ErrorLoc, StringRef("expected symbol operand"));
+    return false;
+  }
+
+  bool GetGlobal(SMLoc ErrorLoc, const MCInst &Inst, wasm::ValType &Type) {
+    const MCSymbolRefExpr *SymRef;
+    if (GetSymRef(ErrorLoc, Inst, SymRef))
+      return true;
+    auto WasmSym = cast<MCSymbolWasm>(&SymRef->getSymbol());
+    switch (WasmSym->getType().getValueOr(wasm::WASM_SYMBOL_TYPE_DATA)) {
+    case wasm::WASM_SYMBOL_TYPE_GLOBAL:
+      Type = static_cast<wasm::ValType>(WasmSym->getGlobalType().Type);
+      break;
+    case wasm::WASM_SYMBOL_TYPE_FUNCTION:
+    case wasm::WASM_SYMBOL_TYPE_DATA:
+      if (SymRef->getKind() == MCSymbolRefExpr::VK_GOT) {
+        Type = is64 ? wasm::ValType::I64 : wasm::ValType::I32;
+        break;
+      }
+      // FALL-THROUGH:
+    default:
+      return TypeError(ErrorLoc, StringRef("symbol ") + WasmSym->getName() +
+                                     " missing .globaltype");
+    }
+    return false;
+  }
+
+  bool TypeCheck(SMLoc ErrorLoc, const MCInst &Inst) {
+    auto Opc = Inst.getOpcode();
+    auto Name = GetMnemonic(Opc);
+    DumpTypeStack("typechecking " + Name + ": ");
+    wasm::ValType Type;
+    if (Name == "local.get") {
+      if (GetLocal(ErrorLoc, Inst, Type))
+        return true;
+      TS.Stack.push_back(Type);
+    } else if (Name == "local.set") {
+      if (GetLocal(ErrorLoc, Inst, Type))
+        return true;
+      if (PopType(ErrorLoc, Type))
+        return true;
+    } else if (Name == "local.tee") {
+      if (GetLocal(ErrorLoc, Inst, Type))
+        return true;
+      if (PopType(ErrorLoc, Type))
+        return true;
+      TS.Stack.push_back(Type);
+    } else if (Name == "global.get") {
+      if (GetGlobal(ErrorLoc, Inst, Type))
+        return true;
+      TS.Stack.push_back(Type);
+    } else if (Name == "global.set") {
+      if (GetGlobal(ErrorLoc, Inst, Type))
+        return true;
+      if (PopType(ErrorLoc, Type))
+        return true;
+    } else if (Name == "drop") {
+      if (PopType(ErrorLoc, {}))
+        return true;
+    } else if (Name == "end_block" || Name == "end_loop" || Name == "end_if" ||
+               Name == "else") {
+      if (CheckEnd(ErrorLoc))
+        return true;
+    } else if (Name == "call_indirect" || Name == "return_call_indirect") {
+      // Function value.
+      if (PopType(ErrorLoc, wasm::ValType::I32)) return true;
+      if (CheckSig(ErrorLoc, LastSig)) return true;
+    } else if (Name == "call" || Name == "return_call") {
+      const MCSymbolRefExpr *SymRef;
+      if (GetSymRef(ErrorLoc, Inst, SymRef))
+        return true;
+      auto WasmSym = cast<MCSymbolWasm>(&SymRef->getSymbol());
+      auto Sig = WasmSym->getSignature();
+      if (!Sig || WasmSym->getType() != wasm::WASM_SYMBOL_TYPE_FUNCTION)
+        return TypeError(ErrorLoc, StringRef("symbol ") + WasmSym->getName() +
+                                       " missing .functype");
+      if (CheckSig(ErrorLoc, *Sig)) return true;
+    } else if (Name == "ref.null") {
+      auto VT = static_cast<wasm::ValType>(Inst.getOperand(0).getImm());
+      TS.Stack.push_back(VT);
+    } else {
+      // The current instruction is a stack instruction which doesn't have
+      // explicit operands that indicate push/pop types, so we get those from
+      // the register version of the same instruction.
+      auto RegOpc = WebAssembly::getRegisterOpcode(Opc);
+      assert(RegOpc != -1 && "Failed to get register version of MC instruction");
+      const auto &II = MII.get(RegOpc);
+      // First pop all the uses off the stack and check them.
+      for (unsigned I = II.getNumOperands(); I > II.getNumDefs(); I--) {
+        const auto &Op = II.OpInfo[I - 1];
+        if (Op.OperandType == MCOI::OPERAND_REGISTER) {
+          auto VT = WebAssembly::regClassToValType(Op.RegClass);
+          if (PopType(ErrorLoc, VT))
+            return true;
+        }
+      }
+      // Now push all the defs onto the stack.
+      for (unsigned I = 0; I < II.getNumDefs(); I++) {
+        const auto &Op = II.OpInfo[I];
+        assert(Op.OperandType == MCOI::OPERAND_REGISTER && "Register expected");
+        auto VT = WebAssembly::regClassToValType(Op.RegClass);
+        TS.Stack.push_back(VT);
+      }
+    }
+    return false;
+  }
+
   bool MatchAndEmitInstruction(SMLoc IDLoc, unsigned & /*Opcode*/,
                                OperandVector &Operands, MCStreamer &Out,
                                uint64_t &ErrorInfo,
                                bool MatchingInlineAsm) override {
     MCInst Inst;
     Inst.setLoc(IDLoc);
     FeatureBitset MissingFeatures;
     unsigned MatchResult = MatchInstructionImpl(
         Operands, Inst, ErrorInfo, MissingFeatures, MatchingInlineAsm);
     switch (MatchResult) {
     case Match_Success: {
       ensureLocals(Out);
       // Fix unknown p2align operands.
       auto Align = WebAssembly::GetDefaultP2AlignAny(Inst.getOpcode());
       if (Align != -1U) {
         auto &Op0 = Inst.getOperand(0);
         if (Op0.getImm() == -1)
           Op0.setImm(Align);
       }
-      if (getSTI().getTargetTriple().isArch64Bit()) {
+      if (is64) {
         // Upgrade 32-bit loads/stores to 64-bit. These mostly differ by having
         // an offset64 arg instead of offset32, but to the assembler matcher
         // they're both immediates so don't get selected for.
         auto Opc64 = WebAssembly::getWasm64Opcode(
             static_cast<uint16_t>(Inst.getOpcode()));
         if (Opc64 >= 0) {
           Inst.setOpcode(Opc64);
         }
       }
+      if (!SkipTypeCheck && TypeCheck(IDLoc, Inst))
+        return true;
       Out.emitInstruction(Inst, getSTI());
       if (CurrentState == EndFunction) {
-        onEndOfFunction();
+        onEndOfFunction(IDLoc);
       } else {
         CurrentState = Instructions;
       }
       return false;
     }
     case Match_MissingFeature: {
       assert(MissingFeatures.count() > 0 && "Expected missing features");
       SmallString<128> Message;
auto *WS =
         getContext().getWasmSection(SecName, SectionKind::getText(), 0, Group,
                                     MCContext::GenericSectionID, nullptr);
     getStreamer().SwitchSection(WS);
     // Also generate DWARF for this section if requested.
     if (getContext().getGenDwarfForAssembly())
       getContext().addGenDwarfSection(WS);
   }
 
-  void onEndOfFunction() {
+  void onEndOfFunction(SMLoc ErrorLoc) {
+    // Check the return types.
+    for (auto RVT : llvm::reverse(ReturnTypes)) {
+      PopType(ErrorLoc, RVT);
+    }
+    if (!TS.Stack.empty()) {
+      TypeError(ErrorLoc,
+                   std::to_string(TS.Stack.size()) +
+                       " superfluous return values");
+    }
+    // Reset the type checker state.
+    TS.Stack.clear();
+    TypedLabels.clear();
+    LocalTypes.clear();
+    ReturnTypes.clear();
+    TypeErrorThisFunction = false;
     // Automatically output a .size directive, so it becomes optional for the
     // user.
     if (!LastFunctionLabel) return;
     auto TempSym = getContext().createLinkerPrivateTempSymbol();
     getStreamer().emitLabel(TempSym);
     auto Start = MCSymbolRefExpr::create(LastFunctionLabel, getContext());
     auto End = MCSymbolRefExpr::create(TempSym, getContext());
     auto Expr =
extern "C" LLVM_EXTERNAL_VISIBILITY void LLVMInitializeWebAssemblyAsmParser() {
   RegisterMCAsmParser<WebAssemblyAsmParser> X(getTheWebAssemblyTarget32());
   RegisterMCAsmParser<WebAssemblyAsmParser> Y(getTheWebAssemblyTarget64());
 }
 
 #define GET_REGISTER_MATCHER
 #define GET_SUBTARGET_FEATURE_NAME
 #define GET_MATCHER_IMPLEMENTATION
 #include "WebAssemblyGenAsmMatcher.inc"
+
+static StringRef GetMnemonic(unsigned Opc) {
+  // FIXME: linear search!
+  for (auto &ME : MatchTable0) {
+    if (ME.Opcode == Opc) {
+      return ME.getMnemonic();
+    }
+  }
+  assert(false && "mnemonic not found");
+  return StringRef();
+}

llvm/lib/Target/WebAssembly/CMakeLists.txt

add_llvm_target(WebAssemblyCodeGen
   WebAssemblyISelDAGToDAG.cpp
   WebAssemblyISelLowering.cpp
   WebAssemblyInstrInfo.cpp
   WebAssemblyLowerBrUnless.cpp
   WebAssemblyLowerEmscriptenEHSjLj.cpp
   WebAssemblyLowerGlobalDtors.cpp
   WebAssemblyMachineFunctionInfo.cpp
   WebAssemblyMCInstLower.cpp
+  WebAssemblyMCLowerPrePass.cpp
   WebAssemblyOptimizeLiveIntervals.cpp
   WebAssemblyOptimizeReturned.cpp
   WebAssemblyPeephole.cpp
   WebAssemblyPrepareForLiveIntervals.cpp
   WebAssemblyRegisterInfo.cpp
   WebAssemblyRegColoring.cpp
   WebAssemblyRegNumbering.cpp
   WebAssemblyRegStackify.cpp

llvm/lib/Target/WebAssembly/TargetInfo/WebAssemblyTargetInfo.h

 class Target;
 
 Target &getTheWebAssemblyTarget32();
 Target &getTheWebAssemblyTarget64();
 
 namespace WebAssembly {
 
 int getStackOpcode(unsigned short Opcode);
+int getRegisterOpcode(unsigned short Opcode);
 int getWasm64Opcode(unsigned short Opcode);
 
 } // namespace WebAssembly
 
 } // namespace llvm
 
 #endif // LLVM_LIB_TARGET_WEBASSEMBLY_TARGETINFO_WEBASSEMBLYTARGETINFO_H

llvm/lib/Target/WebAssembly/Utils/WebAssemblyTypeUtilities.h

 // Convert a wasm signature into a string in the format of
 // "(params) -> (results)", where params and results are a string of ValType
 // lists.
 std::string signatureToString(const wasm::WasmSignature *Sig);
 
 // Convert a MVT into its corresponding wasm ValType.
 wasm::ValType toValType(MVT Type);
 
+// Convert a register class to a wasm ValType.
+wasm::ValType regClassToValType(unsigned RC);
+
 } // end namespace WebAssembly
 } // end namespace llvm
 
 #endif

llvm/lib/Target/WebAssembly/Utils/WebAssemblyTypeUtilities.cpp

 //===-- WebAssemblyTypeUtilities.cpp - WebAssembly Type Utility Functions -===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 ///
 /// \file
 /// This file implements several utility functions for WebAssembly type parsing.
 ///
 //===----------------------------------------------------------------------===//
 
 #include "WebAssemblyTypeUtilities.h"
 #include "llvm/ADT/StringSwitch.h"
 
+// Get register classes enum.
+#define GET_REGINFO_ENUM
+#include "WebAssemblyGenRegisterInfo.inc"
+
 using namespace llvm;
 
 Optional<wasm::ValType> WebAssembly::parseType(StringRef Type) {
   // FIXME: can't use StringSwitch because wasm::ValType doesn't have a
   // "invalid" value.
   if (Type == "i32")
     return wasm::ValType::I32;
   if (Type == "i64")
wasm::ValType WebAssembly::toValType(MVT Type) {
   case MVT::funcref:
     return wasm::ValType::FUNCREF;
   case MVT::externref:
     return wasm::ValType::EXTERNREF;
   default:
     llvm_unreachable("unexpected type");
   }
 }
+
+wasm::ValType WebAssembly::regClassToValType(unsigned RC) {
+  switch (RC) {
+  case WebAssembly::I32RegClassID:
+    return wasm::ValType::I32;
+  case WebAssembly::I64RegClassID:
+    return wasm::ValType::I64;
+  case WebAssembly::F32RegClassID:
+    return wasm::ValType::F32;
+  case WebAssembly::F64RegClassID:
+    return wasm::ValType::F64;
+  case WebAssembly::V128RegClassID:
+    return wasm::ValType::V128;
+  case WebAssembly::FUNCREFRegClassID:
+    return wasm::ValType::FUNCREF;
+  case WebAssembly::EXTERNREFRegClassID:
+    return wasm::ValType::EXTERNREF;
+  default:
+    llvm_unreachable("unexpected type");
+  }
+}

llvm/lib/Target/WebAssembly/WebAssembly.h

 FunctionPass *createWebAssemblyLateEHPrepare();
 FunctionPass *createWebAssemblyCFGSort();
 FunctionPass *createWebAssemblyCFGStackify();
 FunctionPass *createWebAssemblyExplicitLocals();
 FunctionPass *createWebAssemblyLowerBrUnless();
 FunctionPass *createWebAssemblyRegNumbering();
 FunctionPass *createWebAssemblyDebugFixup();
 FunctionPass *createWebAssemblyPeephole();
+FunctionPass *createWebAssemblyMCLowerPrePass();
 
 // PassRegistry initialization declarations.
 void initializeWebAssemblyAddMissingPrototypesPass(PassRegistry &);
 void initializeWebAssemblyLowerEmscriptenEHSjLjPass(PassRegistry &);
 void initializeLowerGlobalDtorsPass(PassRegistry &);
 void initializeFixFunctionBitcastsPass(PassRegistry &);
 void initializeOptimizeReturnedPass(PassRegistry &);
 void initializeWebAssemblyArgumentMovePass(PassRegistry &);

 void initializeWebAssemblyExceptionInfoPass(PassRegistry &);
 void initializeWebAssemblyCFGSortPass(PassRegistry &);
 void initializeWebAssemblyCFGStackifyPass(PassRegistry &);
 void initializeWebAssemblyExplicitLocalsPass(PassRegistry &);
 void initializeWebAssemblyLowerBrUnlessPass(PassRegistry &);
 void initializeWebAssemblyRegNumberingPass(PassRegistry &);
 void initializeWebAssemblyDebugFixupPass(PassRegistry &);
 void initializeWebAssemblyPeepholePass(PassRegistry &);
+void initializeWebAssemblyMCLowerPrePassPass(PassRegistry &);
 
 namespace WebAssembly {
 enum TargetIndex {
   // Followed by a local index (ULEB).
   TI_LOCAL,
   // Followed by an absolute global index (ULEB). DEPRECATED.
   TI_GLOBAL_FIXED,
   // Followed by the index from the bottom of the Wasm stack.

llvm/lib/Target/WebAssembly/WebAssemblyAsmPrinter.h

 
 class LLVM_LIBRARY_VISIBILITY WebAssemblyAsmPrinter final : public AsmPrinter {
   const WebAssemblySubtarget *Subtarget;
   const MachineRegisterInfo *MRI;
   WebAssemblyFunctionInfo *MFI;
   // TODO: Do the uniquing of Signatures here instead of ObjectFileWriter?
   std::vector<std::unique_ptr<wasm::WasmSignature>> Signatures;
   std::vector<std::unique_ptr<std::string>> Names;
+  bool signaturesEmitted = false;
 
   StringRef storeName(StringRef Name) {
     std::unique_ptr<std::string> N = std::make_unique<std::string>(Name);
     Names.push_back(std::move(N));
     return *Names.back();
   }
 
 public:
public:
   //===------------------------------------------------------------------===//
 
   void emitEndOfAsmFile(Module &M) override;
   void EmitProducerInfo(Module &M);
   void EmitTargetFeatures(Module &M);
   void emitGlobalVariable(const GlobalVariable *GV) override;
   void emitJumpTableInfo() override;
   void emitConstantPool() override;
+  void emitLinkage(const GlobalValue *, MCSymbol *) const override;
   void emitFunctionBodyStart() override;
   void emitInstruction(const MachineInstr *MI) override;
   bool PrintAsmOperand(const MachineInstr *MI, unsigned OpNo,
                        const char *ExtraCode, raw_ostream &OS) override;
   bool PrintAsmMemoryOperand(const MachineInstr *MI, unsigned OpNo,
                              const char *ExtraCode, raw_ostream &OS) override;
 
   MVT getRegType(unsigned RegNo) const;
   std::string regToString(const MachineOperand &MO);
   WebAssemblyTargetStreamer *getTargetStreamer();
   MCSymbolWasm *getMCSymbolForFunction(const Function *F, bool EnableEmEH,
                                        wasm::WasmSignature *Sig,
                                        bool &InvokeDetected);
+  MCSymbol *SetWasmSymType(StringRef Name);
+  void emitExternalDecls(const Module &M);
 };
 
 } // end namespace llvm
 
 #endif

llvm/lib/Target/WebAssembly/WebAssemblyAsmPrinter.cpp

 #include "MCTargetDesc/WebAssemblyTargetStreamer.h"
 #include "TargetInfo/WebAssemblyTargetInfo.h"
 #include "Utils/WebAssemblyTypeUtilities.h"
 #include "Utils/WebAssemblyUtilities.h"
 #include "WebAssembly.h"
 #include "WebAssemblyMCInstLower.h"
 #include "WebAssemblyMachineFunctionInfo.h"
 #include "WebAssemblyRegisterInfo.h"
+#include "WebAssemblyRuntimeLibcallSignatures.h"
 #include "WebAssemblyTargetMachine.h"
 #include "llvm/ADT/SmallSet.h"
 #include "llvm/ADT/StringExtras.h"
 #include "llvm/BinaryFormat/Wasm.h"
 #include "llvm/CodeGen/Analysis.h"
 #include "llvm/CodeGen/AsmPrinter.h"
 #include "llvm/CodeGen/MachineConstantPool.h"
 #include "llvm/CodeGen/MachineInstr.h"
if (GV->hasInitializer()) {
     getTargetStreamer()->emitGlobalType(Sym);
     OutStreamer->emitLabel(Sym);
     // TODO: Actually emit the initializer value.  Otherwise the global has the
     // default value for its type (0, ref.null, etc).
     OutStreamer->AddBlankLine();
   }
 }
 
-void WebAssemblyAsmPrinter::emitEndOfAsmFile(Module &M) {
+MCSymbol *WebAssemblyAsmPrinter::SetWasmSymType(StringRef Name) {
+  auto *WasmSym = cast<MCSymbolWasm>(GetExternalSymbolSymbol(Name));
+  const WebAssemblySubtarget &Subtarget = getSubtarget();
+
+  // Except for certain known symbols, all symbols used by CodeGen are
+  // functions. It's OK to hardcode knowledge of specific symbols here; this
+  // method is precisely there for fetching the signatures of known
+  // Clang-provided symbols.
+  if (Name == "__stack_pointer" || Name == "__tls_base" ||
+      Name == "__memory_base" || Name == "__table_base" ||
+      Name == "__tls_size" || Name == "__tls_align") {
+    bool Mutable =
+        Name == "__stack_pointer" || Name == "__tls_base";
+    WasmSym->setType(wasm::WASM_SYMBOL_TYPE_GLOBAL);
+    WasmSym->setGlobalType(wasm::WasmGlobalType{
+        uint8_t(Subtarget.hasAddr64() ? wasm::WASM_TYPE_I64
+                                      : wasm::WASM_TYPE_I32),
+        Mutable});
+    return WasmSym;
+  }
+
+  SmallVector<wasm::ValType, 4> Returns;
+  SmallVector<wasm::ValType, 4> Params;
+  if (Name == "__cpp_exception") {
+    WasmSym->setType(wasm::WASM_SYMBOL_TYPE_EVENT);
+    // We can't confirm its signature index for now because there can be
+    // imported exceptions. Set it to be 0 for now.
+    WasmSym->setEventType(
+        {wasm::WASM_EVENT_ATTRIBUTE_EXCEPTION, /* SigIndex */ 0});
+    // We may have multiple C++ compilation units to be linked together, each of
+    // which defines the exception symbol. To resolve them, we declare them as
+    // weak.
+    WasmSym->setWeak(true);
+    WasmSym->setExternal(true);
+
+    // All C++ exceptions are assumed to have a single i32 (for wasm32) or i64
+    // (for wasm64) param type and void return type. The reaon is, all C++
+    // exception values are pointers, and to share the type section with
+    // functions, exceptions are assumed to have void return type.
+    Params.push_back(Subtarget.hasAddr64() ? wasm::ValType::I64
+                                           : wasm::ValType::I32);
+  } else { // Function symbols
+    WasmSym->setType(wasm::WASM_SYMBOL_TYPE_FUNCTION);
+    getLibcallSignature(Subtarget, Name, Returns, Params);
+  }
+  auto Signature = std::make_unique<wasm::WasmSignature>(std::move(Returns),
+                                                         std::move(Params));
+  WasmSym->setSignature(Signature.get());
+  addSignature(std::move(Signature));
+
+  return WasmSym;
+}
+
+void WebAssemblyAsmPrinter::emitExternalDecls(const Module &M) {
+  if (signaturesEmitted)
+    return;
+  signaturesEmitted = true;
+
+  // Normally symbols for globals get discovered as the MI gets lowered,
+  // but we need to know about them ahead of time.
+  // FIXME: this potentially causes SetWasmSymType to be run twice.
+  MachineModuleInfoWasm &MMIW = MMI->getObjFileInfo<MachineModuleInfoWasm>();
+  for (const auto &Name : MMIW.MachineSymbolsUsed) {
+    SetWasmSymType(Name.getKey());
+  }
+
   for (auto &It : OutContext.getSymbols()) {
     // Emit .globaltype, .eventtype, or .tabletype declarations.
     auto Sym = cast<MCSymbolWasm>(It.getValue());
     if (Sym->getType() == wasm::WASM_SYMBOL_TYPE_GLOBAL) {
       // .globaltype already handled by emitGlobalVariable for defined
       // variables; here we make sure the types of external wasm globals get
       // written to the file.
       if (Sym->isUndefined())
         getTargetStreamer()->emitGlobalType(Sym);
     } else if (Sym->getType() == wasm::WASM_SYMBOL_TYPE_EVENT)
       getTargetStreamer()->emitEventType(Sym);
     else if (Sym->getType() == wasm::WASM_SYMBOL_TYPE_TABLE)
       getTargetStreamer()->emitTableType(Sym);
   }
 
   DenseSet<MCSymbol *> InvokeSymbols;
-  bool HasAddressTakenFunction = false;
   for (const auto &F : M) {
     if (F.isIntrinsic())
       continue;
 
-    if (F.hasAddressTaken())
-      HasAddressTakenFunction = true;
-
     // Emit function type info for all undefined functions
     if (F.isDeclarationForLinker()) {
       SmallVector<MVT, 4> Results;
       SmallVector<MVT, 4> Params;
       computeSignatureVTs(F.getFunctionType(), &F, F, TM, Params, Results);
       // At this point these MCSymbols may or may not have been created already
       // and thus also contain a signature, but we need to get the signature
       // anyway here in case it is an invoke that has not yet been created. We
for (const auto &F : M) {
 
     if (F.hasFnAttribute("wasm-export-name")) {
       auto *Sym = cast<MCSymbolWasm>(getSymbol(&F));
       StringRef Name = F.getFnAttribute("wasm-export-name").getValueAsString();
       Sym->setExportName(storeName(Name));
       getTargetStreamer()->emitExportName(Sym, Name);
     }
   }
+}
+  
+void WebAssemblyAsmPrinter::emitEndOfAsmFile(Module &M) {
+  emitExternalDecls(M);
 
   // When a function's address is taken, a TABLE_INDEX relocation is emitted
   // against the function symbol at the use site.  However the relocation
   // doesn't explicitly refer to the table.  In the future we may want to
   // define a new kind of reloc against both the function and the table, so
   // that the linker can see that the function symbol keeps the table alive,
   // but for now manually mark the table as live.
-  if (HasAddressTakenFunction) {
+  for (const auto &F : M) {
+    if (F.hasAddressTaken()) {
       MCSymbolWasm *FunctionTable =
           WebAssembly::getOrCreateFunctionTableSymbol(OutContext, Subtarget);
-    OutStreamer->emitSymbolAttribute(FunctionTable, MCSA_NoDeadStrip);
+      OutStreamer->emitSymbolAttribute(FunctionTable, MCSA_NoDeadStrip);    
+      break;
+    }
   }
 
   for (const auto &G : M.globals()) {
+    auto S = G.getName();
     if (!G.hasInitializer() && G.hasExternalLinkage() &&
         !WebAssembly::isWasmVarAddressSpace(G.getAddressSpace()) &&
         G.getValueType()->isSized()) {
       uint16_t Size = M.getDataLayout().getTypeAllocSize(G.getValueType());
       OutStreamer->emitELFSize(getSymbol(&G),
                                MCConstantExpr::create(Size, OutContext));
     }
   }
void WebAssemblyAsmPrinter::emitConstantPool() {
   assert(MF->getConstantPool()->getConstants().empty() &&
          "WebAssembly disables constant pools");
 }
 
 void WebAssemblyAsmPrinter::emitJumpTableInfo() {
   // Nothing to do; jump tables are incorporated into the instruction stream.
 }
 
+void WebAssemblyAsmPrinter::emitLinkage(const GlobalValue *GV, MCSymbol *Sym)
+  const {
+  AsmPrinter::emitLinkage(GV, Sym);
+  // This gets called before the function label and type are emitted.
+  // We use it to emit signatures of external functions.
+  // FIXME casts!
+  ((WebAssemblyAsmPrinter *)this)->emitExternalDecls(*MMI->getModule());
+}
+
+
 void WebAssemblyAsmPrinter::emitFunctionBodyStart() {
   const Function &F = MF->getFunction();
   SmallVector<MVT, 1> ResultVTs;
   SmallVector<MVT, 4> ParamVTs;
   computeSignatureVTs(F.getFunctionType(), &F, F, TM, ParamVTs, ResultVTs);
 
   auto Signature = signatureFromMVTs(ResultVTs, ParamVTs);
   auto *WasmSym = cast<MCSymbolWasm>(CurrentFnSym);

llvm/lib/Target/WebAssembly/WebAssemblyInstrFormats.td

 /// WebAssembly instruction format definitions.
 ///
 //===----------------------------------------------------------------------===//
 
 // WebAssembly Instruction Format.
 // We instantiate 2 of these for every actual instruction (register based
 // and stack based), see below.
 class WebAssemblyInst<bits<32> inst, string asmstr, string stack, string is64>
-  : StackRel, Wasm64Rel, Instruction {
+  : StackRel, RegisterRel, Wasm64Rel, Instruction {
   bits<32> Inst = inst; // Instruction encoding.
   string StackBased = stack;
   string BaseName = NAME;
   string IsWasm64 = is64;
   string Wasm32Name = !subst("_A64", "_A32", NAME);
   let Namespace   = "WebAssembly";
   let Pattern     = [];
   let AsmString   = asmstr;

llvm/lib/Target/WebAssembly/WebAssemblyInstrInfo.td

def getStackOpcode : InstrMapping {
   let FilterClass = "StackRel";
   let RowFields = ["BaseName"];
   let ColFields = ["StackBased"];
   let KeyCol = ["false"];
   let ValueCols = [["true"]];
 }
 
 //===----------------------------------------------------------------------===//
+// WebAssembly Stack to Register instruction mapping
+//===----------------------------------------------------------------------===//
+
+class RegisterRel;
+def getRegisterOpcode : InstrMapping {
+  let FilterClass = "RegisterRel";
+  let RowFields = ["BaseName"];
+  let ColFields = ["StackBased"];
+  let KeyCol = ["true"];
+  let ValueCols = [["false"]];
+}
+
+//===----------------------------------------------------------------------===//
 // WebAssembly 32 to 64-bit instruction mapping
 //===----------------------------------------------------------------------===//
 
 class Wasm64Rel;
 def getWasm64Opcode : InstrMapping {
   let FilterClass = "Wasm64Rel";
   let RowFields = ["Wasm32Name"];
   let ColFields = ["IsWasm64"];

llvm/lib/Target/WebAssembly/WebAssemblyInstrTable.td

 // WebAssemblyInstrTable.td - WebAssembly Table codegen support -*- tablegen -*-
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 ///
 /// \file
 /// WebAssembly Table operand code-gen constructs.
 /// Instructions that handle tables
 //===----------------------------------------------------------------------===//
 
 
 multiclass TABLE<WebAssemblyRegClass rt> {
-  defm TABLE_GET_#rt : I<(outs rt:$res), (ins table32_op:$table),
+  defm TABLE_GET_#rt : I<(outs rt:$res), (ins table32_op:$table, I32:$i),
                          (outs), (ins table32_op:$table),
                          [],
-                         "table.get\t$res, $table",
+                         "table.get\t$res, $table, $i",
                          "table.get\t$table",
                          0x25>;
 
   defm TABLE_SET_#rt : I<(outs), (ins table32_op:$table, I32:$i, rt:$val),
                          (outs), (ins table32_op:$table),
                          [],
                          "table.set\t$table, $i, $val",
                          "table.set\t$table",

llvm/lib/Target/WebAssembly/WebAssemblyMCInstLower.cpp

 //===----------------------------------------------------------------------===//
 
 #include "WebAssemblyMCInstLower.h"
 #include "TargetInfo/WebAssemblyTargetInfo.h"
 #include "Utils/WebAssemblyTypeUtilities.h"
 #include "Utils/WebAssemblyUtilities.h"
 #include "WebAssemblyAsmPrinter.h"
 #include "WebAssemblyMachineFunctionInfo.h"
-#include "WebAssemblyRuntimeLibcallSignatures.h"
 #include "llvm/CodeGen/AsmPrinter.h"
 #include "llvm/CodeGen/MachineFunction.h"
 #include "llvm/IR/Constants.h"
 #include "llvm/MC/MCAsmInfo.h"
 #include "llvm/MC/MCContext.h"
 #include "llvm/MC/MCExpr.h"
 #include "llvm/MC/MCInst.h"
 #include "llvm/MC/MCSymbolWasm.h"
WebAssemblyMCInstLower::GetGlobalAddressSymbol(const MachineOperand &MO) const {
   WasmSym->setSignature(Signature.get());
   Printer.addSignature(std::move(Signature));
   WasmSym->setType(wasm::WASM_SYMBOL_TYPE_FUNCTION);
   return WasmSym;
 }
 
 MCSymbol *WebAssemblyMCInstLower::GetExternalSymbolSymbol(
     const MachineOperand &MO) const {
-  const char *Name = MO.getSymbolName();
-  auto *WasmSym = cast<MCSymbolWasm>(Printer.GetExternalSymbolSymbol(Name));
-  const WebAssemblySubtarget &Subtarget = Printer.getSubtarget();
-
-  // Except for certain known symbols, all symbols used by CodeGen are
-  // functions. It's OK to hardcode knowledge of specific symbols here; this
-  // method is precisely there for fetching the signatures of known
-  // Clang-provided symbols.
-  if (strcmp(Name, "__stack_pointer") == 0 || strcmp(Name, "__tls_base") == 0 ||
-      strcmp(Name, "__memory_base") == 0 || strcmp(Name, "__table_base") == 0 ||
-      strcmp(Name, "__tls_size") == 0 || strcmp(Name, "__tls_align") == 0) {
-    bool Mutable =
-        strcmp(Name, "__stack_pointer") == 0 || strcmp(Name, "__tls_base") == 0;
-    WasmSym->setType(wasm::WASM_SYMBOL_TYPE_GLOBAL);
-    WasmSym->setGlobalType(wasm::WasmGlobalType{
-        uint8_t(Subtarget.hasAddr64() ? wasm::WASM_TYPE_I64
-                                      : wasm::WASM_TYPE_I32),
-        Mutable});
-    return WasmSym;
-  }
-
-  SmallVector<wasm::ValType, 4> Returns;
-  SmallVector<wasm::ValType, 4> Params;
-  if (strcmp(Name, "__cpp_exception") == 0) {
-    WasmSym->setType(wasm::WASM_SYMBOL_TYPE_EVENT);
-    // We can't confirm its signature index for now because there can be
-    // imported exceptions. Set it to be 0 for now.
-    WasmSym->setEventType(
-        {wasm::WASM_EVENT_ATTRIBUTE_EXCEPTION, /* SigIndex */ 0});
-    // We may have multiple C++ compilation units to be linked together, each of
-    // which defines the exception symbol. To resolve them, we declare them as
-    // weak.
-    WasmSym->setWeak(true);
-    WasmSym->setExternal(true);
-
-    // All C++ exceptions are assumed to have a single i32 (for wasm32) or i64
-    // (for wasm64) param type and void return type. The reaon is, all C++
-    // exception values are pointers, and to share the type section with
-    // functions, exceptions are assumed to have void return type.
-    Params.push_back(Subtarget.hasAddr64() ? wasm::ValType::I64
-                                           : wasm::ValType::I32);
-  } else { // Function symbols
-    WasmSym->setType(wasm::WASM_SYMBOL_TYPE_FUNCTION);
-    getLibcallSignature(Subtarget, Name, Returns, Params);
-  }
-  auto Signature =
-      std::make_unique<wasm::WasmSignature>(std::move(Returns), std::move(Params));
-  WasmSym->setSignature(Signature.get());
-  Printer.addSignature(std::move(Signature));
-
-  return WasmSym;
+  return Printer.SetWasmSymType(MO.getSymbolName());
 }
 
 MCOperand WebAssemblyMCInstLower::lowerSymbolOperand(const MachineOperand &MO,
                                                      MCSymbol *Sym) const {
   MCSymbolRefExpr::VariantKind Kind = MCSymbolRefExpr::VK_None;
   unsigned TargetFlags = MO.getTargetFlags();
 
   switch (TargetFlags) {

llvm/lib/Target/WebAssembly/WebAssemblyMCLowerPrePass.cpp

+//===-- WebAssemblyMCLowerPrePass.cpp - Prepare for MC lower --------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+///
+/// \file
+/// Some information in MC lowering / asm printing gets generated as
+/// instructions get emitted, but may be necessary at the start, such as for
+/// .globaltype declarations. This pass collects this information.
+///
+//===----------------------------------------------------------------------===//
+
+#include "MCTargetDesc/WebAssemblyMCTargetDesc.h"
+#include "Utils/WebAssemblyUtilities.h"
+#include "WebAssembly.h"
+#include "WebAssemblyMachineFunctionInfo.h"
+#include "WebAssemblySubtarget.h"
+#include "llvm/ADT/SCCIterator.h"
+#include "llvm/CodeGen/MachineFrameInfo.h"
+#include "llvm/CodeGen/MachineFunction.h"
+#include "llvm/CodeGen/MachineInstrBuilder.h"
+#include "llvm/CodeGen/MachineLoopInfo.h"
+#include "llvm/CodeGen/MachineModuleInfoImpls.h"
+#include "llvm/CodeGen/MachineRegisterInfo.h"
+#include "llvm/CodeGen/Passes.h"
+#include "llvm/Support/Debug.h"
+#include "llvm/Support/raw_ostream.h"
+using namespace llvm;
+
+#define DEBUG_TYPE "wasm-mclower-prepass"
+
+namespace {
+class WebAssemblyMCLowerPrePass final : public MachineFunctionPass {
+  StringRef getPassName() const override {
+    return "WebAssembly MC Lower Pre Pass";
+  }
+
+  void getAnalysisUsage(AnalysisUsage &AU) const override {
+    AU.setPreservesCFG();
+    MachineFunctionPass::getAnalysisUsage(AU);
+  }
+
+  bool runOnMachineFunction(MachineFunction &MF) override;
+
+public:
+  static char ID; // Pass identification, replacement for typeid
+  WebAssemblyMCLowerPrePass() : MachineFunctionPass(ID) {}
+};
+} // end anonymous namespace
+
+char WebAssemblyMCLowerPrePass::ID = 0;
+INITIALIZE_PASS(
+    WebAssemblyMCLowerPrePass, DEBUG_TYPE,
+    "Collects information ahead of time for MC lowering",
+    false, false)
+
+FunctionPass *llvm::createWebAssemblyMCLowerPrePass() {
+  return new WebAssemblyMCLowerPrePass();
+}
+
+bool WebAssemblyMCLowerPrePass::runOnMachineFunction(MachineFunction &MF) {
+  LLVM_DEBUG(dbgs() << "********** MC Lower Pre Pass **********\n"
+                       "********** Function: "
+                    << MF.getName() << '\n');
+
+  MachineModuleInfo &MMI = MF.getMMI();
+  MachineModuleInfoWasm &MMIW = MMI.getObjFileInfo<MachineModuleInfoWasm>();
+
+  for (MachineBasicBlock &MBB : MF) {
+    for (auto &MI : MBB) {
+      // FIXME: what should all be filtered out beyond these?
+      if (MI.isDebugInstr() || MI.isInlineAsm())
+        continue;
+      for (MachineOperand &MO : MI.uses()) {
+        if (MO.isSymbol()) {
+          MMIW.MachineSymbolsUsed.insert(MO.getSymbolName());
+        }
+      }
+    }
+  }
+
+  return true;
+}

llvm/lib/Target/WebAssembly/WebAssemblyRuntimeLibcallSignatures.h

 class WebAssemblySubtarget;
 
 extern void getLibcallSignature(const WebAssemblySubtarget &Subtarget,
                                 RTLIB::Libcall LC,
                                 SmallVectorImpl<wasm::ValType> &Rets,
                                 SmallVectorImpl<wasm::ValType> &Params);
 
 extern void getLibcallSignature(const WebAssemblySubtarget &Subtarget,
-                                const char *Name,
+                                StringRef Name,
                                 SmallVectorImpl<wasm::ValType> &Rets,
                                 SmallVectorImpl<wasm::ValType> &Params);
 
 } // end namespace llvm
 
 #endif

llvm/lib/Target/WebAssembly/WebAssemblyRuntimeLibcallSignatures.cpp

case unsupported:
     llvm_unreachable("unsupported runtime library signature");
   }
 }
 
 static ManagedStatic<StaticLibcallNameMap> LibcallNameMap;
 // TODO: If the RTLIB::Libcall-taking flavor of GetSignature remains unsed
 // other than here, just roll its logic into this version.
 void llvm::getLibcallSignature(const WebAssemblySubtarget &Subtarget,
-                               const char *Name,
+                               StringRef Name,
                                SmallVectorImpl<wasm::ValType> &Rets,
                                SmallVectorImpl<wasm::ValType> &Params) {
   auto &Map = LibcallNameMap->Map;
   auto Val = Map.find(Name);
 #ifndef NDEBUG
   if (Val == Map.end()) {
-    auto message = std::string("unexpected runtime library name: ") + Name;
+    auto message = std::string("unexpected runtime library name: ") +
+                   std::string(Name);
     llvm_unreachable(message.c_str());
   }
 #endif
   return getLibcallSignature(Subtarget, Val->second, Rets, Params);
 }

llvm/lib/Target/WebAssembly/WebAssemblyTargetMachine.cpp

extern "C" LLVM_EXTERNAL_VISIBILITY void LLVMInitializeWebAssemblyTarget() {
   initializeWebAssemblyExceptionInfoPass(PR);
   initializeWebAssemblyCFGSortPass(PR);
   initializeWebAssemblyCFGStackifyPass(PR);
   initializeWebAssemblyExplicitLocalsPass(PR);
   initializeWebAssemblyLowerBrUnlessPass(PR);
   initializeWebAssemblyRegNumberingPass(PR);
   initializeWebAssemblyDebugFixupPass(PR);
   initializeWebAssemblyPeepholePass(PR);
+  initializeWebAssemblyMCLowerPrePassPass(PR);
 }
 
 //===----------------------------------------------------------------------===//
 // WebAssembly Lowering public interface.
 //===----------------------------------------------------------------------===//
 
 static Reloc::Model getEffectiveRelocModel(Optional<Reloc::Model> RM,
                                            const Triple &TT) {
if (getOptLevel() != CodeGenOpt::None)
     addPass(createWebAssemblyPeephole());
 
   // Create a mapping from LLVM CodeGen virtual registers to wasm registers.
   addPass(createWebAssemblyRegNumbering());
 
   // Fix debug_values whose defs have been stackified.
   if (!WasmDisableExplicitLocals)
     addPass(createWebAssemblyDebugFixup());
+
+  // Collect information to prepare for MC lowering / asm printing.
+  addPass(createWebAssemblyMCLowerPrePass());
 }
 
 yaml::MachineFunctionInfo *
 WebAssemblyTargetMachine::createDefaultFuncInfoYAML() const {
   return new yaml::WebAssemblyFunctionInfo();
 }
 
 yaml::MachineFunctionInfo *WebAssemblyTargetMachine::convertFuncInfoToYAML(

llvm/test/CodeGen/WebAssembly/exception.ll

 ; RUN: llc < %s -asm-verbose=false -disable-wasm-fallthrough-return-opt -wasm-disable-explicit-locals -wasm-keep-registers -exception-model=wasm -mattr=+exception-handling -verify-machineinstrs | FileCheck --implicit-check-not=ehgcr -allow-deprecated-dag-overlap %s
 ; RUN: llc < %s -asm-verbose=false -disable-wasm-fallthrough-return-opt -wasm-disable-explicit-locals -wasm-keep-registers -exception-model=wasm -mattr=+exception-handling -verify-machineinstrs -O0
 ; RUN: llc < %s -disable-wasm-fallthrough-return-opt -wasm-keep-registers -exception-model=wasm -mattr=+exception-handling
 
 target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128"
 target triple = "wasm32-unknown-unknown"
 
 %struct.Temp = type { i8 }
 
 @_ZTIi = external dso_local constant i8*
 
+; CHECK: .eventtype  __cpp_exception i32
+
 ; CHECK-LABEL: test_throw:
 ; CHECK:     throw __cpp_exception, $0
 ; CHECK-NOT: unreachable
 define void @test_throw(i8* %p) {
   call void @llvm.wasm.throw(i32 0, i8* %p)
   ret void
 }
 

 declare void @__cxa_end_catch()
 declare void @_ZSt9terminatev()
 declare %struct.Temp* @_ZN4TempD2Ev(%struct.Temp* returned)
 
 attributes #0 = { nounwind }
 attributes #1 = { noreturn }
 
 ; CHECK: __cpp_exception:
-; CHECK: .eventtype  __cpp_exception i32

llvm/test/CodeGen/WebAssembly/global-get.ll

 ; CHECK: .globl f32_global
 ; CHECK: .globaltype f32_global, f32
 ; CHECK-LABEL: f32_global:
 
 ; CHECK: .globl f64_global
 ; CHECK: .globaltype f64_global, f64
 ; CHECK-LABEL: f64_global:
 
+; FIXME: are we still expecting these to be emitted?
+
 ; CHECK-NOT: .global i32_external_used
-; CHECK: .globaltype i32_external_used, i32
+; CHECK-NOT: .globaltype i32_external_used, i32
 ; CHECK-NOT: i32_external_used:
 
 ; CHECK-NOT: .global i32_external_unused
-; CHECK: .globaltype i32_external_unused, i32
+; CHECK-NOT: .globaltype i32_external_unused, i32
 ; CHECK-NOT: i32_external_unused:

llvm/test/CodeGen/WebAssembly/i128-returned.ll

 ; RUN: llc < %s -asm-verbose=false | FileCheck %s
 
 ; Test that the "returned" attribute works with i128 types.
 ; PR36128
 
 target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128"
 target triple = "wasm32-unknown-unknown"
 
 declare i128 @bar(i128 returned)
 
 define i128 @foo(i128) {
   %r = tail call i128 @bar(i128 %0)
   ret i128 %r
 }
 
+; CHECK: .functype bar (i32, i64, i64) -> ()
+
 ; CHECK-LABEL: foo:
 ; CHECK-NEXT: .functype foo (i32, i64, i64) -> ()
 
-; CHECK: .functype bar (i32, i64, i64) -> ()

llvm/test/CodeGen/WebAssembly/indirect-import.ll

 ; RUN: llc < %s -asm-verbose=false -disable-wasm-fallthrough-return-opt -wasm-keep-registers -verify-machineinstrs | FileCheck %s
 ; RUN: llc < %s -asm-verbose=false -disable-wasm-fallthrough-return-opt -wasm-keep-registers -verify-machineinstrs -fast-isel | FileCheck %s
 
 ; ModuleID = 'test/dot_s/indirect-import.c'
 source_filename = "test/dot_s/indirect-import.c"
 target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128"
 target triple = "wasm32"
 
+; CHECK: .functype extern_fd (f64) -> (f32)
+; CHECK: .functype extern_vj (i64) -> ()
+; CHECK: .functype extern_v () -> ()
+; CHECK: .functype extern_ijidf  (i64, i32, f64, f32) -> (i32)
+; CHECK: .functype extern_struct (i32) -> ()
+; CHECK: .functype extern_sret (i32) -> ()
+; CHECK: .functype extern_i128ret (i32, i64) -> ()
+
 %struct.big = type { float, double, i32 }
 
 ; Function Attrs: nounwind
 ; CHECK-LABEL: bar:
 define hidden i32 @bar() #0 {
 entry:
   %fd = alloca float (double)*, align 4
   %vj = alloca void (i64)*, align 4

 declare void @extern_sret(%struct.big* sret(%struct.big)) #1
 
 declare i128 @extern_i128ret(i64) #1
 
 attributes #0 = { nounwind "disable-tail-calls"="false" "less-precise-fpmad"="false" "frame-pointer"="none" "no-infs-fp-math"="false" "no-jump-tables"="false" "no-nans-fp-math"="false" "stack-protector-buffer-size"="8" "target-cpu"="generic" "unsafe-fp-math"="false" "use-soft-float"="false" }
 attributes #1 = { "disable-tail-calls"="false" "less-precise-fpmad"="false" "frame-pointer"="none" "no-infs-fp-math"="false" "no-nans-fp-math"="false" "stack-protector-buffer-size"="8" "target-cpu"="generic" "unsafe-fp-math"="false" "use-soft-float"="false" }
 
 
-; CHECK: .functype extern_fd (f64) -> (f32)
-; CHECK: .functype extern_vj (i64) -> ()
-; CHECK: .functype extern_v () -> ()
-; CHECK: .functype extern_ijidf  (i64, i32, f64, f32) -> (i32)
-; CHECK: .functype extern_struct (i32) -> ()
-; CHECK: .functype extern_sret (i32) -> ()
-; CHECK: .functype extern_i128ret (i32, i64) -> ()

llvm/test/CodeGen/WebAssembly/load-store-pic.ll

 ; RUN: llc < %s --mtriple=wasm32-unknown-emscripten -asm-verbose=false -relocation-model=pic -fast-isel -wasm-disable-explicit-locals -wasm-keep-registers | FileCheck %s -check-prefixes=PIC,CHECK -DPTR=i32
 ; RUN: llc < %s --mtriple=wasm32-unknown-emscripten -asm-verbose=false -relocation-model=pic -fast-isel=false -wasm-disable-explicit-locals -wasm-keep-registers | FileCheck %s -check-prefixes=PIC,CHECK -DPTR=i32
 ; RUN: llc < %s --mtriple=wasm64-unknown-emscripten -asm-verbose=false -relocation-model=pic -fast-isel -wasm-disable-explicit-locals -wasm-keep-registers | FileCheck %s -check-prefixes=PIC,CHECK -DPTR=i64
 ; RUN: llc < %s --mtriple=wasm64-unknown-emscripten -asm-verbose=false -relocation-model=pic -fast-isel=false -wasm-disable-explicit-locals -wasm-keep-registers | FileCheck %s -check-prefixes=PIC,CHECK -DPTR=i64
 
 ; Test that globals assemble as expected with -fPIC.
 ; We test here both with and without fast-isel.
 
 @hidden_global         = external hidden global i32
 @hidden_global_array   = external hidden global [10 x i32]
 @external_global       = external        global i32
 @external_global_array = external        global [10 x i32]
 
+; PIC: .globaltype __memory_base, [[PTR]]
+
 declare i32 @foo();
 
 ; For hidden symbols PIC code needs to offset all loads and stores
 ; by the value of the __memory_base global
 
 define i32 @load_hidden_global() {
 ; CHECK-LABEL: load_hidden_global:
 ; PIC:         global.get $push[[L0:[0-9]+]]=, __memory_base{{$}}

 ; PIC-NEXT:     i32.store 0($pop[[L2]]), $0{{$}}
 
 ; CHECK-NEXT:   end_function
 
   %1 = getelementptr [10 x i32], [10 x i32]* @external_global_array, i32 0, i32 5
   store i32 %n, i32* %1
   ret void
 }
-
-; PIC: .globaltype __memory_base, [[PTR]]

llvm/test/CodeGen/WebAssembly/lower-em-ehsjlj-options.ll

 ; RUN: llc < %s -enable-emscripten-cxx-exceptions | FileCheck %s --check-prefix=EH
 ; RUN: llc < %s -enable-emscripten-sjlj | FileCheck %s --check-prefix=SJLJ
 ; RUN: llc < %s | FileCheck %s --check-prefix=NONE
 ; RUN: not --crash llc < %s -enable-emscripten-cxx-exceptions -exception-model=wasm 2>&1 | FileCheck %s --check-prefix=WASM-EH-EM-EH
 
 target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128"
 target triple = "wasm32-unknown-unknown"
 
+; EH: .functype  invoke_vi (i32, i32) -> ()
+; EH: .import_module  invoke_vi, env
+; EH: .import_name  invoke_vi, invoke_vi
+; EH-NOT: .functype  __invoke_void_i32
+; EH-NOT: .import_module  __invoke_void_i32
+; EH-NOT: .import_name  __invoke_void_i32
+
+; SJLJ: .functype  emscripten_longjmp (i32, i32) -> ()
+; SJLJ: .import_module  emscripten_longjmp, env
+; SJLJ: .import_name  emscripten_longjmp, emscripten_longjmp
+; SJLJ-NOT: .functype  emscripten_longjmp_jmpbuf
+; SJLJ-NOT: .import_module  emscripten_longjmp_jmpbuf
+; SJLJ-NOT: .import_name  emscripten_longjmp_jmpbuf
+
 %struct.__jmp_buf_tag = type { [6 x i32], i32, [32 x i32] }
 
 define void @exception() personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*) {
 ; EH-LABEL:   type exception,@function
 ; NONE-LABEL: type exception,@function
 entry:
   invoke void @foo(i32 3)
           to label %invoke.cont unwind label %lpad

 declare void @longjmp(%struct.__jmp_buf_tag*, i32) #1
 declare i8* @malloc(i32)
 declare void @free(i8*)
 
 attributes #0 = { returns_twice }
 attributes #1 = { noreturn }
 attributes #2 = { nounwind }
 
-; EH: .functype  invoke_vi (i32, i32) -> ()
-; EH: .import_module  invoke_vi, env
-; EH: .import_name  invoke_vi, invoke_vi
-; EH-NOT: .functype  __invoke_void_i32
-; EH-NOT: .import_module  __invoke_void_i32
-; EH-NOT: .import_name  __invoke_void_i32
-
-; SJLJ: .functype  emscripten_longjmp (i32, i32) -> ()
-; SJLJ: .import_module  emscripten_longjmp, env
-; SJLJ: .import_name  emscripten_longjmp, emscripten_longjmp
-; SJLJ-NOT: .functype  emscripten_longjmp_jmpbuf
-; SJLJ-NOT: .import_module  emscripten_longjmp_jmpbuf
-; SJLJ-NOT: .import_name  emscripten_longjmp_jmpbuf
-
 ; WASM-EH-EM-EH: LLVM ERROR: -exception-model=wasm not allowed with -enable-emscripten-cxx-exceptions

llvm/test/CodeGen/WebAssembly/lower-global-dtors.ll

[
   { i32, void ()*, i8* } { i32 1, void ()* @orig_dtor1c3, i8* @associatedc3 },
   { i32, void ()*, i8* } { i32 1, void ()* @orig_dtor1d, i8* null },
   { i32, void ()*, i8* } { i32 65535, void ()* @orig_dtor65535c0, i8* @associatedc0 },
   { i32, void ()*, i8* } { i32 65535, void ()* @orig_dtor65535, i8* null },
   { i32, void ()*, i8* } { i32 65535, void ()* null, i8* null },
   { i32, void ()*, i8* } { i32 65535, void ()* @after_the_null, i8* null }
 ]
 
+; CHECK-LABEL: .functype __cxa_atexit (i32, i32, i32) -> (i32){{$}}
+
 ; CHECK-LABEL: .Lcall_dtors.0:
 ; CHECK-NEXT: .functype .Lcall_dtors.0 (i32) -> (){{$}}
 ; CHECK-NEXT: call            orig_dtor0{{$}}
 
 ; CHECK-LABEL: .Lregister_call_dtors.0:
 ; CHECK:      block
 ; CHECK-NEXT: i32.const       $push2=, .Lcall_dtors.0{{$}}
 ; CHECK-NEXT: i32.const       $push1=, 0

 ; CHECK-NEXT: .int32  .Lregister_call_dtors.1$5{{$}}
 ; CHECK-LABEL: .section .init_array.200,"",@
 ;      CHECK: .int32  orig_ctor{{$}}
 ; CHECK-LABEL: .section .init_array,"",@
 ;      CHECK: .int32  .Lregister_call_dtors$1{{$}}
 
 ; CHECK-LABEL: .weak __dso_handle
 
-; CHECK-LABEL: .functype __cxa_atexit (i32, i32, i32) -> (i32){{$}}
-
 ; We shouldn't make use of a .fini_array section.
 
 ; FINI-NOT: fini_array
 
 ; This function is listed after the null terminator, so it should
 ; be excluded.
 
 ; NULL-NOT: after_the_null

llvm/test/CodeGen/WebAssembly/userstack.ll

 ; RUN: llc < %s --mtriple=wasm32-unknown-unknown -asm-verbose=false -disable-wasm-fallthrough-return-opt -wasm-keep-registers | FileCheck -DPTR=32 %s
 ; RUN: llc < %s --mtriple=wasm64-unknown-unknown -asm-verbose=false -disable-wasm-fallthrough-return-opt -wasm-keep-registers | FileCheck -DPTR=64 %s
 
 declare void @ext_func(i64* %ptr)
 declare void @ext_func_i32(i32* %ptr)
 
+; CHECK: .globaltype  __stack_pointer, i[[PTR]]{{$}}
+
 ; CHECK-LABEL: alloca32:
 ; Check that there is an extra local for the stack pointer.
 ; CHECK: .local i[[PTR]]{{$}}
 define void @alloca32() noredzone {
  ; CHECK-NEXT: global.get $push[[L2:.+]]=, __stack_pointer{{$}}
  ; CHECK-NEXT: i[[PTR]].const $push[[L3:.+]]=, 16
  ; CHECK-NEXT: i[[PTR]].sub $push[[L9:.+]]=, $pop[[L2]], $pop[[L3]]
  ; CHECK-NEXT: local.tee $push[[L8:.+]]=, [[SP:.+]], $pop[[L9]]{{$}}
define i8 @frame_offset_with_global_address() {
   %2 = ptrtoint i8* %1 to i32
   ;; Here @str is a global address and not an immediate, so cannot be folded
   %3 = getelementptr [3 x i8], [3 x i8]* @str, i32 0, i32 %2
   %4 = load i8, i8* %3, align 8
   %5 = and i8 %4, 67
   ret i8 %5
 }
 
-; CHECK: .globaltype  __stack_pointer, i[[PTR]]{{$}}
-
 ; TODO: test over-aligned alloca

llvm/test/MC/WebAssembly/alias-offset.s

 # CHECK-NEXT: 00000004 l     O DATA sym_a
 # CHECK-NEXT: 00000008 l     O DATA sym_b
 # CHECK-NEXT: 00000001 l     F CODE main
 
   .text
   .section    .text,"",@
 main:
   .functype   main () -> ()
+  i32.const 0
   i32.const sym_a
   i32.store sym_b
   end_function
 
 # CHECK-LABEL: <main>:
 # CHECK-EMPTY:
-# CHECK-NEXT:       3: 41 84 80 80 80 00     i32.const       4
-# CHECK-NEXT:                        00000004:  R_WASM_MEMORY_ADDR_SLEB      sym_a+0
-# CHECK-NEXT:       9: 36 02 88 80 80 80 00  i32.store       8
-# CHECK-NEXT:                        0000000b:  R_WASM_MEMORY_ADDR_LEB      sym_b+0
-# CHECK-NEXT:      10: 0b            end
+# CHECK-NEXT:       3: 41 00                 i32.const       0
+# CHECK-NEXT:       5: 41 84 80 80 80 00     i32.const       4
+# CHECK-NEXT:                        00000006:  R_WASM_MEMORY_ADDR_SLEB      sym_a+0
+# CHECK-NEXT:       b: 36 02 88 80 80 80 00  i32.store       8
+# CHECK-NEXT:                        0000000d:  R_WASM_MEMORY_ADDR_LEB      sym_b+0
+# CHECK-NEXT:      12: 0b            end

llvm/test/MC/WebAssembly/annotations.s

-# RUN: llvm-mc -triple=wasm32-unknown-unknown -mattr=+exception-handling < %s | FileCheck %s
+# RUN: llvm-mc -no-type-check -triple=wasm32-unknown-unknown -mattr=+exception-handling < %s | FileCheck %s
 
 # Tests if block/loop/try/catch/end/branch/rethrow instructions are correctly
 # printed with their annotations.
 
   .text
   .section .text.test_annotation,"",@
   .type    test_annotation,@function
 test_annotation:

llvm/test/MC/WebAssembly/assembler-binary.ll

 }
 
 ; Checking assembly is not the point of this test, but if something breaks
 ; it is easier to spot it here than in the yaml output.
 
 ; ASM:      .text
 ; ASM:        .file "assembler-binary.ll"
 ; ASM:        .globl  foo
+; ASM:        .functype bar () -> ()
 ; ASM:      foo:
 ; ASM-NEXT:   .functype foo (i32) -> ()
 ; ASM-NEXT:   call  bar
 ; ASM-NEXT:   end_function
-; ASM:        .functype bar () -> ()
 
 
 ; CHECK:      --- !WASM
 ; CHECK-NEXT: FileHeader:
 ; CHECK-NEXT:   Version:         0x1
 ; CHECK-NEXT: Sections:
 ; CHECK-NEXT:   - Type:            TYPE
 ; CHECK-NEXT:     Signatures:

llvm/test/MC/WebAssembly/atomics-encodings.s

-# RUN: llvm-mc -show-encoding -triple=wasm32-unknown-unknown -mattr=+atomics < %s | FileCheck %s
+# RUN: llvm-mc -no-type-check -show-encoding -triple=wasm32-unknown-unknown -mattr=+atomics < %s | FileCheck %s
 
 main:
   .functype main () -> ()
 
   # CHECK:  memory.atomic.notify 0 # encoding: [0xfe,0x00,0x02,0x00]
   memory.atomic.notify 0
   # CHECK:  memory.atomic.wait32 0 # encoding: [0xfe,0x01,0x02,0x00]
   memory.atomic.wait32 0

llvm/test/MC/WebAssembly/bad-fixup-expr.s

 // CHECK: 'fizz' can not be placed in a different section
   .int32 undef_baz-fizz
   .size       segment1, 12
 
 
   .text
   .section    .text.main,"",@
 main:
-  .functype   main () -> (i32)
+  .functype   main () -> (i32, i32, i32, i32, i32)
 // Expressions involving symbols within the same sections can be evaluated
 // prior to writing the object file.
 // CHECK-NOT: foo
   i32.const foo-foo_other+2
   i32.const foo_other-foo-10
 
 // CHECK: 'bar' unsupported subtraction expression used in relocation in code section.
   i32.const foo-bar
 // CHECK: 'undef_baz' unsupported subtraction expression used in relocation in code section.
   i32.const foo-undef_baz
 // CHECK: 'foo' unsupported subtraction expression used in relocation in code section.
   i32.const undef_baz-foo
   end_function

llvm/test/MC/WebAssembly/basic-assembly.s

 # RUN: llvm-mc -triple=wasm32-unknown-unknown -mattr=+reference-types,atomics,+simd128,+nontrapping-fptoint,+exception-handling < %s | FileCheck %s
 # Check that it converts to .o without errors, but don't check any output:
 # RUN: llvm-mc -triple=wasm32-unknown-unknown -filetype=obj -mattr=+reference-types,+atomics,+simd128,+nontrapping-fptoint,+exception-handling -o %t.o < %s
 
+.functype   something1 () -> ()
+.functype   something2 (i64) -> (i32, f64)
+.globaltype __stack_pointer, i32
 
 empty_func:
     .functype empty_func () -> ()
     end_function
 
 test0:
 # local labels can appear between label and its .functype.
 .Ltest0begin:
     # Test all types:
     .functype   test0 (i32, i64) -> (i32)
     .eventtype  __cpp_exception i32
     .local      f32, f64, v128, v128
     # Explicit getlocal/setlocal:
     local.get   2
     local.set   2
     # Immediates:
-    i32.const   -1
-    f64.const   0x1.999999999999ap1
     f32.const   -1.0
+    drop
     f32.const   -infinity
-    f32.const   nan
+    drop
     v128.const  0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15
+    drop
     v128.const  0, 1, 2, 3, 4, 5, 6, 7
-    # Indirect addressing:
+    drop
     local.get   0
+    f64.const   0x1.999999999999ap1
+    # Indirect addressing:
     f64.store   1234:p2align=4
+    i32.const   -1
+    f64.const   nan
     f64.store   1234     # Natural alignment (3)
     # Loops, conditionals, binary ops, calls etc:
-    block       i32
+    block       f32
+    f32.const   2.0
     i32.const   1
     local.get   0
     i32.ge_s
     br_if       0        # 0: down to label0
 .LBB0_1:
-    loop        i32      # label1:
+    loop        void      # label1:
     call        something1
     i64.const   1234
     call        something2
     i32.const   0
     call_indirect (i32, f64) -> ()
     i32.const   1
+    i32.const   2
     i32.add
     local.tee   0
     local.get   0
     i32.lt_s
     br_if       0        # 0: up to label1
 .LBB0_2:
     end_loop
     end_block            # label0:
-    local.get   4
-    local.get   5
+    drop
+    block       i32
+    block       void
+    block       void
     block       void
-    block       i64
-    block       f32
-    block       f64
     block       () -> (i32, i32)
     i32.const   1
     i32.const   2
     end_block
     drop
-    drop
     br_table {0, 1, 2}   # 2 entries, default
     end_block            # first entry jumps here.
     i32.const   1
     br          2
     end_block            # second entry jumps here.
     i32.const   2
     br          1
     end_block            # default jumps here.
     i32.const   3
     end_block            # "switch" exit.
     if                   # void
     if          i32
     end_if
     else
     end_if
+    drop
+    local.get   4
+    local.get   5
     f32x4.add
+    drop
     # Test correct parsing of instructions with / and : in them:
     # TODO: enable once instruction has been added.
     #i32x4.trunc_sat_f32x4_s
+    f32.const   1.0
     i32.trunc_f32_s
     try
     i32.atomic.load 0
+    i32.const   0
     memory.atomic.notify 0
+    drop
 .LBB0_3:
     catch       __cpp_exception
     local.set   0
     end_try
     i32.const   .L.str
     i32.load8_u .L.str+2
     i32.load16_u .L.str:p2align=0
     throw 0
 .LBB0_4:
     #i32.trunc_sat_f32_s
     global.get  __stack_pointer
+    global.set  __stack_pointer
     end_function
 
     .section    .rodata..L.str,"",@
     .hidden     .L.str
     .type       .L.str,@object
 .L.str:
     .int8       'H'
     .asciz      "ello, World!"
     .int16      1234
     .int64      5000000000
     .int32      2000000000
     .size       .L.str, 28
 
     .section    .init_array.42,"",@
     .p2align    2
     .int32      test0
 
     .ident      "clang version 9.0.0 (trunk 364502) (llvm/trunk 364571)"
-    .globaltype __stack_pointer, i32
 
 .tabletype empty_eref_table, externref
 empty_eref_table:
 
 .tabletype empty_fref_table, funcref
 empty_fref_table:
 
 
 # CHECK:           .text
+# CHECK:           .globaltype __stack_pointer, i32
+
 # CHECK-LABEL: empty_func:
 # CHECK-NEXT:      .functype  empty_func () -> ()
 # CHECK-NEXT:      end_function
 # CHECK-LABEL: test0:
 # CHECK-NEXT:  .Ltest0begin:
 # CHECK-NEXT:      .functype   test0 (i32, i64) -> (i32)
 # CHECK-NEXT:      .eventtype  __cpp_exception i32
 # CHECK-NEXT:      .local      f32, f64
 # CHECK-NEXT:      local.get   2
 # CHECK-NEXT:      local.set   2
-# CHECK-NEXT:      i32.const   -1
-# CHECK-NEXT:      f64.const   0x1.999999999999ap1
 # CHECK-NEXT:      f32.const   -0x1p0
+# CHECK-NEXT:      drop
 # CHECK-NEXT:      f32.const   -infinity
-# CHECK-NEXT:      f32.const   nan
+# CHECK-NEXT:      drop
 # CHECK-NEXT:      v128.const  0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15
+# CHECK-NEXT:      drop
 # CHECK-NEXT:      v128.const  0, 1, 2, 3, 4, 5, 6, 7
+# CHECK-NEXT:      drop
 # CHECK-NEXT:      local.get   0
+# CHECK-NEXT:      f64.const   0x1.999999999999ap1
 # CHECK-NEXT:      f64.store   1234:p2align=4
+# CHECK-NEXT:      i32.const   -1
+# CHECK-NEXT:      f64.const   nan
 # CHECK-NEXT:      f64.store   1234
-# CHECK-NEXT:      block       i32
+# CHECK-NEXT:      block       f32
+# CHECK-NEXT:      f32.const   0x1p1
 # CHECK-NEXT:      i32.const   1
 # CHECK-NEXT:      local.get   0
 # CHECK-NEXT:      i32.ge_s
 # CHECK-NEXT:      br_if       0       # 0: down to label0
 # CHECK-NEXT:  .LBB0_1:
-# CHECK-NEXT:      loop        i32     # label1:
+# CHECK-NEXT:      loop                # label1:
 # CHECK-NEXT:      call        something1
 # CHECK-NEXT:      i64.const   1234
 # CHECK-NEXT:      call        something2
 # CHECK-NEXT:      i32.const   0
 # CHECK-NEXT:      call_indirect __indirect_function_table, (i32, f64) -> ()
 # CHECK-NEXT:      i32.const   1
+# CHECK-NEXT:      i32.const   2
 # CHECK-NEXT:      i32.add
 # CHECK-NEXT:      local.tee   0
 # CHECK-NEXT:      local.get   0
 # CHECK-NEXT:      i32.lt_s
 # CHECK-NEXT:      br_if       0       # 0: up to label1
 # CHECK-NEXT:  .LBB0_2:
 # CHECK-NEXT:      end_loop
 # CHECK-NEXT:      end_block           # label0:
-# CHECK-NEXT:      local.get   4
-# CHECK-NEXT:      local.get   5
+# CHECK-NEXT:      drop
+# CHECK-NEXT:      block       i32
+# CHECK-NEXT:      block
+# CHECK-NEXT:      block
 # CHECK-NEXT:      block
-# CHECK-NEXT:      block       i64
-# CHECK-NEXT:      block       f32
-# CHECK-NEXT:      block       f64
 # CHECK-NEXT:      block       () -> (i32, i32)
 # CHECK-NEXT:      i32.const   1
 # CHECK-NEXT:      i32.const   2
 # CHECK-NEXT:      end_block
 # CHECK-NEXT:      drop
-# CHECK-NEXT:      drop
 # CHECK-NEXT:      br_table {0, 1, 2}  # 1: down to label4
 # CHECK-NEXT:                          # 2: down to label3
 # CHECK-NEXT:      end_block           # label5:
 # CHECK-NEXT:      i32.const   1
 # CHECK-NEXT:      br          2       # 2: down to label2
 # CHECK-NEXT:      end_block           # label4:
 # CHECK-NEXT:      i32.const   2
 # CHECK-NEXT:      br          1       # 1: down to label2
 # CHECK-NEXT:      end_block           # label3:
 # CHECK-NEXT:      i32.const   3
 # CHECK-NEXT:      end_block           # label2:
 # CHECK-NEXT:      if
 # CHECK-NEXT:      if          i32
 # CHECK-NEXT:      end_if
 # CHECK-NEXT:      else
 # CHECK-NEXT:      end_if
+# CHECK-NEXT:      drop
+# CHECK-NEXT:      local.get   4
+# CHECK-NEXT:      local.get   5
 # CHECK-NEXT:      f32x4.add
+# CHECK-NEXT:      drop
+# CHECK-NEXT:      f32.const   0x1p0
 # CHECK-NEXT:      i32.trunc_f32_s
 # CHECK-NEXT:      try
 # CHECK-NEXT:      i32.atomic.load 0
+# CHECK-NEXT:      i32.const   0
 # CHECK-NEXT:      memory.atomic.notify 0
+# CHECK-NEXT:      drop
 # CHECK-NEXT:  .LBB0_3:
 # CHECK-NEXT:      catch       __cpp_exception
 # CHECK-NEXT:      local.set   0
 # CHECK-NEXT:      end_try
 # CHECK-NEXT:      i32.const   .L.str
 # CHECK-NEXT:      i32.load8_u .L.str+2
 # CHECK-NEXT:      i32.load16_u .L.str:p2align=0
 # CHECK-NEXT:      throw       0
 # CHECK-NEXT:  .LBB0_4:
 # CHECK-NEXT:      global.get  __stack_pointer
+# CHECK-NEXT:      global.set  __stack_pointer
 # CHECK-NEXT:      end_function
 
 # CHECK:           .section    .rodata..L.str,"",@
 # CHECK-NEXT:      .hidden     .L.str
 # CHECK-NEXT:  .L.str:
 # CHECK-NEXT:      .int8       72
 # CHECK-NEXT:      .asciz      "ello, World!"
 # CHECK-NEXT:      .int16      1234
 # CHECK-NEXT:      .int64      5000000000
 # CHECK-NEXT:      .int32      2000000000
 # CHECK-NEXT:      .size       .L.str, 28
 
 # CHECK:           .section    .init_array.42,"",@
 # CHECK-NEXT:      .p2align    2
 # CHECK-NEXT:      .int32      test0
 
-# CHECK:           .globaltype __stack_pointer, i32
-
 # CHECK:           .tabletype empty_eref_table, externref
 # CHECK-NEXT: empty_eref_table:
 
 # CHECK:           .tabletype empty_fref_table, funcref
 # CHECK-NEXT: empty_fref_table:

llvm/test/MC/WebAssembly/bulk-memory-encodings.s

-# RUN: llvm-mc -show-encoding -triple=wasm32-unknown-unknown -mattr=+bulk-memory < %s | FileCheck %s
-# RUN: llvm-mc -show-encoding -triple=wasm64-unknown-unknown -mattr=+bulk-memory < %s | FileCheck %s
+# RUN: llvm-mc -show-encoding -no-type-check -triple=wasm32-unknown-unknown -mattr=+bulk-memory < %s | FileCheck %s
+# RUN: llvm-mc -show-encoding -no-type-check -triple=wasm64-unknown-unknown -mattr=+bulk-memory < %s | FileCheck %s
 
 main:
     .functype main () -> ()
 
     # CHECK: memory.init 3, 0 # encoding: [0xfc,0x08,0x03,0x00]
     memory.init 3, 0
 
     # CHECK: data.drop 3 # encoding: [0xfc,0x09,0x03]

llvm/test/MC/WebAssembly/data-section-combined.s

 # Test that placing multiple data symbols in the same section works
 
 # RUN: llvm-mc -triple=wasm32-unknown-unknown < %s | FileCheck %s
 
 test0:
-    .functype   test0 () -> (i32)
+    .functype   test0 () -> (i32, i32)
     i32.const a
     i32.const b
     end_function
 
     .section mysec,"",@
 a:
     .int32 42
     .int32 43

llvm/test/MC/WebAssembly/globals.s

 .globaltype global4, f64
 
 read_global:
   .functype read_global () -> (i32)
   global.get foo_global
   end_function
 
 write_global:
-  .functype write_global (i32) -> ()
+  .functype write_global (i32, i64, f32, f64) -> ()
   local.get 0
   global.set foo_global
+  local.get 1
   global.set global2
+  local.get 2
   global.set global3
+  local.get 3
   global.set global4
   end_function
 
 foo_global:
 global2:
 global3:
 global4:
 

llvm/test/MC/WebAssembly/import-module.s

 # RUN: llvm-mc -triple=wasm32 < %s | FileCheck %s -check-prefix=CHECK-ASM
 # RUN: llvm-mc -triple=wasm32 -filetype=obj -o - < %s | obj2yaml | FileCheck %s
 
+.functype foo () -> ()
+.functype plain () -> ()
+
 test:
   .functype test () -> ()
   call      foo
   call      plain
   end_function
 
-  .functype foo () -> ()
-  .functype plain () -> ()
   .import_module  foo, bar
   .import_name  foo, qux
 
 # CHECK-ASM: .import_module  foo, bar
 # CHECK-ASM: .import_name  foo, qux
 
 # CHECK:        - Type:            IMPORT
 # CHECK-NEXT:     Imports:

llvm/test/MC/WebAssembly/null-output.s

 # RUN: llvm-mc -triple=wasm32-unknown-unknown -filetype=obj -o /dev/null < %s
 
     .text
     .section .text.main,"",@
     .type    main,@function
 main:
     .functype   main (i32, i32) -> (i32)
+    local.get 0
     end_function
 .Lfunc_end0:
     .size main, .Lfunc_end0-main

llvm/test/MC/WebAssembly/objdump.s

 # RUN: llvm-mc -triple=wasm32-unknown-unknown -filetype=obj -o %t.o -mattr=+simd128,+nontrapping-fptoint,+exception-handling < %s
 # RUN: llvm-objdump --triple=wasm32-unknown-unknown -d %t.o | FileCheck %s
 
 test0:
-    .functype   test0 (i32, i64) -> (i32)
+    .functype   test0 (i32, i64) -> (f32)
     .local      f32, f64, v128, v128
     local.get   2
     end_function
 
 test1:
-    .functype   test1 (i32, i64) -> (i32)
+    .functype   test1 (i32, i64) -> (i64)
     .local      i32, i64, funcref
     local.get   3
     end_function
 
 
 # CHECK-LABEL: CODE:
 # CHECK:             # 2 functions in section.
 # CHECK-LABEL: <test0>:
 # CHECK-NEXT:        .local  f32, f64, v128, v128
 # CHECK-NEXT:       9:       20 02  local.get 2
 # CHECK-NEXT:       b:       0b     end
 # CHECK-LABEL: <test1>:
 # CHECK-NEXT:        .local  i32, i64, funcref
 # CHECK-NEXT:      14:       20 03  local.get 3
 # CHECK-NEXT:      16:       0b     end

llvm/test/MC/WebAssembly/reference-types.s

ref_null_test:
   ref.null extern
   drop
   end_function
 
 # CHECK-LABEL: ref_sig_test_funcref:
 # CHECK-NEXT: .functype ref_sig_test_funcref (funcref) -> (funcref)
 ref_sig_test_funcref:
   .functype ref_sig_test_funcref (funcref) -> (funcref)
+  local.get 0
   end_function
 
 # CHECK-LABEL: ref_sig_test_externref:
 # CHECK-NEXT: .functype ref_sig_test_externref (externref) -> (externref)
 ref_sig_test_externref:
   .functype ref_sig_test_externref (externref) -> (externref)
+  local.get 0
   end_function
 
 # CHECK-LABEL: ref_select_test:
 # CHECK: funcref.select   # encoding: [0x1b]
 # CHECK: externref.select # encoding: [0x1b]
 ref_select_test:
   .functype ref_select_test () -> ()
   ref.null func
   ref.null func
   i32.const 0
   funcref.select
   drop
   ref.null extern
   ref.null extern
   i32.const 0
   externref.select
   drop
   end_function
 
 # CHECK-LABEL: ref_block_test:
 # CHECK: block funcref
 # CHECK: block externref
 ref_block_test:
-  .functype ref_block_test () -> ()
+  .functype ref_block_test () -> (externref, funcref)
   block funcref
   block externref
+  ref.null extern
   end_block
+  ref.null func
   end_block
   end_function

llvm/test/MC/WebAssembly/reloc-pic.s

 # RUN: llvm-mc -triple=wasm32-unknown-unknown -filetype=obj < %s | obj2yaml | FileCheck %s
 # RUN: llvm-mc -triple=wasm32-unknown-unknown -mattr=+reference-types -filetype=obj < %s | obj2yaml | FileCheck --check-prefix=REF %s
 
 # Verify that @GOT relocation entryes result in R_WASM_GLOBAL_INDEX_LEB against
 # against the corrsponding function or data symbol and that the corresponding
 # data symbols are imported as a wasm globals.
 
+.functype default_func () -> (i32)
+
+.globaltype __memory_base, i32
+.globaltype __table_base, i32
+
 load_default_data:
     .functype   load_default_data () -> (i32)
     global.get  default_data@GOT
     i32.load    0
     end_function
 
 load_default_func:
     .functype   load_default_func () -> (i32)

 .section .rodata.hidden_data,"",@
 .L.hidden_data:
     .int8 100
     .size .L.hidden_data, 1
 
 #.hidden hidden_func
 #.hidden hidden_data
 .size default_data, 4
-.functype default_func () -> (i32)
 
 # CHECK:      --- !WASM
 # CHECK-NEXT: FileHeader:
 # CHECK-NEXT:   Version:         0x1
 # CHECK-NEXT: Sections:
 # CHECK-NEXT:   - Type:            TYPE
 # CHECK-NEXT:     Signatures:
 # CHECK-NEXT:       - Index:           0
 # CHECK-NEXT:         ParamTypes:      []
 # CHECK-NEXT:         ReturnTypes:
 # CHECK-NEXT:           - I32
 # CHECK-NEXT:   - Type:            IMPORT
 # CHECK-NEXT:     Imports:
 # CHECK-NEXT:       - Module:          env
 # CHECK-NEXT:         Field:           __linear_memory
 # CHECK-NEXT:         Kind:            MEMORY
 # CHECK-NEXT:         Memory:
 # CHECK-NEXT:           Minimum:         0x1
 # CHECK-NEXT:       - Module:          env
 # CHECK-NEXT:         Field:           default_func
 # CHECK-NEXT:         Kind:            FUNCTION
 # CHECK-NEXT:         SigIndex:        0
 # CHECK-NEXT:       - Module:          env
+# CHECK-NEXT:         Field:           __memory_base
+# CHECK-NEXT:         Kind:            GLOBAL
+# CHECK-NEXT:         GlobalType:      I32
+# CHECK-NEXT:         GlobalMutable:   true
+# CHECK-NEXT:       - Module:          env
+# CHECK-NEXT:         Field:           __table_base
+# CHECK-NEXT:         Kind:            GLOBAL
+# CHECK-NEXT:         GlobalType:      I32
+# CHECK-NEXT:         GlobalMutable:   true
+# CHECK-NEXT:       - Module:          env
 # CHECK-NEXT:         Field:           __indirect_function_table
 # CHECK-NEXT:         Kind:            TABLE
 # CHECK-NEXT:         Table:
 # CHECK-NEXT:           Index:           0
 # CHECK-NEXT:           ElemType:        FUNCREF
 # CHECK-NEXT:           Limits:
 # CHECK-NEXT:             Minimum:         0x1
 # CHECK-NEXT:       - Module:          GOT.mem

 # CHECK-NEXT:   - Type:            CODE
 # CHECK-NEXT:     Relocations:
 # CHECK-NEXT:       - Type:            R_WASM_GLOBAL_INDEX_LEB
 # CHECK-NEXT:         Index:           1
 # CHECK-NEXT:         Offset:          0x4
 # CHECK-NEXT:       - Type:            R_WASM_GLOBAL_INDEX_LEB
 # CHECK-NEXT:         Index:           3
 # CHECK-NEXT:         Offset:          0x10
-# CHECK-NEXT:       - Type:            R_WASM_MEMORY_ADDR_LEB
+# CHECK-NEXT:       - Type:            R_WASM_GLOBAL_INDEX_LEB
 # CHECK-NEXT:         Index:           5
 # CHECK-NEXT:         Offset:          0x1C
 # CHECK-NEXT:       - Type:            R_WASM_MEMORY_ADDR_REL_SLEB
 # CHECK-NEXT:         Index:           6
 # CHECK-NEXT:         Offset:          0x22
-# CHECK-NEXT:       - Type:            R_WASM_MEMORY_ADDR_LEB
+# CHECK-NEXT:       - Type:            R_WASM_GLOBAL_INDEX_LEB
 # CHECK-NEXT:         Index:           8
 # CHECK-NEXT:         Offset:          0x2C
 # CHECK-NEXT:       - Type:            R_WASM_TABLE_INDEX_REL_SLEB
 # CHECK-NEXT:         Index:           9
 # CHECK-NEXT:         Offset:          0x32
 # CHECK-NEXT:     Functions:
 # CHECK-NEXT:       - Index:           1
 # CHECK-NEXT:         Locals:          []
-# CHECK-NEXT:         Body:            2380808080002802000B
+# CHECK-NEXT:         Body:            2382808080002802000B
 # CHECK-NEXT:       - Index:           2
 # CHECK-NEXT:         Locals:          []
-# CHECK-NEXT:         Body:            2381808080002802000B
+# CHECK-NEXT:         Body:            2383808080002802000B
 # CHECK-NEXT:       - Index:           3
 # CHECK-NEXT:         Locals:          []
 # CHECK-NEXT:         Body:            2380808080004180808080006A0B
 # CHECK-NEXT:       - Index:           4
 # CHECK-NEXT:         Locals:          []
-# CHECK-NEXT:         Body:            2380808080004180808080006A0B
+# CHECK-NEXT:         Body:            2381808080004180808080006A0B
 # CHECK-NEXT:       - Index:           5
 # CHECK-NEXT:         Locals:          []
 # CHECK-NEXT:         Body:            41000B
 # CHECK-NEXT:   - Type:            DATA
 # CHECK-NEXT:     Segments:
 # CHECK-NEXT:       - SectionOffset:   6
 # CHECK-NEXT:         InitFlags:       0
 # CHECK-NEXT:         Offset:

 # CHECK-NEXT:         Flags:           [ UNDEFINED ]
 # CHECK-NEXT:         Function:        0
 # CHECK-NEXT:       - Index:           4
 # CHECK-NEXT:         Kind:            FUNCTION
 # CHECK-NEXT:         Name:            load_hidden_data
 # CHECK-NEXT:         Flags:           [ BINDING_LOCAL ]
 # CHECK-NEXT:         Function:        3
 # CHECK-NEXT:       - Index:           5
-# CHECK-NEXT:         Kind:            DATA
+# CHECK-NEXT:         Kind:            GLOBAL
 # CHECK-NEXT:         Name:            __memory_base
 # CHECK-NEXT:         Flags:           [ UNDEFINED ]
+# CHECK-NEXT:         Global:          0
 # CHECK-NEXT:       - Index:           6
 # CHECK-NEXT:         Kind:            DATA
 # CHECK-NEXT:         Name:            .L.hidden_data
 # CHECK-NEXT:         Flags:           [ BINDING_LOCAL ]
 # CHECK-NEXT:         Segment:         0
 # CHECK-NEXT:         Size:            1
 # CHECK-NEXT:       - Index:           7
 # CHECK-NEXT:         Kind:            FUNCTION
 # CHECK-NEXT:         Name:            load_hidden_func
 # CHECK-NEXT:         Flags:           [ BINDING_LOCAL ]
 # CHECK-NEXT:         Function:        4
 # CHECK-NEXT:       - Index:           8
-# CHECK-NEXT:         Kind:            DATA
+# CHECK-NEXT:         Kind:            GLOBAL
 # CHECK-NEXT:         Name:            __table_base
 # CHECK-NEXT:         Flags:           [ UNDEFINED ]
+# CHECK-NEXT:         Global:          1
 # CHECK-NEXT:       - Index:           9
 # CHECK-NEXT:         Kind:            FUNCTION
 # CHECK-NEXT:         Name:            hidden_func
 # CHECK-NEXT:         Flags:           [ BINDING_LOCAL ]
 # CHECK-NEXT:         Function:        5
 # REF:              - Index:           10
 # REF-NEXT:           Kind:            TABLE
 # REF-NEXT:           Name:            __indirect_function_table
 # REF-NEXT:           Flags:           [ UNDEFINED, NO_STRIP ]
 # REF-NEXT:           Table:           0
 # CHECK-NEXT:     SegmentInfo:
 # CHECK-NEXT:       - Index:           0
 # CHECK-NEXT:         Name:            .rodata.hidden_data
 # CHECK-NEXT:         Alignment:       0
 # CHECK-NEXT:         Flags:           [  ]
 # CHECK-NEXT: ...

llvm/test/MC/WebAssembly/reloc-pic64.s

 # RUN: llvm-mc -triple=wasm64-unknown-unknown -filetype=obj < %s | obj2yaml | FileCheck %s
 # RUN: llvm-mc -triple=wasm64-unknown-unknown -mattr=+reference-types -filetype=obj < %s | obj2yaml | FileCheck --check-prefix=REF %s
 
 # Verify that @GOT relocation entries result in R_WASM_GLOBAL_INDEX_LEB against
 # against the corrsponding function or data symbol and that the corresponding
 # data symbols are imported as a wasm globals.
 
+.functype default_func () -> (i32)
+
+.globaltype __memory_base, i64
+.globaltype __table_base, i64
+
 load_default_data:
     .functype   load_default_data () -> (i32)
     global.get  default_data@GOT
     i32.load    0
     end_function
 
 load_default_func:
     .functype   load_default_func () -> (i32)

 .section .rodata.hidden_data,"",@
 .L.hidden_data:
     .int8 100
     .size .L.hidden_data, 1
 
 #.hidden hidden_func
 #.hidden hidden_data
 .size default_data, 4
-.functype default_func () -> (i32)
 
 # CHECK:      --- !WASM
 # CHECK-NEXT: FileHeader:
 # CHECK-NEXT:   Version:         0x1
 # CHECK-NEXT: Sections:
 # CHECK-NEXT:   - Type:            TYPE
 # CHECK-NEXT:     Signatures:
 # CHECK-NEXT:       - Index:           0

 # CHECK-NEXT:         Memory:
 # CHECK-NEXT:           Flags:           [ IS_64 ]
 # CHECK-NEXT:           Minimum:         0x1
 # CHECK-NEXT:       - Module:          env
 # CHECK-NEXT:         Field:           default_func
 # CHECK-NEXT:         Kind:            FUNCTION
 # CHECK-NEXT:         SigIndex:        0
 # CHECK-NEXT:       - Module:          env
+# CHECK-NEXT:         Field:           __memory_base
+# CHECK-NEXT:         Kind:            GLOBAL
+# CHECK-NEXT:         GlobalType:      I64
+# CHECK-NEXT:         GlobalMutable:   true
+# CHECK-NEXT:       - Module:          env
+# CHECK-NEXT:         Field:           __table_base
+# CHECK-NEXT:         Kind:            GLOBAL
+# CHECK-NEXT:         GlobalType:      I64
+# CHECK-NEXT:         GlobalMutable:   true
+# CHECK-NEXT:       - Module:          env
 # CHECK-NEXT:         Field:           __indirect_function_table
 # CHECK-NEXT:         Kind:            TABLE
 # CHECK-NEXT:         Table:
 # CHECK-NEXT:           Index:           0
 # CHECK-NEXT:           ElemType:        FUNCREF
 # CHECK-NEXT:           Limits:
 # CHECK-NEXT:             Minimum:         0x1
 # CHECK-NEXT:       - Module:          GOT.mem

 # CHECK-NEXT:   - Type:            CODE
 # CHECK-NEXT:     Relocations:
 # CHECK-NEXT:       - Type:            R_WASM_GLOBAL_INDEX_LEB
 # CHECK-NEXT:         Index:           1
 # CHECK-NEXT:         Offset:          0x4
 # CHECK-NEXT:       - Type:            R_WASM_GLOBAL_INDEX_LEB
 # CHECK-NEXT:         Index:           3
 # CHECK-NEXT:         Offset:          0x10
-# CHECK-NEXT:       - Type:            R_WASM_MEMORY_ADDR_LEB
+# CHECK-NEXT:       - Type:            R_WASM_GLOBAL_INDEX_LEB
 # CHECK-NEXT:         Index:           5
 # CHECK-NEXT:         Offset:          0x1C
-# CHECK-NEXT:       - Type:            R_WASM_MEMORY_ADDR_REL_SLEB
+# CHECK-NEXT:       - Type:            R_WASM_MEMORY_ADDR_REL_SLEB64
 # CHECK-NEXT:         Index:           6
 # CHECK-NEXT:         Offset:          0x22
-# CHECK-NEXT:       - Type:            R_WASM_MEMORY_ADDR_LEB
+# CHECK-NEXT:       - Type:            R_WASM_GLOBAL_INDEX_LEB
 # CHECK-NEXT:         Index:           8
 # CHECK-NEXT:         Offset:          0x31
-# CHECK-NEXT:       - Type:            R_WASM_TABLE_INDEX_REL_SLEB
+# CHECK-NEXT:       - Type:            R_WASM_TABLE_INDEX_REL_SLEB64
 # CHECK-NEXT:         Index:           9
 # CHECK-NEXT:         Offset:          0x37
 # CHECK-NEXT:     Functions:
 # CHECK-NEXT:       - Index:           1
 # CHECK-NEXT:         Locals:          []
-# CHECK-NEXT:         Body:            2380808080002802000B
+# CHECK-NEXT:         Body:            2382808080002802000B
 # CHECK-NEXT:       - Index:           2
 # CHECK-NEXT:         Locals:          []
-# CHECK-NEXT:         Body:            2381808080002802000B
+# CHECK-NEXT:         Body:            2383808080002802000B
 # CHECK-NEXT:       - Index:           3
 # CHECK-NEXT:         Locals:          []
 # CHECK-NEXT:         Body:            23808080800042808080808080808080007C0B
 # CHECK-NEXT:       - Index:           4
 # CHECK-NEXT:         Locals:          []
-# CHECK-NEXT:         Body:            23808080800042808080808080808080007C0B
+# CHECK-NEXT:         Body:            23818080800042808080808080808080007C0B
 # CHECK-NEXT:       - Index:           5
 # CHECK-NEXT:         Locals:          []
 # CHECK-NEXT:         Body:            41000B
 # CHECK-NEXT:   - Type:            DATA
 # CHECK-NEXT:     Segments:
 # CHECK-NEXT:       - SectionOffset:   6
 # CHECK-NEXT:         InitFlags:       0
 # CHECK-NEXT:         Offset:

 # CHECK-NEXT:         Flags:           [ UNDEFINED ]
 # CHECK-NEXT:         Function:        0
 # CHECK-NEXT:       - Index:           4
 # CHECK-NEXT:         Kind:            FUNCTION
 # CHECK-NEXT:         Name:            load_hidden_data
 # CHECK-NEXT:         Flags:           [ BINDING_LOCAL ]
 # CHECK-NEXT:         Function:        3
 # CHECK-NEXT:       - Index:           5
-# CHECK-NEXT:         Kind:            DATA
+# CHECK-NEXT:         Kind:            GLOBAL
 # CHECK-NEXT:         Name:            __memory_base
 # CHECK-NEXT:         Flags:           [ UNDEFINED ]
+# CHECK-NEXT:         Global:          0
 # CHECK-NEXT:       - Index:           6
 # CHECK-NEXT:         Kind:            DATA
 # CHECK-NEXT:         Name:            .L.hidden_data
 # CHECK-NEXT:         Flags:           [ BINDING_LOCAL ]
 # CHECK-NEXT:         Segment:         0
 # CHECK-NEXT:         Size:            1
 # CHECK-NEXT:       - Index:           7
 # CHECK-NEXT:         Kind:            FUNCTION
 # CHECK-NEXT:         Name:            load_hidden_func
 # CHECK-NEXT:         Flags:           [ BINDING_LOCAL ]
 # CHECK-NEXT:         Function:        4
 # CHECK-NEXT:       - Index:           8
-# CHECK-NEXT:         Kind:            DATA
+# CHECK-NEXT:         Kind:            GLOBAL
 # CHECK-NEXT:         Name:            __table_base
 # CHECK-NEXT:         Flags:           [ UNDEFINED ]
+# CHECK-NEXT:         Global:          1
 # CHECK-NEXT:       - Index:           9
 # CHECK-NEXT:         Kind:            FUNCTION
 # CHECK-NEXT:         Name:            hidden_func
 # CHECK-NEXT:         Flags:           [ BINDING_LOCAL ]
 # CHECK-NEXT:         Function:        5
 # REF:              - Index:           10
 # REF-NEXT:           Kind:            TABLE
 # REF-NEXT:           Name:            __indirect_function_table
 # REF-NEXT:           Flags:           [ UNDEFINED, NO_STRIP ]
 # REF-NEXT:           Table:           0
 # CHECK-NEXT:     SegmentInfo:
 # CHECK-NEXT:       - Index:           0
 # CHECK-NEXT:         Name:            .rodata.hidden_data
 # CHECK-NEXT:         Alignment:       0
 # CHECK-NEXT:         Flags:           [  ]
 # CHECK-NEXT: ...

llvm/test/MC/WebAssembly/simd-encodings.s

-# RUN: llvm-mc -show-encoding -triple=wasm32-unknown-unknown -mattr=+simd128 < %s | FileCheck %s
+# RUN: llvm-mc -no-type-check -show-encoding -triple=wasm32-unknown-unknown -mattr=+simd128 < %s | FileCheck %s
 
 main:
     .functype main () -> ()
 
     # CHECK: v128.load 48 # encoding: [0xfd,0x00,0x04,0x30]
     v128.load 48
 
     # CHECK: i16x8.load8x8_s 32 # encoding: [0xfd,0x01,0x03,0x20]

llvm/test/MC/WebAssembly/tail-call-encodings.s

foo1:
 
     # CHECK: return_call bar1  # encoding: [0x12,
     # CHECK-NEXT: fixup A - offset: 1, value: bar1, kind: fixup_uleb128_i32
     return_call bar1
 
     end_function
 
 foo2:
-    .functype foo2 () -> ()
+    .functype foo2 () -> (i32)
 
+    i32.const 0
+    i32.const 0
     # REF: return_call_indirect __indirect_function_table, (i32) -> (i32) # encoding: [0x13,
     # CHECK: return_call_indirect (i32) -> (i32) # encoding: [0x13,
     # CHECK-NEXT: fixup A - offset: 1, value: .Ltypeindex0@TYPEINDEX, kind: fixup_uleb128_i32
     return_call_indirect (i32) -> (i32)
 
     end_function

llvm/test/MC/WebAssembly/tls.s

 # RUN: llvm-mc -triple=wasm32-unknown-unknown < %s | FileCheck %s
 # RUN: llvm-mc -triple=wasm32-unknown-unknown -filetype=obj -o %t.o < %s
 # RUN: obj2yaml %t.o | FileCheck %s --check-prefix=CHECK-OBJ
 
+.globaltype __tls_base, i32
+
 tls_store:
   .functype tls_store (i32) -> ()
   # CHECK: global.get __tls_base
   # CHECK-NEXT: i32.const tls1@TLSREL
   # CHECK-NEXT: i32.add
   # CHECK-NEXT: i32.store 0
+  local.get 0
   global.get __tls_base
   i32.const tls1@TLSREL
   i32.add
   i32.store 0
   end_function
 
 .section .tls.foo,"T",@
 # CHECK: .tls.foo,"T",@
 tls1:
   .int32 42
   .size tls1, 4
 
 .section custom_tls,"T",@
 # CHECK: custom_tls,"T",@
 tls2:
   .int32 43
   .size tls2, 4
 
 #      CHECK-OBJ:  - Type:            CODE
 # CHECK-OBJ-NEXT:    Relocations:
-# CHECK-OBJ-NEXT:      - Type:            R_WASM_MEMORY_ADDR_LEB
+# CHECK-OBJ-NEXT:      - Type:            R_WASM_GLOBAL_INDEX_LEB
 # CHECK-OBJ-NEXT:        Index:           1
-# CHECK-OBJ-NEXT:        Offset:          0x4
+# CHECK-OBJ-NEXT:        Offset:          0x6
 # CHECK-OBJ-NEXT:      - Type:            R_WASM_MEMORY_ADDR_TLS_SLEB
 # CHECK-OBJ-NEXT:        Index:           2
-# CHECK-OBJ-NEXT:        Offset:          0xA
+# CHECK-OBJ-NEXT:        Offset:          0xC
 
 #      CHECK-OBJ:  - Type:            CUSTOM
 # CHECK-OBJ-NEXT:    Name:            linking
 # CHECK-OBJ-NEXT:    Version:         2
 # CHECK-OBJ-NEXT:    SymbolTable:
 # CHECK-OBJ-NEXT:      - Index:           0
 # CHECK-OBJ-NEXT:        Kind:            FUNCTION
 # CHECK-OBJ-NEXT:        Name:            tls_store
 # CHECK-OBJ-NEXT:        Flags:           [ BINDING_LOCAL ]
 # CHECK-OBJ-NEXT:        Function:        0
 # CHECK-OBJ-NEXT:      - Index:           1
-# CHECK-OBJ-NEXT:        Kind:            DATA
+# CHECK-OBJ-NEXT:        Kind:            GLOBAL
 # CHECK-OBJ-NEXT:        Name:            __tls_base
 # CHECK-OBJ-NEXT:        Flags:           [ UNDEFINED ]
+# CHECK-OBJ-NEXT:        Global:          0
 # CHECK-OBJ-NEXT:      - Index:           2
 # CHECK-OBJ-NEXT:        Kind:            DATA
 # CHECK-OBJ-NEXT:        Name:            tls1
 # CHECK-OBJ-NEXT:        Flags:           [ BINDING_LOCAL ]
 # CHECK-OBJ-NEXT:        Segment:         0
 # CHECK-OBJ-NEXT:        Size:            4
 # CHECK-OBJ-NEXT:      - Index:           3
 # CHECK-OBJ-NEXT:        Kind:            DATA

llvm/test/MC/WebAssembly/type-index.s

 # RUN: llvm-mc -triple=wasm32-unknown-unknown -mattr=+reference-types,+simd128,+nontrapping-fptoint,+exception-handling < %s | FileCheck %s
 # Check that it converts to .o without errors:
 # RUN: llvm-mc -triple=wasm32-unknown-unknown -filetype=obj -mattr=+reference-types,+simd128,+nontrapping-fptoint,+exception-handling < %s | obj2yaml | FileCheck -check-prefix=BIN %s
 
 # Minimal test for type indices and table references in call_indirect.
 
 test0:
     .functype   test0 (i32) -> (i32)
-    call_indirect (f64) -> (f64)
+    f64.const 1.0
+    local.get 0
+    call_indirect (f64) -> (i32)
     end_function
 
 # CHECK:  .text
 # CHECK-LABEL: test0:
 # CHECK-NEXT: .functype test0 (i32) -> (i32)
-# CHECK-NEXT: call_indirect __indirect_function_table, (f64) -> (f64)
+# CHECK:      call_indirect __indirect_function_table, (f64) -> (i32)
 # CHECK-NEXT: end_function
 
 # BIN:      --- !WASM
 # BIN-NEXT: FileHeader:
 # BIN-NEXT:   Version:         0x1
 # BIN-NEXT: Sections:
 # BIN-NEXT:   - Type:            TYPE
 # BIN-NEXT:     Signatures:
 # BIN-NEXT:       - Index:           0
 # BIN-NEXT:         ParamTypes:
 # BIN-NEXT:           - I32
 # BIN-NEXT:         ReturnTypes:
 # BIN-NEXT:           - I32
 # BIN-NEXT:       - Index:           1
 # BIN-NEXT:         ParamTypes:
 # BIN-NEXT:           - F64
 # BIN-NEXT:         ReturnTypes:
-# BIN-NEXT:           - F64
+# BIN-NEXT:           - I32
 # BIN-NEXT:   - Type:            IMPORT
 # BIN-NEXT:     Imports:
 # BIN-NEXT:       - Module:          env
 # BIN-NEXT:         Field:           __linear_memory
 # BIN-NEXT:         Kind:            MEMORY
 # BIN-NEXT:         Memory:
 # BIN-NEXT:           Minimum:         0x0
 # BIN-NEXT:       - Module:          env
 # BIN-NEXT:         Field:           __indirect_function_table
 # BIN-NEXT:         Kind:            TABLE
 # BIN-NEXT:         Table:
 # BIN-NEXT:           Index:           0
 # BIN-NEXT:           ElemType:        FUNCREF
 # BIN-NEXT:           Limits:
 # BIN-NEXT:             Minimum:         0x0
 # BIN-NEXT:   - Type:            FUNCTION
 # BIN-NEXT:     FunctionTypes:   [ 0 ]
 # BIN-NEXT:   - Type:            CODE
 # BIN-NEXT:     Relocations:
 # BIN-NEXT:       - Type:            R_WASM_TYPE_INDEX_LEB
 # BIN-NEXT:         Index:           1
-# BIN-NEXT:         Offset:          0x4
+# BIN-NEXT:         Offset:          0xF
 # BIN-NEXT:       - Type:            R_WASM_TABLE_NUMBER_LEB
 # BIN-NEXT:         Index:           1
-# BIN-NEXT:         Offset:          0x9
+# BIN-NEXT:         Offset:          0x14
 # BIN-NEXT:     Functions:
 # BIN-NEXT:       - Index:           0
 # BIN-NEXT:         Locals:          []
-# BIN-NEXT:         Body:            11818080800080808080000B
+# BIN-NEXT:         Body:            44000000000000F03F200011818080800080808080000B
 # BIN-NEXT:   - Type:            CUSTOM
 # BIN-NEXT:     Name:            linking
 # BIN-NEXT:     Version:         2
 # BIN-NEXT:     SymbolTable:
 # BIN-NEXT:       - Index:           0
 # BIN-NEXT:         Kind:            FUNCTION
 # BIN-NEXT:         Name:            test0
 # BIN-NEXT:         Flags:           [ BINDING_LOCAL ]
 # BIN-NEXT:         Function:        0
 # BIN-NEXT:       - Index:           1
 # BIN-NEXT:         Kind:            TABLE
 # BIN-NEXT:         Name:            __indirect_function_table
 # BIN-NEXT:         Flags:           [ UNDEFINED ]
 # BIN-NEXT:         Table:           0
 # BIN-NEXT: ...

llvm/test/MC/WebAssembly/wasm64.s

 # RUN: llvm-mc -triple=wasm64-unknown-unknown -mattr=+atomics,+simd128,+nontrapping-fptoint,+exception-handling < %s | FileCheck %s
 # RUN: llvm-mc -triple=wasm64-unknown-unknown -filetype=obj -mattr=+atomics,+simd128,+nontrapping-fptoint,+exception-handling -o - < %s | obj2yaml | FileCheck %s -check-prefix=BIN
 
 # Most of our other tests are for wasm32, this one adds some wasm64 specific tests.
 
+.globaltype myglob64, i64
+.globaltype __stack_pointer, i64
+
 test:
     .functype   test (i64) -> ()
     .local      i64
 
     ### basic loads
 
     i64.const   0         # get i64 from constant.
     f32.load    0
test:
     drop
 
     i64.const   0
     f32.load    .L.str    # relocatable offset!
     drop
 
     ### basic stores
 
-    f32.const   0.0
     i64.const   0         # get i64 from constant.
+    f32.const   0.0
     f32.store   0
 
-    f32.const   0.0
     local.get   0         # get i64 from local.
+    f32.const   0.0
     f32.store   0
 
-    f32.const   0.0
     i64.const   .L.str    # get i64 relocatable.
+    f32.const   0.0
     f32.store   0
 
-    f32.const   0.0
     global.get  myglob64  # get i64 from global
+    f32.const   0.0
     f32.store   0
 
-    f32.const   0.0
     i64.const   0
+    f32.const   0.0
     f32.store   .L.str    # relocatable offset!
 
     ### 64-bit SP
 
     global.get  __stack_pointer
     drop
 
     end_function
 
     .section    .rodata..L.str,"",@
     .hidden     .L.str
     .type       .L.str,@object
 .L.str:
     .asciz      "Hello, World!!!"
     .int64      .L.str    # relocatable inside data.
     .size       .L.str, 24
 
-    .globaltype myglob64, i64
-    .globaltype __stack_pointer, i64
 
+# CHECK:              .globaltype     myglob64, i64
 
 # CHECK:              .functype       test (i64) -> ()
 # CHECK-NEXT:         .local          i64
 
 
 # CHECK:              i64.const       0
 # CHECK-NEXT:         f32.load        0
 # CHECK-NEXT:         drop

 # CHECK-NEXT:         f32.load        0
 # CHECK-NEXT:         drop
 
 # CHECK:              i64.const       0
 # CHECK-NEXT:         f32.load        .L.str
 # CHECK-NEXT:         drop
 
 
-# CHECK:              f32.const       0x0p0
-# CHECK-NEXT:         i64.const       0
+# CHECK:              i64.const       0
+# CHECK-NEXT:         f32.const       0x0p0
 # CHECK-NEXT:         f32.store       0
 
-# CHECK:              f32.const       0x0p0
-# CHECK-NEXT:         local.get       0
+# CHECK:              local.get       0
+# CHECK-NEXT:         f32.const       0x0p0
 # CHECK-NEXT:         f32.store       0
 
-# CHECK:              f32.const       0x0p0
-# CHECK-NEXT:         i64.const       .L.str
+# CHECK:              i64.const       .L.str
+# CHECK-NEXT:         f32.const       0x0p0
 # CHECK-NEXT:         f32.store       0
 
-# CHECK:              f32.const       0x0p0
-# CHECK-NEXT:         global.get      myglob64
+# CHECK:              global.get      myglob64
+# CHECK-NEXT:         f32.const       0x0p0
 # CHECK-NEXT:         f32.store       0
 
-# CHECK:              f32.const       0x0p0
-# CHECK-NEXT:         i64.const       0
+# CHECK:              i64.const       0
+# CHECK-NEXT:         f32.const       0x0p0
 # CHECK-NEXT:         f32.store       .L.str
 
 
 # CHECK:              end_function
 # CHECK-NEXT: .Ltmp0:
 # CHECK-NEXT:         .size   test, .Ltmp0-test
 
 # CHECK:              .section        .rodata..L.str,"",@
 # CHECK-NEXT:         .hidden .L.str
 # CHECK-NEXT: .L.str:
 # CHECK-NEXT:         .asciz  "Hello, World!!!"
 # CHECK-NEXT:         .int64      .L.str
 # CHECK-NEXT:         .size       .L.str, 24
 
-# CHECK:              .globaltype     myglob64, i64
-
 
 
 # BIN:      --- !WASM
 # BIN-NEXT: FileHeader:
 # BIN-NEXT:   Version:         0x1
 # BIN-NEXT: Sections:
 # BIN-NEXT:   - Type:            TYPE
 # BIN-NEXT:     Signatures:

 # BIN-NEXT:       - Type:            R_WASM_GLOBAL_INDEX_LEB
 # BIN-NEXT:         Index:           2
 # BIN-NEXT:         Offset:          0x22
 # BIN-NEXT:       - Type:            R_WASM_MEMORY_ADDR_LEB64
 # BIN-NEXT:         Index:           1
 # BIN-NEXT:         Offset:          0x2F
 # BIN-NEXT:       - Type:            R_WASM_MEMORY_ADDR_SLEB64
 # BIN-NEXT:         Index:           1
-# BIN-NEXT:         Offset:          0x54
+# BIN-NEXT:         Offset:          0x4F
 # BIN-NEXT:       - Type:            R_WASM_GLOBAL_INDEX_LEB
 # BIN-NEXT:         Index:           2
-# BIN-NEXT:         Offset:          0x67
+# BIN-NEXT:         Offset:          0x62
 # BIN-NEXT:       - Type:            R_WASM_MEMORY_ADDR_LEB64
 # BIN-NEXT:         Index:           1
 # BIN-NEXT:         Offset:          0x78
 # BIN-NEXT:       - Type: R_WASM_GLOBAL_INDEX_LEB
 # BIN-NEXT:         Index: 3
 # BIN-NEXT:         Offset: 0x83
 # BIN-NEXT:     Functions:
 # BIN-NEXT:       - Index:           0
 # BIN-NEXT:         Locals:
 # BIN-NEXT:           - Type:            I64
 # BIN-NEXT:             Count:           1
-# BIN-NEXT:         Body:            42002A02001A20002A02001A42808080808080808080002A02001A2380808080002A02001A42002A02808080808080808080001A4300000000420038020043000000002000380200430000000042808080808080808080003802004300000000238080808000380200430000000042003802808080808080808080002381808080001A0B
+# BIN-NEXT:         Body:            42002A02001A20002A02001A42808080808080808080002A02001A2380808080002A02001A42002A02808080808080808080001A4200430000000038020020004300000000380200428080808080808080800043000000003802002380808080004300000000380200420043000000003802808080808080808080002381808080001A0B
 # BIN-NEXT:   - Type:            DATA
 # BIN-NEXT:     Relocations:
 # BIN-NEXT:       - Type:            R_WASM_MEMORY_ADDR_I64
 # BIN-NEXT:         Index:           1
 # BIN-NEXT:         Offset:          0x16
 # BIN-NEXT:     Segments:
 # BIN-NEXT:       - SectionOffset:   6
 # BIN-NEXT:         InitFlags:       0

llvm/test/MC/WebAssembly/weak-alias.s

 # RUN: llvm-mc -triple=wasm32-unknown-unknown -filetype=obj < %s | obj2yaml | FileCheck --check-prefix=CHECK %s
 # RUN: llvm-mc -triple=wasm32-unknown-unknown -mattr=+reference-types -filetype=obj < %s | obj2yaml | FileCheck --check-prefix=REF %s
 
 # 'foo_alias()' is weak alias of function 'foo()'
 # 'bar_alias' is weak alias of global variable 'bar'
 # Generates two exports of the same function, one of them weak
 
+.functype foo_alias () -> (i32)
+
 foo:
   .hidden foo
   .globl  foo
   .functype foo () -> (i32)
   i32.const 0
   end_function
 
 call_direct:

llvm/utils/gn/secondary/llvm/lib/Target/WebAssembly/BUILD.gn

sources = [
     "WebAssemblyISelDAGToDAG.cpp",
     "WebAssemblyISelLowering.cpp",
     "WebAssemblyInstrInfo.cpp",
     "WebAssemblyLateEHPrepare.cpp",
     "WebAssemblyLowerBrUnless.cpp",
     "WebAssemblyLowerEmscriptenEHSjLj.cpp",
     "WebAssemblyLowerGlobalDtors.cpp",
     "WebAssemblyMCInstLower.cpp",
+    "WebAssemblyMCLowerPrePass.cpp",
     "WebAssemblyMachineFunctionInfo.cpp",
     "WebAssemblyMemIntrinsicResults.cpp",
     "WebAssemblyOptimizeLiveIntervals.cpp",
     "WebAssemblyOptimizeReturned.cpp",
     "WebAssemblyPeephole.cpp",
     "WebAssemblyPrepareForLiveIntervals.cpp",
     "WebAssemblyRegColoring.cpp",
     "WebAssemblyRegNumbering.cpp",