Index: include/llvm/BinaryFormat/Wasm.h =================================================================== --- include/llvm/BinaryFormat/Wasm.h +++ include/llvm/BinaryFormat/Wasm.h @@ -211,7 +211,7 @@ WASM_TYPE_F32 = 0x7D, WASM_TYPE_F64 = 0x7C, WASM_TYPE_V128 = 0x7B, - WASM_TYPE_ANYFUNC = 0x70, + WASM_TYPE_FUNCREF = 0x70, WASM_TYPE_EXCEPT_REF = 0x68, WASM_TYPE_FUNC = 0x60, WASM_TYPE_NORESULT = 0x40, // for blocks with no result values @@ -229,7 +229,7 @@ // Opcodes used in initializer expressions. enum : unsigned { WASM_OPCODE_END = 0x0b, - WASM_OPCODE_GET_GLOBAL = 0x23, + WASM_OPCODE_GLOBAL_GET = 0x23, WASM_OPCODE_I32_CONST = 0x41, WASM_OPCODE_I64_CONST = 0x42, WASM_OPCODE_F32_CONST = 0x43, Index: lib/MC/WasmObjectWriter.cpp =================================================================== --- lib/MC/WasmObjectWriter.cpp +++ lib/MC/WasmObjectWriter.cpp @@ -1176,7 +1176,7 @@ TableImport.Module = TableSym->getModuleName(); TableImport.Field = TableSym->getName(); TableImport.Kind = wasm::WASM_EXTERNAL_TABLE; - TableImport.Table.ElemType = wasm::WASM_TYPE_ANYFUNC; + TableImport.Table.ElemType = wasm::WASM_TYPE_FUNCREF; Imports.push_back(TableImport); // Populate SignatureIndices, and Imports and WasmIndices for undefined Index: lib/Object/WasmObjectFile.cpp =================================================================== --- lib/Object/WasmObjectFile.cpp +++ lib/Object/WasmObjectFile.cpp @@ -176,7 +176,7 @@ case wasm::WASM_OPCODE_F64_CONST: Expr.Value.Float64 = readFloat64(Ctx); break; - case wasm::WASM_OPCODE_GET_GLOBAL: + case wasm::WASM_OPCODE_GLOBAL_GET: Expr.Value.Global = readULEB128(Ctx); break; default: @@ -819,7 +819,7 @@ break; case wasm::WASM_EXTERNAL_TABLE: Im.Table = readTable(Ctx); - if (Im.Table.ElemType != wasm::WASM_TYPE_ANYFUNC) + if (Im.Table.ElemType != wasm::WASM_TYPE_FUNCREF) return make_error("Invalid table element type", object_error::parse_failed); break; @@ -862,7 +862,7 @@ Tables.reserve(Count); while (Count--) { Tables.push_back(readTable(Ctx)); - if (Tables.back().ElemType != wasm::WASM_TYPE_ANYFUNC) { + if (Tables.back().ElemType != wasm::WASM_TYPE_FUNCREF) { return make_error("Invalid table element type", object_error::parse_failed); } Index: lib/ObjectYAML/WasmYAML.cpp =================================================================== --- lib/ObjectYAML/WasmYAML.cpp +++ lib/ObjectYAML/WasmYAML.cpp @@ -377,7 +377,7 @@ case wasm::WASM_OPCODE_F64_CONST: IO.mapRequired("Value", Expr.Value.Float64); break; - case wasm::WASM_OPCODE_GET_GLOBAL: + case wasm::WASM_OPCODE_GLOBAL_GET: IO.mapRequired("Index", Expr.Value.Global); break; } @@ -491,7 +491,7 @@ ECase(F32); ECase(F64); ECase(V128); - ECase(ANYFUNC); + ECase(FUNCREF); ECase(FUNC); ECase(NORESULT); #undef ECase @@ -516,14 +516,14 @@ ECase(I64_CONST); ECase(F64_CONST); ECase(F32_CONST); - ECase(GET_GLOBAL); + ECase(GLOBAL_GET); #undef ECase } void ScalarEnumerationTraits::enumeration( IO &IO, WasmYAML::TableType &Type) { #define ECase(X) IO.enumCase(Type, #X, wasm::WASM_TYPE_##X); - ECase(ANYFUNC); + ECase(FUNCREF); #undef ECase } Index: lib/Target/WebAssembly/InstPrinter/WebAssemblyInstPrinter.cpp =================================================================== --- lib/Target/WebAssembly/InstPrinter/WebAssemblyInstPrinter.cpp +++ lib/Target/WebAssembly/InstPrinter/WebAssemblyInstPrinter.cpp @@ -40,7 +40,7 @@ void WebAssemblyInstPrinter::printRegName(raw_ostream &OS, unsigned RegNo) const { assert(RegNo != WebAssemblyFunctionInfo::UnusedReg); - // Note that there's an implicit get_local/set_local here! + // Note that there's an implicit local.get/local.set here! OS << "$" << RegNo; } @@ -292,8 +292,8 @@ return "f64"; case wasm::WASM_TYPE_V128: return "v128"; - case wasm::WASM_TYPE_ANYFUNC: - return "anyfunc"; + case wasm::WASM_TYPE_FUNCREF: + return "funcref"; case wasm::WASM_TYPE_FUNC: return "func"; case wasm::WASM_TYPE_EXCEPT_REF: Index: lib/Target/WebAssembly/README.txt =================================================================== --- lib/Target/WebAssembly/README.txt +++ lib/Target/WebAssembly/README.txt @@ -120,8 +120,8 @@ It could be done with a smaller encoding like this: i32.const $push5=, 0 - tee_local $push6=, $4=, $pop5 - copy_local $3=, $pop6 + local.tee $push6=, $4=, $pop5 + local.copy $3=, $pop6 //===---------------------------------------------------------------------===// @@ -180,11 +180,11 @@ //===---------------------------------------------------------------------===// The function @dynamic_alloca_redzone in test/CodeGen/WebAssembly/userstack.ll -ends up with a tee_local in its prolog which has an unused result, requiring +ends up with a local.tee in its prolog which has an unused result, requiring an extra drop: - get_global $push8=, 0 - tee_local $push9=, 1, $pop8 + global.get $push8=, 0 + local.tee $push9=, 1, $pop8 drop $pop9 [...] Index: lib/Target/WebAssembly/WebAssemblyExplicitLocals.cpp =================================================================== --- lib/Target/WebAssembly/WebAssemblyExplicitLocals.cpp +++ lib/Target/WebAssembly/WebAssemblyExplicitLocals.cpp @@ -11,7 +11,7 @@ /// This file converts any remaining registers into WebAssembly locals. /// /// After register stackification and register coloring, convert non-stackified -/// registers into locals, inserting explicit get_local and set_local +/// registers into locals, inserting explicit local.get and local.set /// instructions. /// //===----------------------------------------------------------------------===// @@ -96,54 +96,54 @@ llvm_unreachable("Unexpected register class"); } -/// Get the appropriate get_local opcode for the given register class. +/// Get the appropriate local.get opcode for the given register class. static unsigned getGetLocalOpcode(const TargetRegisterClass *RC) { if (RC == &WebAssembly::I32RegClass) - return WebAssembly::GET_LOCAL_I32; + return WebAssembly::LOCAL_GET_I32; if (RC == &WebAssembly::I64RegClass) - return WebAssembly::GET_LOCAL_I64; + return WebAssembly::LOCAL_GET_I64; if (RC == &WebAssembly::F32RegClass) - return WebAssembly::GET_LOCAL_F32; + return WebAssembly::LOCAL_GET_F32; if (RC == &WebAssembly::F64RegClass) - return WebAssembly::GET_LOCAL_F64; + return WebAssembly::LOCAL_GET_F64; if (RC == &WebAssembly::V128RegClass) - return WebAssembly::GET_LOCAL_V128; + return WebAssembly::LOCAL_GET_V128; if (RC == &WebAssembly::EXCEPT_REFRegClass) - return WebAssembly::GET_LOCAL_EXCEPT_REF; + return WebAssembly::LOCAL_GET_EXCEPT_REF; llvm_unreachable("Unexpected register class"); } -/// Get the appropriate set_local opcode for the given register class. +/// Get the appropriate local.set opcode for the given register class. static unsigned getSetLocalOpcode(const TargetRegisterClass *RC) { if (RC == &WebAssembly::I32RegClass) - return WebAssembly::SET_LOCAL_I32; + return WebAssembly::LOCAL_SET_I32; if (RC == &WebAssembly::I64RegClass) - return WebAssembly::SET_LOCAL_I64; + return WebAssembly::LOCAL_SET_I64; if (RC == &WebAssembly::F32RegClass) - return WebAssembly::SET_LOCAL_F32; + return WebAssembly::LOCAL_SET_F32; if (RC == &WebAssembly::F64RegClass) - return WebAssembly::SET_LOCAL_F64; + return WebAssembly::LOCAL_SET_F64; if (RC == &WebAssembly::V128RegClass) - return WebAssembly::SET_LOCAL_V128; + return WebAssembly::LOCAL_SET_V128; if (RC == &WebAssembly::EXCEPT_REFRegClass) - return WebAssembly::SET_LOCAL_EXCEPT_REF; + return WebAssembly::LOCAL_SET_EXCEPT_REF; llvm_unreachable("Unexpected register class"); } -/// Get the appropriate tee_local opcode for the given register class. +/// Get the appropriate local.tee opcode for the given register class. static unsigned getTeeLocalOpcode(const TargetRegisterClass *RC) { if (RC == &WebAssembly::I32RegClass) - return WebAssembly::TEE_LOCAL_I32; + return WebAssembly::LOCAL_TEE_I32; if (RC == &WebAssembly::I64RegClass) - return WebAssembly::TEE_LOCAL_I64; + return WebAssembly::LOCAL_TEE_I64; if (RC == &WebAssembly::F32RegClass) - return WebAssembly::TEE_LOCAL_F32; + return WebAssembly::LOCAL_TEE_F32; if (RC == &WebAssembly::F64RegClass) - return WebAssembly::TEE_LOCAL_F64; + return WebAssembly::LOCAL_TEE_F64; if (RC == &WebAssembly::V128RegClass) - return WebAssembly::TEE_LOCAL_V128; + return WebAssembly::LOCAL_TEE_V128; if (RC == &WebAssembly::EXCEPT_REFRegClass) - return WebAssembly::TEE_LOCAL_EXCEPT_REF; + return WebAssembly::LOCAL_TEE_EXCEPT_REF; llvm_unreachable("Unexpected register class"); } @@ -233,8 +233,8 @@ if (MI.isDebugInstr() || MI.isLabel()) continue; - // Replace tee instructions with tee_local. The difference is that tee - // instructions have two defs, while tee_local instructions have one def + // Replace tee instructions with local.tee. The difference is that tee + // instructions have two defs, while local.tee instructions have one def // and an index of a local to write to. if (WebAssembly::isTee(MI)) { assert(MFI.isVRegStackified(MI.getOperand(0).getReg())); @@ -253,7 +253,7 @@ MFI.stackifyVReg(NewReg); } - // Replace the TEE with a TEE_LOCAL. + // Replace the TEE with a LOCAL_TEE. unsigned LocalId = getLocalId(Reg2Local, CurLocal, MI.getOperand(1).getReg()); unsigned Opc = getTeeLocalOpcode(RC); @@ -267,7 +267,7 @@ continue; } - // Insert set_locals for any defs that aren't stackified yet. Currently + // Insert local.sets for any defs that aren't stackified yet. Currently // we handle at most one def. assert(MI.getDesc().getNumDefs() <= 1); if (MI.getDesc().getNumDefs() == 1) { @@ -297,7 +297,7 @@ } MI.getOperand(0).setReg(NewReg); // This register operand of the original instruction is now being used - // by the inserted drop or set_local instruction, so make it not dead + // by the inserted drop or local.set instruction, so make it not dead // yet. MI.getOperand(0).setIsDead(false); MFI.stackifyVReg(NewReg); @@ -305,7 +305,7 @@ } } - // Insert get_locals for any uses that aren't stackified yet. + // Insert local.gets for any uses that aren't stackified yet. MachineInstr *InsertPt = &MI; for (MachineOperand &MO : reverse(MI.explicit_uses())) { if (!MO.isReg()) @@ -327,7 +327,7 @@ } // If we see a stackified register, prepare to insert subsequent - // get_locals before the start of its tree. + // local.gets before the start of its tree. if (MFI.isVRegStackified(OldReg)) { InsertPt = findStartOfTree(MO, MRI, MFI); continue; @@ -343,7 +343,7 @@ continue; } - // Insert a get_local. + // Insert a local.get. unsigned LocalId = getLocalId(Reg2Local, CurLocal, OldReg); const TargetRegisterClass *RC = MRI.getRegClass(OldReg); unsigned NewReg = MRI.createVirtualRegister(RC); Index: lib/Target/WebAssembly/WebAssemblyFrameLowering.cpp =================================================================== --- lib/Target/WebAssembly/WebAssemblyFrameLowering.cpp +++ lib/Target/WebAssembly/WebAssemblyFrameLowering.cpp @@ -130,7 +130,7 @@ const char *ES = "__stack_pointer"; auto *SPSymbol = MF.createExternalSymbolName(ES); - BuildMI(MBB, InsertStore, DL, TII->get(WebAssembly::SET_GLOBAL_I32)) + BuildMI(MBB, InsertStore, DL, TII->get(WebAssembly::GLOBAL_SET_I32)) .addExternalSymbol(SPSymbol, WebAssemblyII::MO_SYMBOL_GLOBAL) .addReg(SrcReg); } @@ -177,7 +177,7 @@ const char *ES = "__stack_pointer"; auto *SPSymbol = MF.createExternalSymbolName(ES); - BuildMI(MBB, InsertPt, DL, TII->get(WebAssembly::GET_GLOBAL_I32), SPReg) + BuildMI(MBB, InsertPt, DL, TII->get(WebAssembly::GLOBAL_GET_I32), SPReg) .addExternalSymbol(SPSymbol, WebAssemblyII::MO_SYMBOL_GLOBAL); bool HasBP = hasBP(MF); Index: lib/Target/WebAssembly/WebAssemblyISelLowering.cpp =================================================================== --- lib/Target/WebAssembly/WebAssemblyISelLowering.cpp +++ lib/Target/WebAssembly/WebAssemblyISelLowering.cpp @@ -917,7 +917,7 @@ // the FI to some LEA-like instruction, but since we don't have that, we // need to insert some kind of instruction that can take an FI operand and // produces a value usable by CopyToReg (i.e. in a vreg). So insert a dummy - // copy_local between Op and its FI operand. + // local.copy between Op and its FI operand. SDValue Chain = Op.getOperand(0); SDLoc DL(Op); unsigned Reg = cast(Op.getOperand(1))->getReg(); Index: lib/Target/WebAssembly/WebAssemblyInstrAtomics.td =================================================================== --- lib/Target/WebAssembly/WebAssemblyInstrAtomics.td +++ lib/Target/WebAssembly/WebAssemblyInstrAtomics.td @@ -114,7 +114,7 @@ def : LoadPatNoOffset; def : LoadPatNoOffset; def : LoadPatNoOffset; -// 32->64 sext load gets selected as i32.atomic.load, i64.extend_s/i32 +// 32->64 sext load gets selected as i32.atomic.load, i64.extend_i32_s // Zero-extending loads with constant offset def : LoadPatImmOff; @@ -344,82 +344,82 @@ defm ATOMIC_RMW_ADD_I32 : WebAssemblyBinRMW; defm ATOMIC_RMW_ADD_I64 : WebAssemblyBinRMW; defm ATOMIC_RMW8_U_ADD_I32 : - WebAssemblyBinRMW; + WebAssemblyBinRMW; defm ATOMIC_RMW16_U_ADD_I32 : - WebAssemblyBinRMW; + WebAssemblyBinRMW; defm ATOMIC_RMW8_U_ADD_I64 : - WebAssemblyBinRMW; + WebAssemblyBinRMW; defm ATOMIC_RMW16_U_ADD_I64 : - WebAssemblyBinRMW; + WebAssemblyBinRMW; defm ATOMIC_RMW32_U_ADD_I64 : - WebAssemblyBinRMW; + WebAssemblyBinRMW; defm ATOMIC_RMW_SUB_I32 : WebAssemblyBinRMW; defm ATOMIC_RMW_SUB_I64 : WebAssemblyBinRMW; defm ATOMIC_RMW8_U_SUB_I32 : - WebAssemblyBinRMW; + WebAssemblyBinRMW; defm ATOMIC_RMW16_U_SUB_I32 : - WebAssemblyBinRMW; + WebAssemblyBinRMW; defm ATOMIC_RMW8_U_SUB_I64 : - WebAssemblyBinRMW; + WebAssemblyBinRMW; defm ATOMIC_RMW16_U_SUB_I64 : - WebAssemblyBinRMW; + WebAssemblyBinRMW; defm ATOMIC_RMW32_U_SUB_I64 : - WebAssemblyBinRMW; + WebAssemblyBinRMW; defm ATOMIC_RMW_AND_I32 : WebAssemblyBinRMW; defm ATOMIC_RMW_AND_I64 : WebAssemblyBinRMW; defm ATOMIC_RMW8_U_AND_I32 : - WebAssemblyBinRMW; + WebAssemblyBinRMW; defm ATOMIC_RMW16_U_AND_I32 : - WebAssemblyBinRMW; + WebAssemblyBinRMW; defm ATOMIC_RMW8_U_AND_I64 : - WebAssemblyBinRMW; + WebAssemblyBinRMW; defm ATOMIC_RMW16_U_AND_I64 : - WebAssemblyBinRMW; + WebAssemblyBinRMW; defm ATOMIC_RMW32_U_AND_I64 : - WebAssemblyBinRMW; + WebAssemblyBinRMW; defm ATOMIC_RMW_OR_I32 : WebAssemblyBinRMW; defm ATOMIC_RMW_OR_I64 : WebAssemblyBinRMW; defm ATOMIC_RMW8_U_OR_I32 : - WebAssemblyBinRMW; + WebAssemblyBinRMW; defm ATOMIC_RMW16_U_OR_I32 : - WebAssemblyBinRMW; + WebAssemblyBinRMW; defm ATOMIC_RMW8_U_OR_I64 : - WebAssemblyBinRMW; + WebAssemblyBinRMW; defm ATOMIC_RMW16_U_OR_I64 : - WebAssemblyBinRMW; + WebAssemblyBinRMW; defm ATOMIC_RMW32_U_OR_I64 : - WebAssemblyBinRMW; + WebAssemblyBinRMW; defm ATOMIC_RMW_XOR_I32 : WebAssemblyBinRMW; defm ATOMIC_RMW_XOR_I64 : WebAssemblyBinRMW; defm ATOMIC_RMW8_U_XOR_I32 : - WebAssemblyBinRMW; + WebAssemblyBinRMW; defm ATOMIC_RMW16_U_XOR_I32 : - WebAssemblyBinRMW; + WebAssemblyBinRMW; defm ATOMIC_RMW8_U_XOR_I64 : - WebAssemblyBinRMW; + WebAssemblyBinRMW; defm ATOMIC_RMW16_U_XOR_I64 : - WebAssemblyBinRMW; + WebAssemblyBinRMW; defm ATOMIC_RMW32_U_XOR_I64 : - WebAssemblyBinRMW; + WebAssemblyBinRMW; defm ATOMIC_RMW_XCHG_I32 : WebAssemblyBinRMW; defm ATOMIC_RMW_XCHG_I64 : WebAssemblyBinRMW; defm ATOMIC_RMW8_U_XCHG_I32 : - WebAssemblyBinRMW; + WebAssemblyBinRMW; defm ATOMIC_RMW16_U_XCHG_I32 : - WebAssemblyBinRMW; + WebAssemblyBinRMW; defm ATOMIC_RMW8_U_XCHG_I64 : - WebAssemblyBinRMW; + WebAssemblyBinRMW; defm ATOMIC_RMW16_U_XCHG_I64 : - WebAssemblyBinRMW; + WebAssemblyBinRMW; defm ATOMIC_RMW32_U_XCHG_I64 : - WebAssemblyBinRMW; + WebAssemblyBinRMW; // Select binary RMWs with no constant offset. class BinRMWPatNoOffset : @@ -530,7 +530,7 @@ PatFrag<(ops node:$addr, node:$val), (anyext (i32 (kind node:$addr, (i32 (trunc (i64 node:$val))))))>; class sext_bin_rmw_16_64 : sext_bin_rmw_8_64; -// 32->64 sext RMW gets selected as i32.atomic.rmw.***, i64.extend_s/i32 +// 32->64 sext RMW gets selected as i32.atomic.rmw.***, i64.extend_i32_s // Patterns for various addressing modes for truncating-extending binary RMWs. multiclass BinRMWTruncExtPattern< @@ -677,15 +677,15 @@ defm ATOMIC_RMW_CMPXCHG_I64 : WebAssemblyTerRMW; defm ATOMIC_RMW8_U_CMPXCHG_I32 : - WebAssemblyTerRMW; + WebAssemblyTerRMW; defm ATOMIC_RMW16_U_CMPXCHG_I32 : - WebAssemblyTerRMW; + WebAssemblyTerRMW; defm ATOMIC_RMW8_U_CMPXCHG_I64 : - WebAssemblyTerRMW; + WebAssemblyTerRMW; defm ATOMIC_RMW16_U_CMPXCHG_I64 : - WebAssemblyTerRMW; + WebAssemblyTerRMW; defm ATOMIC_RMW32_U_CMPXCHG_I64 : - WebAssemblyTerRMW; + WebAssemblyTerRMW; // Select ternary RMWs with no constant offset. class TerRMWPatNoOffset : @@ -790,7 +790,7 @@ (i32 (trunc (i64 node:$exp))), (i32 (trunc (i64 node:$new))))))))>; class sext_ter_rmw_16_64 : sext_ter_rmw_8_64; -// 32->64 sext RMW gets selected as i32.atomic.rmw.***, i64.extend_s/i32 +// 32->64 sext RMW gets selected as i32.atomic.rmw.***, i64.extend_i32_s // Patterns for various addressing modes for truncating-extending ternary RMWs. multiclass TerRMWTruncExtPattern< Index: lib/Target/WebAssembly/WebAssemblyInstrConv.td =================================================================== --- lib/Target/WebAssembly/WebAssemblyInstrConv.td +++ lib/Target/WebAssembly/WebAssemblyInstrConv.td @@ -15,15 +15,15 @@ defm I32_WRAP_I64 : I<(outs I32:$dst), (ins I64:$src), (outs), (ins), [(set I32:$dst, (trunc I64:$src))], - "i32.wrap/i64\t$dst, $src", "i32.wrap/i64", 0xa7>; + "i32.wrap_i64\t$dst, $src", "i32.wrap_i64", 0xa7>; defm I64_EXTEND_S_I32 : I<(outs I64:$dst), (ins I32:$src), (outs), (ins), [(set I64:$dst, (sext I32:$src))], - "i64.extend_s/i32\t$dst, $src", "i64.extend_s/i32", + "i64.extend_i32_s\t$dst, $src", "i64.extend_i32_s", 0xac>; defm I64_EXTEND_U_I32 : I<(outs I64:$dst), (ins I32:$src), (outs), (ins), [(set I64:$dst, (zext I32:$src))], - "i64.extend_u/i32\t$dst, $src", "i64.extend_u/i32", + "i64.extend_i32_u\t$dst, $src", "i64.extend_i32_u", 0xad>; let Predicates = [HasSignExt] in { @@ -58,43 +58,43 @@ // overflow or invalid. defm I32_TRUNC_S_SAT_F32 : I<(outs I32:$dst), (ins F32:$src), (outs), (ins), [(set I32:$dst, (fp_to_sint F32:$src))], - "i32.trunc_s:sat/f32\t$dst, $src", - "i32.trunc_s:sat/f32", 0xfc00>, + "i32.trunc_sat_f32_s\t$dst, $src", + "i32.trunc_sat_f32_s", 0xfc00>, Requires<[HasNontrappingFPToInt]>; defm I32_TRUNC_U_SAT_F32 : I<(outs I32:$dst), (ins F32:$src), (outs), (ins), [(set I32:$dst, (fp_to_uint F32:$src))], - "i32.trunc_u:sat/f32\t$dst, $src", - "i32.trunc_u:sat/f32", 0xfc01>, + "i32.trunc_sat_f32_u\t$dst, $src", + "i32.trunc_sat_f32_u", 0xfc01>, Requires<[HasNontrappingFPToInt]>; defm I64_TRUNC_S_SAT_F32 : I<(outs I64:$dst), (ins F32:$src), (outs), (ins), [(set I64:$dst, (fp_to_sint F32:$src))], - "i64.trunc_s:sat/f32\t$dst, $src", - "i64.trunc_s:sat/f32", 0xfc04>, + "i64.trunc_sat_f32_s\t$dst, $src", + "i64.trunc_sat_f32_s", 0xfc04>, Requires<[HasNontrappingFPToInt]>; defm I64_TRUNC_U_SAT_F32 : I<(outs I64:$dst), (ins F32:$src), (outs), (ins), [(set I64:$dst, (fp_to_uint F32:$src))], - "i64.trunc_u:sat/f32\t$dst, $src", - "i64.trunc_u:sat/f32", 0xfc05>, + "i64.trunc_sat_f32_u\t$dst, $src", + "i64.trunc_sat_f32_u", 0xfc05>, Requires<[HasNontrappingFPToInt]>; defm I32_TRUNC_S_SAT_F64 : I<(outs I32:$dst), (ins F64:$src), (outs), (ins), [(set I32:$dst, (fp_to_sint F64:$src))], - "i32.trunc_s:sat/f64\t$dst, $src", - "i32.trunc_s:sat/f64", 0xfc02>, + "i32.trunc_sat_f64_s\t$dst, $src", + "i32.trunc_sat_f64_s", 0xfc02>, Requires<[HasNontrappingFPToInt]>; defm I32_TRUNC_U_SAT_F64 : I<(outs I32:$dst), (ins F64:$src), (outs), (ins), [(set I32:$dst, (fp_to_uint F64:$src))], - "i32.trunc_u:sat/f64\t$dst, $src", - "i32.trunc_u:sat/f64", 0xfc03>, + "i32.trunc_sat_f64_u\t$dst, $src", + "i32.trunc_sat_f64_u", 0xfc03>, Requires<[HasNontrappingFPToInt]>; defm I64_TRUNC_S_SAT_F64 : I<(outs I64:$dst), (ins F64:$src), (outs), (ins), [(set I64:$dst, (fp_to_sint F64:$src))], - "i64.trunc_s:sat/f64\t$dst, $src", - "i64.trunc_s:sat/f64", 0xfc06>, + "i64.trunc_sat_f64_s\t$dst, $src", + "i64.trunc_sat_f64_s", 0xfc06>, Requires<[HasNontrappingFPToInt]>; defm I64_TRUNC_U_SAT_F64 : I<(outs I64:$dst), (ins F64:$src), (outs), (ins), [(set I64:$dst, (fp_to_uint F64:$src))], - "i64.trunc_u:sat/f64\t$dst, $src", - "i64.trunc_u:sat/f64", 0xfc07>, + "i64.trunc_sat_f64_u\t$dst, $src", + "i64.trunc_sat_f64_u", 0xfc07>, Requires<[HasNontrappingFPToInt]>; // Lower llvm.wasm.trunc.saturate.* to saturating instructions @@ -147,86 +147,86 @@ // Conversion from floating point to integer traps on overflow and invalid. let hasSideEffects = 1 in { defm I32_TRUNC_S_F32 : I<(outs I32:$dst), (ins F32:$src), (outs), (ins), - [], "i32.trunc_s/f32\t$dst, $src", "i32.trunc_s/f32", + [], "i32.trunc_f32_s\t$dst, $src", "i32.trunc_f32_s", 0xa8>; defm I32_TRUNC_U_F32 : I<(outs I32:$dst), (ins F32:$src), (outs), (ins), - [], "i32.trunc_u/f32\t$dst, $src", "i32.trunc_u/f32", + [], "i32.trunc_f32_u\t$dst, $src", "i32.trunc_f32_u", 0xa9>; defm I64_TRUNC_S_F32 : I<(outs I64:$dst), (ins F32:$src), (outs), (ins), - [], "i64.trunc_s/f32\t$dst, $src", "i64.trunc_s/f32", + [], "i64.trunc_f32_s\t$dst, $src", "i64.trunc_f32_s", 0xae>; defm I64_TRUNC_U_F32 : I<(outs I64:$dst), (ins F32:$src), (outs), (ins), - [], "i64.trunc_u/f32\t$dst, $src", "i64.trunc_u/f32", + [], "i64.trunc_f32_u\t$dst, $src", "i64.trunc_f32_u", 0xaf>; defm I32_TRUNC_S_F64 : I<(outs I32:$dst), (ins F64:$src), (outs), (ins), - [], "i32.trunc_s/f64\t$dst, $src", "i32.trunc_s/f64", + [], "i32.trunc_f64_s\t$dst, $src", "i32.trunc_f64_s", 0xaa>; defm I32_TRUNC_U_F64 : I<(outs I32:$dst), (ins F64:$src), (outs), (ins), - [], "i32.trunc_u/f64\t$dst, $src", "i32.trunc_u/f64", + [], "i32.trunc_f64_u\t$dst, $src", "i32.trunc_f64_u", 0xab>; defm I64_TRUNC_S_F64 : I<(outs I64:$dst), (ins F64:$src), (outs), (ins), - [], "i64.trunc_s/f64\t$dst, $src", "i64.trunc_s/f64", + [], "i64.trunc_f64_s\t$dst, $src", "i64.trunc_f64_s", 0xb0>; defm I64_TRUNC_U_F64 : I<(outs I64:$dst), (ins F64:$src), (outs), (ins), - [], "i64.trunc_u/f64\t$dst, $src", "i64.trunc_u/f64", + [], "i64.trunc_f64_u\t$dst, $src", "i64.trunc_f64_u", 0xb1>; } // hasSideEffects = 1 defm F32_CONVERT_S_I32 : I<(outs F32:$dst), (ins I32:$src), (outs), (ins), [(set F32:$dst, (sint_to_fp I32:$src))], - "f32.convert_s/i32\t$dst, $src", "f32.convert_s/i32", + "f32.convert_i32_s\t$dst, $src", "f32.convert_i32_s", 0xb2>; defm F32_CONVERT_U_I32 : I<(outs F32:$dst), (ins I32:$src), (outs), (ins), [(set F32:$dst, (uint_to_fp I32:$src))], - "f32.convert_u/i32\t$dst, $src", "f32.convert_u/i32", + "f32.convert_i32_u\t$dst, $src", "f32.convert_i32_u", 0xb3>; defm F64_CONVERT_S_I32 : I<(outs F64:$dst), (ins I32:$src), (outs), (ins), [(set F64:$dst, (sint_to_fp I32:$src))], - "f64.convert_s/i32\t$dst, $src", "f64.convert_s/i32", + "f64.convert_i32_s\t$dst, $src", "f64.convert_i32_s", 0xb7>; defm F64_CONVERT_U_I32 : I<(outs F64:$dst), (ins I32:$src), (outs), (ins), [(set F64:$dst, (uint_to_fp I32:$src))], - "f64.convert_u/i32\t$dst, $src", "f64.convert_u/i32", + "f64.convert_i32_u\t$dst, $src", "f64.convert_i32_u", 0xb8>; defm F32_CONVERT_S_I64 : I<(outs F32:$dst), (ins I64:$src), (outs), (ins), [(set F32:$dst, (sint_to_fp I64:$src))], - "f32.convert_s/i64\t$dst, $src", "f32.convert_s/i64", + "f32.convert_i64_s\t$dst, $src", "f32.convert_i64_s", 0xb4>; defm F32_CONVERT_U_I64 : I<(outs F32:$dst), (ins I64:$src), (outs), (ins), [(set F32:$dst, (uint_to_fp I64:$src))], - "f32.convert_u/i64\t$dst, $src", "f32.convert_u/i64", + "f32.convert_i64_u\t$dst, $src", "f32.convert_i64_u", 0xb5>; defm F64_CONVERT_S_I64 : I<(outs F64:$dst), (ins I64:$src), (outs), (ins), [(set F64:$dst, (sint_to_fp I64:$src))], - "f64.convert_s/i64\t$dst, $src", "f64.convert_s/i64", + "f64.convert_i64_s\t$dst, $src", "f64.convert_i64_s", 0xb9>; defm F64_CONVERT_U_I64 : I<(outs F64:$dst), (ins I64:$src), (outs), (ins), [(set F64:$dst, (uint_to_fp I64:$src))], - "f64.convert_u/i64\t$dst, $src", "f64.convert_u/i64", + "f64.convert_i64_u\t$dst, $src", "f64.convert_i64_u", 0xba>; defm F64_PROMOTE_F32 : I<(outs F64:$dst), (ins F32:$src), (outs), (ins), [(set F64:$dst, (fpextend F32:$src))], - "f64.promote/f32\t$dst, $src", "f64.promote/f32", + "f64.promote_f32\t$dst, $src", "f64.promote_f32", 0xbb>; defm F32_DEMOTE_F64 : I<(outs F32:$dst), (ins F64:$src), (outs), (ins), [(set F32:$dst, (fpround F64:$src))], - "f32.demote/f64\t$dst, $src", "f32.demote/f64", + "f32.demote_f64\t$dst, $src", "f32.demote_f64", 0xb6>; defm I32_REINTERPRET_F32 : I<(outs I32:$dst), (ins F32:$src), (outs), (ins), [(set I32:$dst, (bitconvert F32:$src))], - "i32.reinterpret/f32\t$dst, $src", - "i32.reinterpret/f32", 0xbc>; + "i32.reinterpret_f32\t$dst, $src", + "i32.reinterpret_f32", 0xbc>; defm F32_REINTERPRET_I32 : I<(outs F32:$dst), (ins I32:$src), (outs), (ins), [(set F32:$dst, (bitconvert I32:$src))], - "f32.reinterpret/i32\t$dst, $src", - "f32.reinterpret/i32", 0xbe>; + "f32.reinterpret_i32\t$dst, $src", + "f32.reinterpret_i32", 0xbe>; defm I64_REINTERPRET_F64 : I<(outs I64:$dst), (ins F64:$src), (outs), (ins), [(set I64:$dst, (bitconvert F64:$src))], - "i64.reinterpret/f64\t$dst, $src", - "i64.reinterpret/f64", 0xbd>; + "i64.reinterpret_f64\t$dst, $src", + "i64.reinterpret_f64", 0xbd>; defm F64_REINTERPRET_I64 : I<(outs F64:$dst), (ins I64:$src), (outs), (ins), [(set F64:$dst, (bitconvert I64:$src))], - "f64.reinterpret/i64\t$dst, $src", - "f64.reinterpret/i64", 0xbf>; + "f64.reinterpret_i64\t$dst, $src", + "f64.reinterpret_i64", 0xbf>; Index: lib/Target/WebAssembly/WebAssemblyInstrFormats.td =================================================================== --- lib/Target/WebAssembly/WebAssemblyInstrFormats.td +++ lib/Target/WebAssembly/WebAssemblyInstrFormats.td @@ -40,10 +40,10 @@ // based version of this instruction, as well as the corresponding asmstr. // The register versions have virtual-register operands which correspond to wasm // locals or stack locations. Each use and def of the register corresponds to an -// implicit get_local / set_local or access of stack operands in wasm. These +// implicit local.get / local.set or access of stack operands in wasm. These // instructions are used for ISel and all MI passes. The stack versions of the // instructions do not have register operands (they implicitly operate on the -// stack), and get_locals and set_locals are explicit. The register instructions +// stack), and local.gets and local.sets are explicit. The register instructions // are converted to their corresponding stack instructions before lowering to // MC. // Every instruction should want to be based on this multi-class to guarantee Index: lib/Target/WebAssembly/WebAssemblyInstrInfo.td =================================================================== --- lib/Target/WebAssembly/WebAssemblyInstrInfo.td +++ lib/Target/WebAssembly/WebAssemblyInstrInfo.td @@ -197,49 +197,49 @@ defm "": ARGUMENT; defm "": ARGUMENT; -// get_local and set_local are not generated by instruction selection; they +// local.get and local.set are not generated by instruction selection; they // are implied by virtual register uses and defs. multiclass LOCAL { let hasSideEffects = 0 in { - // COPY is not an actual instruction in wasm, but since we allow get_local and - // set_local to be implicit during most of codegen, we can have a COPY which - // is actually a no-op because all the work is done in the implied get_local - // and set_local. COPYs are eliminated (and replaced with - // get_local/set_local) in the ExplicitLocals pass. + // COPY is not an actual instruction in wasm, but since we allow local.get and + // local.set to be implicit during most of codegen, we can have a COPY which + // is actually a no-op because all the work is done in the implied local.get + // and local.set. COPYs are eliminated (and replaced with + // local.get/local.set) in the ExplicitLocals pass. let isAsCheapAsAMove = 1, isCodeGenOnly = 1 in defm COPY_#vt : I<(outs vt:$res), (ins vt:$src), (outs), (ins), [], - "copy_local\t$res, $src", "copy_local">; + "local.copy\t$res, $src", "local.copy">; // TEE is similar to COPY, but writes two copies of its result. Typically // this would be used to stackify one result and write the other result to a // local. let isAsCheapAsAMove = 1, isCodeGenOnly = 1 in defm TEE_#vt : I<(outs vt:$res, vt:$also), (ins vt:$src), (outs), (ins), [], - "tee_local\t$res, $also, $src", "tee_local">; + "local.tee\t$res, $also, $src", "local.tee">; - // This is the actual get_local instruction in wasm. These are made explicit + // This is the actual local.get instruction in wasm. These are made explicit // by the ExplicitLocals pass. It has mayLoad because it reads from a wasm // local, which is a side effect not otherwise modeled in LLVM. let mayLoad = 1, isAsCheapAsAMove = 1 in - defm GET_LOCAL_#vt : I<(outs vt:$res), (ins local_op:$local), + defm LOCAL_GET_#vt : I<(outs vt:$res), (ins local_op:$local), (outs), (ins local_op:$local), [], - "get_local\t$res, $local", "get_local\t$local", 0x20>; + "local.get\t$res, $local", "local.get\t$local", 0x20>; - // This is the actual set_local instruction in wasm. These are made explicit + // This is the actual local.set instruction in wasm. These are made explicit // by the ExplicitLocals pass. It has mayStore because it writes to a wasm // local, which is a side effect not otherwise modeled in LLVM. let mayStore = 1, isAsCheapAsAMove = 1 in - defm SET_LOCAL_#vt : I<(outs), (ins local_op:$local, vt:$src), + defm LOCAL_SET_#vt : I<(outs), (ins local_op:$local, vt:$src), (outs), (ins local_op:$local), [], - "set_local\t$local, $src", "set_local\t$local", 0x21>; + "local.set\t$local, $src", "local.set\t$local", 0x21>; - // This is the actual tee_local instruction in wasm. TEEs are turned into - // TEE_LOCALs by the ExplicitLocals pass. It has mayStore for the same reason - // as SET_LOCAL. + // This is the actual local.tee instruction in wasm. TEEs are turned into + // LOCAL_TEEs by the ExplicitLocals pass. It has mayStore for the same reason + // as LOCAL_SET. let mayStore = 1, isAsCheapAsAMove = 1 in - defm TEE_LOCAL_#vt : I<(outs vt:$res), (ins local_op:$local, vt:$src), + defm LOCAL_TEE_#vt : I<(outs vt:$res), (ins local_op:$local, vt:$src), (outs), (ins local_op:$local), [], - "tee_local\t$res, $local, $src", "tee_local\t$local", + "local.tee\t$res, $local, $src", "local.tee\t$local", 0x22>; // Unused values must be dropped in some contexts. @@ -247,15 +247,15 @@ "drop\t$src", "drop", 0x1a>; let mayLoad = 1 in - defm GET_GLOBAL_#vt : I<(outs vt:$res), (ins global_op:$local), + defm GLOBAL_GET_#vt : I<(outs vt:$res), (ins global_op:$local), (outs), (ins global_op:$local), [], - "get_global\t$res, $local", "get_global\t$local", + "global.get\t$res, $local", "global.get\t$local", 0x23>; let mayStore = 1 in - defm SET_GLOBAL_#vt : I<(outs), (ins global_op:$local, vt:$src), + defm GLOBAL_SET_#vt : I<(outs), (ins global_op:$local, vt:$src), (outs), (ins global_op:$local), [], - "set_global\t$local, $src", "set_global\t$local", + "global.set\t$local, $src", "global.set\t$local", 0x24>; } // hasSideEffects = 0 Index: lib/Target/WebAssembly/WebAssemblyInstrSIMD.td =================================================================== --- lib/Target/WebAssembly/WebAssemblyInstrSIMD.td +++ lib/Target/WebAssembly/WebAssemblyInstrSIMD.td @@ -773,17 +773,17 @@ name#"\t$dst, $vec", name, simdop>; } -// Integer to floating point: convert_s / convert_u -defm "" : SIMDConvert; -defm "" : SIMDConvert; -defm "" : SIMDConvert; -defm "" : SIMDConvert; - -// Floating point to integer with saturation: trunc_sat_s / trunc_sat_u -defm "" : SIMDConvert; -defm "" : SIMDConvert; -defm "" : SIMDConvert; -defm "" : SIMDConvert; +// Integer to floating point: convert +defm "" : SIMDConvert; +defm "" : SIMDConvert; +defm "" : SIMDConvert; +defm "" : SIMDConvert; + +// Floating point to integer with saturation: trunc_sat +defm "" : SIMDConvert; +defm "" : SIMDConvert; +defm "" : SIMDConvert; +defm "" : SIMDConvert; // Lower llvm.wasm.trunc.saturate.* to saturating instructions def : Pat<(v4i32 (int_wasm_trunc_saturate_signed (v4f32 V128:$src))), Index: lib/Target/WebAssembly/WebAssemblyLateEHPrepare.cpp =================================================================== --- lib/Target/WebAssembly/WebAssemblyLateEHPrepare.cpp +++ lib/Target/WebAssembly/WebAssemblyLateEHPrepare.cpp @@ -287,7 +287,7 @@ // %exn = catch 0 // call @__clang_call_terminate(%exn) // unreachable -// (There can be set_local and get_locals before the call if we didn't run +// (There can be local.set and local.gets before the call if we didn't run // RegStackify) // But code transformations can change or add more control flow, so the call to // __clang_call_terminate() function may not be in the original EH pad anymore. @@ -326,7 +326,7 @@ // This runs after hoistCatches(), so catch instruction should be at the top assert(WebAssembly::isCatch(*Catch)); // Takes the result register of the catch instruction as argument. There may - // have been some other set_local/get_locals in between, but at this point + // have been some other local.set/local.gets in between, but at this point // we don't care. Call->getOperand(1).setReg(Catch->getOperand(0).getReg()); auto InsertPos = std::next(MachineBasicBlock::iterator(Catch)); Index: lib/Target/WebAssembly/WebAssemblyRegStackify.cpp =================================================================== --- lib/Target/WebAssembly/WebAssemblyRegStackify.cpp +++ lib/Target/WebAssembly/WebAssemblyRegStackify.cpp @@ -425,8 +425,8 @@ // Actually, dominating is over-conservative. Test that the use would // happen after the one selected use in the stack evaluation order. // - // This is needed as a consequence of using implicit get_locals for - // uses and implicit set_locals for defs. + // This is needed as a consequence of using implicit local.gets for + // uses and implicit local.sets for defs. if (UseInst->getDesc().getNumDefs() == 0) return false; const MachineOperand &MO = UseInst->getOperand(0); @@ -628,7 +628,7 @@ /// INST ..., Reg, ... /// INST ..., Reg, ... /// -/// with DefReg and TeeReg stackified. This eliminates a get_local from the +/// with DefReg and TeeReg stackified. This eliminates a local.get from the /// resulting code. static MachineInstr *MoveAndTeeForMultiUse( unsigned Reg, MachineOperand &Op, MachineInstr *Def, MachineBasicBlock &MBB, @@ -739,8 +739,8 @@ /// operand in the tree that we haven't visited yet. Moving a definition of /// Reg to a point in the tree after that would change its value. /// - /// This is needed as a consequence of using implicit get_locals for - /// uses and implicit set_locals for defs. + /// This is needed as a consequence of using implicit local.gets for + /// uses and implicit local.sets for defs. bool IsOnStack(unsigned Reg) const { for (const RangeTy &Range : Worklist) for (const MachineOperand &MO : Range) Index: lib/Target/WebAssembly/WebAssemblyStoreResults.cpp =================================================================== --- lib/Target/WebAssembly/WebAssemblyStoreResults.cpp +++ lib/Target/WebAssembly/WebAssemblyStoreResults.cpp @@ -15,7 +15,7 @@ /// the store's result value, making the stored value register more likely to /// be single-use, thus more likely to be useful to register stackifying, and /// potentially also exposing the store to register stackifying. These both can -/// reduce get_local/set_local traffic. +/// reduce local.get/local.set traffic. /// /// This pass also performs this optimization for memcpy, memmove, and memset /// calls, since the LLVM intrinsics for these return void so they can't use the Index: lib/Target/WebAssembly/WebAssemblyTargetMachine.cpp =================================================================== --- lib/Target/WebAssembly/WebAssemblyTargetMachine.cpp +++ lib/Target/WebAssembly/WebAssemblyTargetMachine.cpp @@ -320,12 +320,12 @@ addPass(createWebAssemblyRegColoring()); } - // Eliminate multiple-entry loops. Do this before inserting explicit get_local - // and set_local operators because we create a new variable that we want + // Eliminate multiple-entry loops. Do this before inserting explicit local.get + // and local.set operators because we create a new variable that we want // converted into a local. addPass(createWebAssemblyFixIrreducibleControlFlow()); - // Insert explicit get_local and set_local operators. + // Insert explicit local.get and local.set operators. addPass(createWebAssemblyExplicitLocals()); // Do various transformations for exception handling Index: test/CodeGen/WebAssembly/atomic-rmw.ll =================================================================== --- test/CodeGen/WebAssembly/atomic-rmw.ll +++ test/CodeGen/WebAssembly/atomic-rmw.ll @@ -276,7 +276,7 @@ ; CHECK-LABEL: add_sext_i8_i32: ; CHECK-NEXT: .functype add_sext_i8_i32 (i32, i32) -> (i32){{$}} -; CHECK: i32.atomic.rmw8_u.add $push0=, 0($0), $1{{$}} +; CHECK: i32.atomic.rmw8.add_u $push0=, 0($0), $1{{$}} ; CHECK-NEXT: i32.extend8_s $push1=, $pop0{{$}} ; CHECK-NEXT: return $pop1{{$}} define i32 @add_sext_i8_i32(i8* %p, i32 %v) { @@ -288,7 +288,7 @@ ; CHECK-LABEL: add_sext_i16_i32: ; CHECK-NEXT: .functype add_sext_i16_i32 (i32, i32) -> (i32){{$}} -; CHECK: i32.atomic.rmw16_u.add $push0=, 0($0), $1{{$}} +; CHECK: i32.atomic.rmw16.add_u $push0=, 0($0), $1{{$}} ; CHECK-NEXT: i32.extend16_s $push1=, $pop0{{$}} ; CHECK-NEXT: return $pop1{{$}} define i32 @add_sext_i16_i32(i16* %p, i32 %v) { @@ -300,7 +300,7 @@ ; CHECK-LABEL: add_sext_i8_i64: ; CHECK-NEXT: .functype add_sext_i8_i64 (i32, i64) -> (i64){{$}} -; CHECK: i64.atomic.rmw8_u.add $push0=, 0($0), $1{{$}} +; CHECK: i64.atomic.rmw8.add_u $push0=, 0($0), $1{{$}} ; CHECK-NEXT: i64.extend8_s $push1=, $pop0{{$}} ; CHECK-NEXT: return $pop1{{$}} define i64 @add_sext_i8_i64(i8* %p, i64 %v) { @@ -312,7 +312,7 @@ ; CHECK-LABEL: add_sext_i16_i64: ; CHECK-NEXT: .functype add_sext_i16_i64 (i32, i64) -> (i64){{$}} -; CHECK: i64.atomic.rmw16_u.add $push0=, 0($0), $1{{$}} +; CHECK: i64.atomic.rmw16.add_u $push0=, 0($0), $1{{$}} ; CHECK-NEXT: i64.extend16_s $push1=, $pop0{{$}} ; CHECK-NEXT: return $pop1{{$}} define i64 @add_sext_i16_i64(i16* %p, i64 %v) { @@ -322,12 +322,12 @@ ret i64 %e } -; 32->64 sext rmw gets selected as i32.atomic.rmw.add, i64_extend_s/i32 +; 32->64 sext rmw gets selected as i32.atomic.rmw.add, i64.extend_i32_s ; CHECK-LABEL: add_sext_i32_i64: ; CHECK-NEXT: .functype add_sext_i32_i64 (i32, i64) -> (i64){{$}} -; CHECK: i32.wrap/i64 $push0=, $1{{$}} +; CHECK: i32.wrap_i64 $push0=, $1{{$}} ; CHECK: i32.atomic.rmw.add $push1=, 0($0), $pop0{{$}} -; CHECK-NEXT: i64.extend_s/i32 $push2=, $pop1{{$}} +; CHECK-NEXT: i64.extend_i32_s $push2=, $pop1{{$}} ; CHECK-NEXT: return $pop2{{$}} define i64 @add_sext_i32_i64(i32* %p, i64 %v) { %t = trunc i64 %v to i32 @@ -340,7 +340,7 @@ ; CHECK-LABEL: sub_sext_i8_i32: ; CHECK-NEXT: .functype sub_sext_i8_i32 (i32, i32) -> (i32){{$}} -; CHECK: i32.atomic.rmw8_u.sub $push0=, 0($0), $1{{$}} +; CHECK: i32.atomic.rmw8.sub_u $push0=, 0($0), $1{{$}} ; CHECK-NEXT: i32.extend8_s $push1=, $pop0{{$}} ; CHECK-NEXT: return $pop1{{$}} define i32 @sub_sext_i8_i32(i8* %p, i32 %v) { @@ -352,7 +352,7 @@ ; CHECK-LABEL: sub_sext_i16_i32: ; CHECK-NEXT: .functype sub_sext_i16_i32 (i32, i32) -> (i32){{$}} -; CHECK: i32.atomic.rmw16_u.sub $push0=, 0($0), $1{{$}} +; CHECK: i32.atomic.rmw16.sub_u $push0=, 0($0), $1{{$}} ; CHECK-NEXT: i32.extend16_s $push1=, $pop0{{$}} ; CHECK-NEXT: return $pop1{{$}} define i32 @sub_sext_i16_i32(i16* %p, i32 %v) { @@ -364,7 +364,7 @@ ; CHECK-LABEL: sub_sext_i8_i64: ; CHECK-NEXT: .functype sub_sext_i8_i64 (i32, i64) -> (i64){{$}} -; CHECK: i64.atomic.rmw8_u.sub $push0=, 0($0), $1{{$}} +; CHECK: i64.atomic.rmw8.sub_u $push0=, 0($0), $1{{$}} ; CHECK-NEXT: i64.extend8_s $push1=, $pop0{{$}} ; CHECK-NEXT: return $pop1{{$}} define i64 @sub_sext_i8_i64(i8* %p, i64 %v) { @@ -376,7 +376,7 @@ ; CHECK-LABEL: sub_sext_i16_i64: ; CHECK-NEXT: .functype sub_sext_i16_i64 (i32, i64) -> (i64){{$}} -; CHECK: i64.atomic.rmw16_u.sub $push0=, 0($0), $1{{$}} +; CHECK: i64.atomic.rmw16.sub_u $push0=, 0($0), $1{{$}} ; CHECK-NEXT: i64.extend16_s $push1=, $pop0{{$}} ; CHECK-NEXT: return $pop1{{$}} define i64 @sub_sext_i16_i64(i16* %p, i64 %v) { @@ -386,12 +386,12 @@ ret i64 %e } -; 32->64 sext rmw gets selected as i32.atomic.rmw.sub, i64_extend_s/i32 +; 32->64 sext rmw gets selected as i32.atomic.rmw.sub, i64.extend_i32_s ; CHECK-LABEL: sub_sext_i32_i64: ; CHECK-NEXT: .functype sub_sext_i32_i64 (i32, i64) -> (i64){{$}} -; CHECK: i32.wrap/i64 $push0=, $1 +; CHECK: i32.wrap_i64 $push0=, $1 ; CHECK: i32.atomic.rmw.sub $push1=, 0($0), $pop0{{$}} -; CHECK-NEXT: i64.extend_s/i32 $push2=, $pop1{{$}} +; CHECK-NEXT: i64.extend_i32_s $push2=, $pop1{{$}} ; CHECK-NEXT: return $pop2{{$}} define i64 @sub_sext_i32_i64(i32* %p, i64 %v) { %t = trunc i64 %v to i32 @@ -404,7 +404,7 @@ ; CHECK-LABEL: and_sext_i8_i32: ; CHECK-NEXT: .functype and_sext_i8_i32 (i32, i32) -> (i32){{$}} -; CHECK: i32.atomic.rmw8_u.and $push0=, 0($0), $1{{$}} +; CHECK: i32.atomic.rmw8.and_u $push0=, 0($0), $1{{$}} ; CHECK-NEXT: i32.extend8_s $push1=, $pop0{{$}} ; CHECK-NEXT: return $pop1{{$}} define i32 @and_sext_i8_i32(i8* %p, i32 %v) { @@ -416,7 +416,7 @@ ; CHECK-LABEL: and_sext_i16_i32: ; CHECK-NEXT: .functype and_sext_i16_i32 (i32, i32) -> (i32){{$}} -; CHECK: i32.atomic.rmw16_u.and $push0=, 0($0), $1{{$}} +; CHECK: i32.atomic.rmw16.and_u $push0=, 0($0), $1{{$}} ; CHECK-NEXT: i32.extend16_s $push1=, $pop0{{$}} ; CHECK-NEXT: return $pop1{{$}} define i32 @and_sext_i16_i32(i16* %p, i32 %v) { @@ -428,7 +428,7 @@ ; CHECK-LABEL: and_sext_i8_i64: ; CHECK-NEXT: .functype and_sext_i8_i64 (i32, i64) -> (i64){{$}} -; CHECK: i64.atomic.rmw8_u.and $push0=, 0($0), $1{{$}} +; CHECK: i64.atomic.rmw8.and_u $push0=, 0($0), $1{{$}} ; CHECK-NEXT: i64.extend8_s $push1=, $pop0{{$}} ; CHECK-NEXT: return $pop1{{$}} define i64 @and_sext_i8_i64(i8* %p, i64 %v) { @@ -440,7 +440,7 @@ ; CHECK-LABEL: and_sext_i16_i64: ; CHECK-NEXT: .functype and_sext_i16_i64 (i32, i64) -> (i64){{$}} -; CHECK: i64.atomic.rmw16_u.and $push0=, 0($0), $1{{$}} +; CHECK: i64.atomic.rmw16.and_u $push0=, 0($0), $1{{$}} ; CHECK-NEXT: i64.extend16_s $push1=, $pop0{{$}} ; CHECK-NEXT: return $pop1{{$}} define i64 @and_sext_i16_i64(i16* %p, i64 %v) { @@ -450,12 +450,12 @@ ret i64 %e } -; 32->64 sext rmw gets selected as i32.atomic.rmw.and, i64_extend_s/i32 +; 32->64 sext rmw gets selected as i32.atomic.rmw.and, i64.extend_i32_s ; CHECK-LABEL: and_sext_i32_i64: ; CHECK-NEXT: .functype and_sext_i32_i64 (i32, i64) -> (i64){{$}} -; CHECK: i32.wrap/i64 $push0=, $1{{$}} +; CHECK: i32.wrap_i64 $push0=, $1{{$}} ; CHECK: i32.atomic.rmw.and $push1=, 0($0), $pop0{{$}} -; CHECK-NEXT: i64.extend_s/i32 $push2=, $pop1{{$}} +; CHECK-NEXT: i64.extend_i32_s $push2=, $pop1{{$}} ; CHECK-NEXT: return $pop2{{$}} define i64 @and_sext_i32_i64(i32* %p, i64 %v) { %t = trunc i64 %v to i32 @@ -468,7 +468,7 @@ ; CHECK-LABEL: or_sext_i8_i32: ; CHECK-NEXT: .functype or_sext_i8_i32 (i32, i32) -> (i32){{$}} -; CHECK: i32.atomic.rmw8_u.or $push0=, 0($0), $1{{$}} +; CHECK: i32.atomic.rmw8.or_u $push0=, 0($0), $1{{$}} ; CHECK-NEXT: i32.extend8_s $push1=, $pop0{{$}} ; CHECK-NEXT: return $pop1{{$}} define i32 @or_sext_i8_i32(i8* %p, i32 %v) { @@ -480,7 +480,7 @@ ; CHECK-LABEL: or_sext_i16_i32: ; CHECK-NEXT: .functype or_sext_i16_i32 (i32, i32) -> (i32){{$}} -; CHECK: i32.atomic.rmw16_u.or $push0=, 0($0), $1{{$}} +; CHECK: i32.atomic.rmw16.or_u $push0=, 0($0), $1{{$}} ; CHECK-NEXT: i32.extend16_s $push1=, $pop0{{$}} ; CHECK-NEXT: return $pop1{{$}} define i32 @or_sext_i16_i32(i16* %p, i32 %v) { @@ -492,7 +492,7 @@ ; CHECK-LABEL: or_sext_i8_i64: ; CHECK-NEXT: .functype or_sext_i8_i64 (i32, i64) -> (i64){{$}} -; CHECK: i64.atomic.rmw8_u.or $push0=, 0($0), $1{{$}} +; CHECK: i64.atomic.rmw8.or_u $push0=, 0($0), $1{{$}} ; CHECK-NEXT: i64.extend8_s $push1=, $pop0{{$}} ; CHECK-NEXT: return $pop1{{$}} define i64 @or_sext_i8_i64(i8* %p, i64 %v) { @@ -504,7 +504,7 @@ ; CHECK-LABEL: or_sext_i16_i64: ; CHECK-NEXT: .functype or_sext_i16_i64 (i32, i64) -> (i64){{$}} -; CHECK: i64.atomic.rmw16_u.or $push0=, 0($0), $1{{$}} +; CHECK: i64.atomic.rmw16.or_u $push0=, 0($0), $1{{$}} ; CHECK-NEXT: i64.extend16_s $push1=, $pop0{{$}} ; CHECK-NEXT: return $pop1{{$}} define i64 @or_sext_i16_i64(i16* %p, i64 %v) { @@ -514,12 +514,12 @@ ret i64 %e } -; 32->64 sext rmw gets selected as i32.atomic.rmw.or, i64_extend_s/i32 +; 32->64 sext rmw gets selected as i32.atomic.rmw.or, i64.extend_i32_s ; CHECK-LABEL: or_sext_i32_i64: ; CHECK-NEXT: .functype or_sext_i32_i64 (i32, i64) -> (i64){{$}} -; CHECK: i32.wrap/i64 $push0=, $1{{$}} +; CHECK: i32.wrap_i64 $push0=, $1{{$}} ; CHECK: i32.atomic.rmw.or $push1=, 0($0), $pop0{{$}} -; CHECK-NEXT: i64.extend_s/i32 $push2=, $pop1{{$}} +; CHECK-NEXT: i64.extend_i32_s $push2=, $pop1{{$}} ; CHECK-NEXT: return $pop2{{$}} define i64 @or_sext_i32_i64(i32* %p, i64 %v) { %t = trunc i64 %v to i32 @@ -532,7 +532,7 @@ ; CHECK-LABEL: xor_sext_i8_i32: ; CHECK-NEXT: .functype xor_sext_i8_i32 (i32, i32) -> (i32){{$}} -; CHECK: i32.atomic.rmw8_u.xor $push0=, 0($0), $1{{$}} +; CHECK: i32.atomic.rmw8.xor_u $push0=, 0($0), $1{{$}} ; CHECK-NEXT: i32.extend8_s $push1=, $pop0{{$}} ; CHECK-NEXT: return $pop1{{$}} define i32 @xor_sext_i8_i32(i8* %p, i32 %v) { @@ -544,7 +544,7 @@ ; CHECK-LABEL: xor_sext_i16_i32: ; CHECK-NEXT: .functype xor_sext_i16_i32 (i32, i32) -> (i32){{$}} -; CHECK: i32.atomic.rmw16_u.xor $push0=, 0($0), $1{{$}} +; CHECK: i32.atomic.rmw16.xor_u $push0=, 0($0), $1{{$}} ; CHECK-NEXT: i32.extend16_s $push1=, $pop0{{$}} ; CHECK-NEXT: return $pop1{{$}} define i32 @xor_sext_i16_i32(i16* %p, i32 %v) { @@ -556,7 +556,7 @@ ; CHECK-LABEL: xor_sext_i8_i64: ; CHECK-NEXT: .functype xor_sext_i8_i64 (i32, i64) -> (i64){{$}} -; CHECK: i64.atomic.rmw8_u.xor $push0=, 0($0), $1{{$}} +; CHECK: i64.atomic.rmw8.xor_u $push0=, 0($0), $1{{$}} ; CHECK-NEXT: i64.extend8_s $push1=, $pop0{{$}} ; CHECK-NEXT: return $pop1{{$}} define i64 @xor_sext_i8_i64(i8* %p, i64 %v) { @@ -568,7 +568,7 @@ ; CHECK-LABEL: xor_sext_i16_i64: ; CHECK-NEXT: .functype xor_sext_i16_i64 (i32, i64) -> (i64){{$}} -; CHECK: i64.atomic.rmw16_u.xor $push0=, 0($0), $1{{$}} +; CHECK: i64.atomic.rmw16.xor_u $push0=, 0($0), $1{{$}} ; CHECK-NEXT: i64.extend16_s $push1=, $pop0{{$}} ; CHECK-NEXT: return $pop1{{$}} define i64 @xor_sext_i16_i64(i16* %p, i64 %v) { @@ -578,12 +578,12 @@ ret i64 %e } -; 32->64 sext rmw gets selected as i32.atomic.rmw.xor, i64_extend_s/i32 +; 32->64 sext rmw gets selected as i32.atomic.rmw.xor, i64.extend_i32_s ; CHECK-LABEL: xor_sext_i32_i64: ; CHECK-NEXT: .functype xor_sext_i32_i64 (i32, i64) -> (i64){{$}} -; CHECK: i32.wrap/i64 $push0=, $1{{$}} +; CHECK: i32.wrap_i64 $push0=, $1{{$}} ; CHECK: i32.atomic.rmw.xor $push1=, 0($0), $pop0{{$}} -; CHECK-NEXT: i64.extend_s/i32 $push2=, $pop1{{$}} +; CHECK-NEXT: i64.extend_i32_s $push2=, $pop1{{$}} ; CHECK-NEXT: return $pop2{{$}} define i64 @xor_sext_i32_i64(i32* %p, i64 %v) { %t = trunc i64 %v to i32 @@ -596,7 +596,7 @@ ; CHECK-LABEL: xchg_sext_i8_i32: ; CHECK-NEXT: .functype xchg_sext_i8_i32 (i32, i32) -> (i32){{$}} -; CHECK: i32.atomic.rmw8_u.xchg $push0=, 0($0), $1{{$}} +; CHECK: i32.atomic.rmw8.xchg_u $push0=, 0($0), $1{{$}} ; CHECK-NEXT: i32.extend8_s $push1=, $pop0{{$}} ; CHECK-NEXT: return $pop1{{$}} define i32 @xchg_sext_i8_i32(i8* %p, i32 %v) { @@ -608,7 +608,7 @@ ; CHECK-LABEL: xchg_sext_i16_i32: ; CHECK-NEXT: .functype xchg_sext_i16_i32 (i32, i32) -> (i32){{$}} -; CHECK: i32.atomic.rmw16_u.xchg $push0=, 0($0), $1{{$}} +; CHECK: i32.atomic.rmw16.xchg_u $push0=, 0($0), $1{{$}} ; CHECK-NEXT: i32.extend16_s $push1=, $pop0{{$}} ; CHECK-NEXT: return $pop1{{$}} define i32 @xchg_sext_i16_i32(i16* %p, i32 %v) { @@ -620,7 +620,7 @@ ; CHECK-LABEL: xchg_sext_i8_i64: ; CHECK-NEXT: .functype xchg_sext_i8_i64 (i32, i64) -> (i64){{$}} -; CHECK: i64.atomic.rmw8_u.xchg $push0=, 0($0), $1{{$}} +; CHECK: i64.atomic.rmw8.xchg_u $push0=, 0($0), $1{{$}} ; CHECK-NEXT: i64.extend8_s $push1=, $pop0{{$}} ; CHECK-NEXT: return $pop1{{$}} define i64 @xchg_sext_i8_i64(i8* %p, i64 %v) { @@ -632,7 +632,7 @@ ; CHECK-LABEL: xchg_sext_i16_i64: ; CHECK-NEXT: .functype xchg_sext_i16_i64 (i32, i64) -> (i64){{$}} -; CHECK: i64.atomic.rmw16_u.xchg $push0=, 0($0), $1{{$}} +; CHECK: i64.atomic.rmw16.xchg_u $push0=, 0($0), $1{{$}} ; CHECK-NEXT: i64.extend16_s $push1=, $pop0{{$}} ; CHECK-NEXT: return $pop1{{$}} define i64 @xchg_sext_i16_i64(i16* %p, i64 %v) { @@ -642,12 +642,12 @@ ret i64 %e } -; 32->64 sext rmw gets selected as i32.atomic.rmw.xchg, i64_extend_s/i32 +; 32->64 sext rmw gets selected as i32.atomic.rmw.xchg, i64.extend_i32_s ; CHECK-LABEL: xchg_sext_i32_i64: ; CHECK-NEXT: .functype xchg_sext_i32_i64 (i32, i64) -> (i64){{$}} -; CHECK: i32.wrap/i64 $push0=, $1{{$}} +; CHECK: i32.wrap_i64 $push0=, $1{{$}} ; CHECK: i32.atomic.rmw.xchg $push1=, 0($0), $pop0{{$}} -; CHECK-NEXT: i64.extend_s/i32 $push2=, $pop1{{$}} +; CHECK-NEXT: i64.extend_i32_s $push2=, $pop1{{$}} ; CHECK-NEXT: return $pop2{{$}} define i64 @xchg_sext_i32_i64(i32* %p, i64 %v) { %t = trunc i64 %v to i32 @@ -660,7 +660,7 @@ ; CHECK-LABEL: cmpxchg_sext_i8_i32: ; CHECK-NEXT: .functype cmpxchg_sext_i8_i32 (i32, i32, i32) -> (i32){{$}} -; CHECK: i32.atomic.rmw8_u.cmpxchg $push0=, 0($0), $1, $2{{$}} +; CHECK: i32.atomic.rmw8.cmpxchg_u $push0=, 0($0), $1, $2{{$}} ; CHECK-NEXT: i32.extend8_s $push1=, $pop0{{$}} ; CHECK-NEXT: return $pop1{{$}} define i32 @cmpxchg_sext_i8_i32(i8* %p, i32 %exp, i32 %new) { @@ -674,7 +674,7 @@ ; CHECK-LABEL: cmpxchg_sext_i16_i32: ; CHECK-NEXT: .functype cmpxchg_sext_i16_i32 (i32, i32, i32) -> (i32){{$}} -; CHECK: i32.atomic.rmw16_u.cmpxchg $push0=, 0($0), $1, $2{{$}} +; CHECK: i32.atomic.rmw16.cmpxchg_u $push0=, 0($0), $1, $2{{$}} ; CHECK-NEXT: i32.extend16_s $push1=, $pop0{{$}} ; CHECK-NEXT: return $pop1{{$}} define i32 @cmpxchg_sext_i16_i32(i16* %p, i32 %exp, i32 %new) { @@ -688,7 +688,7 @@ ; CHECK-LABEL: cmpxchg_sext_i8_i64: ; CHECK-NEXT: .functype cmpxchg_sext_i8_i64 (i32, i64, i64) -> (i64){{$}} -; CHECK: i64.atomic.rmw8_u.cmpxchg $push0=, 0($0), $1, $2{{$}} +; CHECK: i64.atomic.rmw8.cmpxchg_u $push0=, 0($0), $1, $2{{$}} ; CHECK-NEXT: i64.extend8_s $push1=, $pop0{{$}} ; CHECK-NEXT: return $pop1{{$}} define i64 @cmpxchg_sext_i8_i64(i8* %p, i64 %exp, i64 %new) { @@ -702,7 +702,7 @@ ; CHECK-LABEL: cmpxchg_sext_i16_i64: ; CHECK-NEXT: .functype cmpxchg_sext_i16_i64 (i32, i64, i64) -> (i64){{$}} -; CHECK: i64.atomic.rmw16_u.cmpxchg $push0=, 0($0), $1, $2{{$}} +; CHECK: i64.atomic.rmw16.cmpxchg_u $push0=, 0($0), $1, $2{{$}} ; CHECK-NEXT: i64.extend16_s $push1=, $pop0{{$}} ; CHECK-NEXT: return $pop1{{$}} define i64 @cmpxchg_sext_i16_i64(i16* %p, i64 %exp, i64 %new) { @@ -714,13 +714,13 @@ ret i64 %e } -; 32->64 sext rmw gets selected as i32.atomic.rmw.cmpxchg, i64_extend_s/i32 +; 32->64 sext rmw gets selected as i32.atomic.rmw.cmpxchg, i64.extend_i32_s ; CHECK-LABEL: cmpxchg_sext_i32_i64: ; CHECK-NEXT: .functype cmpxchg_sext_i32_i64 (i32, i64, i64) -> (i64){{$}} -; CHECK: i32.wrap/i64 $push1=, $1{{$}} -; CHECK-NEXT: i32.wrap/i64 $push0=, $2{{$}} +; CHECK: i32.wrap_i64 $push1=, $1{{$}} +; CHECK-NEXT: i32.wrap_i64 $push0=, $2{{$}} ; CHECK-NEXT: i32.atomic.rmw.cmpxchg $push2=, 0($0), $pop1, $pop0{{$}} -; CHECK-NEXT: i64.extend_s/i32 $push3=, $pop2{{$}} +; CHECK-NEXT: i64.extend_i32_s $push3=, $pop2{{$}} ; CHECK-NEXT: return $pop3{{$}} define i64 @cmpxchg_sext_i32_i64(i32* %p, i64 %exp, i64 %new) { %exp_t = trunc i64 %exp to i32 @@ -739,7 +739,7 @@ ; CHECK-LABEL: nand_sext_i8_i32: ; CHECK-NEXT: .functype nand_sext_i8_i32 (i32, i32) -> (i32){{$}} ; CHECK: loop -; CHECK: i32.atomic.rmw8_u.cmpxchg +; CHECK: i32.atomic.rmw8.cmpxchg_u ; CHECK: i32.extend8_s define i32 @nand_sext_i8_i32(i8* %p, i32 %v) { %t = trunc i32 %v to i8 @@ -751,7 +751,7 @@ ; CHECK-LABEL: nand_sext_i16_i32: ; CHECK-NEXT: .functype nand_sext_i16_i32 (i32, i32) -> (i32){{$}} ; CHECK: loop -; CHECK: i32.atomic.rmw16_u.cmpxchg +; CHECK: i32.atomic.rmw16.cmpxchg_u ; CHECK: i32.extend16_s define i32 @nand_sext_i16_i32(i16* %p, i32 %v) { %t = trunc i32 %v to i16 @@ -760,12 +760,12 @@ ret i32 %e } -; FIXME Currently this cannot make use of i64.atomic.rmw8_u.cmpxchg +; FIXME Currently this cannot make use of i64.atomic.rmw8.cmpxchg_u ; CHECK-LABEL: nand_sext_i8_i64: ; CHECK-NEXT: .functype nand_sext_i8_i64 (i32, i64) -> (i64){{$}} ; CHECK: loop -; CHECK: i32.atomic.rmw8_u.cmpxchg -; CHECK: i64.extend_u/i32 +; CHECK: i32.atomic.rmw8.cmpxchg_u +; CHECK: i64.extend_i32_u ; CHECK: i64.extend8_s define i64 @nand_sext_i8_i64(i8* %p, i64 %v) { %t = trunc i64 %v to i8 @@ -774,12 +774,12 @@ ret i64 %e } -; FIXME Currently this cannot make use of i64.atomic.rmw16_u.cmpxchg +; FIXME Currently this cannot make use of i64.atomic.rmw16.cmpxchg_u ; CHECK-LABEL: nand_sext_i16_i64: ; CHECK-NEXT: .functype nand_sext_i16_i64 (i32, i64) -> (i64){{$}} ; CHECK: loop -; CHECK: i32.atomic.rmw16_u.cmpxchg -; CHECK: i64.extend_u/i32 +; CHECK: i32.atomic.rmw16.cmpxchg_u +; CHECK: i64.extend_i32_u ; CHECK: i64.extend16_s define i64 @nand_sext_i16_i64(i16* %p, i64 %v) { %t = trunc i64 %v to i16 @@ -788,12 +788,12 @@ ret i64 %e } -; 32->64 sext rmw gets selected as i32.atomic.rmw.nand, i64_extend_s/i32 +; 32->64 sext rmw gets selected as i32.atomic.rmw.nand, i64.extend_i32_s ; CHECK-LABEL: nand_sext_i32_i64: ; CHECK-NEXT: .functype nand_sext_i32_i64 (i32, i64) -> (i64){{$}} ; CHECK: loop ; CHECK: i32.atomic.rmw.cmpxchg -; CHECK: i64.extend_s/i32 +; CHECK: i64.extend_i32_s define i64 @nand_sext_i32_i64(i32* %p, i64 %v) { %t = trunc i64 %v to i32 %old = atomicrmw nand i32* %p, i32 %t seq_cst @@ -809,7 +809,7 @@ ; CHECK-LABEL: add_zext_i8_i32: ; CHECK-NEXT: .functype add_zext_i8_i32 (i32, i32) -> (i32){{$}} -; CHECK: i32.atomic.rmw8_u.add $push0=, 0($0), $1{{$}} +; CHECK: i32.atomic.rmw8.add_u $push0=, 0($0), $1{{$}} ; CHECK-NEXT: return $pop0{{$}} define i32 @add_zext_i8_i32(i8* %p, i32 %v) { %t = trunc i32 %v to i8 @@ -820,7 +820,7 @@ ; CHECK-LABEL: add_zext_i16_i32: ; CHECK-NEXT: .functype add_zext_i16_i32 (i32, i32) -> (i32){{$}} -; CHECK: i32.atomic.rmw16_u.add $push0=, 0($0), $1{{$}} +; CHECK: i32.atomic.rmw16.add_u $push0=, 0($0), $1{{$}} ; CHECK-NEXT: return $pop0{{$}} define i32 @add_zext_i16_i32(i16* %p, i32 %v) { %t = trunc i32 %v to i16 @@ -831,7 +831,7 @@ ; CHECK-LABEL: add_zext_i8_i64: ; CHECK-NEXT: .functype add_zext_i8_i64 (i32, i64) -> (i64){{$}} -; CHECK: i64.atomic.rmw8_u.add $push0=, 0($0), $1{{$}} +; CHECK: i64.atomic.rmw8.add_u $push0=, 0($0), $1{{$}} ; CHECK-NEXT: return $pop0{{$}} define i64 @add_zext_i8_i64(i8* %p, i64 %v) { %t = trunc i64 %v to i8 @@ -842,7 +842,7 @@ ; CHECK-LABEL: add_zext_i16_i64: ; CHECK-NEXT: .functype add_zext_i16_i64 (i32, i64) -> (i64){{$}} -; CHECK: i64.atomic.rmw16_u.add $push0=, 0($0), $1{{$}} +; CHECK: i64.atomic.rmw16.add_u $push0=, 0($0), $1{{$}} ; CHECK-NEXT: return $pop0{{$}} define i64 @add_zext_i16_i64(i16* %p, i64 %v) { %t = trunc i64 %v to i16 @@ -853,7 +853,7 @@ ; CHECK-LABEL: add_zext_i32_i64: ; CHECK-NEXT: .functype add_zext_i32_i64 (i32, i64) -> (i64){{$}} -; CHECK: i64.atomic.rmw32_u.add $push0=, 0($0), $1{{$}} +; CHECK: i64.atomic.rmw32.add_u $push0=, 0($0), $1{{$}} ; CHECK-NEXT: return $pop0{{$}} define i64 @add_zext_i32_i64(i32* %p, i64 %v) { %t = trunc i64 %v to i32 @@ -866,7 +866,7 @@ ; CHECK-LABEL: sub_zext_i8_i32: ; CHECK-NEXT: .functype sub_zext_i8_i32 (i32, i32) -> (i32){{$}} -; CHECK: i32.atomic.rmw8_u.sub $push0=, 0($0), $1{{$}} +; CHECK: i32.atomic.rmw8.sub_u $push0=, 0($0), $1{{$}} ; CHECK-NEXT: return $pop0{{$}} define i32 @sub_zext_i8_i32(i8* %p, i32 %v) { %t = trunc i32 %v to i8 @@ -877,7 +877,7 @@ ; CHECK-LABEL: sub_zext_i16_i32: ; CHECK-NEXT: .functype sub_zext_i16_i32 (i32, i32) -> (i32){{$}} -; CHECK: i32.atomic.rmw16_u.sub $push0=, 0($0), $1{{$}} +; CHECK: i32.atomic.rmw16.sub_u $push0=, 0($0), $1{{$}} ; CHECK-NEXT: return $pop0{{$}} define i32 @sub_zext_i16_i32(i16* %p, i32 %v) { %t = trunc i32 %v to i16 @@ -888,7 +888,7 @@ ; CHECK-LABEL: sub_zext_i8_i64: ; CHECK-NEXT: .functype sub_zext_i8_i64 (i32, i64) -> (i64){{$}} -; CHECK: i64.atomic.rmw8_u.sub $push0=, 0($0), $1{{$}} +; CHECK: i64.atomic.rmw8.sub_u $push0=, 0($0), $1{{$}} ; CHECK-NEXT: return $pop0{{$}} define i64 @sub_zext_i8_i64(i8* %p, i64 %v) { %t = trunc i64 %v to i8 @@ -899,7 +899,7 @@ ; CHECK-LABEL: sub_zext_i16_i64: ; CHECK-NEXT: .functype sub_zext_i16_i64 (i32, i64) -> (i64){{$}} -; CHECK: i64.atomic.rmw16_u.sub $push0=, 0($0), $1{{$}} +; CHECK: i64.atomic.rmw16.sub_u $push0=, 0($0), $1{{$}} ; CHECK-NEXT: return $pop0{{$}} define i64 @sub_zext_i16_i64(i16* %p, i64 %v) { %t = trunc i64 %v to i16 @@ -910,7 +910,7 @@ ; CHECK-LABEL: sub_zext_i32_i64: ; CHECK-NEXT: .functype sub_zext_i32_i64 (i32, i64) -> (i64){{$}} -; CHECK: i64.atomic.rmw32_u.sub $push0=, 0($0), $1{{$}} +; CHECK: i64.atomic.rmw32.sub_u $push0=, 0($0), $1{{$}} ; CHECK-NEXT: return $pop0{{$}} define i64 @sub_zext_i32_i64(i32* %p, i64 %v) { %t = trunc i64 %v to i32 @@ -923,7 +923,7 @@ ; CHECK-LABEL: and_zext_i8_i32: ; CHECK-NEXT: .functype and_zext_i8_i32 (i32, i32) -> (i32){{$}} -; CHECK: i32.atomic.rmw8_u.and $push0=, 0($0), $1{{$}} +; CHECK: i32.atomic.rmw8.and_u $push0=, 0($0), $1{{$}} ; CHECK-NEXT: return $pop0{{$}} define i32 @and_zext_i8_i32(i8* %p, i32 %v) { %t = trunc i32 %v to i8 @@ -934,7 +934,7 @@ ; CHECK-LABEL: and_zext_i16_i32: ; CHECK-NEXT: .functype and_zext_i16_i32 (i32, i32) -> (i32){{$}} -; CHECK: i32.atomic.rmw16_u.and $push0=, 0($0), $1{{$}} +; CHECK: i32.atomic.rmw16.and_u $push0=, 0($0), $1{{$}} ; CHECK-NEXT: return $pop0{{$}} define i32 @and_zext_i16_i32(i16* %p, i32 %v) { %t = trunc i32 %v to i16 @@ -945,7 +945,7 @@ ; CHECK-LABEL: and_zext_i8_i64: ; CHECK-NEXT: .functype and_zext_i8_i64 (i32, i64) -> (i64){{$}} -; CHECK: i64.atomic.rmw8_u.and $push0=, 0($0), $1{{$}} +; CHECK: i64.atomic.rmw8.and_u $push0=, 0($0), $1{{$}} ; CHECK-NEXT: return $pop0{{$}} define i64 @and_zext_i8_i64(i8* %p, i64 %v) { %t = trunc i64 %v to i8 @@ -956,7 +956,7 @@ ; CHECK-LABEL: and_zext_i16_i64: ; CHECK-NEXT: .functype and_zext_i16_i64 (i32, i64) -> (i64){{$}} -; CHECK: i64.atomic.rmw16_u.and $push0=, 0($0), $1{{$}} +; CHECK: i64.atomic.rmw16.and_u $push0=, 0($0), $1{{$}} ; CHECK-NEXT: return $pop0{{$}} define i64 @and_zext_i16_i64(i16* %p, i64 %v) { %t = trunc i64 %v to i16 @@ -967,7 +967,7 @@ ; CHECK-LABEL: and_zext_i32_i64: ; CHECK-NEXT: .functype and_zext_i32_i64 (i32, i64) -> (i64){{$}} -; CHECK: i64.atomic.rmw32_u.and $push0=, 0($0), $1{{$}} +; CHECK: i64.atomic.rmw32.and_u $push0=, 0($0), $1{{$}} ; CHECK-NEXT: return $pop0{{$}} define i64 @and_zext_i32_i64(i32* %p, i64 %v) { %t = trunc i64 %v to i32 @@ -980,7 +980,7 @@ ; CHECK-LABEL: or_zext_i8_i32: ; CHECK-NEXT: .functype or_zext_i8_i32 (i32, i32) -> (i32){{$}} -; CHECK: i32.atomic.rmw8_u.or $push0=, 0($0), $1{{$}} +; CHECK: i32.atomic.rmw8.or_u $push0=, 0($0), $1{{$}} ; CHECK-NEXT: return $pop0{{$}} define i32 @or_zext_i8_i32(i8* %p, i32 %v) { %t = trunc i32 %v to i8 @@ -991,7 +991,7 @@ ; CHECK-LABEL: or_zext_i16_i32: ; CHECK-NEXT: .functype or_zext_i16_i32 (i32, i32) -> (i32){{$}} -; CHECK: i32.atomic.rmw16_u.or $push0=, 0($0), $1{{$}} +; CHECK: i32.atomic.rmw16.or_u $push0=, 0($0), $1{{$}} ; CHECK-NEXT: return $pop0{{$}} define i32 @or_zext_i16_i32(i16* %p, i32 %v) { %t = trunc i32 %v to i16 @@ -1002,7 +1002,7 @@ ; CHECK-LABEL: or_zext_i8_i64: ; CHECK-NEXT: .functype or_zext_i8_i64 (i32, i64) -> (i64){{$}} -; CHECK: i64.atomic.rmw8_u.or $push0=, 0($0), $1{{$}} +; CHECK: i64.atomic.rmw8.or_u $push0=, 0($0), $1{{$}} ; CHECK-NEXT: return $pop0{{$}} define i64 @or_zext_i8_i64(i8* %p, i64 %v) { %t = trunc i64 %v to i8 @@ -1013,7 +1013,7 @@ ; CHECK-LABEL: or_zext_i16_i64: ; CHECK-NEXT: .functype or_zext_i16_i64 (i32, i64) -> (i64){{$}} -; CHECK: i64.atomic.rmw16_u.or $push0=, 0($0), $1{{$}} +; CHECK: i64.atomic.rmw16.or_u $push0=, 0($0), $1{{$}} ; CHECK-NEXT: return $pop0{{$}} define i64 @or_zext_i16_i64(i16* %p, i64 %v) { %t = trunc i64 %v to i16 @@ -1024,7 +1024,7 @@ ; CHECK-LABEL: or_zext_i32_i64: ; CHECK-NEXT: .functype or_zext_i32_i64 (i32, i64) -> (i64){{$}} -; CHECK: i64.atomic.rmw32_u.or $push0=, 0($0), $1{{$}} +; CHECK: i64.atomic.rmw32.or_u $push0=, 0($0), $1{{$}} ; CHECK-NEXT: return $pop0{{$}} define i64 @or_zext_i32_i64(i32* %p, i64 %v) { %t = trunc i64 %v to i32 @@ -1037,7 +1037,7 @@ ; CHECK-LABEL: xor_zext_i8_i32: ; CHECK-NEXT: .functype xor_zext_i8_i32 (i32, i32) -> (i32){{$}} -; CHECK: i32.atomic.rmw8_u.xor $push0=, 0($0), $1{{$}} +; CHECK: i32.atomic.rmw8.xor_u $push0=, 0($0), $1{{$}} ; CHECK-NEXT: return $pop0{{$}} define i32 @xor_zext_i8_i32(i8* %p, i32 %v) { %t = trunc i32 %v to i8 @@ -1048,7 +1048,7 @@ ; CHECK-LABEL: xor_zext_i16_i32: ; CHECK-NEXT: .functype xor_zext_i16_i32 (i32, i32) -> (i32){{$}} -; CHECK: i32.atomic.rmw16_u.xor $push0=, 0($0), $1{{$}} +; CHECK: i32.atomic.rmw16.xor_u $push0=, 0($0), $1{{$}} ; CHECK-NEXT: return $pop0{{$}} define i32 @xor_zext_i16_i32(i16* %p, i32 %v) { %t = trunc i32 %v to i16 @@ -1059,7 +1059,7 @@ ; CHECK-LABEL: xor_zext_i8_i64: ; CHECK-NEXT: .functype xor_zext_i8_i64 (i32, i64) -> (i64){{$}} -; CHECK: i64.atomic.rmw8_u.xor $push0=, 0($0), $1{{$}} +; CHECK: i64.atomic.rmw8.xor_u $push0=, 0($0), $1{{$}} ; CHECK-NEXT: return $pop0{{$}} define i64 @xor_zext_i8_i64(i8* %p, i64 %v) { %t = trunc i64 %v to i8 @@ -1070,7 +1070,7 @@ ; CHECK-LABEL: xor_zext_i16_i64: ; CHECK-NEXT: .functype xor_zext_i16_i64 (i32, i64) -> (i64){{$}} -; CHECK: i64.atomic.rmw16_u.xor $push0=, 0($0), $1{{$}} +; CHECK: i64.atomic.rmw16.xor_u $push0=, 0($0), $1{{$}} ; CHECK-NEXT: return $pop0{{$}} define i64 @xor_zext_i16_i64(i16* %p, i64 %v) { %t = trunc i64 %v to i16 @@ -1081,7 +1081,7 @@ ; CHECK-LABEL: xor_zext_i32_i64: ; CHECK-NEXT: .functype xor_zext_i32_i64 (i32, i64) -> (i64){{$}} -; CHECK: i64.atomic.rmw32_u.xor $push0=, 0($0), $1{{$}} +; CHECK: i64.atomic.rmw32.xor_u $push0=, 0($0), $1{{$}} ; CHECK-NEXT: return $pop0{{$}} define i64 @xor_zext_i32_i64(i32* %p, i64 %v) { %t = trunc i64 %v to i32 @@ -1094,7 +1094,7 @@ ; CHECK-LABEL: xchg_zext_i8_i32: ; CHECK-NEXT: .functype xchg_zext_i8_i32 (i32, i32) -> (i32){{$}} -; CHECK: i32.atomic.rmw8_u.xchg $push0=, 0($0), $1{{$}} +; CHECK: i32.atomic.rmw8.xchg_u $push0=, 0($0), $1{{$}} ; CHECK-NEXT: return $pop0{{$}} define i32 @xchg_zext_i8_i32(i8* %p, i32 %v) { %t = trunc i32 %v to i8 @@ -1105,7 +1105,7 @@ ; CHECK-LABEL: xchg_zext_i16_i32: ; CHECK-NEXT: .functype xchg_zext_i16_i32 (i32, i32) -> (i32){{$}} -; CHECK: i32.atomic.rmw16_u.xchg $push0=, 0($0), $1{{$}} +; CHECK: i32.atomic.rmw16.xchg_u $push0=, 0($0), $1{{$}} ; CHECK-NEXT: return $pop0{{$}} define i32 @xchg_zext_i16_i32(i16* %p, i32 %v) { %t = trunc i32 %v to i16 @@ -1116,7 +1116,7 @@ ; CHECK-LABEL: xchg_zext_i8_i64: ; CHECK-NEXT: .functype xchg_zext_i8_i64 (i32, i64) -> (i64){{$}} -; CHECK: i64.atomic.rmw8_u.xchg $push0=, 0($0), $1{{$}} +; CHECK: i64.atomic.rmw8.xchg_u $push0=, 0($0), $1{{$}} ; CHECK-NEXT: return $pop0{{$}} define i64 @xchg_zext_i8_i64(i8* %p, i64 %v) { %t = trunc i64 %v to i8 @@ -1127,7 +1127,7 @@ ; CHECK-LABEL: xchg_zext_i16_i64: ; CHECK-NEXT: .functype xchg_zext_i16_i64 (i32, i64) -> (i64){{$}} -; CHECK: i64.atomic.rmw16_u.xchg $push0=, 0($0), $1{{$}} +; CHECK: i64.atomic.rmw16.xchg_u $push0=, 0($0), $1{{$}} ; CHECK-NEXT: return $pop0{{$}} define i64 @xchg_zext_i16_i64(i16* %p, i64 %v) { %t = trunc i64 %v to i16 @@ -1138,7 +1138,7 @@ ; CHECK-LABEL: xchg_zext_i32_i64: ; CHECK-NEXT: .functype xchg_zext_i32_i64 (i32, i64) -> (i64){{$}} -; CHECK: i64.atomic.rmw32_u.xchg $push0=, 0($0), $1{{$}} +; CHECK: i64.atomic.rmw32.xchg_u $push0=, 0($0), $1{{$}} ; CHECK-NEXT: return $pop0{{$}} define i64 @xchg_zext_i32_i64(i32* %p, i64 %v) { %t = trunc i64 %v to i32 @@ -1151,7 +1151,7 @@ ; CHECK-LABEL: cmpxchg_zext_i8_i32: ; CHECK-NEXT: .functype cmpxchg_zext_i8_i32 (i32, i32, i32) -> (i32){{$}} -; CHECK: i32.atomic.rmw8_u.cmpxchg $push0=, 0($0), $1, $2{{$}} +; CHECK: i32.atomic.rmw8.cmpxchg_u $push0=, 0($0), $1, $2{{$}} ; CHECK-NEXT: return $pop0{{$}} define i32 @cmpxchg_zext_i8_i32(i8* %p, i32 %exp, i32 %new) { %exp_t = trunc i32 %exp to i8 @@ -1164,7 +1164,7 @@ ; CHECK-LABEL: cmpxchg_zext_i16_i32: ; CHECK-NEXT: .functype cmpxchg_zext_i16_i32 (i32, i32, i32) -> (i32){{$}} -; CHECK: i32.atomic.rmw16_u.cmpxchg $push0=, 0($0), $1, $2{{$}} +; CHECK: i32.atomic.rmw16.cmpxchg_u $push0=, 0($0), $1, $2{{$}} ; CHECK-NEXT: return $pop0{{$}} define i32 @cmpxchg_zext_i16_i32(i16* %p, i32 %exp, i32 %new) { %exp_t = trunc i32 %exp to i16 @@ -1177,7 +1177,7 @@ ; CHECK-LABEL: cmpxchg_zext_i8_i64: ; CHECK-NEXT: .functype cmpxchg_zext_i8_i64 (i32, i64, i64) -> (i64){{$}} -; CHECK: i64.atomic.rmw8_u.cmpxchg $push0=, 0($0), $1, $2{{$}} +; CHECK: i64.atomic.rmw8.cmpxchg_u $push0=, 0($0), $1, $2{{$}} ; CHECK-NEXT: return $pop0{{$}} define i64 @cmpxchg_zext_i8_i64(i8* %p, i64 %exp, i64 %new) { %exp_t = trunc i64 %exp to i8 @@ -1190,7 +1190,7 @@ ; CHECK-LABEL: cmpxchg_zext_i16_i64: ; CHECK-NEXT: .functype cmpxchg_zext_i16_i64 (i32, i64, i64) -> (i64){{$}} -; CHECK: i64.atomic.rmw16_u.cmpxchg $push0=, 0($0), $1, $2{{$}} +; CHECK: i64.atomic.rmw16.cmpxchg_u $push0=, 0($0), $1, $2{{$}} ; CHECK-NEXT: return $pop0{{$}} define i64 @cmpxchg_zext_i16_i64(i16* %p, i64 %exp, i64 %new) { %exp_t = trunc i64 %exp to i16 @@ -1203,7 +1203,7 @@ ; CHECK-LABEL: cmpxchg_zext_i32_i64: ; CHECK-NEXT: .functype cmpxchg_zext_i32_i64 (i32, i64, i64) -> (i64){{$}} -; CHECK: i64.atomic.rmw32_u.cmpxchg $push0=, 0($0), $1, $2{{$}} +; CHECK: i64.atomic.rmw32.cmpxchg_u $push0=, 0($0), $1, $2{{$}} ; CHECK-NEXT: return $pop0{{$}} define i64 @cmpxchg_zext_i32_i64(i32* %p, i64 %exp, i64 %new) { %exp_t = trunc i64 %exp to i32 @@ -1222,7 +1222,7 @@ ; CHECK-LABEL: nand_zext_i8_i32: ; CHECK-NEXT: .functype nand_zext_i8_i32 (i32, i32) -> (i32){{$}} ; CHECK: loop -; CHECK: i32.atomic.rmw8_u.cmpxchg +; CHECK: i32.atomic.rmw8.cmpxchg_u define i32 @nand_zext_i8_i32(i8* %p, i32 %v) { %t = trunc i32 %v to i8 %old = atomicrmw nand i8* %p, i8 %t seq_cst @@ -1233,7 +1233,7 @@ ; CHECK-LABEL: nand_zext_i16_i32: ; CHECK-NEXT: .functype nand_zext_i16_i32 (i32, i32) -> (i32){{$}} ; CHECK: loop -; CHECK: i32.atomic.rmw16_u.cmpxchg +; CHECK: i32.atomic.rmw16.cmpxchg_u define i32 @nand_zext_i16_i32(i16* %p, i32 %v) { %t = trunc i32 %v to i16 %old = atomicrmw nand i16* %p, i16 %t seq_cst @@ -1241,12 +1241,12 @@ ret i32 %e } -; FIXME Currently this cannot make use of i64.atomic.rmw8_u.cmpxchg +; FIXME Currently this cannot make use of i64.atomic.rmw8.cmpxchg_u ; CHECK-LABEL: nand_zext_i8_i64: ; CHECK-NEXT: .functype nand_zext_i8_i64 (i32, i64) -> (i64){{$}} ; CHECK: loop -; CHECK: i32.atomic.rmw8_u.cmpxchg -; CHECK: i64.extend_u/i32 +; CHECK: i32.atomic.rmw8.cmpxchg_u +; CHECK: i64.extend_i32_u define i64 @nand_zext_i8_i64(i8* %p, i64 %v) { %t = trunc i64 %v to i8 %old = atomicrmw nand i8* %p, i8 %t seq_cst @@ -1254,12 +1254,12 @@ ret i64 %e } -; FIXME Currently this cannot make use of i64.atomic.rmw16_u.cmpxchg +; FIXME Currently this cannot make use of i64.atomic.rmw16.cmpxchg_u ; CHECK-LABEL: nand_zext_i16_i64: ; CHECK-NEXT: .functype nand_zext_i16_i64 (i32, i64) -> (i64){{$}} ; CHECK: loop -; CHECK: i32.atomic.rmw16_u.cmpxchg -; CHECK: i64.extend_u/i32 +; CHECK: i32.atomic.rmw16.cmpxchg_u +; CHECK: i64.extend_i32_u define i64 @nand_zext_i16_i64(i16* %p, i64 %v) { %t = trunc i64 %v to i16 %old = atomicrmw nand i16* %p, i16 %t seq_cst @@ -1267,12 +1267,12 @@ ret i64 %e } -; FIXME Currently this cannot make use of i64.atomic.rmw32_u.cmpxchg +; FIXME Currently this cannot make use of i64.atomic.rmw32.cmpxchg_u ; CHECK-LABEL: nand_zext_i32_i64: ; CHECK-NEXT: .functype nand_zext_i32_i64 (i32, i64) -> (i64){{$}} ; CHECK: loop ; CHECK: i32.atomic.rmw.cmpxchg -; CHECK: i64.extend_u/i32 +; CHECK: i64.extend_i32_u define i64 @nand_zext_i32_i64(i32* %p, i64 %v) { %t = trunc i64 %v to i32 %old = atomicrmw nand i32* %p, i32 %t seq_cst Index: test/CodeGen/WebAssembly/byval.ll =================================================================== --- test/CodeGen/WebAssembly/byval.ll +++ test/CodeGen/WebAssembly/byval.ll @@ -21,12 +21,12 @@ define void @byval_arg(%SmallStruct* %ptr) { ; CHECK: .functype byval_arg (i32) -> () ; Subtract 16 from SP (SP is 16-byte aligned) - ; CHECK-NEXT: get_global $push[[L2:.+]]=, __stack_pointer@GLOBAL + ; CHECK-NEXT: global.get $push[[L2:.+]]=, __stack_pointer@GLOBAL ; CHECK-NEXT: i32.const $push[[L3:.+]]=, 16 ; CHECK-NEXT: i32.sub $push[[L11:.+]]=, $pop[[L2]], $pop[[L3]] ; Ensure SP is stored back before the call - ; CHECK-NEXT: tee_local $push[[L10:.+]]=, $[[SP:.+]]=, $pop[[L11]]{{$}} - ; CHECK-NEXT: set_global __stack_pointer@GLOBAL, $pop[[L10]]{{$}} + ; CHECK-NEXT: local.tee $push[[L10:.+]]=, $[[SP:.+]]=, $pop[[L11]]{{$}} + ; CHECK-NEXT: global.set __stack_pointer@GLOBAL, $pop[[L10]]{{$}} ; Copy the SmallStruct argument to the stack (SP+12, original SP-4) ; CHECK-NEXT: i32.load $push[[L0:.+]]=, 0($0) ; CHECK-NEXT: i32.store 12($[[SP]]), $pop[[L0]] @@ -38,7 +38,7 @@ ; Restore the stack ; CHECK-NEXT: i32.const $push[[L6:.+]]=, 16 ; CHECK-NEXT: i32.add $push[[L8:.+]]=, $[[SP]], $pop[[L6]] - ; CHECK-NEXT: set_global __stack_pointer@GLOBAL, $pop[[L8]] + ; CHECK-NEXT: global.set __stack_pointer@GLOBAL, $pop[[L8]] ; CHECK-NEXT: return ret void } @@ -49,8 +49,8 @@ ; Don't check the entire SP sequence, just enough to get the alignment. ; CHECK: i32.const $push[[L1:.+]]=, 16 ; CHECK-NEXT: i32.sub $push[[L11:.+]]=, {{.+}}, $pop[[L1]] - ; CHECK-NEXT: tee_local $push[[L10:.+]]=, $[[SP:.+]]=, $pop[[L11]]{{$}} - ; CHECK-NEXT: set_global __stack_pointer@GLOBAL, $pop[[L10]]{{$}} + ; CHECK-NEXT: local.tee $push[[L10:.+]]=, $[[SP:.+]]=, $pop[[L11]]{{$}} + ; CHECK-NEXT: global.set __stack_pointer@GLOBAL, $pop[[L10]]{{$}} ; Copy the SmallStruct argument to the stack (SP+8, original SP-8) ; CHECK-NEXT: i32.load $push[[L0:.+]]=, 0($0){{$}} ; CHECK-NEXT: i32.store 8($[[SP]]), $pop[[L0]]{{$}} @@ -68,8 +68,8 @@ ; Subtract 16 from SP (SP is 16-byte aligned) ; CHECK: i32.const $push[[L1:.+]]=, 16 ; CHECK-NEXT: i32.sub $push[[L14:.+]]=, {{.+}}, $pop[[L1]] - ; CHECK-NEXT: tee_local $push[[L13:.+]]=, $[[SP:.+]]=, $pop[[L14]] - ; CHECK-NEXT: set_global __stack_pointer@GLOBAL, $pop[[L13]] + ; CHECK-NEXT: local.tee $push[[L13:.+]]=, $[[SP:.+]]=, $pop[[L14]] + ; CHECK-NEXT: global.set __stack_pointer@GLOBAL, $pop[[L13]] ; Copy the AlignedStruct argument to the stack (SP+0, original SP-16) ; Just check the last load/store pair of the memcpy ; CHECK: i64.load $push[[L4:.+]]=, 0($0) @@ -107,14 +107,14 @@ ; Call memcpy for "big" byvals. ; CHECK-LABEL: big_byval: -; CHECK: get_global $push[[L2:.+]]=, __stack_pointer@GLOBAL{{$}} +; CHECK: global.get $push[[L2:.+]]=, __stack_pointer@GLOBAL{{$}} ; CHECK-NEXT: i32.const $push[[L3:.+]]=, 131072 ; CHECK-NEXT: i32.sub $push[[L11:.+]]=, $pop[[L2]], $pop[[L3]] -; CHECK-NEXT: tee_local $push[[L10:.+]]=, $[[SP:.+]]=, $pop[[L11]]{{$}} -; CHECK-NEXT: set_global __stack_pointer@GLOBAL, $pop[[L10]]{{$}} +; CHECK-NEXT: local.tee $push[[L10:.+]]=, $[[SP:.+]]=, $pop[[L11]]{{$}} +; CHECK-NEXT: global.set __stack_pointer@GLOBAL, $pop[[L10]]{{$}} ; CHECK-NEXT: i32.const $push[[L0:.+]]=, 131072 ; CHECK-NEXT: i32.call $push[[L11:.+]]=, memcpy@FUNCTION, $[[SP]], ${{.+}}, $pop{{.+}} -; CHECK-NEXT: tee_local $push[[L9:.+]]=, $[[SP:.+]]=, $pop[[L11]]{{$}} +; CHECK-NEXT: local.tee $push[[L9:.+]]=, $[[SP:.+]]=, $pop[[L11]]{{$}} ; CHECK-NEXT: call big_byval_callee@FUNCTION, %big = type [131072 x i8] declare void @big_byval_callee(%big* byval align 1) Index: test/CodeGen/WebAssembly/call.ll =================================================================== --- test/CodeGen/WebAssembly/call.ll +++ test/CodeGen/WebAssembly/call.ll @@ -71,7 +71,7 @@ ; CHECK-LABEL: call_i32_unary: ; CHECK-NEXT: .functype call_i32_unary (i32) -> (i32){{$}} -; CHECK-NEXT: get_local $push[[L0:[0-9]+]]=, 0{{$}} +; CHECK-NEXT: local.get $push[[L0:[0-9]+]]=, 0{{$}} ; CHECK-NEXT: {{^}} i32.call $push[[NUM:[0-9]+]]=, i32_unary@FUNCTION, $pop[[L0]]{{$}} ; CHECK-NEXT: return $pop[[NUM]]{{$}} define i32 @call_i32_unary(i32 %a) { @@ -81,8 +81,8 @@ ; CHECK-LABEL: call_i32_binary: ; CHECK-NEXT: .functype call_i32_binary (i32, i32) -> (i32){{$}} -; CHECK-NEXT: get_local $push[[L0:[0-9]+]]=, 0{{$}} -; CHECK-NEXT: get_local $push[[L1:[0-9]+]]=, 1{{$}} +; CHECK-NEXT: local.get $push[[L0:[0-9]+]]=, 0{{$}} +; CHECK-NEXT: local.get $push[[L1:[0-9]+]]=, 1{{$}} ; CHECK-NEXT: {{^}} i32.call $push[[NUM:[0-9]+]]=, i32_binary@FUNCTION, $pop[[L0]], $pop[[L1]]{{$}} ; CHECK-NEXT: return $pop[[NUM]]{{$}} define i32 @call_i32_binary(i32 %a, i32 %b) { @@ -92,7 +92,7 @@ ; CHECK-LABEL: call_indirect_void: ; CHECK-NEXT: .functype call_indirect_void (i32) -> (){{$}} -; CHECK-NEXT: get_local $push[[L0:[0-9]+]]=, 0{{$}} +; CHECK-NEXT: local.get $push[[L0:[0-9]+]]=, 0{{$}} ; CHECK-NEXT: {{^}} call_indirect $pop[[L0]]{{$}} ; CHECK-NEXT: return{{$}} define void @call_indirect_void(void ()* %callee) { @@ -102,7 +102,7 @@ ; CHECK-LABEL: call_indirect_i32: ; CHECK-NEXT: .functype call_indirect_i32 (i32) -> (i32){{$}} -; CHECK-NEXT: get_local $push[[L0:[0-9]+]]=, 0{{$}} +; CHECK-NEXT: local.get $push[[L0:[0-9]+]]=, 0{{$}} ; CHECK-NEXT: {{^}} i32.call_indirect $push[[NUM:[0-9]+]]=, $pop[[L0]]{{$}} ; CHECK-NEXT: return $pop[[NUM]]{{$}} define i32 @call_indirect_i32(i32 ()* %callee) { @@ -112,7 +112,7 @@ ; CHECK-LABEL: call_indirect_i64: ; CHECK-NEXT: .functype call_indirect_i64 (i32) -> (i64){{$}} -; CHECK-NEXT: get_local $push[[L0:[0-9]+]]=, 0{{$}} +; CHECK-NEXT: local.get $push[[L0:[0-9]+]]=, 0{{$}} ; CHECK-NEXT: {{^}} i64.call_indirect $push[[NUM:[0-9]+]]=, $pop[[L0]]{{$}} ; CHECK-NEXT: return $pop[[NUM]]{{$}} define i64 @call_indirect_i64(i64 ()* %callee) { @@ -122,7 +122,7 @@ ; CHECK-LABEL: call_indirect_float: ; CHECK-NEXT: .functype call_indirect_float (i32) -> (f32){{$}} -; CHECK-NEXT: get_local $push[[L0:[0-9]+]]=, 0{{$}} +; CHECK-NEXT: local.get $push[[L0:[0-9]+]]=, 0{{$}} ; CHECK-NEXT: {{^}} f32.call_indirect $push[[NUM:[0-9]+]]=, $pop[[L0]]{{$}} ; CHECK-NEXT: return $pop[[NUM]]{{$}} define float @call_indirect_float(float ()* %callee) { @@ -132,7 +132,7 @@ ; CHECK-LABEL: call_indirect_double: ; CHECK-NEXT: .functype call_indirect_double (i32) -> (f64){{$}} -; CHECK-NEXT: get_local $push[[L0:[0-9]+]]=, 0{{$}} +; CHECK-NEXT: local.get $push[[L0:[0-9]+]]=, 0{{$}} ; CHECK-NEXT: {{^}} f64.call_indirect $push[[NUM:[0-9]+]]=, $pop[[L0]]{{$}} ; CHECK-NEXT: return $pop[[NUM]]{{$}} define double @call_indirect_double(double ()* %callee) { @@ -142,7 +142,7 @@ ; CHECK-LABEL: call_indirect_v128: ; CHECK-NEXT: .functype call_indirect_v128 (i32) -> (v128){{$}} -; CHECK-NEXT: get_local $push[[L0:[0-9]+]]=, 0{{$}} +; CHECK-NEXT: local.get $push[[L0:[0-9]+]]=, 0{{$}} ; CHECK-NEXT: {{^}} v128.call_indirect $push[[NUM:[0-9]+]]=, $pop[[L0]]{{$}} ; CHECK-NEXT: return $pop[[NUM]]{{$}} define <16 x i8> @call_indirect_v128(<16 x i8> ()* %callee) { @@ -152,8 +152,8 @@ ; CHECK-LABEL: call_indirect_arg: ; CHECK-NEXT: .functype call_indirect_arg (i32, i32) -> (){{$}} -; CHECK-NEXT: get_local $push[[L0:[0-9]+]]=, 1{{$}} -; CHECK-NEXT: get_local $push[[L1:[0-9]+]]=, 0{{$}} +; CHECK-NEXT: local.get $push[[L0:[0-9]+]]=, 1{{$}} +; CHECK-NEXT: local.get $push[[L1:[0-9]+]]=, 0{{$}} ; CHECK-NEXT: {{^}} call_indirect $pop[[L0]], $pop[[L1]]{{$}} ; CHECK-NEXT: return{{$}} define void @call_indirect_arg(void (i32)* %callee, i32 %arg) { @@ -163,9 +163,9 @@ ; CHECK-LABEL: call_indirect_arg_2: ; CHECK-NEXT: .functype call_indirect_arg_2 (i32, i32, i32) -> (){{$}} -; CHECK-NEXT: get_local $push[[L0:[0-9]+]]=, 1{{$}} -; CHECK-NEXT: get_local $push[[L1:[0-9]+]]=, 2{{$}} -; CHECK-NEXT: get_local $push[[L2:[0-9]+]]=, 0{{$}} +; CHECK-NEXT: local.get $push[[L0:[0-9]+]]=, 1{{$}} +; CHECK-NEXT: local.get $push[[L1:[0-9]+]]=, 2{{$}} +; CHECK-NEXT: local.get $push[[L2:[0-9]+]]=, 0{{$}} ; CHECK-NEXT: {{^}} i32.call_indirect $push[[NUM:[0-9]+]]=, $pop[[L0]], $pop[[L1]], $pop[[L2]]{{$}} ; CHECK-NEXT: drop $pop[[NUM]]{{$}} ; CHECK-NEXT: return{{$}} Index: test/CodeGen/WebAssembly/cfg-stackify-dbg-skip.ll =================================================================== --- test/CodeGen/WebAssembly/cfg-stackify-dbg-skip.ll +++ test/CodeGen/WebAssembly/cfg-stackify-dbg-skip.ll @@ -7,7 +7,7 @@ ; CHECK: body: ; CHECK: BLOCK ; <-- Stackified expression starts -; CHECK-NEXT: GET_LOCAL_I64 +; CHECK-NEXT: LOCAL_GET_I64 ; CHECK-NEXT: I32_WRAP_I64 ; CHECK-NEXT: DBG_VALUE ; <-- BLOCK should NOT be placed here! Index: test/CodeGen/WebAssembly/cfg-stackify-eh.mir =================================================================== --- test/CodeGen/WebAssembly/cfg-stackify-eh.mir +++ test/CodeGen/WebAssembly/cfg-stackify-eh.mir @@ -98,14 +98,14 @@ successors: %bb.2, %bb.7 %30:i32 = CATCH_I32 0, implicit-def dead $arguments - SET_LOCAL_I32 0, %30:i32, implicit-def $arguments + LOCAL_SET_I32 0, %30:i32, implicit-def $arguments %16:i32 = CONST_I32 0, implicit-def dead $arguments, implicit-def $value_stack, implicit $value_stack %27:i32 = CONST_I32 0, implicit-def dead $arguments, implicit-def $value_stack, implicit $value_stack STORE_I32 2, @__wasm_lpad_context + 4, %16:i32, %27:i32, implicit-def dead $arguments, implicit-def $value_stack, implicit $value_stack :: (store 4 into `i8** getelementptr inbounds ({ i32, i8*, i32 }, { i32, i8*, i32 }* @__wasm_lpad_context, i32 0, i32 1)`) %26:i32 = CONST_I32 0, implicit-def dead $arguments, implicit-def $value_stack, implicit $value_stack %25:i32 = CONST_I32 0, implicit-def dead $arguments, implicit-def $value_stack, implicit $value_stack STORE_I32 2, @__wasm_lpad_context, %26:i32, %25:i32, implicit-def dead $arguments, implicit-def $value_stack, implicit $value_stack :: (store 4 into `i32* getelementptr inbounds ({ i32, i8*, i32 }, { i32, i8*, i32 }* @__wasm_lpad_context, i32 0, i32 0)`) - %32:i32 = GET_LOCAL_I32 0, implicit-def $arguments + %32:i32 = LOCAL_GET_I32 0, implicit-def $arguments %31:i32 = CALL_I32 @_Unwind_CallPersonality, %32:i32, implicit-def dead $arguments, implicit $sp32, implicit $sp64 DROP_I32 killed %31:i32, implicit-def $arguments %24:i32 = CONST_I32 0, implicit-def dead $arguments, implicit-def $value_stack, implicit $value_stack @@ -118,7 +118,7 @@ ; predecessors: %bb.1 successors: %bb.8, %bb.3, %bb.6 - %34:i32 = GET_LOCAL_I32 0, implicit-def $arguments + %34:i32 = LOCAL_GET_I32 0, implicit-def $arguments %33:i32 = CALL_I32 @__cxa_begin_catch, %34:i32, implicit-def dead $arguments, implicit $sp32, implicit $sp64 DROP_I32 killed %33:i32, implicit-def $arguments CALL_VOID @may_throw, implicit-def dead $arguments, implicit $sp32, implicit $sp64 @@ -134,11 +134,11 @@ successors: %bb.4, %bb.5 %35:i32 = CATCH_I32 0, implicit-def dead $arguments - SET_LOCAL_I32 0, %35:i32, implicit-def $arguments + LOCAL_SET_I32 0, %35:i32, implicit-def $arguments %21:i32 = CONST_I32 0, implicit-def dead $arguments, implicit-def $value_stack, implicit $value_stack %20:i32 = CONST_I32 1, implicit-def dead $arguments, implicit-def $value_stack, implicit $value_stack STORE_I32 2, @__wasm_lpad_context, %21:i32, %20:i32, implicit-def dead $arguments, implicit-def $value_stack, implicit $value_stack :: (store 4 into `i32* getelementptr inbounds ({ i32, i8*, i32 }, { i32, i8*, i32 }* @__wasm_lpad_context, i32 0, i32 0)`) - %37:i32 = GET_LOCAL_I32 0, implicit-def $arguments + %37:i32 = LOCAL_GET_I32 0, implicit-def $arguments %36:i32 = CALL_I32 @_Unwind_CallPersonality, %37:i32, implicit-def dead $arguments, implicit $sp32, implicit $sp64 DROP_I32 killed %36:i32, implicit-def $arguments %29:i32 = CONST_I32 0, implicit-def dead $arguments, implicit-def $value_stack, implicit $value_stack @@ -151,7 +151,7 @@ ; predecessors: %bb.3 successors: %bb.8 - %39:i32 = GET_LOCAL_I32 0, implicit-def $arguments + %39:i32 = LOCAL_GET_I32 0, implicit-def $arguments %38:i32 = CALL_I32 @__cxa_begin_catch, %39:i32, implicit-def dead $arguments, implicit $sp32, implicit $sp64 DROP_I32 killed %38:i32, implicit-def $arguments CALL_VOID @__cxa_end_catch, implicit-def dead $arguments, implicit $sp32, implicit $sp64 @@ -212,9 +212,9 @@ successors: %bb.1, %bb.4 %18:i32 = CONST_I32 0, implicit-def dead $arguments - SET_LOCAL_I32 1, %18:i32, implicit-def $arguments + LOCAL_SET_I32 1, %18:i32, implicit-def $arguments %14:i32 = CONST_I32 0, implicit-def dead $arguments, implicit-def $value_stack, implicit $value_stack - %19:i32 = GET_LOCAL_I32 0, implicit-def $arguments + %19:i32 = LOCAL_GET_I32 0, implicit-def $arguments %9:i32 = GE_S_I32 %14:i32, %19:i32, implicit-def dead $arguments, implicit-def $value_stack, implicit $value_stack BR_IF %bb.4, %9:i32, implicit-def $arguments @@ -243,11 +243,11 @@ ; predecessors: %bb.1 successors: %bb.1, %bb.4 - %20:i32 = GET_LOCAL_I32 1, implicit-def $arguments + %20:i32 = LOCAL_GET_I32 1, implicit-def $arguments %17:i32 = CONST_I32 1, implicit-def dead $arguments, implicit-def $value_stack, implicit $value_stack %16:i32 = ADD_I32 %20:i32, %17:i32, implicit-def dead $arguments, implicit-def $value_stack, implicit $value_stack - %15:i32 = TEE_LOCAL_I32 1, %16:i32, implicit-def $arguments - %21:i32 = GET_LOCAL_I32 0, implicit-def $arguments + %15:i32 = LOCAL_TEE_I32 1, %16:i32, implicit-def $arguments + %21:i32 = LOCAL_GET_I32 0, implicit-def $arguments %10:i32 = GE_S_I32 %15:i32, %21:i32, implicit-def dead $arguments, implicit-def $value_stack, implicit $value_stack BR_UNLESS %bb.1, %10:i32, implicit-def $arguments ; CHECK-LABEL: bb.3: @@ -289,9 +289,9 @@ %18:i32 = CALL_I32 @__cxa_begin_catch, %9:i32, implicit-def dead $arguments, implicit $sp32, implicit $sp64, implicit-def $value_stack, implicit $value_stack DROP_I32 killed %18:i32, implicit-def $arguments %19:i32 = CONST_I32 0, implicit-def dead $arguments - SET_LOCAL_I32 1, %19:i32, implicit-def $arguments + LOCAL_SET_I32 1, %19:i32, implicit-def $arguments %14:i32 = CONST_I32 0, implicit-def dead $arguments, implicit-def $value_stack, implicit $value_stack - %20:i32 = GET_LOCAL_I32 0, implicit-def $arguments + %20:i32 = LOCAL_GET_I32 0, implicit-def $arguments %10:i32 = GE_S_I32 %14:i32, %20:i32, implicit-def dead $arguments, implicit-def $value_stack, implicit $value_stack BR_IF %bb.3, %10:i32, implicit-def $arguments, implicit-def $value_stack, implicit $value_stack @@ -300,11 +300,11 @@ successors: %bb.2, %bb.3 CALL_VOID @dont_throw, implicit-def dead $arguments, implicit $sp32, implicit $sp64 - %21:i32 = GET_LOCAL_I32 1, implicit-def $arguments + %21:i32 = LOCAL_GET_I32 1, implicit-def $arguments %17:i32 = CONST_I32 1, implicit-def dead $arguments, implicit-def $value_stack, implicit $value_stack %16:i32 = ADD_I32 %21:i32, %17:i32, implicit-def dead $arguments, implicit-def $value_stack, implicit $value_stack - %15:i32 = TEE_LOCAL_I32 1, %16:i32, implicit-def $arguments - %22:i32 = GET_LOCAL_I32 0, implicit-def $arguments + %15:i32 = LOCAL_TEE_I32 1, %16:i32, implicit-def $arguments + %22:i32 = LOCAL_GET_I32 0, implicit-def $arguments %11:i32 = GE_S_I32 %15:i32, %22:i32, implicit-def dead $arguments, implicit-def $value_stack, implicit $value_stack BR_UNLESS %bb.2, %11:i32, implicit-def $arguments, implicit-def $value_stack, implicit $value_stack Index: test/CodeGen/WebAssembly/comparisons-f32.ll =================================================================== --- test/CodeGen/WebAssembly/comparisons-f32.ll +++ test/CodeGen/WebAssembly/comparisons-f32.ll @@ -8,11 +8,11 @@ ; CHECK-LABEL: ord_f32: ; CHECK-NEXT: .functype ord_f32 (f32, f32) -> (i32){{$}} -; CHECK-NEXT: get_local $push[[L0:[0-9]+]]=, 0{{$}} -; CHECK-NEXT: get_local $push[[L1:[0-9]+]]=, 0{{$}} +; CHECK-NEXT: local.get $push[[L0:[0-9]+]]=, 0{{$}} +; CHECK-NEXT: local.get $push[[L1:[0-9]+]]=, 0{{$}} ; CHECK-NEXT: f32.eq $push[[NUM0:[0-9]+]]=, $pop[[L0]], $pop[[L1]]{{$}} -; CHECK-NEXT: get_local $push[[L2:[0-9]+]]=, 1{{$}} -; CHECK-NEXT: get_local $push[[L3:[0-9]+]]=, 1{{$}} +; CHECK-NEXT: local.get $push[[L2:[0-9]+]]=, 1{{$}} +; CHECK-NEXT: local.get $push[[L3:[0-9]+]]=, 1{{$}} ; CHECK-NEXT: f32.eq $push[[NUM1:[0-9]+]]=, $pop[[L2]], $pop[[L3]]{{$}} ; CHECK-NEXT: i32.and $push[[NUM2:[0-9]+]]=, $pop[[NUM0]], $pop[[NUM1]]{{$}} ; CHECK-NEXT: return $pop[[NUM2]]{{$}} @@ -24,11 +24,11 @@ ; CHECK-LABEL: uno_f32: ; CHECK-NEXT: .functype uno_f32 (f32, f32) -> (i32){{$}} -; CHECK-NEXT: get_local $push[[L0:[0-9]+]]=, 0{{$}} -; CHECK-NEXT: get_local $push[[L1:[0-9]+]]=, 0{{$}} +; CHECK-NEXT: local.get $push[[L0:[0-9]+]]=, 0{{$}} +; CHECK-NEXT: local.get $push[[L1:[0-9]+]]=, 0{{$}} ; CHECK-NEXT: f32.ne $push[[NUM0:[0-9]+]]=, $pop[[L0]], $pop[[L1]]{{$}} -; CHECK-NEXT: get_local $push[[L2:[0-9]+]]=, 1{{$}} -; CHECK-NEXT: get_local $push[[L3:[0-9]+]]=, 1{{$}} +; CHECK-NEXT: local.get $push[[L2:[0-9]+]]=, 1{{$}} +; CHECK-NEXT: local.get $push[[L3:[0-9]+]]=, 1{{$}} ; CHECK-NEXT: f32.ne $push[[NUM1:[0-9]+]]=, $pop[[L2]], $pop[[L3]]{{$}} ; CHECK-NEXT: i32.or $push[[NUM2:[0-9]+]]=, $pop[[NUM0]], $pop[[NUM1]]{{$}} ; CHECK-NEXT: return $pop[[NUM2]]{{$}} @@ -40,8 +40,8 @@ ; CHECK-LABEL: oeq_f32: ; CHECK-NEXT: .functype oeq_f32 (f32, f32) -> (i32){{$}} -; CHECK-NEXT: get_local $push[[L0:[0-9]+]]=, 0{{$}} -; CHECK-NEXT: get_local $push[[L1:[0-9]+]]=, 1{{$}} +; CHECK-NEXT: local.get $push[[L0:[0-9]+]]=, 0{{$}} +; CHECK-NEXT: local.get $push[[L1:[0-9]+]]=, 1{{$}} ; CHECK-NEXT: f32.eq $push[[NUM:[0-9]+]]=, $pop[[L0]], $pop[[L1]]{{$}} ; CHECK-NEXT: return $pop[[NUM]]{{$}} define i32 @oeq_f32(float %x, float %y) { @@ -100,14 +100,14 @@ ; CHECK-LABEL: ueq_f32: ; CHECK-NEXT: .functype ueq_f32 (f32, f32) -> (i32){{$}} -; CHECK-NEXT: get_local $push[[L0:[0-9]+]]=, 0{{$}} -; CHECK-NEXT: get_local $push[[L1:[0-9]+]]=, 1{{$}} +; CHECK-NEXT: local.get $push[[L0:[0-9]+]]=, 0{{$}} +; CHECK-NEXT: local.get $push[[L1:[0-9]+]]=, 1{{$}} ; CHECK-NEXT: f32.eq $push[[NUM0:[0-9]+]]=, $pop[[L0]], $pop[[L1]]{{$}} -; CHECK-NEXT: get_local $push[[L2:[0-9]+]]=, 0{{$}} -; CHECK-NEXT: get_local $push[[L3:[0-9]+]]=, 0{{$}} +; CHECK-NEXT: local.get $push[[L2:[0-9]+]]=, 0{{$}} +; CHECK-NEXT: local.get $push[[L3:[0-9]+]]=, 0{{$}} ; CHECK-NEXT: f32.ne $push[[NUM1:[0-9]+]]=, $pop[[L2]], $pop[[L3]]{{$}} -; CHECK-NEXT: get_local $push[[L4:[0-9]+]]=, 1{{$}} -; CHECK-NEXT: get_local $push[[L5:[0-9]+]]=, 1{{$}} +; CHECK-NEXT: local.get $push[[L4:[0-9]+]]=, 1{{$}} +; CHECK-NEXT: local.get $push[[L5:[0-9]+]]=, 1{{$}} ; CHECK-NEXT: f32.ne $push[[NUM2:[0-9]+]]=, $pop[[L4]], $pop[[L5]]{{$}} ; CHECK-NEXT: i32.or $push[[NUM3:[0-9]+]]=, $pop[[NUM1]], $pop[[NUM2]]{{$}} ; CHECK-NEXT: i32.or $push[[NUM4:[0-9]+]]=, $pop[[NUM0]], $pop[[NUM3]]{{$}} @@ -120,14 +120,14 @@ ; CHECK-LABEL: one_f32: ; CHECK-NEXT: .functype one_f32 (f32, f32) -> (i32){{$}} -; CHECK-NEXT: get_local $push[[L0:[0-9]+]]=, 0{{$}} -; CHECK-NEXT: get_local $push[[L1:[0-9]+]]=, 1{{$}} +; CHECK-NEXT: local.get $push[[L0:[0-9]+]]=, 0{{$}} +; CHECK-NEXT: local.get $push[[L1:[0-9]+]]=, 1{{$}} ; CHECK-NEXT: f32.ne $push[[NUM0:[0-9]+]]=, $pop[[L0]], $pop[[L1]]{{$}} -; CHECK-NEXT: get_local $push[[L2:[0-9]+]]=, 0{{$}} -; CHECK-NEXT: get_local $push[[L3:[0-9]+]]=, 0{{$}} +; CHECK-NEXT: local.get $push[[L2:[0-9]+]]=, 0{{$}} +; CHECK-NEXT: local.get $push[[L3:[0-9]+]]=, 0{{$}} ; CHECK-NEXT: f32.eq $push[[NUM1:[0-9]+]]=, $pop[[L2]], $pop[[L3]]{{$}} -; CHECK-NEXT: get_local $push[[L4:[0-9]+]]=, 1{{$}} -; CHECK-NEXT: get_local $push[[L5:[0-9]+]]=, 1{{$}} +; CHECK-NEXT: local.get $push[[L4:[0-9]+]]=, 1{{$}} +; CHECK-NEXT: local.get $push[[L5:[0-9]+]]=, 1{{$}} ; CHECK-NEXT: f32.eq $push[[NUM2:[0-9]+]]=, $pop[[L4]], $pop[[L5]]{{$}} ; CHECK-NEXT: i32.and $push[[NUM3:[0-9]+]]=, $pop[[NUM1]], $pop[[NUM2]]{{$}} ; CHECK-NEXT: i32.and $push[[NUM4:[0-9]+]]=, $pop[[NUM0]], $pop[[NUM3]]{{$}} @@ -140,8 +140,8 @@ ; CHECK-LABEL: ult_f32: ; CHECK-NEXT: .functype ult_f32 (f32, f32) -> (i32){{$}} -; CHECK-NEXT: get_local $push[[L0:[0-9]+]]=, 0{{$}} -; CHECK-NEXT: get_local $push[[L1:[0-9]+]]=, 1{{$}} +; CHECK-NEXT: local.get $push[[L0:[0-9]+]]=, 0{{$}} +; CHECK-NEXT: local.get $push[[L1:[0-9]+]]=, 1{{$}} ; CHECK-NEXT: f32.ge $push[[NUM0:[0-9]+]]=, $pop[[L0]], $pop[[L1]]{{$}} ; CHECK-NEXT: i32.const $push[[C0:[0-9]+]]=, 1 ; CHECK-NEXT: i32.xor $push[[NUM2:[0-9]+]]=, $pop[[NUM0]], $pop[[C0]]{{$}} @@ -154,8 +154,8 @@ ; CHECK-LABEL: ule_f32: ; CHECK-NEXT: .functype ule_f32 (f32, f32) -> (i32){{$}} -; CHECK-NEXT: get_local $push[[L0:[0-9]+]]=, 0{{$}} -; CHECK-NEXT: get_local $push[[L1:[0-9]+]]=, 1{{$}} +; CHECK-NEXT: local.get $push[[L0:[0-9]+]]=, 0{{$}} +; CHECK-NEXT: local.get $push[[L1:[0-9]+]]=, 1{{$}} ; CHECK-NEXT: f32.gt $push[[NUM0:[0-9]+]]=, $pop[[L0]], $pop[[L1]]{{$}} ; CHECK-NEXT: i32.const $push[[C0:[0-9]+]]=, 1 ; CHECK-NEXT: i32.xor $push[[NUM2:[0-9]+]]=, $pop[[NUM0]], $pop[[C0]]{{$}} @@ -168,8 +168,8 @@ ; CHECK-LABEL: ugt_f32: ; CHECK-NEXT: .functype ugt_f32 (f32, f32) -> (i32){{$}} -; CHECK-NEXT: get_local $push[[L0:[0-9]+]]=, 0{{$}} -; CHECK-NEXT: get_local $push[[L1:[0-9]+]]=, 1{{$}} +; CHECK-NEXT: local.get $push[[L0:[0-9]+]]=, 0{{$}} +; CHECK-NEXT: local.get $push[[L1:[0-9]+]]=, 1{{$}} ; CHECK-NEXT: f32.le $push[[NUM0:[0-9]+]]=, $pop[[L0]], $pop[[L1]]{{$}} ; CHECK-NEXT: i32.const $push[[C0:[0-9]+]]=, 1 ; CHECK-NEXT: i32.xor $push[[NUM2:[0-9]+]]=, $pop[[NUM0]], $pop[[C0]]{{$}} @@ -182,8 +182,8 @@ ; CHECK-LABEL: uge_f32: ; CHECK-NEXT: .functype uge_f32 (f32, f32) -> (i32){{$}} -; CHECK-NEXT: get_local $push[[L0:[0-9]+]]=, 0{{$}} -; CHECK-NEXT: get_local $push[[L1:[0-9]+]]=, 1{{$}} +; CHECK-NEXT: local.get $push[[L0:[0-9]+]]=, 0{{$}} +; CHECK-NEXT: local.get $push[[L1:[0-9]+]]=, 1{{$}} ; CHECK-NEXT: f32.lt $push[[NUM0:[0-9]+]]=, $pop[[L0]], $pop[[L1]]{{$}} ; CHECK-NEXT: i32.const $push[[C0:[0-9]+]]=, 1 ; CHECK-NEXT: i32.xor $push[[NUM2:[0-9]+]]=, $pop[[NUM0]], $pop[[C0]]{{$}} Index: test/CodeGen/WebAssembly/comparisons-f64.ll =================================================================== --- test/CodeGen/WebAssembly/comparisons-f64.ll +++ test/CodeGen/WebAssembly/comparisons-f64.ll @@ -8,11 +8,11 @@ ; CHECK-LABEL: ord_f64: ; CHECK-NEXT: .functype ord_f64 (f64, f64) -> (i32){{$}} -; CHECK-NEXT: get_local $push[[L0:[0-9]+]]=, 0{{$}} -; CHECK-NEXT: get_local $push[[L1:[0-9]+]]=, 0{{$}} +; CHECK-NEXT: local.get $push[[L0:[0-9]+]]=, 0{{$}} +; CHECK-NEXT: local.get $push[[L1:[0-9]+]]=, 0{{$}} ; CHECK-NEXT: f64.eq $push[[NUM0:[0-9]+]]=, $pop[[L0]], $pop[[L1]]{{$}} -; CHECK-NEXT: get_local $push[[L2:[0-9]+]]=, 1{{$}} -; CHECK-NEXT: get_local $push[[L3:[0-9]+]]=, 1{{$}} +; CHECK-NEXT: local.get $push[[L2:[0-9]+]]=, 1{{$}} +; CHECK-NEXT: local.get $push[[L3:[0-9]+]]=, 1{{$}} ; CHECK-NEXT: f64.eq $push[[NUM1:[0-9]+]]=, $pop[[L2]], $pop[[L3]]{{$}} ; CHECK-NEXT: i32.and $push[[NUM2:[0-9]+]]=, $pop[[NUM0]], $pop[[NUM1]]{{$}} ; CHECK-NEXT: return $pop[[NUM2]]{{$}} @@ -24,11 +24,11 @@ ; CHECK-LABEL: uno_f64: ; CHECK-NEXT: .functype uno_f64 (f64, f64) -> (i32){{$}} -; CHECK-NEXT: get_local $push[[L0:[0-9]+]]=, 0{{$}} -; CHECK-NEXT: get_local $push[[L1:[0-9]+]]=, 0{{$}} +; CHECK-NEXT: local.get $push[[L0:[0-9]+]]=, 0{{$}} +; CHECK-NEXT: local.get $push[[L1:[0-9]+]]=, 0{{$}} ; CHECK-NEXT: f64.ne $push[[NUM0:[0-9]+]]=, $pop[[L0]], $pop[[L1]]{{$}} -; CHECK-NEXT: get_local $push[[L2:[0-9]+]]=, 1{{$}} -; CHECK-NEXT: get_local $push[[L3:[0-9]+]]=, 1{{$}} +; CHECK-NEXT: local.get $push[[L2:[0-9]+]]=, 1{{$}} +; CHECK-NEXT: local.get $push[[L3:[0-9]+]]=, 1{{$}} ; CHECK-NEXT: f64.ne $push[[NUM1:[0-9]+]]=, $pop[[L2]], $pop[[L3]]{{$}} ; CHECK-NEXT: i32.or $push[[NUM2:[0-9]+]]=, $pop[[NUM0]], $pop[[NUM1]]{{$}} ; CHECK-NEXT: return $pop[[NUM2]]{{$}} @@ -40,8 +40,8 @@ ; CHECK-LABEL: oeq_f64: ; CHECK-NEXT: .functype oeq_f64 (f64, f64) -> (i32){{$}} -; CHECK-NEXT: get_local $push[[L0:[0-9]+]]=, 0{{$}} -; CHECK-NEXT: get_local $push[[L1:[0-9]+]]=, 1{{$}} +; CHECK-NEXT: local.get $push[[L0:[0-9]+]]=, 0{{$}} +; CHECK-NEXT: local.get $push[[L1:[0-9]+]]=, 1{{$}} ; CHECK-NEXT: f64.eq $push[[NUM:[0-9]+]]=, $pop[[L0]], $pop[[L1]]{{$}} ; CHECK-NEXT: return $pop[[NUM]]{{$}} define i32 @oeq_f64(double %x, double %y) { @@ -99,14 +99,14 @@ ; CHECK-LABEL: ueq_f64: ; CHECK-NEXT: .functype ueq_f64 (f64, f64) -> (i32){{$}} -; CHECK-NEXT: get_local $push[[L0:[0-9]+]]=, 0{{$}} -; CHECK-NEXT: get_local $push[[L1:[0-9]+]]=, 1{{$}} +; CHECK-NEXT: local.get $push[[L0:[0-9]+]]=, 0{{$}} +; CHECK-NEXT: local.get $push[[L1:[0-9]+]]=, 1{{$}} ; CHECK-NEXT: f64.eq $push[[NUM0:[0-9]+]]=, $pop[[L0]], $pop[[L1]]{{$}} -; CHECK-NEXT: get_local $push[[L2:[0-9]+]]=, 0{{$}} -; CHECK-NEXT: get_local $push[[L3:[0-9]+]]=, 0{{$}} +; CHECK-NEXT: local.get $push[[L2:[0-9]+]]=, 0{{$}} +; CHECK-NEXT: local.get $push[[L3:[0-9]+]]=, 0{{$}} ; CHECK-NEXT: f64.ne $push[[NUM1:[0-9]+]]=, $pop[[L2]], $pop[[L3]]{{$}} -; CHECK-NEXT: get_local $push[[L4:[0-9]+]]=, 1{{$}} -; CHECK-NEXT: get_local $push[[L5:[0-9]+]]=, 1{{$}} +; CHECK-NEXT: local.get $push[[L4:[0-9]+]]=, 1{{$}} +; CHECK-NEXT: local.get $push[[L5:[0-9]+]]=, 1{{$}} ; CHECK-NEXT: f64.ne $push[[NUM2:[0-9]+]]=, $pop[[L4]], $pop[[L5]]{{$}} ; CHECK-NEXT: i32.or $push[[NUM3:[0-9]+]]=, $pop[[NUM1]], $pop[[NUM2]]{{$}} ; CHECK-NEXT: i32.or $push[[NUM4:[0-9]+]]=, $pop[[NUM0]], $pop[[NUM3]]{{$}} @@ -119,14 +119,14 @@ ; CHECK-LABEL: one_f64: ; CHECK-NEXT: .functype one_f64 (f64, f64) -> (i32){{$}} -; CHECK-NEXT: get_local $push[[L0:[0-9]+]]=, 0{{$}} -; CHECK-NEXT: get_local $push[[L1:[0-9]+]]=, 1{{$}} +; CHECK-NEXT: local.get $push[[L0:[0-9]+]]=, 0{{$}} +; CHECK-NEXT: local.get $push[[L1:[0-9]+]]=, 1{{$}} ; CHECK-NEXT: f64.ne $push[[NUM0:[0-9]+]]=, $pop[[L0]], $pop[[L1]]{{$}} -; CHECK-NEXT: get_local $push[[L2:[0-9]+]]=, 0{{$}} -; CHECK-NEXT: get_local $push[[L3:[0-9]+]]=, 0{{$}} +; CHECK-NEXT: local.get $push[[L2:[0-9]+]]=, 0{{$}} +; CHECK-NEXT: local.get $push[[L3:[0-9]+]]=, 0{{$}} ; CHECK-NEXT: f64.eq $push[[NUM1:[0-9]+]]=, $pop[[L2]], $pop[[L3]]{{$}} -; CHECK-NEXT: get_local $push[[L4:[0-9]+]]=, 1{{$}} -; CHECK-NEXT: get_local $push[[L5:[0-9]+]]=, 1{{$}} +; CHECK-NEXT: local.get $push[[L4:[0-9]+]]=, 1{{$}} +; CHECK-NEXT: local.get $push[[L5:[0-9]+]]=, 1{{$}} ; CHECK-NEXT: f64.eq $push[[NUM2:[0-9]+]]=, $pop[[L4]], $pop[[L5]]{{$}} ; CHECK-NEXT: i32.and $push[[NUM3:[0-9]+]]=, $pop[[NUM1]], $pop[[NUM2]]{{$}} ; CHECK-NEXT: i32.and $push[[NUM4:[0-9]+]]=, $pop[[NUM0]], $pop[[NUM3]]{{$}} @@ -139,8 +139,8 @@ ; CHECK-LABEL: ult_f64: ; CHECK-NEXT: .functype ult_f64 (f64, f64) -> (i32){{$}} -; CHECK-NEXT: get_local $push[[L0:[0-9]+]]=, 0{{$}} -; CHECK-NEXT: get_local $push[[L1:[0-9]+]]=, 1{{$}} +; CHECK-NEXT: local.get $push[[L0:[0-9]+]]=, 0{{$}} +; CHECK-NEXT: local.get $push[[L1:[0-9]+]]=, 1{{$}} ; CHECK-NEXT: f64.ge $push[[NUM0:[0-9]+]]=, $pop[[L0]], $pop[[L1]]{{$}} ; CHECK-NEXT: i32.const $push[[C0:[0-9]+]]=, 1 ; CHECK-NEXT: i32.xor $push[[NUM2:[0-9]+]]=, $pop[[NUM0]], $pop[[C0]]{{$}} @@ -153,8 +153,8 @@ ; CHECK-LABEL: ule_f64: ; CHECK-NEXT: .functype ule_f64 (f64, f64) -> (i32){{$}} -; CHECK-NEXT: get_local $push[[L0:[0-9]+]]=, 0{{$}} -; CHECK-NEXT: get_local $push[[L1:[0-9]+]]=, 1{{$}} +; CHECK-NEXT: local.get $push[[L0:[0-9]+]]=, 0{{$}} +; CHECK-NEXT: local.get $push[[L1:[0-9]+]]=, 1{{$}} ; CHECK-NEXT: f64.gt $push[[NUM0:[0-9]+]]=, $pop[[L0]], $pop[[L1]]{{$}} ; CHECK-NEXT: i32.const $push[[C0:[0-9]+]]=, 1 ; CHECK-NEXT: i32.xor $push[[NUM2:[0-9]+]]=, $pop[[NUM0]], $pop[[C0]]{{$}} @@ -167,8 +167,8 @@ ; CHECK-LABEL: ugt_f64: ; CHECK-NEXT: .functype ugt_f64 (f64, f64) -> (i32){{$}} -; CHECK-NEXT: get_local $push[[L0:[0-9]+]]=, 0{{$}} -; CHECK-NEXT: get_local $push[[L1:[0-9]+]]=, 1{{$}} +; CHECK-NEXT: local.get $push[[L0:[0-9]+]]=, 0{{$}} +; CHECK-NEXT: local.get $push[[L1:[0-9]+]]=, 1{{$}} ; CHECK-NEXT: f64.le $push[[NUM0:[0-9]+]]=, $pop[[L0]], $pop[[L1]]{{$}} ; CHECK-NEXT: i32.const $push[[C0:[0-9]+]]=, 1 ; CHECK-NEXT: i32.xor $push[[NUM2:[0-9]+]]=, $pop[[NUM0]], $pop[[C0]]{{$}} @@ -181,8 +181,8 @@ ; CHECK-LABEL: uge_f64: ; CHECK-NEXT: .functype uge_f64 (f64, f64) -> (i32){{$}} -; CHECK-NEXT: get_local $push[[L0:[0-9]+]]=, 0{{$}} -; CHECK-NEXT: get_local $push[[L1:[0-9]+]]=, 1{{$}} +; CHECK-NEXT: local.get $push[[L0:[0-9]+]]=, 0{{$}} +; CHECK-NEXT: local.get $push[[L1:[0-9]+]]=, 1{{$}} ; CHECK-NEXT: f64.lt $push[[NUM0:[0-9]+]]=, $pop[[L0]], $pop[[L1]]{{$}} ; CHECK-NEXT: i32.const $push[[C0:[0-9]+]]=, 1 ; CHECK-NEXT: i32.xor $push[[NUM2:[0-9]+]]=, $pop[[NUM0]], $pop[[C0]]{{$}} Index: test/CodeGen/WebAssembly/comparisons-i32.ll =================================================================== --- test/CodeGen/WebAssembly/comparisons-i32.ll +++ test/CodeGen/WebAssembly/comparisons-i32.ll @@ -8,8 +8,8 @@ ; CHECK-LABEL: eq_i32: ; CHECK-NEXT: .functype eq_i32 (i32, i32) -> (i32){{$}} -; CHECK-NEXT: get_local $push[[L0:[0-9]+]]=, 0{{$}} -; CHECK-NEXT: get_local $push[[L1:[0-9]+]]=, 1{{$}} +; CHECK-NEXT: local.get $push[[L0:[0-9]+]]=, 0{{$}} +; CHECK-NEXT: local.get $push[[L1:[0-9]+]]=, 1{{$}} ; CHECK-NEXT: i32.eq $push[[NUM:[0-9]+]]=, $pop[[L0]], $pop[[L1]]{{$}} ; CHECK-NEXT: return $pop[[NUM]]{{$}} define i32 @eq_i32(i32 %x, i32 %y) { Index: test/CodeGen/WebAssembly/comparisons-i64.ll =================================================================== --- test/CodeGen/WebAssembly/comparisons-i64.ll +++ test/CodeGen/WebAssembly/comparisons-i64.ll @@ -8,8 +8,8 @@ ; CHECK-LABEL: eq_i64: ; CHECK-NEXT: .functype eq_i64 (i64, i64) -> (i32){{$}} -; CHECK-NEXT: get_local $push[[L0:[0-9]+]]=, 0{{$}} -; CHECK-NEXT: get_local $push[[L1:[0-9]+]]=, 1{{$}} +; CHECK-NEXT: local.get $push[[L0:[0-9]+]]=, 0{{$}} +; CHECK-NEXT: local.get $push[[L1:[0-9]+]]=, 1{{$}} ; CHECK-NEXT: i64.eq $push[[NUM:[0-9]+]]=, $pop[[L0]], $pop[[L1]]{{$}} ; CHECK-NEXT: return $pop[[NUM]]{{$}} define i32 @eq_i64(i64 %x, i64 %y) { Index: test/CodeGen/WebAssembly/conv-trap.ll =================================================================== --- test/CodeGen/WebAssembly/conv-trap.ll +++ test/CodeGen/WebAssembly/conv-trap.ll @@ -17,7 +17,7 @@ ; CHECK-NEXT: return $pop[[ALT]]{{$}} ; CHECK-NEXT: BB ; CHECK-NEXT: end_block -; CHECK-NEXT: i32.trunc_s/f32 $push[[NUM:[0-9]+]]=, $0{{$}} +; CHECK-NEXT: i32.trunc_f32_s $push[[NUM:[0-9]+]]=, $0{{$}} ; CHECK-NEXT: return $pop[[NUM]]{{$}} define i32 @i32_trunc_s_f32(float %x) { %a = fptosi float %x to i32 @@ -37,7 +37,7 @@ ; CHECK-NEXT: return $pop[[ALT]]{{$}} ; CHECK-NEXT: BB ; CHECK-NEXT: end_block -; CHECK-NEXT: i32.trunc_u/f32 $push[[NUM:[0-9]+]]=, $0{{$}} +; CHECK-NEXT: i32.trunc_f32_u $push[[NUM:[0-9]+]]=, $0{{$}} ; CHECK-NEXT: return $pop[[NUM]]{{$}} define i32 @i32_trunc_u_f32(float %x) { %a = fptoui float %x to i32 @@ -55,7 +55,7 @@ ; CHECK-NEXT: return $pop[[ALT]]{{$}} ; CHECK-NEXT: BB ; CHECK-NEXT: end_block -; CHECK-NEXT: i32.trunc_s/f64 $push[[NUM:[0-9]+]]=, $0{{$}} +; CHECK-NEXT: i32.trunc_f64_s $push[[NUM:[0-9]+]]=, $0{{$}} ; CHECK-NEXT: return $pop[[NUM]]{{$}} define i32 @i32_trunc_s_f64(double %x) { %a = fptosi double %x to i32 @@ -75,7 +75,7 @@ ; CHECK-NEXT: return $pop[[ALT]]{{$}} ; CHECK-NEXT: BB ; CHECK-NEXT: end_block -; CHECK-NEXT: i32.trunc_u/f64 $push[[NUM:[0-9]+]]=, $0{{$}} +; CHECK-NEXT: i32.trunc_f64_u $push[[NUM:[0-9]+]]=, $0{{$}} ; CHECK-NEXT: return $pop[[NUM]]{{$}} define i32 @i32_trunc_u_f64(double %x) { %a = fptoui double %x to i32 @@ -93,7 +93,7 @@ ; CHECK-NEXT: return $pop[[ALT]]{{$}} ; CHECK-NEXT: BB ; CHECK-NEXT: end_block -; CHECK-NEXT: i64.trunc_s/f32 $push[[NUM:[0-9]+]]=, $0{{$}} +; CHECK-NEXT: i64.trunc_f32_s $push[[NUM:[0-9]+]]=, $0{{$}} ; CHECK-NEXT: return $pop[[NUM]]{{$}} define i64 @i64_trunc_s_f32(float %x) { %a = fptosi float %x to i64 @@ -113,7 +113,7 @@ ; CHECK-NEXT: return $pop[[ALT]]{{$}} ; CHECK-NEXT: BB ; CHECK-NEXT: end_block -; CHECK-NEXT: i64.trunc_u/f32 $push[[NUM:[0-9]+]]=, $0{{$}} +; CHECK-NEXT: i64.trunc_f32_u $push[[NUM:[0-9]+]]=, $0{{$}} ; CHECK-NEXT: return $pop[[NUM]]{{$}} define i64 @i64_trunc_u_f32(float %x) { %a = fptoui float %x to i64 @@ -131,7 +131,7 @@ ; CHECK-NEXT: return $pop[[ALT]]{{$}} ; CHECK-NEXT: BB ; CHECK-NEXT: end_block -; CHECK-NEXT: i64.trunc_s/f64 $push[[NUM:[0-9]+]]=, $0{{$}} +; CHECK-NEXT: i64.trunc_f64_s $push[[NUM:[0-9]+]]=, $0{{$}} ; CHECK-NEXT: return $pop[[NUM]]{{$}} define i64 @i64_trunc_s_f64(double %x) { %a = fptosi double %x to i64 @@ -151,7 +151,7 @@ ; CHECK-NEXT: return $pop[[ALT]]{{$}} ; CHECK-NEXT: BB ; CHECK-NEXT: end_block -; CHECK-NEXT: i64.trunc_u/f64 $push[[NUM:[0-9]+]]=, $0{{$}} +; CHECK-NEXT: i64.trunc_f64_u $push[[NUM:[0-9]+]]=, $0{{$}} ; CHECK-NEXT: return $pop[[NUM]]{{$}} define i64 @i64_trunc_u_f64(double %x) { %a = fptoui double %x to i64 Index: test/CodeGen/WebAssembly/conv.ll =================================================================== --- test/CodeGen/WebAssembly/conv.ll +++ test/CodeGen/WebAssembly/conv.ll @@ -7,7 +7,7 @@ ; CHECK-LABEL: i32_wrap_i64: ; CHECK-NEXT: .functype i32_wrap_i64 (i64) -> (i32){{$}} -; CHECK-NEXT: i32.wrap/i64 $push[[NUM:[0-9]+]]=, $0{{$}} +; CHECK-NEXT: i32.wrap_i64 $push[[NUM:[0-9]+]]=, $0{{$}} ; CHECK-NEXT: return $pop[[NUM]]{{$}} define i32 @i32_wrap_i64(i64 %x) { %a = trunc i64 %x to i32 @@ -16,7 +16,7 @@ ; CHECK-LABEL: i64_extend_s_i32: ; CHECK-NEXT: .functype i64_extend_s_i32 (i32) -> (i64){{$}} -; CHECK-NEXT: i64.extend_s/i32 $push[[NUM:[0-9]+]]=, $0{{$}} +; CHECK-NEXT: i64.extend_i32_s $push[[NUM:[0-9]+]]=, $0{{$}} ; CHECK-NEXT: return $pop[[NUM]]{{$}} define i64 @i64_extend_s_i32(i32 %x) { %a = sext i32 %x to i64 @@ -25,7 +25,7 @@ ; CHECK-LABEL: i64_extend_u_i32: ; CHECK-NEXT: .functype i64_extend_u_i32 (i32) -> (i64){{$}} -; CHECK-NEXT: i64.extend_u/i32 $push[[NUM:[0-9]+]]=, $0{{$}} +; CHECK-NEXT: i64.extend_i32_u $push[[NUM:[0-9]+]]=, $0{{$}} ; CHECK-NEXT: return $pop[[NUM]]{{$}} define i64 @i64_extend_u_i32(i32 %x) { %a = zext i32 %x to i64 @@ -34,7 +34,7 @@ ; CHECK-LABEL: i32_trunc_s_f32: ; CHECK-NEXT: .functype i32_trunc_s_f32 (f32) -> (i32){{$}} -; CHECK-NEXT: i32.trunc_s:sat/f32 $push[[NUM:[0-9]+]]=, $0{{$}} +; CHECK-NEXT: i32.trunc_sat_f32_s $push[[NUM:[0-9]+]]=, $0{{$}} ; CHECK-NEXT: return $pop[[NUM]]{{$}} define i32 @i32_trunc_s_f32(float %x) { %a = fptosi float %x to i32 @@ -43,7 +43,7 @@ ; CHECK-LABEL: i32_trunc_sat_s_f32: ; CHECK-NEXT: .functype i32_trunc_sat_s_f32 (f32) -> (i32){{$}} -; CHECK-NEXT: i32.trunc_s:sat/f32 $push[[NUM:[0-9]+]]=, $0{{$}} +; CHECK-NEXT: i32.trunc_sat_f32_s $push[[NUM:[0-9]+]]=, $0{{$}} ; CHECK-NEXT: return $pop[[NUM]]{{$}} declare i32 @llvm.wasm.trunc.saturate.signed.i32.f32(float) define i32 @i32_trunc_sat_s_f32(float %x) { @@ -53,7 +53,7 @@ ; CHECK-LABEL: i32_trunc_u_f32: ; CHECK-NEXT: .functype i32_trunc_u_f32 (f32) -> (i32){{$}} -; CHECK-NEXT: i32.trunc_u:sat/f32 $push[[NUM:[0-9]+]]=, $0{{$}} +; CHECK-NEXT: i32.trunc_sat_f32_u $push[[NUM:[0-9]+]]=, $0{{$}} ; CHECK-NEXT: return $pop[[NUM]]{{$}} define i32 @i32_trunc_u_f32(float %x) { %a = fptoui float %x to i32 @@ -62,7 +62,7 @@ ; CHECK-LABEL: i32_trunc_sat_u_f32: ; CHECK-NEXT: .functype i32_trunc_sat_u_f32 (f32) -> (i32){{$}} -; CHECK-NEXT: i32.trunc_u:sat/f32 $push[[NUM:[0-9]+]]=, $0{{$}} +; CHECK-NEXT: i32.trunc_sat_f32_u $push[[NUM:[0-9]+]]=, $0{{$}} ; CHECK-NEXT: return $pop[[NUM]]{{$}} declare i32 @llvm.wasm.trunc.saturate.unsigned.i32.f32(float) define i32 @i32_trunc_sat_u_f32(float %x) { @@ -72,7 +72,7 @@ ; CHECK-LABEL: i32_trunc_s_f64: ; CHECK-NEXT: .functype i32_trunc_s_f64 (f64) -> (i32){{$}} -; CHECK-NEXT: i32.trunc_s:sat/f64 $push[[NUM:[0-9]+]]=, $0{{$}} +; CHECK-NEXT: i32.trunc_sat_f64_s $push[[NUM:[0-9]+]]=, $0{{$}} ; CHECK-NEXT: return $pop[[NUM]]{{$}} define i32 @i32_trunc_s_f64(double %x) { %a = fptosi double %x to i32 @@ -81,7 +81,7 @@ ; CHECK-LABEL: i32_trunc_sat_s_f64: ; CHECK-NEXT: .functype i32_trunc_sat_s_f64 (f64) -> (i32){{$}} -; CHECK-NEXT: i32.trunc_s:sat/f64 $push[[NUM:[0-9]+]]=, $0{{$}} +; CHECK-NEXT: i32.trunc_sat_f64_s $push[[NUM:[0-9]+]]=, $0{{$}} ; CHECK-NEXT: return $pop[[NUM]]{{$}} declare i32 @llvm.wasm.trunc.saturate.signed.i32.f64(double) define i32 @i32_trunc_sat_s_f64(double %x) { @@ -91,7 +91,7 @@ ; CHECK-LABEL: i32_trunc_u_f64: ; CHECK-NEXT: .functype i32_trunc_u_f64 (f64) -> (i32){{$}} -; CHECK-NEXT: i32.trunc_u:sat/f64 $push[[NUM:[0-9]+]]=, $0{{$}} +; CHECK-NEXT: i32.trunc_sat_f64_u $push[[NUM:[0-9]+]]=, $0{{$}} ; CHECK-NEXT: return $pop[[NUM]]{{$}} define i32 @i32_trunc_u_f64(double %x) { %a = fptoui double %x to i32 @@ -100,7 +100,7 @@ ; CHECK-LABEL: i32_trunc_sat_u_f64: ; CHECK-NEXT: .functype i32_trunc_sat_u_f64 (f64) -> (i32){{$}} -; CHECK-NEXT: i32.trunc_u:sat/f64 $push[[NUM:[0-9]+]]=, $0{{$}} +; CHECK-NEXT: i32.trunc_sat_f64_u $push[[NUM:[0-9]+]]=, $0{{$}} ; CHECK-NEXT: return $pop[[NUM]]{{$}} declare i32 @llvm.wasm.trunc.saturate.unsigned.i32.f64(double) define i32 @i32_trunc_sat_u_f64(double %x) { @@ -110,7 +110,7 @@ ; CHECK-LABEL: i64_trunc_s_f32: ; CHECK-NEXT: .functype i64_trunc_s_f32 (f32) -> (i64){{$}} -; CHECK-NEXT: i64.trunc_s:sat/f32 $push[[NUM:[0-9]+]]=, $0{{$}} +; CHECK-NEXT: i64.trunc_sat_f32_s $push[[NUM:[0-9]+]]=, $0{{$}} ; CHECK-NEXT: return $pop[[NUM]]{{$}} define i64 @i64_trunc_s_f32(float %x) { %a = fptosi float %x to i64 @@ -119,7 +119,7 @@ ; CHECK-LABEL: i64_trunc_sat_s_f32: ; CHECK-NEXT: .functype i64_trunc_sat_s_f32 (f32) -> (i64){{$}} -; CHECK-NEXT: i64.trunc_s:sat/f32 $push[[NUM:[0-9]+]]=, $0{{$}} +; CHECK-NEXT: i64.trunc_sat_f32_s $push[[NUM:[0-9]+]]=, $0{{$}} ; CHECK-NEXT: return $pop[[NUM]]{{$}} declare i64 @llvm.wasm.trunc.saturate.signed.i64.f32(float) define i64 @i64_trunc_sat_s_f32(float %x) { @@ -129,7 +129,7 @@ ; CHECK-LABEL: i64_trunc_u_f32: ; CHECK-NEXT: .functype i64_trunc_u_f32 (f32) -> (i64){{$}} -; CHECK-NEXT: i64.trunc_u:sat/f32 $push[[NUM:[0-9]+]]=, $0{{$}} +; CHECK-NEXT: i64.trunc_sat_f32_u $push[[NUM:[0-9]+]]=, $0{{$}} ; CHECK-NEXT: return $pop[[NUM]]{{$}} define i64 @i64_trunc_u_f32(float %x) { %a = fptoui float %x to i64 @@ -138,7 +138,7 @@ ; CHECK-LABEL: i64_trunc_sat_u_f32: ; CHECK-NEXT: .functype i64_trunc_sat_u_f32 (f32) -> (i64){{$}} -; CHECK-NEXT: i64.trunc_u:sat/f32 $push[[NUM:[0-9]+]]=, $0{{$}} +; CHECK-NEXT: i64.trunc_sat_f32_u $push[[NUM:[0-9]+]]=, $0{{$}} ; CHECK-NEXT: return $pop[[NUM]]{{$}} declare i64 @llvm.wasm.trunc.saturate.unsigned.i64.f32(float) define i64 @i64_trunc_sat_u_f32(float %x) { @@ -148,7 +148,7 @@ ; CHECK-LABEL: i64_trunc_s_f64: ; CHECK-NEXT: .functype i64_trunc_s_f64 (f64) -> (i64){{$}} -; CHECK-NEXT: i64.trunc_s:sat/f64 $push[[NUM:[0-9]+]]=, $0{{$}} +; CHECK-NEXT: i64.trunc_sat_f64_s $push[[NUM:[0-9]+]]=, $0{{$}} ; CHECK-NEXT: return $pop[[NUM]]{{$}} define i64 @i64_trunc_s_f64(double %x) { %a = fptosi double %x to i64 @@ -157,7 +157,7 @@ ; CHECK-LABEL: i64_trunc_sat_s_f64: ; CHECK-NEXT: .functype i64_trunc_sat_s_f64 (f64) -> (i64){{$}} -; CHECK-NEXT: i64.trunc_s:sat/f64 $push[[NUM:[0-9]+]]=, $0{{$}} +; CHECK-NEXT: i64.trunc_sat_f64_s $push[[NUM:[0-9]+]]=, $0{{$}} ; CHECK-NEXT: return $pop[[NUM]]{{$}} declare i64 @llvm.wasm.trunc.saturate.signed.i64.f64(double) define i64 @i64_trunc_sat_s_f64(double %x) { @@ -167,7 +167,7 @@ ; CHECK-LABEL: i64_trunc_u_f64: ; CHECK-NEXT: .functype i64_trunc_u_f64 (f64) -> (i64){{$}} -; CHECK-NEXT: i64.trunc_u:sat/f64 $push[[NUM:[0-9]+]]=, $0{{$}} +; CHECK-NEXT: i64.trunc_sat_f64_u $push[[NUM:[0-9]+]]=, $0{{$}} ; CHECK-NEXT: return $pop[[NUM]]{{$}} define i64 @i64_trunc_u_f64(double %x) { %a = fptoui double %x to i64 @@ -176,7 +176,7 @@ ; CHECK-LABEL: i64_trunc_sat_u_f64: ; CHECK-NEXT: .functype i64_trunc_sat_u_f64 (f64) -> (i64){{$}} -; CHECK-NEXT: i64.trunc_u:sat/f64 $push[[NUM:[0-9]+]]=, $0{{$}} +; CHECK-NEXT: i64.trunc_sat_f64_u $push[[NUM:[0-9]+]]=, $0{{$}} ; CHECK-NEXT: return $pop[[NUM]]{{$}} declare i64 @llvm.wasm.trunc.saturate.unsigned.i64.f64(double) define i64 @i64_trunc_sat_u_f64(double %x) { @@ -186,7 +186,7 @@ ; CHECK-LABEL: f32_convert_s_i32: ; CHECK-NEXT: .functype f32_convert_s_i32 (i32) -> (f32){{$}} -; CHECK-NEXT: f32.convert_s/i32 $push[[NUM:[0-9]+]]=, $0{{$}} +; CHECK-NEXT: f32.convert_i32_s $push[[NUM:[0-9]+]]=, $0{{$}} ; CHECK-NEXT: return $pop[[NUM]]{{$}} define float @f32_convert_s_i32(i32 %x) { %a = sitofp i32 %x to float @@ -195,7 +195,7 @@ ; CHECK-LABEL: f32_convert_u_i32: ; CHECK-NEXT: .functype f32_convert_u_i32 (i32) -> (f32){{$}} -; CHECK-NEXT: f32.convert_u/i32 $push[[NUM:[0-9]+]]=, $0{{$}} +; CHECK-NEXT: f32.convert_i32_u $push[[NUM:[0-9]+]]=, $0{{$}} ; CHECK-NEXT: return $pop[[NUM]]{{$}} define float @f32_convert_u_i32(i32 %x) { %a = uitofp i32 %x to float @@ -204,7 +204,7 @@ ; CHECK-LABEL: f64_convert_s_i32: ; CHECK-NEXT: .functype f64_convert_s_i32 (i32) -> (f64){{$}} -; CHECK-NEXT: f64.convert_s/i32 $push[[NUM:[0-9]+]]=, $0{{$}} +; CHECK-NEXT: f64.convert_i32_s $push[[NUM:[0-9]+]]=, $0{{$}} ; CHECK-NEXT: return $pop[[NUM]]{{$}} define double @f64_convert_s_i32(i32 %x) { %a = sitofp i32 %x to double @@ -213,7 +213,7 @@ ; CHECK-LABEL: f64_convert_u_i32: ; CHECK-NEXT: .functype f64_convert_u_i32 (i32) -> (f64){{$}} -; CHECK-NEXT: f64.convert_u/i32 $push[[NUM:[0-9]+]]=, $0{{$}} +; CHECK-NEXT: f64.convert_i32_u $push[[NUM:[0-9]+]]=, $0{{$}} ; CHECK-NEXT: return $pop[[NUM]]{{$}} define double @f64_convert_u_i32(i32 %x) { %a = uitofp i32 %x to double @@ -222,7 +222,7 @@ ; CHECK-LABEL: f32_convert_s_i64: ; CHECK-NEXT: .functype f32_convert_s_i64 (i64) -> (f32){{$}} -; CHECK-NEXT: f32.convert_s/i64 $push[[NUM:[0-9]+]]=, $0{{$}} +; CHECK-NEXT: f32.convert_i64_s $push[[NUM:[0-9]+]]=, $0{{$}} ; CHECK-NEXT: return $pop[[NUM]]{{$}} define float @f32_convert_s_i64(i64 %x) { %a = sitofp i64 %x to float @@ -231,7 +231,7 @@ ; CHECK-LABEL: f32_convert_u_i64: ; CHECK-NEXT: .functype f32_convert_u_i64 (i64) -> (f32){{$}} -; CHECK-NEXT: f32.convert_u/i64 $push[[NUM:[0-9]+]]=, $0{{$}} +; CHECK-NEXT: f32.convert_i64_u $push[[NUM:[0-9]+]]=, $0{{$}} ; CHECK-NEXT: return $pop[[NUM]]{{$}} define float @f32_convert_u_i64(i64 %x) { %a = uitofp i64 %x to float @@ -240,7 +240,7 @@ ; CHECK-LABEL: f64_convert_s_i64: ; CHECK-NEXT: .functype f64_convert_s_i64 (i64) -> (f64){{$}} -; CHECK-NEXT: f64.convert_s/i64 $push[[NUM:[0-9]+]]=, $0{{$}} +; CHECK-NEXT: f64.convert_i64_s $push[[NUM:[0-9]+]]=, $0{{$}} ; CHECK-NEXT: return $pop[[NUM]]{{$}} define double @f64_convert_s_i64(i64 %x) { %a = sitofp i64 %x to double @@ -249,7 +249,7 @@ ; CHECK-LABEL: f64_convert_u_i64: ; CHECK-NEXT: .functype f64_convert_u_i64 (i64) -> (f64){{$}} -; CHECK-NEXT: f64.convert_u/i64 $push[[NUM:[0-9]+]]=, $0{{$}} +; CHECK-NEXT: f64.convert_i64_u $push[[NUM:[0-9]+]]=, $0{{$}} ; CHECK-NEXT: return $pop[[NUM]]{{$}} define double @f64_convert_u_i64(i64 %x) { %a = uitofp i64 %x to double @@ -258,7 +258,7 @@ ; CHECK-LABEL: f64_promote_f32: ; CHECK-NEXT: .functype f64_promote_f32 (f32) -> (f64){{$}} -; CHECK-NEXT: f64.promote/f32 $push[[NUM:[0-9]+]]=, $0{{$}} +; CHECK-NEXT: f64.promote_f32 $push[[NUM:[0-9]+]]=, $0{{$}} ; CHECK-NEXT: return $pop[[NUM]]{{$}} define double @f64_promote_f32(float %x) { %a = fpext float %x to double @@ -267,7 +267,7 @@ ; CHECK-LABEL: f32_demote_f64: ; CHECK-NEXT: .functype f32_demote_f64 (f64) -> (f32){{$}} -; CHECK-NEXT: f32.demote/f64 $push[[NUM:[0-9]+]]=, $0{{$}} +; CHECK-NEXT: f32.demote_f64 $push[[NUM:[0-9]+]]=, $0{{$}} ; CHECK-NEXT: return $pop[[NUM]]{{$}} define float @f32_demote_f64(double %x) { %a = fptrunc double %x to float @@ -278,7 +278,7 @@ ; we need to patterm-match back to a specific instruction. ; CHECK-LABEL: anyext: -; CHECK: i64.extend_u/i32 $push0=, $0{{$}} +; CHECK: i64.extend_i32_u $push0=, $0{{$}} define i64 @anyext(i32 %x) { %y = sext i32 %x to i64 %w = shl i64 %y, 32 @@ -286,28 +286,28 @@ } ; CHECK-LABEL: bitcast_i32_to_float: -; CHECK: f32.reinterpret/i32 $push0=, $0{{$}} +; CHECK: f32.reinterpret_i32 $push0=, $0{{$}} define float @bitcast_i32_to_float(i32 %a) { %t = bitcast i32 %a to float ret float %t } ; CHECK-LABEL: bitcast_float_to_i32: -; CHECK: i32.reinterpret/f32 $push0=, $0{{$}} +; CHECK: i32.reinterpret_f32 $push0=, $0{{$}} define i32 @bitcast_float_to_i32(float %a) { %t = bitcast float %a to i32 ret i32 %t } ; CHECK-LABEL: bitcast_i64_to_double: -; CHECK: f64.reinterpret/i64 $push0=, $0{{$}} +; CHECK: f64.reinterpret_i64 $push0=, $0{{$}} define double @bitcast_i64_to_double(i64 %a) { %t = bitcast i64 %a to double ret double %t } ; CHECK-LABEL: bitcast_double_to_i64: -; CHECK: i64.reinterpret/f64 $push0=, $0{{$}} +; CHECK: i64.reinterpret_f64 $push0=, $0{{$}} define i64 @bitcast_double_to_i64(double %a) { %t = bitcast double %a to i64 ret i64 %t Index: test/CodeGen/WebAssembly/copysign-casts.ll =================================================================== --- test/CodeGen/WebAssembly/copysign-casts.ll +++ test/CodeGen/WebAssembly/copysign-casts.ll @@ -10,7 +10,7 @@ declare float @copysignf(float, float) nounwind readnone ; CHECK-LABEL: fold_promote: -; CHECK: f64.promote/f32 $push0=, $pop{{[0-9]+}}{{$}} +; CHECK: f64.promote_f32 $push0=, $pop{{[0-9]+}}{{$}} ; CHECK: f64.copysign $push1=, $pop{{[0-9]+}}, $pop0{{$}} define double @fold_promote(double %a, float %b) { %c = fpext float %b to double @@ -19,7 +19,7 @@ } ; CHECK-LABEL: fold_demote:{{$}} -; CHECK: f32.demote/f64 $push0=, $pop{{[0-9]+}}{{$}} +; CHECK: f32.demote_f64 $push0=, $pop{{[0-9]+}}{{$}} ; CHECK: f32.copysign $push1=, $pop{{[0-9]+}}, $pop0{{$}} define float @fold_demote(float %a, double %b) { %c = fptrunc double %b to float Index: test/CodeGen/WebAssembly/exception.ll =================================================================== --- test/CodeGen/WebAssembly/exception.ll +++ test/CodeGen/WebAssembly/exception.ll @@ -12,7 +12,7 @@ declare void @llvm.wasm.throw(i32, i8*) ; CHECK-LABEL: test_throw: -; CHECK: get_local $push0=, 0 +; CHECK: local.get $push0=, 0 ; CHECK-NEXT: throw __cpp_exception@EVENT, $pop0 ; CHECK-NOT: unreachable define void @test_throw(i8* %p) { @@ -21,11 +21,11 @@ } ; CHECK-LABEL: test_catch_rethrow: -; CHECK: get_global $push{{.+}}=, __stack_pointer@GLOBAL +; CHECK: global.get $push{{.+}}=, __stack_pointer@GLOBAL ; CHECK: try ; CHECK: call foo@FUNCTION ; CHECK: i32.catch $push{{.+}}=, 0 -; CHECK: set_global __stack_pointer@GLOBAL +; CHECK: global.set __stack_pointer@GLOBAL ; CHECK-DAG: i32.store __wasm_lpad_context ; CHECK-DAG: i32.store __wasm_lpad_context+4 ; CHECK: i32.call $push{{.+}}=, _Unwind_CallPersonality@FUNCTION @@ -67,7 +67,7 @@ ; CHECK: try ; CHECK: call foo@FUNCTION ; CHECK: catch_all -; CHECK: set_global __stack_pointer@GLOBAL +; CHECK: global.set __stack_pointer@GLOBAL ; CHECK: i32.call $push{{.+}}=, _ZN7CleanupD1Ev@FUNCTION ; CHECK: rethrow ; CHECK: end_try @@ -165,17 +165,17 @@ ; CHECK: try ; CHECK: call foo@FUNCTION ; CHECK: i32.catch -; CHECK-NOT: get_global $push{{.+}}=, __stack_pointer@GLOBAL -; CHECK: set_global __stack_pointer@GLOBAL +; CHECK-NOT: global.get $push{{.+}}=, __stack_pointer@GLOBAL +; CHECK: global.set __stack_pointer@GLOBAL ; CHECK: try ; CHECK: call foo@FUNCTION ; CHECK: catch_all -; CHECK-NOT: get_global $push{{.+}}=, __stack_pointer@GLOBAL -; CHECK: set_global __stack_pointer@GLOBAL +; CHECK-NOT: global.get $push{{.+}}=, __stack_pointer@GLOBAL +; CHECK: global.set __stack_pointer@GLOBAL ; CHECK: call __cxa_end_catch@FUNCTION -; CHECK-NOT: set_global __stack_pointer@GLOBAL, $pop{{.+}} +; CHECK-NOT: global.set __stack_pointer@GLOBAL, $pop{{.+}} ; CHECK: end_try -; CHECK-NOT: set_global __stack_pointer@GLOBAL, $pop{{.+}} +; CHECK-NOT: global.set __stack_pointer@GLOBAL, $pop{{.+}} ; CHECK: end_try define void @test_no_prolog_epilog_in_ehpad() personality i8* bitcast (i32 (...)* @__gxx_wasm_personality_v0 to i8*) { entry: @@ -226,7 +226,7 @@ ; CHECK: try ; CHECK: call foo@FUNCTION ; CHECK: end_try -; CHECK-NOT: set_global __stack_pointer@GLOBAL +; CHECK-NOT: global.set __stack_pointer@GLOBAL ; CHECK: return define void @no_sp_writeback() personality i8* bitcast (i32 (...)* @__gxx_wasm_personality_v0 to i8*) { entry: Index: test/CodeGen/WebAssembly/f16.ll =================================================================== --- test/CodeGen/WebAssembly/f16.ll +++ test/CodeGen/WebAssembly/f16.ll @@ -8,7 +8,7 @@ ; CHECK-LABEL: demote: ; CHECK-NEXT: .functype demote (f32) -> (f32){{$}} -; CHECK-NEXT: get_local $push[[L0:[0-9]+]]=, 0{{$}} +; CHECK-NEXT: local.get $push[[L0:[0-9]+]]=, 0{{$}} ; CHECK-NEXT: i32.call $push[[L1:[0-9]+]]=, __gnu_f2h_ieee@FUNCTION, $pop[[L0]]{{$}} ; CHECK-NEXT: f32.call $push[[L2:[0-9]+]]=, __gnu_h2f_ieee@FUNCTION, $pop[[L1]]{{$}} ; CHECK-NEXT: return $pop[[L2]]{{$}} @@ -19,7 +19,7 @@ ; CHECK-LABEL: promote: ; CHECK-NEXT: .functype promote (f32) -> (f32){{$}} -; CHECK-NEXT: get_local $push0=, 0{{$}} +; CHECK-NEXT: local.get $push0=, 0{{$}} ; CHECK-NEXT: return $pop0{{$}} define float @promote(half %f) { %t = fpext half %f to float Index: test/CodeGen/WebAssembly/f32.ll =================================================================== --- test/CodeGen/WebAssembly/f32.ll +++ test/CodeGen/WebAssembly/f32.ll @@ -17,8 +17,8 @@ ; CHECK-LABEL: fadd32: ; CHECK-NEXT: .functype fadd32 (f32, f32) -> (f32){{$}} -; CHECK-NEXT: get_local $push[[L0:[0-9]+]]=, 0{{$}} -; CHECK-NEXT: get_local $push[[L1:[0-9]+]]=, 1{{$}} +; CHECK-NEXT: local.get $push[[L0:[0-9]+]]=, 0{{$}} +; CHECK-NEXT: local.get $push[[L1:[0-9]+]]=, 1{{$}} ; CHECK-NEXT: f32.add $push[[LR:[0-9]+]]=, $pop[[L0]], $pop[[L1]]{{$}} ; CHECK-NEXT: return $pop[[LR]]{{$}} define float @fadd32(float %x, float %y) { Index: test/CodeGen/WebAssembly/f64.ll =================================================================== --- test/CodeGen/WebAssembly/f64.ll +++ test/CodeGen/WebAssembly/f64.ll @@ -17,8 +17,8 @@ ; CHECK-LABEL: fadd64: ; CHECK-NEXT: .functype fadd64 (f64, f64) -> (f64){{$}} -; CHECK-NEXT: get_local $push[[L0:[0-9]+]]=, 0{{$}} -; CHECK-NEXT: get_local $push[[L1:[0-9]+]]=, 1{{$}} +; CHECK-NEXT: local.get $push[[L0:[0-9]+]]=, 0{{$}} +; CHECK-NEXT: local.get $push[[L1:[0-9]+]]=, 1{{$}} ; CHECK-NEXT: f64.add $push[[LR:[0-9]+]]=, $pop[[L0]], $pop[[L1]]{{$}} ; CHECK-NEXT: return $pop[[LR]]{{$}} define double @fadd64(double %x, double %y) { Index: test/CodeGen/WebAssembly/fast-isel-i24.ll =================================================================== --- test/CodeGen/WebAssembly/fast-isel-i24.ll +++ test/CodeGen/WebAssembly/fast-isel-i24.ll @@ -9,8 +9,8 @@ ; CHECK-LABEL: add: ; CHECK-NEXT: .functype add (i32, i32) -> (i32){{$}} -; CHECK-NEXT: get_local $push2=, 0{{$}} -; CHECK-NEXT: get_local $push1=, 1{{$}} +; CHECK-NEXT: local.get $push2=, 0{{$}} +; CHECK-NEXT: local.get $push1=, 1{{$}} ; CHECK-NEXT: i32.add $push0=, $pop2, $pop1{{$}} ; CHECK-NEXT: end_function define i24 @add(i24 %x, i24 %y) { Index: test/CodeGen/WebAssembly/fast-isel.ll =================================================================== --- test/CodeGen/WebAssembly/fast-isel.ll +++ test/CodeGen/WebAssembly/fast-isel.ll @@ -21,28 +21,28 @@ } ; CHECK-LABEL: bitcast_i32_f32: -; CHECK: i32.reinterpret/f32 $push{{[0-9]+}}=, $0{{$}} +; CHECK: i32.reinterpret_f32 $push{{[0-9]+}}=, $0{{$}} define i32 @bitcast_i32_f32(float %x) { %y = bitcast float %x to i32 ret i32 %y } ; CHECK-LABEL: bitcast_f32_i32: -; CHECK: f32.reinterpret/i32 $push{{[0-9]+}}=, $0{{$}} +; CHECK: f32.reinterpret_i32 $push{{[0-9]+}}=, $0{{$}} define float @bitcast_f32_i32(i32 %x) { %y = bitcast i32 %x to float ret float %y } ; CHECK-LABEL: bitcast_i64_f64: -; CHECK: i64.reinterpret/f64 $push{{[0-9]+}}=, $0{{$}} +; CHECK: i64.reinterpret_f64 $push{{[0-9]+}}=, $0{{$}} define i64 @bitcast_i64_f64(double %x) { %y = bitcast double %x to i64 ret i64 %y } ; CHECK-LABEL: bitcast_f64_i64: -; CHECK: f64.reinterpret/i64 $push{{[0-9]+}}=, $0{{$}} +; CHECK: f64.reinterpret_i64 $push{{[0-9]+}}=, $0{{$}} define double @bitcast_f64_i64(i64 %x) { %y = bitcast i64 %x to double ret double %y Index: test/CodeGen/WebAssembly/function-bitcasts.ll =================================================================== --- test/CodeGen/WebAssembly/function-bitcasts.ll +++ test/CodeGen/WebAssembly/function-bitcasts.ll @@ -79,7 +79,7 @@ } ; CHECK-LABEL: test_varargs: -; CHECK: set_global +; CHECK: global.set ; CHECK: i32.const $push[[L3:[0-9]+]]=, 0{{$}} ; CHECK-NEXT: call .Lvararg_bitcast@FUNCTION, $pop[[L3]]{{$}} ; CHECK-NEXT: i32.const $push[[L4:[0-9]+]]=, 0{{$}} @@ -199,5 +199,5 @@ ; CHECK-LABEL: .Lfoo1_bitcast: ; CHECK-NEXT: .functype .Lfoo1_bitcast () -> (i32) ; CHECK-NEXT: call foo1@FUNCTION{{$}} -; CHECK-NEXT: copy_local $push0=, $0 +; CHECK-NEXT: local.copy $push0=, $0 ; CHECK-NEXT: end_function Index: test/CodeGen/WebAssembly/i32.ll =================================================================== --- test/CodeGen/WebAssembly/i32.ll +++ test/CodeGen/WebAssembly/i32.ll @@ -11,8 +11,8 @@ ; CHECK-LABEL: add32: ; CHECK-NEXT: .functype add32 (i32, i32) -> (i32){{$}} -; CHECK-NEXT: get_local $push[[L0:[0-9]+]]=, 0{{$}} -; CHECK-NEXT: get_local $push[[L1:[0-9]+]]=, 1{{$}} +; CHECK-NEXT: local.get $push[[L0:[0-9]+]]=, 0{{$}} +; CHECK-NEXT: local.get $push[[L1:[0-9]+]]=, 1{{$}} ; CHECK-NEXT: i32.add $push0=, $pop[[L0]], $pop[[L1]]{{$}} ; CHECK-NEXT: return $pop0{{$}} define i32 @add32(i32 %x, i32 %y) { @@ -22,8 +22,8 @@ ; CHECK-LABEL: sub32: ; CHECK-NEXT: .functype sub32 (i32, i32) -> (i32){{$}} -; CHECK-NEXT: get_local $push[[L0:[0-9]+]]=, 0{{$}} -; CHECK-NEXT: get_local $push[[L1:[0-9]+]]=, 1{{$}} +; CHECK-NEXT: local.get $push[[L0:[0-9]+]]=, 0{{$}} +; CHECK-NEXT: local.get $push[[L1:[0-9]+]]=, 1{{$}} ; CHECK-NEXT: i32.sub $push0=, $pop[[L0]], $pop[[L1]]{{$}} ; CHECK-NEXT: return $pop0{{$}} define i32 @sub32(i32 %x, i32 %y) { @@ -33,8 +33,8 @@ ; CHECK-LABEL: mul32: ; CHECK-NEXT: .functype mul32 (i32, i32) -> (i32){{$}} -; CHECK-NEXT: get_local $push[[L0:[0-9]+]]=, 0{{$}} -; CHECK-NEXT: get_local $push[[L1:[0-9]+]]=, 1{{$}} +; CHECK-NEXT: local.get $push[[L0:[0-9]+]]=, 0{{$}} +; CHECK-NEXT: local.get $push[[L1:[0-9]+]]=, 1{{$}} ; CHECK-NEXT: i32.mul $push0=, $pop[[L0]], $pop[[L1]]{{$}} ; CHECK-NEXT: return $pop0{{$}} define i32 @mul32(i32 %x, i32 %y) { @@ -44,8 +44,8 @@ ; CHECK-LABEL: sdiv32: ; CHECK-NEXT: .functype sdiv32 (i32, i32) -> (i32){{$}} -; CHECK-NEXT: get_local $push[[L0:[0-9]+]]=, 0{{$}} -; CHECK-NEXT: get_local $push[[L1:[0-9]+]]=, 1{{$}} +; CHECK-NEXT: local.get $push[[L0:[0-9]+]]=, 0{{$}} +; CHECK-NEXT: local.get $push[[L1:[0-9]+]]=, 1{{$}} ; CHECK-NEXT: i32.div_s $push0=, $pop[[L0]], $pop[[L1]]{{$}} ; CHECK-NEXT: return $pop0{{$}} define i32 @sdiv32(i32 %x, i32 %y) { @@ -55,8 +55,8 @@ ; CHECK-LABEL: udiv32: ; CHECK-NEXT: .functype udiv32 (i32, i32) -> (i32){{$}} -; CHECK-NEXT: get_local $push[[L0:[0-9]+]]=, 0{{$}} -; CHECK-NEXT: get_local $push[[L1:[0-9]+]]=, 1{{$}} +; CHECK-NEXT: local.get $push[[L0:[0-9]+]]=, 0{{$}} +; CHECK-NEXT: local.get $push[[L1:[0-9]+]]=, 1{{$}} ; CHECK-NEXT: i32.div_u $push0=, $pop[[L0]], $pop[[L1]]{{$}} ; CHECK-NEXT: return $pop0{{$}} define i32 @udiv32(i32 %x, i32 %y) { @@ -66,8 +66,8 @@ ; CHECK-LABEL: srem32: ; CHECK-NEXT: .functype srem32 (i32, i32) -> (i32){{$}} -; CHECK-NEXT: get_local $push[[L0:[0-9]+]]=, 0{{$}} -; CHECK-NEXT: get_local $push[[L1:[0-9]+]]=, 1{{$}} +; CHECK-NEXT: local.get $push[[L0:[0-9]+]]=, 0{{$}} +; CHECK-NEXT: local.get $push[[L1:[0-9]+]]=, 1{{$}} ; CHECK-NEXT: i32.rem_s $push0=, $pop[[L0]], $pop[[L1]]{{$}} ; CHECK-NEXT: return $pop0{{$}} define i32 @srem32(i32 %x, i32 %y) { @@ -77,8 +77,8 @@ ; CHECK-LABEL: urem32: ; CHECK-NEXT: .functype urem32 (i32, i32) -> (i32){{$}} -; CHECK-NEXT: get_local $push[[L0:[0-9]+]]=, 0{{$}} -; CHECK-NEXT: get_local $push[[L1:[0-9]+]]=, 1{{$}} +; CHECK-NEXT: local.get $push[[L0:[0-9]+]]=, 0{{$}} +; CHECK-NEXT: local.get $push[[L1:[0-9]+]]=, 1{{$}} ; CHECK-NEXT: i32.rem_u $push0=, $pop[[L0]], $pop[[L1]]{{$}} ; CHECK-NEXT: return $pop0{{$}} define i32 @urem32(i32 %x, i32 %y) { @@ -88,8 +88,8 @@ ; CHECK-LABEL: and32: ; CHECK-NEXT: .functype and32 (i32, i32) -> (i32){{$}} -; CHECK-NEXT: get_local $push[[L0:[0-9]+]]=, 0{{$}} -; CHECK-NEXT: get_local $push[[L1:[0-9]+]]=, 1{{$}} +; CHECK-NEXT: local.get $push[[L0:[0-9]+]]=, 0{{$}} +; CHECK-NEXT: local.get $push[[L1:[0-9]+]]=, 1{{$}} ; CHECK-NEXT: i32.and $push0=, $pop[[L0]], $pop[[L1]]{{$}} ; CHECK-NEXT: return $pop0{{$}} define i32 @and32(i32 %x, i32 %y) { @@ -99,8 +99,8 @@ ; CHECK-LABEL: or32: ; CHECK-NEXT: .functype or32 (i32, i32) -> (i32){{$}} -; CHECK-NEXT: get_local $push[[L0:[0-9]+]]=, 0{{$}} -; CHECK-NEXT: get_local $push[[L1:[0-9]+]]=, 1{{$}} +; CHECK-NEXT: local.get $push[[L0:[0-9]+]]=, 0{{$}} +; CHECK-NEXT: local.get $push[[L1:[0-9]+]]=, 1{{$}} ; CHECK-NEXT: i32.or $push0=, $pop[[L0]], $pop[[L1]]{{$}} ; CHECK-NEXT: return $pop0{{$}} define i32 @or32(i32 %x, i32 %y) { @@ -110,8 +110,8 @@ ; CHECK-LABEL: xor32: ; CHECK-NEXT: .functype xor32 (i32, i32) -> (i32){{$}} -; CHECK-NEXT: get_local $push[[L0:[0-9]+]]=, 0{{$}} -; CHECK-NEXT: get_local $push[[L1:[0-9]+]]=, 1{{$}} +; CHECK-NEXT: local.get $push[[L0:[0-9]+]]=, 0{{$}} +; CHECK-NEXT: local.get $push[[L1:[0-9]+]]=, 1{{$}} ; CHECK-NEXT: i32.xor $push0=, $pop[[L0]], $pop[[L1]]{{$}} ; CHECK-NEXT: return $pop0{{$}} define i32 @xor32(i32 %x, i32 %y) { @@ -121,8 +121,8 @@ ; CHECK-LABEL: shl32: ; CHECK-NEXT: .functype shl32 (i32, i32) -> (i32){{$}} -; CHECK-NEXT: get_local $push[[L0:[0-9]+]]=, 0{{$}} -; CHECK-NEXT: get_local $push[[L1:[0-9]+]]=, 1{{$}} +; CHECK-NEXT: local.get $push[[L0:[0-9]+]]=, 0{{$}} +; CHECK-NEXT: local.get $push[[L1:[0-9]+]]=, 1{{$}} ; CHECK-NEXT: i32.shl $push0=, $pop[[L0]], $pop[[L1]]{{$}} ; CHECK-NEXT: return $pop0{{$}} define i32 @shl32(i32 %x, i32 %y) { @@ -132,8 +132,8 @@ ; CHECK-LABEL: shr32: ; CHECK-NEXT: .functype shr32 (i32, i32) -> (i32){{$}} -; CHECK-NEXT: get_local $push[[L0:[0-9]+]]=, 0{{$}} -; CHECK-NEXT: get_local $push[[L1:[0-9]+]]=, 1{{$}} +; CHECK-NEXT: local.get $push[[L0:[0-9]+]]=, 0{{$}} +; CHECK-NEXT: local.get $push[[L1:[0-9]+]]=, 1{{$}} ; CHECK-NEXT: i32.shr_u $push0=, $pop[[L0]], $pop[[L1]]{{$}} ; CHECK-NEXT: return $pop0{{$}} define i32 @shr32(i32 %x, i32 %y) { @@ -143,8 +143,8 @@ ; CHECK-LABEL: sar32: ; CHECK-NEXT: .functype sar32 (i32, i32) -> (i32){{$}} -; CHECK-NEXT: get_local $push[[L0:[0-9]+]]=, 0{{$}} -; CHECK-NEXT: get_local $push[[L1:[0-9]+]]=, 1{{$}} +; CHECK-NEXT: local.get $push[[L0:[0-9]+]]=, 0{{$}} +; CHECK-NEXT: local.get $push[[L1:[0-9]+]]=, 1{{$}} ; CHECK-NEXT: i32.shr_s $push0=, $pop[[L0]], $pop[[L1]]{{$}} ; CHECK-NEXT: return $pop0{{$}} define i32 @sar32(i32 %x, i32 %y) { @@ -154,7 +154,7 @@ ; CHECK-LABEL: clz32: ; CHECK-NEXT: .functype clz32 (i32) -> (i32){{$}} -; CHECK-NEXT: get_local $push[[L0:[0-9]+]]=, 0{{$}} +; CHECK-NEXT: local.get $push[[L0:[0-9]+]]=, 0{{$}} ; CHECK-NEXT: i32.clz $push0=, $pop[[L0]]{{$}} ; CHECK-NEXT: return $pop0{{$}} define i32 @clz32(i32 %x) { @@ -164,7 +164,7 @@ ; CHECK-LABEL: clz32_zero_undef: ; CHECK-NEXT: .functype clz32_zero_undef (i32) -> (i32){{$}} -; CHECK-NEXT: get_local $push[[L0:[0-9]+]]=, 0{{$}} +; CHECK-NEXT: local.get $push[[L0:[0-9]+]]=, 0{{$}} ; CHECK-NEXT: i32.clz $push0=, $pop[[L0]]{{$}} ; CHECK-NEXT: return $pop0{{$}} define i32 @clz32_zero_undef(i32 %x) { @@ -174,7 +174,7 @@ ; CHECK-LABEL: ctz32: ; CHECK-NEXT: .functype ctz32 (i32) -> (i32){{$}} -; CHECK-NEXT: get_local $push[[L0:[0-9]+]]=, 0{{$}} +; CHECK-NEXT: local.get $push[[L0:[0-9]+]]=, 0{{$}} ; CHECK-NEXT: i32.ctz $push0=, $pop[[L0]]{{$}} ; CHECK-NEXT: return $pop0{{$}} define i32 @ctz32(i32 %x) { @@ -184,7 +184,7 @@ ; CHECK-LABEL: ctz32_zero_undef: ; CHECK-NEXT: .functype ctz32_zero_undef (i32) -> (i32){{$}} -; CHECK-NEXT: get_local $push[[L0:[0-9]+]]=, 0{{$}} +; CHECK-NEXT: local.get $push[[L0:[0-9]+]]=, 0{{$}} ; CHECK-NEXT: i32.ctz $push0=, $pop[[L0]]{{$}} ; CHECK-NEXT: return $pop0{{$}} define i32 @ctz32_zero_undef(i32 %x) { @@ -194,7 +194,7 @@ ; CHECK-LABEL: popcnt32: ; CHECK-NEXT: .functype popcnt32 (i32) -> (i32){{$}} -; CHECK-NEXT: get_local $push[[L0:[0-9]+]]=, 0{{$}} +; CHECK-NEXT: local.get $push[[L0:[0-9]+]]=, 0{{$}} ; CHECK-NEXT: i32.popcnt $push0=, $pop[[L0]]{{$}} ; CHECK-NEXT: return $pop0{{$}} define i32 @popcnt32(i32 %x) { @@ -204,7 +204,7 @@ ; CHECK-LABEL: eqz32: ; CHECK-NEXT: .functype eqz32 (i32) -> (i32){{$}} -; CHECK-NEXT: get_local $push[[L0:[0-9]+]]=, 0{{$}} +; CHECK-NEXT: local.get $push[[L0:[0-9]+]]=, 0{{$}} ; CHECK-NEXT: i32.eqz $push0=, $pop[[L0]]{{$}} ; CHECK-NEXT: return $pop0{{$}} define i32 @eqz32(i32 %x) { @@ -215,8 +215,8 @@ ; CHECK-LABEL: rotl: ; CHECK-NEXT: .functype rotl (i32, i32) -> (i32){{$}} -; CHECK-NEXT: get_local $push[[L0:[0-9]+]]=, 0{{$}} -; CHECK-NEXT: get_local $push[[L1:[0-9]+]]=, 1{{$}} +; CHECK-NEXT: local.get $push[[L0:[0-9]+]]=, 0{{$}} +; CHECK-NEXT: local.get $push[[L1:[0-9]+]]=, 1{{$}} ; CHECK-NEXT: i32.rotl $push0=, $pop[[L0]], $pop[[L1]] ; CHECK-NEXT: return $pop0{{$}} define i32 @rotl(i32 %x, i32 %y) { @@ -229,8 +229,8 @@ ; CHECK-LABEL: masked_rotl: ; CHECK-NEXT: .functype masked_rotl (i32, i32) -> (i32){{$}} -; CHECK-NEXT: get_local $push[[L0:[0-9]+]]=, 0{{$}} -; CHECK-NEXT: get_local $push[[L1:[0-9]+]]=, 1{{$}} +; CHECK-NEXT: local.get $push[[L0:[0-9]+]]=, 0{{$}} +; CHECK-NEXT: local.get $push[[L1:[0-9]+]]=, 1{{$}} ; CHECK-NEXT: i32.rotl $push0=, $pop[[L0]], $pop[[L1]] ; CHECK-NEXT: return $pop0{{$}} define i32 @masked_rotl(i32 %x, i32 %y) { @@ -244,8 +244,8 @@ ; CHECK-LABEL: rotr: ; CHECK-NEXT: .functype rotr (i32, i32) -> (i32){{$}} -; CHECK-NEXT: get_local $push[[L0:[0-9]+]]=, 0{{$}} -; CHECK-NEXT: get_local $push[[L1:[0-9]+]]=, 1{{$}} +; CHECK-NEXT: local.get $push[[L0:[0-9]+]]=, 0{{$}} +; CHECK-NEXT: local.get $push[[L1:[0-9]+]]=, 1{{$}} ; CHECK-NEXT: i32.rotr $push0=, $pop[[L0]], $pop[[L1]] ; CHECK-NEXT: return $pop0{{$}} define i32 @rotr(i32 %x, i32 %y) { @@ -258,8 +258,8 @@ ; CHECK-LABEL: masked_rotr: ; CHECK-NEXT: .functype masked_rotr (i32, i32) -> (i32){{$}} -; CHECK-NEXT: get_local $push[[L0:[0-9]+]]=, 0{{$}} -; CHECK-NEXT: get_local $push[[L1:[0-9]+]]=, 1{{$}} +; CHECK-NEXT: local.get $push[[L0:[0-9]+]]=, 0{{$}} +; CHECK-NEXT: local.get $push[[L1:[0-9]+]]=, 1{{$}} ; CHECK-NEXT: i32.rotr $push0=, $pop[[L0]], $pop[[L1]] ; CHECK-NEXT: return $pop0{{$}} define i32 @masked_rotr(i32 %x, i32 %y) { Index: test/CodeGen/WebAssembly/i64.ll =================================================================== --- test/CodeGen/WebAssembly/i64.ll +++ test/CodeGen/WebAssembly/i64.ll @@ -11,8 +11,8 @@ ; CHECK-LABEL: add64: ; CHECK-NEXT: .functype add64 (i64, i64) -> (i64){{$}} -; CHECK-NEXT: get_local $push[[L0:[0-9]+]]=, 0{{$}} -; CHECK-NEXT: get_local $push[[L1:[0-9]+]]=, 1{{$}} +; CHECK-NEXT: local.get $push[[L0:[0-9]+]]=, 0{{$}} +; CHECK-NEXT: local.get $push[[L1:[0-9]+]]=, 1{{$}} ; CHECK-NEXT: i64.add $push0=, $pop[[L0]], $pop[[L1]]{{$}} ; CHECK-NEXT: return $pop0{{$}} define i64 @add64(i64 %x, i64 %y) { @@ -22,8 +22,8 @@ ; CHECK-LABEL: sub64: ; CHECK-NEXT: .functype sub64 (i64, i64) -> (i64){{$}} -; CHECK-NEXT: get_local $push[[L0:[0-9]+]]=, 0{{$}} -; CHECK-NEXT: get_local $push[[L1:[0-9]+]]=, 1{{$}} +; CHECK-NEXT: local.get $push[[L0:[0-9]+]]=, 0{{$}} +; CHECK-NEXT: local.get $push[[L1:[0-9]+]]=, 1{{$}} ; CHECK-NEXT: i64.sub $push0=, $pop[[L0]], $pop[[L1]]{{$}} ; CHECK-NEXT: return $pop0{{$}} define i64 @sub64(i64 %x, i64 %y) { @@ -33,8 +33,8 @@ ; CHECK-LABEL: mul64: ; CHECK-NEXT: .functype mul64 (i64, i64) -> (i64){{$}} -; CHECK-NEXT: get_local $push[[L0:[0-9]+]]=, 0{{$}} -; CHECK-NEXT: get_local $push[[L1:[0-9]+]]=, 1{{$}} +; CHECK-NEXT: local.get $push[[L0:[0-9]+]]=, 0{{$}} +; CHECK-NEXT: local.get $push[[L1:[0-9]+]]=, 1{{$}} ; CHECK-NEXT: i64.mul $push0=, $pop[[L0]], $pop[[L1]]{{$}} ; CHECK-NEXT: return $pop0{{$}} define i64 @mul64(i64 %x, i64 %y) { @@ -44,8 +44,8 @@ ; CHECK-LABEL: sdiv64: ; CHECK-NEXT: .functype sdiv64 (i64, i64) -> (i64){{$}} -; CHECK-NEXT: get_local $push[[L0:[0-9]+]]=, 0{{$}} -; CHECK-NEXT: get_local $push[[L1:[0-9]+]]=, 1{{$}} +; CHECK-NEXT: local.get $push[[L0:[0-9]+]]=, 0{{$}} +; CHECK-NEXT: local.get $push[[L1:[0-9]+]]=, 1{{$}} ; CHECK-NEXT: i64.div_s $push0=, $pop[[L0]], $pop[[L1]]{{$}} ; CHECK-NEXT: return $pop0{{$}} define i64 @sdiv64(i64 %x, i64 %y) { @@ -55,8 +55,8 @@ ; CHECK-LABEL: udiv64: ; CHECK-NEXT: .functype udiv64 (i64, i64) -> (i64){{$}} -; CHECK-NEXT: get_local $push[[L0:[0-9]+]]=, 0{{$}} -; CHECK-NEXT: get_local $push[[L1:[0-9]+]]=, 1{{$}} +; CHECK-NEXT: local.get $push[[L0:[0-9]+]]=, 0{{$}} +; CHECK-NEXT: local.get $push[[L1:[0-9]+]]=, 1{{$}} ; CHECK-NEXT: i64.div_u $push0=, $pop[[L0]], $pop[[L1]]{{$}} ; CHECK-NEXT: return $pop0{{$}} define i64 @udiv64(i64 %x, i64 %y) { @@ -66,8 +66,8 @@ ; CHECK-LABEL: srem64: ; CHECK-NEXT: .functype srem64 (i64, i64) -> (i64){{$}} -; CHECK-NEXT: get_local $push[[L0:[0-9]+]]=, 0{{$}} -; CHECK-NEXT: get_local $push[[L1:[0-9]+]]=, 1{{$}} +; CHECK-NEXT: local.get $push[[L0:[0-9]+]]=, 0{{$}} +; CHECK-NEXT: local.get $push[[L1:[0-9]+]]=, 1{{$}} ; CHECK-NEXT: i64.rem_s $push0=, $pop[[L0]], $pop[[L1]]{{$}} ; CHECK-NEXT: return $pop0{{$}} define i64 @srem64(i64 %x, i64 %y) { @@ -77,8 +77,8 @@ ; CHECK-LABEL: urem64: ; CHECK-NEXT: .functype urem64 (i64, i64) -> (i64){{$}} -; CHECK-NEXT: get_local $push[[L0:[0-9]+]]=, 0{{$}} -; CHECK-NEXT: get_local $push[[L1:[0-9]+]]=, 1{{$}} +; CHECK-NEXT: local.get $push[[L0:[0-9]+]]=, 0{{$}} +; CHECK-NEXT: local.get $push[[L1:[0-9]+]]=, 1{{$}} ; CHECK-NEXT: i64.rem_u $push0=, $pop[[L0]], $pop[[L1]]{{$}} ; CHECK-NEXT: return $pop0{{$}} define i64 @urem64(i64 %x, i64 %y) { @@ -88,8 +88,8 @@ ; CHECK-LABEL: and64: ; CHECK-NEXT: .functype and64 (i64, i64) -> (i64){{$}} -; CHECK-NEXT: get_local $push[[L0:[0-9]+]]=, 0{{$}} -; CHECK-NEXT: get_local $push[[L1:[0-9]+]]=, 1{{$}} +; CHECK-NEXT: local.get $push[[L0:[0-9]+]]=, 0{{$}} +; CHECK-NEXT: local.get $push[[L1:[0-9]+]]=, 1{{$}} ; CHECK-NEXT: i64.and $push0=, $pop[[L0]], $pop[[L1]]{{$}} ; CHECK-NEXT: return $pop0{{$}} define i64 @and64(i64 %x, i64 %y) { @@ -99,8 +99,8 @@ ; CHECK-LABEL: or64: ; CHECK-NEXT: .functype or64 (i64, i64) -> (i64){{$}} -; CHECK-NEXT: get_local $push[[L0:[0-9]+]]=, 0{{$}} -; CHECK-NEXT: get_local $push[[L1:[0-9]+]]=, 1{{$}} +; CHECK-NEXT: local.get $push[[L0:[0-9]+]]=, 0{{$}} +; CHECK-NEXT: local.get $push[[L1:[0-9]+]]=, 1{{$}} ; CHECK-NEXT: i64.or $push0=, $pop[[L0]], $pop[[L1]]{{$}} ; CHECK-NEXT: return $pop0{{$}} define i64 @or64(i64 %x, i64 %y) { @@ -110,8 +110,8 @@ ; CHECK-LABEL: xor64: ; CHECK-NEXT: .functype xor64 (i64, i64) -> (i64){{$}} -; CHECK-NEXT: get_local $push[[L0:[0-9]+]]=, 0{{$}} -; CHECK-NEXT: get_local $push[[L1:[0-9]+]]=, 1{{$}} +; CHECK-NEXT: local.get $push[[L0:[0-9]+]]=, 0{{$}} +; CHECK-NEXT: local.get $push[[L1:[0-9]+]]=, 1{{$}} ; CHECK-NEXT: i64.xor $push0=, $pop[[L0]], $pop[[L1]]{{$}} ; CHECK-NEXT: return $pop0{{$}} define i64 @xor64(i64 %x, i64 %y) { @@ -121,8 +121,8 @@ ; CHECK-LABEL: shl64: ; CHECK-NEXT: .functype shl64 (i64, i64) -> (i64){{$}} -; CHECK-NEXT: get_local $push[[L0:[0-9]+]]=, 0{{$}} -; CHECK-NEXT: get_local $push[[L1:[0-9]+]]=, 1{{$}} +; CHECK-NEXT: local.get $push[[L0:[0-9]+]]=, 0{{$}} +; CHECK-NEXT: local.get $push[[L1:[0-9]+]]=, 1{{$}} ; CHECK-NEXT: i64.shl $push0=, $pop[[L0]], $pop[[L1]]{{$}} ; CHECK-NEXT: return $pop0{{$}} define i64 @shl64(i64 %x, i64 %y) { @@ -132,8 +132,8 @@ ; CHECK-LABEL: shr64: ; CHECK-NEXT: .functype shr64 (i64, i64) -> (i64){{$}} -; CHECK-NEXT: get_local $push[[L0:[0-9]+]]=, 0{{$}} -; CHECK-NEXT: get_local $push[[L1:[0-9]+]]=, 1{{$}} +; CHECK-NEXT: local.get $push[[L0:[0-9]+]]=, 0{{$}} +; CHECK-NEXT: local.get $push[[L1:[0-9]+]]=, 1{{$}} ; CHECK-NEXT: i64.shr_u $push0=, $pop[[L0]], $pop[[L1]]{{$}} ; CHECK-NEXT: return $pop0{{$}} define i64 @shr64(i64 %x, i64 %y) { @@ -143,8 +143,8 @@ ; CHECK-LABEL: sar64: ; CHECK-NEXT: .functype sar64 (i64, i64) -> (i64){{$}} -; CHECK-NEXT: get_local $push[[L0:[0-9]+]]=, 0{{$}} -; CHECK-NEXT: get_local $push[[L1:[0-9]+]]=, 1{{$}} +; CHECK-NEXT: local.get $push[[L0:[0-9]+]]=, 0{{$}} +; CHECK-NEXT: local.get $push[[L1:[0-9]+]]=, 1{{$}} ; CHECK-NEXT: i64.shr_s $push0=, $pop[[L0]], $pop[[L1]]{{$}} ; CHECK-NEXT: return $pop0{{$}} define i64 @sar64(i64 %x, i64 %y) { @@ -154,7 +154,7 @@ ; CHECK-LABEL: clz64: ; CHECK-NEXT: .functype clz64 (i64) -> (i64){{$}} -; CHECK-NEXT: get_local $push[[L0:[0-9]+]]=, 0{{$}} +; CHECK-NEXT: local.get $push[[L0:[0-9]+]]=, 0{{$}} ; CHECK-NEXT: i64.clz $push0=, $pop[[L0]]{{$}} ; CHECK-NEXT: return $pop0{{$}} define i64 @clz64(i64 %x) { @@ -164,7 +164,7 @@ ; CHECK-LABEL: clz64_zero_undef: ; CHECK-NEXT: .functype clz64_zero_undef (i64) -> (i64){{$}} -; CHECK-NEXT: get_local $push[[L0:[0-9]+]]=, 0{{$}} +; CHECK-NEXT: local.get $push[[L0:[0-9]+]]=, 0{{$}} ; CHECK-NEXT: i64.clz $push0=, $pop[[L0]]{{$}} ; CHECK-NEXT: return $pop0{{$}} define i64 @clz64_zero_undef(i64 %x) { @@ -174,7 +174,7 @@ ; CHECK-LABEL: ctz64: ; CHECK-NEXT: .functype ctz64 (i64) -> (i64){{$}} -; CHECK-NEXT: get_local $push[[L0:[0-9]+]]=, 0{{$}} +; CHECK-NEXT: local.get $push[[L0:[0-9]+]]=, 0{{$}} ; CHECK-NEXT: i64.ctz $push0=, $pop[[L0]]{{$}} ; CHECK-NEXT: return $pop0{{$}} define i64 @ctz64(i64 %x) { @@ -184,7 +184,7 @@ ; CHECK-LABEL: ctz64_zero_undef: ; CHECK-NEXT: .functype ctz64_zero_undef (i64) -> (i64){{$}} -; CHECK-NEXT: get_local $push[[L0:[0-9]+]]=, 0{{$}} +; CHECK-NEXT: local.get $push[[L0:[0-9]+]]=, 0{{$}} ; CHECK-NEXT: i64.ctz $push0=, $pop[[L0]]{{$}} ; CHECK-NEXT: return $pop0{{$}} define i64 @ctz64_zero_undef(i64 %x) { @@ -194,7 +194,7 @@ ; CHECK-LABEL: popcnt64: ; CHECK-NEXT: .functype popcnt64 (i64) -> (i64){{$}} -; CHECK-NEXT: get_local $push[[L0:[0-9]+]]=, 0{{$}} +; CHECK-NEXT: local.get $push[[L0:[0-9]+]]=, 0{{$}} ; CHECK-NEXT: i64.popcnt $push0=, $pop[[L0]]{{$}} ; CHECK-NEXT: return $pop0{{$}} define i64 @popcnt64(i64 %x) { @@ -204,7 +204,7 @@ ; CHECK-LABEL: eqz64: ; CHECK-NEXT: .functype eqz64 (i64) -> (i32){{$}} -; CHECK-NEXT: get_local $push[[L0:[0-9]+]]=, 0{{$}} +; CHECK-NEXT: local.get $push[[L0:[0-9]+]]=, 0{{$}} ; CHECK-NEXT: i64.eqz $push0=, $pop[[L0]]{{$}} ; CHECK-NEXT: return $pop0{{$}} define i32 @eqz64(i64 %x) { @@ -215,8 +215,8 @@ ; CHECK-LABEL: rotl: ; CHECK-NEXT: .functype rotl (i64, i64) -> (i64){{$}} -; CHECK-NEXT: get_local $push[[L0:[0-9]+]]=, 0{{$}} -; CHECK-NEXT: get_local $push[[L1:[0-9]+]]=, 1{{$}} +; CHECK-NEXT: local.get $push[[L0:[0-9]+]]=, 0{{$}} +; CHECK-NEXT: local.get $push[[L1:[0-9]+]]=, 1{{$}} ; CHECK-NEXT: i64.rotl $push0=, $pop[[L0]], $pop[[L1]] ; CHECK-NEXT: return $pop0{{$}} define i64 @rotl(i64 %x, i64 %y) { @@ -229,8 +229,8 @@ ; CHECK-LABEL: masked_rotl: ; CHECK-NEXT: .functype masked_rotl (i64, i64) -> (i64){{$}} -; CHECK-NEXT: get_local $push[[L0:[0-9]+]]=, 0{{$}} -; CHECK-NEXT: get_local $push[[L1:[0-9]+]]=, 1{{$}} +; CHECK-NEXT: local.get $push[[L0:[0-9]+]]=, 0{{$}} +; CHECK-NEXT: local.get $push[[L1:[0-9]+]]=, 1{{$}} ; CHECK-NEXT: i64.rotl $push0=, $pop[[L0]], $pop[[L1]] ; CHECK-NEXT: return $pop0{{$}} define i64 @masked_rotl(i64 %x, i64 %y) { @@ -244,8 +244,8 @@ ; CHECK-LABEL: rotr: ; CHECK-NEXT: .functype rotr (i64, i64) -> (i64){{$}} -; CHECK-NEXT: get_local $push[[L0:[0-9]+]]=, 0{{$}} -; CHECK-NEXT: get_local $push[[L1:[0-9]+]]=, 1{{$}} +; CHECK-NEXT: local.get $push[[L0:[0-9]+]]=, 0{{$}} +; CHECK-NEXT: local.get $push[[L1:[0-9]+]]=, 1{{$}} ; CHECK-NEXT: i64.rotr $push0=, $pop[[L0]], $pop[[L1]] ; CHECK-NEXT: return $pop0{{$}} define i64 @rotr(i64 %x, i64 %y) { @@ -258,8 +258,8 @@ ; CHECK-LABEL: masked_rotr: ; CHECK-NEXT: .functype masked_rotr (i64, i64) -> (i64){{$}} -; CHECK-NEXT: get_local $push[[L0:[0-9]+]]=, 0{{$}} -; CHECK-NEXT: get_local $push[[L1:[0-9]+]]=, 1{{$}} +; CHECK-NEXT: local.get $push[[L0:[0-9]+]]=, 0{{$}} +; CHECK-NEXT: local.get $push[[L1:[0-9]+]]=, 1{{$}} ; CHECK-NEXT: i64.rotr $push0=, $pop[[L0]], $pop[[L1]] ; CHECK-NEXT: return $pop0{{$}} define i64 @masked_rotr(i64 %x, i64 %y) { Index: test/CodeGen/WebAssembly/inline-asm-roundtrip.ll =================================================================== --- test/CodeGen/WebAssembly/inline-asm-roundtrip.ll +++ test/CodeGen/WebAssembly/inline-asm-roundtrip.ll @@ -9,9 +9,9 @@ ; int src = 1; ; int dst; ; asm ("i32.const\t2\n" -; "\tget_local\t%1\n" +; "\tlocal.get\t%1\n" ; "\ti32.add\n" -; "\tset_local\t%0" +; "\tlocal.set\t%0" ; : "=r" (dst) ; : "r" (src)); ; return dst != 3; @@ -24,18 +24,18 @@ ; CHECK-NEXT: .functype main (i32, i32) -> (i32) ; CHECK-NEXT: .local i32 ; CHECK-NEXT: i32.const 1 -; CHECK-NEXT: set_local [[SRC:[0-9]+]] +; CHECK-NEXT: local.set [[SRC:[0-9]+]] ; CHECK-NEXT: i32.const 2 -; CHECK-NEXT: get_local [[SRC]] +; CHECK-NEXT: local.get [[SRC]] ; CHECK-NEXT: i32.add -; CHECK-NEXT: set_local [[DST:[0-9]+]] -; CHECK-NEXT: get_local [[DST]] +; CHECK-NEXT: local.set [[DST:[0-9]+]] +; CHECK-NEXT: local.get [[DST]] ; CHECK-NEXT: i32.const 3 ; CHECK-NEXT: i32.ne define i32 @main(i32 %argc, i8** nocapture readnone %argv) #0 { entry: - %0 = tail call i32 asm "i32.const\092\0A\09get_local\09$1\0A\09i32.add\0A\09set_local\09$0", "=r,r"(i32 1) #1 + %0 = tail call i32 asm "i32.const\092\0A\09local.get\09$1\0A\09i32.add\0A\09local.set\09$0", "=r,r"(i32 1) #1 %cmp = icmp ne i32 %0, 3 %conv = zext i1 %cmp to i32 ret i32 %conv Index: test/CodeGen/WebAssembly/inline-asm.ll =================================================================== --- test/CodeGen/WebAssembly/inline-asm.ll +++ test/CodeGen/WebAssembly/inline-asm.ll @@ -11,7 +11,7 @@ ; CHECK-NEXT: #APP{{$}} ; CHECK-NEXT: # 0 = aaa(0){{$}} ; CHECK-NEXT: #NO_APP{{$}} -; CHECK-NEXT: get_local $push0=, 0{{$}} +; CHECK-NEXT: local.get $push0=, 0{{$}} ; CHECK-NEXT: return $pop0{{$}} define i32 @foo(i32 %r) { entry: @@ -25,7 +25,7 @@ ; CHECK-NEXT: #APP{{$}} ; CHECK-NEXT: # 0 = ccc(42){{$}} ; CHECK-NEXT: #NO_APP{{$}} -; CHECK-NEXT: get_local $push0=, 0{{$}} +; CHECK-NEXT: local.get $push0=, 0{{$}} ; CHECK-NEXT: return $pop0{{$}} define i32 @imm() { entry: @@ -38,7 +38,7 @@ ; CHECK-NEXT: #APP{{$}} ; CHECK-NEXT: # 0 = aaa(0){{$}} ; CHECK-NEXT: #NO_APP{{$}} -; CHECK-NEXT: get_local $push0=, 0{{$}} +; CHECK-NEXT: local.get $push0=, 0{{$}} ; CHECK-NEXT: return $pop0{{$}} define i64 @foo_i64(i64 %r) { entry: @@ -48,8 +48,8 @@ ; CHECK-LABEL: X_i16: ; CHECK: foo 1{{$}} -; CHECK: get_local $push[[S0:[0-9]+]]=, 0{{$}} -; CHECK-NEXT: get_local $push[[S1:[0-9]+]]=, 1{{$}} +; CHECK: local.get $push[[S0:[0-9]+]]=, 0{{$}} +; CHECK-NEXT: local.get $push[[S1:[0-9]+]]=, 1{{$}} ; CHECK-NEXT: i32.store16 0($pop[[S0]]), $pop[[S1]]{{$}} define void @X_i16(i16 * %t) { call void asm sideeffect "foo $0", "=*X,~{dirflag},~{fpsr},~{flags},~{memory}"(i16* %t) @@ -58,8 +58,8 @@ ; CHECK-LABEL: X_ptr: ; CHECK: foo 1{{$}} -; CHECK: get_local $push[[S0:[0-9]+]]=, 0{{$}} -; CHECK-NEXT: get_local $push[[S1:[0-9]+]]=, 1{{$}} +; CHECK: local.get $push[[S0:[0-9]+]]=, 0{{$}} +; CHECK-NEXT: local.get $push[[S1:[0-9]+]]=, 1{{$}} ; CHECK-NEXT: i32.store 0($pop[[S0]]), $pop[[S1]]{{$}} define void @X_ptr(i16 ** %t) { call void asm sideeffect "foo $0", "=*X,~{dirflag},~{fpsr},~{flags},~{memory}"(i16** %t) @@ -83,11 +83,11 @@ ; CHECK-LABEL: r_constraint ; CHECK: i32.const $push[[S0:[0-9]+]]=, 0{{$}} -; CHECK-NEXT: set_local [[L0:[0-9]+]], $pop[[S0]]{{$}} +; CHECK-NEXT: local.set [[L0:[0-9]+]], $pop[[S0]]{{$}} ; CHECK-NEXT: i32.const $push[[S1:[0-9]+]]=, 37{{$}} -; CHECK-NEXT: set_local [[L1:[0-9]+]], $pop[[S1]]{{$}} +; CHECK-NEXT: local.set [[L1:[0-9]+]], $pop[[S1]]{{$}} ; CHECK: foo [[L2:[0-9]+]], 1, [[L0]], [[L1]]{{$}} -; CHECK: get_local $push{{[0-9]+}}=, [[L2]]{{$}} +; CHECK: local.get $push{{[0-9]+}}=, [[L2]]{{$}} define hidden i32 @r_constraint(i32 %a, i32 %y) { entry: %z = bitcast i32 0 to i32 @@ -96,7 +96,7 @@ } ; CHECK-LABEL: tied_operands -; CHECK: get_local $push0=, 0 +; CHECK: local.get $push0=, 0 ; CHECK: return $pop0 define i32 @tied_operands(i32 %var) { entry: Index: test/CodeGen/WebAssembly/legalize.ll =================================================================== --- test/CodeGen/WebAssembly/legalize.ll +++ test/CodeGen/WebAssembly/legalize.ll @@ -34,7 +34,7 @@ ; CHECK-LABEL: fpext_f32_f64: ; CHECK: f32.load $push0=, 0($0){{$}} -; CHECK: f64.promote/f32 $push1=, $pop0{{$}} +; CHECK: f64.promote_f32 $push1=, $pop0{{$}} ; CHECK: return $pop1{{$}} define double @fpext_f32_f64(float *%p) { %v = load float, float* %p @@ -44,7 +44,7 @@ ; CHECK-LABEL: fpconv_f64_f32: ; CHECK: f64.load $push0=, 0($0){{$}} -; CHECK: f32.demote/f64 $push1=, $pop0{{$}} +; CHECK: f32.demote_f64 $push1=, $pop0{{$}} ; CHECK: return $pop1{{$}} define float @fpconv_f64_f32(double *%p) { %v = load double, double* %p Index: test/CodeGen/WebAssembly/load-ext-atomic.ll =================================================================== --- test/CodeGen/WebAssembly/load-ext-atomic.ll +++ test/CodeGen/WebAssembly/load-ext-atomic.ll @@ -84,7 +84,7 @@ ; CHECK-LABEL: sext_i32_i64: ; CHECK: i32.atomic.load $push0=, 0($0){{$}} -; CHECK: i64.extend_s/i32 $push1=, $pop0{{$}} +; CHECK: i64.extend_i32_s $push1=, $pop0{{$}} ; CHECK-NEXT: return $pop1{{$}} define i64 @sext_i32_i64(i32 *%p) { %v = load atomic i32, i32* %p seq_cst, align 4 Index: test/CodeGen/WebAssembly/load.ll =================================================================== --- test/CodeGen/WebAssembly/load.ll +++ test/CodeGen/WebAssembly/load.ll @@ -8,7 +8,7 @@ ; CHECK-LABEL: ldi32: ; CHECK-NEXT: .functype ldi32 (i32) -> (i32){{$}} -; CHECK-NEXT: get_local $push[[L0:[0-9]+]]=, 0{{$}} +; CHECK-NEXT: local.get $push[[L0:[0-9]+]]=, 0{{$}} ; CHECK-NEXT: i32.load $push[[NUM:[0-9]+]]=, 0($pop[[L0]]){{$}} ; CHECK-NEXT: return $pop[[NUM]]{{$}} define i32 @ldi32(i32 *%p) { @@ -18,7 +18,7 @@ ; CHECK-LABEL: ldi64: ; CHECK-NEXT: .functype ldi64 (i32) -> (i64){{$}} -; CHECK-NEXT: get_local $push[[L0:[0-9]+]]=, 0{{$}} +; CHECK-NEXT: local.get $push[[L0:[0-9]+]]=, 0{{$}} ; CHECK-NEXT: i64.load $push[[NUM:[0-9]+]]=, 0($pop[[L0]]){{$}} ; CHECK-NEXT: return $pop[[NUM]]{{$}} define i64 @ldi64(i64 *%p) { @@ -28,7 +28,7 @@ ; CHECK-LABEL: ldf32: ; CHECK-NEXT: .functype ldf32 (i32) -> (f32){{$}} -; CHECK-NEXT: get_local $push[[L0:[0-9]+]]=, 0{{$}} +; CHECK-NEXT: local.get $push[[L0:[0-9]+]]=, 0{{$}} ; CHECK-NEXT: f32.load $push[[NUM:[0-9]+]]=, 0($pop[[L0]]){{$}} ; CHECK-NEXT: return $pop[[NUM]]{{$}} define float @ldf32(float *%p) { @@ -38,7 +38,7 @@ ; CHECK-LABEL: ldf64: ; CHECK-NEXT: .functype ldf64 (i32) -> (f64){{$}} -; CHECK-NEXT: get_local $push[[L0:[0-9]+]]=, 0{{$}} +; CHECK-NEXT: local.get $push[[L0:[0-9]+]]=, 0{{$}} ; CHECK-NEXT: f64.load $push[[NUM:[0-9]+]]=, 0($pop[[L0]]){{$}} ; CHECK-NEXT: return $pop[[NUM]]{{$}} define double @ldf64(double *%p) { Index: test/CodeGen/WebAssembly/negative-base-reg.ll =================================================================== --- test/CodeGen/WebAssembly/negative-base-reg.ll +++ test/CodeGen/WebAssembly/negative-base-reg.ll @@ -11,7 +11,7 @@ ; If LSR stops selecting a negative base reg value, then this test will no ; longer be useful as written. ; CHECK: i32.const $push[[L0:[0-9]+]]=, -128 -; CHECK-NEXT: set_local 0, $pop[[L0]] +; CHECK-NEXT: local.set 0, $pop[[L0]] entry: br label %for.body Index: test/CodeGen/WebAssembly/offset-atomics.ll =================================================================== --- test/CodeGen/WebAssembly/offset-atomics.ll +++ test/CodeGen/WebAssembly/offset-atomics.ll @@ -363,10 +363,10 @@ ret i32 %u } -; 32->64 sext load gets selected as i32.atomic.load, i64_extend_s/i32 +; 32->64 sext load gets selected as i32.atomic.load, i64.extend_i32_s ; CHECK-LABEL: load_i32_i64_s_with_folded_offset: ; CHECK: i32.atomic.load $push0=, 24($0){{$}} -; CHECK-NEXT: i64.extend_s/i32 $push1=, $pop0{{$}} +; CHECK-NEXT: i64.extend_i32_s $push1=, $pop0{{$}} define i64 @load_i32_i64_s_with_folded_offset(i32* %p) { %q = ptrtoint i32* %p to i32 %r = add nuw i32 %q, 24 @@ -832,7 +832,7 @@ ; Fold an offset into a sign-extending rmw. ; CHECK-LABEL: rmw_add_i8_i32_s_with_folded_offset: -; CHECK: i32.atomic.rmw8_u.add $push0=, 24($0), $1{{$}} +; CHECK: i32.atomic.rmw8.add_u $push0=, 24($0), $1{{$}} ; CHECK-NEXT: i32.extend8_s $push1=, $pop0 define i32 @rmw_add_i8_i32_s_with_folded_offset(i8* %p, i32 %v) { %q = ptrtoint i8* %p to i32 @@ -844,11 +844,11 @@ ret i32 %u } -; 32->64 sext rmw gets selected as i32.atomic.rmw.add, i64_extend_s/i32 +; 32->64 sext rmw gets selected as i32.atomic.rmw.add, i64.extend_i32_s ; CHECK-LABEL: rmw_add_i32_i64_s_with_folded_offset: -; CHECK: i32.wrap/i64 $push0=, $1 +; CHECK: i32.wrap_i64 $push0=, $1 ; CHECK-NEXT: i32.atomic.rmw.add $push1=, 24($0), $pop0{{$}} -; CHECK-NEXT: i64.extend_s/i32 $push2=, $pop1{{$}} +; CHECK-NEXT: i64.extend_i32_s $push2=, $pop1{{$}} define i64 @rmw_add_i32_i64_s_with_folded_offset(i32* %p, i64 %v) { %q = ptrtoint i32* %p to i32 %r = add nuw i32 %q, 24 @@ -862,7 +862,7 @@ ; Fold a gep offset into a sign-extending rmw. ; CHECK-LABEL: rmw_add_i8_i32_s_with_folded_gep_offset: -; CHECK: i32.atomic.rmw8_u.add $push0=, 24($0), $1{{$}} +; CHECK: i32.atomic.rmw8.add_u $push0=, 24($0), $1{{$}} ; CHECK-NEXT: i32.extend8_s $push1=, $pop0 define i32 @rmw_add_i8_i32_s_with_folded_gep_offset(i8* %p, i32 %v) { %s = getelementptr inbounds i8, i8* %p, i32 24 @@ -873,7 +873,7 @@ } ; CHECK-LABEL: rmw_add_i16_i32_s_with_folded_gep_offset: -; CHECK: i32.atomic.rmw16_u.add $push0=, 48($0), $1{{$}} +; CHECK: i32.atomic.rmw16.add_u $push0=, 48($0), $1{{$}} ; CHECK-NEXT: i32.extend16_s $push1=, $pop0 define i32 @rmw_add_i16_i32_s_with_folded_gep_offset(i16* %p, i32 %v) { %s = getelementptr inbounds i16, i16* %p, i32 24 @@ -884,7 +884,7 @@ } ; CHECK-LABEL: rmw_add_i16_i64_s_with_folded_gep_offset: -; CHECK: i64.atomic.rmw16_u.add $push0=, 48($0), $1{{$}} +; CHECK: i64.atomic.rmw16.add_u $push0=, 48($0), $1{{$}} ; CHECK-NEXT: i64.extend16_s $push1=, $pop0 define i64 @rmw_add_i16_i64_s_with_folded_gep_offset(i16* %p, i64 %v) { %s = getelementptr inbounds i16, i16* %p, i32 24 @@ -898,7 +898,7 @@ ; an 'add' if the or'ed bits are known to be zero. ; CHECK-LABEL: rmw_add_i8_i32_s_with_folded_or_offset: -; CHECK: i32.atomic.rmw8_u.add $push[[R1:[0-9]+]]=, 2($pop{{[0-9]+}}), $1{{$}} +; CHECK: i32.atomic.rmw8.add_u $push[[R1:[0-9]+]]=, 2($pop{{[0-9]+}}), $1{{$}} ; CHECK-NEXT: i32.extend8_s $push{{[0-9]+}}=, $pop[[R1]]{{$}} define i32 @rmw_add_i8_i32_s_with_folded_or_offset(i32 %x, i32 %v) { %and = and i32 %x, -4 @@ -911,7 +911,7 @@ } ; CHECK-LABEL: rmw_add_i8_i64_s_with_folded_or_offset: -; CHECK: i64.atomic.rmw8_u.add $push[[R1:[0-9]+]]=, 2($pop{{[0-9]+}}), $1{{$}} +; CHECK: i64.atomic.rmw8.add_u $push[[R1:[0-9]+]]=, 2($pop{{[0-9]+}}), $1{{$}} ; CHECK-NEXT: i64.extend8_s $push{{[0-9]+}}=, $pop[[R1]]{{$}} define i64 @rmw_add_i8_i64_s_with_folded_or_offset(i32 %x, i64 %v) { %and = and i32 %x, -4 @@ -927,7 +927,7 @@ ; CHECK-LABEL: rmw_add_i16_i32_s_from_numeric_address ; CHECK: i32.const $push0=, 0{{$}} -; CHECK: i32.atomic.rmw16_u.add $push1=, 42($pop0), $0{{$}} +; CHECK: i32.atomic.rmw16.add_u $push1=, 42($pop0), $0{{$}} ; CHECK-NEXT: i32.extend16_s $push2=, $pop1 define i32 @rmw_add_i16_i32_s_from_numeric_address(i32 %v) { %s = inttoptr i32 42 to i16* @@ -939,7 +939,7 @@ ; CHECK-LABEL: rmw_add_i8_i32_s_from_global_address ; CHECK: i32.const $push0=, 0{{$}} -; CHECK: i32.atomic.rmw8_u.add $push1=, gv8($pop0), $0{{$}} +; CHECK: i32.atomic.rmw8.add_u $push1=, gv8($pop0), $0{{$}} ; CHECK-NEXT: i32.extend8_s $push2=, $pop1{{$}} define i32 @rmw_add_i8_i32_s_from_global_address(i32 %v) { %t = trunc i32 %v to i8 @@ -955,7 +955,7 @@ ; Fold an offset into a zero-extending rmw. ; CHECK-LABEL: rmw_add_i8_i32_z_with_folded_offset: -; CHECK: i32.atomic.rmw8_u.add $push0=, 24($0), $1{{$}} +; CHECK: i32.atomic.rmw8.add_u $push0=, 24($0), $1{{$}} define i32 @rmw_add_i8_i32_z_with_folded_offset(i8* %p, i32 %v) { %q = ptrtoint i8* %p to i32 %r = add nuw i32 %q, 24 @@ -967,7 +967,7 @@ } ; CHECK-LABEL: rmw_add_i32_i64_z_with_folded_offset: -; CHECK: i64.atomic.rmw32_u.add $push0=, 24($0), $1{{$}} +; CHECK: i64.atomic.rmw32.add_u $push0=, 24($0), $1{{$}} define i64 @rmw_add_i32_i64_z_with_folded_offset(i32* %p, i64 %v) { %q = ptrtoint i32* %p to i32 %r = add nuw i32 %q, 24 @@ -981,7 +981,7 @@ ; Fold a gep offset into a zero-extending rmw. ; CHECK-LABEL: rmw_add_i8_i32_z_with_folded_gep_offset: -; CHECK: i32.atomic.rmw8_u.add $push0=, 24($0), $1{{$}} +; CHECK: i32.atomic.rmw8.add_u $push0=, 24($0), $1{{$}} define i32 @rmw_add_i8_i32_z_with_folded_gep_offset(i8* %p, i32 %v) { %s = getelementptr inbounds i8, i8* %p, i32 24 %t = trunc i32 %v to i8 @@ -991,7 +991,7 @@ } ; CHECK-LABEL: rmw_add_i16_i32_z_with_folded_gep_offset: -; CHECK: i32.atomic.rmw16_u.add $push0=, 48($0), $1{{$}} +; CHECK: i32.atomic.rmw16.add_u $push0=, 48($0), $1{{$}} define i32 @rmw_add_i16_i32_z_with_folded_gep_offset(i16* %p, i32 %v) { %s = getelementptr inbounds i16, i16* %p, i32 24 %t = trunc i32 %v to i16 @@ -1001,7 +1001,7 @@ } ; CHECK-LABEL: rmw_add_i16_i64_z_with_folded_gep_offset: -; CHECK: i64.atomic.rmw16_u.add $push0=, 48($0), $1{{$}} +; CHECK: i64.atomic.rmw16.add_u $push0=, 48($0), $1{{$}} define i64 @rmw_add_i16_i64_z_with_folded_gep_offset(i16* %p, i64 %v) { %s = getelementptr inbounds i16, i16* %p, i32 24 %t = trunc i64 %v to i16 @@ -1014,7 +1014,7 @@ ; an 'add' if the or'ed bits are known to be zero. ; CHECK-LABEL: rmw_add_i8_i32_z_with_folded_or_offset: -; CHECK: i32.atomic.rmw8_u.add $push[[R1:[0-9]+]]=, 2($pop{{[0-9]+}}), $1{{$}} +; CHECK: i32.atomic.rmw8.add_u $push[[R1:[0-9]+]]=, 2($pop{{[0-9]+}}), $1{{$}} define i32 @rmw_add_i8_i32_z_with_folded_or_offset(i32 %x, i32 %v) { %and = and i32 %x, -4 %t0 = inttoptr i32 %and to i8* @@ -1026,7 +1026,7 @@ } ; CHECK-LABEL: rmw_add_i8_i64_z_with_folded_or_offset: -; CHECK: i64.atomic.rmw8_u.add $push[[R1:[0-9]+]]=, 2($pop{{[0-9]+}}), $1{{$}} +; CHECK: i64.atomic.rmw8.add_u $push[[R1:[0-9]+]]=, 2($pop{{[0-9]+}}), $1{{$}} define i64 @rmw_add_i8_i64_z_with_folded_or_offset(i32 %x, i64 %v) { %and = and i32 %x, -4 %t0 = inttoptr i32 %and to i8* @@ -1041,7 +1041,7 @@ ; CHECK-LABEL: rmw_add_i16_i32_z_from_numeric_address ; CHECK: i32.const $push0=, 0{{$}} -; CHECK: i32.atomic.rmw16_u.add $push1=, 42($pop0), $0{{$}} +; CHECK: i32.atomic.rmw16.add_u $push1=, 42($pop0), $0{{$}} define i32 @rmw_add_i16_i32_z_from_numeric_address(i32 %v) { %s = inttoptr i32 42 to i16* %t = trunc i32 %v to i16 @@ -1052,7 +1052,7 @@ ; CHECK-LABEL: rmw_add_i8_i32_z_from_global_address ; CHECK: i32.const $push0=, 0{{$}} -; CHECK: i32.atomic.rmw8_u.add $push1=, gv8($pop0), $0{{$}} +; CHECK: i32.atomic.rmw8.add_u $push1=, gv8($pop0), $0{{$}} define i32 @rmw_add_i8_i32_z_from_global_address(i32 %v) { %t = trunc i32 %v to i8 %old = atomicrmw add i8* @gv8, i8 %t seq_cst @@ -1063,7 +1063,7 @@ ; i8 return value should test anyext RMWs ; CHECK-LABEL: rmw_add_i8_i32_retvalue: -; CHECK: i32.atomic.rmw8_u.add $push0=, 0($0), $1{{$}} +; CHECK: i32.atomic.rmw8.add_u $push0=, 0($0), $1{{$}} ; CHECK-NEXT: return $pop0{{$}} define i8 @rmw_add_i8_i32_retvalue(i8 *%p, i32 %v) { %t = trunc i32 %v to i8 @@ -1261,7 +1261,7 @@ ; Fold an offset into a sign-extending rmw. ; CHECK-LABEL: cmpxchg_i8_i32_s_with_folded_offset: -; CHECK: i32.atomic.rmw8_u.cmpxchg $push0=, 24($0), $1, $2{{$}} +; CHECK: i32.atomic.rmw8.cmpxchg_u $push0=, 24($0), $1, $2{{$}} ; CHECK-NEXT: i32.extend8_s $push1=, $pop0 define i32 @cmpxchg_i8_i32_s_with_folded_offset(i8* %p, i32 %exp, i32 %new) { %q = ptrtoint i8* %p to i32 @@ -1275,12 +1275,12 @@ ret i32 %u } -; 32->64 sext rmw gets selected as i32.atomic.rmw.cmpxchg, i64_extend_s/i32 +; 32->64 sext rmw gets selected as i32.atomic.rmw.cmpxchg, i64.extend_i32_s ; CHECK-LABEL: cmpxchg_i32_i64_s_with_folded_offset: -; CHECK: i32.wrap/i64 $push1=, $1 -; CHECK-NEXT: i32.wrap/i64 $push0=, $2 +; CHECK: i32.wrap_i64 $push1=, $1 +; CHECK-NEXT: i32.wrap_i64 $push0=, $2 ; CHECK-NEXT: i32.atomic.rmw.cmpxchg $push2=, 24($0), $pop1, $pop0{{$}} -; CHECK-NEXT: i64.extend_s/i32 $push3=, $pop2{{$}} +; CHECK-NEXT: i64.extend_i32_s $push3=, $pop2{{$}} define i64 @cmpxchg_i32_i64_s_with_folded_offset(i32* %p, i64 %exp, i64 %new) { %q = ptrtoint i32* %p to i32 %r = add nuw i32 %q, 24 @@ -1296,7 +1296,7 @@ ; Fold a gep offset into a sign-extending rmw. ; CHECK-LABEL: cmpxchg_i8_i32_s_with_folded_gep_offset: -; CHECK: i32.atomic.rmw8_u.cmpxchg $push0=, 24($0), $1, $2{{$}} +; CHECK: i32.atomic.rmw8.cmpxchg_u $push0=, 24($0), $1, $2{{$}} ; CHECK-NEXT: i32.extend8_s $push1=, $pop0 define i32 @cmpxchg_i8_i32_s_with_folded_gep_offset(i8* %p, i32 %exp, i32 %new) { %s = getelementptr inbounds i8, i8* %p, i32 24 @@ -1309,7 +1309,7 @@ } ; CHECK-LABEL: cmpxchg_i16_i32_s_with_folded_gep_offset: -; CHECK: i32.atomic.rmw16_u.cmpxchg $push0=, 48($0), $1, $2{{$}} +; CHECK: i32.atomic.rmw16.cmpxchg_u $push0=, 48($0), $1, $2{{$}} ; CHECK-NEXT: i32.extend16_s $push1=, $pop0 define i32 @cmpxchg_i16_i32_s_with_folded_gep_offset(i16* %p, i32 %exp, i32 %new) { %s = getelementptr inbounds i16, i16* %p, i32 24 @@ -1322,7 +1322,7 @@ } ; CHECK-LABEL: cmpxchg_i16_i64_s_with_folded_gep_offset: -; CHECK: i64.atomic.rmw16_u.cmpxchg $push0=, 48($0), $1, $2{{$}} +; CHECK: i64.atomic.rmw16.cmpxchg_u $push0=, 48($0), $1, $2{{$}} ; CHECK-NEXT: i64.extend16_s $push1=, $pop0 define i64 @cmpxchg_i16_i64_s_with_folded_gep_offset(i16* %p, i64 %exp, i64 %new) { %s = getelementptr inbounds i16, i16* %p, i32 24 @@ -1338,7 +1338,7 @@ ; an 'add' if the or'ed bits are known to be zero. ; CHECK-LABEL: cmpxchg_i8_i32_s_with_folded_or_offset: -; CHECK: i32.atomic.rmw8_u.cmpxchg $push[[R1:[0-9]+]]=, 2($pop{{[0-9]+}}), $1, $2{{$}} +; CHECK: i32.atomic.rmw8.cmpxchg_u $push[[R1:[0-9]+]]=, 2($pop{{[0-9]+}}), $1, $2{{$}} ; CHECK-NEXT: i32.extend8_s $push{{[0-9]+}}=, $pop[[R1]]{{$}} define i32 @cmpxchg_i8_i32_s_with_folded_or_offset(i32 %x, i32 %exp, i32 %new) { %and = and i32 %x, -4 @@ -1353,7 +1353,7 @@ } ; CHECK-LABEL: cmpxchg_i8_i64_s_with_folded_or_offset: -; CHECK: i64.atomic.rmw8_u.cmpxchg $push[[R1:[0-9]+]]=, 2($pop{{[0-9]+}}), $1, $2{{$}} +; CHECK: i64.atomic.rmw8.cmpxchg_u $push[[R1:[0-9]+]]=, 2($pop{{[0-9]+}}), $1, $2{{$}} ; CHECK-NEXT: i64.extend8_s $push{{[0-9]+}}=, $pop[[R1]]{{$}} define i64 @cmpxchg_i8_i64_s_with_folded_or_offset(i32 %x, i64 %exp, i64 %new) { %and = and i32 %x, -4 @@ -1371,7 +1371,7 @@ ; CHECK-LABEL: cmpxchg_i16_i32_s_from_numeric_address ; CHECK: i32.const $push0=, 0{{$}} -; CHECK: i32.atomic.rmw16_u.cmpxchg $push1=, 42($pop0), $0, $1{{$}} +; CHECK: i32.atomic.rmw16.cmpxchg_u $push1=, 42($pop0), $0, $1{{$}} ; CHECK-NEXT: i32.extend16_s $push2=, $pop1 define i32 @cmpxchg_i16_i32_s_from_numeric_address(i32 %exp, i32 %new) { %s = inttoptr i32 42 to i16* @@ -1385,7 +1385,7 @@ ; CHECK-LABEL: cmpxchg_i8_i32_s_from_global_address ; CHECK: i32.const $push0=, 0{{$}} -; CHECK: i32.atomic.rmw8_u.cmpxchg $push1=, gv8($pop0), $0, $1{{$}} +; CHECK: i32.atomic.rmw8.cmpxchg_u $push1=, gv8($pop0), $0, $1{{$}} ; CHECK-NEXT: i32.extend8_s $push2=, $pop1{{$}} define i32 @cmpxchg_i8_i32_s_from_global_address(i32 %exp, i32 %new) { %exp_t = trunc i32 %exp to i8 @@ -1403,7 +1403,7 @@ ; Fold an offset into a sign-extending rmw. ; CHECK-LABEL: cmpxchg_i8_i32_z_with_folded_offset: -; CHECK: i32.atomic.rmw8_u.cmpxchg $push0=, 24($0), $1, $2{{$}} +; CHECK: i32.atomic.rmw8.cmpxchg_u $push0=, 24($0), $1, $2{{$}} define i32 @cmpxchg_i8_i32_z_with_folded_offset(i8* %p, i32 %exp, i32 %new) { %q = ptrtoint i8* %p to i32 %r = add nuw i32 %q, 24 @@ -1417,7 +1417,7 @@ } ; CHECK-LABEL: cmpxchg_i32_i64_z_with_folded_offset: -; CHECK: i64.atomic.rmw32_u.cmpxchg $push0=, 24($0), $1, $2{{$}} +; CHECK: i64.atomic.rmw32.cmpxchg_u $push0=, 24($0), $1, $2{{$}} define i64 @cmpxchg_i32_i64_z_with_folded_offset(i32* %p, i64 %exp, i64 %new) { %q = ptrtoint i32* %p to i32 %r = add nuw i32 %q, 24 @@ -1433,7 +1433,7 @@ ; Fold a gep offset into a sign-extending rmw. ; CHECK-LABEL: cmpxchg_i8_i32_z_with_folded_gep_offset: -; CHECK: i32.atomic.rmw8_u.cmpxchg $push0=, 24($0), $1, $2{{$}} +; CHECK: i32.atomic.rmw8.cmpxchg_u $push0=, 24($0), $1, $2{{$}} define i32 @cmpxchg_i8_i32_z_with_folded_gep_offset(i8* %p, i32 %exp, i32 %new) { %s = getelementptr inbounds i8, i8* %p, i32 24 %exp_t = trunc i32 %exp to i8 @@ -1445,7 +1445,7 @@ } ; CHECK-LABEL: cmpxchg_i16_i32_z_with_folded_gep_offset: -; CHECK: i32.atomic.rmw16_u.cmpxchg $push0=, 48($0), $1, $2{{$}} +; CHECK: i32.atomic.rmw16.cmpxchg_u $push0=, 48($0), $1, $2{{$}} define i32 @cmpxchg_i16_i32_z_with_folded_gep_offset(i16* %p, i32 %exp, i32 %new) { %s = getelementptr inbounds i16, i16* %p, i32 24 %exp_t = trunc i32 %exp to i16 @@ -1457,7 +1457,7 @@ } ; CHECK-LABEL: cmpxchg_i16_i64_z_with_folded_gep_offset: -; CHECK: i64.atomic.rmw16_u.cmpxchg $push0=, 48($0), $1, $2{{$}} +; CHECK: i64.atomic.rmw16.cmpxchg_u $push0=, 48($0), $1, $2{{$}} define i64 @cmpxchg_i16_i64_z_with_folded_gep_offset(i16* %p, i64 %exp, i64 %new) { %s = getelementptr inbounds i16, i16* %p, i32 24 %exp_t = trunc i64 %exp to i16 @@ -1472,7 +1472,7 @@ ; an 'add' if the or'ed bits are known to be zero. ; CHECK-LABEL: cmpxchg_i8_i32_z_with_folded_or_offset: -; CHECK: i32.atomic.rmw8_u.cmpxchg $push[[R1:[0-9]+]]=, 2($pop{{[0-9]+}}), $1, $2{{$}} +; CHECK: i32.atomic.rmw8.cmpxchg_u $push[[R1:[0-9]+]]=, 2($pop{{[0-9]+}}), $1, $2{{$}} define i32 @cmpxchg_i8_i32_z_with_folded_or_offset(i32 %x, i32 %exp, i32 %new) { %and = and i32 %x, -4 %t0 = inttoptr i32 %and to i8* @@ -1486,7 +1486,7 @@ } ; CHECK-LABEL: cmpxchg_i8_i64_z_with_folded_or_offset: -; CHECK: i64.atomic.rmw8_u.cmpxchg $push[[R1:[0-9]+]]=, 2($pop{{[0-9]+}}), $1, $2{{$}} +; CHECK: i64.atomic.rmw8.cmpxchg_u $push[[R1:[0-9]+]]=, 2($pop{{[0-9]+}}), $1, $2{{$}} define i64 @cmpxchg_i8_i64_z_with_folded_or_offset(i32 %x, i64 %exp, i64 %new) { %and = and i32 %x, -4 %t0 = inttoptr i32 %and to i8* @@ -1503,7 +1503,7 @@ ; CHECK-LABEL: cmpxchg_i16_i32_z_from_numeric_address ; CHECK: i32.const $push0=, 0{{$}} -; CHECK: i32.atomic.rmw16_u.cmpxchg $push1=, 42($pop0), $0, $1{{$}} +; CHECK: i32.atomic.rmw16.cmpxchg_u $push1=, 42($pop0), $0, $1{{$}} define i32 @cmpxchg_i16_i32_z_from_numeric_address(i32 %exp, i32 %new) { %s = inttoptr i32 42 to i16* %exp_t = trunc i32 %exp to i16 @@ -1516,7 +1516,7 @@ ; CHECK-LABEL: cmpxchg_i8_i32_z_from_global_address ; CHECK: i32.const $push0=, 0{{$}} -; CHECK: i32.atomic.rmw8_u.cmpxchg $push1=, gv8($pop0), $0, $1{{$}} +; CHECK: i32.atomic.rmw8.cmpxchg_u $push1=, gv8($pop0), $0, $1{{$}} define i32 @cmpxchg_i8_i32_z_from_global_address(i32 %exp, i32 %new) { %exp_t = trunc i32 %exp to i8 %new_t = trunc i32 %new to i8 Index: test/CodeGen/WebAssembly/offset-fastisel.ll =================================================================== --- test/CodeGen/WebAssembly/offset-fastisel.ll +++ test/CodeGen/WebAssembly/offset-fastisel.ll @@ -16,10 +16,10 @@ } ; CHECK-LABEL: store_i8_with_array_alloca_gep: -; CHECK: get_global $push[[L0:[0-9]+]]=, __stack_pointer +; CHECK: global.get $push[[L0:[0-9]+]]=, __stack_pointer ; CHECK: i32.const $push[[L1:[0-9]+]]=, 32{{$}} ; CHECK: i32.sub $push[[L2:[0-9]+]]=, $pop[[L0]], $pop[[L1]]{{$}} -; CHECK: copy_local $push[[L3:[0-9]+]]=, $pop[[L2]] +; CHECK: local.copy $push[[L3:[0-9]+]]=, $pop[[L2]] ; CHECK: i32.add $push[[L4:[0-9]+]]=, $pop[[L3]], $0{{$}} ; CHECK: i32.const $push[[L5:[0-9]+]]=, 0{{$}} ; CHECK: i32.store8 0($pop[[L4]]), $pop[[L5]]{{$}} Index: test/CodeGen/WebAssembly/phi.ll =================================================================== --- test/CodeGen/WebAssembly/phi.ll +++ test/CodeGen/WebAssembly/phi.ll @@ -27,9 +27,9 @@ ; CHECK-LABEL: test1: ; CHECK: .LBB1_1: -; CHECK: copy_local $[[NUM0:[0-9]+]]=, $[[NUM1:[0-9]+]]{{$}} -; CHECK: copy_local $[[NUM1]]=, $[[NUM2:[0-9]+]]{{$}} -; CHECK: copy_local $[[NUM2]]=, $[[NUM0]]{{$}} +; CHECK: local.copy $[[NUM0:[0-9]+]]=, $[[NUM1:[0-9]+]]{{$}} +; CHECK: local.copy $[[NUM1]]=, $[[NUM2:[0-9]+]]{{$}} +; CHECK: local.copy $[[NUM2]]=, $[[NUM0]]{{$}} define i32 @test1(i32 %n) { entry: br label %loop Index: test/CodeGen/WebAssembly/reg-stackify.ll =================================================================== --- test/CodeGen/WebAssembly/reg-stackify.ll +++ test/CodeGen/WebAssembly/reg-stackify.ll @@ -125,17 +125,17 @@ ; NOREGS-LABEL: stack_uses: ; NOREGS: .functype stack_uses (i32, i32, i32, i32) -> (i32){{$}} ; NOREGS-NEXT: block {{$}} -; NOREGS-NEXT: get_local 0{{$}} +; NOREGS-NEXT: local.get 0{{$}} ; NOREGS-NEXT: i32.const 1{{$}} ; NOREGS-NEXT: i32.lt_s -; NOREGS-NEXT: get_local 1{{$}} +; NOREGS-NEXT: local.get 1{{$}} ; NOREGS-NEXT: i32.const 2{{$}} ; NOREGS-NEXT: i32.lt_s ; NOREGS-NEXT: i32.xor {{$}} -; NOREGS-NEXT: get_local 2{{$}} +; NOREGS-NEXT: local.get 2{{$}} ; NOREGS-NEXT: i32.const 1{{$}} ; NOREGS-NEXT: i32.lt_s -; NOREGS-NEXT: get_local 3{{$}} +; NOREGS-NEXT: local.get 3{{$}} ; NOREGS-NEXT: i32.const 2{{$}} ; NOREGS-NEXT: i32.lt_s ; NOREGS-NEXT: i32.xor {{$}} @@ -166,13 +166,13 @@ } ; Test an interesting case where the load has multiple uses and cannot -; be trivially stackified. However, it can be stackified with a tee_local. +; be trivially stackified. However, it can be stackified with a local.tee. ; CHECK-LABEL: multiple_uses: ; CHECK: .functype multiple_uses (i32, i32, i32) -> (){{$}} ; CHECK-NEXT: block {{$}} ; CHECK-NEXT: i32.load $push[[NUM0:[0-9]+]]=, 0($2){{$}} -; CHECK-NEXT: tee_local $push[[NUM1:[0-9]+]]=, $3=, $pop[[NUM0]]{{$}} +; CHECK-NEXT: local.tee $push[[NUM1:[0-9]+]]=, $3=, $pop[[NUM0]]{{$}} ; CHECK-NEXT: i32.ge_u $push[[NUM2:[0-9]+]]=, $pop[[NUM1]], $1{{$}} ; CHECK-NEXT: br_if 0, $pop[[NUM2]]{{$}} ; CHECK-NEXT: i32.lt_u $push[[NUM3:[0-9]+]]=, $3, $0{{$}} @@ -185,18 +185,18 @@ ; NOREGS: .functype multiple_uses (i32, i32, i32) -> (){{$}} ; NOREGS: .local i32{{$}} ; NOREGS-NEXT: block {{$}} -; NOREGS-NEXT: get_local 2{{$}} +; NOREGS-NEXT: local.get 2{{$}} ; NOREGS-NEXT: i32.load 0{{$}} -; NOREGS-NEXT: tee_local 3{{$}} -; NOREGS-NEXT: get_local 1{{$}} +; NOREGS-NEXT: local.tee 3{{$}} +; NOREGS-NEXT: local.get 1{{$}} ; NOREGS-NEXT: i32.ge_u ; NOREGS-NEXT: br_if 0{{$}} -; NOREGS-NEXT: get_local 3{{$}} -; NOREGS-NEXT: get_local 0{{$}} +; NOREGS-NEXT: local.get 3{{$}} +; NOREGS-NEXT: local.get 0{{$}} ; NOREGS-NEXT: i32.lt_u ; NOREGS-NEXT: br_if 0{{$}} -; NOREGS-NEXT: get_local 2{{$}} -; NOREGS-NEXT: get_local 3{{$}} +; NOREGS-NEXT: local.get 2{{$}} +; NOREGS-NEXT: local.get 3{{$}} ; NOREGS-NEXT: i32.store 0{{$}} ; NOREGS-NEXT: .LBB8_3: ; NOREGS-NEXT: end_block{{$}} @@ -270,33 +270,33 @@ ; CHECK-NEXT: return $pop[[L14]]{{$}} ; NOREGS-LABEL: div_tree: ; NOREGS: .functype div_tree (i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32) -> (i32){{$}} -; NOREGS-NEXT: get_local 0{{$}} -; NOREGS-NEXT: get_local 1{{$}} +; NOREGS-NEXT: local.get 0{{$}} +; NOREGS-NEXT: local.get 1{{$}} ; NOREGS-NEXT: i32.div_s{{$}} -; NOREGS-NEXT: get_local 2{{$}} -; NOREGS-NEXT: get_local 3{{$}} +; NOREGS-NEXT: local.get 2{{$}} +; NOREGS-NEXT: local.get 3{{$}} ; NOREGS-NEXT: i32.div_s{{$}} ; NOREGS-NEXT: i32.div_s{{$}} -; NOREGS-NEXT: get_local 4{{$}} -; NOREGS-NEXT: get_local 5{{$}} +; NOREGS-NEXT: local.get 4{{$}} +; NOREGS-NEXT: local.get 5{{$}} ; NOREGS-NEXT: i32.div_s{{$}} -; NOREGS-NEXT: get_local 6{{$}} -; NOREGS-NEXT: get_local 7{{$}} +; NOREGS-NEXT: local.get 6{{$}} +; NOREGS-NEXT: local.get 7{{$}} ; NOREGS-NEXT: i32.div_s{{$}} ; NOREGS-NEXT: i32.div_s{{$}} ; NOREGS-NEXT: i32.div_s{{$}} -; NOREGS-NEXT: get_local 8{{$}} -; NOREGS-NEXT: get_local 9{{$}} +; NOREGS-NEXT: local.get 8{{$}} +; NOREGS-NEXT: local.get 9{{$}} ; NOREGS-NEXT: i32.div_s{{$}} -; NOREGS-NEXT: get_local 10{{$}} -; NOREGS-NEXT: get_local 11{{$}} +; NOREGS-NEXT: local.get 10{{$}} +; NOREGS-NEXT: local.get 11{{$}} ; NOREGS-NEXT: i32.div_s{{$}} ; NOREGS-NEXT: i32.div_s{{$}} -; NOREGS-NEXT: get_local 12{{$}} -; NOREGS-NEXT: get_local 13{{$}} +; NOREGS-NEXT: local.get 12{{$}} +; NOREGS-NEXT: local.get 13{{$}} ; NOREGS-NEXT: i32.div_s{{$}} -; NOREGS-NEXT: get_local 14{{$}} -; NOREGS-NEXT: get_local 15{{$}} +; NOREGS-NEXT: local.get 14{{$}} +; NOREGS-NEXT: local.get 15{{$}} ; NOREGS-NEXT: i32.div_s{{$}} ; NOREGS-NEXT: i32.div_s{{$}} ; NOREGS-NEXT: i32.div_s{{$}} @@ -327,18 +327,18 @@ ; CHECK-LABEL: simple_multiple_use: ; CHECK: .functype simple_multiple_use (i32, i32) -> (){{$}} ; CHECK-NEXT: i32.mul $push[[NUM0:[0-9]+]]=, $1, $0{{$}} -; CHECK-NEXT: tee_local $push[[NUM1:[0-9]+]]=, $[[NUM2:[0-9]+]]=, $pop[[NUM0]]{{$}} +; CHECK-NEXT: local.tee $push[[NUM1:[0-9]+]]=, $[[NUM2:[0-9]+]]=, $pop[[NUM0]]{{$}} ; CHECK-NEXT: call use_a@FUNCTION, $pop[[NUM1]]{{$}} ; CHECK-NEXT: call use_b@FUNCTION, $[[NUM2]]{{$}} ; CHECK-NEXT: return{{$}} ; NOREGS-LABEL: simple_multiple_use: ; NOREGS: .functype simple_multiple_use (i32, i32) -> (){{$}} -; NOREGS-NEXT: get_local 1{{$}} -; NOREGS-NEXT: get_local 0{{$}} +; NOREGS-NEXT: local.get 1{{$}} +; NOREGS-NEXT: local.get 0{{$}} ; NOREGS-NEXT: i32.mul -; NOREGS-NEXT: tee_local 1{{$}} +; NOREGS-NEXT: local.tee 1{{$}} ; NOREGS-NEXT: call use_a@FUNCTION{{$}} -; NOREGS-NEXT: get_local 1{{$}} +; NOREGS-NEXT: local.get 1{{$}} ; NOREGS-NEXT: call use_b@FUNCTION{{$}} ; NOREGS-NEXT: return{{$}} declare void @use_a(i32) @@ -355,16 +355,16 @@ ; CHECK-LABEL: multiple_uses_in_same_insn: ; CHECK: .functype multiple_uses_in_same_insn (i32, i32) -> (){{$}} ; CHECK-NEXT: i32.mul $push[[NUM0:[0-9]+]]=, $1, $0{{$}} -; CHECK-NEXT: tee_local $push[[NUM1:[0-9]+]]=, $[[NUM2:[0-9]+]]=, $pop[[NUM0]]{{$}} +; CHECK-NEXT: local.tee $push[[NUM1:[0-9]+]]=, $[[NUM2:[0-9]+]]=, $pop[[NUM0]]{{$}} ; CHECK-NEXT: call use_2@FUNCTION, $pop[[NUM1]], $[[NUM2]]{{$}} ; CHECK-NEXT: return{{$}} ; NOREGS-LABEL: multiple_uses_in_same_insn: ; NOREGS: .functype multiple_uses_in_same_insn (i32, i32) -> (){{$}} -; NOREGS-NEXT: get_local 1{{$}} -; NOREGS-NEXT: get_local 0{{$}} +; NOREGS-NEXT: local.get 1{{$}} +; NOREGS-NEXT: local.get 0{{$}} ; NOREGS-NEXT: i32.mul -; NOREGS-NEXT: tee_local 1{{$}} -; NOREGS-NEXT: get_local 1{{$}} +; NOREGS-NEXT: local.tee 1{{$}} +; NOREGS-NEXT: local.get 1{{$}} ; NOREGS-NEXT: call use_2@FUNCTION{{$}} ; NOREGS-NEXT: return{{$}} declare void @use_2(i32, i32) @@ -405,7 +405,7 @@ } ; Don't stackify a register when it would move a the def of the register past -; an implicit get_local for the register. +; an implicit local.get for the register. ; CHECK-LABEL: no_stackify_past_use: ; CHECK: i32.call $1=, callee@FUNCTION, $0 @@ -416,16 +416,16 @@ ; CHECK-NEXT: i32.div_s $push4=, $pop3, $1 ; CHECK-NEXT: return $pop4 ; NOREGS-LABEL: no_stackify_past_use: -; NOREGS: get_local 0{{$}} +; NOREGS: local.get 0{{$}} ; NOREGS-NEXT: i32.call callee@FUNCTION -; NOREGS-NEXT: set_local 1{{$}} -; NOREGS-NEXT: get_local 0{{$}} +; NOREGS-NEXT: local.set 1{{$}} +; NOREGS-NEXT: local.get 0{{$}} ; NOREGS-NEXT: i32.const 1 ; NOREGS-NEXT: i32.add ; NOREGS-NEXT: i32.call callee@FUNCTION -; NOREGS-NEXT: get_local 1{{$}} +; NOREGS-NEXT: local.get 1{{$}} ; NOREGS-NEXT: i32.sub -; NOREGS-NEXT: get_local 1{{$}} +; NOREGS-NEXT: local.get 1{{$}} ; NOREGS-NEXT: i32.div_s ; NOREGS-NEXT: return declare i32 @callee(i32) @@ -443,7 +443,7 @@ ; CHECK-LABEL: commute_to_fix_ordering: ; CHECK: i32.call $push[[L0:.+]]=, callee@FUNCTION, $0 -; CHECK: tee_local $push[[L1:.+]]=, $1=, $pop[[L0]] +; CHECK: local.tee $push[[L1:.+]]=, $1=, $pop[[L0]] ; CHECK: i32.const $push0=, 1 ; CHECK: i32.add $push1=, $0, $pop0 ; CHECK: i32.call $push2=, callee@FUNCTION, $pop1 @@ -451,11 +451,11 @@ ; CHECK: i32.mul $push4=, $pop[[L1]], $pop3 ; CHECK: return $pop4 ; NOREGS-LABEL: commute_to_fix_ordering: -; NOREGS: get_local 0{{$}} +; NOREGS: local.get 0{{$}} ; NOREGS: i32.call callee@FUNCTION -; NOREGS: tee_local 1 -; NOREGS: get_local 1{{$}} -; NOREGS: get_local 0{{$}} +; NOREGS: local.tee 1 +; NOREGS: local.get 1{{$}} +; NOREGS: local.get 0{{$}} ; NOREGS: i32.const 1 ; NOREGS: i32.add ; NOREGS: i32.call callee@FUNCTION @@ -475,12 +475,12 @@ ; CHECK-LABEL: multiple_defs: ; CHECK: f64.add $push[[NUM0:[0-9]+]]=, ${{[0-9]+}}, $pop{{[0-9]+}}{{$}} -; CHECK-NEXT: tee_local $push[[NUM1:[0-9]+]]=, $[[NUM2:[0-9]+]]=, $pop[[NUM0]]{{$}} +; CHECK-NEXT: local.tee $push[[NUM1:[0-9]+]]=, $[[NUM2:[0-9]+]]=, $pop[[NUM0]]{{$}} ; CHECK-NEXT: f64.select $push{{[0-9]+}}=, $pop{{[0-9]+}}, $pop[[NUM1]], ${{[0-9]+}}{{$}} ; CHECK: $[[NUM2]]=, ; NOREGS-LABEL: multiple_defs: ; NOREGS: f64.add -; NOREGS: tee_local +; NOREGS: local.tee ; NOREGS: f64.select define void @multiple_defs(i32 %arg, i32 %arg1, i1 %arg2, i1 %arg3, i1 %arg4) { bb: @@ -602,12 +602,12 @@ ; CHECK-LABEL: stackify_indvar: ; CHECK: i32.const $push[[L5:.+]]=, 1{{$}} ; CHECK-NEXT: i32.add $push[[L4:.+]]=, $[[R0:.+]], $pop[[L5]]{{$}} -; CHECK-NEXT: tee_local $push[[L3:.+]]=, $[[R0]]=, $pop[[L4]]{{$}} +; CHECK-NEXT: local.tee $push[[L3:.+]]=, $[[R0]]=, $pop[[L4]]{{$}} ; CHECK-NEXT: i32.ne $push[[L2:.+]]=, $0, $pop[[L3]]{{$}} ; NOREGS-LABEL: stackify_indvar: ; NOREGS: i32.const 1{{$}} ; NOREGS-NEXT: i32.add -; NOREGS-NEXT: tee_local 2{{$}} +; NOREGS-NEXT: local.tee 2{{$}} ; NOREGS-NEXT: i32.ne define void @stackify_indvar(i32 %tmp, i32* %v) #0 { bb: @@ -630,10 +630,10 @@ ; CHECK-LABEL: stackpointer_dependency: ; CHECK: call {{.+}}, stackpointer_callee@FUNCTION, -; CHECK-NEXT: set_global __stack_pointer@GLOBAL, +; CHECK-NEXT: global.set __stack_pointer@GLOBAL, ; NOREGS-LABEL: stackpointer_dependency: ; NOREGS: call stackpointer_callee@FUNCTION -; NOREGS: set_global __stack_pointer +; NOREGS: global.set __stack_pointer declare i32 @stackpointer_callee(i8* readnone, i8* readnone) declare i8* @llvm.frameaddress(i32) define i32 @stackpointer_dependency(i8* readnone) { @@ -646,13 +646,13 @@ ; CHECK-LABEL: call_indirect_stackify: ; CHECK: i32.load $push[[L4:.+]]=, 0($0) -; CHECK-NEXT: tee_local $push[[L3:.+]]=, $0=, $pop[[L4]] +; CHECK-NEXT: local.tee $push[[L3:.+]]=, $0=, $pop[[L4]] ; CHECK-NEXT: i32.load $push[[L0:.+]]=, 0($0) ; CHECK-NEXT: i32.load $push[[L1:.+]]=, 0($pop[[L0]]) ; CHECK-NEXT: i32.call_indirect $push{{.+}}=, $pop[[L3]], $1, $pop[[L1]] ; NOREGS-LABEL: call_indirect_stackify: ; NOREGS: i32.load 0 -; NOREGS-NEXT: tee_local 0 +; NOREGS-NEXT: local.tee 0 ; NOREGS: i32.load 0 ; NOREGS-NEXT: i32.load 0 ; NOREGS-NEXT: i32.call_indirect Index: test/CodeGen/WebAssembly/return-int32.ll =================================================================== --- test/CodeGen/WebAssembly/return-int32.ll +++ test/CodeGen/WebAssembly/return-int32.ll @@ -6,7 +6,7 @@ ; CHECK-LABEL: return_i32: ; CHECK-NEXT: .functype return_i32 (i32) -> (i32){{$}} -; CHECK-NEXT: get_local $push0=, 0 +; CHECK-NEXT: local.get $push0=, 0 ; CHECK-NEXT: end_function{{$}} define i32 @return_i32(i32 %p) { ret i32 %p Index: test/CodeGen/WebAssembly/signext-inreg.ll =================================================================== --- test/CodeGen/WebAssembly/signext-inreg.ll +++ test/CodeGen/WebAssembly/signext-inreg.ll @@ -30,7 +30,7 @@ ; CHECK-LABEL: i64_extend8_s: ; CHECK-NEXT: .functype i64_extend8_s (i32) -> (i64){{$}} -; CHECK-NEXT: i64.extend_u/i32 $push[[NUM1:[0-9]+]]=, $0{{$}} +; CHECK-NEXT: i64.extend_i32_u $push[[NUM1:[0-9]+]]=, $0{{$}} ; CHECK-NEXT: i64.extend8_s $push[[NUM2:[0-9]+]]=, $pop[[NUM1]]{{$}} ; CHECK-NEXT: return $pop[[NUM2]]{{$}} @@ -43,7 +43,7 @@ ; CHECK-LABEL: i64_extend16_s: ; CHECK-NEXT: .functype i64_extend16_s (i32) -> (i64){{$}} -; CHECK-NEXT: i64.extend_u/i32 $push[[NUM1:[0-9]+]]=, $0{{$}} +; CHECK-NEXT: i64.extend_i32_u $push[[NUM1:[0-9]+]]=, $0{{$}} ; CHECK-NEXT: i64.extend16_s $push[[NUM2:[0-9]+]]=, $pop[[NUM1]]{{$}} ; CHECK-NEXT: return $pop[[NUM2]]{{$}} @@ -57,7 +57,7 @@ ; No SIGN_EXTEND_INREG is needed for 32->64 extension. ; CHECK-LABEL: i64_extend32_s: ; CHECK-NEXT: .functype i64_extend32_s (i32) -> (i64){{$}} -; CHECK-NEXT: i64.extend_s/i32 $push[[NUM:[0-9]+]]=, $0{{$}} +; CHECK-NEXT: i64.extend_i32_s $push[[NUM:[0-9]+]]=, $0{{$}} ; CHECK-NEXT: return $pop[[NUM]]{{$}} define i64 @i64_extend32_s(i32 %x) { %a = sext i32 %x to i64 Index: test/CodeGen/WebAssembly/simd-arith.ll =================================================================== --- test/CodeGen/WebAssembly/simd-arith.ll +++ test/CodeGen/WebAssembly/simd-arith.ll @@ -725,7 +725,7 @@ ; CHECK-LABEL: shl_nozext_v2i64: ; NO-SIMD128-NOT: i64x2 ; SIMD128-NEXT: .functype shl_nozext_v2i64 (v128, i64) -> (v128){{$}} -; SIMD128-NEXT: i32.wrap/i64 $push[[L0:[0-9]+]]=, $1{{$}} +; SIMD128-NEXT: i32.wrap_i64 $push[[L0:[0-9]+]]=, $1{{$}} ; SIMD128-NEXT: i64x2.shl $push[[R:[0-9]+]]=, $0, $pop[[L0]]{{$}} ; SIMD128-NEXT: return $pop[[R]]{{$}} define <2 x i64> @shl_nozext_v2i64(<2 x i64> %v, i64 %x) { @@ -779,7 +779,7 @@ ; CHECK-LABEL: shr_s_nozext_v2i64: ; NO-SIMD128-NOT: i64x2 ; SIMD128-NEXT: .functype shr_s_nozext_v2i64 (v128, i64) -> (v128){{$}} -; SIMD128-NEXT: i32.wrap/i64 $push[[L0:[0-9]+]]=, $1{{$}} +; SIMD128-NEXT: i32.wrap_i64 $push[[L0:[0-9]+]]=, $1{{$}} ; SIMD128-NEXT: i64x2.shr_s $push[[R:[0-9]+]]=, $0, $pop[[L0]]{{$}} ; SIMD128-NEXT: return $pop[[R]]{{$}} define <2 x i64> @shr_s_nozext_v2i64(<2 x i64> %v, i64 %x) { @@ -833,7 +833,7 @@ ; CHECK-LABEL: shr_u_nozext_v2i64: ; NO-SIMD128-NOT: i64x2 ; SIMD128-NEXT: .functype shr_u_nozext_v2i64 (v128, i64) -> (v128){{$}} -; SIMD128-NEXT: i32.wrap/i64 $push[[L0:[0-9]+]]=, $1{{$}} +; SIMD128-NEXT: i32.wrap_i64 $push[[L0:[0-9]+]]=, $1{{$}} ; SIMD128-NEXT: i64x2.shr_u $push[[R:[0-9]+]]=, $0, $pop[[L0]]{{$}} ; SIMD128-NEXT: return $pop[[R]]{{$}} define <2 x i64> @shr_u_nozext_v2i64(<2 x i64> %v, i64 %x) { Index: test/CodeGen/WebAssembly/simd-conversions.ll =================================================================== --- test/CodeGen/WebAssembly/simd-conversions.ll +++ test/CodeGen/WebAssembly/simd-conversions.ll @@ -10,7 +10,7 @@ ; CHECK-LABEL: convert_s_v4f32: ; NO-SIMD128-NOT: i32x4 ; SIMD128-NEXT: .functype convert_s_v4f32 (v128) -> (v128){{$}} -; SIMD128-NEXT: f32x4.convert_s/i32x4 $push[[R:[0-9]+]]=, $0 +; SIMD128-NEXT: f32x4.convert_i32x4_s $push[[R:[0-9]+]]=, $0 ; SIMD128-NEXT: return $pop[[R]] define <4 x float> @convert_s_v4f32(<4 x i32> %x) { %a = sitofp <4 x i32> %x to <4 x float> @@ -20,7 +20,7 @@ ; CHECK-LABEL: convert_u_v4f32: ; NO-SIMD128-NOT: i32x4 ; SIMD128-NEXT: .functype convert_u_v4f32 (v128) -> (v128){{$}} -; SIMD128-NEXT: f32x4.convert_u/i32x4 $push[[R:[0-9]+]]=, $0 +; SIMD128-NEXT: f32x4.convert_i32x4_u $push[[R:[0-9]+]]=, $0 ; SIMD128-NEXT: return $pop[[R]] define <4 x float> @convert_u_v4f32(<4 x i32> %x) { %a = uitofp <4 x i32> %x to <4 x float> @@ -29,9 +29,9 @@ ; CHECK-LABEL: convert_s_v2f64: ; NO-SIMD128-NOT: i64x2 -; SIMD128-VM-NOT: f64x2.convert_s/i64x2 +; SIMD128-VM-NOT: f64x2.convert_i64x2_s ; SIMD128-NEXT: .functype convert_s_v2f64 (v128) -> (v128){{$}} -; SIMD128-NEXT: f64x2.convert_s/i64x2 $push[[R:[0-9]+]]=, $0 +; SIMD128-NEXT: f64x2.convert_i64x2_s $push[[R:[0-9]+]]=, $0 ; SIMD128-NEXT: return $pop[[R]] define <2 x double> @convert_s_v2f64(<2 x i64> %x) { %a = sitofp <2 x i64> %x to <2 x double> @@ -40,9 +40,9 @@ ; CHECK-LABEL: convert_u_v2f64: ; NO-SIMD128-NOT: i64x2 -; SIMD128-VM-NOT: f64x2.convert_u/i64x2 +; SIMD128-VM-NOT: f64x2.convert_i64x2_u ; SIMD128-NEXT: .functype convert_u_v2f64 (v128) -> (v128){{$}} -; SIMD128-NEXT: f64x2.convert_u/i64x2 $push[[R:[0-9]+]]=, $0 +; SIMD128-NEXT: f64x2.convert_i64x2_u $push[[R:[0-9]+]]=, $0 ; SIMD128-NEXT: return $pop[[R]] define <2 x double> @convert_u_v2f64(<2 x i64> %x) { %a = uitofp <2 x i64> %x to <2 x double> @@ -52,7 +52,7 @@ ; CHECK-LABEL: trunc_sat_s_v4i32: ; NO-SIMD128-NOT: f32x4 ; SIMD128-NEXT: .functype trunc_sat_s_v4i32 (v128) -> (v128){{$}} -; SIMD128-NEXT: i32x4.trunc_sat_s/f32x4 $push[[R:[0-9]+]]=, $0 +; SIMD128-NEXT: i32x4.trunc_sat_f32x4_s $push[[R:[0-9]+]]=, $0 ; SIMD128-NEXT: return $pop[[R]] define <4 x i32> @trunc_sat_s_v4i32(<4 x float> %x) { %a = fptosi <4 x float> %x to <4 x i32> @@ -62,7 +62,7 @@ ; CHECK-LABEL: trunc_sat_u_v4i32: ; NO-SIMD128-NOT: f32x4 ; SIMD128-NEXT: .functype trunc_sat_u_v4i32 (v128) -> (v128){{$}} -; SIMD128-NEXT: i32x4.trunc_sat_u/f32x4 $push[[R:[0-9]+]]=, $0 +; SIMD128-NEXT: i32x4.trunc_sat_f32x4_u $push[[R:[0-9]+]]=, $0 ; SIMD128-NEXT: return $pop[[R]] define <4 x i32> @trunc_sat_u_v4i32(<4 x float> %x) { %a = fptoui <4 x float> %x to <4 x i32> @@ -71,9 +71,9 @@ ; CHECK-LABEL: trunc_sat_s_v2i64: ; NO-SIMD128-NOT: f64x2 -; SIMD128-VM-NOT: i64x2.trunc_sat_s/f64x2 +; SIMD128-VM-NOT: i64x2.trunc_sat_f64x2_s ; SIMD128-NEXT: .functype trunc_sat_s_v2i64 (v128) -> (v128){{$}} -; SIMD128-NEXT: i64x2.trunc_sat_s/f64x2 $push[[R:[0-9]+]]=, $0 +; SIMD128-NEXT: i64x2.trunc_sat_f64x2_s $push[[R:[0-9]+]]=, $0 ; SIMD128-NEXT: return $pop[[R]] define <2 x i64> @trunc_sat_s_v2i64(<2 x double> %x) { %a = fptosi <2 x double> %x to <2 x i64> @@ -82,9 +82,9 @@ ; CHECK-LABEL: trunc_sat_u_v2i64: ; NO-SIMD128-NOT: f64x2 -; SIMD128-VM-NOT: i64x2.trunc_sat_u/f64x2 +; SIMD128-VM-NOT: i64x2.trunc_sat_f64x2_u ; SIMD128-NEXT: .functype trunc_sat_u_v2i64 (v128) -> (v128){{$}} -; SIMD128-NEXT: i64x2.trunc_sat_u/f64x2 $push[[R:[0-9]+]]=, $0 +; SIMD128-NEXT: i64x2.trunc_sat_f64x2_u $push[[R:[0-9]+]]=, $0 ; SIMD128-NEXT: return $pop[[R]] define <2 x i64> @trunc_sat_u_v2i64(<2 x double> %x) { %a = fptoui <2 x double> %x to <2 x i64> Index: test/CodeGen/WebAssembly/simd-intrinsics.ll =================================================================== --- test/CodeGen/WebAssembly/simd-intrinsics.ll +++ test/CodeGen/WebAssembly/simd-intrinsics.ll @@ -204,7 +204,7 @@ ; CHECK-LABEL: trunc_sat_s_v4i32: ; NO-SIMD128-NOT: f32x4 ; SIMD128-NEXT: .functype trunc_sat_s_v4i32 (v128) -> (v128){{$}} -; SIMD128-NEXT: i32x4.trunc_sat_s/f32x4 $push[[R:[0-9]+]]=, $0 +; SIMD128-NEXT: i32x4.trunc_sat_f32x4_s $push[[R:[0-9]+]]=, $0 ; SIMD128-NEXT: return $pop[[R]] declare <4 x i32> @llvm.wasm.trunc.saturate.signed.v4i32.v4f32(<4 x float>) define <4 x i32> @trunc_sat_s_v4i32(<4 x float> %x) { @@ -215,7 +215,7 @@ ; CHECK-LABEL: trunc_sat_u_v4i32: ; NO-SIMD128-NOT: f32x4 ; SIMD128-NEXT: .functype trunc_sat_u_v4i32 (v128) -> (v128){{$}} -; SIMD128-NEXT: i32x4.trunc_sat_u/f32x4 $push[[R:[0-9]+]]=, $0 +; SIMD128-NEXT: i32x4.trunc_sat_f32x4_u $push[[R:[0-9]+]]=, $0 ; SIMD128-NEXT: return $pop[[R]] declare <4 x i32> @llvm.wasm.trunc.saturate.unsigned.v4i32.v4f32(<4 x float>) define <4 x i32> @trunc_sat_u_v4i32(<4 x float> %x) { @@ -261,7 +261,7 @@ ; CHECK-LABEL: trunc_sat_s_v2i64: ; NO-SIMD128-NOT: f32x4 ; SIMD128-NEXT: .functype trunc_sat_s_v2i64 (v128) -> (v128){{$}} -; SIMD128-NEXT: i64x2.trunc_sat_s/f64x2 $push[[R:[0-9]+]]=, $0 +; SIMD128-NEXT: i64x2.trunc_sat_f64x2_s $push[[R:[0-9]+]]=, $0 ; SIMD128-NEXT: return $pop[[R]] declare <2 x i64> @llvm.wasm.trunc.saturate.signed.v2i64.v2f64(<2 x double>) define <2 x i64> @trunc_sat_s_v2i64(<2 x double> %x) { @@ -272,7 +272,7 @@ ; CHECK-LABEL: trunc_sat_u_v2i64: ; NO-SIMD128-NOT: f32x4 ; SIMD128-NEXT: .functype trunc_sat_u_v2i64 (v128) -> (v128){{$}} -; SIMD128-NEXT: i64x2.trunc_sat_u/f64x2 $push[[R:[0-9]+]]=, $0 +; SIMD128-NEXT: i64x2.trunc_sat_f64x2_u $push[[R:[0-9]+]]=, $0 ; SIMD128-NEXT: return $pop[[R]] declare <2 x i64> @llvm.wasm.trunc.saturate.unsigned.v2i64.v2f64(<2 x double>) define <2 x i64> @trunc_sat_u_v2i64(<2 x double> %x) { Index: test/CodeGen/WebAssembly/simd.ll =================================================================== --- test/CodeGen/WebAssembly/simd.ll +++ test/CodeGen/WebAssembly/simd.ll @@ -56,10 +56,10 @@ ; CHECK-LABEL: extract_var_v16i8_s: ; NO-SIMD128-NOT: i8x16 ; SIMD128-NEXT: .functype extract_var_v16i8_s (v128, i32) -> (i32){{$}} -; SIMD128-NEXT: get_global $push[[L0:[0-9]+]]=, __stack_pointer@GLOBAL +; SIMD128-NEXT: global.get $push[[L0:[0-9]+]]=, __stack_pointer@GLOBAL ; SIMD128-NEXT: i32.const $push[[L1:[0-9]+]]=, 16 ; SIMD128-NEXT: i32.sub $push[[L2:[0-9]+]]=, $pop[[L0]], $pop[[L1]] -; SIMD128-NEXT: tee_local $push[[L3:[0-9]+]]=, $2=, $pop[[L2]] +; SIMD128-NEXT: local.tee $push[[L3:[0-9]+]]=, $2=, $pop[[L2]] ; SIMD128-NEXT: v128.store 0($pop[[L3]]), $0 ; SIMD128-NEXT: i32.const $push[[L4:[0-9]+]]=, 15 ; SIMD128-NEXT: i32.and $push[[L5:[0-9]+]]=, $1, $pop[[L4]] @@ -98,10 +98,10 @@ ; CHECK-LABEL: extract_var_v16i8_u: ; NO-SIMD128-NOT: i8x16 ; SIMD128-NEXT: .functype extract_var_v16i8_u (v128, i32) -> (i32){{$}} -; SIMD128-NEXT: get_global $push[[L0:[0-9]+]]=, __stack_pointer@GLOBAL{{$}} +; SIMD128-NEXT: global.get $push[[L0:[0-9]+]]=, __stack_pointer@GLOBAL{{$}} ; SIMD128-NEXT: i32.const $push[[L1:[0-9]+]]=, 16{{$}} ; SIMD128-NEXT: i32.sub $push[[L2:[0-9]+]]=, $pop[[L0]], $pop[[L1]]{{$}} -; SIMD128-NEXT: tee_local $push[[L3:[0-9]+]]=, $2=, $pop[[L2]]{{$}} +; SIMD128-NEXT: local.tee $push[[L3:[0-9]+]]=, $2=, $pop[[L2]]{{$}} ; SIMD128-NEXT: v128.store 0($pop[[L3]]), $0{{$}} ; SIMD128-NEXT: i32.const $push[[L4:[0-9]+]]=, 15{{$}} ; SIMD128-NEXT: i32.and $push[[L5:[0-9]+]]=, $1, $pop[[L4]]{{$}} @@ -139,10 +139,10 @@ ; CHECK-LABEL: extract_var_v16i8: ; NO-SIMD128-NOT: i8x16 ; SIMD128-NEXT: .functype extract_var_v16i8 (v128, i32) -> (i32){{$}} -; SIMD128-NEXT: get_global $push[[L0:[0-9]+]]=, __stack_pointer@GLOBAL{{$}} +; SIMD128-NEXT: global.get $push[[L0:[0-9]+]]=, __stack_pointer@GLOBAL{{$}} ; SIMD128-NEXT: i32.const $push[[L1:[0-9]+]]=, 16{{$}} ; SIMD128-NEXT: i32.sub $push[[L2:[0-9]+]]=, $pop[[L0]], $pop[[L1]]{{$}} -; SIMD128-NEXT: tee_local $push[[L3:[0-9]+]]=, $2=, $pop[[L2]]{{$}} +; SIMD128-NEXT: local.tee $push[[L3:[0-9]+]]=, $2=, $pop[[L2]]{{$}} ; SIMD128-NEXT: v128.store 0($pop[[L3]]), $0{{$}} ; SIMD128-NEXT: i32.const $push[[L4:[0-9]+]]=, 15{{$}} ; SIMD128-NEXT: i32.and $push[[L5:[0-9]+]]=, $1, $pop[[L4]]{{$}} @@ -177,10 +177,10 @@ ; CHECK-LABEL: replace_var_v16i8: ; NO-SIMD128-NOT: i8x16 ; SIMD128-NEXT: .functype replace_var_v16i8 (v128, i32, i32) -> (v128){{$}} -; SIMD128-NEXT: get_global $push[[L0:[0-9]+]]=, __stack_pointer@GLOBAL{{$}} +; SIMD128-NEXT: global.get $push[[L0:[0-9]+]]=, __stack_pointer@GLOBAL{{$}} ; SIMD128-NEXT: i32.const $push[[L1:[0-9]+]]=, 16{{$}} ; SIMD128-NEXT: i32.sub $push[[L2:[0-9]+]]=, $pop[[L0]], $pop[[L1]]{{$}} -; SIMD128-NEXT: tee_local $push[[L3:[0-9]+]]=, $3=, $pop[[L2]]{{$}} +; SIMD128-NEXT: local.tee $push[[L3:[0-9]+]]=, $3=, $pop[[L2]]{{$}} ; SIMD128-NEXT: v128.store 0($pop[[L3]]), $0{{$}} ; SIMD128-NEXT: i32.const $push[[L4:[0-9]+]]=, 15{{$}} ; SIMD128-NEXT: i32.and $push[[L5:[0-9]+]]=, $1, $pop[[L4]]{{$}} @@ -319,10 +319,10 @@ ; CHECK-LABEL: extract_var_v8i16_s: ; NO-SIMD128-NOT: i16x8 ; SIMD128-NEXT: .functype extract_var_v8i16_s (v128, i32) -> (i32){{$}} -; SIMD128-NEXT: get_global $push[[L0:[0-9]+]]=, __stack_pointer@GLOBAL{{$}} +; SIMD128-NEXT: global.get $push[[L0:[0-9]+]]=, __stack_pointer@GLOBAL{{$}} ; SIMD128-NEXT: i32.const $push[[L1:[0-9]+]]=, 16{{$}} ; SIMD128-NEXT: i32.sub $push[[L2:[0-9]+]]=, $pop[[L0]], $pop[[L1]]{{$}} -; SIMD128-NEXT: tee_local $push[[L3:[0-9]+]]=, $2=, $pop[[L2]]{{$}} +; SIMD128-NEXT: local.tee $push[[L3:[0-9]+]]=, $2=, $pop[[L2]]{{$}} ; SIMD128-NEXT: v128.store 0($pop[[L3]]), $0{{$}} ; SIMD128-NEXT: i32.const $push[[L4:[0-9]+]]=, 7{{$}} ; SIMD128-NEXT: i32.and $push[[L5:[0-9]+]]=, $1, $pop[[L4]]{{$}} @@ -363,10 +363,10 @@ ; CHECK-LABEL: extract_var_v8i16_u: ; NO-SIMD128-NOT: i16x8 ; SIMD128-NEXT: .functype extract_var_v8i16_u (v128, i32) -> (i32){{$}} -; SIMD128-NEXT: get_global $push[[L0:[0-9]+]]=, __stack_pointer@GLOBAL{{$}} +; SIMD128-NEXT: global.get $push[[L0:[0-9]+]]=, __stack_pointer@GLOBAL{{$}} ; SIMD128-NEXT: i32.const $push[[L1:[0-9]+]]=, 16{{$}} ; SIMD128-NEXT: i32.sub $push[[L2:[0-9]+]]=, $pop[[L0]], $pop[[L1]]{{$}} -; SIMD128-NEXT: tee_local $push[[L3:[0-9]+]]=, $2=, $pop[[L2]]{{$}} +; SIMD128-NEXT: local.tee $push[[L3:[0-9]+]]=, $2=, $pop[[L2]]{{$}} ; SIMD128-NEXT: v128.store 0($pop[[L3]]), $0{{$}} ; SIMD128-NEXT: i32.const $push[[L4:[0-9]+]]=, 7{{$}} ; SIMD128-NEXT: i32.and $push[[L5:[0-9]+]]=, $1, $pop[[L4]]{{$}} @@ -406,10 +406,10 @@ ; CHECK-LABEL: extract_var_v8i16: ; NO-SIMD128-NOT: i16x8 ; SIMD128-NEXT: .functype extract_var_v8i16 (v128, i32) -> (i32){{$}} -; SIMD128-NEXT: get_global $push[[L0:[0-9]+]]=, __stack_pointer@GLOBAL{{$}} +; SIMD128-NEXT: global.get $push[[L0:[0-9]+]]=, __stack_pointer@GLOBAL{{$}} ; SIMD128-NEXT: i32.const $push[[L1:[0-9]+]]=, 16{{$}} ; SIMD128-NEXT: i32.sub $push[[L2:[0-9]+]]=, $pop[[L0]], $pop[[L1]]{{$}} -; SIMD128-NEXT: tee_local $push[[L3:[0-9]+]]=, $2=, $pop[[L2]]{{$}} +; SIMD128-NEXT: local.tee $push[[L3:[0-9]+]]=, $2=, $pop[[L2]]{{$}} ; SIMD128-NEXT: v128.store 0($pop[[L3]]), $0{{$}} ; SIMD128-NEXT: i32.const $push[[L4:[0-9]+]]=, 7{{$}} ; SIMD128-NEXT: i32.and $push[[L5:[0-9]+]]=, $1, $pop[[L4]]{{$}} @@ -446,10 +446,10 @@ ; CHECK-LABEL: replace_var_v8i16: ; NO-SIMD128-NOT: i16x8 ; SIMD128-NEXT: .functype replace_var_v8i16 (v128, i32, i32) -> (v128){{$}} -; SIMD128-NEXT: get_global $push[[L0:[0-9]+]]=, __stack_pointer@GLOBAL{{$}} +; SIMD128-NEXT: global.get $push[[L0:[0-9]+]]=, __stack_pointer@GLOBAL{{$}} ; SIMD128-NEXT: i32.const $push[[L1:[0-9]+]]=, 16{{$}} ; SIMD128-NEXT: i32.sub $push[[L2:[0-9]+]]=, $pop[[L0]], $pop[[L1]]{{$}} -; SIMD128-NEXT: tee_local $push[[L3:[0-9]+]]=, $3=, $pop[[L2]]{{$}} +; SIMD128-NEXT: local.tee $push[[L3:[0-9]+]]=, $3=, $pop[[L2]]{{$}} ; SIMD128-NEXT: v128.store 0($pop[[L3]]), $0{{$}} ; SIMD128-NEXT: i32.const $push[[L4:[0-9]+]]=, 7{{$}} ; SIMD128-NEXT: i32.and $push[[L5:[0-9]+]]=, $1, $pop[[L4]]{{$}} @@ -567,10 +567,10 @@ ; CHECK-LABEL: extract_var_v4i32: ; NO-SIMD128-NOT: i32x4 ; SIMD128-NEXT: .functype extract_var_v4i32 (v128, i32) -> (i32){{$}} -; SIMD128-NEXT: get_global $push[[L0:[0-9]+]]=, __stack_pointer@GLOBAL{{$}} +; SIMD128-NEXT: global.get $push[[L0:[0-9]+]]=, __stack_pointer@GLOBAL{{$}} ; SIMD128-NEXT: i32.const $push[[L1:[0-9]+]]=, 16{{$}} ; SIMD128-NEXT: i32.sub $push[[L2:[0-9]+]]=, $pop[[L0]], $pop[[L1]]{{$}} -; SIMD128-NEXT: tee_local $push[[L3:[0-9]+]]=, $2=, $pop[[L2]]{{$}} +; SIMD128-NEXT: local.tee $push[[L3:[0-9]+]]=, $2=, $pop[[L2]]{{$}} ; SIMD128-NEXT: v128.store 0($pop[[L3]]), $0{{$}} ; SIMD128-NEXT: i32.const $push[[L4:[0-9]+]]=, 3{{$}} ; SIMD128-NEXT: i32.and $push[[L5:[0-9]+]]=, $1, $pop[[L4]]{{$}} @@ -607,10 +607,10 @@ ; CHECK-LABEL: replace_var_v4i32: ; NO-SIMD128-NOT: i32x4 ; SIMD128-NEXT: .functype replace_var_v4i32 (v128, i32, i32) -> (v128){{$}} -; SIMD128-NEXT: get_global $push[[L0:[0-9]+]]=, __stack_pointer@GLOBAL{{$}} +; SIMD128-NEXT: global.get $push[[L0:[0-9]+]]=, __stack_pointer@GLOBAL{{$}} ; SIMD128-NEXT: i32.const $push[[L1:[0-9]+]]=, 16{{$}} ; SIMD128-NEXT: i32.sub $push[[L2:[0-9]+]]=, $pop[[L0]], $pop[[L1]]{{$}} -; SIMD128-NEXT: tee_local $push[[L3:[0-9]+]]=, $3=, $pop[[L2]]{{$}} +; SIMD128-NEXT: local.tee $push[[L3:[0-9]+]]=, $3=, $pop[[L2]]{{$}} ; SIMD128-NEXT: v128.store 0($pop[[L3]]), $0{{$}} ; SIMD128-NEXT: i32.const $push[[L4:[0-9]+]]=, 3{{$}} ; SIMD128-NEXT: i32.and $push[[L5:[0-9]+]]=, $1, $pop[[L4]]{{$}} @@ -720,10 +720,10 @@ ; CHECK-LABEL: extract_var_v2i64: ; NO-SIMD128-NOT: i64x2 ; SIMD128-NEXT: .functype extract_var_v2i64 (v128, i32) -> (i64){{$}} -; SIMD128-NEXT: get_global $push[[L0:[0-9]+]]=, __stack_pointer@GLOBAL{{$}} +; SIMD128-NEXT: global.get $push[[L0:[0-9]+]]=, __stack_pointer@GLOBAL{{$}} ; SIMD128-NEXT: i32.const $push[[L1:[0-9]+]]=, 16{{$}} ; SIMD128-NEXT: i32.sub $push[[L2:[0-9]+]]=, $pop[[L0]], $pop[[L1]]{{$}} -; SIMD128-NEXT: tee_local $push[[L3:[0-9]+]]=, $2=, $pop[[L2]]{{$}} +; SIMD128-NEXT: local.tee $push[[L3:[0-9]+]]=, $2=, $pop[[L2]]{{$}} ; SIMD128-NEXT: v128.store 0($pop[[L3]]), $0{{$}} ; SIMD128-NEXT: i32.const $push[[L2:[0-9]+]]=, 1{{$}} ; SIMD128-NEXT: i32.and $push[[L5:[0-9]+]]=, $1, $pop[[L2]]{{$}} @@ -763,10 +763,10 @@ ; NO-SIMD128-NOT: i64x2 ; SIMD128-VM-NOT: i64x2 ; SIMD128-NEXT: .functype replace_var_v2i64 (v128, i32, i64) -> (v128){{$}} -; SIMD128-NEXT: get_global $push[[L0:[0-9]+]]=, __stack_pointer@GLOBAL{{$}} +; SIMD128-NEXT: global.get $push[[L0:[0-9]+]]=, __stack_pointer@GLOBAL{{$}} ; SIMD128-NEXT: i32.const $push[[L1:[0-9]+]]=, 16{{$}} ; SIMD128-NEXT: i32.sub $push[[L2:[0-9]+]]=, $pop[[L0]], $pop[[L1]]{{$}} -; SIMD128-NEXT: tee_local $push[[L3:[0-9]+]]=, $3=, $pop[[L2]]{{$}} +; SIMD128-NEXT: local.tee $push[[L3:[0-9]+]]=, $3=, $pop[[L2]]{{$}} ; SIMD128-NEXT: v128.store 0($pop[[L3]]), $0{{$}} ; SIMD128-NEXT: i32.const $push[[L2:[0-9]+]]=, 1{{$}} ; SIMD128-NEXT: i32.and $push[[L5:[0-9]+]]=, $1, $pop[[L2]]{{$}} @@ -873,10 +873,10 @@ ; CHECK-LABEL: extract_var_v4f32: ; NO-SIMD128-NOT: i64x2 ; SIMD128-NEXT: .functype extract_var_v4f32 (v128, i32) -> (f32){{$}} -; SIMD128-NEXT: get_global $push[[L0:[0-9]+]]=, __stack_pointer@GLOBAL{{$}} +; SIMD128-NEXT: global.get $push[[L0:[0-9]+]]=, __stack_pointer@GLOBAL{{$}} ; SIMD128-NEXT: i32.const $push[[L1:[0-9]+]]=, 16{{$}} ; SIMD128-NEXT: i32.sub $push[[L2:[0-9]+]]=, $pop[[L0]], $pop[[L1]]{{$}} -; SIMD128-NEXT: tee_local $push[[L3:[0-9]+]]=, $2=, $pop[[L2]]{{$}} +; SIMD128-NEXT: local.tee $push[[L3:[0-9]+]]=, $2=, $pop[[L2]]{{$}} ; SIMD128-NEXT: v128.store 0($pop[[L3]]), $0{{$}} ; SIMD128-NEXT: i32.const $push[[L2:[0-9]+]]=, 3{{$}} ; SIMD128-NEXT: i32.and $push[[L5:[0-9]+]]=, $1, $pop[[L2]]{{$}} @@ -913,10 +913,10 @@ ; CHECK-LABEL: replace_var_v4f32: ; NO-SIMD128-NOT: f32x4 ; SIMD128-NEXT: .functype replace_var_v4f32 (v128, i32, f32) -> (v128){{$}} -; SIMD128-NEXT: get_global $push[[L0:[0-9]+]]=, __stack_pointer@GLOBAL{{$}} +; SIMD128-NEXT: global.get $push[[L0:[0-9]+]]=, __stack_pointer@GLOBAL{{$}} ; SIMD128-NEXT: i32.const $push[[L1:[0-9]+]]=, 16{{$}} ; SIMD128-NEXT: i32.sub $push[[L2:[0-9]+]]=, $pop[[L0]], $pop[[L1]]{{$}} -; SIMD128-NEXT: tee_local $push[[L3:[0-9]+]]=, $3=, $pop[[L2]]{{$}} +; SIMD128-NEXT: local.tee $push[[L3:[0-9]+]]=, $3=, $pop[[L2]]{{$}} ; SIMD128-NEXT: v128.store 0($pop[[L3]]), $0{{$}} ; SIMD128-NEXT: i32.const $push[[L2:[0-9]+]]=, 3{{$}} ; SIMD128-NEXT: i32.and $push[[L5:[0-9]+]]=, $1, $pop[[L2]]{{$}} @@ -1025,10 +1025,10 @@ ; CHECK-LABEL: extract_var_v2f64: ; NO-SIMD128-NOT: i62x2 ; SIMD128-NEXT: .functype extract_var_v2f64 (v128, i32) -> (f64){{$}} -; SIMD128-NEXT: get_global $push[[L0:[0-9]+]]=, __stack_pointer@GLOBAL{{$}} +; SIMD128-NEXT: global.get $push[[L0:[0-9]+]]=, __stack_pointer@GLOBAL{{$}} ; SIMD128-NEXT: i32.const $push[[L1:[0-9]+]]=, 16{{$}} ; SIMD128-NEXT: i32.sub $push[[L2:[0-9]+]]=, $pop[[L0]], $pop[[L1]]{{$}} -; SIMD128-NEXT: tee_local $push[[L3:[0-9]+]]=, $2=, $pop[[L2]]{{$}} +; SIMD128-NEXT: local.tee $push[[L3:[0-9]+]]=, $2=, $pop[[L2]]{{$}} ; SIMD128-NEXT: v128.store 0($pop[[L3]]), $0{{$}} ; SIMD128-NEXT: i32.const $push[[L2:[0-9]+]]=, 1{{$}} ; SIMD128-NEXT: i32.and $push[[L5:[0-9]+]]=, $1, $pop[[L2]]{{$}} @@ -1068,10 +1068,10 @@ ; NO-SIMD128-NOT: f64x2 ; SIMD128-VM-NOT: f64x2 ; SIMD128-NEXT: .functype replace_var_v2f64 (v128, i32, f64) -> (v128){{$}} -; SIMD128-NEXT: get_global $push[[L0:[0-9]+]]=, __stack_pointer@GLOBAL{{$}} +; SIMD128-NEXT: global.get $push[[L0:[0-9]+]]=, __stack_pointer@GLOBAL{{$}} ; SIMD128-NEXT: i32.const $push[[L1:[0-9]+]]=, 16{{$}} ; SIMD128-NEXT: i32.sub $push[[L2:[0-9]+]]=, $pop[[L0]], $pop[[L1]]{{$}} -; SIMD128-NEXT: tee_local $push[[L3:[0-9]+]]=, $3=, $pop[[L2]]{{$}} +; SIMD128-NEXT: local.tee $push[[L3:[0-9]+]]=, $3=, $pop[[L2]]{{$}} ; SIMD128-NEXT: v128.store 0($pop[[L3]]), $0{{$}} ; SIMD128-NEXT: i32.const $push[[L2:[0-9]+]]=, 1{{$}} ; SIMD128-NEXT: i32.and $push[[L5:[0-9]+]]=, $1, $pop[[L2]]{{$}} Index: test/CodeGen/WebAssembly/stack-alignment.ll =================================================================== --- test/CodeGen/WebAssembly/stack-alignment.ll +++ test/CodeGen/WebAssembly/stack-alignment.ll @@ -6,18 +6,18 @@ declare void @somefunc(i32*) ; CHECK-LABEL: underalign: -; CHECK: get_global $push[[L1:.+]]=, __stack_pointer@GLOBAL{{$}} +; CHECK: global.get $push[[L1:.+]]=, __stack_pointer@GLOBAL{{$}} ; CHECK-NEXT: i32.const $push[[L2:.+]]=, 16 ; CHECK-NEXT: i32.sub $push[[L10:.+]]=, $pop[[L1]], $pop[[L2]] -; CHECK-NEXT: tee_local $push{{.+}}=, [[SP:.+]], $pop[[L10]] +; CHECK-NEXT: local.tee $push{{.+}}=, [[SP:.+]], $pop[[L10]] -; CHECK: get_local $push[[L3:.+]]=, [[SP]]{{$}} +; CHECK: local.get $push[[L3:.+]]=, [[SP]]{{$}} ; CHECK: i32.add $push[[underaligned:.+]]=, $pop[[L3]], $pop{{.+}} ; CHECK-NEXT: call somefunc@FUNCTION, $pop[[underaligned]] -; CHECK: get_local $push[[M4:.+]]=, [[SP]]{{$}} +; CHECK: local.get $push[[M4:.+]]=, [[SP]]{{$}} ; CHECK: i32.add $push[[L5:.+]]=, $pop[[M4]], $pop{{.+}} -; CHECK-NEXT: set_global __stack_pointer@GLOBAL, $pop[[L5]] +; CHECK-NEXT: global.set __stack_pointer@GLOBAL, $pop[[L5]] define void @underalign() { entry: %underaligned = alloca i32, align 8 @@ -26,19 +26,19 @@ } ; CHECK-LABEL: overalign: -; CHECK: get_global $push[[L10:.+]]=, __stack_pointer@GLOBAL{{$}} -; CHECK-NEXT: tee_local $push[[L9:.+]]=, [[BP:.+]], $pop[[L10]] +; CHECK: global.get $push[[L10:.+]]=, __stack_pointer@GLOBAL{{$}} +; CHECK-NEXT: local.tee $push[[L9:.+]]=, [[BP:.+]], $pop[[L10]] ; CHECK-NEXT: i32.const $push[[L2:.+]]=, 32 ; CHECK-NEXT: i32.sub $push[[L8:.+]]=, $pop[[L9]], $pop[[L2]] ; CHECK-NEXT: i32.const $push[[L3:.+]]=, -32 ; CHECK-NEXT: i32.and $push[[L7:.+]]=, $pop[[L8]], $pop[[L3]] -; CHECK-NEXT: tee_local $push{{.+}}=, [[SP:.+]], $pop[[L7]] +; CHECK-NEXT: local.tee $push{{.+}}=, [[SP:.+]], $pop[[L7]] -; CHECK: get_local $push[[M5:.+]]=, [[SP]]{{$}} +; CHECK: local.get $push[[M5:.+]]=, [[SP]]{{$}} ; CHECK: call somefunc@FUNCTION, $pop[[M5]]{{$}} -; CHECK: get_local $push[[M6:.+]]=, [[BP]]{{$}} -; CHECK-NEXT: set_global __stack_pointer@GLOBAL, $pop[[M6]] +; CHECK: local.get $push[[M6:.+]]=, [[BP]]{{$}} +; CHECK-NEXT: global.set __stack_pointer@GLOBAL, $pop[[M6]] define void @overalign() { entry: %overaligned = alloca i32, align 32 @@ -47,21 +47,21 @@ } ; CHECK-LABEL: over_and_normal_align: -; CHECK: get_global $push[[L14:.+]]=, __stack_pointer@GLOBAL{{$}} -; CHECK-NEXT: tee_local $push[[L13:.+]]=, [[BP:.+]], $pop[[L14]] +; CHECK: global.get $push[[L14:.+]]=, __stack_pointer@GLOBAL{{$}} +; CHECK-NEXT: local.tee $push[[L13:.+]]=, [[BP:.+]], $pop[[L14]] ; CHECK: i32.sub $push[[L12:.+]]=, $pop[[L13]], $pop{{.+}} ; CHECK: i32.and $push[[L11:.+]]=, $pop[[L12]], $pop{{.+}} -; CHECK-NEXT: tee_local $push{{.+}}=, [[SP:.+]], $pop[[L11]] +; CHECK-NEXT: local.tee $push{{.+}}=, [[SP:.+]], $pop[[L11]] -; CHECK: get_local $push[[M6:.+]]=, [[SP]]{{$}} +; CHECK: local.get $push[[M6:.+]]=, [[SP]]{{$}} ; CHECK: i32.add $push[[L6:.+]]=, $pop[[M6]], $pop{{.+}} ; CHECK-NEXT: call somefunc@FUNCTION, $pop[[L6]] -; CHECK: get_local $push[[M7:.+]]=, [[SP]]{{$}} +; CHECK: local.get $push[[M7:.+]]=, [[SP]]{{$}} ; CHECK: i32.add $push[[L8:.+]]=, $pop[[M7]], $pop{{.+}} ; CHECK-NEXT: call somefunc@FUNCTION, $pop[[L8]] -; CHECK: get_local $push[[L6:.+]]=, [[BP]]{{$}} -; CHECK-NEXT: set_global __stack_pointer@GLOBAL, $pop[[L6]] +; CHECK: local.get $push[[L6:.+]]=, [[BP]]{{$}} +; CHECK-NEXT: global.set __stack_pointer@GLOBAL, $pop[[L6]] define void @over_and_normal_align() { entry: %over = alloca i32, align 32 @@ -72,16 +72,16 @@ } ; CHECK-LABEL: dynamic_overalign: -; CHECK: get_global $push[[L18:.+]]=, __stack_pointer@GLOBAL{{$}} -; CHECK-NEXT: tee_local $push[[L17:.+]]=, [[SP:.+]], $pop[[L18]] -; CHECK-NEXT: set_local [[BP:.+]], $pop[[L17]] -; CHECK: tee_local $push{{.+}}=, [[SP_2:.+]], $pop{{.+}} +; CHECK: global.get $push[[L18:.+]]=, __stack_pointer@GLOBAL{{$}} +; CHECK-NEXT: local.tee $push[[L17:.+]]=, [[SP:.+]], $pop[[L18]] +; CHECK-NEXT: local.set [[BP:.+]], $pop[[L17]] +; CHECK: local.tee $push{{.+}}=, [[SP_2:.+]], $pop{{.+}} -; CHECK: get_local $push[[M8:.+]]=, [[SP_2]]{{$}} +; CHECK: local.get $push[[M8:.+]]=, [[SP_2]]{{$}} ; CHECK: call somefunc@FUNCTION, $pop[[M8]] -; CHECK: get_local $push[[M9:.+]]=, [[BP]]{{$}} -; CHECK-NEXT: set_global __stack_pointer@GLOBAL, $pop[[M9]] +; CHECK: local.get $push[[M9:.+]]=, [[BP]]{{$}} +; CHECK-NEXT: global.set __stack_pointer@GLOBAL, $pop[[M9]] define void @dynamic_overalign(i32 %num) { entry: %dynamic = alloca i32, i32 %num, align 32 @@ -90,22 +90,22 @@ } ; CHECK-LABEL: overalign_and_dynamic: -; CHECK: get_global $push[[L21:.+]]=, __stack_pointer@GLOBAL{{$}} -; CHECK-NEXT: tee_local $push[[L20:.+]]=, [[BP:.+]], $pop[[L21]] +; CHECK: global.get $push[[L21:.+]]=, __stack_pointer@GLOBAL{{$}} +; CHECK-NEXT: local.tee $push[[L20:.+]]=, [[BP:.+]], $pop[[L21]] ; CHECK: i32.sub $push[[L19:.+]]=, $pop[[L20]], $pop{{.+}} ; CHECK: i32.and $push[[L18:.+]]=, $pop[[L19]], $pop{{.+}} -; CHECK: tee_local $push{{.+}}=, [[FP:.+]], $pop[[L18]] -; CHECK: get_local $push[[M10:.+]]=, [[FP]]{{$}} +; CHECK: local.tee $push{{.+}}=, [[FP:.+]], $pop[[L18]] +; CHECK: local.get $push[[M10:.+]]=, [[FP]]{{$}} ; CHECK: i32.sub $push[[L16:.+]]=, $pop[[M10]], $pop{{.+}} -; CHECK-NEXT: tee_local $push{{.+}}=, [[SP:.+]], $pop[[L16]] +; CHECK-NEXT: local.tee $push{{.+}}=, [[SP:.+]], $pop[[L16]] -; CHECK: get_local $push[[over:.+]]=, [[FP]] +; CHECK: local.get $push[[over:.+]]=, [[FP]] ; CHECK-NEXT: call somefunc@FUNCTION, $pop[[over]] -; CHECK: get_local $push[[another:.+]]=, [[SP]] +; CHECK: local.get $push[[another:.+]]=, [[SP]] ; CHECK-NEXT: call somefunc@FUNCTION, $pop[[another]] -; CHECK: get_local $push[[M11:.+]]=, [[BP]]{{$}} -; CHECK-NEXT: set_global __stack_pointer@GLOBAL, $pop[[M11]] +; CHECK: local.get $push[[M11:.+]]=, [[BP]]{{$}} +; CHECK-NEXT: global.set __stack_pointer@GLOBAL, $pop[[M11]] define void @overalign_and_dynamic(i32 %num) { entry: %over = alloca i32, align 32 @@ -116,27 +116,27 @@ } ; CHECK-LABEL: overalign_static_and_dynamic: -; CHECK: get_global $push[[L26:.+]]=, __stack_pointer@GLOBAL{{$}} -; CHECK-NEXT: tee_local $push[[L25:.+]]=, [[BP:.+]], $pop[[L26]] +; CHECK: global.get $push[[L26:.+]]=, __stack_pointer@GLOBAL{{$}} +; CHECK-NEXT: local.tee $push[[L25:.+]]=, [[BP:.+]], $pop[[L26]] ; CHECK: i32.sub $push[[L24:.+]]=, $pop[[L25]], $pop{{.+}} ; CHECK: i32.and $push[[L23:.+]]=, $pop[[L24]], $pop{{.+}} -; CHECK: tee_local $push{{.+}}=, [[FP:.+]], $pop[[L23]] -; CHECK: get_local $push[[M12:.+]]=, [[FP]]{{$}} +; CHECK: local.tee $push{{.+}}=, [[FP:.+]], $pop[[L23]] +; CHECK: local.get $push[[M12:.+]]=, [[FP]]{{$}} ; CHECK: i32.sub $push[[L21:.+]]=, $pop[[M12]], $pop{{.+}} -; CHECK-NEXT: tee_local $push{{.+}}=, [[SP:.+]], $pop[[L21]] +; CHECK-NEXT: local.tee $push{{.+}}=, [[SP:.+]], $pop[[L21]] -; CHECK: get_local $push[[L19:.+]]=, [[FP]] -; CHECK: tee_local $push[[L18:.+]]=, [[FP_2:.+]], $pop[[L19]] +; CHECK: local.get $push[[L19:.+]]=, [[FP]] +; CHECK: local.tee $push[[L18:.+]]=, [[FP_2:.+]], $pop[[L19]] ; CHECK: i32.add $push[[over:.+]]=, $pop[[L18]], $pop{{.+}} ; CHECK-NEXT: call somefunc@FUNCTION, $pop[[over]] -; CHECK: get_local $push[[M12:.+]]=, [[SP]] +; CHECK: local.get $push[[M12:.+]]=, [[SP]] ; CHECK: call somefunc@FUNCTION, $pop[[M12]] -; CHECK: get_local $push[[M13:.+]]=, [[FP_2]] +; CHECK: local.get $push[[M13:.+]]=, [[FP_2]] ; CHECK: i32.add $push[[static:.+]]=, $pop[[M13]], $pop{{.+}} ; CHECK-NEXT: call somefunc@FUNCTION, $pop[[static]] -; CHECK: get_local $push[[M14:.+]]=, [[BP]]{{$}} -; CHECK-NEXT: set_global __stack_pointer@GLOBAL, $pop[[M14]] +; CHECK: local.get $push[[M14:.+]]=, [[BP]]{{$}} +; CHECK-NEXT: global.set __stack_pointer@GLOBAL, $pop[[M14]] define void @overalign_static_and_dynamic(i32 %num) { entry: %over = alloca i32, align 32 Index: test/CodeGen/WebAssembly/store.ll =================================================================== --- test/CodeGen/WebAssembly/store.ll +++ test/CodeGen/WebAssembly/store.ll @@ -8,8 +8,8 @@ ; CHECK-LABEL: sti32: ; CHECK-NEXT: .functype sti32 (i32, i32) -> (){{$}} -; CHECK-NEXT: get_local $push[[L0:[0-9]+]]=, 0{{$}} -; CHECK-NEXT: get_local $push[[L1:[0-9]+]]=, 1{{$}} +; CHECK-NEXT: local.get $push[[L0:[0-9]+]]=, 0{{$}} +; CHECK-NEXT: local.get $push[[L1:[0-9]+]]=, 1{{$}} ; CHECK-NEXT: i32.store 0($pop[[L0]]), $pop[[L1]]{{$}} ; CHECK-NEXT: return{{$}} define void @sti32(i32 *%p, i32 %v) { @@ -19,8 +19,8 @@ ; CHECK-LABEL: sti64: ; CHECK-NEXT: .functype sti64 (i32, i64) -> (){{$}} -; CHECK-NEXT: get_local $push[[L0:[0-9]+]]=, 0{{$}} -; CHECK-NEXT: get_local $push[[L1:[0-9]+]]=, 1{{$}} +; CHECK-NEXT: local.get $push[[L0:[0-9]+]]=, 0{{$}} +; CHECK-NEXT: local.get $push[[L1:[0-9]+]]=, 1{{$}} ; CHECK-NEXT: i64.store 0($pop[[L0]]), $pop[[L1]]{{$}} ; CHECK-NEXT: return{{$}} define void @sti64(i64 *%p, i64 %v) { @@ -30,8 +30,8 @@ ; CHECK-LABEL: stf32: ; CHECK-NEXT: .functype stf32 (i32, f32) -> (){{$}} -; CHECK-NEXT: get_local $push[[L0:[0-9]+]]=, 0{{$}} -; CHECK-NEXT: get_local $push[[L1:[0-9]+]]=, 1{{$}} +; CHECK-NEXT: local.get $push[[L0:[0-9]+]]=, 0{{$}} +; CHECK-NEXT: local.get $push[[L1:[0-9]+]]=, 1{{$}} ; CHECK-NEXT: f32.store 0($pop[[L0]]), $pop[[L1]]{{$}} ; CHECK-NEXT: return{{$}} define void @stf32(float *%p, float %v) { @@ -41,8 +41,8 @@ ; CHECK-LABEL: stf64: ; CHECK-NEXT: .functype stf64 (i32, f64) -> (){{$}} -; CHECK-NEXT: get_local $push[[L0:[0-9]+]]=, 0{{$}} -; CHECK-NEXT: get_local $push[[L1:[0-9]+]]=, 1{{$}} +; CHECK-NEXT: local.get $push[[L0:[0-9]+]]=, 0{{$}} +; CHECK-NEXT: local.get $push[[L1:[0-9]+]]=, 1{{$}} ; CHECK-NEXT: f64.store 0($pop[[L0]]), $pop[[L1]]{{$}} ; CHECK-NEXT: return{{$}} define void @stf64(double *%p, double %v) { Index: test/CodeGen/WebAssembly/umulo-128-legalisation-lowering.ll =================================================================== --- test/CodeGen/WebAssembly/umulo-128-legalisation-lowering.ll +++ test/CodeGen/WebAssembly/umulo-128-legalisation-lowering.ll @@ -3,78 +3,78 @@ define { i128, i8 } @muloti_test(i128 %l, i128 %r) unnamed_addr #0 { ; WASM32-LABEL: muloti_test -; WASM32: get_global $push18=, __stack_pointer@GLOBAL +; WASM32: global.get $push18=, __stack_pointer@GLOBAL ; WASM32: i32.const $push19=, 48 ; WASM32: i32.sub $push40=, $pop18, $pop19 -; WASM32: tee_local $push39=, 5, $pop40 -; WASM32: set_global __stack_pointer@GLOBAL, $pop39 -; WASM32: get_local $push41=, 5 +; WASM32: local.tee $push39=, 5, $pop40 +; WASM32: global.set __stack_pointer@GLOBAL, $pop39 +; WASM32: local.get $push41=, 5 ; WASM32: i32.const $push22=, 32 ; WASM32: i32.add $push23=, $pop41, $pop22 -; WASM32: get_local $push43=, 1 +; WASM32: local.get $push43=, 1 ; WASM32: i64.const $push0=, 0 -; WASM32: get_local $push42=, 3 +; WASM32: local.get $push42=, 3 ; WASM32: i64.const $push38=, 0 ; WASM32: call __multi3@FUNCTION, $pop23, $pop43, $pop0, $pop42, $pop38 -; WASM32: get_local $push44=, 5 +; WASM32: local.get $push44=, 5 ; WASM32: i32.const $push24=, 16 ; WASM32: i32.add $push25=, $pop44, $pop24 -; WASM32: get_local $push46=, 4 +; WASM32: local.get $push46=, 4 ; WASM32: i64.const $push37=, 0 -; WASM32: get_local $push45=, 1 +; WASM32: local.get $push45=, 1 ; WASM32: i64.const $push36=, 0 ; WASM32: call __multi3@FUNCTION, $pop25, $pop46, $pop37, $pop45, $pop36 -; WASM32: get_local $push49=, 5 -; WASM32: get_local $push48=, 2 +; WASM32: local.get $push49=, 5 +; WASM32: local.get $push48=, 2 ; WASM32: i64.const $push35=, 0 -; WASM32: get_local $push47=, 3 +; WASM32: local.get $push47=, 3 ; WASM32: i64.const $push34=, 0 ; WASM32: call __multi3@FUNCTION, $pop49, $pop48, $pop35, $pop47, $pop34 -; WASM32: get_local $push51=, 0 -; WASM32: get_local $push50=, 5 +; WASM32: local.get $push51=, 0 +; WASM32: local.get $push50=, 5 ; WASM32: i64.load $push1=, 32($pop50) ; WASM32: i64.store 0($pop51), $pop1 -; WASM32: get_local $push55=, 0 -; WASM32: get_local $push52=, 5 +; WASM32: local.get $push55=, 0 +; WASM32: local.get $push52=, 5 ; WASM32: i32.const $push5=, 40 ; WASM32: i32.add $push6=, $pop52, $pop5 ; WASM32: i64.load $push33=, 0($pop6) -; WASM32: tee_local $push32=, 1, $pop33 -; WASM32: get_local $push53=, 5 +; WASM32: local.tee $push32=, 1, $pop33 +; WASM32: local.get $push53=, 5 ; WASM32: i64.load $push3=, 0($pop53) -; WASM32: get_local $push54=, 5 +; WASM32: local.get $push54=, 5 ; WASM32: i64.load $push2=, 16($pop54) ; WASM32: i64.add $push4=, $pop3, $pop2 ; WASM32: i64.add $push31=, $pop32, $pop4 -; WASM32: tee_local $push30=, 3, $pop31 +; WASM32: local.tee $push30=, 3, $pop31 ; WASM32: i64.store 8($pop55), $pop30 -; WASM32: get_local $push62=, 0 -; WASM32: get_local $push56=, 2 +; WASM32: local.get $push62=, 0 +; WASM32: local.get $push56=, 2 ; WASM32: i64.const $push29=, 0 ; WASM32: i64.ne $push8=, $pop56, $pop29 -; WASM32: get_local $push57=, 4 +; WASM32: local.get $push57=, 4 ; WASM32: i64.const $push28=, 0 ; WASM32: i64.ne $push7=, $pop57, $pop28 ; WASM32: i32.and $push9=, $pop8, $pop7 -; WASM32: get_local $push58=, 5 +; WASM32: local.get $push58=, 5 ; WASM32: i64.load $push10=, 8($pop58) ; WASM32: i64.const $push27=, 0 ; WASM32: i64.ne $push11=, $pop10, $pop27 ; WASM32: i32.or $push12=, $pop9, $pop11 -; WASM32: get_local $push59=, 5 +; WASM32: local.get $push59=, 5 ; WASM32: i64.load $push13=, 24($pop59) ; WASM32: i64.const $push26=, 0 ; WASM32: i64.ne $push14=, $pop13, $pop26 ; WASM32: i32.or $push15=, $pop12, $pop14 -; WASM32: get_local $push61=, 3 -; WASM32: get_local $push60=, 1 +; WASM32: local.get $push61=, 3 +; WASM32: local.get $push60=, 1 ; WASM32: i64.lt_u $push16=, $pop61, $pop60 ; WASM32: i32.or $push17=, $pop15, $pop16 ; WASM32: i32.store8 16($pop62), $pop17 -; WASM32: get_local $push63=, 5 +; WASM32: local.get $push63=, 5 ; WASM32: i32.const $push20=, 48 ; WASM32: i32.add $push21=, $pop63, $pop20 -; WASM32: set_global __stack_pointer@GLOBAL, $pop21 +; WASM32: global.set __stack_pointer@GLOBAL, $pop21 start: %0 = tail call { i128, i1 } @llvm.umul.with.overflow.i128(i128 %l, i128 %r) #2 Index: test/CodeGen/WebAssembly/userstack.ll =================================================================== --- test/CodeGen/WebAssembly/userstack.ll +++ test/CodeGen/WebAssembly/userstack.ll @@ -10,37 +10,37 @@ ; Check that there is an extra local for the stack pointer. ; CHECK: .local i32{{$}} define void @alloca32() noredzone { - ; CHECK-NEXT: get_global $push[[L2:.+]]=, __stack_pointer@GLOBAL{{$}} + ; CHECK-NEXT: global.get $push[[L2:.+]]=, __stack_pointer@GLOBAL{{$}} ; CHECK-NEXT: i32.const $push[[L3:.+]]=, 16 ; CHECK-NEXT: i32.sub $push[[L9:.+]]=, $pop[[L2]], $pop[[L3]] - ; CHECK-NEXT: tee_local $push[[L8:.+]]=, [[SP:.+]], $pop[[L9]]{{$}} - ; CHECK-NEXT: set_global __stack_pointer@GLOBAL, $pop[[L8]]{{$}} + ; CHECK-NEXT: local.tee $push[[L8:.+]]=, [[SP:.+]], $pop[[L9]]{{$}} + ; CHECK-NEXT: global.set __stack_pointer@GLOBAL, $pop[[L8]]{{$}} %retval = alloca i32 - ; CHECK: get_local $push[[L4:.+]]=, [[SP]]{{$}} + ; CHECK: local.get $push[[L4:.+]]=, [[SP]]{{$}} ; CHECK: i32.const $push[[L0:.+]]=, 0 ; CHECK: i32.store 12($pop[[L4]]), $pop[[L0]] store i32 0, i32* %retval - ; CHECK: get_local $push[[L6:.+]]=, [[SP]]{{$}} + ; CHECK: local.get $push[[L6:.+]]=, [[SP]]{{$}} ; CHECK-NEXT: i32.const $push[[L5:.+]]=, 16 ; CHECK-NEXT: i32.add $push[[L7:.+]]=, $pop[[L6]], $pop[[L5]] - ; CHECK-NEXT: set_global __stack_pointer@GLOBAL, $pop[[L7]] + ; CHECK-NEXT: global.set __stack_pointer@GLOBAL, $pop[[L7]] ret void } ; CHECK-LABEL: alloca3264: ; CHECK: .local i32{{$}} define void @alloca3264() { - ; CHECK: get_global $push[[L3:.+]]=, __stack_pointer@GLOBAL{{$}} + ; CHECK: global.get $push[[L3:.+]]=, __stack_pointer@GLOBAL{{$}} ; CHECK-NEXT: i32.const $push[[L4:.+]]=, 16 ; CHECK-NEXT: i32.sub $push[[L6:.+]]=, $pop[[L3]], $pop[[L4]] - ; CHECK-NEXT: tee_local $push[[L5:.+]]=, [[SP:.+]], $pop[[L6]] + ; CHECK-NEXT: local.tee $push[[L5:.+]]=, [[SP:.+]], $pop[[L6]] %r1 = alloca i32 %r2 = alloca double store i32 0, i32* %r1 store double 0.0, double* %r2 ; CHECK-NEXT: i64.const $push[[L1:.+]]=, 0 ; CHECK-NEXT: i64.store 0($pop[[L5]]), $pop[[L1]] - ; CHECK-NEXT: get_local $push[[L2:.+]]=, [[SP]]{{$}} + ; CHECK-NEXT: local.get $push[[L2:.+]]=, [[SP]]{{$}} ; CHECK-NEXT: i32.const $push[[L0:.+]]=, 0 ; CHECK-NEXT: i32.store 12($pop[[L2]]), $pop[[L0]] ; CHECK-NEXT: return @@ -50,18 +50,18 @@ ; CHECK-LABEL: allocarray: ; CHECK: .local i32{{$}} define void @allocarray() { - ; CHECK-NEXT: get_global $push[[L4:.+]]=, __stack_pointer@GLOBAL{{$}} + ; CHECK-NEXT: global.get $push[[L4:.+]]=, __stack_pointer@GLOBAL{{$}} ; CHECK-NEXT: i32.const $push[[L5:.+]]=, 144{{$}} ; CHECK-NEXT: i32.sub $push[[L12:.+]]=, $pop[[L4]], $pop[[L5]] - ; CHECK-NEXT: tee_local $push[[L11:.+]]=, 0, $pop[[L12]] - ; CHECK-NEXT: set_global __stack_pointer@GLOBAL, $pop[[L11]] + ; CHECK-NEXT: local.tee $push[[L11:.+]]=, 0, $pop[[L12]] + ; CHECK-NEXT: global.set __stack_pointer@GLOBAL, $pop[[L11]] %r = alloca [33 x i32] ; CHECK: i32.const $push{{.+}}=, 24 ; CHECK-NEXT: i32.add $push[[L3:.+]]=, $pop{{.+}}, $pop{{.+}} ; CHECK-NEXT: i32.const $push[[L1:.+]]=, 1{{$}} ; CHECK-NEXT: i32.store 0($pop[[L3]]), $pop[[L1]]{{$}} - ; CHECK-NEXT: get_local $push[[L4:.+]]=, 0{{$}} + ; CHECK-NEXT: local.get $push[[L4:.+]]=, 0{{$}} ; CHECK-NEXT: i32.const $push[[L10:.+]]=, 1{{$}} ; CHECK-NEXT: i32.store 12($pop[[L4]]), $pop[[L10]]{{$}} %p = getelementptr [33 x i32], [33 x i32]* %r, i32 0, i32 0 @@ -69,10 +69,10 @@ %p2 = getelementptr [33 x i32], [33 x i32]* %r, i32 0, i32 3 store i32 1, i32* %p2 - ; CHECK-NEXT: get_local $push[[L2:.+]]=, [[SP]]{{$}} + ; CHECK-NEXT: local.get $push[[L2:.+]]=, [[SP]]{{$}} ; CHECK-NEXT: i32.const $push[[L7:.+]]=, 144 ; CHECK-NEXT: i32.add $push[[L8:.+]]=, $pop[[L2]], $pop[[L7]] - ; CHECK-NEXT: set_global __stack_pointer@GLOBAL, $pop[[L8]] + ; CHECK-NEXT: global.set __stack_pointer@GLOBAL, $pop[[L8]] ret void } @@ -80,24 +80,24 @@ define void @non_mem_use(i8** %addr) { ; CHECK: i32.const $push[[L2:.+]]=, 48 ; CHECK-NEXT: i32.sub $push[[L12:.+]]=, {{.+}}, $pop[[L2]] - ; CHECK-NEXT: tee_local $push[[L11:.+]]=, [[SP:.+]], $pop[[L12]] - ; CHECK-NEXT: set_global __stack_pointer@GLOBAL, $pop[[L11]] + ; CHECK-NEXT: local.tee $push[[L11:.+]]=, [[SP:.+]], $pop[[L12]] + ; CHECK-NEXT: global.set __stack_pointer@GLOBAL, $pop[[L11]] %buf = alloca [27 x i8], align 16 %r = alloca i64 %r2 = alloca i64 ; %r is at SP+8 - ; CHECK: get_local $push[[L3:.+]]=, [[SP]] + ; CHECK: local.get $push[[L3:.+]]=, [[SP]] ; CHECK: i32.const $push[[OFF:.+]]=, 8 ; CHECK-NEXT: i32.add $push[[ARG1:.+]]=, $pop[[L3]], $pop[[OFF]] ; CHECK-NEXT: call ext_func@FUNCTION, $pop[[ARG1]] call void @ext_func(i64* %r) ; %r2 is at SP+0, no add needed - ; CHECK: get_local $push[[L4:.+]]=, [[SP]] + ; CHECK: local.get $push[[L4:.+]]=, [[SP]] ; CHECK-NEXT: call ext_func@FUNCTION, $pop[[L4]] call void @ext_func(i64* %r2) ; Use as a value, but in a store ; %buf is at SP+16 - ; CHECK: get_local $push[[L5:.+]]=, [[SP]] + ; CHECK: local.get $push[[L5:.+]]=, [[SP]] ; CHECK: i32.const $push[[OFF:.+]]=, 16 ; CHECK-NEXT: i32.add $push[[VAL:.+]]=, $pop[[L5]], $pop[[OFF]] ; CHECK-NEXT: i32.store 0($pop{{.+}}), $pop[[VAL]] @@ -109,11 +109,11 @@ ; CHECK-LABEL: allocarray_inbounds: ; CHECK: .local i32{{$}} define void @allocarray_inbounds() { - ; CHECK: get_global $push[[L3:.+]]=, __stack_pointer@GLOBAL{{$}} + ; CHECK: global.get $push[[L3:.+]]=, __stack_pointer@GLOBAL{{$}} ; CHECK-NEXT: i32.const $push[[L4:.+]]=, 32{{$}} ; CHECK-NEXT: i32.sub $push[[L11:.+]]=, $pop[[L3]], $pop[[L4]] - ; CHECK-NEXT: tee_local $push[[L10:.+]]=, [[SP:.+]], $pop[[L11]] - ; CHECK-NEXT: set_global __stack_pointer@GLOBAL, $pop[[L10]]{{$}} + ; CHECK-NEXT: local.tee $push[[L10:.+]]=, [[SP:.+]], $pop[[L11]] + ; CHECK-NEXT: global.set __stack_pointer@GLOBAL, $pop[[L10]]{{$}} %r = alloca [5 x i32] ; CHECK: i32.const $push[[L3:.+]]=, 1 ; CHECK-DAG: i32.store 24(${{.+}}), $pop[[L3]] @@ -127,35 +127,35 @@ ; CHECK: call ext_func ; CHECK: i32.const $push[[L5:.+]]=, 32{{$}} ; CHECK-NEXT: i32.add $push[[L7:.+]]=, ${{.+}}, $pop[[L5]] - ; CHECK-NEXT: set_global __stack_pointer@GLOBAL, $pop[[L7]] + ; CHECK-NEXT: global.set __stack_pointer@GLOBAL, $pop[[L7]] ret void } ; CHECK-LABEL: dynamic_alloca: define void @dynamic_alloca(i32 %alloc) { - ; CHECK: get_global $push[[L13:.+]]=, __stack_pointer@GLOBAL{{$}} - ; CHECK-NEXT: tee_local $push[[L12:.+]]=, [[SP:.+]], $pop[[L13]]{{$}} + ; CHECK: global.get $push[[L13:.+]]=, __stack_pointer@GLOBAL{{$}} + ; CHECK-NEXT: local.tee $push[[L12:.+]]=, [[SP:.+]], $pop[[L13]]{{$}} ; Target independent codegen bumps the stack pointer. ; CHECK: i32.sub ; Check that SP is written back to memory after decrement - ; CHECK: set_global __stack_pointer@GLOBAL, + ; CHECK: global.set __stack_pointer@GLOBAL, %r = alloca i32, i32 %alloc ; Target-independent codegen also calculates the store addr ; CHECK: call ext_func_i32@FUNCTION call void @ext_func_i32(i32* %r) - ; CHECK: set_global __stack_pointer@GLOBAL, $pop{{.+}} + ; CHECK: global.set __stack_pointer@GLOBAL, $pop{{.+}} ret void } ; CHECK-LABEL: dynamic_alloca_redzone: define void @dynamic_alloca_redzone(i32 %alloc) { - ; CHECK: get_global $push[[L13:.+]]=, __stack_pointer@GLOBAL{{$}} - ; CHECK-NEXT: tee_local $push[[L12:.+]]=, [[SP:.+]], $pop[[L13]]{{$}} + ; CHECK: global.get $push[[L13:.+]]=, __stack_pointer@GLOBAL{{$}} + ; CHECK-NEXT: local.tee $push[[L12:.+]]=, [[SP:.+]], $pop[[L13]]{{$}} ; Target independent codegen bumps the stack pointer ; CHECK: i32.sub %r = alloca i32, i32 %alloc - ; CHECK-NEXT: tee_local $push[[L8:.+]]=, {{.+}}, $pop - ; CHECK: get_local $push[[L7:.+]]=, 0{{$}} + ; CHECK-NEXT: local.tee $push[[L8:.+]]=, {{.+}}, $pop + ; CHECK: local.get $push[[L7:.+]]=, 0{{$}} ; CHECK-NEXT: i32.const $push[[L6:.+]]=, 0{{$}} ; CHECK-NEXT: i32.store 0($pop[[L7]]), $pop[[L6]]{{$}} store i32 0, i32* %r @@ -166,15 +166,15 @@ ; CHECK-LABEL: dynamic_static_alloca: define void @dynamic_static_alloca(i32 %alloc) noredzone { ; Decrement SP in the prolog by the static amount and writeback to memory. - ; CHECK: get_global $push[[L11:.+]]=, __stack_pointer@GLOBAL{{$}} + ; CHECK: global.get $push[[L11:.+]]=, __stack_pointer@GLOBAL{{$}} ; CHECK-NEXT: i32.const $push[[L12:.+]]=, 16 ; CHECK-NEXT: i32.sub $push[[L23:.+]]=, $pop[[L11]], $pop[[L12]] - ; CHECK-NEXT: tee_local $push[[L22:.+]]=, [[SP:.+]], $pop[[L23]] - ; CHECK-NEXT: set_global __stack_pointer@GLOBAL, $pop[[L22]] + ; CHECK-NEXT: local.tee $push[[L22:.+]]=, [[SP:.+]], $pop[[L23]] + ; CHECK-NEXT: global.set __stack_pointer@GLOBAL, $pop[[L22]] ; Alloc and write to a static alloca - ; CHECK: get_local $push[[L21:.+]]=, [[SP:.+]] - ; CHECK-NEXT: tee_local $push[[pushedFP:.+]]=, [[FP:.+]], $pop[[L21]] + ; CHECK: local.get $push[[L21:.+]]=, [[SP:.+]] + ; CHECK-NEXT: local.tee $push[[pushedFP:.+]]=, [[FP:.+]], $pop[[L21]] ; CHECK-NEXT: i32.const $push[[L0:.+]]=, 101 ; CHECK-NEXT: i32.store [[static_offset:.+]]($pop[[pushedFP]]), $pop[[L0]] %static = alloca i32 @@ -182,19 +182,19 @@ ; Decrement SP in the body by the dynamic amount. ; CHECK: i32.sub - ; CHECK: tee_local $push[[L16:.+]]=, [[dynamic_local:.+]], $pop{{.+}} - ; CHECK: tee_local $push[[L15:.+]]=, [[other:.+]], $pop[[L16]]{{$}} - ; CHECK: set_global __stack_pointer@GLOBAL, $pop[[L15]]{{$}} + ; CHECK: local.tee $push[[L16:.+]]=, [[dynamic_local:.+]], $pop{{.+}} + ; CHECK: local.tee $push[[L15:.+]]=, [[other:.+]], $pop[[L16]]{{$}} + ; CHECK: global.set __stack_pointer@GLOBAL, $pop[[L15]]{{$}} %dynamic = alloca i32, i32 %alloc ; Ensure we don't modify the frame pointer after assigning it. ; CHECK-NOT: $[[FP]]= ; Ensure the static address doesn't change after modifying the stack pointer. - ; CHECK: get_local $push[[L17:.+]]=, [[FP]] + ; CHECK: local.get $push[[L17:.+]]=, [[FP]] ; CHECK: i32.const $push[[L7:.+]]=, 102 ; CHECK-NEXT: i32.store [[static_offset]]($pop[[L17]]), $pop[[L7]] - ; CHECK-NEXT: get_local $push[[L9:.+]]=, [[dynamic_local]]{{$}} + ; CHECK-NEXT: local.get $push[[L9:.+]]=, [[dynamic_local]]{{$}} ; CHECK-NEXT: i32.const $push[[L8:.+]]=, 103 ; CHECK-NEXT: i32.store 0($pop[[L9]]), $pop[[L8]] store volatile i32 102, i32* %static @@ -202,20 +202,20 @@ ; Decrement SP in the body by the dynamic amount. ; CHECK: i32.sub - ; CHECK: tee_local $push{{.+}}=, [[dynamic2_local:.+]], $pop{{.+}} + ; CHECK: local.tee $push{{.+}}=, [[dynamic2_local:.+]], $pop{{.+}} %dynamic.2 = alloca i32, i32 %alloc ; CHECK-NOT: $[[FP]]= ; Ensure neither the static nor dynamic address changes after the second ; modification of the stack pointer. - ; CHECK: get_local $push[[L22:.+]]=, [[FP]] + ; CHECK: local.get $push[[L22:.+]]=, [[FP]] ; CHECK: i32.const $push[[L9:.+]]=, 104 ; CHECK-NEXT: i32.store [[static_offset]]($pop[[L22]]), $pop[[L9]] - ; CHECK-NEXT: get_local $push[[L23:.+]]=, [[dynamic_local]] + ; CHECK-NEXT: local.get $push[[L23:.+]]=, [[dynamic_local]] ; CHECK-NEXT: i32.const $push[[L10:.+]]=, 105 ; CHECK-NEXT: i32.store 0($pop[[L23]]), $pop[[L10]] - ; CHECK-NEXT: get_local $push[[L23:.+]]=, [[dynamic2_local]] + ; CHECK-NEXT: local.get $push[[L23:.+]]=, [[dynamic2_local]] ; CHECK-NEXT: i32.const $push[[L11:.+]]=, 106 ; CHECK-NEXT: i32.store 0($pop[[L23]]), $pop[[L11]] store volatile i32 104, i32* %static @@ -223,10 +223,10 @@ store volatile i32 106, i32* %dynamic.2 ; Writeback to memory. - ; CHECK: get_local $push[[L24:.+]]=, [[FP]]{{$}} + ; CHECK: local.get $push[[L24:.+]]=, [[FP]]{{$}} ; CHECK: i32.const $push[[L18:.+]]=, 16 ; CHECK-NEXT: i32.add $push[[L19:.+]]=, $pop[[L24]], $pop[[L18]] - ; CHECK-NEXT: set_global __stack_pointer@GLOBAL, $pop[[L19]] + ; CHECK-NEXT: global.set __stack_pointer@GLOBAL, $pop[[L19]] ret void } @@ -235,17 +235,17 @@ ; CHECK-LABEL: llvm_stack_builtins: define void @llvm_stack_builtins(i32 %alloc) noredzone { - ; CHECK: get_global $push[[L11:.+]]=, __stack_pointer@GLOBAL{{$}} - ; CHECK-NEXT: tee_local $push[[L10:.+]]=, {{.+}}, $pop[[L11]] - ; CHECK-NEXT: set_local [[STACK:.+]], $pop[[L10]] + ; CHECK: global.get $push[[L11:.+]]=, __stack_pointer@GLOBAL{{$}} + ; CHECK-NEXT: local.tee $push[[L10:.+]]=, {{.+}}, $pop[[L11]] + ; CHECK-NEXT: local.set [[STACK:.+]], $pop[[L10]] %stack = call i8* @llvm.stacksave() ; Ensure we don't reassign the stacksave local - ; CHECK-NOT: set_local [[STACK]], + ; CHECK-NOT: local.set [[STACK]], %dynamic = alloca i32, i32 %alloc - ; CHECK: get_local $push[[L12:.+]]=, [[STACK]] - ; CHECK-NEXT: set_global __stack_pointer@GLOBAL, $pop[[L12]] + ; CHECK: local.get $push[[L12:.+]]=, [[STACK]] + ; CHECK-NEXT: global.set __stack_pointer@GLOBAL, $pop[[L12]] call void @llvm.stackrestore(i8* %stack) ret void @@ -256,15 +256,15 @@ ; moved after the stack pointer was updated for the dynamic alloca. ; CHECK-LABEL: dynamic_alloca_nouse: define void @dynamic_alloca_nouse(i32 %alloc) noredzone { - ; CHECK: get_global $push[[L11:.+]]=, __stack_pointer@GLOBAL{{$}} - ; CHECK-NEXT: tee_local $push[[L10:.+]]=, {{.+}}, $pop[[L11]] - ; CHECK-NEXT: set_local [[FP:.+]], $pop[[L10]] + ; CHECK: global.get $push[[L11:.+]]=, __stack_pointer@GLOBAL{{$}} + ; CHECK-NEXT: local.tee $push[[L10:.+]]=, {{.+}}, $pop[[L11]] + ; CHECK-NEXT: local.set [[FP:.+]], $pop[[L10]] %dynamic = alloca i32, i32 %alloc - ; CHECK-NOT: set_local [[FP]], + ; CHECK-NOT: local.set [[FP]], - ; CHECK: get_local $push[[L12:.+]]=, [[FP]] - ; CHECK-NEXT: set_global __stack_pointer@GLOBAL, $pop[[L12]] + ; CHECK: local.get $push[[L12:.+]]=, [[FP]] + ; CHECK-NEXT: global.set __stack_pointer@GLOBAL, $pop[[L12]] ret void } @@ -278,12 +278,12 @@ %addr = alloca i32 ; CHECK: i32.const $push[[OFF:.+]]=, 12 ; CHECK-NEXT: i32.add $push[[ADDR:.+]]=, $pop[[L3]], $pop[[OFF]] - ; CHECK-NEXT: set_local [[COPY:.+]], $pop[[ADDR]] + ; CHECK-NEXT: local.set [[COPY:.+]], $pop[[ADDR]] br label %body body: %a = phi i32* [%addr, %entry], [%b, %body] store i32 1, i32* %a - ; CHECK: get_local $push[[L12:.+]]=, [[COPY]] + ; CHECK: local.get $push[[L12:.+]]=, [[COPY]] ; CHECK: i32.store 0($pop[[L12]]), br i1 %cond, label %body, label %exit exit: @@ -295,11 +295,11 @@ ; Test __builtin_frame_address(0). ; CHECK-LABEL: frameaddress_0: -; CHECK: get_global $push[[L3:.+]]=, __stack_pointer@GLOBAL{{$}} -; CHECK-NEXT: tee_local $push[[L2:.+]]=, [[FP:.+]], $pop[[L3]]{{$}} +; CHECK: global.get $push[[L3:.+]]=, __stack_pointer@GLOBAL{{$}} +; CHECK-NEXT: local.tee $push[[L2:.+]]=, [[FP:.+]], $pop[[L3]]{{$}} ; CHECK-NEXT: call use_i8_star@FUNCTION, $pop[[L2]] -; CHECK-NEXT: get_local $push[[L5:.+]]=, [[FP]] -; CHECK-NEXT: set_global __stack_pointer@GLOBAL, $pop[[L5]] +; CHECK-NEXT: local.get $push[[L5:.+]]=, [[FP]] +; CHECK-NEXT: global.set __stack_pointer@GLOBAL, $pop[[L5]] define void @frameaddress_0() { %t = call i8* @llvm.frameaddress(i32 0) call void @use_i8_star(i8* %t) @@ -320,7 +320,7 @@ ; Test a stack address passed to an inline asm. ; CHECK-LABEL: inline_asm: -; CHECK: get_global {{.+}}, __stack_pointer@GLOBAL{{$}} +; CHECK: global.get {{.+}}, __stack_pointer@GLOBAL{{$}} ; CHECK: #APP ; CHECK-NEXT: # %{{[0-9]+}}{{$}} ; CHECK-NEXT: #NO_APP Index: test/CodeGen/WebAssembly/varargs.ll =================================================================== --- test/CodeGen/WebAssembly/varargs.ll +++ test/CodeGen/WebAssembly/varargs.ll @@ -52,7 +52,7 @@ ; CHECK-LABEL: arg_i8: ; CHECK-NEXT: .functype arg_i8 (i32) -> (i32){{$}} ; CHECK-NEXT: i32.load $push[[NUM0:[0-9]+]]=, 0($0){{$}} -; CHECK-NEXT: tee_local $push[[NUM1:[0-9]+]]=, $1=, $pop[[NUM0]]{{$}} +; CHECK-NEXT: local.tee $push[[NUM1:[0-9]+]]=, $1=, $pop[[NUM0]]{{$}} ; CHECK-NEXT: i32.const $push[[NUM2:[0-9]+]]=, 4{{$}} ; CHECK-NEXT: i32.add $push[[NUM3:[0-9]+]]=, $pop[[NUM1]], $pop[[NUM2]]{{$}} ; CHECK-NEXT: i32.store 0($0), $pop[[NUM3]]{{$}} @@ -73,7 +73,7 @@ ; CHECK-NEXT: i32.add $push[[NUM2:[0-9]+]]=, $pop[[NUM0]], $pop[[NUM1]]{{$}} ; CHECK-NEXT: i32.const $push[[NUM3:[0-9]+]]=, -4{{$}} ; CHECK-NEXT: i32.and $push[[NUM4:[0-9]+]]=, $pop[[NUM2]], $pop[[NUM3]]{{$}} -; CHECK-NEXT: tee_local $push[[NUM5:[0-9]+]]=, $1=, $pop[[NUM4]]{{$}} +; CHECK-NEXT: local.tee $push[[NUM5:[0-9]+]]=, $1=, $pop[[NUM4]]{{$}} ; CHECK-NEXT: i32.const $push[[NUM6:[0-9]+]]=, 4{{$}} ; CHECK-NEXT: i32.add $push[[NUM7:[0-9]+]]=, $pop[[NUM5]], $pop[[NUM6]]{{$}} ; CHECK-NEXT: i32.store 0($0), $pop[[NUM7]]{{$}} Index: test/MC/Disassembler/WebAssembly/wasm.txt =================================================================== --- test/MC/Disassembler/WebAssembly/wasm.txt +++ test/MC/Disassembler/WebAssembly/wasm.txt @@ -22,11 +22,11 @@ # FIXME: WebAssemblyInstPrinter does not print immediates. 0x11 0x80 0x01 0x00 -# CHECK: get_local 128 +# CHECK: local.get 128 0x20 0x80 0x01 # Prefix byte example: -# CHECK: i64.trunc_u:sat/f64 +# CHECK: i64.trunc_sat_f64_u 0xFC 0x07 # v128.const is arbitrarily disassembled as v16i8 Index: test/MC/WebAssembly/assembler-binary.ll =================================================================== --- test/MC/WebAssembly/assembler-binary.ll +++ test/MC/WebAssembly/assembler-binary.ll @@ -57,7 +57,7 @@ ; CHECK-NEXT: Field: __indirect_function_table ; CHECK-NEXT: Kind: TABLE ; CHECK-NEXT: Table: -; CHECK-NEXT: ElemType: ANYFUNC +; CHECK-NEXT: ElemType: FUNCREF ; CHECK-NEXT: Limits: ; CHECK-NEXT: Initial: 0x00000000 ; CHECK-NEXT: - Module: env Index: test/MC/WebAssembly/basic-assembly.s =================================================================== --- test/MC/WebAssembly/basic-assembly.s +++ test/MC/WebAssembly/basic-assembly.s @@ -11,20 +11,20 @@ .eventtype __cpp_exception i32 .local f32, f64, v128, v128 # Explicit getlocal/setlocal: - get_local 2 - set_local 2 + local.get 2 + local.set 2 # Immediates: i32.const -1 f64.const 0x1.999999999999ap1 v128.const 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15 v128.const 0, 1, 2, 3, 4, 5, 6, 7 # Indirect addressing: - get_local 0 + local.get 0 f64.store 0 # Loops, conditionals, binary ops, calls etc: block i32 i32.const 1 - get_local 0 + local.get 0 i32.ge_s br_if 0 # 0: down to label0 .LBB0_1: @@ -36,15 +36,15 @@ call_indirect 0 i32.const 1 i32.add - tee_local 0 - get_local 0 + local.tee 0 + local.get 0 i32.lt_s br_if 0 # 0: up to label1 .LBB0_2: end_loop end_block # label0: - get_local 4 - get_local 5 + local.get 4 + local.get 5 block void block i64 block f32 @@ -67,8 +67,8 @@ f32x4.add # Test correct parsing of instructions with / and : in them: # TODO: enable once instruction has been added. - #i32x4.trunc_s/f32x4:sat - i32.trunc_s/f32 + #i32x4.trunc_sat_f32x4_s + i32.trunc_f32_s try except_ref .LBB0_3: i32.catch 0 @@ -76,8 +76,8 @@ catch_all .LBB0_5: end_try - #i32.trunc_s:sat/f32 - get_global __stack_pointer@GLOBAL + #i32.trunc_sat_f32_s + global.get __stack_pointer@GLOBAL end_function .Lfunc_end0: .size test0, .Lfunc_end0-test0 @@ -88,17 +88,17 @@ # CHECK-NEXT: .functype test0 (i32, i64) -> (i32) # CHECK-NEXT: .eventtype __cpp_exception i32 # CHECK-NEXT: .local f32, f64 -# CHECK-NEXT: get_local 2 -# CHECK-NEXT: set_local 2 +# CHECK-NEXT: local.get 2 +# CHECK-NEXT: local.set 2 # CHECK-NEXT: i32.const -1 # CHECK-NEXT: f64.const 0x1.999999999999ap1 # CHECK-NEXT: v128.const 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15 # CHECK-NEXT: v128.const 0, 1, 2, 3, 4, 5, 6, 7 -# CHECK-NEXT: get_local 0 +# CHECK-NEXT: local.get 0 # CHECK-NEXT: f64.store 0:p2align=0 # CHECK-NEXT: block i32 # CHECK-NEXT: i32.const 1 -# CHECK-NEXT: get_local 0 +# CHECK-NEXT: local.get 0 # CHECK-NEXT: i32.ge_s # CHECK-NEXT: br_if 0 # 0: down to label0 # CHECK-NEXT: .LBB0_1: @@ -110,15 +110,15 @@ # CHECK-NEXT: call_indirect 0 # CHECK-NEXT: i32.const 1 # CHECK-NEXT: i32.add -# CHECK-NEXT: tee_local 0 -# CHECK-NEXT: get_local 0 +# CHECK-NEXT: local.tee 0 +# CHECK-NEXT: local.get 0 # CHECK-NEXT: i32.lt_s # CHECK-NEXT: br_if 0 # 0: up to label1 # CHECK-NEXT: .LBB0_2: # CHECK-NEXT: end_loop # CHECK-NEXT: end_block # label0: -# CHECK-NEXT: get_local 4 -# CHECK-NEXT: get_local 5 +# CHECK-NEXT: local.get 4 +# CHECK-NEXT: local.get 5 # CHECK-NEXT: block # CHECK-NEXT: block i64 # CHECK-NEXT: block f32 @@ -140,7 +140,7 @@ # CHECK-NEXT: else # CHECK-NEXT: end_if # CHECK-NEXT: f32x4.add -# CHECK-NEXT: i32.trunc_s/f32 +# CHECK-NEXT: i32.trunc_f32_s # CHECK-NEXT: try except_ref # CHECK-NEXT: .LBB0_3: # CHECK-NEXT: i32.catch 0 @@ -148,7 +148,7 @@ # CHECK-NEXT: catch_all # CHECK-NEXT: .LBB0_5: # CHECK-NEXT: end_try -# CHECK-NEXT: get_global __stack_pointer@GLOBAL +# CHECK-NEXT: global.get __stack_pointer@GLOBAL # CHECK-NEXT: end_function # CHECK: .globaltype __stack_pointer, i32 Index: test/MC/WebAssembly/comdat.ll =================================================================== --- test/MC/WebAssembly/comdat.ll +++ test/MC/WebAssembly/comdat.ll @@ -41,7 +41,7 @@ ; CHECK-NEXT: Field: __indirect_function_table ; CHECK-NEXT: Kind: TABLE ; CHECK-NEXT: Table: -; CHECK-NEXT: ElemType: ANYFUNC +; CHECK-NEXT: ElemType: FUNCREF ; CHECK-NEXT: Limits: ; CHECK-NEXT: Initial: 0x00000000 ; CHECK-NEXT: - Module: env Index: test/MC/WebAssembly/global-ctor-dtor.ll =================================================================== --- test/MC/WebAssembly/global-ctor-dtor.ll +++ test/MC/WebAssembly/global-ctor-dtor.ll @@ -30,7 +30,7 @@ ; CHECK-NEXT: Field: __indirect_function_table ; CHECK-NEXT: Kind: TABLE ; CHECK-NEXT: Table: -; CHECK-NEXT: ElemType: ANYFUNC +; CHECK-NEXT: ElemType: FUNCREF ; CHECK-NEXT: Limits: ; CHECK-NEXT: Initial: 0x00000002 ; CHECK-NEXT: - Module: env Index: test/MC/WebAssembly/simd-encodings.s =================================================================== --- test/MC/WebAssembly/simd-encodings.s +++ test/MC/WebAssembly/simd-encodings.s @@ -427,28 +427,28 @@ # CHECK: f64x2.max # encoding: [0xfd,0xaa,0x01] f64x2.max - # CHECK: i32x4.trunc_sat_s/f32x4 # encoding: [0xfd,0xab,0x01] - i32x4.trunc_sat_s/f32x4 + # CHECK: i32x4.trunc_sat_f32x4_s # encoding: [0xfd,0xab,0x01] + i32x4.trunc_sat_f32x4_s - # CHECK: i32x4.trunc_sat_u/f32x4 # encoding: [0xfd,0xac,0x01] - i32x4.trunc_sat_u/f32x4 + # CHECK: i32x4.trunc_sat_f32x4_u # encoding: [0xfd,0xac,0x01] + i32x4.trunc_sat_f32x4_u - # CHECK: i64x2.trunc_sat_s/f64x2 # encoding: [0xfd,0xad,0x01] - i64x2.trunc_sat_s/f64x2 + # CHECK: i64x2.trunc_sat_f64x2_s # encoding: [0xfd,0xad,0x01] + i64x2.trunc_sat_f64x2_s - # CHECK: i64x2.trunc_sat_u/f64x2 # encoding: [0xfd,0xae,0x01] - i64x2.trunc_sat_u/f64x2 + # CHECK: i64x2.trunc_sat_f64x2_u # encoding: [0xfd,0xae,0x01] + i64x2.trunc_sat_f64x2_u - # CHECK: f32x4.convert_s/i32x4 # encoding: [0xfd,0xaf,0x01] - f32x4.convert_s/i32x4 + # CHECK: f32x4.convert_i32x4_s # encoding: [0xfd,0xaf,0x01] + f32x4.convert_i32x4_s - # CHECK: f32x4.convert_u/i32x4 # encoding: [0xfd,0xb0,0x01] - f32x4.convert_u/i32x4 + # CHECK: f32x4.convert_i32x4_u # encoding: [0xfd,0xb0,0x01] + f32x4.convert_i32x4_u - # CHECK: f64x2.convert_s/i64x2 # encoding: [0xfd,0xb1,0x01] - f64x2.convert_s/i64x2 + # CHECK: f64x2.convert_i64x2_s # encoding: [0xfd,0xb1,0x01] + f64x2.convert_i64x2_s - # CHECK: f64x2.convert_u/i64x2 # encoding: [0xfd,0xb2,0x01] - f64x2.convert_u/i64x2 + # CHECK: f64x2.convert_i64x2_u # encoding: [0xfd,0xb2,0x01] + f64x2.convert_i64x2_u end_function Index: test/MC/WebAssembly/weak-alias.ll =================================================================== --- test/MC/WebAssembly/weak-alias.ll +++ test/MC/WebAssembly/weak-alias.ll @@ -62,7 +62,7 @@ ; CHECK-NEXT: Field: __indirect_function_table ; CHECK-NEXT: Kind: TABLE ; CHECK-NEXT: Table: -; CHECK-NEXT: ElemType: ANYFUNC +; CHECK-NEXT: ElemType: FUNCREF ; CHECK-NEXT: Limits: ; CHECK-NEXT: Initial: 0x00000001 ; CHECK-NEXT: - Type: FUNCTION Index: test/ObjectYAML/wasm/elem_section.yaml =================================================================== --- test/ObjectYAML/wasm/elem_section.yaml +++ test/ObjectYAML/wasm/elem_section.yaml @@ -5,7 +5,7 @@ Sections: - Type: TABLE Tables: - - ElemType: ANYFUNC + - ElemType: FUNCREF Limits: Flags: [ HAS_MAX ] Initial: 0x00000010 @@ -18,7 +18,7 @@ Functions: - 1 - Offset: - Opcode: GET_GLOBAL + Opcode: GLOBAL_GET Index: 1 Functions: - 4 @@ -34,7 +34,7 @@ # CHECK: Value: 3 # CHECK: Functions: [ 1 ] # CHECK: - Offset: -# CHECK: Opcode: GET_GLOBAL +# CHECK: Opcode: GLOBAL_GET # CHECK: Index: 1 # CHECK: Functions: [ 4 ] # CHECK: ... Index: test/ObjectYAML/wasm/import_section.yaml =================================================================== --- test/ObjectYAML/wasm/import_section.yaml +++ test/ObjectYAML/wasm/import_section.yaml @@ -31,7 +31,7 @@ Field: imported_table Kind: TABLE Table: - ElemType: ANYFUNC + ElemType: FUNCREF Limits: Flags: [ HAS_MAX ] Initial: 0x00000020 @@ -63,7 +63,7 @@ # CHECK: Field: imported_table # CHECK: Kind: TABLE # CHECK: Table: -# CHECK: ElemType: ANYFUNC +# CHECK: ElemType: FUNCREF # CHECK: Limits: # CHECK: Flags: [ HAS_MAX ] # CHECK: Initial: 0x00000020 Index: test/ObjectYAML/wasm/table_section.yaml =================================================================== --- test/ObjectYAML/wasm/table_section.yaml +++ test/ObjectYAML/wasm/table_section.yaml @@ -5,7 +5,7 @@ Sections: - Type: TABLE Tables: - - ElemType: ANYFUNC + - ElemType: FUNCREF Limits: Flags: [ HAS_MAX ] Initial: 0x00000010 @@ -17,7 +17,7 @@ # CHECK: Sections: # CHECK: - Type: TABLE # CHECK: Tables: -# CHECK: - ElemType: ANYFUNC +# CHECK: - ElemType: FUNCREF # CHECK: Limits: # CHECK: Flags: [ HAS_MAX ] # CHECK: Initial: 0x00000010 Index: tools/yaml2obj/yaml2wasm.cpp =================================================================== --- tools/yaml2obj/yaml2wasm.cpp +++ tools/yaml2obj/yaml2wasm.cpp @@ -105,7 +105,7 @@ case wasm::WASM_OPCODE_F64_CONST: writeUint64(OS, InitExpr.Value.Float64); break; - case wasm::WASM_OPCODE_GET_GLOBAL: + case wasm::WASM_OPCODE_GLOBAL_GET: encodeULEB128(InitExpr.Value.Global, OS); break; default: