mirror of
https://github.com/RPCS3/llvm-mirror.git
synced 2024-10-19 02:52:53 +02:00
[WebAssembly] Massive instruction renaming
Summary: An automated renaming of all the instructions listed at https://github.com/WebAssembly/spec/issues/884#issuecomment-426433329 as well as some similarly-named identifiers. Reviewers: aheejin, dschuff, aardappel Subscribers: sbc100, jgravelle-google, eraman, sunfish, jfb, llvm-commits Differential Revision: https://reviews.llvm.org/D56338 llvm-svn: 350609
This commit is contained in:
parent
268bb6f5c2
commit
ab0820716d
@ -211,7 +211,7 @@ enum : unsigned {
|
||||
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 @@ enum : unsigned {
|
||||
// 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,
|
||||
|
@ -1176,7 +1176,7 @@ uint64_t WasmObjectWriter::writeObject(MCAssembler &Asm,
|
||||
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
|
||||
|
@ -176,7 +176,7 @@ static Error readInitExpr(wasm::WasmInitExpr &Expr,
|
||||
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 @@ Error WasmObjectFile::parseImportSection(ReadContext &Ctx) {
|
||||
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<GenericBinaryError>("Invalid table element type",
|
||||
object_error::parse_failed);
|
||||
break;
|
||||
@ -862,7 +862,7 @@ Error WasmObjectFile::parseTableSection(ReadContext &Ctx) {
|
||||
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<GenericBinaryError>("Invalid table element type",
|
||||
object_error::parse_failed);
|
||||
}
|
||||
|
@ -377,7 +377,7 @@ void MappingTraits<wasm::WasmInitExpr>::mapping(IO &IO,
|
||||
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 @@ void ScalarEnumerationTraits<WasmYAML::ValueType>::enumeration(
|
||||
ECase(F32);
|
||||
ECase(F64);
|
||||
ECase(V128);
|
||||
ECase(ANYFUNC);
|
||||
ECase(FUNCREF);
|
||||
ECase(FUNC);
|
||||
ECase(NORESULT);
|
||||
#undef ECase
|
||||
@ -516,14 +516,14 @@ void ScalarEnumerationTraits<WasmYAML::Opcode>::enumeration(
|
||||
ECase(I64_CONST);
|
||||
ECase(F64_CONST);
|
||||
ECase(F32_CONST);
|
||||
ECase(GET_GLOBAL);
|
||||
ECase(GLOBAL_GET);
|
||||
#undef ECase
|
||||
}
|
||||
|
||||
void ScalarEnumerationTraits<WasmYAML::TableType>::enumeration(
|
||||
IO &IO, WasmYAML::TableType &Type) {
|
||||
#define ECase(X) IO.enumCase(Type, #X, wasm::WASM_TYPE_##X);
|
||||
ECase(ANYFUNC);
|
||||
ECase(FUNCREF);
|
||||
#undef ECase
|
||||
}
|
||||
|
||||
|
@ -40,7 +40,7 @@ WebAssemblyInstPrinter::WebAssemblyInstPrinter(const MCAsmInfo &MAI,
|
||||
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 @@ const char *llvm::WebAssembly::anyTypeToString(unsigned Ty) {
|
||||
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:
|
||||
|
@ -120,8 +120,8 @@ code like this:
|
||||
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 @@ floating-point constants.
|
||||
//===---------------------------------------------------------------------===//
|
||||
|
||||
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
|
||||
[...]
|
||||
|
||||
|
@ -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 @@ static unsigned getDropOpcode(const TargetRegisterClass *RC) {
|
||||
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 @@ bool WebAssemblyExplicitLocals::runOnMachineFunction(MachineFunction &MF) {
|
||||
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 @@ bool WebAssemblyExplicitLocals::runOnMachineFunction(MachineFunction &MF) {
|
||||
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 @@ bool WebAssemblyExplicitLocals::runOnMachineFunction(MachineFunction &MF) {
|
||||
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 @@ bool WebAssemblyExplicitLocals::runOnMachineFunction(MachineFunction &MF) {
|
||||
}
|
||||
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 @@ bool WebAssemblyExplicitLocals::runOnMachineFunction(MachineFunction &MF) {
|
||||
}
|
||||
}
|
||||
|
||||
// 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 @@ bool WebAssemblyExplicitLocals::runOnMachineFunction(MachineFunction &MF) {
|
||||
}
|
||||
|
||||
// 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 @@ bool WebAssemblyExplicitLocals::runOnMachineFunction(MachineFunction &MF) {
|
||||
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);
|
||||
|
@ -130,7 +130,7 @@ void WebAssemblyFrameLowering::writeSPToGlobal(
|
||||
|
||||
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 @@ void WebAssemblyFrameLowering::emitPrologue(MachineFunction &MF,
|
||||
|
||||
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);
|
||||
|
@ -917,7 +917,7 @@ SDValue WebAssemblyTargetLowering::LowerCopyToReg(SDValue Op,
|
||||
// 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<RegisterSDNode>(Op.getOperand(1))->getReg();
|
||||
|
@ -114,7 +114,7 @@ def : LoadPatNoOffset<i32, atomic_load_8, ATOMIC_LOAD8_U_I32>;
|
||||
def : LoadPatNoOffset<i32, atomic_load_16, ATOMIC_LOAD16_U_I32>;
|
||||
def : LoadPatNoOffset<i64, sext_aload_8_64, ATOMIC_LOAD8_U_I64>;
|
||||
def : LoadPatNoOffset<i64, sext_aload_16_64, ATOMIC_LOAD16_U_I64>;
|
||||
// 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<i32, zext_aload_8_32, regPlusImm, ATOMIC_LOAD8_U_I32>;
|
||||
@ -344,82 +344,82 @@ multiclass WebAssemblyBinRMW<WebAssemblyRegClass rc, string Name, int Opcode> {
|
||||
defm ATOMIC_RMW_ADD_I32 : WebAssemblyBinRMW<I32, "i32.atomic.rmw.add", 0xfe1e>;
|
||||
defm ATOMIC_RMW_ADD_I64 : WebAssemblyBinRMW<I64, "i64.atomic.rmw.add", 0xfe1f>;
|
||||
defm ATOMIC_RMW8_U_ADD_I32 :
|
||||
WebAssemblyBinRMW<I32, "i32.atomic.rmw8_u.add", 0xfe20>;
|
||||
WebAssemblyBinRMW<I32, "i32.atomic.rmw8.add_u", 0xfe20>;
|
||||
defm ATOMIC_RMW16_U_ADD_I32 :
|
||||
WebAssemblyBinRMW<I32, "i32.atomic.rmw16_u.add", 0xfe21>;
|
||||
WebAssemblyBinRMW<I32, "i32.atomic.rmw16.add_u", 0xfe21>;
|
||||
defm ATOMIC_RMW8_U_ADD_I64 :
|
||||
WebAssemblyBinRMW<I64, "i64.atomic.rmw8_u.add", 0xfe22>;
|
||||
WebAssemblyBinRMW<I64, "i64.atomic.rmw8.add_u", 0xfe22>;
|
||||
defm ATOMIC_RMW16_U_ADD_I64 :
|
||||
WebAssemblyBinRMW<I64, "i64.atomic.rmw16_u.add", 0xfe23>;
|
||||
WebAssemblyBinRMW<I64, "i64.atomic.rmw16.add_u", 0xfe23>;
|
||||
defm ATOMIC_RMW32_U_ADD_I64 :
|
||||
WebAssemblyBinRMW<I64, "i64.atomic.rmw32_u.add", 0xfe24>;
|
||||
WebAssemblyBinRMW<I64, "i64.atomic.rmw32.add_u", 0xfe24>;
|
||||
|
||||
defm ATOMIC_RMW_SUB_I32 : WebAssemblyBinRMW<I32, "i32.atomic.rmw.sub", 0xfe25>;
|
||||
defm ATOMIC_RMW_SUB_I64 : WebAssemblyBinRMW<I64, "i64.atomic.rmw.sub", 0xfe26>;
|
||||
defm ATOMIC_RMW8_U_SUB_I32 :
|
||||
WebAssemblyBinRMW<I32, "i32.atomic.rmw8_u.sub", 0xfe27>;
|
||||
WebAssemblyBinRMW<I32, "i32.atomic.rmw8.sub_u", 0xfe27>;
|
||||
defm ATOMIC_RMW16_U_SUB_I32 :
|
||||
WebAssemblyBinRMW<I32, "i32.atomic.rmw16_u.sub", 0xfe28>;
|
||||
WebAssemblyBinRMW<I32, "i32.atomic.rmw16.sub_u", 0xfe28>;
|
||||
defm ATOMIC_RMW8_U_SUB_I64 :
|
||||
WebAssemblyBinRMW<I64, "i64.atomic.rmw8_u.sub", 0xfe29>;
|
||||
WebAssemblyBinRMW<I64, "i64.atomic.rmw8.sub_u", 0xfe29>;
|
||||
defm ATOMIC_RMW16_U_SUB_I64 :
|
||||
WebAssemblyBinRMW<I64, "i64.atomic.rmw16_u.sub", 0xfe2a>;
|
||||
WebAssemblyBinRMW<I64, "i64.atomic.rmw16.sub_u", 0xfe2a>;
|
||||
defm ATOMIC_RMW32_U_SUB_I64 :
|
||||
WebAssemblyBinRMW<I64, "i64.atomic.rmw32_u.sub", 0xfe2b>;
|
||||
WebAssemblyBinRMW<I64, "i64.atomic.rmw32.sub_u", 0xfe2b>;
|
||||
|
||||
defm ATOMIC_RMW_AND_I32 : WebAssemblyBinRMW<I32, "i32.atomic.rmw.and", 0xfe2c>;
|
||||
defm ATOMIC_RMW_AND_I64 : WebAssemblyBinRMW<I64, "i64.atomic.rmw.and", 0xfe2d>;
|
||||
defm ATOMIC_RMW8_U_AND_I32 :
|
||||
WebAssemblyBinRMW<I32, "i32.atomic.rmw8_u.and", 0xfe2e>;
|
||||
WebAssemblyBinRMW<I32, "i32.atomic.rmw8.and_u", 0xfe2e>;
|
||||
defm ATOMIC_RMW16_U_AND_I32 :
|
||||
WebAssemblyBinRMW<I32, "i32.atomic.rmw16_u.and", 0xfe2f>;
|
||||
WebAssemblyBinRMW<I32, "i32.atomic.rmw16.and_u", 0xfe2f>;
|
||||
defm ATOMIC_RMW8_U_AND_I64 :
|
||||
WebAssemblyBinRMW<I64, "i64.atomic.rmw8_u.and", 0xfe30>;
|
||||
WebAssemblyBinRMW<I64, "i64.atomic.rmw8.and_u", 0xfe30>;
|
||||
defm ATOMIC_RMW16_U_AND_I64 :
|
||||
WebAssemblyBinRMW<I64, "i64.atomic.rmw16_u.and", 0xfe31>;
|
||||
WebAssemblyBinRMW<I64, "i64.atomic.rmw16.and_u", 0xfe31>;
|
||||
defm ATOMIC_RMW32_U_AND_I64 :
|
||||
WebAssemblyBinRMW<I64, "i64.atomic.rmw32_u.and", 0xfe32>;
|
||||
WebAssemblyBinRMW<I64, "i64.atomic.rmw32.and_u", 0xfe32>;
|
||||
|
||||
defm ATOMIC_RMW_OR_I32 : WebAssemblyBinRMW<I32, "i32.atomic.rmw.or", 0xfe33>;
|
||||
defm ATOMIC_RMW_OR_I64 : WebAssemblyBinRMW<I64, "i64.atomic.rmw.or", 0xfe34>;
|
||||
defm ATOMIC_RMW8_U_OR_I32 :
|
||||
WebAssemblyBinRMW<I32, "i32.atomic.rmw8_u.or", 0xfe35>;
|
||||
WebAssemblyBinRMW<I32, "i32.atomic.rmw8.or_u", 0xfe35>;
|
||||
defm ATOMIC_RMW16_U_OR_I32 :
|
||||
WebAssemblyBinRMW<I32, "i32.atomic.rmw16_u.or", 0xfe36>;
|
||||
WebAssemblyBinRMW<I32, "i32.atomic.rmw16.or_u", 0xfe36>;
|
||||
defm ATOMIC_RMW8_U_OR_I64 :
|
||||
WebAssemblyBinRMW<I64, "i64.atomic.rmw8_u.or", 0xfe37>;
|
||||
WebAssemblyBinRMW<I64, "i64.atomic.rmw8.or_u", 0xfe37>;
|
||||
defm ATOMIC_RMW16_U_OR_I64 :
|
||||
WebAssemblyBinRMW<I64, "i64.atomic.rmw16_u.or", 0xfe38>;
|
||||
WebAssemblyBinRMW<I64, "i64.atomic.rmw16.or_u", 0xfe38>;
|
||||
defm ATOMIC_RMW32_U_OR_I64 :
|
||||
WebAssemblyBinRMW<I64, "i64.atomic.rmw32_u.or", 0xfe39>;
|
||||
WebAssemblyBinRMW<I64, "i64.atomic.rmw32.or_u", 0xfe39>;
|
||||
|
||||
defm ATOMIC_RMW_XOR_I32 : WebAssemblyBinRMW<I32, "i32.atomic.rmw.xor", 0xfe3a>;
|
||||
defm ATOMIC_RMW_XOR_I64 : WebAssemblyBinRMW<I64, "i64.atomic.rmw.xor", 0xfe3b>;
|
||||
defm ATOMIC_RMW8_U_XOR_I32 :
|
||||
WebAssemblyBinRMW<I32, "i32.atomic.rmw8_u.xor", 0xfe3c>;
|
||||
WebAssemblyBinRMW<I32, "i32.atomic.rmw8.xor_u", 0xfe3c>;
|
||||
defm ATOMIC_RMW16_U_XOR_I32 :
|
||||
WebAssemblyBinRMW<I32, "i32.atomic.rmw16_u.xor", 0xfe3d>;
|
||||
WebAssemblyBinRMW<I32, "i32.atomic.rmw16.xor_u", 0xfe3d>;
|
||||
defm ATOMIC_RMW8_U_XOR_I64 :
|
||||
WebAssemblyBinRMW<I64, "i64.atomic.rmw8_u.xor", 0xfe3e>;
|
||||
WebAssemblyBinRMW<I64, "i64.atomic.rmw8.xor_u", 0xfe3e>;
|
||||
defm ATOMIC_RMW16_U_XOR_I64 :
|
||||
WebAssemblyBinRMW<I64, "i64.atomic.rmw16_u.xor", 0xfe3f>;
|
||||
WebAssemblyBinRMW<I64, "i64.atomic.rmw16.xor_u", 0xfe3f>;
|
||||
defm ATOMIC_RMW32_U_XOR_I64 :
|
||||
WebAssemblyBinRMW<I64, "i64.atomic.rmw32_u.xor", 0xfe40>;
|
||||
WebAssemblyBinRMW<I64, "i64.atomic.rmw32.xor_u", 0xfe40>;
|
||||
|
||||
defm ATOMIC_RMW_XCHG_I32 :
|
||||
WebAssemblyBinRMW<I32, "i32.atomic.rmw.xchg", 0xfe41>;
|
||||
defm ATOMIC_RMW_XCHG_I64 :
|
||||
WebAssemblyBinRMW<I64, "i64.atomic.rmw.xchg", 0xfe42>;
|
||||
defm ATOMIC_RMW8_U_XCHG_I32 :
|
||||
WebAssemblyBinRMW<I32, "i32.atomic.rmw8_u.xchg", 0xfe43>;
|
||||
WebAssemblyBinRMW<I32, "i32.atomic.rmw8.xchg_u", 0xfe43>;
|
||||
defm ATOMIC_RMW16_U_XCHG_I32 :
|
||||
WebAssemblyBinRMW<I32, "i32.atomic.rmw16_u.xchg", 0xfe44>;
|
||||
WebAssemblyBinRMW<I32, "i32.atomic.rmw16.xchg_u", 0xfe44>;
|
||||
defm ATOMIC_RMW8_U_XCHG_I64 :
|
||||
WebAssemblyBinRMW<I64, "i64.atomic.rmw8_u.xchg", 0xfe45>;
|
||||
WebAssemblyBinRMW<I64, "i64.atomic.rmw8.xchg_u", 0xfe45>;
|
||||
defm ATOMIC_RMW16_U_XCHG_I64 :
|
||||
WebAssemblyBinRMW<I64, "i64.atomic.rmw16_u.xchg", 0xfe46>;
|
||||
WebAssemblyBinRMW<I64, "i64.atomic.rmw16.xchg_u", 0xfe46>;
|
||||
defm ATOMIC_RMW32_U_XCHG_I64 :
|
||||
WebAssemblyBinRMW<I64, "i64.atomic.rmw32_u.xchg", 0xfe47>;
|
||||
WebAssemblyBinRMW<I64, "i64.atomic.rmw32.xchg_u", 0xfe47>;
|
||||
|
||||
// Select binary RMWs with no constant offset.
|
||||
class BinRMWPatNoOffset<ValueType ty, PatFrag kind, NI inst> :
|
||||
@ -530,7 +530,7 @@ class sext_bin_rmw_8_64<PatFrag kind> :
|
||||
PatFrag<(ops node:$addr, node:$val),
|
||||
(anyext (i32 (kind node:$addr, (i32 (trunc (i64 node:$val))))))>;
|
||||
class sext_bin_rmw_16_64<PatFrag kind> : sext_bin_rmw_8_64<kind>;
|
||||
// 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_I32 :
|
||||
defm ATOMIC_RMW_CMPXCHG_I64 :
|
||||
WebAssemblyTerRMW<I64, "i64.atomic.rmw.cmpxchg", 0xfe49>;
|
||||
defm ATOMIC_RMW8_U_CMPXCHG_I32 :
|
||||
WebAssemblyTerRMW<I32, "i32.atomic.rmw8_u.cmpxchg", 0xfe4a>;
|
||||
WebAssemblyTerRMW<I32, "i32.atomic.rmw8.cmpxchg_u", 0xfe4a>;
|
||||
defm ATOMIC_RMW16_U_CMPXCHG_I32 :
|
||||
WebAssemblyTerRMW<I32, "i32.atomic.rmw16_u.cmpxchg", 0xfe4b>;
|
||||
WebAssemblyTerRMW<I32, "i32.atomic.rmw16.cmpxchg_u", 0xfe4b>;
|
||||
defm ATOMIC_RMW8_U_CMPXCHG_I64 :
|
||||
WebAssemblyTerRMW<I64, "i64.atomic.rmw8_u.cmpxchg", 0xfe4c>;
|
||||
WebAssemblyTerRMW<I64, "i64.atomic.rmw8.cmpxchg_u", 0xfe4c>;
|
||||
defm ATOMIC_RMW16_U_CMPXCHG_I64 :
|
||||
WebAssemblyTerRMW<I64, "i64.atomic.rmw16_u.cmpxchg", 0xfe4d>;
|
||||
WebAssemblyTerRMW<I64, "i64.atomic.rmw16.cmpxchg_u", 0xfe4d>;
|
||||
defm ATOMIC_RMW32_U_CMPXCHG_I64 :
|
||||
WebAssemblyTerRMW<I64, "i64.atomic.rmw32_u.cmpxchg", 0xfe4e>;
|
||||
WebAssemblyTerRMW<I64, "i64.atomic.rmw32.cmpxchg_u", 0xfe4e>;
|
||||
|
||||
// Select ternary RMWs with no constant offset.
|
||||
class TerRMWPatNoOffset<ValueType ty, PatFrag kind, NI inst> :
|
||||
@ -790,7 +790,7 @@ class sext_ter_rmw_8_64<PatFrag kind> :
|
||||
(i32 (trunc (i64 node:$exp))),
|
||||
(i32 (trunc (i64 node:$new))))))))>;
|
||||
class sext_ter_rmw_16_64<PatFrag kind> : sext_ter_rmw_8_64<kind>;
|
||||
// 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<
|
||||
|
@ -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 @@ def : Pat<(i64 (anyext I32:$src)), (I64_EXTEND_U_I32 I32:$src)>;
|
||||
// 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 @@ defm FP_TO_UINT_I64_F64 : I<(outs I64:$dst), (ins F64:$src), (outs), (ins),
|
||||
// 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>;
|
||||
|
@ -40,10 +40,10 @@ class NI<dag oops, dag iops, list<dag> pattern, string stack,
|
||||
// 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
|
||||
|
@ -197,49 +197,49 @@ defm "": ARGUMENT<F32, f32>;
|
||||
defm "": ARGUMENT<F64, f64>;
|
||||
defm "": ARGUMENT<EXCEPT_REF, ExceptRef>;
|
||||
|
||||
// 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<WebAssemblyRegClass vt> {
|
||||
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 @@ let hasSideEffects = 0 in {
|
||||
"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
|
||||
|
@ -773,17 +773,17 @@ multiclass SIMDConvert<ValueType vec_t, ValueType arg_t, SDNode op,
|
||||
name#"\t$dst, $vec", name, simdop>;
|
||||
}
|
||||
|
||||
// Integer to floating point: convert_s / convert_u
|
||||
defm "" : SIMDConvert<v4f32, v4i32, sint_to_fp, "f32x4.convert_s/i32x4", 175>;
|
||||
defm "" : SIMDConvert<v4f32, v4i32, uint_to_fp, "f32x4.convert_u/i32x4", 176>;
|
||||
defm "" : SIMDConvert<v2f64, v2i64, sint_to_fp, "f64x2.convert_s/i64x2", 177>;
|
||||
defm "" : SIMDConvert<v2f64, v2i64, uint_to_fp, "f64x2.convert_u/i64x2", 178>;
|
||||
// Integer to floating point: convert
|
||||
defm "" : SIMDConvert<v4f32, v4i32, sint_to_fp, "f32x4.convert_i32x4_s", 175>;
|
||||
defm "" : SIMDConvert<v4f32, v4i32, uint_to_fp, "f32x4.convert_i32x4_u", 176>;
|
||||
defm "" : SIMDConvert<v2f64, v2i64, sint_to_fp, "f64x2.convert_i64x2_s", 177>;
|
||||
defm "" : SIMDConvert<v2f64, v2i64, uint_to_fp, "f64x2.convert_i64x2_u", 178>;
|
||||
|
||||
// Floating point to integer with saturation: trunc_sat_s / trunc_sat_u
|
||||
defm "" : SIMDConvert<v4i32, v4f32, fp_to_sint, "i32x4.trunc_sat_s/f32x4", 171>;
|
||||
defm "" : SIMDConvert<v4i32, v4f32, fp_to_uint, "i32x4.trunc_sat_u/f32x4", 172>;
|
||||
defm "" : SIMDConvert<v2i64, v2f64, fp_to_sint, "i64x2.trunc_sat_s/f64x2", 173>;
|
||||
defm "" : SIMDConvert<v2i64, v2f64, fp_to_uint, "i64x2.trunc_sat_u/f64x2", 174>;
|
||||
// Floating point to integer with saturation: trunc_sat
|
||||
defm "" : SIMDConvert<v4i32, v4f32, fp_to_sint, "i32x4.trunc_sat_f32x4_s", 171>;
|
||||
defm "" : SIMDConvert<v4i32, v4f32, fp_to_uint, "i32x4.trunc_sat_f32x4_u", 172>;
|
||||
defm "" : SIMDConvert<v2i64, v2f64, fp_to_sint, "i64x2.trunc_sat_f64x2_s", 173>;
|
||||
defm "" : SIMDConvert<v2i64, v2f64, fp_to_uint, "i64x2.trunc_sat_f64x2_u", 174>;
|
||||
|
||||
// Lower llvm.wasm.trunc.saturate.* to saturating instructions
|
||||
def : Pat<(v4i32 (int_wasm_trunc_saturate_signed (v4f32 V128:$src))),
|
||||
|
@ -287,7 +287,7 @@ bool WebAssemblyLateEHPrepare::addRethrows(MachineFunction &MF) {
|
||||
// %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 @@ bool WebAssemblyLateEHPrepare::ensureSingleBBTermPads(MachineFunction &MF) {
|
||||
// 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));
|
||||
|
@ -425,8 +425,8 @@ static bool OneUseDominatesOtherUses(unsigned Reg, const MachineOperand &OneUse,
|
||||
// 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 @@ static MachineInstr *RematerializeCheapDef(
|
||||
/// 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 @@ public:
|
||||
/// 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)
|
||||
|
@ -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
|
||||
|
@ -326,7 +326,7 @@ void WebAssemblyPassConfig::addPreEmitPass() {
|
||||
addPass(createWebAssemblyRegColoring());
|
||||
}
|
||||
|
||||
// Insert explicit get_local and set_local operators.
|
||||
// Insert explicit local.get and local.set operators.
|
||||
addPass(createWebAssemblyExplicitLocals());
|
||||
|
||||
// Sort the blocks of the CFG into topological order, a prerequisite for
|
||||
|
@ -276,7 +276,7 @@ define i64 @umin_i64(i64* %p, i64 %v) {
|
||||
|
||||
; 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 @@ define i32 @add_sext_i8_i32(i8* %p, i32 %v) {
|
||||
|
||||
; 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 @@ define i32 @add_sext_i16_i32(i16* %p, i32 %v) {
|
||||
|
||||
; 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 @@ define i64 @add_sext_i8_i64(i8* %p, i64 %v) {
|
||||
|
||||
; 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 @@ define i64 @add_sext_i16_i64(i16* %p, i64 %v) {
|
||||
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 @@ define i64 @add_sext_i32_i64(i32* %p, i64 %v) {
|
||||
|
||||
; 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 @@ define i32 @sub_sext_i8_i32(i8* %p, i32 %v) {
|
||||
|
||||
; 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 @@ define i32 @sub_sext_i16_i32(i16* %p, i32 %v) {
|
||||
|
||||
; 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 @@ define i64 @sub_sext_i8_i64(i8* %p, i64 %v) {
|
||||
|
||||
; 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 @@ define i64 @sub_sext_i16_i64(i16* %p, i64 %v) {
|
||||
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 @@ define i64 @sub_sext_i32_i64(i32* %p, i64 %v) {
|
||||
|
||||
; 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 @@ define i32 @and_sext_i8_i32(i8* %p, i32 %v) {
|
||||
|
||||
; 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 @@ define i32 @and_sext_i16_i32(i16* %p, i32 %v) {
|
||||
|
||||
; 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 @@ define i64 @and_sext_i8_i64(i8* %p, i64 %v) {
|
||||
|
||||
; 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 @@ define i64 @and_sext_i16_i64(i16* %p, i64 %v) {
|
||||
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 @@ define i64 @and_sext_i32_i64(i32* %p, i64 %v) {
|
||||
|
||||
; 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 @@ define i32 @or_sext_i8_i32(i8* %p, i32 %v) {
|
||||
|
||||
; 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 @@ define i32 @or_sext_i16_i32(i16* %p, i32 %v) {
|
||||
|
||||
; 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 @@ define i64 @or_sext_i8_i64(i8* %p, i64 %v) {
|
||||
|
||||
; 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 @@ define i64 @or_sext_i16_i64(i16* %p, i64 %v) {
|
||||
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 @@ define i64 @or_sext_i32_i64(i32* %p, i64 %v) {
|
||||
|
||||
; 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 @@ define i32 @xor_sext_i8_i32(i8* %p, i32 %v) {
|
||||
|
||||
; 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 @@ define i32 @xor_sext_i16_i32(i16* %p, i32 %v) {
|
||||
|
||||
; 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 @@ define i64 @xor_sext_i8_i64(i8* %p, i64 %v) {
|
||||
|
||||
; 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 @@ define i64 @xor_sext_i16_i64(i16* %p, i64 %v) {
|
||||
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 @@ define i64 @xor_sext_i32_i64(i32* %p, i64 %v) {
|
||||
|
||||
; 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 @@ define i32 @xchg_sext_i8_i32(i8* %p, i32 %v) {
|
||||
|
||||
; 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 @@ define i32 @xchg_sext_i16_i32(i16* %p, i32 %v) {
|
||||
|
||||
; 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 @@ define i64 @xchg_sext_i8_i64(i8* %p, i64 %v) {
|
||||
|
||||
; 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 @@ define i64 @xchg_sext_i16_i64(i16* %p, i64 %v) {
|
||||
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 @@ define i64 @xchg_sext_i32_i64(i32* %p, i64 %v) {
|
||||
|
||||
; 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 @@ define i32 @cmpxchg_sext_i8_i32(i8* %p, i32 %exp, i32 %new) {
|
||||
|
||||
; 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 @@ define i32 @cmpxchg_sext_i16_i32(i16* %p, i32 %exp, i32 %new) {
|
||||
|
||||
; 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 @@ define i64 @cmpxchg_sext_i8_i64(i8* %p, i64 %exp, i64 %new) {
|
||||
|
||||
; 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 @@ define i64 @cmpxchg_sext_i16_i64(i16* %p, i64 %exp, i64 %new) {
|
||||
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 @@ define i64 @cmpxchg_sext_i32_i64(i32* %p, i64 %exp, i64 %new) {
|
||||
; 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 @@ define i32 @nand_sext_i8_i32(i8* %p, i32 %v) {
|
||||
; 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 @@ define i32 @nand_sext_i16_i32(i16* %p, i32 %v) {
|
||||
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 @@ define i64 @nand_sext_i8_i64(i8* %p, i64 %v) {
|
||||
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 @@ define i64 @nand_sext_i16_i64(i16* %p, i64 %v) {
|
||||
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 @@ define i64 @nand_sext_i32_i64(i32* %p, i64 %v) {
|
||||
|
||||
; 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 @@ define i32 @add_zext_i8_i32(i8* %p, i32 %v) {
|
||||
|
||||
; 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 @@ define i32 @add_zext_i16_i32(i16* %p, i32 %v) {
|
||||
|
||||
; 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 @@ define i64 @add_zext_i8_i64(i8* %p, i64 %v) {
|
||||
|
||||
; 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 @@ define i64 @add_zext_i16_i64(i16* %p, i64 %v) {
|
||||
|
||||
; 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 @@ define i64 @add_zext_i32_i64(i32* %p, i64 %v) {
|
||||
|
||||
; 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 @@ define i32 @sub_zext_i8_i32(i8* %p, i32 %v) {
|
||||
|
||||
; 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 @@ define i32 @sub_zext_i16_i32(i16* %p, i32 %v) {
|
||||
|
||||
; 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 @@ define i64 @sub_zext_i8_i64(i8* %p, i64 %v) {
|
||||
|
||||
; 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 @@ define i64 @sub_zext_i16_i64(i16* %p, i64 %v) {
|
||||
|
||||
; 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 @@ define i64 @sub_zext_i32_i64(i32* %p, i64 %v) {
|
||||
|
||||
; 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 @@ define i32 @and_zext_i8_i32(i8* %p, i32 %v) {
|
||||
|
||||
; 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 @@ define i32 @and_zext_i16_i32(i16* %p, i32 %v) {
|
||||
|
||||
; 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 @@ define i64 @and_zext_i8_i64(i8* %p, i64 %v) {
|
||||
|
||||
; 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 @@ define i64 @and_zext_i16_i64(i16* %p, i64 %v) {
|
||||
|
||||
; 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 @@ define i64 @and_zext_i32_i64(i32* %p, i64 %v) {
|
||||
|
||||
; 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 @@ define i32 @or_zext_i8_i32(i8* %p, i32 %v) {
|
||||
|
||||
; 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 @@ define i32 @or_zext_i16_i32(i16* %p, i32 %v) {
|
||||
|
||||
; 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 @@ define i64 @or_zext_i8_i64(i8* %p, i64 %v) {
|
||||
|
||||
; 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 @@ define i64 @or_zext_i16_i64(i16* %p, i64 %v) {
|
||||
|
||||
; 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 @@ define i64 @or_zext_i32_i64(i32* %p, i64 %v) {
|
||||
|
||||
; 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 @@ define i32 @xor_zext_i8_i32(i8* %p, i32 %v) {
|
||||
|
||||
; 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 @@ define i32 @xor_zext_i16_i32(i16* %p, i32 %v) {
|
||||
|
||||
; 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 @@ define i64 @xor_zext_i8_i64(i8* %p, i64 %v) {
|
||||
|
||||
; 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 @@ define i64 @xor_zext_i16_i64(i16* %p, i64 %v) {
|
||||
|
||||
; 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 @@ define i64 @xor_zext_i32_i64(i32* %p, i64 %v) {
|
||||
|
||||
; 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 @@ define i32 @xchg_zext_i8_i32(i8* %p, i32 %v) {
|
||||
|
||||
; 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 @@ define i32 @xchg_zext_i16_i32(i16* %p, i32 %v) {
|
||||
|
||||
; 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 @@ define i64 @xchg_zext_i8_i64(i8* %p, i64 %v) {
|
||||
|
||||
; 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 @@ define i64 @xchg_zext_i16_i64(i16* %p, i64 %v) {
|
||||
|
||||
; 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 @@ define i64 @xchg_zext_i32_i64(i32* %p, i64 %v) {
|
||||
|
||||
; 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 @@ define i32 @cmpxchg_zext_i8_i32(i8* %p, i32 %exp, i32 %new) {
|
||||
|
||||
; 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 @@ define i32 @cmpxchg_zext_i16_i32(i16* %p, i32 %exp, i32 %new) {
|
||||
|
||||
; 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 @@ define i64 @cmpxchg_zext_i8_i64(i8* %p, i64 %exp, i64 %new) {
|
||||
|
||||
; 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 @@ define i64 @cmpxchg_zext_i16_i64(i16* %p, i64 %exp, i64 %new) {
|
||||
|
||||
; 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 @@ define i64 @cmpxchg_zext_i32_i64(i32* %p, i64 %exp, i64 %new) {
|
||||
; 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 @@ define i32 @nand_zext_i8_i32(i8* %p, i32 %v) {
|
||||
; 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 @@ define i32 @nand_zext_i16_i32(i16* %p, i32 %v) {
|
||||
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 @@ define i64 @nand_zext_i8_i64(i8* %p, i64 %v) {
|
||||
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 @@ define i64 @nand_zext_i16_i64(i16* %p, i64 %v) {
|
||||
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
|
||||
|
@ -21,12 +21,12 @@ declare void @ext_byval_func_empty(%EmptyStruct* byval)
|
||||
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 @@ define void @byval_arg(%SmallStruct* %ptr) {
|
||||
; 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 @@ define void @byval_arg_align8(%SmallStruct* %ptr) {
|
||||
; 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 @@ define void @byval_arg_double(%AlignedStruct* %ptr) {
|
||||
; 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 @@ define void @byval_empty_callee(%EmptyStruct* byval %ptr) {
|
||||
|
||||
; 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)
|
||||
|
@ -71,7 +71,7 @@ define void @call_void_nullary() {
|
||||
|
||||
; 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 @@ define i32 @call_i32_unary(i32 %a) {
|
||||
|
||||
; 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 @@ define i32 @call_i32_binary(i32 %a, i32 %b) {
|
||||
|
||||
; 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 @@ define void @call_indirect_void(void ()* %callee) {
|
||||
|
||||
; 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 @@ define i32 @call_indirect_i32(i32 ()* %callee) {
|
||||
|
||||
; 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 @@ define i64 @call_indirect_i64(i64 ()* %callee) {
|
||||
|
||||
; 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 @@ define float @call_indirect_float(float ()* %callee) {
|
||||
|
||||
; 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 @@ define double @call_indirect_double(double ()* %callee) {
|
||||
|
||||
; 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 @@ define <16 x i8> @call_indirect_v128(<16 x i8> ()* %callee) {
|
||||
|
||||
; 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 @@ define void @call_indirect_arg(void (i32)* %callee, i32 %arg) {
|
||||
|
||||
; 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{{$}}
|
||||
|
@ -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!
|
||||
|
@ -98,14 +98,14 @@ body: |
|
||||
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 @@ body: |
|
||||
; 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 @@ body: |
|
||||
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 @@ body: |
|
||||
; 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 @@ body: |
|
||||
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 @@ body: |
|
||||
; 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 @@ body: |
|
||||
%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 @@ body: |
|
||||
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
|
||||
|
||||
|
@ -8,11 +8,11 @@ target triple = "wasm32-unknown-unknown"
|
||||
|
||||
; 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 @@ define i32 @ord_f32(float %x, float %y) {
|
||||
|
||||
; 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 @@ define i32 @uno_f32(float %x, float %y) {
|
||||
|
||||
; 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 @@ define i32 @oge_f32(float %x, float %y) {
|
||||
|
||||
; 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 @@ define i32 @ueq_f32(float %x, float %y) {
|
||||
|
||||
; 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 @@ define i32 @one_f32(float %x, float %y) {
|
||||
|
||||
; 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 @@ define i32 @ult_f32(float %x, float %y) {
|
||||
|
||||
; 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 @@ define i32 @ule_f32(float %x, float %y) {
|
||||
|
||||
; 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 @@ define i32 @ugt_f32(float %x, float %y) {
|
||||
|
||||
; 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]]{{$}}
|
||||
|
@ -8,11 +8,11 @@ target triple = "wasm32-unknown-unknown"
|
||||
|
||||
; 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 @@ define i32 @ord_f64(double %x, double %y) {
|
||||
|
||||
; 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 @@ define i32 @uno_f64(double %x, double %y) {
|
||||
|
||||
; 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 @@ define i32 @oge_f64(double %x, double %y) {
|
||||
|
||||
; 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 @@ define i32 @ueq_f64(double %x, double %y) {
|
||||
|
||||
; 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 @@ define i32 @one_f64(double %x, double %y) {
|
||||
|
||||
; 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 @@ define i32 @ult_f64(double %x, double %y) {
|
||||
|
||||
; 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 @@ define i32 @ule_f64(double %x, double %y) {
|
||||
|
||||
; 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 @@ define i32 @ugt_f64(double %x, double %y) {
|
||||
|
||||
; 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]]{{$}}
|
||||
|
@ -8,8 +8,8 @@ target triple = "wasm32-unknown-unknown"
|
||||
|
||||
; 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) {
|
||||
|
@ -8,8 +8,8 @@ target triple = "wasm32-unknown-unknown"
|
||||
|
||||
; 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) {
|
||||
|
@ -17,7 +17,7 @@ target triple = "wasm32-unknown-unknown"
|
||||
; 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 @@ define i32 @i32_trunc_s_f32(float %x) {
|
||||
; 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 @@ define i32 @i32_trunc_u_f32(float %x) {
|
||||
; 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 @@ define i32 @i32_trunc_s_f64(double %x) {
|
||||
; 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 @@ define i32 @i32_trunc_u_f64(double %x) {
|
||||
; 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 @@ define i64 @i64_trunc_s_f32(float %x) {
|
||||
; 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 @@ define i64 @i64_trunc_u_f32(float %x) {
|
||||
; 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 @@ define i64 @i64_trunc_s_f64(double %x) {
|
||||
; 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
|
||||
|
@ -7,7 +7,7 @@ target triple = "wasm32-unknown-unknown"
|
||||
|
||||
; 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 @@ define i32 @i32_wrap_i64(i64 %x) {
|
||||
|
||||
; 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 @@ define i64 @i64_extend_s_i32(i32 %x) {
|
||||
|
||||
; 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 @@ define i64 @i64_extend_u_i32(i32 %x) {
|
||||
|
||||
; 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 @@ define i32 @i32_trunc_s_f32(float %x) {
|
||||
|
||||
; 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 @@ define i32 @i32_trunc_sat_s_f32(float %x) {
|
||||
|
||||
; 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 @@ define i32 @i32_trunc_u_f32(float %x) {
|
||||
|
||||
; 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 @@ define i32 @i32_trunc_sat_u_f32(float %x) {
|
||||
|
||||
; 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 @@ define i32 @i32_trunc_s_f64(double %x) {
|
||||
|
||||
; 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 @@ define i32 @i32_trunc_sat_s_f64(double %x) {
|
||||
|
||||
; 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 @@ define i32 @i32_trunc_u_f64(double %x) {
|
||||
|
||||
; 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 @@ define i32 @i32_trunc_sat_u_f64(double %x) {
|
||||
|
||||
; 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 @@ define i64 @i64_trunc_s_f32(float %x) {
|
||||
|
||||
; 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 @@ define i64 @i64_trunc_sat_s_f32(float %x) {
|
||||
|
||||
; 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 @@ define i64 @i64_trunc_u_f32(float %x) {
|
||||
|
||||
; 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 @@ define i64 @i64_trunc_sat_u_f32(float %x) {
|
||||
|
||||
; 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 @@ define i64 @i64_trunc_s_f64(double %x) {
|
||||
|
||||
; 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 @@ define i64 @i64_trunc_sat_s_f64(double %x) {
|
||||
|
||||
; 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 @@ define i64 @i64_trunc_u_f64(double %x) {
|
||||
|
||||
; 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 @@ define i64 @i64_trunc_sat_u_f64(double %x) {
|
||||
|
||||
; 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 @@ define float @f32_convert_s_i32(i32 %x) {
|
||||
|
||||
; 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 @@ define float @f32_convert_u_i32(i32 %x) {
|
||||
|
||||
; 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 @@ define double @f64_convert_s_i32(i32 %x) {
|
||||
|
||||
; 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 @@ define double @f64_convert_u_i32(i32 %x) {
|
||||
|
||||
; 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 @@ define float @f32_convert_s_i64(i64 %x) {
|
||||
|
||||
; 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 @@ define float @f32_convert_u_i64(i64 %x) {
|
||||
|
||||
; 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 @@ define double @f64_convert_s_i64(i64 %x) {
|
||||
|
||||
; 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 @@ define double @f64_convert_u_i64(i64 %x) {
|
||||
|
||||
; 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 @@ define double @f64_promote_f32(float %x) {
|
||||
|
||||
; 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 @@ define float @f32_demote_f64(double %x) {
|
||||
; 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 @@ define i64 @anyext(i32 %x) {
|
||||
}
|
||||
|
||||
; 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
|
||||
|
@ -10,7 +10,7 @@ declare double @copysign(double, double) nounwind readnone
|
||||
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 @@ define double @fold_promote(double %a, float %b) {
|
||||
}
|
||||
|
||||
; 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
|
||||
|
@ -12,7 +12,7 @@ target triple = "wasm32-unknown-unknown"
|
||||
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 @@ define void @test_throw(i8* %p) {
|
||||
}
|
||||
|
||||
; 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 @@ try.cont: ; preds = %entry, %catch
|
||||
; 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 @@ terminate10: ; preds = %ehcleanup7
|
||||
; 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 @@ ehcleanup: ; preds = %catch
|
||||
; 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:
|
||||
|
@ -8,7 +8,7 @@ target triple = "wasm32-unknown-unknown"
|
||||
|
||||
; 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 @@ define half @demote(float %f) {
|
||||
|
||||
; 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
|
||||
|
@ -17,8 +17,8 @@ declare float @llvm.fma.f32(float, float, float)
|
||||
|
||||
; 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) {
|
||||
|
@ -17,8 +17,8 @@ declare double @llvm.fma.f64(double, double, double)
|
||||
|
||||
; 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) {
|
||||
|
@ -9,8 +9,8 @@ target triple = "wasm32-unknown-unknown"
|
||||
|
||||
; 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) {
|
||||
|
@ -21,28 +21,28 @@ define double @immediate_f64() {
|
||||
}
|
||||
|
||||
; 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
|
||||
|
@ -79,7 +79,7 @@ entry:
|
||||
}
|
||||
|
||||
; 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 @@ end:
|
||||
; 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
|
||||
|
@ -11,8 +11,8 @@ declare i32 @llvm.ctpop.i32(i32)
|
||||
|
||||
; 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 @@ define i32 @add32(i32 %x, i32 %y) {
|
||||
|
||||
; 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 @@ define i32 @sub32(i32 %x, i32 %y) {
|
||||
|
||||
; 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 @@ define i32 @mul32(i32 %x, i32 %y) {
|
||||
|
||||
; 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 @@ define i32 @sdiv32(i32 %x, i32 %y) {
|
||||
|
||||
; 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 @@ define i32 @udiv32(i32 %x, i32 %y) {
|
||||
|
||||
; 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 @@ define i32 @srem32(i32 %x, i32 %y) {
|
||||
|
||||
; 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 @@ define i32 @urem32(i32 %x, i32 %y) {
|
||||
|
||||
; 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 @@ define i32 @and32(i32 %x, i32 %y) {
|
||||
|
||||
; 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 @@ define i32 @or32(i32 %x, i32 %y) {
|
||||
|
||||
; 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 @@ define i32 @xor32(i32 %x, i32 %y) {
|
||||
|
||||
; 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 @@ define i32 @shl32(i32 %x, i32 %y) {
|
||||
|
||||
; 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 @@ define i32 @shr32(i32 %x, i32 %y) {
|
||||
|
||||
; 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 @@ define i32 @sar32(i32 %x, i32 %y) {
|
||||
|
||||
; 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 @@ define i32 @clz32(i32 %x) {
|
||||
|
||||
; 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 @@ define i32 @clz32_zero_undef(i32 %x) {
|
||||
|
||||
; 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 @@ define i32 @ctz32(i32 %x) {
|
||||
|
||||
; 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 @@ define i32 @ctz32_zero_undef(i32 %x) {
|
||||
|
||||
; 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 @@ define i32 @popcnt32(i32 %x) {
|
||||
|
||||
; 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 @@ define i32 @eqz32(i32 %x) {
|
||||
|
||||
; 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 @@ define i32 @rotl(i32 %x, i32 %y) {
|
||||
|
||||
; 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 @@ define i32 @masked_rotl(i32 %x, i32 %y) {
|
||||
|
||||
; 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 @@ define i32 @rotr(i32 %x, i32 %y) {
|
||||
|
||||
; 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) {
|
||||
|
@ -11,8 +11,8 @@ declare i64 @llvm.ctpop.i64(i64)
|
||||
|
||||
; 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 @@ define i64 @add64(i64 %x, i64 %y) {
|
||||
|
||||
; 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 @@ define i64 @sub64(i64 %x, i64 %y) {
|
||||
|
||||
; 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 @@ define i64 @mul64(i64 %x, i64 %y) {
|
||||
|
||||
; 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 @@ define i64 @sdiv64(i64 %x, i64 %y) {
|
||||
|
||||
; 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 @@ define i64 @udiv64(i64 %x, i64 %y) {
|
||||
|
||||
; 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 @@ define i64 @srem64(i64 %x, i64 %y) {
|
||||
|
||||
; 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 @@ define i64 @urem64(i64 %x, i64 %y) {
|
||||
|
||||
; 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 @@ define i64 @and64(i64 %x, i64 %y) {
|
||||
|
||||
; 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 @@ define i64 @or64(i64 %x, i64 %y) {
|
||||
|
||||
; 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 @@ define i64 @xor64(i64 %x, i64 %y) {
|
||||
|
||||
; 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 @@ define i64 @shl64(i64 %x, i64 %y) {
|
||||
|
||||
; 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 @@ define i64 @shr64(i64 %x, i64 %y) {
|
||||
|
||||
; 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 @@ define i64 @sar64(i64 %x, i64 %y) {
|
||||
|
||||
; 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 @@ define i64 @clz64(i64 %x) {
|
||||
|
||||
; 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 @@ define i64 @clz64_zero_undef(i64 %x) {
|
||||
|
||||
; 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 @@ define i64 @ctz64(i64 %x) {
|
||||
|
||||
; 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 @@ define i64 @ctz64_zero_undef(i64 %x) {
|
||||
|
||||
; 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 @@ define i64 @popcnt64(i64 %x) {
|
||||
|
||||
; 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 @@ define i32 @eqz64(i64 %x) {
|
||||
|
||||
; 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 @@ define i64 @rotl(i64 %x, i64 %y) {
|
||||
|
||||
; 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 @@ define i64 @masked_rotl(i64 %x, i64 %y) {
|
||||
|
||||
; 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 @@ define i64 @rotr(i64 %x, i64 %y) {
|
||||
|
||||
; 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) {
|
||||
|
@ -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 @@ target triple = "wasm32-unknown-unknown"
|
||||
; 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
|
||||
|
@ -11,7 +11,7 @@ target triple = "wasm32-unknown-unknown"
|
||||
; 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 @@ entry:
|
||||
; 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 @@ entry:
|
||||
; 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 @@ entry:
|
||||
|
||||
; 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 @@ define void @X_i16(i16 * %t) {
|
||||
|
||||
; 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 @@ define void @varname() {
|
||||
|
||||
; 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 @@ entry:
|
||||
}
|
||||
|
||||
; CHECK-LABEL: tied_operands
|
||||
; CHECK: get_local $push0=, 0
|
||||
; CHECK: local.get $push0=, 0
|
||||
; CHECK: return $pop0
|
||||
define i32 @tied_operands(i32 %var) {
|
||||
entry:
|
||||
|
@ -34,7 +34,7 @@ define i64 @sext_in_reg_i32_i64(i64 %a) {
|
||||
|
||||
; 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 @@ define double @fpext_f32_f64(float *%p) {
|
||||
|
||||
; 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
|
||||
|
@ -84,7 +84,7 @@ define i64 @zext_i16_i64(i16 *%p) {
|
||||
|
||||
; 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
|
||||
|
@ -8,7 +8,7 @@ target triple = "wasm32-unknown-unknown"
|
||||
|
||||
; 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 @@ define i32 @ldi32(i32 *%p) {
|
||||
|
||||
; 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 @@ define i64 @ldi64(i64 *%p) {
|
||||
|
||||
; 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 @@ define float @ldf32(float *%p) {
|
||||
|
||||
; 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) {
|
||||
|
@ -11,7 +11,7 @@ define hidden i32 @main() local_unnamed_addr #0 {
|
||||
; 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
|
||||
|
||||
|
@ -363,10 +363,10 @@ define i32 @load_i8_i32_s_with_folded_offset(i8* %p) {
|
||||
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 @@ define i64 @rmw_add_i64_with_unfolded_gep_offset(i64* %p, i64 %v) {
|
||||
; 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 @@ define i32 @rmw_add_i8_i32_s_with_folded_offset(i8* %p, i32 %v) {
|
||||
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 @@ define i64 @rmw_add_i32_i64_s_with_folded_offset(i32* %p, i64 %v) {
|
||||
; 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 @@ define i32 @rmw_add_i8_i32_s_with_folded_gep_offset(i8* %p, i32 %v) {
|
||||
}
|
||||
|
||||
; 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 @@ define i32 @rmw_add_i16_i32_s_with_folded_gep_offset(i16* %p, i32 %v) {
|
||||
}
|
||||
|
||||
; 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 @@ define i64 @rmw_add_i16_i64_s_with_folded_gep_offset(i16* %p, i64 %v) {
|
||||
; 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 @@ define i32 @rmw_add_i8_i32_s_with_folded_or_offset(i32 %x, i32 %v) {
|
||||
}
|
||||
|
||||
; 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 @@ define i64 @rmw_add_i8_i64_s_with_folded_or_offset(i32 %x, i64 %v) {
|
||||
|
||||
; 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 @@ define i32 @rmw_add_i16_i32_s_from_numeric_address(i32 %v) {
|
||||
|
||||
; 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 @@ define i32 @rmw_add_i8_i32_s_from_global_address(i32 %v) {
|
||||
; 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 @@ define i32 @rmw_add_i8_i32_z_with_folded_offset(i8* %p, i32 %v) {
|
||||
}
|
||||
|
||||
; 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 @@ define i64 @rmw_add_i32_i64_z_with_folded_offset(i32* %p, i64 %v) {
|
||||
; 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 @@ define i32 @rmw_add_i8_i32_z_with_folded_gep_offset(i8* %p, i32 %v) {
|
||||
}
|
||||
|
||||
; 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 @@ define i32 @rmw_add_i16_i32_z_with_folded_gep_offset(i16* %p, i32 %v) {
|
||||
}
|
||||
|
||||
; 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 @@ define i64 @rmw_add_i16_i64_z_with_folded_gep_offset(i16* %p, i64 %v) {
|
||||
; 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 @@ define i32 @rmw_add_i8_i32_z_with_folded_or_offset(i32 %x, i32 %v) {
|
||||
}
|
||||
|
||||
; 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 @@ define i64 @rmw_add_i8_i64_z_with_folded_or_offset(i32 %x, i64 %v) {
|
||||
|
||||
; 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 @@ define i32 @rmw_add_i16_i32_z_from_numeric_address(i32 %v) {
|
||||
|
||||
; 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 @@ define i32 @rmw_add_i8_i32_z_from_global_address(i32 %v) {
|
||||
; 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 @@ define i64 @cmpxchg_i64_with_unfolded_gep_offset(i64* %p, i64 %exp, i64 %new) {
|
||||
; 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 @@ define i32 @cmpxchg_i8_i32_s_with_folded_offset(i8* %p, i32 %exp, i32 %new) {
|
||||
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 @@ define i64 @cmpxchg_i32_i64_s_with_folded_offset(i32* %p, i64 %exp, i64 %new) {
|
||||
; 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 @@ define i32 @cmpxchg_i8_i32_s_with_folded_gep_offset(i8* %p, i32 %exp, i32 %new)
|
||||
}
|
||||
|
||||
; 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 @@ define i32 @cmpxchg_i16_i32_s_with_folded_gep_offset(i16* %p, i32 %exp, i32 %new
|
||||
}
|
||||
|
||||
; 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 @@ define i64 @cmpxchg_i16_i64_s_with_folded_gep_offset(i16* %p, i64 %exp, i64 %new
|
||||
; 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 @@ define i32 @cmpxchg_i8_i32_s_with_folded_or_offset(i32 %x, i32 %exp, i32 %new) {
|
||||
}
|
||||
|
||||
; 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 @@ define i64 @cmpxchg_i8_i64_s_with_folded_or_offset(i32 %x, i64 %exp, i64 %new) {
|
||||
|
||||
; 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 @@ define i32 @cmpxchg_i16_i32_s_from_numeric_address(i32 %exp, i32 %new) {
|
||||
|
||||
; 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 @@ define i32 @cmpxchg_i8_i32_s_from_global_address(i32 %exp, i32 %new) {
|
||||
; 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 @@ define i32 @cmpxchg_i8_i32_z_with_folded_offset(i8* %p, i32 %exp, i32 %new) {
|
||||
}
|
||||
|
||||
; 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 @@ define i64 @cmpxchg_i32_i64_z_with_folded_offset(i32* %p, i64 %exp, i64 %new) {
|
||||
; 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 @@ define i32 @cmpxchg_i8_i32_z_with_folded_gep_offset(i8* %p, i32 %exp, i32 %new)
|
||||
}
|
||||
|
||||
; 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 @@ define i32 @cmpxchg_i16_i32_z_with_folded_gep_offset(i16* %p, i32 %exp, i32 %new
|
||||
}
|
||||
|
||||
; 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 @@ define i64 @cmpxchg_i16_i64_z_with_folded_gep_offset(i16* %p, i64 %exp, i64 %new
|
||||
; 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 @@ define i32 @cmpxchg_i8_i32_z_with_folded_or_offset(i32 %x, i32 %exp, i32 %new) {
|
||||
}
|
||||
|
||||
; 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 @@ define i64 @cmpxchg_i8_i64_z_with_folded_or_offset(i32 %x, i64 %exp, i64 %new) {
|
||||
|
||||
; 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 @@ define i32 @cmpxchg_i16_i32_z_from_numeric_address(i32 %exp, i32 %new) {
|
||||
|
||||
; 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
|
||||
|
@ -16,10 +16,10 @@ define void @store_i8_with_variable_gep_offset(i8* %p, i32 %idx) {
|
||||
}
|
||||
|
||||
; 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]]{{$}}
|
||||
|
@ -27,9 +27,9 @@ done:
|
||||
|
||||
; 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
|
||||
|
@ -125,17 +125,17 @@ define i32 @no_sink_readonly_call(i32 %x, i32 %y, i32* %p) {
|
||||
; 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 @@ false:
|
||||
}
|
||||
|
||||
; 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 @@ false:
|
||||
; 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 @@ entry:
|
||||
; 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 @@ entry:
|
||||
; 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 @@ define void @simple_multiple_use(i32 %x, i32 %y) {
|
||||
; 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 @@ define i32 @commute() {
|
||||
}
|
||||
|
||||
; 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 @@ define i32 @commute() {
|
||||
; 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 @@ define i32 @no_stackify_past_use(i32 %arg) {
|
||||
|
||||
; 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 @@ define i32 @no_stackify_past_use(i32 %arg) {
|
||||
; 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 @@ define i32 @commute_to_fix_ordering(i32 %arg) {
|
||||
|
||||
; 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 @@ define i32 @no_stackify_past_epilogue() {
|
||||
; 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 @@ bb10: ; preds = %bb9, %bb
|
||||
|
||||
; 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 @@ define i32 @stackpointer_dependency(i8* readnone) {
|
||||
|
||||
; 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
|
||||
|
@ -6,7 +6,7 @@ target triple = "wasm32-unknown-unknown"
|
||||
|
||||
; 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
|
||||
|
@ -30,7 +30,7 @@ define i32 @i32_extend16_s(i16 %x) {
|
||||
|
||||
; 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 @@ define i64 @i64_extend8_s(i8 %x) {
|
||||
|
||||
; 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 @@ define i64 @i64_extend16_s(i16 %x) {
|
||||
; 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
|
||||
|
@ -725,7 +725,7 @@ define <2 x i64> @shl_v2i64(<2 x i64> %v, i32 %x) {
|
||||
; 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 @@ define <2 x i64> @shr_s_v2i64(<2 x i64> %v, i32 %x) {
|
||||
; 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 @@ define <2 x i64> @shr_u_v2i64(<2 x i64> %v, i32 %x) {
|
||||
; 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) {
|
||||
|
@ -10,7 +10,7 @@ target triple = "wasm32-unknown-unknown"
|
||||
; 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 @@ define <4 x float> @convert_s_v4f32(<4 x i32> %x) {
|
||||
; 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 @@ define <4 x float> @convert_u_v4f32(<4 x i32> %x) {
|
||||
|
||||
; 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 @@ define <2 x double> @convert_s_v2f64(<2 x i64> %x) {
|
||||
|
||||
; 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 @@ define <2 x double> @convert_u_v2f64(<2 x i64> %x) {
|
||||
; 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 @@ define <4 x i32> @trunc_sat_s_v4i32(<4 x float> %x) {
|
||||
; 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 @@ define <4 x i32> @trunc_sat_u_v4i32(<4 x float> %x) {
|
||||
|
||||
; 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 @@ define <2 x i64> @trunc_sat_s_v2i64(<2 x double> %x) {
|
||||
|
||||
; 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>
|
||||
|
@ -204,7 +204,7 @@ define <4 x i32> @bitselect_v4i32(<4 x i32> %c, <4 x i32> %v1, <4 x i32> %v2) {
|
||||
; 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 @@ define <4 x i32> @trunc_sat_s_v4i32(<4 x float> %x) {
|
||||
; 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 @@ define <2 x i64> @bitselect_v2i64(<2 x i64> %c, <2 x i64> %v1, <2 x i64> %v2) {
|
||||
; 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 @@ define <2 x i64> @trunc_sat_s_v2i64(<2 x double> %x) {
|
||||
; 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) {
|
||||
|
@ -56,10 +56,10 @@ define i32 @extract_v16i8_s(<16 x i8> %v) {
|
||||
; 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 @@ define i32 @extract_v16i8_u(<16 x i8> %v) {
|
||||
; 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 @@ define i8 @extract_v16i8(<16 x i8> %v) {
|
||||
; 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 @@ define <16 x i8> @replace_v16i8(<16 x i8> %v, i8 %x) {
|
||||
; 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 @@ define i32 @extract_v8i16_s(<8 x i16> %v) {
|
||||
; 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 @@ define i32 @extract_v8i16_u(<8 x i16> %v) {
|
||||
; 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 @@ define i16 @extract_v8i16(<8 x i16> %v) {
|
||||
; 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 @@ define <8 x i16> @replace_v8i16(<8 x i16> %v, i16 %x) {
|
||||
; 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 @@ define i32 @extract_v4i32(<4 x i32> %v) {
|
||||
; 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 @@ define <4 x i32> @replace_v4i32(<4 x i32> %v, i32 %x) {
|
||||
; 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 @@ define i64 @extract_v2i64(<2 x i64> %v) {
|
||||
; 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 @@ define <2 x i64> @replace_v2i64(<2 x i64> %v, i64 %x) {
|
||||
; 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 @@ define float @extract_v4f32(<4 x float> %v) {
|
||||
; 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 @@ define <4 x float> @replace_v4f32(<4 x float> %v, float %x) {
|
||||
; 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 @@ define double @extract_v2f64(<2 x double> %v) {
|
||||
; 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 @@ define <2 x double> @replace_v2f64(<2 x double> %v, double %x) {
|
||||
; 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]]{{$}}
|
||||
|
@ -6,18 +6,18 @@ target triple = "wasm32-unknown-unknown"
|
||||
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 @@ entry:
|
||||
}
|
||||
|
||||
; 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 @@ entry:
|
||||
}
|
||||
|
||||
; 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 @@ entry:
|
||||
}
|
||||
|
||||
; 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 @@ entry:
|
||||
}
|
||||
|
||||
; 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 @@ entry:
|
||||
}
|
||||
|
||||
; 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
|
||||
|
@ -8,8 +8,8 @@ target triple = "wasm32-unknown-unknown"
|
||||
|
||||
; 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 @@ define void @sti32(i32 *%p, i32 %v) {
|
||||
|
||||
; 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 @@ define void @sti64(i64 *%p, i64 %v) {
|
||||
|
||||
; 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 @@ define void @stf32(float *%p, float %v) {
|
||||
|
||||
; 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) {
|
||||
|
@ -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
|
||||
|
@ -10,37 +10,37 @@ declare void @ext_func_i32(i32* %ptr)
|
||||
; 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 @@ define void @alloca3264() {
|
||||
; 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 @@ define void @allocarray() {
|
||||
%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 @allocarray() {
|
||||
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 @@ define void @non_mem_use(i8** %addr) {
|
||||
; 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 @@ define void @allocarray_inbounds() {
|
||||
; 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 @@ define void @dynamic_alloca_redzone(i32 %alloc) {
|
||||
; 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 @@ define void @dynamic_static_alloca(i32 %alloc) noredzone {
|
||||
|
||||
; 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 @@ define void @dynamic_static_alloca(i32 %alloc) noredzone {
|
||||
|
||||
; 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 @@ define void @dynamic_static_alloca(i32 %alloc) noredzone {
|
||||
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 @@ declare void @llvm.stackrestore(i8*)
|
||||
|
||||
; 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 @@ define void @llvm_stack_builtins(i32 %alloc) noredzone {
|
||||
; 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 @@ entry:
|
||||
%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 @@ declare i8* @llvm.frameaddress(i32)
|
||||
|
||||
; 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 @@ define void @frameaddress_1() {
|
||||
|
||||
; 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
|
||||
|
@ -52,7 +52,7 @@ entry:
|
||||
; 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 @@ entry:
|
||||
; 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]]{{$}}
|
||||
|
@ -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
|
||||
|
@ -57,7 +57,7 @@ entry:
|
||||
; 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
|
||||
|
@ -11,20 +11,20 @@ test0:
|
||||
.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 @@ test0:
|
||||
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 @@ test0:
|
||||
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 @@ test0:
|
||||
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 @@ test0:
|
||||
# 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 @@ test0:
|
||||
# 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 @@ test0:
|
||||
# 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 @@ test0:
|
||||
# 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
|
||||
|
@ -41,7 +41,7 @@ define linkonce_odr i32 @sharedFn() #1 comdat($sharedComdat) {
|
||||
; 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
|
||||
|
@ -30,7 +30,7 @@ declare void @func3()
|
||||
; 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
|
||||
|
@ -427,28 +427,28 @@ main:
|
||||
# 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
|
||||
|
@ -62,7 +62,7 @@ entry:
|
||||
; 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
|
||||
|
@ -5,7 +5,7 @@ FileHeader:
|
||||
Sections:
|
||||
- Type: TABLE
|
||||
Tables:
|
||||
- ElemType: ANYFUNC
|
||||
- ElemType: FUNCREF
|
||||
Limits:
|
||||
Flags: [ HAS_MAX ]
|
||||
Initial: 0x00000010
|
||||
@ -18,7 +18,7 @@ Sections:
|
||||
Functions:
|
||||
- 1
|
||||
- Offset:
|
||||
Opcode: GET_GLOBAL
|
||||
Opcode: GLOBAL_GET
|
||||
Index: 1
|
||||
Functions:
|
||||
- 4
|
||||
@ -34,7 +34,7 @@ Sections:
|
||||
# CHECK: Value: 3
|
||||
# CHECK: Functions: [ 1 ]
|
||||
# CHECK: - Offset:
|
||||
# CHECK: Opcode: GET_GLOBAL
|
||||
# CHECK: Opcode: GLOBAL_GET
|
||||
# CHECK: Index: 1
|
||||
# CHECK: Functions: [ 4 ]
|
||||
# CHECK: ...
|
||||
|
@ -31,7 +31,7 @@ Sections:
|
||||
Field: imported_table
|
||||
Kind: TABLE
|
||||
Table:
|
||||
ElemType: ANYFUNC
|
||||
ElemType: FUNCREF
|
||||
Limits:
|
||||
Flags: [ HAS_MAX ]
|
||||
Initial: 0x00000020
|
||||
@ -63,7 +63,7 @@ Sections:
|
||||
# CHECK: Field: imported_table
|
||||
# CHECK: Kind: TABLE
|
||||
# CHECK: Table:
|
||||
# CHECK: ElemType: ANYFUNC
|
||||
# CHECK: ElemType: FUNCREF
|
||||
# CHECK: Limits:
|
||||
# CHECK: Flags: [ HAS_MAX ]
|
||||
# CHECK: Initial: 0x00000020
|
||||
|
@ -5,7 +5,7 @@ FileHeader:
|
||||
Sections:
|
||||
- Type: TABLE
|
||||
Tables:
|
||||
- ElemType: ANYFUNC
|
||||
- ElemType: FUNCREF
|
||||
Limits:
|
||||
Flags: [ HAS_MAX ]
|
||||
Initial: 0x00000010
|
||||
@ -17,7 +17,7 @@ Sections:
|
||||
# CHECK: Sections:
|
||||
# CHECK: - Type: TABLE
|
||||
# CHECK: Tables:
|
||||
# CHECK: - ElemType: ANYFUNC
|
||||
# CHECK: - ElemType: FUNCREF
|
||||
# CHECK: Limits:
|
||||
# CHECK: Flags: [ HAS_MAX ]
|
||||
# CHECK: Initial: 0x00000010
|
||||
|
@ -105,7 +105,7 @@ static int writeInitExpr(const wasm::WasmInitExpr &InitExpr, raw_ostream &OS) {
|
||||
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:
|
||||
|
Loading…
Reference in New Issue
Block a user