[WebAssembly] Refactor and fix emission of external IR global decls

[pmatos]

Summary

Reland of 00bf4755.

This patches fixes the visibility and linkage information of symbols
referring to IR globals.

Emission of external declarations is now done in the first execution
of emitConstantPool rather than in emitLinkage (and a few other
places). This is the point where we have already gathered information
about used symbols (by running the MC Lower PrePass) and not yet
started emitting any functions so that any declarations that need to
be emitted are done so at the top of the file before any functions.

This changes the order of a few directives in the final asm file which
required an update to a few tests.

[pmatos]

llvm/lib/Target/WebAssembly/WebAssemblyAsmPrinter.cpp

185–194

To be honest, we shouldn't be using Subtarget or TLI here at all since using these means we are inside a Function. But we aren't, what we do is set Subtarget from the last Function we saw. Which means that it will always be assigned to the Subtarget from the last seen Function. This might be ok in the Wasm backend but not in general and breaks when no function is defined. However, as far as I can tell from doing some checks whenever we call this _and_ Subtarget is null, we don't need to call computeLegalValueVTs therefore I added this check.

386

Added a comment here so we don't forget why this is necessary. Removing this call will cause hidden-decl.ll to fail.

llvm/test/CodeGen/WebAssembly/hidden-decl.ll

1 ↗

