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 let neverHasSideEffects = 1 in
  15 class T_Immext<dag ins> :
  16   EXTENDERInst<(outs), ins, "immext(#$imm)", []>,
  17   Requires<[HasV4T]>;
  18
  19 def IMMEXT_b : T_Immext<(ins brtarget:$imm)>;
  20 def IMMEXT_c : T_Immext<(ins calltarget:$imm)>;
  21 def IMMEXT_g : T_Immext<(ins globaladdress:$imm)>;
  22 def IMMEXT_i : T_Immext<(ins u26_6Imm:$imm)>;
  23
  24 // Fold (add (CONST32 tglobaladdr:$addr) <offset>) into a global address.
  25 def FoldGlobalAddr : ComplexPattern<i32, 1, "foldGlobalAddress", [], []>;
  26
  27 // Fold (add (CONST32_GP tglobaladdr:$addr) <offset>) into a global address.
  28 def FoldGlobalAddrGP : ComplexPattern<i32, 1, "foldGlobalAddressGP", [], []>;
  29
  30 def NumUsesBelowThresCONST32 : PatFrag<(ops node:$addr),
  31                                        (HexagonCONST32 node:$addr), [{
  32   return hasNumUsesBelowThresGA(N->getOperand(0).getNode());
  33 }]>;
  34
  35 // Hexagon V4 Architecture spec defines 8 instruction classes:
  36 // LD ST ALU32 XTYPE J JR MEMOP NV CR SYSTEM(system is not implemented in the
  37 // compiler)
  38
  39 // LD Instructions:
  40 // ========================================
  41 // Loads (8/16/32/64 bit)
  42 // Deallocframe
  43
  44 // ST Instructions:
  45 // ========================================
  46 // Stores (8/16/32/64 bit)
  47 // Allocframe
  48
  49 // ALU32 Instructions:
  50 // ========================================
  51 // Arithmetic / Logical (32 bit)
  52 // Vector Halfword
  53
  54 // XTYPE Instructions (32/64 bit):
  55 // ========================================
  56 // Arithmetic, Logical, Bit Manipulation
  57 // Multiply (Integer, Fractional, Complex)
  58 // Permute / Vector Permute Operations
  59 // Predicate Operations
  60 // Shift / Shift with Add/Sub/Logical
  61 // Vector Byte ALU
  62 // Vector Halfword (ALU, Shift, Multiply)
  63 // Vector Word (ALU, Shift)
  64
  65 // J Instructions:
  66 // ========================================
  67 // Jump/Call PC-relative
  68
  69 // JR Instructions:
  70 // ========================================
  71 // Jump/Call Register
  72
  73 // MEMOP Instructions:
  74 // ========================================
  75 // Operation on memory (8/16/32 bit)
  76
  77 // NV Instructions:
  78 // ========================================
  79 // New-value Jumps
  80 // New-value Stores
  81
  82 // CR Instructions:
  83 // ========================================
  84 // Control-Register Transfers
  85 // Hardware Loop Setup
  86 // Predicate Logicals & Reductions
  87
  88 // SYSTEM Instructions (not implemented in the compiler):
  89 // ========================================
  90 // Prefetch
  91 // Cache Maintenance
  92 // Bus Operations
  93
  94
  95 //===----------------------------------------------------------------------===//
  96 // ALU32 +
  97 //===----------------------------------------------------------------------===//
  98
  99 // Shift halfword.
 100
 101 let isPredicated = 1, neverHasSideEffects = 1, validSubTargets = HasV4SubT in {
 102 def ASLH_cPt_V4 : ALU32_rr<(outs IntRegs:$dst),
 103             (ins PredRegs:$src1, IntRegs:$src2),
 104             "if ($src1) $dst = aslh($src2)",
 105             []>,
 106             Requires<[HasV4T]>;
 107
 108 def ASLH_cNotPt_V4 : ALU32_rr<(outs IntRegs:$dst),
 109             (ins PredRegs:$src1, IntRegs:$src2),
 110             "if (!$src1) $dst = aslh($src2)",
 111             []>,
 112             Requires<[HasV4T]>;
 113
 114 def ASLH_cdnPt_V4 : ALU32_rr<(outs IntRegs:$dst),
 115             (ins PredRegs:$src1, IntRegs:$src2),
 116             "if ($src1.new) $dst = aslh($src2)",
 117             []>,
 118             Requires<[HasV4T]>;
 119
 120 def ASLH_cdnNotPt_V4 : ALU32_rr<(outs IntRegs:$dst),
 121             (ins PredRegs:$src1, IntRegs:$src2),
 122             "if (!$src1.new) $dst = aslh($src2)",
 123             []>,
 124             Requires<[HasV4T]>;
 125
 126 def ASRH_cPt_V4 : ALU32_rr<(outs IntRegs:$dst),
 127             (ins PredRegs:$src1, IntRegs:$src2),
 128             "if ($src1) $dst = asrh($src2)",
 129             []>,
 130             Requires<[HasV4T]>;
 131
 132 def ASRH_cNotPt_V4 : ALU32_rr<(outs IntRegs:$dst),
 133             (ins PredRegs:$src1, IntRegs:$src2),
 134             "if (!$src1) $dst = asrh($src2)",
 135             []>,
 136             Requires<[HasV4T]>;
 137
 138 def ASRH_cdnPt_V4 : ALU32_rr<(outs IntRegs:$dst),
 139             (ins PredRegs:$src1, IntRegs:$src2),
 140             "if ($src1.new) $dst = asrh($src2)",
 141             []>,
 142             Requires<[HasV4T]>;
 143
 144 def ASRH_cdnNotPt_V4 : ALU32_rr<(outs IntRegs:$dst),
 145             (ins PredRegs:$src1, IntRegs:$src2),
 146             "if (!$src1.new) $dst = asrh($src2)",
 147             []>,
 148             Requires<[HasV4T]>;
 149 }
 150
 151 // Sign extend.
 152
 153 let isPredicated = 1, neverHasSideEffects = 1, validSubTargets = HasV4SubT in {
 154 def SXTB_cPt_V4 : ALU32_rr<(outs IntRegs:$dst),
 155             (ins PredRegs:$src1, IntRegs:$src2),
 156             "if ($src1) $dst = sxtb($src2)",
 157             []>,
 158             Requires<[HasV4T]>;
 159
 160 def SXTB_cNotPt_V4 : ALU32_rr<(outs IntRegs:$dst),
 161             (ins PredRegs:$src1, IntRegs:$src2),
 162             "if (!$src1) $dst = sxtb($src2)",
 163             []>,
 164             Requires<[HasV4T]>;
 165
 166 def SXTB_cdnPt_V4 : ALU32_rr<(outs IntRegs:$dst),
 167             (ins PredRegs:$src1, IntRegs:$src2),
 168             "if ($src1.new) $dst = sxtb($src2)",
 169             []>,
 170             Requires<[HasV4T]>;
 171
 172 def SXTB_cdnNotPt_V4 : ALU32_rr<(outs IntRegs:$dst),
 173             (ins PredRegs:$src1, IntRegs:$src2),
 174             "if (!$src1.new) $dst = sxtb($src2)",
 175             []>,
 176             Requires<[HasV4T]>;
 177
 178
 179 def SXTH_cPt_V4 : ALU32_rr<(outs IntRegs:$dst),
 180             (ins PredRegs:$src1, IntRegs:$src2),
 181             "if ($src1) $dst = sxth($src2)",
 182             []>,
 183             Requires<[HasV4T]>;
 184
 185 def SXTH_cNotPt_V4 : ALU32_rr<(outs IntRegs:$dst),
 186             (ins PredRegs:$src1, IntRegs:$src2),
 187             "if (!$src1) $dst = sxth($src2)",
 188             []>,
 189             Requires<[HasV4T]>;
 190
 191 def SXTH_cdnPt_V4 : ALU32_rr<(outs IntRegs:$dst),
 192             (ins PredRegs:$src1, IntRegs:$src2),
 193             "if ($src1.new) $dst = sxth($src2)",
 194             []>,
 195             Requires<[HasV4T]>;
 196
 197 def SXTH_cdnNotPt_V4 : ALU32_rr<(outs IntRegs:$dst),
 198             (ins PredRegs:$src1, IntRegs:$src2),
 199             "if (!$src1.new) $dst = sxth($src2)",
 200             []>,
 201             Requires<[HasV4T]>;
 202 }
 203
 204 // Zero exten.
 205
 206 let neverHasSideEffects = 1, isPredicated = 1, validSubTargets = HasV4SubT in {
 207 def ZXTB_cPt_V4 : ALU32_rr<(outs IntRegs:$dst),
 208             (ins PredRegs:$src1, IntRegs:$src2),
 209             "if ($src1) $dst = zxtb($src2)",
 210             []>,
 211             Requires<[HasV4T]>;
 212
 213 def ZXTB_cNotPt_V4 : ALU32_rr<(outs IntRegs:$dst),
 214             (ins PredRegs:$src1, IntRegs:$src2),
 215             "if (!$src1) $dst = zxtb($src2)",
 216             []>,
 217             Requires<[HasV4T]>;
 218
 219 def ZXTB_cdnPt_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 def ZXTB_cdnNotPt_V4 : ALU32_rr<(outs IntRegs:$dst),
 226             (ins PredRegs:$src1, IntRegs:$src2),
 227             "if (!$src1.new) $dst = zxtb($src2)",
 228             []>,
 229             Requires<[HasV4T]>;
 230
 231 def ZXTH_cPt_V4 : ALU32_rr<(outs IntRegs:$dst),
 232             (ins PredRegs:$src1, IntRegs:$src2),
 233             "if ($src1) $dst = zxth($src2)",
 234             []>,
 235             Requires<[HasV4T]>;
 236
 237 def ZXTH_cNotPt_V4 : ALU32_rr<(outs IntRegs:$dst),
 238             (ins PredRegs:$src1, IntRegs:$src2),
 239             "if (!$src1) $dst = zxth($src2)",
 240             []>,
 241             Requires<[HasV4T]>;
 242
 243 def ZXTH_cdnPt_V4 : ALU32_rr<(outs IntRegs:$dst),
 244             (ins PredRegs:$src1, IntRegs:$src2),
 245             "if ($src1.new) $dst = zxth($src2)",
 246             []>,
 247             Requires<[HasV4T]>;
 248
 249 def ZXTH_cdnNotPt_V4 : ALU32_rr<(outs IntRegs:$dst),
 250             (ins PredRegs:$src1, IntRegs:$src2),
 251             "if (!$src1.new) $dst = zxth($src2)",
 252             []>,
 253             Requires<[HasV4T]>;
 254 }
 255
 256 // Generate frame index addresses.
 257 let neverHasSideEffects = 1, isReMaterializable = 1,
 258 isExtended = 1, opExtendable = 2, validSubTargets = HasV4SubT in
 259 def TFR_FI_immext_V4 : ALU32_ri<(outs IntRegs:$dst),
 260             (ins IntRegs:$src1, s32Imm:$offset),
 261             "$dst = add($src1, ##$offset)",
 262             []>,
 263             Requires<[HasV4T]>;
 264
 265 // Rd=cmp.eq(Rs,#s8)
 266 let validSubTargets = HasV4SubT, isExtendable = 1, opExtendable = 2,
 267 isExtentSigned = 1, opExtentBits = 8 in
 268 def V4_A4_rcmpeqi : ALU32_ri<(outs IntRegs:$Rd),
 269                     (ins IntRegs:$Rs, s8Ext:$s8),
 270                     "$Rd = cmp.eq($Rs, #$s8)",
 271                     [(set (i32 IntRegs:$Rd),
 272                           (i32 (zext (i1 (seteq (i32 IntRegs:$Rs),
 273                                                 s8ExtPred:$s8)))))]>,
 274                     Requires<[HasV4T]>;
 275
 276 // Preserve the TSTBIT generation
 277 def : Pat <(i32 (zext (i1 (setne (i32 (and (i32 (shl 1, (i32 IntRegs:$src2))),
 278                                            (i32 IntRegs:$src1))), 0)))),
 279       (i32 (MUX_ii (i1 (TSTBIT_rr (i32 IntRegs:$src1), (i32 IntRegs:$src2))),
 280                    1, 0))>;
 281
 282 // Interfered with tstbit generation, above pattern preserves, see : tstbit.ll
 283 // Rd=cmp.ne(Rs,#s8)
 284 let validSubTargets = HasV4SubT, isExtendable = 1, opExtendable = 2,
 285 isExtentSigned = 1, opExtentBits = 8 in
 286 def V4_A4_rcmpneqi : ALU32_ri<(outs IntRegs:$Rd),
 287                      (ins IntRegs:$Rs, s8Ext:$s8),
 288                      "$Rd = !cmp.eq($Rs, #$s8)",
 289                      [(set (i32 IntRegs:$Rd),
 290                            (i32 (zext (i1 (setne (i32 IntRegs:$Rs),
 291                                                  s8ExtPred:$s8)))))]>,
 292                      Requires<[HasV4T]>;
 293
 294 // Rd=cmp.eq(Rs,Rt)
 295 let validSubTargets = HasV4SubT in
 296 def V4_A4_rcmpeq : ALU32_ri<(outs IntRegs:$Rd),
 297                    (ins IntRegs:$Rs, IntRegs:$Rt),
 298                    "$Rd = cmp.eq($Rs, $Rt)",
 299                    [(set (i32 IntRegs:$Rd),
 300                          (i32 (zext (i1 (seteq (i32 IntRegs:$Rs),
 301                                                IntRegs:$Rt)))))]>,
 302                    Requires<[HasV4T]>;
 303
 304 // Rd=cmp.ne(Rs,Rt)
 305 let validSubTargets = HasV4SubT in
 306 def V4_A4_rcmpneq : ALU32_ri<(outs IntRegs:$Rd),
 307                     (ins IntRegs:$Rs, IntRegs:$Rt),
 308                     "$Rd = !cmp.eq($Rs, $Rt)",
 309                     [(set (i32 IntRegs:$Rd),
 310                           (i32 (zext (i1 (setne (i32 IntRegs:$Rs),
 311                                                IntRegs:$Rt)))))]>,
 312                     Requires<[HasV4T]>;
 313
 314 //===----------------------------------------------------------------------===//
 315 // ALU32 -
 316 //===----------------------------------------------------------------------===//
 317
 318
 319 //===----------------------------------------------------------------------===//
 320 // ALU32/PERM +
 321 //===----------------------------------------------------------------------===//
 322
 323 // Combine
 324 // Rdd=combine(Rs, #s8)
 325 let isExtendable = 1, opExtendable = 2, isExtentSigned = 1, opExtentBits = 8,
 326     neverHasSideEffects = 1, validSubTargets = HasV4SubT in
 327 def COMBINE_rI_V4 : ALU32_ri<(outs DoubleRegs:$dst),
 328             (ins IntRegs:$src1, s8Ext:$src2),
 329             "$dst = combine($src1, #$src2)",
 330             []>,
 331             Requires<[HasV4T]>;
 332
 333 // Rdd=combine(#s8, Rs)
 334 let isExtendable = 1, opExtendable = 1, isExtentSigned = 1, opExtentBits = 8,
 335     neverHasSideEffects = 1, validSubTargets = HasV4SubT in
 336 def COMBINE_Ir_V4 : ALU32_ir<(outs DoubleRegs:$dst),
 337             (ins s8Ext:$src1, IntRegs:$src2),
 338             "$dst = combine(#$src1, $src2)",
 339             []>,
 340             Requires<[HasV4T]>;
 341
 342 def HexagonWrapperCombineRI_V4 :
 343   SDNode<"HexagonISD::WrapperCombineRI_V4", SDTHexagonI64I32I32>;
 344 def HexagonWrapperCombineIR_V4 :
 345   SDNode<"HexagonISD::WrapperCombineIR_V4", SDTHexagonI64I32I32>;
 346
 347 def : Pat <(HexagonWrapperCombineRI_V4 IntRegs:$r, s8ExtPred:$i),
 348            (COMBINE_rI_V4 IntRegs:$r, s8ExtPred:$i)>,
 349           Requires<[HasV4T]>;
 350
 351 def : Pat <(HexagonWrapperCombineIR_V4 s8ExtPred:$i, IntRegs:$r),
 352            (COMBINE_Ir_V4 s8ExtPred:$i, IntRegs:$r)>,
 353           Requires<[HasV4T]>;
 354
 355 let isExtendable = 1, opExtendable = 2, isExtentSigned = 0, opExtentBits = 6,
 356     neverHasSideEffects = 1, validSubTargets = HasV4SubT in
 357 def COMBINE_iI_V4 : ALU32_ii<(outs DoubleRegs:$dst),
 358             (ins s8Imm:$src1, u6Ext:$src2),
 359             "$dst = combine(#$src1, #$src2)",
 360             []>,
 361             Requires<[HasV4T]>;
 362
 363 //===----------------------------------------------------------------------===//
 364 // ALU32/PERM +
 365 //===----------------------------------------------------------------------===//
 366
 367 //===----------------------------------------------------------------------===//
 368 // LD +
 369 //===----------------------------------------------------------------------===//
 370 //
 371 // These absolute set addressing mode instructions accept immediate as
 372 // an operand. We have duplicated these patterns to take global address.
 373
 374 let isExtended = 1, opExtendable = 2, neverHasSideEffects = 1,
 375 validSubTargets = HasV4SubT in {
 376 def LDrid_abs_setimm_V4 : LDInst2<(outs DoubleRegs:$dst1, IntRegs:$dst2),
 377             (ins u0AlwaysExt:$addr),
 378             "$dst1 = memd($dst2=##$addr)",
 379             []>,
 380             Requires<[HasV4T]>;
 381
 382 // Rd=memb(Re=#U6)
 383 def LDrib_abs_setimm_V4 : LDInst2<(outs IntRegs:$dst1, IntRegs:$dst2),
 384             (ins u0AlwaysExt:$addr),
 385             "$dst1 = memb($dst2=##$addr)",
 386             []>,
 387             Requires<[HasV4T]>;
 388
 389 // Rd=memh(Re=#U6)
 390 def LDrih_abs_setimm_V4 : LDInst2<(outs IntRegs:$dst1, IntRegs:$dst2),
 391             (ins u0AlwaysExt:$addr),
 392             "$dst1 = memh($dst2=##$addr)",
 393             []>,
 394             Requires<[HasV4T]>;
 395
 396 // Rd=memub(Re=#U6)
 397 def LDriub_abs_setimm_V4 : LDInst2<(outs IntRegs:$dst1, IntRegs:$dst2),
 398             (ins u0AlwaysExt:$addr),
 399             "$dst1 = memub($dst2=##$addr)",
 400             []>,
 401             Requires<[HasV4T]>;
 402
 403 // Rd=memuh(Re=#U6)
 404 def LDriuh_abs_setimm_V4 : LDInst2<(outs IntRegs:$dst1, IntRegs:$dst2),
 405             (ins u0AlwaysExt:$addr),
 406             "$dst1 = memuh($dst2=##$addr)",
 407             []>,
 408             Requires<[HasV4T]>;
 409
 410 // Rd=memw(Re=#U6)
 411 def LDriw_abs_setimm_V4 : LDInst2<(outs IntRegs:$dst1, IntRegs:$dst2),
 412             (ins u0AlwaysExt:$addr),
 413             "$dst1 = memw($dst2=##$addr)",
 414             []>,
 415             Requires<[HasV4T]>;
 416 }
 417
 418 // Following patterns are defined for absolute set addressing mode
 419 // instruction which take global address as operand.
 420 let isExtended = 1, opExtendable = 2, neverHasSideEffects = 1,
 421 validSubTargets = HasV4SubT in {
 422 def LDrid_abs_set_V4 : LDInst2<(outs DoubleRegs:$dst1, IntRegs:$dst2),
 423             (ins globaladdressExt:$addr),
 424             "$dst1 = memd($dst2=##$addr)",
 425             []>,
 426             Requires<[HasV4T]>;
 427
 428 // Rd=memb(Re=#U6)
 429 def LDrib_abs_set_V4 : LDInst2<(outs IntRegs:$dst1, IntRegs:$dst2),
 430             (ins globaladdressExt:$addr),
 431             "$dst1 = memb($dst2=##$addr)",
 432             []>,
 433             Requires<[HasV4T]>;
 434
 435 // Rd=memh(Re=#U6)
 436 def LDrih_abs_set_V4 : LDInst2<(outs IntRegs:$dst1, IntRegs:$dst2),
 437             (ins globaladdressExt:$addr),
 438             "$dst1 = memh($dst2=##$addr)",
 439             []>,
 440             Requires<[HasV4T]>;
 441
 442 // Rd=memub(Re=#U6)
 443 def LDriub_abs_set_V4 : LDInst2<(outs IntRegs:$dst1, IntRegs:$dst2),
 444             (ins globaladdressExt:$addr),
 445             "$dst1 = memub($dst2=##$addr)",
 446             []>,
 447             Requires<[HasV4T]>;
 448
 449 // Rd=memuh(Re=#U6)
 450 def LDriuh_abs_set_V4 : LDInst2<(outs IntRegs:$dst1, IntRegs:$dst2),
 451             (ins globaladdressExt:$addr),
 452             "$dst1 = memuh($dst2=##$addr)",
 453             []>,
 454             Requires<[HasV4T]>;
 455
 456 // Rd=memw(Re=#U6)
 457 def LDriw_abs_set_V4 : LDInst2<(outs IntRegs:$dst1, IntRegs:$dst2),
 458             (ins globaladdressExt:$addr),
 459             "$dst1 = memw($dst2=##$addr)",
 460             []>,
 461             Requires<[HasV4T]>;
 462 }
 463
 464 // multiclass for load instructions with base + register offset
 465 // addressing mode
 466 multiclass ld_idxd_shl_pbase<string mnemonic, RegisterClass RC, bit isNot,
 467                              bit isPredNew> {
 468   let PNewValue = !if(isPredNew, "new", "") in
 469   def NAME : LDInst2<(outs RC:$dst),
 470             (ins PredRegs:$src1, IntRegs:$src2, IntRegs:$src3, u2Imm:$offset),
 471             !if(isNot, "if (!$src1", "if ($src1")#!if(isPredNew, ".new) ",
 472             ") ")#"$dst = "#mnemonic#"($src2+$src3<<#$offset)",
 473             []>, Requires<[HasV4T]>;
 474 }
 475
 476 multiclass ld_idxd_shl_pred<string mnemonic, RegisterClass RC, bit PredNot> {
 477   let PredSense = !if(PredNot, "false", "true") in {
 478     defm _c#NAME : ld_idxd_shl_pbase<mnemonic, RC, PredNot, 0>;
 479     // Predicate new
 480     defm _cdn#NAME : ld_idxd_shl_pbase<mnemonic, RC, PredNot, 1>;
 481   }
 482 }
 483
 484 let neverHasSideEffects  = 1 in
 485 multiclass ld_idxd_shl<string mnemonic, string CextOp, RegisterClass RC> {
 486   let CextOpcode = CextOp, BaseOpcode = CextOp#_indexed_shl in {
 487     let isPredicable = 1 in
 488     def NAME#_V4 : LDInst2<(outs RC:$dst),
 489             (ins IntRegs:$src1, IntRegs:$src2, u2Imm:$offset),
 490             "$dst = "#mnemonic#"($src1+$src2<<#$offset)",
 491             []>, Requires<[HasV4T]>;
 492
 493     let isPredicated = 1 in {
 494       defm Pt_V4 : ld_idxd_shl_pred<mnemonic, RC, 0 >;
 495       defm NotPt_V4 : ld_idxd_shl_pred<mnemonic, RC, 1>;
 496     }
 497   }
 498 }
 499
 500 let addrMode = BaseRegOffset in {
 501   defm LDrib_indexed_shl: ld_idxd_shl<"memb", "LDrib", IntRegs>, AddrModeRel;
 502   defm LDriub_indexed_shl: ld_idxd_shl<"memub", "LDriub", IntRegs>, AddrModeRel;
 503   defm LDrih_indexed_shl: ld_idxd_shl<"memh", "LDrih", IntRegs>, AddrModeRel;
 504   defm LDriuh_indexed_shl: ld_idxd_shl<"memuh", "LDriuh", IntRegs>, AddrModeRel;
 505   defm LDriw_indexed_shl: ld_idxd_shl<"memw", "LDriw", IntRegs>, AddrModeRel;
 506   defm LDrid_indexed_shl: ld_idxd_shl<"memd", "LDrid", DoubleRegs>, AddrModeRel;
 507 }
 508
 509 // 'def pats' for load instructions with base + register offset and non-zero
 510 // immediate value. Immediate value is used to left-shift the second
 511 // register operand.
 512 let AddedComplexity = 40 in {
 513 def : Pat <(i32 (sextloadi8 (add IntRegs:$src1,
 514                                  (shl IntRegs:$src2, u2ImmPred:$offset)))),
 515            (LDrib_indexed_shl_V4 IntRegs:$src1,
 516             IntRegs:$src2, u2ImmPred:$offset)>,
 517             Requires<[HasV4T]>;
 518
 519 def : Pat <(i32 (zextloadi8 (add IntRegs:$src1,
 520                                  (shl IntRegs:$src2, u2ImmPred:$offset)))),
 521            (LDriub_indexed_shl_V4 IntRegs:$src1,
 522             IntRegs:$src2, u2ImmPred:$offset)>,
 523             Requires<[HasV4T]>;
 524
 525 def : Pat <(i32 (extloadi8 (add IntRegs:$src1,
 526                                 (shl IntRegs:$src2, u2ImmPred:$offset)))),
 527            (LDriub_indexed_shl_V4 IntRegs:$src1,
 528             IntRegs:$src2, u2ImmPred:$offset)>,
 529             Requires<[HasV4T]>;
 530
 531 def : Pat <(i32 (sextloadi16 (add IntRegs:$src1,
 532                                   (shl IntRegs:$src2, u2ImmPred:$offset)))),
 533            (LDrih_indexed_shl_V4 IntRegs:$src1,
 534             IntRegs:$src2, u2ImmPred:$offset)>,
 535             Requires<[HasV4T]>;
 536
 537 def : Pat <(i32 (zextloadi16 (add IntRegs:$src1,
 538                                   (shl IntRegs:$src2, u2ImmPred:$offset)))),
 539            (LDriuh_indexed_shl_V4 IntRegs:$src1,
 540             IntRegs:$src2, u2ImmPred:$offset)>,
 541             Requires<[HasV4T]>;
 542
 543 def : Pat <(i32 (extloadi16 (add IntRegs:$src1,
 544                                  (shl IntRegs:$src2, u2ImmPred:$offset)))),
 545            (LDriuh_indexed_shl_V4 IntRegs:$src1,
 546             IntRegs:$src2, u2ImmPred:$offset)>,
 547             Requires<[HasV4T]>;
 548
 549 def : Pat <(i32 (load (add IntRegs:$src1,
 550                            (shl IntRegs:$src2, u2ImmPred:$offset)))),
 551            (LDriw_indexed_shl_V4 IntRegs:$src1,
 552             IntRegs:$src2, u2ImmPred:$offset)>,
 553             Requires<[HasV4T]>;
 554
 555 def : Pat <(i64 (load (add IntRegs:$src1,
 556                            (shl IntRegs:$src2, u2ImmPred:$offset)))),
 557            (LDrid_indexed_shl_V4 IntRegs:$src1,
 558             IntRegs:$src2, u2ImmPred:$offset)>,
 559             Requires<[HasV4T]>;
 560 }
 561
 562
 563 // 'def pats' for load instruction base + register offset and
 564 // zero immediate value.
 565 let AddedComplexity = 10 in {
 566 def : Pat <(i64 (load (add IntRegs:$src1, IntRegs:$src2))),
 567            (LDrid_indexed_shl_V4 IntRegs:$src1, IntRegs:$src2, 0)>,
 568             Requires<[HasV4T]>;
 569
 570 def : Pat <(i32 (sextloadi8 (add IntRegs:$src1, IntRegs:$src2))),
 571            (LDrib_indexed_shl_V4 IntRegs:$src1, IntRegs:$src2, 0)>,
 572             Requires<[HasV4T]>;
 573
 574 def : Pat <(i32 (zextloadi8 (add IntRegs:$src1, IntRegs:$src2))),
 575            (LDriub_indexed_shl_V4 IntRegs:$src1, IntRegs:$src2, 0)>,
 576             Requires<[HasV4T]>;
 577
 578 def : Pat <(i32 (extloadi8 (add IntRegs:$src1, IntRegs:$src2))),
 579            (LDriub_indexed_shl_V4 IntRegs:$src1, IntRegs:$src2, 0)>,
 580             Requires<[HasV4T]>;
 581
 582 def : Pat <(i32 (sextloadi16 (add IntRegs:$src1, IntRegs:$src2))),
 583            (LDrih_indexed_shl_V4 IntRegs:$src1, IntRegs:$src2, 0)>,
 584             Requires<[HasV4T]>;
 585
 586 def : Pat <(i32 (zextloadi16 (add IntRegs:$src1, IntRegs:$src2))),
 587            (LDriuh_indexed_shl_V4 IntRegs:$src1, IntRegs:$src2, 0)>,
 588             Requires<[HasV4T]>;
 589
 590 def : Pat <(i32 (extloadi16 (add IntRegs:$src1, IntRegs:$src2))),
 591            (LDriuh_indexed_shl_V4 IntRegs:$src1, IntRegs:$src2, 0)>,
 592             Requires<[HasV4T]>;
 593
 594 def : Pat <(i32 (load (add IntRegs:$src1, IntRegs:$src2))),
 595            (LDriw_indexed_shl_V4 IntRegs:$src1, IntRegs:$src2, 0)>,
 596             Requires<[HasV4T]>;
 597 }
 598
 599 let isPredicable = 1, neverHasSideEffects = 1, validSubTargets = HasV4SubT in
 600 def LDd_GP_V4 : LDInst2<(outs DoubleRegs:$dst),
 601             (ins globaladdress:$global),
 602             "$dst=memd(#$global)",
 603             []>,
 604             Requires<[HasV4T]>;
 605
 606 // if (Pv) Rtt=memd(##global)
 607 let neverHasSideEffects = 1, isPredicated = 1, isExtended = 1, opExtendable = 2,
 608 validSubTargets = HasV4SubT in {
 609 def LDd_GP_cPt_V4 : LDInst2<(outs DoubleRegs:$dst),
 610             (ins PredRegs:$src1, globaladdress:$global),
 611             "if ($src1) $dst=memd(##$global)",
 612             []>,
 613             Requires<[HasV4T]>;
 614
 615
 616 // if (!Pv) Rtt=memd(##global)
 617 def LDd_GP_cNotPt_V4 : LDInst2<(outs DoubleRegs:$dst),
 618             (ins PredRegs:$src1, globaladdress:$global),
 619             "if (!$src1) $dst=memd(##$global)",
 620             []>,
 621             Requires<[HasV4T]>;
 622
 623 // if (Pv) Rtt=memd(##global)
 624 def LDd_GP_cdnPt_V4 : LDInst2<(outs DoubleRegs:$dst),
 625             (ins PredRegs:$src1, globaladdress:$global),
 626             "if ($src1.new) $dst=memd(##$global)",
 627             []>,
 628             Requires<[HasV4T]>;
 629
 630
 631 // if (!Pv) Rtt=memd(##global)
 632 def LDd_GP_cdnNotPt_V4 : LDInst2<(outs DoubleRegs:$dst),
 633             (ins PredRegs:$src1, globaladdress:$global),
 634             "if (!$src1.new) $dst=memd(##$global)",
 635             []>,
 636             Requires<[HasV4T]>;
 637 }
 638
 639 let isPredicable = 1, neverHasSideEffects = 1, validSubTargets = HasV4SubT in
 640 def LDb_GP_V4 : LDInst2<(outs IntRegs:$dst),
 641             (ins globaladdress:$global),
 642             "$dst=memb(#$global)",
 643             []>,
 644             Requires<[HasV4T]>;
 645
 646 // if (Pv) Rt=memb(##global)
 647 let neverHasSideEffects = 1, isPredicated = 1, isExtended = 1, opExtendable = 2,
 648 validSubTargets = HasV4SubT in {
 649 def LDb_GP_cPt_V4 : LDInst2<(outs IntRegs:$dst),
 650             (ins PredRegs:$src1, globaladdress:$global),
 651             "if ($src1) $dst=memb(##$global)",
 652             []>,
 653             Requires<[HasV4T]>;
 654
 655 // if (!Pv) Rt=memb(##global)
 656 def LDb_GP_cNotPt_V4 : LDInst2<(outs IntRegs:$dst),
 657             (ins PredRegs:$src1, globaladdress:$global),
 658             "if (!$src1) $dst=memb(##$global)",
 659             []>,
 660             Requires<[HasV4T]>;
 661
 662 // if (Pv) Rt=memb(##global)
 663 def LDb_GP_cdnPt_V4 : LDInst2<(outs IntRegs:$dst),
 664             (ins PredRegs:$src1, globaladdress:$global),
 665             "if ($src1.new) $dst=memb(##$global)",
 666             []>,
 667             Requires<[HasV4T]>;
 668
 669 // if (!Pv) Rt=memb(##global)
 670 def LDb_GP_cdnNotPt_V4 : LDInst2<(outs IntRegs:$dst),
 671             (ins PredRegs:$src1, globaladdress:$global),
 672             "if (!$src1.new) $dst=memb(##$global)",
 673             []>,
 674             Requires<[HasV4T]>;
 675 }
 676
 677 let isPredicable = 1, neverHasSideEffects = 1, validSubTargets = HasV4SubT in
 678 def LDub_GP_V4 : LDInst2<(outs IntRegs:$dst),
 679             (ins globaladdress:$global),
 680             "$dst=memub(#$global)",
 681             []>,
 682             Requires<[HasV4T]>;
 683
 684 // if (Pv) Rt=memub(##global)
 685 let neverHasSideEffects = 1, isPredicated = 1, isExtended = 1, opExtendable = 2,
 686 validSubTargets = HasV4SubT in {
 687 def LDub_GP_cPt_V4 : LDInst2<(outs IntRegs:$dst),
 688             (ins PredRegs:$src1, globaladdress:$global),
 689             "if ($src1) $dst=memub(##$global)",
 690             []>,
 691             Requires<[HasV4T]>;
 692
 693
 694 // if (!Pv) Rt=memub(##global)
 695 def LDub_GP_cNotPt_V4 : LDInst2<(outs IntRegs:$dst),
 696             (ins PredRegs:$src1, globaladdress:$global),
 697             "if (!$src1) $dst=memub(##$global)",
 698             []>,
 699             Requires<[HasV4T]>;
 700
 701 // if (Pv) Rt=memub(##global)
 702 def LDub_GP_cdnPt_V4 : LDInst2<(outs IntRegs:$dst),
 703             (ins PredRegs:$src1, globaladdress:$global),
 704             "if ($src1.new) $dst=memub(##$global)",
 705             []>,
 706             Requires<[HasV4T]>;
 707
 708
 709 // if (!Pv) Rt=memub(##global)
 710 def LDub_GP_cdnNotPt_V4 : LDInst2<(outs IntRegs:$dst),
 711             (ins PredRegs:$src1, globaladdress:$global),
 712             "if (!$src1.new) $dst=memub(##$global)",
 713             []>,
 714             Requires<[HasV4T]>;
 715 }
 716
 717 let isPredicable = 1, neverHasSideEffects = 1, validSubTargets = HasV4SubT in
 718 def LDh_GP_V4 : LDInst2<(outs IntRegs:$dst),
 719             (ins globaladdress:$global),
 720             "$dst=memh(#$global)",
 721             []>,
 722             Requires<[HasV4T]>;
 723
 724 // if (Pv) Rt=memh(##global)
 725 let neverHasSideEffects = 1, isPredicated = 1, isExtended = 1, opExtendable = 2,
 726 validSubTargets = HasV4SubT in {
 727 def LDh_GP_cPt_V4 : LDInst2<(outs IntRegs:$dst),
 728             (ins PredRegs:$src1, globaladdress:$global),
 729             "if ($src1) $dst=memh(##$global)",
 730             []>,
 731             Requires<[HasV4T]>;
 732
 733 // if (!Pv) Rt=memh(##global)
 734 def LDh_GP_cNotPt_V4 : LDInst2<(outs IntRegs:$dst),
 735             (ins PredRegs:$src1, globaladdress:$global),
 736             "if (!$src1) $dst=memh(##$global)",
 737             []>,
 738             Requires<[HasV4T]>;
 739
 740 // if (Pv) Rt=memh(##global)
 741 def LDh_GP_cdnPt_V4 : LDInst2<(outs IntRegs:$dst),
 742             (ins PredRegs:$src1, globaladdress:$global),
 743             "if ($src1.new) $dst=memh(##$global)",
 744             []>,
 745             Requires<[HasV4T]>;
 746
 747 // if (!Pv) Rt=memh(##global)
 748 def LDh_GP_cdnNotPt_V4 : LDInst2<(outs IntRegs:$dst),
 749             (ins PredRegs:$src1, globaladdress:$global),
 750             "if (!$src1.new) $dst=memh(##$global)",
 751             []>,
 752             Requires<[HasV4T]>;
 753 }
 754
 755 let isPredicable = 1, neverHasSideEffects = 1, validSubTargets = HasV4SubT in
 756 def LDuh_GP_V4 : LDInst2<(outs IntRegs:$dst),
 757             (ins globaladdress:$global),
 758             "$dst=memuh(#$global)",
 759             []>,
 760             Requires<[HasV4T]>;
 761
 762 // if (Pv) Rt=memuh(##global)
 763 let neverHasSideEffects = 1, isPredicated = 1, isExtended = 1, opExtendable = 2,
 764 validSubTargets = HasV4SubT in {
 765 def LDuh_GP_cPt_V4 : LDInst2<(outs IntRegs:$dst),
 766             (ins PredRegs:$src1, globaladdress:$global),
 767             "if ($src1) $dst=memuh(##$global)",
 768             []>,
 769             Requires<[HasV4T]>;
 770
 771 // if (!Pv) Rt=memuh(##global)
 772 def LDuh_GP_cNotPt_V4 : LDInst2<(outs IntRegs:$dst),
 773             (ins PredRegs:$src1, globaladdress:$global),
 774             "if (!$src1) $dst=memuh(##$global)",
 775             []>,
 776             Requires<[HasV4T]>;
 777
 778 // if (Pv) Rt=memuh(##global)
 779 def LDuh_GP_cdnPt_V4 : LDInst2<(outs IntRegs:$dst),
 780             (ins PredRegs:$src1, globaladdress:$global),
 781             "if ($src1.new) $dst=memuh(##$global)",
 782             []>,
 783             Requires<[HasV4T]>;
 784
 785 // if (!Pv) Rt=memuh(##global)
 786 def LDuh_GP_cdnNotPt_V4 : LDInst2<(outs IntRegs:$dst),
 787             (ins PredRegs:$src1, globaladdress:$global),
 788             "if (!$src1.new) $dst=memuh(##$global)",
 789             []>,
 790             Requires<[HasV4T]>;
 791 }
 792
 793 let isPredicable = 1, neverHasSideEffects = 1, validSubTargets = HasV4SubT in
 794 def LDw_GP_V4 : LDInst2<(outs IntRegs:$dst),
 795             (ins globaladdress:$global),
 796             "$dst=memw(#$global)",
 797             []>,
 798             Requires<[HasV4T]>;
 799
 800 // if (Pv) Rt=memw(##global)
 801 let neverHasSideEffects = 1, isPredicated = 1, isExtended = 1, opExtendable = 2,
 802 validSubTargets = HasV4SubT in {
 803 def LDw_GP_cPt_V4 : LDInst2<(outs IntRegs:$dst),
 804             (ins PredRegs:$src1, globaladdress:$global),
 805             "if ($src1) $dst=memw(##$global)",
 806             []>,
 807             Requires<[HasV4T]>;
 808
 809
 810 // if (!Pv) Rt=memw(##global)
 811 def LDw_GP_cNotPt_V4 : LDInst2<(outs IntRegs:$dst),
 812             (ins PredRegs:$src1, globaladdress:$global),
 813             "if (!$src1) $dst=memw(##$global)",
 814             []>,
 815             Requires<[HasV4T]>;
 816
 817 // if (Pv) Rt=memw(##global)
 818 def LDw_GP_cdnPt_V4 : LDInst2<(outs IntRegs:$dst),
 819             (ins PredRegs:$src1, globaladdress:$global),
 820             "if ($src1.new) $dst=memw(##$global)",
 821             []>,
 822             Requires<[HasV4T]>;
 823
 824
 825 // if (!Pv) Rt=memw(##global)
 826 def LDw_GP_cdnNotPt_V4 : LDInst2<(outs IntRegs:$dst),
 827             (ins PredRegs:$src1, globaladdress:$global),
 828             "if (!$src1.new) $dst=memw(##$global)",
 829             []>,
 830             Requires<[HasV4T]>;
 831 }
 832
 833
 834 def : Pat <(atomic_load_64 (HexagonCONST32_GP tglobaladdr:$global)),
 835            (i64 (LDd_GP_V4 tglobaladdr:$global))>,
 836             Requires<[HasV4T]>;
 837
 838 def : Pat <(atomic_load_32 (HexagonCONST32_GP tglobaladdr:$global)),
 839            (i32 (LDw_GP_V4 tglobaladdr:$global))>,
 840             Requires<[HasV4T]>;
 841
 842 def : Pat <(atomic_load_16 (HexagonCONST32_GP tglobaladdr:$global)),
 843            (i32 (LDuh_GP_V4 tglobaladdr:$global))>,
 844             Requires<[HasV4T]>;
 845
 846 def : Pat <(atomic_load_8 (HexagonCONST32_GP tglobaladdr:$global)),
 847            (i32 (LDub_GP_V4 tglobaladdr:$global))>,
 848             Requires<[HasV4T]>;
 849
 850 // Map from load(globaladdress) -> memw(#foo + 0)
 851 let AddedComplexity = 100 in
 852 def : Pat <(i64 (load (HexagonCONST32_GP tglobaladdr:$global))),
 853            (i64 (LDd_GP_V4 tglobaladdr:$global))>,
 854             Requires<[HasV4T]>;
 855
 856 // Map from Pd = load(globaladdress) -> Rd = memb(globaladdress), Pd = Rd
 857 let AddedComplexity = 100 in
 858 def : Pat <(i1 (load (HexagonCONST32_GP tglobaladdr:$global))),
 859            (i1 (TFR_PdRs (i32 (LDb_GP_V4 tglobaladdr:$global))))>,
 860            Requires<[HasV4T]>;
 861
 862 // When the Interprocedural Global Variable optimizer realizes that a certain
 863 // global variable takes only two constant values, it shrinks the global to
 864 // a boolean. Catch those loads here in the following 3 patterns.
 865 let AddedComplexity = 100 in
 866 def : Pat <(i32 (extloadi1 (HexagonCONST32_GP tglobaladdr:$global))),
 867            (i32 (LDb_GP_V4 tglobaladdr:$global))>,
 868             Requires<[HasV4T]>;
 869
 870 let AddedComplexity = 100 in
 871 def : Pat <(i32 (sextloadi1 (HexagonCONST32_GP tglobaladdr:$global))),
 872            (i32 (LDb_GP_V4 tglobaladdr:$global))>,
 873             Requires<[HasV4T]>;
 874
 875 // Map from load(globaladdress) -> memb(#foo)
 876 let AddedComplexity = 100 in
 877 def : Pat <(i32 (extloadi8 (HexagonCONST32_GP tglobaladdr:$global))),
 878            (i32 (LDb_GP_V4 tglobaladdr:$global))>,
 879             Requires<[HasV4T]>;
 880
 881 // Map from load(globaladdress) -> memb(#foo)
 882 let AddedComplexity = 100 in
 883 def : Pat <(i32 (sextloadi8 (HexagonCONST32_GP tglobaladdr:$global))),
 884            (i32 (LDb_GP_V4 tglobaladdr:$global))>,
 885             Requires<[HasV4T]>;
 886
 887 let AddedComplexity = 100 in
 888 def : Pat <(i32 (zextloadi1 (HexagonCONST32_GP tglobaladdr:$global))),
 889            (i32 (LDub_GP_V4 tglobaladdr:$global))>,
 890             Requires<[HasV4T]>;
 891
 892 // Map from load(globaladdress) -> memub(#foo)
 893 let AddedComplexity = 100 in
 894 def : Pat <(i32 (zextloadi8 (HexagonCONST32_GP tglobaladdr:$global))),
 895            (i32 (LDub_GP_V4 tglobaladdr:$global))>,
 896             Requires<[HasV4T]>;
 897
 898 // Map from load(globaladdress) -> memh(#foo)
 899 let AddedComplexity = 100 in
 900 def : Pat <(i32 (extloadi16 (HexagonCONST32_GP tglobaladdr:$global))),
 901            (i32 (LDh_GP_V4 tglobaladdr:$global))>,
 902             Requires<[HasV4T]>;
 903
 904 // Map from load(globaladdress) -> memh(#foo)
 905 let AddedComplexity = 100 in
 906 def : Pat <(i32 (sextloadi16 (HexagonCONST32_GP tglobaladdr:$global))),
 907            (i32 (LDh_GP_V4 tglobaladdr:$global))>,
 908             Requires<[HasV4T]>;
 909
 910 // Map from load(globaladdress) -> memuh(#foo)
 911 let AddedComplexity = 100 in
 912 def : Pat <(i32 (zextloadi16 (HexagonCONST32_GP tglobaladdr:$global))),
 913            (i32 (LDuh_GP_V4 tglobaladdr:$global))>,
 914             Requires<[HasV4T]>;
 915
 916 // Map from load(globaladdress) -> memw(#foo)
 917 let AddedComplexity = 100 in
 918 def : Pat <(i32 (load (HexagonCONST32_GP tglobaladdr:$global))),
 919            (i32 (LDw_GP_V4 tglobaladdr:$global))>,
 920             Requires<[HasV4T]>;
 921
 922 // zext i1->i64
 923 def : Pat <(i64 (zext (i1 PredRegs:$src1))),
 924       (i64 (COMBINE_Ir_V4 0, (MUX_ii (i1 PredRegs:$src1), 1, 0)))>,
 925       Requires<[HasV4T]>;
 926
 927 // zext i32->i64
 928 def : Pat <(i64 (zext (i32 IntRegs:$src1))),
 929       (i64 (COMBINE_Ir_V4 0, (i32 IntRegs:$src1)))>,
 930       Requires<[HasV4T]>;
 931 // zext i8->i64
 932 def:  Pat <(i64 (zextloadi8 ADDRriS11_0:$src1)),
 933       (i64 (COMBINE_Ir_V4 0, (LDriub ADDRriS11_0:$src1)))>,
 934       Requires<[HasV4T]>;
 935
 936 let AddedComplexity = 20 in
 937 def:  Pat <(i64 (zextloadi8 (add (i32 IntRegs:$src1),
 938                                 s11_0ExtPred:$offset))),
 939       (i64 (COMBINE_Ir_V4 0, (LDriub_indexed IntRegs:$src1,
 940                                   s11_0ExtPred:$offset)))>,
 941       Requires<[HasV4T]>;
 942
 943 // zext i16->i64
 944 def:  Pat <(i64 (zextloadi16 ADDRriS11_1:$src1)),
 945       (i64 (COMBINE_Ir_V4 0, (LDriuh ADDRriS11_1:$src1)))>,
 946       Requires<[HasV4T]>;
 947
 948 let AddedComplexity = 20 in
 949 def:  Pat <(i64 (zextloadi16 (add (i32 IntRegs:$src1),
 950                                   s11_1ExtPred:$offset))),
 951       (i64 (COMBINE_Ir_V4 0, (LDriuh_indexed IntRegs:$src1,
 952                                   s11_1ExtPred:$offset)))>,
 953       Requires<[HasV4T]>;
 954
 955 // anyext i16->i64
 956 def:  Pat <(i64 (extloadi16 ADDRriS11_2:$src1)),
 957       (i64 (COMBINE_Ir_V4 0, (LDrih ADDRriS11_2:$src1)))>,
 958       Requires<[HasV4T]>;
 959
 960 let AddedComplexity = 20 in
 961 def:  Pat <(i64 (extloadi16 (add (i32 IntRegs:$src1),
 962                                   s11_1ExtPred:$offset))),
 963       (i64 (COMBINE_Ir_V4 0, (LDrih_indexed IntRegs:$src1,
 964                                   s11_1ExtPred:$offset)))>,
 965       Requires<[HasV4T]>;
 966
 967 // zext i32->i64
 968 def:  Pat <(i64 (zextloadi32 ADDRriS11_2:$src1)),
 969       (i64 (COMBINE_Ir_V4 0, (LDriw ADDRriS11_2:$src1)))>,
 970       Requires<[HasV4T]>;
 971
 972 let AddedComplexity = 100 in
 973 def:  Pat <(i64 (zextloadi32 (i32 (add IntRegs:$src1, s11_2ExtPred:$offset)))),
 974       (i64 (COMBINE_Ir_V4 0, (LDriw_indexed IntRegs:$src1,
 975                                   s11_2ExtPred:$offset)))>,
 976       Requires<[HasV4T]>;
 977
 978 // anyext i32->i64
 979 def:  Pat <(i64 (extloadi32 ADDRriS11_2:$src1)),
 980       (i64 (COMBINE_Ir_V4 0, (LDriw ADDRriS11_2:$src1)))>,
 981       Requires<[HasV4T]>;
 982
 983 let AddedComplexity = 100 in
 984 def:  Pat <(i64 (extloadi32 (i32 (add IntRegs:$src1, s11_2ExtPred:$offset)))),
 985       (i64 (COMBINE_Ir_V4 0, (LDriw_indexed IntRegs:$src1,
 986                                   s11_2ExtPred:$offset)))>,
 987       Requires<[HasV4T]>;
 988
 989
 990
 991 //===----------------------------------------------------------------------===//
 992 // LD -
 993 //===----------------------------------------------------------------------===//
 994
 995 //===----------------------------------------------------------------------===//
 996 // ST +
 997 //===----------------------------------------------------------------------===//
 998 ///
 999 /// Assumptions::: ****** DO NOT IGNORE ********
