diff options
Diffstat (limited to 'llvm/lib/Target')
| -rw-r--r-- | llvm/lib/Target/WebAssembly/WebAssemblyInstrAtomics.td | 123 | ||||
| -rw-r--r-- | llvm/lib/Target/WebAssembly/WebAssemblyInstrMemory.td | 65 |
2 files changed, 89 insertions, 99 deletions
diff --git a/llvm/lib/Target/WebAssembly/WebAssemblyInstrAtomics.td b/llvm/lib/Target/WebAssembly/WebAssemblyInstrAtomics.td index e19de1ac0ef..cac651dc68e 100644 --- a/llvm/lib/Target/WebAssembly/WebAssemblyInstrAtomics.td +++ b/llvm/lib/Target/WebAssembly/WebAssemblyInstrAtomics.td @@ -40,7 +40,6 @@ def : LoadPatGlobalAddr<i64, atomic_load_64, ATOMIC_LOAD_I64>; def : LoadPatExternalSym<i32, atomic_load_32, ATOMIC_LOAD_I32>; def : LoadPatExternalSym<i64, atomic_load_64, ATOMIC_LOAD_I64>; - // Select loads with just a constant offset. def : LoadPatOffsetOnly<i32, atomic_load_32, ATOMIC_LOAD_I32>; def : LoadPatOffsetOnly<i64, atomic_load_64, ATOMIC_LOAD_I64>; @@ -63,7 +62,7 @@ defm ATOMIC_LOAD16_U_I64 : WebAssemblyLoad<I64, "i64.atomic.load16_u", 0xfe15>; defm ATOMIC_LOAD32_U_I64 : WebAssemblyLoad<I64, "i64.atomic.load32_u", 0xfe16>; } // Defs = [ARGUMENTS] -// Fragments for exending loads. These are different from regular loads because +// Fragments for extending loads. These are different from regular loads because // the SDNodes are derived from AtomicSDNode rather than LoadSDNode and // therefore don't have the extension type field. So instead of matching that, // we match the patterns that the type legalizer expands them to. @@ -72,10 +71,10 @@ defm ATOMIC_LOAD32_U_I64 : WebAssemblyLoad<I64, "i64.atomic.load32_u", 0xfe16>; // i32 (zext (i8 (atomic_load_8))) gets legalized to // i32 (and (i32 (atomic_load_8)), 255) // These can be selected to a single zero-extending atomic load instruction. -def zext_aload_8 : PatFrag<(ops node:$addr), - (and (i32 (atomic_load_8 node:$addr)), 255)>; -def zext_aload_16 : PatFrag<(ops node:$addr), - (and (i32 (atomic_load_16 node:$addr)), 65535)>; +def zext_aload_8_32 : + PatFrag<(ops node:$addr), (and (i32 (atomic_load_8 node:$addr)), 255)>; +def zext_aload_16_32 : + PatFrag<(ops node:$addr), (and (i32 (atomic_load_16 node:$addr)), 65535)>; // Unlike regular loads, extension to i64 is handled differently than i32. // i64 (zext (i8 (atomic_load_8))) gets legalized to // i64 (and (i64 (anyext (i32 (atomic_load_8)))), 255) @@ -93,15 +92,15 @@ def zext_aload_32_64 : // match bare subword loads (for 32-bit results) and anyext loads (for 64-bit // results) and select a zext load; the next instruction will be sext_inreg // which is selected by itself. -def anyext_aload_8_64 : +def sext_aload_8_64 : PatFrag<(ops node:$addr), (anyext (i32 (atomic_load_8 node:$addr)))>; -def anyext_aload_16_64 : +def sext_aload_16_64 : PatFrag<(ops node:$addr), (anyext (i32 (atomic_load_16 node:$addr)))>; let Predicates = [HasAtomics] in { // Select zero-extending loads with no constant offset. -def : LoadPatNoOffset<i32, zext_aload_8, ATOMIC_LOAD8_U_I32>; -def : LoadPatNoOffset<i32, zext_aload_16, ATOMIC_LOAD16_U_I32>; +def : LoadPatNoOffset<i32, zext_aload_8_32, ATOMIC_LOAD8_U_I32>; +def : LoadPatNoOffset<i32, zext_aload_16_32, ATOMIC_LOAD16_U_I32>; def : LoadPatNoOffset<i64, zext_aload_8_64, ATOMIC_LOAD8_U_I64>; def : LoadPatNoOffset<i64, zext_aload_16_64, ATOMIC_LOAD16_U_I64>; def : LoadPatNoOffset<i64, zext_aload_32_64, ATOMIC_LOAD32_U_I64>; @@ -109,16 +108,15 @@ def : LoadPatNoOffset<i64, zext_aload_32_64, ATOMIC_LOAD32_U_I64>; // Select sign-extending loads with no constant offset def : LoadPatNoOffset<i32, atomic_load_8, ATOMIC_LOAD8_U_I32>; def : LoadPatNoOffset<i32, atomic_load_16, ATOMIC_LOAD16_U_I32>; -def : LoadPatNoOffset<i64, anyext_aload_8_64, ATOMIC_LOAD8_U_I64>; -def : LoadPatNoOffset<i64, anyext_aload_16_64, ATOMIC_LOAD16_U_I64>; -// 32->64 sext load gets selected as i32.atomic.load, i64.extend_s/i64 - +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 // Zero-extending loads with constant offset -def : LoadPatImmOff<i32, zext_aload_8, regPlusImm, ATOMIC_LOAD8_U_I32>; -def : LoadPatImmOff<i32, zext_aload_16, regPlusImm, ATOMIC_LOAD16_U_I32>; -def : LoadPatImmOff<i32, zext_aload_8, or_is_add, ATOMIC_LOAD8_U_I32>; -def : LoadPatImmOff<i32, zext_aload_16, or_is_add, ATOMIC_LOAD16_U_I32>; +def : LoadPatImmOff<i32, zext_aload_8_32, regPlusImm, ATOMIC_LOAD8_U_I32>; +def : LoadPatImmOff<i32, zext_aload_16_32, regPlusImm, ATOMIC_LOAD16_U_I32>; +def : LoadPatImmOff<i32, zext_aload_8_32, or_is_add, ATOMIC_LOAD8_U_I32>; +def : LoadPatImmOff<i32, zext_aload_16_32, or_is_add, ATOMIC_LOAD16_U_I32>; def : LoadPatImmOff<i64, zext_aload_8_64, regPlusImm, ATOMIC_LOAD8_U_I64>; def : LoadPatImmOff<i64, zext_aload_16_64, regPlusImm, ATOMIC_LOAD16_U_I64>; def : LoadPatImmOff<i64, zext_aload_32_64, regPlusImm, ATOMIC_LOAD32_U_I64>; @@ -131,64 +129,62 @@ def : LoadPatImmOff<i32, atomic_load_8, regPlusImm, ATOMIC_LOAD8_U_I32>; def : LoadPatImmOff<i32, atomic_load_16, regPlusImm, ATOMIC_LOAD16_U_I32>; def : LoadPatImmOff<i32, atomic_load_8, or_is_add, ATOMIC_LOAD8_U_I32>; def : LoadPatImmOff<i32, atomic_load_16, or_is_add, ATOMIC_LOAD16_U_I32>; -def : LoadPatImmOff<i64, anyext_aload_8_64, regPlusImm, ATOMIC_LOAD8_U_I64>; -def : LoadPatImmOff<i64, anyext_aload_16_64, regPlusImm, ATOMIC_LOAD16_U_I64>; -def : LoadPatImmOff<i64, anyext_aload_8_64, or_is_add, ATOMIC_LOAD8_U_I64>; -def : LoadPatImmOff<i64, anyext_aload_16_64, or_is_add, ATOMIC_LOAD16_U_I64>; +def : LoadPatImmOff<i64, sext_aload_8_64, regPlusImm, ATOMIC_LOAD8_U_I64>; +def : LoadPatImmOff<i64, sext_aload_16_64, regPlusImm, ATOMIC_LOAD16_U_I64>; +def : LoadPatImmOff<i64, sext_aload_8_64, or_is_add, ATOMIC_LOAD8_U_I64>; +def : LoadPatImmOff<i64, sext_aload_16_64, or_is_add, ATOMIC_LOAD16_U_I64>; // No 32->64 patterns, just use i32.atomic.load and i64.extend_s/i64 -def : LoadPatGlobalAddr<i32, zext_aload_8, ATOMIC_LOAD8_U_I32>; -def : LoadPatGlobalAddr<i32, zext_aload_16, ATOMIC_LOAD16_U_I32>; +def : LoadPatGlobalAddr<i32, zext_aload_8_32, ATOMIC_LOAD8_U_I32>; +def : LoadPatGlobalAddr<i32, zext_aload_16_32, ATOMIC_LOAD16_U_I32>; def : LoadPatGlobalAddr<i64, zext_aload_8_64, ATOMIC_LOAD8_U_I64>; def : LoadPatGlobalAddr<i64, zext_aload_16_64, ATOMIC_LOAD16_U_I64>; def : LoadPatGlobalAddr<i64, zext_aload_32_64, ATOMIC_LOAD32_U_I64>; def : LoadPatGlobalAddr<i32, atomic_load_8, ATOMIC_LOAD8_U_I32>; def : LoadPatGlobalAddr<i32, atomic_load_16, ATOMIC_LOAD16_U_I32>; -def : LoadPatGlobalAddr<i64, anyext_aload_8_64, ATOMIC_LOAD8_U_I64>; -def : LoadPatGlobalAddr<i64, anyext_aload_16_64, ATOMIC_LOAD16_U_I64>; +def : LoadPatGlobalAddr<i64, sext_aload_8_64, ATOMIC_LOAD8_U_I64>; +def : LoadPatGlobalAddr<i64, sext_aload_16_64, ATOMIC_LOAD16_U_I64>; -def : LoadPatExternalSym<i32, zext_aload_8, ATOMIC_LOAD8_U_I32>; -def : LoadPatExternalSym<i32, zext_aload_16, ATOMIC_LOAD16_U_I32>; +def : LoadPatExternalSym<i32, zext_aload_8_32, ATOMIC_LOAD8_U_I32>; +def : LoadPatExternalSym<i32, zext_aload_16_32, ATOMIC_LOAD16_U_I32>; def : LoadPatExternalSym<i64, zext_aload_8_64, ATOMIC_LOAD8_U_I64>; def : LoadPatExternalSym<i64, zext_aload_16_64, ATOMIC_LOAD16_U_I64>; def : LoadPatExternalSym<i64, zext_aload_32_64, ATOMIC_LOAD32_U_I64>; def : LoadPatExternalSym<i32, atomic_load_8, ATOMIC_LOAD8_U_I32>; def : LoadPatExternalSym<i32, atomic_load_16, ATOMIC_LOAD16_U_I32>; -def : LoadPatExternalSym<i64, anyext_aload_8_64, ATOMIC_LOAD8_U_I64>; -def : LoadPatExternalSym<i64, anyext_aload_16_64, ATOMIC_LOAD16_U_I64>; - +def : LoadPatExternalSym<i64, sext_aload_8_64, ATOMIC_LOAD8_U_I64>; +def : LoadPatExternalSym<i64, sext_aload_16_64, ATOMIC_LOAD16_U_I64>; // Extending loads with just a constant offset -def : LoadPatOffsetOnly<i32, zext_aload_8, ATOMIC_LOAD8_U_I32>; -def : LoadPatOffsetOnly<i32, zext_aload_16, ATOMIC_LOAD16_U_I32>; +def : LoadPatOffsetOnly<i32, zext_aload_8_32, ATOMIC_LOAD8_U_I32>; +def : LoadPatOffsetOnly<i32, zext_aload_16_32, ATOMIC_LOAD16_U_I32>; def : LoadPatOffsetOnly<i64, zext_aload_8_64, ATOMIC_LOAD8_U_I64>; def : LoadPatOffsetOnly<i64, zext_aload_16_64, ATOMIC_LOAD16_U_I64>; def : LoadPatOffsetOnly<i64, zext_aload_32_64, ATOMIC_LOAD32_U_I64>; def : LoadPatOffsetOnly<i32, atomic_load_8, ATOMIC_LOAD8_U_I32>; def : LoadPatOffsetOnly<i32, atomic_load_16, ATOMIC_LOAD16_U_I32>; -def : LoadPatOffsetOnly<i64, anyext_aload_8_64, ATOMIC_LOAD8_U_I64>; -def : LoadPatOffsetOnly<i64, anyext_aload_16_64, ATOMIC_LOAD16_U_I64>; +def : LoadPatOffsetOnly<i64, sext_aload_8_64, ATOMIC_LOAD8_U_I64>; +def : LoadPatOffsetOnly<i64, sext_aload_16_64, ATOMIC_LOAD16_U_I64>; -def : LoadPatGlobalAddrOffOnly<i32, zext_aload_8, ATOMIC_LOAD8_U_I32>; -def : LoadPatGlobalAddrOffOnly<i32, zext_aload_16, ATOMIC_LOAD16_U_I32>; +def : LoadPatGlobalAddrOffOnly<i32, zext_aload_8_32, ATOMIC_LOAD8_U_I32>; +def : LoadPatGlobalAddrOffOnly<i32, zext_aload_16_32, ATOMIC_LOAD16_U_I32>; def : LoadPatGlobalAddrOffOnly<i64, zext_aload_8_64, ATOMIC_LOAD8_U_I64>; def : LoadPatGlobalAddrOffOnly<i64, zext_aload_16_64, ATOMIC_LOAD16_U_I64>; def : LoadPatGlobalAddrOffOnly<i64, zext_aload_32_64, ATOMIC_LOAD32_U_I64>; def : LoadPatGlobalAddrOffOnly<i32, atomic_load_8, ATOMIC_LOAD8_U_I32>; def : LoadPatGlobalAddrOffOnly<i32, atomic_load_16, ATOMIC_LOAD16_U_I32>; -def : LoadPatGlobalAddrOffOnly<i64, anyext_aload_8_64, ATOMIC_LOAD8_U_I64>; -def : LoadPatGlobalAddrOffOnly<i64, anyext_aload_16_64, ATOMIC_LOAD16_U_I64>; +def : LoadPatGlobalAddrOffOnly<i64, sext_aload_8_64, ATOMIC_LOAD8_U_I64>; +def : LoadPatGlobalAddrOffOnly<i64, sext_aload_16_64, ATOMIC_LOAD16_U_I64>; -def : LoadPatExternSymOffOnly<i32, zext_aload_8, ATOMIC_LOAD8_U_I32>; -def : LoadPatExternSymOffOnly<i32, zext_aload_16, ATOMIC_LOAD16_U_I32>; +def : LoadPatExternSymOffOnly<i32, zext_aload_8_32, ATOMIC_LOAD8_U_I32>; +def : LoadPatExternSymOffOnly<i32, zext_aload_16_32, ATOMIC_LOAD16_U_I32>; def : LoadPatExternSymOffOnly<i64, zext_aload_8_64, ATOMIC_LOAD8_U_I64>; def : LoadPatExternSymOffOnly<i64, zext_aload_16_64, ATOMIC_LOAD16_U_I64>; def : LoadPatExternSymOffOnly<i64, zext_aload_32_64, ATOMIC_LOAD32_U_I64>; def : LoadPatExternSymOffOnly<i32, atomic_load_8, ATOMIC_LOAD8_U_I32>; def : LoadPatExternSymOffOnly<i32, atomic_load_16, ATOMIC_LOAD16_U_I32>; -def : LoadPatExternSymOffOnly<i64, anyext_aload_8_64, ATOMIC_LOAD8_U_I64>; -def : LoadPatExternSymOffOnly<i64, anyext_aload_16_64, ATOMIC_LOAD16_U_I64>; - +def : LoadPatExternSymOffOnly<i64, sext_aload_8_64, ATOMIC_LOAD8_U_I64>; +def : LoadPatExternSymOffOnly<i64, sext_aload_16_64, ATOMIC_LOAD16_U_I64>; } // Predicates = [HasAtomics] @@ -209,52 +205,49 @@ defm ATOMIC_STORE_I64 : WebAssemblyStore<I64, "i64.atomic.store", 0xfe18>; let Predicates = [HasAtomics] in { // Select stores with no constant offset. -class AStorePatNoOffset<ValueType ty, PatFrag node, NI inst> : - Pat<(node I32:$addr, ty:$val), (inst 0, 0, $addr, $val)>; +class AStorePatNoOffset<ValueType ty, PatFrag kind, NI inst> : + Pat<(kind I32:$addr, ty:$val), (inst 0, 0, I32:$addr, ty:$val)>; def : AStorePatNoOffset<i32, atomic_store_32, ATOMIC_STORE_I32>; def : AStorePatNoOffset<i64, atomic_store_64, ATOMIC_STORE_I64>; // Select stores with a constant offset. // Pattern with address + immediate offset -class AStorePatImmOff<ValueType ty, PatFrag storekind, PatFrag operand, - NI inst> : - Pat<(storekind (operand I32:$addr, imm:$off), ty:$val), - (inst 0, imm:$off, $addr, ty:$val)>; +class AStorePatImmOff<ValueType ty, PatFrag kind, PatFrag operand, NI inst> : + Pat<(kind (operand I32:$addr, imm:$off), ty:$val), + (inst 0, imm:$off, I32:$addr, ty:$val)>; def : AStorePatImmOff<i32, atomic_store_32, regPlusImm, ATOMIC_STORE_I32>; def : AStorePatImmOff<i64, atomic_store_64, regPlusImm, ATOMIC_STORE_I64>; def : AStorePatImmOff<i32, atomic_store_32, or_is_add, ATOMIC_STORE_I32>; def : AStorePatImmOff<i64, atomic_store_64, or_is_add, ATOMIC_STORE_I64>; -class AStorePatGlobalAddr<ValueType ty, PatFrag storekind, NI inst> : - Pat<(storekind (regPlusGA I32:$addr, (WebAssemblywrapper tglobaladdr:$off)), - ty:$val), +class AStorePatGlobalAddr<ValueType ty, PatFrag kind, NI inst> : + Pat<(kind (regPlusGA I32:$addr, (WebAssemblywrapper tglobaladdr:$off)), + ty:$val), (inst 0, tglobaladdr:$off, I32:$addr, ty:$val)>; def : AStorePatGlobalAddr<i32, atomic_store_32, ATOMIC_STORE_I32>; def : AStorePatGlobalAddr<i64, atomic_store_64, ATOMIC_STORE_I64>; -class AStorePatExternalSym<ValueType ty, PatFrag storekind, NI inst> : - Pat<(storekind (add I32:$addr, (WebAssemblywrapper texternalsym:$off)), - ty:$val), +class AStorePatExternalSym<ValueType ty, PatFrag kind, NI inst> : + Pat<(kind (add I32:$addr, (WebAssemblywrapper texternalsym:$off)), ty:$val), (inst 0, texternalsym:$off, I32:$addr, ty:$val)>; def : AStorePatExternalSym<i32, atomic_store_32, ATOMIC_STORE_I32>; def : AStorePatExternalSym<i64, atomic_store_64, ATOMIC_STORE_I64>; // Select stores with just a constant offset. -class AStorePatOffsetOnly<ValueType ty, PatFrag storekind, NI inst> : - Pat<(storekind imm:$off, ty:$val), - (inst 0, imm:$off, (CONST_I32 0), ty:$val)>; +class AStorePatOffsetOnly<ValueType ty, PatFrag kind, NI inst> : + Pat<(kind imm:$off, ty:$val), (inst 0, imm:$off, (CONST_I32 0), ty:$val)>; def : AStorePatOffsetOnly<i32, atomic_store_32, ATOMIC_STORE_I32>; def : AStorePatOffsetOnly<i64, atomic_store_64, ATOMIC_STORE_I64>; -class AStorePatGlobalAddrOffOnly<ValueType ty, PatFrag storekind, NI inst> : - Pat<(storekind (WebAssemblywrapper tglobaladdr:$off), ty:$val), +class AStorePatGlobalAddrOffOnly<ValueType ty, PatFrag kind, NI inst> : + Pat<(kind (WebAssemblywrapper tglobaladdr:$off), ty:$val), (inst 0, tglobaladdr:$off, (CONST_I32 0), ty:$val)>; def : AStorePatGlobalAddrOffOnly<i32, atomic_store_32, ATOMIC_STORE_I32>; def : AStorePatGlobalAddrOffOnly<i64, atomic_store_64, ATOMIC_STORE_I64>; -class AStorePatExternSymOffOnly<ValueType ty, PatFrag storekind, NI inst> : - Pat<(storekind (WebAssemblywrapper texternalsym:$off), ty:$val), +class AStorePatExternSymOffOnly<ValueType ty, PatFrag kind, NI inst> : + Pat<(kind (WebAssemblywrapper texternalsym:$off), ty:$val), (inst 0, texternalsym:$off, (CONST_I32 0), ty:$val)>; def : AStorePatExternSymOffOnly<i32, atomic_store_32, ATOMIC_STORE_I32>; def : AStorePatExternSymOffOnly<i64, atomic_store_64, ATOMIC_STORE_I64>; @@ -275,9 +268,9 @@ defm ATOMIC_STORE32_I64 : WebAssemblyStore<I64, "i64.atomic.store32", 0xfe1d>; // We don't have single truncating atomic store instructions. For 32-bit // instructions, we just need to match bare atomic stores. On the other hand, // truncating stores from i64 values are once truncated to i32 first. -class trunc_astore_64<PatFrag storekind> : +class trunc_astore_64<PatFrag kind> : PatFrag<(ops node:$addr, node:$val), - (storekind node:$addr, (i32 (trunc (i64 node:$val))))>; + (kind node:$addr, (i32 (trunc (i64 node:$val))))>; def trunc_astore_8_64 : trunc_astore_64<atomic_store_8>; def trunc_astore_16_64 : trunc_astore_64<atomic_store_16>; def trunc_astore_32_64 : trunc_astore_64<atomic_store_32>; diff --git a/llvm/lib/Target/WebAssembly/WebAssemblyInstrMemory.td b/llvm/lib/Target/WebAssembly/WebAssemblyInstrMemory.td index e97e34b183d..8a49325af2b 100644 --- a/llvm/lib/Target/WebAssembly/WebAssemblyInstrMemory.td +++ b/llvm/lib/Target/WebAssembly/WebAssemblyInstrMemory.td @@ -75,8 +75,8 @@ defm LOAD_F64 : WebAssemblyLoad<F64, "f64.load", 0x2b>; } // Defs = [ARGUMENTS] // Select loads with no constant offset. -class LoadPatNoOffset<ValueType ty, PatFrag node, NI inst> : - Pat<(ty (node I32:$addr)), (inst 0, 0, $addr)>; +class LoadPatNoOffset<ValueType ty, PatFrag kind, NI inst> : + Pat<(ty (kind I32:$addr)), (inst 0, 0, I32:$addr)>; def : LoadPatNoOffset<i32, load, LOAD_I32>; def : LoadPatNoOffset<i64, load, LOAD_I64>; @@ -87,9 +87,8 @@ def : LoadPatNoOffset<f64, load, LOAD_F64>; // Select loads with a constant offset. // Pattern with address + immediate offset -class LoadPatImmOff<ValueType ty, PatFrag loadkind, PatFrag operand, NI inst> : - Pat<(ty (loadkind (operand I32:$addr, imm:$off))), - (inst 0, imm:$off, $addr)>; +class LoadPatImmOff<ValueType ty, PatFrag kind, PatFrag operand, NI inst> : + Pat<(ty (kind (operand I32:$addr, imm:$off))), (inst 0, imm:$off, I32:$addr)>; def : LoadPatImmOff<i32, load, regPlusImm, LOAD_I32>; def : LoadPatImmOff<i64, load, regPlusImm, LOAD_I64>; @@ -100,18 +99,18 @@ def : LoadPatImmOff<i64, load, or_is_add, LOAD_I64>; def : LoadPatImmOff<f32, load, or_is_add, LOAD_F32>; def : LoadPatImmOff<f64, load, or_is_add, LOAD_F64>; -class LoadPatGlobalAddr<ValueType ty, PatFrag loadkind, NI inst> : - Pat<(ty (loadkind (regPlusGA I32:$addr, (WebAssemblywrapper tglobaladdr:$off)))), - (inst 0, tglobaladdr:$off, $addr)>; +class LoadPatGlobalAddr<ValueType ty, PatFrag kind, NI inst> : + Pat<(ty (kind (regPlusGA I32:$addr, (WebAssemblywrapper tglobaladdr:$off)))), + (inst 0, tglobaladdr:$off, I32:$addr)>; def : LoadPatGlobalAddr<i32, load, LOAD_I32>; def : LoadPatGlobalAddr<i64, load, LOAD_I64>; def : LoadPatGlobalAddr<f32, load, LOAD_F32>; def : LoadPatGlobalAddr<f64, load, LOAD_F64>; -class LoadPatExternalSym<ValueType ty, PatFrag loadkind, NI inst> : - Pat<(ty (loadkind (add I32:$addr, (WebAssemblywrapper texternalsym:$off)))), - (inst 0, texternalsym:$off, $addr)>; +class LoadPatExternalSym<ValueType ty, PatFrag kind, NI inst> : + Pat<(ty (kind (add I32:$addr, (WebAssemblywrapper texternalsym:$off)))), + (inst 0, texternalsym:$off, I32:$addr)>; def : LoadPatExternalSym<i32, load, LOAD_I32>; def : LoadPatExternalSym<i64, load, LOAD_I64>; def : LoadPatExternalSym<f32, load, LOAD_F32>; @@ -119,16 +118,16 @@ def : LoadPatExternalSym<f64, load, LOAD_F64>; // Select loads with just a constant offset. -class LoadPatOffsetOnly<ValueType ty, PatFrag loadkind, NI inst> : - Pat<(ty (loadkind imm:$off)), (inst 0, imm:$off, (CONST_I32 0))>; +class LoadPatOffsetOnly<ValueType ty, PatFrag kind, NI inst> : + Pat<(ty (kind imm:$off)), (inst 0, imm:$off, (CONST_I32 0))>; def : LoadPatOffsetOnly<i32, load, LOAD_I32>; def : LoadPatOffsetOnly<i64, load, LOAD_I64>; def : LoadPatOffsetOnly<f32, load, LOAD_F32>; def : LoadPatOffsetOnly<f64, load, LOAD_F64>; -class LoadPatGlobalAddrOffOnly<ValueType ty, PatFrag loadkind, NI inst> : - Pat<(ty (loadkind (WebAssemblywrapper tglobaladdr:$off))), +class LoadPatGlobalAddrOffOnly<ValueType ty, PatFrag kind, NI inst> : + Pat<(ty (kind (WebAssemblywrapper tglobaladdr:$off))), (inst 0, tglobaladdr:$off, (CONST_I32 0))>; def : LoadPatGlobalAddrOffOnly<i32, load, LOAD_I32>; @@ -136,8 +135,8 @@ def : LoadPatGlobalAddrOffOnly<i64, load, LOAD_I64>; def : LoadPatGlobalAddrOffOnly<f32, load, LOAD_F32>; def : LoadPatGlobalAddrOffOnly<f64, load, LOAD_F64>; -class LoadPatExternSymOffOnly<ValueType ty, PatFrag loadkind, NI inst> : - Pat<(ty (loadkind (WebAssemblywrapper texternalsym:$off))), +class LoadPatExternSymOffOnly<ValueType ty, PatFrag kind, NI inst> : + Pat<(ty (kind (WebAssemblywrapper texternalsym:$off))), (inst 0, texternalsym:$off, (CONST_I32 0))>; def : LoadPatExternSymOffOnly<i32, load, LOAD_I32>; def : LoadPatExternSymOffOnly<i64, load, LOAD_I64>; @@ -326,7 +325,7 @@ defm STORE_F64 : WebAssemblyStore<F64, "f64.store", 0x39>; // Select stores with no constant offset. class StorePatNoOffset<ValueType ty, PatFrag node, NI inst> : - Pat<(node ty:$val, I32:$addr), (inst 0, 0, $addr, $val)>; + Pat<(node ty:$val, I32:$addr), (inst 0, 0, I32:$addr, ty:$val)>; def : StorePatNoOffset<i32, store, STORE_I32>; def : StorePatNoOffset<i64, store, STORE_I64>; @@ -334,9 +333,9 @@ def : StorePatNoOffset<f32, store, STORE_F32>; def : StorePatNoOffset<f64, store, STORE_F64>; // Select stores with a constant offset. -class StorePatImmOff<ValueType ty, PatFrag storekind, PatFrag operand, NI inst> : - Pat<(storekind ty:$val, (operand I32:$addr, imm:$off)), - (inst 0, imm:$off, $addr, ty:$val)>; +class StorePatImmOff<ValueType ty, PatFrag kind, PatFrag operand, NI inst> : + Pat<(kind ty:$val, (operand I32:$addr, imm:$off)), + (inst 0, imm:$off, I32:$addr, ty:$val)>; def : StorePatImmOff<i32, store, regPlusImm, STORE_I32>; def : StorePatImmOff<i64, store, regPlusImm, STORE_I64>; @@ -347,18 +346,17 @@ def : StorePatImmOff<i64, store, or_is_add, STORE_I64>; def : StorePatImmOff<f32, store, or_is_add, STORE_F32>; def : StorePatImmOff<f64, store, or_is_add, STORE_F64>; -class StorePatGlobalAddr<ValueType ty, PatFrag storekind, NI inst> : - Pat<(storekind ty:$val, (regPlusGA I32:$addr, - (WebAssemblywrapper tglobaladdr:$off))), +class StorePatGlobalAddr<ValueType ty, PatFrag kind, NI inst> : + Pat<(kind ty:$val, + (regPlusGA I32:$addr, (WebAssemblywrapper tglobaladdr:$off))), (inst 0, tglobaladdr:$off, I32:$addr, ty:$val)>; def : StorePatGlobalAddr<i32, store, STORE_I32>; def : StorePatGlobalAddr<i64, store, STORE_I64>; def : StorePatGlobalAddr<f32, store, STORE_F32>; def : StorePatGlobalAddr<f64, store, STORE_F64>; -class StorePatExternalSym<ValueType ty, PatFrag storekind, NI inst> : - Pat<(storekind ty:$val, (add I32:$addr, - (WebAssemblywrapper texternalsym:$off))), +class StorePatExternalSym<ValueType ty, PatFrag kind, NI inst> : + Pat<(kind ty:$val, (add I32:$addr, (WebAssemblywrapper texternalsym:$off))), (inst 0, texternalsym:$off, I32:$addr, ty:$val)>; def : StorePatExternalSym<i32, store, STORE_I32>; def : StorePatExternalSym<i64, store, STORE_I64>; @@ -366,24 +364,23 @@ def : StorePatExternalSym<f32, store, STORE_F32>; def : StorePatExternalSym<f64, store, STORE_F64>; // Select stores with just a constant offset. -class StorePatOffsetOnly<ValueType ty, PatFrag storekind, NI inst> : - Pat<(storekind ty:$val, imm:$off), - (inst 0, imm:$off, (CONST_I32 0), ty:$val)>; +class StorePatOffsetOnly<ValueType ty, PatFrag kind, NI inst> : + Pat<(kind ty:$val, imm:$off), (inst 0, imm:$off, (CONST_I32 0), ty:$val)>; def : StorePatOffsetOnly<i32, store, STORE_I32>; def : StorePatOffsetOnly<i64, store, STORE_I64>; def : StorePatOffsetOnly<f32, store, STORE_F32>; def : StorePatOffsetOnly<f64, store, STORE_F64>; -class StorePatGlobalAddrOffOnly<ValueType ty, PatFrag storekind, NI inst> : - Pat<(storekind ty:$val, (WebAssemblywrapper tglobaladdr:$off)), +class StorePatGlobalAddrOffOnly<ValueType ty, PatFrag kind, NI inst> : + Pat<(kind ty:$val, (WebAssemblywrapper tglobaladdr:$off)), (inst 0, tglobaladdr:$off, (CONST_I32 0), ty:$val)>; def : StorePatGlobalAddrOffOnly<i32, store, STORE_I32>; def : StorePatGlobalAddrOffOnly<i64, store, STORE_I64>; def : StorePatGlobalAddrOffOnly<f32, store, STORE_F32>; def : StorePatGlobalAddrOffOnly<f64, store, STORE_F64>; -class StorePatExternSymOffOnly<ValueType ty, PatFrag storekind, NI inst> : - Pat<(storekind ty:$val, (WebAssemblywrapper texternalsym:$off)), +class StorePatExternSymOffOnly<ValueType ty, PatFrag kind, NI inst> : + Pat<(kind ty:$val, (WebAssemblywrapper texternalsym:$off)), (inst 0, texternalsym:$off, (CONST_I32 0), ty:$val)>; def : StorePatExternSymOffOnly<i32, store, STORE_I32>; def : StorePatExternSymOffOnly<i64, store, STORE_I64>; |
