lib/Target/Hexagon/HexagonInstrInfoV4.td

   1 //=- HexagonInstrInfoV4.td - Target Desc. for Hexagon Target -*- 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 // This file describes the Hexagon V4 instructions in TableGen format.
  11 //
  12 //===----------------------------------------------------------------------===//
  13
  14 // Hexagon V4 Architecture spec defines 8 instruction classes:
  15 // LD ST ALU32 XTYPE J JR MEMOP NV CR SYSTEM(system is not implemented in the
  16 // compiler)
  17
  18 // LD Instructions:
  19 // ========================================
  20 // Loads (8/16/32/64 bit)
  21 // Deallocframe
  22
  23 // ST Instructions:
  24 // ========================================
  25 // Stores (8/16/32/64 bit)
  26 // Allocframe
  27
  28 // ALU32 Instructions:
  29 // ========================================
  30 // Arithmetic / Logical (32 bit)
  31 // Vector Halfword
  32
  33 // XTYPE Instructions (32/64 bit):
  34 // ========================================
  35 // Arithmetic, Logical, Bit Manipulation
  36 // Multiply (Integer, Fractional, Complex)
  37 // Permute / Vector Permute Operations
  38 // Predicate Operations
  39 // Shift / Shift with Add/Sub/Logical
  40 // Vector Byte ALU
  41 // Vector Halfword (ALU, Shift, Multiply)
  42 // Vector Word (ALU, Shift)
  43
  44 // J Instructions:
  45 // ========================================
  46 // Jump/Call PC-relative
  47
  48 // JR Instructions:
  49 // ========================================
  50 // Jump/Call Register
  51
  52 // MEMOP Instructions:
  53 // ========================================
  54 // Operation on memory (8/16/32 bit)
  55
  56 // NV Instructions:
  57 // ========================================
  58 // New-value Jumps
  59 // New-value Stores
  60
  61 // CR Instructions:
  62 // ========================================
  63 // Control-Register Transfers
  64 // Hardware Loop Setup
  65 // Predicate Logicals & Reductions
  66
  67 // SYSTEM Instructions (not implemented in the compiler):
  68 // ========================================
  69 // Prefetch
  70 // Cache Maintenance
  71 // Bus Operations
  72
  73
  74 //===----------------------------------------------------------------------===//
  75 // ALU32 +
  76 //===----------------------------------------------------------------------===//
  77
  78 // Shift halfword.
  79
  80 let isPredicated = 1 in
  81 def ASLH_cPt_V4 : ALU32_rr<(outs IntRegs:$dst),
  82             (ins PredRegs:$src1, IntRegs:$src2),
  83             "if ($src1) $dst = aslh($src2)",
  84             []>,
  85             Requires<[HasV4T]>;
  86
  87 let isPredicated = 1 in
  88 def ASLH_cNotPt_V4 : ALU32_rr<(outs IntRegs:$dst),
  89             (ins PredRegs:$src1, IntRegs:$src2),
  90             "if (!$src1) $dst = aslh($src2)",
  91             []>,
  92             Requires<[HasV4T]>;
  93
  94 let isPredicated = 1 in
  95 def ASLH_cdnPt_V4 : ALU32_rr<(outs IntRegs:$dst),
  96             (ins PredRegs:$src1, IntRegs:$src2),
  97             "if ($src1.new) $dst = aslh($src2)",
  98             []>,
  99             Requires<[HasV4T]>;
 100
 101 let isPredicated = 1 in
 102 def ASLH_cdnNotPt_V4 : ALU32_rr<(outs IntRegs:$dst),
 103             (ins PredRegs:$src1, IntRegs:$src2),
 104             "if (!$src1.new) $dst = aslh($src2)",
 105             []>,
 106             Requires<[HasV4T]>;
 107
 108 let isPredicated = 1 in
 109 def ASRH_cPt_V4 : ALU32_rr<(outs IntRegs:$dst),
 110             (ins PredRegs:$src1, IntRegs:$src2),
 111             "if ($src1) $dst = asrh($src2)",
 112             []>,
 113             Requires<[HasV4T]>;
 114
 115 let isPredicated = 1 in
 116 def ASRH_cNotPt_V4 : ALU32_rr<(outs IntRegs:$dst),
 117             (ins PredRegs:$src1, IntRegs:$src2),
 118             "if (!$src1) $dst = asrh($src2)",
 119             []>,
 120             Requires<[HasV4T]>;
 121
 122 let isPredicated = 1 in
 123 def ASRH_cdnPt_V4 : ALU32_rr<(outs IntRegs:$dst),
 124             (ins PredRegs:$src1, IntRegs:$src2),
 125             "if ($src1.new) $dst = asrh($src2)",
 126             []>,
 127             Requires<[HasV4T]>;
 128
 129 let isPredicated = 1 in
 130 def ASRH_cdnNotPt_V4 : ALU32_rr<(outs IntRegs:$dst),
 131             (ins PredRegs:$src1, IntRegs:$src2),
 132             "if (!$src1.new) $dst = asrh($src2)",
 133             []>,
 134             Requires<[HasV4T]>;
 135
 136 // Sign extend.
 137
 138 let isPredicated = 1 in
 139 def SXTB_cPt_V4 : ALU32_rr<(outs IntRegs:$dst),
 140             (ins PredRegs:$src1, IntRegs:$src2),
 141             "if ($src1) $dst = sxtb($src2)",
 142             []>,
 143             Requires<[HasV4T]>;
 144
 145 let isPredicated = 1 in
 146 def SXTB_cNotPt_V4 : ALU32_rr<(outs IntRegs:$dst),
 147             (ins PredRegs:$src1, IntRegs:$src2),
 148             "if (!$src1) $dst = sxtb($src2)",
 149             []>,
 150             Requires<[HasV4T]>;
 151
 152 let isPredicated = 1 in
 153 def SXTB_cdnPt_V4 : ALU32_rr<(outs IntRegs:$dst),
 154             (ins PredRegs:$src1, IntRegs:$src2),
 155             "if ($src1.new) $dst = sxtb($src2)",
 156             []>,
 157             Requires<[HasV4T]>;
 158
 159 let isPredicated = 1 in
 160 def SXTB_cdnNotPt_V4 : ALU32_rr<(outs IntRegs:$dst),
 161             (ins PredRegs:$src1, IntRegs:$src2),
 162             "if (!$src1.new) $dst = sxtb($src2)",
 163             []>,
 164             Requires<[HasV4T]>;
 165
 166
 167 let isPredicated = 1 in
 168 def SXTH_cPt_V4 : ALU32_rr<(outs IntRegs:$dst),
 169             (ins PredRegs:$src1, IntRegs:$src2),
 170             "if ($src1) $dst = sxth($src2)",
 171             []>,
 172             Requires<[HasV4T]>;
 173
 174 let isPredicated = 1 in
 175 def SXTH_cNotPt_V4 : ALU32_rr<(outs IntRegs:$dst),
 176             (ins PredRegs:$src1, IntRegs:$src2),
 177             "if (!$src1) $dst = sxth($src2)",
 178             []>,
 179             Requires<[HasV4T]>;
 180
 181 let isPredicated = 1 in
 182 def SXTH_cdnPt_V4 : ALU32_rr<(outs IntRegs:$dst),
 183             (ins PredRegs:$src1, IntRegs:$src2),
 184             "if ($src1.new) $dst = sxth($src2)",
 185             []>,
 186             Requires<[HasV4T]>;
 187
 188 let isPredicated = 1 in
 189 def SXTH_cdnNotPt_V4 : ALU32_rr<(outs IntRegs:$dst),
 190             (ins PredRegs:$src1, IntRegs:$src2),
 191             "if (!$src1.new) $dst = sxth($src2)",
 192             []>,
 193             Requires<[HasV4T]>;
 194
 195 // Zero exten.
 196
 197 let neverHasSideEffects = 1, isPredicated = 1 in
 198 def ZXTB_cPt_V4 : ALU32_rr<(outs IntRegs:$dst),
 199             (ins PredRegs:$src1, IntRegs:$src2),
 200             "if ($src1) $dst = zxtb($src2)",
 201             []>,
 202             Requires<[HasV4T]>;
 203
 204 let neverHasSideEffects = 1, isPredicated = 1 in
 205 def ZXTB_cNotPt_V4 : ALU32_rr<(outs IntRegs:$dst),
 206             (ins PredRegs:$src1, IntRegs:$src2),
 207             "if (!$src1) $dst = zxtb($src2)",
 208             []>,
 209             Requires<[HasV4T]>;
 210
 211 let neverHasSideEffects = 1, isPredicated = 1 in
 212 def ZXTB_cdnPt_V4 : ALU32_rr<(outs IntRegs:$dst),
 213             (ins PredRegs:$src1, IntRegs:$src2),
 214             "if ($src1.new) $dst = zxtb($src2)",
 215             []>,
 216             Requires<[HasV4T]>;
 217
 218 let neverHasSideEffects = 1, isPredicated = 1 in
 219 def ZXTB_cdnNotPt_V4 : ALU32_rr<(outs IntRegs:$dst),
 220             (ins PredRegs:$src1, IntRegs:$src2),
 221             "if (!$src1.new) $dst = zxtb($src2)",
 222             []>,
 223             Requires<[HasV4T]>;
 224
 225 let neverHasSideEffects = 1, isPredicated = 1 in
 226 def ZXTH_cPt_V4 : ALU32_rr<(outs IntRegs:$dst),
 227             (ins PredRegs:$src1, IntRegs:$src2),
 228             "if ($src1) $dst = zxth($src2)",
 229             []>,
 230             Requires<[HasV4T]>;
 231
 232 let neverHasSideEffects = 1, isPredicated = 1 in
 233 def ZXTH_cNotPt_V4 : ALU32_rr<(outs IntRegs:$dst),
 234             (ins PredRegs:$src1, IntRegs:$src2),
 235             "if (!$src1) $dst = zxth($src2)",
 236             []>,
 237             Requires<[HasV4T]>;
 238
 239 let neverHasSideEffects = 1, isPredicated = 1 in
 240 def ZXTH_cdnPt_V4 : ALU32_rr<(outs IntRegs:$dst),
 241             (ins PredRegs:$src1, IntRegs:$src2),
 242             "if ($src1.new) $dst = zxth($src2)",
 243             []>,
 244             Requires<[HasV4T]>;
 245
 246 let neverHasSideEffects = 1, isPredicated = 1 in
 247 def ZXTH_cdnNotPt_V4 : ALU32_rr<(outs IntRegs:$dst),
 248             (ins PredRegs:$src1, IntRegs:$src2),
 249             "if (!$src1.new) $dst = zxth($src2)",
 250             []>,
 251             Requires<[HasV4T]>;
 252
 253
 254 //===----------------------------------------------------------------------===//
 255 // ALU32 -
 256 //===----------------------------------------------------------------------===//
 257
 258
 259
 260 //===----------------------------------------------------------------------===//
 261 // LD +
 262 //===----------------------------------------------------------------------===//
 263 ///
 264 /// Make sure that in post increment load, the first operand is always the post
 265 /// increment operand.
 266 ///
 267 //// Load doubleword.
 268 // Rdd=memd(Re=#U6)
 269
 270 // Rdd=memd(Rs+Rt<<#u2)
 271 // Special case pattern for indexed load without offset which is easier to
 272 // match. AddedComplexity of this pattern should be lower than base+offset load
 273 // and lower yet than the more generic version with offset/shift below
 274 // Similar approach is taken for all other base+index loads.
 275 let AddedComplexity = 10, isPredicable = 1 in
 276 def LDrid_indexed_V4 : LDInst<(outs DoubleRegs:$dst),
 277                     (ins IntRegs:$src1, IntRegs:$src2),
 278                     "$dst=memd($src1+$src2<<#0)",
 279                     [(set DoubleRegs:$dst, (load (add IntRegs:$src1,
 280                                                       IntRegs:$src2)))]>,
 281                     Requires<[HasV4T]>;
 282
 283 let AddedComplexity = 40, isPredicable = 1 in
 284 def LDrid_indexed_shl_V4 : LDInst<(outs DoubleRegs:$dst),
 285                     (ins IntRegs:$src1, IntRegs:$src2, u2Imm:$offset),
 286                     "$dst=memd($src1+$src2<<#$offset)",
 287                     [(set DoubleRegs:$dst, (load (add IntRegs:$src1,
 288                                                  (shl IntRegs:$src2,
 289                                                       u2ImmPred:$offset))))]>,
 290                     Requires<[HasV4T]>;
 291
 292 //// Load doubleword conditionally.
 293 // if ([!]Pv[.new]) Rd=memd(Rs+Rt<<#u2)
 294 // if (Pv) Rd=memd(Rs+Rt<<#u2)
 295 let mayLoad = 1, AddedComplexity = 15, isPredicated = 1 in
 296 def LDrid_indexed_cPt_V4 : LDInst<(outs DoubleRegs:$dst),
 297                     (ins PredRegs:$src1, IntRegs:$src2, IntRegs:$src3),
 298                     "if ($src1) $dst=memd($src2+$src3<<#0)",
 299                     []>,
 300                     Requires<[HasV4T]>;
 301
 302 // if (Pv.new) Rd=memd(Rs+Rt<<#u2)
 303 let mayLoad = 1, AddedComplexity = 15, isPredicated = 1 in
 304 def LDrid_indexed_cdnPt_V4 : LDInst<(outs DoubleRegs:$dst),
 305                     (ins PredRegs:$src1, IntRegs:$src2, IntRegs:$src3),
 306                     "if ($src1.new) $dst=memd($src2+$src3<<#0)",
 307                     []>,
 308                     Requires<[HasV4T]>;
 309
 310 // if (!Pv) Rd=memd(Rs+Rt<<#u2)
 311 let mayLoad = 1, AddedComplexity = 15, isPredicated = 1 in
 312 def LDrid_indexed_cNotPt_V4 : LDInst<(outs DoubleRegs:$dst),
 313                     (ins PredRegs:$src1, IntRegs:$src2, IntRegs:$src3),
 314                     "if (!$src1) $dst=memd($src2+$src3<<#0)",
 315                     []>,
 316                     Requires<[HasV4T]>;
 317
 318 // if (!Pv.new) Rd=memd(Rs+Rt<<#u2)
 319 let mayLoad = 1, AddedComplexity = 15, isPredicated = 1 in
 320 def LDrid_indexed_cdnNotPt_V4 : LDInst<(outs DoubleRegs:$dst),
 321                     (ins PredRegs:$src1, IntRegs:$src2, IntRegs:$src3),
 322                     "if (!$src1.new) $dst=memd($src2+$src3<<#0)",
 323                     []>,
 324                     Requires<[HasV4T]>;
 325
 326 // if (Pv) Rd=memd(Rs+Rt<<#u2)
 327 let mayLoad = 1, AddedComplexity = 45, isPredicated = 1 in
 328 def LDrid_indexed_shl_cPt_V4 : LDInst<(outs DoubleRegs:$dst),
 329                     (ins PredRegs:$src1, IntRegs:$src2, IntRegs:$src3,
 330                          u2Imm:$offset),
 331                     "if ($src1) $dst=memd($src2+$src3<<#$offset)",
 332                     []>,
 333                     Requires<[HasV4T]>;
 334
 335 // if (Pv.new) Rd=memd(Rs+Rt<<#u2)
 336 let mayLoad = 1, AddedComplexity = 45, isPredicated = 1 in
 337 def LDrid_indexed_shl_cdnPt_V4 : LDInst<(outs DoubleRegs:$dst),
 338                     (ins PredRegs:$src1, IntRegs:$src2, IntRegs:$src3,
 339                          u2Imm:$offset),
 340                     "if ($src1.new) $dst=memd($src2+$src3<<#$offset)",
 341                     []>,
 342                     Requires<[HasV4T]>;
 343
 344 // if (!Pv) Rd=memd(Rs+Rt<<#u2)
 345 let mayLoad = 1, AddedComplexity = 45, isPredicated = 1 in
 346 def LDrid_indexed_shl_cNotPt_V4 : LDInst<(outs DoubleRegs:$dst),
 347                     (ins PredRegs:$src1, IntRegs:$src2, IntRegs:$src3,
 348                          u2Imm:$offset),
 349                     "if (!$src1) $dst=memd($src2+$src3<<#$offset)",
 350                     []>,
 351                     Requires<[HasV4T]>;
 352
 353 // if (!Pv.new) Rd=memd(Rs+Rt<<#u2)
 354 let mayLoad = 1, AddedComplexity = 45, isPredicated = 1 in
 355 def LDrid_indexed_shl_cdnNotPt_V4 : LDInst<(outs DoubleRegs:$dst),
 356                     (ins PredRegs:$src1, IntRegs:$src2, IntRegs:$src3,
 357                          u2Imm:$offset),
 358                     "if (!$src1.new) $dst=memd($src2+$src3<<#$offset)",
 359                     []>,
 360                     Requires<[HasV4T]>;
 361
 362 // Rdd=memd(Rt<<#u2+#U6)
 363
 364 //// Load byte.
 365 // Rd=memb(Re=#U6)
 366
 367 // Rd=memb(Rs+Rt<<#u2)
 368 let AddedComplexity = 10, isPredicable = 1 in
 369 def LDrib_indexed_V4 : LDInst<(outs IntRegs:$dst),
 370                     (ins IntRegs:$src1, IntRegs:$src2),
 371                     "$dst=memb($src1+$src2<<#0)",
 372                     [(set IntRegs:$dst, (sextloadi8 (add IntRegs:$src1,
 373                                                          IntRegs:$src2)))]>,
 374                     Requires<[HasV4T]>;
 375
 376 let AddedComplexity = 10, isPredicable = 1 in
 377 def LDriub_indexed_V4 : LDInst<(outs IntRegs:$dst),
 378                     (ins IntRegs:$src1, IntRegs:$src2),
 379                     "$dst=memub($src1+$src2<<#0)",
 380                     [(set IntRegs:$dst, (zextloadi8 (add IntRegs:$src1,
 381                                                          IntRegs:$src2)))]>,
 382                     Requires<[HasV4T]>;
 383
 384 let AddedComplexity = 10, isPredicable = 1 in
 385 def LDriub_ae_indexed_V4 : LDInst<(outs IntRegs:$dst),
 386                     (ins IntRegs:$src1, IntRegs:$src2),
 387                     "$dst=memub($src1+$src2<<#0)",
 388                     [(set IntRegs:$dst, (extloadi8 (add IntRegs:$src1,
 389                                                         IntRegs:$src2)))]>,
 390                     Requires<[HasV4T]>;
 391
 392 let AddedComplexity = 40, isPredicable = 1 in
 393 def LDrib_indexed_shl_V4 : LDInst<(outs IntRegs:$dst),
 394                     (ins IntRegs:$src1, IntRegs:$src2, u2Imm:$offset),
 395                     "$dst=memb($src1+$src2<<#$offset)",
 396                     [(set IntRegs:$dst,
 397                           (sextloadi8 (add IntRegs:$src1,
 398                                            (shl IntRegs:$src2,
 399                                                 u2ImmPred:$offset))))]>,
 400                     Requires<[HasV4T]>;
 401
 402 let AddedComplexity = 40, isPredicable = 1 in
 403 def LDriub_indexed_shl_V4 : LDInst<(outs IntRegs:$dst),
 404                     (ins IntRegs:$src1, IntRegs:$src2, u2Imm:$offset),
 405                     "$dst=memub($src1+$src2<<#$offset)",
 406                     [(set IntRegs:$dst,
 407                           (zextloadi8 (add IntRegs:$src1,
 408                                            (shl IntRegs:$src2,
 409                                                 u2ImmPred:$offset))))]>,
 410                     Requires<[HasV4T]>;
 411
 412 let AddedComplexity = 40, isPredicable = 1 in
 413 def LDriub_ae_indexed_shl_V4 : LDInst<(outs IntRegs:$dst),
 414                     (ins IntRegs:$src1, IntRegs:$src2, u2Imm:$offset),
 415                     "$dst=memub($src1+$src2<<#$offset)",
 416                     [(set IntRegs:$dst, (extloadi8 (add IntRegs:$src1,
 417                                                    (shl IntRegs:$src2,
 418                                                         u2ImmPred:$offset))))]>,
 419                     Requires<[HasV4T]>;
 420
 421 //// Load byte conditionally.
 422 // if ([!]Pv[.new]) Rd=memb(Rs+Rt<<#u2)
 423 // if (Pv) Rd=memb(Rs+Rt<<#u2)
 424 let mayLoad = 1, AddedComplexity = 15, isPredicated = 1 in
 425 def LDrib_indexed_cPt_V4 : LDInst<(outs IntRegs:$dst),
 426                     (ins PredRegs:$src1, IntRegs:$src2, IntRegs:$src3),
 427                     "if ($src1) $dst=memb($src2+$src3<<#0)",
 428                     []>,
 429                     Requires<[HasV4T]>;
 430
 431 // if (Pv.new) Rd=memb(Rs+Rt<<#u2)
 432 let mayLoad = 1, AddedComplexity = 15, isPredicated = 1 in
 433 def LDrib_indexed_cdnPt_V4 : LDInst<(outs IntRegs:$dst),
 434                     (ins PredRegs:$src1, IntRegs:$src2, IntRegs:$src3),
 435                     "if ($src1.new) $dst=memb($src2+$src3<<#0)",
 436                     []>,
 437                     Requires<[HasV4T]>;
 438
 439 // if (!Pv) Rd=memb(Rs+Rt<<#u2)
 440 let mayLoad = 1, AddedComplexity = 15, isPredicated = 1 in
 441 def LDrib_indexed_cNotPt_V4 : LDInst<(outs IntRegs:$dst),
 442                     (ins PredRegs:$src1, IntRegs:$src2, IntRegs:$src3),
 443                     "if (!$src1) $dst=memb($src2+$src3<<#0)",
 444                     []>,
 445                     Requires<[HasV4T]>;
 446
 447 // if (!Pv.new) Rd=memb(Rs+Rt<<#u2)
 448 let mayLoad = 1, AddedComplexity = 15, isPredicated = 1 in
 449 def LDrib_indexed_cdnNotPt_V4 : LDInst<(outs IntRegs:$dst),
 450                     (ins PredRegs:$src1, IntRegs:$src2, IntRegs:$src3),
 451                     "if (!$src1.new) $dst=memb($src2+$src3<<#0)",
 452                     []>,
 453                     Requires<[HasV4T]>;
 454
 455 // if (Pv) Rd=memb(Rs+Rt<<#u2)
 456 let mayLoad = 1, AddedComplexity = 45, isPredicated = 1 in
 457 def LDrib_indexed_shl_cPt_V4 : LDInst<(outs IntRegs:$dst),
 458                     (ins PredRegs:$src1, IntRegs:$src2, IntRegs:$src3,
 459                          u2Imm:$offset),
 460                     "if ($src1) $dst=memb($src2+$src3<<#$offset)",
 461                     []>,
 462                     Requires<[HasV4T]>;
 463
 464 // if (Pv.new) Rd=memb(Rs+Rt<<#u2)
 465 let mayLoad = 1, AddedComplexity = 45, isPredicated = 1 in
 466 def LDrib_indexed_shl_cdnPt_V4 : LDInst<(outs IntRegs:$dst),
 467                     (ins PredRegs:$src1, IntRegs:$src2, IntRegs:$src3,
 468                          u2Imm:$offset),
 469                     "if ($src1.new) $dst=memb($src2+$src3<<#$offset)",
 470                     []>,
 471                     Requires<[HasV4T]>;
 472
 473 // if (!Pv) Rd=memb(Rs+Rt<<#u2)
 474 let mayLoad = 1, AddedComplexity = 45, isPredicated = 1 in
 475 def LDrib_indexed_shl_cNotPt_V4 : LDInst<(outs IntRegs:$dst),
 476                     (ins PredRegs:$src1, IntRegs:$src2, IntRegs:$src3,
 477                          u2Imm:$offset),
 478                     "if (!$src1) $dst=memb($src2+$src3<<#$offset)",
 479                     []>,
 480                     Requires<[HasV4T]>;
 481
 482 // if (!Pv.new) Rd=memb(Rs+Rt<<#u2)
 483 let mayLoad = 1, AddedComplexity = 45, isPredicated = 1 in
 484 def LDrib_indexed_shl_cdnNotPt_V4 : LDInst<(outs IntRegs:$dst),
 485                     (ins PredRegs:$src1, IntRegs:$src2, IntRegs:$src3,
 486                          u2Imm:$offset),
 487                     "if (!$src1.new) $dst=memb($src2+$src3<<#$offset)",
 488                     []>,
 489                     Requires<[HasV4T]>;
 490
 491 //// Load unsigned byte conditionally.
 492 // if ([!]Pv[.new]) Rd=memub(Rs+Rt<<#u2)
 493 // if (Pv) Rd=memub(Rs+Rt<<#u2)
 494 let mayLoad = 1, AddedComplexity = 15, isPredicated = 1 in
 495 def LDriub_indexed_cPt_V4 : LDInst<(outs IntRegs:$dst),
 496                     (ins PredRegs:$src1, IntRegs:$src2, IntRegs:$src3),
 497                     "if ($src1) $dst=memub($src2+$src3<<#0)",
 498                     []>,
 499                     Requires<[HasV4T]>;
 500
 501 // if (Pv.new) Rd=memub(Rs+Rt<<#u2)
 502 let mayLoad = 1, AddedComplexity = 15, isPredicated = 1 in
 503 def LDriub_indexed_cdnPt_V4 : LDInst<(outs IntRegs:$dst),
 504                     (ins PredRegs:$src1, IntRegs:$src2, IntRegs:$src3),
 505                     "if ($src1.new) $dst=memub($src2+$src3<<#0)",
 506                     []>,
 507                     Requires<[HasV4T]>;
 508
 509 // if (!Pv) Rd=memub(Rs+Rt<<#u2)
 510 let mayLoad = 1, AddedComplexity = 15, isPredicated = 1 in
 511 def LDriub_indexed_cNotPt_V4 : LDInst<(outs IntRegs:$dst),
 512                     (ins PredRegs:$src1, IntRegs:$src2, IntRegs:$src3),
 513                     "if (!$src1) $dst=memub($src2+$src3<<#0)",
 514                     []>,
 515                     Requires<[HasV4T]>;
 516
 517 // if (!Pv.new) Rd=memub(Rs+Rt<<#u2)
 518 let mayLoad = 1, AddedComplexity = 15, isPredicated = 1 in
 519 def LDriub_indexed_cdnNotPt_V4 : LDInst<(outs IntRegs:$dst),
 520                     (ins PredRegs:$src1, IntRegs:$src2, IntRegs:$src3),
 521                     "if (!$src1.new) $dst=memub($src2+$src3<<#0)",
 522                     []>,
 523                     Requires<[HasV4T]>;
 524
 525 // if (Pv) Rd=memub(Rs+Rt<<#u2)
 526 let mayLoad = 1, AddedComplexity = 45, isPredicated = 1 in
 527 def LDriub_indexed_shl_cPt_V4 : LDInst<(outs IntRegs:$dst),
 528                     (ins PredRegs:$src1, IntRegs:$src2, IntRegs:$src3,
 529                          u2Imm:$offset),
 530                     "if ($src1) $dst=memub($src2+$src3<<#$offset)",
 531                     []>,
 532                     Requires<[HasV4T]>;
 533
 534 // if (Pv.new) Rd=memub(Rs+Rt<<#u2)
 535 let mayLoad = 1, AddedComplexity = 45, isPredicated = 1 in
 536 def LDriub_indexed_shl_cdnPt_V4 : LDInst<(outs IntRegs:$dst),
 537                     (ins PredRegs:$src1, IntRegs:$src2, IntRegs:$src3,
 538                          u2Imm:$offset),
 539                     "if ($src1.new) $dst=memub($src2+$src3<<#$offset)",
 540                     []>,
 541                     Requires<[HasV4T]>;
 542
 543 // if (!Pv) Rd=memub(Rs+Rt<<#u2)
 544 let mayLoad = 1, AddedComplexity = 45, isPredicated = 1 in
 545 def LDriub_indexed_shl_cNotPt_V4 : LDInst<(outs IntRegs:$dst),
 546                     (ins PredRegs:$src1, IntRegs:$src2, IntRegs:$src3,
 547                          u2Imm:$offset),
 548                     "if (!$src1) $dst=memub($src2+$src3<<#$offset)",
 549                     []>,
 550                     Requires<[HasV4T]>;
 551
 552 // if (!Pv.new) Rd=memub(Rs+Rt<<#u2)
 553 let mayLoad = 1, AddedComplexity = 45, isPredicated = 1 in
 554 def LDriub_indexed_shl_cdnNotPt_V4 : LDInst<(outs IntRegs:$dst),
 555                     (ins PredRegs:$src1, IntRegs:$src2, IntRegs:$src3,
 556                          u2Imm:$offset),
 557                     "if (!$src1.new) $dst=memub($src2+$src3<<#$offset)",
 558                     []>,
 559                     Requires<[HasV4T]>;
 560
 561 // Rd=memb(Rt<<#u2+#U6)
 562
 563 //// Load halfword
 564 // Rd=memh(Re=#U6)
 565
 566 // Rd=memh(Rs+Rt<<#u2)
 567 let AddedComplexity = 10, isPredicable = 1 in
 568 def LDrih_indexed_V4 : LDInst<(outs IntRegs:$dst),
 569                     (ins IntRegs:$src1, IntRegs:$src2),
 570                     "$dst=memh($src1+$src2<<#0)",
 571                     [(set IntRegs:$dst, (sextloadi16 (add IntRegs:$src1,
 572                                                           IntRegs:$src2)))]>,
 573                     Requires<[HasV4T]>;
 574
 575 let AddedComplexity = 10, isPredicable = 1 in
 576 def LDriuh_indexed_V4 : LDInst<(outs IntRegs:$dst),
 577                     (ins IntRegs:$src1, IntRegs:$src2),
 578                     "$dst=memuh($src1+$src2<<#0)",
 579                     [(set IntRegs:$dst, (zextloadi16 (add IntRegs:$src1,
 580                                                           IntRegs:$src2)))]>,
 581                     Requires<[HasV4T]>;
 582
 583 let AddedComplexity = 10, isPredicable = 1 in
 584 def LDriuh_ae_indexed_V4 : LDInst<(outs IntRegs:$dst),
 585                     (ins IntRegs:$src1, IntRegs:$src2),
 586                     "$dst=memuh($src1+$src2<<#0)",
 587                     [(set IntRegs:$dst, (extloadi16 (add IntRegs:$src1,
 588                                                          IntRegs:$src2)))]>,
 589                     Requires<[HasV4T]>;
 590
 591 // Rd=memh(Rs+Rt<<#u2)
 592 let AddedComplexity = 40, isPredicable = 1 in
 593 def LDrih_indexed_shl_V4 : LDInst<(outs IntRegs:$dst),
 594                     (ins IntRegs:$src1, IntRegs:$src2, u2Imm:$offset),
 595                     "$dst=memh($src1+$src2<<#$offset)",
 596                     [(set IntRegs:$dst,
 597                           (sextloadi16 (add IntRegs:$src1,
 598                                             (shl IntRegs:$src2,
 599                                                  u2ImmPred:$offset))))]>,
 600                     Requires<[HasV4T]>;
 601
 602 let AddedComplexity = 40, isPredicable = 1 in
 603 def LDriuh_indexed_shl_V4 : LDInst<(outs IntRegs:$dst),
 604                     (ins IntRegs:$src1, IntRegs:$src2, u2Imm:$offset),
 605                     "$dst=memuh($src1+$src2<<#$offset)",
 606                     [(set IntRegs:$dst,
 607                           (zextloadi16 (add IntRegs:$src1,
 608                                             (shl IntRegs:$src2,
 609                                                  u2ImmPred:$offset))))]>,
 610                     Requires<[HasV4T]>;
 611
 612 let AddedComplexity = 40, isPredicable = 1 in
 613 def LDriuh_ae_indexed_shl_V4 : LDInst<(outs IntRegs:$dst),
 614                     (ins IntRegs:$src1, IntRegs:$src2, u2Imm:$offset),
 615                     "$dst=memuh($src1+$src2<<#$offset)",
 616                     [(set IntRegs:$dst,
 617                           (extloadi16 (add IntRegs:$src1,
 618                                            (shl IntRegs:$src2,
 619                                                 u2ImmPred:$offset))))]>,
 620                     Requires<[HasV4T]>;
 621
 622 //// Load halfword conditionally.
 623 // if ([!]Pv[.new]) Rd=memh(Rs+Rt<<#u2)
 624 // if (Pv) Rd=memh(Rs+Rt<<#u2)
 625 let mayLoad = 1, AddedComplexity = 15, isPredicated = 1 in
 626 def LDrih_indexed_cPt_V4 : LDInst<(outs IntRegs:$dst),
 627                     (ins PredRegs:$src1, IntRegs:$src2, IntRegs:$src3),
 628                     "if ($src1) $dst=memh($src2+$src3<<#0)",
 629                     []>,
 630                     Requires<[HasV4T]>;
 631
 632 // if (Pv.new) Rd=memh(Rs+Rt<<#u2)
 633 let mayLoad = 1, AddedComplexity = 15, isPredicated = 1 in
 634 def LDrih_indexed_cdnPt_V4 : LDInst<(outs IntRegs:$dst),
 635                     (ins PredRegs:$src1, IntRegs:$src2, IntRegs:$src3),
 636                     "if ($src1.new) $dst=memh($src2+$src3<<#0)",
 637                     []>,
 638                     Requires<[HasV4T]>;
 639
 640 // if (!Pv) Rd=memh(Rs+Rt<<#u2)
 641 let mayLoad = 1, AddedComplexity = 15, isPredicated = 1 in
 642 def LDrih_indexed_cNotPt_V4 : LDInst<(outs IntRegs:$dst),
 643                     (ins PredRegs:$src1, IntRegs:$src2, IntRegs:$src3),
 644                     "if (!$src1) $dst=memh($src2+$src3<<#0)",
 645                     []>,
 646                     Requires<[HasV4T]>;
 647
 648 // if (!Pv.new) Rd=memh(Rs+Rt<<#u2)
 649 let mayLoad = 1, AddedComplexity = 15, isPredicated = 1 in
 650 def LDrih_indexed_cdnNotPt_V4 : LDInst<(outs IntRegs:$dst),
 651                     (ins PredRegs:$src1, IntRegs:$src2, IntRegs:$src3),
 652                     "if (!$src1.new) $dst=memh($src2+$src3<<#0)",
 653                     []>,
 654                     Requires<[HasV4T]>;
 655
 656 // if (Pv) Rd=memh(Rs+Rt<<#u2)
 657 let mayLoad = 1, AddedComplexity = 45, isPredicated = 1 in
 658 def LDrih_indexed_shl_cPt_V4 : LDInst<(outs IntRegs:$dst),
 659                     (ins PredRegs:$src1, IntRegs:$src2, IntRegs:$src3,
 660                          u2Imm:$offset),
 661                     "if ($src1) $dst=memh($src2+$src3<<#$offset)",
 662                     []>,
 663                     Requires<[HasV4T]>;
 664
 665 // if (Pv.new) Rd=memh(Rs+Rt<<#u2)
 666 let mayLoad = 1, AddedComplexity = 45, isPredicated = 1 in
 667 def LDrih_indexed_shl_cdnPt_V4 : LDInst<(outs IntRegs:$dst),
 668                     (ins PredRegs:$src1, IntRegs:$src2, IntRegs:$src3,
 669                          u2Imm:$offset),
 670                     "if ($src1.new) $dst=memh($src2+$src3<<#$offset)",
 671                     []>,
 672                     Requires<[HasV4T]>;
 673
 674 // if (!Pv) Rd=memh(Rs+Rt<<#u2)
 675 let mayLoad = 1, AddedComplexity = 45, isPredicated = 1 in
 676 def LDrih_indexed_shl_cNotPt_V4 : LDInst<(outs IntRegs:$dst),
 677                     (ins PredRegs:$src1, IntRegs:$src2, IntRegs:$src3,
 678                          u2Imm:$offset),
 679                     "if (!$src1) $dst=memh($src2+$src3<<#$offset)",
 680                     []>,
 681                     Requires<[HasV4T]>;
 682
 683 // if (!Pv.new) Rd=memh(Rs+Rt<<#u2)
 684 let mayLoad = 1, AddedComplexity = 45, isPredicated = 1 in
 685 def LDrih_indexed_shl_cdnNotPt_V4 : LDInst<(outs IntRegs:$dst),
 686                     (ins PredRegs:$src1, IntRegs:$src2, IntRegs:$src3,
 687                          u2Imm:$offset),
 688                     "if (!$src1.new) $dst=memh($src2+$src3<<#$offset)",
 689                     []>,
 690                     Requires<[HasV4T]>;
 691
 692 //// Load unsigned halfword conditionally.
 693 // if ([!]Pv[.new]) Rd=memuh(Rs+Rt<<#u2)
 694 // if (Pv) Rd=memuh(Rs+Rt<<#u2)
 695 let mayLoad = 1, AddedComplexity = 15, isPredicated = 1 in
 696 def LDriuh_indexed_cPt_V4 : LDInst<(outs IntRegs:$dst),
 697                     (ins PredRegs:$src1, IntRegs:$src2, IntRegs:$src3),
 698                     "if ($src1) $dst=memuh($src2+$src3<<#0)",
 699                     []>,
 700                     Requires<[HasV4T]>;
 701
 702 // if (Pv.new) Rd=memuh(Rs+Rt<<#u2)
 703 let mayLoad = 1, AddedComplexity = 15, isPredicated = 1 in
 704 def LDriuh_indexed_cdnPt_V4 : LDInst<(outs IntRegs:$dst),
 705                     (ins PredRegs:$src1, IntRegs:$src2, IntRegs:$src3),
 706                     "if ($src1.new) $dst=memuh($src2+$src3<<#0)",
 707                     []>,
 708                     Requires<[HasV4T]>;
 709
 710 // if (!Pv) Rd=memuh(Rs+Rt<<#u2)
 711 let mayLoad = 1, AddedComplexity = 15, isPredicated = 1 in
 712 def LDriuh_indexed_cNotPt_V4 : LDInst<(outs IntRegs:$dst),
 713                     (ins PredRegs:$src1, IntRegs:$src2, IntRegs:$src3),
 714                     "if (!$src1) $dst=memuh($src2+$src3<<#0)",
 715                     []>,
 716                     Requires<[HasV4T]>;
 717
 718 // if (!Pv.new) Rd=memuh(Rs+Rt<<#u2)
 719 let mayLoad = 1, AddedComplexity = 15, isPredicated = 1 in
 720 def LDriuh_indexed_cdnNotPt_V4 : LDInst<(outs IntRegs:$dst),
 721                     (ins PredRegs:$src1, IntRegs:$src2, IntRegs:$src3),
 722                     "if (!$src1.new) $dst=memuh($src2+$src3<<#0)",
 723                     []>,
 724                     Requires<[HasV4T]>;
 725
 726 // if (Pv) Rd=memuh(Rs+Rt<<#u2)
 727 let mayLoad = 1, AddedComplexity = 45, isPredicated = 1 in
 728 def LDriuh_indexed_shl_cPt_V4 : LDInst<(outs IntRegs:$dst),
 729                     (ins PredRegs:$src1, IntRegs:$src2, IntRegs:$src3,
 730                          u2Imm:$offset),
 731                     "if ($src1) $dst=memuh($src2+$src3<<#$offset)",
 732                     []>,
 733                     Requires<[HasV4T]>;
 734
 735 // if (Pv.new) Rd=memuh(Rs+Rt<<#u2)
 736 let mayLoad = 1, AddedComplexity = 45, isPredicated = 1 in
 737 def LDriuh_indexed_shl_cdnPt_V4 : LDInst<(outs IntRegs:$dst),
 738                     (ins PredRegs:$src1, IntRegs:$src2, IntRegs:$src3,
 739                          u2Imm:$offset),
 740                     "if ($src1.new) $dst=memuh($src2+$src3<<#$offset)",
 741                     []>,
 742                     Requires<[HasV4T]>;
 743
 744 // if (!Pv) Rd=memuh(Rs+Rt<<#u2)
 745 let mayLoad = 1, AddedComplexity = 45, isPredicated = 1 in
 746 def LDriuh_indexed_shl_cNotPt_V4 : LDInst<(outs IntRegs:$dst),
 747                     (ins PredRegs:$src1, IntRegs:$src2, IntRegs:$src3,
 748                          u2Imm:$offset),
 749                     "if (!$src1) $dst=memuh($src2+$src3<<#$offset)",
 750                     []>,
 751                     Requires<[HasV4T]>;
 752
 753 // if (!Pv.new) Rd=memuh(Rs+Rt<<#u2)
 754 let mayLoad = 1, AddedComplexity = 45, isPredicated = 1 in
 755 def LDriuh_indexed_shl_cdnNotPt_V4 : LDInst<(outs IntRegs:$dst),
 756                     (ins PredRegs:$src1, IntRegs:$src2, IntRegs:$src3,
 757                          u2Imm:$offset),
 758                     "if (!$src1.new) $dst=memuh($src2+$src3<<#$offset)",
 759                     []>,
 760                     Requires<[HasV4T]>;
 761
 762 // Rd=memh(Rt<<#u2+#U6)
 763
 764 //// Load word.
 765 // Rd=memw(Re=#U6)
 766
 767 // Rd=memw(Rs+Rt<<#u2)
 768 let AddedComplexity = 10, isPredicable = 1 in
 769 def LDriw_indexed_V4 : LDInst<(outs IntRegs:$dst),
 770                     (ins IntRegs:$src1, IntRegs:$src2),
 771                     "$dst=memw($src1+$src2<<#0)",
 772                     [(set IntRegs:$dst, (load (add IntRegs:$src1,
 773                                                    IntRegs:$src2)))]>,
 774                     Requires<[HasV4T]>;
 775
 776 // Rd=memw(Rs+Rt<<#u2)
 777 let AddedComplexity = 40, isPredicable = 1 in
 778 def LDriw_indexed_shl_V4 : LDInst<(outs IntRegs:$dst),
 779                     (ins IntRegs:$src1, IntRegs:$src2, u2Imm:$offset),
 780                     "$dst=memw($src1+$src2<<#$offset)",
 781                     [(set IntRegs:$dst, (load (add IntRegs:$src1,
 782                                               (shl IntRegs:$src2,
 783                                                    u2ImmPred:$offset))))]>,
 784                     Requires<[HasV4T]>;
 785
 786 //// Load word conditionally.
 787 // if ([!]Pv[.new]) Rd=memw(Rs+Rt<<#u2)
 788 // if (Pv) Rd=memw(Rs+Rt<<#u2)
 789 let mayLoad = 1, AddedComplexity = 15, isPredicated = 1 in
 790 def LDriw_indexed_cPt_V4 : LDInst<(outs IntRegs:$dst),
 791                     (ins PredRegs:$src1, IntRegs:$src2, IntRegs:$src3),
 792                     "if ($src1) $dst=memw($src2+$src3<<#0)",
 793                     []>,
 794                     Requires<[HasV4T]>;
 795
 796 // if (Pv.new) Rd=memh(Rs+Rt<<#u2)
 797 let mayLoad = 1, AddedComplexity = 15, isPredicated = 1 in
 798 def LDriw_indexed_cdnPt_V4 : LDInst<(outs IntRegs:$dst),
 799                     (ins PredRegs:$src1, IntRegs:$src2, IntRegs:$src3),
 800                     "if ($src1.new) $dst=memw($src2+$src3<<#0)",
 801                     []>,
 802                     Requires<[HasV4T]>;
 803
 804 // if (!Pv) Rd=memh(Rs+Rt<<#u2)
 805 let mayLoad = 1, AddedComplexity = 15, isPredicated = 1 in
 806 def LDriw_indexed_cNotPt_V4 : LDInst<(outs IntRegs:$dst),
 807                     (ins PredRegs:$src1, IntRegs:$src2, IntRegs:$src3),
 808                     "if (!$src1) $dst=memw($src2+$src3<<#0)",
 809                     []>,
 810                     Requires<[HasV4T]>;
 811
 812 // if (!Pv.new) Rd=memh(Rs+Rt<<#u2)
 813 let mayLoad = 1, AddedComplexity = 15, isPredicated = 1 in
 814 def LDriw_indexed_cdnNotPt_V4 : LDInst<(outs IntRegs:$dst),
 815                     (ins PredRegs:$src1, IntRegs:$src2, IntRegs:$src3),
 816                     "if (!$src1.new) $dst=memw($src2+$src3<<#0)",
 817                     []>,
 818                     Requires<[HasV4T]>;
 819
 820 // if (Pv) Rd=memh(Rs+Rt<<#u2)
 821 let mayLoad = 1, AddedComplexity = 45, isPredicated = 1 in
 822 def LDriw_indexed_shl_cPt_V4 : LDInst<(outs IntRegs:$dst),
 823                     (ins PredRegs:$src1, IntRegs:$src2, IntRegs:$src3,
 824                          u2Imm:$offset),
 825                     "if ($src1) $dst=memw($src2+$src3<<#$offset)",
 826                     []>,
 827                     Requires<[HasV4T]>;
 828
 829 // if (Pv.new) Rd=memh(Rs+Rt<<#u2)
 830 let mayLoad = 1, AddedComplexity = 45, isPredicated = 1 in
 831 def LDriw_indexed_shl_cdnPt_V4 : LDInst<(outs IntRegs:$dst),
 832                     (ins PredRegs:$src1, IntRegs:$src2, IntRegs:$src3,
 833                          u2Imm:$offset),
 834                     "if ($src1.new) $dst=memw($src2+$src3<<#$offset)",
 835                     []>,
 836                     Requires<[HasV4T]>;
 837
 838 // if (!Pv) Rd=memh(Rs+Rt<<#u2)
 839 let mayLoad = 1, AddedComplexity = 45, isPredicated = 1 in
 840 def LDriw_indexed_shl_cNotPt_V4 : LDInst<(outs IntRegs:$dst),
 841                     (ins PredRegs:$src1, IntRegs:$src2, IntRegs:$src3,
 842                          u2Imm:$offset),
 843                     "if (!$src1) $dst=memw($src2+$src3<<#$offset)",
 844                     []>,
 845                     Requires<[HasV4T]>;
 846
 847 // if (!Pv.new) Rd=memh(Rs+Rt<<#u2)
 848 let mayLoad = 1, AddedComplexity = 45, isPredicated = 1 in
 849 def LDriw_indexed_shl_cdnNotPt_V4 : LDInst<(outs IntRegs:$dst),
 850                     (ins PredRegs:$src1, IntRegs:$src2, IntRegs:$src3,
 851                          u2Imm:$offset),
 852                     "if (!$src1.new) $dst=memw($src2+$src3<<#$offset)",
 853                     []>,
 854                     Requires<[HasV4T]>;
 855
 856 // Rd=memw(Rt<<#u2+#U6)
 857
 858
 859 // Post-inc Load, Predicated, Dot new
 860
 861
 862 let mayLoad = 1, hasCtrlDep = 1, neverHasSideEffects = 1, isPredicated = 1 in
 863 def POST_LDrid_cdnPt_V4 : LDInstPI<(outs DoubleRegs:$dst1, IntRegs:$dst2),
 864             (ins PredRegs:$src1, IntRegs:$src2, s4_3Imm:$src3),
 865             "if ($src1.new) $dst1 = memd($src2++#$src3)",
 866             [],
 867             "$src2 = $dst2">,
 868             Requires<[HasV4T]>;
 869
 870 let mayLoad = 1, hasCtrlDep = 1, neverHasSideEffects = 1, isPredicated = 1 in
 871 def POST_LDrid_cdnNotPt_V4 : LDInstPI<(outs DoubleRegs:$dst1, IntRegs:$dst2),
 872             (ins PredRegs:$src1, IntRegs:$src2, s4_3Imm:$src3),
 873             "if (!$src1.new) $dst1 = memd($src2++#$src3)",
 874             [],
 875             "$src2 = $dst2">,
 876             Requires<[HasV4T]>;
 877
 878 let mayLoad = 1, hasCtrlDep = 1, neverHasSideEffects = 1, isPredicated = 1 in
 879 def POST_LDrib_cdnPt_V4 : LDInstPI<(outs IntRegs:$dst1, IntRegs:$dst2),
 880             (ins PredRegs:$src1, IntRegs:$src2, s4_0Imm:$src3),
 881             "if ($src1.new) $dst1 = memb($src2++#$src3)",
 882             [],
 883             "$src2 = $dst2">,
 884             Requires<[HasV4T]>;
 885
 886 let mayLoad = 1, hasCtrlDep = 1, neverHasSideEffects = 1, isPredicated = 1 in
 887 def POST_LDrib_cdnNotPt_V4 : LDInstPI<(outs IntRegs:$dst1, IntRegs:$dst2),
 888             (ins PredRegs:$src1, IntRegs:$src2, s4_0Imm:$src3),
 889             "if (!$src1.new) $dst1 = memb($src2++#$src3)",
 890             [],
 891             "$src2 = $dst2">,
 892             Requires<[HasV4T]>;
 893
 894 let mayLoad = 1, hasCtrlDep = 1, neverHasSideEffects = 1, isPredicated = 1 in
 895 def POST_LDrih_cdnPt_V4 : LDInstPI<(outs IntRegs:$dst1, IntRegs:$dst2),
 896             (ins PredRegs:$src1, IntRegs:$src2, s4_1Imm:$src3),
 897             "if ($src1.new) $dst1 = memh($src2++#$src3)",
 898             [],
 899             "$src2 = $dst2">,
 900             Requires<[HasV4T]>;
 901
 902 let mayLoad = 1, hasCtrlDep = 1, neverHasSideEffects = 1, isPredicated = 1 in
 903 def POST_LDrih_cdnNotPt_V4 : LDInstPI<(outs IntRegs:$dst1, IntRegs:$dst2),
 904             (ins PredRegs:$src1, IntRegs:$src2, s4_1Imm:$src3),
 905             "if (!$src1.new) $dst1 = memh($src2++#$src3)",
 906             [],
 907             "$src2 = $dst2">,
 908             Requires<[HasV4T]>;
 909
 910 let mayLoad = 1, hasCtrlDep = 1, neverHasSideEffects = 1, isPredicated = 1 in
 911 def POST_LDriub_cdnPt_V4 : LDInstPI<(outs IntRegs:$dst1, IntRegs:$dst2),
 912             (ins PredRegs:$src1, IntRegs:$src2, s4_0Imm:$src3),
 913             "if ($src1.new) $dst1 = memub($src2++#$src3)",
 914             [],
 915             "$src2 = $dst2">,
 916             Requires<[HasV4T]>;
 917
 918 let mayLoad = 1, hasCtrlDep = 1, neverHasSideEffects = 1, isPredicated = 1 in
 919 def POST_LDriub_cdnNotPt_V4 : LDInstPI<(outs IntRegs:$dst1, IntRegs:$dst2),
 920             (ins PredRegs:$src1, IntRegs:$src2, s4_0Imm:$src3),
 921             "if (!$src1.new) $dst1 = memub($src2++#$src3)",
 922             [],
 923             "$src2 = $dst2">,
 924             Requires<[HasV4T]>;
 925
 926 let mayLoad = 1, hasCtrlDep = 1, neverHasSideEffects = 1, isPredicated = 1 in
 927 def POST_LDriuh_cdnPt_V4 : LDInstPI<(outs IntRegs:$dst1, IntRegs:$dst2),
 928             (ins PredRegs:$src1, IntRegs:$src2, s4_1Imm:$src3),
 929             "if ($src1.new) $dst1 = memuh($src2++#$src3)",
 930             [],
 931             "$src2 = $dst2">,
 932             Requires<[HasV4T]>;
 933
 934 let mayLoad = 1, hasCtrlDep = 1, neverHasSideEffects = 1, isPredicated = 1 in
 935 def POST_LDriuh_cdnNotPt_V4 : LDInstPI<(outs IntRegs:$dst1, IntRegs:$dst2),
 936             (ins PredRegs:$src1, IntRegs:$src2, s4_1Imm:$src3),
 937             "if (!$src1.new) $dst1 = memuh($src2++#$src3)",
 938             [],
 939             "$src2 = $dst2">,
 940             Requires<[HasV4T]>;
 941
 942 let mayLoad = 1, hasCtrlDep = 1, neverHasSideEffects = 1, isPredicated = 1 in
 943 def POST_LDriw_cdnPt_V4 : LDInstPI<(outs IntRegs:$dst1, IntRegs:$dst2),
 944             (ins PredRegs:$src1, IntRegs:$src2, s4_2Imm:$src3),
 945             "if ($src1.new) $dst1 = memw($src2++#$src3)",
 946             [],
 947             "$src2 = $dst2">,
 948             Requires<[HasV4T]>;
 949
 950 let mayLoad = 1, hasCtrlDep = 1, neverHasSideEffects = 1, isPredicated = 1 in
 951 def POST_LDriw_cdnNotPt_V4 : LDInstPI<(outs IntRegs:$dst1, IntRegs:$dst2),
 952             (ins PredRegs:$src1, IntRegs:$src2, s4_2Imm:$src3),
 953             "if (!$src1.new) $dst1 = memw($src2++#$src3)",
 954             [],
 955             "$src2 = $dst2">,
 956             Requires<[HasV4T]>;
 957
 958
 959 //===----------------------------------------------------------------------===//
 960 // LD -
 961 //===----------------------------------------------------------------------===//
 962
 963 //===----------------------------------------------------------------------===//
 964 // ST +
 965 //===----------------------------------------------------------------------===//
 966 ///
 967 /// Assumptions::: ****** DO NOT IGNORE ********
 968 /// 1. Make sure that in post increment store, the zero'th operand is always the
 969 ///    post increment operand.
 970 /// 2. Make sure that the store value operand(Rt/Rtt) in a store is always the
 971 ///    last operand.
 972 ///
 973
 974 // Store doubleword.
 975 // memd(Re=#U6)=Rtt
 976 // TODO: needs to be implemented
 977
 978 // memd(Rs+#s11:3)=Rtt
 979 // memd(Rs+Ru<<#u2)=Rtt
 980 let AddedComplexity = 10, isPredicable = 1 in
 981 def STrid_indexed_shl_V4 : STInst<(outs),
 982             (ins IntRegs:$src1, IntRegs:$src2, u2Imm:$src3, DoubleRegs:$src4),
 983             "memd($src1+$src2<<#$src3) = $src4",
 984             [(store DoubleRegs:$src4, (add IntRegs:$src1,
 985                                       (shl IntRegs:$src2, u2ImmPred:$src3)))]>,
 986             Requires<[HasV4T]>;
 987
 988 // memd(Ru<<#u2+#U6)=Rtt
 989 let AddedComplexity = 10 in
 990 def STrid_shl_V4 : STInst<(outs),
 991             (ins IntRegs:$src1, u2Imm:$src2, u6Imm:$src3, DoubleRegs:$src4),
 992             "memd($src1<<#$src2+#$src3) = $src4",
 993             [(store DoubleRegs:$src4, (shl IntRegs:$src1,
 994                                       (add u2ImmPred:$src2,
 995                                            u6ImmPred:$src3)))]>,
 996             Requires<[HasV4T]>;
 997
 998 // memd(Rx++#s4:3)=Rtt
 999 // memd(Rx++#s4:3:circ(Mu))=Rtt
