lib/Target/WebAssembly/WebAssemblyInstrMemory.td

   1 // WebAssemblyInstrMemory.td-WebAssembly Memory codegen support -*- tablegen -*-
   2 //
   3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
   4 // See https://llvm.org/LICENSE.txt for license information.
   5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   6 //
   7 //===----------------------------------------------------------------------===//
   8 ///
   9 /// \file
  10 /// WebAssembly Memory operand code-gen constructs.
  11 ///
  12 //===----------------------------------------------------------------------===//
  13
  14 // TODO:
  15 //  - HasAddr64
  16 //  - WebAssemblyTargetLowering having to do with atomics
  17 //  - Each has optional alignment.
  18
  19 // WebAssembly has i8/i16/i32/i64/f32/f64 memory types, but doesn't have i8/i16
  20 // local types. These memory-only types instead zero- or sign-extend into local
  21 // types when loading, and truncate when storing.
  22
  23 // WebAssembly constant offsets are performed as unsigned with infinite
  24 // precision, so we need to check for NoUnsignedWrap so that we don't fold an
  25 // offset for an add that needs wrapping.
  26 def regPlusImm : PatFrag<(ops node:$addr, node:$off),
  27                          (add node:$addr, node:$off),
  28                          [{ return N->getFlags().hasNoUnsignedWrap(); }]>;
  29
  30 // Treat an 'or' node as an 'add' if the or'ed bits are known to be zero.
  31 def or_is_add : PatFrag<(ops node:$lhs, node:$rhs), (or node:$lhs, node:$rhs),[{
  32   if (ConstantSDNode *CN = dyn_cast<ConstantSDNode>(N->getOperand(1)))
  33     return CurDAG->MaskedValueIsZero(N->getOperand(0), CN->getAPIntValue());
  34
  35   KnownBits Known0 = CurDAG->computeKnownBits(N->getOperand(0), 0);
  36   KnownBits Known1 = CurDAG->computeKnownBits(N->getOperand(1), 0);
  37   return (~Known0.Zero & ~Known1.Zero) == 0;
  38 }]>;
  39
  40 // GlobalAddresses are conceptually unsigned values, so we can also fold them
  41 // into immediate values as long as the add is 'nuw'.
  42 // TODO: We'd like to also match GA offsets but there are cases where the
  43 // register can have a negative value. Find out what more we can do.
  44 def regPlusGA : PatFrag<(ops node:$addr, node:$off),
  45                         (add node:$addr, node:$off),
  46                         [{
  47   return N->getFlags().hasNoUnsignedWrap();
  48 }]>;
  49
  50 // We don't need a regPlusES because external symbols never have constant
  51 // offsets folded into them, so we can just use add.
  52
  53 // Defines atomic and non-atomic loads, regular and extending.
  54 multiclass WebAssemblyLoad<WebAssemblyRegClass rc, string Name, int Opcode> {
  55   let mayLoad = 1 in
  56   defm "": I<(outs rc:$dst),
  57              (ins P2Align:$p2align, offset32_op:$off, I32:$addr),
  58              (outs), (ins P2Align:$p2align, offset32_op:$off),
  59              [], !strconcat(Name, "\t$dst, ${off}(${addr})${p2align}"),
  60              !strconcat(Name, "\t${off}${p2align}"), Opcode>;
  61 }
  62
  63 // Basic load.
  64 // FIXME: When we can break syntax compatibility, reorder the fields in the
  65 // asmstrings to match the binary encoding.
  66 defm LOAD_I32 : WebAssemblyLoad<I32, "i32.load", 0x28>;
  67 defm LOAD_I64 : WebAssemblyLoad<I64, "i64.load", 0x29>;
  68 defm LOAD_F32 : WebAssemblyLoad<F32, "f32.load", 0x2a>;
  69 defm LOAD_F64 : WebAssemblyLoad<F64, "f64.load", 0x2b>;
  70
  71 // Select loads with no constant offset.
  72 class LoadPatNoOffset<ValueType ty, PatFrag kind, NI inst> :
  73   Pat<(ty (kind I32:$addr)), (inst 0, 0, I32:$addr)>;
  74
  75 def : LoadPatNoOffset<i32, load, LOAD_I32>;
  76 def : LoadPatNoOffset<i64, load, LOAD_I64>;
  77 def : LoadPatNoOffset<f32, load, LOAD_F32>;
  78 def : LoadPatNoOffset<f64, load, LOAD_F64>;
  79
  80
  81 // Select loads with a constant offset.
  82
  83 // Pattern with address + immediate offset
  84 class LoadPatImmOff<ValueType ty, PatFrag kind, PatFrag operand, NI inst> :
  85   Pat<(ty (kind (operand I32:$addr, imm:$off))), (inst 0, imm:$off, I32:$addr)>;
  86
  87 def : LoadPatImmOff<i32, load, regPlusImm, LOAD_I32>;
  88 def : LoadPatImmOff<i64, load, regPlusImm, LOAD_I64>;
  89 def : LoadPatImmOff<f32, load, regPlusImm, LOAD_F32>;
  90 def : LoadPatImmOff<f64, load, regPlusImm, LOAD_F64>;
  91 def : LoadPatImmOff<i32, load, or_is_add, LOAD_I32>;
  92 def : LoadPatImmOff<i64, load, or_is_add, LOAD_I64>;
  93 def : LoadPatImmOff<f32, load, or_is_add, LOAD_F32>;
  94 def : LoadPatImmOff<f64, load, or_is_add, LOAD_F64>;
  95
  96 class LoadPatGlobalAddr<ValueType ty, PatFrag kind, NI inst> :
  97   Pat<(ty (kind (regPlusGA I32:$addr, (WebAssemblywrapper tglobaladdr:$off)))),
  98       (inst 0, tglobaladdr:$off, I32:$addr)>;
  99
 100 def : LoadPatGlobalAddr<i32, load, LOAD_I32>;
 101 def : LoadPatGlobalAddr<i64, load, LOAD_I64>;
 102 def : LoadPatGlobalAddr<f32, load, LOAD_F32>;
 103 def : LoadPatGlobalAddr<f64, load, LOAD_F64>;
 104
 105 class LoadPatExternalSym<ValueType ty, PatFrag kind, NI inst> :
 106   Pat<(ty (kind (add I32:$addr, (WebAssemblywrapper texternalsym:$off)))),
 107       (inst 0, texternalsym:$off, I32:$addr)>;
 108 def : LoadPatExternalSym<i32, load, LOAD_I32>;
 109 def : LoadPatExternalSym<i64, load, LOAD_I64>;
 110 def : LoadPatExternalSym<f32, load, LOAD_F32>;
 111 def : LoadPatExternalSym<f64, load, LOAD_F64>;
 112
 113
 114 // Select loads with just a constant offset.
 115 class LoadPatOffsetOnly<ValueType ty, PatFrag kind, NI inst> :
 116   Pat<(ty (kind imm:$off)), (inst 0, imm:$off, (CONST_I32 0))>;
 117
 118 def : LoadPatOffsetOnly<i32, load, LOAD_I32>;
 119 def : LoadPatOffsetOnly<i64, load, LOAD_I64>;
 120 def : LoadPatOffsetOnly<f32, load, LOAD_F32>;
 121 def : LoadPatOffsetOnly<f64, load, LOAD_F64>;
 122
 123 class LoadPatGlobalAddrOffOnly<ValueType ty, PatFrag kind, NI inst> :
 124   Pat<(ty (kind (WebAssemblywrapper tglobaladdr:$off))),
 125       (inst 0, tglobaladdr:$off, (CONST_I32 0))>;
 126
 127 def : LoadPatGlobalAddrOffOnly<i32, load, LOAD_I32>;
 128 def : LoadPatGlobalAddrOffOnly<i64, load, LOAD_I64>;
 129 def : LoadPatGlobalAddrOffOnly<f32, load, LOAD_F32>;
 130 def : LoadPatGlobalAddrOffOnly<f64, load, LOAD_F64>;
 131
 132 class LoadPatExternSymOffOnly<ValueType ty, PatFrag kind, NI inst> :
 133   Pat<(ty (kind (WebAssemblywrapper texternalsym:$off))),
 134       (inst 0, texternalsym:$off, (CONST_I32 0))>;
 135 def : LoadPatExternSymOffOnly<i32, load, LOAD_I32>;
 136 def : LoadPatExternSymOffOnly<i64, load, LOAD_I64>;
 137 def : LoadPatExternSymOffOnly<f32, load, LOAD_F32>;
 138 def : LoadPatExternSymOffOnly<f64, load, LOAD_F64>;
 139
 140 // Extending load.
 141 defm LOAD8_S_I32 : WebAssemblyLoad<I32, "i32.load8_s", 0x2c>;
 142 defm LOAD8_U_I32 : WebAssemblyLoad<I32, "i32.load8_u", 0x2d>;
 143 defm LOAD16_S_I32 : WebAssemblyLoad<I32, "i32.load16_s", 0x2e>;
 144 defm LOAD16_U_I32 : WebAssemblyLoad<I32, "i32.load16_u", 0x2f>;
 145 defm LOAD8_S_I64 : WebAssemblyLoad<I64, "i64.load8_s", 0x30>;
 146 defm LOAD8_U_I64 : WebAssemblyLoad<I64, "i64.load8_u", 0x31>;
 147 defm LOAD16_S_I64 : WebAssemblyLoad<I64, "i64.load16_s", 0x32>;
 148 defm LOAD16_U_I64 : WebAssemblyLoad<I64, "i64.load16_u", 0x33>;
 149 defm LOAD32_S_I64 : WebAssemblyLoad<I64, "i64.load32_s", 0x34>;
 150 defm LOAD32_U_I64 : WebAssemblyLoad<I64, "i64.load32_u", 0x35>;
 151
 152 // Select extending loads with no constant offset.
 153 def : LoadPatNoOffset<i32, sextloadi8, LOAD8_S_I32>;
 154 def : LoadPatNoOffset<i32, zextloadi8, LOAD8_U_I32>;
 155 def : LoadPatNoOffset<i32, sextloadi16, LOAD16_S_I32>;
 156 def : LoadPatNoOffset<i32, zextloadi16, LOAD16_U_I32>;
 157 def : LoadPatNoOffset<i64, sextloadi8, LOAD8_S_I64>;
 158 def : LoadPatNoOffset<i64, zextloadi8, LOAD8_U_I64>;
 159 def : LoadPatNoOffset<i64, sextloadi16, LOAD16_S_I64>;
 160 def : LoadPatNoOffset<i64, zextloadi16, LOAD16_U_I64>;
 161 def : LoadPatNoOffset<i64, sextloadi32, LOAD32_S_I64>;
 162 def : LoadPatNoOffset<i64, zextloadi32, LOAD32_U_I64>;
 163
 164 // Select extending loads with a constant offset.
 165 def : LoadPatImmOff<i32, sextloadi8, regPlusImm, LOAD8_S_I32>;
 166 def : LoadPatImmOff<i32, zextloadi8, regPlusImm, LOAD8_U_I32>;
 167 def : LoadPatImmOff<i32, sextloadi16, regPlusImm, LOAD16_S_I32>;
 168 def : LoadPatImmOff<i32, zextloadi16, regPlusImm, LOAD16_U_I32>;
 169 def : LoadPatImmOff<i64, sextloadi8, regPlusImm, LOAD8_S_I64>;
 170 def : LoadPatImmOff<i64, zextloadi8, regPlusImm, LOAD8_U_I64>;
 171 def : LoadPatImmOff<i64, sextloadi16, regPlusImm, LOAD16_S_I64>;
 172 def : LoadPatImmOff<i64, zextloadi16, regPlusImm, LOAD16_U_I64>;
 173 def : LoadPatImmOff<i64, sextloadi32, regPlusImm, LOAD32_S_I64>;
 174 def : LoadPatImmOff<i64, zextloadi32, regPlusImm, LOAD32_U_I64>;
 175
 176 def : LoadPatImmOff<i32, sextloadi8, or_is_add, LOAD8_S_I32>;
 177 def : LoadPatImmOff<i32, zextloadi8, or_is_add, LOAD8_U_I32>;
 178 def : LoadPatImmOff<i32, sextloadi16, or_is_add, LOAD16_S_I32>;
 179 def : LoadPatImmOff<i32, zextloadi16, or_is_add, LOAD16_U_I32>;
 180 def : LoadPatImmOff<i64, sextloadi8, or_is_add, LOAD8_S_I64>;
 181 def : LoadPatImmOff<i64, zextloadi8, or_is_add, LOAD8_U_I64>;
 182 def : LoadPatImmOff<i64, sextloadi16, or_is_add, LOAD16_S_I64>;
 183 def : LoadPatImmOff<i64, zextloadi16, or_is_add, LOAD16_U_I64>;
 184 def : LoadPatImmOff<i64, sextloadi32, or_is_add, LOAD32_S_I64>;
 185 def : LoadPatImmOff<i64, zextloadi32, or_is_add, LOAD32_U_I64>;
 186
 187 def : LoadPatGlobalAddr<i32, sextloadi8, LOAD8_S_I32>;
 188 def : LoadPatGlobalAddr<i32, zextloadi8, LOAD8_U_I32>;
 189 def : LoadPatGlobalAddr<i32, sextloadi16, LOAD16_S_I32>;
 190 def : LoadPatGlobalAddr<i32, zextloadi8, LOAD16_U_I32>;
 191
 192 def : LoadPatGlobalAddr<i64, sextloadi8, LOAD8_S_I64>;
 193 def : LoadPatGlobalAddr<i64, zextloadi8, LOAD8_U_I64>;
 194 def : LoadPatGlobalAddr<i64, sextloadi16, LOAD16_S_I64>;
 195 def : LoadPatGlobalAddr<i64, zextloadi16, LOAD16_U_I64>;
 196 def : LoadPatGlobalAddr<i64, sextloadi32, LOAD32_S_I64>;
 197 def : LoadPatGlobalAddr<i64, zextloadi32, LOAD32_U_I64>;
 198
 199 def : LoadPatExternalSym<i32, sextloadi8, LOAD8_S_I32>;
 200 def : LoadPatExternalSym<i32, zextloadi8, LOAD8_U_I32>;
 201 def : LoadPatExternalSym<i32, sextloadi16, LOAD16_S_I32>;
 202 def : LoadPatExternalSym<i32, zextloadi16, LOAD16_U_I32>;
 203 def : LoadPatExternalSym<i64, sextloadi8, LOAD8_S_I64>;
 204 def : LoadPatExternalSym<i64, zextloadi8, LOAD8_U_I64>;
 205 def : LoadPatExternalSym<i64, sextloadi16, LOAD16_S_I64>;
 206 def : LoadPatExternalSym<i64, zextloadi16, LOAD16_U_I64>;
 207 def : LoadPatExternalSym<i64, sextloadi32, LOAD32_S_I64>;
 208 def : LoadPatExternalSym<i64, zextloadi32, LOAD32_U_I64>;
 209
 210
 211 // Select extending loads with just a constant offset.
 212 def : LoadPatOffsetOnly<i32, sextloadi8, LOAD8_S_I32>;
 213 def : LoadPatOffsetOnly<i32, zextloadi8, LOAD8_U_I32>;
 214 def : LoadPatOffsetOnly<i32, sextloadi16, LOAD16_S_I32>;
 215 def : LoadPatOffsetOnly<i32, zextloadi16, LOAD16_U_I32>;
 216
 217 def : LoadPatOffsetOnly<i64, sextloadi8, LOAD8_S_I64>;
 218 def : LoadPatOffsetOnly<i64, zextloadi8, LOAD8_U_I64>;
 219 def : LoadPatOffsetOnly<i64, sextloadi16, LOAD16_S_I64>;
 220 def : LoadPatOffsetOnly<i64, zextloadi16, LOAD16_U_I64>;
 221 def : LoadPatOffsetOnly<i64, sextloadi32, LOAD32_S_I64>;
 222 def : LoadPatOffsetOnly<i64, zextloadi32, LOAD32_U_I64>;
 223
 224 def : LoadPatGlobalAddrOffOnly<i32, sextloadi8, LOAD8_S_I32>;
 225 def : LoadPatGlobalAddrOffOnly<i32, zextloadi8, LOAD8_U_I32>;
 226 def : LoadPatGlobalAddrOffOnly<i32, sextloadi16, LOAD16_S_I32>;
 227 def : LoadPatGlobalAddrOffOnly<i32, zextloadi16, LOAD16_U_I32>;
 228 def : LoadPatGlobalAddrOffOnly<i64, sextloadi8, LOAD8_S_I64>;
 229 def : LoadPatGlobalAddrOffOnly<i64, zextloadi8, LOAD8_U_I64>;
 230 def : LoadPatGlobalAddrOffOnly<i64, sextloadi16, LOAD16_S_I64>;
 231 def : LoadPatGlobalAddrOffOnly<i64, zextloadi16, LOAD16_U_I64>;
 232 def : LoadPatGlobalAddrOffOnly<i64, sextloadi32, LOAD32_S_I64>;
 233 def : LoadPatGlobalAddrOffOnly<i64, zextloadi32, LOAD32_U_I64>;
 234
 235 def : LoadPatExternSymOffOnly<i32, sextloadi8, LOAD8_S_I32>;
 236 def : LoadPatExternSymOffOnly<i32, zextloadi8, LOAD8_U_I32>;
 237 def : LoadPatExternSymOffOnly<i32, sextloadi16, LOAD16_S_I32>;
 238 def : LoadPatExternSymOffOnly<i32, zextloadi16, LOAD16_U_I32>;
 239 def : LoadPatExternSymOffOnly<i64, sextloadi8, LOAD8_S_I64>;
 240 def : LoadPatExternSymOffOnly<i64, zextloadi8, LOAD8_U_I64>;
 241 def : LoadPatExternSymOffOnly<i64, sextloadi16, LOAD16_S_I64>;
 242 def : LoadPatExternSymOffOnly<i64, zextloadi16, LOAD16_U_I64>;
 243 def : LoadPatExternSymOffOnly<i64, sextloadi32, LOAD32_S_I64>;
 244 def : LoadPatExternSymOffOnly<i64, zextloadi32, LOAD32_U_I64>;
 245
 246 // Resolve "don't care" extending loads to zero-extending loads. This is
 247 // somewhat arbitrary, but zero-extending is conceptually simpler.
 248
 249 // Select "don't care" extending loads with no constant offset.
 250 def : LoadPatNoOffset<i32, extloadi8, LOAD8_U_I32>;
 251 def : LoadPatNoOffset<i32, extloadi16, LOAD16_U_I32>;
 252 def : LoadPatNoOffset<i64, extloadi8, LOAD8_U_I64>;
 253 def : LoadPatNoOffset<i64, extloadi16, LOAD16_U_I64>;
 254 def : LoadPatNoOffset<i64, extloadi32, LOAD32_U_I64>;
 255
 256 // Select "don't care" extending loads with a constant offset.
 257 def : LoadPatImmOff<i32, extloadi8, regPlusImm, LOAD8_U_I32>;
 258 def : LoadPatImmOff<i32, extloadi16, regPlusImm, LOAD16_U_I32>;
 259 def : LoadPatImmOff<i64, extloadi8, regPlusImm, LOAD8_U_I64>;
 260 def : LoadPatImmOff<i64, extloadi16, regPlusImm, LOAD16_U_I64>;
 261 def : LoadPatImmOff<i64, extloadi32, regPlusImm, LOAD32_U_I64>;
 262 def : LoadPatImmOff<i32, extloadi8, or_is_add, LOAD8_U_I32>;
 263 def : LoadPatImmOff<i32, extloadi16, or_is_add, LOAD16_U_I32>;
 264 def : LoadPatImmOff<i64, extloadi8, or_is_add, LOAD8_U_I64>;
 265 def : LoadPatImmOff<i64, extloadi16, or_is_add, LOAD16_U_I64>;
 266 def : LoadPatImmOff<i64, extloadi32, or_is_add, LOAD32_U_I64>;
 267 def : LoadPatGlobalAddr<i32, extloadi8, LOAD8_U_I32>;
 268 def : LoadPatGlobalAddr<i32, extloadi16, LOAD16_U_I32>;
 269 def : LoadPatGlobalAddr<i64, extloadi8, LOAD8_U_I64>;
 270 def : LoadPatGlobalAddr<i64, extloadi16, LOAD16_U_I64>;
 271 def : LoadPatGlobalAddr<i64, extloadi32, LOAD32_U_I64>;
 272 def : LoadPatExternalSym<i32, extloadi8, LOAD8_U_I32>;
 273 def : LoadPatExternalSym<i32, extloadi16, LOAD16_U_I32>;
 274 def : LoadPatExternalSym<i64, extloadi8, LOAD8_U_I64>;
 275 def : LoadPatExternalSym<i64, extloadi16, LOAD16_U_I64>;
 276 def : LoadPatExternalSym<i64, extloadi32, LOAD32_U_I64>;
 277
 278 // Select "don't care" extending loads with just a constant offset.
 279 def : LoadPatOffsetOnly<i32, extloadi8, LOAD8_U_I32>;
 280 def : LoadPatOffsetOnly<i32, extloadi16, LOAD16_U_I32>;
 281 def : LoadPatOffsetOnly<i64, extloadi8, LOAD8_U_I64>;
 282 def : LoadPatOffsetOnly<i64, extloadi16, LOAD16_U_I64>;
 283 def : LoadPatOffsetOnly<i64, extloadi32, LOAD32_U_I64>;
 284 def : LoadPatGlobalAddrOffOnly<i32, extloadi8, LOAD8_U_I32>;
 285 def : LoadPatGlobalAddrOffOnly<i32, extloadi16, LOAD16_U_I32>;
 286 def : LoadPatGlobalAddrOffOnly<i64, extloadi8, LOAD8_U_I64>;
 287 def : LoadPatGlobalAddrOffOnly<i64, extloadi16, LOAD16_U_I64>;
 288 def : LoadPatGlobalAddrOffOnly<i64, extloadi32, LOAD32_U_I64>;
 289 def : LoadPatExternSymOffOnly<i32, extloadi8, LOAD8_U_I32>;
 290 def : LoadPatExternSymOffOnly<i32, extloadi16, LOAD16_U_I32>;
 291 def : LoadPatExternSymOffOnly<i64, extloadi8, LOAD8_U_I64>;
 292 def : LoadPatExternSymOffOnly<i64, extloadi16, LOAD16_U_I64>;
 293 def : LoadPatExternSymOffOnly<i64, extloadi32, LOAD32_U_I64>;
 294
 295 // Defines atomic and non-atomic stores, regular and truncating
 296 multiclass WebAssemblyStore<WebAssemblyRegClass rc, string Name, int Opcode> {
 297   let mayStore = 1 in
 298   defm "" : I<(outs),
 299               (ins P2Align:$p2align, offset32_op:$off, I32:$addr, rc:$val),
 300               (outs),
 301               (ins P2Align:$p2align, offset32_op:$off), [],
 302               !strconcat(Name, "\t${off}(${addr})${p2align}, $val"),
 303               !strconcat(Name, "\t${off}${p2align}"), Opcode>;
 304 }
 305 // Basic store.
 306 // Note: WebAssembly inverts SelectionDAG's usual operand order.
 307 defm STORE_I32  : WebAssemblyStore<I32, "i32.store", 0x36>;
 308 defm STORE_I64  : WebAssemblyStore<I64, "i64.store", 0x37>;
 309 defm STORE_F32  : WebAssemblyStore<F32, "f32.store", 0x38>;
 310 defm STORE_F64  : WebAssemblyStore<F64, "f64.store", 0x39>;
 311
 312 // Select stores with no constant offset.
 313 class StorePatNoOffset<ValueType ty, PatFrag node, NI inst> :
 314   Pat<(node ty:$val, I32:$addr), (inst 0, 0, I32:$addr, ty:$val)>;
 315
 316 def : StorePatNoOffset<i32, store, STORE_I32>;
 317 def : StorePatNoOffset<i64, store, STORE_I64>;
 318 def : StorePatNoOffset<f32, store, STORE_F32>;
 319 def : StorePatNoOffset<f64, store, STORE_F64>;
 320
 321 // Select stores with a constant offset.
 322 class StorePatImmOff<ValueType ty, PatFrag kind, PatFrag operand, NI inst> :
 323   Pat<(kind ty:$val, (operand I32:$addr, imm:$off)),
 324       (inst 0, imm:$off, I32:$addr, ty:$val)>;
 325
 326 def : StorePatImmOff<i32, store, regPlusImm, STORE_I32>;
 327 def : StorePatImmOff<i64, store, regPlusImm, STORE_I64>;
 328 def : StorePatImmOff<f32, store, regPlusImm, STORE_F32>;
 329 def : StorePatImmOff<f64, store, regPlusImm, STORE_F64>;
 330 def : StorePatImmOff<i32, store, or_is_add, STORE_I32>;
 331 def : StorePatImmOff<i64, store, or_is_add, STORE_I64>;
 332 def : StorePatImmOff<f32, store, or_is_add, STORE_F32>;
 333 def : StorePatImmOff<f64, store, or_is_add, STORE_F64>;
 334
 335 class StorePatGlobalAddr<ValueType ty, PatFrag kind, NI inst> :
 336   Pat<(kind ty:$val,
 337             (regPlusGA I32:$addr, (WebAssemblywrapper tglobaladdr:$off))),
 338       (inst 0, tglobaladdr:$off, I32:$addr, ty:$val)>;
 339 def : StorePatGlobalAddr<i32, store, STORE_I32>;
 340 def : StorePatGlobalAddr<i64, store, STORE_I64>;
 341 def : StorePatGlobalAddr<f32, store, STORE_F32>;
 342 def : StorePatGlobalAddr<f64, store, STORE_F64>;
 343
 344 class StorePatExternalSym<ValueType ty, PatFrag kind, NI inst> :
 345   Pat<(kind ty:$val, (add I32:$addr, (WebAssemblywrapper texternalsym:$off))),
 346       (inst 0, texternalsym:$off, I32:$addr, ty:$val)>;
 347 def : StorePatExternalSym<i32, store, STORE_I32>;
 348 def : StorePatExternalSym<i64, store, STORE_I64>;
 349 def : StorePatExternalSym<f32, store, STORE_F32>;
 350 def : StorePatExternalSym<f64, store, STORE_F64>;
 351
 352 // Select stores with just a constant offset.
 353 class StorePatOffsetOnly<ValueType ty, PatFrag kind, NI inst> :
 354   Pat<(kind ty:$val, imm:$off), (inst 0, imm:$off, (CONST_I32 0), ty:$val)>;
 355 def : StorePatOffsetOnly<i32, store, STORE_I32>;
 356 def : StorePatOffsetOnly<i64, store, STORE_I64>;
 357 def : StorePatOffsetOnly<f32, store, STORE_F32>;
 358 def : StorePatOffsetOnly<f64, store, STORE_F64>;
 359
 360 class StorePatGlobalAddrOffOnly<ValueType ty, PatFrag kind, NI inst> :
 361   Pat<(kind ty:$val, (WebAssemblywrapper tglobaladdr:$off)),
 362       (inst 0, tglobaladdr:$off, (CONST_I32 0), ty:$val)>;
 363 def : StorePatGlobalAddrOffOnly<i32, store, STORE_I32>;
 364 def : StorePatGlobalAddrOffOnly<i64, store, STORE_I64>;
 365 def : StorePatGlobalAddrOffOnly<f32, store, STORE_F32>;
 366 def : StorePatGlobalAddrOffOnly<f64, store, STORE_F64>;
 367
 368 class StorePatExternSymOffOnly<ValueType ty, PatFrag kind, NI inst> :
 369   Pat<(kind ty:$val, (WebAssemblywrapper texternalsym:$off)),
 370       (inst 0, texternalsym:$off, (CONST_I32 0), ty:$val)>;
 371 def : StorePatExternSymOffOnly<i32, store, STORE_I32>;
 372 def : StorePatExternSymOffOnly<i64, store, STORE_I64>;
 373 def : StorePatExternSymOffOnly<f32, store, STORE_F32>;
 374 def : StorePatExternSymOffOnly<f64, store, STORE_F64>;
 375
 376 // Truncating store.
 377 defm STORE8_I32 : WebAssemblyStore<I32, "i32.store8", 0x3a>;
 378 defm STORE16_I32 : WebAssemblyStore<I32, "i32.store16", 0x3b>;
 379 defm STORE8_I64 : WebAssemblyStore<I64, "i64.store8", 0x3c>;
 380 defm STORE16_I64 : WebAssemblyStore<I64, "i64.store16", 0x3d>;
 381 defm STORE32_I64 : WebAssemblyStore<I64, "i64.store32", 0x3e>;
 382
 383 // Select truncating stores with no constant offset.
 384 def : StorePatNoOffset<i32, truncstorei8, STORE8_I32>;
 385 def : StorePatNoOffset<i32, truncstorei16, STORE16_I32>;
 386 def : StorePatNoOffset<i64, truncstorei8, STORE8_I64>;
 387 def : StorePatNoOffset<i64, truncstorei16, STORE16_I64>;
 388 def : StorePatNoOffset<i64, truncstorei32, STORE32_I64>;
 389
 390 // Select truncating stores with a constant offset.
 391 def : StorePatImmOff<i32, truncstorei8, regPlusImm, STORE8_I32>;
 392 def : StorePatImmOff<i32, truncstorei16, regPlusImm, STORE16_I32>;
 393 def : StorePatImmOff<i64, truncstorei8, regPlusImm, STORE8_I64>;
 394 def : StorePatImmOff<i64, truncstorei16, regPlusImm, STORE16_I64>;
 395 def : StorePatImmOff<i64, truncstorei32, regPlusImm, STORE32_I64>;
 396 def : StorePatImmOff<i32, truncstorei8, or_is_add, STORE8_I32>;
 397 def : StorePatImmOff<i32, truncstorei16, or_is_add, STORE16_I32>;
 398 def : StorePatImmOff<i64, truncstorei8, or_is_add, STORE8_I64>;
 399 def : StorePatImmOff<i64, truncstorei16, or_is_add, STORE16_I64>;
 400 def : StorePatImmOff<i64, truncstorei32, or_is_add, STORE32_I64>;
 401
 402 def : StorePatGlobalAddr<i32, truncstorei8, STORE8_I32>;
 403 def : StorePatGlobalAddr<i32, truncstorei16, STORE16_I32>;
 404 def : StorePatGlobalAddr<i64, truncstorei8, STORE8_I64>;
 405 def : StorePatGlobalAddr<i64, truncstorei16, STORE16_I64>;
 406 def : StorePatGlobalAddr<i64, truncstorei32, STORE32_I64>;
 407 def : StorePatExternalSym<i32, truncstorei8, STORE8_I32>;
 408 def : StorePatExternalSym<i32, truncstorei16, STORE16_I32>;
 409 def : StorePatExternalSym<i64, truncstorei8, STORE8_I64>;
 410 def : StorePatExternalSym<i64, truncstorei16, STORE16_I64>;
 411 def : StorePatExternalSym<i64, truncstorei32, STORE32_I64>;
 412
 413 // Select truncating stores with just a constant offset.
 414 def : StorePatOffsetOnly<i32, truncstorei8, STORE8_I32>;
 415 def : StorePatOffsetOnly<i32, truncstorei16, STORE16_I32>;
 416 def : StorePatOffsetOnly<i64, truncstorei8, STORE8_I64>;
 417 def : StorePatOffsetOnly<i64, truncstorei16, STORE16_I64>;
 418 def : StorePatOffsetOnly<i64, truncstorei32, STORE32_I64>;
 419 def : StorePatGlobalAddrOffOnly<i32, truncstorei8, STORE8_I32>;
 420 def : StorePatGlobalAddrOffOnly<i32, truncstorei16, STORE16_I32>;
 421 def : StorePatGlobalAddrOffOnly<i64, truncstorei8, STORE8_I64>;
 422 def : StorePatGlobalAddrOffOnly<i64, truncstorei16, STORE16_I64>;
 423 def : StorePatGlobalAddrOffOnly<i64, truncstorei32, STORE32_I64>;
 424 def : StorePatExternSymOffOnly<i32, truncstorei8, STORE8_I32>;
 425 def : StorePatExternSymOffOnly<i32, truncstorei16, STORE16_I32>;
 426 def : StorePatExternSymOffOnly<i64, truncstorei8, STORE8_I64>;
 427 def : StorePatExternSymOffOnly<i64, truncstorei16, STORE16_I64>;
 428 def : StorePatExternSymOffOnly<i64, truncstorei32, STORE32_I64>;
 429
 430 // Current memory size.
 431 defm MEMORY_SIZE_I32 : I<(outs I32:$dst), (ins i32imm:$flags),
 432                          (outs), (ins i32imm:$flags),
 433                          [(set I32:$dst,
 434                            (int_wasm_memory_size (i32 imm:$flags)))],
 435                          "memory.size\t$dst, $flags", "memory.size\t$flags",
 436                          0x3f>,
 437                        Requires<[HasAddr32]>;
 438
 439 // Grow memory.
 440 defm MEMORY_GROW_I32 : I<(outs I32:$dst), (ins i32imm:$flags, I32:$delta),
 441                          (outs), (ins i32imm:$flags),
 442                          [(set I32:$dst,
 443                            (int_wasm_memory_grow (i32 imm:$flags),
 444                              I32:$delta))],
 445                          "memory.grow\t$dst, $flags, $delta",
 446                          "memory.grow\t$flags", 0x40>,
 447                        Requires<[HasAddr32]>;