[WebAssembly] Switch to a more traditional assembly syntax

[sunfish]

Summary

The s-expression syntax is problematic for MC because it requires nested instructions, nested control flow, and entirely custom handling of static initializers. Instead of using s-expressions as the immediate output of the compiler, use a more traditional-looking assembly syntax using a stack-machine-like mechanism to represent nesting.

[jfb]

I haven't reviewed the patch itself yet, but I'd like to bring up an issue: we definitely want to do this move for the reasons you outline (as we've discussed offline), but I think we should first get the code support further along so we can get an end-to-end prototype working using s-epxressions first. Once we have this, then browsers can play with a specific version of LLVM while we fix the bigger issues that you outline.

Do you think we could first finalize control flow and linear memory initialization, snapshot things, and then apply this patch?

[sunfish]

Rebased, and shrunk with parts of this patch being checked in independently.

[jfb]

This looks great. Only a few minor things, otherwise lgtm.

lib/Target/WebAssembly/WebAssemblyAsmPrinter.cpp

122

Comment that wasm arguments and locals are in the same number space, with args coming first (and there are no vaargs).

173–174

Is this check needed? It seems like the below code does the right thing without it.

211

Should we just drop GLOBAL since it's not in the design anymore?

238

Move NeedComma = true; to here?

239

Create a new string here instead?

242

@pop is a bit confusing since it's more of an internal opcode not an identifier (which we use @ for). Maybe %pop or something (since we're already using $ and # looks like a comment)?

[sunfish]

lib/Target/WebAssembly/WebAssemblyAsmPrinter.cpp

173–174

EmitRawText automatically appends a newline, so this avoids printing an extra newline in that case.

211

We need to keep global addresses symbolic until link time. So even if wasm itself doesn't have GLOBAL, we need something like it at this stage.

242

How about just pop?

[sunfish]

Update for review comments.

[jfb]

lib/Target/WebAssembly/WebAssemblyAsmPrinter.cpp

242

sgtm

[sunfish]

Commited in r249364. Thanks!

lib/Target/WebAssembly/MCTargetDesc/WebAssemblyMCAsmInfo.cpp

 
 WebAssemblyMCAsmInfo::~WebAssemblyMCAsmInfo() {}
 
 WebAssemblyMCAsmInfo::WebAssemblyMCAsmInfo(const Triple &T) {
   PointerSize = CalleeSaveStackSlotSize = T.isArch64Bit() ? 8 : 4;
 
   // TODO: What should MaxInstLength be?
 
-  // The s-expression format of WebAssembly uses LISP-style comments.
-  CommentString = ";;";
-
   PrivateGlobalPrefix = "";
   PrivateLabelPrefix = "";
 
   UseDataRegionDirectives = true;
 
   Data8bitsDirective = "\t.int8\t";
   Data16bitsDirective = "\t.int16\t";
   Data32bitsDirective = "\t.int32\t";
   Data64bitsDirective = "\t.int64\t";
 
   AlignmentIsInBytes = false;
   COMMDirectiveAlignmentIsInBytes = false;
   LCOMMDirectiveAlignmentType = LCOMM::Log2Alignment;
 
-  HasDotTypeDotSizeDirective = false;
-  HasSingleParameterDotFile = false;
-
   SupportsDebugInformation = true;
 
   // For now, WebAssembly does not support exceptions.
   ExceptionsType = ExceptionHandling::None;
 
-  // FIXME: modify AsmPrinter to be more flexible, and fix other virtual ISAs.
-  WeakDirective = "\t;; .weak\t";
-  GlobalDirective = "\t;; .globl\t";
-
   // TODO: UseIntegratedAssembler?
 }

lib/Target/WebAssembly/WebAssemblyAsmPrinter.cpp

bool runOnMachineFunction(MachineFunction &MF) override {
     TII = Subtarget.getInstrInfo();
     return AsmPrinter::runOnMachineFunction(MF);
   }
 
   //===------------------------------------------------------------------===//
   // AsmPrinter Implementation.
   //===------------------------------------------------------------------===//
 
-  void EmitGlobalVariable(const GlobalVariable *GV) override;
-
   void EmitJumpTableInfo() override;
   void EmitConstantPool() override;
-  void EmitFunctionEntryLabel() override;
   void EmitFunctionBodyStart() override;
-  void EmitFunctionBodyEnd() override;
 
   void EmitInstruction(const MachineInstr *MI) override;
 
   static std::string toString(const APFloat &APF);
   const char *toString(Type *Ty) const;
 };
 
 } // end anonymous namespace