(On Diff #405955)

This test is the test that I extracted from the emscripten failure you referred to in D118122.

[sbc100]

lgtm % comments

llvm/lib/Target/WebAssembly/WebAssemblyAsmPrinter.cpp

555

Just emitExternalDecls(*MMI->getModule()) maybe?

llvm/test/CodeGen/WebAssembly/hidden-decl.ll

1 ↗

(On Diff #405955)

IIUC that "hidden" thing is no actually important there... isn't the important part that there are no functions declared here?

17 ↗

(On Diff #405955)

Can we make this a little simpler and more obvious what its testing?

Maybe just a function foo and some data foo_ptr which stores a pointer to that function? (I think you can remove all the function args, the 'hidden` keywords and the #0 at the end).

[pmatos]

llvm/lib/Target/WebAssembly/WebAssemblyAsmPrinter.cpp

555

Sure!

llvm/test/CodeGen/WebAssembly/hidden-decl.ll

1 ↗

(On Diff #405955)

Correct, hidden is not necessary, just part of the file that I extracted.

17 ↗

(On Diff #405955)

Sure, I will do the change now.

[pmatos]

@sbc100 addresses your concerns.

[sbc100]

Are you able to verify this against emscripten? Perhaps run the core2 test suite there? If not let me know and I can give it a go.

llvm/test/CodeGen/WebAssembly/only-data.ll

3

How about adding a comment about why we do this? "Verify that types are output for external symbols, even in the absence of any defined functions".

15

Remove trailing newline

[pmatos]

In D118995#3297060, @sbc100 wrote:

Are you able to verify this against emscripten? Perhaps run the core2 test suite there? If not let me know and I can give it a go.

Yes, the ubsan tests just finished and passing. I was going to give a go on the emscripten as well, but I am having some issues with the testsuites. For some reason running tests/runner shows no testsuites available. I will contact you in pvt.

[pmatos]

Address last set of comments.

[pmatos]

In D118995#3297389, @pmatos wrote:

In D118995#3297060, @sbc100 wrote:

Are you able to verify this against emscripten? Perhaps run the core2 test suite there? If not let me know and I can give it a go.

Yes, the ubsan tests just finished and passing. I was going to give a go on the emscripten as well, but I am having some issues with the testsuites. For some reason running tests/runner shows no testsuites available. I will contact you in pvt.

Ah sorry, found my mistake. I am running the core2 tests of emscripten.

[pmatos]

@sbc100 might have an incorrect version of node as I keep getting /usr/bin/node: invalid value for --unhandled-rejections. Other than that there are no failures.
Maybe you can give it a go on your side just to be certain before landing?

[sbc100]

In D118995#3297466, @pmatos wrote:

@sbc100 might have an incorrect version of node as I keep getting /usr/bin/node: invalid value for --unhandled-rejections. Other than that there are no failures.
Maybe you can give it a go on your side just to be certain before landing?

Yup, sounds unrelated to this change, ... is that just a warning or do one or more tests fail? What version is /usr/bin/node (we should probably detect this incompatibility)?

[pmatos]

In D118995#3297475, @sbc100 wrote:

In D118995#3297466, @pmatos wrote:

@sbc100 might have an incorrect version of node as I keep getting /usr/bin/node: invalid value for --unhandled-rejections. Other than that there are no failures.
Maybe you can give it a go on your side just to be certain before landing?

Yup, sounds unrelated to this change, ... is that just a warning or do one or more tests fail? What version is /usr/bin/node (we should probably detect this incompatibility)?

Only the fails related to the warning:

test_openjpeg (test_core.core2) ... FAIL
-- begin program output --
/usr/bin/node: invalid value for --unhandled-rejections
-- end program output --

node --version
v12.22.5

It's the ubuntu 21.10 version. What's the minimum version for emscripten?

[pmatos]

In D118995#3297627, @pmatos wrote:

In D118995#3297475, @sbc100 wrote:

In D118995#3297466, @pmatos wrote:

@sbc100 might have an incorrect version of node as I keep getting /usr/bin/node: invalid value for --unhandled-rejections. Other than that there are no failures.
Maybe you can give it a go on your side just to be certain before landing?

Yup, sounds unrelated to this change, ... is that just a warning or do one or more tests fail? What version is /usr/bin/node (we should probably detect this incompatibility)?

Only the fails related to the warning:

test_openjpeg (test_core.core2) ... FAIL
-- begin program output --
/usr/bin/node: invalid value for --unhandled-rejections
-- end program output --

node --version
v12.22.5

It's the ubuntu 21.10 version. What's the minimum version for emscripten?

Version 16.x of node is giving better results but still have tests failing with:

test_unaligned (test_core.core2) ... skipped 'LLVM marks the reads of s as fully aligned, making this test invalid'
-- begin program output --
/usr/bin/node: bad option: --experimental-wasm-bigint
-- end program output --

I guess I need 17.x or so...

[sbc100]

Looks good to me! don't worry about configuring your node correctly (if you want one that will certainly work use the emsdk version).

[pmatos]

In D118995#3297737, @sbc100 wrote:

Looks good to me! don't worry about configuring your node correctly (if you want one that will certainly work use the emsdk version).

OK - thanks. Lets get this landed. Thanks for your time.

llvm/lib/Target/WebAssembly/WebAssemblyAsmPrinter.h

public:
 
   //===------------------------------------------------------------------===//
   // AsmPrinter Implementation.
   //===------------------------------------------------------------------===//
 
   void emitEndOfAsmFile(Module &M) override;
   void EmitProducerInfo(Module &M);
   void EmitTargetFeatures(Module &M);
+  void emitSymbolType(const MCSymbolWasm *Sym);
   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;

llvm/lib/Target/WebAssembly/WebAssemblyAsmPrinter.cpp

if (!WebAssembly::isWasmVarAddressSpace(GV->getAddressSpace())) {
     return;
   }
 
   assert(!GV->isThreadLocal());
 
   MCSymbolWasm *Sym = cast<MCSymbolWasm>(getSymbol(GV));
 
   if (!Sym->getType()) {
-    const WebAssemblyTargetLowering &TLI = *Subtarget->getTargetLowering();
     SmallVector<MVT, 1> VTs;
     Type *GlobalVT = GV->getValueType();
+    if (Subtarget) {
+      // Subtarget is only set when a function is defined, because
+      // each function can declare a different subtarget. For example,
+      // on ARM a compilation unit might have a function on ARM and
+      // another on Thumb. Therefore only if Subtarget is non-null we
+      // can actually calculate the legal VTs.
+      const WebAssemblyTargetLowering &TLI = *Subtarget->getTargetLowering();
       computeLegalValueVTs(TLI, GV->getParent()->getContext(),
                            GV->getParent()->getDataLayout(), GlobalVT, VTs);
-    WebAssembly::wasmSymbolSetType(Sym, GlobalVT, VTs);
     }
-
-  // If the GlobalVariable refers to a table, we handle it here instead of
-  // in emitExternalDecls
-  if (Sym->isTable()) {
-    getTargetStreamer()->emitTableType(Sym);
-    return;
+    WebAssembly::wasmSymbolSetType(Sym, GlobalVT, VTs);
   }
 
   emitVisibility(Sym, GV->getVisibility(), !GV->isDeclaration());
+  emitSymbolType(Sym);
   if (GV->hasInitializer()) {
     assert(getSymbolPreferLocal(*GV) == Sym);
     emitLinkage(GV, Sym);
-    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();
   }
 }
 
 MCSymbol *WebAssemblyAsmPrinter::getOrCreateWasmSymbol(StringRef Name) {
MCSymbol *WebAssemblyAsmPrinter::getOrCreateWasmSymbol(StringRef Name) {
   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::emitSymbolType(const MCSymbolWasm *Sym) {
+  Optional<wasm::WasmSymbolType> WasmTy = Sym->getType();
+  if (!WasmTy)
+    return;
+
+  switch (WasmTy.getValue()) {
+  case wasm::WASM_SYMBOL_TYPE_GLOBAL:
+    getTargetStreamer()->emitGlobalType(Sym);
+    break;
+  case wasm::WASM_SYMBOL_TYPE_TAG:
+    getTargetStreamer()->emitTagType(Sym);
+    break;
+  case wasm::WASM_SYMBOL_TYPE_TABLE:
+    getTargetStreamer()->emitTableType(Sym);
+    break;
+  default:
+    break; // We only handle globals, tags and tables here
+  }
+}
+
 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.
+  // but we need to know about them ahead of time. This will however,
+  // only find symbols that have been used. Unused symbols from globals will
+  // not be found here.
   MachineModuleInfoWasm &MMIW = MMI->getObjFileInfo<MachineModuleInfoWasm>();
   for (const auto &Name : MMIW.MachineSymbolsUsed) {
     getOrCreateWasmSymbol(Name.getKey());
   }
 
   for (auto &It : OutContext.getSymbols()) {
-    // Emit .globaltype, .tagtype, or .tabletype declarations.
+    // Emit .globaltype, .tagtype, or .tabletype declarations for extern
+    // declarations, i.e. those that have only been declared (but not defined)
+    // in the current module
     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_TAG)
-      getTargetStreamer()->emitTagType(Sym);
-    else if (Sym->getType() == wasm::WASM_SYMBOL_TYPE_TABLE)
-      getTargetStreamer()->emitTableType(Sym);
+    if (!Sym->isDefined())
+      emitSymbolType(Sym);
   }
 
   DenseSet<MCSymbol *> InvokeSymbols;
   for (const auto &F : M) {
     if (F.isIntrinsic())
       continue;
 
     // Emit function type info for all undefined functions
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) {
+  // This is required to emit external declarations (like .functypes) when
+  // no functions are defined in the compilation unit and therefore,
+  // emitExternalDecls() is not called until now.
   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.
   for (const auto &F : M) {
for (auto &F : EmittedFeatures) {
     OutStreamer->emitULEB128IntValue(F.Name.size());
     OutStreamer->emitBytes(F.Name);
   }
 
   OutStreamer->PopSection();
 }
 
 void WebAssemblyAsmPrinter::emitConstantPool() {
+  emitExternalDecls(*MMI->getModule());
   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!
-  const_cast<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/WebAssemblyMCLowerPrePass.cpp

 ModulePass *llvm::createWebAssemblyMCLowerPrePass() {
   return new WebAssemblyMCLowerPrePass();
 }
 
 // NOTE: this is a ModulePass since we need to enforce that this code has run
 // for all functions before AsmPrinter. If this way of doing things is ever
 // suboptimal, we could opt to make it a MachineFunctionPass and instead use
 // something like createBarrierNoopPass() to enforce ordering.
+//
+// The information stored here is essential for emitExternalDecls in the Wasm
+// AsmPrinter
 bool WebAssemblyMCLowerPrePass::runOnModule(Module &M) {
   auto *MMIWP = getAnalysisIfAvailable<MachineModuleInfoWrapperPass>();
   if (!MMIWP)
     return true;
 
   MachineModuleInfo &MMI = MMIWP->getMMI();
   MachineModuleInfoWasm &MMIW = MMI.getObjFileInfo<MachineModuleInfoWasm>();
 

llvm/test/CodeGen/WebAssembly/externref-tableget.ll

 ; CHECK-NEXT:  end_function
   %j = call i32 @get_offset()
   %off = add nsw i32 %i, %j
   %p = getelementptr [0 x %externref], [0 x %externref] addrspace (1)* @externref_table, i32 0, i32 %off
   %ref = load %externref, %externref addrspace(1)* %p
   ret %externref %ref
 }
 
-; CHECK: .tabletype externref_table, externref
+; CHECK:       .tabletype externref_table, externref
+; CHECK-LABEL: externref_table:

llvm/test/CodeGen/WebAssembly/externref-tableset.ll

 ; CHECK-NEXT:  table.set       externref_table
 ; CHECK-NEXT:  end_function
   %id = call i32 @get_table_slot()
   %p = getelementptr [0 x %externref], [0 x %externref] addrspace (1)* @externref_table, i32 0, i32 %id
   store %externref %g, %externref addrspace(1)* %p
   ret void
 }
 
-; CHECK: .tabletype externref_table, externref
+;       CHECK: .tabletype externref_table, externref
+; CHECK-LABEL: externref_table:

llvm/test/CodeGen/WebAssembly/funcref-table_call.ll

 ; RUN: llc < %s --mtriple=wasm32-unknown-unknown -asm-verbose=false -mattr=+reference-types | FileCheck %s
 
 %funcptr = type void () addrspace(20)*
 %funcref = type i8 addrspace(20)* ;; addrspace 20 is nonintegral
 
 @funcref_table = local_unnamed_addr addrspace(1) global [0 x %funcref] undef
 
-define void @call_funcref_from_table(i32 %i) {
-  %p = getelementptr [0 x %funcref], [0 x %funcref] addrspace (1)* @funcref_table, i32 0, i32 %i
-  %ref = load %funcref, %funcref addrspace(1)* %p
-  %fn = bitcast %funcref %ref to %funcptr
-  call addrspace(20) void %fn()
-  ret void
-}
-
-; CHECK: .tabletype      __funcref_call_table, funcref, 1
+;  CHECK: .tabletype  __funcref_call_table, funcref, 1
 
+define void @call_funcref_from_table(i32 %i) {
 ; CHECK-LABEL: call_funcref_from_table:
 ; CHECK-NEXT: .functype       call_funcref_from_table (i32) -> ()
 ; CHECK-NEXT: i32.const       0
 ; CHECK-NEXT: local.get       0
 ; CHECK-NEXT: table.get       funcref_table
 ; CHECK-NEXT: table.set       __funcref_call_table
 ; CHECK-NEXT: i32.const       0
 ; CHECK-NEXT: call_indirect    __funcref_call_table, () -> ()
 ; CHECK-NEXT: i32.const       0
 ; CHECK-NEXT: ref.null_func
 ; CHECK-NEXT: table.set       __funcref_call_table
 ; CHECK-NEXT: end_function
+  %p = getelementptr [0 x %funcref], [0 x %funcref] addrspace (1)* @funcref_table, i32 0, i32 %i
+  %ref = load %funcref, %funcref addrspace(1)* %p
+  %fn = bitcast %funcref %ref to %funcptr
+  call addrspace(20) void %fn()
+  ret void
+}
 
-; CHECK: .tabletype     funcref_table, funcref
+;       CHECK: .tabletype funcref_table, funcref
+; CHECK-LABEL: funcref_table:
 

llvm/test/CodeGen/WebAssembly/funcref-tableget.ll

 ; CHECK-NEXT:  end_function
   %j = call i32 @get_offset()
   %off = add nsw i32 %i, %j
   %p = getelementptr [0 x %funcref], [0 x %funcref] addrspace (1)* @funcref_table, i32 0, i32 %off
   %ref = load %funcref, %funcref addrspace(1)* %p
   ret %funcref %ref
 }
 
-; CHECK: .tabletype funcref_table, funcref
+;       CHECK: .tabletype funcref_table, funcref
+; CHECK-LABEL: funcref_table:

llvm/test/CodeGen/WebAssembly/funcref-tableset.ll

 ; CHECK-NEXT:  end_function
   %j = call i32 @set_offset()
   %off = add nsw i32 %i, %j
   %p = getelementptr [0 x %funcref], [0 x %funcref] addrspace (1)* @funcref_table, i32 0, i32 %off
   store %funcref %g, %funcref addrspace(1)* %p
   ret void
 }
 
-; CHECK: .tabletype funcref_table, funcref
+;       CHECK: .tabletype funcref_table, funcref
+; CHECK-LABEL: funcref_table:

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

 ; CHECK-NEXT: functype       return_extern_i32_global () -> (i32)
 ; CHECK-NEXT: global.get i32_external_used
 ; CHECK-NEXT: end_function
   %v = load i32, i32 addrspace(1)* @i32_external_used
   ret i32 %v
 }
 
 
-; CHECK: .globl i32_global
 ; CHECK: .globaltype i32_global, i32
+; CHECK: .globl i32_global
 ; CHECK-LABEL: i32_global:
 
-; CHECK: .globl i64_global
 ; CHECK: .globaltype i64_global, i64
+; CHECK: .globl i64_global
 ; CHECK-LABEL: i64_global:
 
-; CHECK: .globl f32_global
 ; CHECK: .globaltype f32_global, f32
+; CHECK: .globl f32_global
 ; CHECK-LABEL: f32_global:
 
-; CHECK: .globl f64_global
 ; CHECK: .globaltype f64_global, f64
+; CHECK: .globl f64_global
 ; CHECK-LABEL: f64_global:
 
-; FIXME: are we still expecting these to be emitted?
-
+; CHECK: .globaltype i32_external_used, i32
 ; CHECK-NOT: .global i32_external_used
-; CHECK-NOT: .globaltype i32_external_used, i32
 ; CHECK-NOT: i32_external_used:
 
+; CHECK: .globaltype i32_external_unused, i32
 ; CHECK-NOT: .global i32_external_unused
-; CHECK-NOT: .globaltype i32_external_unused, i32
 ; CHECK-NOT: i32_external_unused:

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

 ; CHECK-NEXT: functype       set_f64_global (f64) -> ()
 ; CHECK-NEXT: local.get 0
 ; CHECK-NEXT: global.set f64_global
 ; CHECK-NEXT: end_function
   store double %v, double addrspace(1)* @f64_global
   ret void
 }
 
-; CHECK: .globl i32_global
 ; CHECK: .globaltype i32_global, i32
+; CHECK: .globl i32_global
 ; CHECK-LABEL: i32_global:
 
-; CHECK: .globl i64_global
 ; CHECK: .globaltype i64_global, i64
+; CHECK: .globl i64_global
 ; CHECK-LABEL: i64_global:
 
-; CHECK: .globl f32_global
 ; CHECK: .globaltype f32_global, f32
+; CHECK: .globl f32_global
 ; CHECK-LABEL: f32_global:
 
-; CHECK: .globl f64_global
 ; CHECK: .globaltype f64_global, f64
+; CHECK: .globl f64_global
 ; CHECK-LABEL: f64_global:

llvm/test/CodeGen/WebAssembly/only-data.ll

+; RUN: llc < %s --mtriple=wasm32-unknown-unknown -asm-verbose=false -mattr=+reference-types | FileCheck %s
+; Verify that types are output for external symbols, even in the absence of any defined functions
+
+;      CHECK: .type foo,@object
+; CHECK-NEXT: .section .data.foo,"",@
+; CHECK-NEXT: .globl foo
+@foo = local_unnamed_addr global i32 (i32)* @bar, align 4
+
+; CHECK-LABEL: foo:
+;  CHECK-NEXT: .int32 bar
+;  CHECK-NEXT: .size foo, 4
+
+; CHECK: .functype bar (i32) -> (i32)
+declare i32 @bar(i32 noundef)

llvm/test/CodeGen/WebAssembly/table-types.ll

+; RUN: llc < %s --mtriple=wasm32-unknown-unknown -asm-verbose=false -mattr=+reference-types | FileCheck %s
+
+%extern = type opaque
+%externref = type %extern addrspace(10)* ;; addrspace 10 is nonintegral
+
+%func = type void ()
+%funcref = type %func addrspace(20)* ;; addrspace 20 is nonintegral
+
+; CHECK: .tabletype eref_table, externref
+; CHECK-NEXT: .globl eref_table
+; CHECK-LABEL: eref_table:
+@eref_table = local_unnamed_addr addrspace(1) global [0 x %externref] undef
+
+; CHECK-NOT: .globl .Lprivate_eref_table
+; CHECK: .tabletype .Lprivate_eref_table, externref
+; CHECK-LABEL: .Lprivate_eref_table:
+@private_eref_table = private local_unnamed_addr addrspace(1) global [0 x %externref] undef
+
+; CHECK: .tabletype extern_eref_table, externref
+; CHECK-NOT: .globl extern_eref_table
+; CHECK-NOT: extern_eref_table:
+@extern_eref_table = external addrspace(1) global [0 x %externref]
+
+; CHECK: .tabletype fref_table, funcref
+; CHECK-NEXT: .globl fref_table
+; CHECK-LABEL: fref_table:
+@fref_table = local_unnamed_addr addrspace(1) global [0 x %funcref] undef
+
+; CHECK-NOT: .globl .Lprivate_fref_table
+; CHECK: .tabletype .Lprivate_fref_table, funcref
+; CHECK-LABEL: .Lprivate_fref_table:
+@private_fref_table = private local_unnamed_addr addrspace(1) global [0 x %funcref] undef
+
+; CHECK: .tabletype extern_fref_table, funcref
+; CHECK-NOT: .globl extern_fref_table
+; CHECK-NOT: extern_fref_table:
+@extern_fref_table = external addrspace(1) global [0 x %funcref]

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

entry:
   ret void
 }
 
 ; 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:        .globl  foo
 ; ASM:      foo:
 ; ASM-NEXT:   .functype foo (i32) -> ()
 ; ASM-NEXT:   call  bar
 ; ASM-NEXT:   end_function
 
 
 ; CHECK:      --- !WASM
 ; CHECK-NEXT: FileHeader:

llvm/test/MC/WebAssembly/stack-ptr-mclower.ll

 ; RUN: llc --mtriple=wasm32-unknown-unknown -asm-verbose=false %s -o - | FileCheck --check-prefixes CHECK -DPTR=i32 %s
 ; RUN: llc --mtriple=wasm64-unknown-unknown -asm-verbose=false %s -o - | FileCheck --check-prefixes CHECK -DPTR=i64 %s
 
 ; empty function that does not use stack, to check WebAssemblyMCLowerPrePass
 ; works correctly.
 define hidden void @bar() #0 {
   ret void
 }
 
 ; Function that uses explict stack, and should generate a reference to
-; __stack_pointer, along with the corresponding reloction entry.
+; __stack_pointer, along with the corresponding relocation entry.
 define hidden void @foo() #0 {
 entry:
   alloca i32, align 4
   ret void
 }
 
 ; CHECK:              .text
 ; CHECK-NEXT:         .file   "stack-ptr-mclower.ll"
+; CHECK-NEXT:         .globaltype     __stack_pointer, [[PTR]]
 ; CHECK-NEXT:         .section        .text.bar,"",@
 ; CHECK-NEXT:         .hidden bar
 ; CHECK-NEXT:         .globl  bar
-; CHECK-NEXT:         .globaltype     __stack_pointer, [[PTR]]
 ; CHECK-NEXT:         .type   bar,@function
 ; CHECK-NEXT: bar:
 ; CHECK-NEXT:         .functype       bar () -> ()
 ; CHECK-NEXT:         end_function
 ; CHECK-NEXT: .Lfunc_end0:
 ; CHECK-NEXT:         .size   bar, .Lfunc_end0-bar
 
 ; CHECK:              .section        .text.foo,"",@