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

[pmatos]

Summary

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]

@sbc100 I addressed your questions regarding this part of the patch in D115749. I think it's ready for your review.

[pmatos]

Move the removal of some lines setting table global type from D118121 to this revision.

llvm/lib/Target/WebAssembly/WebAssemblyAsmPrinter.cpp

190

@sbc100 the lines that were being previously removed in D118121, are now here.

[sbc100]

lgtm % comments

llvm/lib/Target/WebAssembly/WebAssemblyAsmPrinter.cpp

270

Does this happen? i.e. are there symbols that don't have their type set at this point?

360

I guess this was here to handle the case that emitLinkage was never called? Does that not apply to emitConstantPool too?

In other words, why remove this line?

[pmatos]

llvm/lib/Target/WebAssembly/WebAssemblyAsmPrinter.cpp

270

Yes, just set a breakpoint on the return line (270) and run simd-arith.ll and you'll see a few cases of this.

[pmatos]

llvm/lib/Target/WebAssembly/WebAssemblyAsmPrinter.cpp

360

So - in all my tests I couldn't find a reason for this line to exist. And I noticed that whenever it was called, it had generally been called through emitLinkage.

With this patch, emitExternalDecls is not called unless there are functions in the compilation unit. Globals are still emitted properly through emitGlobalVariable though. So this only leaves symbols that are necessary for use in functions, I think. But if those functions exist, they are emitted anyway, so I don't see the need for this.

Note that before this patch, this line was needed because we were emitting global symbol types in emitExternalDecls, and now we have move that to emitGlobalVariable.

[bkramer]

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

2

This test crashes with -fsanitize=null because Subtarget is a nullptr.

llvm/lib/Target/WebAssembly/WebAssemblyAsmPrinter.cpp:183:56: runtime error: member call on null pointer of type 'llvm::WebAssemblySubtarget'
    #0 0x565025dd6a86 in llvm::WebAssemblyAsmPrinter::emitGlobalVariable(llvm::GlobalVariable const*) llvm/lib/Target/WebAssembly/WebAssemblyAsmPrinter.cpp:183:56
    #1 0x56502684357b in llvm::AsmPrinter::doFinalization(llvm::Module&) llvm/lib/CodeGen/AsmPrinter/AsmPrinter.cpp:1756:5
    #2 0x56502b16810e in llvm::FPPassManager::doFinalization(llvm::Module&) llvm/lib/IR/LegacyPassManager.cpp:1499:41
    #3 0x56502b1558ea in runOnModule llvm/lib/IR/LegacyPassManager.cpp:1586:41
    #4 0x56502b1558ea in llvm::legacy::PassManagerImpl::run(llvm::Module&) llvm/lib/IR/LegacyPassManager.cpp:540:44
    #5 0x56502b1683a4 in llvm::legacy::PassManager::run(llvm::Module&) llvm/lib/IR/LegacyPassManager.cpp:1677:14
    #6 0x5650238100ae in compileModule(char**, llvm::LLVMContext&) llvm/tools/llc/llc.cpp:719:8
    #7 0x565023809fb6 in main llvm/tools/llc/llc.cpp:417:22

Probably not the fault of this change though, it just happens when there is no function. Any ideas how to fix it?

[pmatos]

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

2

@bkramer Thanks for pointing this out. I am not at work atm. I will take a look as soon as I return. Feel free to revert if its causing some issues elsewhere. I am surprised you found this. I ran regularly all tests. Is there a specific mode which includes running tests with sanitizers?

[kda]

This has broken fast buildbot: https://lab.llvm.org/buildbot/#/builders/5/builds/18257/steps/16/logs/stdio

I will revert in 60 minutes.

[kda]

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

2

for reproducing as buildbot does:
https://github.com/google/sanitizers/wiki/SanitizerBotReproduceBuild

[sbc100]

Sadly this appears to also be breaking the emscripten CI:

https://ci.chromium.org/ui/p/emscripten-releases/builders/try/linux/b8823500584349280721/overview

Sample failure:

test_unistd_unlink (test_core.core0) ... 
wasm-ld: error: symbol type mismatch: __stdio_write
>>> defined as WASM_SYMBOL_TYPE_FUNCTION in /usr/local/google/home/sbc/dev/wasm/emscripten/cache/sysroot/lib/wasm32-emscripten/libc-debug.a(__stdio_write.o)
>>> defined as WASM_SYMBOL_TYPE_DATA in /usr/local/google/home/sbc/dev/wasm/emscripten/cache/sysroot/lib/wasm32-emscripten/libc-debug.a(stderr.o)

I guess we should revert

[sbc100]

The emscripten breakage appears to be related to missing function types when function are only references in static data. For example musl's stderr.c: https://github.com/emscripten-core/emscripten/blob/6754be32129e9392a2d1f684a1d02172cda0d640/system/lib/libc/musl/src/stdio/stderr.c#L12-L14

Without this change __stdio_close/seek/write get .function_type directives and with this change they don't. i.e. These lines are missing after this change:

	.functype	__stdio_close (i32) -> (i32)
	.functype	__stdio_write (i32, i32, i32) -> (i32)
	.functype	__stdio_seek (i32, i64, i32) -> (i64)

I'm guessing this is because this translation unit contains no functions.. only data.

[sbc100]

I guess that re-enabling the emitExternalDecls in emitEndOfAsmFile would fix the emscripten issue (although that points to a missing test case). Not sure about the other failures reported here.

[pmatos]

In D118122#3287371, @sbc100 wrote:

I guess that re-enabling the emitExternalDecls in emitEndOfAsmFile would fix the emscripten issue (although that points to a missing test case). Not sure about the other failures reported here.

I have now added a missing test case and confirmed that the emitExternalsDecls is required in emitEndOfAsmFile.
The null Subtarget issue was supposed to be simple to fix. The Subtarget field is set on a per-function basis and we use that to obtain the TLI. The problem is, if you have no functions defined in the file Subtarget will always be null and never be set. We therefore need to obtain the TLI to pass to computeLegalValuesVT using some other way. I have however been looking at this for over an hour now and for some reason that escapes me the TLI seems to always be linked to a function and not obtainable otherwise. I will need to keep investigating this to be able to push a new patch.

[pmatos]

I confirmed with Anton K. in discord that indeed it's not possible to obtain a TLI outside a function, because a function can change the subtarget. Apparently ARM allows this with ARM vs Thumb functions being defined in the same file.

That means that we either reimplement computeLegalValueVTs such that it doesn't need to call TLI.getNumRegisters nor TLI.getRegisterType(), or find a way not to call it at all. I am continuing my investigation.

[pmatos]

Attempting to reland this with D118995 after fixing issues found.

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

void WebAssemblyAsmPrinter::emitGlobalVariable(const GlobalVariable *GV) {
   if (!Sym->getType()) {
     const WebAssemblyTargetLowering &TLI = *Subtarget->getTargetLowering();
     SmallVector<MVT, 1> VTs;
     Type *GlobalVT = GV->getValueType();
     computeLegalValueVTs(TLI, GV->getParent()->getContext(),
                          GV->getParent()->getDataLayout(), GlobalVT, VTs);
     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) {
-  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) {
     if (!F.isIntrinsic() && F.hasAddressTaken()) {
for (auto &F : EmittedFeatures) {
     OutStreamer->emitULEB128IntValue(F.Name.size());
     OutStreamer->emitBytes(F.Name);
   }
 
   OutStreamer->PopSection();
 }
 
 void WebAssemblyAsmPrinter::emitConstantPool() {
+  const Module *M = MMI->getModule();
+  emitExternalDecls(*M);
   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/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,"",@