1000 /// 1. Make sure that in post increment store, the zero'th operand is always the
1001 ///    post increment operand.
1002 /// 2. Make sure that the store value operand(Rt/Rtt) in a store is always the
1003 ///    last operand.
1004 ///
1005
1006 // memd(Re=#U)=Rtt
1007 let isExtended = 1, opExtendable = 2, validSubTargets = HasV4SubT in {
1008 def STrid_abs_setimm_V4 : STInst2<(outs IntRegs:$dst1),
1009             (ins DoubleRegs:$src1, u0AlwaysExt:$src2),
1010             "memd($dst1=##$src2) = $src1",
1011             []>,
1012             Requires<[HasV4T]>;
1013
1014 // memb(Re=#U)=Rs
1015 def STrib_abs_setimm_V4 : STInst2<(outs IntRegs:$dst1),
1016             (ins IntRegs:$src1, u0AlwaysExt:$src2),
1017             "memb($dst1=##$src2) = $src1",
1018             []>,
1019             Requires<[HasV4T]>;
1020
1021 // memh(Re=#U)=Rs
1022 def STrih_abs_setimm_V4 : STInst2<(outs IntRegs:$dst1),
1023             (ins IntRegs:$src1, u0AlwaysExt:$src2),
1024             "memh($dst1=##$src2) = $src1",
1025             []>,
1026             Requires<[HasV4T]>;
1027
1028 // memw(Re=#U)=Rs
1029 def STriw_abs_setimm_V4 : STInst2<(outs IntRegs:$dst1),
1030             (ins IntRegs:$src1, u0AlwaysExt:$src2),
1031             "memw($dst1=##$src2) = $src1",
1032             []>,
1033             Requires<[HasV4T]>;
1034 }
1035
1036 // memd(Re=#U)=Rtt
1037 let isExtended = 1, opExtendable = 2, validSubTargets = HasV4SubT in {
1038 def STrid_abs_set_V4 : STInst2<(outs IntRegs:$dst1),
1039             (ins DoubleRegs:$src1, globaladdressExt:$src2),
1040             "memd($dst1=##$src2) = $src1",
1041             []>,
1042             Requires<[HasV4T]>;
1043
1044 // memb(Re=#U)=Rs
1045 def STrib_abs_set_V4 : STInst2<(outs IntRegs:$dst1),
1046             (ins IntRegs:$src1, globaladdressExt:$src2),
1047             "memb($dst1=##$src2) = $src1",
1048             []>,
1049             Requires<[HasV4T]>;
1050
1051 // memh(Re=#U)=Rs
1052 def STrih_abs_set_V4 : STInst2<(outs IntRegs:$dst1),
1053             (ins IntRegs:$src1, globaladdressExt:$src2),
1054             "memh($dst1=##$src2) = $src1",
1055             []>,
1056             Requires<[HasV4T]>;
1057
1058 // memw(Re=#U)=Rs
1059 def STriw_abs_set_V4 : STInst2<(outs IntRegs:$dst1),
1060             (ins IntRegs:$src1, globaladdressExt:$src2),
1061             "memw($dst1=##$src2) = $src1",
1062             []>,
1063             Requires<[HasV4T]>;
1064 }
1065
1066 // multiclass for store instructions with base + register offset addressing
1067 // mode
1068 multiclass ST_Idxd_shl_Pbase<string mnemonic, RegisterClass RC, bit isNot,
1069                              bit isPredNew> {
1070   let PNewValue = !if(isPredNew, "new", "") in
1071   def NAME : STInst2<(outs),
1072             (ins PredRegs:$src1, IntRegs:$src2, IntRegs:$src3, u2Imm:$src4,
1073                  RC:$src5),
1074             !if(isNot, "if (!$src1", "if ($src1")#!if(isPredNew, ".new) ",
1075             ") ")#mnemonic#"($src2+$src3<<#$src4) = $src5",
1076             []>,
1077             Requires<[HasV4T]>;
1078 }
1079
1080 multiclass ST_Idxd_shl_Pred<string mnemonic, RegisterClass RC, bit PredNot> {
1081   let PredSense = !if(PredNot, "false", "true") in {
1082     defm _c#NAME : ST_Idxd_shl_Pbase<mnemonic, RC, PredNot, 0>;
1083     // Predicate new
1084     defm _cdn#NAME : ST_Idxd_shl_Pbase<mnemonic, RC, PredNot, 1>;
1085   }
1086 }
1087
1088 let isNVStorable = 1 in
1089 multiclass ST_Idxd_shl<string mnemonic, string CextOp, RegisterClass RC> {
1090   let CextOpcode = CextOp, BaseOpcode = CextOp#_indexed_shl in {
1091     let isPredicable = 1 in
1092     def NAME#_V4 : STInst2<(outs),
1093             (ins IntRegs:$src1, IntRegs:$src2, u2Imm:$src3, RC:$src4),
1094             mnemonic#"($src1+$src2<<#$src3) = $src4",
1095             []>,
1096             Requires<[HasV4T]>;
1097
1098     let isPredicated = 1 in {
1099       defm Pt_V4 : ST_Idxd_shl_Pred<mnemonic, RC, 0 >;
1100       defm NotPt_V4 : ST_Idxd_shl_Pred<mnemonic, RC, 1>;
1101     }
1102   }
1103 }
1104
1105 // multiclass for new-value store instructions with base + register offset
1106 // addressing mode.
1107 multiclass ST_Idxd_shl_Pbase_nv<string mnemonic, RegisterClass RC, bit isNot,
1108                              bit isPredNew> {
1109   let PNewValue = !if(isPredNew, "new", "") in
1110   def NAME#_nv_V4 : NVInst_V4<(outs),
1111             (ins PredRegs:$src1, IntRegs:$src2, IntRegs:$src3, u2Imm:$src4,
1112                  RC:$src5),
1113             !if(isNot, "if (!$src1", "if ($src1")#!if(isPredNew, ".new) ",
1114             ") ")#mnemonic#"($src2+$src3<<#$src4) = $src5.new",
1115             []>,
1116             Requires<[HasV4T]>;
1117 }
1118
1119 multiclass ST_Idxd_shl_Pred_nv<string mnemonic, RegisterClass RC, bit PredNot> {
1120   let PredSense = !if(PredNot, "false", "true") in {
1121     defm _c#NAME : ST_Idxd_shl_Pbase_nv<mnemonic, RC, PredNot, 0>;
1122     // Predicate new
1123     defm _cdn#NAME : ST_Idxd_shl_Pbase_nv<mnemonic, RC, PredNot, 1>;
1124   }
1125 }
1126
1127 let mayStore = 1, isNVStore = 1 in
1128 multiclass ST_Idxd_shl_nv<string mnemonic, string CextOp, RegisterClass RC> {
1129   let CextOpcode = CextOp, BaseOpcode = CextOp#_indexed_shl in {
1130     let isPredicable = 1 in
1131     def NAME#_nv_V4 : NVInst_V4<(outs),
1132             (ins IntRegs:$src1, IntRegs:$src2, u2Imm:$src3, RC:$src4),
1133             mnemonic#"($src1+$src2<<#$src3) = $src4.new",
1134             []>,
1135             Requires<[HasV4T]>;
1136
1137     let isPredicated = 1 in {
1138       defm Pt : ST_Idxd_shl_Pred_nv<mnemonic, RC, 0 >;
1139       defm NotPt : ST_Idxd_shl_Pred_nv<mnemonic, RC, 1>;
1140     }
1141   }
1142 }
1143
1144 let addrMode = BaseRegOffset, neverHasSideEffects = 1,
1145 validSubTargets = HasV4SubT in {
1146   defm STrib_indexed_shl: ST_Idxd_shl<"memb", "STrib", IntRegs>,
1147                           ST_Idxd_shl_nv<"memb", "STrib", IntRegs>, AddrModeRel;
1148
1149   defm STrih_indexed_shl: ST_Idxd_shl<"memh", "STrih", IntRegs>,
1150                           ST_Idxd_shl_nv<"memh", "STrih", IntRegs>, AddrModeRel;
1151
1152   defm STriw_indexed_shl: ST_Idxd_shl<"memw", "STriw", IntRegs>,
1153                           ST_Idxd_shl_nv<"memw", "STriw", IntRegs>, AddrModeRel;
1154
1155   let isNVStorable = 0 in
1156   defm STrid_indexed_shl: ST_Idxd_shl<"memd", "STrid", DoubleRegs>, AddrModeRel;
1157 }
1158
1159 let Predicates = [HasV4T], AddedComplexity = 10 in {
1160 def : Pat<(truncstorei8 (i32 IntRegs:$src4),
1161                        (add IntRegs:$src1, (shl IntRegs:$src2,
1162                                                 u2ImmPred:$src3))),
1163           (STrib_indexed_shl_V4 IntRegs:$src1, IntRegs:$src2,
1164                                 u2ImmPred:$src3, IntRegs:$src4)>;
1165
1166 def : Pat<(truncstorei16 (i32 IntRegs:$src4),
1167                         (add IntRegs:$src1, (shl IntRegs:$src2,
1168                                                  u2ImmPred:$src3))),
1169           (STrih_indexed_shl_V4 IntRegs:$src1, IntRegs:$src2,
1170                                 u2ImmPred:$src3, IntRegs:$src4)>;
1171
1172 def : Pat<(store (i32 IntRegs:$src4),
1173                  (add IntRegs:$src1, (shl IntRegs:$src2, u2ImmPred:$src3))),
1174           (STriw_indexed_shl_V4 IntRegs:$src1, IntRegs:$src2,
1175                                 u2ImmPred:$src3, IntRegs:$src4)>;
1176
1177 def : Pat<(store (i64 DoubleRegs:$src4),
1178                 (add IntRegs:$src1, (shl IntRegs:$src2, u2ImmPred:$src3))),
1179           (STrid_indexed_shl_V4 IntRegs:$src1, IntRegs:$src2,
1180                                 u2ImmPred:$src3, DoubleRegs:$src4)>;
1181 }
1182
1183 // memd(Ru<<#u2+#U6)=Rtt
1184 let isExtended = 1, opExtendable = 2, AddedComplexity = 10,
1185 validSubTargets = HasV4SubT in
1186 def STrid_shl_V4 : STInst<(outs),
1187             (ins IntRegs:$src1, u2Imm:$src2, u0AlwaysExt:$src3, DoubleRegs:$src4),
1188             "memd($src1<<#$src2+#$src3) = $src4",
1189             [(store (i64 DoubleRegs:$src4),
1190                     (add (shl (i32 IntRegs:$src1), u2ImmPred:$src2),
1191                          u0AlwaysExtPred:$src3))]>,
1192             Requires<[HasV4T]>;
1193
1194 // memd(Rx++#s4:3)=Rtt
1195 // memd(Rx++#s4:3:circ(Mu))=Rtt
1196 // memd(Rx++I:circ(Mu))=Rtt
1197 // memd(Rx++Mu)=Rtt
1198 // memd(Rx++Mu:brev)=Rtt
1199 // memd(gp+#u16:3)=Rtt
1200
1201 // Store doubleword conditionally.
1202 // if ([!]Pv[.new]) memd(#u6)=Rtt
1203 // TODO: needs to be implemented.
1204
1205 //===----------------------------------------------------------------------===//
1206 // multiclass for store instructions with base + immediate offset
1207 // addressing mode and immediate stored value.
1208 // mem[bhw](Rx++#s4:3)=#s8
1209 // if ([!]Pv[.new]) mem[bhw](Rx++#s4:3)=#s6
1210 //===----------------------------------------------------------------------===//
1211 multiclass ST_Imm_Pbase<string mnemonic, Operand OffsetOp, bit isNot,
1212                         bit isPredNew> {
1213   let PNewValue = !if(isPredNew, "new", "") in
1214   def NAME : STInst2<(outs),
1215             (ins PredRegs:$src1, IntRegs:$src2, OffsetOp:$src3, s6Ext:$src4),
1216             !if(isNot, "if (!$src1", "if ($src1")#!if(isPredNew, ".new) ",
1217             ") ")#mnemonic#"($src2+#$src3) = #$src4",
1218             []>,
1219             Requires<[HasV4T]>;
1220 }
1221
1222 multiclass ST_Imm_Pred<string mnemonic, Operand OffsetOp, bit PredNot> {
1223   let PredSense = !if(PredNot, "false", "true") in {
1224     defm _c#NAME : ST_Imm_Pbase<mnemonic, OffsetOp, PredNot, 0>;
1225     // Predicate new
1226     defm _cdn#NAME : ST_Imm_Pbase<mnemonic, OffsetOp, PredNot, 1>;
1227   }
1228 }
1229
1230 let isExtendable = 1, isExtentSigned = 1, neverHasSideEffects = 1 in
1231 multiclass ST_Imm<string mnemonic, string CextOp, Operand OffsetOp> {
1232   let CextOpcode = CextOp, BaseOpcode = CextOp#_imm in {
1233     let opExtendable = 2, opExtentBits = 8, isPredicable = 1 in
1234     def NAME#_V4 : STInst2<(outs),
1235             (ins IntRegs:$src1, OffsetOp:$src2, s8Ext:$src3),
1236             mnemonic#"($src1+#$src2) = #$src3",
1237             []>,
1238             Requires<[HasV4T]>;
1239
1240     let opExtendable = 3, opExtentBits = 6, isPredicated = 1 in {
1241       defm Pt_V4 : ST_Imm_Pred<mnemonic, OffsetOp, 0>;
1242       defm NotPt_V4 : ST_Imm_Pred<mnemonic, OffsetOp, 1 >;
1243     }
1244   }
1245 }
1246
1247 let addrMode = BaseImmOffset, InputType = "imm",
1248     validSubTargets = HasV4SubT in {
1249   defm STrib_imm : ST_Imm<"memb", "STrib", u6_0Imm>, ImmRegRel, PredNewRel;
1250   defm STrih_imm : ST_Imm<"memh", "STrih", u6_1Imm>, ImmRegRel, PredNewRel;
1251   defm STriw_imm : ST_Imm<"memw", "STriw", u6_2Imm>, ImmRegRel, PredNewRel;
1252 }
1253
1254 let Predicates = [HasV4T], AddedComplexity = 10 in {
1255 def: Pat<(truncstorei8 s8ExtPred:$src3, (add IntRegs:$src1, u6_0ImmPred:$src2)),
1256             (STrib_imm_V4 IntRegs:$src1, u6_0ImmPred:$src2, s8ExtPred:$src3)>;
1257
1258 def: Pat<(truncstorei16 s8ExtPred:$src3, (add IntRegs:$src1,
1259                                               u6_1ImmPred:$src2)),
1260             (STrih_imm_V4 IntRegs:$src1, u6_1ImmPred:$src2, s8ExtPred:$src3)>;
1261
1262 def: Pat<(store s8ExtPred:$src3, (add IntRegs:$src1, u6_2ImmPred:$src2)),
1263             (STriw_imm_V4 IntRegs:$src1, u6_2ImmPred:$src2, s8ExtPred:$src3)>;
1264 }
1265
1266 let AddedComplexity = 6 in
1267 def : Pat <(truncstorei8 s8ExtPred:$src2, (i32 IntRegs:$src1)),
1268            (STrib_imm_V4 IntRegs:$src1, 0, s8ExtPred:$src2)>,
1269            Requires<[HasV4T]>;
1270
1271 // memb(Ru<<#u2+#U6)=Rt
1272 let isExtended = 1, opExtendable = 2, AddedComplexity = 10, isNVStorable = 1,
1273 validSubTargets = HasV4SubT in
1274 def STrib_shl_V4 : STInst<(outs),
1275             (ins IntRegs:$src1, u2Imm:$src2, u0AlwaysExt:$src3, IntRegs:$src4),
1276             "memb($src1<<#$src2+#$src3) = $src4",
1277             [(truncstorei8 (i32 IntRegs:$src4),
1278                            (add (shl (i32 IntRegs:$src1), u2ImmPred:$src2),
1279                                 u0AlwaysExtPred:$src3))]>,
1280             Requires<[HasV4T]>;
1281
1282 // memb(Rx++#s4:0:circ(Mu))=Rt
1283 // memb(Rx++I:circ(Mu))=Rt
1284 // memb(Rx++Mu)=Rt
1285 // memb(Rx++Mu:brev)=Rt
1286 // memb(gp+#u16:0)=Rt
1287
1288
1289 // Store halfword.
1290 // TODO: needs to be implemented
1291 // memh(Re=#U6)=Rt.H
1292 // memh(Rs+#s11:1)=Rt.H
1293 let AddedComplexity = 6 in
1294 def : Pat <(truncstorei16 s8ExtPred:$src2, (i32 IntRegs:$src1)),
1295            (STrih_imm_V4 IntRegs:$src1, 0, s8ExtPred:$src2)>,
1296            Requires<[HasV4T]>;
1297
1298 // memh(Rs+Ru<<#u2)=Rt.H
1299 // TODO: needs to be implemented.
1300
1301 // memh(Ru<<#u2+#U6)=Rt.H
1302 // memh(Ru<<#u2+#U6)=Rt
1303 let isExtended = 1, opExtendable = 2, AddedComplexity = 10, isNVStorable = 1,
1304 validSubTargets = HasV4SubT in
1305 def STrih_shl_V4 : STInst<(outs),
1306             (ins IntRegs:$src1, u2Imm:$src2, u0AlwaysExt:$src3, IntRegs:$src4),
1307             "memh($src1<<#$src2+#$src3) = $src4",
1308             [(truncstorei16 (i32 IntRegs:$src4),
1309                             (add (shl (i32 IntRegs:$src1), u2ImmPred:$src2),
1310                                  u0AlwaysExtPred:$src3))]>,
1311             Requires<[HasV4T]>;
1312
1313 // memh(Rx++#s4:1:circ(Mu))=Rt.H
1314 // memh(Rx++#s4:1:circ(Mu))=Rt
1315 // memh(Rx++I:circ(Mu))=Rt.H
1316 // memh(Rx++I:circ(Mu))=Rt
1317 // memh(Rx++Mu)=Rt.H
1318 // memh(Rx++Mu)=Rt
1319 // memh(Rx++Mu:brev)=Rt.H
1320 // memh(Rx++Mu:brev)=Rt
1321 // memh(gp+#u16:1)=Rt
1322 // if ([!]Pv[.new]) memh(#u6)=Rt.H
1323 // if ([!]Pv[.new]) memh(#u6)=Rt
1324
1325
1326 // if ([!]Pv[.new]) memh(Rs+#u6:1)=Rt.H
1327 // TODO: needs to be implemented.
1328
1329 // if ([!]Pv[.new]) memh(Rx++#s4:1)=Rt.H
1330 // TODO: Needs to be implemented.
1331
1332 // Store word.
1333 // memw(Re=#U6)=Rt
1334 // TODO: Needs to be implemented.
1335
1336 // Store predicate:
1337 let neverHasSideEffects = 1 in
1338 def STriw_pred_V4 : STInst2<(outs),
1339             (ins MEMri:$addr, PredRegs:$src1),
1340             "Error; should not emit",
1341             []>,
1342             Requires<[HasV4T]>;
1343
1344 let AddedComplexity = 6 in
1345 def : Pat <(store s8ExtPred:$src2, (i32 IntRegs:$src1)),
1346            (STriw_imm_V4 IntRegs:$src1, 0, s8ExtPred:$src2)>,
1347            Requires<[HasV4T]>;
1348
1349 // memw(Ru<<#u2+#U6)=Rt
1350 let isExtended = 1, opExtendable = 2, AddedComplexity = 10, isNVStorable = 1,
1351 validSubTargets = HasV4SubT in
1352 def STriw_shl_V4 : STInst<(outs),
1353             (ins IntRegs:$src1, u2Imm:$src2, u0AlwaysExt:$src3, IntRegs:$src4),
1354             "memw($src1<<#$src2+#$src3) = $src4",
1355             [(store (i32 IntRegs:$src4),
1356                     (add (shl (i32 IntRegs:$src1), u2ImmPred:$src2),
1357                               u0AlwaysExtPred:$src3))]>,
1358             Requires<[HasV4T]>;
1359
1360 // memw(Rx++#s4:2)=Rt
1361 // memw(Rx++#s4:2:circ(Mu))=Rt
1362 // memw(Rx++I:circ(Mu))=Rt
1363 // memw(Rx++Mu)=Rt
1364 // memw(Rx++Mu:brev)=Rt
1365 // memw(gp+#u16:2)=Rt
1366
1367
1368 // memd(#global)=Rtt
1369 let isPredicable = 1, mayStore = 1, neverHasSideEffects = 1,
1370 validSubTargets = HasV4SubT in
1371 def STd_GP_V4 : STInst2<(outs),
1372             (ins globaladdress:$global, DoubleRegs:$src),
1373             "memd(#$global) = $src",
1374             []>,
1375             Requires<[HasV4T]>;
1376
1377 // if (Pv) memd(##global) = Rtt
1378 let mayStore = 1, neverHasSideEffects = 1, isPredicated = 1,
1379 isExtended = 1, opExtendable = 1, validSubTargets = HasV4SubT in {
1380 def STd_GP_cPt_V4 : STInst2<(outs),
1381             (ins PredRegs:$src1, globaladdress:$global, DoubleRegs:$src2),
1382             "if ($src1) memd(##$global) = $src2",
1383             []>,
1384             Requires<[HasV4T]>;
1385
1386 // if (!Pv) memd(##global) = Rtt
1387 def STd_GP_cNotPt_V4 : STInst2<(outs),
1388             (ins PredRegs:$src1, globaladdress:$global, DoubleRegs:$src2),
1389             "if (!$src1) memd(##$global) = $src2",
1390             []>,
1391               Requires<[HasV4T]>;
1392
1393 // if (Pv) memd(##global) = Rtt
1394 def STd_GP_cdnPt_V4 : STInst2<(outs),
1395             (ins PredRegs:$src1, globaladdress:$global, DoubleRegs:$src2),
1396             "if ($src1.new) memd(##$global) = $src2",
1397             []>,
1398               Requires<[HasV4T]>;
1399
1400 // if (!Pv) memd(##global) = Rtt
1401 def STd_GP_cdnNotPt_V4 : STInst2<(outs),
1402             (ins PredRegs:$src1, globaladdress:$global, DoubleRegs:$src2),
1403             "if (!$src1.new) memd(##$global) = $src2",
1404             []>,
1405             Requires<[HasV4T]>;
1406 }
1407
1408 // memb(#global)=Rt
1409 let isPredicable = 1, neverHasSideEffects = 1, isNVStorable = 1,
1410 validSubTargets = HasV4SubT in
1411 def STb_GP_V4 : STInst2<(outs),
1412             (ins globaladdress:$global, IntRegs:$src),
1413             "memb(#$global) = $src",
1414             []>,
1415             Requires<[HasV4T]>;
1416
1417 // if (Pv) memb(##global) = Rt
1418 let neverHasSideEffects = 1, isPredicated = 1, isNVStorable = 1,
1419 isExtended = 1, opExtendable = 1, validSubTargets = HasV4SubT in {
1420 def STb_GP_cPt_V4 : STInst2<(outs),
1421             (ins PredRegs:$src1, globaladdress:$global, IntRegs:$src2),
1422             "if ($src1) memb(##$global) = $src2",
1423               []>,
1424               Requires<[HasV4T]>;
1425
1426 // if (!Pv) memb(##global) = Rt
1427 def STb_GP_cNotPt_V4 : STInst2<(outs),
1428             (ins PredRegs:$src1, globaladdress:$global, IntRegs:$src2),
1429             "if (!$src1) memb(##$global) = $src2",
1430               []>,
1431               Requires<[HasV4T]>;
1432
1433 // if (Pv) memb(##global) = Rt
1434 def STb_GP_cdnPt_V4 : STInst2<(outs),
1435             (ins PredRegs:$src1, globaladdress:$global, IntRegs:$src2),
1436             "if ($src1.new) memb(##$global) = $src2",
1437               []>,
1438               Requires<[HasV4T]>;
1439
1440 // if (!Pv) memb(##global) = Rt
1441 def STb_GP_cdnNotPt_V4 : STInst2<(outs),
1442             (ins PredRegs:$src1, globaladdress:$global, IntRegs:$src2),
1443             "if (!$src1.new) memb(##$global) = $src2",
1444               []>,
1445               Requires<[HasV4T]>;
1446 }
1447
1448 // memh(#global)=Rt
1449 let isPredicable = 1, neverHasSideEffects = 1, isNVStorable = 1,
1450 validSubTargets = HasV4SubT in
1451 def STh_GP_V4 : STInst2<(outs),
1452             (ins globaladdress:$global, IntRegs:$src),
1453             "memh(#$global) = $src",
1454             []>,
1455             Requires<[HasV4T]>;
1456
1457 // if (Pv) memh(##global) = Rt
1458 let neverHasSideEffects = 1, isPredicated = 1, isNVStorable = 1,
1459 isExtended = 1, opExtendable = 1, validSubTargets = HasV4SubT in {
1460 def STh_GP_cPt_V4 : STInst2<(outs),
1461             (ins PredRegs:$src1, globaladdress:$global, IntRegs:$src2),
1462             "if ($src1) memh(##$global) = $src2",
1463               []>,
1464               Requires<[HasV4T]>;
1465
1466 // if (!Pv) memh(##global) = Rt
1467 def STh_GP_cNotPt_V4 : STInst2<(outs),
1468             (ins PredRegs:$src1, globaladdress:$global, IntRegs:$src2),
1469             "if (!$src1) memh(##$global) = $src2",
1470               []>,
1471               Requires<[HasV4T]>;
1472
1473 // if (Pv) memh(##global) = Rt
1474 def STh_GP_cdnPt_V4 : STInst2<(outs),
1475             (ins PredRegs:$src1, globaladdress:$global, IntRegs:$src2),
1476             "if ($src1.new) memh(##$global) = $src2",
1477               []>,
1478               Requires<[HasV4T]>;
1479
1480 // if (!Pv) memh(##global) = Rt
1481 def STh_GP_cdnNotPt_V4 : STInst2<(outs),
1482             (ins PredRegs:$src1, globaladdress:$global, IntRegs:$src2),
1483             "if (!$src1.new) memh(##$global) = $src2",
1484               []>,
1485               Requires<[HasV4T]>;
1486 }
1487
1488 // memw(#global)=Rt
1489 let isPredicable = 1, neverHasSideEffects = 1, isNVStorable = 1,
1490 validSubTargets = HasV4SubT in
1491 def STw_GP_V4 : STInst2<(outs),
1492             (ins globaladdress:$global, IntRegs:$src),
1493             "memw(#$global) = $src",
1494               []>,
1495               Requires<[HasV4T]>;
1496
1497 // if (Pv) memw(##global) = Rt
1498 let neverHasSideEffects = 1, isPredicated = 1, isNVStorable = 1,
1499 isExtended = 1, opExtendable = 1, validSubTargets = HasV4SubT in {
1500 def STw_GP_cPt_V4 : STInst2<(outs),
1501             (ins PredRegs:$src1, globaladdress:$global, IntRegs:$src2),
1502             "if ($src1) memw(##$global) = $src2",
1503               []>,
1504               Requires<[HasV4T]>;
1505
1506 // if (!Pv) memw(##global) = Rt
1507 def STw_GP_cNotPt_V4 : STInst2<(outs),
1508             (ins PredRegs:$src1, globaladdress:$global, IntRegs:$src2),
1509             "if (!$src1) memw(##$global) = $src2",
1510               []>,
1511               Requires<[HasV4T]>;
1512
1513 // if (Pv) memw(##global) = Rt
1514 def STw_GP_cdnPt_V4 : STInst2<(outs),
1515             (ins PredRegs:$src1, globaladdress:$global, IntRegs:$src2),
1516             "if ($src1.new) memw(##$global) = $src2",
1517               []>,
1518               Requires<[HasV4T]>;
1519
1520 // if (!Pv) memw(##global) = Rt
1521 def STw_GP_cdnNotPt_V4 : STInst2<(outs),
1522             (ins PredRegs:$src1, globaladdress:$global, IntRegs:$src2),
1523             "if (!$src1.new) memw(##$global) = $src2",
1524             []>,
1525               Requires<[HasV4T]>;
1526 }
1527
1528 // 64 bit atomic store
1529 def : Pat <(atomic_store_64 (HexagonCONST32_GP tglobaladdr:$global),
1530                             (i64 DoubleRegs:$src1)),
1531            (STd_GP_V4 tglobaladdr:$global, (i64 DoubleRegs:$src1))>,
1532            Requires<[HasV4T]>;
1533
1534 // Map from store(globaladdress) -> memd(#foo)
1535 let AddedComplexity = 100 in
1536 def : Pat <(store (i64 DoubleRegs:$src1),
1537                   (HexagonCONST32_GP tglobaladdr:$global)),
1538            (STd_GP_V4 tglobaladdr:$global, (i64 DoubleRegs:$src1))>,
1539            Requires<[HasV4T]>;
1540
1541 // 8 bit atomic store
1542 def : Pat < (atomic_store_8 (HexagonCONST32_GP tglobaladdr:$global),
1543                             (i32 IntRegs:$src1)),
1544             (STb_GP_V4 tglobaladdr:$global, (i32 IntRegs:$src1))>,
1545               Requires<[HasV4T]>;
1546
1547 // Map from store(globaladdress) -> memb(#foo)
1548 let AddedComplexity = 100 in
1549 def : Pat<(truncstorei8 (i32 IntRegs:$src1),
1550           (HexagonCONST32_GP tglobaladdr:$global)),
1551           (STb_GP_V4 tglobaladdr:$global, (i32 IntRegs:$src1))>,
1552           Requires<[HasV4T]>;
1553
1554 // Map from "i1 = constant<-1>; memw(CONST32(#foo)) = i1"
1555 //       to "r0 = 1; memw(#foo) = r0"
1556 let AddedComplexity = 100 in
1557 def : Pat<(store (i1 -1), (HexagonCONST32_GP tglobaladdr:$global)),
1558           (STb_GP_V4 tglobaladdr:$global, (TFRI 1))>,
1559           Requires<[HasV4T]>;
1560
1561 def : Pat<(atomic_store_16 (HexagonCONST32_GP tglobaladdr:$global),
1562                            (i32 IntRegs:$src1)),
1563           (STh_GP_V4 tglobaladdr:$global, (i32 IntRegs:$src1))>,
1564           Requires<[HasV4T]>;
1565
1566 // Map from store(globaladdress) -> memh(#foo)
1567 let AddedComplexity = 100 in
1568 def : Pat<(truncstorei16 (i32 IntRegs:$src1),
1569                          (HexagonCONST32_GP tglobaladdr:$global)),
1570           (STh_GP_V4 tglobaladdr:$global, (i32 IntRegs:$src1))>,
1571           Requires<[HasV4T]>;
1572
1573 // 32 bit atomic store
1574 def : Pat<(atomic_store_32 (HexagonCONST32_GP tglobaladdr:$global),
1575                            (i32 IntRegs:$src1)),
1576           (STw_GP_V4 tglobaladdr:$global, (i32 IntRegs:$src1))>,
1577           Requires<[HasV4T]>;
1578
1579 // Map from store(globaladdress) -> memw(#foo)
1580 let AddedComplexity = 100 in
1581 def : Pat<(store (i32 IntRegs:$src1), (HexagonCONST32_GP tglobaladdr:$global)),
1582           (STw_GP_V4 tglobaladdr:$global, (i32 IntRegs:$src1))>,
1583           Requires<[HasV4T]>;
1584
1585 //===----------------------------------------------------------------------===
1586 // ST -
1587 //===----------------------------------------------------------------------===
1588
1589
1590 //===----------------------------------------------------------------------===//
1591 // NV/ST +
1592 //===----------------------------------------------------------------------===//
1593
1594 // multiclass for new-value store instructions with base + immediate offset.
1595 //
1596 multiclass ST_Idxd_Pbase_nv<string mnemonic, RegisterClass RC,
1597                             Operand predImmOp, bit isNot, bit isPredNew> {
1598   let PNewValue = !if(isPredNew, "new", "") in
1599   def NAME#_nv_V4 : NVInst_V4<(outs),
1600             (ins PredRegs:$src1, IntRegs:$src2, predImmOp:$src3, RC: $src4),
1601             !if(isNot, "if (!$src1", "if ($src1")#!if(isPredNew, ".new) ",
1602             ") ")#mnemonic#"($src2+#$src3) = $src4.new",
1603             []>,
1604             Requires<[HasV4T]>;
1605 }
1606
1607 multiclass ST_Idxd_Pred_nv<string mnemonic, RegisterClass RC, Operand predImmOp,
1608                            bit PredNot> {
1609   let PredSense = !if(PredNot, "false", "true") in {
1610     defm _c#NAME : ST_Idxd_Pbase_nv<mnemonic, RC, predImmOp, PredNot, 0>;
1611     // Predicate new
1612     defm _cdn#NAME : ST_Idxd_Pbase_nv<mnemonic, RC, predImmOp, PredNot, 1>;
1613   }
1614 }
1615
1616 let mayStore = 1, isNVStore = 1, neverHasSideEffects = 1, isExtendable = 1 in
1617 multiclass ST_Idxd_nv<string mnemonic, string CextOp, RegisterClass RC,
1618                    Operand ImmOp, Operand predImmOp, bits<5> ImmBits,
1619                    bits<5> PredImmBits> {
1620
1621   let CextOpcode = CextOp, BaseOpcode = CextOp#_indexed in {
1622     let opExtendable = 1, isExtentSigned = 1, opExtentBits = ImmBits,
1623     isPredicable = 1 in
1624     def NAME#_nv_V4 : NVInst_V4<(outs),
1625             (ins IntRegs:$src1, ImmOp:$src2, RC:$src3),
1626             mnemonic#"($src1+#$src2) = $src3.new",
1627             []>,
1628             Requires<[HasV4T]>;
1629
1630     let opExtendable = 2, isExtentSigned = 0, opExtentBits = PredImmBits,
1631     isPredicated = 1 in {
1632       defm Pt : ST_Idxd_Pred_nv<mnemonic, RC, predImmOp, 0>;
1633       defm NotPt : ST_Idxd_Pred_nv<mnemonic, RC, predImmOp, 1>;
1634     }
1635   }
1636 }
1637
1638 let addrMode = BaseImmOffset, validSubTargets = HasV4SubT in {
1639   defm STrib_indexed: ST_Idxd_nv<"memb", "STrib", IntRegs, s11_0Ext,
1640                                  u6_0Ext, 11, 6>, AddrModeRel;
1641   defm STrih_indexed: ST_Idxd_nv<"memh", "STrih", IntRegs, s11_1Ext,
1642                                  u6_1Ext, 12, 7>, AddrModeRel;
1643   defm STriw_indexed: ST_Idxd_nv<"memw", "STriw", IntRegs, s11_2Ext,
1644                                  u6_2Ext, 13, 8>, AddrModeRel;
1645 }
1646
1647 // multiclass for new-value store instructions with base + immediate offset.
1648 // and MEMri operand.
1649 multiclass ST_MEMri_Pbase_nv<string mnemonic, RegisterClass RC, bit isNot,
1650                           bit isPredNew> {
1651   let PNewValue = !if(isPredNew, "new", "") in
1652   def NAME#_nv_V4 : NVInst_V4<(outs),
1653             (ins PredRegs:$src1, MEMri:$addr, RC: $src2),
1654             !if(isNot, "if (!$src1", "if ($src1")#!if(isPredNew, ".new) ",
1655             ") ")#mnemonic#"($addr) = $src2.new",
1656             []>,
1657             Requires<[HasV4T]>;
1658 }
1659
1660 multiclass ST_MEMri_Pred_nv<string mnemonic, RegisterClass RC, bit PredNot> {
1661   let PredSense = !if(PredNot, "false", "true") in {
1662     defm _c#NAME : ST_MEMri_Pbase_nv<mnemonic, RC, PredNot, 0>;
1663
1664     // Predicate new
1665     defm _cdn#NAME : ST_MEMri_Pbase_nv<mnemonic, RC, PredNot, 1>;
1666   }
1667 }
1668
1669 let mayStore = 1, isNVStore = 1, isExtendable = 1, neverHasSideEffects = 1 in
1670 multiclass ST_MEMri_nv<string mnemonic, string CextOp, RegisterClass RC,
1671                     bits<5> ImmBits, bits<5> PredImmBits> {
1672
1673   let CextOpcode = CextOp, BaseOpcode = CextOp in {
1674     let opExtendable = 1, isExtentSigned = 1, opExtentBits = ImmBits,
1675          isPredicable = 1 in
1676     def NAME#_nv_V4 : NVInst_V4<(outs),
1677             (ins MEMri:$addr, RC:$src),
1678             mnemonic#"($addr) = $src.new",
1679             []>,
1680             Requires<[HasV4T]>;
1681
1682     let opExtendable = 2, isExtentSigned = 0, opExtentBits = PredImmBits,
1683         neverHasSideEffects = 1, isPredicated = 1 in {
1684       defm Pt : ST_MEMri_Pred_nv<mnemonic, RC, 0>;
1685       defm NotPt : ST_MEMri_Pred_nv<mnemonic, RC, 1>;
1686     }
1687   }
1688 }
1689
1690 let addrMode = BaseImmOffset, isMEMri = "true", validSubTargets = HasV4SubT,
1691 mayStore = 1 in {
1692   defm STrib: ST_MEMri_nv<"memb", "STrib", IntRegs, 11, 6>, AddrModeRel;
1693   defm STrih: ST_MEMri_nv<"memh", "STrih", IntRegs, 12, 7>, AddrModeRel;
1694   defm STriw: ST_MEMri_nv<"memw", "STriw", IntRegs, 13, 8>, AddrModeRel;
1695 }
1696
1697 // memb(Ru<<#u2+#U6)=Nt.new
1698 let isExtended = 1, opExtendable = 2, mayStore = 1, AddedComplexity = 10,
1699 isNVStore = 1, validSubTargets = HasV4SubT in
1700 def STrib_shl_nv_V4 : NVInst_V4<(outs),
1701             (ins IntRegs:$src1, u2Imm:$src2, u0AlwaysExt:$src3, IntRegs:$src4),
1702             "memb($src1<<#$src2+#$src3) = $src4.new",
1703             []>,
1704             Requires<[HasV4T]>;
1705
1706 //===----------------------------------------------------------------------===//
1707 // Post increment store
1708 // mem[bhwd](Rx++#s4:[0123])=Nt.new
1709 //===----------------------------------------------------------------------===//
1710
1711 multiclass ST_PostInc_Pbase_nv<string mnemonic, RegisterClass RC, Operand ImmOp,
1712                             bit isNot, bit isPredNew> {
1713   let PNewValue = !if(isPredNew, "new", "") in
1714   def NAME#_nv_V4 : NVInstPI_V4<(outs IntRegs:$dst),
1715             (ins PredRegs:$src1, IntRegs:$src2, ImmOp:$offset, RC:$src3),
1716             !if(isNot, "if (!$src1", "if ($src1")#!if(isPredNew, ".new) ",
1717             ") ")#mnemonic#"($src2++#$offset) = $src3.new",
1718             [],
1719             "$src2 = $dst">,
1720             Requires<[HasV4T]>;
1721 }
1722
1723 multiclass ST_PostInc_Pred_nv<string mnemonic, RegisterClass RC,
1724                            Operand ImmOp, bit PredNot> {
1725   let PredSense = !if(PredNot, "false", "true") in {
1726     defm _c#NAME : ST_PostInc_Pbase_nv<mnemonic, RC, ImmOp, PredNot, 0>;
1727     // Predicate new
1728     let Predicates = [HasV4T], validSubTargets = HasV4SubT in
1729     defm _cdn#NAME : ST_PostInc_Pbase_nv<mnemonic, RC, ImmOp, PredNot, 1>;
1730   }
1731 }
1732
1733 let hasCtrlDep = 1, isNVStore = 1, neverHasSideEffects = 1 in
1734 multiclass ST_PostInc_nv<string mnemonic, string BaseOp, RegisterClass RC,
1735                       Operand ImmOp> {
1736
1737   let BaseOpcode = "POST_"#BaseOp in {
1738     let isPredicable = 1 in
1739     def NAME#_nv_V4 : NVInstPI_V4<(outs IntRegs:$dst),
1740                 (ins IntRegs:$src1, ImmOp:$offset, RC:$src2),
1741                 mnemonic#"($src1++#$offset) = $src2.new",
1742                 [],
1743                 "$src1 = $dst">,
1744                 Requires<[HasV4T]>;
1745
1746     let isPredicated = 1 in {
1747       defm Pt : ST_PostInc_Pred_nv<mnemonic, RC, ImmOp, 0 >;
1748       defm NotPt : ST_PostInc_Pred_nv<mnemonic, RC, ImmOp, 1 >;
1749     }
1750   }
1751 }
1752
1753 let validSubTargets = HasV4SubT in {
1754 defm POST_STbri: ST_PostInc_nv <"memb", "STrib", IntRegs, s4_0Imm>, AddrModeRel;
1755 defm POST_SThri: ST_PostInc_nv <"memh", "STrih", IntRegs, s4_1Imm>, AddrModeRel;
1756 defm POST_STwri: ST_PostInc_nv <"memw", "STriw", IntRegs, s4_2Imm>, AddrModeRel;
1757 }
1758
1759 // memb(Rx++#s4:0:circ(Mu))=Nt.new
1760 // memb(Rx++I:circ(Mu))=Nt.new
1761 // memb(Rx++Mu)=Nt.new
1762 // memb(Rx++Mu:brev)=Nt.new
1763
1764 // memb(#global)=Nt.new
1765 let mayStore = 1, neverHasSideEffects = 1 in
1766 def STb_GP_nv_V4 : NVInst_V4<(outs),
1767             (ins globaladdress:$global, IntRegs:$src),
1768             "memb(#$global) = $src.new",
1769             []>,
1770             Requires<[HasV4T]>;
1771
1772 // memh(Ru<<#u2+#U6)=Nt.new
1773 let isExtended = 1, opExtendable = 2, mayStore = 1, AddedComplexity = 10,
1774 isNVStore = 1, validSubTargets = HasV4SubT in
1775 def STrih_shl_nv_V4 : NVInst_V4<(outs),
1776             (ins IntRegs:$src1, u2Imm:$src2, u0AlwaysExt:$src3, IntRegs:$src4),
1777             "memh($src1<<#$src2+#$src3) = $src4.new",
1778             []>,
1779             Requires<[HasV4T]>;
1780
1781 // memh(Rx++#s4:1:circ(Mu))=Nt.new
1782 // memh(Rx++I:circ(Mu))=Nt.new
1783 // memh(Rx++Mu)=Nt.new
1784 // memh(Rx++Mu:brev)=Nt.new
1785
1786 // memh(#global)=Nt.new
1787 let mayStore = 1, neverHasSideEffects = 1 in
1788 def STh_GP_nv_V4 : NVInst_V4<(outs),
1789             (ins globaladdress:$global, IntRegs:$src),
1790             "memh(#$global) = $src.new",
1791             []>,
1792             Requires<[HasV4T]>;
1793
1794 // memw(Ru<<#u2+#U6)=Nt.new
1795 let isExtended = 1, opExtendable = 2, mayStore = 1, AddedComplexity = 10,
1796 isNVStore = 1, validSubTargets = HasV4SubT in
1797 def STriw_shl_nv_V4 : NVInst_V4<(outs),
1798             (ins IntRegs:$src1, u2Imm:$src2, u0AlwaysExt:$src3, IntRegs:$src4),
1799             "memw($src1<<#$src2+#$src3) = $src4.new",
1800             []>,
1801             Requires<[HasV4T]>;
1802
1803 // memw(Rx++#s4:2:circ(Mu))=Nt.new
1804 // memw(Rx++I:circ(Mu))=Nt.new
1805 // memw(Rx++Mu)=Nt.new
1806 // memw(Rx++Mu:brev)=Nt.new
1807 // memw(gp+#u16:2)=Nt.new
1808
1809 let mayStore = 1, neverHasSideEffects = 1, isNVStore = 1,
1810 validSubTargets = HasV4SubT in
1811 def STw_GP_nv_V4 : NVInst_V4<(outs),
1812             (ins globaladdress:$global, IntRegs:$src),
1813             "memw(#$global) = $src.new",
1814             []>,
1815             Requires<[HasV4T]>;
1816
1817 // if (Pv) memb(##global) = Rt
1818 let mayStore = 1, neverHasSideEffects = 1, isNVStore = 1,
1819 isExtended = 1, opExtendable = 1, validSubTargets = HasV4SubT in {
1820 def STb_GP_cPt_nv_V4 : NVInst_V4<(outs),
1821             (ins PredRegs:$src1, globaladdress:$global, IntRegs:$src2),
1822             "if ($src1) memb(##$global) = $src2.new",
1823             []>,
1824             Requires<[HasV4T]>;
1825
1826 // if (!Pv) memb(##global) = Rt
1827 def STb_GP_cNotPt_nv_V4 : NVInst_V4<(outs),
1828             (ins PredRegs:$src1, globaladdress:$global, IntRegs:$src2),
1829             "if (!$src1) memb(##$global) = $src2.new",
1830             []>,
1831             Requires<[HasV4T]>;
1832
1833 // if (Pv) memb(##global) = Rt
1834 def STb_GP_cdnPt_nv_V4 : NVInst_V4<(outs),
1835             (ins PredRegs:$src1, globaladdress:$global, IntRegs:$src2),
1836             "if ($src1.new) memb(##$global) = $src2.new",
1837             []>,
1838             Requires<[HasV4T]>;
1839
1840 // if (!Pv) memb(##global) = Rt
1841 def STb_GP_cdnNotPt_nv_V4 : NVInst_V4<(outs),
1842             (ins PredRegs:$src1, globaladdress:$global, IntRegs:$src2),
1843             "if (!$src1.new) memb(##$global) = $src2.new",
1844             []>,
1845             Requires<[HasV4T]>;
1846
1847 // if (Pv) memh(##global) = Rt
1848 def STh_GP_cPt_nv_V4 : NVInst_V4<(outs),
1849             (ins PredRegs:$src1, globaladdress:$global, IntRegs:$src2),
1850             "if ($src1) memh(##$global) = $src2.new",
1851             []>,
1852             Requires<[HasV4T]>;
1853
1854 // if (!Pv) memh(##global) = Rt
1855 def STh_GP_cNotPt_nv_V4 : NVInst_V4<(outs),
1856             (ins PredRegs:$src1, globaladdress:$global, IntRegs:$src2),
1857             "if (!$src1) memh(##$global) = $src2.new",
1858             []>,
1859             Requires<[HasV4T]>;
1860
1861 // if (Pv) memh(##global) = Rt
1862 def STh_GP_cdnPt_nv_V4 : NVInst_V4<(outs),
1863             (ins PredRegs:$src1, globaladdress:$global, IntRegs:$src2),
1864             "if ($src1.new) memh(##$global) = $src2.new",
1865             []>,
1866             Requires<[HasV4T]>;
1867
1868 // if (!Pv) memh(##global) = Rt
1869 def STh_GP_cdnNotPt_nv_V4 : NVInst_V4<(outs),
1870             (ins PredRegs:$src1, globaladdress:$global, IntRegs:$src2),
1871             "if (!$src1.new) memh(##$global) = $src2.new",
1872             []>,
1873             Requires<[HasV4T]>;
1874
1875 // if (Pv) memw(##global) = Rt
1876 def STw_GP_cPt_nv_V4 : NVInst_V4<(outs),
1877             (ins PredRegs:$src1, globaladdress:$global, IntRegs:$src2),
1878             "if ($src1) memw(##$global) = $src2.new",
1879             []>,
1880             Requires<[HasV4T]>;
1881
1882 // if (!Pv) memw(##global) = Rt
1883 def STw_GP_cNotPt_nv_V4 : NVInst_V4<(outs),
1884             (ins PredRegs:$src1, globaladdress:$global, IntRegs:$src2),
1885             "if (!$src1) memw(##$global) = $src2.new",
1886             []>,
1887             Requires<[HasV4T]>;
1888
1889 // if (Pv) memw(##global) = Rt
1890 def STw_GP_cdnPt_nv_V4 : NVInst_V4<(outs),
1891             (ins PredRegs:$src1, globaladdress:$global, IntRegs:$src2),
1892             "if ($src1.new) memw(##$global) = $src2.new",
1893             []>,
1894             Requires<[HasV4T]>;
1895
1896 // if (!Pv) memw(##global) = Rt
1897 def STw_GP_cdnNotPt_nv_V4 : NVInst_V4<(outs),
1898             (ins PredRegs:$src1, globaladdress:$global, IntRegs:$src2),
1899             "if (!$src1.new) memw(##$global) = $src2.new",
1900             []>,
1901             Requires<[HasV4T]>;
1902 }
1903
1904 //===----------------------------------------------------------------------===//
1905 // NV/ST -
1906 //===----------------------------------------------------------------------===//
1907
1908 //===----------------------------------------------------------------------===//
1909 // NV/J +
1910 //===----------------------------------------------------------------------===//
1911
1912 multiclass NVJ_type_basic_reg<string NotStr, string OpcStr, string TakenStr> {
1913   def _ie_nv_V4 : NVInst_V4<(outs),
1914             (ins IntRegs:$src1, IntRegs:$src2, brtarget:$offset),
1915             !strconcat("if (", !strconcat(NotStr, !strconcat(OpcStr,
1916             !strconcat("($src1.new, $src2)) jump:",
1917             !strconcat(TakenStr, " $offset"))))),
1918             []>,
1919             Requires<[HasV4T]>;
1920
1921   def _nv_V4 : NVInst_V4<(outs),
1922             (ins IntRegs:$src1, IntRegs:$src2, brtarget:$offset),
1923             !strconcat("if (", !strconcat(NotStr, !strconcat(OpcStr,
1924             !strconcat("($src1.new, $src2)) jump:",
1925             !strconcat(TakenStr, " $offset"))))),
1926             []>,
1927             Requires<[HasV4T]>;
1928 }
1929
1930 multiclass NVJ_type_basic_2ndDotNew<string NotStr, string OpcStr,
1931                                                    string TakenStr> {
1932   def _ie_nv_V4 : NVInst_V4<(outs),
1933             (ins IntRegs:$src1, IntRegs:$src2, brtarget:$offset),
1934             !strconcat("if (", !strconcat(NotStr, !strconcat(OpcStr,
1935             !strconcat("($src1, $src2.new)) jump:",
1936             !strconcat(TakenStr, " $offset"))))),
1937             []>,
1938             Requires<[HasV4T]>;
1939
1940   def _nv_V4 : NVInst_V4<(outs),
1941             (ins IntRegs:$src1, IntRegs:$src2, brtarget:$offset),
1942             !strconcat("if (", !strconcat(NotStr, !strconcat(OpcStr,
1943             !strconcat("($src1, $src2.new)) jump:",
1944             !strconcat(TakenStr, " $offset"))))),
1945             []>,
1946             Requires<[HasV4T]>;
1947 }
1948
1949 multiclass NVJ_type_basic_imm<string NotStr, string OpcStr, string TakenStr> {
1950   def _ie_nv_V4 : NVInst_V4<(outs),
1951             (ins IntRegs:$src1, u5Imm:$src2, brtarget:$offset),
1952             !strconcat("if (", !strconcat(NotStr, !strconcat(OpcStr,
1953             !strconcat("($src1.new, #$src2)) jump:",
1954             !strconcat(TakenStr, " $offset"))))),
1955             []>,
1956             Requires<[HasV4T]>;
1957
1958   def _nv_V4 : NVInst_V4<(outs),
1959             (ins IntRegs:$src1, u5Imm:$src2, brtarget:$offset),
1960             !strconcat("if (", !strconcat(NotStr, !strconcat(OpcStr,
1961             !strconcat("($src1.new, #$src2)) jump:",
1962             !strconcat(TakenStr, " $offset"))))),
1963             []>,
1964             Requires<[HasV4T]>;
1965 }
1966
1967 multiclass NVJ_type_basic_neg<string NotStr, string OpcStr, string TakenStr> {
1968   def _ie_nv_V4 : NVInst_V4<(outs),
1969             (ins IntRegs:$src1, nOneImm:$src2, brtarget:$offset),
1970             !strconcat("if (", !strconcat(NotStr, !strconcat(OpcStr,
1971             !strconcat("($src1.new, #$src2)) jump:",
1972             !strconcat(TakenStr, " $offset"))))),
1973             []>,
1974             Requires<[HasV4T]>;
1975
1976   def _nv_V4 : NVInst_V4<(outs),
1977             (ins IntRegs:$src1, nOneImm:$src2, brtarget:$offset),
1978             !strconcat("if (", !strconcat(NotStr, !strconcat(OpcStr,
1979             !strconcat("($src1.new, #$src2)) jump:",
1980             !strconcat(TakenStr, " $offset"))))),
1981             []>,
1982             Requires<[HasV4T]>;
1983 }
1984
1985 multiclass NVJ_type_basic_tstbit<string NotStr, string OpcStr,
1986                                                 string TakenStr> {
1987   def _ie_nv_V4 : NVInst_V4<(outs),
1988             (ins IntRegs:$src1, u1Imm:$src2, brtarget:$offset),
1989             !strconcat("if (", !strconcat(NotStr, !strconcat(OpcStr,
1990             !strconcat("($src1.new, #$src2)) jump:",
1991             !strconcat(TakenStr, " $offset"))))),
1992             []>,
1993             Requires<[HasV4T]>;
1994
1995   def _nv_V4 : NVInst_V4<(outs),
1996             (ins IntRegs:$src1, u1Imm:$src2, brtarget:$offset),
1997             !strconcat("if (", !strconcat(NotStr, !strconcat(OpcStr,
1998             !strconcat("($src1.new, #$src2)) jump:",
1999             !strconcat(TakenStr, " $offset"))))),
2000             []>,
2001             Requires<[HasV4T]>;
2002 }
2003
2004 // Multiclass for regular dot new of Ist operand register.
2005 multiclass NVJ_type_br_pred_reg<string NotStr, string OpcStr> {
2006   defm Pt  : NVJ_type_basic_reg<NotStr, OpcStr, "t">;
2007   defm Pnt : NVJ_type_basic_reg<NotStr, OpcStr, "nt">;
2008 }
2009
2010 // Multiclass for dot new of 2nd operand register.
2011 multiclass NVJ_type_br_pred_2ndDotNew<string NotStr, string OpcStr> {
2012   defm Pt  : NVJ_type_basic_2ndDotNew<NotStr, OpcStr, "t">;
2013   defm Pnt : NVJ_type_basic_2ndDotNew<NotStr, OpcStr, "nt">;
2014 }
2015
2016 // Multiclass for 2nd operand immediate, including -1.
2017 multiclass NVJ_type_br_pred_imm<string NotStr, string OpcStr> {
2018   defm Pt     : NVJ_type_basic_imm<NotStr, OpcStr, "t">;
2019   defm Pnt    : NVJ_type_basic_imm<NotStr, OpcStr, "nt">;
2020   defm Ptneg  : NVJ_type_basic_neg<NotStr, OpcStr, "t">;
2021   defm Pntneg : NVJ_type_basic_neg<NotStr, OpcStr, "nt">;
2022 }
2023
2024 // Multiclass for 2nd operand immediate, excluding -1.
2025 multiclass NVJ_type_br_pred_imm_only<string NotStr, string OpcStr> {
2026   defm Pt     : NVJ_type_basic_imm<NotStr, OpcStr, "t">;
2027   defm Pnt    : NVJ_type_basic_imm<NotStr, OpcStr, "nt">;
2028 }
2029
2030 // Multiclass for tstbit, where 2nd operand is always #0.
2031 multiclass NVJ_type_br_pred_tstbit<string NotStr, string OpcStr> {
2032   defm Pt     : NVJ_type_basic_tstbit<NotStr, OpcStr, "t">;
2033   defm Pnt    : NVJ_type_basic_tstbit<NotStr, OpcStr, "nt">;
2034 }
2035
2036 // Multiclass for GT.
2037 multiclass NVJ_type_rr_ri<string OpcStr> {
2038   defm rrNot   : NVJ_type_br_pred_reg<"!", OpcStr>;
2039   defm rr      : NVJ_type_br_pred_reg<"",  OpcStr>;
2040   defm rrdnNot : NVJ_type_br_pred_2ndDotNew<"!", OpcStr>;
2041   defm rrdn    : NVJ_type_br_pred_2ndDotNew<"",  OpcStr>;
2042   defm riNot   : NVJ_type_br_pred_imm<"!", OpcStr>;
2043   defm ri      : NVJ_type_br_pred_imm<"",  OpcStr>;
2044 }
2045
2046 // Multiclass for EQ.
2047 multiclass NVJ_type_rr_ri_no_2ndDotNew<string OpcStr> {
2048   defm rrNot   : NVJ_type_br_pred_reg<"!", OpcStr>;
2049   defm rr      : NVJ_type_br_pred_reg<"",  OpcStr>;
2050   defm riNot   : NVJ_type_br_pred_imm<"!", OpcStr>;
2051   defm ri      : NVJ_type_br_pred_imm<"",  OpcStr>;
2052 }
2053
2054 // Multiclass for GTU.
2055 multiclass NVJ_type_rr_ri_no_nOne<string OpcStr> {
2056   defm rrNot   : NVJ_type_br_pred_reg<"!", OpcStr>;
2057   defm rr      : NVJ_type_br_pred_reg<"",  OpcStr>;
2058   defm rrdnNot : NVJ_type_br_pred_2ndDotNew<"!", OpcStr>;
2059   defm rrdn    : NVJ_type_br_pred_2ndDotNew<"",  OpcStr>;
2060   defm riNot   : NVJ_type_br_pred_imm_only<"!", OpcStr>;
2061   defm ri      : NVJ_type_br_pred_imm_only<"",  OpcStr>;
2062 }
2063
2064 // Multiclass for tstbit.
2065 multiclass NVJ_type_r0<string OpcStr> {
2066   defm r0Not : NVJ_type_br_pred_tstbit<"!", OpcStr>;
2067   defm r0    : NVJ_type_br_pred_tstbit<"",  OpcStr>;
2068  }
2069
2070 // Base Multiclass for New Value Jump.
2071 multiclass NVJ_type {
2072   defm GT     : NVJ_type_rr_ri<"cmp.gt">;
2073   defm EQ     : NVJ_type_rr_ri_no_2ndDotNew<"cmp.eq">;
2074   defm GTU    : NVJ_type_rr_ri_no_nOne<"cmp.gtu">;
2075   defm TSTBIT : NVJ_type_r0<"tstbit">;
2076 }
2077
2078 let isBranch = 1, isTerminator=1, neverHasSideEffects = 1, Defs = [PC] in {
2079   defm JMP_ : NVJ_type;
2080 }
2081
2082 //===----------------------------------------------------------------------===//
2083 // NV/J -
2084 //===----------------------------------------------------------------------===//
2085
2086 //===----------------------------------------------------------------------===//
2087 // XTYPE/ALU +
2088 //===----------------------------------------------------------------------===//
2089
2090 //  Add and accumulate.
2091 //  Rd=add(Rs,add(Ru,#s6))
2092 let isExtendable = 1, opExtendable = 3, isExtentSigned = 1, opExtentBits = 6,
2093 validSubTargets = HasV4SubT in
2094 def ADDr_ADDri_V4 : MInst<(outs IntRegs:$dst),
2095           (ins IntRegs:$src1, IntRegs:$src2, s6Ext:$src3),
2096           "$dst = add($src1, add($src2, #$src3))",
2097           [(set (i32 IntRegs:$dst),
2098            (add (i32 IntRegs:$src1), (add (i32 IntRegs:$src2),
2099                                           s6_16ExtPred:$src3)))]>,
2100           Requires<[HasV4T]>;
2101
2102 //  Rd=add(Rs,sub(#s6,Ru))
2103 let isExtendable = 1, opExtendable = 2, isExtentSigned = 1, opExtentBits = 6,
2104 validSubTargets = HasV4SubT in
2105 def ADDr_SUBri_V4 : MInst<(outs IntRegs:$dst),
2106           (ins IntRegs:$src1, s6Ext:$src2, IntRegs:$src3),
2107           "$dst = add($src1, sub(#$src2, $src3))",
2108           [(set (i32 IntRegs:$dst),
2109            (add (i32 IntRegs:$src1), (sub s6_10ExtPred:$src2,
2110                                           (i32 IntRegs:$src3))))]>,
2111           Requires<[HasV4T]>;
2112
2113 // Generates the same instruction as ADDr_SUBri_V4 but matches different
2114 // pattern.
2115 //  Rd=add(Rs,sub(#s6,Ru))
2116 let isExtendable = 1, opExtendable = 2, isExtentSigned = 1, opExtentBits = 6,
2117 validSubTargets = HasV4SubT in
2118 def ADDri_SUBr_V4 : MInst<(outs IntRegs:$dst),
2119           (ins IntRegs:$src1, s6Ext:$src2, IntRegs:$src3),
2120           "$dst = add($src1, sub(#$src2, $src3))",
2121           [(set (i32 IntRegs:$dst),
2122                 (sub (add (i32 IntRegs:$src1), s6_10ExtPred:$src2),
2123                      (i32 IntRegs:$src3)))]>,
2124           Requires<[HasV4T]>;
2125
2126
2127 //  Add or subtract doublewords with carry.
2128 //TODO:
2129 //  Rdd=add(Rss,Rtt,Px):carry
2130 //TODO:
2131 //  Rdd=sub(Rss,Rtt,Px):carry
2132
2133
2134 //  Logical doublewords.
2135 //  Rdd=and(Rtt,~Rss)
2136 let validSubTargets = HasV4SubT in
2137 def ANDd_NOTd_V4 : MInst<(outs DoubleRegs:$dst),
2138           (ins DoubleRegs:$src1, DoubleRegs:$src2),
2139           "$dst = and($src1, ~$src2)",
2140           [(set (i64 DoubleRegs:$dst), (and (i64 DoubleRegs:$src1),
2141                                       (not (i64 DoubleRegs:$src2))))]>,
2142           Requires<[HasV4T]>;
2143
2144 //  Rdd=or(Rtt,~Rss)
2145 let validSubTargets = HasV4SubT in
2146 def ORd_NOTd_V4 : MInst<(outs DoubleRegs:$dst),
2147           (ins DoubleRegs:$src1, DoubleRegs:$src2),
2148           "$dst = or($src1, ~$src2)",
2149           [(set (i64 DoubleRegs:$dst),
2150            (or (i64 DoubleRegs:$src1), (not (i64 DoubleRegs:$src2))))]>,
2151           Requires<[HasV4T]>;
2152
2153
2154 //  Logical-logical doublewords.
2155 //  Rxx^=xor(Rss,Rtt)
2156 let validSubTargets = HasV4SubT in
2157 def XORd_XORdd: MInst_acc<(outs DoubleRegs:$dst),
2158           (ins DoubleRegs:$src1, DoubleRegs:$src2, DoubleRegs:$src3),
2159           "$dst ^= xor($src2, $src3)",
2160           [(set (i64 DoubleRegs:$dst),
2161            (xor (i64 DoubleRegs:$src1), (xor (i64 DoubleRegs:$src2),
2162                                              (i64 DoubleRegs:$src3))))],
2163           "$src1 = $dst">,
2164           Requires<[HasV4T]>;
2165
2166
2167 // Logical-logical words.
2168 // Rx=or(Ru,and(Rx,#s10))
2169 let isExtendable = 1, opExtendable = 3, isExtentSigned = 1, opExtentBits = 10,
2170 validSubTargets = HasV4SubT in
2171 def ORr_ANDri_V4 : MInst_acc<(outs IntRegs:$dst),
2172             (ins IntRegs:$src1, IntRegs: $src2, s10Ext:$src3),
2173             "$dst = or($src1, and($src2, #$src3))",
2174             [(set (i32 IntRegs:$dst),
2175                   (or (i32 IntRegs:$src1), (and (i32 IntRegs:$src2),
2176                                                 s10ExtPred:$src3)))],
2177             "$src2 = $dst">,
2178             Requires<[HasV4T]>;
2179
2180 // Rx[&|^]=and(Rs,Rt)
2181 // Rx&=and(Rs,Rt)
2182 let validSubTargets = HasV4SubT in
2183 def ANDr_ANDrr_V4 : MInst_acc<(outs IntRegs:$dst),
2184             (ins IntRegs:$src1, IntRegs: $src2, IntRegs:$src3),
2185             "$dst &= and($src2, $src3)",
2186             [(set (i32 IntRegs:$dst),
2187                   (and (i32 IntRegs:$src1), (and (i32 IntRegs:$src2),
2188                                                  (i32 IntRegs:$src3))))],
2189             "$src1 = $dst">,
2190             Requires<[HasV4T]>;
2191
2192 // Rx|=and(Rs,Rt)
2193 let validSubTargets = HasV4SubT, CextOpcode = "ORr_ANDr", InputType = "reg" in
2194 def ORr_ANDrr_V4 : MInst_acc<(outs IntRegs:$dst),
2195             (ins IntRegs:$src1, IntRegs: $src2, IntRegs:$src3),
2196             "$dst |= and($src2, $src3)",
2197             [(set (i32 IntRegs:$dst),
2198                   (or (i32 IntRegs:$src1), (and (i32 IntRegs:$src2),
2199                                                 (i32 IntRegs:$src3))))],
2200             "$src1 = $dst">,
2201             Requires<[HasV4T]>, ImmRegRel;
2202
2203 // Rx^=and(Rs,Rt)
2204 let validSubTargets = HasV4SubT in
2205 def XORr_ANDrr_V4 : MInst_acc<(outs IntRegs:$dst),
2206             (ins IntRegs:$src1, IntRegs: $src2, IntRegs:$src3),
2207             "$dst ^= and($src2, $src3)",
2208             [(set (i32 IntRegs:$dst),
2209              (xor (i32 IntRegs:$src1), (and (i32 IntRegs:$src2),
2210                                             (i32 IntRegs:$src3))))],
2211             "$src1 = $dst">,
2212             Requires<[HasV4T]>;
2213
2214 // Rx[&|^]=and(Rs,~Rt)
2215 // Rx&=and(Rs,~Rt)
2216 let validSubTargets = HasV4SubT in
2217 def ANDr_ANDr_NOTr_V4 : MInst_acc<(outs IntRegs:$dst),
2218             (ins IntRegs:$src1, IntRegs: $src2, IntRegs:$src3),
2219             "$dst &= and($src2, ~$src3)",
2220             [(set (i32 IntRegs:$dst),
2221                   (and (i32 IntRegs:$src1), (and (i32 IntRegs:$src2),
2222                                                  (not (i32 IntRegs:$src3)))))],
2223             "$src1 = $dst">,
2224             Requires<[HasV4T]>;
2225
2226 // Rx|=and(Rs,~Rt)
2227 let validSubTargets = HasV4SubT in
2228 def ORr_ANDr_NOTr_V4 : MInst_acc<(outs IntRegs:$dst),
2229             (ins IntRegs:$src1, IntRegs: $src2, IntRegs:$src3),
2230             "$dst |= and($src2, ~$src3)",
2231             [(set (i32 IntRegs:$dst),
2232              (or (i32 IntRegs:$src1), (and (i32 IntRegs:$src2),
2233                                            (not (i32 IntRegs:$src3)))))],
2234             "$src1 = $dst">,
2235             Requires<[HasV4T]>;
2236
2237 // Rx^=and(Rs,~Rt)
2238 let validSubTargets = HasV4SubT in
2239 def XORr_ANDr_NOTr_V4 : MInst_acc<(outs IntRegs:$dst),
2240             (ins IntRegs:$src1, IntRegs: $src2, IntRegs:$src3),
2241             "$dst ^= and($src2, ~$src3)",
2242             [(set (i32 IntRegs:$dst),
2243              (xor (i32 IntRegs:$src1), (and (i32 IntRegs:$src2),
2244                                             (not (i32 IntRegs:$src3)))))],
2245             "$src1 = $dst">,
2246             Requires<[HasV4T]>;
2247
2248 // Rx[&|^]=or(Rs,Rt)
2249 // Rx&=or(Rs,Rt)
2250 let validSubTargets = HasV4SubT in
2251 def ANDr_ORrr_V4 : MInst_acc<(outs IntRegs:$dst),
2252             (ins IntRegs:$src1, IntRegs: $src2, IntRegs:$src3),
2253             "$dst &= or($src2, $src3)",
2254             [(set (i32 IntRegs:$dst),
2255                   (and (i32 IntRegs:$src1), (or (i32 IntRegs:$src2),
2256                                                 (i32 IntRegs:$src3))))],
2257             "$src1 = $dst">,
2258             Requires<[HasV4T]>;
2259
2260 // Rx|=or(Rs,Rt)
2261 let validSubTargets = HasV4SubT, CextOpcode = "ORr_ORr", InputType = "reg" in
2262 def ORr_ORrr_V4 : MInst_acc<(outs IntRegs:$dst),
2263             (ins IntRegs:$src1, IntRegs: $src2, IntRegs:$src3),
2264             "$dst |= or($src2, $src3)",
2265             [(set (i32 IntRegs:$dst),
2266                   (or (i32 IntRegs:$src1), (or (i32 IntRegs:$src2),
2267                                                (i32 IntRegs:$src3))))],
2268             "$src1 = $dst">,
2269             Requires<[HasV4T]>, ImmRegRel;
2270
2271 // Rx^=or(Rs,Rt)
2272 let validSubTargets = HasV4SubT in
2273 def XORr_ORrr_V4 : MInst_acc<(outs IntRegs:$dst),
2274             (ins IntRegs:$src1, IntRegs: $src2, IntRegs:$src3),
2275             "$dst ^= or($src2, $src3)",
2276             [(set (i32 IntRegs:$dst),
2277              (xor (i32 IntRegs:$src1), (or (i32 IntRegs:$src2),
2278                                            (i32 IntRegs:$src3))))],
2279             "$src1 = $dst">,
2280             Requires<[HasV4T]>;
2281
2282 // Rx[&|^]=xor(Rs,Rt)
2283 // Rx&=xor(Rs,Rt)
2284 let validSubTargets = HasV4SubT in
2285 def ANDr_XORrr_V4 : MInst_acc<(outs IntRegs:$dst),
2286             (ins IntRegs:$src1, IntRegs: $src2, IntRegs:$src3),
2287             "$dst &= xor($src2, $src3)",
2288             [(set (i32 IntRegs:$dst),
2289                   (and (i32 IntRegs:$src1), (xor (i32 IntRegs:$src2),
2290                                                  (i32 IntRegs:$src3))))],
2291             "$src1 = $dst">,
2292             Requires<[HasV4T]>;
2293
2294 // Rx|=xor(Rs,Rt)
2295 let validSubTargets = HasV4SubT in
2296 def ORr_XORrr_V4 : MInst_acc<(outs IntRegs:$dst),
2297             (ins IntRegs:$src1, IntRegs: $src2, IntRegs:$src3),
2298             "$dst |= xor($src2, $src3)",
2299             [(set (i32 IntRegs:$dst),
2300                   (and (i32 IntRegs:$src1), (xor (i32 IntRegs:$src2),
2301                                                  (i32 IntRegs:$src3))))],
2302             "$src1 = $dst">,
2303             Requires<[HasV4T]>;
2304
2305 // Rx^=xor(Rs,Rt)
2306 let validSubTargets = HasV4SubT in
2307 def XORr_XORrr_V4 : MInst_acc<(outs IntRegs:$dst),
2308             (ins IntRegs:$src1, IntRegs: $src2, IntRegs:$src3),
2309             "$dst ^= xor($src2, $src3)",
2310             [(set (i32 IntRegs:$dst),
2311              (and (i32 IntRegs:$src1), (xor (i32 IntRegs:$src2),
2312                                             (i32 IntRegs:$src3))))],
2313             "$src1 = $dst">,
2314             Requires<[HasV4T]>;
2315
2316 // Rx|=and(Rs,#s10)
2317 let isExtendable = 1, opExtendable = 3, isExtentSigned = 1, opExtentBits = 10,
2318 validSubTargets = HasV4SubT, CextOpcode = "ORr_ANDr", InputType = "imm" in
2319 def ORr_ANDri2_V4 : MInst_acc<(outs IntRegs:$dst),
2320             (ins IntRegs:$src1, IntRegs: $src2, s10Ext:$src3),
2321             "$dst |= and($src2, #$src3)",
2322             [(set (i32 IntRegs:$dst),
2323                   (or (i32 IntRegs:$src1), (and (i32 IntRegs:$src2),
2324                                                 s10ExtPred:$src3)))],
2325             "$src1 = $dst">,
2326             Requires<[HasV4T]>, ImmRegRel;
2327
2328 // Rx|=or(Rs,#s10)
2329 let isExtendable = 1, opExtendable = 3, isExtentSigned = 1, opExtentBits = 10,
2330 validSubTargets = HasV4SubT, CextOpcode = "ORr_ORr", InputType = "imm" in
2331 def ORr_ORri_V4 : MInst_acc<(outs IntRegs:$dst),
2332             (ins IntRegs:$src1, IntRegs: $src2, s10Ext:$src3),
2333             "$dst |= or($src2, #$src3)",
2334             [(set (i32 IntRegs:$dst),
2335                   (or (i32 IntRegs:$src1), (and (i32 IntRegs:$src2),
2336                                                 s10ExtPred:$src3)))],
2337             "$src1 = $dst">,
2338             Requires<[HasV4T]>, ImmRegRel;
2339
2340
2341 //    Modulo wrap
2342 //        Rd=modwrap(Rs,Rt)
2343 //    Round
2344 //        Rd=cround(Rs,#u5)
2345 //        Rd=cround(Rs,Rt)
2346 //        Rd=round(Rs,#u5)[:sat]
2347 //        Rd=round(Rs,Rt)[:sat]
2348 //    Vector reduce add unsigned halfwords
2349 //        Rd=vraddh(Rss,Rtt)
2350 //    Vector add bytes
2351 //        Rdd=vaddb(Rss,Rtt)
2352 //    Vector conditional negate
2353 //        Rdd=vcnegh(Rss,Rt)
2354 //        Rxx+=vrcnegh(Rss,Rt)
2355 //    Vector maximum bytes
2356 //        Rdd=vmaxb(Rtt,Rss)
2357 //    Vector reduce maximum halfwords
2358 //        Rxx=vrmaxh(Rss,Ru)
2359 //        Rxx=vrmaxuh(Rss,Ru)
2360 //    Vector reduce maximum words
2361 //        Rxx=vrmaxuw(Rss,Ru)
2362 //        Rxx=vrmaxw(Rss,Ru)
2363 //    Vector minimum bytes
2364 //        Rdd=vminb(Rtt,Rss)
2365 //    Vector reduce minimum halfwords
2366 //        Rxx=vrminh(Rss,Ru)
2367 //        Rxx=vrminuh(Rss,Ru)
2368 //    Vector reduce minimum words
2369 //        Rxx=vrminuw(Rss,Ru)
2370 //        Rxx=vrminw(Rss,Ru)
2371 //    Vector subtract bytes
2372 //        Rdd=vsubb(Rss,Rtt)
2373
2374 //===----------------------------------------------------------------------===//
2375 // XTYPE/ALU -
2376 //===----------------------------------------------------------------------===//
2377
2378
2379 //===----------------------------------------------------------------------===//
2380 // XTYPE/MPY +
2381 //===----------------------------------------------------------------------===//
2382
2383 // Multiply and user lower result.
2384 // Rd=add(#u6,mpyi(Rs,#U6))
2385 let isExtendable = 1, opExtendable = 1, isExtentSigned = 0, opExtentBits = 6,
2386 validSubTargets = HasV4SubT in
2387 def ADDi_MPYri_V4 : MInst<(outs IntRegs:$dst),
2388             (ins u6Ext:$src1, IntRegs:$src2, u6Imm:$src3),
2389             "$dst = add(#$src1, mpyi($src2, #$src3))",
2390             [(set (i32 IntRegs:$dst),
2391                   (add (mul (i32 IntRegs:$src2), u6ImmPred:$src3),
2392                        u6ExtPred:$src1))]>,
2393             Requires<[HasV4T]>;
2394
2395 // Rd=add(##,mpyi(Rs,#U6))
2396 def : Pat <(add (mul (i32 IntRegs:$src2), u6ImmPred:$src3),
2397                      (HexagonCONST32 tglobaladdr:$src1)),
2398            (i32 (ADDi_MPYri_V4 tglobaladdr:$src1, IntRegs:$src2,
2399                                u6ImmPred:$src3))>;
2400
2401 // Rd=add(#u6,mpyi(Rs,Rt))
2402 let isExtendable = 1, opExtendable = 1, isExtentSigned = 0, opExtentBits = 6,
2403 validSubTargets = HasV4SubT, InputType = "imm", CextOpcode = "ADD_MPY" in
2404 def ADDi_MPYrr_V4 : MInst<(outs IntRegs:$dst),
2405             (ins u6Ext:$src1, IntRegs:$src2, IntRegs:$src3),
2406             "$dst = add(#$src1, mpyi($src2, $src3))",
2407             [(set (i32 IntRegs:$dst),
2408                   (add (mul (i32 IntRegs:$src2), (i32 IntRegs:$src3)),
2409                        u6ExtPred:$src1))]>,
2410             Requires<[HasV4T]>, ImmRegRel;
2411
2412 // Rd=add(##,mpyi(Rs,Rt))
2413 def : Pat <(add (mul (i32 IntRegs:$src2), (i32 IntRegs:$src3)),
2414                      (HexagonCONST32 tglobaladdr:$src1)),
2415            (i32 (ADDi_MPYrr_V4 tglobaladdr:$src1, IntRegs:$src2,
2416                                IntRegs:$src3))>;
2417
2418 // Rd=add(Ru,mpyi(#u6:2,Rs))
2419 let validSubTargets = HasV4SubT in
2420 def ADDr_MPYir_V4 : MInst<(outs IntRegs:$dst),
2421             (ins IntRegs:$src1, u6Imm:$src2, IntRegs:$src3),
2422             "$dst = add($src1, mpyi(#$src2, $src3))",
2423             [(set (i32 IntRegs:$dst),
2424              (add (i32 IntRegs:$src1), (mul (i32 IntRegs:$src3),
2425                                             u6_2ImmPred:$src2)))]>,
2426             Requires<[HasV4T]>;
2427
2428 // Rd=add(Ru,mpyi(Rs,#u6))
2429 let isExtendable = 1, opExtendable = 3, isExtentSigned = 0, opExtentBits = 6,
2430 validSubTargets = HasV4SubT, InputType = "imm", CextOpcode = "ADD_MPY" in
2431 def ADDr_MPYri_V4 : MInst<(outs IntRegs:$dst),
2432             (ins IntRegs:$src1, IntRegs:$src2, u6Ext:$src3),
2433             "$dst = add($src1, mpyi($src2, #$src3))",
2434             [(set (i32 IntRegs:$dst),
2435                   (add (i32 IntRegs:$src1), (mul (i32 IntRegs:$src2),
2436                                                  u6ExtPred:$src3)))]>,
2437             Requires<[HasV4T]>, ImmRegRel;
2438
2439 // Rx=add(Ru,mpyi(Rx,Rs))
2440 let validSubTargets = HasV4SubT, InputType = "reg", CextOpcode = "ADD_MPY" in
2441 def ADDr_MPYrr_V4 : MInst_acc<(outs IntRegs:$dst),
2442             (ins IntRegs:$src1, IntRegs:$src2, IntRegs:$src3),
2443             "$dst = add($src1, mpyi($src2, $src3))",
2444             [(set (i32 IntRegs:$dst),
2445              (add (i32 IntRegs:$src1), (mul (i32 IntRegs:$src2),
2446                                             (i32 IntRegs:$src3))))],
2447             "$src2 = $dst">,
2448             Requires<[HasV4T]>, ImmRegRel;
2449
2450
2451 // Polynomial multiply words
2452 // Rdd=pmpyw(Rs,Rt)
2453 // Rxx^=pmpyw(Rs,Rt)
2454
2455 // Vector reduce multiply word by signed half (32x16)
2456 // Rdd=vrmpyweh(Rss,Rtt)[:<<1]
2457 // Rdd=vrmpywoh(Rss,Rtt)[:<<1]
2458 // Rxx+=vrmpyweh(Rss,Rtt)[:<<1]
2459 // Rxx+=vrmpywoh(Rss,Rtt)[:<<1]
2460
2461 // Multiply and use upper result
2462 // Rd=mpy(Rs,Rt.H):<<1:sat
2463 // Rd=mpy(Rs,Rt.L):<<1:sat
2464 // Rd=mpy(Rs,Rt):<<1
2465 // Rd=mpy(Rs,Rt):<<1:sat
2466 // Rd=mpysu(Rs,Rt)
2467 // Rx+=mpy(Rs,Rt):<<1:sat
2468 // Rx-=mpy(Rs,Rt):<<1:sat
2469
2470 // Vector multiply bytes
2471 // Rdd=vmpybsu(Rs,Rt)
2472 // Rdd=vmpybu(Rs,Rt)
2473 // Rxx+=vmpybsu(Rs,Rt)
2474 // Rxx+=vmpybu(Rs,Rt)
2475
2476 // Vector polynomial multiply halfwords
2477 // Rdd=vpmpyh(Rs,Rt)
2478 // Rxx^=vpmpyh(Rs,Rt)
2479
2480 //===----------------------------------------------------------------------===//
2481 // XTYPE/MPY -
2482 //===----------------------------------------------------------------------===//
2483
2484
2485 //===----------------------------------------------------------------------===//
2486 // XTYPE/SHIFT +
2487 //===----------------------------------------------------------------------===//
2488
2489 // Shift by immediate and accumulate.
2490 // Rx=add(#u8,asl(Rx,#U5))
2491 let isExtendable = 1, opExtendable = 1, isExtentSigned = 0, opExtentBits = 8,
2492 validSubTargets = HasV4SubT in
2493 def ADDi_ASLri_V4 : MInst_acc<(outs IntRegs:$dst),
2494             (ins u8Ext:$src1, IntRegs:$src2, u5Imm:$src3),
2495             "$dst = add(#$src1, asl($src2, #$src3))",
2496             [(set (i32 IntRegs:$dst),
2497                   (add (shl (i32 IntRegs:$src2), u5ImmPred:$src3),
2498                        u8ExtPred:$src1))],
2499             "$src2 = $dst">,
2500             Requires<[HasV4T]>;
2501
2502 // Rx=add(#u8,lsr(Rx,#U5))
2503 let isExtendable = 1, opExtendable = 1, isExtentSigned = 0, opExtentBits = 8,
2504 validSubTargets = HasV4SubT in
2505 def ADDi_LSRri_V4 : MInst_acc<(outs IntRegs:$dst),
2506             (ins u8Ext:$src1, IntRegs:$src2, u5Imm:$src3),
2507             "$dst = add(#$src1, lsr($src2, #$src3))",
2508             [(set (i32 IntRegs:$dst),
2509                   (add (srl (i32 IntRegs:$src2), u5ImmPred:$src3),
2510                        u8ExtPred:$src1))],
2511             "$src2 = $dst">,
2512             Requires<[HasV4T]>;
2513
2514 // Rx=sub(#u8,asl(Rx,#U5))
2515 let isExtendable = 1, opExtendable = 1, isExtentSigned = 0, opExtentBits = 8,
2516 validSubTargets = HasV4SubT in
2517 def SUBi_ASLri_V4 : MInst_acc<(outs IntRegs:$dst),
2518             (ins u8Ext:$src1, IntRegs:$src2, u5Imm:$src3),
2519             "$dst = sub(#$src1, asl($src2, #$src3))",
2520             [(set (i32 IntRegs:$dst),
2521                   (sub (shl (i32 IntRegs:$src2), u5ImmPred:$src3),
2522                        u8ExtPred:$src1))],
2523             "$src2 = $dst">,
2524             Requires<[HasV4T]>;
2525
2526 // Rx=sub(#u8,lsr(Rx,#U5))
2527 let isExtendable = 1, opExtendable = 1, isExtentSigned = 0, opExtentBits = 8,
2528 validSubTargets = HasV4SubT in
2529 def SUBi_LSRri_V4 : MInst_acc<(outs IntRegs:$dst),
2530             (ins u8Ext:$src1, IntRegs:$src2, u5Imm:$src3),
2531             "$dst = sub(#$src1, lsr($src2, #$src3))",
2532             [(set (i32 IntRegs:$dst),
2533                   (sub (srl (i32 IntRegs:$src2), u5ImmPred:$src3),
2534                        u8ExtPred:$src1))],
2535             "$src2 = $dst">,
2536             Requires<[HasV4T]>;
2537
2538
2539 //Shift by immediate and logical.
2540 //Rx=and(#u8,asl(Rx,#U5))
2541 let isExtendable = 1, opExtendable = 1, isExtentSigned = 0, opExtentBits = 8,
2542 validSubTargets = HasV4SubT in
2543 def ANDi_ASLri_V4 : MInst_acc<(outs IntRegs:$dst),
2544             (ins u8Ext:$src1, IntRegs:$src2, u5Imm:$src3),
2545             "$dst = and(#$src1, asl($src2, #$src3))",
2546             [(set (i32 IntRegs:$dst),
2547                   (and (shl (i32 IntRegs:$src2), u5ImmPred:$src3),
2548                        u8ExtPred:$src1))],
2549             "$src2 = $dst">,
2550             Requires<[HasV4T]>;
2551
2552 //Rx=and(#u8,lsr(Rx,#U5))
2553 let isExtendable = 1, opExtendable = 1, isExtentSigned = 0, opExtentBits = 8,
2554 validSubTargets = HasV4SubT in
2555 def ANDi_LSRri_V4 : MInst_acc<(outs IntRegs:$dst),
2556             (ins u8Ext:$src1, IntRegs:$src2, u5Imm:$src3),
2557             "$dst = and(#$src1, lsr($src2, #$src3))",
2558             [(set (i32 IntRegs:$dst),
2559                   (and (srl (i32 IntRegs:$src2), u5ImmPred:$src3),
2560                        u8ExtPred:$src1))],
2561             "$src2 = $dst">,
2562             Requires<[HasV4T]>;
2563
2564 //Rx=or(#u8,asl(Rx,#U5))
2565 let isExtendable = 1, opExtendable = 1, isExtentSigned = 0, opExtentBits = 8,
2566 AddedComplexity = 30, validSubTargets = HasV4SubT in
2567 def ORi_ASLri_V4 : MInst_acc<(outs IntRegs:$dst),
2568             (ins u8Ext:$src1, IntRegs:$src2, u5Imm:$src3),
2569             "$dst = or(#$src1, asl($src2, #$src3))",
2570             [(set (i32 IntRegs:$dst),
2571                   (or (shl (i32 IntRegs:$src2), u5ImmPred:$src3),
2572                       u8ExtPred:$src1))],
2573             "$src2 = $dst">,
2574             Requires<[HasV4T]>;
2575
2576 //Rx=or(#u8,lsr(Rx,#U5))
2577 let isExtendable = 1, opExtendable = 1, isExtentSigned = 0, opExtentBits = 8,
2578 AddedComplexity = 30, validSubTargets = HasV4SubT in
2579 def ORi_LSRri_V4 : MInst_acc<(outs IntRegs:$dst),
2580             (ins u8Ext:$src1, IntRegs:$src2, u5Imm:$src3),
2581             "$dst = or(#$src1, lsr($src2, #$src3))",
2582             [(set (i32 IntRegs:$dst),
2583                   (or (srl (i32 IntRegs:$src2), u5ImmPred:$src3),
2584                       u8ExtPred:$src1))],
2585             "$src2 = $dst">,
2586             Requires<[HasV4T]>;
2587
2588
2589 //Shift by register.
2590 //Rd=lsl(#s6,Rt)
2591 let validSubTargets = HasV4SubT in {
2592 def LSLi_V4 : MInst<(outs IntRegs:$dst), (ins s6Imm:$src1, IntRegs:$src2),
2593             "$dst = lsl(#$src1, $src2)",
2594             [(set (i32 IntRegs:$dst), (shl s6ImmPred:$src1,
2595                                            (i32 IntRegs:$src2)))]>,
2596             Requires<[HasV4T]>;
2597
2598
2599 //Shift by register and logical.
2600 //Rxx^=asl(Rss,Rt)
2601 def ASLd_rr_xor_V4 : MInst_acc<(outs DoubleRegs:$dst),
2602             (ins DoubleRegs:$src1, DoubleRegs:$src2, IntRegs:$src3),
2603             "$dst ^= asl($src2, $src3)",
2604             [(set (i64 DoubleRegs:$dst),
2605                   (xor (i64 DoubleRegs:$src1), (shl (i64 DoubleRegs:$src2),
2606                                                     (i32 IntRegs:$src3))))],
2607             "$src1 = $dst">,
2608             Requires<[HasV4T]>;
2609
2610 //Rxx^=asr(Rss,Rt)
2611 def ASRd_rr_xor_V4 : MInst_acc<(outs DoubleRegs:$dst),
2612             (ins DoubleRegs:$src1, DoubleRegs:$src2, IntRegs:$src3),
2613             "$dst ^= asr($src2, $src3)",
2614             [(set (i64 DoubleRegs:$dst),
2615                   (xor (i64 DoubleRegs:$src1), (sra (i64 DoubleRegs:$src2),
2616                                                     (i32 IntRegs:$src3))))],
2617             "$src1 = $dst">,
2618             Requires<[HasV4T]>;
2619
2620 //Rxx^=lsl(Rss,Rt)
2621 def LSLd_rr_xor_V4 : MInst_acc<(outs DoubleRegs:$dst),
2622             (ins DoubleRegs:$src1, DoubleRegs:$src2, IntRegs:$src3),
2623             "$dst ^= lsl($src2, $src3)",
2624             [(set (i64 DoubleRegs:$dst), (xor (i64 DoubleRegs:$src1),
2625                                               (shl (i64 DoubleRegs:$src2),
2626                                                    (i32 IntRegs:$src3))))],
2627             "$src1 = $dst">,
2628             Requires<[HasV4T]>;
2629
2630 //Rxx^=lsr(Rss,Rt)
2631 def LSRd_rr_xor_V4 : MInst_acc<(outs DoubleRegs:$dst),
2632             (ins DoubleRegs:$src1, DoubleRegs:$src2, IntRegs:$src3),
2633             "$dst ^= lsr($src2, $src3)",
2634             [(set (i64 DoubleRegs:$dst),
2635                   (xor (i64 DoubleRegs:$src1), (srl (i64 DoubleRegs:$src2),
2636                                                     (i32 IntRegs:$src3))))],
2637             "$src1 = $dst">,
2638             Requires<[HasV4T]>;
2639 }
2640
2641 //===----------------------------------------------------------------------===//
2642 // XTYPE/SHIFT -
2643 //===----------------------------------------------------------------------===//
2644
2645 //===----------------------------------------------------------------------===//
2646 // MEMOP: Word, Half, Byte
2647 //===----------------------------------------------------------------------===//
2648
2649 //===----------------------------------------------------------------------===//
2650 // MEMOP: Word
2651 //
2652 //  Implemented:
2653 //     MEMw_ADDi_indexed_V4  : memw(Rs+#u6:2)+=#U5
2654 //     MEMw_SUBi_indexed_V4  : memw(Rs+#u6:2)-=#U5
2655 //     MEMw_ADDr_indexed_V4  : memw(Rs+#u6:2)+=Rt
2656 //     MEMw_SUBr_indexed_V4  : memw(Rs+#u6:2)-=Rt
2657 //     MEMw_CLRr_indexed_V4  : memw(Rs+#u6:2)&=Rt
2658 //     MEMw_SETr_indexed_V4  : memw(Rs+#u6:2)|=Rt
2659 //     MEMw_ADDi_V4          : memw(Rs+#u6:2)+=#U5
2660 //     MEMw_SUBi_V4          : memw(Rs+#u6:2)-=#U5
2661 //     MEMw_ADDr_V4          : memw(Rs+#u6:2)+=Rt
2662 //     MEMw_SUBr_V4          : memw(Rs+#u6:2)-=Rt
2663 //     MEMw_CLRr_V4          : memw(Rs+#u6:2)&=Rt
2664 //     MEMw_SETr_V4          : memw(Rs+#u6:2)|=Rt
2665 //
2666 //   Not implemented:
2667 //     MEMw_CLRi_indexed_V4  : memw(Rs+#u6:2)=clrbit(#U5)
2668 //     MEMw_SETi_indexed_V4  : memw(Rs+#u6:2)=setbit(#U5)
2669 //     MEMw_CLRi_V4          : memw(Rs+#u6:2)=clrbit(#U5)
2670 //     MEMw_SETi_V4          : memw(Rs+#u6:2)=setbit(#U5)
2671 //===----------------------------------------------------------------------===//
2672
2673
2674
2675 // memw(Rs+#u6:2) += #U5
2676 let AddedComplexity = 30 in
2677 def MEMw_ADDi_indexed_MEM_V4 : MEMInst_V4<(outs),
2678             (ins IntRegs:$base, u6_2Imm:$offset, u5Imm:$addend),
2679             "memw($base+#$offset) += #$addend",
2680             []>,
2681             Requires<[HasV4T, UseMEMOP]>;
2682
2683 // memw(Rs+#u6:2) -= #U5
2684 let AddedComplexity = 30 in
2685 def MEMw_SUBi_indexed_MEM_V4 : MEMInst_V4<(outs),
2686             (ins IntRegs:$base, u6_2Imm:$offset, u5Imm:$subend),
2687             "memw($base+#$offset) -= #$subend",
2688             []>,
2689             Requires<[HasV4T, UseMEMOP]>;
2690
2691 // memw(Rs+#u6:2) += Rt
2692 let AddedComplexity = 30 in
2693 def MEMw_ADDr_indexed_MEM_V4 : MEMInst_V4<(outs),
2694             (ins IntRegs:$base, u6_2Imm:$offset, IntRegs:$addend),
2695             "memw($base+#$offset) += $addend",
2696             [(store (add (load (add (i32 IntRegs:$base), u6_2ImmPred:$offset)),
2697                          (i32 IntRegs:$addend)),
2698                     (add (i32 IntRegs:$base), u6_2ImmPred:$offset))]>,
2699             Requires<[HasV4T, UseMEMOP]>;
2700
2701 // memw(Rs+#u6:2) -= Rt
2702 let AddedComplexity = 30 in
2703 def MEMw_SUBr_indexed_MEM_V4 : MEMInst_V4<(outs),
2704             (ins IntRegs:$base, u6_2Imm:$offset, IntRegs:$subend),
2705             "memw($base+#$offset) -= $subend",
2706             [(store (sub (load (add (i32 IntRegs:$base), u6_2ImmPred:$offset)),
2707                          (i32 IntRegs:$subend)),
2708                     (add (i32 IntRegs:$base), u6_2ImmPred:$offset))]>,
2709             Requires<[HasV4T, UseMEMOP]>;
2710
2711 // memw(Rs+#u6:2) &= Rt
2712 let AddedComplexity = 30 in
2713 def MEMw_ANDr_indexed_MEM_V4 : MEMInst_V4<(outs),
2714             (ins IntRegs:$base, u6_2Imm:$offset, IntRegs:$andend),
2715             "memw($base+#$offset) &= $andend",
2716             [(store (and (load (add (i32 IntRegs:$base), u6_2ImmPred:$offset)),
2717                          (i32 IntRegs:$andend)),
2718                     (add (i32 IntRegs:$base), u6_2ImmPred:$offset))]>,
2719             Requires<[HasV4T, UseMEMOP]>;
2720
2721 // memw(Rs+#u6:2) |= Rt
2722 let AddedComplexity = 30 in
2723 def MEMw_ORr_indexed_MEM_V4 : MEMInst_V4<(outs),
2724             (ins IntRegs:$base, u6_2Imm:$offset, IntRegs:$orend),
2725             "memw($base+#$offset) |= $orend",
2726             [(store (or (load (add (i32 IntRegs:$base), u6_2ImmPred:$offset)),
2727                         (i32 IntRegs:$orend)),
2728                     (add (i32 IntRegs:$base), u6_2ImmPred:$offset))]>,
2729             Requires<[HasV4T, UseMEMOP]>;
2730
2731 // memw(Rs+#u6:2) += #U5
2732 let AddedComplexity = 30 in
2733 def MEMw_ADDi_MEM_V4 : MEMInst_V4<(outs),
2734             (ins MEMri:$addr, u5Imm:$addend),
2735             "memw($addr) += $addend",
2736             []>,
2737             Requires<[HasV4T, UseMEMOP]>;
2738
2739 // memw(Rs+#u6:2) -= #U5
2740 let AddedComplexity = 30 in
2741 def MEMw_SUBi_MEM_V4 : MEMInst_V4<(outs),
2742             (ins MEMri:$addr, u5Imm:$subend),
2743             "memw($addr) -= $subend",
2744             []>,
2745             Requires<[HasV4T, UseMEMOP]>;
2746
2747 // memw(Rs+#u6:2) += Rt
2748 let AddedComplexity = 30 in
2749 def MEMw_ADDr_MEM_V4 : MEMInst_V4<(outs),
2750             (ins MEMri:$addr, IntRegs:$addend),
2751             "memw($addr) += $addend",
2752             [(store (add (load ADDRriU6_2:$addr), (i32 IntRegs:$addend)),
2753                     ADDRriU6_2:$addr)]>,
2754             Requires<[HasV4T, UseMEMOP]>;
2755
2756 // memw(Rs+#u6:2) -= Rt
2757 let AddedComplexity = 30 in
2758 def MEMw_SUBr_MEM_V4 : MEMInst_V4<(outs),
2759             (ins MEMri:$addr, IntRegs:$subend),
2760             "memw($addr) -= $subend",
2761             [(store (sub (load ADDRriU6_2:$addr), (i32 IntRegs:$subend)),
2762                     ADDRriU6_2:$addr)]>,
2763             Requires<[HasV4T, UseMEMOP]>;
2764
2765 // memw(Rs+#u6:2) &= Rt
2766 let AddedComplexity = 30 in
2767 def MEMw_ANDr_MEM_V4 : MEMInst_V4<(outs),
2768             (ins MEMri:$addr, IntRegs:$andend),
2769             "memw($addr) &= $andend",
2770             [(store (and (load ADDRriU6_2:$addr), (i32 IntRegs:$andend)),
2771                     ADDRriU6_2:$addr)]>,
2772             Requires<[HasV4T, UseMEMOP]>;
2773
2774 // memw(Rs+#u6:2) |= Rt
2775 let AddedComplexity = 30 in
2776 def MEMw_ORr_MEM_V4 : MEMInst_V4<(outs),
2777             (ins MEMri:$addr, IntRegs:$orend),
2778             "memw($addr) |= $orend",
2779             [(store (or (load ADDRriU6_2:$addr), (i32 IntRegs:$orend)),
2780                     ADDRriU6_2:$addr)]>,
2781             Requires<[HasV4T, UseMEMOP]>;
2782
2783 //===----------------------------------------------------------------------===//
2784 // MEMOP: Halfword
2785 //
2786 //  Implemented:
2787 //     MEMh_ADDi_indexed_V4  : memw(Rs+#u6:2)+=#U5
2788 //     MEMh_SUBi_indexed_V4  : memw(Rs+#u6:2)-=#U5
2789 //     MEMh_ADDr_indexed_V4  : memw(Rs+#u6:2)+=Rt
2790 //     MEMh_SUBr_indexed_V4  : memw(Rs+#u6:2)-=Rt
2791 //     MEMh_CLRr_indexed_V4  : memw(Rs+#u6:2)&=Rt
2792 //     MEMh_SETr_indexed_V4  : memw(Rs+#u6:2)|=Rt
2793 //     MEMh_ADDi_V4          : memw(Rs+#u6:2)+=#U5
2794 //     MEMh_SUBi_V4          : memw(Rs+#u6:2)-=#U5
2795 //     MEMh_ADDr_V4          : memw(Rs+#u6:2)+=Rt
2796 //     MEMh_SUBr_V4          : memw(Rs+#u6:2)-=Rt
2797 //     MEMh_CLRr_V4          : memw(Rs+#u6:2)&=Rt
2798 //     MEMh_SETr_V4          : memw(Rs+#u6:2)|=Rt
2799 //
2800 //   Not implemented:
2801 //     MEMh_CLRi_indexed_V4  : memw(Rs+#u6:2)=clrbit(#U5)
2802 //     MEMh_SETi_indexed_V4  : memw(Rs+#u6:2)=setbit(#U5)
2803 //     MEMh_CLRi_V4          : memw(Rs+#u6:2)=clrbit(#U5)
2804 //     MEMh_SETi_V4          : memw(Rs+#u6:2)=setbit(#U5)
2805 //===----------------------------------------------------------------------===//
2806
2807
2808 // memh(Rs+#u6:1) += #U5
2809 let AddedComplexity = 30 in
2810 def MEMh_ADDi_indexed_MEM_V4 : MEMInst_V4<(outs),
2811             (ins IntRegs:$base, u6_1Imm:$offset, u5Imm:$addend),
2812             "memh($base+#$offset) += $addend",
2813             []>,
2814             Requires<[HasV4T, UseMEMOP]>;
2815
2816 // memh(Rs+#u6:1) -= #U5
2817 let AddedComplexity = 30 in
2818 def MEMh_SUBi_indexed_MEM_V4 : MEMInst_V4<(outs),
2819             (ins IntRegs:$base, u6_1Imm:$offset, u5Imm:$subend),
2820             "memh($base+#$offset) -= $subend",
2821             []>,
2822             Requires<[HasV4T, UseMEMOP]>;
2823
2824 // memh(Rs+#u6:1) += Rt
2825 let AddedComplexity = 30 in
2826 def MEMh_ADDr_indexed_MEM_V4 : MEMInst_V4<(outs),
2827             (ins IntRegs:$base, u6_1Imm:$offset, IntRegs:$addend),
2828             "memh($base+#$offset) += $addend",
2829             [(truncstorei16 (add (sextloadi16 (add (i32 IntRegs:$base),
2830                                                    u6_1ImmPred:$offset)),
2831                                  (i32 IntRegs:$addend)),
2832                             (add (i32 IntRegs:$base), u6_1ImmPred:$offset))]>,
2833             Requires<[HasV4T, UseMEMOP]>;
2834
2835 // memh(Rs+#u6:1) -= Rt
2836 let AddedComplexity = 30 in
2837 def MEMh_SUBr_indexed_MEM_V4 : MEMInst_V4<(outs),
2838             (ins IntRegs:$base, u6_1Imm:$offset, IntRegs:$subend),
2839             "memh($base+#$offset) -= $subend",
2840             [(truncstorei16 (sub (sextloadi16 (add (i32 IntRegs:$base),
2841                                                    u6_1ImmPred:$offset)),
2842                                  (i32 IntRegs:$subend)),
2843                             (add (i32 IntRegs:$base), u6_1ImmPred:$offset))]>,
2844             Requires<[HasV4T, UseMEMOP]>;
2845
2846 // memh(Rs+#u6:1) &= Rt
2847 let AddedComplexity = 30 in
2848 def MEMh_ANDr_indexed_MEM_V4 : MEMInst_V4<(outs),
2849             (ins IntRegs:$base, u6_1Imm:$offset, IntRegs:$andend),
2850             "memh($base+#$offset) += $andend",
2851             [(truncstorei16 (and (sextloadi16 (add (i32 IntRegs:$base),
2852                                                    u6_1ImmPred:$offset)),
2853                                  (i32 IntRegs:$andend)),
2854                             (add (i32 IntRegs:$base), u6_1ImmPred:$offset))]>,
2855             Requires<[HasV4T, UseMEMOP]>;
2856
2857 // memh(Rs+#u6:1) |= Rt
2858 let AddedComplexity = 30 in
2859 def MEMh_ORr_indexed_MEM_V4 : MEMInst_V4<(outs),
2860             (ins IntRegs:$base, u6_1Imm:$offset, IntRegs:$orend),
2861             "memh($base+#$offset) |= $orend",
2862             [(truncstorei16 (or (sextloadi16 (add (i32 IntRegs:$base),
2863                                               u6_1ImmPred:$offset)),
2864                              (i32 IntRegs:$orend)),
2865                             (add (i32 IntRegs:$base), u6_1ImmPred:$offset))]>,
2866             Requires<[HasV4T, UseMEMOP]>;
2867
2868 // memh(Rs+#u6:1) += #U5
2869 let AddedComplexity = 30 in
2870 def MEMh_ADDi_MEM_V4 : MEMInst_V4<(outs),
2871             (ins MEMri:$addr, u5Imm:$addend),
2872             "memh($addr) += $addend",
2873             []>,
2874             Requires<[HasV4T, UseMEMOP]>;
2875
2876 // memh(Rs+#u6:1) -= #U5
2877 let AddedComplexity = 30 in
2878 def MEMh_SUBi_MEM_V4 : MEMInst_V4<(outs),
2879             (ins MEMri:$addr, u5Imm:$subend),
2880             "memh($addr) -= $subend",
2881             []>,
2882             Requires<[HasV4T, UseMEMOP]>;
2883
2884 // memh(Rs+#u6:1) += Rt
2885 let AddedComplexity = 30 in
2886 def MEMh_ADDr_MEM_V4 : MEMInst_V4<(outs),
2887             (ins MEMri:$addr, IntRegs:$addend),
2888             "memh($addr) += $addend",
2889             [(truncstorei16 (add (sextloadi16 ADDRriU6_1:$addr),
2890                                  (i32 IntRegs:$addend)), ADDRriU6_1:$addr)]>,
2891             Requires<[HasV4T, UseMEMOP]>;
2892
2893 // memh(Rs+#u6:1) -= Rt
2894 let AddedComplexity = 30 in
2895 def MEMh_SUBr_MEM_V4 : MEMInst_V4<(outs),
2896             (ins MEMri:$addr, IntRegs:$subend),
2897             "memh($addr) -= $subend",
2898             [(truncstorei16 (sub (sextloadi16 ADDRriU6_1:$addr),
2899                                  (i32 IntRegs:$subend)), ADDRriU6_1:$addr)]>,
2900             Requires<[HasV4T, UseMEMOP]>;
2901
2902 // memh(Rs+#u6:1) &= Rt
2903 let AddedComplexity = 30 in
2904 def MEMh_ANDr_MEM_V4 : MEMInst_V4<(outs),
2905             (ins MEMri:$addr, IntRegs:$andend),
2906             "memh($addr) &= $andend",
2907             [(truncstorei16 (and (sextloadi16 ADDRriU6_1:$addr),
2908                                  (i32 IntRegs:$andend)), ADDRriU6_1:$addr)]>,
2909             Requires<[HasV4T, UseMEMOP]>;
2910
2911 // memh(Rs+#u6:1) |= Rt
2912 let AddedComplexity = 30 in
2913 def MEMh_ORr_MEM_V4 : MEMInst_V4<(outs),
2914             (ins MEMri:$addr, IntRegs:$orend),
2915             "memh($addr) |= $orend",
2916             [(truncstorei16 (or (sextloadi16 ADDRriU6_1:$addr),
2917                                 (i32 IntRegs:$orend)), ADDRriU6_1:$addr)]>,
2918             Requires<[HasV4T, UseMEMOP]>;
2919
2920
2921 //===----------------------------------------------------------------------===//
2922 // MEMOP: Byte
2923 //
2924 //  Implemented:
2925 //     MEMb_ADDi_indexed_V4  : memb(Rs+#u6:0)+=#U5
2926 //     MEMb_SUBi_indexed_V4  : memb(Rs+#u6:0)-=#U5
2927 //     MEMb_ADDr_indexed_V4  : memb(Rs+#u6:0)+=Rt
2928 //     MEMb_SUBr_indexed_V4  : memb(Rs+#u6:0)-=Rt
2929 //     MEMb_CLRr_indexed_V4  : memb(Rs+#u6:0)&=Rt
2930 //     MEMb_SETr_indexed_V4  : memb(Rs+#u6:0)|=Rt
2931 //     MEMb_ADDi_V4          : memb(Rs+#u6:0)+=#U5
2932 //     MEMb_SUBi_V4          : memb(Rs+#u6:0)-=#U5
2933 //     MEMb_ADDr_V4          : memb(Rs+#u6:0)+=Rt
2934 //     MEMb_SUBr_V4          : memb(Rs+#u6:0)-=Rt
2935 //     MEMb_CLRr_V4          : memb(Rs+#u6:0)&=Rt
2936 //     MEMb_SETr_V4          : memb(Rs+#u6:0)|=Rt
2937 //
2938 //   Not implemented:
2939 //     MEMb_CLRi_indexed_V4  : memb(Rs+#u6:0)=clrbit(#U5)
2940 //     MEMb_SETi_indexed_V4  : memb(Rs+#u6:0)=setbit(#U5)
2941 //     MEMb_CLRi_V4          : memb(Rs+#u6:0)=clrbit(#U5)
2942 //     MEMb_SETi_V4          : memb(Rs+#u6:0)=setbit(#U5)
2943 //===----------------------------------------------------------------------===//
2944
2945 // memb(Rs+#u6:0) += #U5
2946 let AddedComplexity = 30 in
2947 def MEMb_ADDi_indexed_MEM_V4 : MEMInst_V4<(outs),
2948             (ins IntRegs:$base, u6_0Imm:$offset, u5Imm:$addend),
2949             "memb($base+#$offset) += $addend",
2950             []>,
2951             Requires<[HasV4T, UseMEMOP]>;
2952
2953 // memb(Rs+#u6:0) -= #U5
2954 let AddedComplexity = 30 in
2955 def MEMb_SUBi_indexed_MEM_V4 : MEMInst_V4<(outs),
2956             (ins IntRegs:$base, u6_0Imm:$offset, u5Imm:$subend),
2957             "memb($base+#$offset) -= $subend",
2958             []>,
2959             Requires<[HasV4T, UseMEMOP]>;
2960
2961 // memb(Rs+#u6:0) += Rt
2962 let AddedComplexity = 30 in
2963 def MEMb_ADDr_indexed_MEM_V4 : MEMInst_V4<(outs),
2964             (ins IntRegs:$base, u6_0Imm:$offset, IntRegs:$addend),
2965             "memb($base+#$offset) += $addend",
2966             [(truncstorei8 (add (sextloadi8 (add (i32 IntRegs:$base),
2967                                                  u6_0ImmPred:$offset)),
2968                                 (i32 IntRegs:$addend)),
2969                            (add (i32 IntRegs:$base), u6_0ImmPred:$offset))]>,
2970             Requires<[HasV4T, UseMEMOP]>;
2971
2972 // memb(Rs+#u6:0) -= Rt
2973 let AddedComplexity = 30 in
2974 def MEMb_SUBr_indexed_MEM_V4 : MEMInst_V4<(outs),
2975             (ins IntRegs:$base, u6_0Imm:$offset, IntRegs:$subend),
2976             "memb($base+#$offset) -= $subend",
2977             [(truncstorei8 (sub (sextloadi8 (add (i32 IntRegs:$base),
2978                                                  u6_0ImmPred:$offset)),
2979                                 (i32 IntRegs:$subend)),
2980                            (add (i32 IntRegs:$base), u6_0ImmPred:$offset))]>,
2981             Requires<[HasV4T, UseMEMOP]>;
2982
2983 // memb(Rs+#u6:0) &= Rt
2984 let AddedComplexity = 30 in
2985 def MEMb_ANDr_indexed_MEM_V4 : MEMInst_V4<(outs),
2986             (ins IntRegs:$base, u6_0Imm:$offset, IntRegs:$andend),
2987             "memb($base+#$offset) += $andend",
2988             [(truncstorei8 (and (sextloadi8 (add (i32 IntRegs:$base),
2989                                                  u6_0ImmPred:$offset)),
2990                                 (i32 IntRegs:$andend)),
2991                            (add (i32 IntRegs:$base), u6_0ImmPred:$offset))]>,
2992             Requires<[HasV4T, UseMEMOP]>;
2993
2994 // memb(Rs+#u6:0) |= Rt
2995 let AddedComplexity = 30 in
2996 def MEMb_ORr_indexed_MEM_V4 : MEMInst_V4<(outs),
2997             (ins IntRegs:$base, u6_0Imm:$offset, IntRegs:$orend),
2998             "memb($base+#$offset) |= $orend",
2999             [(truncstorei8 (or (sextloadi8 (add (i32 IntRegs:$base),
3000                                                 u6_0ImmPred:$offset)),
3001                                (i32 IntRegs:$orend)),
3002                            (add (i32 IntRegs:$base), u6_0ImmPred:$offset))]>,
3003             Requires<[HasV4T, UseMEMOP]>;
3004
3005 // memb(Rs+#u6:0) += #U5
3006 let AddedComplexity = 30 in
3007 def MEMb_ADDi_MEM_V4 : MEMInst_V4<(outs),
3008             (ins MEMri:$addr, u5Imm:$addend),
3009             "memb($addr) += $addend",
3010             []>,
3011             Requires<[HasV4T, UseMEMOP]>;
3012
3013 // memb(Rs+#u6:0) -= #U5
3014 let AddedComplexity = 30 in
3015 def MEMb_SUBi_MEM_V4 : MEMInst_V4<(outs),
3016             (ins MEMri:$addr, u5Imm:$subend),
3017             "memb($addr) -= $subend",
3018             []>,
3019             Requires<[HasV4T, UseMEMOP]>;
3020
3021 // memb(Rs+#u6:0) += Rt
3022 let AddedComplexity = 30 in
3023 def MEMb_ADDr_MEM_V4 : MEMInst_V4<(outs),
3024             (ins MEMri:$addr, IntRegs:$addend),
3025             "memb($addr) += $addend",
3026             [(truncstorei8 (add (sextloadi8 ADDRriU6_0:$addr),
3027                                 (i32 IntRegs:$addend)), ADDRriU6_0:$addr)]>,
3028             Requires<[HasV4T, UseMEMOP]>;
3029
3030 // memb(Rs+#u6:0) -= Rt
3031 let AddedComplexity = 30 in
3032 def MEMb_SUBr_MEM_V4 : MEMInst_V4<(outs),
3033             (ins MEMri:$addr, IntRegs:$subend),
3034             "memb($addr) -= $subend",
3035             [(truncstorei8 (sub (sextloadi8 ADDRriU6_0:$addr),
3036                                 (i32 IntRegs:$subend)), ADDRriU6_0:$addr)]>,
3037             Requires<[HasV4T, UseMEMOP]>;
3038
3039 // memb(Rs+#u6:0) &= Rt
3040 let AddedComplexity = 30 in
3041 def MEMb_ANDr_MEM_V4 : MEMInst_V4<(outs),
3042             (ins MEMri:$addr, IntRegs:$andend),
3043             "memb($addr) &= $andend",
3044             [(truncstorei8 (and (sextloadi8 ADDRriU6_0:$addr),
3045                                 (i32 IntRegs:$andend)), ADDRriU6_0:$addr)]>,
3046             Requires<[HasV4T, UseMEMOP]>;
3047
3048 // memb(Rs+#u6:0) |= Rt
3049 let AddedComplexity = 30 in
3050 def MEMb_ORr_MEM_V4 : MEMInst_V4<(outs),
3051             (ins MEMri:$addr, IntRegs:$orend),
3052             "memb($addr) |= $orend",
3053             [(truncstorei8 (or (sextloadi8 ADDRriU6_0:$addr),
3054                                (i32 IntRegs:$orend)), ADDRriU6_0:$addr)]>,
3055             Requires<[HasV4T, UseMEMOP]>;
3056
3057
3058 //===----------------------------------------------------------------------===//
3059 // XTYPE/PRED +
3060 //===----------------------------------------------------------------------===//
3061
3062 // Hexagon V4 only supports these flavors of byte/half compare instructions:
3063 // EQ/GT/GTU. Other flavors like GE/GEU/LT/LTU/LE/LEU are not supported by
3064 // hardware. However, compiler can still implement these patterns through
3065 // appropriate patterns combinations based on current implemented patterns.
3066 // The implemented patterns are: EQ/GT/GTU.
3067 // Missing patterns are: GE/GEU/LT/LTU/LE/LEU.
3068
3069 // Following instruction is not being extended as it results into the
3070 // incorrect code for negative numbers.
3071 // Pd=cmpb.eq(Rs,#u8)
3072
3073 // p=!cmp.eq(r1,r2)
3074 let isCompare = 1, validSubTargets = HasV4SubT in
3075 def CMPnotEQ_rr : ALU32_rr<(outs PredRegs:$dst),
3076                            (ins IntRegs:$src1, IntRegs:$src2),
3077       "$dst = !cmp.eq($src1, $src2)",
3078       [(set (i1 PredRegs:$dst),
3079             (setne (i32 IntRegs:$src1), (i32 IntRegs:$src2)))]>,
3080       Requires<[HasV4T]>;
3081
3082 // p=!cmp.eq(r1,#s10)
3083 let isCompare = 1, validSubTargets = HasV4SubT in
3084 def CMPnotEQ_ri : ALU32_ri<(outs PredRegs:$dst),
3085                            (ins IntRegs:$src1, s10Ext:$src2),
3086       "$dst = !cmp.eq($src1, #$src2)",
3087       [(set (i1 PredRegs:$dst),
3088             (setne (i32 IntRegs:$src1), s10ImmPred:$src2))]>,
3089       Requires<[HasV4T]>;
3090
3091 // p=!cmp.gt(r1,r2)
3092 let isCompare = 1, validSubTargets = HasV4SubT in
3093 def CMPnotGT_rr : ALU32_rr<(outs PredRegs:$dst),
3094                            (ins IntRegs:$src1, IntRegs:$src2),
3095       "$dst = !cmp.gt($src1, $src2)",
3096       [(set (i1 PredRegs:$dst),
3097             (not (setgt (i32 IntRegs:$src1), (i32 IntRegs:$src2))))]>,
3098       Requires<[HasV4T]>;
3099
3100 // p=!cmp.gt(r1,#s10)
3101 let isCompare = 1, validSubTargets = HasV4SubT in
3102 def CMPnotGT_ri : ALU32_ri<(outs PredRegs:$dst),
3103                            (ins IntRegs:$src1, s10Ext:$src2),
3104       "$dst = !cmp.gt($src1, #$src2)",
3105       [(set (i1 PredRegs:$dst),
3106             (not (setgt (i32 IntRegs:$src1), s10ImmPred:$src2)))]>,
3107       Requires<[HasV4T]>;
3108
3109 // p=!cmp.gtu(r1,r2)
3110 let isCompare = 1, validSubTargets = HasV4SubT in
3111 def CMPnotGTU_rr : ALU32_rr<(outs PredRegs:$dst),
3112                             (ins IntRegs:$src1, IntRegs:$src2),
3113       "$dst = !cmp.gtu($src1, $src2)",
3114       [(set (i1 PredRegs:$dst),
3115             (not (setugt (i32 IntRegs:$src1), (i32 IntRegs:$src2))))]>,
3116       Requires<[HasV4T]>;
3117
3118 // p=!cmp.gtu(r1,#u9)
3119 let isCompare = 1, validSubTargets = HasV4SubT in
3120 def CMPnotGTU_ri : ALU32_ri<(outs PredRegs:$dst),
3121                             (ins IntRegs:$src1, u9Ext:$src2),
3122       "$dst = !cmp.gtu($src1, #$src2)",
3123       [(set (i1 PredRegs:$dst),
3124             (not (setugt (i32 IntRegs:$src1), u9ImmPred:$src2)))]>,
3125       Requires<[HasV4T]>;
3126
3127 let isCompare = 1, validSubTargets = HasV4SubT in
3128 def CMPbEQri_V4 : MInst<(outs PredRegs:$dst),
3129             (ins IntRegs:$src1, u8Imm:$src2),
3130             "$dst = cmpb.eq($src1, #$src2)",
3131             [(set (i1 PredRegs:$dst),
3132                   (seteq (and (i32 IntRegs:$src1), 255), u8ImmPred:$src2))]>,
3133             Requires<[HasV4T]>;
3134
3135 def : Pat <(brcond (i1 (setne (and (i32 IntRegs:$src1), 255), u8ImmPred:$src2)),
3136                        bb:$offset),
3137       (JMP_cNot (CMPbEQri_V4 (i32 IntRegs:$src1), u8ImmPred:$src2),
3138                 bb:$offset)>,
3139       Requires<[HasV4T]>;
3140
3141 // Pd=cmpb.eq(Rs,Rt)
3142 let isCompare = 1, validSubTargets = HasV4SubT in
3143 def CMPbEQrr_ubub_V4 : MInst<(outs PredRegs:$dst),
3144             (ins IntRegs:$src1, IntRegs:$src2),
3145             "$dst = cmpb.eq($src1, $src2)",
3146             [(set (i1 PredRegs:$dst),
3147                   (seteq (and (xor (i32 IntRegs:$src1),
3148                                    (i32 IntRegs:$src2)), 255), 0))]>,
3149             Requires<[HasV4T]>;
3150
3151 // Pd=cmpb.eq(Rs,Rt)
3152 let isCompare = 1, validSubTargets = HasV4SubT in
3153 def CMPbEQrr_sbsb_V4 : MInst<(outs PredRegs:$dst),
3154             (ins IntRegs:$src1, IntRegs:$src2),
3155             "$dst = cmpb.eq($src1, $src2)",
3156             [(set (i1 PredRegs:$dst),
3157                   (seteq (shl (i32 IntRegs:$src1), (i32 24)),
3158                          (shl (i32 IntRegs:$src2), (i32 24))))]>,
3159             Requires<[HasV4T]>;
3160
3161 // Pd=cmpb.gt(Rs,Rt)
3162 let isCompare = 1, validSubTargets = HasV4SubT in
3163 def CMPbGTrr_V4 : MInst<(outs PredRegs:$dst),
3164             (ins IntRegs:$src1, IntRegs:$src2),
3165             "$dst = cmpb.gt($src1, $src2)",
3166             [(set (i1 PredRegs:$dst),
3167                   (setgt (shl (i32 IntRegs:$src1), (i32 24)),
3168                          (shl (i32 IntRegs:$src2), (i32 24))))]>,
3169             Requires<[HasV4T]>;
3170
3171 // Pd=cmpb.gtu(Rs,#u7)
3172 let isExtendable = 1, opExtendable = 2, isExtentSigned = 0, opExtentBits = 7,
3173 isCompare = 1, validSubTargets = HasV4SubT, CextOpcode = "CMPbGTU", InputType = "imm" in
3174 def CMPbGTUri_V4 : MInst<(outs PredRegs:$dst),
3175             (ins IntRegs:$src1, u7Ext:$src2),
3176             "$dst = cmpb.gtu($src1, #$src2)",
3177             [(set (i1 PredRegs:$dst), (setugt (and (i32 IntRegs:$src1), 255),
3178                                               u7ExtPred:$src2))]>,
3179             Requires<[HasV4T]>, ImmRegRel;
3180
3181 // SDNode for converting immediate C to C-1.
3182 def DEC_CONST_BYTE : SDNodeXForm<imm, [{
3183    // Return the byte immediate const-1 as an SDNode.
3184    int32_t imm = N->getSExtValue();
3185    return XformU7ToU7M1Imm(imm);
3186 }]>;
3187
3188 // For the sequence
3189 //   zext( seteq ( and(Rs, 255), u8))
3190 // Generate
3191 //   Pd=cmpb.eq(Rs, #u8)
3192 //   if (Pd.new) Rd=#1
3193 //   if (!Pd.new) Rd=#0
3194 def : Pat <(i32 (zext (i1 (seteq (i32 (and (i32 IntRegs:$Rs), 255)),
3195                                            u8ExtPred:$u8)))),
3196            (i32 (TFR_condset_ii (i1 (CMPbEQri_V4 (i32 IntRegs:$Rs),
3197                                                  (u8ExtPred:$u8))),
3198                                 1, 0))>,
3199            Requires<[HasV4T]>;
3200
3201 // For the sequence
3202 //   zext( setne ( and(Rs, 255), u8))
3203 // Generate
3204 //   Pd=cmpb.eq(Rs, #u8)
3205 //   if (Pd.new) Rd=#0
3206 //   if (!Pd.new) Rd=#1
3207 def : Pat <(i32 (zext (i1 (setne (i32 (and (i32 IntRegs:$Rs), 255)),
3208                                            u8ExtPred:$u8)))),
3209            (i32 (TFR_condset_ii (i1 (CMPbEQri_V4 (i32 IntRegs:$Rs),
3210                                                  (u8ExtPred:$u8))),
3211                                 0, 1))>,
3212            Requires<[HasV4T]>;
3213
3214 // For the sequence
3215 //   zext( seteq (Rs, and(Rt, 255)))
3216 // Generate
3217 //   Pd=cmpb.eq(Rs, Rt)
3218 //   if (Pd.new) Rd=#1
3219 //   if (!Pd.new) Rd=#0
3220 def : Pat <(i32 (zext (i1 (seteq (i32 IntRegs:$Rt),
3221                                  (i32 (and (i32 IntRegs:$Rs), 255)))))),
3222            (i32 (TFR_condset_ii (i1 (CMPbEQrr_ubub_V4 (i32 IntRegs:$Rs),
3223                                                       (i32 IntRegs:$Rt))),
3224                                 1, 0))>,
3225            Requires<[HasV4T]>;
3226
3227 // For the sequence
3228 //   zext( setne (Rs, and(Rt, 255)))
3229 // Generate
3230 //   Pd=cmpb.eq(Rs, Rt)
3231 //   if (Pd.new) Rd=#0
3232 //   if (!Pd.new) Rd=#1
3233 def : Pat <(i32 (zext (i1 (setne (i32 IntRegs:$Rt),
3234                                  (i32 (and (i32 IntRegs:$Rs), 255)))))),
3235            (i32 (TFR_condset_ii (i1 (CMPbEQrr_ubub_V4 (i32 IntRegs:$Rs),
3236                                                       (i32 IntRegs:$Rt))),
3237                                 0, 1))>,
3238            Requires<[HasV4T]>;
3239
3240 // For the sequence
3241 //   zext( setugt ( and(Rs, 255), u8))
3242 // Generate
3243 //   Pd=cmpb.gtu(Rs, #u8)
3244 //   if (Pd.new) Rd=#1
3245 //   if (!Pd.new) Rd=#0
3246 def : Pat <(i32 (zext (i1 (setugt (i32 (and (i32 IntRegs:$Rs), 255)),
3247                                             u8ExtPred:$u8)))),
3248            (i32 (TFR_condset_ii (i1 (CMPbGTUri_V4 (i32 IntRegs:$Rs),
3249                                                   (u8ExtPred:$u8))),
3250                                 1, 0))>,
3251            Requires<[HasV4T]>;
3252
3253 // For the sequence
3254 //   zext( setugt ( and(Rs, 254), u8))
3255 // Generate
3256 //   Pd=cmpb.gtu(Rs, #u8)
3257 //   if (Pd.new) Rd=#1
3258 //   if (!Pd.new) Rd=#0
3259 def : Pat <(i32 (zext (i1 (setugt (i32 (and (i32 IntRegs:$Rs), 254)),
3260                                             u8ExtPred:$u8)))),
3261            (i32 (TFR_condset_ii (i1 (CMPbGTUri_V4 (i32 IntRegs:$Rs),
3262                                                   (u8ExtPred:$u8))),
3263                                 1, 0))>,
3264            Requires<[HasV4T]>;
3265
3266 // For the sequence
3267 //   zext( setult ( Rs, Rt))
3268 // Generate
3269 //   Pd=cmp.ltu(Rs, Rt)
3270 //   if (Pd.new) Rd=#1
3271 //   if (!Pd.new) Rd=#0
3272 // cmp.ltu(Rs, Rt) -> cmp.gtu(Rt, Rs)
3273 def : Pat <(i32 (zext (i1 (setult (i32 IntRegs:$Rs), (i32 IntRegs:$Rt))))),
3274            (i32 (TFR_condset_ii (i1 (CMPGTUrr (i32 IntRegs:$Rt),
3275                                               (i32 IntRegs:$Rs))),
3276                                 1, 0))>,
3277            Requires<[HasV4T]>;
3278
3279 // For the sequence
3280 //   zext( setlt ( Rs, Rt))
3281 // Generate
3282 //   Pd=cmp.lt(Rs, Rt)
3283 //   if (Pd.new) Rd=#1
3284 //   if (!Pd.new) Rd=#0
3285 // cmp.lt(Rs, Rt) -> cmp.gt(Rt, Rs)
3286 def : Pat <(i32 (zext (i1 (setlt (i32 IntRegs:$Rs), (i32 IntRegs:$Rt))))),
3287            (i32 (TFR_condset_ii (i1 (CMPGTrr (i32 IntRegs:$Rt),
3288                                              (i32 IntRegs:$Rs))),
3289                                 1, 0))>,
3290            Requires<[HasV4T]>;
3291
3292 // For the sequence
3293 //   zext( setugt ( Rs, Rt))
3294 // Generate
3295 //   Pd=cmp.gtu(Rs, Rt)
3296 //   if (Pd.new) Rd=#1
3297 //   if (!Pd.new) Rd=#0
3298 def : Pat <(i32 (zext (i1 (setugt (i32 IntRegs:$Rs), (i32 IntRegs:$Rt))))),
3299            (i32 (TFR_condset_ii (i1 (CMPGTUrr (i32 IntRegs:$Rs),
3300                                               (i32 IntRegs:$Rt))),
3301                                 1, 0))>,
3302            Requires<[HasV4T]>;
3303
3304 // This pattern interefers with coremark performance, not implementing at this
3305 // time.
3306 // For the sequence
3307 //   zext( setgt ( Rs, Rt))
3308 // Generate
3309 //   Pd=cmp.gt(Rs, Rt)
3310 //   if (Pd.new) Rd=#1
3311 //   if (!Pd.new) Rd=#0
3312
3313 // For the sequence
3314 //   zext( setuge ( Rs, Rt))
3315 // Generate
3316 //   Pd=cmp.ltu(Rs, Rt)
3317 //   if (Pd.new) Rd=#0
3318 //   if (!Pd.new) Rd=#1
3319 // cmp.ltu(Rs, Rt) -> cmp.gtu(Rt, Rs)
3320 def : Pat <(i32 (zext (i1 (setuge (i32 IntRegs:$Rs), (i32 IntRegs:$Rt))))),
3321            (i32 (TFR_condset_ii (i1 (CMPGTUrr (i32 IntRegs:$Rt),
3322                                               (i32 IntRegs:$Rs))),
3323                                 0, 1))>,
3324            Requires<[HasV4T]>;
3325
3326 // For the sequence
3327 //   zext( setge ( Rs, Rt))
3328 // Generate
3329 //   Pd=cmp.lt(Rs, Rt)
3330 //   if (Pd.new) Rd=#0
3331 //   if (!Pd.new) Rd=#1
3332 // cmp.lt(Rs, Rt) -> cmp.gt(Rt, Rs)
3333 def : Pat <(i32 (zext (i1 (setge (i32 IntRegs:$Rs), (i32 IntRegs:$Rt))))),
3334            (i32 (TFR_condset_ii (i1 (CMPGTrr (i32 IntRegs:$Rt),
3335                                              (i32 IntRegs:$Rs))),
3336                                 0, 1))>,
3337            Requires<[HasV4T]>;
3338
3339 // For the sequence
3340 //   zext( setule ( Rs, Rt))
3341 // Generate
3342 //   Pd=cmp.gtu(Rs, Rt)
3343 //   if (Pd.new) Rd=#0
3344 //   if (!Pd.new) Rd=#1
3345 def : Pat <(i32 (zext (i1 (setule (i32 IntRegs:$Rs), (i32 IntRegs:$Rt))))),
3346            (i32 (TFR_condset_ii (i1 (CMPGTUrr (i32 IntRegs:$Rs),
3347                                               (i32 IntRegs:$Rt))),
3348                                 0, 1))>,
3349            Requires<[HasV4T]>;
3350
3351 // For the sequence
3352 //   zext( setle ( Rs, Rt))
3353 // Generate
3354 //   Pd=cmp.gt(Rs, Rt)
3355 //   if (Pd.new) Rd=#0
3356 //   if (!Pd.new) Rd=#1
3357 def : Pat <(i32 (zext (i1 (setle (i32 IntRegs:$Rs), (i32 IntRegs:$Rt))))),
3358            (i32 (TFR_condset_ii (i1 (CMPGTrr (i32 IntRegs:$Rs),
3359                                              (i32 IntRegs:$Rt))),
3360                                 0, 1))>,
3361            Requires<[HasV4T]>;
3362
3363 // For the sequence
3364 //   zext( setult ( and(Rs, 255), u8))
3365 // Use the isdigit transformation below
3366
3367 // Generate code of the form 'mux_ii(cmpbgtu(Rdd, C-1),0,1)'
3368 // for C code of the form r = ((c>='0') & (c<='9')) ? 1 : 0;.
3369 // The isdigit transformation relies on two 'clever' aspects:
3370 // 1) The data type is unsigned which allows us to eliminate a zero test after
3371 //    biasing the expression by 48. We are depending on the representation of
3372 //    the unsigned types, and semantics.
3373 // 2) The front end has converted <= 9 into < 10 on entry to LLVM
3374 //
3375 // For the C code:
3376 //   retval = ((c>='0') & (c<='9')) ? 1 : 0;
3377 // The code is transformed upstream of llvm into
3378 //   retval = (c-48) < 10 ? 1 : 0;
3379 let AddedComplexity = 139 in
3380 def : Pat <(i32 (zext (i1 (setult (i32 (and (i32 IntRegs:$src1), 255)),
3381                                   u7StrictPosImmPred:$src2)))),
3382   (i32 (MUX_ii (i1 (CMPbGTUri_V4 (i32 IntRegs:$src1),
3383                                  (DEC_CONST_BYTE u7StrictPosImmPred:$src2))),
3384                    0, 1))>,
3385                    Requires<[HasV4T]>;
3386
3387 // Pd=cmpb.gtu(Rs,Rt)
3388 let isCompare = 1, validSubTargets = HasV4SubT, CextOpcode = "CMPbGTU",
3389 InputType = "reg" in
3390 def CMPbGTUrr_V4 : MInst<(outs PredRegs:$dst),
3391             (ins IntRegs:$src1, IntRegs:$src2),
3392             "$dst = cmpb.gtu($src1, $src2)",
3393             [(set (i1 PredRegs:$dst), (setugt (and (i32 IntRegs:$src1), 255),
3394                                              (and (i32 IntRegs:$src2), 255)))]>,
3395             Requires<[HasV4T]>, ImmRegRel;
3396
3397 // Following instruction is not being extended as it results into the incorrect
3398 // code for negative numbers.
3399
3400 // Signed half compare(.eq) ri.
3401 // Pd=cmph.eq(Rs,#s8)
3402 let isCompare = 1, validSubTargets = HasV4SubT in
3403 def CMPhEQri_V4 : MInst<(outs PredRegs:$dst),
3404             (ins IntRegs:$src1, s8Imm:$src2),
3405             "$dst = cmph.eq($src1, #$src2)",
3406             [(set (i1 PredRegs:$dst), (seteq (and (i32 IntRegs:$src1), 65535),
3407                                              s8ImmPred:$src2))]>,
3408             Requires<[HasV4T]>;
3409
3410 // Signed half compare(.eq) rr.
3411 // Case 1: xor + and, then compare:
3412 //   r0=xor(r0,r1)
3413 //   r0=and(r0,#0xffff)
3414 //   p0=cmp.eq(r0,#0)
3415 // Pd=cmph.eq(Rs,Rt)
3416 let isCompare = 1, validSubTargets = HasV4SubT in
3417 def CMPhEQrr_xor_V4 : MInst<(outs PredRegs:$dst),
3418             (ins IntRegs:$src1, IntRegs:$src2),
3419             "$dst = cmph.eq($src1, $src2)",
3420             [(set (i1 PredRegs:$dst), (seteq (and (xor (i32 IntRegs:$src1),
3421                                                        (i32 IntRegs:$src2)),
3422                                                   65535), 0))]>,
3423             Requires<[HasV4T]>;
3424
3425 // Signed half compare(.eq) rr.
3426 // Case 2: shift left 16 bits then compare:
3427 //   r0=asl(r0,16)
3428 //   r1=asl(r1,16)
3429 //   p0=cmp.eq(r0,r1)
3430 // Pd=cmph.eq(Rs,Rt)
3431 let isCompare = 1, validSubTargets = HasV4SubT in
3432 def CMPhEQrr_shl_V4 : MInst<(outs PredRegs:$dst),
3433             (ins IntRegs:$src1, IntRegs:$src2),
3434             "$dst = cmph.eq($src1, $src2)",
3435             [(set (i1 PredRegs:$dst),
3436                   (seteq (shl (i32 IntRegs:$src1), (i32 16)),
3437                          (shl (i32 IntRegs:$src2), (i32 16))))]>,
3438             Requires<[HasV4T]>;
3439
3440 /* Incorrect Pattern -- immediate should be right shifted before being
3441 used in the cmph.gt instruction.
3442 // Signed half compare(.gt) ri.
3443 // Pd=cmph.gt(Rs,#s8)
3444
3445 let isExtendable = 1, opExtendable = 2, isExtentSigned = 1, opExtentBits = 8,
3446 isCompare = 1, validSubTargets = HasV4SubT in
3447 def CMPhGTri_V4 : MInst<(outs PredRegs:$dst),
3448             (ins IntRegs:$src1, s8Ext:$src2),
3449             "$dst = cmph.gt($src1, #$src2)",
3450             [(set (i1 PredRegs:$dst),
3451                   (setgt (shl (i32 IntRegs:$src1), (i32 16)),
3452                          s8ExtPred:$src2))]>,
3453             Requires<[HasV4T]>;
3454 */
3455
3456 // Signed half compare(.gt) rr.
3457 // Pd=cmph.gt(Rs,Rt)
3458 let isCompare = 1, validSubTargets = HasV4SubT in
3459 def CMPhGTrr_shl_V4 : MInst<(outs PredRegs:$dst),
3460             (ins IntRegs:$src1, IntRegs:$src2),
3461             "$dst = cmph.gt($src1, $src2)",
3462             [(set (i1 PredRegs:$dst),
3463                   (setgt (shl (i32 IntRegs:$src1), (i32 16)),
3464                          (shl (i32 IntRegs:$src2), (i32 16))))]>,
3465             Requires<[HasV4T]>;
3466
3467 // Unsigned half compare rr (.gtu).
3468 // Pd=cmph.gtu(Rs,Rt)
3469 let isCompare = 1, validSubTargets = HasV4SubT, CextOpcode = "CMPhGTU",
3470 InputType = "reg" in
3471 def CMPhGTUrr_V4 : MInst<(outs PredRegs:$dst),
3472             (ins IntRegs:$src1, IntRegs:$src2),
3473             "$dst = cmph.gtu($src1, $src2)",
3474             [(set (i1 PredRegs:$dst),
3475                   (setugt (and (i32 IntRegs:$src1), 65535),
3476                           (and (i32 IntRegs:$src2), 65535)))]>,
3477             Requires<[HasV4T]>, ImmRegRel;
3478
3479 // Unsigned half compare ri (.gtu).
3480 // Pd=cmph.gtu(Rs,#u7)
3481 let isExtendable = 1, opExtendable = 2, isExtentSigned = 0, opExtentBits = 7,
3482 isCompare = 1, validSubTargets = HasV4SubT, CextOpcode = "CMPhGTU",
3483 InputType = "imm" in
3484 def CMPhGTUri_V4 : MInst<(outs PredRegs:$dst),
3485             (ins IntRegs:$src1, u7Ext:$src2),
3486             "$dst = cmph.gtu($src1, #$src2)",
3487             [(set (i1 PredRegs:$dst), (setugt (and (i32 IntRegs:$src1), 65535),
3488                                               u7ExtPred:$src2))]>,
3489             Requires<[HasV4T]>, ImmRegRel;
3490
3491 let validSubTargets = HasV4SubT in
3492 def NTSTBIT_rr : SInst<(outs PredRegs:$dst), (ins IntRegs:$src1, IntRegs:$src2),
3493     "$dst = !tstbit($src1, $src2)",
3494     [(set (i1 PredRegs:$dst),
3495           (seteq (and (shl 1, (i32 IntRegs:$src2)), (i32 IntRegs:$src1)), 0))]>,
3496     Requires<[HasV4T]>;
3497
3498 let validSubTargets = HasV4SubT in
3499 def NTSTBIT_ri : SInst<(outs PredRegs:$dst), (ins IntRegs:$src1, u5Imm:$src2),
3500     "$dst = !tstbit($src1, $src2)",
3501     [(set (i1 PredRegs:$dst),
3502           (seteq (and (shl 1, u5ImmPred:$src2), (i32 IntRegs:$src1)), 0))]>,
3503     Requires<[HasV4T]>;
3504
3505 //===----------------------------------------------------------------------===//
3506 // XTYPE/PRED -
3507 //===----------------------------------------------------------------------===//
3508
3509 //Deallocate frame and return.
3510 //    dealloc_return
3511 let isReturn = 1, isTerminator = 1, isBarrier = 1, isPredicable = 1,
3512   Defs = [R29, R30, R31, PC], Uses = [R29, R31], neverHasSideEffects = 1 in {
3513   def DEALLOC_RET_V4 : NVInst_V4<(outs), (ins i32imm:$amt1),
3514             "dealloc_return",
3515             []>,
3516             Requires<[HasV4T]>;
3517 }
3518
3519 // Restore registers and dealloc return function call.
3520 let isCall = 1, isBarrier = 1, isReturn = 1, isTerminator = 1,
3521   Defs = [R29, R30, R31, PC] in {
3522   def RESTORE_DEALLOC_RET_JMP_V4 : JInst<(outs),
3523                                    (ins calltarget:$dst),
3524              "jump $dst // Restore_and_dealloc_return",
3525              []>,
3526              Requires<[HasV4T]>;
3527 }
3528
3529 // Restore registers and dealloc frame before a tail call.
3530 let isCall = 1, isBarrier = 1,
3531   Defs = [R29, R30, R31, PC] in {
3532   def RESTORE_DEALLOC_BEFORE_TAILCALL_V4 : JInst<(outs),
3533                                            (ins calltarget:$dst),
3534              "call $dst // Restore_and_dealloc_before_tailcall",
3535              []>,
3536              Requires<[HasV4T]>;
3537 }
3538
3539 // Save registers function call.
3540 let isCall = 1, isBarrier = 1,
3541   Uses = [R29, R31] in {
3542   def SAVE_REGISTERS_CALL_V4 : JInst<(outs),
3543                                (ins calltarget:$dst),
3544              "call $dst // Save_calle_saved_registers",
3545              []>,
3546              Requires<[HasV4T]>;
3547 }
3548
3549 //    if (Ps) dealloc_return
3550 let isReturn = 1, isTerminator = 1,
3551     Defs = [R29, R30, R31, PC], Uses = [R29, R31], neverHasSideEffects = 1,
3552     isPredicated = 1 in {
3553   def DEALLOC_RET_cPt_V4 : NVInst_V4<(outs),
3554                            (ins PredRegs:$src1, i32imm:$amt1),
3555             "if ($src1) dealloc_return",
3556             []>,
3557             Requires<[HasV4T]>;
3558 }
3559
3560 //    if (!Ps) dealloc_return
3561 let isReturn = 1, isTerminator = 1,
3562     Defs = [R29, R30, R31, PC], Uses = [R29, R31], neverHasSideEffects = 1,
3563     isPredicated = 1 in {
3564   def DEALLOC_RET_cNotPt_V4 : NVInst_V4<(outs), (ins PredRegs:$src1,
3565                                                      i32imm:$amt1),
3566             "if (!$src1) dealloc_return",
3567             []>,
3568             Requires<[HasV4T]>;
3569 }
3570
3571 //    if (Ps.new) dealloc_return:nt
3572 let isReturn = 1, isTerminator = 1,
3573     Defs = [R29, R30, R31, PC], Uses = [R29, R31], neverHasSideEffects = 1,
3574     isPredicated = 1 in {
3575   def DEALLOC_RET_cdnPnt_V4 : NVInst_V4<(outs), (ins PredRegs:$src1,
3576                                                      i32imm:$amt1),
3577             "if ($src1.new) dealloc_return:nt",
3578             []>,
3579             Requires<[HasV4T]>;
3580 }
3581
3582 //    if (!Ps.new) dealloc_return:nt
3583 let isReturn = 1, isTerminator = 1,
3584     Defs = [R29, R30, R31, PC], Uses = [R29, R31], neverHasSideEffects = 1,
3585     isPredicated = 1 in {
3586   def DEALLOC_RET_cNotdnPnt_V4 : NVInst_V4<(outs), (ins PredRegs:$src1,
3587                                                         i32imm:$amt1),
3588             "if (!$src1.new) dealloc_return:nt",
3589             []>,
3590             Requires<[HasV4T]>;
3591 }
3592
3593 //    if (Ps.new) dealloc_return:t
3594 let isReturn = 1, isTerminator = 1,
3595     Defs = [R29, R30, R31, PC], Uses = [R29, R31], neverHasSideEffects = 1,
3596     isPredicated = 1 in {
3597   def DEALLOC_RET_cdnPt_V4 : NVInst_V4<(outs), (ins PredRegs:$src1,
3598                                                     i32imm:$amt1),
3599             "if ($src1.new) dealloc_return:t",
3600             []>,
3601             Requires<[HasV4T]>;
3602 }
3603
3604 //    if (!Ps.new) dealloc_return:nt
3605 let isReturn = 1, isTerminator = 1,
3606     Defs = [R29, R30, R31, PC], Uses = [R29, R31], neverHasSideEffects = 1,
3607     isPredicated = 1 in {
3608   def DEALLOC_RET_cNotdnPt_V4 : NVInst_V4<(outs), (ins PredRegs:$src1,
3609                                                        i32imm:$amt1),
3610             "if (!$src1.new) dealloc_return:t",
3611             []>,
3612             Requires<[HasV4T]>;
3613 }
3614
3615 // Load/Store with absolute addressing mode
3616 // memw(#u6)=Rt
3617
3618 multiclass ST_Abs_Predbase<string mnemonic, RegisterClass RC, bit isNot,
3619                            bit isPredNew> {
3620   let PNewValue = !if(isPredNew, "new", "") in
3621   def NAME#_V4 : STInst2<(outs),
3622             (ins PredRegs:$src1, globaladdressExt:$absaddr, RC: $src2),
3623             !if(isNot, "if (!$src1", "if ($src1")#!if(isPredNew, ".new) ",
3624             ") ")#mnemonic#"(##$absaddr) = $src2",
3625             []>,
3626             Requires<[HasV4T]>;
3627 }
3628
3629 multiclass ST_Abs_Pred<string mnemonic, RegisterClass RC, bit PredNot> {
3630   let PredSense = !if(PredNot, "false", "true") in {
3631     defm _c#NAME : ST_Abs_Predbase<mnemonic, RC, PredNot, 0>;
3632     // Predicate new
3633     defm _cdn#NAME : ST_Abs_Predbase<mnemonic, RC, PredNot, 1>;
3634   }
3635 }
3636
3637 let isNVStorable = 1, isExtended = 1, neverHasSideEffects = 1 in
3638 multiclass ST_Abs<string mnemonic, string CextOp, RegisterClass RC> {
3639   let CextOpcode = CextOp, BaseOpcode = CextOp#_abs in {
3640     let opExtendable = 0, isPredicable = 1 in
3641     def NAME#_V4 : STInst2<(outs),
3642             (ins globaladdressExt:$absaddr, RC:$src),
3643             mnemonic#"(##$absaddr) = $src",
3644             []>,
3645             Requires<[HasV4T]>;
3646
3647     let opExtendable = 1, isPredicated = 1 in {
3648       defm Pt : ST_Abs_Pred<mnemonic, RC, 0>;
3649       defm NotPt : ST_Abs_Pred<mnemonic, RC, 1>;
3650     }
3651   }
3652 }
3653
3654 multiclass ST_Abs_Predbase_nv<string mnemonic, RegisterClass RC, bit isNot,
3655                            bit isPredNew> {
3656   let PNewValue = !if(isPredNew, "new", "") in
3657   def NAME#_nv_V4 : NVInst_V4<(outs),
3658             (ins PredRegs:$src1, globaladdressExt:$absaddr, RC: $src2),
3659             !if(isNot, "if (!$src1", "if ($src1")#!if(isPredNew, ".new) ",
3660             ") ")#mnemonic#"(##$absaddr) = $src2.new",
3661             []>,
3662             Requires<[HasV4T]>;
3663 }
3664
3665 multiclass ST_Abs_Pred_nv<string mnemonic, RegisterClass RC, bit PredNot> {
3666   let PredSense = !if(PredNot, "false", "true") in {
3667     defm _c#NAME : ST_Abs_Predbase_nv<mnemonic, RC, PredNot, 0>;
3668     // Predicate new
3669     defm _cdn#NAME : ST_Abs_Predbase_nv<mnemonic, RC, PredNot, 1>;
3670   }
3671 }
3672
3673 let mayStore = 1, isNVStore = 1, isExtended = 1, neverHasSideEffects = 1 in
3674 multiclass ST_Abs_nv<string mnemonic, string CextOp, RegisterClass RC> {
3675   let CextOpcode = CextOp, BaseOpcode = CextOp#_abs in {
3676     let opExtendable = 0, isPredicable = 1 in
3677     def NAME#_nv_V4 : NVInst_V4<(outs),
3678             (ins globaladdressExt:$absaddr, RC:$src),
3679             mnemonic#"(##$absaddr) = $src.new",
3680             []>,
3681             Requires<[HasV4T]>;
3682
3683     let opExtendable = 1, isPredicated = 1 in {
3684       defm Pt : ST_Abs_Pred_nv<mnemonic, RC, 0>;
3685       defm NotPt : ST_Abs_Pred_nv<mnemonic, RC, 1>;
3686     }
3687   }
3688 }
3689
3690 let addrMode = Absolute in {
3691     defm STrib_abs : ST_Abs<"memb", "STrib", IntRegs>,
3692                      ST_Abs_nv<"memb", "STrib", IntRegs>, AddrModeRel;
3693
3694     defm STrih_abs : ST_Abs<"memh", "STrih", IntRegs>,
3695                      ST_Abs_nv<"memh", "STrih", IntRegs>, AddrModeRel;
3696
3697     defm STriw_abs : ST_Abs<"memw", "STriw", IntRegs>,
3698                      ST_Abs_nv<"memw", "STriw", IntRegs>, AddrModeRel;
3699
3700   let isNVStorable = 0 in
3701     defm STrid_abs : ST_Abs<"memd", "STrid", DoubleRegs>, AddrModeRel;
3702 }
3703
3704 let Predicates = [HasV4T], AddedComplexity = 30 in {
3705 def : Pat<(truncstorei8 (i32 IntRegs:$src1),
3706                         (HexagonCONST32 tglobaladdr:$absaddr)),
3707           (STrib_abs_V4 tglobaladdr: $absaddr, IntRegs: $src1)>;
3708
3709 def : Pat<(truncstorei16 (i32 IntRegs:$src1),
3710                           (HexagonCONST32 tglobaladdr:$absaddr)),
3711           (STrih_abs_V4 tglobaladdr: $absaddr, IntRegs: $src1)>;
3712
3713 def : Pat<(store (i32 IntRegs:$src1), (HexagonCONST32 tglobaladdr:$absaddr)),
3714           (STriw_abs_V4 tglobaladdr: $absaddr, IntRegs: $src1)>;
3715
3716 def : Pat<(store (i64 DoubleRegs:$src1),
3717                  (HexagonCONST32 tglobaladdr:$absaddr)),
3718           (STrid_abs_V4 tglobaladdr: $absaddr, DoubleRegs: $src1)>;
3719 }
3720
3721 multiclass LD_Abs_Predbase<string mnemonic, RegisterClass RC, bit isNot,
3722                            bit isPredNew> {
3723   let PNewValue = !if(isPredNew, "new", "") in
3724   def NAME : LDInst2<(outs RC:$dst),
3725             (ins PredRegs:$src1, globaladdressExt:$absaddr),
3726             !if(isNot, "if (!$src1", "if ($src1")#!if(isPredNew, ".new) ",
3727             ") ")#"$dst = "#mnemonic#"(##$absaddr)",
3728             []>,
3729             Requires<[HasV4T]>;
3730 }
3731
3732 multiclass LD_Abs_Pred<string mnemonic, RegisterClass RC, bit PredNot> {
3733   let PredSense = !if(PredNot, "false", "true") in {
3734     defm _c#NAME : LD_Abs_Predbase<mnemonic, RC, PredNot, 0>;
3735     // Predicate new
3736     defm _cdn#NAME : LD_Abs_Predbase<mnemonic, RC, PredNot, 1>;
3737   }
3738 }
3739
3740 let isExtended = 1, neverHasSideEffects = 1 in
3741 multiclass LD_Abs<string mnemonic, string CextOp, RegisterClass RC> {
3742   let CextOpcode = CextOp, BaseOpcode = CextOp#_abs in {
3743     let  opExtendable = 1, isPredicable = 1 in
3744     def NAME#_V4 : LDInst2<(outs RC:$dst),
3745             (ins globaladdressExt:$absaddr),
3746             "$dst = "#mnemonic#"(##$absaddr)",
3747             []>,
3748             Requires<[HasV4T]>;
3749
3750     let opExtendable = 2, isPredicated = 1 in {
3751       defm Pt_V4 : LD_Abs_Pred<mnemonic, RC, 0>;
3752       defm NotPt_V4 : LD_Abs_Pred<mnemonic, RC, 1>;
3753     }
3754   }
3755 }
3756
3757 let addrMode = Absolute in {
3758     defm LDrib_abs  : LD_Abs<"memb", "LDrib", IntRegs>, AddrModeRel;
3759     defm LDriub_abs : LD_Abs<"memub", "LDriub", IntRegs>, AddrModeRel;
3760     defm LDrih_abs  : LD_Abs<"memh", "LDrih", IntRegs>, AddrModeRel;
3761     defm LDriuh_abs : LD_Abs<"memuh", "LDriuh", IntRegs>, AddrModeRel;
3762     defm LDriw_abs  : LD_Abs<"memw", "LDriw", IntRegs>, AddrModeRel;
3763     defm LDrid_abs : LD_Abs<"memd",  "LDrid", DoubleRegs>, AddrModeRel;
3764 }
3765
3766 let Predicates = [HasV4T], AddedComplexity  = 30 in
3767 def : Pat<(i32 (load (HexagonCONST32 tglobaladdr:$absaddr))),
3768           (LDriw_abs_V4 tglobaladdr: $absaddr)>;
3769
3770 let Predicates = [HasV4T], AddedComplexity=30 in
3771 def : Pat<(i32 (sextloadi8 (HexagonCONST32 tglobaladdr:$absaddr))),
3772           (LDrib_abs_V4 tglobaladdr:$absaddr)>;
3773
3774 let Predicates = [HasV4T], AddedComplexity=30 in
3775 def : Pat<(i32 (zextloadi8 (HexagonCONST32 tglobaladdr:$absaddr))),
3776           (LDriub_abs_V4 tglobaladdr:$absaddr)>;
3777
3778 let Predicates = [HasV4T], AddedComplexity=30 in
3779 def : Pat<(i32 (sextloadi16 (HexagonCONST32 tglobaladdr:$absaddr))),
3780           (LDrih_abs_V4 tglobaladdr:$absaddr)>;
3781
3782 let Predicates = [HasV4T], AddedComplexity=30 in
3783 def : Pat<(i32 (zextloadi16 (HexagonCONST32 tglobaladdr:$absaddr))),
3784           (LDriuh_abs_V4 tglobaladdr:$absaddr)>;
3785
3786 // Transfer global address into a register
3787 let AddedComplexity=50, isMoveImm = 1, isReMaterializable = 1 in
3788 def TFRI_V4 : ALU32_ri<(outs IntRegs:$dst), (ins globaladdress:$src1),
3789            "$dst = ##$src1",
3790            [(set IntRegs:$dst, (HexagonCONST32 tglobaladdr:$src1))]>,
3791            Requires<[HasV4T]>;
3792
3793 // Transfer a block address into a register
3794 def : Pat<(HexagonCONST32_GP tblockaddress:$src1),
3795           (TFRI_V4 tblockaddress:$src1)>,
3796           Requires<[HasV4T]>;
3797
3798 let AddedComplexity=50, neverHasSideEffects = 1, isPredicated = 1 in
3799 def TFRI_cPt_V4 : ALU32_ri<(outs IntRegs:$dst),
3800                            (ins PredRegs:$src1, globaladdress:$src2),
3801            "if($src1) $dst = ##$src2",
3802            []>,
3803            Requires<[HasV4T]>;
3804
3805 let AddedComplexity=50, neverHasSideEffects = 1, isPredicated = 1 in
3806 def TFRI_cNotPt_V4 : ALU32_ri<(outs IntRegs:$dst),
3807                               (ins PredRegs:$src1, globaladdress:$src2),
3808            "if(!$src1) $dst = ##$src2",
3809            []>,
3810            Requires<[HasV4T]>;
3811
3812 let AddedComplexity=50, neverHasSideEffects = 1, isPredicated = 1 in
3813 def TFRI_cdnPt_V4 : ALU32_ri<(outs IntRegs:$dst),
3814                              (ins PredRegs:$src1, globaladdress:$src2),
3815            "if($src1.new) $dst = ##$src2",
3816            []>,
3817            Requires<[HasV4T]>;
3818
3819 let AddedComplexity=50, neverHasSideEffects = 1, isPredicated = 1 in
3820 def TFRI_cdnNotPt_V4 : ALU32_ri<(outs IntRegs:$dst),
3821                                 (ins PredRegs:$src1, globaladdress:$src2),
3822            "if(!$src1.new) $dst = ##$src2",
3823            []>,
3824            Requires<[HasV4T]>;
3825
3826 let AddedComplexity = 50, Predicates = [HasV4T] in
3827 def : Pat<(HexagonCONST32_GP tglobaladdr:$src1),
3828            (TFRI_V4 tglobaladdr:$src1)>;
3829
3830
3831 // Load - Indirect with long offset: These instructions take global address
3832 // as an operand
3833 let AddedComplexity = 10 in
3834 def LDrid_ind_lo_V4 : LDInst<(outs DoubleRegs:$dst),
3835             (ins IntRegs:$src1, u2Imm:$src2, globaladdress:$offset),
3836             "$dst=memd($src1<<#$src2+##$offset)",
3837             [(set (i64 DoubleRegs:$dst),
3838                   (load (add (shl IntRegs:$src1, u2ImmPred:$src2),
3839                         (HexagonCONST32 tglobaladdr:$offset))))]>,
3840             Requires<[HasV4T]>;
3841
3842 let AddedComplexity = 10 in
3843 multiclass LD_indirect_lo<string OpcStr, PatFrag OpNode> {
3844   def _lo_V4 : LDInst<(outs IntRegs:$dst),
3845             (ins IntRegs:$src1, u2Imm:$src2, globaladdress:$offset),
3846             !strconcat("$dst = ",
3847             !strconcat(OpcStr, "($src1<<#$src2+##$offset)")),
3848             [(set IntRegs:$dst,
3849                   (i32 (OpNode (add (shl IntRegs:$src1, u2ImmPred:$src2),
3850                           (HexagonCONST32 tglobaladdr:$offset)))))]>,
3851             Requires<[HasV4T]>;
3852 }
3853
3854 defm LDrib_ind : LD_indirect_lo<"memb", sextloadi8>;
3855 defm LDriub_ind : LD_indirect_lo<"memub", zextloadi8>;
3856 defm LDrih_ind : LD_indirect_lo<"memh", sextloadi16>;
3857 defm LDriuh_ind : LD_indirect_lo<"memuh", zextloadi16>;
3858 defm LDriw_ind : LD_indirect_lo<"memw", load>;
3859
3860 // Store - Indirect with long offset: These instructions take global address
3861 // as an operand
3862 let AddedComplexity = 10 in
3863 def STrid_ind_lo_V4 : STInst<(outs),
3864             (ins IntRegs:$src1, u2Imm:$src2, globaladdress:$src3,
3865                  DoubleRegs:$src4),
3866             "memd($src1<<#$src2+#$src3) = $src4",
3867             [(store (i64 DoubleRegs:$src4),
3868                  (add (shl IntRegs:$src1, u2ImmPred:$src2),
3869                       (HexagonCONST32 tglobaladdr:$src3)))]>,
3870              Requires<[HasV4T]>;
3871
3872 let AddedComplexity = 10 in
3873 multiclass ST_indirect_lo<string OpcStr, PatFrag OpNode> {
3874   def _lo_V4 : STInst<(outs),
3875             (ins IntRegs:$src1, u2Imm:$src2, globaladdress:$src3,
3876                  IntRegs:$src4),
3877             !strconcat(OpcStr, "($src1<<#$src2+##$src3) = $src4"),
3878             [(OpNode (i32 IntRegs:$src4),
3879                  (add (shl IntRegs:$src1, u2ImmPred:$src2),
3880                       (HexagonCONST32 tglobaladdr:$src3)))]>,
3881              Requires<[HasV4T]>;
3882 }
3883
3884 defm STrib_ind : ST_indirect_lo<"memb", truncstorei8>;
3885 defm STrih_ind : ST_indirect_lo<"memh", truncstorei16>;
3886 defm STriw_ind : ST_indirect_lo<"memw", store>;
3887
3888 // Store - absolute addressing mode: These instruction take constant
3889 // value as the extended operand.
3890 multiclass ST_absimm<string OpcStr> {
3891 let isExtended = 1, opExtendable = 0, isPredicable = 1,
3892 validSubTargets = HasV4SubT in
3893   def _abs_V4 : STInst2<(outs),
3894             (ins u0AlwaysExt:$src1, IntRegs:$src2),
3895             !strconcat(OpcStr, "(##$src1) = $src2"),
3896             []>,
3897             Requires<[HasV4T]>;
3898
3899 let isExtended = 1, opExtendable = 1, isPredicated = 1,
3900 validSubTargets = HasV4SubT in {
3901   def _abs_cPt_V4 : STInst2<(outs),
3902             (ins PredRegs:$src1, u0AlwaysExt:$src2, IntRegs:$src3),
3903             !strconcat("if ($src1)", !strconcat(OpcStr, "(##$src2) = $src3")),
3904             []>,
3905             Requires<[HasV4T]>;
3906
3907   def _abs_cNotPt_V4 : STInst2<(outs),
3908             (ins PredRegs:$src1, u0AlwaysExt:$src2, IntRegs:$src3),
3909             !strconcat("if (!$src1)", !strconcat(OpcStr, "(##$src2) = $src3")),
3910             []>,
3911             Requires<[HasV4T]>;
3912
3913   def _abs_cdnPt_V4 : STInst2<(outs),
3914             (ins PredRegs:$src1, u0AlwaysExt:$src2, IntRegs:$src3),
3915             !strconcat("if ($src1.new)",
3916             !strconcat(OpcStr, "(##$src2) = $src3")),
3917             []>,
3918             Requires<[HasV4T]>;
3919
3920   def _abs_cdnNotPt_V4 : STInst2<(outs),
3921             (ins PredRegs:$src1, u0AlwaysExt:$src2, IntRegs:$src3),
3922             !strconcat("if (!$src1.new)",
3923             !strconcat(OpcStr, "(##$src2) = $src3")),
3924             []>,
3925             Requires<[HasV4T]>;
3926 }
3927
3928 let isExtended = 1, opExtendable = 0, mayStore = 1, isNVStore = 1,
3929 validSubTargets = HasV4SubT in
3930   def _abs_nv_V4 : NVInst_V4<(outs),
3931             (ins u0AlwaysExt:$src1, IntRegs:$src2),
3932             !strconcat(OpcStr, "(##$src1) = $src2.new"),
3933             []>,
3934             Requires<[HasV4T]>;
3935
3936 let isExtended = 1, opExtendable = 1, mayStore = 1, isPredicated = 1,
3937 isNVStore = 1, validSubTargets = HasV4SubT in {
3938   def _abs_cPt_nv_V4 : NVInst_V4<(outs),
3939             (ins PredRegs:$src1, u0AlwaysExt:$src2, IntRegs:$src3),
3940             !strconcat("if ($src1)",
3941             !strconcat(OpcStr, "(##$src2) = $src3.new")),
3942             []>,
3943             Requires<[HasV4T]>;
3944
3945   def _abs_cNotPt_nv_V4 : NVInst_V4<(outs),
3946             (ins PredRegs:$src1, u0AlwaysExt:$src2, IntRegs:$src3),
3947             !strconcat("if (!$src1)",
3948             !strconcat(OpcStr, "(##$src2) = $src3.new")),
3949             []>,
3950             Requires<[HasV4T]>;
3951
3952   def _abs_cdnPt_nv_V4 : NVInst_V4<(outs),
3953             (ins PredRegs:$src1, u0AlwaysExt:$src2, IntRegs:$src3),
3954             !strconcat("if ($src1.new)",
3955             !strconcat(OpcStr, "(##$src2) = $src3.new")),
3956             []>,
3957             Requires<[HasV4T]>;
3958
3959   def _abs_cdnNotPt_nv_V4 : NVInst_V4<(outs),
3960             (ins PredRegs:$src1, u0AlwaysExt:$src2, IntRegs:$src3),
3961             !strconcat("if (!$src1.new)",
3962             !strconcat(OpcStr, "(##$src2) = $src3.new")),
3963             []>,
3964             Requires<[HasV4T]>;
3965 }
3966 }
3967
3968 defm STrib_imm : ST_absimm<"memb">;
3969 defm STrih_imm : ST_absimm<"memh">;
3970 defm STriw_imm : ST_absimm<"memw">;
3971
3972 let Predicates = [HasV4T], AddedComplexity  = 30 in {
3973 def : Pat<(truncstorei8 (i32 IntRegs:$src1), u0AlwaysExtPred:$src2),
3974           (STrib_imm_abs_V4 u0AlwaysExtPred:$src2, IntRegs: $src1)>;
3975
3976 def : Pat<(truncstorei16 (i32 IntRegs:$src1), u0AlwaysExtPred:$src2),
3977           (STrih_imm_abs_V4 u0AlwaysExtPred:$src2, IntRegs: $src1)>;
3978
3979 def : Pat<(store (i32 IntRegs:$src1), u0AlwaysExtPred:$src2),
3980           (STriw_imm_abs_V4 u0AlwaysExtPred:$src2, IntRegs: $src1)>;
3981 }
3982
3983 // Load - absolute addressing mode: These instruction take constant
3984 // value as the extended operand
3985
3986 multiclass LD_absimm<string OpcStr> {
3987 let isExtended = 1, opExtendable = 1, isPredicable = 1,
3988 validSubTargets = HasV4SubT in
3989   def _abs_V4 : LDInst2<(outs IntRegs:$dst),
3990             (ins u0AlwaysExt:$src),
3991             !strconcat("$dst = ",
3992             !strconcat(OpcStr, "(##$src)")),
3993             []>,
3994             Requires<[HasV4T]>;
3995
3996 let isExtended = 1, opExtendable = 2, isPredicated = 1,
3997 validSubTargets = HasV4SubT in {
3998   def _abs_cPt_V4 : LDInst2<(outs IntRegs:$dst),
3999             (ins PredRegs:$src1, u0AlwaysExt:$src2),
4000             !strconcat("if ($src1) $dst = ",
4001             !strconcat(OpcStr, "(##$src2)")),
4002             []>,
4003             Requires<[HasV4T]>;
4004
4005   def _abs_cNotPt_V4 : LDInst2<(outs IntRegs:$dst),
4006             (ins PredRegs:$src1, u0AlwaysExt:$src2),
4007             !strconcat("if (!$src1) $dst = ",
4008             !strconcat(OpcStr, "(##$src2)")),
4009             []>,
4010             Requires<[HasV4T]>;
4011
4012   def _abs_cdnPt_V4 : LDInst2<(outs IntRegs:$dst),
4013             (ins PredRegs:$src1, u0AlwaysExt:$src2),
4014             !strconcat("if ($src1.new) $dst = ",
4015             !strconcat(OpcStr, "(##$src2)")),
4016             []>,
4017             Requires<[HasV4T]>;
4018
4019   def _abs_cdnNotPt_V4 : LDInst2<(outs IntRegs:$dst),
4020             (ins PredRegs:$src1, u0AlwaysExt:$src2),
4021             !strconcat("if (!$src1.new) $dst = ",
4022             !strconcat(OpcStr, "(##$src2)")),
4023             []>,
4024             Requires<[HasV4T]>;
4025 }
4026 }
4027
4028 defm LDrib_imm  : LD_absimm<"memb">;
4029 defm LDriub_imm : LD_absimm<"memub">;
4030 defm LDrih_imm  : LD_absimm<"memh">;
4031 defm LDriuh_imm : LD_absimm<"memuh">;
4032 defm LDriw_imm  : LD_absimm<"memw">;
4033
4034 let Predicates = [HasV4T], AddedComplexity  = 30 in {
4035 def : Pat<(i32 (load u0AlwaysExtPred:$src)),
4036           (LDriw_imm_abs_V4 u0AlwaysExtPred:$src)>;
4037
4038 def : Pat<(i32 (sextloadi8 u0AlwaysExtPred:$src)),
4039           (LDrib_imm_abs_V4 u0AlwaysExtPred:$src)>;
4040
4041 def : Pat<(i32 (zextloadi8 u0AlwaysExtPred:$src)),
4042           (LDriub_imm_abs_V4 u0AlwaysExtPred:$src)>;
4043
4044 def : Pat<(i32 (sextloadi16 u0AlwaysExtPred:$src)),
4045           (LDrih_imm_abs_V4 u0AlwaysExtPred:$src)>;
4046
4047 def : Pat<(i32 (zextloadi16 u0AlwaysExtPred:$src)),
4048           (LDriuh_imm_abs_V4 u0AlwaysExtPred:$src)>;
4049 }
4050
4051 // Indexed store double word - global address.
4052 // memw(Rs+#u6:2)=#S8
4053 let AddedComplexity = 10 in
4054 def STriw_offset_ext_V4 : STInst<(outs),
4055             (ins IntRegs:$src1, u6_2Imm:$src2, globaladdress:$src3),
4056             "memw($src1+#$src2) = ##$src3",
4057             [(store (HexagonCONST32 tglobaladdr:$src3),
4058                     (add IntRegs:$src1, u6_2ImmPred:$src2))]>,
4059             Requires<[HasV4T]>;
4060
4061
4062 // Indexed store double word - global address.
4063 // memw(Rs+#u6:2)=#S8
4064 let AddedComplexity = 10 in
4065 def STrih_offset_ext_V4 : STInst<(outs),
4066             (ins IntRegs:$src1, u6_1Imm:$src2, globaladdress:$src3),
4067             "memh($src1+#$src2) = ##$src3",
4068             [(truncstorei16 (HexagonCONST32 tglobaladdr:$src3),
4069                     (add IntRegs:$src1, u6_1ImmPred:$src2))]>,
4070             Requires<[HasV4T]>;
4071 // Map from store(globaladdress + x) -> memd(#foo + x)
4072 let AddedComplexity = 100 in
4073 def : Pat<(store (i64 DoubleRegs:$src1),
4074                  FoldGlobalAddrGP:$addr),
4075           (STrid_abs_V4 FoldGlobalAddrGP:$addr, (i64 DoubleRegs:$src1))>,
4076           Requires<[HasV4T]>;
4077
4078 def : Pat<(atomic_store_64 FoldGlobalAddrGP:$addr,
4079                            (i64 DoubleRegs:$src1)),
4080           (STrid_abs_V4 FoldGlobalAddrGP:$addr, (i64 DoubleRegs:$src1))>,
4081           Requires<[HasV4T]>;
4082
4083 // Map from store(globaladdress + x) -> memb(#foo + x)
4084 let AddedComplexity = 100 in
4085 def : Pat<(truncstorei8 (i32 IntRegs:$src1), FoldGlobalAddrGP:$addr),
4086           (STrib_abs_V4 FoldGlobalAddrGP:$addr, (i32 IntRegs:$src1))>,
4087             Requires<[HasV4T]>;
4088
4089 def : Pat<(atomic_store_8 FoldGlobalAddrGP:$addr, (i32 IntRegs:$src1)),
4090           (STrib_abs_V4 FoldGlobalAddrGP:$addr, (i32 IntRegs:$src1))>,
4091             Requires<[HasV4T]>;
4092
4093 // Map from store(globaladdress + x) -> memh(#foo + x)
4094 let AddedComplexity = 100 in
4095 def : Pat<(truncstorei16 (i32 IntRegs:$src1), FoldGlobalAddrGP:$addr),
4096           (STrih_abs_V4 FoldGlobalAddrGP:$addr, (i32 IntRegs:$src1))>,
4097             Requires<[HasV4T]>;
4098
4099 def : Pat<(atomic_store_16 FoldGlobalAddrGP:$addr, (i32 IntRegs:$src1)),
4100           (STrih_abs_V4 FoldGlobalAddrGP:$addr, (i32 IntRegs:$src1))>,
4101             Requires<[HasV4T]>;
4102
4103 // Map from store(globaladdress + x) -> memw(#foo + x)
4104 let AddedComplexity = 100 in
4105 def : Pat<(store (i32 IntRegs:$src1), FoldGlobalAddrGP:$addr),
4106           (STriw_abs_V4 FoldGlobalAddrGP:$addr, (i32 IntRegs:$src1))>,
4107            Requires<[HasV4T]>;
4108
4109 def : Pat<(atomic_store_32 FoldGlobalAddrGP:$addr, (i32 IntRegs:$src1)),
4110           (STriw_abs_V4 FoldGlobalAddrGP:$addr, (i32 IntRegs:$src1))>,
4111             Requires<[HasV4T]>;
4112
4113 // Map from load(globaladdress + x) -> memd(#foo + x)
4114 let AddedComplexity = 100 in
4115 def : Pat<(i64 (load FoldGlobalAddrGP:$addr)),
4116           (i64 (LDrid_abs_V4 FoldGlobalAddrGP:$addr))>,
4117            Requires<[HasV4T]>;
4118
4119 def : Pat<(atomic_load_64 FoldGlobalAddrGP:$addr),
4120           (i64 (LDrid_abs_V4 FoldGlobalAddrGP:$addr))>,
4121            Requires<[HasV4T]>;
4122
4123 // Map from load(globaladdress + x) -> memb(#foo + x)
4124 let AddedComplexity = 100 in
4125 def : Pat<(i32 (extloadi8 FoldGlobalAddrGP:$addr)),
4126           (i32 (LDrib_abs_V4 FoldGlobalAddrGP:$addr))>,
4127            Requires<[HasV4T]>;
4128
4129 // Map from load(globaladdress + x) -> memb(#foo + x)
4130 let AddedComplexity = 100 in
4131 def : Pat<(i32 (sextloadi8 FoldGlobalAddrGP:$addr)),
4132           (i32 (LDrib_abs_V4 FoldGlobalAddrGP:$addr))>,
4133            Requires<[HasV4T]>;
4134
4135 //let AddedComplexity = 100 in
4136 let AddedComplexity = 100 in
4137 def : Pat<(i32 (extloadi16 FoldGlobalAddrGP:$addr)),
4138           (i32 (LDrih_abs_V4 FoldGlobalAddrGP:$addr))>,
4139            Requires<[HasV4T]>;
4140
4141 // Map from load(globaladdress + x) -> memh(#foo + x)
4142 let AddedComplexity = 100 in
4143 def : Pat<(i32 (sextloadi16 FoldGlobalAddrGP:$addr)),
4144           (i32 (LDrih_abs_V4 FoldGlobalAddrGP:$addr))>,
4145            Requires<[HasV4T]>;
4146
4147 // Map from load(globaladdress + x) -> memuh(#foo + x)
4148 let AddedComplexity = 100 in
4149 def : Pat<(i32 (zextloadi16 FoldGlobalAddrGP:$addr)),
4150           (i32 (LDriuh_abs_V4 FoldGlobalAddrGP:$addr))>,
4151            Requires<[HasV4T]>;
4152
4153 def : Pat<(atomic_load_16 FoldGlobalAddrGP:$addr),
4154           (i32 (LDriuh_abs_V4 FoldGlobalAddrGP:$addr))>,
4155            Requires<[HasV4T]>;
4156
4157 // Map from load(globaladdress + x) -> memub(#foo + x)
4158 let AddedComplexity = 100 in
4159 def : Pat<(i32 (zextloadi8 FoldGlobalAddrGP:$addr)),
4160           (i32 (LDriub_abs_V4 FoldGlobalAddrGP:$addr))>,
4161            Requires<[HasV4T]>;
4162
4163 def : Pat<(atomic_load_8 FoldGlobalAddrGP:$addr),
4164           (i32 (LDriub_abs_V4 FoldGlobalAddrGP:$addr))>,
4165            Requires<[HasV4T]>;
4166
4167 // Map from load(globaladdress + x) -> memw(#foo + x)
4168 let AddedComplexity = 100 in
4169 def : Pat<(i32 (load FoldGlobalAddrGP:$addr)),
4170           (i32 (LDriw_abs_V4 FoldGlobalAddrGP:$addr))>,
4171            Requires<[HasV4T]>;
4172
4173 def : Pat<(atomic_load_32 FoldGlobalAddrGP:$addr),
4174           (i32 (LDriw_abs_V4 FoldGlobalAddrGP:$addr))>,
4175            Requires<[HasV4T]>;
4176