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, UseNamedOperandTable = 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)>, Requires<[IsNotPIC]>;
  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 // Select loads with just a constant offset.
 106 class LoadPatOffsetOnly<ValueType ty, PatFrag kind, NI inst> :
 107   Pat<(ty (kind imm:$off)), (inst 0, imm:$off, (CONST_I32 0))>;
 108
 109 def : LoadPatOffsetOnly<i32, load, LOAD_I32>;
 110 def : LoadPatOffsetOnly<i64, load, LOAD_I64>;
 111 def : LoadPatOffsetOnly<f32, load, LOAD_F32>;
 112 def : LoadPatOffsetOnly<f64, load, LOAD_F64>;
 113
 114 class LoadPatGlobalAddrOffOnly<ValueType ty, PatFrag kind, NI inst> :
 115   Pat<(ty (kind (WebAssemblywrapper tglobaladdr:$off))),
 116       (inst 0, tglobaladdr:$off, (CONST_I32 0))>, Requires<[IsNotPIC]>;
 117
 118 def : LoadPatGlobalAddrOffOnly<i32, load, LOAD_I32>;
 119 def : LoadPatGlobalAddrOffOnly<i64, load, LOAD_I64>;
 120 def : LoadPatGlobalAddrOffOnly<f32, load, LOAD_F32>;
 121 def : LoadPatGlobalAddrOffOnly<f64, load, LOAD_F64>;
 122
 123 // Extending load.
 124 defm LOAD8_S_I32 : WebAssemblyLoad<I32, "i32.load8_s", 0x2c>;
 125 defm LOAD8_U_I32 : WebAssemblyLoad<I32, "i32.load8_u", 0x2d>;
 126 defm LOAD16_S_I32 : WebAssemblyLoad<I32, "i32.load16_s", 0x2e>;
 127 defm LOAD16_U_I32 : WebAssemblyLoad<I32, "i32.load16_u", 0x2f>;
 128 defm LOAD8_S_I64 : WebAssemblyLoad<I64, "i64.load8_s", 0x30>;
 129 defm LOAD8_U_I64 : WebAssemblyLoad<I64, "i64.load8_u", 0x31>;
 130 defm LOAD16_S_I64 : WebAssemblyLoad<I64, "i64.load16_s", 0x32>;
 131 defm LOAD16_U_I64 : WebAssemblyLoad<I64, "i64.load16_u", 0x33>;
 132 defm LOAD32_S_I64 : WebAssemblyLoad<I64, "i64.load32_s", 0x34>;
 133 defm LOAD32_U_I64 : WebAssemblyLoad<I64, "i64.load32_u", 0x35>;
 134
 135 // Select extending loads with no constant offset.
 136 def : LoadPatNoOffset<i32, sextloadi8, LOAD8_S_I32>;
 137 def : LoadPatNoOffset<i32, zextloadi8, LOAD8_U_I32>;
 138 def : LoadPatNoOffset<i32, sextloadi16, LOAD16_S_I32>;
 139 def : LoadPatNoOffset<i32, zextloadi16, LOAD16_U_I32>;
 140 def : LoadPatNoOffset<i64, sextloadi8, LOAD8_S_I64>;
 141 def : LoadPatNoOffset<i64, zextloadi8, LOAD8_U_I64>;
 142 def : LoadPatNoOffset<i64, sextloadi16, LOAD16_S_I64>;
 143 def : LoadPatNoOffset<i64, zextloadi16, LOAD16_U_I64>;
 144 def : LoadPatNoOffset<i64, sextloadi32, LOAD32_S_I64>;
 145 def : LoadPatNoOffset<i64, zextloadi32, LOAD32_U_I64>;
 146
 147 // Select extending loads with a constant offset.
 148 def : LoadPatImmOff<i32, sextloadi8, regPlusImm, LOAD8_S_I32>;
 149 def : LoadPatImmOff<i32, zextloadi8, regPlusImm, LOAD8_U_I32>;
 150 def : LoadPatImmOff<i32, sextloadi16, regPlusImm, LOAD16_S_I32>;
 151 def : LoadPatImmOff<i32, zextloadi16, regPlusImm, LOAD16_U_I32>;
 152 def : LoadPatImmOff<i64, sextloadi8, regPlusImm, LOAD8_S_I64>;
 153 def : LoadPatImmOff<i64, zextloadi8, regPlusImm, LOAD8_U_I64>;
 154 def : LoadPatImmOff<i64, sextloadi16, regPlusImm, LOAD16_S_I64>;
 155 def : LoadPatImmOff<i64, zextloadi16, regPlusImm, LOAD16_U_I64>;
 156 def : LoadPatImmOff<i64, sextloadi32, regPlusImm, LOAD32_S_I64>;
 157 def : LoadPatImmOff<i64, zextloadi32, regPlusImm, LOAD32_U_I64>;
 158
 159 def : LoadPatImmOff<i32, sextloadi8, or_is_add, LOAD8_S_I32>;
 160 def : LoadPatImmOff<i32, zextloadi8, or_is_add, LOAD8_U_I32>;
 161 def : LoadPatImmOff<i32, sextloadi16, or_is_add, LOAD16_S_I32>;
 162 def : LoadPatImmOff<i32, zextloadi16, or_is_add, LOAD16_U_I32>;
 163 def : LoadPatImmOff<i64, sextloadi8, or_is_add, LOAD8_S_I64>;
 164 def : LoadPatImmOff<i64, zextloadi8, or_is_add, LOAD8_U_I64>;
 165 def : LoadPatImmOff<i64, sextloadi16, or_is_add, LOAD16_S_I64>;
 166 def : LoadPatImmOff<i64, zextloadi16, or_is_add, LOAD16_U_I64>;
 167 def : LoadPatImmOff<i64, sextloadi32, or_is_add, LOAD32_S_I64>;
 168 def : LoadPatImmOff<i64, zextloadi32, or_is_add, LOAD32_U_I64>;
 169
 170 def : LoadPatGlobalAddr<i32, sextloadi8, LOAD8_S_I32>;
 171 def : LoadPatGlobalAddr<i32, zextloadi8, LOAD8_U_I32>;
 172 def : LoadPatGlobalAddr<i32, sextloadi16, LOAD16_S_I32>;
 173 def : LoadPatGlobalAddr<i32, zextloadi8, LOAD16_U_I32>;
 174
 175 def : LoadPatGlobalAddr<i64, sextloadi8, LOAD8_S_I64>;
 176 def : LoadPatGlobalAddr<i64, zextloadi8, LOAD8_U_I64>;
 177 def : LoadPatGlobalAddr<i64, sextloadi16, LOAD16_S_I64>;
 178 def : LoadPatGlobalAddr<i64, zextloadi16, LOAD16_U_I64>;
 179 def : LoadPatGlobalAddr<i64, sextloadi32, LOAD32_S_I64>;
 180 def : LoadPatGlobalAddr<i64, zextloadi32, LOAD32_U_I64>;
 181
 182 // Select extending loads with just a constant offset.
 183 def : LoadPatOffsetOnly<i32, sextloadi8, LOAD8_S_I32>;
 184 def : LoadPatOffsetOnly<i32, zextloadi8, LOAD8_U_I32>;
 185 def : LoadPatOffsetOnly<i32, sextloadi16, LOAD16_S_I32>;
 186 def : LoadPatOffsetOnly<i32, zextloadi16, LOAD16_U_I32>;
 187
 188 def : LoadPatOffsetOnly<i64, sextloadi8, LOAD8_S_I64>;
 189 def : LoadPatOffsetOnly<i64, zextloadi8, LOAD8_U_I64>;
 190 def : LoadPatOffsetOnly<i64, sextloadi16, LOAD16_S_I64>;
 191 def : LoadPatOffsetOnly<i64, zextloadi16, LOAD16_U_I64>;
 192 def : LoadPatOffsetOnly<i64, sextloadi32, LOAD32_S_I64>;
 193 def : LoadPatOffsetOnly<i64, zextloadi32, LOAD32_U_I64>;
 194
 195 def : LoadPatGlobalAddrOffOnly<i32, sextloadi8, LOAD8_S_I32>;
 196 def : LoadPatGlobalAddrOffOnly<i32, zextloadi8, LOAD8_U_I32>;
 197 def : LoadPatGlobalAddrOffOnly<i32, sextloadi16, LOAD16_S_I32>;
 198 def : LoadPatGlobalAddrOffOnly<i32, zextloadi16, LOAD16_U_I32>;
 199 def : LoadPatGlobalAddrOffOnly<i64, sextloadi8, LOAD8_S_I64>;
 200 def : LoadPatGlobalAddrOffOnly<i64, zextloadi8, LOAD8_U_I64>;
 201 def : LoadPatGlobalAddrOffOnly<i64, sextloadi16, LOAD16_S_I64>;
 202 def : LoadPatGlobalAddrOffOnly<i64, zextloadi16, LOAD16_U_I64>;
 203 def : LoadPatGlobalAddrOffOnly<i64, sextloadi32, LOAD32_S_I64>;
 204 def : LoadPatGlobalAddrOffOnly<i64, zextloadi32, LOAD32_U_I64>;
 205
 206 // Resolve "don't care" extending loads to zero-extending loads. This is
 207 // somewhat arbitrary, but zero-extending is conceptually simpler.
 208
 209 // Select "don't care" extending loads with no constant offset.
 210 def : LoadPatNoOffset<i32, extloadi8, LOAD8_U_I32>;
 211 def : LoadPatNoOffset<i32, extloadi16, LOAD16_U_I32>;
 212 def : LoadPatNoOffset<i64, extloadi8, LOAD8_U_I64>;
 213 def : LoadPatNoOffset<i64, extloadi16, LOAD16_U_I64>;
 214 def : LoadPatNoOffset<i64, extloadi32, LOAD32_U_I64>;
 215
 216 // Select "don't care" extending loads with a constant offset.
 217 def : LoadPatImmOff<i32, extloadi8, regPlusImm, LOAD8_U_I32>;
 218 def : LoadPatImmOff<i32, extloadi16, regPlusImm, LOAD16_U_I32>;
 219 def : LoadPatImmOff<i64, extloadi8, regPlusImm, LOAD8_U_I64>;
 220 def : LoadPatImmOff<i64, extloadi16, regPlusImm, LOAD16_U_I64>;
 221 def : LoadPatImmOff<i64, extloadi32, regPlusImm, LOAD32_U_I64>;
 222 def : LoadPatImmOff<i32, extloadi8, or_is_add, LOAD8_U_I32>;
 223 def : LoadPatImmOff<i32, extloadi16, or_is_add, LOAD16_U_I32>;
 224 def : LoadPatImmOff<i64, extloadi8, or_is_add, LOAD8_U_I64>;
 225 def : LoadPatImmOff<i64, extloadi16, or_is_add, LOAD16_U_I64>;
 226 def : LoadPatImmOff<i64, extloadi32, or_is_add, LOAD32_U_I64>;
 227 def : LoadPatGlobalAddr<i32, extloadi8, LOAD8_U_I32>;
 228 def : LoadPatGlobalAddr<i32, extloadi16, LOAD16_U_I32>;
 229 def : LoadPatGlobalAddr<i64, extloadi8, LOAD8_U_I64>;
 230 def : LoadPatGlobalAddr<i64, extloadi16, LOAD16_U_I64>;
 231 def : LoadPatGlobalAddr<i64, extloadi32, LOAD32_U_I64>;
 232
 233 // Select "don't care" extending loads with just a constant offset.
 234 def : LoadPatOffsetOnly<i32, extloadi8, LOAD8_U_I32>;
 235 def : LoadPatOffsetOnly<i32, extloadi16, LOAD16_U_I32>;
 236 def : LoadPatOffsetOnly<i64, extloadi8, LOAD8_U_I64>;
 237 def : LoadPatOffsetOnly<i64, extloadi16, LOAD16_U_I64>;
 238 def : LoadPatOffsetOnly<i64, extloadi32, LOAD32_U_I64>;
 239 def : LoadPatGlobalAddrOffOnly<i32, extloadi8, LOAD8_U_I32>;
 240 def : LoadPatGlobalAddrOffOnly<i32, extloadi16, LOAD16_U_I32>;
 241 def : LoadPatGlobalAddrOffOnly<i64, extloadi8, LOAD8_U_I64>;
 242 def : LoadPatGlobalAddrOffOnly<i64, extloadi16, LOAD16_U_I64>;
 243 def : LoadPatGlobalAddrOffOnly<i64, extloadi32, LOAD32_U_I64>;
 244
 245 // Defines atomic and non-atomic stores, regular and truncating
 246 multiclass WebAssemblyStore<WebAssemblyRegClass rc, string Name, int Opcode> {
 247   let mayStore = 1, UseNamedOperandTable = 1 in
 248   defm "" : I<(outs),
 249               (ins P2Align:$p2align, offset32_op:$off, I32:$addr, rc:$val),
 250               (outs),
 251               (ins P2Align:$p2align, offset32_op:$off), [],
 252               !strconcat(Name, "\t${off}(${addr})${p2align}, $val"),
 253               !strconcat(Name, "\t${off}${p2align}"), Opcode>;
 254 }
 255 // Basic store.
 256 // Note: WebAssembly inverts SelectionDAG's usual operand order.
 257 defm STORE_I32  : WebAssemblyStore<I32, "i32.store", 0x36>;
 258 defm STORE_I64  : WebAssemblyStore<I64, "i64.store", 0x37>;
 259 defm STORE_F32  : WebAssemblyStore<F32, "f32.store", 0x38>;
 260 defm STORE_F64  : WebAssemblyStore<F64, "f64.store", 0x39>;
 261
 262 // Select stores with no constant offset.
 263 class StorePatNoOffset<ValueType ty, PatFrag node, NI inst> :
 264   Pat<(node ty:$val, I32:$addr), (inst 0, 0, I32:$addr, ty:$val)>;
 265
 266 def : StorePatNoOffset<i32, store, STORE_I32>;
 267 def : StorePatNoOffset<i64, store, STORE_I64>;
 268 def : StorePatNoOffset<f32, store, STORE_F32>;
 269 def : StorePatNoOffset<f64, store, STORE_F64>;
 270
 271 // Select stores with a constant offset.
 272 class StorePatImmOff<ValueType ty, PatFrag kind, PatFrag operand, NI inst> :
 273   Pat<(kind ty:$val, (operand I32:$addr, imm:$off)),
 274       (inst 0, imm:$off, I32:$addr, ty:$val)>;
 275
 276 def : StorePatImmOff<i32, store, regPlusImm, STORE_I32>;
 277 def : StorePatImmOff<i64, store, regPlusImm, STORE_I64>;
 278 def : StorePatImmOff<f32, store, regPlusImm, STORE_F32>;
 279 def : StorePatImmOff<f64, store, regPlusImm, STORE_F64>;
 280 def : StorePatImmOff<i32, store, or_is_add, STORE_I32>;
 281 def : StorePatImmOff<i64, store, or_is_add, STORE_I64>;
 282 def : StorePatImmOff<f32, store, or_is_add, STORE_F32>;
 283 def : StorePatImmOff<f64, store, or_is_add, STORE_F64>;
 284
 285 class StorePatGlobalAddr<ValueType ty, PatFrag kind, NI inst> :
 286   Pat<(kind ty:$val,
 287             (regPlusGA I32:$addr, (WebAssemblywrapper tglobaladdr:$off))),
 288       (inst 0, tglobaladdr:$off, I32:$addr, ty:$val)>, Requires<[IsNotPIC]>;
 289 def : StorePatGlobalAddr<i32, store, STORE_I32>;
 290 def : StorePatGlobalAddr<i64, store, STORE_I64>;
 291 def : StorePatGlobalAddr<f32, store, STORE_F32>;
 292 def : StorePatGlobalAddr<f64, store, STORE_F64>;
 293
 294 // Select stores with just a constant offset.
 295 class StorePatOffsetOnly<ValueType ty, PatFrag kind, NI inst> :
 296   Pat<(kind ty:$val, imm:$off), (inst 0, imm:$off, (CONST_I32 0), ty:$val)>;
 297 def : StorePatOffsetOnly<i32, store, STORE_I32>;
 298 def : StorePatOffsetOnly<i64, store, STORE_I64>;
 299 def : StorePatOffsetOnly<f32, store, STORE_F32>;
 300 def : StorePatOffsetOnly<f64, store, STORE_F64>;
 301
 302 class StorePatGlobalAddrOffOnly<ValueType ty, PatFrag kind, NI inst> :
 303   Pat<(kind ty:$val, (WebAssemblywrapper tglobaladdr:$off)),
 304       (inst 0, tglobaladdr:$off, (CONST_I32 0), ty:$val)>, Requires<[IsNotPIC]>;
 305 def : StorePatGlobalAddrOffOnly<i32, store, STORE_I32>;
 306 def : StorePatGlobalAddrOffOnly<i64, store, STORE_I64>;
 307 def : StorePatGlobalAddrOffOnly<f32, store, STORE_F32>;
 308 def : StorePatGlobalAddrOffOnly<f64, store, STORE_F64>;
 309
 310 // Truncating store.
 311 defm STORE8_I32 : WebAssemblyStore<I32, "i32.store8", 0x3a>;
 312 defm STORE16_I32 : WebAssemblyStore<I32, "i32.store16", 0x3b>;
 313 defm STORE8_I64 : WebAssemblyStore<I64, "i64.store8", 0x3c>;
 314 defm STORE16_I64 : WebAssemblyStore<I64, "i64.store16", 0x3d>;
 315 defm STORE32_I64 : WebAssemblyStore<I64, "i64.store32", 0x3e>;
 316
 317 // Select truncating stores with no constant offset.
 318 def : StorePatNoOffset<i32, truncstorei8, STORE8_I32>;
 319 def : StorePatNoOffset<i32, truncstorei16, STORE16_I32>;
 320 def : StorePatNoOffset<i64, truncstorei8, STORE8_I64>;
 321 def : StorePatNoOffset<i64, truncstorei16, STORE16_I64>;
 322 def : StorePatNoOffset<i64, truncstorei32, STORE32_I64>;
 323
 324 // Select truncating stores with a constant offset.
 325 def : StorePatImmOff<i32, truncstorei8, regPlusImm, STORE8_I32>;
 326 def : StorePatImmOff<i32, truncstorei16, regPlusImm, STORE16_I32>;
 327 def : StorePatImmOff<i64, truncstorei8, regPlusImm, STORE8_I64>;
 328 def : StorePatImmOff<i64, truncstorei16, regPlusImm, STORE16_I64>;
 329 def : StorePatImmOff<i64, truncstorei32, regPlusImm, STORE32_I64>;
 330 def : StorePatImmOff<i32, truncstorei8, or_is_add, STORE8_I32>;
 331 def : StorePatImmOff<i32, truncstorei16, or_is_add, STORE16_I32>;
 332 def : StorePatImmOff<i64, truncstorei8, or_is_add, STORE8_I64>;
 333 def : StorePatImmOff<i64, truncstorei16, or_is_add, STORE16_I64>;
 334 def : StorePatImmOff<i64, truncstorei32, or_is_add, STORE32_I64>;
 335
 336 def : StorePatGlobalAddr<i32, truncstorei8, STORE8_I32>;
 337 def : StorePatGlobalAddr<i32, truncstorei16, STORE16_I32>;
 338 def : StorePatGlobalAddr<i64, truncstorei8, STORE8_I64>;
 339 def : StorePatGlobalAddr<i64, truncstorei16, STORE16_I64>;
 340 def : StorePatGlobalAddr<i64, truncstorei32, STORE32_I64>;
 341
 342 // Select truncating stores with just a constant offset.
 343 def : StorePatOffsetOnly<i32, truncstorei8, STORE8_I32>;
 344 def : StorePatOffsetOnly<i32, truncstorei16, STORE16_I32>;
 345 def : StorePatOffsetOnly<i64, truncstorei8, STORE8_I64>;
 346 def : StorePatOffsetOnly<i64, truncstorei16, STORE16_I64>;
 347 def : StorePatOffsetOnly<i64, truncstorei32, STORE32_I64>;
 348 def : StorePatGlobalAddrOffOnly<i32, truncstorei8, STORE8_I32>;
 349 def : StorePatGlobalAddrOffOnly<i32, truncstorei16, STORE16_I32>;
 350 def : StorePatGlobalAddrOffOnly<i64, truncstorei8, STORE8_I64>;
 351 def : StorePatGlobalAddrOffOnly<i64, truncstorei16, STORE16_I64>;
 352 def : StorePatGlobalAddrOffOnly<i64, truncstorei32, STORE32_I64>;
 353
 354 // Current memory size.
 355 defm MEMORY_SIZE_I32 : I<(outs I32:$dst), (ins i32imm:$flags),
 356                          (outs), (ins i32imm:$flags),
 357                          [(set I32:$dst,
 358                            (int_wasm_memory_size (i32 imm:$flags)))],
 359                          "memory.size\t$dst, $flags", "memory.size\t$flags",
 360                          0x3f>,
 361                        Requires<[HasAddr32]>;
 362
 363 // Grow memory.
 364 defm MEMORY_GROW_I32 : I<(outs I32:$dst), (ins i32imm:$flags, I32:$delta),
 365                          (outs), (ins i32imm:$flags),
 366                          [(set I32:$dst,
 367                            (int_wasm_memory_grow (i32 imm:$flags),
 368                              I32:$delta))],
 369                          "memory.grow\t$dst, $flags, $delta",
 370                          "memory.grow\t$flags", 0x40>,
 371                        Requires<[HasAddr32]>;