Index: lib/Target/WebAssembly/MCTargetDesc/WebAssemblyMCAsmInfo.cpp =================================================================== --- lib/Target/WebAssembly/MCTargetDesc/WebAssemblyMCAsmInfo.cpp +++ lib/Target/WebAssembly/MCTargetDesc/WebAssemblyMCAsmInfo.cpp @@ -27,9 +27,6 @@ // TODO: What should MaxInstLength be? - // The s-expression format of WebAssembly uses LISP-style comments. - CommentString = ";;"; - PrivateGlobalPrefix = ""; PrivateLabelPrefix = ""; @@ -44,17 +41,10 @@ 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? } Index: lib/Target/WebAssembly/WebAssemblyAsmPrinter.cpp =================================================================== --- lib/Target/WebAssembly/WebAssemblyAsmPrinter.cpp +++ lib/Target/WebAssembly/WebAssemblyAsmPrinter.cpp @@ -22,6 +22,7 @@ #include "MCTargetDesc/WebAssemblyMCTargetDesc.h" #include "llvm/ADT/SmallString.h" +#include "llvm/ADT/StringExtras.h" #include "llvm/CodeGen/AsmPrinter.h" #include "llvm/CodeGen/MachineConstantPool.h" #include "llvm/CodeGen/MachineInstr.h" @@ -41,6 +42,7 @@ class WebAssemblyAsmPrinter final : public AsmPrinter { const WebAssemblyInstrInfo *TII; + unsigned NumArgs; public: WebAssemblyAsmPrinter(TargetMachine &TM, std::unique_ptr Streamer) @@ -62,6 +64,7 @@ bool runOnMachineFunction(MachineFunction &MF) override { const auto &Subtarget = MF.getSubtarget(); TII = Subtarget.getInstrInfo(); + NumArgs = MF.getInfo()->getNumArguments(); return AsmPrinter::runOnMachineFunction(MF); } @@ -69,18 +72,16 @@ // 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; + std::string regToString(unsigned RegNo); + std::string argToString(unsigned ArgNo); }; } // end anonymous namespace @@ -119,6 +120,18 @@ return buf; } +std::string WebAssemblyAsmPrinter::regToString(unsigned RegNo) { + if (TargetRegisterInfo::isPhysicalRegister(RegNo)) + return WebAssemblyInstPrinter::getRegisterName(RegNo); + + return '@' + utostr(TargetRegisterInfo::virtReg2Index(RegNo) + NumArgs); +} + +std::string WebAssemblyAsmPrinter::argToString(unsigned ArgNo) { + // Same as above, but we don't need to add NumArgs here. + return '@' + utostr(ArgNo); +} + const char *WebAssemblyAsmPrinter::toString(Type *Ty) const { switch (Ty->getTypeID()) { default: @@ -161,70 +174,6 @@ // 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(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(Init)) { - assert(C->getBitWidth() <= 64 && "Printing wider types unimplemented"); - OS << C->getZExtValue(); - } else if (const auto *C = dyn_cast(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"); @@ -234,44 +183,30 @@ // 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) << ')'; + SmallString<128> Str; + raw_svector_ostream OS(Str); + 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()); } -} -void WebAssemblyAsmPrinter::EmitFunctionBodyEnd() { - SmallString<128> Str; - raw_svector_ostream OS(Str); - OS << ") ;; end func " << toSymbol(CurrentFnSym->getName()); - OutStreamer->EmitRawText(OS.str()); + AsmPrinter::EmitFunctionBodyStart(); } void WebAssemblyAsmPrinter::EmitInstruction(const MachineInstr *MI) { @@ -285,46 +220,75 @@ OS << '\t'; - if (NumDefs != 0) { - const MachineOperand &MO = MI->getOperand(0); - unsigned Reg = MO.getReg(); - OS << "(set_local @" << 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()) + switch (MI->getOpcode()) { + case TargetOpcode::COPY: + OS << regToString(MI->getOperand(1).getReg()); + break; + case WebAssembly::GLOBAL: + // TODO: wasm64 + OS << "i32.const " << toSymbol(MI->getOperand(1).getGlobal()->getName()); + break; + case WebAssembly::ARGUMENT_I32: + case WebAssembly::ARGUMENT_I64: + case WebAssembly::ARGUMENT_F32: + case WebAssembly::ARGUMENT_F64: + OS << argToString(MI->getOperand(1).getImm()); + break; + case WebAssembly::Immediate_I32: + OS << "i32.const " << MI->getOperand(1).getImm(); + break; + case WebAssembly::Immediate_I64: + OS << "i64.const " << MI->getOperand(1).getImm(); + break; + case WebAssembly::Immediate_F32: + OS << "f32.const " << toString(MI->getOperand(1).getFPImm()->getValueAPF()); + break; + case WebAssembly::Immediate_F64: + OS << "f64.const " << toString(MI->getOperand(1).getFPImm()->getValueAPF()); + break; + default: { + 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; + case MachineOperand::MO_Register: + OS << regToString(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; } - OS << ')'; + NeedComma = true; + } + break; + } } - - if (NumDefs != 0) - OS << ')'; OutStreamer->EmitRawText(OS.str()); + + if (NumDefs != 0) { + Str.clear(); + OS << "\t" "set_local " + << regToString(MI->getOperand(0).getReg()) << ", " + "@pop"; + OutStreamer->EmitRawText(OS.str()); + } } // Force static initialization. Index: lib/Target/WebAssembly/WebAssemblyISelLowering.cpp =================================================================== --- lib/Target/WebAssembly/WebAssemblyISelLowering.cpp +++ lib/Target/WebAssembly/WebAssemblyISelLowering.cpp @@ -370,6 +370,10 @@ ++ArgNo; } + // Record the number of arguments, since argument indices and local variable + // indices are in the same index space. + MF.getInfo()->setNumArguments(ArgNo); + return Chain; } @@ -450,5 +454,6 @@ MCSection *WebAssemblyTargetObjectFile::SelectSectionForGlobal( const GlobalValue *GV, SectionKind Kind, Mangler &Mang, const TargetMachine &TM) const { - return getDataSection(); + // TODO: Be more sophisticated than this. + return isa(GV) ? getTextSection() : getDataSection(); } Index: lib/Target/WebAssembly/WebAssemblyMachineFunctionInfo.h =================================================================== --- lib/Target/WebAssembly/WebAssemblyMachineFunctionInfo.h +++ lib/Target/WebAssembly/WebAssemblyMachineFunctionInfo.h @@ -27,9 +27,15 @@ class WebAssemblyFunctionInfo final : public MachineFunctionInfo { MachineFunction &MF; + unsigned NumArguments; + public: - explicit WebAssemblyFunctionInfo(MachineFunction &MF) : MF(MF) {} + explicit WebAssemblyFunctionInfo(MachineFunction &MF) + : MF(MF), NumArguments(0) {} ~WebAssemblyFunctionInfo() override; + + void setNumArguments(unsigned N) { NumArguments = N; } + unsigned getNumArguments() const { return NumArguments; } }; } // end namespace llvm Index: test/CodeGen/WebAssembly/call.ll =================================================================== --- test/CodeGen/WebAssembly/call.ll +++ test/CodeGen/WebAssembly/call.ll @@ -13,110 +13,126 @@ declare double @double_nullary() declare void @void_nullary() -; CHECK-LABEL: (func $call_i32_nullary -; CHECK-NEXT: (result i32) -; CHECK-NEXT: (set_local @0 (call $i32_nullary)) -; CHECK-NEXT: (return @0) +; CHECK-LABEL: call_i32_nullary: +; CHECK-NEXT: .result i32 +; CHECK-NEXT: call $i32_nullary +; CHECK-NEXT: set_local @0, @pop +; CHECK-NEXT: return @0 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: (set_local @0 (call $i64_nullary)) -; CHECK-NEXT: (return @0) +; CHECK-LABEL: call_i64_nullary: +; CHECK-NEXT: .result i64 +; CHECK-NEXT: call $i64_nullary +; CHECK-NEXT: set_local @0, @pop +; CHECK-NEXT: return @0 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: (set_local @0 (call $float_nullary)) -; CHECK-NEXT: (return @0) +; CHECK-LABEL: call_float_nullary: +; CHECK-NEXT: .result f32 +; CHECK-NEXT: call $float_nullary +; CHECK-NEXT: set_local @0, @pop +; CHECK-NEXT: return @0 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: (set_local @0 (call $double_nullary)) -; CHECK-NEXT: (return @0) +; CHECK-LABEL: call_double_nullary: +; CHECK-NEXT: .result f64 +; CHECK-NEXT: call $double_nullary +; CHECK-NEXT: set_local @0, @pop +; CHECK-NEXT: return @0 define double @call_double_nullary() { %r = call double @double_nullary() ret double %r } -; CHECK-LABEL: (func $call_void_nullary -; CHECK-NEXT: (call $void_nullary) -; CHECK-NEXT: (return) +; CHECK-LABEL: call_void_nullary: +; CHECK-NEXT: call $void_nullary +; 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: (set_local @0 (argument 0)) -; CHECK-NEXT: (set_local @1 (call $i32_unary @0)) -; CHECK-NEXT: (return @1) +; CHECK-LABEL: call_i32_unary: +; CHECK-NEXT: .param i32 +; CHECK-NEXT: .result i32 +; CHECK-NEXT: @0 +; CHECK-NEXT: set_local @1, @pop +; CHECK-NEXT: call $i32_unary, @1 +; CHECK-NEXT: set_local @2, @pop +; 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: (set_local @0 (argument 1)) -; CHECK-NEXT: (set_local @1 (argument 0)) -; CHECK-NEXT: (set_local @2 (call $i32_binary @1 @0)) -; CHECK-NEXT: (return @2) +; CHECK-LABEL: call_i32_binary: +; CHECK-NEXT: .param i32 +; CHECK-NEXT: .param i32 +; CHECK-NEXT: .result i32 +; CHECK-NEXT: @1 +; CHECK-NEXT: set_local @2, @pop +; CHECK-NEXT: @0 +; CHECK-NEXT: set_local @3, @pop +; CHECK-NEXT: call $i32_binary, @3, @2 +; CHECK-NEXT: set_local @4, @pop +; CHECK-NEXT: return @4 define i32 @call_i32_binary(i32 %a, i32 %b) { %r = call i32 @i32_binary(i32 %a, i32 %b) ret i32 %r } -; CHECK-LABEL: (func $call_indirect_void -; CHECK-NEXT: (param i32) -; CHECK-NEXT: (set_local @0 (argument 0)) -; CHECK-NEXT: (call_indirect @0) -; CHECK-NEXT: (return) +; CHECK-LABEL: call_indirect_void: +; CHECK-NEXT: .param i32 +; CHECK-NEXT: @0 +; CHECK-NEXT: set_local @1, @pop +; CHECK-NEXT: call_indirect @1 +; CHECK-NEXT: return define void @call_indirect_void(void ()* %callee) { call void %callee() ret void } -; CHECK-LABEL: (func $call_indirect_i32 -; CHECK-NEXT: (param i32) -; CHECK-NEXT: (set_local @0 (argument 0)) -; CHECK-NEXT: (set_local @1 (call_indirect @0)) -; CHECK-NEXT: (return @1) +; CHECK-LABEL: call_indirect_i32: +; CHECK-NEXT: .param i32 +; CHECK-NEXT: .result i32 +; CHECK-NEXT: @0 +; CHECK-NEXT: set_local @1, @pop +; CHECK-NEXT: call_indirect @1 +; CHECK-NEXT: set_local @2, @pop +; CHECK-NEXT: return @2 define i32 @call_indirect_i32(i32 ()* %callee) { %t = call i32 %callee() ret i32 %t } -; CHECK-LABEL: (func $tail_call_void_nullary -; CHECK-NEXT: (call $void_nullary) -; CHECK-NEXT: (return) +; CHECK-LABEL: tail_call_void_nullary: +; CHECK-NEXT: call $void_nullary +; CHECK-NEXT: return{{$}} define void @tail_call_void_nullary() { tail call void @void_nullary() ret void } -; CHECK-LABEL: (func $fastcc_tail_call_void_nullary -; CHECK-NEXT: (call $void_nullary) -; CHECK-NEXT: (return) +; CHECK-LABEL: fastcc_tail_call_void_nullary: +; CHECK-NEXT: call $void_nullary +; CHECK-NEXT: return{{$}} define void @fastcc_tail_call_void_nullary() { tail call fastcc void @void_nullary() ret void } -; CHECK-LABEL: (func $coldcc_tail_call_void_nullary -; CHECK-NEXT: (call $void_nullary) -; CHECK-NEXT: (return) +; CHECK-LABEL: coldcc_tail_call_void_nullary: +; CHECK-NEXT: call $void_nullary +; CHECK-NEXT: return{{$}} define void @coldcc_tail_call_void_nullary() { tail call coldcc void @void_nullary() ret void Index: test/CodeGen/WebAssembly/cfg-stackify.ll =================================================================== --- test/CodeGen/WebAssembly/cfg-stackify.ll +++ test/CodeGen/WebAssembly/cfg-stackify.ll @@ -9,13 +9,13 @@ ; 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 @@ -37,13 +37,13 @@ ; 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 @@ -65,13 +65,13 @@ ; 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, @16{{$}} ; CHECK: BB2_2: -; CHECK: (return) +; CHECK: return{{$}} define void @test2(double* nocapture %p, i32 %n) { entry: %cmp.4 = icmp sgt i32 %n, 0 @@ -97,18 +97,18 @@ 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, @7{{$}} +; CHECK: br $BB3_5{{$}} ; CHECK: BB3_2: -; CHECK: (brif $BB3_4 @7) -; CHECK: (br $BB3_5) +; CHECK: brif $BB3_4, @10{{$}} +; CHECK: br $BB3_5{{$}} ; CHECK: BB3_4: ; CHECK: BB3_5: -; CHECK: (return @3) +; CHECK: return @6{{$}} define i32 @doublediamond(i32 %a, i32 %b, i32* %p) { entry: %c = icmp eq i32 %a, 0 @@ -132,11 +132,11 @@ 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, @5{{$}} ; CHECK: BB4_2: -; CHECK: (return @2) +; CHECK: return @4{{$}} define i32 @triangle(i32* %p, i32 %a) { entry: %c = icmp eq i32 %a, 0 @@ -150,14 +150,14 @@ 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, @5{{$}} +; CHECK: br $BB5_3{{$}} ; CHECK: BB5_2: ; CHECK: BB5_3: -; CHECK: (return @2) +; CHECK: return @4{{$}} define i32 @diamond(i32* %p, i32 %a) { entry: %c = icmp eq i32 %a, 0 @@ -174,20 +174,20 @@ ret i32 0 } -; CHECK-LABEL: single_block +; CHECK-LABEL: single_block: ; CHECK-NOT: br -; CHECK: (return @1) +; CHECK: return @2{{$}} 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 @1, @3{{$}} +; CHECK: br $BB7_1{{$}} define i32 @minimal_loop(i32* %p) { entry: store volatile i32 0, i32* %p @@ -197,12 +197,12 @@ br label %loop } -; CHECK-LABEL: simple_loop +; CHECK-LABEL: simple_loop: ; CHECK-NOT: br ; CHECK: BB8_1: -; CHECK: (loop $BB8_2) -; CHECK: (brif $BB8_1 @4) -; CHECK: (return @2) +; CHECK: loop $BB8_2{{$}} +; CHECK: brif $BB8_1, @6{{$}} +; CHECK: return @4{{$}} define i32 @simple_loop(i32* %p, i32 %a) { entry: %c = icmp eq i32 %a, 0 @@ -216,14 +216,14 @@ 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, @7{{$}} +; CHECK: brif $BB9_3, @10{{$}} ; CHECK: BB9_3: ; CHECK: BB9_4: -; CHECK: (return @3) +; CHECK: return @6{{$}} define i32 @doubletriangle(i32 %a, i32 %b, i32* %p) { entry: %c = icmp eq i32 %a, 0 @@ -244,15 +244,15 @@ 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, @7{{$}} +; CHECK: br $BB10_4{{$}} ; CHECK: BB10_2: -; CHECK: (brif $BB10_4 @7) +; CHECK: brif $BB10_4, @10{{$}} ; CHECK: BB10_4: -; CHECK: (return @3) +; CHECK: return @6{{$}} define i32 @ifelse_earlyexits(i32 %a, i32 %b, i32* %p) { entry: %c = icmp eq i32 %a, 0 Index: test/CodeGen/WebAssembly/comparisons_f32.ll =================================================================== --- test/CodeGen/WebAssembly/comparisons_f32.ll +++ test/CodeGen/WebAssembly/comparisons_f32.ll @@ -6,80 +6,104 @@ 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: (set_local @0 (argument 0)) -; CHECK-NEXT: (set_local @1 (argument 1)) -; CHECK-NEXT: (set_local @2 (eq @1 @1)) -; CHECK-NEXT: (set_local @3 (eq @0 @0)) -; CHECK-NEXT: (set_local @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: @0{{$}} +; CHECK-NEXT: set_local @2, @pop{{$}} +; CHECK-NEXT: @1{{$}} +; CHECK-NEXT: set_local @3, @pop{{$}} +; CHECK-NEXT: eq @3, @3{{$}} +; CHECK-NEXT: set_local @4, @pop{{$}} +; CHECK-NEXT: eq @2, @2{{$}} +; CHECK-NEXT: set_local @5, @pop{{$}} +; CHECK-NEXT: and @5, @4{{$}} +; CHECK-NEXT: set_local @6, @pop{{$}} +; CHECK-NEXT: return @6{{$}} 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: (set_local @0 (argument 0)) -; CHECK-NEXT: (set_local @1 (argument 1)) -; CHECK-NEXT: (set_local @2 (ne @1 @1)) -; CHECK-NEXT: (set_local @3 (ne @0 @0)) -; CHECK-NEXT: (set_local @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: @0{{$}} +; CHECK-NEXT: set_local @2, @pop{{$}} +; CHECK-NEXT: @1{{$}} +; CHECK-NEXT: set_local @3, @pop{{$}} +; CHECK-NEXT: ne @3, @3{{$}} +; CHECK-NEXT: set_local @4, @pop{{$}} +; CHECK-NEXT: ne @2, @2{{$}} +; CHECK-NEXT: set_local @5, @pop{{$}} +; CHECK-NEXT: ior @5, @4{{$}} +; CHECK-NEXT: set_local @6, @pop{{$}} +; CHECK-NEXT: return @6{{$}} 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: (set_local @0 (argument 1)) -; CHECK-NEXT: (set_local @1 (argument 0)) -; CHECK-NEXT: (set_local @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: @1{{$}} +; CHECK-NEXT: set_local @2, @pop{{$}} +; CHECK-NEXT: @0{{$}} +; CHECK-NEXT: set_local @3, @pop{{$}} +; CHECK-NEXT: eq @3, @2{{$}} +; CHECK-NEXT: set_local @4, @pop{{$}} +; CHECK-NEXT: return @4{{$}} 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: (set_local @2 (ne @1 @0)) +; CHECK-LABEL: une_f32: +; CHECK: ne @3, @2{{$}} +; CHECK-NEXT: set_local @4, @pop{{$}} 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: (set_local @2 (lt @1 @0)) +; CHECK-LABEL: olt_f32: +; CHECK: lt @3, @2{{$}} +; CHECK-NEXT: set_local @4, @pop{{$}} 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: (set_local @2 (le @1 @0)) +; CHECK-LABEL: ole_f32: +; CHECK: le @3, @2{{$}} +; CHECK-NEXT: set_local @4, @pop{{$}} 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: (set_local @2 (gt @1 @0)) +; CHECK-LABEL: ogt_f32: +; CHECK: gt @3, @2{{$}} +; CHECK-NEXT: set_local @4, @pop{{$}} 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: (set_local @2 (ge @1 @0)) +; CHECK-LABEL: oge_f32: +; CHECK: ge @3, @2{{$}} +; CHECK-NEXT: set_local @4, @pop{{$}} define i32 @oge_f32(float %x, float %y) { %a = fcmp oge float %x, %y %b = zext i1 %a to i32 @@ -88,56 +112,70 @@ ; Expanded comparisons, which also check for NaN. -; CHECK-LABEL: (func $ueq_f32 -; CHECK-NEXT: (param f32) (param f32) (result i32) -; CHECK-NEXT: (set_local @0 (argument 1)) -; CHECK-NEXT: (set_local @1 (argument 0)) -; CHECK-NEXT: (set_local @2 (eq @1 @0)) -; CHECK-NEXT: (set_local @3 (ne @0 @0)) -; CHECK-NEXT: (set_local @4 (ne @1 @1)) -; CHECK-NEXT: (set_local @5 (ior @4 @3)) -; CHECK-NEXT: (set_local @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: @1{{$}} +; CHECK-NEXT: set_local @2, @pop{{$}} +; CHECK-NEXT: @0{{$}} +; CHECK-NEXT: set_local @3, @pop{{$}} +; CHECK-NEXT: eq @3, @2{{$}} +; CHECK-NEXT: set_local @4, @pop{{$}} +; CHECK-NEXT: ne @2, @2{{$}} +; CHECK-NEXT: set_local @5, @pop{{$}} +; CHECK-NEXT: ne @3, @3{{$}} +; CHECK-NEXT: set_local @6, @pop{{$}} +; CHECK-NEXT: ior @6, @5{{$}} +; CHECK-NEXT: set_local @7, @pop{{$}} +; CHECK-NEXT: ior @4, @7{{$}} +; CHECK-NEXT: set_local @8, @pop{{$}} +; CHECK-NEXT: return @8{{$}} 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: (set_local @2 (ne @1 @0)) +; CHECK-LABEL: one_f32: +; CHECK: ne @3, @2{{$}} +; CHECK-NEXT: set_local @4, @pop{{$}} 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: (set_local @2 (lt @1 @0)) +; CHECK-LABEL: ult_f32: +; CHECK: lt @3, @2{{$}} +; CHECK-NEXT: set_local @4, @pop{{$}} 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: (set_local @2 (le @1 @0)) +; CHECK-LABEL: ule_f32: +; CHECK: le @3, @2{{$}} +; CHECK-NEXT: set_local @4, @pop{{$}} 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: (set_local @2 (gt @1 @0)) +; CHECK-LABEL: ugt_f32: +; CHECK: gt @3, @2{{$}} +; CHECK-NEXT: set_local @4, @pop{{$}} 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: (set_local @2 (ge @1 @0)) +; CHECK-LABEL: uge_f32: +; CHECK: ge @3, @2{{$}} +; CHECK-NEXT: set_local @4, @pop{{$}} define i32 @uge_f32(float %x, float %y) { %a = fcmp uge float %x, %y %b = zext i1 %a to i32 Index: test/CodeGen/WebAssembly/comparisons_f64.ll =================================================================== --- test/CodeGen/WebAssembly/comparisons_f64.ll +++ test/CodeGen/WebAssembly/comparisons_f64.ll @@ -6,80 +6,104 @@ 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: (set_local @0 (argument 0)) -; CHECK-NEXT: (set_local @1 (argument 1)) -; CHECK-NEXT: (set_local @2 (eq @1 @1)) -; CHECK-NEXT: (set_local @3 (eq @0 @0)) -; CHECK-NEXT: (set_local @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: @0{{$}} +; CHECK-NEXT: set_local @2, @pop{{$}} +; CHECK-NEXT: @1{{$}} +; CHECK-NEXT: set_local @3, @pop{{$}} +; CHECK-NEXT: eq @3, @3{{$}} +; CHECK-NEXT: set_local @4, @pop{{$}} +; CHECK-NEXT: eq @2, @2{{$}} +; CHECK-NEXT: set_local @5, @pop{{$}} +; CHECK-NEXT: and @5, @4{{$}} +; CHECK-NEXT: set_local @6, @pop{{$}} +; CHECK-NEXT: return @6{{$}} 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: (set_local @0 (argument 0)) -; CHECK-NEXT: (set_local @1 (argument 1)) -; CHECK-NEXT: (set_local @2 (ne @1 @1)) -; CHECK-NEXT: (set_local @3 (ne @0 @0)) -; CHECK-NEXT: (set_local @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: @0{{$}} +; CHECK-NEXT: set_local @2, @pop{{$}} +; CHECK-NEXT: @1{{$}} +; CHECK-NEXT: set_local @3, @pop{{$}} +; CHECK-NEXT: ne @3, @3{{$}} +; CHECK-NEXT: set_local @4, @pop{{$}} +; CHECK-NEXT: ne @2, @2{{$}} +; CHECK-NEXT: set_local @5, @pop{{$}} +; CHECK-NEXT: ior @5, @4{{$}} +; CHECK-NEXT: set_local @6, @pop{{$}} +; CHECK-NEXT: return @6{{$}} 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: (set_local @0 (argument 1)) -; CHECK-NEXT: (set_local @1 (argument 0)) -; CHECK-NEXT: (set_local @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: @1{{$}} +; CHECK-NEXT: set_local @2, @pop{{$}} +; CHECK-NEXT: @0{{$}} +; CHECK-NEXT: set_local @3, @pop{{$}} +; CHECK-NEXT: eq @3, @2{{$}} +; CHECK-NEXT: set_local @4, @pop{{$}} +; CHECK-NEXT: return @4{{$}} 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: (set_local @2 (ne @1 @0)) +; CHECK-LABEL: une_f64: +; CHECK: ne @3, @2{{$}} +; CHECK-NEXT: set_local @4, @pop{{$}} 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: (set_local @2 (lt @1 @0)) +; CHECK-LABEL: olt_f64: +; CHECK: lt @3, @2{{$}} +; CHECK-NEXT: set_local @4, @pop{{$}} 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: (set_local @2 (le @1 @0)) +; CHECK-LABEL: ole_f64: +; CHECK: le @3, @2{{$}} +; CHECK-NEXT: set_local @4, @pop{{$}} 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: (set_local @2 (gt @1 @0)) +; CHECK-LABEL: ogt_f64: +; CHECK: gt @3, @2{{$}} +; CHECK-NEXT: set_local @4, @pop{{$}} 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: (set_local @2 (ge @1 @0)) +; CHECK-LABEL: oge_f64: +; CHECK: ge @3, @2{{$}} +; CHECK-NEXT: set_local @4, @pop{{$}} define i32 @oge_f64(double %x, double %y) { %a = fcmp oge double %x, %y %b = zext i1 %a to i32 @@ -88,56 +112,70 @@ ; Expanded comparisons, which also check for NaN. -; CHECK-LABEL: (func $ueq_f64 -; CHECK-NEXT: (param f64) (param f64) (result i32) -; CHECK-NEXT: (set_local @0 (argument 1)) -; CHECK-NEXT: (set_local @1 (argument 0)) -; CHECK-NEXT: (set_local @2 (eq @1 @0)) -; CHECK-NEXT: (set_local @3 (ne @0 @0)) -; CHECK-NEXT: (set_local @4 (ne @1 @1)) -; CHECK-NEXT: (set_local @5 (ior @4 @3)) -; CHECK-NEXT: (set_local @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: @1{{$}} +; CHECK-NEXT: set_local @2, @pop{{$}} +; CHECK-NEXT: @0{{$}} +; CHECK-NEXT: set_local @3, @pop{{$}} +; CHECK-NEXT: eq @3, @2{{$}} +; CHECK-NEXT: set_local @4, @pop{{$}} +; CHECK-NEXT: ne @2, @2{{$}} +; CHECK-NEXT: set_local @5, @pop{{$}} +; CHECK-NEXT: ne @3, @3{{$}} +; CHECK-NEXT: set_local @6, @pop{{$}} +; CHECK-NEXT: ior @6, @5{{$}} +; CHECK-NEXT: set_local @7, @pop{{$}} +; CHECK-NEXT: ior @4, @7{{$}} +; CHECK-NEXT: set_local @8, @pop{{$}} +; CHECK-NEXT: return @8{{$}} 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: (set_local @2 (ne @1 @0)) +; CHECK-LABEL: one_f64: +; CHECK: ne @3, @2{{$}} +; CHECK-NEXT: set_local @4, @pop{{$}} 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: (set_local @2 (lt @1 @0)) +; CHECK-LABEL: ult_f64: +; CHECK: lt @3, @2{{$}} +; CHECK-NEXT: set_local @4, @pop{{$}} 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: (set_local @2 (le @1 @0)) +; CHECK-LABEL: ule_f64: +; CHECK: le @3, @2{{$}} +; CHECK-NEXT: set_local @4, @pop{{$}} 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: (set_local @2 (gt @1 @0)) +; CHECK-LABEL: ugt_f64: +; CHECK: gt @3, @2{{$}} +; CHECK-NEXT: set_local @4, @pop{{$}} 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: (set_local @2 (ge @1 @0)) +; CHECK-LABEL: uge_f64: +; CHECK: ge @3, @2{{$}} +; CHECK-NEXT: set_local @4, @pop{{$}} define i32 @uge_f64(double %x, double %y) { %a = fcmp uge double %x, %y %b = zext i1 %a to i32 Index: test/CodeGen/WebAssembly/comparisons_i32.ll =================================================================== --- test/CodeGen/WebAssembly/comparisons_i32.ll +++ test/CodeGen/WebAssembly/comparisons_i32.ll @@ -5,84 +5,98 @@ 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: (set_local @0 (argument 1)) -; CHECK-NEXT: (set_local @1 (argument 0)) -; CHECK-NEXT: (set_local @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: @1{{$}} +; CHECK-NEXT: set_local @2, @pop{{$}} +; CHECK-NEXT: @0{{$}} +; CHECK-NEXT: set_local @3, @pop{{$}} +; CHECK-NEXT: eq @3, @2{{$}} +; CHECK-NEXT: set_local @4, @pop{{$}} +; CHECK-NEXT: return @4{{$}} 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: (set_local @2 (ne @1 @0)) +; CHECK-LABEL: ne_i32: +; CHECK: ne @3, @2{{$}} +; CHECK-NEXT: set_local @4, @pop{{$}} 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: (set_local @2 (slt @1 @0)) +; CHECK-LABEL: slt_i32: +; CHECK: slt @3, @2{{$}} +; CHECK-NEXT: set_local @4, @pop{{$}} 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: (set_local @2 (sle @1 @0)) +; CHECK-LABEL: sle_i32: +; CHECK: sle @3, @2{{$}} +; CHECK-NEXT: set_local @4, @pop{{$}} 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: (set_local @2 (ult @1 @0)) +; CHECK-LABEL: ult_i32: +; CHECK: ult @3, @2{{$}} +; CHECK-NEXT: set_local @4, @pop{{$}} 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: (set_local @2 (ule @1 @0)) +; CHECK-LABEL: ule_i32: +; CHECK: ule @3, @2{{$}} +; CHECK-NEXT: set_local @4, @pop{{$}} 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: (set_local @2 (sgt @1 @0)) +; CHECK-LABEL: sgt_i32: +; CHECK: sgt @3, @2{{$}} +; CHECK-NEXT: set_local @4, @pop{{$}} 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: (set_local @2 (sge @1 @0)) +; CHECK-LABEL: sge_i32: +; CHECK: sge @3, @2{{$}} +; CHECK-NEXT: set_local @4, @pop{{$}} 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: (set_local @2 (ugt @1 @0)) +; CHECK-LABEL: ugt_i32: +; CHECK: ugt @3, @2{{$}} +; CHECK-NEXT: set_local @4, @pop{{$}} 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: (set_local @2 (uge @1 @0)) +; CHECK-LABEL: uge_i32: +; CHECK: uge @3, @2{{$}} +; CHECK-NEXT: set_local @4, @pop{{$}} define i32 @uge_i32(i32 %x, i32 %y) { %a = icmp uge i32 %x, %y %b = zext i1 %a to i32 Index: test/CodeGen/WebAssembly/comparisons_i64.ll =================================================================== --- test/CodeGen/WebAssembly/comparisons_i64.ll +++ test/CodeGen/WebAssembly/comparisons_i64.ll @@ -5,84 +5,98 @@ 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: (set_local @0 (argument 1)) -; CHECK-NEXT: (set_local @1 (argument 0)) -; CHECK-NEXT: (set_local @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: @1{{$}} +; CHECK-NEXT: set_local @2, @pop{{$}} +; CHECK-NEXT: @0{{$}} +; CHECK-NEXT: set_local @3, @pop{{$}} +; CHECK-NEXT: eq @3, @2{{$}} +; CHECK-NEXT: set_local @4, @pop{{$}} +; CHECK-NEXT: return @4{{$}} 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: (set_local @2 (ne @1 @0)) +; CHECK-LABEL: ne_i64: +; CHECK: ne @3, @2{{$}} +; CHECK-NEXT: set_local @4, @pop{{$}} 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: (set_local @2 (slt @1 @0)) +; CHECK-LABEL: slt_i64: +; CHECK: slt @3, @2{{$}} +; CHECK-NEXT: set_local @4, @pop{{$}} 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: (set_local @2 (sle @1 @0)) +; CHECK-LABEL: sle_i64: +; CHECK: sle @3, @2{{$}} +; CHECK-NEXT: set_local @4, @pop{{$}} 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: (set_local @2 (ult @1 @0)) +; CHECK-LABEL: ult_i64: +; CHECK: ult @3, @2{{$}} +; CHECK-NEXT: set_local @4, @pop{{$}} 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: (set_local @2 (ule @1 @0)) +; CHECK-LABEL: ule_i64: +; CHECK: ule @3, @2{{$}} +; CHECK-NEXT: set_local @4, @pop{{$}} 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: (set_local @2 (sgt @1 @0)) +; CHECK-LABEL: sgt_i64: +; CHECK: sgt @3, @2{{$}} +; CHECK-NEXT: set_local @4, @pop{{$}} 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: (set_local @2 (sge @1 @0)) +; CHECK-LABEL: sge_i64: +; CHECK: sge @3, @2{{$}} +; CHECK-NEXT: set_local @4, @pop{{$}} 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: (set_local @2 (ugt @1 @0)) +; CHECK-LABEL: ugt_i64: +; CHECK: ugt @3, @2{{$}} +; CHECK-NEXT: set_local @4, @pop{{$}} 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: (set_local @2 (uge @1 @0)) +; CHECK-LABEL: uge_i64: +; CHECK: uge @3, @2{{$}} +; CHECK-NEXT: set_local @4, @pop{{$}} define i32 @uge_i64(i64 %x, i64 %y) { %a = icmp uge i64 %x, %y %b = zext i1 %a to i32 Index: test/CodeGen/WebAssembly/conv.ll =================================================================== --- test/CodeGen/WebAssembly/conv.ll +++ test/CodeGen/WebAssembly/conv.ll @@ -5,211 +5,274 @@ target datalayout = "e-p:32:32-i64:64-n32:64-S128" target triple = "wasm32-unknown-unknown" -; CHECK-LABEL: $i32_wrap_i64 -; CHECK-NEXT: (param i64) (result i32) -; CHECK-NEXT: (set_local @0 (argument 0)) -; CHECK-NEXT: (set_local @1 (i32_wrap @0)) -; CHECK-NEXT: (return @1) +; CHECK-LABEL: i32_wrap_i64: +; CHECK-NEXT: .param i64{{$}} +; CHECK-NEXT: .result i32{{$}} +; CHECK-NEXT: @0{{$}} +; CHECK-NEXT: set_local @1, @pop{{$}} +; CHECK-NEXT: i32_wrap @1{{$}} +; CHECK-NEXT: set_local @2, @pop{{$}} +; CHECK-NEXT: return @2{{$}} define i32 @i32_wrap_i64(i64 %x) { %a = trunc i64 %x to i32 ret i32 %a } -; CHECK-LABEL: $i64_extend_s_i32 -; CHECK-NEXT: (param i32) (result i64) -; CHECK-NEXT: (set_local @0 (argument 0)) -; CHECK-NEXT: (set_local @1 (i64_extend_s @0)) -; CHECK-NEXT: (return @1) +; CHECK-LABEL: i64_extend_s_i32: +; CHECK-NEXT: .param i32 +; CHECK-NEXT: .result i64 +; CHECK-NEXT: @0{{$}} +; CHECK-NEXT: set_local @1, @pop{{$}} +; CHECK-NEXT: i64_extend_s @1{{$}} +; CHECK-NEXT: set_local @2, @pop{{$}} +; CHECK-NEXT: return @2{{$}} define i64 @i64_extend_s_i32(i32 %x) { %a = sext i32 %x to i64 ret i64 %a } -; CHECK-LABEL: $i64_extend_u_i32 -; CHECK-NEXT: (param i32) (result i64) -; CHECK-NEXT: (set_local @0 (argument 0)) -; CHECK-NEXT: (set_local @1 (i64_extend_u @0)) -; CHECK-NEXT: (return @1) +; CHECK-LABEL: i64_extend_u_i32: +; CHECK-NEXT: .param i32 +; CHECK-NEXT: .result i64 +; CHECK-NEXT: @0{{$}} +; CHECK-NEXT: set_local @1, @pop{{$}} +; CHECK-NEXT: i64_extend_u @1{{$}} +; CHECK-NEXT: set_local @2, @pop{{$}} +; CHECK-NEXT: return @2{{$}} define i64 @i64_extend_u_i32(i32 %x) { %a = zext i32 %x to i64 ret i64 %a } -; CHECK-LABEL: $i32_trunc_s_f32 -; CHECK-NEXT: (param f32) (result i32) -; CHECK-NEXT: (set_local @0 (argument 0)) -; CHECK-NEXT: (set_local @1 (i32_trunc_s @0)) -; CHECK-NEXT: (return @1) +; CHECK-LABEL: i32_trunc_s_f32: +; CHECK-NEXT: .param f32 +; CHECK-NEXT: .result i32 +; CHECK-NEXT: @0{{$}} +; CHECK-NEXT: set_local @1, @pop{{$}} +; CHECK-NEXT: i32_trunc_s @1{{$}} +; CHECK-NEXT: set_local @2, @pop{{$}} +; CHECK-NEXT: return @2{{$}} define i32 @i32_trunc_s_f32(float %x) { %a = fptosi float %x to i32 ret i32 %a } -; CHECK-LABEL: $i32_trunc_u_f32 -; CHECK-NEXT: (param f32) (result i32) -; CHECK-NEXT: (set_local @0 (argument 0)) -; CHECK-NEXT: (set_local @1 (i32_trunc_u @0)) -; CHECK-NEXT: (return @1) +; CHECK-LABEL: i32_trunc_u_f32: +; CHECK-NEXT: .param f32 +; CHECK-NEXT: .result i32 +; CHECK-NEXT: @0{{$}} +; CHECK-NEXT: set_local @1, @pop{{$}} +; CHECK-NEXT: i32_trunc_u @1{{$}} +; CHECK-NEXT: set_local @2, @pop{{$}} +; CHECK-NEXT: return @2{{$}} define i32 @i32_trunc_u_f32(float %x) { %a = fptoui float %x to i32 ret i32 %a } -; CHECK-LABEL: $i32_trunc_s_f64 -; CHECK-NEXT: (param f64) (result i32) -; CHECK-NEXT: (set_local @0 (argument 0)) -; CHECK-NEXT: (set_local @1 (i32_trunc_s @0)) -; CHECK-NEXT: (return @1) +; CHECK-LABEL: i32_trunc_s_f64: +; CHECK-NEXT: .param f64 +; CHECK-NEXT: .result i32 +; CHECK-NEXT: @0{{$}} +; CHECK-NEXT: set_local @1, @pop{{$}} +; CHECK-NEXT: i32_trunc_s @1{{$}} +; CHECK-NEXT: set_local @2, @pop{{$}} +; CHECK-NEXT: return @2{{$}} define i32 @i32_trunc_s_f64(double %x) { %a = fptosi double %x to i32 ret i32 %a } -; CHECK-LABEL: $i32_trunc_u_f64 -; CHECK-NEXT: (param f64) (result i32) -; CHECK-NEXT: (set_local @0 (argument 0)) -; CHECK-NEXT: (set_local @1 (i32_trunc_u @0)) -; CHECK-NEXT: (return @1) +; CHECK-LABEL: i32_trunc_u_f64: +; CHECK-NEXT: .param f64 +; CHECK-NEXT: .result i32 +; CHECK-NEXT: @0{{$}} +; CHECK-NEXT: set_local @1, @pop{{$}} +; CHECK-NEXT: i32_trunc_u @1{{$}} +; CHECK-NEXT: set_local @2, @pop{{$}} +; CHECK-NEXT: return @2{{$}} define i32 @i32_trunc_u_f64(double %x) { %a = fptoui double %x to i32 ret i32 %a } -; CHECK-LABEL: $i64_trunc_s_f32 -; CHECK-NEXT: (param f32) (result i64) -; CHECK-NEXT: (set_local @0 (argument 0)) -; CHECK-NEXT: (set_local @1 (i64_trunc_s @0)) -; CHECK-NEXT: (return @1) +; CHECK-LABEL: i64_trunc_s_f32: +; CHECK-NEXT: .param f32 +; CHECK-NEXT: .result i64 +; CHECK-NEXT: @0{{$}} +; CHECK-NEXT: set_local @1, @pop{{$}} +; CHECK-NEXT: i64_trunc_s @1{{$}} +; CHECK-NEXT: set_local @2, @pop{{$}} +; CHECK-NEXT: return @2{{$}} define i64 @i64_trunc_s_f32(float %x) { %a = fptosi float %x to i64 ret i64 %a } -; CHECK-LABEL: $i64_trunc_u_f32 -; CHECK-NEXT: (param f32) (result i64) -; CHECK-NEXT: (set_local @0 (argument 0)) -; CHECK-NEXT: (set_local @1 (i64_trunc_u @0)) -; CHECK-NEXT: (return @1) +; CHECK-LABEL: i64_trunc_u_f32: +; CHECK-NEXT: .param f32 +; CHECK-NEXT: .result i64 +; CHECK-NEXT: @0{{$}} +; CHECK-NEXT: set_local @1, @pop{{$}} +; CHECK-NEXT: i64_trunc_u @1{{$}} +; CHECK-NEXT: set_local @2, @pop{{$}} +; CHECK-NEXT: return @2{{$}} define i64 @i64_trunc_u_f32(float %x) { %a = fptoui float %x to i64 ret i64 %a } -; CHECK-LABEL: $i64_trunc_s_f64 -; CHECK-NEXT: (param f64) (result i64) -; CHECK-NEXT: (set_local @0 (argument 0)) -; CHECK-NEXT: (set_local @1 (i64_trunc_s @0)) -; CHECK-NEXT: (return @1) +; CHECK-LABEL: i64_trunc_s_f64: +; CHECK-NEXT: .param f64 +; CHECK-NEXT: .result i64 +; CHECK-NEXT: @0{{$}} +; CHECK-NEXT: set_local @1, @pop{{$}} +; CHECK-NEXT: i64_trunc_s @1{{$}} +; CHECK-NEXT: set_local @2, @pop{{$}} +; CHECK-NEXT: return @2{{$}} define i64 @i64_trunc_s_f64(double %x) { %a = fptosi double %x to i64 ret i64 %a } -; CHECK-LABEL: $i64_trunc_u_f64 -; CHECK-NEXT: (param f64) (result i64) -; CHECK-NEXT: (set_local @0 (argument 0)) -; CHECK-NEXT: (set_local @1 (i64_trunc_u @0)) -; CHECK-NEXT: (return @1) +; CHECK-LABEL: i64_trunc_u_f64: +; CHECK-NEXT: .param f64 +; CHECK-NEXT: .result i64 +; CHECK-NEXT: @0{{$}} +; CHECK-NEXT: set_local @1, @pop{{$}} +; CHECK-NEXT: i64_trunc_u @1{{$}} +; CHECK-NEXT: set_local @2, @pop{{$}} +; CHECK-NEXT: return @2{{$}} define i64 @i64_trunc_u_f64(double %x) { %a = fptoui double %x to i64 ret i64 %a } -; CHECK-LABEL: $f32_convert_s_i32 -; CHECK-NEXT: (param i32) (result f32) -; CHECK-NEXT: (set_local @0 (argument 0)) -; CHECK-NEXT: (set_local @1 (f32_convert_s @0)) -; CHECK-NEXT: (return @1) +; CHECK-LABEL: f32_convert_s_i32: +; CHECK-NEXT: .param i32 +; CHECK-NEXT: .result f32 +; CHECK-NEXT: @0{{$}} +; CHECK-NEXT: set_local @1, @pop{{$}} +; CHECK-NEXT: f32_convert_s @1{{$}} +; CHECK-NEXT: set_local @2, @pop{{$}} +; CHECK-NEXT: return @2{{$}} define float @f32_convert_s_i32(i32 %x) { %a = sitofp i32 %x to float ret float %a } -; CHECK-LABEL: $f32_convert_u_i32 -; CHECK-NEXT: (param i32) (result f32) -; CHECK-NEXT: (set_local @0 (argument 0)) -; CHECK-NEXT: (set_local @1 (f32_convert_u @0)) -; CHECK-NEXT: (return @1) +; CHECK-LABEL: f32_convert_u_i32: +; CHECK-NEXT: .param i32 +; CHECK-NEXT: .result f32 +; CHECK-NEXT: @0{{$}} +; CHECK-NEXT: set_local @1, @pop{{$}} +; CHECK-NEXT: f32_convert_u @1{{$}} +; CHECK-NEXT: set_local @2, @pop{{$}} +; CHECK-NEXT: return @2{{$}} define float @f32_convert_u_i32(i32 %x) { %a = uitofp i32 %x to float ret float %a } -; CHECK-LABEL: $f64_convert_s_i32 -; CHECK-NEXT: (param i32) (result f64) -; CHECK-NEXT: (set_local @0 (argument 0)) -; CHECK-NEXT: (set_local @1 (f64_convert_s @0)) -; CHECK-NEXT: (return @1) +; CHECK-LABEL: f64_convert_s_i32: +; CHECK-NEXT: .param i32 +; CHECK-NEXT: .result f64 +; CHECK-NEXT: @0{{$}} +; CHECK-NEXT: set_local @1, @pop{{$}} +; CHECK-NEXT: f64_convert_s @1{{$}} +; CHECK-NEXT: set_local @2, @pop{{$}} +; CHECK-NEXT: return @2{{$}} define double @f64_convert_s_i32(i32 %x) { %a = sitofp i32 %x to double ret double %a } -; CHECK-LABEL: $f64_convert_u_i32 -; CHECK-NEXT: (param i32) (result f64) -; CHECK-NEXT: (set_local @0 (argument 0)) -; CHECK-NEXT: (set_local @1 (f64_convert_u @0)) -; CHECK-NEXT: (return @1) +; CHECK-LABEL: f64_convert_u_i32: +; CHECK-NEXT: .param i32 +; CHECK-NEXT: .result f64 +; CHECK-NEXT: @0{{$}} +; CHECK-NEXT: set_local @1, @pop{{$}} +; CHECK-NEXT: f64_convert_u @1{{$}} +; CHECK-NEXT: set_local @2, @pop{{$}} +; CHECK-NEXT: return @2{{$}} define double @f64_convert_u_i32(i32 %x) { %a = uitofp i32 %x to double ret double %a } -; CHECK-LABEL: $f32_convert_s_i64 -; CHECK-NEXT: (param i64) (result f32) -; CHECK-NEXT: (set_local @0 (argument 0)) -; CHECK-NEXT: (set_local @1 (f32_convert_s @0)) -; CHECK-NEXT: (return @1) +; CHECK-LABEL: f32_convert_s_i64: +; CHECK-NEXT: .param i64 +; CHECK-NEXT: .result f32 +; CHECK-NEXT: @0{{$}} +; CHECK-NEXT: set_local @1, @pop{{$}} +; CHECK-NEXT: f32_convert_s @1{{$}} +; CHECK-NEXT: set_local @2, @pop{{$}} +; CHECK-NEXT: return @2{{$}} define float @f32_convert_s_i64(i64 %x) { %a = sitofp i64 %x to float ret float %a } -; CHECK-LABEL: $f32_convert_u_i64 -; CHECK-NEXT: (param i64) (result f32) -; CHECK-NEXT: (set_local @0 (argument 0)) -; CHECK-NEXT: (set_local @1 (f32_convert_u @0)) -; CHECK-NEXT: (return @1) +; CHECK-LABEL: f32_convert_u_i64: +; CHECK-NEXT: .param i64 +; CHECK-NEXT: .result f32 +; CHECK-NEXT: @0{{$}} +; CHECK-NEXT: set_local @1, @pop{{$}} +; CHECK-NEXT: f32_convert_u @1{{$}} +; CHECK-NEXT: set_local @2, @pop{{$}} +; CHECK-NEXT: return @2{{$}} define float @f32_convert_u_i64(i64 %x) { %a = uitofp i64 %x to float ret float %a } -; CHECK-LABEL: $f64_convert_s_i64 -; CHECK-NEXT: (param i64) (result f64) -; CHECK-NEXT: (set_local @0 (argument 0)) -; CHECK-NEXT: (set_local @1 (f64_convert_s @0)) -; CHECK-NEXT: (return @1) +; CHECK-LABEL: f64_convert_s_i64: +; CHECK-NEXT: .param i64 +; CHECK-NEXT: .result f64 +; CHECK-NEXT: @0{{$}} +; CHECK-NEXT: set_local @1, @pop{{$}} +; CHECK-NEXT: f64_convert_s @1{{$}} +; CHECK-NEXT: set_local @2, @pop{{$}} +; CHECK-NEXT: return @2{{$}} define double @f64_convert_s_i64(i64 %x) { %a = sitofp i64 %x to double ret double %a } -; CHECK-LABEL: $f64_convert_u_i64 -; CHECK-NEXT: (param i64) (result f64) -; CHECK-NEXT: (set_local @0 (argument 0)) -; CHECK-NEXT: (set_local @1 (f64_convert_u @0)) -; CHECK-NEXT: (return @1) +; CHECK-LABEL: f64_convert_u_i64: +; CHECK-NEXT: .param i64 +; CHECK-NEXT: .result f64 +; CHECK-NEXT: @0{{$}} +; CHECK-NEXT: set_local @1, @pop{{$}} +; CHECK-NEXT: f64_convert_u @1{{$}} +; CHECK-NEXT: set_local @2, @pop{{$}} +; CHECK-NEXT: return @2{{$}} define double @f64_convert_u_i64(i64 %x) { %a = uitofp i64 %x to double ret double %a } -; CHECK-LABEL: $f64_promote_f32 -; CHECK-NEXT: (param f32) (result f64) -; CHECK-NEXT: (set_local @0 (argument 0)) -; CHECK-NEXT: (set_local @1 (f64_promote @0)) -; CHECK-NEXT: (return @1) +; CHECK-LABEL: f64_promote_f32: +; CHECK-NEXT: .param f32 +; CHECK-NEXT: .result f64 +; CHECK-NEXT: @0{{$}} +; CHECK-NEXT: set_local @1, @pop{{$}} +; CHECK-NEXT: f64_promote @1{{$}} +; CHECK-NEXT: set_local @2, @pop{{$}} +; CHECK-NEXT: return @2{{$}} define double @f64_promote_f32(float %x) { %a = fpext float %x to double ret double %a } -; CHECK-LABEL: $f32_demote_f64 -; CHECK-NEXT: (param f64) (result f32) -; CHECK-NEXT: (set_local @0 (argument 0)) -; CHECK-NEXT: (set_local @1 (f32_demote @0)) -; CHECK-NEXT: (return @1) +; CHECK-LABEL: f32_demote_f64: +; CHECK-NEXT: .param f64 +; CHECK-NEXT: .result f32 +; CHECK-NEXT: @0{{$}} +; CHECK-NEXT: set_local @1, @pop{{$}} +; CHECK-NEXT: f32_demote @1{{$}} +; CHECK-NEXT: set_local @2, @pop{{$}} +; CHECK-NEXT: return @2{{$}} define float @f32_demote_f64(double %x) { %a = fptrunc double %x to float ret float %a Index: test/CodeGen/WebAssembly/f32.ll =================================================================== --- test/CodeGen/WebAssembly/f32.ll +++ test/CodeGen/WebAssembly/f32.ll @@ -14,96 +14,113 @@ 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: (set_local @0 (argument 1)) -; CHECK-NEXT: (set_local @1 (argument 0)) -; CHECK-NEXT: (set_local @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: @1{{$}} +; CHECK-NEXT: set_local @2, @pop{{$}} +; CHECK-NEXT: @0{{$}} +; CHECK-NEXT: set_local @3, @pop{{$}} +; CHECK-NEXT: fadd @3, @2{{$}} +; CHECK-NEXT: set_local @4, @pop{{$}} +; CHECK-NEXT: return @4{{$}} define float @fadd32(float %x, float %y) { %a = fadd float %x, %y ret float %a } -; CHECK-LABEL: (func $fsub32 -; CHECK: (set_local @2 (fsub @1 @0)) +; CHECK-LABEL: fsub32: +; CHECK: fsub @3, @2{{$}} +; CHECK-NEXT: set_local @4, @pop{{$}} define float @fsub32(float %x, float %y) { %a = fsub float %x, %y ret float %a } -; CHECK-LABEL: (func $fmul32 -; CHECK: (set_local @2 (fmul @1 @0)) +; CHECK-LABEL: fmul32: +; CHECK: fmul @3, @2{{$}} +; CHECK-NEXT: set_local @4, @pop{{$}} define float @fmul32(float %x, float %y) { %a = fmul float %x, %y ret float %a } -; CHECK-LABEL: (func $fdiv32 -; CHECK: (set_local @2 (fdiv @1 @0)) +; CHECK-LABEL: fdiv32: +; CHECK: fdiv @3, @2{{$}} +; CHECK-NEXT: set_local @4, @pop{{$}} define float @fdiv32(float %x, float %y) { %a = fdiv float %x, %y ret float %a } -; CHECK-LABEL: (func $fabs32 -; CHECK: (set_local @1 (fabs @0)) +; CHECK-LABEL: fabs32: +; CHECK: fabs @1{{$}} +; CHECK-NEXT: set_local @2, @pop{{$}} define float @fabs32(float %x) { %a = call float @llvm.fabs.f32(float %x) ret float %a } -; CHECK-LABEL: (func $fneg32 -; CHECK: (set_local @1 (fneg @0)) +; CHECK-LABEL: fneg32: +; CHECK: fneg @1{{$}} +; CHECK-NEXT: set_local @2, @pop{{$}} define float @fneg32(float %x) { %a = fsub float -0., %x ret float %a } -; CHECK-LABEL: (func $copysign32 -; CHECK: (set_local @2 (copysign @1 @0)) +; CHECK-LABEL: copysign32: +; CHECK: copysign @3, @2{{$}} +; CHECK-NEXT: set_local @4, @pop{{$}} 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: (set_local @1 (sqrt @0)) +; CHECK-LABEL: sqrt32: +; CHECK: sqrt @1{{$}} +; CHECK-NEXT: set_local @2, @pop{{$}} define float @sqrt32(float %x) { %a = call float @llvm.sqrt.f32(float %x) ret float %a } -; CHECK-LABEL: (func $ceil32 -; CHECK: (set_local @1 (ceil @0)) +; CHECK-LABEL: ceil32: +; CHECK: ceil @1{{$}} +; CHECK-NEXT: set_local @2, @pop{{$}} define float @ceil32(float %x) { %a = call float @llvm.ceil.f32(float %x) ret float %a } -; CHECK-LABEL: (func $floor32 -; CHECK: (set_local @1 (floor @0)) +; CHECK-LABEL: floor32: +; CHECK: floor @1{{$}} +; CHECK-NEXT: set_local @2, @pop{{$}} define float @floor32(float %x) { %a = call float @llvm.floor.f32(float %x) ret float %a } -; CHECK-LABEL: (func $trunc32 -; CHECK: (set_local @1 (trunc @0)) +; CHECK-LABEL: trunc32: +; CHECK: trunc @1{{$}} +; CHECK-NEXT: set_local @2, @pop{{$}} define float @trunc32(float %x) { %a = call float @llvm.trunc.f32(float %x) ret float %a } -; CHECK-LABEL: (func $nearest32 -; CHECK: (set_local @1 (nearest @0)) +; CHECK-LABEL: nearest32: +; CHECK: nearest @1{{$}} +; CHECK-NEXT: set_local @2, @pop{{$}} define float @nearest32(float %x) { %a = call float @llvm.nearbyint.f32(float %x) ret float %a } -; CHECK-LABEL: (func $nearest32_via_rint -; CHECK: (set_local @1 (nearest @0)) +; CHECK-LABEL: nearest32_via_rint: +; CHECK: nearest @1{{$}} +; CHECK-NEXT: set_local @2, @pop{{$}} define float @nearest32_via_rint(float %x) { %a = call float @llvm.rint.f32(float %x) ret float %a Index: test/CodeGen/WebAssembly/f64.ll =================================================================== --- test/CodeGen/WebAssembly/f64.ll +++ test/CodeGen/WebAssembly/f64.ll @@ -14,96 +14,113 @@ 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: (set_local @0 (argument 1)) -; CHECK-NEXT: (set_local @1 (argument 0)) -; CHECK-NEXT: (set_local @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: @1{{$}} +; CHECK-NEXT: set_local @2, @pop{{$}} +; CHECK-NEXT: @0{{$}} +; CHECK-NEXT: set_local @3, @pop{{$}} +; CHECK-NEXT: fadd @3, @2{{$}} +; CHECK-NEXT: set_local @4, @pop{{$}} +; CHECK-NEXT: return @4{{$}} define double @fadd64(double %x, double %y) { %a = fadd double %x, %y ret double %a } -; CHECK-LABEL: (func $fsub64 -; CHECK: (set_local @2 (fsub @1 @0)) +; CHECK-LABEL: fsub64: +; CHECK: fsub @3, @2{{$}} +; CHECK-NEXT: set_local @4, @pop{{$}} define double @fsub64(double %x, double %y) { %a = fsub double %x, %y ret double %a } -; CHECK-LABEL: (func $fmul64 -; CHECK: (set_local @2 (fmul @1 @0)) +; CHECK-LABEL: fmul64: +; CHECK: fmul @3, @2{{$}} +; CHECK-NEXT: set_local @4, @pop{{$}} define double @fmul64(double %x, double %y) { %a = fmul double %x, %y ret double %a } -; CHECK-LABEL: (func $fdiv64 -; CHECK: (set_local @2 (fdiv @1 @0)) +; CHECK-LABEL: fdiv64: +; CHECK: fdiv @3, @2{{$}} +; CHECK-NEXT: set_local @4, @pop{{$}} define double @fdiv64(double %x, double %y) { %a = fdiv double %x, %y ret double %a } -; CHECK-LABEL: (func $fabs64 -; CHECK: (set_local @1 (fabs @0)) +; CHECK-LABEL: fabs64: +; CHECK: fabs @1{{$}} +; CHECK-NEXT: set_local @2, @pop{{$}} define double @fabs64(double %x) { %a = call double @llvm.fabs.f64(double %x) ret double %a } -; CHECK-LABEL: (func $fneg64 -; CHECK: (set_local @1 (fneg @0)) +; CHECK-LABEL: fneg64: +; CHECK: fneg @1{{$}} +; CHECK-NEXT: set_local @2, @pop{{$}} define double @fneg64(double %x) { %a = fsub double -0., %x ret double %a } -; CHECK-LABEL: (func $copysign64 -; CHECK: (set_local @2 (copysign @1 @0)) +; CHECK-LABEL: copysign64: +; CHECK: copysign @3, @2{{$}} +; CHECK-NEXT: set_local @4, @pop{{$}} 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: (set_local @1 (sqrt @0)) +; CHECK-LABEL: sqrt64: +; CHECK: sqrt @1{{$}} +; CHECK-NEXT: set_local @2, @pop{{$}} define double @sqrt64(double %x) { %a = call double @llvm.sqrt.f64(double %x) ret double %a } -; CHECK-LABEL: (func $ceil64 -; CHECK: (set_local @1 (ceil @0)) +; CHECK-LABEL: ceil64: +; CHECK: ceil @1{{$}} +; CHECK-NEXT: set_local @2, @pop{{$}} define double @ceil64(double %x) { %a = call double @llvm.ceil.f64(double %x) ret double %a } -; CHECK-LABEL: (func $floor64 -; CHECK: (set_local @1 (floor @0)) +; CHECK-LABEL: floor64: +; CHECK: floor @1{{$}} +; CHECK-NEXT: set_local @2, @pop{{$}} define double @floor64(double %x) { %a = call double @llvm.floor.f64(double %x) ret double %a } -; CHECK-LABEL: (func $trunc64 -; CHECK: (set_local @1 (trunc @0)) +; CHECK-LABEL: trunc64: +; CHECK: trunc @1{{$}} +; CHECK-NEXT: set_local @2, @pop{{$}} define double @trunc64(double %x) { %a = call double @llvm.trunc.f64(double %x) ret double %a } -; CHECK-LABEL: (func $nearest64 -; CHECK: (set_local @1 (nearest @0)) +; CHECK-LABEL: nearest64: +; CHECK: nearest @1{{$}} +; CHECK-NEXT: set_local @2, @pop{{$}} define double @nearest64(double %x) { %a = call double @llvm.nearbyint.f64(double %x) ret double %a } -; CHECK-LABEL: (func $nearest64_via_rint -; CHECK: (set_local @1 (nearest @0)) +; CHECK-LABEL: nearest64_via_rint: +; CHECK: nearest @1{{$}} +; CHECK-NEXT: set_local @2, @pop{{$}} define double @nearest64_via_rint(double %x) { %a = call double @llvm.rint.f64(double %x) ret double %a Index: test/CodeGen/WebAssembly/fast-isel.ll =================================================================== --- test/CodeGen/WebAssembly/fast-isel.ll +++ test/CodeGen/WebAssembly/fast-isel.ll @@ -7,14 +7,14 @@ ; This tests very minimal fast-isel functionality. -; CHECK-LABEL: (func $immediate_f32 -; CHECK: (immediate 0x1.4p1) +; CHECK-LABEL: immediate_f32: +; CHECK: f32.const 0x1.4p1{{$}} define float @immediate_f32() { ret float 2.5 } -; CHECK-LABEL: (func $immediate_f64 -; CHECK: (immediate 0x1.4p1) +; CHECK-LABEL: immediate_f64: +; CHECK: f64.const 0x1.4p1{{$}} define double @immediate_f64() { ret double 2.5 } Index: test/CodeGen/WebAssembly/func.ll =================================================================== --- test/CodeGen/WebAssembly/func.ll +++ test/CodeGen/WebAssembly/func.ll @@ -5,35 +5,40 @@ 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: (set_local @0 (immediate 0)){{$}} -; CHECK-NEXT: (return @0){{$}} -; CHECK-NEXT: ) ;; end func $f1{{$}} +; CHECK-LABEL: f1: +; CHECK-NEXT: .result i32{{$}} +; CHECK-NEXT: i32.const 0{{$}} +; CHECK-NEXT: set_local @0, @pop{{$}} +; 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: (set_local @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: i32.const 0{{$}} +; CHECK-NEXT: set_local @2, @pop{{$}} +; CHECK-NEXT: return @2{{$}} +; 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 } Index: test/CodeGen/WebAssembly/global.ll =================================================================== --- test/CodeGen/WebAssembly/global.ll +++ test/CodeGen/WebAssembly/global.ll @@ -9,29 +9,130 @@ ; 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 Index: test/CodeGen/WebAssembly/globl.ll =================================================================== --- test/CodeGen/WebAssembly/globl.ll +++ test/CodeGen/WebAssembly/globl.ll @@ -1,14 +1,10 @@ ; 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 } Index: test/CodeGen/WebAssembly/i32.ll =================================================================== --- test/CodeGen/WebAssembly/i32.ll +++ test/CodeGen/WebAssembly/i32.ll @@ -9,194 +9,274 @@ 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: (set_local @0 (argument 1)) -; CHECK-NEXT: (set_local @1 (argument 0)) -; CHECK-NEXT: (set_local @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: @1{{$}} +; CHECK-NEXT: set_local @2, @pop{{$}} +; CHECK-NEXT: @0{{$}} +; CHECK-NEXT: set_local @3, @pop{{$}} +; CHECK-NEXT: add @3, @2{{$}} +; CHECK-NEXT: set_local @4, @pop{{$}} +; CHECK-NEXT: return @4{{$}} 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: (set_local @0 (argument 1)) -; CHECK-NEXT: (set_local @1 (argument 0)) -; CHECK-NEXT: (set_local @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: @1{{$}} +; CHECK-NEXT: set_local @2, @pop{{$}} +; CHECK-NEXT: @0{{$}} +; CHECK-NEXT: set_local @3, @pop{{$}} +; CHECK-NEXT: sub @3, @2{{$}} +; CHECK-NEXT: set_local @4, @pop{{$}} +; CHECK-NEXT: return @4{{$}} 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: (set_local @0 (argument 1)) -; CHECK-NEXT: (set_local @1 (argument 0)) -; CHECK-NEXT: (set_local @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: @1{{$}} +; CHECK-NEXT: set_local @2, @pop{{$}} +; CHECK-NEXT: @0{{$}} +; CHECK-NEXT: set_local @3, @pop{{$}} +; CHECK-NEXT: mul @3, @2{{$}} +; CHECK-NEXT: set_local @4, @pop{{$}} +; CHECK-NEXT: return @4{{$}} 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: (set_local @0 (argument 1)) -; CHECK-NEXT: (set_local @1 (argument 0)) -; CHECK-NEXT: (set_local @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: @1{{$}} +; CHECK-NEXT: set_local @2, @pop{{$}} +; CHECK-NEXT: @0{{$}} +; CHECK-NEXT: set_local @3, @pop{{$}} +; CHECK-NEXT: sdiv @3, @2{{$}} +; CHECK-NEXT: set_local @4, @pop{{$}} +; CHECK-NEXT: return @4{{$}} 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: (set_local @0 (argument 1)) -; CHECK-NEXT: (set_local @1 (argument 0)) -; CHECK-NEXT: (set_local @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: @1{{$}} +; CHECK-NEXT: set_local @2, @pop{{$}} +; CHECK-NEXT: @0{{$}} +; CHECK-NEXT: set_local @3, @pop{{$}} +; CHECK-NEXT: udiv @3, @2{{$}} +; CHECK-NEXT: set_local @4, @pop{{$}} +; CHECK-NEXT: return @4{{$}} 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: (set_local @0 (argument 1)) -; CHECK-NEXT: (set_local @1 (argument 0)) -; CHECK-NEXT: (set_local @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: @1{{$}} +; CHECK-NEXT: set_local @2, @pop{{$}} +; CHECK-NEXT: @0{{$}} +; CHECK-NEXT: set_local @3, @pop{{$}} +; CHECK-NEXT: srem @3, @2{{$}} +; CHECK-NEXT: set_local @4, @pop{{$}} +; CHECK-NEXT: return @4{{$}} 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: (set_local @0 (argument 1)) -; CHECK-NEXT: (set_local @1 (argument 0)) -; CHECK-NEXT: (set_local @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: @1{{$}} +; CHECK-NEXT: set_local @2, @pop{{$}} +; CHECK-NEXT: @0{{$}} +; CHECK-NEXT: set_local @3, @pop{{$}} +; CHECK-NEXT: urem @3, @2{{$}} +; CHECK-NEXT: set_local @4, @pop{{$}} +; CHECK-NEXT: return @4{{$}} 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: (set_local @0 (argument 1)) -; CHECK-NEXT: (set_local @1 (argument 0)) -; CHECK-NEXT: (set_local @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: @1{{$}} +; CHECK-NEXT: set_local @2, @pop{{$}} +; CHECK-NEXT: @0{{$}} +; CHECK-NEXT: set_local @3, @pop{{$}} +; CHECK-NEXT: and @3, @2{{$}} +; CHECK-NEXT: set_local @4, @pop{{$}} +; CHECK-NEXT: return @4{{$}} 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: (set_local @0 (argument 1)) -; CHECK-NEXT: (set_local @1 (argument 0)) -; CHECK-NEXT: (set_local @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: @1{{$}} +; CHECK-NEXT: set_local @2, @pop{{$}} +; CHECK-NEXT: @0{{$}} +; CHECK-NEXT: set_local @3, @pop{{$}} +; CHECK-NEXT: ior @3, @2{{$}} +; CHECK-NEXT: set_local @4, @pop{{$}} +; CHECK-NEXT: return @4{{$}} 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: (set_local @0 (argument 1)) -; CHECK-NEXT: (set_local @1 (argument 0)) -; CHECK-NEXT: (set_local @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: @1{{$}} +; CHECK-NEXT: set_local @2, @pop{{$}} +; CHECK-NEXT: @0{{$}} +; CHECK-NEXT: set_local @3, @pop{{$}} +; CHECK-NEXT: xor @3, @2{{$}} +; CHECK-NEXT: set_local @4, @pop{{$}} +; CHECK-NEXT: return @4{{$}} 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: (set_local @0 (argument 1)) -; CHECK-NEXT: (set_local @1 (argument 0)) -; CHECK-NEXT: (set_local @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: @1{{$}} +; CHECK-NEXT: set_local @2, @pop{{$}} +; CHECK-NEXT: @0{{$}} +; CHECK-NEXT: set_local @3, @pop{{$}} +; CHECK-NEXT: shl @3, @2{{$}} +; CHECK-NEXT: set_local @4, @pop{{$}} +; CHECK-NEXT: return @4{{$}} 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: (set_local @0 (argument 1)) -; CHECK-NEXT: (set_local @1 (argument 0)) -; CHECK-NEXT: (set_local @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: @1{{$}} +; CHECK-NEXT: set_local @2, @pop{{$}} +; CHECK-NEXT: @0{{$}} +; CHECK-NEXT: set_local @3, @pop{{$}} +; CHECK-NEXT: shr_u @3, @2{{$}} +; CHECK-NEXT: set_local @4, @pop{{$}} +; CHECK-NEXT: return @4{{$}} 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: (set_local @0 (argument 1)) -; CHECK-NEXT: (set_local @1 (argument 0)) -; CHECK-NEXT: (set_local @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: @1{{$}} +; CHECK-NEXT: set_local @2, @pop{{$}} +; CHECK-NEXT: @0{{$}} +; CHECK-NEXT: set_local @3, @pop{{$}} +; CHECK-NEXT: shr_s @3, @2{{$}} +; CHECK-NEXT: set_local @4, @pop{{$}} +; CHECK-NEXT: return @4{{$}} 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: (set_local @0 (argument 0)) -; CHECK-NEXT: (set_local @1 (clz @0)) -; CHECK-NEXT: (return @1) +; CHECK-LABEL: clz32: +; CHECK-NEXT: .param i32{{$}} +; CHECK-NEXT: .result i32{{$}} +; CHECK-NEXT: @0{{$}} +; CHECK-NEXT: set_local @1, @pop{{$}} +; CHECK-NEXT: clz @1{{$}} +; CHECK-NEXT: set_local @2, @pop{{$}} +; CHECK-NEXT: return @2{{$}} 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: (set_local @0 (argument 0)) -; CHECK-NEXT: (set_local @1 (clz @0)) -; CHECK-NEXT: (return @1) +; CHECK-LABEL: clz32_zero_undef: +; CHECK-NEXT: .param i32{{$}} +; CHECK-NEXT: .result i32{{$}} +; CHECK-NEXT: @0{{$}} +; CHECK-NEXT: set_local @1, @pop{{$}} +; CHECK-NEXT: clz @1{{$}} +; CHECK-NEXT: set_local @2, @pop{{$}} +; CHECK-NEXT: return @2{{$}} 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: (set_local @0 (argument 0)) -; CHECK-NEXT: (set_local @1 (ctz @0)) -; CHECK-NEXT: (return @1) +; CHECK-LABEL: ctz32: +; CHECK-NEXT: .param i32{{$}} +; CHECK-NEXT: .result i32{{$}} +; CHECK-NEXT: @0{{$}} +; CHECK-NEXT: set_local @1, @pop{{$}} +; CHECK-NEXT: ctz @1{{$}} +; CHECK-NEXT: set_local @2, @pop{{$}} +; CHECK-NEXT: return @2{{$}} 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: (set_local @0 (argument 0)) -; CHECK-NEXT: (set_local @1 (ctz @0)) -; CHECK-NEXT: (return @1) +; CHECK-LABEL: ctz32_zero_undef: +; CHECK-NEXT: .param i32{{$}} +; CHECK-NEXT: .result i32{{$}} +; CHECK-NEXT: @0{{$}} +; CHECK-NEXT: set_local @1, @pop{{$}} +; CHECK-NEXT: ctz @1{{$}} +; CHECK-NEXT: set_local @2, @pop{{$}} +; CHECK-NEXT: return @2{{$}} 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: (set_local @0 (argument 0)) -; CHECK-NEXT: (set_local @1 (popcnt @0)) -; CHECK-NEXT: (return @1) +; CHECK-LABEL: popcnt32: +; CHECK-NEXT: .param i32{{$}} +; CHECK-NEXT: .result i32{{$}} +; CHECK-NEXT: @0{{$}} +; CHECK-NEXT: set_local @1, @pop{{$}} +; CHECK-NEXT: popcnt @1{{$}} +; CHECK-NEXT: set_local @2, @pop{{$}} +; CHECK-NEXT: return @2{{$}} define i32 @popcnt32(i32 %x) { %a = call i32 @llvm.ctpop.i32(i32 %x) ret i32 %a Index: test/CodeGen/WebAssembly/i64.ll =================================================================== --- test/CodeGen/WebAssembly/i64.ll +++ test/CodeGen/WebAssembly/i64.ll @@ -9,194 +9,274 @@ 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: (set_local @0 (argument 1)) -; CHECK-NEXT: (set_local @1 (argument 0)) -; CHECK-NEXT: (set_local @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: @1{{$}} +; CHECK-NEXT: set_local @2, @pop{{$}} +; CHECK-NEXT: @0{{$}} +; CHECK-NEXT: set_local @3, @pop{{$}} +; CHECK-NEXT: add @3, @2{{$}} +; CHECK-NEXT: set_local @4, @pop{{$}} +; CHECK-NEXT: return @4{{$}} 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: (set_local @0 (argument 1)) -; CHECK-NEXT: (set_local @1 (argument 0)) -; CHECK-NEXT: (set_local @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: @1{{$}} +; CHECK-NEXT: set_local @2, @pop{{$}} +; CHECK-NEXT: @0{{$}} +; CHECK-NEXT: set_local @3, @pop{{$}} +; CHECK-NEXT: sub @3, @2{{$}} +; CHECK-NEXT: set_local @4, @pop{{$}} +; CHECK-NEXT: return @4{{$}} 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: (set_local @0 (argument 1)) -; CHECK-NEXT: (set_local @1 (argument 0)) -; CHECK-NEXT: (set_local @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: @1{{$}} +; CHECK-NEXT: set_local @2, @pop{{$}} +; CHECK-NEXT: @0{{$}} +; CHECK-NEXT: set_local @3, @pop{{$}} +; CHECK-NEXT: mul @3, @2{{$}} +; CHECK-NEXT: set_local @4, @pop{{$}} +; CHECK-NEXT: return @4{{$}} 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: (set_local @0 (argument 1)) -; CHECK-NEXT: (set_local @1 (argument 0)) -; CHECK-NEXT: (set_local @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: @1{{$}} +; CHECK-NEXT: set_local @2, @pop{{$}} +; CHECK-NEXT: @0{{$}} +; CHECK-NEXT: set_local @3, @pop{{$}} +; CHECK-NEXT: sdiv @3, @2{{$}} +; CHECK-NEXT: set_local @4, @pop{{$}} +; CHECK-NEXT: return @4{{$}} 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: (set_local @0 (argument 1)) -; CHECK-NEXT: (set_local @1 (argument 0)) -; CHECK-NEXT: (set_local @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: @1{{$}} +; CHECK-NEXT: set_local @2, @pop{{$}} +; CHECK-NEXT: @0{{$}} +; CHECK-NEXT: set_local @3, @pop{{$}} +; CHECK-NEXT: udiv @3, @2{{$}} +; CHECK-NEXT: set_local @4, @pop{{$}} +; CHECK-NEXT: return @4{{$}} 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: (set_local @0 (argument 1)) -; CHECK-NEXT: (set_local @1 (argument 0)) -; CHECK-NEXT: (set_local @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: @1{{$}} +; CHECK-NEXT: set_local @2, @pop{{$}} +; CHECK-NEXT: @0{{$}} +; CHECK-NEXT: set_local @3, @pop{{$}} +; CHECK-NEXT: srem @3, @2{{$}} +; CHECK-NEXT: set_local @4, @pop{{$}} +; CHECK-NEXT: return @4{{$}} 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: (set_local @0 (argument 1)) -; CHECK-NEXT: (set_local @1 (argument 0)) -; CHECK-NEXT: (set_local @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: @1{{$}} +; CHECK-NEXT: set_local @2, @pop{{$}} +; CHECK-NEXT: @0{{$}} +; CHECK-NEXT: set_local @3, @pop{{$}} +; CHECK-NEXT: urem @3, @2{{$}} +; CHECK-NEXT: set_local @4, @pop{{$}} +; CHECK-NEXT: return @4{{$}} 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: (set_local @0 (argument 1)) -; CHECK-NEXT: (set_local @1 (argument 0)) -; CHECK-NEXT: (set_local @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: @1{{$}} +; CHECK-NEXT: set_local @2, @pop{{$}} +; CHECK-NEXT: @0{{$}} +; CHECK-NEXT: set_local @3, @pop{{$}} +; CHECK-NEXT: and @3, @2{{$}} +; CHECK-NEXT: set_local @4, @pop{{$}} +; CHECK-NEXT: return @4{{$}} 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: (set_local @0 (argument 1)) -; CHECK-NEXT: (set_local @1 (argument 0)) -; CHECK-NEXT: (set_local @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: @1{{$}} +; CHECK-NEXT: set_local @2, @pop{{$}} +; CHECK-NEXT: @0{{$}} +; CHECK-NEXT: set_local @3, @pop{{$}} +; CHECK-NEXT: ior @3, @2{{$}} +; CHECK-NEXT: set_local @4, @pop{{$}} +; CHECK-NEXT: return @4{{$}} 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: (set_local @0 (argument 1)) -; CHECK-NEXT: (set_local @1 (argument 0)) -; CHECK-NEXT: (set_local @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: @1{{$}} +; CHECK-NEXT: set_local @2, @pop{{$}} +; CHECK-NEXT: @0{{$}} +; CHECK-NEXT: set_local @3, @pop{{$}} +; CHECK-NEXT: xor @3, @2{{$}} +; CHECK-NEXT: set_local @4, @pop{{$}} +; CHECK-NEXT: return @4{{$}} 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: (set_local @0 (argument 1)) -; CHECK-NEXT: (set_local @1 (argument 0)) -; CHECK-NEXT: (set_local @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: @1{{$}} +; CHECK-NEXT: set_local @2, @pop{{$}} +; CHECK-NEXT: @0{{$}} +; CHECK-NEXT: set_local @3, @pop{{$}} +; CHECK-NEXT: shl @3, @2{{$}} +; CHECK-NEXT: set_local @4, @pop{{$}} +; CHECK-NEXT: return @4{{$}} 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: (set_local @0 (argument 1)) -; CHECK-NEXT: (set_local @1 (argument 0)) -; CHECK-NEXT: (set_local @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: @1{{$}} +; CHECK-NEXT: set_local @2, @pop{{$}} +; CHECK-NEXT: @0{{$}} +; CHECK-NEXT: set_local @3, @pop{{$}} +; CHECK-NEXT: shr_u @3, @2{{$}} +; CHECK-NEXT: set_local @4, @pop{{$}} +; CHECK-NEXT: return @4{{$}} 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: (set_local @0 (argument 1)) -; CHECK-NEXT: (set_local @1 (argument 0)) -; CHECK-NEXT: (set_local @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: @1{{$}} +; CHECK-NEXT: set_local @2, @pop{{$}} +; CHECK-NEXT: @0{{$}} +; CHECK-NEXT: set_local @3, @pop{{$}} +; CHECK-NEXT: shr_s @3, @2{{$}} +; CHECK-NEXT: set_local @4, @pop{{$}} +; CHECK-NEXT: return @4{{$}} 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: (set_local @0 (argument 0)) -; CHECK-NEXT: (set_local @1 (clz @0)) -; CHECK-NEXT: (return @1) +; CHECK-LABEL: clz64: +; CHECK-NEXT: .param i64{{$}} +; CHECK-NEXT: .result i64{{$}} +; CHECK-NEXT: @0{{$}} +; CHECK-NEXT: set_local @1, @pop{{$}} +; CHECK-NEXT: clz @1{{$}} +; CHECK-NEXT: set_local @2, @pop{{$}} +; CHECK-NEXT: return @2{{$}} 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: (set_local @0 (argument 0)) -; CHECK-NEXT: (set_local @1 (clz @0)) -; CHECK-NEXT: (return @1) +; CHECK-LABEL: clz64_zero_undef: +; CHECK-NEXT: .param i64{{$}} +; CHECK-NEXT: .result i64{{$}} +; CHECK-NEXT: @0{{$}} +; CHECK-NEXT: set_local @1, @pop{{$}} +; CHECK-NEXT: clz @1{{$}} +; CHECK-NEXT: set_local @2, @pop{{$}} +; CHECK-NEXT: return @2{{$}} 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: (set_local @0 (argument 0)) -; CHECK-NEXT: (set_local @1 (ctz @0)) -; CHECK-NEXT: (return @1) +; CHECK-LABEL: ctz64: +; CHECK-NEXT: .param i64{{$}} +; CHECK-NEXT: .result i64{{$}} +; CHECK-NEXT: @0{{$}} +; CHECK-NEXT: set_local @1, @pop{{$}} +; CHECK-NEXT: ctz @1{{$}} +; CHECK-NEXT: set_local @2, @pop{{$}} +; CHECK-NEXT: return @2{{$}} 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: (set_local @0 (argument 0)) -; CHECK-NEXT: (set_local @1 (ctz @0)) -; CHECK-NEXT: (return @1) +; CHECK-LABEL: ctz64_zero_undef: +; CHECK-NEXT: .param i64{{$}} +; CHECK-NEXT: .result i64{{$}} +; CHECK-NEXT: @0{{$}} +; CHECK-NEXT: set_local @1, @pop{{$}} +; CHECK-NEXT: ctz @1{{$}} +; CHECK-NEXT: set_local @2, @pop{{$}} +; CHECK-NEXT: return @2{{$}} 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: (set_local @0 (argument 0)) -; CHECK-NEXT: (set_local @1 (popcnt @0)) -; CHECK-NEXT: (return @1) +; CHECK-LABEL: popcnt64: +; CHECK-NEXT: .param i64{{$}} +; CHECK-NEXT: .result i64{{$}} +; CHECK-NEXT: @0{{$}} +; CHECK-NEXT: set_local @1, @pop{{$}} +; CHECK-NEXT: popcnt @1{{$}} +; CHECK-NEXT: set_local @2, @pop{{$}} +; CHECK-NEXT: return @2{{$}} define i64 @popcnt64(i64 %x) { %a = call i64 @llvm.ctpop.i64(i64 %x) ret i64 %a Index: test/CodeGen/WebAssembly/immediates.ll =================================================================== --- test/CodeGen/WebAssembly/immediates.ll +++ test/CodeGen/WebAssembly/immediates.ll @@ -5,194 +5,218 @@ 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: (set_local @0 (immediate 0)) -; CHECK-NEXT: (return @0) +; CHECK-LABEL: zero_i32: +; CHECK-NEXT: .result i32{{$}} +; CHECK-NEXT: i32.const 0{{$}} +; CHECK-NEXT: set_local @0, @pop{{$}} +; CHECK-NEXT: return @0{{$}} define i32 @zero_i32() { ret i32 0 } -; CHECK-LABEL: (func $one_i32 -; CHECK-NEXT: (result i32) -; CHECK-NEXT: (set_local @0 (immediate 1)) -; CHECK-NEXT: (return @0) +; CHECK-LABEL: one_i32: +; CHECK-NEXT: .result i32{{$}} +; CHECK-NEXT: i32.const 1{{$}} +; CHECK-NEXT: set_local @0, @pop{{$}} +; CHECK-NEXT: return @0{{$}} define i32 @one_i32() { ret i32 1 } -; CHECK-LABEL: (func $max_i32 -; CHECK-NEXT: (result i32) -; CHECK-NEXT: (set_local @0 (immediate 2147483647)) -; CHECK-NEXT: (return @0) +; CHECK-LABEL: max_i32: +; CHECK-NEXT: .result i32{{$}} +; CHECK-NEXT: i32.const 2147483647{{$}} +; CHECK-NEXT: set_local @0, @pop{{$}} +; CHECK-NEXT: return @0{{$}} define i32 @max_i32() { ret i32 2147483647 } -; CHECK-LABEL: (func $min_i32 -; CHECK-NEXT: (result i32) -; CHECK-NEXT: (set_local @0 (immediate -2147483648)) -; CHECK-NEXT: (return @0) +; CHECK-LABEL: min_i32: +; CHECK-NEXT: .result i32{{$}} +; CHECK-NEXT: i32.const -2147483648{{$}} +; CHECK-NEXT: set_local @0, @pop{{$}} +; CHECK-NEXT: return @0{{$}} define i32 @min_i32() { ret i32 -2147483648 } -; CHECK-LABEL: (func $zero_i64 -; CHECK-NEXT: (result i64) -; CHECK-NEXT: (set_local @0 (immediate 0)) -; CHECK-NEXT: (return @0) +; CHECK-LABEL: zero_i64: +; CHECK-NEXT: .result i64{{$}} +; CHECK-NEXT: i64.const 0{{$}} +; CHECK-NEXT: set_local @0, @pop{{$}} +; CHECK-NEXT: return @0{{$}} define i64 @zero_i64() { ret i64 0 } -; CHECK-LABEL: (func $one_i64 -; CHECK-NEXT: (result i64) -; CHECK-NEXT: (set_local @0 (immediate 1)) -; CHECK-NEXT: (return @0) +; CHECK-LABEL: one_i64: +; CHECK-NEXT: .result i64{{$}} +; CHECK-NEXT: i64.const 1{{$}} +; CHECK-NEXT: set_local @0, @pop{{$}} +; CHECK-NEXT: return @0{{$}} define i64 @one_i64() { ret i64 1 } -; CHECK-LABEL: (func $max_i64 -; CHECK-NEXT: (result i64) -; CHECK-NEXT: (set_local @0 (immediate 9223372036854775807)) -; CHECK-NEXT: (return @0) +; CHECK-LABEL: max_i64: +; CHECK-NEXT: .result i64{{$}} +; CHECK-NEXT: i64.const 9223372036854775807{{$}} +; CHECK-NEXT: set_local @0, @pop{{$}} +; CHECK-NEXT: return @0{{$}} define i64 @max_i64() { ret i64 9223372036854775807 } -; CHECK-LABEL: (func $min_i64 -; CHECK-NEXT: (result i64) -; CHECK-NEXT: (set_local @0 (immediate -9223372036854775808)) -; CHECK-NEXT: (return @0) +; CHECK-LABEL: min_i64: +; CHECK-NEXT: .result i64{{$}} +; CHECK-NEXT: i64.const -9223372036854775808{{$}} +; CHECK-NEXT: set_local @0, @pop{{$}} +; CHECK-NEXT: return @0{{$}} define i64 @min_i64() { ret i64 -9223372036854775808 } -; CHECK-LABEL: (func $negzero_f32 -; CHECK-NEXT: (result f32) -; CHECK-NEXT: (set_local @0 (immediate -0x0p0)) -; CHECK-NEXT: (return @0) +; CHECK-LABEL: negzero_f32: +; CHECK-NEXT: .result f32{{$}} +; CHECK-NEXT: f32.const -0x0p0{{$}} +; CHECK-NEXT: set_local @0, @pop{{$}} +; CHECK-NEXT: return @0{{$}} define float @negzero_f32() { ret float -0.0 } -; CHECK-LABEL: (func $zero_f32 -; CHECK-NEXT: (result f32) -; CHECK-NEXT: (set_local @0 (immediate 0x0p0)) -; CHECK-NEXT: (return @0) +; CHECK-LABEL: zero_f32: +; CHECK-NEXT: .result f32{{$}} +; CHECK-NEXT: f32.const 0x0p0{{$}} +; CHECK-NEXT: set_local @0, @pop{{$}} +; CHECK-NEXT: return @0{{$}} define float @zero_f32() { ret float 0.0 } -; CHECK-LABEL: (func $one_f32 -; CHECK-NEXT: (result f32) -; CHECK-NEXT: (set_local @0 (immediate 0x1p0)) -; CHECK-NEXT: (return @0) +; CHECK-LABEL: one_f32: +; CHECK-NEXT: .result f32{{$}} +; CHECK-NEXT: f32.const 0x1p0{{$}} +; CHECK-NEXT: set_local @0, @pop{{$}} +; CHECK-NEXT: return @0{{$}} define float @one_f32() { ret float 1.0 } -; CHECK-LABEL: (func $two_f32 -; CHECK-NEXT: (result f32) -; CHECK-NEXT: (set_local @0 (immediate 0x1p1)) -; CHECK-NEXT: (return @0) +; CHECK-LABEL: two_f32: +; CHECK-NEXT: .result f32{{$}} +; CHECK-NEXT: f32.const 0x1p1{{$}} +; CHECK-NEXT: set_local @0, @pop{{$}} +; CHECK-NEXT: return @0{{$}} define float @two_f32() { ret float 2.0 } -; CHECK-LABEL: (func $nan_f32 -; CHECK-NEXT: (result f32) -; CHECK-NEXT: (set_local @0 (immediate nan)) -; CHECK-NEXT: (return @0) +; CHECK-LABEL: nan_f32: +; CHECK-NEXT: .result f32{{$}} +; CHECK-NEXT: f32.const nan +; CHECK-NEXT: set_local @0, @pop{{$}} +; CHECK-NEXT: return @0{{$}} define float @nan_f32() { ret float 0x7FF8000000000000 } -; CHECK-LABEL: (func $negnan_f32 -; CHECK-NEXT: (result f32) -; CHECK-NEXT: (set_local @0 (immediate -nan)) -; CHECK-NEXT: (return @0) +; CHECK-LABEL: negnan_f32: +; CHECK-NEXT: .result f32{{$}} +; CHECK-NEXT: f32.const -nan +; CHECK-NEXT: set_local @0, @pop{{$}} +; CHECK-NEXT: return @0{{$}} define float @negnan_f32() { ret float 0xFFF8000000000000 } -; CHECK-LABEL: (func $inf_f32 -; CHECK-NEXT: (result f32) -; CHECK-NEXT: (set_local @0 (immediate infinity)) -; CHECK-NEXT: (return @0) +; CHECK-LABEL: inf_f32: +; CHECK-NEXT: .result f32{{$}} +; CHECK-NEXT: f32.const infinity +; CHECK-NEXT: set_local @0, @pop{{$}} +; CHECK-NEXT: return @0{{$}} define float @inf_f32() { ret float 0x7FF0000000000000 } -; CHECK-LABEL: (func $neginf_f32 -; CHECK-NEXT: (result f32) -; CHECK-NEXT: (set_local @0 (immediate -infinity)) -; CHECK-NEXT: (return @0) +; CHECK-LABEL: neginf_f32: +; CHECK-NEXT: .result f32{{$}} +; CHECK-NEXT: f32.const -infinity +; CHECK-NEXT: set_local @0, @pop{{$}} +; CHECK-NEXT: return @0{{$}} define float @neginf_f32() { ret float 0xFFF0000000000000 } -; CHECK-LABEL: (func $negzero_f64 -; CHECK-NEXT: (result f64) -; CHECK-NEXT: (set_local @0 (immediate -0x0p0)) -; CHECK-NEXT: (return @0) +; CHECK-LABEL: negzero_f64: +; CHECK-NEXT: .result f64{{$}} +; CHECK-NEXT: f64.const -0x0p0{{$}} +; CHECK-NEXT: set_local @0, @pop{{$}} +; CHECK-NEXT: return @0{{$}} define double @negzero_f64() { ret double -0.0 } -; CHECK-LABEL: (func $zero_f64 -; CHECK-NEXT: (result f64) -; CHECK-NEXT: (set_local @0 (immediate 0x0p0)) -; CHECK-NEXT: (return @0) +; CHECK-LABEL: zero_f64: +; CHECK-NEXT: .result f64{{$}} +; CHECK-NEXT: f64.const 0x0p0{{$}} +; CHECK-NEXT: set_local @0, @pop{{$}} +; CHECK-NEXT: return @0{{$}} define double @zero_f64() { ret double 0.0 } -; CHECK-LABEL: (func $one_f64 -; CHECK-NEXT: (result f64) -; CHECK-NEXT: (set_local @0 (immediate 0x1p0)) -; CHECK-NEXT: (return @0) +; CHECK-LABEL: one_f64: +; CHECK-NEXT: .result f64{{$}} +; CHECK-NEXT: f64.const 0x1p0{{$}} +; CHECK-NEXT: set_local @0, @pop{{$}} +; CHECK-NEXT: return @0{{$}} define double @one_f64() { ret double 1.0 } -; CHECK-LABEL: (func $two_f64 -; CHECK-NEXT: (result f64) -; CHECK-NEXT: (set_local @0 (immediate 0x1p1)) -; CHECK-NEXT: (return @0) +; CHECK-LABEL: two_f64: +; CHECK-NEXT: .result f64{{$}} +; CHECK-NEXT: f64.const 0x1p1{{$}} +; CHECK-NEXT: set_local @0, @pop{{$}} +; CHECK-NEXT: return @0{{$}} define double @two_f64() { ret double 2.0 } -; CHECK-LABEL: (func $nan_f64 -; CHECK-NEXT: (result f64) -; CHECK-NEXT: (set_local @0 (immediate nan)) -; CHECK-NEXT: (return @0) +; CHECK-LABEL: nan_f64: +; CHECK-NEXT: .result f64{{$}} +; CHECK-NEXT: f64.const nan +; CHECK-NEXT: set_local @0, @pop{{$}} +; CHECK-NEXT: return @0{{$}} define double @nan_f64() { ret double 0x7FF8000000000000 } -; CHECK-LABEL: (func $negnan_f64 -; CHECK-NEXT: (result f64) -; CHECK-NEXT: (set_local @0 (immediate -nan)) -; CHECK-NEXT: (return @0) +; CHECK-LABEL: negnan_f64: +; CHECK-NEXT: .result f64{{$}} +; CHECK-NEXT: f64.const -nan +; CHECK-NEXT: set_local @0, @pop{{$}} +; CHECK-NEXT: return @0{{$}} define double @negnan_f64() { ret double 0xFFF8000000000000 } -; CHECK-LABEL: (func $inf_f64 -; CHECK-NEXT: (result f64) -; CHECK-NEXT: (set_local @0 (immediate infinity)) -; CHECK-NEXT: (return @0) +; CHECK-LABEL: inf_f64: +; CHECK-NEXT: .result f64{{$}} +; CHECK-NEXT: f64.const infinity +; CHECK-NEXT: set_local @0, @pop{{$}} +; CHECK-NEXT: return @0{{$}} define double @inf_f64() { ret double 0x7FF0000000000000 } -; CHECK-LABEL: (func $neginf_f64 -; CHECK-NEXT: (result f64) -; CHECK-NEXT: (set_local @0 (immediate -infinity)) -; CHECK-NEXT: (return @0) +; CHECK-LABEL: neginf_f64: +; CHECK-NEXT: .result f64{{$}} +; CHECK-NEXT: f64.const -infinity +; CHECK-NEXT: set_local @0, @pop{{$}} +; CHECK-NEXT: return @0{{$}} define double @neginf_f64() { ret double 0xFFF0000000000000 } Index: test/CodeGen/WebAssembly/load-ext.ll =================================================================== --- test/CodeGen/WebAssembly/load-ext.ll +++ test/CodeGen/WebAssembly/load-ext.ll @@ -5,80 +5,90 @@ target datalayout = "e-p:32:32-i64:64-n32:64-S128" target triple = "wasm32-unknown-unknown" -; CHECK-LABEL: (func $sext_i8_i32 -; CHECK: (set_local @1 (load_s_i8_i32 @0)) +; CHECK-LABEL: sext_i8_i32: +; CHECK: load_s_i8_i32 @1{{$}} +; CHECK-NEXT: set_local @2, @pop{{$}} 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: (set_local @1 (load_u_i8_i32 @0)) +; CHECK-LABEL: zext_i8_i32: +; CHECK: load_u_i8_i32 @1{{$}} +; CHECK-NEXT: set_local @2, @pop{{$}} 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: (set_local @1 (load_s_i16_i32 @0)) +; CHECK-LABEL: sext_i16_i32: +; CHECK: load_s_i16_i32 @1{{$}} +; CHECK-NEXT: set_local @2, @pop{{$}} 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: (set_local @1 (load_u_i16_i32 @0)) +; CHECK-LABEL: zext_i16_i32: +; CHECK: load_u_i16_i32 @1{{$}} +; CHECK-NEXT: set_local @2, @pop{{$}} 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: (set_local @1 (load_s_i8_i64 @0)) +; CHECK-LABEL: sext_i8_i64: +; CHECK: load_s_i8_i64 @1{{$}} +; CHECK-NEXT: set_local @2, @pop{{$}} 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: (set_local @1 (load_u_i8_i64 @0)) +; CHECK-LABEL: zext_i8_i64: +; CHECK: load_u_i8_i64 @1{{$}} +; CHECK-NEXT: set_local @2, @pop{{$}} 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: (set_local @1 (load_s_i16_i64 @0)) +; CHECK-LABEL: sext_i16_i64: +; CHECK: load_s_i16_i64 @1{{$}} +; CHECK-NEXT: set_local @2, @pop{{$}} 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: (set_local @1 (load_u_i16_i64 @0)) +; CHECK-LABEL: zext_i16_i64: +; CHECK: load_u_i16_i64 @1{{$}} +; CHECK-NEXT: set_local @2, @pop{{$}} 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: (set_local @1 (load_s_i32_i64 @0)) +; CHECK-LABEL: sext_i32_i64: +; CHECK: load_s_i32_i64 @1{{$}} +; CHECK-NEXT: set_local @2, @pop{{$}} 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: (set_local @1 (load_u_i32_i64 @0)) +; CHECK-LABEL: zext_i32_i64: +; CHECK: load_u_i32_i64 @1{{$}} +; CHECK: set_local @2, @pop{{$}} define i64 @zext_i32_i64(i32 *%p) { %v = load i32, i32* %p %e = zext i32 %v to i64 Index: test/CodeGen/WebAssembly/load-store-i1.ll =================================================================== --- test/CodeGen/WebAssembly/load-store-i1.ll +++ test/CodeGen/WebAssembly/load-store-i1.ll @@ -5,62 +5,76 @@ target datalayout = "e-p:32:32-i64:64-n32:64-S128" target triple = "wasm32-unknown-unknown" -; CHECK-LABEL: (func $load_u_i1_i32 -; CHECK: (set_local @1 (load_u_i8_i32 @0)) -; CHECK-NEXT: (return @1) +; CHECK-LABEL: load_u_i1_i32: +; CHECK: load_u_i8_i32 @1{{$}} +; CHECK-NEXT: set_local @2, @pop{{$}} +; CHECK-NEXT: return @2{{$}} define i32 @load_u_i1_i32(i1* %p) { %v = load i1, i1* %p %e = zext i1 %v to i32 ret i32 %e } -; CHECK-LABEL: (func $load_s_i1_i32 -; CHECK: (set_local @1 (load_u_i8_i32 @0)) -; CHECK-NEXT: (set_local @2 (immediate 31)) -; CHECK-NEXT: (set_local @3 (shl @1 @2)) -; CHECK-NEXT: (set_local @4 (shr_s @3 @2)) -; CHECK-NEXT: (return @4) +; CHECK-LABEL: load_s_i1_i32: +; CHECK: load_u_i8_i32 @1{{$}} +; CHECK-NEXT: set_local @2, @pop{{$}} +; CHECK-NEXT: i32.const 31{{$}} +; CHECK-NEXT: set_local @3, @pop{{$}} +; CHECK-NEXT: shl @2, @3{{$}} +; CHECK-NEXT: set_local @4, @pop{{$}} +; CHECK-NEXT: shr_s @4, @3{{$}} +; CHECK-NEXT: set_local @5, @pop{{$}} +; CHECK-NEXT: return @5{{$}} define i32 @load_s_i1_i32(i1* %p) { %v = load i1, i1* %p %e = sext i1 %v to i32 ret i32 %e } -; CHECK-LABEL: (func $load_u_i1_i64 -; CHECK: (set_local @1 (load_u_i8_i64 @0)) -; CHECK-NEXT: (return @1) +; CHECK-LABEL: load_u_i1_i64: +; CHECK: load_u_i8_i64 @1{{$}} +; CHECK-NEXT: set_local @2, @pop{{$}} +; CHECK-NEXT: return @2{{$}} define i64 @load_u_i1_i64(i1* %p) { %v = load i1, i1* %p %e = zext i1 %v to i64 ret i64 %e } -; CHECK-LABEL: (func $load_s_i1_i64 -; CHECK: (set_local @1 (load_u_i8_i64 @0)) -; CHECK-NEXT: (set_local @2 (immediate 63)) -; CHECK-NEXT: (set_local @3 (shl @1 @2)) -; CHECK-NEXT: (set_local @4 (shr_s @3 @2)) -; CHECK-NEXT: (return @4) +; CHECK-LABEL: load_s_i1_i64: +; CHECK: load_u_i8_i64 @1{{$}} +; CHECK-NEXT: set_local @2, @pop{{$}} +; CHECK-NEXT: i64.const 63{{$}} +; CHECK-NEXT: set_local @3, @pop{{$}} +; CHECK-NEXT: shl @2, @3{{$}} +; CHECK-NEXT: set_local @4, @pop{{$}} +; CHECK-NEXT: shr_s @4, @3{{$}} +; CHECK-NEXT: set_local @5, @pop{{$}} +; CHECK-NEXT: return @5{{$}} define i64 @load_s_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: (set_local @2 (immediate 1)) -; CHECK-NEXT: (set_local @3 (and @1 @2)) -; CHECK-NEXT: (store_i8 @0 @3) +; CHECK-LABEL: store_i32_i1: +; CHECK: i32.const 1{{$}} +; CHECK-NEXT: set_local @4, @pop{{$}} +; CHECK-NEXT: and @3, @4{{$}} +; CHECK-NEXT: set_local @5, @pop{{$}} +; CHECK-NEXT: store_i8 @2, @5{{$}} 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: (set_local @2 (immediate 1)) -; CHECK-NEXT: (set_local @3 (and @1 @2)) -; CHECK-NEXT: (store_i8 @0 @3) +; CHECK-LABEL: store_i64_i1: +; CHECK: i64.const 1{{$}} +; CHECK-NEXT: set_local @4, @pop{{$}} +; CHECK-NEXT: and @3, @4{{$}} +; CHECK-NEXT: set_local @5, @pop{{$}} +; CHECK-NEXT: store_i8 @2, @5{{$}} define void @store_i64_i1(i1* %p, i64 %v) { %t = trunc i64 %v to i1 store i1 %t, i1* %p Index: test/CodeGen/WebAssembly/load.ll =================================================================== --- test/CodeGen/WebAssembly/load.ll +++ test/CodeGen/WebAssembly/load.ll @@ -5,41 +5,53 @@ 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: (set_local @0 (argument 0)) -; CHECK-NEXT: (set_local @1 (load_i32 @0)) -; CHECK-NEXT: (return @1) +; CHECK-LABEL: ldi32: +; CHECK-NEXT: .param i32{{$}} +; CHECK-NEXT: .result i32{{$}} +; CHECK-NEXT: @0{{$}} +; CHECK-NEXT: set_local @1, @pop{{$}} +; CHECK-NEXT: load_i32 @1{{$}} +; CHECK-NEXT: set_local @2, @pop{{$}} +; CHECK-NEXT: return @2{{$}} 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: (set_local @0 (argument 0)) -; CHECK-NEXT: (set_local @1 (load_i64 @0)) -; CHECK-NEXT: (return @1) +; CHECK-LABEL: ldi64: +; CHECK-NEXT: .param i32{{$}} +; CHECK-NEXT: .result i64{{$}} +; CHECK-NEXT: @0{{$}} +; CHECK-NEXT: set_local @1, @pop{{$}} +; CHECK-NEXT: load_i64 @1{{$}} +; CHECK-NEXT: set_local @2, @pop{{$}} +; CHECK-NEXT: return @2{{$}} 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: (set_local @0 (argument 0)) -; CHECK-NEXT: (set_local @1 (load_f32 @0)) -; CHECK-NEXT: (return @1) +; CHECK-LABEL: ldf32: +; CHECK-NEXT: .param i32{{$}} +; CHECK-NEXT: .result f32{{$}} +; CHECK-NEXT: @0{{$}} +; CHECK-NEXT: set_local @1, @pop{{$}} +; CHECK-NEXT: load_f32 @1{{$}} +; CHECK-NEXT: set_local @2, @pop{{$}} +; CHECK-NEXT: return @2{{$}} 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: (set_local @0 (argument 0)) -; CHECK-NEXT: (set_local @1 (load_f64 @0)) -; CHECK-NEXT: (return @1) +; CHECK-LABEL: ldf64: +; CHECK-NEXT: .param i32{{$}} +; CHECK-NEXT: .result f64{{$}} +; CHECK-NEXT: @0{{$}} +; CHECK-NEXT: set_local @1, @pop{{$}} +; CHECK-NEXT: load_f64 @1{{$}} +; CHECK-NEXT: set_local @2, @pop{{$}} +; CHECK-NEXT: return @2{{$}} define double @ldf64(double *%p) { %v = load double, double* %p ret double %v Index: test/CodeGen/WebAssembly/memory-addr32.ll =================================================================== --- test/CodeGen/WebAssembly/memory-addr32.ll +++ test/CodeGen/WebAssembly/memory-addr32.ll @@ -9,28 +9,30 @@ declare i32 @llvm.wasm.memory.size.i32() nounwind readnone declare void @llvm.wasm.resize.memory.i32(i32) nounwind -; CHECK-LABEL: (func $page_size -; CHECK-NEXT: (result i32) -; CHECK-NEXT: (set_local @0 (page_size)) -; CHECK-NEXT: (return @0) +; CHECK-LABEL: page_size: +; CHECK-NEXT: .result i32{{$}} +; CHECK-NEXT: page_size +; CHECK-NEXT: set_local @0, @pop{{$}} +; CHECK-NEXT: return @0{{$}} define i32 @page_size() { %a = call i32 @llvm.wasm.page.size.i32() ret i32 %a } -; CHECK-LABEL: (func $memory_size -; CHECK-NEXT: (result i32) -; CHECK-NEXT: (set_local @0 (memory_size)) -; CHECK-NEXT: (return @0) +; CHECK-LABEL: memory_size: +; CHECK-NEXT: .result i32{{$}} +; CHECK-NEXT: memory_size +; CHECK-NEXT: set_local @0, @pop{{$}} +; CHECK-NEXT: return @0{{$}} define i32 @memory_size() { %a = call i32 @llvm.wasm.memory.size.i32() ret i32 %a } -; CHECK-LABEL: (func $resize_memory -; CHECK-NEXT: (param i32) -; CHECK: (resize_memory @0) -; CHECK-NEXT: (return) +; CHECK-LABEL: resize_memory: +; CHECK-NEXT: .param i32 +; CHECK: resize_memory @1 +; CHECK-NEXT: return define void @resize_memory(i32 %n) { call void @llvm.wasm.resize.memory.i32(i32 %n) ret void Index: test/CodeGen/WebAssembly/memory-addr64.ll =================================================================== --- test/CodeGen/WebAssembly/memory-addr64.ll +++ test/CodeGen/WebAssembly/memory-addr64.ll @@ -9,28 +9,30 @@ declare i64 @llvm.wasm.memory.size.i64() nounwind readnone declare void @llvm.wasm.resize.memory.i64(i64) nounwind -; CHECK-LABEL: (func $page_size -; CHECK-NEXT: (result i64) -; CHECK-NEXT: (set_local @0 (page_size)) -; CHECK-NEXT: (return @0) +; CHECK-LABEL: page_size: +; CHECK-NEXT: .result i64{{$}} +; CHECK-NEXT: page_size +; CHECK-NEXT: set_local @0, @pop{{$}} +; CHECK-NEXT: return @0{{$}} define i64 @page_size() { %a = call i64 @llvm.wasm.page.size.i64() ret i64 %a } -; CHECK-LABEL: (func $memory_size -; CHECK-NEXT: (result i64) -; CHECK-NEXT: (set_local @0 (memory_size)) -; CHECK-NEXT: (return @0) +; CHECK-LABEL: memory_size: +; CHECK-NEXT: .result i64{{$}} +; CHECK-NEXT: memory_size +; CHECK-NEXT: set_local @0, @pop{{$}} +; CHECK-NEXT: return @0{{$}} define i64 @memory_size() { %a = call i64 @llvm.wasm.memory.size.i64() ret i64 %a } -; CHECK-LABEL: (func $resize_memory -; CHECK-NEXT: (param i64) -; CHECK: (resize_memory @0) -; CHECK-NEXT: (return) +; CHECK-LABEL: resize_memory: +; CHECK-NEXT: .param i64 +; CHECK: resize_memory @1 +; CHECK-NEXT: return define void @resize_memory(i64 %n) { call void @llvm.wasm.resize.memory.i64(i64 %n) ret void Index: test/CodeGen/WebAssembly/phi.ll =================================================================== --- test/CodeGen/WebAssembly/phi.ll +++ test/CodeGen/WebAssembly/phi.ll @@ -7,10 +7,12 @@ ; Basic phi triangle. -; CHECK-LABEL: test0 -; CHECK: (set_local [[REG:@.*]] (argument 0)) -; CHECK: (set_local [[REG]] (sdiv [[REG]] {{.*}})) -; CHECK: (return [[REG]]) +; CHECK-LABEL: test0: +; CHECK: @0{{$}} +; CHECK: set_local [[REG:@.*]], @pop +; CHECK: sdiv [[REG]], {{.*}} +; CHECK: set_local [[REG]], @pop +; CHECK: return [[REG]] define i32 @test0(i32 %p) { entry: %t = icmp slt i32 %p, 0 @@ -25,11 +27,14 @@ ; Swap phis. -; CHECK-LABEL: test1 +; CHECK-LABEL: test1: ; CHECK: BB1_1: -; CHECK: (set_local [[REG0:@.*]] [[REG1:@.*]]) -; CHECK: (set_local [[REG1]] [[REG2:@.*]]) -; CHECK: (set_local [[REG2]] [[REG0]]) +; CHECK: [[REG1:@.*]] +; CHECK: set_local [[REG0:@.*]], @pop +; CHECK: [[REG2:@.*]] +; CHECK: set_local [[REG1]], @pop +; CHECK: [[REG0]] +; CHECK: set_local [[REG2]], @pop define i32 @test1(i32 %n) { entry: br label %loop Index: test/CodeGen/WebAssembly/return-void.ll =================================================================== --- test/CodeGen/WebAssembly/return-void.ll +++ test/CodeGen/WebAssembly/return-void.ll @@ -3,8 +3,8 @@ 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 } Index: test/CodeGen/WebAssembly/store-trunc.ll =================================================================== --- test/CodeGen/WebAssembly/store-trunc.ll +++ test/CodeGen/WebAssembly/store-trunc.ll @@ -5,40 +5,40 @@ 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 @3, @2{{$}} 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 @3, @2{{$}} 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 @3, @2{{$}} 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 @3, @2{{$}} 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 @3, @2{{$}} define void @trunc_i32_i64(i32 *%p, i64 %v) { %t = trunc i64 %v to i32 store i32 %t, i32* %p Index: test/CodeGen/WebAssembly/store.ll =================================================================== --- test/CodeGen/WebAssembly/store.ll +++ test/CodeGen/WebAssembly/store.ll @@ -5,45 +5,57 @@ 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: (set_local @0 (argument 1)) -; CHECK-NEXT: (set_local @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: @1{{$}} +; CHECK-NEXT: set_local @2, @pop{{$}} +; CHECK-NEXT: @0{{$}} +; CHECK-NEXT: set_local @3, @pop{{$}} +; CHECK-NEXT: store_i32 @3, @2{{$}} +; 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: (set_local @0 (argument 1)) -; CHECK-NEXT: (set_local @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: @1{{$}} +; CHECK-NEXT: set_local @2, @pop{{$}} +; CHECK-NEXT: @0{{$}} +; CHECK-NEXT: set_local @3, @pop{{$}} +; CHECK-NEXT: store_i64 @3, @2{{$}} +; 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: (set_local @0 (argument 1)) -; CHECK-NEXT: (set_local @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: @1{{$}} +; CHECK-NEXT: set_local @2, @pop{{$}} +; CHECK-NEXT: @0{{$}} +; CHECK-NEXT: set_local @3, @pop{{$}} +; CHECK-NEXT: store_f32 @3, @2{{$}} +; 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: (set_local @0 (argument 1)) -; CHECK-NEXT: (set_local @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: @1{{$}} +; CHECK-NEXT: set_local @2, @pop{{$}} +; CHECK-NEXT: @0{{$}} +; CHECK-NEXT: set_local @3, @pop{{$}} +; CHECK-NEXT: store_f64 @3, @2{{$}} +; CHECK-NEXT: return{{$}} define void @stf64(double *%p, double %v) { store double %v, double* %p ret void Index: test/CodeGen/WebAssembly/switch.ll =================================================================== --- test/CodeGen/WebAssembly/switch.ll +++ test/CodeGen/WebAssembly/switch.ll @@ -12,29 +12,29 @@ 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: (call $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: call $foo0 ; CHECK: BB0_3: -; CHECK: (call $foo1) +; CHECK: call $foo1 ; CHECK: BB0_4: -; CHECK: (call $foo2) +; CHECK: call $foo2 ; CHECK: BB0_5: -; CHECK: (call $foo3) +; CHECK: call $foo3 ; CHECK: BB0_6: -; CHECK: (call $foo4) +; CHECK: call $foo4 ; CHECK: BB0_7: -; CHECK: (call $foo5) +; CHECK: call $foo5 ; CHECK: BB0_8: -; CHECK: (return) +; CHECK: return{{$}} define void @bar32(i32 %n) { entry: switch i32 %n, label %sw.epilog [ @@ -92,29 +92,29 @@ 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: (call $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: call $foo0 ; CHECK: BB1_3: -; CHECK: (call $foo1) +; CHECK: call $foo1 ; CHECK: BB1_4: -; CHECK: (call $foo2) +; CHECK: call $foo2 ; CHECK: BB1_5: -; CHECK: (call $foo3) +; CHECK: call $foo3 ; CHECK: BB1_6: -; CHECK: (call $foo4) +; CHECK: call $foo4 ; CHECK: BB1_7: -; CHECK: (call $foo5) +; CHECK: call $foo5 ; CHECK: BB1_8: -; CHECK: (return) +; CHECK: return{{$}} define void @bar64(i64 %n) { entry: switch i64 %n, label %sw.epilog [ Index: test/CodeGen/WebAssembly/unused-argument.ll =================================================================== --- test/CodeGen/WebAssembly/unused-argument.ll +++ test/CodeGen/WebAssembly/unused-argument.ll @@ -5,18 +5,24 @@ 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: (set_local @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: @1{{$}} +; CHECK-NEXT: set_local @2, @pop{{$}} +; CHECK-NEXT: return @2{{$}} 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: (set_local @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: @0{{$}} +; CHECK-NEXT: set_local @2, @pop{{$}} +; CHECK-NEXT: return @2{{$}} define i32 @unused_second(i32 %x, i32 %y) { ret i32 %x }