lib/Target/WebAssembly/WebAssemblyInstrAtomics.td

   1 // WebAssemblyInstrAtomics.td-WebAssembly Atomic 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 Atomic operand code-gen constructs.
  11 ///
  12 //===----------------------------------------------------------------------===//
  13
  14 let UseNamedOperandTable = 1 in
  15 multiclass ATOMIC_I<dag oops_r, dag iops_r, dag oops_s, dag iops_s,
  16                     list<dag> pattern_r, string asmstr_r = "",
  17                     string asmstr_s = "", bits<32> atomic_op = -1> {
  18   defm "" : I<oops_r, iops_r, oops_s, iops_s, pattern_r, asmstr_r, asmstr_s,
  19               !or(0xfe00, !and(0xff, atomic_op))>,
  20             Requires<[HasAtomics]>;
  21 }
  22
  23 multiclass ATOMIC_NRI<dag oops, dag iops, list<dag> pattern, string asmstr = "",
  24                       bits<32> atomic_op = -1> {
  25   defm "" : NRI<oops, iops, pattern, asmstr,
  26                 !or(0xfe00, !and(0xff, atomic_op))>,
  27             Requires<[HasAtomics]>;
  28 }
  29
  30 //===----------------------------------------------------------------------===//
  31 // Atomic wait / notify
  32 //===----------------------------------------------------------------------===//
  33
  34 let hasSideEffects = 1 in {
  35 defm ATOMIC_NOTIFY :
  36   ATOMIC_I<(outs I32:$dst),
  37            (ins P2Align:$p2align, offset32_op:$off, I32:$addr, I32:$count),
  38            (outs), (ins P2Align:$p2align, offset32_op:$off), [],
  39            "atomic.notify \t$dst, ${off}(${addr})${p2align}, $count",
  40            "atomic.notify \t${off}${p2align}", 0x00>;
  41 let mayLoad = 1 in {
  42 defm ATOMIC_WAIT_I32 :
  43   ATOMIC_I<(outs I32:$dst),
  44            (ins P2Align:$p2align, offset32_op:$off, I32:$addr, I32:$exp,
  45                 I64:$timeout),
  46            (outs), (ins P2Align:$p2align, offset32_op:$off), [],
  47            "i32.atomic.wait \t$dst, ${off}(${addr})${p2align}, $exp, $timeout",
  48            "i32.atomic.wait \t${off}${p2align}", 0x01>;
  49 defm ATOMIC_WAIT_I64 :
  50   ATOMIC_I<(outs I32:$dst),
  51            (ins P2Align:$p2align, offset32_op:$off, I32:$addr, I64:$exp,
  52                 I64:$timeout),
  53            (outs), (ins P2Align:$p2align, offset32_op:$off), [],
  54            "i64.atomic.wait \t$dst, ${off}(${addr})${p2align}, $exp, $timeout",
  55            "i64.atomic.wait \t${off}${p2align}", 0x02>;
  56 } // mayLoad = 1
  57 } // hasSideEffects = 1
  58
  59 let Predicates = [HasAtomics] in {
  60 // Select notifys with no constant offset.
  61 def NotifyPatNoOffset :
  62   Pat<(i32 (int_wasm_atomic_notify I32:$addr, I32:$count)),
  63       (ATOMIC_NOTIFY 0, 0, I32:$addr, I32:$count)>;
  64
  65 // Select notifys with a constant offset.
  66
  67 // Pattern with address + immediate offset
  68 class NotifyPatImmOff<PatFrag operand> :
  69   Pat<(i32 (int_wasm_atomic_notify (operand I32:$addr, imm:$off), I32:$count)),
  70       (ATOMIC_NOTIFY 0, imm:$off, I32:$addr, I32:$count)>;
  71 def : NotifyPatImmOff<regPlusImm>;
  72 def : NotifyPatImmOff<or_is_add>;
  73
  74 def NotifyPatGlobalAddr :
  75   Pat<(i32 (int_wasm_atomic_notify (regPlusGA I32:$addr,
  76                                     (WebAssemblywrapper tglobaladdr:$off)),
  77                                    I32:$count)),
  78       (ATOMIC_NOTIFY 0, tglobaladdr:$off, I32:$addr, I32:$count)>;
  79
  80 // Select notifys with just a constant offset.
  81 def NotifyPatOffsetOnly :
  82   Pat<(i32 (int_wasm_atomic_notify imm:$off, I32:$count)),
  83       (ATOMIC_NOTIFY 0, imm:$off, (CONST_I32 0), I32:$count)>;
  84
  85 def NotifyPatGlobalAddrOffOnly :
  86   Pat<(i32 (int_wasm_atomic_notify (WebAssemblywrapper tglobaladdr:$off),
  87                                    I32:$count)),
  88       (ATOMIC_NOTIFY 0, tglobaladdr:$off, (CONST_I32 0), I32:$count)>;
  89
  90 // Select waits with no constant offset.
  91 class WaitPatNoOffset<ValueType ty, Intrinsic kind, NI inst> :
  92   Pat<(i32 (kind I32:$addr, ty:$exp, I64:$timeout)),
  93       (inst 0, 0, I32:$addr, ty:$exp, I64:$timeout)>;
  94 def : WaitPatNoOffset<i32, int_wasm_atomic_wait_i32, ATOMIC_WAIT_I32>;
  95 def : WaitPatNoOffset<i64, int_wasm_atomic_wait_i64, ATOMIC_WAIT_I64>;
  96
  97 // Select waits with a constant offset.
  98
  99 // Pattern with address + immediate offset
 100 class WaitPatImmOff<ValueType ty, Intrinsic kind, PatFrag operand, NI inst> :
 101   Pat<(i32 (kind (operand I32:$addr, imm:$off), ty:$exp, I64:$timeout)),
 102       (inst 0, imm:$off, I32:$addr, ty:$exp, I64:$timeout)>;
 103 def : WaitPatImmOff<i32, int_wasm_atomic_wait_i32, regPlusImm, ATOMIC_WAIT_I32>;
 104 def : WaitPatImmOff<i32, int_wasm_atomic_wait_i32, or_is_add, ATOMIC_WAIT_I32>;
 105 def : WaitPatImmOff<i64, int_wasm_atomic_wait_i64, regPlusImm, ATOMIC_WAIT_I64>;
 106 def : WaitPatImmOff<i64, int_wasm_atomic_wait_i64, or_is_add, ATOMIC_WAIT_I64>;
 107
 108 class WaitPatGlobalAddr<ValueType ty, Intrinsic kind, NI inst> :
 109   Pat<(i32 (kind (regPlusGA I32:$addr, (WebAssemblywrapper tglobaladdr:$off)),
 110                  ty:$exp, I64:$timeout)),
 111       (inst 0, tglobaladdr:$off, I32:$addr, ty:$exp, I64:$timeout)>;
 112 def : WaitPatGlobalAddr<i32, int_wasm_atomic_wait_i32, ATOMIC_WAIT_I32>;
 113 def : WaitPatGlobalAddr<i64, int_wasm_atomic_wait_i64, ATOMIC_WAIT_I64>;
 114
 115 // Select wait_i32, ATOMIC_WAIT_I32s with just a constant offset.
 116 class WaitPatOffsetOnly<ValueType ty, Intrinsic kind, NI inst> :
 117   Pat<(i32 (kind imm:$off, ty:$exp, I64:$timeout)),
 118       (inst 0, imm:$off, (CONST_I32 0), ty:$exp, I64:$timeout)>;
 119 def : WaitPatOffsetOnly<i32, int_wasm_atomic_wait_i32, ATOMIC_WAIT_I32>;
 120 def : WaitPatOffsetOnly<i64, int_wasm_atomic_wait_i64, ATOMIC_WAIT_I64>;
 121
 122 class WaitPatGlobalAddrOffOnly<ValueType ty, Intrinsic kind, NI inst> :
 123   Pat<(i32 (kind (WebAssemblywrapper tglobaladdr:$off), ty:$exp, I64:$timeout)),
 124       (inst 0, tglobaladdr:$off, (CONST_I32 0), ty:$exp, I64:$timeout)>;
 125 def : WaitPatGlobalAddrOffOnly<i32, int_wasm_atomic_wait_i32, ATOMIC_WAIT_I32>;
 126 def : WaitPatGlobalAddrOffOnly<i64, int_wasm_atomic_wait_i64, ATOMIC_WAIT_I64>;
 127 } // Predicates = [HasAtomics]
 128
 129 //===----------------------------------------------------------------------===//
 130 // Atomic fences
 131 //===----------------------------------------------------------------------===//
 132
 133 // A compiler fence instruction that prevents reordering of instructions.
 134 let Defs = [ARGUMENTS] in {
 135 let isPseudo = 1, hasSideEffects = 1 in
 136 defm COMPILER_FENCE : ATOMIC_NRI<(outs), (ins), [], "compiler_fence">;
 137 let hasSideEffects = 1 in
 138 defm ATOMIC_FENCE : ATOMIC_NRI<(outs), (ins i8imm:$flags), [], "atomic.fence",
 139                                0x03>;
 140 } // Defs = [ARGUMENTS]
 141
 142 //===----------------------------------------------------------------------===//
 143 // Atomic loads
 144 //===----------------------------------------------------------------------===//
 145
 146 multiclass AtomicLoad<WebAssemblyRegClass rc, string name, int atomic_op> {
 147   defm "" : WebAssemblyLoad<rc, name, !or(0xfe00, !and(0xff, atomic_op))>,
 148             Requires<[HasAtomics]>;
 149 }
 150
 151 defm ATOMIC_LOAD_I32 : AtomicLoad<I32, "i32.atomic.load", 0x10>;
 152 defm ATOMIC_LOAD_I64 : AtomicLoad<I64, "i64.atomic.load", 0x11>;
 153
 154 // Select loads with no constant offset.
 155 let Predicates = [HasAtomics] in {
 156 def : LoadPatNoOffset<i32, atomic_load_32, ATOMIC_LOAD_I32>;
 157 def : LoadPatNoOffset<i64, atomic_load_64, ATOMIC_LOAD_I64>;
 158
 159 // Select loads with a constant offset.
 160
 161 // Pattern with address + immediate offset
 162 def : LoadPatImmOff<i32, atomic_load_32, regPlusImm, ATOMIC_LOAD_I32>;
 163 def : LoadPatImmOff<i64, atomic_load_64, regPlusImm, ATOMIC_LOAD_I64>;
 164 def : LoadPatImmOff<i32, atomic_load_32, or_is_add, ATOMIC_LOAD_I32>;
 165 def : LoadPatImmOff<i64, atomic_load_64, or_is_add, ATOMIC_LOAD_I64>;
 166
 167 def : LoadPatGlobalAddr<i32, atomic_load_32, ATOMIC_LOAD_I32>;
 168 def : LoadPatGlobalAddr<i64, atomic_load_64, ATOMIC_LOAD_I64>;
 169
 170 // Select loads with just a constant offset.
 171 def : LoadPatOffsetOnly<i32, atomic_load_32, ATOMIC_LOAD_I32>;
 172 def : LoadPatOffsetOnly<i64, atomic_load_64, ATOMIC_LOAD_I64>;
 173
 174 def : LoadPatGlobalAddrOffOnly<i32, atomic_load_32, ATOMIC_LOAD_I32>;
 175 def : LoadPatGlobalAddrOffOnly<i64, atomic_load_64, ATOMIC_LOAD_I64>;
 176
 177 } // Predicates = [HasAtomics]
 178
 179 // Extending loads. Note that there are only zero-extending atomic loads, no
 180 // sign-extending loads.
 181 defm ATOMIC_LOAD8_U_I32 : AtomicLoad<I32, "i32.atomic.load8_u", 0x12>;
 182 defm ATOMIC_LOAD16_U_I32 : AtomicLoad<I32, "i32.atomic.load16_u", 0x13>;
 183 defm ATOMIC_LOAD8_U_I64 : AtomicLoad<I64, "i64.atomic.load8_u", 0x14>;
 184 defm ATOMIC_LOAD16_U_I64 : AtomicLoad<I64, "i64.atomic.load16_u", 0x15>;
 185 defm ATOMIC_LOAD32_U_I64 : AtomicLoad<I64, "i64.atomic.load32_u", 0x16>;
 186
 187 // Fragments for extending loads. These are different from regular loads because
 188 // the SDNodes are derived from AtomicSDNode rather than LoadSDNode and
 189 // therefore don't have the extension type field. So instead of matching that,
 190 // we match the patterns that the type legalizer expands them to.
 191
 192 // We directly match zext patterns and select the zext atomic loads.
 193 // i32 (zext (i8 (atomic_load_8))) gets legalized to
 194 // i32 (and (i32 (atomic_load_8)), 255)
 195 // These can be selected to a single zero-extending atomic load instruction.
 196 def zext_aload_8_32 :
 197   PatFrag<(ops node:$addr), (and (i32 (atomic_load_8 node:$addr)), 255)>;
 198 def zext_aload_16_32 :
 199   PatFrag<(ops node:$addr), (and (i32 (atomic_load_16 node:$addr)), 65535)>;
 200 // Unlike regular loads, extension to i64 is handled differently than i32.
 201 // i64 (zext (i8 (atomic_load_8))) gets legalized to
 202 // i64 (and (i64 (anyext (i32 (atomic_load_8)))), 255)
 203 def zext_aload_8_64 :
 204   PatFrag<(ops node:$addr),
 205           (and (i64 (anyext (i32 (atomic_load_8 node:$addr)))), 255)>;
 206 def zext_aload_16_64 :
 207   PatFrag<(ops node:$addr),
 208           (and (i64 (anyext (i32 (atomic_load_16 node:$addr)))), 65535)>;
 209 def zext_aload_32_64 :
 210   PatFrag<(ops node:$addr),
 211           (zext (i32 (atomic_load node:$addr)))>;
 212
 213 // We don't have single sext atomic load instructions. So for sext loads, we
 214 // match bare subword loads (for 32-bit results) and anyext loads (for 64-bit
 215 // results) and select a zext load; the next instruction will be sext_inreg
 216 // which is selected by itself.
 217 def sext_aload_8_64 :
 218   PatFrag<(ops node:$addr), (anyext (i32 (atomic_load_8 node:$addr)))>;
 219 def sext_aload_16_64 :
 220   PatFrag<(ops node:$addr), (anyext (i32 (atomic_load_16 node:$addr)))>;
 221
 222 let Predicates = [HasAtomics] in {
 223 // Select zero-extending loads with no constant offset.
 224 def : LoadPatNoOffset<i32, zext_aload_8_32, ATOMIC_LOAD8_U_I32>;
 225 def : LoadPatNoOffset<i32, zext_aload_16_32, ATOMIC_LOAD16_U_I32>;
 226 def : LoadPatNoOffset<i64, zext_aload_8_64, ATOMIC_LOAD8_U_I64>;
 227 def : LoadPatNoOffset<i64, zext_aload_16_64, ATOMIC_LOAD16_U_I64>;
 228 def : LoadPatNoOffset<i64, zext_aload_32_64, ATOMIC_LOAD32_U_I64>;
 229
 230 // Select sign-extending loads with no constant offset
 231 def : LoadPatNoOffset<i32, atomic_load_8, ATOMIC_LOAD8_U_I32>;
 232 def : LoadPatNoOffset<i32, atomic_load_16, ATOMIC_LOAD16_U_I32>;
 233 def : LoadPatNoOffset<i64, sext_aload_8_64, ATOMIC_LOAD8_U_I64>;
 234 def : LoadPatNoOffset<i64, sext_aload_16_64, ATOMIC_LOAD16_U_I64>;
 235 // 32->64 sext load gets selected as i32.atomic.load, i64.extend_i32_s
 236
 237 // Zero-extending loads with constant offset
 238 def : LoadPatImmOff<i32, zext_aload_8_32, regPlusImm, ATOMIC_LOAD8_U_I32>;
 239 def : LoadPatImmOff<i32, zext_aload_16_32, regPlusImm, ATOMIC_LOAD16_U_I32>;
 240 def : LoadPatImmOff<i32, zext_aload_8_32, or_is_add, ATOMIC_LOAD8_U_I32>;
 241 def : LoadPatImmOff<i32, zext_aload_16_32, or_is_add, ATOMIC_LOAD16_U_I32>;
 242 def : LoadPatImmOff<i64, zext_aload_8_64, regPlusImm, ATOMIC_LOAD8_U_I64>;
 243 def : LoadPatImmOff<i64, zext_aload_16_64, regPlusImm, ATOMIC_LOAD16_U_I64>;
 244 def : LoadPatImmOff<i64, zext_aload_32_64, regPlusImm, ATOMIC_LOAD32_U_I64>;
 245 def : LoadPatImmOff<i64, zext_aload_8_64, or_is_add, ATOMIC_LOAD8_U_I64>;
 246 def : LoadPatImmOff<i64, zext_aload_16_64, or_is_add, ATOMIC_LOAD16_U_I64>;
 247 def : LoadPatImmOff<i64, zext_aload_32_64, or_is_add, ATOMIC_LOAD32_U_I64>;
 248
 249 // Sign-extending loads with constant offset
 250 def : LoadPatImmOff<i32, atomic_load_8, regPlusImm, ATOMIC_LOAD8_U_I32>;
 251 def : LoadPatImmOff<i32, atomic_load_16, regPlusImm, ATOMIC_LOAD16_U_I32>;
 252 def : LoadPatImmOff<i32, atomic_load_8, or_is_add, ATOMIC_LOAD8_U_I32>;
 253 def : LoadPatImmOff<i32, atomic_load_16, or_is_add, ATOMIC_LOAD16_U_I32>;
 254 def : LoadPatImmOff<i64, sext_aload_8_64, regPlusImm, ATOMIC_LOAD8_U_I64>;
 255 def : LoadPatImmOff<i64, sext_aload_16_64, regPlusImm, ATOMIC_LOAD16_U_I64>;
 256 def : LoadPatImmOff<i64, sext_aload_8_64, or_is_add, ATOMIC_LOAD8_U_I64>;
 257 def : LoadPatImmOff<i64, sext_aload_16_64, or_is_add, ATOMIC_LOAD16_U_I64>;
 258 // No 32->64 patterns, just use i32.atomic.load and i64.extend_s/i64
 259
 260 def : LoadPatGlobalAddr<i32, zext_aload_8_32, ATOMIC_LOAD8_U_I32>;
 261 def : LoadPatGlobalAddr<i32, zext_aload_16_32, ATOMIC_LOAD16_U_I32>;
 262 def : LoadPatGlobalAddr<i64, zext_aload_8_64, ATOMIC_LOAD8_U_I64>;
 263 def : LoadPatGlobalAddr<i64, zext_aload_16_64, ATOMIC_LOAD16_U_I64>;
 264 def : LoadPatGlobalAddr<i64, zext_aload_32_64, ATOMIC_LOAD32_U_I64>;
 265 def : LoadPatGlobalAddr<i32, atomic_load_8, ATOMIC_LOAD8_U_I32>;
 266 def : LoadPatGlobalAddr<i32, atomic_load_16, ATOMIC_LOAD16_U_I32>;
 267 def : LoadPatGlobalAddr<i64, sext_aload_8_64, ATOMIC_LOAD8_U_I64>;
 268 def : LoadPatGlobalAddr<i64, sext_aload_16_64, ATOMIC_LOAD16_U_I64>;
 269
 270 // Extending loads with just a constant offset
 271 def : LoadPatOffsetOnly<i32, zext_aload_8_32, ATOMIC_LOAD8_U_I32>;
 272 def : LoadPatOffsetOnly<i32, zext_aload_16_32, ATOMIC_LOAD16_U_I32>;
 273 def : LoadPatOffsetOnly<i64, zext_aload_8_64, ATOMIC_LOAD8_U_I64>;
 274 def : LoadPatOffsetOnly<i64, zext_aload_16_64, ATOMIC_LOAD16_U_I64>;
 275 def : LoadPatOffsetOnly<i64, zext_aload_32_64, ATOMIC_LOAD32_U_I64>;
 276 def : LoadPatOffsetOnly<i32, atomic_load_8, ATOMIC_LOAD8_U_I32>;
 277 def : LoadPatOffsetOnly<i32, atomic_load_16, ATOMIC_LOAD16_U_I32>;
 278 def : LoadPatOffsetOnly<i64, sext_aload_8_64, ATOMIC_LOAD8_U_I64>;
 279 def : LoadPatOffsetOnly<i64, sext_aload_16_64, ATOMIC_LOAD16_U_I64>;
 280
 281 def : LoadPatGlobalAddrOffOnly<i32, zext_aload_8_32, ATOMIC_LOAD8_U_I32>;
 282 def : LoadPatGlobalAddrOffOnly<i32, zext_aload_16_32, ATOMIC_LOAD16_U_I32>;
 283 def : LoadPatGlobalAddrOffOnly<i64, zext_aload_8_64, ATOMIC_LOAD8_U_I64>;
 284 def : LoadPatGlobalAddrOffOnly<i64, zext_aload_16_64, ATOMIC_LOAD16_U_I64>;
 285 def : LoadPatGlobalAddrOffOnly<i64, zext_aload_32_64, ATOMIC_LOAD32_U_I64>;
 286 def : LoadPatGlobalAddrOffOnly<i32, atomic_load_8, ATOMIC_LOAD8_U_I32>;
 287 def : LoadPatGlobalAddrOffOnly<i32, atomic_load_16, ATOMIC_LOAD16_U_I32>;
 288 def : LoadPatGlobalAddrOffOnly<i64, sext_aload_8_64, ATOMIC_LOAD8_U_I64>;
 289 def : LoadPatGlobalAddrOffOnly<i64, sext_aload_16_64, ATOMIC_LOAD16_U_I64>;
 290
 291 } // Predicates = [HasAtomics]
 292
 293 //===----------------------------------------------------------------------===//
 294 // Atomic stores
 295 //===----------------------------------------------------------------------===//
 296
 297 multiclass AtomicStore<WebAssemblyRegClass rc, string name, int atomic_op> {
 298   defm "" : WebAssemblyStore<rc, name, !or(0xfe00, !and(0xff, atomic_op))>,
 299             Requires<[HasAtomics]>;
 300 }
 301
 302 defm ATOMIC_STORE_I32 : AtomicStore<I32, "i32.atomic.store", 0x17>;
 303 defm ATOMIC_STORE_I64 : AtomicStore<I64, "i64.atomic.store", 0x18>;
 304
 305 // We need an 'atomic' version of store patterns because store and atomic_store
 306 // nodes have different operand orders:
 307 // store: (store $val, $ptr)
 308 // atomic_store: (store $ptr, $val)
 309
 310 let Predicates = [HasAtomics] in {
 311
 312 // Select stores with no constant offset.
 313 class AStorePatNoOffset<ValueType ty, PatFrag kind, NI inst> :
 314   Pat<(kind I32:$addr, ty:$val), (inst 0, 0, I32:$addr, ty:$val)>;
 315 def : AStorePatNoOffset<i32, atomic_store_32, ATOMIC_STORE_I32>;
 316 def : AStorePatNoOffset<i64, atomic_store_64, ATOMIC_STORE_I64>;
 317
 318 // Select stores with a constant offset.
 319
 320 // Pattern with address + immediate offset
 321 class AStorePatImmOff<ValueType ty, PatFrag kind, PatFrag operand, NI inst> :
 322   Pat<(kind (operand I32:$addr, imm:$off), ty:$val),
 323       (inst 0, imm:$off, I32:$addr, ty:$val)>;
 324 def : AStorePatImmOff<i32, atomic_store_32, regPlusImm, ATOMIC_STORE_I32>;
 325 def : AStorePatImmOff<i64, atomic_store_64, regPlusImm, ATOMIC_STORE_I64>;
 326 def : AStorePatImmOff<i32, atomic_store_32, or_is_add, ATOMIC_STORE_I32>;
 327 def : AStorePatImmOff<i64, atomic_store_64, or_is_add, ATOMIC_STORE_I64>;
 328
 329 class AStorePatGlobalAddr<ValueType ty, PatFrag kind, NI inst> :
 330   Pat<(kind (regPlusGA I32:$addr, (WebAssemblywrapper tglobaladdr:$off)),
 331             ty:$val),
 332       (inst 0, tglobaladdr:$off, I32:$addr, ty:$val)>;
 333 def : AStorePatGlobalAddr<i32, atomic_store_32, ATOMIC_STORE_I32>;
 334 def : AStorePatGlobalAddr<i64, atomic_store_64, ATOMIC_STORE_I64>;
 335
 336 // Select stores with just a constant offset.
 337 class AStorePatOffsetOnly<ValueType ty, PatFrag kind, NI inst> :
 338   Pat<(kind imm:$off, ty:$val), (inst 0, imm:$off, (CONST_I32 0), ty:$val)>;
 339 def : AStorePatOffsetOnly<i32, atomic_store_32, ATOMIC_STORE_I32>;
 340 def : AStorePatOffsetOnly<i64, atomic_store_64, ATOMIC_STORE_I64>;
 341
 342 class AStorePatGlobalAddrOffOnly<ValueType ty, PatFrag kind, NI inst> :
 343   Pat<(kind (WebAssemblywrapper tglobaladdr:$off), ty:$val),
 344       (inst 0, tglobaladdr:$off, (CONST_I32 0), ty:$val)>;
 345 def : AStorePatGlobalAddrOffOnly<i32, atomic_store_32, ATOMIC_STORE_I32>;
 346 def : AStorePatGlobalAddrOffOnly<i64, atomic_store_64, ATOMIC_STORE_I64>;
 347
 348 } // Predicates = [HasAtomics]
 349
 350 // Truncating stores.
 351 defm ATOMIC_STORE8_I32 : AtomicStore<I32, "i32.atomic.store8", 0x19>;
 352 defm ATOMIC_STORE16_I32 : AtomicStore<I32, "i32.atomic.store16", 0x1a>;
 353 defm ATOMIC_STORE8_I64 : AtomicStore<I64, "i64.atomic.store8", 0x1b>;
 354 defm ATOMIC_STORE16_I64 : AtomicStore<I64, "i64.atomic.store16", 0x1c>;
 355 defm ATOMIC_STORE32_I64 : AtomicStore<I64, "i64.atomic.store32", 0x1d>;
 356
 357 // Fragments for truncating stores.
 358
 359 // We don't have single truncating atomic store instructions. For 32-bit
 360 // instructions, we just need to match bare atomic stores. On the other hand,
 361 // truncating stores from i64 values are once truncated to i32 first.
 362 class trunc_astore_64<PatFrag kind> :
 363   PatFrag<(ops node:$addr, node:$val),
 364           (kind node:$addr, (i32 (trunc (i64 node:$val))))>;
 365 def trunc_astore_8_64 : trunc_astore_64<atomic_store_8>;
 366 def trunc_astore_16_64 : trunc_astore_64<atomic_store_16>;
 367 def trunc_astore_32_64 : trunc_astore_64<atomic_store_32>;
 368
 369 let Predicates = [HasAtomics] in {
 370
 371 // Truncating stores with no constant offset
 372 def : AStorePatNoOffset<i32, atomic_store_8, ATOMIC_STORE8_I32>;
 373 def : AStorePatNoOffset<i32, atomic_store_16, ATOMIC_STORE16_I32>;
 374 def : AStorePatNoOffset<i64, trunc_astore_8_64, ATOMIC_STORE8_I64>;
 375 def : AStorePatNoOffset<i64, trunc_astore_16_64, ATOMIC_STORE16_I64>;
 376 def : AStorePatNoOffset<i64, trunc_astore_32_64, ATOMIC_STORE32_I64>;
 377
 378 // Truncating stores with a constant offset
 379 def : AStorePatImmOff<i32, atomic_store_8, regPlusImm, ATOMIC_STORE8_I32>;
 380 def : AStorePatImmOff<i32, atomic_store_16, regPlusImm, ATOMIC_STORE16_I32>;
 381 def : AStorePatImmOff<i64, trunc_astore_8_64, regPlusImm, ATOMIC_STORE8_I64>;
 382 def : AStorePatImmOff<i64, trunc_astore_16_64, regPlusImm, ATOMIC_STORE16_I64>;
 383 def : AStorePatImmOff<i64, trunc_astore_32_64, regPlusImm, ATOMIC_STORE32_I64>;
 384 def : AStorePatImmOff<i32, atomic_store_8, or_is_add, ATOMIC_STORE8_I32>;
 385 def : AStorePatImmOff<i32, atomic_store_16, or_is_add, ATOMIC_STORE16_I32>;
 386 def : AStorePatImmOff<i64, trunc_astore_8_64, or_is_add, ATOMIC_STORE8_I64>;
 387 def : AStorePatImmOff<i64, trunc_astore_16_64, or_is_add, ATOMIC_STORE16_I64>;
 388 def : AStorePatImmOff<i64, trunc_astore_32_64, or_is_add, ATOMIC_STORE32_I64>;
 389
 390 def : AStorePatGlobalAddr<i32, atomic_store_8, ATOMIC_STORE8_I32>;
 391 def : AStorePatGlobalAddr<i32, atomic_store_16, ATOMIC_STORE16_I32>;
 392 def : AStorePatGlobalAddr<i64, trunc_astore_8_64, ATOMIC_STORE8_I64>;
 393 def : AStorePatGlobalAddr<i64, trunc_astore_16_64, ATOMIC_STORE16_I64>;
 394 def : AStorePatGlobalAddr<i64, trunc_astore_32_64, ATOMIC_STORE32_I64>;
 395
 396 // Truncating stores with just a constant offset
 397 def : AStorePatOffsetOnly<i32, atomic_store_8, ATOMIC_STORE8_I32>;
 398 def : AStorePatOffsetOnly<i32, atomic_store_16, ATOMIC_STORE16_I32>;
 399 def : AStorePatOffsetOnly<i64, trunc_astore_8_64, ATOMIC_STORE8_I64>;
 400 def : AStorePatOffsetOnly<i64, trunc_astore_16_64, ATOMIC_STORE16_I64>;
 401 def : AStorePatOffsetOnly<i64, trunc_astore_32_64, ATOMIC_STORE32_I64>;
 402
 403 def : AStorePatGlobalAddrOffOnly<i32, atomic_store_8, ATOMIC_STORE8_I32>;
 404 def : AStorePatGlobalAddrOffOnly<i32, atomic_store_16, ATOMIC_STORE16_I32>;
 405 def : AStorePatGlobalAddrOffOnly<i64, trunc_astore_8_64, ATOMIC_STORE8_I64>;
 406 def : AStorePatGlobalAddrOffOnly<i64, trunc_astore_16_64, ATOMIC_STORE16_I64>;
 407 def : AStorePatGlobalAddrOffOnly<i64, trunc_astore_32_64, ATOMIC_STORE32_I64>;
 408
 409 } // Predicates = [HasAtomics]
 410
 411 //===----------------------------------------------------------------------===//
 412 // Atomic binary read-modify-writes
 413 //===----------------------------------------------------------------------===//
 414
 415 multiclass WebAssemblyBinRMW<WebAssemblyRegClass rc, string name,
 416                              int atomic_op> {
 417   defm "" :
 418     ATOMIC_I<(outs rc:$dst),
 419              (ins P2Align:$p2align, offset32_op:$off, I32:$addr, rc:$val),
 420              (outs), (ins P2Align:$p2align, offset32_op:$off), [],
 421              !strconcat(name, "\t$dst, ${off}(${addr})${p2align}, $val"),
 422              !strconcat(name, "\t${off}${p2align}"), atomic_op>;
 423 }
 424
 425 defm ATOMIC_RMW_ADD_I32 : WebAssemblyBinRMW<I32, "i32.atomic.rmw.add", 0x1e>;
 426 defm ATOMIC_RMW_ADD_I64 : WebAssemblyBinRMW<I64, "i64.atomic.rmw.add", 0x1f>;
 427 defm ATOMIC_RMW8_U_ADD_I32 :
 428   WebAssemblyBinRMW<I32, "i32.atomic.rmw8.add_u", 0x20>;
 429 defm ATOMIC_RMW16_U_ADD_I32 :
 430   WebAssemblyBinRMW<I32, "i32.atomic.rmw16.add_u", 0x21>;
 431 defm ATOMIC_RMW8_U_ADD_I64 :
 432   WebAssemblyBinRMW<I64, "i64.atomic.rmw8.add_u", 0x22>;
 433 defm ATOMIC_RMW16_U_ADD_I64 :
 434   WebAssemblyBinRMW<I64, "i64.atomic.rmw16.add_u", 0x23>;
 435 defm ATOMIC_RMW32_U_ADD_I64 :
 436   WebAssemblyBinRMW<I64, "i64.atomic.rmw32.add_u", 0x24>;
 437
 438 defm ATOMIC_RMW_SUB_I32 : WebAssemblyBinRMW<I32, "i32.atomic.rmw.sub", 0x25>;
 439 defm ATOMIC_RMW_SUB_I64 : WebAssemblyBinRMW<I64, "i64.atomic.rmw.sub", 0x26>;
 440 defm ATOMIC_RMW8_U_SUB_I32 :
 441   WebAssemblyBinRMW<I32, "i32.atomic.rmw8.sub_u", 0x27>;
 442 defm ATOMIC_RMW16_U_SUB_I32 :
 443   WebAssemblyBinRMW<I32, "i32.atomic.rmw16.sub_u", 0x28>;
 444 defm ATOMIC_RMW8_U_SUB_I64 :
 445   WebAssemblyBinRMW<I64, "i64.atomic.rmw8.sub_u", 0x29>;
 446 defm ATOMIC_RMW16_U_SUB_I64 :
 447   WebAssemblyBinRMW<I64, "i64.atomic.rmw16.sub_u", 0x2a>;
 448 defm ATOMIC_RMW32_U_SUB_I64 :
 449   WebAssemblyBinRMW<I64, "i64.atomic.rmw32.sub_u", 0x2b>;
 450
 451 defm ATOMIC_RMW_AND_I32 : WebAssemblyBinRMW<I32, "i32.atomic.rmw.and", 0x2c>;
 452 defm ATOMIC_RMW_AND_I64 : WebAssemblyBinRMW<I64, "i64.atomic.rmw.and", 0x2d>;
 453 defm ATOMIC_RMW8_U_AND_I32 :
 454   WebAssemblyBinRMW<I32, "i32.atomic.rmw8.and_u", 0x2e>;
 455 defm ATOMIC_RMW16_U_AND_I32 :
 456   WebAssemblyBinRMW<I32, "i32.atomic.rmw16.and_u", 0x2f>;
 457 defm ATOMIC_RMW8_U_AND_I64 :
 458   WebAssemblyBinRMW<I64, "i64.atomic.rmw8.and_u", 0x30>;
 459 defm ATOMIC_RMW16_U_AND_I64 :
 460   WebAssemblyBinRMW<I64, "i64.atomic.rmw16.and_u", 0x31>;
 461 defm ATOMIC_RMW32_U_AND_I64 :
 462   WebAssemblyBinRMW<I64, "i64.atomic.rmw32.and_u", 0x32>;
 463
 464 defm ATOMIC_RMW_OR_I32 : WebAssemblyBinRMW<I32, "i32.atomic.rmw.or", 0x33>;
 465 defm ATOMIC_RMW_OR_I64 : WebAssemblyBinRMW<I64, "i64.atomic.rmw.or", 0x34>;
 466 defm ATOMIC_RMW8_U_OR_I32 :
 467   WebAssemblyBinRMW<I32, "i32.atomic.rmw8.or_u", 0x35>;
 468 defm ATOMIC_RMW16_U_OR_I32 :
 469   WebAssemblyBinRMW<I32, "i32.atomic.rmw16.or_u", 0x36>;
 470 defm ATOMIC_RMW8_U_OR_I64 :
 471   WebAssemblyBinRMW<I64, "i64.atomic.rmw8.or_u", 0x37>;
 472 defm ATOMIC_RMW16_U_OR_I64 :
 473   WebAssemblyBinRMW<I64, "i64.atomic.rmw16.or_u", 0x38>;
 474 defm ATOMIC_RMW32_U_OR_I64 :
 475   WebAssemblyBinRMW<I64, "i64.atomic.rmw32.or_u", 0x39>;
 476
 477 defm ATOMIC_RMW_XOR_I32 : WebAssemblyBinRMW<I32, "i32.atomic.rmw.xor", 0x3a>;
 478 defm ATOMIC_RMW_XOR_I64 : WebAssemblyBinRMW<I64, "i64.atomic.rmw.xor", 0x3b>;
 479 defm ATOMIC_RMW8_U_XOR_I32 :
 480   WebAssemblyBinRMW<I32, "i32.atomic.rmw8.xor_u", 0x3c>;
 481 defm ATOMIC_RMW16_U_XOR_I32 :
 482   WebAssemblyBinRMW<I32, "i32.atomic.rmw16.xor_u", 0x3d>;
 483 defm ATOMIC_RMW8_U_XOR_I64 :
 484   WebAssemblyBinRMW<I64, "i64.atomic.rmw8.xor_u", 0x3e>;
 485 defm ATOMIC_RMW16_U_XOR_I64 :
 486   WebAssemblyBinRMW<I64, "i64.atomic.rmw16.xor_u", 0x3f>;
 487 defm ATOMIC_RMW32_U_XOR_I64 :
 488   WebAssemblyBinRMW<I64, "i64.atomic.rmw32.xor_u", 0x40>;
 489
 490 defm ATOMIC_RMW_XCHG_I32 :
 491   WebAssemblyBinRMW<I32, "i32.atomic.rmw.xchg", 0x41>;
 492 defm ATOMIC_RMW_XCHG_I64 :
 493   WebAssemblyBinRMW<I64, "i64.atomic.rmw.xchg", 0x42>;
 494 defm ATOMIC_RMW8_U_XCHG_I32 :
 495   WebAssemblyBinRMW<I32, "i32.atomic.rmw8.xchg_u", 0x43>;
 496 defm ATOMIC_RMW16_U_XCHG_I32 :
 497   WebAssemblyBinRMW<I32, "i32.atomic.rmw16.xchg_u", 0x44>;
 498 defm ATOMIC_RMW8_U_XCHG_I64 :
 499   WebAssemblyBinRMW<I64, "i64.atomic.rmw8.xchg_u", 0x45>;
 500 defm ATOMIC_RMW16_U_XCHG_I64 :
 501   WebAssemblyBinRMW<I64, "i64.atomic.rmw16.xchg_u", 0x46>;
 502 defm ATOMIC_RMW32_U_XCHG_I64 :
 503   WebAssemblyBinRMW<I64, "i64.atomic.rmw32.xchg_u", 0x47>;
 504
 505 // Select binary RMWs with no constant offset.
 506 class BinRMWPatNoOffset<ValueType ty, PatFrag kind, NI inst> :
 507   Pat<(ty (kind I32:$addr, ty:$val)), (inst 0, 0, I32:$addr, ty:$val)>;
 508
 509 // Select binary RMWs with a constant offset.
 510
 511 // Pattern with address + immediate offset
 512 class BinRMWPatImmOff<ValueType ty, PatFrag kind, PatFrag operand, NI inst> :
 513   Pat<(ty (kind (operand I32:$addr, imm:$off), ty:$val)),
 514       (inst 0, imm:$off, I32:$addr, ty:$val)>;
 515
 516 class BinRMWPatGlobalAddr<ValueType ty, PatFrag kind, NI inst> :
 517   Pat<(ty (kind (regPlusGA I32:$addr, (WebAssemblywrapper tglobaladdr:$off)),
 518                 ty:$val)),
 519       (inst 0, tglobaladdr:$off, I32:$addr, ty:$val)>;
 520
 521 // Select binary RMWs with just a constant offset.
 522 class BinRMWPatOffsetOnly<ValueType ty, PatFrag kind, NI inst> :
 523   Pat<(ty (kind imm:$off, ty:$val)),
 524       (inst 0, imm:$off, (CONST_I32 0), ty:$val)>;
 525
 526 class BinRMWPatGlobalAddrOffOnly<ValueType ty, PatFrag kind, NI inst> :
 527   Pat<(ty (kind (WebAssemblywrapper tglobaladdr:$off), ty:$val)),
 528       (inst 0, tglobaladdr:$off, (CONST_I32 0), ty:$val)>;
 529
 530 // Patterns for various addressing modes.
 531 multiclass BinRMWPattern<PatFrag rmw_32, PatFrag rmw_64, NI inst_32,
 532                          NI inst_64> {
 533   def : BinRMWPatNoOffset<i32, rmw_32, inst_32>;
 534   def : BinRMWPatNoOffset<i64, rmw_64, inst_64>;
 535
 536   def : BinRMWPatImmOff<i32, rmw_32, regPlusImm, inst_32>;
 537   def : BinRMWPatImmOff<i64, rmw_64, regPlusImm, inst_64>;
 538   def : BinRMWPatImmOff<i32, rmw_32, or_is_add, inst_32>;
 539   def : BinRMWPatImmOff<i64, rmw_64, or_is_add, inst_64>;
 540
 541   def : BinRMWPatGlobalAddr<i32, rmw_32, inst_32>;
 542   def : BinRMWPatGlobalAddr<i64, rmw_64, inst_64>;
 543
 544   def : BinRMWPatOffsetOnly<i32, rmw_32, inst_32>;
 545   def : BinRMWPatOffsetOnly<i64, rmw_64, inst_64>;
 546
 547   def : BinRMWPatGlobalAddrOffOnly<i32, rmw_32, inst_32>;
 548   def : BinRMWPatGlobalAddrOffOnly<i64, rmw_64, inst_64>;
 549 }
 550
 551 let Predicates = [HasAtomics] in {
 552 defm : BinRMWPattern<atomic_load_add_32, atomic_load_add_64, ATOMIC_RMW_ADD_I32,
 553                      ATOMIC_RMW_ADD_I64>;
 554 defm : BinRMWPattern<atomic_load_sub_32, atomic_load_sub_64, ATOMIC_RMW_SUB_I32,
 555                      ATOMIC_RMW_SUB_I64>;
 556 defm : BinRMWPattern<atomic_load_and_32, atomic_load_and_64, ATOMIC_RMW_AND_I32,
 557                      ATOMIC_RMW_AND_I64>;
 558 defm : BinRMWPattern<atomic_load_or_32, atomic_load_or_64, ATOMIC_RMW_OR_I32,
 559                      ATOMIC_RMW_OR_I64>;
 560 defm : BinRMWPattern<atomic_load_xor_32, atomic_load_xor_64, ATOMIC_RMW_XOR_I32,
 561                      ATOMIC_RMW_XOR_I64>;
 562 defm : BinRMWPattern<atomic_swap_32, atomic_swap_64, ATOMIC_RMW_XCHG_I32,
 563                      ATOMIC_RMW_XCHG_I64>;
 564 } // Predicates = [HasAtomics]
 565
 566 // Truncating & zero-extending binary RMW patterns.
 567 // These are combined patterns of truncating store patterns and zero-extending
 568 // load patterns above.
 569 class zext_bin_rmw_8_32<PatFrag kind> :
 570   PatFrag<(ops node:$addr, node:$val),
 571           (and (i32 (kind node:$addr, node:$val)), 255)>;
 572 class zext_bin_rmw_16_32<PatFrag kind> :
 573   PatFrag<(ops node:$addr, node:$val),
 574           (and (i32 (kind node:$addr, node:$val)), 65535)>;
 575 class zext_bin_rmw_8_64<PatFrag kind> :
 576   PatFrag<(ops node:$addr, node:$val),
 577     (and (i64 (anyext (i32 (kind node:$addr,
 578                                  (i32 (trunc (i64 node:$val))))))), 255)>;
 579 class zext_bin_rmw_16_64<PatFrag kind> :
 580   PatFrag<(ops node:$addr, node:$val),
 581     (and (i64 (anyext (i32 (kind node:$addr,
 582                                  (i32 (trunc (i64 node:$val))))))), 65535)>;
 583 class zext_bin_rmw_32_64<PatFrag kind> :
 584   PatFrag<(ops node:$addr, node:$val),
 585           (zext (i32 (kind node:$addr, (i32 (trunc (i64 node:$val))))))>;
 586
 587 // Truncating & sign-extending binary RMW patterns.
 588 // These are combined patterns of truncating store patterns and sign-extending
 589 // load patterns above. We match subword RMWs (for 32-bit) and anyext RMWs (for
 590 // 64-bit) and select a zext RMW; the next instruction will be sext_inreg which
 591 // is selected by itself.
 592 class sext_bin_rmw_8_32<PatFrag kind> :
 593   PatFrag<(ops node:$addr, node:$val), (kind node:$addr, node:$val)>;
 594 class sext_bin_rmw_16_32<PatFrag kind> : sext_bin_rmw_8_32<kind>;
 595 class sext_bin_rmw_8_64<PatFrag kind> :
 596   PatFrag<(ops node:$addr, node:$val),
 597           (anyext (i32 (kind node:$addr, (i32 (trunc (i64 node:$val))))))>;
 598 class sext_bin_rmw_16_64<PatFrag kind> : sext_bin_rmw_8_64<kind>;
 599 // 32->64 sext RMW gets selected as i32.atomic.rmw.***, i64.extend_i32_s
 600
 601 // Patterns for various addressing modes for truncating-extending binary RMWs.
 602 multiclass BinRMWTruncExtPattern<
 603   PatFrag rmw_8, PatFrag rmw_16, PatFrag rmw_32, PatFrag rmw_64,
 604   NI inst8_32, NI inst16_32, NI inst8_64, NI inst16_64, NI inst32_64> {
 605   // Truncating-extending binary RMWs with no constant offset
 606   def : BinRMWPatNoOffset<i32, zext_bin_rmw_8_32<rmw_8>, inst8_32>;
 607   def : BinRMWPatNoOffset<i32, zext_bin_rmw_16_32<rmw_16>, inst16_32>;
 608   def : BinRMWPatNoOffset<i64, zext_bin_rmw_8_64<rmw_8>, inst8_64>;
 609   def : BinRMWPatNoOffset<i64, zext_bin_rmw_16_64<rmw_16>, inst16_64>;
 610   def : BinRMWPatNoOffset<i64, zext_bin_rmw_32_64<rmw_32>, inst32_64>;
 611
 612   def : BinRMWPatNoOffset<i32, sext_bin_rmw_8_32<rmw_8>, inst8_32>;
 613   def : BinRMWPatNoOffset<i32, sext_bin_rmw_16_32<rmw_16>, inst16_32>;
 614   def : BinRMWPatNoOffset<i64, sext_bin_rmw_8_64<rmw_8>, inst8_64>;
 615   def : BinRMWPatNoOffset<i64, sext_bin_rmw_16_64<rmw_16>, inst16_64>;
 616
 617   // Truncating-extending binary RMWs with a constant offset
 618   def : BinRMWPatImmOff<i32, zext_bin_rmw_8_32<rmw_8>, regPlusImm, inst8_32>;
 619   def : BinRMWPatImmOff<i32, zext_bin_rmw_16_32<rmw_16>, regPlusImm, inst16_32>;
 620   def : BinRMWPatImmOff<i64, zext_bin_rmw_8_64<rmw_8>, regPlusImm, inst8_64>;
 621   def : BinRMWPatImmOff<i64, zext_bin_rmw_16_64<rmw_16>, regPlusImm, inst16_64>;
 622   def : BinRMWPatImmOff<i64, zext_bin_rmw_32_64<rmw_32>, regPlusImm, inst32_64>;
 623   def : BinRMWPatImmOff<i32, zext_bin_rmw_8_32<rmw_8>, or_is_add, inst8_32>;
 624   def : BinRMWPatImmOff<i32, zext_bin_rmw_16_32<rmw_16>, or_is_add, inst16_32>;
 625   def : BinRMWPatImmOff<i64, zext_bin_rmw_8_64<rmw_8>, or_is_add, inst8_64>;
 626   def : BinRMWPatImmOff<i64, zext_bin_rmw_16_64<rmw_16>, or_is_add, inst16_64>;
 627   def : BinRMWPatImmOff<i64, zext_bin_rmw_32_64<rmw_32>, or_is_add, inst32_64>;
 628
 629   def : BinRMWPatImmOff<i32, sext_bin_rmw_8_32<rmw_8>, regPlusImm, inst8_32>;
 630   def : BinRMWPatImmOff<i32, sext_bin_rmw_16_32<rmw_16>, regPlusImm, inst16_32>;
 631   def : BinRMWPatImmOff<i64, sext_bin_rmw_8_64<rmw_8>, regPlusImm, inst8_64>;
 632   def : BinRMWPatImmOff<i64, sext_bin_rmw_16_64<rmw_16>, regPlusImm, inst16_64>;
 633   def : BinRMWPatImmOff<i32, sext_bin_rmw_8_32<rmw_8>, or_is_add, inst8_32>;
 634   def : BinRMWPatImmOff<i32, sext_bin_rmw_16_32<rmw_16>, or_is_add, inst16_32>;
 635   def : BinRMWPatImmOff<i64, sext_bin_rmw_8_64<rmw_8>, or_is_add, inst8_64>;
 636   def : BinRMWPatImmOff<i64, sext_bin_rmw_16_64<rmw_16>, or_is_add, inst16_64>;
 637
 638   def : BinRMWPatGlobalAddr<i32, zext_bin_rmw_8_32<rmw_8>, inst8_32>;
 639   def : BinRMWPatGlobalAddr<i32, zext_bin_rmw_16_32<rmw_16>, inst16_32>;
 640   def : BinRMWPatGlobalAddr<i64, zext_bin_rmw_8_64<rmw_8>, inst8_64>;
 641   def : BinRMWPatGlobalAddr<i64, zext_bin_rmw_16_64<rmw_16>, inst16_64>;
 642   def : BinRMWPatGlobalAddr<i64, zext_bin_rmw_32_64<rmw_32>, inst32_64>;
 643
 644   def : BinRMWPatGlobalAddr<i32, sext_bin_rmw_8_32<rmw_8>, inst8_32>;
 645   def : BinRMWPatGlobalAddr<i32, sext_bin_rmw_16_32<rmw_16>, inst16_32>;
 646   def : BinRMWPatGlobalAddr<i64, sext_bin_rmw_8_64<rmw_8>, inst8_64>;
 647   def : BinRMWPatGlobalAddr<i64, sext_bin_rmw_16_64<rmw_16>, inst16_64>;
 648
 649   // Truncating-extending binary RMWs with just a constant offset
 650   def : BinRMWPatOffsetOnly<i32, zext_bin_rmw_8_32<rmw_8>, inst8_32>;
 651   def : BinRMWPatOffsetOnly<i32, zext_bin_rmw_16_32<rmw_16>, inst16_32>;
 652   def : BinRMWPatOffsetOnly<i64, zext_bin_rmw_8_64<rmw_8>, inst8_64>;
 653   def : BinRMWPatOffsetOnly<i64, zext_bin_rmw_16_64<rmw_16>, inst16_64>;
 654   def : BinRMWPatOffsetOnly<i64, zext_bin_rmw_32_64<rmw_32>, inst32_64>;
 655
 656   def : BinRMWPatOffsetOnly<i32, sext_bin_rmw_8_32<rmw_8>, inst8_32>;
 657   def : BinRMWPatOffsetOnly<i32, sext_bin_rmw_16_32<rmw_16>, inst16_32>;
 658   def : BinRMWPatOffsetOnly<i64, sext_bin_rmw_8_64<rmw_8>, inst8_64>;
 659   def : BinRMWPatOffsetOnly<i64, sext_bin_rmw_16_64<rmw_16>, inst16_64>;
 660
 661   def : BinRMWPatGlobalAddrOffOnly<i32, zext_bin_rmw_8_32<rmw_8>, inst8_32>;
 662   def : BinRMWPatGlobalAddrOffOnly<i32, zext_bin_rmw_16_32<rmw_16>, inst16_32>;
 663   def : BinRMWPatGlobalAddrOffOnly<i64, zext_bin_rmw_8_64<rmw_8>, inst8_64>;
 664   def : BinRMWPatGlobalAddrOffOnly<i64, zext_bin_rmw_16_64<rmw_16>, inst16_64>;
 665   def : BinRMWPatGlobalAddrOffOnly<i64, zext_bin_rmw_32_64<rmw_32>, inst32_64>;
 666
 667   def : BinRMWPatGlobalAddrOffOnly<i32, sext_bin_rmw_8_32<rmw_8>, inst8_32>;
 668   def : BinRMWPatGlobalAddrOffOnly<i32, sext_bin_rmw_16_32<rmw_16>, inst16_32>;
 669   def : BinRMWPatGlobalAddrOffOnly<i64, sext_bin_rmw_8_64<rmw_8>, inst8_64>;
 670   def : BinRMWPatGlobalAddrOffOnly<i64, sext_bin_rmw_16_64<rmw_16>, inst16_64>;
 671 }
 672
 673 let Predicates = [HasAtomics] in {
 674 defm : BinRMWTruncExtPattern<
 675   atomic_load_add_8, atomic_load_add_16, atomic_load_add_32, atomic_load_add_64,
 676   ATOMIC_RMW8_U_ADD_I32, ATOMIC_RMW16_U_ADD_I32,
 677   ATOMIC_RMW8_U_ADD_I64, ATOMIC_RMW16_U_ADD_I64, ATOMIC_RMW32_U_ADD_I64>;
 678 defm : BinRMWTruncExtPattern<
 679   atomic_load_sub_8, atomic_load_sub_16, atomic_load_sub_32, atomic_load_sub_64,
 680   ATOMIC_RMW8_U_SUB_I32, ATOMIC_RMW16_U_SUB_I32,
 681   ATOMIC_RMW8_U_SUB_I64, ATOMIC_RMW16_U_SUB_I64, ATOMIC_RMW32_U_SUB_I64>;
 682 defm : BinRMWTruncExtPattern<
 683   atomic_load_and_8, atomic_load_and_16, atomic_load_and_32, atomic_load_and_64,
 684   ATOMIC_RMW8_U_AND_I32, ATOMIC_RMW16_U_AND_I32,
 685   ATOMIC_RMW8_U_AND_I64, ATOMIC_RMW16_U_AND_I64, ATOMIC_RMW32_U_AND_I64>;
 686 defm : BinRMWTruncExtPattern<
 687   atomic_load_or_8, atomic_load_or_16, atomic_load_or_32, atomic_load_or_64,
 688   ATOMIC_RMW8_U_OR_I32, ATOMIC_RMW16_U_OR_I32,
 689   ATOMIC_RMW8_U_OR_I64, ATOMIC_RMW16_U_OR_I64, ATOMIC_RMW32_U_OR_I64>;
 690 defm : BinRMWTruncExtPattern<
 691   atomic_load_xor_8, atomic_load_xor_16, atomic_load_xor_32, atomic_load_xor_64,
 692   ATOMIC_RMW8_U_XOR_I32, ATOMIC_RMW16_U_XOR_I32,
 693   ATOMIC_RMW8_U_XOR_I64, ATOMIC_RMW16_U_XOR_I64, ATOMIC_RMW32_U_XOR_I64>;
 694 defm : BinRMWTruncExtPattern<
 695   atomic_swap_8, atomic_swap_16, atomic_swap_32, atomic_swap_64,
 696   ATOMIC_RMW8_U_XCHG_I32, ATOMIC_RMW16_U_XCHG_I32,
 697   ATOMIC_RMW8_U_XCHG_I64, ATOMIC_RMW16_U_XCHG_I64, ATOMIC_RMW32_U_XCHG_I64>;
 698 } // Predicates = [HasAtomics]
 699
 700 //===----------------------------------------------------------------------===//
 701 // Atomic ternary read-modify-writes
 702 //===----------------------------------------------------------------------===//
 703
 704 // TODO LLVM IR's cmpxchg instruction returns a pair of {loaded value, success
 705 // flag}. When we use the success flag or both values, we can't make use of i64
 706 // truncate/extend versions of instructions for now, which is suboptimal.
 707 // Consider adding a pass after instruction selection that optimizes this case
 708 // if it is frequent.
 709
 710 multiclass WebAssemblyTerRMW<WebAssemblyRegClass rc, string name,
 711                              int atomic_op> {
 712   defm "" :
 713     ATOMIC_I<(outs rc:$dst),
 714              (ins P2Align:$p2align, offset32_op:$off, I32:$addr, rc:$exp,
 715                   rc:$new_),
 716              (outs), (ins P2Align:$p2align, offset32_op:$off), [],
 717              !strconcat(name, "\t$dst, ${off}(${addr})${p2align}, $exp, $new_"),
 718              !strconcat(name, "\t${off}${p2align}"), atomic_op>;
 719 }
 720
 721 defm ATOMIC_RMW_CMPXCHG_I32 :
 722   WebAssemblyTerRMW<I32, "i32.atomic.rmw.cmpxchg", 0x48>;
 723 defm ATOMIC_RMW_CMPXCHG_I64 :
 724   WebAssemblyTerRMW<I64, "i64.atomic.rmw.cmpxchg", 0x49>;
 725 defm ATOMIC_RMW8_U_CMPXCHG_I32 :
 726   WebAssemblyTerRMW<I32, "i32.atomic.rmw8.cmpxchg_u", 0x4a>;
 727 defm ATOMIC_RMW16_U_CMPXCHG_I32 :
 728   WebAssemblyTerRMW<I32, "i32.atomic.rmw16.cmpxchg_u", 0x4b>;
 729 defm ATOMIC_RMW8_U_CMPXCHG_I64 :
 730   WebAssemblyTerRMW<I64, "i64.atomic.rmw8.cmpxchg_u", 0x4c>;
 731 defm ATOMIC_RMW16_U_CMPXCHG_I64 :
 732   WebAssemblyTerRMW<I64, "i64.atomic.rmw16.cmpxchg_u", 0x4d>;
 733 defm ATOMIC_RMW32_U_CMPXCHG_I64 :
 734   WebAssemblyTerRMW<I64, "i64.atomic.rmw32.cmpxchg_u", 0x4e>;
 735
 736 // Select ternary RMWs with no constant offset.
 737 class TerRMWPatNoOffset<ValueType ty, PatFrag kind, NI inst> :
 738   Pat<(ty (kind I32:$addr, ty:$exp, ty:$new)),
 739       (inst 0, 0, I32:$addr, ty:$exp, ty:$new)>;
 740
 741 // Select ternary RMWs with a constant offset.
 742
 743 // Pattern with address + immediate offset
 744 class TerRMWPatImmOff<ValueType ty, PatFrag kind, PatFrag operand, NI inst> :
 745   Pat<(ty (kind (operand I32:$addr, imm:$off), ty:$exp, ty:$new)),
 746       (inst 0, imm:$off, I32:$addr, ty:$exp, ty:$new)>;
 747
 748 class TerRMWPatGlobalAddr<ValueType ty, PatFrag kind, NI inst> :
 749   Pat<(ty (kind (regPlusGA I32:$addr, (WebAssemblywrapper tglobaladdr:$off)),
 750                 ty:$exp, ty:$new)),
 751       (inst 0, tglobaladdr:$off, I32:$addr, ty:$exp, ty:$new)>;
 752
 753 // Select ternary RMWs with just a constant offset.
 754 class TerRMWPatOffsetOnly<ValueType ty, PatFrag kind, NI inst> :
 755   Pat<(ty (kind imm:$off, ty:$exp, ty:$new)),
 756       (inst 0, imm:$off, (CONST_I32 0), ty:$exp, ty:$new)>;
 757
 758 class TerRMWPatGlobalAddrOffOnly<ValueType ty, PatFrag kind, NI inst> :
 759   Pat<(ty (kind (WebAssemblywrapper tglobaladdr:$off), ty:$exp, ty:$new)),
 760       (inst 0, tglobaladdr:$off, (CONST_I32 0), ty:$exp, ty:$new)>;
 761
 762 // Patterns for various addressing modes.
 763 multiclass TerRMWPattern<PatFrag rmw_32, PatFrag rmw_64, NI inst_32,
 764                          NI inst_64> {
 765   def : TerRMWPatNoOffset<i32, rmw_32, inst_32>;
 766   def : TerRMWPatNoOffset<i64, rmw_64, inst_64>;
 767
 768   def : TerRMWPatImmOff<i32, rmw_32, regPlusImm, inst_32>;
 769   def : TerRMWPatImmOff<i64, rmw_64, regPlusImm, inst_64>;
 770   def : TerRMWPatImmOff<i32, rmw_32, or_is_add, inst_32>;
 771   def : TerRMWPatImmOff<i64, rmw_64, or_is_add, inst_64>;
 772
 773   def : TerRMWPatGlobalAddr<i32, rmw_32, inst_32>;
 774   def : TerRMWPatGlobalAddr<i64, rmw_64, inst_64>;
 775
 776   def : TerRMWPatOffsetOnly<i32, rmw_32, inst_32>;
 777   def : TerRMWPatOffsetOnly<i64, rmw_64, inst_64>;
 778
 779   def : TerRMWPatGlobalAddrOffOnly<i32, rmw_32, inst_32>;
 780   def : TerRMWPatGlobalAddrOffOnly<i64, rmw_64, inst_64>;
 781 }
 782
 783 let Predicates = [HasAtomics] in
 784 defm : TerRMWPattern<atomic_cmp_swap_32, atomic_cmp_swap_64,
 785                      ATOMIC_RMW_CMPXCHG_I32, ATOMIC_RMW_CMPXCHG_I64>;
 786
 787 // Truncating & zero-extending ternary RMW patterns.
 788 // DAG legalization & optimization before instruction selection may introduce
 789 // additional nodes such as anyext or assertzext depending on operand types.
 790 class zext_ter_rmw_8_32<PatFrag kind> :
 791   PatFrag<(ops node:$addr, node:$exp, node:$new),
 792           (and (i32 (kind node:$addr, node:$exp, node:$new)), 255)>;
 793 class zext_ter_rmw_16_32<PatFrag kind> :
 794   PatFrag<(ops node:$addr, node:$exp, node:$new),
 795           (and (i32 (kind node:$addr, node:$exp, node:$new)), 65535)>;
 796 class zext_ter_rmw_8_64<PatFrag kind> :
 797   PatFrag<(ops node:$addr, node:$exp, node:$new),
 798           (zext (i32 (assertzext (i32 (kind node:$addr,
 799                                             (i32 (trunc (i64 node:$exp))),
 800                                             (i32 (trunc (i64 node:$new))))))))>;
 801 class zext_ter_rmw_16_64<PatFrag kind> : zext_ter_rmw_8_64<kind>;
 802 class zext_ter_rmw_32_64<PatFrag kind> :
 803   PatFrag<(ops node:$addr, node:$exp, node:$new),
 804           (zext (i32 (kind node:$addr,
 805                            (i32 (trunc (i64 node:$exp))),
 806                            (i32 (trunc (i64 node:$new))))))>;
 807
 808 // Truncating & sign-extending ternary RMW patterns.
 809 // We match subword RMWs (for 32-bit) and anyext RMWs (for 64-bit) and select a
 810 // zext RMW; the next instruction will be sext_inreg which is selected by
 811 // itself.
 812 class sext_ter_rmw_8_32<PatFrag kind> :
 813   PatFrag<(ops node:$addr, node:$exp, node:$new),
 814           (kind node:$addr, node:$exp, node:$new)>;
 815 class sext_ter_rmw_16_32<PatFrag kind> : sext_ter_rmw_8_32<kind>;
 816 class sext_ter_rmw_8_64<PatFrag kind> :
 817   PatFrag<(ops node:$addr, node:$exp, node:$new),
 818           (anyext (i32 (assertzext (i32
 819             (kind node:$addr,
 820                   (i32 (trunc (i64 node:$exp))),
 821                   (i32 (trunc (i64 node:$new))))))))>;
 822 class sext_ter_rmw_16_64<PatFrag kind> : sext_ter_rmw_8_64<kind>;
 823 // 32->64 sext RMW gets selected as i32.atomic.rmw.***, i64.extend_i32_s
 824
 825 // Patterns for various addressing modes for truncating-extending ternary RMWs.
 826 multiclass TerRMWTruncExtPattern<
 827   PatFrag rmw_8, PatFrag rmw_16, PatFrag rmw_32, PatFrag rmw_64,
 828   NI inst8_32, NI inst16_32, NI inst8_64, NI inst16_64, NI inst32_64> {
 829   // Truncating-extending ternary RMWs with no constant offset
 830   def : TerRMWPatNoOffset<i32, zext_ter_rmw_8_32<rmw_8>, inst8_32>;
 831   def : TerRMWPatNoOffset<i32, zext_ter_rmw_16_32<rmw_16>, inst16_32>;
 832   def : TerRMWPatNoOffset<i64, zext_ter_rmw_8_64<rmw_8>, inst8_64>;
 833   def : TerRMWPatNoOffset<i64, zext_ter_rmw_16_64<rmw_16>, inst16_64>;
 834   def : TerRMWPatNoOffset<i64, zext_ter_rmw_32_64<rmw_32>, inst32_64>;
 835
 836   def : TerRMWPatNoOffset<i32, sext_ter_rmw_8_32<rmw_8>, inst8_32>;
 837   def : TerRMWPatNoOffset<i32, sext_ter_rmw_16_32<rmw_16>, inst16_32>;
 838   def : TerRMWPatNoOffset<i64, sext_ter_rmw_8_64<rmw_8>, inst8_64>;
 839   def : TerRMWPatNoOffset<i64, sext_ter_rmw_16_64<rmw_16>, inst16_64>;
 840
 841   // Truncating-extending ternary RMWs with a constant offset
 842   def : TerRMWPatImmOff<i32, zext_ter_rmw_8_32<rmw_8>, regPlusImm, inst8_32>;
 843   def : TerRMWPatImmOff<i32, zext_ter_rmw_16_32<rmw_16>, regPlusImm, inst16_32>;
 844   def : TerRMWPatImmOff<i64, zext_ter_rmw_8_64<rmw_8>, regPlusImm, inst8_64>;
 845   def : TerRMWPatImmOff<i64, zext_ter_rmw_16_64<rmw_16>, regPlusImm, inst16_64>;
 846   def : TerRMWPatImmOff<i64, zext_ter_rmw_32_64<rmw_32>, regPlusImm, inst32_64>;
 847   def : TerRMWPatImmOff<i32, zext_ter_rmw_8_32<rmw_8>, or_is_add, inst8_32>;
 848   def : TerRMWPatImmOff<i32, zext_ter_rmw_16_32<rmw_16>, or_is_add, inst16_32>;
 849   def : TerRMWPatImmOff<i64, zext_ter_rmw_8_64<rmw_8>, or_is_add, inst8_64>;
 850   def : TerRMWPatImmOff<i64, zext_ter_rmw_16_64<rmw_16>, or_is_add, inst16_64>;
 851   def : TerRMWPatImmOff<i64, zext_ter_rmw_32_64<rmw_32>, or_is_add, inst32_64>;
 852
 853   def : TerRMWPatImmOff<i32, sext_ter_rmw_8_32<rmw_8>, regPlusImm, inst8_32>;
 854   def : TerRMWPatImmOff<i32, sext_ter_rmw_16_32<rmw_16>, regPlusImm, inst16_32>;
 855   def : TerRMWPatImmOff<i64, sext_ter_rmw_8_64<rmw_8>, regPlusImm, inst8_64>;
 856   def : TerRMWPatImmOff<i64, sext_ter_rmw_16_64<rmw_16>, regPlusImm, inst16_64>;
 857   def : TerRMWPatImmOff<i32, sext_ter_rmw_8_32<rmw_8>, or_is_add, inst8_32>;
 858   def : TerRMWPatImmOff<i32, sext_ter_rmw_16_32<rmw_16>, or_is_add, inst16_32>;
 859   def : TerRMWPatImmOff<i64, sext_ter_rmw_8_64<rmw_8>, or_is_add, inst8_64>;
 860   def : TerRMWPatImmOff<i64, sext_ter_rmw_16_64<rmw_16>, or_is_add, inst16_64>;
 861
 862   def : TerRMWPatGlobalAddr<i32, zext_ter_rmw_8_32<rmw_8>, inst8_32>;
 863   def : TerRMWPatGlobalAddr<i32, zext_ter_rmw_16_32<rmw_16>, inst16_32>;
 864   def : TerRMWPatGlobalAddr<i64, zext_ter_rmw_8_64<rmw_8>, inst8_64>;
 865   def : TerRMWPatGlobalAddr<i64, zext_ter_rmw_16_64<rmw_16>, inst16_64>;
 866   def : TerRMWPatGlobalAddr<i64, zext_ter_rmw_32_64<rmw_32>, inst32_64>;
 867
 868   def : TerRMWPatGlobalAddr<i32, sext_ter_rmw_8_32<rmw_8>, inst8_32>;
 869   def : TerRMWPatGlobalAddr<i32, sext_ter_rmw_16_32<rmw_16>, inst16_32>;
 870   def : TerRMWPatGlobalAddr<i64, sext_ter_rmw_8_64<rmw_8>, inst8_64>;
 871   def : TerRMWPatGlobalAddr<i64, sext_ter_rmw_16_64<rmw_16>, inst16_64>;
 872
 873   // Truncating-extending ternary RMWs with just a constant offset
 874   def : TerRMWPatOffsetOnly<i32, zext_ter_rmw_8_32<rmw_8>, inst8_32>;
 875   def : TerRMWPatOffsetOnly<i32, zext_ter_rmw_16_32<rmw_16>, inst16_32>;
 876   def : TerRMWPatOffsetOnly<i64, zext_ter_rmw_8_64<rmw_8>, inst8_64>;
 877   def : TerRMWPatOffsetOnly<i64, zext_ter_rmw_16_64<rmw_16>, inst16_64>;
 878   def : TerRMWPatOffsetOnly<i64, zext_ter_rmw_32_64<rmw_32>, inst32_64>;
 879
 880   def : TerRMWPatOffsetOnly<i32, sext_ter_rmw_8_32<rmw_8>, inst8_32>;
 881   def : TerRMWPatOffsetOnly<i32, sext_ter_rmw_16_32<rmw_16>, inst16_32>;
 882   def : TerRMWPatOffsetOnly<i64, sext_ter_rmw_8_64<rmw_8>, inst8_64>;
 883   def : TerRMWPatOffsetOnly<i64, sext_ter_rmw_16_64<rmw_16>, inst16_64>;
 884
 885   def : TerRMWPatGlobalAddrOffOnly<i32, zext_ter_rmw_8_32<rmw_8>, inst8_32>;
 886   def : TerRMWPatGlobalAddrOffOnly<i32, zext_ter_rmw_16_32<rmw_16>, inst16_32>;
 887   def : TerRMWPatGlobalAddrOffOnly<i64, zext_ter_rmw_8_64<rmw_8>, inst8_64>;
 888   def : TerRMWPatGlobalAddrOffOnly<i64, zext_ter_rmw_16_64<rmw_16>, inst16_64>;
 889   def : TerRMWPatGlobalAddrOffOnly<i64, zext_ter_rmw_32_64<rmw_32>, inst32_64>;
 890
 891   def : TerRMWPatGlobalAddrOffOnly<i32, sext_ter_rmw_8_32<rmw_8>, inst8_32>;
 892   def : TerRMWPatGlobalAddrOffOnly<i32, sext_ter_rmw_16_32<rmw_16>, inst16_32>;
 893   def : TerRMWPatGlobalAddrOffOnly<i64, sext_ter_rmw_8_64<rmw_8>, inst8_64>;
 894   def : TerRMWPatGlobalAddrOffOnly<i64, sext_ter_rmw_16_64<rmw_16>, inst16_64>;
 895 }
 896
 897 let Predicates = [HasAtomics] in
 898 defm : TerRMWTruncExtPattern<
 899   atomic_cmp_swap_8, atomic_cmp_swap_16, atomic_cmp_swap_32, atomic_cmp_swap_64,
 900   ATOMIC_RMW8_U_CMPXCHG_I32, ATOMIC_RMW16_U_CMPXCHG_I32,
 901   ATOMIC_RMW8_U_CMPXCHG_I64, ATOMIC_RMW16_U_CMPXCHG_I64,
 902   ATOMIC_RMW32_U_CMPXCHG_I64>;