std::string WebAssemblyAsmPrinter::toString(const APFloat &FP) {
   assert(Written < BufBytes);
   return buf;
 }
 
 const char *WebAssemblyAsmPrinter::toString(Type *Ty) const {
   switch (Ty->getTypeID()) {
   default:
     break;
   // Treat all pointers as the underlying integer into linear memory.
   case Type::PointerTyID:
     switch (getPointerSize()) {
     case 4:
       return "i32";
     case 8:
       return "i64";
     default:
       llvm_unreachable("unsupported pointer size");
const char *WebAssemblyAsmPrinter::toString(Type *Ty) const {
   llvm_unreachable("invalid type");
   return "<invalid>";
 }
 
 //===----------------------------------------------------------------------===//
 // WebAssemblyAsmPrinter Implementation.
 //===----------------------------------------------------------------------===//
 
-void WebAssemblyAsmPrinter::EmitGlobalVariable(const GlobalVariable *GV) {
-  SmallString<128> Str;
-  raw_svector_ostream OS(Str);
-  StringRef Name = GV->getName();
-  DEBUG(dbgs() << "Global " << Name << '\n');
-
-  if (!GV->hasInitializer()) {
-    DEBUG(dbgs() << "  Skipping declaration.\n");
-    return;
-  }
-
-  // Check to see if this is a special global used by LLVM.
-  static const char *Ignored[] = {"llvm.used", "llvm.metadata"};
-  for (const char *I : Ignored)
-    if (Name == I)
-      return;
-  // FIXME: Handle the following globals.
-  static const char *Unhandled[] = {"llvm.global_ctors", "llvm.global_dtors"};
-  for (const char *U : Unhandled)
-    if (Name == U)
-      report_fatal_error("Unhandled global");
-  if (Name.startswith("llvm."))
-    report_fatal_error("Unknown LLVM-internal global");
-
-  if (GV->isThreadLocal())
-    report_fatal_error("TLS isn't yet supported by WebAssembly");
-
-  const DataLayout &DL = getDataLayout();
-  const Constant *Init = GV->getInitializer();
-  if (isa<UndefValue>(Init))
-    Init = Constant::getNullValue(Init->getType());
-  unsigned Align = DL.getPrefTypeAlignment(Init->getType());
-
-  switch (GV->getLinkage()) {
-  case GlobalValue::InternalLinkage:
-  case GlobalValue::PrivateLinkage:
-    break;
-  case GlobalValue::AppendingLinkage:
-  case GlobalValue::LinkOnceAnyLinkage:
-  case GlobalValue::LinkOnceODRLinkage:
-  case GlobalValue::WeakAnyLinkage:
-  case GlobalValue::WeakODRLinkage:
-  case GlobalValue::ExternalLinkage:
-  case GlobalValue::CommonLinkage:
-    report_fatal_error("Linkage types other than internal and private aren't "
-                       "supported by WebAssembly yet");
-  default:
-    llvm_unreachable("Unknown linkage type");
-    return;
-  }
-
-  OS << "(global " << toSymbol(Name) << ' ' << toString(Init->getType()) << ' ';
-  if (const auto *C = dyn_cast<ConstantInt>(Init)) {
-    assert(C->getBitWidth() <= 64 && "Printing wider types unimplemented");
-    OS << C->getZExtValue();
-  } else if (const auto *C = dyn_cast<ConstantFP>(Init)) {
-    OS << toString(C->getValueAPF());
-  } else {
-    assert(false && "Only integer and floating-point constants are supported");
-  }
-  OS << ") ;; align " << Align;
-  OutStreamer->EmitRawText(OS.str());
-}
-
 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::EmitFunctionEntryLabel() {
-  SmallString<128> Str;
-  raw_svector_ostream OS(Str);
-
-  CurrentFnSym->redefineIfPossible();
-
-  // The function label could have already been emitted if two symbols end up
-  // conflicting due to asm renaming.  Detect this and emit an error.
-  if (CurrentFnSym->isVariable())
-    report_fatal_error("'" + Twine(CurrentFnSym->getName()) +
-                       "' is a protected alias");
-  if (CurrentFnSym->isDefined())
-    report_fatal_error("'" + Twine(CurrentFnSym->getName()) +
-                       "' label emitted multiple times to assembly file");
-
-  OS << "(func " << toSymbol(CurrentFnSym->getName());
-  OutStreamer->EmitRawText(OS.str());
-}
-
 void WebAssemblyAsmPrinter::EmitFunctionBodyStart() {
-  SmallString<128> Str;
-  raw_svector_ostream OS(Str);
   const Function *F = MF->getFunction();
   Type *Rt = F->getReturnType();
-  if (!Rt->isVoidTy() || !F->arg_empty()) {
-    for (const Argument &A : F->args())
-      OS << " (param " << toString(A.getType()) << ')';
-    if (!Rt->isVoidTy())
-      OS << " (result " << toString(Rt) << ')';
-    OutStreamer->EmitRawText(OS.str());
-  }
-}
 
-void WebAssemblyAsmPrinter::EmitFunctionBodyEnd() {
+  if (!Rt->isVoidTy() || !F->arg_empty()) {
     SmallString<128> Str;
     raw_svector_ostream OS(Str);
-  OS << ") ;; end func " << toSymbol(CurrentFnSym->getName());
+    bool First = true;
+    for (const Argument &A : F->args()) {
+      OS << (First ? "" : "\n") << "\t" ".param " << toString(A.getType());
+      First = false;
+    }
+    if (!Rt->isVoidTy()) {
+      OS << (First ? "" : "\n") << "\t" ".result " << toString(Rt);
+      First = false;
+    }
     OutStreamer->EmitRawText(OS.str());
   }
 
+  AsmPrinter::EmitFunctionBodyStart();
+}
+
 void WebAssemblyAsmPrinter::EmitInstruction(const MachineInstr *MI) {
   DEBUG(dbgs() << "EmitInstruction: " << *MI << '\n');
   SmallString<128> Str;
   raw_svector_ostream OS(Str);
 
   unsigned NumDefs = MI->getDesc().getNumDefs();
   assert(NumDefs <= 1 &&
          "Instructions with multiple result values not implemented");
 
   OS << '\t';
 
-  if (NumDefs != 0) {
-    const MachineOperand &MO = MI->getOperand(0);
-    unsigned Reg = MO.getReg();
-    OS << "(setlocal @" << TargetRegisterInfo::virtReg2Index(Reg) << ' ';
-  }
-
   if (MI->getOpcode() == WebAssembly::COPY) {
     OS << '@' << TargetRegisterInfo::virtReg2Index(MI->getOperand(1).getReg());
   } else {
-    OS << '(' << OpcodeName(TII, MI);
-    for (const MachineOperand &MO : MI->uses())
+    OS << OpcodeName(TII, MI);
+    bool NeedComma = false;
+    for (const MachineOperand &MO : MI->uses()) {
+      if (MO.isReg() && MO.isImplicit())
+        continue;
+      if (NeedComma)
+        OS << ',';
+      OS << ' ';
       switch (MO.getType()) {
       default:
         llvm_unreachable("unexpected machine operand type");
-      case MachineOperand::MO_Register: {
-        if (MO.isImplicit())
-          continue;
-        unsigned Reg = MO.getReg();
-        OS << " @" << TargetRegisterInfo::virtReg2Index(Reg);
-      } break;
-      case MachineOperand::MO_Immediate: {
-        OS << ' ' << MO.getImm();
-      } break;
-      case MachineOperand::MO_FPImmediate: {
-        OS << ' ' << toString(MO.getFPImm()->getValueAPF());
-      } break;
-      case MachineOperand::MO_GlobalAddress: {
-        OS << ' ' << toSymbol(MO.getGlobal()->getName());
-      } break;
-      case MachineOperand::MO_MachineBasicBlock: {
-        OS << ' ' << toSymbol(MO.getMBB()->getSymbol()->getName());
-      } break;
-      }
-    OS << ')';
+      case MachineOperand::MO_Register:
+        OS << '@' << TargetRegisterInfo::virtReg2Index(MO.getReg());
+        break;
+      case MachineOperand::MO_Immediate:
+        OS << MO.getImm();
+        break;
+      case MachineOperand::MO_FPImmediate:
+        OS << toString(MO.getFPImm()->getValueAPF());
+        break;
+      case MachineOperand::MO_GlobalAddress:
+        OS << toSymbol(MO.getGlobal()->getName());
+        break;
+      case MachineOperand::MO_MachineBasicBlock:
+        OS << toSymbol(MO.getMBB()->getSymbol()->getName());
+        break;
+      }
+      NeedComma = true;
   }
 
-  if (NumDefs != 0)
-    OS << ')';
+  OutStreamer->EmitRawText(OS.str());
 
+  if (NumDefs != 0) {
+    Str.clear();
+    OS << "\t" "setlocal "
+          "@" << TargetRegisterInfo::virtReg2Index(MI->getOperand(0).getReg());
     OutStreamer->EmitRawText(OS.str());
   }
+}
 
 // Force static initialization.
 extern "C" void LLVMInitializeWebAssemblyAsmPrinter() {
   RegisterAsmPrinter<WebAssemblyAsmPrinter> X(TheWebAssemblyTarget32);
   RegisterAsmPrinter<WebAssemblyAsmPrinter> Y(TheWebAssemblyTarget64);
 }

test/CodeGen/WebAssembly/call.ll

 ; RUN: llc < %s -asm-verbose=false | FileCheck %s
 
 ; Test that basic call operations assemble as expected.
 
 target datalayout = "e-p:32:32-i64:64-n32:64-S128"
 target triple = "wasm32-unknown-unknown"
 
 declare i32 @i32_nullary()
 declare i32 @i32_unary(i32)
 declare i32 @i32_binary(i32, i32)
 declare i64 @i64_nullary()
 declare float @float_nullary()
 declare double @double_nullary()
 declare void @void_nullary()
 
-; CHECK-LABEL: (func $call_i32_nullary
-; CHECK-NEXT: (result i32)
-; CHECK-NEXT: (setlocal @0 (global $i32_nullary))
-; CHECK-NEXT: (setlocal @1 (call @0))
-; CHECK-NEXT: (return @1)
+; CHECK-LABEL: call_i32_nullary:
+; CHECK-NEXT: .result i32{{$}}
+; CHECK-NEXT: global $i32_nullary
+; CHECK-NEXT: setlocal @0{{$}}
+; CHECK-NEXT: call @0{{$}}
+; CHECK-NEXT: setlocal @1{{$}}
+; CHECK-NEXT: return @1{{$}}
 define i32 @call_i32_nullary() {
   %r = call i32 @i32_nullary()
   ret i32 %r
 }
 
-; CHECK-LABEL: (func $call_i64_nullary
-; CHECK-NEXT: (result i64)
-; CHECK-NEXT: (setlocal @0 (global $i64_nullary))
-; CHECK-NEXT: (setlocal @1 (call @0))
-; CHECK-NEXT: (return @1)
+; CHECK-LABEL: call_i64_nullary:
+; CHECK-NEXT: .result i64{{$}}
+; CHECK-NEXT: global $i64_nullary
+; CHECK-NEXT: setlocal @0{{$}}
+; CHECK-NEXT: call @0{{$}}
+; CHECK-NEXT: setlocal @1{{$}}
+; CHECK-NEXT: return @1{{$}}
 define i64 @call_i64_nullary() {
   %r = call i64 @i64_nullary()
   ret i64 %r
 }
 
-; CHECK-LABEL: (func $call_float_nullary
-; CHECK-NEXT: (result f32)
-; CHECK-NEXT: (setlocal @0 (global $float_nullary))
-; CHECK-NEXT: (setlocal @1 (call @0))
-; CHECK-NEXT: (return @1)
+; CHECK-LABEL: call_float_nullary:
+; CHECK-NEXT: .result f32{{$}}
+; CHECK-NEXT: global $float_nullary
+; CHECK-NEXT: setlocal @0{{$}}
+; CHECK-NEXT: call @0{{$}}
+; CHECK-NEXT: setlocal @1{{$}}
+; CHECK-NEXT: return @1{{$}}
 define float @call_float_nullary() {
   %r = call float @float_nullary()
   ret float %r
 }
 
-; CHECK-LABEL: (func $call_double_nullary
-; CHECK-NEXT: (result f64)
-; CHECK-NEXT: (setlocal @0 (global $double_nullary))
-; CHECK-NEXT: (setlocal @1 (call @0))
-; CHECK-NEXT: (return @1)
+; CHECK-LABEL: call_double_nullary:
+; CHECK-NEXT: .result f64{{$}}
+; CHECK-NEXT: global $double_nullary
+; CHECK-NEXT: setlocal @0{{$}}
+; CHECK-NEXT: call @0{{$}}
+; CHECK-NEXT: setlocal @1{{$}}
+; CHECK-NEXT: return @1{{$}}
 define double @call_double_nullary() {
   %r = call double @double_nullary()
   ret double %r
 }
 
-; CHECK-LABEL: (func $call_void_nullary
-; CHECK-NEXT: (setlocal @0 (global $void_nullary))
-; CHECK-NEXT: (call @0)
-; CHECK-NEXT: (return)
+; CHECK-LABEL: call_void_nullary:
+; CHECK-NEXT: global $void_nullary
+; CHECK-NEXT: setlocal @0{{$}}
+; CHECK-NEXT: call @0{{$}}
+; CHECK-NEXT: return{{$}}
 define void @call_void_nullary() {
   call void @void_nullary()
   ret void
 }
 
-; CHECK-LABEL: (func $call_i32_unary
-; CHECK-NEXT: (param i32) (result i32)
-; CHECK-NEXT: (setlocal @0 (argument 0))
-; CHECK-NEXT: (setlocal @1 (global $i32_unary))
-; CHECK-NEXT: (setlocal @2 (call @1 @0))
-; CHECK-NEXT: (return @2)
+; CHECK-LABEL: call_i32_unary:
+; CHECK-NEXT: .param i32{{$}}
+; CHECK-NEXT: .result i32{{$}}
+; CHECK-NEXT: argument 0{{$}}
+; CHECK-NEXT: setlocal @0{{$}}
+; CHECK-NEXT: global $i32_unary
+; CHECK-NEXT: setlocal @1{{$}}
+; CHECK-NEXT: call @1, @0{{$}}
+; CHECK-NEXT: setlocal @2{{$}}
+; CHECK-NEXT: return @2{{$}}
 define i32 @call_i32_unary(i32 %a) {
   %r = call i32 @i32_unary(i32 %a)
   ret i32 %r
 }
 
-; CHECK-LABEL: (func $call_i32_binary
-; CHECK-NEXT: (param i32) (param i32) (result i32)
-; CHECK-NEXT: (setlocal @0 (argument 1))
-; CHECK-NEXT: (setlocal @1 (argument 0))
-; CHECK-NEXT: (setlocal @2 (global $i32_binary))
-; CHECK-NEXT: (setlocal @3 (call @2 @1 @0))
-; CHECK-NEXT: (return @3)
+; CHECK-LABEL: call_i32_binary:
+; CHECK-NEXT: .param i32{{$}}
+; CHECK-NEXT: .param i32{{$}}
+; CHECK-NEXT: .result i32{{$}}
+; CHECK-NEXT: argument 1{{$}}
+; CHECK-NEXT: setlocal @0{{$}}
+; CHECK-NEXT: argument 0{{$}}
+; CHECK-NEXT: setlocal @1{{$}}
+; CHECK-NEXT: global $i32_binary
+; CHECK-NEXT: setlocal @2{{$}}
+; CHECK-NEXT: call @2, @1, @0{{$}}
+; CHECK-NEXT: setlocal @3{{$}}
+; CHECK-NEXT: return @3{{$}}
 define i32 @call_i32_binary(i32 %a, i32 %b) {
   %r = call i32 @i32_binary(i32 %a, i32 %b)
   ret i32 %r
 }
 
 ; FIXME test the following:
 ;  - Functions without return.
 ;  - More argument combinations.
 ;  - Tail call.
 ;  - Interesting returns (struct, multiple).
 ;  - Vararg.

test/CodeGen/WebAssembly/cfg-stackify.ll

 ; RUN: llc < %s -asm-verbose=false | FileCheck %s
 
 ; Test the CFG stackifier pass.
 
 target datalayout = "e-p:32:32-i64:64-n32:64-S128"
 target triple = "wasm32-unknown-unknown"
 
 declare void @something()
 
 ; Test that loops are made contiguous, even in the presence of split backedges.
 
-; CHECK-LABEL: test0
-; CHECK: (loop
-; CHECK: (add
-; CHECK: (brif
-; CHECK: (call
-; CHECK: (br $BB0_1)
-; CHECK: (return)
+; CHECK-LABEL: test0:
+; CHECK: loop
+; CHECK: add
+; CHECK: brif
+; CHECK: call
+; CHECK: br $BB0_1{{$}}
+; CHECK: return{{$}}
 define void @test0(i32 %n) {
 entry:
   br label %header
 
 header:
   %i = phi i32 [ 0, %entry ], [ %i.next, %back ]
   %i.next = add i32 %i, 1
 
   %c = icmp slt i32 %i.next, %n
   br i1 %c, label %back, label %exit
 
 exit:
   ret void
 
 back:
   call void @something()
   br label %header
 }
 
 ; Same as test0, but the branch condition is reversed.
 
-; CHECK-LABEL: test1
-; CHECK: (loop
-; CHECK: (add
-; CHECK: (brif
-; CHECK: (call
-; CHECK: (br $BB1_1)
-; CHECK: (return)
+; CHECK-LABEL: test1:
+; CHECK: loop
+; CHECK: add
+; CHECK: brif
+; CHECK: call
+; CHECK: br $BB1_1{{$}}
+; CHECK: return{{$}}
 define void @test1(i32 %n) {
 entry:
   br label %header
 
 header:
   %i = phi i32 [ 0, %entry ], [ %i.next, %back ]
   %i.next = add i32 %i, 1
 
   %c = icmp sge i32 %i.next, %n
   br i1 %c, label %exit, label %back
 
 exit:
   ret void
 
 back:
   call void @something()
   br label %header
 }
 
 ; Test that a simple loop is handled as expected.
 
-; CHECK-LABEL: test2
-; CHECK: (block $BB2_2)
-; CHECK: (brif $BB2_2 {{.*}})
+; CHECK-LABEL: test2:
+; CHECK: block $BB2_2{{$}}
+; CHECK: brif $BB2_2, {{.*}}
 ; CHECK: BB2_1:
-; CHECK: (brif $BB2_1 @14)
+; CHECK: brif $BB2_1, @14{{$}}
 ; CHECK: BB2_2:
-; CHECK: (return)
+; CHECK: return{{$}}
 define void @test2(double* nocapture %p, i32 %n) {
 entry:
   %cmp.4 = icmp sgt i32 %n, 0
   br i1 %cmp.4, label %for.body.preheader, label %for.end
 
 for.body.preheader:
   br label %for.body
 

 
 for.end.loopexit:
   br label %for.end
 
 for.end:
   ret void
 }
 
-; CHECK-LABEL: doublediamond
-; CHECK: (block $BB3_5)
-; CHECK: (block $BB3_4)
-; CHECK: (block $BB3_2)
-; CHECK: (brif $BB3_2 @4)
-; CHECK: (br $BB3_5)
+; CHECK-LABEL: doublediamond:
+; CHECK: block $BB3_5{{$}}
+; CHECK: block $BB3_4{{$}}
+; CHECK: block $BB3_2{{$}}
+; CHECK: brif $BB3_2, @4{{$}}
+; CHECK: br $BB3_5{{$}}
 ; CHECK: BB3_2:
-; CHECK: (brif $BB3_4 @7)
-; CHECK: (br $BB3_5)
+; CHECK: brif $BB3_4, @7{{$}}
+; CHECK: br $BB3_5{{$}}
 ; CHECK: BB3_4:
 ; CHECK: BB3_5:
-; CHECK: (return @3)
+; CHECK: return @3{{$}}
 define i32 @doublediamond(i32 %a, i32 %b, i32* %p) {
 entry:
   %c = icmp eq i32 %a, 0
   %d = icmp eq i32 %b, 0
   store volatile i32 0, i32* %p
   br i1 %c, label %true, label %false
 true:
   store volatile i32 1, i32* %p
   br label %exit
 false:
   store volatile i32 2, i32* %p
   br i1 %d, label %ft, label %ff
 ft:
   store volatile i32 3, i32* %p
   br label %exit
 ff:
   store volatile i32 4, i32* %p
   br label %exit
 exit:
   store volatile i32 5, i32* %p
   ret i32 0
 }
 
-; CHECK-LABEL: triangle
-; CHECK: (block $BB4_2)
-; CHECK: (brif $BB4_2 @3)
+; CHECK-LABEL: triangle:
+; CHECK: block $BB4_2{{$}}
+; CHECK: brif $BB4_2, @3{{$}}
 ; CHECK: BB4_2:
-; CHECK: (return @2)
+; CHECK: return @2{{$}}
 define i32 @triangle(i32* %p, i32 %a) {
 entry:
   %c = icmp eq i32 %a, 0
   store volatile i32 0, i32* %p
   br i1 %c, label %true, label %exit
 true:
   store volatile i32 1, i32* %p
   br label %exit
 exit:
   store volatile i32 2, i32* %p
   ret i32 0
 }
 
-; CHECK-LABEL: diamond
-; CHECK: (block $BB5_3)
-; CHECK: (block $BB5_2)
-; CHECK: (brif $BB5_2 @3)
-; CHECK: (br $BB5_3)
+; CHECK-LABEL: diamond:
+; CHECK: block $BB5_3{{$}}
+; CHECK: block $BB5_2{{$}}
+; CHECK: brif $BB5_2, @3{{$}}
+; CHECK: br $BB5_3{{$}}
 ; CHECK: BB5_2:
 ; CHECK: BB5_3:
-; CHECK: (return @2)
+; CHECK: return @2{{$}}
 define i32 @diamond(i32* %p, i32 %a) {
 entry:
   %c = icmp eq i32 %a, 0
   store volatile i32 0, i32* %p
   br i1 %c, label %true, label %false
 true:
   store volatile i32 1, i32* %p
   br label %exit
 false:
   store volatile i32 2, i32* %p
   br label %exit
 exit:
   store volatile i32 3, i32* %p
   ret i32 0
 }
 
-; CHECK-LABEL: single_block
+; CHECK-LABEL: single_block:
 ; CHECK-NOT: br
-; CHECK: (return @1)
+; CHECK: return @1{{$}}
 define i32 @single_block(i32* %p) {
 entry:
   store volatile i32 0, i32* %p
   ret i32 0
 }
 
-; CHECK-LABEL: minimal_loop
+; CHECK-LABEL: minimal_loop:
 ; CHECK-NOT: br
 ; CHECK: BB7_1:
-; CHECK: (store_i32 @0 @2)
-; CHECK: (br $BB7_1)
+; CHECK: store_i32 @0, @2{{$}}
+; CHECK: br $BB7_1{{$}}
 define i32 @minimal_loop(i32* %p) {
 entry:
   store volatile i32 0, i32* %p
   br label %loop
 loop:
   store volatile i32 1, i32* %p
   br label %loop
 }
 
-; CHECK-LABEL: simple_loop
+; CHECK-LABEL: simple_loop:
 ; CHECK-NOT: br
 ; CHECK: BB8_1:
-; CHECK: (loop $BB8_1)
-; CHECK: (brif $BB8_1 @4)
-; CHECK: (return @2)
+; CHECK: loop $BB8_1{{$}}
+; CHECK: brif $BB8_1, @4{{$}}
+; CHECK: return @2{{$}}
 define i32 @simple_loop(i32* %p, i32 %a) {
 entry:
   %c = icmp eq i32 %a, 0
   store volatile i32 0, i32* %p
   br label %loop
 loop:
   store volatile i32 1, i32* %p
   br i1 %c, label %loop, label %exit
 exit:
   store volatile i32 2, i32* %p
   ret i32 0
 }
 
-; CHECK-LABEL: doubletriangle
-; CHECK: (block $BB9_4)
-; CHECK: (block $BB9_3)
-; CHECK: (brif $BB9_4 @4)
-; CHECK: (brif $BB9_3 @7)
+; CHECK-LABEL: doubletriangle:
+; CHECK: block $BB9_4{{$}}
+; CHECK: block $BB9_3{{$}}
+; CHECK: brif $BB9_4, @4{{$}}
+; CHECK: brif $BB9_3, @7{{$}}
 ; CHECK: BB9_3:
 ; CHECK: BB9_4:
-; CHECK: (return @3)
+; CHECK: return @3{{$}}
 define i32 @doubletriangle(i32 %a, i32 %b, i32* %p) {
 entry:
   %c = icmp eq i32 %a, 0
   %d = icmp eq i32 %b, 0
   store volatile i32 0, i32* %p
   br i1 %c, label %true, label %exit
 true:
   store volatile i32 2, i32* %p
   br i1 %d, label %tt, label %tf
 tt:
   store volatile i32 3, i32* %p
   br label %tf
 tf:
   store volatile i32 4, i32* %p
   br label %exit
 exit:
   store volatile i32 5, i32* %p
   ret i32 0
 }
 
-; CHECK-LABEL: ifelse_earlyexits
-; CHECK: (block $BB10_4)
-; CHECK: (block $BB10_2)
-; CHECK: (brif $BB10_2 @4)
-; CHECK: (br $BB10_4)
+; CHECK-LABEL: ifelse_earlyexits:
+; CHECK: block $BB10_4{{$}}
+; CHECK: block $BB10_2{{$}}
+; CHECK: brif $BB10_2, @4{{$}}
+; CHECK: br $BB10_4{{$}}
 ; CHECK: BB10_2:
-; CHECK: (brif $BB10_4 @7)
+; CHECK: brif $BB10_4, @7{{$}}
 ; CHECK: BB10_4:
-; CHECK: (return @3)
+; CHECK: return @3{{$}}
 define i32 @ifelse_earlyexits(i32 %a, i32 %b, i32* %p) {
 entry:
   %c = icmp eq i32 %a, 0
   %d = icmp eq i32 %b, 0
   store volatile i32 0, i32* %p
   br i1 %c, label %true, label %false
 true:
   store volatile i32 1, i32* %p

test/CodeGen/WebAssembly/comparisons_f32.ll

 ; RUN: llc < %s -asm-verbose=false | FileCheck %s
 
 ; Test that basic 32-bit floating-point comparison operations assemble as
 ; expected.
 
 target datalayout = "e-p:32:32-i64:64-n32:64-S128"
 target triple = "wasm32-unknown-unknown"
 
-; CHECK-LABEL: (func $ord_f32
-; CHECK-NEXT: (param f32) (param f32) (result i32)
-; CHECK-NEXT: (setlocal @0 (argument 0))
-; CHECK-NEXT: (setlocal @1 (argument 1))
-; CHECK-NEXT: (setlocal @2 (eq @1 @1))
-; CHECK-NEXT: (setlocal @3 (eq @0 @0))
-; CHECK-NEXT: (setlocal @4 (and @3 @2))
-; CHECK-NEXT: (return @4)
+; CHECK-LABEL: ord_f32:
+; CHECK-NEXT: .param f32{{$}}
+; CHECK-NEXT: .param f32{{$}}
+; CHECK-NEXT: .result i32{{$}}
+; CHECK-NEXT: argument 0{{$}}
+; CHECK-NEXT: setlocal @0{{$}}
+; CHECK-NEXT: argument 1{{$}}
+; CHECK-NEXT: setlocal @1{{$}}
+; CHECK-NEXT: eq @1, @1{{$}}
+; CHECK-NEXT: setlocal @2{{$}}
+; CHECK-NEXT: eq @0, @0{{$}}
+; CHECK-NEXT: setlocal @3{{$}}
+; CHECK-NEXT: and @3, @2{{$}}
+; CHECK-NEXT: setlocal @4{{$}}
+; CHECK-NEXT: return @4{{$}}
 define i32 @ord_f32(float %x, float %y) {
   %a = fcmp ord float %x, %y
   %b = zext i1 %a to i32
   ret i32 %b
 }
 
-; CHECK-LABEL: (func $uno_f32
-; CHECK-NEXT: (param f32) (param f32) (result i32)
-; CHECK-NEXT: (setlocal @0 (argument 0))
-; CHECK-NEXT: (setlocal @1 (argument 1))
-; CHECK-NEXT: (setlocal @2 (ne @1 @1))
-; CHECK-NEXT: (setlocal @3 (ne @0 @0))
-; CHECK-NEXT: (setlocal @4 (ior @3 @2))
-; CHECK-NEXT: (return @4)
+; CHECK-LABEL: uno_f32:
+; CHECK-NEXT: .param f32{{$}}
+; CHECK-NEXT: .param f32{{$}}
+; CHECK-NEXT: .result i32{{$}}
+; CHECK-NEXT: argument 0{{$}}
+; CHECK-NEXT: setlocal @0{{$}}
+; CHECK-NEXT: argument 1{{$}}
+; CHECK-NEXT: setlocal @1{{$}}
+; CHECK-NEXT: ne @1, @1{{$}}
+; CHECK-NEXT: setlocal @2{{$}}
+; CHECK-NEXT: ne @0, @0{{$}}
+; CHECK-NEXT: setlocal @3{{$}}
+; CHECK-NEXT: ior @3, @2{{$}}
+; CHECK-NEXT: setlocal @4{{$}}
+; CHECK-NEXT: return @4{{$}}
 define i32 @uno_f32(float %x, float %y) {
   %a = fcmp uno float %x, %y
   %b = zext i1 %a to i32
   ret i32 %b
 }
 
-; CHECK-LABEL: (func $oeq_f32
-; CHECK-NEXT: (param f32) (param f32) (result i32)
-; CHECK-NEXT: (setlocal @0 (argument 1))
-; CHECK-NEXT: (setlocal @1 (argument 0))
-; CHECK-NEXT: (setlocal @2 (eq @1 @0))
-; CHECK-NEXT: (return @2)
+; CHECK-LABEL: oeq_f32:
+; CHECK-NEXT: .param f32{{$}}
+; CHECK-NEXT: .param f32{{$}}
+; CHECK-NEXT: .result i32{{$}}
+; CHECK-NEXT: argument 1{{$}}
+; CHECK-NEXT: setlocal @0{{$}}
+; CHECK-NEXT: argument 0{{$}}
+; CHECK-NEXT: setlocal @1{{$}}
+; CHECK-NEXT: eq @1, @0{{$}}
+; CHECK-NEXT: setlocal @2{{$}}
+; CHECK-NEXT: return @2{{$}}
 define i32 @oeq_f32(float %x, float %y) {
   %a = fcmp oeq float %x, %y
   %b = zext i1 %a to i32
   ret i32 %b
 }
 
-; CHECK-LABEL: (func $une_f32
-; CHECK: (setlocal @2 (ne @1 @0))
+; CHECK-LABEL: une_f32:
+; CHECK: ne @1, @0{{$}}
+; CHECK-NEXT: setlocal @2{{$}}
 define i32 @une_f32(float %x, float %y) {
   %a = fcmp une float %x, %y
   %b = zext i1 %a to i32
   ret i32 %b
 }
 
-; CHECK-LABEL: (func $olt_f32
-; CHECK: (setlocal @2 (lt @1 @0))
+; CHECK-LABEL: olt_f32:
+; CHECK: lt @1, @0{{$}}
+; CHECK-NEXT: setlocal @2{{$}}
 define i32 @olt_f32(float %x, float %y) {
   %a = fcmp olt float %x, %y
   %b = zext i1 %a to i32
   ret i32 %b
 }
 
-; CHECK-LABEL: (func $ole_f32
-; CHECK: (setlocal @2 (le @1 @0))
+; CHECK-LABEL: ole_f32:
+; CHECK: le @1, @0{{$}}
+; CHECK-NEXT: setlocal @2{{$}}
 define i32 @ole_f32(float %x, float %y) {
   %a = fcmp ole float %x, %y
   %b = zext i1 %a to i32
   ret i32 %b
 }
 
-; CHECK-LABEL: (func $ogt_f32
-; CHECK: (setlocal @2 (gt @1 @0))
+; CHECK-LABEL: ogt_f32:
+; CHECK: gt @1, @0{{$}}
+; CHECK-NEXT: setlocal @2{{$}}
 define i32 @ogt_f32(float %x, float %y) {
   %a = fcmp ogt float %x, %y
   %b = zext i1 %a to i32
   ret i32 %b
 }
 
-; CHECK-LABEL: (func $oge_f32
-; CHECK: (setlocal @2 (ge @1 @0))
+; CHECK-LABEL: oge_f32:
+; CHECK: ge @1, @0{{$}}
+; CHECK-NEXT: setlocal @2{{$}}
 define i32 @oge_f32(float %x, float %y) {
   %a = fcmp oge float %x, %y
   %b = zext i1 %a to i32
   ret i32 %b
 }
 
 ; Expanded comparisons, which also check for NaN.
 
-; CHECK-LABEL: (func $ueq_f32
-; CHECK-NEXT: (param f32) (param f32) (result i32)
-; CHECK-NEXT: (setlocal @0 (argument 1))
-; CHECK-NEXT: (setlocal @1 (argument 0))
-; CHECK-NEXT: (setlocal @2 (eq @1 @0))
-; CHECK-NEXT: (setlocal @3 (ne @0 @0))
-; CHECK-NEXT: (setlocal @4 (ne @1 @1))
-; CHECK-NEXT: (setlocal @5 (ior @4 @3))
-; CHECK-NEXT: (setlocal @6 (ior @2 @5))
-; CHECK-NEXT: (return @6)
+; CHECK-LABEL: ueq_f32:
+; CHECK-NEXT: .param f32{{$}}
+; CHECK-NEXT: .param f32{{$}}
+; CHECK-NEXT: .result i32{{$}}
+; CHECK-NEXT: argument 1{{$}}
+; CHECK-NEXT: setlocal @0{{$}}
+; CHECK-NEXT: argument 0{{$}}
+; CHECK-NEXT: setlocal @1{{$}}
+; CHECK-NEXT: eq @1, @0{{$}}
+; CHECK-NEXT: setlocal @2{{$}}
+; CHECK-NEXT: ne @0, @0{{$}}
+; CHECK-NEXT: setlocal @3{{$}}
+; CHECK-NEXT: ne @1, @1{{$}}
+; CHECK-NEXT: setlocal @4{{$}}
+; CHECK-NEXT: ior @4, @3{{$}}
+; CHECK-NEXT: setlocal @5{{$}}
+; CHECK-NEXT: ior @2, @5{{$}}
+; CHECK-NEXT: setlocal @6{{$}}
+; CHECK-NEXT: return @6{{$}}
 define i32 @ueq_f32(float %x, float %y) {
   %a = fcmp ueq float %x, %y
   %b = zext i1 %a to i32
   ret i32 %b
 }
 
-; CHECK-LABEL: (func $one_f32
-; CHECK: (setlocal @2 (ne @1 @0))
+; CHECK-LABEL: one_f32:
+; CHECK: ne @1, @0{{$}}
+; CHECK-NEXT: setlocal @2{{$}}
 define i32 @one_f32(float %x, float %y) {
   %a = fcmp one float %x, %y
   %b = zext i1 %a to i32
   ret i32 %b
 }
 
-; CHECK-LABEL: (func $ult_f32
-; CHECK: (setlocal @2 (lt @1 @0))
+; CHECK-LABEL: ult_f32:
+; CHECK: lt @1, @0{{$}}
+; CHECK-NEXT: setlocal @2{{$}}
 define i32 @ult_f32(float %x, float %y) {
   %a = fcmp ult float %x, %y
   %b = zext i1 %a to i32
   ret i32 %b
 }
 
-; CHECK-LABEL: (func $ule_f32
-; CHECK: (setlocal @2 (le @1 @0))
+; CHECK-LABEL: ule_f32:
+; CHECK: le @1, @0{{$}}
+; CHECK-NEXT: setlocal @2{{$}}
 define i32 @ule_f32(float %x, float %y) {
   %a = fcmp ule float %x, %y
   %b = zext i1 %a to i32
   ret i32 %b
 }
 
-; CHECK-LABEL: (func $ugt_f32
-; CHECK: (setlocal @2 (gt @1 @0))
+; CHECK-LABEL: ugt_f32:
+; CHECK: gt @1, @0{{$}}
+; CHECK-NEXT: setlocal @2{{$}}
 define i32 @ugt_f32(float %x, float %y) {
   %a = fcmp ugt float %x, %y
   %b = zext i1 %a to i32
   ret i32 %b
 }
 
-; CHECK-LABEL: (func $uge_f32
-; CHECK: (setlocal @2 (ge @1 @0))
+; CHECK-LABEL: uge_f32:
+; CHECK: ge @1, @0{{$}}
+; CHECK-NEXT: setlocal @2{{$}}
 define i32 @uge_f32(float %x, float %y) {
   %a = fcmp uge float %x, %y
   %b = zext i1 %a to i32
   ret i32 %b
 }

test/CodeGen/WebAssembly/comparisons_f64.ll

 ; RUN: llc < %s -asm-verbose=false | FileCheck %s
 
 ; Test that basic 64-bit floating-point comparison operations assemble as
 ; expected.
 
 target datalayout = "e-p:32:32-i64:64-n32:64-S128"
 target triple = "wasm32-unknown-unknown"
 
-; CHECK-LABEL: (func $ord_f64
-; CHECK-NEXT: (param f64) (param f64) (result i32)
-; CHECK-NEXT: (setlocal @0 (argument 0))
-; CHECK-NEXT: (setlocal @1 (argument 1))
-; CHECK-NEXT: (setlocal @2 (eq @1 @1))
-; CHECK-NEXT: (setlocal @3 (eq @0 @0))
-; CHECK-NEXT: (setlocal @4 (and @3 @2))
-; CHECK-NEXT: (return @4)
+; CHECK-LABEL: ord_f64:
+; CHECK-NEXT: .param f64{{$}}
+; CHECK-NEXT: .param f64{{$}}
+; CHECK-NEXT: .result i32{{$}}
+; CHECK-NEXT: argument 0{{$}}
+; CHECK-NEXT: setlocal @0{{$}}
+; CHECK-NEXT: argument 1{{$}}
+; CHECK-NEXT: setlocal @1{{$}}
+; CHECK-NEXT: eq @1, @1{{$}}
+; CHECK-NEXT: setlocal @2{{$}}
+; CHECK-NEXT: eq @0, @0{{$}}
+; CHECK-NEXT: setlocal @3{{$}}
+; CHECK-NEXT: and @3, @2{{$}}
+; CHECK-NEXT: setlocal @4{{$}}
+; CHECK-NEXT: return @4{{$}}
 define i32 @ord_f64(double %x, double %y) {
   %a = fcmp ord double %x, %y
   %b = zext i1 %a to i32
   ret i32 %b
 }
 
-; CHECK-LABEL: (func $uno_f64
-; CHECK-NEXT: (param f64) (param f64) (result i32)
-; CHECK-NEXT: (setlocal @0 (argument 0))
-; CHECK-NEXT: (setlocal @1 (argument 1))
-; CHECK-NEXT: (setlocal @2 (ne @1 @1))
-; CHECK-NEXT: (setlocal @3 (ne @0 @0))
-; CHECK-NEXT: (setlocal @4 (ior @3 @2))
-; CHECK-NEXT: (return @4)
+; CHECK-LABEL: uno_f64:
+; CHECK-NEXT: .param f64{{$}}
+; CHECK-NEXT: .param f64{{$}}
+; CHECK-NEXT: .result i32{{$}}
+; CHECK-NEXT: argument 0{{$}}
+; CHECK-NEXT: setlocal @0{{$}}
+; CHECK-NEXT: argument 1{{$}}
+; CHECK-NEXT: setlocal @1{{$}}
+; CHECK-NEXT: ne @1, @1{{$}}
+; CHECK-NEXT: setlocal @2{{$}}
+; CHECK-NEXT: ne @0, @0{{$}}
+; CHECK-NEXT: setlocal @3{{$}}
+; CHECK-NEXT: ior @3, @2{{$}}
+; CHECK-NEXT: setlocal @4{{$}}
+; CHECK-NEXT: return @4{{$}}
 define i32 @uno_f64(double %x, double %y) {
   %a = fcmp uno double %x, %y
   %b = zext i1 %a to i32
   ret i32 %b
 }
 
-; CHECK-LABEL: (func $oeq_f64
-; CHECK-NEXT: (param f64) (param f64) (result i32)
-; CHECK-NEXT: (setlocal @0 (argument 1))
-; CHECK-NEXT: (setlocal @1 (argument 0))
-; CHECK-NEXT: (setlocal @2 (eq @1 @0))
-; CHECK-NEXT: (return @2)
+; CHECK-LABEL: oeq_f64:
+; CHECK-NEXT: .param f64{{$}}
+; CHECK-NEXT: .param f64{{$}}
+; CHECK-NEXT: .result i32{{$}}
+; CHECK-NEXT: argument 1{{$}}
+; CHECK-NEXT: setlocal @0{{$}}
+; CHECK-NEXT: argument 0{{$}}
+; CHECK-NEXT: setlocal @1{{$}}
+; CHECK-NEXT: eq @1, @0{{$}}
+; CHECK-NEXT: setlocal @2{{$}}
+; CHECK-NEXT: return @2{{$}}
 define i32 @oeq_f64(double %x, double %y) {
   %a = fcmp oeq double %x, %y
   %b = zext i1 %a to i32
   ret i32 %b
 }
 
-; CHECK-LABEL: (func $une_f64
-; CHECK: (setlocal @2 (ne @1 @0))
+; CHECK-LABEL: une_f64:
+; CHECK: ne @1, @0{{$}}
+; CHECK-NEXT: setlocal @2{{$}}
 define i32 @une_f64(double %x, double %y) {
   %a = fcmp une double %x, %y
   %b = zext i1 %a to i32
   ret i32 %b
 }
 
-; CHECK-LABEL: (func $olt_f64
-; CHECK: (setlocal @2 (lt @1 @0))
+; CHECK-LABEL: olt_f64:
+; CHECK: lt @1, @0{{$}}
+; CHECK-NEXT: setlocal @2{{$}}
 define i32 @olt_f64(double %x, double %y) {
   %a = fcmp olt double %x, %y
   %b = zext i1 %a to i32
   ret i32 %b
 }
 
-; CHECK-LABEL: (func $ole_f64
-; CHECK: (setlocal @2 (le @1 @0))
+; CHECK-LABEL: ole_f64:
+; CHECK: le @1, @0{{$}}
+; CHECK-NEXT: setlocal @2{{$}}
 define i32 @ole_f64(double %x, double %y) {
   %a = fcmp ole double %x, %y
   %b = zext i1 %a to i32
   ret i32 %b
 }
 
-; CHECK-LABEL: (func $ogt_f64
-; CHECK: (setlocal @2 (gt @1 @0))
+; CHECK-LABEL: ogt_f64:
+; CHECK: gt @1, @0{{$}}
+; CHECK-NEXT: setlocal @2{{$}}
 define i32 @ogt_f64(double %x, double %y) {
   %a = fcmp ogt double %x, %y
   %b = zext i1 %a to i32
   ret i32 %b
 }
 
-; CHECK-LABEL: (func $oge_f64
-; CHECK: (setlocal @2 (ge @1 @0))
+; CHECK-LABEL: oge_f64:
+; CHECK: ge @1, @0{{$}}
+; CHECK-NEXT: setlocal @2{{$}}
 define i32 @oge_f64(double %x, double %y) {
   %a = fcmp oge double %x, %y
   %b = zext i1 %a to i32
   ret i32 %b
 }
 
 ; Expanded comparisons, which also check for NaN.
 
-; CHECK-LABEL: (func $ueq_f64
-; CHECK-NEXT: (param f64) (param f64) (result i32)
-; CHECK-NEXT: (setlocal @0 (argument 1))
-; CHECK-NEXT: (setlocal @1 (argument 0))
-; CHECK-NEXT: (setlocal @2 (eq @1 @0))
-; CHECK-NEXT: (setlocal @3 (ne @0 @0))
-; CHECK-NEXT: (setlocal @4 (ne @1 @1))
-; CHECK-NEXT: (setlocal @5 (ior @4 @3))
-; CHECK-NEXT: (setlocal @6 (ior @2 @5))
-; CHECK-NEXT: (return @6)
+; CHECK-LABEL: ueq_f64:
+; CHECK-NEXT: .param f64{{$}}
+; CHECK-NEXT: .param f64{{$}}
+; CHECK-NEXT: .result i32{{$}}
+; CHECK-NEXT: argument 1{{$}}
+; CHECK-NEXT: setlocal @0{{$}}
+; CHECK-NEXT: argument 0{{$}}
+; CHECK-NEXT: setlocal @1{{$}}
+; CHECK-NEXT: eq @1, @0{{$}}
+; CHECK-NEXT: setlocal @2{{$}}
+; CHECK-NEXT: ne @0, @0{{$}}
+; CHECK-NEXT: setlocal @3{{$}}
+; CHECK-NEXT: ne @1, @1{{$}}
+; CHECK-NEXT: setlocal @4{{$}}
+; CHECK-NEXT: ior @4, @3{{$}}
+; CHECK-NEXT: setlocal @5{{$}}
+; CHECK-NEXT: ior @2, @5{{$}}
+; CHECK-NEXT: setlocal @6{{$}}
+; CHECK-NEXT: return @6{{$}}
 define i32 @ueq_f64(double %x, double %y) {
   %a = fcmp ueq double %x, %y
   %b = zext i1 %a to i32
   ret i32 %b
 }
 
-; CHECK-LABEL: (func $one_f64
-; CHECK: (setlocal @2 (ne @1 @0))
+; CHECK-LABEL: one_f64:
+; CHECK: ne @1, @0{{$}}
+; CHECK-NEXT: setlocal @2{{$}}
 define i32 @one_f64(double %x, double %y) {
   %a = fcmp one double %x, %y
   %b = zext i1 %a to i32
   ret i32 %b
 }
 
-; CHECK-LABEL: (func $ult_f64
-; CHECK: (setlocal @2 (lt @1 @0))
+; CHECK-LABEL: ult_f64:
+; CHECK: lt @1, @0{{$}}
+; CHECK-NEXT: setlocal @2{{$}}
 define i32 @ult_f64(double %x, double %y) {
   %a = fcmp ult double %x, %y
   %b = zext i1 %a to i32
   ret i32 %b
 }
 
-; CHECK-LABEL: (func $ule_f64
-; CHECK: (setlocal @2 (le @1 @0))
+; CHECK-LABEL: ule_f64:
+; CHECK: le @1, @0{{$}}
+; CHECK-NEXT: setlocal @2{{$}}
 define i32 @ule_f64(double %x, double %y) {
   %a = fcmp ule double %x, %y
   %b = zext i1 %a to i32
   ret i32 %b
 }
 
-; CHECK-LABEL: (func $ugt_f64
-; CHECK: (setlocal @2 (gt @1 @0))
+; CHECK-LABEL: ugt_f64:
+; CHECK: gt @1, @0{{$}}
+; CHECK-NEXT: setlocal @2{{$}}
 define i32 @ugt_f64(double %x, double %y) {
   %a = fcmp ugt double %x, %y
   %b = zext i1 %a to i32
   ret i32 %b
 }
 
-; CHECK-LABEL: (func $uge_f64
-; CHECK: (setlocal @2 (ge @1 @0))
+; CHECK-LABEL: uge_f64:
+; CHECK: ge @1, @0{{$}}
+; CHECK-NEXT: setlocal @2{{$}}
 define i32 @uge_f64(double %x, double %y) {
   %a = fcmp uge double %x, %y
   %b = zext i1 %a to i32
   ret i32 %b
 }

test/CodeGen/WebAssembly/comparisons_i32.ll

 ; RUN: llc < %s -asm-verbose=false | FileCheck %s
 
 ; Test that basic 32-bit integer comparison operations assemble as expected.
 
 target datalayout = "e-p:32:32-i64:64-n32:64-S128"
 target triple = "wasm32-unknown-unknown"
 
-; CHECK-LABEL: (func $eq_i32
-; CHECK-NEXT: (param i32) (param i32) (result i32)
-; CHECK-NEXT: (setlocal @0 (argument 1))
-; CHECK-NEXT: (setlocal @1 (argument 0))
-; CHECK-NEXT: (setlocal @2 (eq @1 @0))
-; CHECK-NEXT: (return @2)
+; CHECK-LABEL: eq_i32:
+; CHECK-NEXT: .param i32{{$}}
+; CHECK-NEXT: .param i32{{$}}
+; CHECK-NEXT: .result i32{{$}}
+; CHECK-NEXT: argument 1{{$}}
+; CHECK-NEXT: setlocal @0{{$}}
+; CHECK-NEXT: argument 0{{$}}
+; CHECK-NEXT: setlocal @1{{$}}
+; CHECK-NEXT: eq @1, @0{{$}}
+; CHECK-NEXT: setlocal @2{{$}}
+; CHECK-NEXT: return @2{{$}}
 define i32 @eq_i32(i32 %x, i32 %y) {
   %a = icmp eq i32 %x, %y
   %b = zext i1 %a to i32
   ret i32 %b
 }
 
-; CHECK-LABEL: (func $ne_i32
-; CHECK: (setlocal @2 (ne @1 @0))
+; CHECK-LABEL: ne_i32:
+; CHECK: ne @1, @0{{$}}
+; CHECK-NEXT: setlocal @2{{$}}
 define i32 @ne_i32(i32 %x, i32 %y) {
   %a = icmp ne i32 %x, %y
   %b = zext i1 %a to i32
   ret i32 %b
 }
 
-; CHECK-LABEL: (func $slt_i32
-; CHECK: (setlocal @2 (slt @1 @0))
+; CHECK-LABEL: slt_i32:
+; CHECK: slt @1, @0{{$}}
+; CHECK-NEXT: setlocal @2{{$}}
 define i32 @slt_i32(i32 %x, i32 %y) {
   %a = icmp slt i32 %x, %y
   %b = zext i1 %a to i32
   ret i32 %b
 }
 
-; CHECK-LABEL: (func $sle_i32
-; CHECK: (setlocal @2 (sle @1 @0))
+; CHECK-LABEL: sle_i32:
+; CHECK: sle @1, @0{{$}}
+; CHECK-NEXT: setlocal @2{{$}}
 define i32 @sle_i32(i32 %x, i32 %y) {
   %a = icmp sle i32 %x, %y
   %b = zext i1 %a to i32
   ret i32 %b
 }
 
-; CHECK-LABEL: (func $ult_i32
-; CHECK: (setlocal @2 (ult @1 @0))
+; CHECK-LABEL: ult_i32:
+; CHECK: ult @1, @0{{$}}
+; CHECK-NEXT: setlocal @2{{$}}
 define i32 @ult_i32(i32 %x, i32 %y) {
   %a = icmp ult i32 %x, %y
   %b = zext i1 %a to i32
   ret i32 %b
 }
 
-; CHECK-LABEL: (func $ule_i32
-; CHECK: (setlocal @2 (ule @1 @0))
+; CHECK-LABEL: ule_i32:
+; CHECK: ule @1, @0{{$}}
+; CHECK-NEXT: setlocal @2{{$}}
 define i32 @ule_i32(i32 %x, i32 %y) {
   %a = icmp ule i32 %x, %y
   %b = zext i1 %a to i32
   ret i32 %b
 }
 
-; CHECK-LABEL: (func $sgt_i32
-; CHECK: (setlocal @2 (sgt @1 @0))
+; CHECK-LABEL: sgt_i32:
+; CHECK: sgt @1, @0{{$}}
+; CHECK-NEXT: setlocal @2{{$}}
 define i32 @sgt_i32(i32 %x, i32 %y) {
   %a = icmp sgt i32 %x, %y
   %b = zext i1 %a to i32
   ret i32 %b
 }
 
-; CHECK-LABEL: (func $sge_i32
-; CHECK: (setlocal @2 (sge @1 @0))
+; CHECK-LABEL: sge_i32:
+; CHECK: sge @1, @0{{$}}
+; CHECK-NEXT: setlocal @2{{$}}
 define i32 @sge_i32(i32 %x, i32 %y) {
   %a = icmp sge i32 %x, %y
   %b = zext i1 %a to i32
   ret i32 %b
 }
 
-; CHECK-LABEL: (func $ugt_i32
-; CHECK: (setlocal @2 (ugt @1 @0))
+; CHECK-LABEL: ugt_i32:
+; CHECK: ugt @1, @0{{$}}
+; CHECK-NEXT: setlocal @2{{$}}
 define i32 @ugt_i32(i32 %x, i32 %y) {
   %a = icmp ugt i32 %x, %y
   %b = zext i1 %a to i32
   ret i32 %b
 }
 
-; CHECK-LABEL: (func $uge_i32
-; CHECK: (setlocal @2 (uge @1 @0))
+; CHECK-LABEL: uge_i32:
+; CHECK: uge @1, @0{{$}}
+; CHECK-NEXT: setlocal @2{{$}}
 define i32 @uge_i32(i32 %x, i32 %y) {
   %a = icmp uge i32 %x, %y
   %b = zext i1 %a to i32
   ret i32 %b
 }

test/CodeGen/WebAssembly/comparisons_i64.ll

 ; RUN: llc < %s -asm-verbose=false | FileCheck %s
 
 ; Test that basic 64-bit integer comparison operations assemble as expected.
 
 target datalayout = "e-p:32:32-i64:64-n32:64-S128"
 target triple = "wasm32-unknown-unknown"
 
-; CHECK-LABEL: (func $eq_i64
-; CHECK-NEXT: (param i64) (param i64) (result i32)
-; CHECK-NEXT: (setlocal @0 (argument 1))
-; CHECK-NEXT: (setlocal @1 (argument 0))
-; CHECK-NEXT: (setlocal @2 (eq @1 @0))
-; CHECK-NEXT: (return @2)
+; CHECK-LABEL: eq_i64:
+; CHECK-NEXT: .param i64{{$}}
+; CHECK-NEXT: .param i64{{$}}
+; CHECK-NEXT: .result i32{{$}}
+; CHECK-NEXT: argument 1{{$}}
+; CHECK-NEXT: setlocal @0{{$}}
+; CHECK-NEXT: argument 0{{$}}
+; CHECK-NEXT: setlocal @1{{$}}
+; CHECK-NEXT: eq @1, @0{{$}}
+; CHECK-NEXT: setlocal @2{{$}}
+; CHECK-NEXT: return @2{{$}}
 define i32 @eq_i64(i64 %x, i64 %y) {
   %a = icmp eq i64 %x, %y
   %b = zext i1 %a to i32
   ret i32 %b
 }
 
-; CHECK-LABEL: (func $ne_i64
-; CHECK: (setlocal @2 (ne @1 @0))
+; CHECK-LABEL: ne_i64:
+; CHECK: ne @1, @0{{$}}
+; CHECK-NEXT: setlocal @2{{$}}
 define i32 @ne_i64(i64 %x, i64 %y) {
   %a = icmp ne i64 %x, %y
   %b = zext i1 %a to i32
   ret i32 %b
 }
 
-; CHECK-LABEL: (func $slt_i64
-; CHECK: (setlocal @2 (slt @1 @0))
+; CHECK-LABEL: slt_i64:
+; CHECK: slt @1, @0{{$}}
+; CHECK-NEXT: setlocal @2{{$}}
 define i32 @slt_i64(i64 %x, i64 %y) {
   %a = icmp slt i64 %x, %y
   %b = zext i1 %a to i32
   ret i32 %b
 }
 
-; CHECK-LABEL: (func $sle_i64
-; CHECK: (setlocal @2 (sle @1 @0))
+; CHECK-LABEL: sle_i64:
+; CHECK: sle @1, @0{{$}}
+; CHECK-NEXT: setlocal @2{{$}}
 define i32 @sle_i64(i64 %x, i64 %y) {
   %a = icmp sle i64 %x, %y
   %b = zext i1 %a to i32
   ret i32 %b
 }
 
-; CHECK-LABEL: (func $ult_i64
-; CHECK: (setlocal @2 (ult @1 @0))
+; CHECK-LABEL: ult_i64:
+; CHECK: ult @1, @0{{$}}
+; CHECK-NEXT: setlocal @2{{$}}
 define i32 @ult_i64(i64 %x, i64 %y) {
   %a = icmp ult i64 %x, %y
   %b = zext i1 %a to i32
   ret i32 %b
 }
 
-; CHECK-LABEL: (func $ule_i64
-; CHECK: (setlocal @2 (ule @1 @0))
+; CHECK-LABEL: ule_i64:
+; CHECK: ule @1, @0{{$}}
+; CHECK-NEXT: setlocal @2{{$}}
 define i32 @ule_i64(i64 %x, i64 %y) {
   %a = icmp ule i64 %x, %y
   %b = zext i1 %a to i32
   ret i32 %b
 }
 
-; CHECK-LABEL: (func $sgt_i64
-; CHECK: (setlocal @2 (sgt @1 @0))
+; CHECK-LABEL: sgt_i64:
+; CHECK: sgt @1, @0{{$}}
+; CHECK-NEXT: setlocal @2{{$}}
 define i32 @sgt_i64(i64 %x, i64 %y) {
   %a = icmp sgt i64 %x, %y
   %b = zext i1 %a to i32
   ret i32 %b
 }
 
-; CHECK-LABEL: (func $sge_i64
-; CHECK: (setlocal @2 (sge @1 @0))
+; CHECK-LABEL: sge_i64:
+; CHECK: sge @1, @0{{$}}
+; CHECK-NEXT: setlocal @2{{$}}
 define i32 @sge_i64(i64 %x, i64 %y) {
   %a = icmp sge i64 %x, %y
   %b = zext i1 %a to i32
   ret i32 %b
 }
 
-; CHECK-LABEL: (func $ugt_i64
-; CHECK: (setlocal @2 (ugt @1 @0))
+; CHECK-LABEL: ugt_i64:
+; CHECK: ugt @1, @0{{$}}
+; CHECK-NEXT: setlocal @2{{$}}
 define i32 @ugt_i64(i64 %x, i64 %y) {
   %a = icmp ugt i64 %x, %y
   %b = zext i1 %a to i32
   ret i32 %b
 }
 
-; CHECK-LABEL: (func $uge_i64
-; CHECK: (setlocal @2 (uge @1 @0))
+; CHECK-LABEL: uge_i64:
+; CHECK: uge @1, @0{{$}}
+; CHECK-NEXT: setlocal @2{{$}}
 define i32 @uge_i64(i64 %x, i64 %y) {
   %a = icmp uge i64 %x, %y
   %b = zext i1 %a to i32
   ret i32 %b
 }

test/CodeGen/WebAssembly/conv.ll

 ; RUN: llc < %s -asm-verbose=false | FileCheck %s
 
 ; Test that basic conversion operations assemble as expected.
 
 target datalayout = "e-p:32:32-i64:64-n32:64-S128"
 target triple = "wasm32-unknown-unknown"
 
-; CHECK-LABEL: $wrap_i64_i32
-; CHECK-NEXT: (param i64) (result i32)
-; CHECK-NEXT: (setlocal @0 (argument 0))
-; CHECK-NEXT: (setlocal @1 (wrap_i64 @0))
-; CHECK-NEXT: (return @1)
+; CHECK-LABEL: wrap_i64_i32:
+; CHECK-NEXT: .param i64{{$}}
+; CHECK-NEXT: .result i32{{$}}
+; CHECK-NEXT: argument 0{{$}}
+; CHECK-NEXT: setlocal @0{{$}}
+; CHECK-NEXT: wrap_i64 @0{{$}}
+; CHECK-NEXT: setlocal @1{{$}}
+; CHECK-NEXT: return @1{{$}}
 define i32 @wrap_i64_i32(i64 %x) {
   %a = trunc i64 %x to i32
   ret i32 %a
 }

test/CodeGen/WebAssembly/fast-isel.ll

 ; RUN: llc < %s -asm-verbose=false \
 ; RUN:   -fast-isel -fast-isel-abort=1 -verify-machineinstrs \
 ; RUN:   | FileCheck %s
 
 target datalayout = "e-p:32:32-i64:64-n32:64-S128"
 target triple = "wasm32-unknown-unknown"
 
 ; This tests very minimal fast-isel functionality.
 
-; CHECK-LABEL: (func $immediate_f32
-; CHECK: (immediate 0x1.4p1)
+; CHECK-LABEL: immediate_f32:
+; CHECK: immediate 0x1.4p1{{$}}
 define float @immediate_f32() {
   ret float 2.5
 }
 
-; CHECK-LABEL: (func $immediate_f64
-; CHECK: (immediate 0x1.4p1)
+; CHECK-LABEL: immediate_f64:
+; CHECK: immediate 0x1.4p1{{$}}
 define double @immediate_f64() {
   ret double 2.5
 }

test/CodeGen/WebAssembly/fp32.ll

 ; RUN: llc < %s -asm-verbose=false | FileCheck %s
 
 ; Test that basic 32-bit floating-point operations assemble as expected.
 
 target datalayout = "e-p:32:32-i64:64-n32:64-S128"
 target triple = "wasm32-unknown-unknown"
 
 declare float @llvm.fabs.f32(float)
 declare float @llvm.copysign.f32(float, float)
 declare float @llvm.sqrt.f32(float)
 declare float @llvm.ceil.f32(float)
 declare float @llvm.floor.f32(float)
 declare float @llvm.trunc.f32(float)
 declare float @llvm.nearbyint.f32(float)
 declare float @llvm.rint.f32(float)
 
-; CHECK-LABEL: (func $fadd32
-; CHECK-NEXT: (param f32) (param f32) (result f32)
-; CHECK-NEXT: (setlocal @0 (argument 1))
-; CHECK-NEXT: (setlocal @1 (argument 0))
-; CHECK-NEXT: (setlocal @2 (fadd @1 @0))
-; CHECK-NEXT: (return @2)
+; CHECK-LABEL: fadd32:
+; CHECK-NEXT: .param f32{{$}}
+; CHECK-NEXT: .param f32{{$}}
+; CHECK-NEXT: .result f32{{$}}
+; CHECK-NEXT: argument 1{{$}}
+; CHECK-NEXT: setlocal @0{{$}}
+; CHECK-NEXT: argument 0{{$}}
+; CHECK-NEXT: setlocal @1{{$}}
+; CHECK-NEXT: fadd @1, @0{{$}}
+; CHECK-NEXT: setlocal @2{{$}}
+; CHECK-NEXT: return @2{{$}}
 define float @fadd32(float %x, float %y) {
   %a = fadd float %x, %y
   ret float %a
 }
 
-; CHECK-LABEL: (func $fsub32
-; CHECK: (setlocal @2 (fsub @1 @0))
+; CHECK-LABEL: fsub32:
+; CHECK: fsub @1, @0{{$}}
+; CHECK-NEXT: setlocal @2{{$}}
 define float @fsub32(float %x, float %y) {
   %a = fsub float %x, %y
   ret float %a
 }
 
-; CHECK-LABEL: (func $fmul32
-; CHECK: (setlocal @2 (fmul @1 @0))
+; CHECK-LABEL: fmul32:
+; CHECK: fmul @1, @0{{$}}
+; CHECK-NEXT: setlocal @2{{$}}
 define float @fmul32(float %x, float %y) {
   %a = fmul float %x, %y
   ret float %a
 }
 
-; CHECK-LABEL: (func $fdiv32
-; CHECK: (setlocal @2 (fdiv @1 @0))
+; CHECK-LABEL: fdiv32:
+; CHECK: fdiv @1, @0{{$}}
+; CHECK-NEXT: setlocal @2{{$}}
 define float @fdiv32(float %x, float %y) {
   %a = fdiv float %x, %y
   ret float %a
 }
 
-; CHECK-LABEL: (func $fabs32
-; CHECK: (setlocal @1 (fabs @0))
+; CHECK-LABEL: fabs32:
+; CHECK: fabs @0{{$}}
+; CHECK-NEXT: setlocal @1{{$}}
 define float @fabs32(float %x) {
   %a = call float @llvm.fabs.f32(float %x)
   ret float %a
 }
 
-; CHECK-LABEL: (func $fneg32
-; CHECK: (setlocal @1 (fneg @0))
+; CHECK-LABEL: fneg32:
+; CHECK: fneg @0{{$}}
+; CHECK-NEXT: setlocal @1{{$}}
 define float @fneg32(float %x) {
   %a = fsub float -0., %x
   ret float %a
 }
 
-; CHECK-LABEL: (func $copysign32
-; CHECK: (setlocal @2 (copysign @1 @0))
+; CHECK-LABEL: copysign32:
+; CHECK: copysign @1, @0{{$}}
+; CHECK-NEXT: setlocal @2{{$}}
 define float @copysign32(float %x, float %y) {
   %a = call float @llvm.copysign.f32(float %x, float %y)
   ret float %a
 }
 
-; CHECK-LABEL: (func $sqrt32
-; CHECK: (setlocal @1 (sqrt @0))
+; CHECK-LABEL: sqrt32:
+; CHECK: sqrt @0{{$}}
+; CHECK-NEXT: setlocal @1{{$}}
 define float @sqrt32(float %x) {
   %a = call float @llvm.sqrt.f32(float %x)
   ret float %a
 }
 
-; CHECK-LABEL: (func $ceil32
-; CHECK: (setlocal @1 (ceil @0))
+; CHECK-LABEL: ceil32:
+; CHECK: ceil @0{{$}}
+; CHECK-NEXT: setlocal @1{{$}}
 define float @ceil32(float %x) {
   %a = call float @llvm.ceil.f32(float %x)
   ret float %a
 }
 
-; CHECK-LABEL: (func $floor32
-; CHECK: (setlocal @1 (floor @0))
+; CHECK-LABEL: floor32:
+; CHECK: floor @0{{$}}
+; CHECK-NEXT: setlocal @1{{$}}
 define float @floor32(float %x) {
   %a = call float @llvm.floor.f32(float %x)
   ret float %a
 }
 
-; CHECK-LABEL: (func $trunc32
-; CHECK: (setlocal @1 (trunc @0))
+; CHECK-LABEL: trunc32:
+; CHECK: trunc @0{{$}}
+; CHECK-NEXT: setlocal @1{{$}}
 define float @trunc32(float %x) {
   %a = call float @llvm.trunc.f32(float %x)
   ret float %a
 }
 
-; CHECK-LABEL: (func $nearestint32
-; CHECK: (setlocal @1 (nearestint @0))
+; CHECK-LABEL: nearestint32:
+; CHECK: nearestint @0{{$}}
+; CHECK-NEXT: setlocal @1{{$}}
 define float @nearestint32(float %x) {
   %a = call float @llvm.nearbyint.f32(float %x)
   ret float %a
 }
 
-; CHECK-LABEL: (func $nearestint32_via_rint
-; CHECK: (setlocal @1 (nearestint @0))
+; CHECK-LABEL: nearestint32_via_rint:
+; CHECK: nearestint @0{{$}}
+; CHECK-NEXT: setlocal @1{{$}}
 define float @nearestint32_via_rint(float %x) {
   %a = call float @llvm.rint.f32(float %x)
   ret float %a
 }

test/CodeGen/WebAssembly/fp64.ll

 ; RUN: llc < %s -asm-verbose=false | FileCheck %s
 
 ; Test that basic 64-bit floating-point operations assemble as expected.
 
 target datalayout = "e-p:32:32-i64:64-n32:64-S128"
 target triple = "wasm32-unknown-unknown"
 
 declare double @llvm.fabs.f64(double)
 declare double @llvm.copysign.f64(double, double)
 declare double @llvm.sqrt.f64(double)
 declare double @llvm.ceil.f64(double)
 declare double @llvm.floor.f64(double)
 declare double @llvm.trunc.f64(double)
 declare double @llvm.nearbyint.f64(double)
 declare double @llvm.rint.f64(double)
 
-; CHECK-LABEL: (func $fadd64
-; CHECK-NEXT: (param f64) (param f64) (result f64)
-; CHECK-NEXT: (setlocal @0 (argument 1))
-; CHECK-NEXT: (setlocal @1 (argument 0))
-; CHECK-NEXT: (setlocal @2 (fadd @1 @0))
-; CHECK-NEXT: (return @2)
+; CHECK-LABEL: fadd64:
+; CHECK-NEXT: .param f64{{$}}
+; CHECK-NEXT: .param f64{{$}}
+; CHECK-NEXT: .result f64{{$}}
+; CHECK-NEXT: argument 1{{$}}
+; CHECK-NEXT: setlocal @0{{$}}
+; CHECK-NEXT: argument 0{{$}}
+; CHECK-NEXT: setlocal @1{{$}}
+; CHECK-NEXT: fadd @1, @0{{$}}
+; CHECK-NEXT: setlocal @2{{$}}
+; CHECK-NEXT: return @2{{$}}
 define double @fadd64(double %x, double %y) {
   %a = fadd double %x, %y
   ret double %a
 }
 
-; CHECK-LABEL: (func $fsub64
-; CHECK: (setlocal @2 (fsub @1 @0))
+; CHECK-LABEL: fsub64:
+; CHECK: fsub @1, @0{{$}}
+; CHECK-NEXT: setlocal @2{{$}}
 define double @fsub64(double %x, double %y) {
   %a = fsub double %x, %y
   ret double %a
 }
 
-; CHECK-LABEL: (func $fmul64
-; CHECK: (setlocal @2 (fmul @1 @0))
+; CHECK-LABEL: fmul64:
+; CHECK: fmul @1, @0{{$}}
+; CHECK-NEXT: setlocal @2{{$}}
 define double @fmul64(double %x, double %y) {
   %a = fmul double %x, %y
   ret double %a
 }
 
-; CHECK-LABEL: (func $fdiv64
-; CHECK: (setlocal @2 (fdiv @1 @0))
+; CHECK-LABEL: fdiv64:
+; CHECK: fdiv @1, @0{{$}}
+; CHECK-NEXT: setlocal @2{{$}}
 define double @fdiv64(double %x, double %y) {
   %a = fdiv double %x, %y
   ret double %a
 }
 
-; CHECK-LABEL: (func $fabs64
-; CHECK: (setlocal @1 (fabs @0))
+; CHECK-LABEL: fabs64:
+; CHECK: fabs @0{{$}}
+; CHECK-NEXT: setlocal @1{{$}}
 define double @fabs64(double %x) {
   %a = call double @llvm.fabs.f64(double %x)
   ret double %a
 }
 
-; CHECK-LABEL: (func $fneg64
-; CHECK: (setlocal @1 (fneg @0))
+; CHECK-LABEL: fneg64:
+; CHECK: fneg @0{{$}}
+; CHECK-NEXT: setlocal @1{{$}}
 define double @fneg64(double %x) {
   %a = fsub double -0., %x
   ret double %a
 }
 
-; CHECK-LABEL: (func $copysign64
-; CHECK: (setlocal @2 (copysign @1 @0))
+; CHECK-LABEL: copysign64:
+; CHECK: copysign @1, @0{{$}}
+; CHECK-NEXT: setlocal @2{{$}}
 define double @copysign64(double %x, double %y) {
   %a = call double @llvm.copysign.f64(double %x, double %y)
   ret double %a
 }
 
-; CHECK-LABEL: (func $sqrt64
-; CHECK: (setlocal @1 (sqrt @0))
+; CHECK-LABEL: sqrt64:
+; CHECK: sqrt @0{{$}}
+; CHECK-NEXT: setlocal @1{{$}}
 define double @sqrt64(double %x) {
   %a = call double @llvm.sqrt.f64(double %x)
   ret double %a
 }
 
-; CHECK-LABEL: (func $ceil64
-; CHECK: (setlocal @1 (ceil @0))
+; CHECK-LABEL: ceil64:
+; CHECK: ceil @0{{$}}
+; CHECK-NEXT: setlocal @1{{$}}
 define double @ceil64(double %x) {
   %a = call double @llvm.ceil.f64(double %x)
   ret double %a
 }
 
-; CHECK-LABEL: (func $floor64
-; CHECK: (setlocal @1 (floor @0))
+; CHECK-LABEL: floor64:
+; CHECK: floor @0{{$}}
+; CHECK-NEXT: setlocal @1{{$}}
 define double @floor64(double %x) {
   %a = call double @llvm.floor.f64(double %x)
   ret double %a
 }
 
-; CHECK-LABEL: (func $trunc64
-; CHECK: (setlocal @1 (trunc @0))
+; CHECK-LABEL: trunc64:
+; CHECK: trunc @0{{$}}
+; CHECK-NEXT: setlocal @1{{$}}
 define double @trunc64(double %x) {
   %a = call double @llvm.trunc.f64(double %x)
   ret double %a
 }
 
-; CHECK-LABEL: (func $nearestint64
-; CHECK: (setlocal @1 (nearestint @0))
+; CHECK-LABEL: nearestint64:
+; CHECK: nearestint @0{{$}}
+; CHECK-NEXT: setlocal @1{{$}}
 define double @nearestint64(double %x) {
   %a = call double @llvm.nearbyint.f64(double %x)
   ret double %a
 }
 
-; CHECK-LABEL: (func $nearestint64_via_rint
-; CHECK: (setlocal @1 (nearestint @0))
+; CHECK-LABEL: nearestint64_via_rint:
+; CHECK: nearestint @0{{$}}
+; CHECK-NEXT: setlocal @1{{$}}
 define double @nearestint64_via_rint(double %x) {
   %a = call double @llvm.rint.f64(double %x)
   ret double %a
 }

test/CodeGen/WebAssembly/func.ll

 ; RUN: llc < %s -asm-verbose=false | FileCheck %s
 
 ; Test that basic functions assemble as expected.
 
 target datalayout = "e-p:32:32-i64:64-n32:64-S128"
 target triple = "wasm32-unknown-unknown"
 
-; CHECK-LABEL: (func $f0{{$}}
-; CHECK: (return){{$}}
-; CHECK-NEXT: ) ;; end func $f0{{$}}
+; CHECK-LABEL: f0:
+; CHECK: return{{$}}
+; CHECK: .size f0,
 define void @f0() {
   ret void
 }
 
-; CHECK-LABEL: (func $f1{{$}}
-; CHECK-NEXT: (result i32){{$}}
-; CHECK-NEXT: (setlocal @0 (immediate 0)){{$}}
-; CHECK-NEXT: (return @0){{$}}
-; CHECK-NEXT: ) ;; end func $f1{{$}}
+; CHECK-LABEL: f1:
+; CHECK-NEXT: .result i32{{$}}
+; CHECK-NEXT: immediate 0{{$}}
+; CHECK-NEXT: setlocal @0{{$}}
+; CHECK-NEXT: return @0{{$}}
+; CHECK: .size f1,
 define i32 @f1() {
   ret i32 0
 }
 
-; CHECK-LABEL: (func $f2{{$}}
-; CHECK-NEXT: (param i32) (param f32) (result i32){{$}}
-; CHECK-NEXT: (setlocal @0 (immediate 0)){{$}}
-; CHECK-NEXT: (return @0){{$}}
-; CHECK-NEXT: ) ;; end func $f2{{$}}
+; CHECK-LABEL: f2:
+; CHECK-NEXT: .param i32{{$}}
+; CHECK-NEXT: .param f32{{$}}
+; CHECK-NEXT: .result i32{{$}}
+; CHECK-NEXT: immediate 0{{$}}
+; CHECK-NEXT: setlocal @0{{$}}
+; CHECK-NEXT: return @0{{$}}
+; CHECK: .size f2,
 define i32 @f2(i32 %p1, float %p2) {
   ret i32 0
 }
 
-; CHECK-LABEL: (func $f3{{$}}
-; CHECK-NEXT: (param i32) (param f32){{$}}
-; CHECK-NEXT: (return){{$}}
-; CHECK-NEXT: ) ;; end func $f3{{$}}
+; CHECK-LABEL: f3:
+; CHECK-NEXT: .param i32{{$}}
+; CHECK-NEXT: .param f32{{$}}
+; CHECK-NEXT: return{{$}}
+; CHECK: .size f3,
 define void @f3(i32 %p1, float %p2) {
   ret void
 }

test/CodeGen/WebAssembly/global.ll

 ; RUN: llc < %s -asm-verbose=false | FileCheck %s
 
 ; Test that globals assemble as expected.
 
 target datalayout = "e-p:32:32-i64:64-n32:64-S128"
 target triple = "wasm32-unknown-unknown"
 
 ; CHECK-NOT: llvm.used
 ; CHECK-NOT: llvm.metadata
 @llvm.used = appending global [1 x i32*] [i32* @g], section "llvm.metadata"
 
-@g = private global i32 1337; ; CHECK: (global $g i32 1337)
-
-@ud = internal global i32 undef;            ; CHECK: (global $ud i32 0)
-@nil = internal global i32 zeroinitializer; ; CHECK: (global $nil i32 0)
-@z = internal global i32 0;                 ; CHECK: (global $z i32 0)
-@one = internal global i32 1;               ; CHECK: (global $one i32 1)
-@answer = internal global i32 42;           ; CHECK: (global $answer i32 42)
-@u32max = internal global i32 -1;           ; CHECK: (global $u32max i32 4294967295)
-
-@ud64 = internal global i64 undef;            ; CHECK: (global $ud64 i64 0)
-@nil64 = internal global i64 zeroinitializer; ; CHECK: (global $nil64 i64 0)
-@z64 = internal global i64 0;                 ; CHECK: (global $z64 i64 0)
-@twoP32 = internal global i64 4294967296;     ; CHECK: (global $twoP32 i64 4294967296)
-@u64max = internal global i64 -1;             ; CHECK: (global $u64max i64 18446744073709551615)
-
-@f32ud = internal global float undef;            ; CHECK: (global $f32ud f32 0x0p0)
-@f32nil = internal global float zeroinitializer; ; CHECK: (global $f32nil f32 0x0p0)
-@f32z = internal global float 0.0;               ; CHECK: (global $f32z f32 0x0p0)
-@f32nz = internal global float -0.0;             ; CHECK: (global $f32nz f32 -0x0p0)
-@f32two = internal global float 2.0;             ; CHECK: (global $f32two f32 0x1p1)
-
-@f64ud = internal global double undef;            ; CHECK: (global $f64ud f64 0x0p0)
-@f64nil = internal global double zeroinitializer; ; CHECK: (global $f64nil f64 0x0p0)
-@f64z = internal global double 0.0;               ; CHECK: (global $f64z f64 0x0p0)
-@f64nz = internal global double -0.0;             ; CHECK: (global $f64nz f64 -0x0p0)
-@f64two = internal global double 2.0;             ; CHECK: (global $f64two f64 0x1p1)
+; CHECK: .type   g,@object
+; CHECK: .align  2{{$}}
+; CHECK-NEXT: g:
+; CHECK-NEXT: .int32 1337{{$}}
+; CHECK-NEXT: .size g, 4{{$}}
+@g = private global i32 1337
+
+; CHECK-LABEL: ud:
+; CHECK-NEXT: .zero 4{{$}}
+; CHECK-NEXT: .size ud, 4{{$}}
+@ud = internal global i32 undef
+
+; CHECK: .type nil,@object
+; CHECK-NEXT: .lcomm nil,4,2{{$}}
+@nil = internal global i32 zeroinitializer
+
+; CHECK: .type z,@object
+; CHECK-NEXT: .lcomm z,4,2{{$}}
+@z = internal global i32 0
+
+; CHECK-NEXT: .type one,@object
+; CHECK-NEXT: .align 2{{$}}
+; CHECK-NEXT: one:
+; CHECK-NEXT: .int32 1{{$}}
+; CHECK-NEXT: .size one, 4{{$}}
+@one = internal global i32 1
+
+; CHECK: .type answer,@object
+; CHECK: .align 2{{$}}
+; CHECK-NEXT: answer:
+; CHECK-NEXT: .int32 42{{$}}
+; CHECK-NEXT: .size answer, 4{{$}}
+@answer = internal global i32 42
+
+; CHECK: .type u32max,@object
+; CHECK: .align 2{{$}}
+; CHECK-NEXT: u32max:
+; CHECK-NEXT: .int32 4294967295{{$}}
+; CHECK-NEXT: .size u32max, 4{{$}}
+@u32max = internal global i32 -1
+
+; CHECK: .type ud64,@object
+; CHECK: .align 3{{$}}
+; CHECK-NEXT: ud64:
+; CHECK-NEXT: .zero 8{{$}}
+; CHECK-NEXT: .size ud64, 8{{$}}
+@ud64 = internal global i64 undef
+
+; CHECK: .type nil64,@object
+; CHECK: .lcomm nil64,8,3{{$}}
+@nil64 = internal global i64 zeroinitializer
+
+; CHECK: .type z64,@object
+; CHECK: .lcomm z64,8,3{{$}}
+@z64 = internal global i64 0
+
+; CHECK: .type twoP32,@object
+; CHECK: .align 3{{$}}
+; CHECK-NEXT: twoP32:
+; CHECK-NEXT: .int64 4294967296{{$}}
+; CHECK-NEXT: .size twoP32, 8{{$}}
+@twoP32 = internal global i64 4294967296
+
+; CHECK: .type u64max,@object
+; CHECK: .align 3{{$}}
+; CHECK-NEXT: u64max:
+; CHECK-NEXT: .int64 -1{{$}}
+; CHECK-NEXT: .size u64max, 8{{$}}
+@u64max = internal global i64 -1
+
+; CHECK: .type f32ud,@object
+; CHECK: .align 2{{$}}
+; CHECK-NEXT: f32ud:
+; CHECK-NEXT: .zero 4{{$}}
+; CHECK-NEXT: .size f32ud, 4{{$}}
+@f32ud = internal global float undef
+
+; CHECK: .type f32nil,@object
+; CHECK: .lcomm f32nil,4,2{{$}}
+@f32nil = internal global float zeroinitializer
+
+; CHECK: .type f32z,@object
+; CHECK: .lcomm f32z,4,2{{$}}
+@f32z = internal global float 0.0
+
+; CHECK: .type f32nz,@object
+; CHECK: .align 2{{$}}
+; CHECK: f32nz:
+; CHECK: .int32 2147483648{{$}}
+; CHECK: .size f32nz, 4{{$}}
+@f32nz = internal global float -0.0
+
+; CHECK: .type f32two,@object
+; CHECK: .align 2{{$}}
+; CHECK-NEXT: f32two:
+; CHECK-NEXT: .int32 1073741824{{$}}
+; CHECK-NEXT: .size f32two, 4{{$}}
+@f32two = internal global float 2.0
+
+; CHECK: .type f64ud,@object
+; CHECK: .align 3{{$}}
+; CHECK-NEXT: f64ud:
+; CHECK-NEXT: .zero 8{{$}}
+; CHECK-NEXT: .size f64ud, 8{{$}}
+@f64ud = internal global double undef
+
+; CHECK: .type f64nil,@object
+; CHECK: .lcomm f64nil,8,3{{$}}
+@f64nil = internal global double zeroinitializer
+
+; CHECK: .type f64z,@object
+; CHECK: .lcomm f64z,8,3{{$}}
+@f64z = internal global double 0.0
+
+; CHECK: .type f64nz,@object
+; CHECK: .align 3{{$}}
+; CHECK-NEXT: f64nz:
+; CHECK-NEXT: .int64 -9223372036854775808{{$}}
+; CHECK-NEXT: .size f64nz, 8{{$}}
+@f64nz = internal global double -0.0
+
+; CHECK: .type f64two,@object
+; CHECK: .align 3{{$}}
+; CHECK-NEXT: f64two:
+; CHECK-NEXT: .int64 4611686018427387904{{$}}
+; CHECK-NEXT: .size f64two, 8{{$}}
+@f64two = internal global double 2.0

test/CodeGen/WebAssembly/globl.ll

 ; RUN: llc < %s -asm-verbose=false | FileCheck %s
 
-; Test that the `.globl` directive is commented out.
-
 target datalayout = "e-p:32:32-i64:64-n32:64-S128"
 target triple = "wasm32-unknown-unknown"
 
-; CHECK-NOT: globl
-; CHECK: ;; .globl foo
-; CHECK-NOT: globl
-; CHECK-LABEL: (func $foo
+; CHECK: .globl foo
+; CHECK-LABEL: foo:
 define void @foo() {
   ret void
 }

test/CodeGen/WebAssembly/immediates.ll

 ; RUN: llc < %s -asm-verbose=false | FileCheck %s
 
 ; Test that basic immediates assemble as expected.
 
 target datalayout = "e-p:32:32-i64:64-n32:64-S128"
 target triple = "wasm32-unknown-unknown"
 
-; CHECK-LABEL: (func $zero_i32
-; CHECK-NEXT: (result i32)
-; CHECK-NEXT: (setlocal @0 (immediate 0))
-; CHECK-NEXT: (return @0)
+; CHECK-LABEL: zero_i32:
+; CHECK-NEXT: .result i32{{$}}
+; CHECK-NEXT: immediate 0{{$}}
+; CHECK-NEXT: setlocal @0{{$}}
+; CHECK-NEXT: return @0{{$}}
 define i32 @zero_i32() {
   ret i32 0
 }
 
-; CHECK-LABEL: (func $one_i32
-; CHECK-NEXT: (result i32)
-; CHECK-NEXT: (setlocal @0 (immediate 1))
-; CHECK-NEXT: (return @0)
+; CHECK-LABEL: one_i32:
+; CHECK-NEXT: .result i32{{$}}
+; CHECK-NEXT: immediate 1{{$}}
+; CHECK-NEXT: setlocal @0{{$}}
+; CHECK-NEXT: return @0{{$}}
 define i32 @one_i32() {
   ret i32 1
 }
 
-; CHECK-LABEL: (func $max_i32
-; CHECK-NEXT: (result i32)
-; CHECK-NEXT: (setlocal @0 (immediate 2147483647))
-; CHECK-NEXT: (return @0)
+; CHECK-LABEL: max_i32:
+; CHECK-NEXT: .result i32{{$}}
+; CHECK-NEXT: immediate 2147483647{{$}}
+; CHECK-NEXT: setlocal @0{{$}}
+; CHECK-NEXT: return @0{{$}}
 define i32 @max_i32() {
   ret i32 2147483647
 }
 
-; CHECK-LABEL: (func $min_i32
-; CHECK-NEXT: (result i32)
-; CHECK-NEXT: (setlocal @0 (immediate -2147483648))
-; CHECK-NEXT: (return @0)
+; CHECK-LABEL: min_i32:
+; CHECK-NEXT: .result i32{{$}}
+; CHECK-NEXT: immediate -2147483648{{$}}
+; CHECK-NEXT: setlocal @0{{$}}
+; CHECK-NEXT: return @0{{$}}
 define i32 @min_i32() {
   ret i32 -2147483648
 }
 
-; CHECK-LABEL: (func $zero_i64
-; CHECK-NEXT: (result i64)
-; CHECK-NEXT: (setlocal @0 (immediate 0))
-; CHECK-NEXT: (return @0)
+; CHECK-LABEL: zero_i64:
+; CHECK-NEXT: .result i64{{$}}
+; CHECK-NEXT: immediate 0{{$}}
+; CHECK-NEXT: setlocal @0{{$}}
+; CHECK-NEXT: return @0{{$}}
 define i64 @zero_i64() {
   ret i64 0
 }
 
-; CHECK-LABEL: (func $one_i64
-; CHECK-NEXT: (result i64)
-; CHECK-NEXT: (setlocal @0 (immediate 1))
-; CHECK-NEXT: (return @0)
+; CHECK-LABEL: one_i64:
+; CHECK-NEXT: .result i64{{$}}
+; CHECK-NEXT: immediate 1{{$}}
+; CHECK-NEXT: setlocal @0{{$}}
+; CHECK-NEXT: return @0{{$}}
 define i64 @one_i64() {
   ret i64 1
 }
 
-; CHECK-LABEL: (func $max_i64
-; CHECK-NEXT: (result i64)
-; CHECK-NEXT: (setlocal @0 (immediate 9223372036854775807))
-; CHECK-NEXT: (return @0)
+; CHECK-LABEL: max_i64:
+; CHECK-NEXT: .result i64{{$}}
+; CHECK-NEXT: immediate 9223372036854775807{{$}}
+; CHECK-NEXT: setlocal @0{{$}}
+; CHECK-NEXT: return @0{{$}}
 define i64 @max_i64() {
   ret i64 9223372036854775807
 }
 
-; CHECK-LABEL: (func $min_i64
-; CHECK-NEXT: (result i64)
-; CHECK-NEXT: (setlocal @0 (immediate -9223372036854775808))
-; CHECK-NEXT: (return @0)
+; CHECK-LABEL: min_i64:
+; CHECK-NEXT: .result i64{{$}}
+; CHECK-NEXT: immediate -9223372036854775808{{$}}
+; CHECK-NEXT: setlocal @0{{$}}
+; CHECK-NEXT: return @0{{$}}
 define i64 @min_i64() {
   ret i64 -9223372036854775808
 }
 
-; CHECK-LABEL: (func $negzero_f32
-; CHECK-NEXT: (result f32)
-; CHECK-NEXT: (setlocal @0 (immediate -0x0p0))
-; CHECK-NEXT: (return @0)
+; CHECK-LABEL: negzero_f32:
+; CHECK-NEXT: .result f32{{$}}
+; CHECK-NEXT: immediate -0x0p0{{$}}
+; CHECK-NEXT: setlocal @0{{$}}
+; CHECK-NEXT: return @0{{$}}
 define float @negzero_f32() {
   ret float -0.0
 }
 
-; CHECK-LABEL: (func $zero_f32
-; CHECK-NEXT: (result f32)
-; CHECK-NEXT: (setlocal @0 (immediate 0x0p0))
-; CHECK-NEXT: (return @0)
+; CHECK-LABEL: zero_f32:
+; CHECK-NEXT: .result f32{{$}}
+; CHECK-NEXT: immediate 0x0p0{{$}}
+; CHECK-NEXT: setlocal @0{{$}}
+; CHECK-NEXT: return @0{{$}}
 define float @zero_f32() {
   ret float 0.0
 }
 
-; CHECK-LABEL: (func $one_f32
-; CHECK-NEXT: (result f32)
-; CHECK-NEXT: (setlocal @0 (immediate 0x1p0))
-; CHECK-NEXT: (return @0)
+; CHECK-LABEL: one_f32:
+; CHECK-NEXT: .result f32{{$}}
+; CHECK-NEXT: immediate 0x1p0{{$}}
+; CHECK-NEXT: setlocal @0{{$}}
+; CHECK-NEXT: return @0{{$}}
 define float @one_f32() {
   ret float 1.0
 }
 
-; CHECK-LABEL: (func $two_f32
-; CHECK-NEXT: (result f32)
-; CHECK-NEXT: (setlocal @0 (immediate 0x1p1))
-; CHECK-NEXT: (return @0)
+; CHECK-LABEL: two_f32:
+; CHECK-NEXT: .result f32{{$}}
+; CHECK-NEXT: immediate 0x1p1{{$}}
+; CHECK-NEXT: setlocal @0{{$}}
+; CHECK-NEXT: return @0{{$}}
 define float @two_f32() {
   ret float 2.0
 }
 
-; CHECK-LABEL: (func $nan_f32
-; CHECK-NEXT: (result f32)
-; CHECK-NEXT: (setlocal @0 (immediate nan))
-; CHECK-NEXT: (return @0)
+; CHECK-LABEL: nan_f32:
+; CHECK-NEXT: .result f32{{$}}
+; CHECK-NEXT: immediate nan
+; CHECK-NEXT: setlocal @0{{$}}
+; CHECK-NEXT: return @0{{$}}
 define float @nan_f32() {
   ret float 0x7FF8000000000000
 }
 
-; CHECK-LABEL: (func $negnan_f32
-; CHECK-NEXT: (result f32)
-; CHECK-NEXT: (setlocal @0 (immediate -nan))
-; CHECK-NEXT: (return @0)
+; CHECK-LABEL: negnan_f32:
+; CHECK-NEXT: .result f32{{$}}
+; CHECK-NEXT: immediate -nan
+; CHECK-NEXT: setlocal @0{{$}}
+; CHECK-NEXT: return @0{{$}}
 define float @negnan_f32() {
   ret float 0xFFF8000000000000
 }
 
-; CHECK-LABEL: (func $inf_f32
-; CHECK-NEXT: (result f32)
-; CHECK-NEXT: (setlocal @0 (immediate infinity))
-; CHECK-NEXT: (return @0)
+; CHECK-LABEL: inf_f32:
+; CHECK-NEXT: .result f32{{$}}
+; CHECK-NEXT: immediate infinity
+; CHECK-NEXT: setlocal @0{{$}}
+; CHECK-NEXT: return @0{{$}}
 define float @inf_f32() {
   ret float 0x7FF0000000000000
 }
 
-; CHECK-LABEL: (func $neginf_f32
-; CHECK-NEXT: (result f32)
-; CHECK-NEXT: (setlocal @0 (immediate -infinity))
-; CHECK-NEXT: (return @0)
+; CHECK-LABEL: neginf_f32:
+; CHECK-NEXT: .result f32{{$}}
+; CHECK-NEXT: immediate -infinity
+; CHECK-NEXT: setlocal @0{{$}}
+; CHECK-NEXT: return @0{{$}}
 define float @neginf_f32() {
   ret float 0xFFF0000000000000
 }
 
-; CHECK-LABEL: (func $negzero_f64
-; CHECK-NEXT: (result f64)
-; CHECK-NEXT: (setlocal @0 (immediate -0x0p0))
-; CHECK-NEXT: (return @0)
+; CHECK-LABEL: negzero_f64:
+; CHECK-NEXT: .result f64{{$}}
+; CHECK-NEXT: immediate -0x0p0{{$}}
+; CHECK-NEXT: setlocal @0{{$}}
+; CHECK-NEXT: return @0{{$}}
 define double @negzero_f64() {
   ret double -0.0
 }
 
-; CHECK-LABEL: (func $zero_f64
-; CHECK-NEXT: (result f64)
-; CHECK-NEXT: (setlocal @0 (immediate 0x0p0))
-; CHECK-NEXT: (return @0)
+; CHECK-LABEL: zero_f64:
+; CHECK-NEXT: .result f64{{$}}
+; CHECK-NEXT: immediate 0x0p0{{$}}
+; CHECK-NEXT: setlocal @0{{$}}
+; CHECK-NEXT: return @0{{$}}
 define double @zero_f64() {
   ret double 0.0
 }
 
-; CHECK-LABEL: (func $one_f64
-; CHECK-NEXT: (result f64)
-; CHECK-NEXT: (setlocal @0 (immediate 0x1p0))
-; CHECK-NEXT: (return @0)
+; CHECK-LABEL: one_f64:
+; CHECK-NEXT: .result f64{{$}}
+; CHECK-NEXT: immediate 0x1p0{{$}}
+; CHECK-NEXT: setlocal @0{{$}}
+; CHECK-NEXT: return @0{{$}}
 define double @one_f64() {
   ret double 1.0
 }
 
-; CHECK-LABEL: (func $two_f64
-; CHECK-NEXT: (result f64)
-; CHECK-NEXT: (setlocal @0 (immediate 0x1p1))
-; CHECK-NEXT: (return @0)
+; CHECK-LABEL: two_f64:
+; CHECK-NEXT: .result f64{{$}}
+; CHECK-NEXT: immediate 0x1p1{{$}}
+; CHECK-NEXT: setlocal @0{{$}}
+; CHECK-NEXT: return @0{{$}}
 define double @two_f64() {
   ret double 2.0
 }
 
-; CHECK-LABEL: (func $nan_f64
-; CHECK-NEXT: (result f64)
-; CHECK-NEXT: (setlocal @0 (immediate nan))
-; CHECK-NEXT: (return @0)
+; CHECK-LABEL: nan_f64:
+; CHECK-NEXT: .result f64{{$}}
+; CHECK-NEXT: immediate nan
+; CHECK-NEXT: setlocal @0{{$}}
+; CHECK-NEXT: return @0{{$}}
 define double @nan_f64() {
   ret double 0x7FF8000000000000
 }
 
-; CHECK-LABEL: (func $negnan_f64
-; CHECK-NEXT: (result f64)
-; CHECK-NEXT: (setlocal @0 (immediate -nan))
-; CHECK-NEXT: (return @0)
+; CHECK-LABEL: negnan_f64:
+; CHECK-NEXT: .result f64{{$}}
+; CHECK-NEXT: immediate -nan
+; CHECK-NEXT: setlocal @0{{$}}
+; CHECK-NEXT: return @0{{$}}
 define double @negnan_f64() {
   ret double 0xFFF8000000000000
 }
 
-; CHECK-LABEL: (func $inf_f64
-; CHECK-NEXT: (result f64)
-; CHECK-NEXT: (setlocal @0 (immediate infinity))
-; CHECK-NEXT: (return @0)
+; CHECK-LABEL: inf_f64:
+; CHECK-NEXT: .result f64{{$}}
+; CHECK-NEXT: immediate infinity
+; CHECK-NEXT: setlocal @0{{$}}
+; CHECK-NEXT: return @0{{$}}
 define double @inf_f64() {
   ret double 0x7FF0000000000000
 }
 
-; CHECK-LABEL: (func $neginf_f64
-; CHECK-NEXT: (result f64)
-; CHECK-NEXT: (setlocal @0 (immediate -infinity))
-; CHECK-NEXT: (return @0)
+; CHECK-LABEL: neginf_f64:
+; CHECK-NEXT: .result f64{{$}}
+; CHECK-NEXT: immediate -infinity
+; CHECK-NEXT: setlocal @0{{$}}
+; CHECK-NEXT: return @0{{$}}
 define double @neginf_f64() {
   ret double 0xFFF0000000000000
 }

test/CodeGen/WebAssembly/integer32.ll

 ; RUN: llc < %s -asm-verbose=false | FileCheck %s
 
 ; Test that basic 32-bit integer operations assemble as expected.
 
 target datalayout = "e-p:32:32-i64:64-n32:64-S128"
 target triple = "wasm32-unknown-unknown"
 
 declare i32 @llvm.ctlz.i32(i32, i1)
 declare i32 @llvm.cttz.i32(i32, i1)
 declare i32 @llvm.ctpop.i32(i32)
 
-; CHECK-LABEL: (func $add32
-; CHECK-NEXT: (param i32) (param i32) (result i32)
-; CHECK-NEXT: (setlocal @0 (argument 1))
-; CHECK-NEXT: (setlocal @1 (argument 0))
-; CHECK-NEXT: (setlocal @2 (add @1 @0))
-; CHECK-NEXT: (return @2)
+; CHECK-LABEL: add32:
+; CHECK-NEXT: .param i32{{$}}
+; CHECK-NEXT: .param i32{{$}}
+; CHECK-NEXT: .result i32{{$}}
+; CHECK-NEXT: argument 1{{$}}
+; CHECK-NEXT: setlocal @0{{$}}
+; CHECK-NEXT: argument 0{{$}}
+; CHECK-NEXT: setlocal @1{{$}}
+; CHECK-NEXT: add @1, @0{{$}}
+; CHECK-NEXT: setlocal @2{{$}}
+; CHECK-NEXT: return @2{{$}}
 define i32 @add32(i32 %x, i32 %y) {
   %a = add i32 %x, %y
   ret i32 %a
 }
 
-; CHECK-LABEL: (func $sub32
-; CHECK-NEXT: (param i32) (param i32) (result i32)
-; CHECK-NEXT: (setlocal @0 (argument 1))
-; CHECK-NEXT: (setlocal @1 (argument 0))
-; CHECK-NEXT: (setlocal @2 (sub @1 @0))
-; CHECK-NEXT: (return @2)
+; CHECK-LABEL: sub32:
+; CHECK-NEXT: .param i32{{$}}
+; CHECK-NEXT: .param i32{{$}}
+; CHECK-NEXT: .result i32{{$}}
+; CHECK-NEXT: argument 1{{$}}
+; CHECK-NEXT: setlocal @0{{$}}
+; CHECK-NEXT: argument 0{{$}}
+; CHECK-NEXT: setlocal @1{{$}}
+; CHECK-NEXT: sub @1, @0{{$}}
+; CHECK-NEXT: setlocal @2{{$}}
+; CHECK-NEXT: return @2{{$}}
 define i32 @sub32(i32 %x, i32 %y) {
   %a = sub i32 %x, %y
   ret i32 %a
 }
 
-; CHECK-LABEL: (func $mul32
-; CHECK-NEXT: (param i32) (param i32) (result i32)
-; CHECK-NEXT: (setlocal @0 (argument 1))
-; CHECK-NEXT: (setlocal @1 (argument 0))
-; CHECK-NEXT: (setlocal @2 (mul @1 @0))
-; CHECK-NEXT: (return @2)
+; CHECK-LABEL: mul32:
+; CHECK-NEXT: .param i32{{$}}
+; CHECK-NEXT: .param i32{{$}}
+; CHECK-NEXT: .result i32{{$}}
+; CHECK-NEXT: argument 1{{$}}
+; CHECK-NEXT: setlocal @0{{$}}
+; CHECK-NEXT: argument 0{{$}}
+; CHECK-NEXT: setlocal @1{{$}}
+; CHECK-NEXT: mul @1, @0{{$}}
+; CHECK-NEXT: setlocal @2{{$}}
+; CHECK-NEXT: return @2{{$}}
 define i32 @mul32(i32 %x, i32 %y) {
   %a = mul i32 %x, %y
   ret i32 %a
 }
 
-; CHECK-LABEL: (func $sdiv32
-; CHECK-NEXT: (param i32) (param i32) (result i32)
-; CHECK-NEXT: (setlocal @0 (argument 1))
-; CHECK-NEXT: (setlocal @1 (argument 0))
-; CHECK-NEXT: (setlocal @2 (sdiv @1 @0))
-; CHECK-NEXT: (return @2)
+; CHECK-LABEL: sdiv32:
+; CHECK-NEXT: .param i32{{$}}
+; CHECK-NEXT: .param i32{{$}}
+; CHECK-NEXT: .result i32{{$}}
+; CHECK-NEXT: argument 1{{$}}
+; CHECK-NEXT: setlocal @0{{$}}
+; CHECK-NEXT: argument 0{{$}}
+; CHECK-NEXT: setlocal @1{{$}}
+; CHECK-NEXT: sdiv @1, @0{{$}}
+; CHECK-NEXT: setlocal @2{{$}}
+; CHECK-NEXT: return @2{{$}}
 define i32 @sdiv32(i32 %x, i32 %y) {
   %a = sdiv i32 %x, %y
   ret i32 %a
 }
 
-; CHECK-LABEL: (func $udiv32
-; CHECK-NEXT: (param i32) (param i32) (result i32)
-; CHECK-NEXT: (setlocal @0 (argument 1))
-; CHECK-NEXT: (setlocal @1 (argument 0))
-; CHECK-NEXT: (setlocal @2 (udiv @1 @0))
-; CHECK-NEXT: (return @2)
+; CHECK-LABEL: udiv32:
+; CHECK-NEXT: .param i32{{$}}
+; CHECK-NEXT: .param i32{{$}}
+; CHECK-NEXT: .result i32{{$}}
+; CHECK-NEXT: argument 1{{$}}
+; CHECK-NEXT: setlocal @0{{$}}
+; CHECK-NEXT: argument 0{{$}}
+; CHECK-NEXT: setlocal @1{{$}}
+; CHECK-NEXT: udiv @1, @0{{$}}
+; CHECK-NEXT: setlocal @2{{$}}
+; CHECK-NEXT: return @2{{$}}
 define i32 @udiv32(i32 %x, i32 %y) {
   %a = udiv i32 %x, %y
   ret i32 %a
 }
 
-; CHECK-LABEL: (func $srem32
-; CHECK-NEXT: (param i32) (param i32) (result i32)
-; CHECK-NEXT: (setlocal @0 (argument 1))
-; CHECK-NEXT: (setlocal @1 (argument 0))
-; CHECK-NEXT: (setlocal @2 (srem @1 @0))
-; CHECK-NEXT: (return @2)
+; CHECK-LABEL: srem32:
+; CHECK-NEXT: .param i32{{$}}
+; CHECK-NEXT: .param i32{{$}}
+; CHECK-NEXT: .result i32{{$}}
+; CHECK-NEXT: argument 1{{$}}
+; CHECK-NEXT: setlocal @0{{$}}
+; CHECK-NEXT: argument 0{{$}}
+; CHECK-NEXT: setlocal @1{{$}}
+; CHECK-NEXT: srem @1, @0{{$}}
+; CHECK-NEXT: setlocal @2{{$}}
+; CHECK-NEXT: return @2{{$}}
 define i32 @srem32(i32 %x, i32 %y) {
   %a = srem i32 %x, %y
   ret i32 %a
 }
 
-; CHECK-LABEL: (func $urem32
-; CHECK-NEXT: (param i32) (param i32) (result i32)
-; CHECK-NEXT: (setlocal @0 (argument 1))
-; CHECK-NEXT: (setlocal @1 (argument 0))
-; CHECK-NEXT: (setlocal @2 (urem @1 @0))
-; CHECK-NEXT: (return @2)
+; CHECK-LABEL: urem32:
+; CHECK-NEXT: .param i32{{$}}
+; CHECK-NEXT: .param i32{{$}}
+; CHECK-NEXT: .result i32{{$}}
+; CHECK-NEXT: argument 1{{$}}
+; CHECK-NEXT: setlocal @0{{$}}
+; CHECK-NEXT: argument 0{{$}}
+; CHECK-NEXT: setlocal @1{{$}}
+; CHECK-NEXT: urem @1, @0{{$}}
+; CHECK-NEXT: setlocal @2{{$}}
+; CHECK-NEXT: return @2{{$}}
 define i32 @urem32(i32 %x, i32 %y) {
   %a = urem i32 %x, %y
   ret i32 %a
 }
 
-; CHECK-LABEL: (func $and32
-; CHECK-NEXT: (param i32) (param i32) (result i32)
-; CHECK-NEXT: (setlocal @0 (argument 1))
-; CHECK-NEXT: (setlocal @1 (argument 0))
-; CHECK-NEXT: (setlocal @2 (and @1 @0))
-; CHECK-NEXT: (return @2)
+; CHECK-LABEL: and32:
+; CHECK-NEXT: .param i32{{$}}
+; CHECK-NEXT: .param i32{{$}}
+; CHECK-NEXT: .result i32{{$}}
+; CHECK-NEXT: argument 1{{$}}
+; CHECK-NEXT: setlocal @0{{$}}
+; CHECK-NEXT: argument 0{{$}}
+; CHECK-NEXT: setlocal @1{{$}}
+; CHECK-NEXT: and @1, @0{{$}}
+; CHECK-NEXT: setlocal @2{{$}}
+; CHECK-NEXT: return @2{{$}}
 define i32 @and32(i32 %x, i32 %y) {
   %a = and i32 %x, %y
   ret i32 %a
 }
 
-; CHECK-LABEL: (func $ior32
-; CHECK-NEXT: (param i32) (param i32) (result i32)
-; CHECK-NEXT: (setlocal @0 (argument 1))
-; CHECK-NEXT: (setlocal @1 (argument 0))
-; CHECK-NEXT: (setlocal @2 (ior @1 @0))
-; CHECK-NEXT: (return @2)
+; CHECK-LABEL: ior32:
+; CHECK-NEXT: .param i32{{$}}
+; CHECK-NEXT: .param i32{{$}}
+; CHECK-NEXT: .result i32{{$}}
+; CHECK-NEXT: argument 1{{$}}
+; CHECK-NEXT: setlocal @0{{$}}
+; CHECK-NEXT: argument 0{{$}}
+; CHECK-NEXT: setlocal @1{{$}}
+; CHECK-NEXT: ior @1, @0{{$}}
+; CHECK-NEXT: setlocal @2{{$}}
+; CHECK-NEXT: return @2{{$}}
 define i32 @ior32(i32 %x, i32 %y) {
   %a = or i32 %x, %y
   ret i32 %a
 }
 
-; CHECK-LABEL: (func $xor32
-; CHECK-NEXT: (param i32) (param i32) (result i32)
-; CHECK-NEXT: (setlocal @0 (argument 1))
-; CHECK-NEXT: (setlocal @1 (argument 0))
-; CHECK-NEXT: (setlocal @2 (xor @1 @0))
-; CHECK-NEXT: (return @2)
+; CHECK-LABEL: xor32:
+; CHECK-NEXT: .param i32{{$}}
+; CHECK-NEXT: .param i32{{$}}
+; CHECK-NEXT: .result i32{{$}}
+; CHECK-NEXT: argument 1{{$}}
+; CHECK-NEXT: setlocal @0{{$}}
+; CHECK-NEXT: argument 0{{$}}
+; CHECK-NEXT: setlocal @1{{$}}
+; CHECK-NEXT: xor @1, @0{{$}}
+; CHECK-NEXT: setlocal @2{{$}}
+; CHECK-NEXT: return @2{{$}}
 define i32 @xor32(i32 %x, i32 %y) {
   %a = xor i32 %x, %y
   ret i32 %a
 }
 
-; CHECK-LABEL: (func $shl32
-; CHECK-NEXT: (param i32) (param i32) (result i32)
-; CHECK-NEXT: (setlocal @0 (argument 1))
-; CHECK-NEXT: (setlocal @1 (argument 0))
-; CHECK-NEXT: (setlocal @2 (shl @1 @0))
-; CHECK-NEXT: (return @2)
+; CHECK-LABEL: shl32:
+; CHECK-NEXT: .param i32{{$}}
+; CHECK-NEXT: .param i32{{$}}
+; CHECK-NEXT: .result i32{{$}}
+; CHECK-NEXT: argument 1{{$}}
+; CHECK-NEXT: setlocal @0{{$}}
+; CHECK-NEXT: argument 0{{$}}
+; CHECK-NEXT: setlocal @1{{$}}
+; CHECK-NEXT: shl @1, @0{{$}}
+; CHECK-NEXT: setlocal @2{{$}}
+; CHECK-NEXT: return @2{{$}}
 define i32 @shl32(i32 %x, i32 %y) {
   %a = shl i32 %x, %y
   ret i32 %a
 }
 
-; CHECK-LABEL: (func $shr32
-; CHECK-NEXT: (param i32) (param i32) (result i32)
-; CHECK-NEXT: (setlocal @0 (argument 1))
-; CHECK-NEXT: (setlocal @1 (argument 0))
-; CHECK-NEXT: (setlocal @2 (shr_u @1 @0))
-; CHECK-NEXT: (return @2)
+; CHECK-LABEL: shr32:
+; CHECK-NEXT: .param i32{{$}}
+; CHECK-NEXT: .param i32{{$}}
+; CHECK-NEXT: .result i32{{$}}
+; CHECK-NEXT: argument 1{{$}}
+; CHECK-NEXT: setlocal @0{{$}}
+; CHECK-NEXT: argument 0{{$}}
+; CHECK-NEXT: setlocal @1{{$}}
+; CHECK-NEXT: shr_u @1, @0{{$}}
+; CHECK-NEXT: setlocal @2{{$}}
+; CHECK-NEXT: return @2{{$}}
 define i32 @shr32(i32 %x, i32 %y) {
   %a = lshr i32 %x, %y
   ret i32 %a
 }
 
-; CHECK-LABEL: (func $sar32
-; CHECK-NEXT: (param i32) (param i32) (result i32)
-; CHECK-NEXT: (setlocal @0 (argument 1))
-; CHECK-NEXT: (setlocal @1 (argument 0))
-; CHECK-NEXT: (setlocal @2 (shr_s @1 @0))
-; CHECK-NEXT: (return @2)
+; CHECK-LABEL: sar32:
+; CHECK-NEXT: .param i32{{$}}
+; CHECK-NEXT: .param i32{{$}}
+; CHECK-NEXT: .result i32{{$}}
+; CHECK-NEXT: argument 1{{$}}
+; CHECK-NEXT: setlocal @0{{$}}
+; CHECK-NEXT: argument 0{{$}}
+; CHECK-NEXT: setlocal @1{{$}}
+; CHECK-NEXT: shr_s @1, @0{{$}}
+; CHECK-NEXT: setlocal @2{{$}}
+; CHECK-NEXT: return @2{{$}}
 define i32 @sar32(i32 %x, i32 %y) {
   %a = ashr i32 %x, %y
   ret i32 %a
 }
 
-; CHECK-LABEL: (func $clz32
-; CHECK-NEXT: (param i32) (result i32)
-; CHECK-NEXT: (setlocal @0 (argument 0))
-; CHECK-NEXT: (setlocal @1 (clz @0))
-; CHECK-NEXT: (return @1)
+; CHECK-LABEL: clz32:
+; CHECK-NEXT: .param i32{{$}}
+; CHECK-NEXT: .result i32{{$}}
+; CHECK-NEXT: argument 0{{$}}
+; CHECK-NEXT: setlocal @0{{$}}
+; CHECK-NEXT: clz @0{{$}}
+; CHECK-NEXT: setlocal @1{{$}}
+; CHECK-NEXT: return @1{{$}}
 define i32 @clz32(i32 %x) {
   %a = call i32 @llvm.ctlz.i32(i32 %x, i1 false)
   ret i32 %a
 }
 
-; CHECK-LABEL: (func $clz32_zero_undef
-; CHECK-NEXT: (param i32) (result i32)
-; CHECK-NEXT: (setlocal @0 (argument 0))
-; CHECK-NEXT: (setlocal @1 (clz @0))
-; CHECK-NEXT: (return @1)
+; CHECK-LABEL: clz32_zero_undef:
+; CHECK-NEXT: .param i32{{$}}
+; CHECK-NEXT: .result i32{{$}}
+; CHECK-NEXT: argument 0{{$}}
+; CHECK-NEXT: setlocal @0{{$}}
+; CHECK-NEXT: clz @0{{$}}
+; CHECK-NEXT: setlocal @1{{$}}
+; CHECK-NEXT: return @1{{$}}
 define i32 @clz32_zero_undef(i32 %x) {
   %a = call i32 @llvm.ctlz.i32(i32 %x, i1 true)
   ret i32 %a
 }
 
-; CHECK-LABEL: (func $ctz32
-; CHECK-NEXT: (param i32) (result i32)
-; CHECK-NEXT: (setlocal @0 (argument 0))
-; CHECK-NEXT: (setlocal @1 (ctz @0))
-; CHECK-NEXT: (return @1)
+; CHECK-LABEL: ctz32:
+; CHECK-NEXT: .param i32{{$}}
+; CHECK-NEXT: .result i32{{$}}
+; CHECK-NEXT: argument 0{{$}}
+; CHECK-NEXT: setlocal @0{{$}}
+; CHECK-NEXT: ctz @0{{$}}
+; CHECK-NEXT: setlocal @1{{$}}
+; CHECK-NEXT: return @1{{$}}
 define i32 @ctz32(i32 %x) {
   %a = call i32 @llvm.cttz.i32(i32 %x, i1 false)
   ret i32 %a
 }
 
-; CHECK-LABEL: (func $ctz32_zero_undef
-; CHECK-NEXT: (param i32) (result i32)
-; CHECK-NEXT: (setlocal @0 (argument 0))
-; CHECK-NEXT: (setlocal @1 (ctz @0))
-; CHECK-NEXT: (return @1)
+; CHECK-LABEL: ctz32_zero_undef:
+; CHECK-NEXT: .param i32{{$}}
+; CHECK-NEXT: .result i32{{$}}
+; CHECK-NEXT: argument 0{{$}}
+; CHECK-NEXT: setlocal @0{{$}}
+; CHECK-NEXT: ctz @0{{$}}
+; CHECK-NEXT: setlocal @1{{$}}
+; CHECK-NEXT: return @1{{$}}
 define i32 @ctz32_zero_undef(i32 %x) {
   %a = call i32 @llvm.cttz.i32(i32 %x, i1 true)
   ret i32 %a
 }
 
-; CHECK-LABEL: (func $popcnt32
-; CHECK-NEXT: (param i32) (result i32)
-; CHECK-NEXT: (setlocal @0 (argument 0))
-; CHECK-NEXT: (setlocal @1 (popcnt @0))
-; CHECK-NEXT: (return @1)
+; CHECK-LABEL: popcnt32:
+; CHECK-NEXT: .param i32{{$}}
+; CHECK-NEXT: .result i32{{$}}
+; CHECK-NEXT: argument 0{{$}}
+; CHECK-NEXT: setlocal @0{{$}}
+; CHECK-NEXT: popcnt @0{{$}}
+; CHECK-NEXT: setlocal @1{{$}}
+; CHECK-NEXT: return @1{{$}}
 define i32 @popcnt32(i32 %x) {
   %a = call i32 @llvm.ctpop.i32(i32 %x)
   ret i32 %a
 }

test/CodeGen/WebAssembly/integer64.ll

 ; RUN: llc < %s -asm-verbose=false | FileCheck %s
 
 ; Test that basic 64-bit integer operations assemble as expected.
 
 target datalayout = "e-p:32:32-i64:64-n32:64-S128"
 target triple = "wasm32-unknown-unknown"
 
 declare i64 @llvm.ctlz.i64(i64, i1)
 declare i64 @llvm.cttz.i64(i64, i1)
 declare i64 @llvm.ctpop.i64(i64)
 
-; CHECK-LABEL: (func $add64
-; CHECK-NEXT: (param i64) (param i64) (result i64)
-; CHECK-NEXT: (setlocal @0 (argument 1))
-; CHECK-NEXT: (setlocal @1 (argument 0))
-; CHECK-NEXT: (setlocal @2 (add @1 @0))
-; CHECK-NEXT: (return @2)
+; CHECK-LABEL: add64:
+; CHECK-NEXT: .param i64{{$}}
+; CHECK-NEXT: .param i64{{$}}
+; CHECK-NEXT: .result i64{{$}}
+; CHECK-NEXT: argument 1{{$}}
+; CHECK-NEXT: setlocal @0{{$}}
+; CHECK-NEXT: argument 0{{$}}
+; CHECK-NEXT: setlocal @1{{$}}
+; CHECK-NEXT: add @1, @0{{$}}
+; CHECK-NEXT: setlocal @2{{$}}
+; CHECK-NEXT: return @2{{$}}
 define i64 @add64(i64 %x, i64 %y) {
   %a = add i64 %x, %y
   ret i64 %a
 }
 
-; CHECK-LABEL: (func $sub64
-; CHECK-NEXT: (param i64) (param i64) (result i64)
-; CHECK-NEXT: (setlocal @0 (argument 1))
-; CHECK-NEXT: (setlocal @1 (argument 0))
-; CHECK-NEXT: (setlocal @2 (sub @1 @0))
-; CHECK-NEXT: (return @2)
+; CHECK-LABEL: sub64:
+; CHECK-NEXT: .param i64{{$}}
+; CHECK-NEXT: .param i64{{$}}
+; CHECK-NEXT: .result i64{{$}}
+; CHECK-NEXT: argument 1{{$}}
+; CHECK-NEXT: setlocal @0{{$}}
+; CHECK-NEXT: argument 0{{$}}
+; CHECK-NEXT: setlocal @1{{$}}
+; CHECK-NEXT: sub @1, @0{{$}}
+; CHECK-NEXT: setlocal @2{{$}}
+; CHECK-NEXT: return @2{{$}}
 define i64 @sub64(i64 %x, i64 %y) {
   %a = sub i64 %x, %y
   ret i64 %a
 }
 
-; CHECK-LABEL: (func $mul64
-; CHECK-NEXT: (param i64) (param i64) (result i64)
-; CHECK-NEXT: (setlocal @0 (argument 1))
-; CHECK-NEXT: (setlocal @1 (argument 0))
-; CHECK-NEXT: (setlocal @2 (mul @1 @0))
-; CHECK-NEXT: (return @2)
+; CHECK-LABEL: mul64:
+; CHECK-NEXT: .param i64{{$}}
+; CHECK-NEXT: .param i64{{$}}
+; CHECK-NEXT: .result i64{{$}}
+; CHECK-NEXT: argument 1{{$}}
+; CHECK-NEXT: setlocal @0{{$}}
+; CHECK-NEXT: argument 0{{$}}
+; CHECK-NEXT: setlocal @1{{$}}
+; CHECK-NEXT: mul @1, @0{{$}}
+; CHECK-NEXT: setlocal @2{{$}}
+; CHECK-NEXT: return @2{{$}}
 define i64 @mul64(i64 %x, i64 %y) {
   %a = mul i64 %x, %y
   ret i64 %a
 }
 
-; CHECK-LABEL: (func $sdiv64
-; CHECK-NEXT: (param i64) (param i64) (result i64)
-; CHECK-NEXT: (setlocal @0 (argument 1))
-; CHECK-NEXT: (setlocal @1 (argument 0))
-; CHECK-NEXT: (setlocal @2 (sdiv @1 @0))
-; CHECK-NEXT: (return @2)
+; CHECK-LABEL: sdiv64:
+; CHECK-NEXT: .param i64{{$}}
+; CHECK-NEXT: .param i64{{$}}
+; CHECK-NEXT: .result i64{{$}}
+; CHECK-NEXT: argument 1{{$}}
+; CHECK-NEXT: setlocal @0{{$}}
+; CHECK-NEXT: argument 0{{$}}
+; CHECK-NEXT: setlocal @1{{$}}
+; CHECK-NEXT: sdiv @1, @0{{$}}
+; CHECK-NEXT: setlocal @2{{$}}
+; CHECK-NEXT: return @2{{$}}
 define i64 @sdiv64(i64 %x, i64 %y) {
   %a = sdiv i64 %x, %y
   ret i64 %a
 }
 
-; CHECK-LABEL: (func $udiv64
-; CHECK-NEXT: (param i64) (param i64) (result i64)
-; CHECK-NEXT: (setlocal @0 (argument 1))
-; CHECK-NEXT: (setlocal @1 (argument 0))
-; CHECK-NEXT: (setlocal @2 (udiv @1 @0))
-; CHECK-NEXT: (return @2)
+; CHECK-LABEL: udiv64:
+; CHECK-NEXT: .param i64{{$}}
+; CHECK-NEXT: .param i64{{$}}
+; CHECK-NEXT: .result i64{{$}}
+; CHECK-NEXT: argument 1{{$}}
+; CHECK-NEXT: setlocal @0{{$}}
+; CHECK-NEXT: argument 0{{$}}
+; CHECK-NEXT: setlocal @1{{$}}
+; CHECK-NEXT: udiv @1, @0{{$}}
+; CHECK-NEXT: setlocal @2{{$}}
+; CHECK-NEXT: return @2{{$}}
 define i64 @udiv64(i64 %x, i64 %y) {
   %a = udiv i64 %x, %y
   ret i64 %a
 }
 
-; CHECK-LABEL: (func $srem64
-; CHECK-NEXT: (param i64) (param i64) (result i64)
-; CHECK-NEXT: (setlocal @0 (argument 1))
-; CHECK-NEXT: (setlocal @1 (argument 0))
-; CHECK-NEXT: (setlocal @2 (srem @1 @0))
-; CHECK-NEXT: (return @2)
+; CHECK-LABEL: srem64:
+; CHECK-NEXT: .param i64{{$}}
+; CHECK-NEXT: .param i64{{$}}
+; CHECK-NEXT: .result i64{{$}}
+; CHECK-NEXT: argument 1{{$}}
+; CHECK-NEXT: setlocal @0{{$}}
+; CHECK-NEXT: argument 0{{$}}
+; CHECK-NEXT: setlocal @1{{$}}
+; CHECK-NEXT: srem @1, @0{{$}}
+; CHECK-NEXT: setlocal @2{{$}}
+; CHECK-NEXT: return @2{{$}}
 define i64 @srem64(i64 %x, i64 %y) {
   %a = srem i64 %x, %y
   ret i64 %a
 }
 
-; CHECK-LABEL: (func $urem64
-; CHECK-NEXT: (param i64) (param i64) (result i64)
-; CHECK-NEXT: (setlocal @0 (argument 1))
-; CHECK-NEXT: (setlocal @1 (argument 0))
-; CHECK-NEXT: (setlocal @2 (urem @1 @0))
-; CHECK-NEXT: (return @2)
+; CHECK-LABEL: urem64:
+; CHECK-NEXT: .param i64{{$}}
+; CHECK-NEXT: .param i64{{$}}
+; CHECK-NEXT: .result i64{{$}}
+; CHECK-NEXT: argument 1{{$}}
+; CHECK-NEXT: setlocal @0{{$}}
+; CHECK-NEXT: argument 0{{$}}
+; CHECK-NEXT: setlocal @1{{$}}
+; CHECK-NEXT: urem @1, @0{{$}}
+; CHECK-NEXT: setlocal @2{{$}}
+; CHECK-NEXT: return @2{{$}}
 define i64 @urem64(i64 %x, i64 %y) {
   %a = urem i64 %x, %y
   ret i64 %a
 }
 
-; CHECK-LABEL: (func $and64
-; CHECK-NEXT: (param i64) (param i64) (result i64)
-; CHECK-NEXT: (setlocal @0 (argument 1))
-; CHECK-NEXT: (setlocal @1 (argument 0))
-; CHECK-NEXT: (setlocal @2 (and @1 @0))
-; CHECK-NEXT: (return @2)
+; CHECK-LABEL: and64:
+; CHECK-NEXT: .param i64{{$}}
+; CHECK-NEXT: .param i64{{$}}
+; CHECK-NEXT: .result i64{{$}}
+; CHECK-NEXT: argument 1{{$}}
+; CHECK-NEXT: setlocal @0{{$}}
+; CHECK-NEXT: argument 0{{$}}
+; CHECK-NEXT: setlocal @1{{$}}
+; CHECK-NEXT: and @1, @0{{$}}
+; CHECK-NEXT: setlocal @2{{$}}
+; CHECK-NEXT: return @2{{$}}
 define i64 @and64(i64 %x, i64 %y) {
   %a = and i64 %x, %y
   ret i64 %a
 }
 
-; CHECK-LABEL: (func $ior64
-; CHECK-NEXT: (param i64) (param i64) (result i64)
-; CHECK-NEXT: (setlocal @0 (argument 1))
-; CHECK-NEXT: (setlocal @1 (argument 0))
-; CHECK-NEXT: (setlocal @2 (ior @1 @0))
-; CHECK-NEXT: (return @2)
+; CHECK-LABEL: ior64:
+; CHECK-NEXT: .param i64{{$}}
+; CHECK-NEXT: .param i64{{$}}
+; CHECK-NEXT: .result i64{{$}}
+; CHECK-NEXT: argument 1{{$}}
+; CHECK-NEXT: setlocal @0{{$}}
+; CHECK-NEXT: argument 0{{$}}
+; CHECK-NEXT: setlocal @1{{$}}
+; CHECK-NEXT: ior @1, @0{{$}}
+; CHECK-NEXT: setlocal @2{{$}}
+; CHECK-NEXT: return @2{{$}}
 define i64 @ior64(i64 %x, i64 %y) {
   %a = or i64 %x, %y
   ret i64 %a
 }
 
-; CHECK-LABEL: (func $xor64
-; CHECK-NEXT: (param i64) (param i64) (result i64)
-; CHECK-NEXT: (setlocal @0 (argument 1))
-; CHECK-NEXT: (setlocal @1 (argument 0))
-; CHECK-NEXT: (setlocal @2 (xor @1 @0))
-; CHECK-NEXT: (return @2)
+; CHECK-LABEL: xor64:
+; CHECK-NEXT: .param i64{{$}}
+; CHECK-NEXT: .param i64{{$}}
+; CHECK-NEXT: .result i64{{$}}
+; CHECK-NEXT: argument 1{{$}}
+; CHECK-NEXT: setlocal @0{{$}}
+; CHECK-NEXT: argument 0{{$}}
+; CHECK-NEXT: setlocal @1{{$}}
+; CHECK-NEXT: xor @1, @0{{$}}
+; CHECK-NEXT: setlocal @2{{$}}
+; CHECK-NEXT: return @2{{$}}
 define i64 @xor64(i64 %x, i64 %y) {
   %a = xor i64 %x, %y
   ret i64 %a
 }
 
-; CHECK-LABEL: (func $shl64
-; CHECK-NEXT: (param i64) (param i64) (result i64)
-; CHECK-NEXT: (setlocal @0 (argument 1))
-; CHECK-NEXT: (setlocal @1 (argument 0))
-; CHECK-NEXT: (setlocal @2 (shl @1 @0))
-; CHECK-NEXT: (return @2)
+; CHECK-LABEL: shl64:
+; CHECK-NEXT: .param i64{{$}}
+; CHECK-NEXT: .param i64{{$}}
+; CHECK-NEXT: .result i64{{$}}
+; CHECK-NEXT: argument 1{{$}}
+; CHECK-NEXT: setlocal @0{{$}}
+; CHECK-NEXT: argument 0{{$}}
+; CHECK-NEXT: setlocal @1{{$}}
+; CHECK-NEXT: shl @1, @0{{$}}
+; CHECK-NEXT: setlocal @2{{$}}
+; CHECK-NEXT: return @2{{$}}
 define i64 @shl64(i64 %x, i64 %y) {
   %a = shl i64 %x, %y
   ret i64 %a
 }
 
-; CHECK-LABEL: (func $shr64
-; CHECK-NEXT: (param i64) (param i64) (result i64)
-; CHECK-NEXT: (setlocal @0 (argument 1))
-; CHECK-NEXT: (setlocal @1 (argument 0))
-; CHECK-NEXT: (setlocal @2 (shr_u @1 @0))
-; CHECK-NEXT: (return @2)
+; CHECK-LABEL: shr64:
+; CHECK-NEXT: .param i64{{$}}
+; CHECK-NEXT: .param i64{{$}}
+; CHECK-NEXT: .result i64{{$}}
+; CHECK-NEXT: argument 1{{$}}
+; CHECK-NEXT: setlocal @0{{$}}
+; CHECK-NEXT: argument 0{{$}}
+; CHECK-NEXT: setlocal @1{{$}}
+; CHECK-NEXT: shr_u @1, @0{{$}}
+; CHECK-NEXT: setlocal @2{{$}}
+; CHECK-NEXT: return @2{{$}}
 define i64 @shr64(i64 %x, i64 %y) {
   %a = lshr i64 %x, %y
   ret i64 %a
 }
 
-; CHECK-LABEL: (func $sar64
-; CHECK-NEXT: (param i64) (param i64) (result i64)
-; CHECK-NEXT: (setlocal @0 (argument 1))
-; CHECK-NEXT: (setlocal @1 (argument 0))
-; CHECK-NEXT: (setlocal @2 (shr_s @1 @0))
-; CHECK-NEXT: (return @2)
+; CHECK-LABEL: sar64:
+; CHECK-NEXT: .param i64{{$}}
+; CHECK-NEXT: .param i64{{$}}
+; CHECK-NEXT: .result i64{{$}}
+; CHECK-NEXT: argument 1{{$}}
+; CHECK-NEXT: setlocal @0{{$}}
+; CHECK-NEXT: argument 0{{$}}
+; CHECK-NEXT: setlocal @1{{$}}
+; CHECK-NEXT: shr_s @1, @0{{$}}
+; CHECK-NEXT: setlocal @2{{$}}
+; CHECK-NEXT: return @2{{$}}
 define i64 @sar64(i64 %x, i64 %y) {
   %a = ashr i64 %x, %y
   ret i64 %a
 }
 
-; CHECK-LABEL: (func $clz64
-; CHECK-NEXT: (param i64) (result i64)
-; CHECK-NEXT: (setlocal @0 (argument 0))
-; CHECK-NEXT: (setlocal @1 (clz @0))
-; CHECK-NEXT: (return @1)
+; CHECK-LABEL: clz64:
+; CHECK-NEXT: .param i64{{$}}
+; CHECK-NEXT: .result i64{{$}}
+; CHECK-NEXT: argument 0{{$}}
+; CHECK-NEXT: setlocal @0{{$}}
+; CHECK-NEXT: clz @0{{$}}
+; CHECK-NEXT: setlocal @1{{$}}
+; CHECK-NEXT: return @1{{$}}
 define i64 @clz64(i64 %x) {
   %a = call i64 @llvm.ctlz.i64(i64 %x, i1 false)
   ret i64 %a
 }
 
-; CHECK-LABEL: (func $clz64_zero_undef
-; CHECK-NEXT: (param i64) (result i64)
-; CHECK-NEXT: (setlocal @0 (argument 0))
-; CHECK-NEXT: (setlocal @1 (clz @0))
-; CHECK-NEXT: (return @1)
+; CHECK-LABEL: clz64_zero_undef:
+; CHECK-NEXT: .param i64{{$}}
+; CHECK-NEXT: .result i64{{$}}
+; CHECK-NEXT: argument 0{{$}}
+; CHECK-NEXT: setlocal @0{{$}}
+; CHECK-NEXT: clz @0{{$}}
+; CHECK-NEXT: setlocal @1{{$}}
+; CHECK-NEXT: return @1{{$}}
 define i64 @clz64_zero_undef(i64 %x) {
   %a = call i64 @llvm.ctlz.i64(i64 %x, i1 true)
   ret i64 %a
 }
 
-; CHECK-LABEL: (func $ctz64
-; CHECK-NEXT: (param i64) (result i64)
-; CHECK-NEXT: (setlocal @0 (argument 0))
-; CHECK-NEXT: (setlocal @1 (ctz @0))
-; CHECK-NEXT: (return @1)
+; CHECK-LABEL: ctz64:
+; CHECK-NEXT: .param i64{{$}}
+; CHECK-NEXT: .result i64{{$}}
+; CHECK-NEXT: argument 0{{$}}
+; CHECK-NEXT: setlocal @0{{$}}
+; CHECK-NEXT: ctz @0{{$}}
+; CHECK-NEXT: setlocal @1{{$}}
+; CHECK-NEXT: return @1{{$}}
 define i64 @ctz64(i64 %x) {
   %a = call i64 @llvm.cttz.i64(i64 %x, i1 false)
   ret i64 %a
 }
 
-; CHECK-LABEL: (func $ctz64_zero_undef
-; CHECK-NEXT: (param i64) (result i64)
-; CHECK-NEXT: (setlocal @0 (argument 0))
-; CHECK-NEXT: (setlocal @1 (ctz @0))
-; CHECK-NEXT: (return @1)
+; CHECK-LABEL: ctz64_zero_undef:
+; CHECK-NEXT: .param i64{{$}}
+; CHECK-NEXT: .result i64{{$}}
+; CHECK-NEXT: argument 0{{$}}
+; CHECK-NEXT: setlocal @0{{$}}
+; CHECK-NEXT: ctz @0{{$}}
+; CHECK-NEXT: setlocal @1{{$}}
+; CHECK-NEXT: return @1{{$}}
 define i64 @ctz64_zero_undef(i64 %x) {
   %a = call i64 @llvm.cttz.i64(i64 %x, i1 true)
   ret i64 %a
 }
 
-; CHECK-LABEL: (func $popcnt64
-; CHECK-NEXT: (param i64) (result i64)
-; CHECK-NEXT: (setlocal @0 (argument 0))
-; CHECK-NEXT: (setlocal @1 (popcnt @0))
-; CHECK-NEXT: (return @1)
+; CHECK-LABEL: popcnt64:
+; CHECK-NEXT: .param i64{{$}}
+; CHECK-NEXT: .result i64{{$}}
+; CHECK-NEXT: argument 0{{$}}
+; CHECK-NEXT: setlocal @0{{$}}
+; CHECK-NEXT: popcnt @0{{$}}
+; CHECK-NEXT: setlocal @1{{$}}
+; CHECK-NEXT: return @1{{$}}
 define i64 @popcnt64(i64 %x) {
   %a = call i64 @llvm.ctpop.i64(i64 %x)
   ret i64 %a
 }

test/CodeGen/WebAssembly/load-ext.ll

 ; RUN: llc < %s -asm-verbose=false | FileCheck %s
 
 ; Test that extending loads are assembled properly.
 
 target datalayout = "e-p:32:32-i64:64-n32:64-S128"
 target triple = "wasm32-unknown-unknown"
 
-; CHECK-LABEL: (func $sext_i8_i32
-; CHECK: (setlocal @1 (load_sx_i8_i32 @0))
+; CHECK-LABEL: sext_i8_i32:
+; CHECK: load_sx_i8_i32 @0{{$}}
+; CHECK-NEXT: setlocal @1{{$}}
 define i32 @sext_i8_i32(i8 *%p) {
   %v = load i8, i8* %p
   %e = sext i8 %v to i32
   ret i32 %e
 }
 
-; CHECK-LABEL: (func $zext_i8_i32
-; CHECK: (setlocal @1 (load_zx_i8_i32 @0))
+; CHECK-LABEL: zext_i8_i32:
+; CHECK: load_zx_i8_i32 @0{{$}}
+; CHECK-NEXT: setlocal @1{{$}}
 define i32 @zext_i8_i32(i8 *%p) {
   %v = load i8, i8* %p
   %e = zext i8 %v to i32
   ret i32 %e
 }
 
-; CHECK-LABEL: (func $sext_i16_i32
-; CHECK: (setlocal @1 (load_sx_i16_i32 @0))
+; CHECK-LABEL: sext_i16_i32:
+; CHECK: load_sx_i16_i32 @0{{$}}
+; CHECK-NEXT: setlocal @1{{$}}
 define i32 @sext_i16_i32(i16 *%p) {
   %v = load i16, i16* %p
   %e = sext i16 %v to i32
   ret i32 %e
 }
 
-; CHECK-LABEL: (func $zext_i16_i32
-; CHECK: (setlocal @1 (load_zx_i16_i32 @0))
+; CHECK-LABEL: zext_i16_i32:
+; CHECK: load_zx_i16_i32 @0{{$}}
+; CHECK-NEXT: setlocal @1{{$}}
 define i32 @zext_i16_i32(i16 *%p) {
   %v = load i16, i16* %p
   %e = zext i16 %v to i32
   ret i32 %e
 }
 
-; CHECK-LABEL: (func $sext_i8_i64
-; CHECK: (setlocal @1 (load_sx_i8_i64 @0))
+; CHECK-LABEL: sext_i8_i64:
+; CHECK: load_sx_i8_i64 @0{{$}}
+; CHECK-NEXT: setlocal @1{{$}}
 define i64 @sext_i8_i64(i8 *%p) {
   %v = load i8, i8* %p
   %e = sext i8 %v to i64
   ret i64 %e
 }
 
-; CHECK-LABEL: (func $zext_i8_i64
-; CHECK: (setlocal @1 (load_zx_i8_i64 @0))
+; CHECK-LABEL: zext_i8_i64:
+; CHECK: load_zx_i8_i64 @0{{$}}
+; CHECK-NEXT: setlocal @1{{$}}
 define i64 @zext_i8_i64(i8 *%p) {
   %v = load i8, i8* %p
   %e = zext i8 %v to i64
   ret i64 %e
 }
 
-; CHECK-LABEL: (func $sext_i16_i64
-; CHECK: (setlocal @1 (load_sx_i16_i64 @0))
+; CHECK-LABEL: sext_i16_i64:
+; CHECK: load_sx_i16_i64 @0{{$}}
+; CHECK-NEXT: setlocal @1{{$}}
 define i64 @sext_i16_i64(i16 *%p) {
   %v = load i16, i16* %p
   %e = sext i16 %v to i64
   ret i64 %e
 }
 
-; CHECK-LABEL: (func $zext_i16_i64
-; CHECK: (setlocal @1 (load_zx_i16_i64 @0))
+; CHECK-LABEL: zext_i16_i64:
+; CHECK: load_zx_i16_i64 @0{{$}}
+; CHECK-NEXT: setlocal @1{{$}}
 define i64 @zext_i16_i64(i16 *%p) {
   %v = load i16, i16* %p
   %e = zext i16 %v to i64
   ret i64 %e
 }
 
-; CHECK-LABEL: (func $sext_i32_i64
-; CHECK: (setlocal @1 (load_sx_i32_i64 @0))
+; CHECK-LABEL: sext_i32_i64:
+; CHECK: load_sx_i32_i64 @0{{$}}
+; CHECK-NEXT: setlocal @1{{$}}
 define i64 @sext_i32_i64(i32 *%p) {
   %v = load i32, i32* %p
   %e = sext i32 %v to i64
   ret i64 %e
 }
 
-; CHECK-LABEL: (func $zext_i32_i64
-; CHECK: (setlocal @1 (load_zx_i32_i64 @0))
+; CHECK-LABEL: zext_i32_i64:
+; CHECK: load_zx_i32_i64 @0{{$}}
+; CHECK: setlocal @1{{$}}
 define i64 @zext_i32_i64(i32 *%p) {
   %v = load i32, i32* %p
   %e = zext i32 %v to i64
   ret i64 %e
 }

test/CodeGen/WebAssembly/load-store-i1.ll

 ; RUN: llc < %s -asm-verbose=false | FileCheck %s
 
 ; Test that i1 extending loads and truncating stores are assembled properly.
 
 target datalayout = "e-p:32:32-i64:64-n32:64-S128"
 target triple = "wasm32-unknown-unknown"
 
-; CHECK-LABEL: (func $load_unsigned_i1_i32
-; CHECK:      (setlocal @1 (load_zx_i8_i32 @0))
-; CHECK-NEXT: (return @1)
+; CHECK-LABEL: load_unsigned_i1_i32:
+; CHECK:      load_zx_i8_i32 @0{{$}}
+; CHECK-NEXT: setlocal @1{{$}}
+; CHECK-NEXT: return @1{{$}}
 define i32 @load_unsigned_i1_i32(i1* %p) {
   %v = load i1, i1* %p
   %e = zext i1 %v to i32
   ret i32 %e
 }
 
-; CHECK-LABEL: (func $load_signed_i1_i32
-; CHECK:      (setlocal @1 (load_zx_i8_i32 @0))
-; CHECK-NEXT: (setlocal @2 (immediate 31))
-; CHECK-NEXT: (setlocal @3 (shl @1 @2))
-; CHECK-NEXT: (setlocal @4 (shr_s @3 @2))
-; CHECK-NEXT: (return @4)
+; CHECK-LABEL: load_signed_i1_i32:
+; CHECK:      load_zx_i8_i32 @0{{$}}
+; CHECK-NEXT: setlocal @1{{$}}
+; CHECK-NEXT: immediate 31{{$}}
+; CHECK-NEXT: setlocal @2{{$}}
+; CHECK-NEXT: shl @1, @2{{$}}
+; CHECK-NEXT: setlocal @3{{$}}
+; CHECK-NEXT: shr_s @3, @2{{$}}
+; CHECK-NEXT: setlocal @4{{$}}
+; CHECK-NEXT: return @4{{$}}
 define i32 @load_signed_i1_i32(i1* %p) {
   %v = load i1, i1* %p
   %e = sext i1 %v to i32
   ret i32 %e
 }
 
-; CHECK-LABEL: (func $load_unsigned_i1_i64
-; CHECK:      (setlocal @1 (load_zx_i8_i64 @0))
-; CHECK-NEXT: (return @1)
+; CHECK-LABEL: load_unsigned_i1_i64:
+; CHECK:      load_zx_i8_i64 @0{{$}}
+; CHECK-NEXT: setlocal @1{{$}}
+; CHECK-NEXT: return @1{{$}}
 define i64 @load_unsigned_i1_i64(i1* %p) {
   %v = load i1, i1* %p
   %e = zext i1 %v to i64
   ret i64 %e
 }
 
-; CHECK-LABEL: (func $load_signed_i1_i64
-; CHECK:      (setlocal @1 (load_zx_i8_i64 @0))
-; CHECK-NEXT: (setlocal @2 (immediate 63))
-; CHECK-NEXT: (setlocal @3 (shl @1 @2))
-; CHECK-NEXT: (setlocal @4 (shr_s @3 @2))
-; CHECK-NEXT: (return @4)
+; CHECK-LABEL: load_signed_i1_i64:
+; CHECK:      load_zx_i8_i64 @0{{$}}
+; CHECK-NEXT: setlocal @1{{$}}
+; CHECK-NEXT: immediate 63{{$}}
+; CHECK-NEXT: setlocal @2{{$}}
+; CHECK-NEXT: shl @1, @2{{$}}
+; CHECK-NEXT: setlocal @3{{$}}
+; CHECK-NEXT: shr_s @3, @2{{$}}
+; CHECK-NEXT: setlocal @4{{$}}
+; CHECK-NEXT: return @4{{$}}
 define i64 @load_signed_i1_i64(i1* %p) {
   %v = load i1, i1* %p
   %e = sext i1 %v to i64
   ret i64 %e
 }
 
-; CHECK-LABEL: (func $store_i32_i1
-; CHECK:      (setlocal @2 (immediate 1))
-; CHECK-NEXT: (setlocal @3 (and @1 @2))
-; CHECK-NEXT: (store_i8 @0 @3)
+; CHECK-LABEL: store_i32_i1:
+; CHECK:      immediate 1{{$}}
+; CHECK-NEXT: setlocal @2{{$}}
+; CHECK-NEXT: and @1, @2{{$}}
+; CHECK-NEXT: setlocal @3{{$}}
+; CHECK-NEXT: store_i8 @0, @3{{$}}
 define void @store_i32_i1(i1* %p, i32 %v) {
   %t = trunc i32 %v to i1
   store i1 %t, i1* %p
   ret void
 }
 
-; CHECK-LABEL: (func $store_i64_i1
-; CHECK:      (setlocal @2 (immediate 1))
-; CHECK-NEXT: (setlocal @3 (and @1 @2))
-; CHECK-NEXT: (store_i8 @0 @3)
+; CHECK-LABEL: store_i64_i1:
+; CHECK:      immediate 1{{$}}
+; CHECK-NEXT: setlocal @2{{$}}
+; CHECK-NEXT: and @1, @2{{$}}
+; CHECK-NEXT: setlocal @3{{$}}
+; CHECK-NEXT: store_i8 @0, @3{{$}}
 define void @store_i64_i1(i1* %p, i64 %v) {
   %t = trunc i64 %v to i1
   store i1 %t, i1* %p
   ret void
 }

test/CodeGen/WebAssembly/load.ll

 ; RUN: llc < %s -asm-verbose=false | FileCheck %s
 
 ; Test that basic loads are assembled properly.
 
 target datalayout = "e-p:32:32-i64:64-n32:64-S128"
 target triple = "wasm32-unknown-unknown"
 
-; CHECK-LABEL: (func $ldi32
-; CHECK-NEXT: (param i32) (result i32)
-; CHECK-NEXT: (setlocal @0 (argument 0))
-; CHECK-NEXT: (setlocal @1 (load_i32 @0))
-; CHECK-NEXT: (return @1)
+; CHECK-LABEL: ldi32:
+; CHECK-NEXT: .param i32{{$}}
+; CHECK-NEXT: .result i32{{$}}
+; CHECK-NEXT: argument 0{{$}}
+; CHECK-NEXT: setlocal @0{{$}}
+; CHECK-NEXT: load_i32 @0{{$}}
+; CHECK-NEXT: setlocal @1{{$}}
+; CHECK-NEXT: return @1{{$}}
 define i32 @ldi32(i32 *%p) {
   %v = load i32, i32* %p
   ret i32 %v
 }
 
-; CHECK-LABEL: (func $ldi64
-; CHECK-NEXT: (param i32) (result i64)
-; CHECK-NEXT: (setlocal @0 (argument 0))
-; CHECK-NEXT: (setlocal @1 (load_i64 @0))
-; CHECK-NEXT: (return @1)
+; CHECK-LABEL: ldi64:
+; CHECK-NEXT: .param i32{{$}}
+; CHECK-NEXT: .result i64{{$}}
+; CHECK-NEXT: argument 0{{$}}
+; CHECK-NEXT: setlocal @0{{$}}
+; CHECK-NEXT: load_i64 @0{{$}}
+; CHECK-NEXT: setlocal @1{{$}}
+; CHECK-NEXT: return @1{{$}}
 define i64 @ldi64(i64 *%p) {
   %v = load i64, i64* %p
   ret i64 %v
 }
 
-; CHECK-LABEL: (func $ldf32
-; CHECK-NEXT: (param i32) (result f32)
-; CHECK-NEXT: (setlocal @0 (argument 0))
-; CHECK-NEXT: (setlocal @1 (load_f32 @0))
-; CHECK-NEXT: (return @1)
+; CHECK-LABEL: ldf32:
+; CHECK-NEXT: .param i32{{$}}
+; CHECK-NEXT: .result f32{{$}}
+; CHECK-NEXT: argument 0{{$}}
+; CHECK-NEXT: setlocal @0{{$}}
+; CHECK-NEXT: load_f32 @0{{$}}
+; CHECK-NEXT: setlocal @1{{$}}
+; CHECK-NEXT: return @1{{$}}
 define float @ldf32(float *%p) {
   %v = load float, float* %p
   ret float %v
 }
 
-; CHECK-LABEL: (func $ldf64
-; CHECK-NEXT: (param i32) (result f64)
-; CHECK-NEXT: (setlocal @0 (argument 0))
-; CHECK-NEXT: (setlocal @1 (load_f64 @0))
-; CHECK-NEXT: (return @1)
+; CHECK-LABEL: ldf64:
+; CHECK-NEXT: .param i32{{$}}
+; CHECK-NEXT: .result f64{{$}}
+; CHECK-NEXT: argument 0{{$}}
+; CHECK-NEXT: setlocal @0{{$}}
+; CHECK-NEXT: load_f64 @0{{$}}
+; CHECK-NEXT: setlocal @1{{$}}
+; CHECK-NEXT: return @1{{$}}
 define double @ldf64(double *%p) {
   %v = load double, double* %p
   ret double %v
 }

test/CodeGen/WebAssembly/memory-addr32.ll

 ; RUN: llc < %s -asm-verbose=false | FileCheck %s
 
 ; Test that basic memory operations assemble as expected with 32-bit addresses.
 
 target datalayout = "e-p:32:32-i64:64-n32:64-S128"
 target triple = "wasm32-unknown-unknown"
 
 declare i32 @llvm.wasm.page.size.i32() nounwind readnone
 
-; CHECK-LABEL: (func $page_size
-; CHECK-NEXT: (result i32)
-; CHECK-NEXT: (setlocal @0 (page_size))
-; CHECK-NEXT: (return @0)
+; CHECK-LABEL: page_size:
+; CHECK-NEXT: .result i32{{$}}
+; CHECK-NEXT: page_size
+; CHECK-NEXT: setlocal @0{{$}}
+; CHECK-NEXT: return @0{{$}}
 define i32 @page_size() {
   %a = call i32 @llvm.wasm.page.size.i32()
   ret i32 %a
 }

test/CodeGen/WebAssembly/memory-addr64.ll

 ; RUN: llc < %s -asm-verbose=false | FileCheck %s
 
 ; Test that basic memory operations assemble as expected with 64-bit addresses.
 
 target datalayout = "e-p:64:64-i64:64-n32:64-S128"
 target triple = "wasm64-unknown-unknown"
 
 declare i64 @llvm.wasm.page.size.i64() nounwind readnone
 
-; CHECK-LABEL: (func $page_size
-; CHECK-NEXT: (result i64)
-; CHECK-NEXT: (setlocal @0 (page_size))
-; CHECK-NEXT: (return @0)
+; CHECK-LABEL: page_size:
+; CHECK-NEXT: .result i64{{$}}
+; CHECK-NEXT: page_size
+; CHECK-NEXT: setlocal @0{{$}}
+; CHECK-NEXT: return @0{{$}}
 define i64 @page_size() {
   %a = call i64 @llvm.wasm.page.size.i64()
   ret i64 %a
 }

test/CodeGen/WebAssembly/phi.ll

 ; RUN: llc < %s -asm-verbose=false | FileCheck %s
 
 ; Test that phis are lowered.
 
 target datalayout = "e-p:32:32-i64:64-n32:64-S128"
 target triple = "wasm32-unknown-unknown"
 
 ; Basic phi triangle.
 
-; CHECK-LABEL: test0
-; CHECK: (setlocal [[REG:@.*]] (argument 0))
-; CHECK: (setlocal [[REG]] (sdiv [[REG]] {{.*}}))
-; CHECK: (return [[REG]])
+; CHECK-LABEL: test0:
+; CHECK: argument 0{{$}}
+; CHECK: setlocal [[REG:@.*]]
+; CHECK: sdiv [[REG]], {{.*}}
+; CHECK: setlocal [[REG]]
+; CHECK: return [[REG]]
 define i32 @test0(i32 %p) {
 entry:
   %t = icmp slt i32 %p, 0
   br i1 %t, label %true, label %done
 true:
   %a = sdiv i32 %p, 3
   br label %done
 done:
   %s = phi i32 [ %a, %true ], [ %p, %entry ]
   ret i32 %s
 }
 
 ; Swap phis.
 
-; CHECK-LABEL: test1
+; CHECK-LABEL: test1:
 ; CHECK: BB1_1:
-; CHECK: (setlocal [[REG0:@.*]] [[REG1:@.*]])
-; CHECK: (setlocal [[REG1]] [[REG2:@.*]])
-; CHECK: (setlocal [[REG2]] [[REG0]])
+; CHECK: [[REG1:@.*]]
+; CHECK: setlocal [[REG0:@.*]]
+; CHECK: [[REG2:@.*]]
+; CHECK: setlocal [[REG1]]
+; CHECK: [[REG0]]
+; CHECK: setlocal [[REG2]]
 define i32 @test1(i32 %n) {
 entry:
   br label %loop
 
 loop:
   %a = phi i32 [ 0, %entry ], [ %b, %loop ]
   %b = phi i32 [ 1, %entry ], [ %a, %loop ]
   %i = phi i32 [ 0, %entry ], [ %i.next, %loop ]
 
   %i.next = add i32 %i, 1
   %t = icmp slt i32 %i.next, %n
   br i1 %t, label %loop, label %exit
 
 exit:
   ret i32 %a
 }

test/CodeGen/WebAssembly/return-void.ll

 ; RUN: llc < %s -asm-verbose=false | FileCheck %s
 
 target datalayout = "e-p:32:32-i64:64-n32:64-S128"
 target triple = "wasm32-unknown-unknown"
 
-; CHECK-LABEL: (func $return_void
-; CHECK: (return)
+; CHECK-LABEL: return_void:
+; CHECK: return{{$}}
 define void @return_void() {
   ret void
 }

test/CodeGen/WebAssembly/store-trunc.ll

 ; RUN: llc < %s -asm-verbose=false | FileCheck %s
 
 ; Test that truncating stores are assembled properly.
 
 target datalayout = "e-p:32:32-i64:64-n32:64-S128"
 target triple = "wasm32-unknown-unknown"
 
-; CHECK-LABEL: (func $trunc_i8_i32
-; CHECK: (store_i8 @1 @0)
+; CHECK-LABEL: trunc_i8_i32:
+; CHECK: store_i8 @1, @0{{$}}
 define void @trunc_i8_i32(i8 *%p, i32 %v) {
   %t = trunc i32 %v to i8
   store i8 %t, i8* %p
   ret void
 }
 
-; CHECK-LABEL: (func $trunc_i16_i32
-; CHECK: (store_i16 @1 @0)
+; CHECK-LABEL: trunc_i16_i32:
+; CHECK: store_i16 @1, @0{{$}}
 define void @trunc_i16_i32(i16 *%p, i32 %v) {
   %t = trunc i32 %v to i16
   store i16 %t, i16* %p
   ret void
 }
 
-; CHECK-LABEL: (func $trunc_i8_i64
-; CHECK: (store_i8 @1 @0)
+; CHECK-LABEL: trunc_i8_i64:
+; CHECK: store_i8 @1, @0{{$}}
 define void @trunc_i8_i64(i8 *%p, i64 %v) {
   %t = trunc i64 %v to i8
   store i8 %t, i8* %p
   ret void
 }
 
-; CHECK-LABEL: (func $trunc_i16_i64
-; CHECK: (store_i16 @1 @0)
+; CHECK-LABEL: trunc_i16_i64:
+; CHECK: store_i16 @1, @0{{$}}
 define void @trunc_i16_i64(i16 *%p, i64 %v) {
   %t = trunc i64 %v to i16
   store i16 %t, i16* %p
   ret void
 }
 
-; CHECK-LABEL: (func $trunc_i32_i64
-; CHECK: (store_i32 @1 @0)
+; CHECK-LABEL: trunc_i32_i64:
+; CHECK: store_i32 @1, @0{{$}}
 define void @trunc_i32_i64(i32 *%p, i64 %v) {
   %t = trunc i64 %v to i32
   store i32 %t, i32* %p
   ret void
 }

test/CodeGen/WebAssembly/store.ll

 ; RUN: llc < %s -asm-verbose=false | FileCheck %s
 
 ; Test that basic stores are assembled properly.
 
 target datalayout = "e-p:32:32-i64:64-n32:64-S128"
 target triple = "wasm32-unknown-unknown"
 
-; CHECK-LABEL: (func $sti32
-; CHECK-NEXT: (param i32) (param i32)
-; CHECK-NEXT: (setlocal @0 (argument 1))
-; CHECK-NEXT: (setlocal @1 (argument 0))
-; CHECK-NEXT: (store_i32 @1 @0)
-; CHECK-NEXT: (return)
+; CHECK-LABEL: sti32:
+; CHECK-NEXT: .param i32{{$}}
+; CHECK-NEXT: .param i32{{$}}
+; CHECK-NEXT: argument 1{{$}}
+; CHECK-NEXT: setlocal @0{{$}}
+; CHECK-NEXT: argument 0{{$}}
+; CHECK-NEXT: setlocal @1{{$}}
+; CHECK-NEXT: store_i32 @1, @0{{$}}
+; CHECK-NEXT: return{{$}}
 define void @sti32(i32 *%p, i32 %v) {
   store i32 %v, i32* %p
   ret void
 }
 
-; CHECK-LABEL: (func $sti64
-; CHECK-NEXT: (param i32) (param i64)
-; CHECK-NEXT: (setlocal @0 (argument 1))
-; CHECK-NEXT: (setlocal @1 (argument 0))
-; CHECK-NEXT: (store_i64 @1 @0)
-; CHECK-NEXT: (return)
+; CHECK-LABEL: sti64:
+; CHECK-NEXT: .param i32{{$}}
+; CHECK-NEXT: .param i64{{$}}
+; CHECK-NEXT: argument 1{{$}}
+; CHECK-NEXT: setlocal @0{{$}}
+; CHECK-NEXT: argument 0{{$}}
+; CHECK-NEXT: setlocal @1{{$}}
+; CHECK-NEXT: store_i64 @1, @0{{$}}
+; CHECK-NEXT: return{{$}}
 define void @sti64(i64 *%p, i64 %v) {
   store i64 %v, i64* %p
   ret void
 }
 
-; CHECK-LABEL: (func $stf32
-; CHECK-NEXT: (param i32) (param f32)
-; CHECK-NEXT: (setlocal @0 (argument 1))
-; CHECK-NEXT: (setlocal @1 (argument 0))
-; CHECK-NEXT: (store_f32 @1 @0)
-; CHECK-NEXT: (return)
+; CHECK-LABEL: stf32:
+; CHECK-NEXT: .param i32{{$}}
+; CHECK-NEXT: .param f32{{$}}
+; CHECK-NEXT: argument 1{{$}}
+; CHECK-NEXT: setlocal @0{{$}}
+; CHECK-NEXT: argument 0{{$}}
+; CHECK-NEXT: setlocal @1{{$}}
+; CHECK-NEXT: store_f32 @1, @0{{$}}
+; CHECK-NEXT: return{{$}}
 define void @stf32(float *%p, float %v) {
   store float %v, float* %p
   ret void
 }
 
-; CHECK-LABEL: (func $stf64
-; CHECK-NEXT: (param i32) (param f64)
-; CHECK-NEXT: (setlocal @0 (argument 1))
-; CHECK-NEXT: (setlocal @1 (argument 0))
-; CHECK-NEXT: (store_f64 @1 @0)
-; CHECK-NEXT: (return)
+; CHECK-LABEL: stf64:
+; CHECK-NEXT: .param i32{{$}}
+; CHECK-NEXT: .param f64{{$}}
+; CHECK-NEXT: argument 1{{$}}
+; CHECK-NEXT: setlocal @0{{$}}
+; CHECK-NEXT: argument 0{{$}}
+; CHECK-NEXT: setlocal @1{{$}}
+; CHECK-NEXT: store_f64 @1, @0{{$}}
+; CHECK-NEXT: return{{$}}
 define void @stf64(double *%p, double %v) {
   store double %v, double* %p
   ret void
 }

test/CodeGen/WebAssembly/switch.ll

 ; RUN: llc < %s -asm-verbose=false | FileCheck %s
 
 ; Test switch instructions.
 
 target datalayout = "e-p:32:32-i64:64-n32:64-S128"
 target triple = "wasm32-unknown-unknown"
 
 declare void @foo0()
 declare void @foo1()
 declare void @foo2()
 declare void @foo3()
 declare void @foo4()
 declare void @foo5()
 
-; CHECK-LABEL: bar32
-; CHECK: (block $BB0_8)
-; CHECK: (block $BB0_7)
-; CHECK: (block $BB0_6)
-; CHECK: (block $BB0_5)
-; CHECK: (block $BB0_4)
-; CHECK: (block $BB0_3)
-; CHECK: (block $BB0_2)
-; CHECK: (switch {{.*}} $BB0_2 $BB0_2 $BB0_2 $BB0_2 $BB0_2 $BB0_2 $BB0_2 $BB0_2 $BB0_3 $BB0_3 $BB0_3 $BB0_3 $BB0_3 $BB0_3 $BB0_3 $BB0_3 $BB0_4 $BB0_4 $BB0_4 $BB0_4 $BB0_4 $BB0_4 $BB0_5 $BB0_6 $BB0_7)
-; CHECk: BB0_2:
-; CHECK:   (setlocal {{.*}} (global $foo0))
+; CHECK-LABEL: bar32:
+; CHECK: block $BB0_8{{$}}
+; CHECK: block $BB0_7{{$}}
+; CHECK: block $BB0_6{{$}}
+; CHECK: block $BB0_5{{$}}
+; CHECK: block $BB0_4{{$}}
+; CHECK: block $BB0_3{{$}}
+; CHECK: block $BB0_2{{$}}
+; CHECK: switch {{.*}}, $BB0_2, $BB0_2, $BB0_2, $BB0_2, $BB0_2, $BB0_2, $BB0_2, $BB0_2, $BB0_3, $BB0_3, $BB0_3, $BB0_3, $BB0_3, $BB0_3, $BB0_3, $BB0_3, $BB0_4, $BB0_4, $BB0_4, $BB0_4, $BB0_4, $BB0_4, $BB0_5, $BB0_6, $BB0_7{{$}}
+; CHECK: BB0_2:
+; CHECK:   global $foo0{{$}}
+; CHECK:   setlocal {{.*}}
 ; CHECK: BB0_3:
-; CHECK:   (setlocal {{.*}} (global $foo1))
+; CHECK:   global $foo1{{$}}
+; CHECK:   setlocal {{.*}}
 ; CHECK: BB0_4:
-; CHECK:   (setlocal {{.*}} (global $foo2))
+; CHECK:   global $foo2{{$}}
+; CHECK:   setlocal {{.*}}
 ; CHECK: BB0_5:
-; CHECK:   (setlocal {{.*}} (global $foo3))
+; CHECK:   global $foo3{{$}}
+; CHECK:   setlocal {{.*}}
 ; CHECK: BB0_6:
-; CHECK:   (setlocal {{.*}} (global $foo4))
+; CHECK:   global $foo4{{$}}
+; CHECK:   setlocal {{.*}}
 ; CHECK: BB0_7:
-; CHECK:   (setlocal {{.*}} (global $foo5))
+; CHECK:   global $foo5{{$}}
+; CHECK:   setlocal {{.*}}
 ; CHECK: BB0_8:
-; CHECK:   (return)
+; CHECK:   return{{$}}
 define void @bar32(i32 %n) {
 entry:
   switch i32 %n, label %sw.epilog [
     i32 0, label %sw.bb
     i32 1, label %sw.bb
     i32 2, label %sw.bb
     i32 3, label %sw.bb
     i32 4, label %sw.bb

 sw.bb.5:                                          ; preds = %entry
   tail call void @foo5()
   br label %sw.epilog
 
 sw.epilog:                                        ; preds = %entry, %sw.bb.5, %sw.bb.4, %sw.bb.3, %sw.bb.2, %sw.bb.1, %sw.bb
   ret void
 }
 
-; CHECK-LABEL: bar64
-; CHECK: (block $BB1_8)
-; CHECK: (block $BB1_7)
-; CHECK: (block $BB1_6)
-; CHECK: (block $BB1_5)
-; CHECK: (block $BB1_4)
-; CHECK: (block $BB1_3)
-; CHECK: (block $BB1_2)
-; CHECK: (switch {{.*}} $BB1_2 $BB1_2 $BB1_2 $BB1_2 $BB1_2 $BB1_2 $BB1_2 $BB1_2 $BB1_3 $BB1_3 $BB1_3 $BB1_3 $BB1_3 $BB1_3 $BB1_3 $BB1_3 $BB1_4 $BB1_4 $BB1_4 $BB1_4 $BB1_4 $BB1_4 $BB1_5 $BB1_6 $BB1_7)
-; CHECk: BB1_2:
-; CHECK:   (setlocal {{.*}} (global $foo0))
+; CHECK-LABEL: bar64:
+; CHECK: block $BB1_8{{$}}
+; CHECK: block $BB1_7{{$}}
+; CHECK: block $BB1_6{{$}}
+; CHECK: block $BB1_5{{$}}
+; CHECK: block $BB1_4{{$}}
+; CHECK: block $BB1_3{{$}}
+; CHECK: block $BB1_2{{$}}
+; CHECK: switch {{.*}}, $BB1_2, $BB1_2, $BB1_2, $BB1_2, $BB1_2, $BB1_2, $BB1_2, $BB1_2, $BB1_3, $BB1_3, $BB1_3, $BB1_3, $BB1_3, $BB1_3, $BB1_3, $BB1_3, $BB1_4, $BB1_4, $BB1_4, $BB1_4, $BB1_4, $BB1_4, $BB1_5, $BB1_6, $BB1_7{{$}}
+; CHECK: BB1_2:
+; CHECK:   global $foo0{{$}}
+; CHECK:   setlocal {{.*}}
 ; CHECK: BB1_3:
-; CHECK:   (setlocal {{.*}} (global $foo1))
+; CHECK:   global $foo1{{$}}
+; CHECK:   setlocal {{.*}}
 ; CHECK: BB1_4:
-; CHECK:   (setlocal {{.*}} (global $foo2))
+; CHECK:   global $foo2{{$}}
+; CHECK:   setlocal {{.*}}
 ; CHECK: BB1_5:
-; CHECK:   (setlocal {{.*}} (global $foo3))
+; CHECK:   global $foo3{{$}}
+; CHECK:   setlocal {{.*}}
 ; CHECK: BB1_6:
-; CHECK:   (setlocal {{.*}} (global $foo4))
+; CHECK:   global $foo4{{$}}
+; CHECK:   setlocal {{.*}}
 ; CHECK: BB1_7:
-; CHECK:   (setlocal {{.*}} (global $foo5))
+; CHECK:   global $foo5{{$}}
+; CHECK:   setlocal {{.*}}
 ; CHECK: BB1_8:
-; CHECK:   (return)
+; CHECK:   return{{$}}
 define void @bar64(i64 %n) {
 entry:
   switch i64 %n, label %sw.epilog [
     i64 0, label %sw.bb
     i64 1, label %sw.bb
     i64 2, label %sw.bb
     i64 3, label %sw.bb
     i64 4, label %sw.bb

test/CodeGen/WebAssembly/unused-argument.ll

 ; RUN: llc < %s -asm-verbose=false | FileCheck %s
 
 ; Make sure that argument offsets are correct even if some arguments are unused.
 
 target datalayout = "e-p:32:32-i64:64-n32:64-S128"
 target triple = "wasm32-unknown-unknown"
 
-; CHECK-LABEL: (func $unused_first
-; CHECK-NEXT: (param i32) (param i32) (result i32)
-; CHECK-NEXT: (setlocal @0 (argument 1))
-; CHECK-NEXT: (return @0)
+; CHECK-LABEL: unused_first:
+; CHECK-NEXT: .param i32{{$}}
+; CHECK-NEXT: .param i32{{$}}
+; CHECK-NEXT: .result i32{{$}}
+; CHECK-NEXT: argument 1{{$}}
+; CHECK-NEXT: setlocal @0{{$}}
+; CHECK-NEXT: return @0{{$}}
 define i32 @unused_first(i32 %x, i32 %y) {
   ret i32 %y
 }
 
-; CHECK-LABEL: (func $unused_second
-; CHECK-NEXT: (param i32) (param i32) (result i32)
-; CHECK-NEXT: (setlocal @0 (argument 0))
-; CHECK-NEXT: (return @0)
+; CHECK-LABEL: unused_second:
+; CHECK-NEXT: .param i32{{$}}
+; CHECK-NEXT: .param i32{{$}}
+; CHECK-NEXT: .result i32{{$}}
+; CHECK-NEXT: argument 0{{$}}
+; CHECK-NEXT: setlocal @0{{$}}
+; CHECK-NEXT: return @0{{$}}
 define i32 @unused_second(i32 %x, i32 %y) {
   ret i32 %x
 }