1000 // memd(Rx++I:circ(Mu))=Rtt
1001 // memd(Rx++Mu)=Rtt
1002 // memd(Rx++Mu:brev)=Rtt
1003 // memd(gp+#u16:3)=Rtt
1004
1005 // Store doubleword conditionally.
1006 // if ([!]Pv[.new]) memd(#u6)=Rtt
1007 // TODO: needs to be implemented.
1008
1009 // if ([!]Pv[.new]) memd(Rs+#u6:3)=Rtt
1010 // if (Pv) memd(Rs+#u6:3)=Rtt
1011 // if (Pv.new) memd(Rs+#u6:3)=Rtt
1012 let AddedComplexity = 10, mayStore = 1, neverHasSideEffects = 1 in
1013 def STrid_cdnPt_V4 : STInst<(outs),
1014             (ins PredRegs:$src1, MEMri:$addr, DoubleRegs:$src2),
1015             "if ($src1.new) memd($addr) = $src2",
1016             []>,
1017             Requires<[HasV4T]>;
1018
1019 // if (!Pv) memd(Rs+#u6:3)=Rtt
1020 // if (!Pv.new) memd(Rs+#u6:3)=Rtt
1021 let AddedComplexity = 10, mayStore = 1, neverHasSideEffects = 1 in
1022 def STrid_cdnNotPt_V4 : STInst<(outs),
1023             (ins PredRegs:$src1, MEMri:$addr, DoubleRegs:$src2),
1024             "if (!$src1.new) memd($addr) = $src2",
1025             []>,
1026             Requires<[HasV4T]>;
1027
1028 // if (Pv) memd(Rs+#u6:3)=Rtt
1029 // if (Pv.new) memd(Rs+#u6:3)=Rtt
1030 let AddedComplexity = 10, mayStore = 1, neverHasSideEffects = 1 in
1031 def STrid_indexed_cdnPt_V4 : STInst<(outs),
1032             (ins PredRegs:$src1, IntRegs:$src2, u6_3Imm:$src3,
1033                  DoubleRegs:$src4),
1034             "if ($src1.new) memd($src2+#$src3) = $src4",
1035             []>,
1036             Requires<[HasV4T]>;
1037
1038 // if (!Pv) memd(Rs+#u6:3)=Rtt
1039 // if (!Pv.new) memd(Rs+#u6:3)=Rtt
1040 let AddedComplexity = 10, mayStore = 1, neverHasSideEffects = 1 in
1041 def STrid_indexed_cdnNotPt_V4 : STInst<(outs),
1042             (ins PredRegs:$src1, IntRegs:$src2, u6_3Imm:$src3,
1043                  DoubleRegs:$src4),
1044             "if (!$src1.new) memd($src2+#$src3) = $src4",
1045             []>,
1046             Requires<[HasV4T]>;
1047
1048 // if ([!]Pv[.new]) memd(Rs+Ru<<#u2)=Rtt
1049 // if (Pv) memd(Rs+Ru<<#u2)=Rtt
1050 let AddedComplexity = 10, mayStore = 1, neverHasSideEffects = 1 in
1051 def STrid_indexed_shl_cPt_V4 : STInst<(outs),
1052             (ins PredRegs:$src1, IntRegs:$src2, IntRegs:$src3, u2Imm:$src4,
1053                  DoubleRegs:$src5),
1054             "if ($src1) memd($src2+$src3<<#$src4) = $src5",
1055             []>,
1056             Requires<[HasV4T]>;
1057
1058 // if (Pv.new) memd(Rs+Ru<<#u2)=Rtt
1059 let AddedComplexity = 10, mayStore = 1, neverHasSideEffects = 1 in
1060 def STrid_indexed_shl_cdnPt_V4 : STInst<(outs),
1061             (ins PredRegs:$src1, IntRegs:$src2, IntRegs:$src3, u2Imm:$src4,
1062                  DoubleRegs:$src5),
1063             "if ($src1) memd($src2+$src3<<#$src4) = $src5",
1064             []>,
1065             Requires<[HasV4T]>;
1066 // if (!Pv) memd(Rs+Ru<<#u2)=Rtt
1067 let AddedComplexity = 10, mayStore = 1, neverHasSideEffects = 1 in
1068 def STrid_indexed_shl_cNotPt_V4 : STInst<(outs),
1069             (ins PredRegs:$src1, IntRegs:$src2, IntRegs:$src3, u2Imm:$src4,
1070                  DoubleRegs:$src5),
1071             "if (!$src1) memd($src2+$src3<<#$src4) = $src5",
1072             []>,
1073             Requires<[HasV4T]>;
1074 // if (!Pv.new) memd(Rs+Ru<<#u2)=Rtt
1075 let AddedComplexity = 10, mayStore = 1, neverHasSideEffects = 1 in
1076 def STrid_indexed_shl_cdnNotPt_V4 : STInst<(outs),
1077             (ins PredRegs:$src1, IntRegs:$src2, IntRegs:$src3, u2Imm:$src4,
1078                  DoubleRegs:$src5),
1079             "if (!$src1.new) memd($src2+$src3<<#$src4) = $src5",
1080             []>,
1081             Requires<[HasV4T]>;
1082
1083 // if ([!]Pv[.new]) memd(Rx++#s4:3)=Rtt
1084 // if (Pv) memd(Rx++#s4:3)=Rtt
1085 // if (Pv.new) memd(Rx++#s4:3)=Rtt
1086 let AddedComplexity = 10, mayStore = 1, neverHasSideEffects = 1 in
1087 def POST_STdri_cdnPt_V4 : STInstPI<(outs IntRegs:$dst),
1088             (ins PredRegs:$src1, DoubleRegs:$src2, IntRegs:$src3,
1089                  s4_3Imm:$offset),
1090             "if ($src1.new) memd($src3++#$offset) = $src2",
1091             [],
1092             "$src3 = $dst">,
1093             Requires<[HasV4T]>;
1094
1095 // if (!Pv) memd(Rx++#s4:3)=Rtt
1096 // if (!Pv.new) memd(Rx++#s4:3)=Rtt
1097 let AddedComplexity = 10, mayStore = 1, neverHasSideEffects = 1 in
1098 def POST_STdri_cdnNotPt_V4 : STInstPI<(outs IntRegs:$dst),
1099             (ins PredRegs:$src1, DoubleRegs:$src2, IntRegs:$src3,
1100                  s4_3Imm:$offset),
1101             "if (!$src1.new) memd($src3++#$offset) = $src2",
1102             [],
1103             "$src3 = $dst">,
1104             Requires<[HasV4T]>;
1105
1106
1107 // Store byte.
1108 // memb(Re=#U6)=Rt
1109 // TODO: needs to be implemented.
1110 // memb(Rs+#s11:0)=Rt
1111 // memb(Rs+#u6:0)=#S8
1112 let AddedComplexity = 10, isPredicable = 1 in
1113 def STrib_imm_V4 : STInst<(outs),
1114             (ins IntRegs:$src1, u6_0Imm:$src2, s8Imm:$src3),
1115             "memb($src1+#$src2) = #$src3",
1116             [(truncstorei8 s8ImmPred:$src3, (add IntRegs:$src1,
1117                                                  u6_0ImmPred:$src2))]>,
1118             Requires<[HasV4T]>;
1119
1120 // memb(Rs+Ru<<#u2)=Rt
1121 let AddedComplexity = 10, isPredicable = 1 in
1122 def STrib_indexed_shl_V4 : STInst<(outs),
1123             (ins IntRegs:$src1, IntRegs:$src2, u2Imm:$src3, IntRegs:$src4),
1124             "memb($src1+$src2<<#$src3) = $src4",
1125             [(truncstorei8 IntRegs:$src4, (add IntRegs:$src1,
1126                                           (shl IntRegs:$src2,
1127                                                u2ImmPred:$src3)))]>,
1128             Requires<[HasV4T]>;
1129
1130 // memb(Ru<<#u2+#U6)=Rt
1131 let AddedComplexity = 10 in
1132 def STrib_shl_V4 : STInst<(outs),
1133             (ins IntRegs:$src1, u2Imm:$src2, u6Imm:$src3, IntRegs:$src4),
1134             "memb($src1<<#$src2+#$src3) = $src4",
1135             [(truncstorei8 IntRegs:$src4, (shl IntRegs:$src1,
1136                                           (add u2ImmPred:$src2,
1137                                                u6ImmPred:$src3)))]>,
1138             Requires<[HasV4T]>;
1139
1140 // memb(Rx++#s4:0:circ(Mu))=Rt
1141 // memb(Rx++I:circ(Mu))=Rt
1142 // memb(Rx++Mu)=Rt
1143 // memb(Rx++Mu:brev)=Rt
1144 // memb(gp+#u16:0)=Rt
1145
1146
1147 // Store byte conditionally.
1148 // if ([!]Pv[.new]) memb(#u6)=Rt
1149 // if ([!]Pv[.new]) memb(Rs+#u6:0)=#S6
1150 // if (Pv) memb(Rs+#u6:0)=#S6
1151 let mayStore = 1, neverHasSideEffects = 1 in
1152 def STrib_imm_cPt_V4 : STInst<(outs),
1153             (ins PredRegs:$src1, IntRegs:$src2, u6_0Imm:$src3, s6Imm:$src4),
1154             "if ($src1) memb($src2+#$src3) = #$src4",
1155             []>,
1156             Requires<[HasV4T]>;
1157
1158 // if (Pv.new) memb(Rs+#u6:0)=#S6
1159 let mayStore = 1, neverHasSideEffects = 1 in
1160 def STrib_imm_cdnPt_V4 : STInst<(outs),
1161             (ins PredRegs:$src1, IntRegs:$src2, u6_0Imm:$src3, s6Imm:$src4),
1162             "if ($src1.new) memb($src2+#$src3) = #$src4",
1163             []>,
1164             Requires<[HasV4T]>;
1165
1166 // if (!Pv) memb(Rs+#u6:0)=#S6
1167 let mayStore = 1, neverHasSideEffects = 1 in
1168 def STrib_imm_cNotPt_V4 : STInst<(outs),
1169             (ins PredRegs:$src1, IntRegs:$src2, u6_0Imm:$src3, s6Imm:$src4),
1170             "if (!$src1) memb($src2+#$src3) = #$src4",
1171             []>,
1172             Requires<[HasV4T]>;
1173
1174 // if (!Pv.new) memb(Rs+#u6:0)=#S6
1175 let mayStore = 1, neverHasSideEffects = 1 in
1176 def STrib_imm_cdnNotPt_V4 : STInst<(outs),
1177             (ins PredRegs:$src1, IntRegs:$src2, u6_0Imm:$src3, s6Imm:$src4),
1178             "if (!$src1.new) memb($src2+#$src3) = #$src4",
1179             []>,
1180             Requires<[HasV4T]>;
1181
1182 // if ([!]Pv[.new]) memb(Rs+#u6:0)=Rt
1183 // if (Pv) memb(Rs+#u6:0)=Rt
1184 // if (Pv.new) memb(Rs+#u6:0)=Rt
1185 let mayStore = 1, neverHasSideEffects = 1 in
1186 def STrib_cdnPt_V4 : STInst<(outs),
1187             (ins PredRegs:$src1, MEMri:$addr, IntRegs:$src2),
1188             "if ($src1.new) memb($addr) = $src2",
1189             []>,
1190             Requires<[HasV4T]>;
1191
1192 // if (!Pv) memb(Rs+#u6:0)=Rt
1193 // if (!Pv.new) memb(Rs+#u6:0)=Rt
1194 let mayStore = 1, neverHasSideEffects = 1 in
1195 def STrib_cdnNotPt_V4 : STInst<(outs),
1196             (ins PredRegs:$src1, MEMri:$addr, IntRegs:$src2),
1197             "if (!$src1.new) memb($addr) = $src2",
1198             []>,
1199             Requires<[HasV4T]>;
1200
1201 // if (Pv) memb(Rs+#u6:0)=Rt
1202 // if (!Pv) memb(Rs+#u6:0)=Rt
1203 // if (Pv.new) memb(Rs+#u6:0)=Rt
1204 let mayStore = 1, neverHasSideEffects = 1 in
1205 def STrib_indexed_cdnPt_V4 : STInst<(outs),
1206             (ins PredRegs:$src1, IntRegs:$src2, u6_0Imm:$src3, IntRegs:$src4),
1207             "if ($src1.new) memb($src2+#$src3) = $src4",
1208             []>,
1209             Requires<[HasV4T]>;
1210
1211 // if (!Pv.new) memb(Rs+#u6:0)=Rt
1212 let mayStore = 1, neverHasSideEffects = 1 in
1213 def STrib_indexed_cdnNotPt_V4 : STInst<(outs),
1214             (ins PredRegs:$src1, IntRegs:$src2, u6_0Imm:$src3, IntRegs:$src4),
1215             "if (!$src1.new) memb($src2+#$src3) = $src4",
1216             []>,
1217             Requires<[HasV4T]>;
1218
1219 // if ([!]Pv[.new]) memb(Rs+Ru<<#u2)=Rt
1220 // if (Pv) memb(Rs+Ru<<#u2)=Rt
1221 let mayStore = 1, AddedComplexity = 10 in
1222 def STrib_indexed_shl_cPt_V4 : STInst<(outs),
1223             (ins PredRegs:$src1, IntRegs:$src2, IntRegs:$src3, u2Imm:$src4,
1224                  IntRegs:$src5),
1225             "if ($src1) memb($src2+$src3<<#$src4) = $src5",
1226             []>,
1227             Requires<[HasV4T]>;
1228
1229 // if (Pv.new) memb(Rs+Ru<<#u2)=Rt
1230 let mayStore = 1, AddedComplexity = 10 in
1231 def STrib_indexed_shl_cdnPt_V4 : STInst<(outs),
1232             (ins PredRegs:$src1, IntRegs:$src2, IntRegs:$src3, u2Imm:$src4,
1233                  IntRegs:$src5),
1234             "if ($src1.new) memb($src2+$src3<<#$src4) = $src5",
1235             []>,
1236             Requires<[HasV4T]>;
1237
1238 // if (!Pv) memb(Rs+Ru<<#u2)=Rt
1239 let mayStore = 1, AddedComplexity = 10 in
1240 def STrib_indexed_shl_cNotPt_V4 : STInst<(outs),
1241             (ins PredRegs:$src1, IntRegs:$src2, IntRegs:$src3, u2Imm:$src4,
1242                  IntRegs:$src5),
1243             "if (!$src1) memb($src2+$src3<<#$src4) = $src5",
1244             []>,
1245             Requires<[HasV4T]>;
1246
1247 // if (!Pv.new) memb(Rs+Ru<<#u2)=Rt
1248 let mayStore = 1, AddedComplexity = 10 in
1249 def STrib_indexed_shl_cdnNotPt_V4 : STInst<(outs),
1250             (ins PredRegs:$src1, IntRegs:$src2, IntRegs:$src3, u2Imm:$src4,
1251                  IntRegs:$src5),
1252             "if (!$src1.new) memb($src2+$src3<<#$src4) = $src5",
1253             []>,
1254             Requires<[HasV4T]>;
1255
1256 // if ([!]Pv[.new]) memb(Rx++#s4:0)=Rt
1257 // if (Pv) memb(Rx++#s4:0)=Rt
1258 // if (Pv.new) memb(Rx++#s4:0)=Rt
1259 let mayStore = 1, hasCtrlDep = 1 in
1260 def POST_STbri_cdnPt_V4 : STInstPI<(outs IntRegs:$dst),
1261             (ins PredRegs:$src1, IntRegs:$src2, IntRegs:$src3, s4_0Imm:$offset),
1262             "if ($src1.new) memb($src3++#$offset) = $src2",
1263             [],"$src3 = $dst">,
1264             Requires<[HasV4T]>;
1265
1266 // if (!Pv) memb(Rx++#s4:0)=Rt
1267 // if (!Pv.new) memb(Rx++#s4:0)=Rt
1268 let mayStore = 1, hasCtrlDep = 1 in
1269 def POST_STbri_cdnNotPt_V4 : STInstPI<(outs IntRegs:$dst),
1270             (ins PredRegs:$src1, IntRegs:$src2, IntRegs:$src3, s4_0Imm:$offset),
1271             "if (!$src1.new) memb($src3++#$offset) = $src2",
1272             [],"$src3 = $dst">,
1273             Requires<[HasV4T]>;
1274
1275
1276 // Store halfword.
1277 // memh(Re=#U6)=Rt.H
1278 // TODO: needs to be implemented
1279
1280 // memh(Re=#U6)=Rt
1281 // TODO: needs to be implemented
1282
1283 // memh(Rs+#s11:1)=Rt.H
1284 // memh(Rs+#s11:1)=Rt
1285 // memh(Rs+#u6:1)=#S8
1286 let AddedComplexity = 10, isPredicable = 1 in
1287 def STrih_imm_V4 : STInst<(outs),
1288             (ins IntRegs:$src1, u6_1Imm:$src2, s8Imm:$src3),
1289             "memh($src1+#$src2) = #$src3",
1290             [(truncstorei16 s8ImmPred:$src3, (add IntRegs:$src1,
1291                                                   u6_1ImmPred:$src2))]>,
1292             Requires<[HasV4T]>;
1293
1294 // memh(Rs+Ru<<#u2)=Rt.H
1295 // TODO: needs to be implemented.
1296
1297 // memh(Rs+Ru<<#u2)=Rt
1298 let AddedComplexity = 10, isPredicable = 1 in
1299 def STrih_indexed_shl_V4 : STInst<(outs),
1300             (ins IntRegs:$src1, IntRegs:$src2, u2Imm:$src3, IntRegs:$src4),
1301             "memh($src1+$src2<<#$src3) = $src4",
1302             [(truncstorei16 IntRegs:$src4, (add IntRegs:$src1,
1303                                           (shl IntRegs:$src2,
1304                                                u2ImmPred:$src3)))]>,
1305             Requires<[HasV4T]>;
1306
1307 // memh(Ru<<#u2+#U6)=Rt.H
1308 // memh(Ru<<#u2+#U6)=Rt
1309 let AddedComplexity = 10 in
1310 def STrih_shl_V4 : STInst<(outs),
1311             (ins IntRegs:$src1, u2Imm:$src2, u6Imm:$src3, IntRegs:$src4),
1312             "memh($src1<<#$src2+#$src3) = $src4",
1313             [(truncstorei16 IntRegs:$src4, (shl IntRegs:$src1,
1314                                           (add u2ImmPred:$src2,
1315                                                u6ImmPred:$src3)))]>,
1316             Requires<[HasV4T]>;
1317
1318 // memh(Rx++#s4:1:circ(Mu))=Rt.H
1319 // memh(Rx++#s4:1:circ(Mu))=Rt
1320 // memh(Rx++I:circ(Mu))=Rt.H
1321 // memh(Rx++I:circ(Mu))=Rt
1322 // memh(Rx++Mu)=Rt.H
1323 // memh(Rx++Mu)=Rt
1324 // memh(Rx++Mu:brev)=Rt.H
1325 // memh(Rx++Mu:brev)=Rt
1326 // memh(gp+#u16:1)=Rt.H
1327 // memh(gp+#u16:1)=Rt
1328
1329
1330 // Store halfword conditionally.
1331 // if ([!]Pv[.new]) memh(#u6)=Rt.H
1332 // if ([!]Pv[.new]) memh(#u6)=Rt
1333
1334 // if ([!]Pv[.new]) memh(Rs+#u6:1)=#S6
1335 // if (Pv) memh(Rs+#u6:1)=#S6
1336 let mayStore = 1, neverHasSideEffects = 1 in
1337 def STrih_imm_cPt_V4 : STInst<(outs),
1338             (ins PredRegs:$src1, IntRegs:$src2, u6_1Imm:$src3, s6Imm:$src4),
1339             "if ($src1) memh($src2+#$src3) = #$src4",
1340             []>,
1341             Requires<[HasV4T]>;
1342
1343 // if (Pv.new) memh(Rs+#u6:1)=#S6
1344 let mayStore = 1, neverHasSideEffects = 1 in
1345 def STrih_imm_cdnPt_V4 : STInst<(outs),
1346             (ins PredRegs:$src1, IntRegs:$src2, u6_1Imm:$src3, s6Imm:$src4),
1347             "if ($src1.new) memh($src2+#$src3) = #$src4",
1348             []>,
1349             Requires<[HasV4T]>;
1350
1351 // if (!Pv) memh(Rs+#u6:1)=#S6
1352 let mayStore = 1, neverHasSideEffects = 1 in
1353 def STrih_imm_cNotPt_V4 : STInst<(outs),
1354             (ins PredRegs:$src1, IntRegs:$src2, u6_1Imm:$src3, s6Imm:$src4),
1355             "if (!$src1) memh($src2+#$src3) = #$src4",
1356             []>,
1357             Requires<[HasV4T]>;
1358
1359 // if (!Pv.new) memh(Rs+#u6:1)=#S6
1360 let mayStore = 1, neverHasSideEffects = 1 in
1361 def STrih_imm_cdnNotPt_V4 : STInst<(outs),
1362             (ins PredRegs:$src1, IntRegs:$src2, u6_1Imm:$src3, s6Imm:$src4),
1363             "if (!$src1.new) memh($src2+#$src3) = #$src4",
1364             []>,
1365             Requires<[HasV4T]>;
1366
1367 // if ([!]Pv[.new]) memh(Rs+#u6:1)=Rt.H
1368 // TODO: needs to be implemented.
1369
1370 // if ([!]Pv[.new]) memh(Rs+#u6:1)=Rt
1371 // if (Pv) memh(Rs+#u6:1)=Rt
1372 // if (Pv.new) memh(Rs+#u6:1)=Rt
1373 let mayStore = 1, neverHasSideEffects = 1 in
1374 def STrih_cdnPt_V4 : STInst<(outs),
1375             (ins PredRegs:$src1, MEMri:$addr, IntRegs:$src2),
1376             "if ($src1.new) memh($addr) = $src2",
1377             []>,
1378             Requires<[HasV4T]>;
1379
1380 // if (!Pv) memh(Rs+#u6:1)=Rt
1381 // if (!Pv.new) memh(Rs+#u6:1)=Rt
1382 let mayStore = 1, neverHasSideEffects = 1 in
1383 def STrih_cdnNotPt_V4 : STInst<(outs),
1384             (ins PredRegs:$src1, MEMri:$addr, IntRegs:$src2),
1385             "if (!$src1.new) memh($addr) = $src2",
1386             []>,
1387             Requires<[HasV4T]>;
1388
1389 // if (Pv.new) memh(Rs+#u6:1)=Rt
1390 let mayStore = 1, neverHasSideEffects = 1 in
1391 def STrih_indexed_cdnPt_V4 : STInst<(outs),
1392             (ins PredRegs:$src1, IntRegs:$src2, u6_1Imm:$src3, IntRegs:$src4),
1393             "if ($src1.new) memh($src2+#$src3) = $src4",
1394             []>,
1395             Requires<[HasV4T]>;
1396
1397 // if (!Pv.new) memh(Rs+#u6:1)=Rt
1398 let mayStore = 1, neverHasSideEffects = 1 in
1399 def STrih_indexed_cdnNotPt_V4 : STInst<(outs),
1400             (ins PredRegs:$src1, IntRegs:$src2, u6_1Imm:$src3, IntRegs:$src4),
1401             "if (!$src1.new) memh($src2+#$src3) = $src4",
1402             []>,
1403             Requires<[HasV4T]>;
1404
1405 // if ([!]Pv[.new]) memh(Rs+Ru<<#u2)=Rt.H
1406 // if ([!]Pv[.new]) memh(Rs+Ru<<#u2)=Rt
1407 // if (Pv) memh(Rs+Ru<<#u2)=Rt
1408 let mayStore = 1, AddedComplexity = 10 in
1409 def STrih_indexed_shl_cPt_V4 : STInst<(outs),
1410             (ins PredRegs:$src1, IntRegs:$src2, IntRegs:$src3, u2Imm:$src4,
1411                  IntRegs:$src5),
1412             "if ($src1) memh($src2+$src3<<#$src4) = $src5",
1413             []>,
1414             Requires<[HasV4T]>;
1415
1416 // if (Pv.new) memh(Rs+Ru<<#u2)=Rt
1417 def STrih_indexed_shl_cdnPt_V4 : STInst<(outs),
1418             (ins PredRegs:$src1, IntRegs:$src2, IntRegs:$src3, u2Imm:$src4,
1419                  IntRegs:$src5),
1420             "if ($src1.new) memh($src2+$src3<<#$src4) = $src5",
1421             []>,
1422             Requires<[HasV4T]>;
1423
1424 // if (!Pv) memh(Rs+Ru<<#u2)=Rt
1425 let mayStore = 1, AddedComplexity = 10 in
1426 def STrih_indexed_shl_cNotPt_V4 : STInst<(outs),
1427             (ins PredRegs:$src1, IntRegs:$src2, IntRegs:$src3, u2Imm:$src4,
1428                  IntRegs:$src5),
1429             "if (!$src1) memh($src2+$src3<<#$src4) = $src5",
1430             []>,
1431             Requires<[HasV4T]>;
1432
1433 // if (!Pv.new) memh(Rs+Ru<<#u2)=Rt
1434 let mayStore = 1, AddedComplexity = 10 in
1435 def STrih_indexed_shl_cdnNotPt_V4 : STInst<(outs),
1436             (ins PredRegs:$src1, IntRegs:$src2, IntRegs:$src3, u2Imm:$src4,
1437                  IntRegs:$src5),
1438             "if (!$src1.new) memh($src2+$src3<<#$src4) = $src5",
1439             []>,
1440             Requires<[HasV4T]>;
1441
1442 // if ([!]Pv[.new]) memh(Rx++#s4:1)=Rt.H
1443 // TODO: Needs to be implemented.
1444
1445 // if ([!]Pv[.new]) memh(Rx++#s4:1)=Rt
1446 // if (Pv) memh(Rx++#s4:1)=Rt
1447 // if (Pv.new) memh(Rx++#s4:1)=Rt
1448 let mayStore = 1, hasCtrlDep = 1 in
1449 def POST_SThri_cdnPt_V4 : STInstPI<(outs IntRegs:$dst),
1450             (ins PredRegs:$src1, IntRegs:$src2, IntRegs:$src3, s4_1Imm:$offset),
1451             "if ($src1.new) memh($src3++#$offset) = $src2",
1452             [],"$src3 = $dst">,
1453             Requires<[HasV4T]>;
1454
1455 // if (!Pv) memh(Rx++#s4:1)=Rt
1456 // if (!Pv.new) memh(Rx++#s4:1)=Rt
1457 let mayStore = 1, hasCtrlDep = 1 in
1458 def POST_SThri_cdnNotPt_V4 : STInstPI<(outs IntRegs:$dst),
1459             (ins PredRegs:$src1, IntRegs:$src2, IntRegs:$src3, s4_1Imm:$offset),
1460             "if (!$src1.new) memh($src3++#$offset) = $src2",
1461             [],"$src3 = $dst">,
1462             Requires<[HasV4T]>;
1463
1464
1465 // Store word.
1466 // memw(Re=#U6)=Rt
1467 // TODO: Needs to be implemented.
1468
1469 // memw(Rs+#s11:2)=Rt
1470 // memw(Rs+#u6:2)=#S8
1471 let AddedComplexity = 10, isPredicable = 1 in
1472 def STriw_imm_V4 : STInst<(outs),
1473             (ins IntRegs:$src1, u6_2Imm:$src2, s8Imm:$src3),
1474             "memw($src1+#$src2) = #$src3",
1475             [(store s8ImmPred:$src3, (add IntRegs:$src1, u6_2ImmPred:$src2))]>,
1476             Requires<[HasV4T]>;
1477
1478 // memw(Rs+Ru<<#u2)=Rt
1479 let AddedComplexity = 10, isPredicable = 1 in
1480 def STriw_indexed_shl_V4 : STInst<(outs),
1481             (ins IntRegs:$src1, IntRegs:$src2, u2Imm:$src3, IntRegs:$src4),
1482             "memw($src1+$src2<<#$src3) = $src4",
1483             [(store IntRegs:$src4, (add IntRegs:$src1,
1484                                     (shl IntRegs:$src2, u2ImmPred:$src3)))]>,
1485             Requires<[HasV4T]>;
1486
1487 // memw(Ru<<#u2+#U6)=Rt
1488 let AddedComplexity = 10 in
1489 def STriw_shl_V4 : STInst<(outs),
1490             (ins IntRegs:$src1, u2Imm:$src2, u6Imm:$src3, IntRegs:$src4),
1491             "memw($src1<<#$src2+#$src3) = $src4",
1492             [(store IntRegs:$src4, (shl IntRegs:$src1,
1493                                    (add u2ImmPred:$src2, u6ImmPred:$src3)))]>,
1494             Requires<[HasV4T]>;
1495
1496 // memw(Rx++#s4:2)=Rt
1497 // memw(Rx++#s4:2:circ(Mu))=Rt
1498 // memw(Rx++I:circ(Mu))=Rt
1499 // memw(Rx++Mu)=Rt
1500 // memw(Rx++Mu:brev)=Rt
1501 // memw(gp+#u16:2)=Rt
1502
1503
1504 // Store word conditionally.
1505 // if ([!]Pv[.new]) memw(#u6)=Rt
1506 // TODO: Needs to be implemented.
1507
1508 // if ([!]Pv[.new]) memw(Rs+#u6:2)=#S6
1509 // if (Pv) memw(Rs+#u6:2)=#S6
1510 let mayStore = 1, neverHasSideEffects = 1 in
1511 def STriw_imm_cPt_V4 : STInst<(outs),
1512             (ins PredRegs:$src1, IntRegs:$src2, u6_2Imm:$src3, s6Imm:$src4),
1513             "if ($src1) memw($src2+#$src3) = #$src4",
1514             []>,
1515             Requires<[HasV4T]>;
1516
1517 // if (Pv.new) memw(Rs+#u6:2)=#S6
1518 let mayStore = 1, neverHasSideEffects = 1 in
1519 def STriw_imm_cdnPt_V4 : STInst<(outs),
1520             (ins PredRegs:$src1, IntRegs:$src2, u6_2Imm:$src3, s6Imm:$src4),
1521             "if ($src1.new) memw($src2+#$src3) = #$src4",
1522             []>,
1523             Requires<[HasV4T]>;
1524
1525 // if (!Pv) memw(Rs+#u6:2)=#S6
1526 let mayStore = 1, neverHasSideEffects = 1 in
1527 def STriw_imm_cNotPt_V4 : STInst<(outs),
1528             (ins PredRegs:$src1, IntRegs:$src2, u6_2Imm:$src3, s6Imm:$src4),
1529             "if (!$src1) memw($src2+#$src3) = #$src4",
1530             []>,
1531             Requires<[HasV4T]>;
1532
1533 // if (!Pv.new) memw(Rs+#u6:2)=#S6
1534 let mayStore = 1, neverHasSideEffects = 1 in
1535 def STriw_imm_cdnNotPt_V4 : STInst<(outs),
1536             (ins PredRegs:$src1, IntRegs:$src2, u6_2Imm:$src3, s6Imm:$src4),
1537             "if (!$src1.new) memw($src2+#$src3) = #$src4",
1538             []>,
1539             Requires<[HasV4T]>;
1540
1541 // if ([!]Pv[.new]) memw(Rs+#u6:2)=Rt
1542 // if (Pv) memw(Rs+#u6:2)=Rt
1543 // if (Pv.new) memw(Rs+#u6:2)=Rt
1544 let mayStore = 1, neverHasSideEffects = 1 in
1545 def STriw_cdnPt_V4 : STInst<(outs),
1546             (ins PredRegs:$src1, MEMri:$addr, IntRegs:$src2),
1547             "if ($src1.new) memw($addr) = $src2",
1548             []>,
1549             Requires<[HasV4T]>;
1550
1551 // if (!Pv) memw(Rs+#u6:2)=Rt
1552 // if (!Pv.new) memw(Rs+#u6:2)=Rt
1553 let mayStore = 1, neverHasSideEffects = 1 in
1554 def STriw_cdnNotPt_V4 : STInst<(outs),
1555             (ins PredRegs:$src1, MEMri:$addr, IntRegs:$src2),
1556             "if (!$src1.new) memw($addr) = $src2",
1557             []>,
1558             Requires<[HasV4T]>;
1559
1560 // if (Pv) memw(Rs+#u6:2)=Rt
1561 // if (!Pv) memw(Rs+#u6:2)=Rt
1562 // if (Pv.new) memw(Rs+#u6:2)=Rt
1563 let mayStore = 1, neverHasSideEffects = 1 in
1564 def STriw_indexed_cdnPt_V4 : STInst<(outs),
1565             (ins PredRegs:$src1, IntRegs:$src2, u6_2Imm:$src3, IntRegs:$src4),
1566             "if ($src1.new) memw($src2+#$src3) = $src4",
1567             []>,
1568             Requires<[HasV4T]>;
1569
1570 // if (!Pv.new) memw(Rs+#u6:2)=Rt
1571 let mayStore = 1, neverHasSideEffects = 1 in
1572 def STriw_indexed_cdnNotPt_V4 : STInst<(outs),
1573             (ins PredRegs:$src1, IntRegs:$src2, u6_2Imm:$src3, IntRegs:$src4),
1574             "if (!$src1.new) memw($src2+#$src3) = $src4",
1575             []>,
1576             Requires<[HasV4T]>;
1577
1578 // if ([!]Pv[.new]) memw(Rs+Ru<<#u2)=Rt
1579 // if (Pv) memw(Rs+Ru<<#u2)=Rt
1580 let mayStore = 1, AddedComplexity = 10 in
1581 def STriw_indexed_shl_cPt_V4 : STInst<(outs),
1582             (ins PredRegs:$src1, IntRegs:$src2, IntRegs:$src3, u2Imm:$src4,
1583                  IntRegs:$src5),
1584             "if ($src1) memw($src2+$src3<<#$src4) = $src5",
1585             []>,
1586             Requires<[HasV4T]>;
1587
1588 // if (Pv.new) memw(Rs+Ru<<#u2)=Rt
1589 let mayStore = 1, AddedComplexity = 10 in
1590 def STriw_indexed_shl_cdnPt_V4 : STInst<(outs),
1591             (ins PredRegs:$src1, IntRegs:$src2, IntRegs:$src3, u2Imm:$src4,
1592                  IntRegs:$src5),
1593             "if ($src1.new) memw($src2+$src3<<#$src4) = $src5",
1594             []>,
1595             Requires<[HasV4T]>;
1596
1597 // if (!Pv) memw(Rs+Ru<<#u2)=Rt
1598 let mayStore = 1, AddedComplexity = 10 in
1599 def STriw_indexed_shl_cNotPt_V4 : STInst<(outs),
1600             (ins PredRegs:$src1, IntRegs:$src2, IntRegs:$src3, u2Imm:$src4,
1601                  IntRegs:$src5),
1602             "if (!$src1) memw($src2+$src3<<#$src4) = $src5",
1603             []>,
1604             Requires<[HasV4T]>;
1605
1606 // if (!Pv.new) memw(Rs+Ru<<#u2)=Rt
1607 let mayStore = 1, AddedComplexity = 10 in
1608 def STriw_indexed_shl_cdnNotPt_V4 : STInst<(outs),
1609             (ins PredRegs:$src1, IntRegs:$src2, IntRegs:$src3, u2Imm:$src4,
1610                  IntRegs:$src5),
1611             "if (!$src1.new) memw($src2+$src3<<#$src4) = $src5",
1612             []>,
1613             Requires<[HasV4T]>;
1614
1615 // if ([!]Pv[.new]) memw(Rx++#s4:2)=Rt
1616 // if (Pv) memw(Rx++#s4:2)=Rt
1617 // if (Pv.new) memw(Rx++#s4:2)=Rt
1618 let mayStore = 1, hasCtrlDep = 1 in
1619 def POST_STwri_cdnPt_V4 : STInstPI<(outs IntRegs:$dst),
1620             (ins PredRegs:$src1, IntRegs:$src2, IntRegs:$src3, s4_2Imm:$offset),
1621             "if ($src1.new) memw($src3++#$offset) = $src2",
1622             [],"$src3 = $dst">,
1623             Requires<[HasV4T]>;
1624
1625 // if (!Pv) memw(Rx++#s4:2)=Rt
1626 // if (!Pv.new) memw(Rx++#s4:2)=Rt
1627 let mayStore = 1, hasCtrlDep = 1 in
1628 def POST_STwri_cdnNotPt_V4 : STInstPI<(outs IntRegs:$dst),
1629             (ins PredRegs:$src1, IntRegs:$src2, IntRegs:$src3, s4_2Imm:$offset),
1630             "if (!$src1.new) memw($src3++#$offset) = $src2",
1631             [],"$src3 = $dst">,
1632             Requires<[HasV4T]>;
1633
1634
1635 //===----------------------------------------------------------------------===
1636 // ST -
1637 //===----------------------------------------------------------------------===
1638
1639
1640 //===----------------------------------------------------------------------===//
1641 // NV/ST +
1642 //===----------------------------------------------------------------------===//
1643
1644 // Store new-value byte.
1645
1646 // memb(Re=#U6)=Nt.new
1647 // memb(Rs+#s11:0)=Nt.new
1648 let mayStore = 1, isPredicable = 1 in
1649 def STrib_nv_V4 : NVInst_V4<(outs), (ins MEMri:$addr, IntRegs:$src1),
1650             "memb($addr) = $src1.new",
1651             []>,
1652             Requires<[HasV4T]>;
1653
1654 let mayStore = 1, isPredicable = 1 in
1655 def STrib_indexed_nv_V4 : NVInst_V4<(outs),
1656             (ins IntRegs:$src1, s11_0Imm:$src2, IntRegs:$src3),
1657             "memb($src1+#$src2) = $src3.new",
1658             []>,
1659             Requires<[HasV4T]>;
1660
1661 // memb(Rs+Ru<<#u2)=Nt.new
1662 let mayStore = 1, AddedComplexity = 10, isPredicable = 1 in
1663 def STrib_indexed_shl_nv_V4 : NVInst_V4<(outs),
1664             (ins IntRegs:$src1, IntRegs:$src2, u2Imm:$src3, IntRegs:$src4),
1665             "memb($src1+$src2<<#$src3) = $src4.new",
1666             []>,
1667             Requires<[HasV4T]>;
1668
1669 // memb(Ru<<#u2+#U6)=Nt.new
1670 let mayStore = 1, AddedComplexity = 10 in
1671 def STrib_shl_nv_V4 : NVInst_V4<(outs),
1672             (ins IntRegs:$src1, u2Imm:$src2, u6Imm:$src3, IntRegs:$src4),
1673             "memb($src1<<#$src2+#$src3) = $src4.new",
1674             []>,
1675             Requires<[HasV4T]>;
1676
1677 // memb(Rx++#s4:0)=Nt.new
1678 let mayStore = 1, hasCtrlDep = 1, isPredicable = 1  in
1679 def POST_STbri_nv_V4 : NVInstPI_V4<(outs IntRegs:$dst),
1680             (ins IntRegs:$src1, IntRegs:$src2, s4_0Imm:$offset),
1681             "memb($src2++#$offset) = $src1.new",
1682             [],
1683             "$src2 = $dst">,
1684             Requires<[HasV4T]>;
1685
1686 // memb(Rx++#s4:0:circ(Mu))=Nt.new
1687 // memb(Rx++I:circ(Mu))=Nt.new
1688 // memb(Rx++Mu)=Nt.new
1689 // memb(Rx++Mu:brev)=Nt.new
1690
1691 // memb(gp+#u16:0)=Nt.new
1692 let mayStore = 1, neverHasSideEffects = 1 in
1693 def STrib_GP_nv_V4 : NVInst_V4<(outs),
1694             (ins globaladdress:$global, u16Imm:$offset, IntRegs:$src),
1695             "memb(#$global+$offset) = $src.new",
1696             []>,
1697             Requires<[HasV4T]>;
1698
1699
1700 // Store new-value byte conditionally.
1701 // if ([!]Pv[.new]) memb(#u6)=Nt.new
1702 // if (Pv) memb(Rs+#u6:0)=Nt.new
1703 let mayStore = 1, neverHasSideEffects = 1 in
1704 def STrib_cPt_nv_V4 : NVInst_V4<(outs),
1705             (ins PredRegs:$src1, MEMri:$addr, IntRegs:$src2),
1706             "if ($src1) memb($addr) = $src2.new",
1707             []>,
1708             Requires<[HasV4T]>;
1709
1710 // if (Pv.new) memb(Rs+#u6:0)=Nt.new
1711 let mayStore = 1, neverHasSideEffects = 1 in
1712 def STrib_cdnPt_nv_V4 : NVInst_V4<(outs),
1713             (ins PredRegs:$src1, MEMri:$addr, IntRegs:$src2),
1714             "if ($src1.new) memb($addr) = $src2.new",
1715             []>,
1716             Requires<[HasV4T]>;
1717
1718 // if (!Pv) memb(Rs+#u6:0)=Nt.new
1719 let mayStore = 1, neverHasSideEffects = 1 in
1720 def STrib_cNotPt_nv_V4 : NVInst_V4<(outs),
1721             (ins PredRegs:$src1, MEMri:$addr, IntRegs:$src2),
1722             "if (!$src1) memb($addr) = $src2.new",
1723             []>,
1724             Requires<[HasV4T]>;
1725
1726 // if (!Pv.new) memb(Rs+#u6:0)=Nt.new
1727 let mayStore = 1, neverHasSideEffects = 1 in
1728 def STrib_cdnNotPt_nv_V4 : NVInst_V4<(outs),
1729             (ins PredRegs:$src1, MEMri:$addr, IntRegs:$src2),
1730             "if (!$src1.new) memb($addr) = $src2.new",
1731             []>,
1732             Requires<[HasV4T]>;
1733
1734 // if (Pv) memb(Rs+#u6:0)=Nt.new
1735 let mayStore = 1, neverHasSideEffects = 1 in
1736 def STrib_indexed_cPt_nv_V4 : NVInst_V4<(outs),
1737             (ins PredRegs:$src1, IntRegs:$src2, u6_0Imm:$src3, IntRegs:$src4),
1738             "if ($src1) memb($src2+#$src3) = $src4.new",
1739             []>,
1740             Requires<[HasV4T]>;
1741
1742 // if (Pv.new) memb(Rs+#u6:0)=Nt.new
1743 let mayStore = 1, neverHasSideEffects = 1 in
1744 def STrib_indexed_cdnPt_nv_V4 : NVInst_V4<(outs),
1745             (ins PredRegs:$src1, IntRegs:$src2, u6_0Imm:$src3, IntRegs:$src4),
1746             "if ($src1.new) memb($src2+#$src3) = $src4.new",
1747             []>,
1748             Requires<[HasV4T]>;
1749
1750 // if (!Pv) memb(Rs+#u6:0)=Nt.new
1751 let mayStore = 1, neverHasSideEffects = 1 in
1752 def STrib_indexed_cNotPt_nv_V4 : NVInst_V4<(outs),
1753             (ins PredRegs:$src1, IntRegs:$src2, u6_0Imm:$src3, IntRegs:$src4),
1754             "if (!$src1) memb($src2+#$src3) = $src4.new",
1755             []>,
1756             Requires<[HasV4T]>;
1757
1758 // if (!Pv.new) memb(Rs+#u6:0)=Nt.new
1759 let mayStore = 1, neverHasSideEffects = 1 in
1760 def STrib_indexed_cdnNotPt_nv_V4 : NVInst_V4<(outs),
1761             (ins PredRegs:$src1, IntRegs:$src2, u6_0Imm:$src3, IntRegs:$src4),
1762             "if (!$src1.new) memb($src2+#$src3) = $src4.new",
1763             []>,
1764             Requires<[HasV4T]>;
1765
1766
1767 // if ([!]Pv[.new]) memb(Rs+Ru<<#u2)=Nt.new
1768 // if (Pv) memb(Rs+Ru<<#u2)=Nt.new
1769 let mayStore = 1, AddedComplexity = 10 in
1770 def STrib_indexed_shl_cPt_nv_V4 : NVInst_V4<(outs),
1771             (ins PredRegs:$src1, IntRegs:$src2, IntRegs:$src3, u2Imm:$src4,
1772                  IntRegs:$src5),
1773             "if ($src1) memb($src2+$src3<<#$src4) = $src5.new",
1774             []>,
1775             Requires<[HasV4T]>;
1776
1777 // if (Pv.new) memb(Rs+Ru<<#u2)=Nt.new
1778 let mayStore = 1, AddedComplexity = 10 in
1779 def STrib_indexed_shl_cdnPt_nv_V4 : NVInst_V4<(outs),
1780             (ins PredRegs:$src1, IntRegs:$src2, IntRegs:$src3, u2Imm:$src4,
1781                  IntRegs:$src5),
1782             "if ($src1.new) memb($src2+$src3<<#$src4) = $src5.new",
1783             []>,
1784             Requires<[HasV4T]>;
1785
1786 // if (!Pv) memb(Rs+Ru<<#u2)=Nt.new
1787 let mayStore = 1, AddedComplexity = 10 in
1788 def STrib_indexed_shl_cNotPt_nv_V4 : NVInst_V4<(outs),
1789             (ins PredRegs:$src1, IntRegs:$src2, IntRegs:$src3, u2Imm:$src4,
1790                  IntRegs:$src5),
1791             "if (!$src1) memb($src2+$src3<<#$src4) = $src5.new",
1792             []>,
1793             Requires<[HasV4T]>;
1794
1795 // if (!Pv.new) memb(Rs+Ru<<#u2)=Nt.new
1796 let mayStore = 1, AddedComplexity = 10 in
1797 def STrib_indexed_shl_cdnNotPt_nv_V4 : NVInst_V4<(outs),
1798             (ins PredRegs:$src1, IntRegs:$src2, IntRegs:$src3, u2Imm:$src4,
1799                  IntRegs:$src5),
1800             "if (!$src1.new) memb($src2+$src3<<#$src4) = $src5.new",
1801             []>,
1802             Requires<[HasV4T]>;
1803
1804 // if ([!]Pv[.new]) memb(Rx++#s4:0)=Nt.new
1805 // if (Pv) memb(Rx++#s4:0)=Nt.new
1806 let mayStore = 1, hasCtrlDep = 1 in
1807 def POST_STbri_cPt_nv_V4 : NVInstPI_V4<(outs IntRegs:$dst),
1808             (ins PredRegs:$src1, IntRegs:$src2, IntRegs:$src3, s4_0Imm:$offset),
1809             "if ($src1) memb($src3++#$offset) = $src2.new",
1810             [],"$src3 = $dst">,
1811             Requires<[HasV4T]>;
1812
1813 // if (Pv.new) memb(Rx++#s4:0)=Nt.new
1814 let mayStore = 1, hasCtrlDep = 1 in
1815 def POST_STbri_cdnPt_nv_V4 : NVInstPI_V4<(outs IntRegs:$dst),
1816             (ins PredRegs:$src1, IntRegs:$src2, IntRegs:$src3, s4_0Imm:$offset),
1817             "if ($src1.new) memb($src3++#$offset) = $src2.new",
1818             [],"$src3 = $dst">,
1819             Requires<[HasV4T]>;
1820
1821 // if (!Pv) memb(Rx++#s4:0)=Nt.new
1822 let mayStore = 1, hasCtrlDep = 1 in
1823 def POST_STbri_cNotPt_nv_V4 : NVInstPI_V4<(outs IntRegs:$dst),
1824             (ins PredRegs:$src1, IntRegs:$src2, IntRegs:$src3, s4_0Imm:$offset),
1825             "if (!$src1) memb($src3++#$offset) = $src2.new",
1826             [],"$src3 = $dst">,
1827             Requires<[HasV4T]>;
1828
1829 // if (!Pv.new) memb(Rx++#s4:0)=Nt.new
1830 let mayStore = 1, hasCtrlDep = 1 in
1831 def POST_STbri_cdnNotPt_nv_V4 : NVInstPI_V4<(outs IntRegs:$dst),
1832             (ins PredRegs:$src1, IntRegs:$src2, IntRegs:$src3, s4_0Imm:$offset),
1833             "if (!$src1.new) memb($src3++#$offset) = $src2.new",
1834             [],"$src3 = $dst">,
1835             Requires<[HasV4T]>;
1836
1837
1838 // Store new-value halfword.
1839 // memh(Re=#U6)=Nt.new
1840 // memh(Rs+#s11:1)=Nt.new
1841 let mayStore = 1, isPredicable = 1 in
1842 def STrih_nv_V4 : NVInst_V4<(outs), (ins MEMri:$addr, IntRegs:$src1),
1843             "memh($addr) = $src1.new",
1844             []>,
1845             Requires<[HasV4T]>;
1846
1847 let mayStore = 1, isPredicable = 1 in
1848 def STrih_indexed_nv_V4 : NVInst_V4<(outs),
1849             (ins IntRegs:$src1, s11_1Imm:$src2, IntRegs:$src3),
1850             "memh($src1+#$src2) = $src3.new",
1851             []>,
1852             Requires<[HasV4T]>;
1853
1854 // memh(Rs+Ru<<#u2)=Nt.new
1855 let mayStore = 1, AddedComplexity = 10, isPredicable = 1 in
1856 def STrih_indexed_shl_nv_V4 : NVInst_V4<(outs),
1857             (ins IntRegs:$src1, IntRegs:$src2, u2Imm:$src3, IntRegs:$src4),
1858             "memh($src1+$src2<<#$src3) = $src4.new",
1859             []>,
1860             Requires<[HasV4T]>;
1861
1862 // memh(Ru<<#u2+#U6)=Nt.new
1863 let mayStore = 1, AddedComplexity = 10 in
1864 def STrih_shl_nv_V4 : NVInst_V4<(outs),
1865             (ins IntRegs:$src1, u2Imm:$src2, u6Imm:$src3, IntRegs:$src4),
1866             "memh($src1<<#$src2+#$src3) = $src4.new",
1867             []>,
1868             Requires<[HasV4T]>;
1869
1870 // memh(Rx++#s4:1)=Nt.new
1871 let mayStore = 1, hasCtrlDep = 1, isPredicable = 1  in
1872 def POST_SThri_nv_V4 : NVInstPI_V4<(outs IntRegs:$dst),
1873             (ins IntRegs:$src1, IntRegs:$src2, s4_1Imm:$offset),
1874             "memh($src2++#$offset) = $src1.new",
1875             [],
1876             "$src2 = $dst">,
1877             Requires<[HasV4T]>;
1878
1879 // memh(Rx++#s4:1:circ(Mu))=Nt.new
1880 // memh(Rx++I:circ(Mu))=Nt.new
1881 // memh(Rx++Mu)=Nt.new
1882 // memh(Rx++Mu:brev)=Nt.new
1883
1884 // memh(gp+#u16:1)=Nt.new
1885 let mayStore = 1, neverHasSideEffects = 1 in
1886 def STrih_GP_nv_V4 : NVInst_V4<(outs),
1887             (ins globaladdress:$global, u16Imm:$offset, IntRegs:$src),
1888             "memh(#$global+$offset) = $src.new",
1889             []>,
1890             Requires<[HasV4T]>;
1891
1892
1893 // Store new-value halfword conditionally.
1894
1895 // if ([!]Pv[.new]) memh(#u6)=Nt.new
1896
1897 // if ([!]Pv[.new]) memh(Rs+#u6:1)=Nt.new
1898 // if (Pv) memh(Rs+#u6:1)=Nt.new
1899 let mayStore = 1, neverHasSideEffects = 1 in
1900 def STrih_cPt_nv_V4 : NVInst_V4<(outs),
1901             (ins PredRegs:$src1, MEMri:$addr, IntRegs:$src2),
1902             "if ($src1) memh($addr) = $src2.new",
1903             []>,
1904             Requires<[HasV4T]>;
1905
1906 // if (Pv.new) memh(Rs+#u6:1)=Nt.new
1907 let mayStore = 1, neverHasSideEffects = 1 in
1908 def STrih_cdnPt_nv_V4 : NVInst_V4<(outs),
1909             (ins PredRegs:$src1, MEMri:$addr, IntRegs:$src2),
1910             "if ($src1.new) memh($addr) = $src2.new",
1911             []>,
1912             Requires<[HasV4T]>;
1913
1914 // if (!Pv) memh(Rs+#u6:1)=Nt.new
1915 let mayStore = 1, neverHasSideEffects = 1 in
1916 def STrih_cNotPt_nv_V4 : NVInst_V4<(outs),
1917             (ins PredRegs:$src1, MEMri:$addr, IntRegs:$src2),
1918             "if (!$src1) memh($addr) = $src2.new",
1919             []>,
1920             Requires<[HasV4T]>;
1921
1922 // if (!Pv.new) memh(Rs+#u6:1)=Nt.new
1923 let mayStore = 1, neverHasSideEffects = 1 in
1924 def STrih_cdnNotPt_nv_V4 : NVInst_V4<(outs),
1925             (ins PredRegs:$src1, MEMri:$addr, IntRegs:$src2),
1926             "if (!$src1.new) memh($addr) = $src2.new",
1927             []>,
1928             Requires<[HasV4T]>;
1929
1930 // if (Pv) memh(Rs+#u6:1)=Nt.new
1931 let mayStore = 1, neverHasSideEffects = 1 in
1932 def STrih_indexed_cPt_nv_V4 : NVInst_V4<(outs),
1933             (ins PredRegs:$src1, IntRegs:$src2, u6_1Imm:$src3, IntRegs:$src4),
1934             "if ($src1) memh($src2+#$src3) = $src4.new",
1935             []>,
1936             Requires<[HasV4T]>;
1937
1938 // if (Pv.new) memh(Rs+#u6:1)=Nt.new
1939 let mayStore = 1, neverHasSideEffects = 1 in
1940 def STrih_indexed_cdnPt_nv_V4 : NVInst_V4<(outs),
1941             (ins PredRegs:$src1, IntRegs:$src2, u6_1Imm:$src3, IntRegs:$src4),
1942             "if ($src1.new) memh($src2+#$src3) = $src4.new",
1943             []>,
1944             Requires<[HasV4T]>;
1945
1946 // if (!Pv) memh(Rs+#u6:1)=Nt.new
1947 let mayStore = 1, neverHasSideEffects = 1 in
1948 def STrih_indexed_cNotPt_nv_V4 : NVInst_V4<(outs),
1949             (ins PredRegs:$src1, IntRegs:$src2, u6_1Imm:$src3, IntRegs:$src4),
1950             "if (!$src1) memh($src2+#$src3) = $src4.new",
1951             []>,
1952             Requires<[HasV4T]>;
1953
1954 // if (!Pv.new) memh(Rs+#u6:1)=Nt.new
1955 let mayStore = 1, neverHasSideEffects = 1 in
1956 def STrih_indexed_cdnNotPt_nv_V4 : NVInst_V4<(outs),
1957             (ins PredRegs:$src1, IntRegs:$src2, u6_1Imm:$src3, IntRegs:$src4),
1958             "if (!$src1.new) memh($src2+#$src3) = $src4.new",
1959             []>,
1960             Requires<[HasV4T]>;
1961
1962 // if ([!]Pv[.new]) memh(Rs+Ru<<#u2)=Nt.new
1963 // if (Pv) memh(Rs+Ru<<#u2)=Nt.new
1964 let mayStore = 1, AddedComplexity = 10 in
1965 def STrih_indexed_shl_cPt_nv_V4 : NVInst_V4<(outs),
1966             (ins PredRegs:$src1, IntRegs:$src2, IntRegs:$src3, u2Imm:$src4,
1967                  IntRegs:$src5),
1968             "if ($src1) memh($src2+$src3<<#$src4) = $src5.new",
1969             []>,
1970             Requires<[HasV4T]>;
1971
1972 // if (Pv.new) memh(Rs+Ru<<#u2)=Nt.new
1973 let mayStore = 1, AddedComplexity = 10 in
1974 def STrih_indexed_shl_cdnPt_nv_V4 : NVInst_V4<(outs),
1975             (ins PredRegs:$src1, IntRegs:$src2, IntRegs:$src3, u2Imm:$src4,
1976                  IntRegs:$src5),
1977             "if ($src1.new) memh($src2+$src3<<#$src4) = $src5.new",
1978             []>,
1979             Requires<[HasV4T]>;
1980
1981 // if (!Pv) memh(Rs+Ru<<#u2)=Nt.new
1982 let mayStore = 1, AddedComplexity = 10 in
1983 def STrih_indexed_shl_cNotPt_nv_V4 : NVInst_V4<(outs),
1984             (ins PredRegs:$src1, IntRegs:$src2, IntRegs:$src3, u2Imm:$src4,
1985                  IntRegs:$src5),
1986             "if (!$src1) memh($src2+$src3<<#$src4) = $src5.new",
1987             []>,
1988             Requires<[HasV4T]>;
1989
1990 // if (!Pv.new) memh(Rs+Ru<<#u2)=Nt.new
1991 let mayStore = 1, AddedComplexity = 10 in
1992 def STrih_indexed_shl_cdnNotPt_nv_V4 : NVInst_V4<(outs),
1993             (ins PredRegs:$src1, IntRegs:$src2, IntRegs:$src3, u2Imm:$src4,
1994                  IntRegs:$src5),
1995             "if (!$src1.new) memh($src2+$src3<<#$src4) = $src5.new",
1996             []>,
1997             Requires<[HasV4T]>;
1998
1999 // if ([!]Pv[]) memh(Rx++#s4:1)=Nt.new
2000 // if (Pv) memh(Rx++#s4:1)=Nt.new
2001 let mayStore = 1, hasCtrlDep = 1 in
2002 def POST_SThri_cPt_nv_V4 : NVInstPI_V4<(outs IntRegs:$dst),
2003             (ins PredRegs:$src1, IntRegs:$src2, IntRegs:$src3, s4_1Imm:$offset),
2004             "if ($src1) memh($src3++#$offset) = $src2.new",
2005             [],"$src3 = $dst">,
2006             Requires<[HasV4T]>;
2007
2008 // if (Pv.new) memh(Rx++#s4:1)=Nt.new
2009 let mayStore = 1, hasCtrlDep = 1 in
2010 def POST_SThri_cdnPt_nv_V4 : NVInstPI_V4<(outs IntRegs:$dst),
2011             (ins PredRegs:$src1, IntRegs:$src2, IntRegs:$src3, s4_1Imm:$offset),
2012             "if ($src1.new) memh($src3++#$offset) = $src2.new",
2013             [],"$src3 = $dst">,
2014             Requires<[HasV4T]>;
2015
2016 // if (!Pv) memh(Rx++#s4:1)=Nt.new
2017 let mayStore = 1, hasCtrlDep = 1 in
2018 def POST_SThri_cNotPt_nv_V4 : NVInstPI_V4<(outs IntRegs:$dst),
2019             (ins PredRegs:$src1, IntRegs:$src2, IntRegs:$src3, s4_1Imm:$offset),
2020             "if (!$src1) memh($src3++#$offset) = $src2.new",
2021             [],"$src3 = $dst">,
2022             Requires<[HasV4T]>;
2023
2024 // if (!Pv.new) memh(Rx++#s4:1)=Nt.new
2025 let mayStore = 1, hasCtrlDep = 1 in
2026 def POST_SThri_cdnNotPt_nv_V4 : NVInstPI_V4<(outs IntRegs:$dst),
2027             (ins PredRegs:$src1, IntRegs:$src2, IntRegs:$src3, s4_1Imm:$offset),
2028             "if (!$src1.new) memh($src3++#$offset) = $src2.new",
2029             [],"$src3 = $dst">,
2030             Requires<[HasV4T]>;
2031
2032
2033 // Store new-value word.
2034
2035 // memw(Re=#U6)=Nt.new
2036 // memw(Rs+#s11:2)=Nt.new
2037 let mayStore = 1, isPredicable = 1 in
2038 def STriw_nv_V4 : NVInst_V4<(outs),
2039             (ins MEMri:$addr, IntRegs:$src1),
2040             "memw($addr) = $src1.new",
2041             []>,
2042             Requires<[HasV4T]>;
2043
2044 let mayStore = 1, isPredicable = 1 in
2045 def STriw_indexed_nv_V4 : NVInst_V4<(outs),
2046             (ins IntRegs:$src1, s11_2Imm:$src2, IntRegs:$src3),
2047             "memw($src1+#$src2) = $src3.new",
2048             []>,
2049             Requires<[HasV4T]>;
2050
2051 // memw(Rs+Ru<<#u2)=Nt.new
2052 let mayStore = 1, AddedComplexity = 10, isPredicable = 1 in
2053 def STriw_indexed_shl_nv_V4 : NVInst_V4<(outs),
2054             (ins IntRegs:$src1, IntRegs:$src2, u2Imm:$src3, IntRegs:$src4),
2055             "memw($src1+$src2<<#$src3) = $src4.new",
2056             []>,
2057             Requires<[HasV4T]>;
2058
2059 // memw(Ru<<#u2+#U6)=Nt.new
2060 let mayStore = 1, AddedComplexity = 10 in
2061 def STriw_shl_nv_V4 : NVInst_V4<(outs),
2062             (ins IntRegs:$src1, u2Imm:$src2, u6Imm:$src3, IntRegs:$src4),
2063             "memw($src1<<#$src2+#$src3) = $src4.new",
2064             []>,
2065             Requires<[HasV4T]>;
2066
2067 // memw(Rx++#s4:2)=Nt.new
2068 let mayStore = 1, hasCtrlDep = 1, isPredicable = 1  in
2069 def POST_STwri_nv_V4 : NVInstPI_V4<(outs IntRegs:$dst),
2070             (ins IntRegs:$src1, IntRegs:$src2, s4_2Imm:$offset),
2071             "memw($src2++#$offset) = $src1.new",
2072             [],
2073             "$src2 = $dst">,
2074             Requires<[HasV4T]>;
2075
2076 // memw(Rx++#s4:2:circ(Mu))=Nt.new
2077 // memw(Rx++I:circ(Mu))=Nt.new
2078 // memw(Rx++Mu)=Nt.new
2079 // memw(Rx++Mu:brev)=Nt.new
2080 // memw(gp+#u16:2)=Nt.new
2081 let mayStore = 1, neverHasSideEffects = 1 in
2082 def STriw_GP_nv_V4 : NVInst_V4<(outs),
2083             (ins globaladdress:$global, u16Imm:$offset, IntRegs:$src),
2084             "memw(#$global+$offset) = $src.new",
2085             []>,
2086             Requires<[HasV4T]>;
2087
2088
2089 // Store new-value word conditionally.
2090
2091 // if ([!]Pv[.new]) memw(#u6)=Nt.new
2092
2093 // if ([!]Pv[.new]) memw(Rs+#u6:2)=Nt.new
2094 // if (Pv) memw(Rs+#u6:2)=Nt.new
2095 let mayStore = 1, neverHasSideEffects = 1 in
2096 def STriw_cPt_nv_V4 : NVInst_V4<(outs),
2097             (ins PredRegs:$src1, MEMri:$addr, IntRegs:$src2),
2098             "if ($src1) memw($addr) = $src2.new",
2099             []>,
2100             Requires<[HasV4T]>;
2101
2102 // if (Pv.new) memw(Rs+#u6:2)=Nt.new
2103 let mayStore = 1, neverHasSideEffects = 1 in
2104 def STriw_cdnPt_nv_V4 : NVInst_V4<(outs),
2105             (ins PredRegs:$src1, MEMri:$addr, IntRegs:$src2),
2106             "if ($src1.new) memw($addr) = $src2.new",
2107             []>,
2108             Requires<[HasV4T]>;
2109
2110 // if (!Pv) memw(Rs+#u6:2)=Nt.new
2111 let mayStore = 1, neverHasSideEffects = 1 in
2112 def STriw_cNotPt_nv_V4 : NVInst_V4<(outs),
2113             (ins PredRegs:$src1, MEMri:$addr, IntRegs:$src2),
2114             "if (!$src1) memw($addr) = $src2.new",
2115             []>,
2116             Requires<[HasV4T]>;
2117
2118 // if (!Pv.new) memw(Rs+#u6:2)=Nt.new
2119 let mayStore = 1, neverHasSideEffects = 1 in
2120 def STriw_cdnNotPt_nv_V4 : NVInst_V4<(outs),
2121             (ins PredRegs:$src1, MEMri:$addr, IntRegs:$src2),
2122             "if (!$src1.new) memw($addr) = $src2.new",
2123             []>,
2124             Requires<[HasV4T]>;
2125
2126 // if (Pv) memw(Rs+#u6:2)=Nt.new
2127 let mayStore = 1, neverHasSideEffects = 1 in
2128 def STriw_indexed_cPt_nv_V4 : NVInst_V4<(outs),
2129             (ins PredRegs:$src1, IntRegs:$src2, u6_2Imm:$src3, IntRegs:$src4),
2130             "if ($src1) memw($src2+#$src3) = $src4.new",
2131             []>,
2132             Requires<[HasV4T]>;
2133
2134 // if (Pv.new) memw(Rs+#u6:2)=Nt.new
2135 let mayStore = 1, neverHasSideEffects = 1 in
2136 def STriw_indexed_cdnPt_nv_V4 : NVInst_V4<(outs),
2137             (ins PredRegs:$src1, IntRegs:$src2, u6_2Imm:$src3, IntRegs:$src4),
2138             "if ($src1.new) memw($src2+#$src3) = $src4.new",
2139             []>,
2140             Requires<[HasV4T]>;
2141
2142 // if (!Pv) memw(Rs+#u6:2)=Nt.new
2143 let mayStore = 1, neverHasSideEffects = 1 in
2144 def STriw_indexed_cNotPt_nv_V4 : NVInst_V4<(outs),
2145             (ins PredRegs:$src1, IntRegs:$src2, u6_2Imm:$src3, IntRegs:$src4),
2146             "if (!$src1) memw($src2+#$src3) = $src4.new",
2147             []>,
2148             Requires<[HasV4T]>;
2149
2150 // if (!Pv.new) memw(Rs+#u6:2)=Nt.new
2151 let mayStore = 1, neverHasSideEffects = 1 in
2152 def STriw_indexed_cdnNotPt_nv_V4 : NVInst_V4<(outs),
2153             (ins PredRegs:$src1, IntRegs:$src2, u6_2Imm:$src3, IntRegs:$src4),
2154             "if (!$src1.new) memw($src2+#$src3) = $src4.new",
2155             []>,
2156             Requires<[HasV4T]>;
2157
2158
2159 // if ([!]Pv[.new]) memw(Rs+Ru<<#u2)=Nt.new
2160 // if (Pv) memw(Rs+Ru<<#u2)=Nt.new
2161 let mayStore = 1, AddedComplexity = 10 in
2162 def STriw_indexed_shl_cPt_nv_V4 : NVInst_V4<(outs),
2163             (ins PredRegs:$src1, IntRegs:$src2, IntRegs:$src3, u2Imm:$src4,
2164                  IntRegs:$src5),
2165             "if ($src1) memw($src2+$src3<<#$src4) = $src5.new",
2166             []>,
2167             Requires<[HasV4T]>;
2168
2169 // if (Pv.new) memw(Rs+Ru<<#u2)=Nt.new
2170 let mayStore = 1, AddedComplexity = 10 in
2171 def STriw_indexed_shl_cdnPt_nv_V4 : NVInst_V4<(outs),
2172             (ins PredRegs:$src1, IntRegs:$src2, IntRegs:$src3, u2Imm:$src4,
2173                  IntRegs:$src5),
2174             "if ($src1.new) memw($src2+$src3<<#$src4) = $src5.new",
2175             []>,
2176             Requires<[HasV4T]>;
2177
2178 // if (!Pv) memw(Rs+Ru<<#u2)=Nt.new
2179 let mayStore = 1, AddedComplexity = 10 in
2180 def STriw_indexed_shl_cNotPt_nv_V4 : NVInst_V4<(outs),
2181             (ins PredRegs:$src1, IntRegs:$src2, IntRegs:$src3, u2Imm:$src4,
2182                  IntRegs:$src5),
2183             "if (!$src1) memw($src2+$src3<<#$src4) = $src5.new",
2184             []>,
2185             Requires<[HasV4T]>;
2186
2187 // if (!Pv.new) memw(Rs+Ru<<#u2)=Nt.new
2188 let mayStore = 1, AddedComplexity = 10 in
2189 def STriw_indexed_shl_cdnNotPt_nv_V4 : NVInst_V4<(outs),
2190             (ins PredRegs:$src1, IntRegs:$src2, IntRegs:$src3, u2Imm:$src4,
2191                  IntRegs:$src5),
2192             "if (!$src1.new) memw($src2+$src3<<#$src4) = $src5.new",
2193             []>,
2194             Requires<[HasV4T]>;
2195
2196 // if ([!]Pv[.new]) memw(Rx++#s4:2)=Nt.new
2197 // if (Pv) memw(Rx++#s4:2)=Nt.new
2198 let mayStore = 1, hasCtrlDep = 1 in
2199 def POST_STwri_cPt_nv_V4 : NVInstPI_V4<(outs IntRegs:$dst),
2200             (ins PredRegs:$src1, IntRegs:$src2, IntRegs:$src3, s4_2Imm:$offset),
2201             "if ($src1) memw($src3++#$offset) = $src2.new",
2202             [],"$src3 = $dst">,
2203             Requires<[HasV4T]>;
2204
2205 // if (Pv.new) memw(Rx++#s4:2)=Nt.new
2206 let mayStore = 1, hasCtrlDep = 1 in
2207 def POST_STwri_cdnPt_nv_V4 : NVInstPI_V4<(outs IntRegs:$dst),
2208             (ins PredRegs:$src1, IntRegs:$src2, IntRegs:$src3, s4_2Imm:$offset),
2209             "if ($src1.new) memw($src3++#$offset) = $src2.new",
2210             [],"$src3 = $dst">,
2211             Requires<[HasV4T]>;
2212
2213 // if (!Pv) memw(Rx++#s4:2)=Nt.new
2214 let mayStore = 1, hasCtrlDep = 1 in
2215 def POST_STwri_cNotPt_nv_V4 : NVInstPI_V4<(outs IntRegs:$dst),
2216             (ins PredRegs:$src1, IntRegs:$src2, IntRegs:$src3, s4_2Imm:$offset),
2217             "if (!$src1) memw($src3++#$offset) = $src2.new",
2218             [],"$src3 = $dst">,
2219             Requires<[HasV4T]>;
2220
2221 // if (!Pv.new) memw(Rx++#s4:2)=Nt.new
2222 let mayStore = 1, hasCtrlDep = 1 in
2223 def POST_STwri_cdnNotPt_nv_V4 : NVInstPI_V4<(outs IntRegs:$dst),
2224             (ins PredRegs:$src1, IntRegs:$src2, IntRegs:$src3, s4_2Imm:$offset),
2225             "if (!$src1.new) memw($src3++#$offset) = $src2.new",
2226             [],"$src3 = $dst">,
2227             Requires<[HasV4T]>;
2228
2229
2230 //===----------------------------------------------------------------------===//
2231 // NV/ST -
2232 //===----------------------------------------------------------------------===//
2233
2234
2235 //===----------------------------------------------------------------------===//
2236 // XTYPE/ALU +
2237 //===----------------------------------------------------------------------===//
2238
2239 //  Add and accumulate.
2240 //  Rd=add(Rs,add(Ru,#s6))
2241 def ADDr_ADDri_V4 : MInst<(outs IntRegs:$dst),
2242           (ins IntRegs:$src1, IntRegs:$src2, s6Imm:$src3),
2243           "$dst = add($src1, add($src2, #$src3))",
2244           [(set IntRegs:$dst,
2245            (add IntRegs:$src1, (add IntRegs:$src2, s6ImmPred:$src3)))]>,
2246           Requires<[HasV4T]>;
2247
2248 //  Rd=add(Rs,sub(#s6,Ru))
2249 def ADDr_SUBri_V4 : MInst<(outs IntRegs:$dst),
2250           (ins IntRegs:$src1, s6Imm:$src2, IntRegs:$src3),
2251           "$dst = add($src1, sub(#$src2, $src3))",
2252           [(set IntRegs:$dst,
2253            (add IntRegs:$src1, (sub s6ImmPred:$src2, IntRegs:$src3)))]>,
2254           Requires<[HasV4T]>;
2255
2256 // Generates the same instruction as ADDr_SUBri_V4 but matches different
2257 // pattern.
2258 //  Rd=add(Rs,sub(#s6,Ru))
2259 def ADDri_SUBr_V4 : MInst<(outs IntRegs:$dst),
2260           (ins IntRegs:$src1, s6Imm:$src2, IntRegs:$src3),
2261           "$dst = add($src1, sub(#$src2, $src3))",
2262           [(set IntRegs:$dst,
2263            (sub (add IntRegs:$src1, s6ImmPred:$src2), IntRegs:$src3))]>,
2264           Requires<[HasV4T]>;
2265
2266
2267 //  Add or subtract doublewords with carry.
2268 //TODO:
2269 //  Rdd=add(Rss,Rtt,Px):carry
2270 //TODO:
2271 //  Rdd=sub(Rss,Rtt,Px):carry
2272
2273
2274 //  Logical doublewords.
2275 //  Rdd=and(Rtt,~Rss)
2276 def ANDd_NOTd_V4 : MInst<(outs DoubleRegs:$dst),
2277           (ins DoubleRegs:$src1, DoubleRegs:$src2),
2278           "$dst = and($src1, ~$src2)",
2279           [(set DoubleRegs:$dst, (and DoubleRegs:$src1,
2280                                       (not DoubleRegs:$src2)))]>,
2281           Requires<[HasV4T]>;
2282
2283 //  Rdd=or(Rtt,~Rss)
2284 def ORd_NOTd_V4 : MInst<(outs DoubleRegs:$dst),
2285           (ins DoubleRegs:$src1, DoubleRegs:$src2),
2286           "$dst = or($src1, ~$src2)",
2287           [(set DoubleRegs:$dst,
2288            (or DoubleRegs:$src1, (not DoubleRegs:$src2)))]>,
2289           Requires<[HasV4T]>;
2290
2291
2292 //  Logical-logical doublewords.
2293 //  Rxx^=xor(Rss,Rtt)
2294 def XORd_XORdd: MInst_acc<(outs DoubleRegs:$dst),
2295           (ins DoubleRegs:$src1, DoubleRegs:$src2, DoubleRegs:$src3),
2296           "$dst ^= xor($src2, $src3)",
2297           [(set DoubleRegs:$dst,
2298            (xor DoubleRegs:$src1, (xor DoubleRegs:$src2, DoubleRegs:$src3)))],
2299           "$src1 = $dst">,
2300           Requires<[HasV4T]>;
2301
2302
2303 // Logical-logical words.
2304 // Rx=or(Ru,and(Rx,#s10))
2305 def ORr_ANDri_V4 : MInst_acc<(outs IntRegs:$dst),
2306             (ins IntRegs:$src1, IntRegs: $src2, s10Imm:$src3),
2307             "$dst = or($src1, and($src2, #$src3))",
2308             [(set IntRegs:$dst,
2309              (or IntRegs:$src1, (and IntRegs:$src2, s10ImmPred:$src3)))],
2310             "$src2 = $dst">,
2311             Requires<[HasV4T]>;
2312
2313 // Rx[&|^]=and(Rs,Rt)
2314 // Rx&=and(Rs,Rt)
2315 def ANDr_ANDrr_V4 : MInst_acc<(outs IntRegs:$dst),
2316             (ins IntRegs:$src1, IntRegs: $src2, IntRegs:$src3),
2317             "$dst &= and($src2, $src3)",
2318             [(set IntRegs:$dst,
2319              (and IntRegs:$src1, (and IntRegs:$src2, IntRegs:$src3)))],
2320             "$src1 = $dst">,
2321             Requires<[HasV4T]>;
2322
2323 // Rx|=and(Rs,Rt)
2324 def ORr_ANDrr_V4 : MInst_acc<(outs IntRegs:$dst),
2325             (ins IntRegs:$src1, IntRegs: $src2, IntRegs:$src3),
2326             "$dst |= and($src2, $src3)",
2327             [(set IntRegs:$dst,
2328              (or IntRegs:$src1, (and IntRegs:$src2, IntRegs:$src3)))],
2329             "$src1 = $dst">,
2330             Requires<[HasV4T]>;
2331
2332 // Rx^=and(Rs,Rt)
2333 def XORr_ANDrr_V4 : MInst_acc<(outs IntRegs:$dst),
2334             (ins IntRegs:$src1, IntRegs: $src2, IntRegs:$src3),
2335             "$dst ^= and($src2, $src3)",
2336             [(set IntRegs:$dst,
2337              (xor IntRegs:$src1, (and IntRegs:$src2, IntRegs:$src3)))],
2338             "$src1 = $dst">,
2339             Requires<[HasV4T]>;
2340
2341 // Rx[&|^]=and(Rs,~Rt)
2342 // Rx&=and(Rs,~Rt)
2343 def ANDr_ANDr_NOTr_V4 : MInst_acc<(outs IntRegs:$dst),
2344             (ins IntRegs:$src1, IntRegs: $src2, IntRegs:$src3),
2345             "$dst &= and($src2, ~$src3)",
2346             [(set IntRegs:$dst,
2347              (and IntRegs:$src1, (and IntRegs:$src2, (not IntRegs:$src3))))],
2348             "$src1 = $dst">,
2349             Requires<[HasV4T]>;
2350
2351 // Rx|=and(Rs,~Rt)
2352 def ORr_ANDr_NOTr_V4 : MInst_acc<(outs IntRegs:$dst),
2353             (ins IntRegs:$src1, IntRegs: $src2, IntRegs:$src3),
2354             "$dst |= and($src2, ~$src3)",
2355             [(set IntRegs:$dst,
2356              (or IntRegs:$src1, (and IntRegs:$src2, (not IntRegs:$src3))))],
2357             "$src1 = $dst">,
2358             Requires<[HasV4T]>;
2359
2360 // Rx^=and(Rs,~Rt)
2361 def XORr_ANDr_NOTr_V4 : MInst_acc<(outs IntRegs:$dst),
2362             (ins IntRegs:$src1, IntRegs: $src2, IntRegs:$src3),
2363             "$dst ^= and($src2, ~$src3)",
2364             [(set IntRegs:$dst,
2365              (xor IntRegs:$src1, (and IntRegs:$src2, (not IntRegs:$src3))))],
2366             "$src1 = $dst">,
2367             Requires<[HasV4T]>;
2368
2369 // Rx[&|^]=or(Rs,Rt)
2370 // Rx&=or(Rs,Rt)
2371 def ANDr_ORrr_V4 : MInst_acc<(outs IntRegs:$dst),
2372             (ins IntRegs:$src1, IntRegs: $src2, IntRegs:$src3),
2373             "$dst &= or($src2, $src3)",
2374             [(set IntRegs:$dst,
2375              (and IntRegs:$src1, (or IntRegs:$src2, IntRegs:$src3)))],
2376             "$src1 = $dst">,
2377             Requires<[HasV4T]>;
2378
2379 // Rx|=or(Rs,Rt)
2380 def ORr_ORrr_V4 : MInst_acc<(outs IntRegs:$dst),
2381             (ins IntRegs:$src1, IntRegs: $src2, IntRegs:$src3),
2382             "$dst |= or($src2, $src3)",
2383             [(set IntRegs:$dst,
2384              (or IntRegs:$src1, (or IntRegs:$src2, IntRegs:$src3)))],
2385             "$src1 = $dst">,
2386             Requires<[HasV4T]>;
2387
2388 // Rx^=or(Rs,Rt)
2389 def XORr_ORrr_V4 : MInst_acc<(outs IntRegs:$dst),
2390             (ins IntRegs:$src1, IntRegs: $src2, IntRegs:$src3),
2391             "$dst ^= or($src2, $src3)",
2392             [(set IntRegs:$dst,
2393              (xor IntRegs:$src1, (or IntRegs:$src2, IntRegs:$src3)))],
2394             "$src1 = $dst">,
2395             Requires<[HasV4T]>;
2396
2397 // Rx[&|^]=xor(Rs,Rt)
2398 // Rx&=xor(Rs,Rt)
2399 def ANDr_XORrr_V4 : MInst_acc<(outs IntRegs:$dst),
2400             (ins IntRegs:$src1, IntRegs: $src2, IntRegs:$src3),
2401             "$dst &= xor($src2, $src3)",
2402             [(set IntRegs:$dst,
2403              (and IntRegs:$src1, (xor IntRegs:$src2, IntRegs:$src3)))],
2404             "$src1 = $dst">,
2405             Requires<[HasV4T]>;
2406
2407 // Rx|=xor(Rs,Rt)
2408 def ORr_XORrr_V4 : MInst_acc<(outs IntRegs:$dst),
2409             (ins IntRegs:$src1, IntRegs: $src2, IntRegs:$src3),
2410             "$dst |= xor($src2, $src3)",
2411             [(set IntRegs:$dst,
2412              (and IntRegs:$src1, (xor IntRegs:$src2, IntRegs:$src3)))],
2413             "$src1 = $dst">,
2414             Requires<[HasV4T]>;
2415
2416 // Rx^=xor(Rs,Rt)
2417 def XORr_XORrr_V4 : MInst_acc<(outs IntRegs:$dst),
2418             (ins IntRegs:$src1, IntRegs: $src2, IntRegs:$src3),
2419             "$dst ^= xor($src2, $src3)",
2420             [(set IntRegs:$dst,
2421              (and IntRegs:$src1, (xor IntRegs:$src2, IntRegs:$src3)))],
2422             "$src1 = $dst">,
2423             Requires<[HasV4T]>;
2424
2425 // Rx|=and(Rs,#s10)
2426 def ORr_ANDri2_V4 : MInst_acc<(outs IntRegs:$dst),
2427             (ins IntRegs:$src1, IntRegs: $src2, s10Imm:$src3),
2428             "$dst |= and($src2, #$src3)",
2429             [(set IntRegs:$dst,
2430              (or IntRegs:$src1, (and IntRegs:$src2, s10ImmPred:$src3)))],
2431             "$src1 = $dst">,
2432             Requires<[HasV4T]>;
2433
2434 // Rx|=or(Rs,#s10)
2435 def ORr_ORri_V4 : MInst_acc<(outs IntRegs:$dst),
2436             (ins IntRegs:$src1, IntRegs: $src2, s10Imm:$src3),
2437             "$dst |= or($src2, #$src3)",
2438             [(set IntRegs:$dst,
2439              (or IntRegs:$src1, (and IntRegs:$src2, s10ImmPred:$src3)))],
2440             "$src1 = $dst">,
2441             Requires<[HasV4T]>;
2442
2443
2444 //    Modulo wrap
2445 //        Rd=modwrap(Rs,Rt)
2446 //    Round
2447 //        Rd=cround(Rs,#u5)
2448 //        Rd=cround(Rs,Rt)
2449 //        Rd=round(Rs,#u5)[:sat]
2450 //        Rd=round(Rs,Rt)[:sat]
2451 //    Vector reduce add unsigned halfwords
2452 //        Rd=vraddh(Rss,Rtt)
2453 //    Vector add bytes
2454 //        Rdd=vaddb(Rss,Rtt)
2455 //    Vector conditional negate
2456 //        Rdd=vcnegh(Rss,Rt)
2457 //        Rxx+=vrcnegh(Rss,Rt)
2458 //    Vector maximum bytes
2459 //        Rdd=vmaxb(Rtt,Rss)
2460 //    Vector reduce maximum halfwords
2461 //        Rxx=vrmaxh(Rss,Ru)
2462 //        Rxx=vrmaxuh(Rss,Ru)
2463 //    Vector reduce maximum words
2464 //        Rxx=vrmaxuw(Rss,Ru)
2465 //        Rxx=vrmaxw(Rss,Ru)
2466 //    Vector minimum bytes
2467 //        Rdd=vminb(Rtt,Rss)
2468 //    Vector reduce minimum halfwords
2469 //        Rxx=vrminh(Rss,Ru)
2470 //        Rxx=vrminuh(Rss,Ru)
2471 //    Vector reduce minimum words
2472 //        Rxx=vrminuw(Rss,Ru)
2473 //        Rxx=vrminw(Rss,Ru)
2474 //    Vector subtract bytes
2475 //        Rdd=vsubb(Rss,Rtt)
2476
2477 //===----------------------------------------------------------------------===//
2478 // XTYPE/ALU -
2479 //===----------------------------------------------------------------------===//
2480
2481
2482 //===----------------------------------------------------------------------===//
2483 // XTYPE/MPY +
2484 //===----------------------------------------------------------------------===//
2485
2486 // Multiply and user lower result.
2487 // Rd=add(#u6,mpyi(Rs,#U6))
2488 def ADDi_MPYri_V4 : MInst<(outs IntRegs:$dst),
2489             (ins u6Imm:$src1, IntRegs:$src2, u6Imm:$src3),
2490             "$dst = add(#$src1, mpyi($src2, #$src3))",
2491             [(set IntRegs:$dst,
2492              (add (mul IntRegs:$src2, u6ImmPred:$src3), u6ImmPred:$src1))]>,
2493             Requires<[HasV4T]>;
2494
2495 // Rd=add(#u6,mpyi(Rs,Rt))
2496
2497 def ADDi_MPYrr_V4 : MInst<(outs IntRegs:$dst),
2498             (ins u6Imm:$src1, IntRegs:$src2, IntRegs:$src3),
2499             "$dst = add(#$src1, mpyi($src2, $src3))",
2500             [(set IntRegs:$dst,
2501              (add (mul IntRegs:$src2, IntRegs:$src3), u6ImmPred:$src1))]>,
2502             Requires<[HasV4T]>;
2503
2504 // Rd=add(Ru,mpyi(#u6:2,Rs))
2505 def ADDr_MPYir_V4 : MInst<(outs IntRegs:$dst),
2506             (ins IntRegs:$src1, u6Imm:$src2, IntRegs:$src3),
2507             "$dst = add($src1, mpyi(#$src2, $src3))",
2508             [(set IntRegs:$dst,
2509              (add IntRegs:$src1, (mul IntRegs:$src3, u6_2ImmPred:$src2)))]>,
2510             Requires<[HasV4T]>;
2511
2512 // Rd=add(Ru,mpyi(Rs,#u6))
2513 def ADDr_MPYri_V4 : MInst<(outs IntRegs:$dst),
2514             (ins IntRegs:$src1, IntRegs:$src2, u6Imm:$src3),
2515             "$dst = add($src1, mpyi($src2, #$src3))",
2516             [(set IntRegs:$dst,
2517              (add IntRegs:$src1, (mul IntRegs:$src2, u6ImmPred:$src3)))]>,
2518             Requires<[HasV4T]>;
2519
2520 // Rx=add(Ru,mpyi(Rx,Rs))
2521 def ADDr_MPYrr_V4 : MInst_acc<(outs IntRegs:$dst),
2522             (ins IntRegs:$src1, IntRegs:$src2, IntRegs:$src3),
2523             "$dst = add($src1, mpyi($src2, $src3))",
2524             [(set IntRegs:$dst,
2525              (add IntRegs:$src1, (mul IntRegs:$src2, IntRegs:$src3)))],
2526             "$src2 = $dst">,
2527             Requires<[HasV4T]>;
2528
2529
2530 // Polynomial multiply words
2531 // Rdd=pmpyw(Rs,Rt)
2532 // Rxx^=pmpyw(Rs,Rt)
2533
2534 // Vector reduce multiply word by signed half (32x16)
2535 // Rdd=vrmpyweh(Rss,Rtt)[:<<1]
2536 // Rdd=vrmpywoh(Rss,Rtt)[:<<1]
2537 // Rxx+=vrmpyweh(Rss,Rtt)[:<<1]
2538 // Rxx+=vrmpywoh(Rss,Rtt)[:<<1]
2539
2540 // Multiply and use upper result
2541 // Rd=mpy(Rs,Rt.H):<<1:sat
2542 // Rd=mpy(Rs,Rt.L):<<1:sat
2543 // Rd=mpy(Rs,Rt):<<1
2544 // Rd=mpy(Rs,Rt):<<1:sat
2545 // Rd=mpysu(Rs,Rt)
2546 // Rx+=mpy(Rs,Rt):<<1:sat
2547 // Rx-=mpy(Rs,Rt):<<1:sat
2548
2549 // Vector multiply bytes
2550 // Rdd=vmpybsu(Rs,Rt)
2551 // Rdd=vmpybu(Rs,Rt)
2552 // Rxx+=vmpybsu(Rs,Rt)
2553 // Rxx+=vmpybu(Rs,Rt)
2554
2555 // Vector polynomial multiply halfwords
2556 // Rdd=vpmpyh(Rs,Rt)
2557 // Rxx^=vpmpyh(Rs,Rt)
2558
2559 //===----------------------------------------------------------------------===//
2560 // XTYPE/MPY -
2561 //===----------------------------------------------------------------------===//
2562
2563
2564 //===----------------------------------------------------------------------===//
2565 // XTYPE/SHIFT +
2566 //===----------------------------------------------------------------------===//
2567
2568 // Shift by immediate and accumulate.
2569 // Rx=add(#u8,asl(Rx,#U5))
2570 def ADDi_ASLri_V4 : MInst_acc<(outs IntRegs:$dst),
2571             (ins u8Imm:$src1, IntRegs:$src2, u5Imm:$src3),
2572             "$dst = add(#$src1, asl($src2, #$src3))",
2573             [(set IntRegs:$dst,
2574               (add (shl IntRegs:$src2, u5ImmPred:$src3), u8ImmPred:$src1))],
2575             "$src2 = $dst">,
2576             Requires<[HasV4T]>;
2577
2578 // Rx=add(#u8,lsr(Rx,#U5))
2579 def ADDi_LSRri_V4 : MInst_acc<(outs IntRegs:$dst),
2580             (ins u8Imm:$src1, IntRegs:$src2, u5Imm:$src3),
2581             "$dst = add(#$src1, lsr($src2, #$src3))",
2582             [(set IntRegs:$dst,
2583              (add (srl IntRegs:$src2, u5ImmPred:$src3), u8ImmPred:$src1))],
2584             "$src2 = $dst">,
2585             Requires<[HasV4T]>;
2586
2587 // Rx=sub(#u8,asl(Rx,#U5))
2588 def SUBi_ASLri_V4 : MInst_acc<(outs IntRegs:$dst),
2589             (ins u8Imm:$src1, IntRegs:$src2, u5Imm:$src3),
2590             "$dst = sub(#$src1, asl($src2, #$src3))",
2591             [(set IntRegs:$dst,
2592              (sub (shl IntRegs:$src2, u5ImmPred:$src3), u8ImmPred:$src1))],
2593             "$src2 = $dst">,
2594             Requires<[HasV4T]>;
2595
2596 // Rx=sub(#u8,lsr(Rx,#U5))
2597 def SUBi_LSRri_V4 : MInst_acc<(outs IntRegs:$dst),
2598             (ins u8Imm:$src1, IntRegs:$src2, u5Imm:$src3),
2599             "$dst = sub(#$src1, lsr($src2, #$src3))",
2600             [(set IntRegs:$dst,
2601              (sub (srl IntRegs:$src2, u5ImmPred:$src3), u8ImmPred:$src1))],
2602             "$src2 = $dst">,
2603             Requires<[HasV4T]>;
2604
2605
2606 //Shift by immediate and logical.
2607 //Rx=and(#u8,asl(Rx,#U5))
2608 def ANDi_ASLri_V4 : MInst_acc<(outs IntRegs:$dst),
2609             (ins u8Imm:$src1, IntRegs:$src2, u5Imm:$src3),
2610             "$dst = and(#$src1, asl($src2, #$src3))",
2611             [(set IntRegs:$dst,
2612              (and (shl IntRegs:$src2, u5ImmPred:$src3), u8ImmPred:$src1))],
2613             "$src2 = $dst">,
2614             Requires<[HasV4T]>;
2615
2616 //Rx=and(#u8,lsr(Rx,#U5))
2617 def ANDi_LSRri_V4 : MInst_acc<(outs IntRegs:$dst),
2618             (ins u8Imm:$src1, IntRegs:$src2, u5Imm:$src3),
2619             "$dst = and(#$src1, lsr($src2, #$src3))",
2620             [(set IntRegs:$dst,
2621              (and (srl IntRegs:$src2, u5ImmPred:$src3), u8ImmPred:$src1))],
2622             "$src2 = $dst">,
2623             Requires<[HasV4T]>;
2624
2625 //Rx=or(#u8,asl(Rx,#U5))
2626 def ORi_ASLri_V4 : MInst_acc<(outs IntRegs:$dst),
2627             (ins u8Imm:$src1, IntRegs:$src2, u5Imm:$src3),
2628             "$dst = or(#$src1, asl($src2, #$src3))",
2629             [(set IntRegs:$dst,
2630              (or (shl IntRegs:$src2, u5ImmPred:$src3), u8ImmPred:$src1))],
2631             "$src2 = $dst">,
2632             Requires<[HasV4T]>;
2633
2634 //Rx=or(#u8,lsr(Rx,#U5))
2635 def ORi_LSRri_V4 : MInst_acc<(outs IntRegs:$dst),
2636             (ins u8Imm:$src1, IntRegs:$src2, u5Imm:$src3),
2637             "$dst = or(#$src1, lsr($src2, #$src3))",
2638             [(set IntRegs:$dst,
2639              (or (srl IntRegs:$src2, u5ImmPred:$src3), u8ImmPred:$src1))],
2640             "$src2 = $dst">,
2641             Requires<[HasV4T]>;
2642
2643
2644 //Shift by register.
2645 //Rd=lsl(#s6,Rt)
2646 def LSLi_V4 : MInst<(outs IntRegs:$dst), (ins s6Imm:$src1, IntRegs:$src2),
2647             "$dst = lsl(#$src1, $src2)",
2648             [(set IntRegs:$dst, (shl s6ImmPred:$src1, IntRegs:$src2))]>,
2649             Requires<[HasV4T]>;
2650
2651
2652 //Shift by register and logical.
2653 //Rxx^=asl(Rss,Rt)
2654 def ASLd_rr_xor_V4 : MInst_acc<(outs DoubleRegs:$dst),
2655             (ins DoubleRegs:$src1, DoubleRegs:$src2, IntRegs:$src3),
2656             "$dst ^= asl($src2, $src3)",
2657             [(set DoubleRegs:$dst,
2658              (xor DoubleRegs:$src1, (shl DoubleRegs:$src2, IntRegs:$src3)))],
2659             "$src1 = $dst">,
2660             Requires<[HasV4T]>;
2661
2662 //Rxx^=asr(Rss,Rt)
2663 def ASRd_rr_xor_V4 : MInst_acc<(outs DoubleRegs:$dst),
2664             (ins DoubleRegs:$src1, DoubleRegs:$src2, IntRegs:$src3),
2665             "$dst ^= asr($src2, $src3)",
2666             [(set DoubleRegs:$dst,
2667              (xor DoubleRegs:$src1, (sra DoubleRegs:$src2, IntRegs:$src3)))],
2668             "$src1 = $dst">,
2669             Requires<[HasV4T]>;
2670
2671 //Rxx^=lsl(Rss,Rt)
2672 def LSLd_rr_xor_V4 : MInst_acc<(outs DoubleRegs:$dst),
2673             (ins DoubleRegs:$src1, DoubleRegs:$src2, IntRegs:$src3),
2674             "$dst ^= lsl($src2, $src3)",
2675             [(set DoubleRegs:$dst,
2676              (xor DoubleRegs:$src1, (shl DoubleRegs:$src2, IntRegs:$src3)))],
2677             "$src1 = $dst">,
2678             Requires<[HasV4T]>;
2679
2680 //Rxx^=lsr(Rss,Rt)
2681 def LSRd_rr_xor_V4 : MInst_acc<(outs DoubleRegs:$dst),
2682             (ins DoubleRegs:$src1, DoubleRegs:$src2, IntRegs:$src3),
2683             "$dst ^= lsr($src2, $src3)",
2684             [(set DoubleRegs:$dst,
2685              (xor DoubleRegs:$src1, (srl DoubleRegs:$src2, IntRegs:$src3)))],
2686             "$src1 = $dst">,
2687             Requires<[HasV4T]>;
2688
2689
2690 //===----------------------------------------------------------------------===//
2691 // XTYPE/SHIFT -
2692 //===----------------------------------------------------------------------===//
2693
2694 //===----------------------------------------------------------------------===//
2695 // MEMOP: Word, Half, Byte
2696 //===----------------------------------------------------------------------===//
2697
2698 //===----------------------------------------------------------------------===//
2699 // MEMOP: Word
2700 //
2701 //  Implemented:
2702 //     MEMw_ADDi_indexed_V4  : memw(Rs+#u6:2)+=#U5
2703 //     MEMw_SUBi_indexed_V4  : memw(Rs+#u6:2)-=#U5
2704 //     MEMw_ADDr_indexed_V4  : memw(Rs+#u6:2)+=Rt
2705 //     MEMw_SUBr_indexed_V4  : memw(Rs+#u6:2)-=Rt
2706 //     MEMw_CLRr_indexed_V4  : memw(Rs+#u6:2)&=Rt
2707 //     MEMw_SETr_indexed_V4  : memw(Rs+#u6:2)|=Rt
2708 //     MEMw_ADDi_V4          : memw(Rs+#u6:2)+=#U5
2709 //     MEMw_SUBi_V4          : memw(Rs+#u6:2)-=#U5
2710 //     MEMw_ADDr_V4          : memw(Rs+#u6:2)+=Rt
2711 //     MEMw_SUBr_V4          : memw(Rs+#u6:2)-=Rt
2712 //     MEMw_CLRr_V4          : memw(Rs+#u6:2)&=Rt
2713 //     MEMw_SETr_V4          : memw(Rs+#u6:2)|=Rt
2714 //
2715 //   Not implemented:
2716 //     MEMw_CLRi_indexed_V4  : memw(Rs+#u6:2)=clrbit(#U5)
2717 //     MEMw_SETi_indexed_V4  : memw(Rs+#u6:2)=setbit(#U5)
2718 //     MEMw_CLRi_V4          : memw(Rs+#u6:2)=clrbit(#U5)
2719 //     MEMw_SETi_V4          : memw(Rs+#u6:2)=setbit(#U5)
2720 //===----------------------------------------------------------------------===//
2721
2722
2723 // MEMw_ADDSUBi_indexed_V4:
2724 //   pseudo operation for MEMw_ADDi_indexed_V4 and
2725 //   MEMw_SUBi_indexed_V4 a later pass will change it
2726 //   to the corresponding pattern.
2727 let AddedComplexity = 30 in
2728 def MEMw_ADDSUBi_indexed_MEM_V4 : MEMInst_V4<(outs),
2729             (ins IntRegs:$base, u6_2Imm:$offset, m6Imm:$addend),
2730             "Error; should not emit",
2731             [(store (add (load (add IntRegs:$base, u6_2ImmPred:$offset)),
2732 m6ImmPred:$addend),
2733                     (add IntRegs:$base, u6_2ImmPred:$offset))]>,
2734             Requires<[HasV4T, UseMEMOP]>;
2735
2736 // memw(Rs+#u6:2) += #U5
2737 let AddedComplexity = 30 in
2738 def MEMw_ADDi_indexed_MEM_V4 : MEMInst_V4<(outs),
2739             (ins IntRegs:$base, u6_2Imm:$offset, u5Imm:$addend),
2740             "memw($base+#$offset) += $addend",
2741             []>,
2742             Requires<[HasV4T, UseMEMOP]>;
2743
2744 // memw(Rs+#u6:2) -= #U5
2745 let AddedComplexity = 30 in
2746 def MEMw_SUBi_indexed_MEM_V4 : MEMInst_V4<(outs),
2747             (ins IntRegs:$base, u6_2Imm:$offset, u5Imm:$subend),
2748             "memw($base+#$offset) -= $subend",
2749             []>,
2750             Requires<[HasV4T, UseMEMOP]>;
2751
2752 // memw(Rs+#u6:2) += Rt
2753 let AddedComplexity = 30 in
2754 def MEMw_ADDr_indexed_MEM_V4 : MEMInst_V4<(outs),
2755             (ins IntRegs:$base, u6_2Imm:$offset, IntRegs:$addend),
2756             "memw($base+#$offset) += $addend",
2757             [(store (add (load (add IntRegs:$base, u6_2ImmPred:$offset)),
2758 IntRegs:$addend),
2759                     (add IntRegs:$base, u6_2ImmPred:$offset))]>,
2760             Requires<[HasV4T, UseMEMOP]>;
2761
2762 // memw(Rs+#u6:2) -= Rt
2763 let AddedComplexity = 30 in
2764 def MEMw_SUBr_indexed_MEM_V4 : MEMInst_V4<(outs),
2765             (ins IntRegs:$base, u6_2Imm:$offset, IntRegs:$subend),
2766             "memw($base+#$offset) -= $subend",
2767             [(store (sub (load (add IntRegs:$base, u6_2ImmPred:$offset)),
2768 IntRegs:$subend),
2769                     (add IntRegs:$base, u6_2ImmPred:$offset))]>,
2770             Requires<[HasV4T, UseMEMOP]>;
2771
2772 // memw(Rs+#u6:2) &= Rt
2773 let AddedComplexity = 30 in
2774 def MEMw_ANDr_indexed_MEM_V4 : MEMInst_V4<(outs),
2775             (ins IntRegs:$base, u6_2Imm:$offset, IntRegs:$andend),
2776             "memw($base+#$offset) += $andend",
2777             [(store (and (load (add IntRegs:$base, u6_2ImmPred:$offset)),
2778 IntRegs:$andend),
2779                     (add IntRegs:$base, u6_2ImmPred:$offset))]>,
2780             Requires<[HasV4T, UseMEMOP]>;
2781
2782 // memw(Rs+#u6:2) |= Rt
2783 let AddedComplexity = 30 in
2784 def MEMw_ORr_indexed_MEM_V4 : MEMInst_V4<(outs),
2785             (ins IntRegs:$base, u6_2Imm:$offset, IntRegs:$orend),
2786             "memw($base+#$offset) |= $orend",
2787             [(store (or (load (add IntRegs:$base, u6_2ImmPred:$offset)),
2788                         IntRegs:$orend),
2789                     (add IntRegs:$base, u6_2ImmPred:$offset))]>,
2790             Requires<[HasV4T, UseMEMOP]>;
2791
2792 // MEMw_ADDSUBi_V4:
2793 //   Pseudo operation for MEMw_ADDi_V4 and MEMw_SUBi_V4
2794 //   a later pass will change it to the right pattern.
2795 let AddedComplexity = 30 in
2796 def MEMw_ADDSUBi_MEM_V4 : MEMInst_V4<(outs),
2797             (ins MEMri:$addr, m6Imm:$addend),
2798             "Error; should not emit",
2799             [(store (add (load ADDRriU6_2:$addr), m6ImmPred:$addend),
2800                     ADDRriU6_2:$addr)]>,
2801             Requires<[HasV4T, UseMEMOP]>;
2802
2803 // memw(Rs+#u6:2) += #U5
2804 let AddedComplexity = 30 in
2805 def MEMw_ADDi_MEM_V4 : MEMInst_V4<(outs),
2806             (ins MEMri:$addr, u5Imm:$addend),
2807             "memw($addr) += $addend",
2808             []>,
2809             Requires<[HasV4T, UseMEMOP]>;
2810
2811 // memw(Rs+#u6:2) -= #U5
2812 let AddedComplexity = 30 in
2813 def MEMw_SUBi_MEM_V4 : MEMInst_V4<(outs),
2814             (ins MEMri:$addr, u5Imm:$subend),
2815             "memw($addr) -= $subend",
2816             []>,
2817             Requires<[HasV4T, UseMEMOP]>;
2818
2819 // memw(Rs+#u6:2) += Rt
2820 let AddedComplexity = 30 in
2821 def MEMw_ADDr_MEM_V4 : MEMInst_V4<(outs),
2822             (ins MEMri:$addr, IntRegs:$addend),
2823             "memw($addr) += $addend",
2824             [(store (add (load ADDRriU6_2:$addr), IntRegs:$addend),
2825                     ADDRriU6_2:$addr)]>,
2826             Requires<[HasV4T, UseMEMOP]>;
2827
2828 // memw(Rs+#u6:2) -= Rt
2829 let AddedComplexity = 30 in
2830 def MEMw_SUBr_MEM_V4 : MEMInst_V4<(outs),
2831             (ins MEMri:$addr, IntRegs:$subend),
2832             "memw($addr) -= $subend",
2833             [(store (sub (load ADDRriU6_2:$addr), IntRegs:$subend),
2834                     ADDRriU6_2:$addr)]>,
2835             Requires<[HasV4T, UseMEMOP]>;
2836
2837 // memw(Rs+#u6:2) &= Rt
2838 let AddedComplexity = 30 in
2839 def MEMw_ANDr_MEM_V4 : MEMInst_V4<(outs),
2840             (ins MEMri:$addr, IntRegs:$andend),
2841             "memw($addr) &= $andend",
2842             [(store (and (load ADDRriU6_2:$addr), IntRegs:$andend),
2843                     ADDRriU6_2:$addr)]>,
2844             Requires<[HasV4T, UseMEMOP]>;
2845
2846 // memw(Rs+#u6:2) |= Rt
2847 let AddedComplexity = 30 in
2848 def MEMw_ORr_MEM_V4 : MEMInst_V4<(outs),
2849             (ins MEMri:$addr, IntRegs:$orend),
2850             "memw($addr) |= $orend",
2851             [(store (or (load ADDRriU6_2:$addr), IntRegs:$orend),
2852 ADDRriU6_2:$addr)]>,
2853             Requires<[HasV4T, UseMEMOP]>;
2854
2855 //===----------------------------------------------------------------------===//
2856 // MEMOP: Halfword
2857 //
2858 //  Implemented:
2859 //     MEMh_ADDi_indexed_V4  : memw(Rs+#u6:2)+=#U5
2860 //     MEMh_SUBi_indexed_V4  : memw(Rs+#u6:2)-=#U5
2861 //     MEMh_ADDr_indexed_V4  : memw(Rs+#u6:2)+=Rt
2862 //     MEMh_SUBr_indexed_V4  : memw(Rs+#u6:2)-=Rt
2863 //     MEMh_CLRr_indexed_V4  : memw(Rs+#u6:2)&=Rt
2864 //     MEMh_SETr_indexed_V4  : memw(Rs+#u6:2)|=Rt
2865 //     MEMh_ADDi_V4          : memw(Rs+#u6:2)+=#U5
2866 //     MEMh_SUBi_V4          : memw(Rs+#u6:2)-=#U5
2867 //     MEMh_ADDr_V4          : memw(Rs+#u6:2)+=Rt
2868 //     MEMh_SUBr_V4          : memw(Rs+#u6:2)-=Rt
2869 //     MEMh_CLRr_V4          : memw(Rs+#u6:2)&=Rt
2870 //     MEMh_SETr_V4          : memw(Rs+#u6:2)|=Rt
2871 //
2872 //   Not implemented:
2873 //     MEMh_CLRi_indexed_V4  : memw(Rs+#u6:2)=clrbit(#U5)
2874 //     MEMh_SETi_indexed_V4  : memw(Rs+#u6:2)=setbit(#U5)
2875 //     MEMh_CLRi_V4          : memw(Rs+#u6:2)=clrbit(#U5)
2876 //     MEMh_SETi_V4          : memw(Rs+#u6:2)=setbit(#U5)
2877 //===----------------------------------------------------------------------===//
2878
2879
2880 // MEMh_ADDSUBi_indexed_V4:
2881 //   Pseudo operation for MEMh_ADDi_indexed_V4 and
2882 //   MEMh_SUBi_indexed_V4 a later pass will change it
2883 //   to the corresponding pattern.
2884 let AddedComplexity = 30 in
2885 def MEMh_ADDSUBi_indexed_MEM_V4 : MEMInst_V4<(outs),
2886             (ins IntRegs:$base, u6_1Imm:$offset, m6Imm:$addend),
2887             "Error; should not emit",
2888             [(truncstorei16 (add (sextloadi16 (add IntRegs:$base,
2889                                                    u6_1ImmPred:$offset)),
2890                                  m6ImmPred:$addend),
2891                             (add IntRegs:$base, u6_1ImmPred:$offset))]>,
2892             Requires<[HasV4T, UseMEMOP]>;
2893
2894 // memh(Rs+#u6:1) += #U5
2895 let AddedComplexity = 30 in
2896 def MEMh_ADDi_indexed_MEM_V4 : MEMInst_V4<(outs),
2897             (ins IntRegs:$base, u6_1Imm:$offset, u5Imm:$addend),
2898             "memh($base+#$offset) += $addend",
2899             []>,
2900             Requires<[HasV4T, UseMEMOP]>;
2901
2902 // memh(Rs+#u6:1) -= #U5
2903 let AddedComplexity = 30 in
2904 def MEMh_SUBi_indexed_MEM_V4 : MEMInst_V4<(outs),
2905             (ins IntRegs:$base, u6_1Imm:$offset, u5Imm:$subend),
2906             "memh($base+#$offset) -= $subend",
2907             []>,
2908             Requires<[HasV4T, UseMEMOP]>;
2909
2910 // memh(Rs+#u6:1) += Rt
2911 let AddedComplexity = 30 in
2912 def MEMh_ADDr_indexed_MEM_V4 : MEMInst_V4<(outs),
2913             (ins IntRegs:$base, u6_1Imm:$offset, IntRegs:$addend),
2914             "memh($base+#$offset) += $addend",
2915             [(truncstorei16 (add (sextloadi16 (add IntRegs:$base,
2916                                                    u6_1ImmPred:$offset)),
2917                                  IntRegs:$addend),
2918                             (add IntRegs:$base, u6_1ImmPred:$offset))]>,
2919             Requires<[HasV4T, UseMEMOP]>;
2920
2921 // memh(Rs+#u6:1) -= Rt
2922 let AddedComplexity = 30 in
2923 def MEMh_SUBr_indexed_MEM_V4 : MEMInst_V4<(outs),
2924             (ins IntRegs:$base, u6_1Imm:$offset, IntRegs:$subend),
2925             "memh($base+#$offset) -= $subend",
2926             [(truncstorei16 (sub (sextloadi16 (add IntRegs:$base,
2927                                                    u6_1ImmPred:$offset)),
2928                                  IntRegs:$subend),
2929                             (add IntRegs:$base, u6_1ImmPred:$offset))]>,
2930             Requires<[HasV4T, UseMEMOP]>;
2931
2932 // memh(Rs+#u6:1) &= Rt
2933 let AddedComplexity = 30 in
2934 def MEMh_ANDr_indexed_MEM_V4 : MEMInst_V4<(outs),
2935             (ins IntRegs:$base, u6_1Imm:$offset, IntRegs:$andend),
2936             "memh($base+#$offset) += $andend",
2937             [(truncstorei16 (and (sextloadi16 (add IntRegs:$base,
2938                                                    u6_1ImmPred:$offset)),
2939                                  IntRegs:$andend),
2940                             (add IntRegs:$base, u6_1ImmPred:$offset))]>,
2941             Requires<[HasV4T, UseMEMOP]>;
2942
2943 // memh(Rs+#u6:1) |= Rt
2944 let AddedComplexity = 30 in
2945 def MEMh_ORr_indexed_MEM_V4 : MEMInst_V4<(outs),
2946             (ins IntRegs:$base, u6_1Imm:$offset, IntRegs:$orend),
2947             "memh($base+#$offset) |= $orend",
2948             [(truncstorei16 (or (sextloadi16 (add IntRegs:$base,
2949                                               u6_1ImmPred:$offset)),
2950                              IntRegs:$orend),
2951                             (add IntRegs:$base, u6_1ImmPred:$offset))]>,
2952             Requires<[HasV4T, UseMEMOP]>;
2953
2954 // MEMh_ADDSUBi_V4:
2955 //   Pseudo operation for MEMh_ADDi_V4 and MEMh_SUBi_V4
2956 //   a later pass will change it to the right pattern.
2957 let AddedComplexity = 30 in
2958 def MEMh_ADDSUBi_MEM_V4 : MEMInst_V4<(outs),
2959             (ins MEMri:$addr, m6Imm:$addend),
2960             "Error; should not emit",
2961             [(truncstorei16 (add (sextloadi16 ADDRriU6_1:$addr),
2962                                  m6ImmPred:$addend), ADDRriU6_1:$addr)]>,
2963             Requires<[HasV4T, UseMEMOP]>;
2964
2965 // memh(Rs+#u6:1) += #U5
2966 let AddedComplexity = 30 in
2967 def MEMh_ADDi_MEM_V4 : MEMInst_V4<(outs),
2968             (ins MEMri:$addr, u5Imm:$addend),
2969             "memh($addr) += $addend",
2970             []>,
2971             Requires<[HasV4T, UseMEMOP]>;
2972
2973 // memh(Rs+#u6:1) -= #U5
2974 let AddedComplexity = 30 in
2975 def MEMh_SUBi_MEM_V4 : MEMInst_V4<(outs),
2976             (ins MEMri:$addr, u5Imm:$subend),
2977             "memh($addr) -= $subend",
2978             []>,
2979             Requires<[HasV4T, UseMEMOP]>;
2980
2981 // memh(Rs+#u6:1) += Rt
2982 let AddedComplexity = 30 in
2983 def MEMh_ADDr_MEM_V4 : MEMInst_V4<(outs),
2984             (ins MEMri:$addr, IntRegs:$addend),
2985             "memh($addr) += $addend",
2986             [(truncstorei16 (add (sextloadi16 ADDRriU6_1:$addr),
2987                                  IntRegs:$addend), ADDRriU6_1:$addr)]>,
2988             Requires<[HasV4T, UseMEMOP]>;
2989
2990 // memh(Rs+#u6:1) -= Rt
2991 let AddedComplexity = 30 in
2992 def MEMh_SUBr_MEM_V4 : MEMInst_V4<(outs),
2993             (ins MEMri:$addr, IntRegs:$subend),
2994             "memh($addr) -= $subend",
2995             [(truncstorei16 (sub (sextloadi16 ADDRriU6_1:$addr),
2996                                  IntRegs:$subend), ADDRriU6_1:$addr)]>,
2997             Requires<[HasV4T, UseMEMOP]>;
2998
2999 // memh(Rs+#u6:1) &= Rt
3000 let AddedComplexity = 30 in
3001 def MEMh_ANDr_MEM_V4 : MEMInst_V4<(outs),
3002             (ins MEMri:$addr, IntRegs:$andend),
3003             "memh($addr) &= $andend",
3004             [(truncstorei16 (and (sextloadi16 ADDRriU6_1:$addr),
3005                                  IntRegs:$andend), ADDRriU6_1:$addr)]>,
3006             Requires<[HasV4T, UseMEMOP]>;
3007
3008 // memh(Rs+#u6:1) |= Rt
3009 let AddedComplexity = 30 in
3010 def MEMh_ORr_MEM_V4 : MEMInst_V4<(outs),
3011             (ins MEMri:$addr, IntRegs:$orend),
3012             "memh($addr) |= $orend",
3013             [(truncstorei16 (or (sextloadi16 ADDRriU6_1:$addr),
3014                                 IntRegs:$orend), ADDRriU6_1:$addr)]>,
3015             Requires<[HasV4T, UseMEMOP]>;
3016
3017
3018 //===----------------------------------------------------------------------===//
3019 // MEMOP: Byte
3020 //
3021 //  Implemented:
3022 //     MEMb_ADDi_indexed_V4  : memb(Rs+#u6:0)+=#U5
3023 //     MEMb_SUBi_indexed_V4  : memb(Rs+#u6:0)-=#U5
3024 //     MEMb_ADDr_indexed_V4  : memb(Rs+#u6:0)+=Rt
3025 //     MEMb_SUBr_indexed_V4  : memb(Rs+#u6:0)-=Rt
3026 //     MEMb_CLRr_indexed_V4  : memb(Rs+#u6:0)&=Rt
3027 //     MEMb_SETr_indexed_V4  : memb(Rs+#u6:0)|=Rt
3028 //     MEMb_ADDi_V4          : memb(Rs+#u6:0)+=#U5
3029 //     MEMb_SUBi_V4          : memb(Rs+#u6:0)-=#U5
3030 //     MEMb_ADDr_V4          : memb(Rs+#u6:0)+=Rt
3031 //     MEMb_SUBr_V4          : memb(Rs+#u6:0)-=Rt
3032 //     MEMb_CLRr_V4          : memb(Rs+#u6:0)&=Rt
3033 //     MEMb_SETr_V4          : memb(Rs+#u6:0)|=Rt
3034 //
3035 //   Not implemented:
3036 //     MEMb_CLRi_indexed_V4  : memb(Rs+#u6:0)=clrbit(#U5)
3037 //     MEMb_SETi_indexed_V4  : memb(Rs+#u6:0)=setbit(#U5)
3038 //     MEMb_CLRi_V4          : memb(Rs+#u6:0)=clrbit(#U5)
3039 //     MEMb_SETi_V4          : memb(Rs+#u6:0)=setbit(#U5)
3040 //===----------------------------------------------------------------------===//
3041
3042
3043 // MEMb_ADDSUBi_indexed_V4:
3044 //   Pseudo operation for MEMb_ADDi_indexed_V4 and
3045 //   MEMb_SUBi_indexed_V4 a later pass will change it
3046 //   to the corresponding pattern.
3047 let AddedComplexity = 30 in
3048 def MEMb_ADDSUBi_indexed_MEM_V4 : MEMInst_V4<(outs),
3049             (ins IntRegs:$base, u6_0Imm:$offset, m6Imm:$addend),
3050             "Error; should not emit",
3051             [(truncstorei8 (add (sextloadi8 (add IntRegs:$base,
3052                                                  u6_0ImmPred:$offset)),
3053                                 m6ImmPred:$addend),
3054                            (add IntRegs:$base, u6_0ImmPred:$offset))]>,
3055             Requires<[HasV4T, UseMEMOP]>;
3056
3057 // memb(Rs+#u6:0) += #U5
3058 let AddedComplexity = 30 in
3059 def MEMb_ADDi_indexed_MEM_V4 : MEMInst_V4<(outs),
3060             (ins IntRegs:$base, u6_0Imm:$offset, u5Imm:$addend),
3061             "memb($base+#$offset) += $addend",
3062             []>,
3063             Requires<[HasV4T, UseMEMOP]>;
3064
3065 // memb(Rs+#u6:0) -= #U5
3066 let AddedComplexity = 30 in
3067 def MEMb_SUBi_indexed_MEM_V4 : MEMInst_V4<(outs),
3068             (ins IntRegs:$base, u6_0Imm:$offset, u5Imm:$subend),
3069             "memb($base+#$offset) -= $subend",
3070             []>,
3071             Requires<[HasV4T, UseMEMOP]>;
3072
3073 // memb(Rs+#u6:0) += Rt
3074 let AddedComplexity = 30 in
3075 def MEMb_ADDr_indexed_MEM_V4 : MEMInst_V4<(outs),
3076             (ins IntRegs:$base, u6_0Imm:$offset, IntRegs:$addend),
3077             "memb($base+#$offset) += $addend",
3078             [(truncstorei8 (add (sextloadi8 (add IntRegs:$base,
3079                                                  u6_0ImmPred:$offset)),
3080                                 IntRegs:$addend),
3081                            (add IntRegs:$base, u6_0ImmPred:$offset))]>,
3082             Requires<[HasV4T, UseMEMOP]>;
3083
3084 // memb(Rs+#u6:0) -= Rt
3085 let AddedComplexity = 30 in
3086 def MEMb_SUBr_indexed_MEM_V4 : MEMInst_V4<(outs),
3087             (ins IntRegs:$base, u6_0Imm:$offset, IntRegs:$subend),
3088             "memb($base+#$offset) -= $subend",
3089             [(truncstorei8 (sub (sextloadi8 (add IntRegs:$base,
3090                                                  u6_0ImmPred:$offset)),
3091                                 IntRegs:$subend),
3092                            (add IntRegs:$base, u6_0ImmPred:$offset))]>,
3093             Requires<[HasV4T, UseMEMOP]>;
3094
3095 // memb(Rs+#u6:0) &= Rt
3096 let AddedComplexity = 30 in
3097 def MEMb_ANDr_indexed_MEM_V4 : MEMInst_V4<(outs),
3098             (ins IntRegs:$base, u6_0Imm:$offset, IntRegs:$andend),
3099             "memb($base+#$offset) += $andend",
3100             [(truncstorei8 (and (sextloadi8 (add IntRegs:$base,
3101                                                  u6_0ImmPred:$offset)),
3102                                 IntRegs:$andend),
3103                            (add IntRegs:$base, u6_0ImmPred:$offset))]>,
3104             Requires<[HasV4T, UseMEMOP]>;
3105
3106 // memb(Rs+#u6:0) |= Rt
3107 let AddedComplexity = 30 in
3108 def MEMb_ORr_indexed_MEM_V4 : MEMInst_V4<(outs),
3109             (ins IntRegs:$base, u6_0Imm:$offset, IntRegs:$orend),
3110             "memb($base+#$offset) |= $orend",
3111             [(truncstorei8 (or (sextloadi8 (add IntRegs:$base,
3112                                                 u6_0ImmPred:$offset)),
3113                                 IntRegs:$orend),
3114                            (add IntRegs:$base, u6_0ImmPred:$offset))]>,
3115             Requires<[HasV4T, UseMEMOP]>;
3116
3117 // MEMb_ADDSUBi_V4:
3118 //   Pseudo operation for MEMb_ADDi_V4 and MEMb_SUBi_V4
3119 //   a later pass will change it to the right pattern.
3120 let AddedComplexity = 30 in
3121 def MEMb_ADDSUBi_MEM_V4 : MEMInst_V4<(outs),
3122             (ins MEMri:$addr, m6Imm:$addend),
3123             "Error; should not emit",
3124             [(truncstorei8 (add (sextloadi8 ADDRriU6_0:$addr),
3125                                 m6ImmPred:$addend), ADDRriU6_0:$addr)]>,
3126             Requires<[HasV4T, UseMEMOP]>;
3127
3128 // memb(Rs+#u6:0) += #U5
3129 let AddedComplexity = 30 in
3130 def MEMb_ADDi_MEM_V4 : MEMInst_V4<(outs),
3131             (ins MEMri:$addr, u5Imm:$addend),
3132             "memb($addr) += $addend",
3133             []>,
3134             Requires<[HasV4T, UseMEMOP]>;
3135
3136 // memb(Rs+#u6:0) -= #U5
3137 let AddedComplexity = 30 in
3138 def MEMb_SUBi_MEM_V4 : MEMInst_V4<(outs),
3139             (ins MEMri:$addr, u5Imm:$subend),
3140             "memb($addr) -= $subend",
3141             []>,
3142             Requires<[HasV4T, UseMEMOP]>;
3143
3144 // memb(Rs+#u6:0) += Rt
3145 let AddedComplexity = 30 in
3146 def MEMb_ADDr_MEM_V4 : MEMInst_V4<(outs),
3147             (ins MEMri:$addr, IntRegs:$addend),
3148             "memb($addr) += $addend",
3149             [(truncstorei8 (add (sextloadi8 ADDRriU6_0:$addr),
3150                                 IntRegs:$addend), ADDRriU6_0:$addr)]>,
3151             Requires<[HasV4T, UseMEMOP]>;
3152
3153 // memb(Rs+#u6:0) -= Rt
3154 let AddedComplexity = 30 in
3155 def MEMb_SUBr_MEM_V4 : MEMInst_V4<(outs),
3156             (ins MEMri:$addr, IntRegs:$subend),
3157             "memb($addr) -= $subend",
3158             [(truncstorei8 (sub (sextloadi8 ADDRriU6_0:$addr),
3159                                 IntRegs:$subend), ADDRriU6_0:$addr)]>,
3160             Requires<[HasV4T, UseMEMOP]>;
3161
3162 // memb(Rs+#u6:0) &= Rt
3163 let AddedComplexity = 30 in
3164 def MEMb_ANDr_MEM_V4 : MEMInst_V4<(outs),
3165             (ins MEMri:$addr, IntRegs:$andend),
3166             "memb($addr) &= $andend",
3167             [(truncstorei8 (and (sextloadi8 ADDRriU6_0:$addr),
3168                                 IntRegs:$andend), ADDRriU6_0:$addr)]>,
3169             Requires<[HasV4T, UseMEMOP]>;
3170
3171 // memb(Rs+#u6:0) |= Rt
3172 let AddedComplexity = 30 in
3173 def MEMb_ORr_MEM_V4 : MEMInst_V4<(outs),
3174             (ins MEMri:$addr, IntRegs:$orend),
3175             "memb($addr) |= $orend",
3176             [(truncstorei8 (or (sextloadi8 ADDRriU6_0:$addr),
3177                                 IntRegs:$orend), ADDRriU6_0:$addr)]>,
3178             Requires<[HasV4T, UseMEMOP]>;
3179
3180
3181 //===----------------------------------------------------------------------===//
3182 // XTYPE/PRED +
3183 //===----------------------------------------------------------------------===//
3184
3185 // Hexagon V4 only supports these flavors of byte/half compare instructions:
3186 // EQ/GT/GTU. Other flavors like GE/GEU/LT/LTU/LE/LEU are not supported by
3187 // hardware. However, compiler can still implement these patterns through
3188 // appropriate patterns combinations based on current implemented patterns.
3189 // The implemented patterns are: EQ/GT/GTU.
3190 // Missing patterns are: GE/GEU/LT/LTU/LE/LEU.
3191
3192 // Pd=cmpb.eq(Rs,#u8)
3193 let isCompare = 1 in
3194 def CMPbEQri_V4 : MInst<(outs PredRegs:$dst),
3195             (ins IntRegs:$src1, u8Imm:$src2),
3196             "$dst = cmpb.eq($src1, #$src2)",
3197             [(set PredRegs:$dst, (seteq (and IntRegs:$src1, 255),
3198                                         u8ImmPred:$src2))]>,
3199             Requires<[HasV4T]>;
3200
3201 // Pd=cmpb.eq(Rs,Rt)
3202 let isCompare = 1 in
3203 def CMPbEQrr_ubub_V4 : MInst<(outs PredRegs:$dst),
3204             (ins IntRegs:$src1, IntRegs:$src2),
3205             "$dst = cmpb.eq($src1, $src2)",
3206             [(set PredRegs:$dst, (seteq (and (xor IntRegs:$src1,
3207                                                   IntRegs:$src2),
3208                                              255),
3209                                         0))]>,
3210             Requires<[HasV4T]>;
3211
3212 // Pd=cmpb.eq(Rs,Rt)
3213 let isCompare = 1 in
3214 def CMPbEQrr_sbsb_V4 : MInst<(outs PredRegs:$dst),
3215             (ins IntRegs:$src1, IntRegs:$src2),
3216             "$dst = cmpb.eq($src1, $src2)",
3217             [(set PredRegs:$dst, (seteq (shl IntRegs:$src1, (i32 24)),
3218                                         (shl IntRegs:$src2, (i32 24))))]>,
3219             Requires<[HasV4T]>;
3220
3221 // Pd=cmpb.gt(Rs,#s8)
3222 let isCompare = 1 in
3223 def CMPbGTri_V4 : MInst<(outs PredRegs:$dst),
3224             (ins IntRegs:$src1, s32Imm:$src2),
3225             "$dst = cmpb.gt($src1, #$src2)",
3226             [(set PredRegs:$dst, (setgt (shl IntRegs:$src1, (i32 24)),
3227                                         s32_24ImmPred:$src2))]>,
3228             Requires<[HasV4T]>;
3229
3230 // Pd=cmpb.gt(Rs,Rt)
3231 let isCompare = 1 in
3232 def CMPbGTrr_V4 : MInst<(outs PredRegs:$dst),
3233             (ins IntRegs:$src1, IntRegs:$src2),
3234             "$dst = cmpb.gt($src1, $src2)",
3235             [(set PredRegs:$dst, (setgt (shl IntRegs:$src1, (i32 24)),
3236                                         (shl IntRegs:$src2, (i32 24))))]>,
3237             Requires<[HasV4T]>;
3238
3239 // Pd=cmpb.gtu(Rs,#u7)
3240 let isCompare = 1 in
3241 def CMPbGTUri_V4 : MInst<(outs PredRegs:$dst),
3242             (ins IntRegs:$src1, u7Imm:$src2),
3243             "$dst = cmpb.gtu($src1, #$src2)",
3244             [(set PredRegs:$dst, (setugt (and IntRegs:$src1, 255),
3245                                          u7ImmPred:$src2))]>,
3246             Requires<[HasV4T]>;
3247
3248 // Pd=cmpb.gtu(Rs,Rt)
3249 let isCompare = 1 in
3250 def CMPbGTUrr_V4 : MInst<(outs PredRegs:$dst),
3251             (ins IntRegs:$src1, IntRegs:$src2),
3252             "$dst = cmpb.gtu($src1, $src2)",
3253             [(set PredRegs:$dst, (setugt (and IntRegs:$src1, 255),
3254                                          (and IntRegs:$src2, 255)))]>,
3255             Requires<[HasV4T]>;
3256
3257 // Signed half compare(.eq) ri.
3258 // Pd=cmph.eq(Rs,#s8)
3259 let isCompare = 1 in
3260 def CMPhEQri_V4 : MInst<(outs PredRegs:$dst),
3261             (ins IntRegs:$src1, u16Imm:$src2),
3262             "$dst = cmph.eq($src1, #$src2)",
3263             [(set PredRegs:$dst, (seteq (and IntRegs:$src1, 65535),
3264                                         u16_s8ImmPred:$src2))]>,
3265             Requires<[HasV4T]>;
3266
3267 // Signed half compare(.eq) rr.
3268 // Case 1: xor + and, then compare:
3269 //   r0=xor(r0,r1)
3270 //   r0=and(r0,#0xffff)
3271 //   p0=cmp.eq(r0,#0)
3272 // Pd=cmph.eq(Rs,Rt)
3273 let isCompare = 1 in
3274 def CMPhEQrr_xor_V4 : MInst<(outs PredRegs:$dst),
3275             (ins IntRegs:$src1, IntRegs:$src2),
3276             "$dst = cmph.eq($src1, $src2)",
3277             [(set PredRegs:$dst, (seteq (and (xor IntRegs:$src1,
3278                                                   IntRegs:$src2),
3279                                              65535),
3280                                         0))]>,
3281             Requires<[HasV4T]>;
3282
3283 // Signed half compare(.eq) rr.
3284 // Case 2: shift left 16 bits then compare:
3285 //   r0=asl(r0,16)
3286 //   r1=asl(r1,16)
3287 //   p0=cmp.eq(r0,r1)
3288 // Pd=cmph.eq(Rs,Rt)
3289 let isCompare = 1 in
3290 def CMPhEQrr_shl_V4 : MInst<(outs PredRegs:$dst),
3291             (ins IntRegs:$src1, IntRegs:$src2),
3292             "$dst = cmph.eq($src1, $src2)",
3293             [(set PredRegs:$dst, (seteq (shl IntRegs:$src1, (i32 16)),
3294                                         (shl IntRegs:$src2, (i32 16))))]>,
3295             Requires<[HasV4T]>;
3296
3297 // Signed half compare(.gt) ri.
3298 // Pd=cmph.gt(Rs,#s8)
3299 let isCompare = 1 in
3300 def CMPhGTri_V4 : MInst<(outs PredRegs:$dst),
3301             (ins IntRegs:$src1, s32Imm:$src2),
3302             "$dst = cmph.gt($src1, #$src2)",
3303             [(set PredRegs:$dst, (setgt (shl IntRegs:$src1, (i32 16)),
3304                                         s32_16s8ImmPred:$src2))]>,
3305             Requires<[HasV4T]>;
3306
3307 // Signed half compare(.gt) rr.
3308 // Pd=cmph.gt(Rs,Rt)
3309 let isCompare = 1 in
3310 def CMPhGTrr_shl_V4 : MInst<(outs PredRegs:$dst),
3311             (ins IntRegs:$src1, IntRegs:$src2),
3312             "$dst = cmph.gt($src1, $src2)",
3313             [(set PredRegs:$dst, (setgt (shl IntRegs:$src1, (i32 16)),
3314                                         (shl IntRegs:$src2, (i32 16))))]>,
3315             Requires<[HasV4T]>;
3316
3317 // Unsigned half compare rr (.gtu).
3318 // Pd=cmph.gtu(Rs,Rt)
3319 let isCompare = 1 in
3320 def CMPhGTUrr_V4 : MInst<(outs PredRegs:$dst),
3321             (ins IntRegs:$src1, IntRegs:$src2),
3322             "$dst = cmph.gtu($src1, $src2)",
3323             [(set PredRegs:$dst, (setugt (and IntRegs:$src1, 65535),
3324                                          (and IntRegs:$src2, 65535)))]>,
3325             Requires<[HasV4T]>;
3326
3327 // Unsigned half compare ri (.gtu).
3328 // Pd=cmph.gtu(Rs,#u7)
3329 let isCompare = 1 in
3330 def CMPhGTUri_V4 : MInst<(outs PredRegs:$dst),
3331             (ins IntRegs:$src1, u7Imm:$src2),
3332             "$dst = cmph.gtu($src1, #$src2)",
3333             [(set PredRegs:$dst, (setugt (and IntRegs:$src1, 65535),
3334                                          u7ImmPred:$src2))]>,
3335             Requires<[HasV4T]>;
3336
3337 //===----------------------------------------------------------------------===//
3338 // XTYPE/PRED -
3339 //===----------------------------------------------------------------------===//
3340
3341 //Deallocate frame and return.
3342 //    dealloc_return
3343 let isReturn = 1, isTerminator = 1, isBarrier = 1, isPredicable = 1,
3344   Defs = [R29, R30, R31, PC], Uses = [R29, R31], neverHasSideEffects = 1 in {
3345   def DEALLOC_RET_V4 : NVInst_V4<(outs), (ins i32imm:$amt1),
3346             "dealloc_return",
3347             []>,
3348             Requires<[HasV4T]>;
3349 }
3350
3351 //    if (Ps) dealloc_return
3352 let isReturn = 1, isTerminator = 1,
3353   Defs = [R29, R30, R31, PC], Uses = [R29, R31], neverHasSideEffects = 1 in {
3354   def DEALLOC_RET_cPt_V4 : NVInst_V4<(outs), (ins PredRegs:$src1, i32imm:$amt1),
3355             "if ($src1) dealloc_return",
3356             []>,
3357             Requires<[HasV4T]>;
3358 }
3359
3360 //    if (!Ps) dealloc_return
3361 let isReturn = 1, isTerminator = 1,
3362   Defs = [R29, R30, R31, PC], Uses = [R29, R31], neverHasSideEffects = 1 in {
3363   def DEALLOC_RET_cNotPt_V4 : NVInst_V4<(outs), (ins PredRegs:$src1,
3364                                                      i32imm:$amt1),
3365             "if (!$src1) dealloc_return",
3366             []>,
3367             Requires<[HasV4T]>;
3368 }
3369
3370 //    if (Ps.new) dealloc_return:nt
3371 let isReturn = 1, isTerminator = 1,
3372   Defs = [R29, R30, R31, PC], Uses = [R29, R31], neverHasSideEffects = 1 in {
3373   def DEALLOC_RET_cdnPnt_V4 : NVInst_V4<(outs), (ins PredRegs:$src1,
3374                                                      i32imm:$amt1),
3375             "if ($src1.new) dealloc_return:nt",
3376             []>,
3377             Requires<[HasV4T]>;
3378 }
3379
3380 //    if (!Ps.new) dealloc_return:nt
3381 let isReturn = 1, isTerminator = 1,
3382   Defs = [R29, R30, R31, PC], Uses = [R29, R31], neverHasSideEffects = 1 in {
3383   def DEALLOC_RET_cNotdnPnt_V4 : NVInst_V4<(outs), (ins PredRegs:$src1,
3384                                                         i32imm:$amt1),
3385             "if (!$src1.new) dealloc_return:nt",
3386             []>,
3387             Requires<[HasV4T]>;
3388 }
3389
3390 //    if (Ps.new) dealloc_return:t
3391 let isReturn = 1, isTerminator = 1,
3392   Defs = [R29, R30, R31, PC], Uses = [R29, R31], neverHasSideEffects = 1 in {
3393   def DEALLOC_RET_cdnPt_V4 : NVInst_V4<(outs), (ins PredRegs:$src1,
3394                                                     i32imm:$amt1),
3395             "if ($src1.new) dealloc_return:t",
3396             []>,
3397             Requires<[HasV4T]>;
3398 }
3399
3400 //    if (!Ps.new) dealloc_return:nt
3401 let isReturn = 1, isTerminator = 1,
3402   Defs = [R29, R30, R31, PC], Uses = [R29, R31], neverHasSideEffects = 1 in {
3403   def DEALLOC_RET_cNotdnPt_V4 : NVInst_V4<(outs), (ins PredRegs:$src1,
3404                                                        i32imm:$amt1),
3405             "if (!$src1.new) dealloc_return:t",
3406             []>,
3407             Requires<[HasV4T]>;
3408 }