lib/Target/ARM64/ARM64InstrAtomics.td

   1 //===- ARM64InstrAtomics.td - ARM64 Atomic codegen support -*- tablegen -*-===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9 //
  10 // ARM64 Atomic operand code-gen constructs.
  11 //
  12 //===----------------------------------------------------------------------===//
  13
  14 //===----------------------------------
  15 // Atomic fences
  16 //===----------------------------------
  17 def : Pat<(atomic_fence (i64 4), (imm)), (DMB (i32 0x9))>;
  18 def : Pat<(atomic_fence (imm), (imm)), (DMB (i32 0xb))>;
  19
  20 //===----------------------------------
  21 // Atomic loads
  22 //===----------------------------------
  23
  24 // When they're actually atomic, only one addressing mode (GPR64sp) is
  25 // supported, but when they're relaxed and anything can be used, all the
  26 // standard modes would be valid and may give efficiency gains.
  27
  28 // A atomic load operation that actually needs acquire semantics.
  29 class acquiring_load<PatFrag base>
  30   : PatFrag<(ops node:$ptr), (base node:$ptr), [{
  31   AtomicOrdering Ordering = cast<AtomicSDNode>(N)->getOrdering();
  32   assert(Ordering != AcquireRelease && "unexpected load ordering");
  33   return Ordering == Acquire || Ordering == SequentiallyConsistent;
  34 }]>;
  35
  36 // An atomic load operation that does not need either acquire or release
  37 // semantics.
  38 class relaxed_load<PatFrag base>
  39   : PatFrag<(ops node:$ptr), (base node:$ptr), [{
  40   AtomicOrdering Ordering = cast<AtomicSDNode>(N)->getOrdering();
  41   return Ordering == Monotonic || Ordering == Unordered;
  42 }]>;
  43
  44 // 8-bit loads
  45 def : Pat<(acquiring_load<atomic_load_8>  GPR64sp:$ptr), (LDARB GPR64sp:$ptr)>;
  46 def : Pat<(relaxed_load<atomic_load_8> ro_indexed8:$addr),
  47           (LDRBBro ro_indexed8:$addr)>;
  48 def : Pat<(relaxed_load<atomic_load_8> am_indexed8:$addr),
  49           (LDRBBui am_indexed8:$addr)>;
  50 def : Pat<(relaxed_load<atomic_load_8> am_unscaled8:$addr),
  51           (LDURBBi am_unscaled8:$addr)>;
  52
  53 // 16-bit loads
  54 def : Pat<(acquiring_load<atomic_load_16> GPR64sp:$ptr), (LDARH GPR64sp:$ptr)>;
  55 def : Pat<(relaxed_load<atomic_load_16> ro_indexed16:$addr),
  56           (LDRHHro ro_indexed16:$addr)>;
  57 def : Pat<(relaxed_load<atomic_load_16> am_indexed16:$addr),
  58           (LDRHHui am_indexed16:$addr)>;
  59 def : Pat<(relaxed_load<atomic_load_16> am_unscaled16:$addr),
  60           (LDURHHi am_unscaled16:$addr)>;
  61
  62 // 32-bit loads
  63 def : Pat<(acquiring_load<atomic_load_32> GPR64sp:$ptr), (LDARW GPR64sp:$ptr)>;
  64 def : Pat<(relaxed_load<atomic_load_32> ro_indexed32:$addr),
  65           (LDRWro ro_indexed32:$addr)>;
  66 def : Pat<(relaxed_load<atomic_load_32> am_indexed32:$addr),
  67           (LDRWui am_indexed32:$addr)>;
  68 def : Pat<(relaxed_load<atomic_load_32> am_unscaled32:$addr),
  69           (LDURWi am_unscaled32:$addr)>;
  70
  71 // 64-bit loads
  72 def : Pat<(acquiring_load<atomic_load_64> GPR64sp:$ptr), (LDARX GPR64sp:$ptr)>;
  73 def : Pat<(relaxed_load<atomic_load_64> ro_indexed64:$addr),
  74           (LDRXro ro_indexed64:$addr)>;
  75 def : Pat<(relaxed_load<atomic_load_64> am_indexed64:$addr),
  76           (LDRXui am_indexed64:$addr)>;
  77 def : Pat<(relaxed_load<atomic_load_64> am_unscaled64:$addr),
  78           (LDURXi am_unscaled64:$addr)>;
  79
  80 //===----------------------------------
  81 // Atomic stores
  82 //===----------------------------------
  83
  84 // When they're actually atomic, only one addressing mode (GPR64sp) is
  85 // supported, but when they're relaxed and anything can be used, all the
  86 // standard modes would be valid and may give efficiency gains.
  87
  88 // A store operation that actually needs release semantics.
  89 class releasing_store<PatFrag base>
  90   : PatFrag<(ops node:$ptr, node:$val), (base node:$ptr, node:$val), [{
  91   AtomicOrdering Ordering = cast<AtomicSDNode>(N)->getOrdering();
  92   assert(Ordering != AcquireRelease && "unexpected store ordering");
  93   return Ordering == Release || Ordering == SequentiallyConsistent;
  94 }]>;
  95
  96 // An atomic store operation that doesn't actually need to be atomic on ARM64.
  97 class relaxed_store<PatFrag base>
  98   : PatFrag<(ops node:$ptr, node:$val), (base node:$ptr, node:$val), [{
  99   AtomicOrdering Ordering = cast<AtomicSDNode>(N)->getOrdering();
 100   return Ordering == Monotonic || Ordering == Unordered;
 101 }]>;
 102
 103 // 8-bit stores
 104 def : Pat<(releasing_store<atomic_store_8> GPR64sp:$ptr, GPR32:$val),
 105           (STLRB GPR32:$val, GPR64sp:$ptr)>;
 106 def : Pat<(relaxed_store<atomic_store_8> ro_indexed8:$ptr, GPR32:$val),
 107           (STRBBro GPR32:$val, ro_indexed8:$ptr)>;
 108 def : Pat<(relaxed_store<atomic_store_8> am_indexed8:$ptr, GPR32:$val),
 109           (STRBBui GPR32:$val, am_indexed8:$ptr)>;
 110 def : Pat<(relaxed_store<atomic_store_8> am_unscaled8:$ptr, GPR32:$val),
 111           (STURBBi GPR32:$val, am_unscaled8:$ptr)>;
 112
 113 // 16-bit stores
 114 def : Pat<(releasing_store<atomic_store_16> GPR64sp:$ptr, GPR32:$val),
 115           (STLRH GPR32:$val, GPR64sp:$ptr)>;
 116 def : Pat<(relaxed_store<atomic_store_16> ro_indexed16:$ptr, GPR32:$val),
 117           (STRHHro GPR32:$val, ro_indexed16:$ptr)>;
 118 def : Pat<(relaxed_store<atomic_store_16> am_indexed16:$ptr, GPR32:$val),
 119           (STRHHui GPR32:$val, am_indexed16:$ptr)>;
 120 def : Pat<(relaxed_store<atomic_store_16> am_unscaled16:$ptr, GPR32:$val),
 121           (STURHHi GPR32:$val, am_unscaled16:$ptr)>;
 122
 123 // 32-bit stores
 124 def : Pat<(releasing_store<atomic_store_32> GPR64sp:$ptr, GPR32:$val),
 125           (STLRW GPR32:$val, GPR64sp:$ptr)>;
 126 def : Pat<(relaxed_store<atomic_store_32> ro_indexed32:$ptr, GPR32:$val),
 127           (STRWro GPR32:$val, ro_indexed32:$ptr)>;
 128 def : Pat<(relaxed_store<atomic_store_32> am_indexed32:$ptr, GPR32:$val),
 129           (STRWui GPR32:$val, am_indexed32:$ptr)>;
 130 def : Pat<(relaxed_store<atomic_store_32> am_unscaled32:$ptr, GPR32:$val),
 131           (STURWi GPR32:$val, am_unscaled32:$ptr)>;
 132
 133 // 64-bit stores
 134 def : Pat<(releasing_store<atomic_store_64> GPR64sp:$ptr, GPR64:$val),
 135           (STLRX GPR64:$val, GPR64sp:$ptr)>;
 136 def : Pat<(relaxed_store<atomic_store_64> ro_indexed64:$ptr, GPR64:$val),
 137           (STRXro GPR64:$val, ro_indexed64:$ptr)>;
 138 def : Pat<(relaxed_store<atomic_store_64> am_indexed64:$ptr, GPR64:$val),
 139           (STRXui GPR64:$val, am_indexed64:$ptr)>;
 140 def : Pat<(relaxed_store<atomic_store_64> am_unscaled64:$ptr, GPR64:$val),
 141           (STURXi GPR64:$val, am_unscaled64:$ptr)>;
 142
 143 //===----------------------------------
 144 // Low-level exclusive operations
 145 //===----------------------------------
 146
 147 // Load-exclusives.
 148
 149 def ldxr_1 : PatFrag<(ops node:$ptr), (int_arm64_ldxr node:$ptr), [{
 150   return cast<MemIntrinsicSDNode>(N)->getMemoryVT() == MVT::i8;
 151 }]>;
 152
 153 def ldxr_2 : PatFrag<(ops node:$ptr), (int_arm64_ldxr node:$ptr), [{
 154   return cast<MemIntrinsicSDNode>(N)->getMemoryVT() == MVT::i16;
 155 }]>;
 156
 157 def ldxr_4 : PatFrag<(ops node:$ptr), (int_arm64_ldxr node:$ptr), [{
 158   return cast<MemIntrinsicSDNode>(N)->getMemoryVT() == MVT::i32;
 159 }]>;
 160
 161 def ldxr_8 : PatFrag<(ops node:$ptr), (int_arm64_ldxr node:$ptr), [{
 162   return cast<MemIntrinsicSDNode>(N)->getMemoryVT() == MVT::i64;
 163 }]>;
 164
 165 def : Pat<(ldxr_1 am_noindex:$addr),
 166           (SUBREG_TO_REG (i64 0), (LDXRB am_noindex:$addr), sub_32)>;
 167 def : Pat<(ldxr_2 am_noindex:$addr),
 168           (SUBREG_TO_REG (i64 0), (LDXRH am_noindex:$addr), sub_32)>;
 169 def : Pat<(ldxr_4 am_noindex:$addr),
 170           (SUBREG_TO_REG (i64 0), (LDXRW am_noindex:$addr), sub_32)>;
 171 def : Pat<(ldxr_8 am_noindex:$addr), (LDXRX am_noindex:$addr)>;
 172
 173 def : Pat<(and (ldxr_1 am_noindex:$addr), 0xff),
 174           (SUBREG_TO_REG (i64 0), (LDXRB am_noindex:$addr), sub_32)>;
 175 def : Pat<(and (ldxr_2 am_noindex:$addr), 0xffff),
 176           (SUBREG_TO_REG (i64 0), (LDXRH am_noindex:$addr), sub_32)>;
 177 def : Pat<(and (ldxr_4 am_noindex:$addr), 0xffffffff),
 178           (SUBREG_TO_REG (i64 0), (LDXRW am_noindex:$addr), sub_32)>;
 179
 180 // Load-exclusives.
 181
 182 def ldaxr_1 : PatFrag<(ops node:$ptr), (int_arm64_ldaxr node:$ptr), [{
 183   return cast<MemIntrinsicSDNode>(N)->getMemoryVT() == MVT::i8;
 184 }]>;
 185
 186 def ldaxr_2 : PatFrag<(ops node:$ptr), (int_arm64_ldaxr node:$ptr), [{
 187   return cast<MemIntrinsicSDNode>(N)->getMemoryVT() == MVT::i16;
 188 }]>;
 189
 190 def ldaxr_4 : PatFrag<(ops node:$ptr), (int_arm64_ldaxr node:$ptr), [{
 191   return cast<MemIntrinsicSDNode>(N)->getMemoryVT() == MVT::i32;
 192 }]>;
 193
 194 def ldaxr_8 : PatFrag<(ops node:$ptr), (int_arm64_ldaxr node:$ptr), [{
 195   return cast<MemIntrinsicSDNode>(N)->getMemoryVT() == MVT::i64;
 196 }]>;
 197
 198 def : Pat<(ldaxr_1 am_noindex:$addr),
 199           (SUBREG_TO_REG (i64 0), (LDAXRB am_noindex:$addr), sub_32)>;
 200 def : Pat<(ldaxr_2 am_noindex:$addr),
 201           (SUBREG_TO_REG (i64 0), (LDAXRH am_noindex:$addr), sub_32)>;
 202 def : Pat<(ldaxr_4 am_noindex:$addr),
 203           (SUBREG_TO_REG (i64 0), (LDAXRW am_noindex:$addr), sub_32)>;
 204 def : Pat<(ldaxr_8 am_noindex:$addr), (LDAXRX am_noindex:$addr)>;
 205
 206 def : Pat<(and (ldaxr_1 am_noindex:$addr), 0xff),
 207           (SUBREG_TO_REG (i64 0), (LDAXRB am_noindex:$addr), sub_32)>;
 208 def : Pat<(and (ldaxr_2 am_noindex:$addr), 0xffff),
 209           (SUBREG_TO_REG (i64 0), (LDAXRH am_noindex:$addr), sub_32)>;
 210 def : Pat<(and (ldaxr_4 am_noindex:$addr), 0xffffffff),
 211           (SUBREG_TO_REG (i64 0), (LDAXRW am_noindex:$addr), sub_32)>;
 212
 213 // Store-exclusives.
 214
 215 def stxr_1 : PatFrag<(ops node:$val, node:$ptr),
 216                      (int_arm64_stxr node:$val, node:$ptr), [{
 217   return cast<MemIntrinsicSDNode>(N)->getMemoryVT() == MVT::i8;
 218 }]>;
 219
 220 def stxr_2 : PatFrag<(ops node:$val, node:$ptr),
 221                      (int_arm64_stxr node:$val, node:$ptr), [{
 222   return cast<MemIntrinsicSDNode>(N)->getMemoryVT() == MVT::i16;
 223 }]>;
 224
 225 def stxr_4 : PatFrag<(ops node:$val, node:$ptr),
 226                      (int_arm64_stxr node:$val, node:$ptr), [{
 227   return cast<MemIntrinsicSDNode>(N)->getMemoryVT() == MVT::i32;
 228 }]>;
 229
 230 def stxr_8 : PatFrag<(ops node:$val, node:$ptr),
 231                      (int_arm64_stxr node:$val, node:$ptr), [{
 232   return cast<MemIntrinsicSDNode>(N)->getMemoryVT() == MVT::i64;
 233 }]>;
 234
 235
 236 def : Pat<(stxr_1 GPR64:$val, am_noindex:$addr),
 237           (STXRB (EXTRACT_SUBREG GPR64:$val, sub_32), am_noindex:$addr)>;
 238 def : Pat<(stxr_2 GPR64:$val, am_noindex:$addr),
 239           (STXRH (EXTRACT_SUBREG GPR64:$val, sub_32), am_noindex:$addr)>;
 240 def : Pat<(stxr_4 GPR64:$val, am_noindex:$addr),
 241           (STXRW (EXTRACT_SUBREG GPR64:$val, sub_32), am_noindex:$addr)>;
 242 def : Pat<(stxr_8 GPR64:$val, am_noindex:$addr),
 243           (STXRX GPR64:$val, am_noindex:$addr)>;
 244
 245 def : Pat<(stxr_1 (zext (and GPR32:$val, 0xff)), am_noindex:$addr),
 246           (STXRB GPR32:$val, am_noindex:$addr)>;
 247 def : Pat<(stxr_2 (zext (and GPR32:$val, 0xffff)), am_noindex:$addr),
 248           (STXRH GPR32:$val, am_noindex:$addr)>;
 249 def : Pat<(stxr_4 (zext GPR32:$val), am_noindex:$addr),
 250           (STXRW GPR32:$val, am_noindex:$addr)>;
 251
 252 def : Pat<(stxr_1 (and GPR64:$val, 0xff), am_noindex:$addr),
 253           (STXRB (EXTRACT_SUBREG GPR64:$val, sub_32), am_noindex:$addr)>;
 254 def : Pat<(stxr_2 (and GPR64:$val, 0xffff), am_noindex:$addr),
 255           (STXRH (EXTRACT_SUBREG GPR64:$val, sub_32), am_noindex:$addr)>;
 256 def : Pat<(stxr_4 (and GPR64:$val, 0xffffffff), am_noindex:$addr),
 257           (STXRW (EXTRACT_SUBREG GPR64:$val, sub_32), am_noindex:$addr)>;
 258
 259 // Store-release-exclusives.
 260
 261 def stlxr_1 : PatFrag<(ops node:$val, node:$ptr),
 262                      (int_arm64_stlxr node:$val, node:$ptr), [{
 263   return cast<MemIntrinsicSDNode>(N)->getMemoryVT() == MVT::i8;
 264 }]>;
 265
 266 def stlxr_2 : PatFrag<(ops node:$val, node:$ptr),
 267                      (int_arm64_stlxr node:$val, node:$ptr), [{
 268   return cast<MemIntrinsicSDNode>(N)->getMemoryVT() == MVT::i16;
 269 }]>;
 270
 271 def stlxr_4 : PatFrag<(ops node:$val, node:$ptr),
 272                      (int_arm64_stlxr node:$val, node:$ptr), [{
 273   return cast<MemIntrinsicSDNode>(N)->getMemoryVT() == MVT::i32;
 274 }]>;
 275
 276 def stlxr_8 : PatFrag<(ops node:$val, node:$ptr),
 277                      (int_arm64_stlxr node:$val, node:$ptr), [{
 278   return cast<MemIntrinsicSDNode>(N)->getMemoryVT() == MVT::i64;
 279 }]>;
 280
 281
 282 def : Pat<(stlxr_1 GPR64:$val, am_noindex:$addr),
 283           (STLXRB (EXTRACT_SUBREG GPR64:$val, sub_32), am_noindex:$addr)>;
 284 def : Pat<(stlxr_2 GPR64:$val, am_noindex:$addr),
 285           (STLXRH (EXTRACT_SUBREG GPR64:$val, sub_32), am_noindex:$addr)>;
 286 def : Pat<(stlxr_4 GPR64:$val, am_noindex:$addr),
 287           (STLXRW (EXTRACT_SUBREG GPR64:$val, sub_32), am_noindex:$addr)>;
 288 def : Pat<(stlxr_8 GPR64:$val, am_noindex:$addr),
 289           (STLXRX GPR64:$val, am_noindex:$addr)>;
 290
 291 def : Pat<(stlxr_1 (zext (and GPR32:$val, 0xff)), am_noindex:$addr),
 292           (STLXRB GPR32:$val, am_noindex:$addr)>;
 293 def : Pat<(stlxr_2 (zext (and GPR32:$val, 0xffff)), am_noindex:$addr),
 294           (STLXRH GPR32:$val, am_noindex:$addr)>;
 295 def : Pat<(stlxr_4 (zext GPR32:$val), am_noindex:$addr),
 296           (STLXRW GPR32:$val, am_noindex:$addr)>;
 297
 298 def : Pat<(stlxr_1 (and GPR64:$val, 0xff), am_noindex:$addr),
 299           (STLXRB (EXTRACT_SUBREG GPR64:$val, sub_32), am_noindex:$addr)>;
 300 def : Pat<(stlxr_2 (and GPR64:$val, 0xffff), am_noindex:$addr),
 301           (STLXRH (EXTRACT_SUBREG GPR64:$val, sub_32), am_noindex:$addr)>;
 302 def : Pat<(stlxr_4 (and GPR64:$val, 0xffffffff), am_noindex:$addr),
 303           (STLXRW (EXTRACT_SUBREG GPR64:$val, sub_32), am_noindex:$addr)>;
 304
 305
 306 // And clear exclusive.
 307
 308 def : Pat<(int_arm64_clrex), (CLREX 0xf)>;