lib/Target/Hexagon/HexagonPatterns.td

   1 //==- HexagonPatterns.td - Target Description for Hexagon -*- tablegen -*-===//
   2 //
   3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
   4 // See https://llvm.org/LICENSE.txt for license information.
   5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   6 //
   7 //===----------------------------------------------------------------------===//
   8
   9 // Table of contents:
  10 //     (0) Definitions
  11 //     (1) Immediates
  12 //     (2) Type casts
  13 //     (3) Extend/truncate
  14 //     (4) Logical
  15 //     (5) Compare
  16 //     (6) Select
  17 //     (7) Insert/extract
  18 //     (8) Shift/permute
  19 //     (9) Arithmetic/bitwise
  20 //    (10) Bit
  21 //    (11) PIC
  22 //    (12) Load
  23 //    (13) Store
  24 //    (14) Memop
  25 //    (15) Call
  26 //    (16) Branch
  27 //    (17) Misc
  28
  29 // Guidelines (in no particular order):
  30 // 1. Avoid relying on pattern ordering to give preference to one pattern
  31 //    over another, prefer using AddedComplexity instead. The reason for
  32 //    this is to avoid unintended conseqeuences (caused by altering the
  33 //    order) when making changes. The current order of patterns in this
  34 //    file obviously does play some role, but none of the ordering was
  35 //    deliberately chosen (other than to create a logical structure of
  36 //    this file). When making changes, adding AddedComplexity to existing
  37 //    patterns may be needed.
  38 // 2. Maintain the logical structure of the file, try to put new patterns
  39 //    in designated sections.
  40 // 3. Do not use A2_combinew instruction directly, use Combinew fragment
  41 //    instead. It uses REG_SEQUENCE, which is more amenable to optimizations.
  42 // 4. Most selection macros are based on PatFrags. For DAGs that involve
  43 //    SDNodes, use pf1/pf2 to convert them to PatFrags. Use common frags
  44 //    whenever possible (see the Definitions section). When adding new
  45 //    macro, try to make is general to enable reuse across sections.
  46 // 5. Compound instructions (e.g. Rx+Rs*Rt) are generated under the condition
  47 //    that the nested operation has only one use. Having it separated in case
  48 //    of multiple uses avoids duplication of (processor) work.
  49 // 6. The v4 vector instructions (64-bit) are treated as core instructions,
  50 //    for example, A2_vaddh is in the "arithmetic" section with A2_add.
  51 // 7. When adding a pattern for an instruction with a constant-extendable
  52 //    operand, allow all possible kinds of inputs for the immediate value
  53 //    (see AnyImm/anyimm and their variants in the Definitions section).
  54
  55
  56 // --(0) Definitions -----------------------------------------------------
  57 //
  58
  59 // This complex pattern exists only to create a machine instruction operand
  60 // of type "frame index". There doesn't seem to be a way to do that directly
  61 // in the patterns.
  62 def AddrFI: ComplexPattern<i32, 1, "SelectAddrFI", [frameindex], []>;
  63
  64 // These complex patterns are not strictly necessary, since global address
  65 // folding will happen during DAG combining. For distinguishing between GA
  66 // and GP, pat frags with HexagonCONST32 and HexagonCONST32_GP can be used.
  67 def AddrGA: ComplexPattern<i32, 1, "SelectAddrGA", [], []>;
  68 def AddrGP: ComplexPattern<i32, 1, "SelectAddrGP", [], []>;
  69 def AnyImm: ComplexPattern<i32, 1, "SelectAnyImm", [], []>;
  70 def AnyInt: ComplexPattern<i32, 1, "SelectAnyInt", [], []>;
  71
  72 // Global address or a constant being a multiple of 2^n.
  73 def AnyImm0: ComplexPattern<i32, 1, "SelectAnyImm0", [], []>;
  74 def AnyImm1: ComplexPattern<i32, 1, "SelectAnyImm1", [], []>;
  75 def AnyImm2: ComplexPattern<i32, 1, "SelectAnyImm2", [], []>;
  76 def AnyImm3: ComplexPattern<i32, 1, "SelectAnyImm3", [], []>;
  77
  78
  79 // Type helper frags.
  80 def V2I1:   PatLeaf<(v2i1    PredRegs:$R)>;
  81 def V4I1:   PatLeaf<(v4i1    PredRegs:$R)>;
  82 def V8I1:   PatLeaf<(v8i1    PredRegs:$R)>;
  83 def V4I8:   PatLeaf<(v4i8    IntRegs:$R)>;
  84 def V2I16:  PatLeaf<(v2i16   IntRegs:$R)>;
  85
  86 def V8I8:   PatLeaf<(v8i8    DoubleRegs:$R)>;
  87 def V4I16:  PatLeaf<(v4i16   DoubleRegs:$R)>;
  88 def V2I32:  PatLeaf<(v2i32   DoubleRegs:$R)>;
  89
  90 def HQ8:    PatLeaf<(VecQ8   HvxQR:$R)>;
  91 def HQ16:   PatLeaf<(VecQ16  HvxQR:$R)>;
  92 def HQ32:   PatLeaf<(VecQ32  HvxQR:$R)>;
  93
  94 def HVI8:   PatLeaf<(VecI8   HvxVR:$R)>;
  95 def HVI16:  PatLeaf<(VecI16  HvxVR:$R)>;
  96 def HVI32:  PatLeaf<(VecI32  HvxVR:$R)>;
  97
  98 def HWI8:   PatLeaf<(VecPI8  HvxWR:$R)>;
  99 def HWI16:  PatLeaf<(VecPI16 HvxWR:$R)>;
 100 def HWI32:  PatLeaf<(VecPI32 HvxWR:$R)>;
 101
 102 def SDTVecLeaf:
 103   SDTypeProfile<1, 0, [SDTCisVec<0>]>;
 104 def SDTVecVecIntOp:
 105   SDTypeProfile<1, 3, [SDTCisVec<0>, SDTCisVec<1>, SDTCisSameAs<1,2>,
 106                        SDTCisVT<3,i32>]>;
 107
 108 def HexagonPTRUE:      SDNode<"HexagonISD::PTRUE",      SDTVecLeaf>;
 109 def HexagonPFALSE:     SDNode<"HexagonISD::PFALSE",     SDTVecLeaf>;
 110 def HexagonVALIGN:     SDNode<"HexagonISD::VALIGN",     SDTVecVecIntOp>;
 111 def HexagonVALIGNADDR: SDNode<"HexagonISD::VALIGNADDR", SDTIntUnaryOp>;
 112
 113 def ptrue:  PatFrag<(ops), (HexagonPTRUE)>;
 114 def pfalse: PatFrag<(ops), (HexagonPFALSE)>;
 115 def pnot:   PatFrag<(ops node:$Pu), (xor node:$Pu, ptrue)>;
 116
 117 def valign: PatFrag<(ops node:$Vt, node:$Vs, node:$Ru),
 118                     (HexagonVALIGN node:$Vt, node:$Vs, node:$Ru)>;
 119 def valignaddr: PatFrag<(ops node:$Addr), (HexagonVALIGNADDR node:$Addr)>;
 120
 121 // Pattern fragments to extract the low and high subregisters from a
 122 // 64-bit value.
 123 def LoReg: OutPatFrag<(ops node:$Rs), (EXTRACT_SUBREG (i64 $Rs), isub_lo)>;
 124 def HiReg: OutPatFrag<(ops node:$Rs), (EXTRACT_SUBREG (i64 $Rs), isub_hi)>;
 125
 126 def IsOrAdd: PatFrag<(ops node:$A, node:$B), (or node:$A, node:$B), [{
 127   return isOrEquivalentToAdd(N);
 128 }]>;
 129
 130 def IsPow2_32: PatLeaf<(i32 imm), [{
 131   uint32_t V = N->getZExtValue();
 132   return isPowerOf2_32(V);
 133 }]>;
 134
 135 def IsPow2_64: PatLeaf<(i64 imm), [{
 136   uint64_t V = N->getZExtValue();
 137   return isPowerOf2_64(V);
 138 }]>;
 139
 140 def IsNPow2_32: PatLeaf<(i32 imm), [{
 141   uint32_t NV = ~N->getZExtValue();
 142   return isPowerOf2_32(NV);
 143 }]>;
 144
 145 def IsPow2_64L: PatLeaf<(i64 imm), [{
 146   uint64_t V = N->getZExtValue();
 147   return isPowerOf2_64(V) && Log2_64(V) < 32;
 148 }]>;
 149
 150 def IsPow2_64H: PatLeaf<(i64 imm), [{
 151   uint64_t V = N->getZExtValue();
 152   return isPowerOf2_64(V) && Log2_64(V) >= 32;
 153 }]>;
 154
 155 def IsNPow2_64L: PatLeaf<(i64 imm), [{
 156   uint64_t NV = ~N->getZExtValue();
 157   return isPowerOf2_64(NV) && Log2_64(NV) < 32;
 158 }]>;
 159
 160 def IsNPow2_64H: PatLeaf<(i64 imm), [{
 161   uint64_t NV = ~N->getZExtValue();
 162   return isPowerOf2_64(NV) && Log2_64(NV) >= 32;
 163 }]>;
 164
 165 class IsULE<int Width, int Arg>: PatLeaf<(i32 imm),
 166   "uint64_t V = N->getZExtValue();" #
 167   "return isUInt<" # Width # ">(V) && V <= " # Arg # ";"
 168 >;
 169
 170 class IsUGT<int Width, int Arg>: PatLeaf<(i32 imm),
 171   "uint64_t V = N->getZExtValue();" #
 172   "return isUInt<" # Width # ">(V) && V > " # Arg # ";"
 173 >;
 174
 175 def SDEC1: SDNodeXForm<imm, [{
 176   int32_t V = N->getSExtValue();
 177   return CurDAG->getTargetConstant(V-1, SDLoc(N), MVT::i32);
 178 }]>;
 179
 180 def UDEC1: SDNodeXForm<imm, [{
 181   uint32_t V = N->getZExtValue();
 182   assert(V >= 1);
 183   return CurDAG->getTargetConstant(V-1, SDLoc(N), MVT::i32);
 184 }]>;
 185
 186 def UDEC32: SDNodeXForm<imm, [{
 187   uint32_t V = N->getZExtValue();
 188   assert(V >= 32);
 189   return CurDAG->getTargetConstant(V-32, SDLoc(N), MVT::i32);
 190 }]>;
 191
 192 class Subi<int From>: SDNodeXForm<imm,
 193   "int32_t V = " # From # " - N->getSExtValue();" #
 194   "return CurDAG->getTargetConstant(V, SDLoc(N), MVT::i32);"
 195 >;
 196
 197 def Log2_32: SDNodeXForm<imm, [{
 198   uint32_t V = N->getZExtValue();
 199   return CurDAG->getTargetConstant(Log2_32(V), SDLoc(N), MVT::i32);
 200 }]>;
 201
 202 def Log2_64: SDNodeXForm<imm, [{
 203   uint64_t V = N->getZExtValue();
 204   return CurDAG->getTargetConstant(Log2_64(V), SDLoc(N), MVT::i32);
 205 }]>;
 206
 207 def LogN2_32: SDNodeXForm<imm, [{
 208   uint32_t NV = ~N->getZExtValue();
 209   return CurDAG->getTargetConstant(Log2_32(NV), SDLoc(N), MVT::i32);
 210 }]>;
 211
 212 def LogN2_64: SDNodeXForm<imm, [{
 213   uint64_t NV = ~N->getZExtValue();
 214   return CurDAG->getTargetConstant(Log2_64(NV), SDLoc(N), MVT::i32);
 215 }]>;
 216
 217 def NegImm8: SDNodeXForm<imm, [{
 218   int8_t NV = -N->getSExtValue();
 219   return CurDAG->getTargetConstant(NV, SDLoc(N), MVT::i32);
 220 }]>;
 221
 222 def NegImm16: SDNodeXForm<imm, [{
 223   int16_t NV = -N->getSExtValue();
 224   return CurDAG->getTargetConstant(NV, SDLoc(N), MVT::i32);
 225 }]>;
 226
 227 def NegImm32: SDNodeXForm<imm, [{
 228   int32_t NV = -N->getSExtValue();
 229   return CurDAG->getTargetConstant(NV, SDLoc(N), MVT::i32);
 230 }]>;
 231
 232
 233 // Helpers for type promotions/contractions.
 234 def I1toI32:  OutPatFrag<(ops node:$Rs), (C2_muxii (i1 $Rs), 1, 0)>;
 235 def I32toI1:  OutPatFrag<(ops node:$Rs), (i1 (C2_cmpgtui (i32 $Rs), (i32 0)))>;
 236 def ToZext64: OutPatFrag<(ops node:$Rs), (i64 (A4_combineir 0, (i32 $Rs)))>;
 237 def ToSext64: OutPatFrag<(ops node:$Rs), (i64 (A2_sxtw (i32 $Rs)))>;
 238 def ToAext64: OutPatFrag<(ops node:$Rs),
 239   (REG_SEQUENCE DoubleRegs, (i32 (IMPLICIT_DEF)), isub_hi, (i32 $Rs), isub_lo)>;
 240
 241 def Combinew: OutPatFrag<(ops node:$Rs, node:$Rt),
 242   (REG_SEQUENCE DoubleRegs, $Rs, isub_hi, $Rt, isub_lo)>;
 243
 244 def addrga: PatLeaf<(i32 AddrGA:$Addr)>;
 245 def addrgp: PatLeaf<(i32 AddrGP:$Addr)>;
 246 def anyimm: PatLeaf<(i32 AnyImm:$Imm)>;
 247 def anyint: PatLeaf<(i32 AnyInt:$Imm)>;
 248
 249 // Global address or an aligned constant.
 250 def anyimm0: PatLeaf<(i32 AnyImm0:$Addr)>;
 251 def anyimm1: PatLeaf<(i32 AnyImm1:$Addr)>;
 252 def anyimm2: PatLeaf<(i32 AnyImm2:$Addr)>;
 253 def anyimm3: PatLeaf<(i32 AnyImm3:$Addr)>;
 254
 255 def f32ImmPred : PatLeaf<(f32 fpimm:$F)>;
 256 def f64ImmPred : PatLeaf<(f64 fpimm:$F)>;
 257
 258 // This complex pattern is really only to detect various forms of
 259 // sign-extension i32->i64. The selected value will be of type i64
 260 // whose low word is the value being extended. The high word is
 261 // unspecified.
 262 def Usxtw:  ComplexPattern<i64, 1, "DetectUseSxtw", [], []>;
 263
 264 def Aext64: PatFrag<(ops node:$Rs), (i64 (anyext node:$Rs))>;
 265 def Zext64: PatFrag<(ops node:$Rs), (i64 (zext node:$Rs))>;
 266 def Sext64: PatLeaf<(i64 Usxtw:$Rs)>;
 267
 268 def azext: PatFrags<(ops node:$Rs), [(zext node:$Rs), (anyext node:$Rs)]>;
 269 def asext: PatFrags<(ops node:$Rs), [(sext node:$Rs), (anyext node:$Rs)]>;
 270
 271 def: Pat<(IsOrAdd (i32 AddrFI:$Rs), s32_0ImmPred:$off),
 272          (PS_fi (i32 AddrFI:$Rs), imm:$off)>;
 273
 274
 275 // Converters from unary/binary SDNode to PatFrag.
 276 class pf1<SDNode Op> : PatFrag<(ops node:$a), (Op node:$a)>;
 277 class pf2<SDNode Op> : PatFrag<(ops node:$a, node:$b), (Op node:$a, node:$b)>;
 278
 279 class Not2<PatFrag P>
 280   : PatFrag<(ops node:$A, node:$B), (P node:$A, (not node:$B))>;
 281
 282 // If there is a constant operand that feeds the and/or instruction,
 283 // do not generate the compound instructions.
 284 // It is not always profitable, as some times we end up with a transfer.
 285 // Check the below example.
 286 // ra = #65820; rb = lsr(rb, #8); rc ^= and (rb, ra)
 287 // Instead this is preferable.
 288 // ra = and (#65820, lsr(ra, #8)); rb = xor(rb, ra)
 289 class Su_ni1<PatFrag Op>
 290   : PatFrag<Op.Operands, !head(Op.Fragments), [{
 291             if (hasOneUse(N)){
 292               // Check if Op1 is an immediate operand.
 293               SDValue Op1 = N->getOperand(1);
 294               return !isa<ConstantSDNode>(Op1);
 295             }
 296             return false;}],
 297             Op.OperandTransform>;
 298
 299 class Su<PatFrag Op>
 300   : PatFrag<Op.Operands, !head(Op.Fragments), [{ return hasOneUse(N); }],
 301             Op.OperandTransform>;
 302
 303 // Main selection macros.
 304
 305 class OpR_R_pat<InstHexagon MI, PatFrag Op, ValueType ResVT, PatFrag RegPred>
 306   : Pat<(ResVT (Op RegPred:$Rs)), (MI RegPred:$Rs)>;
 307
 308 class OpR_RI_pat<InstHexagon MI, PatFrag Op, ValueType ResType,
 309                  PatFrag RegPred, PatFrag ImmPred>
 310   : Pat<(ResType (Op RegPred:$Rs, ImmPred:$I)),
 311         (MI RegPred:$Rs, imm:$I)>;
 312
 313 class OpR_RR_pat<InstHexagon MI, PatFrag Op, ValueType ResType,
 314                  PatFrag RsPred, PatFrag RtPred = RsPred>
 315   : Pat<(ResType (Op RsPred:$Rs, RtPred:$Rt)),
 316         (MI RsPred:$Rs, RtPred:$Rt)>;
 317
 318 class AccRRI_pat<InstHexagon MI, PatFrag AccOp, PatFrag Op,
 319                  PatFrag RegPred, PatFrag ImmPred>
 320   : Pat<(AccOp RegPred:$Rx, (Op RegPred:$Rs, ImmPred:$I)),
 321         (MI RegPred:$Rx, RegPred:$Rs, imm:$I)>;
 322
 323 class AccRRR_pat<InstHexagon MI, PatFrag AccOp, PatFrag Op,
 324                  PatFrag RxPred, PatFrag RsPred, PatFrag RtPred>
 325   : Pat<(AccOp RxPred:$Rx, (Op RsPred:$Rs, RtPred:$Rt)),
 326         (MI RxPred:$Rx, RsPred:$Rs, RtPred:$Rt)>;
 327
 328 multiclass SelMinMax_pats<PatFrag CmpOp, PatFrag Val,
 329                           InstHexagon InstA, InstHexagon InstB> {
 330   def: Pat<(select (i1 (CmpOp Val:$A, Val:$B)), Val:$A, Val:$B),
 331            (InstA Val:$A, Val:$B)>;
 332   def: Pat<(select (i1 (CmpOp Val:$A, Val:$B)), Val:$B, Val:$A),
 333            (InstB Val:$A, Val:$B)>;
 334 }
 335
 336 multiclass MinMax_pats<InstHexagon PickT, InstHexagon PickS,
 337                        PatFrag Sel, PatFrag CmpOp,
 338                        ValueType CmpType, PatFrag CmpPred> {
 339   def: Pat<(Sel (CmpType (CmpOp CmpPred:$Vs, CmpPred:$Vt)),
 340                 CmpPred:$Vt, CmpPred:$Vs),
 341            (PickT CmpPred:$Vs, CmpPred:$Vt)>;
 342   def: Pat<(Sel (CmpType (CmpOp CmpPred:$Vs, CmpPred:$Vt)),
 343                 CmpPred:$Vs, CmpPred:$Vt),
 344            (PickS CmpPred:$Vs, CmpPred:$Vt)>;
 345 }
 346
 347
 348 // Frags for commonly used SDNodes.
 349 def Add: pf2<add>;    def And: pf2<and>;    def Sra: pf2<sra>;
 350 def Sub: pf2<sub>;    def Or:  pf2<or>;     def Srl: pf2<srl>;
 351 def Mul: pf2<mul>;    def Xor: pf2<xor>;    def Shl: pf2<shl>;
 352
 353 def Rol: pf2<rotl>;
 354
 355 // --(1) Immediate -------------------------------------------------------
 356 //
 357
 358 def SDTHexagonCONST32
 359   : SDTypeProfile<1, 1, [SDTCisVT<0, i32>, SDTCisVT<1, i32>, SDTCisPtrTy<0>]>;
 360
 361 def HexagonJT:          SDNode<"HexagonISD::JT",          SDTIntUnaryOp>;
 362 def HexagonCP:          SDNode<"HexagonISD::CP",          SDTIntUnaryOp>;
 363 def HexagonCONST32:     SDNode<"HexagonISD::CONST32",     SDTHexagonCONST32>;
 364 def HexagonCONST32_GP:  SDNode<"HexagonISD::CONST32_GP",  SDTHexagonCONST32>;
 365
 366 def TruncI64ToI32: SDNodeXForm<imm, [{
 367   return CurDAG->getTargetConstant(N->getSExtValue(), SDLoc(N), MVT::i32);
 368 }]>;
 369
 370 def: Pat<(s32_0ImmPred:$s16), (A2_tfrsi imm:$s16)>;
 371 def: Pat<(s8_0Imm64Pred:$s8), (A2_tfrpi (TruncI64ToI32 $s8))>;
 372
 373 def: Pat<(HexagonCONST32    tglobaltlsaddr:$A), (A2_tfrsi imm:$A)>;
 374 def: Pat<(HexagonCONST32    bbl:$A),            (A2_tfrsi imm:$A)>;
 375 def: Pat<(HexagonCONST32    tglobaladdr:$A),    (A2_tfrsi imm:$A)>;
 376 def: Pat<(HexagonCONST32_GP tblockaddress:$A),  (A2_tfrsi imm:$A)>;
 377 def: Pat<(HexagonCONST32_GP tglobaladdr:$A),    (A2_tfrsi imm:$A)>;
 378 def: Pat<(HexagonJT         tjumptable:$A),     (A2_tfrsi imm:$A)>;
 379 def: Pat<(HexagonCP         tconstpool:$A),     (A2_tfrsi imm:$A)>;
 380 // The HVX load patterns also match CP directly. Make sure that if
 381 // the selection of this opcode changes, it's updated in all places.
 382
 383 def: Pat<(i1 0),        (PS_false)>;
 384 def: Pat<(i1 1),        (PS_true)>;
 385 def: Pat<(i64 imm:$v),  (CONST64 imm:$v)>;
 386
 387 def ftoi : SDNodeXForm<fpimm, [{
 388   APInt I = N->getValueAPF().bitcastToAPInt();
 389   return CurDAG->getTargetConstant(I.getZExtValue(), SDLoc(N),
 390                                    MVT::getIntegerVT(I.getBitWidth()));
 391 }]>;
 392
 393 def: Pat<(f32ImmPred:$f), (A2_tfrsi (ftoi $f))>;
 394 def: Pat<(f64ImmPred:$f), (CONST64  (ftoi $f))>;
 395
 396 def ToI32: OutPatFrag<(ops node:$V), (A2_tfrsi $V)>;
 397
 398 // --(2) Type cast -------------------------------------------------------
 399 //
 400
 401 def: OpR_R_pat<F2_conv_sf2df,      pf1<fpextend>,   f64, F32>;
 402 def: OpR_R_pat<F2_conv_df2sf,      pf1<fpround>,    f32, F64>;
 403
 404 def: OpR_R_pat<F2_conv_w2sf,       pf1<sint_to_fp>, f32, I32>;
 405 def: OpR_R_pat<F2_conv_d2sf,       pf1<sint_to_fp>, f32, I64>;
 406 def: OpR_R_pat<F2_conv_w2df,       pf1<sint_to_fp>, f64, I32>;
 407 def: OpR_R_pat<F2_conv_d2df,       pf1<sint_to_fp>, f64, I64>;
 408
 409 def: OpR_R_pat<F2_conv_uw2sf,      pf1<uint_to_fp>, f32, I32>;
 410 def: OpR_R_pat<F2_conv_ud2sf,      pf1<uint_to_fp>, f32, I64>;
 411 def: OpR_R_pat<F2_conv_uw2df,      pf1<uint_to_fp>, f64, I32>;
 412 def: OpR_R_pat<F2_conv_ud2df,      pf1<uint_to_fp>, f64, I64>;
 413
 414 def: OpR_R_pat<F2_conv_sf2w_chop,  pf1<fp_to_sint>, i32, F32>;
 415 def: OpR_R_pat<F2_conv_df2w_chop,  pf1<fp_to_sint>, i32, F64>;
 416 def: OpR_R_pat<F2_conv_sf2d_chop,  pf1<fp_to_sint>, i64, F32>;
 417 def: OpR_R_pat<F2_conv_df2d_chop,  pf1<fp_to_sint>, i64, F64>;
 418
 419 def: OpR_R_pat<F2_conv_sf2uw_chop, pf1<fp_to_uint>, i32, F32>;
 420 def: OpR_R_pat<F2_conv_df2uw_chop, pf1<fp_to_uint>, i32, F64>;
 421 def: OpR_R_pat<F2_conv_sf2ud_chop, pf1<fp_to_uint>, i64, F32>;
 422 def: OpR_R_pat<F2_conv_df2ud_chop, pf1<fp_to_uint>, i64, F64>;
 423
 424 // Bitcast is different than [fp|sint|uint]_to_[sint|uint|fp].
 425 def: Pat<(i32 (bitconvert F32:$v)), (I32:$v)>;
 426 def: Pat<(f32 (bitconvert I32:$v)), (F32:$v)>;
 427 def: Pat<(i64 (bitconvert F64:$v)), (I64:$v)>;
 428 def: Pat<(f64 (bitconvert I64:$v)), (F64:$v)>;
 429
 430 multiclass Cast_pat<ValueType Ta, ValueType Tb, RegisterClass RC> {
 431   def: Pat<(Tb (bitconvert (Ta RC:$Rs))), (Tb RC:$Rs)>;
 432   def: Pat<(Ta (bitconvert (Tb RC:$Rs))), (Ta RC:$Rs)>;
 433 }
 434
 435 // Bit convert vector types to integers.
 436 defm: Cast_pat<v4i8,  i32, IntRegs>;
 437 defm: Cast_pat<v2i16, i32, IntRegs>;
 438 defm: Cast_pat<v8i8,  i64, DoubleRegs>;
 439 defm: Cast_pat<v4i16, i64, DoubleRegs>;
 440 defm: Cast_pat<v2i32, i64, DoubleRegs>;
 441
 442
 443 // --(3) Extend/truncate -------------------------------------------------
 444 //
 445
 446 def: Pat<(sext_inreg I32:$Rs, i8),  (A2_sxtb I32:$Rs)>;
 447 def: Pat<(sext_inreg I32:$Rs, i16), (A2_sxth I32:$Rs)>;
 448 def: Pat<(sext_inreg I64:$Rs, i32), (A2_sxtw (LoReg $Rs))>;
 449 def: Pat<(sext_inreg I64:$Rs, i16), (A2_sxtw (A2_sxth (LoReg $Rs)))>;
 450 def: Pat<(sext_inreg I64:$Rs, i8),  (A2_sxtw (A2_sxtb (LoReg $Rs)))>;
 451
 452 def: Pat<(i64 (sext I32:$Rs)), (A2_sxtw I32:$Rs)>;
 453 def: Pat<(Zext64 I32:$Rs),     (ToZext64 $Rs)>;
 454 def: Pat<(Aext64 I32:$Rs),     (ToZext64 $Rs)>;
 455
 456 def: Pat<(i32 (trunc I64:$Rs)), (LoReg $Rs)>;
 457 def: Pat<(i1 (trunc I32:$Rs)),  (S2_tstbit_i I32:$Rs, 0)>;
 458 def: Pat<(i1 (trunc I64:$Rs)),  (S2_tstbit_i (LoReg $Rs), 0)>;
 459
 460 let AddedComplexity = 20 in {
 461   def: Pat<(and I32:$Rs, 255),   (A2_zxtb I32:$Rs)>;
 462   def: Pat<(and I32:$Rs, 65535), (A2_zxth I32:$Rs)>;
 463 }
 464
 465 // Extensions from i1 or vectors of i1.
 466 def: Pat<(i32 (azext I1:$Pu)), (C2_muxii I1:$Pu, 1, 0)>;
 467 def: Pat<(i64 (azext I1:$Pu)), (ToZext64 (C2_muxii I1:$Pu, 1, 0))>;
 468 def: Pat<(i32  (sext I1:$Pu)), (C2_muxii I1:$Pu, -1, 0)>;
 469 def: Pat<(i64  (sext I1:$Pu)), (Combinew (C2_muxii PredRegs:$Pu, -1, 0),
 470                                          (C2_muxii PredRegs:$Pu, -1, 0))>;
 471
 472 def: Pat<(v2i16 (sext V2I1:$Pu)), (S2_vtrunehb (C2_mask V2I1:$Pu))>;
 473 def: Pat<(v2i32 (sext V2I1:$Pu)), (C2_mask V2I1:$Pu)>;
 474 def: Pat<(v4i8  (sext V4I1:$Pu)), (S2_vtrunehb (C2_mask V4I1:$Pu))>;
 475 def: Pat<(v4i16 (sext V4I1:$Pu)), (C2_mask V4I1:$Pu)>;
 476 def: Pat<(v8i8  (sext V8I1:$Pu)), (C2_mask V8I1:$Pu)>;
 477
 478 def Vsplatpi: OutPatFrag<(ops node:$V),
 479                          (Combinew (A2_tfrsi $V), (A2_tfrsi $V))>;
 480
 481 def: Pat<(v2i16 (azext V2I1:$Pu)),
 482          (A2_andir (LoReg (C2_mask V2I1:$Pu)), (i32 0x00010001))>;
 483 def: Pat<(v2i32 (azext V2I1:$Pu)),
 484          (A2_andp (C2_mask V2I1:$Pu), (A2_combineii (i32 1), (i32 1)))>;
 485 def: Pat<(v4i8 (azext V4I1:$Pu)),
 486          (A2_andir (LoReg (C2_mask V4I1:$Pu)), (i32 0x01010101))>;
 487 def: Pat<(v4i16 (azext V4I1:$Pu)),
 488          (A2_andp (C2_mask V4I1:$Pu), (Vsplatpi (i32 0x00010001)))>;
 489 def: Pat<(v8i8 (azext V8I1:$Pu)),
 490          (A2_andp (C2_mask V8I1:$Pu), (Vsplatpi (i32 0x01010101)))>;
 491
 492 def: Pat<(v4i16 (azext  V4I8:$Rs)),  (S2_vzxtbh V4I8:$Rs)>;
 493 def: Pat<(v2i32 (azext  V2I16:$Rs)), (S2_vzxthw V2I16:$Rs)>;
 494 def: Pat<(v4i16 (sext   V4I8:$Rs)),  (S2_vsxtbh V4I8:$Rs)>;
 495 def: Pat<(v2i32 (sext   V2I16:$Rs)), (S2_vsxthw V2I16:$Rs)>;
 496
 497 def: Pat<(v2i32 (sext_inreg V2I32:$Rs, v2i8)),
 498          (Combinew (A2_sxtb (HiReg $Rs)), (A2_sxtb (LoReg $Rs)))>;
 499
 500 def: Pat<(v2i32 (sext_inreg V2I32:$Rs, v2i16)),
 501          (Combinew (A2_sxth (HiReg $Rs)), (A2_sxth (LoReg $Rs)))>;
 502
 503 // Truncate: from vector B copy all 'E'ven 'B'yte elements:
 504 // A[0] = B[0];  A[1] = B[2];  A[2] = B[4];  A[3] = B[6];
 505 def: Pat<(v4i8 (trunc V4I16:$Rs)),
 506          (S2_vtrunehb V4I16:$Rs)>;
 507
 508 // Truncate: from vector B copy all 'O'dd 'B'yte elements:
 509 // A[0] = B[1];  A[1] = B[3];  A[2] = B[5];  A[3] = B[7];
 510 // S2_vtrunohb
 511
 512 // Truncate: from vectors B and C copy all 'E'ven 'H'alf-word elements:
 513 // A[0] = B[0];  A[1] = B[2];  A[2] = C[0];  A[3] = C[2];
 514 // S2_vtruneh
 515
 516 def: Pat<(v2i16 (trunc V2I32:$Rs)),
 517          (A2_combine_ll (HiReg $Rs), (LoReg $Rs))>;
 518
 519
 520 // --(4) Logical ---------------------------------------------------------
 521 //
 522
 523 def: Pat<(not I1:$Ps),      (C2_not I1:$Ps)>;
 524 def: Pat<(pnot V2I1:$Ps),   (C2_not V2I1:$Ps)>;
 525 def: Pat<(pnot V4I1:$Ps),   (C2_not V4I1:$Ps)>;
 526 def: Pat<(pnot V8I1:$Ps),   (C2_not V8I1:$Ps)>;
 527 def: Pat<(add I1:$Ps, -1),  (C2_not I1:$Ps)>;
 528
 529 multiclass BoolOpR_RR_pat<InstHexagon MI, PatFrag Op> {
 530   def: OpR_RR_pat<MI, Op,   i1,   I1>;
 531   def: OpR_RR_pat<MI, Op, v2i1, V2I1>;
 532   def: OpR_RR_pat<MI, Op, v4i1, V4I1>;
 533   def: OpR_RR_pat<MI, Op, v8i1, V8I1>;
 534 }
 535
 536 multiclass BoolAccRRR_pat<InstHexagon MI, PatFrag AccOp, PatFrag Op> {
 537   def: AccRRR_pat<MI, AccOp, Op,   I1,   I1,   I1>;
 538   def: AccRRR_pat<MI, AccOp, Op, V2I1, V2I1, V2I1>;
 539   def: AccRRR_pat<MI, AccOp, Op, V4I1, V4I1, V4I1>;
 540   def: AccRRR_pat<MI, AccOp, Op, V8I1, V8I1, V8I1>;
 541 }
 542
 543 defm: BoolOpR_RR_pat<C2_and,   And>;
 544 defm: BoolOpR_RR_pat<C2_or,    Or>;
 545 defm: BoolOpR_RR_pat<C2_xor,   Xor>;
 546 defm: BoolOpR_RR_pat<C2_andn,  Not2<And>>;
 547 defm: BoolOpR_RR_pat<C2_orn,   Not2<Or>>;
 548
 549 // op(Ps, op(Pt, Pu))
 550 defm: BoolAccRRR_pat<C4_and_and,   And, Su<And>>;
 551 defm: BoolAccRRR_pat<C4_and_or,    And, Su<Or>>;
 552 defm: BoolAccRRR_pat<C4_or_and,    Or,  Su<And>>;
 553 defm: BoolAccRRR_pat<C4_or_or,     Or,  Su<Or>>;
 554
 555 // op(Ps, op(Pt, ~Pu))
 556 defm: BoolAccRRR_pat<C4_and_andn,  And, Su<Not2<And>>>;
 557 defm: BoolAccRRR_pat<C4_and_orn,   And, Su<Not2<Or>>>;
 558 defm: BoolAccRRR_pat<C4_or_andn,   Or,  Su<Not2<And>>>;
 559 defm: BoolAccRRR_pat<C4_or_orn,    Or,  Su<Not2<Or>>>;
 560
 561
 562 // --(5) Compare ---------------------------------------------------------
 563 //
 564
 565 // Avoid negated comparisons, i.e. those of form "Pd = !cmp(...)".
 566 // These cannot form compounds (e.g. J4_cmpeqi_tp0_jump_nt).
 567
 568 def: OpR_RI_pat<C2_cmpeqi,    seteq,          i1, I32,  anyimm>;
 569 def: OpR_RI_pat<C2_cmpgti,    setgt,          i1, I32,  anyimm>;
 570 def: OpR_RI_pat<C2_cmpgtui,   setugt,         i1, I32,  anyimm>;
 571
 572 def: Pat<(i1 (setge I32:$Rs, s32_0ImmPred:$s10)),
 573          (C2_cmpgti I32:$Rs, (SDEC1 imm:$s10))>;
 574 def: Pat<(i1 (setuge I32:$Rs, u32_0ImmPred:$u9)),
 575          (C2_cmpgtui I32:$Rs, (UDEC1 imm:$u9))>;
 576
 577 def: Pat<(i1 (setlt I32:$Rs, s32_0ImmPred:$s10)),
 578          (C2_not (C2_cmpgti I32:$Rs, (SDEC1 imm:$s10)))>;
 579 def: Pat<(i1 (setult I32:$Rs, u32_0ImmPred:$u9)),
 580          (C2_not (C2_cmpgtui I32:$Rs, (UDEC1 imm:$u9)))>;
 581
 582 // Patfrag to convert the usual comparison patfrags (e.g. setlt) to ones
 583 // that reverse the order of the operands.
 584 class RevCmp<PatFrag F>
 585   : PatFrag<(ops node:$rhs, node:$lhs), !head(F.Fragments), F.PredicateCode,
 586             F.OperandTransform>;
 587
 588 def: OpR_RR_pat<C2_cmpeq,     seteq,          i1,   I32>;
 589 def: OpR_RR_pat<C2_cmpgt,     setgt,          i1,   I32>;
 590 def: OpR_RR_pat<C2_cmpgtu,    setugt,         i1,   I32>;
 591 def: OpR_RR_pat<C2_cmpgt,     RevCmp<setlt>,  i1,   I32>;
 592 def: OpR_RR_pat<C2_cmpgtu,    RevCmp<setult>, i1,   I32>;
 593 def: OpR_RR_pat<C2_cmpeqp,    seteq,          i1,   I64>;
 594 def: OpR_RR_pat<C2_cmpgtp,    setgt,          i1,   I64>;
 595 def: OpR_RR_pat<C2_cmpgtup,   setugt,         i1,   I64>;
 596 def: OpR_RR_pat<C2_cmpgtp,    RevCmp<setlt>,  i1,   I64>;
 597 def: OpR_RR_pat<C2_cmpgtup,   RevCmp<setult>, i1,   I64>;
 598 def: OpR_RR_pat<A2_vcmpbeq,   seteq,          i1,   V8I8>;
 599 def: OpR_RR_pat<A2_vcmpbeq,   seteq,          v8i1, V8I8>;
 600 def: OpR_RR_pat<A4_vcmpbgt,   RevCmp<setlt>,  i1,   V8I8>;
 601 def: OpR_RR_pat<A4_vcmpbgt,   RevCmp<setlt>,  v8i1, V8I8>;
 602 def: OpR_RR_pat<A4_vcmpbgt,   setgt,          i1,   V8I8>;
 603 def: OpR_RR_pat<A4_vcmpbgt,   setgt,          v8i1, V8I8>;
 604 def: OpR_RR_pat<A2_vcmpbgtu,  RevCmp<setult>, i1,   V8I8>;
 605 def: OpR_RR_pat<A2_vcmpbgtu,  RevCmp<setult>, v8i1, V8I8>;
 606 def: OpR_RR_pat<A2_vcmpbgtu,  setugt,         i1,   V8I8>;
 607 def: OpR_RR_pat<A2_vcmpbgtu,  setugt,         v8i1, V8I8>;
 608 def: OpR_RR_pat<A2_vcmpheq,   seteq,          i1,   V4I16>;
 609 def: OpR_RR_pat<A2_vcmpheq,   seteq,          v4i1, V4I16>;
 610 def: OpR_RR_pat<A2_vcmphgt,   RevCmp<setlt>,  i1,   V4I16>;
 611 def: OpR_RR_pat<A2_vcmphgt,   RevCmp<setlt>,  v4i1, V4I16>;
 612 def: OpR_RR_pat<A2_vcmphgt,   setgt,          i1,   V4I16>;
 613 def: OpR_RR_pat<A2_vcmphgt,   setgt,          v4i1, V4I16>;
 614 def: OpR_RR_pat<A2_vcmphgtu,  RevCmp<setult>, i1,   V4I16>;
 615 def: OpR_RR_pat<A2_vcmphgtu,  RevCmp<setult>, v4i1, V4I16>;
 616 def: OpR_RR_pat<A2_vcmphgtu,  setugt,         i1,   V4I16>;
 617 def: OpR_RR_pat<A2_vcmphgtu,  setugt,         v4i1, V4I16>;
 618 def: OpR_RR_pat<A2_vcmpweq,   seteq,          i1,   V2I32>;
 619 def: OpR_RR_pat<A2_vcmpweq,   seteq,          v2i1, V2I32>;
 620 def: OpR_RR_pat<A2_vcmpwgt,   RevCmp<setlt>,  i1,   V2I32>;
 621 def: OpR_RR_pat<A2_vcmpwgt,   RevCmp<setlt>,  v2i1, V2I32>;
 622 def: OpR_RR_pat<A2_vcmpwgt,   setgt,          i1,   V2I32>;
 623 def: OpR_RR_pat<A2_vcmpwgt,   setgt,          v2i1, V2I32>;
 624 def: OpR_RR_pat<A2_vcmpwgtu,  RevCmp<setult>, i1,   V2I32>;
 625 def: OpR_RR_pat<A2_vcmpwgtu,  RevCmp<setult>, v2i1, V2I32>;
 626 def: OpR_RR_pat<A2_vcmpwgtu,  setugt,         i1,   V2I32>;
 627 def: OpR_RR_pat<A2_vcmpwgtu,  setugt,         v2i1, V2I32>;
 628
 629 def: OpR_RR_pat<F2_sfcmpeq,   seteq,          i1, F32>;
 630 def: OpR_RR_pat<F2_sfcmpgt,   setgt,          i1, F32>;
 631 def: OpR_RR_pat<F2_sfcmpge,   setge,          i1, F32>;
 632 def: OpR_RR_pat<F2_sfcmpeq,   setoeq,         i1, F32>;
 633 def: OpR_RR_pat<F2_sfcmpgt,   setogt,         i1, F32>;
 634 def: OpR_RR_pat<F2_sfcmpge,   setoge,         i1, F32>;
 635 def: OpR_RR_pat<F2_sfcmpgt,   RevCmp<setolt>, i1, F32>;
 636 def: OpR_RR_pat<F2_sfcmpge,   RevCmp<setole>, i1, F32>;
 637 def: OpR_RR_pat<F2_sfcmpgt,   RevCmp<setlt>,  i1, F32>;
 638 def: OpR_RR_pat<F2_sfcmpge,   RevCmp<setle>,  i1, F32>;
 639 def: OpR_RR_pat<F2_sfcmpuo,   setuo,          i1, F32>;
 640
 641 def: OpR_RR_pat<F2_dfcmpeq,   seteq,          i1, F64>;
 642 def: OpR_RR_pat<F2_dfcmpgt,   setgt,          i1, F64>;
 643 def: OpR_RR_pat<F2_dfcmpge,   setge,          i1, F64>;
 644 def: OpR_RR_pat<F2_dfcmpeq,   setoeq,         i1, F64>;
 645 def: OpR_RR_pat<F2_dfcmpgt,   setogt,         i1, F64>;
 646 def: OpR_RR_pat<F2_dfcmpge,   setoge,         i1, F64>;
 647 def: OpR_RR_pat<F2_dfcmpgt,   RevCmp<setolt>, i1, F64>;
 648 def: OpR_RR_pat<F2_dfcmpge,   RevCmp<setole>, i1, F64>;
 649 def: OpR_RR_pat<F2_dfcmpgt,   RevCmp<setlt>,  i1, F64>;
 650 def: OpR_RR_pat<F2_dfcmpge,   RevCmp<setle>,  i1, F64>;
 651 def: OpR_RR_pat<F2_dfcmpuo,   setuo,          i1, F64>;
 652
 653 // Avoid C4_cmpneqi, C4_cmpltei, C4_cmplteui, since they cannot form compounds.
 654
 655 def: Pat<(i1 (setne I32:$Rs, anyimm:$u5)),
 656          (C2_not (C2_cmpeqi I32:$Rs, imm:$u5))>;
 657 def: Pat<(i1 (setle I32:$Rs, anyimm:$u5)),
 658          (C2_not (C2_cmpgti I32:$Rs, imm:$u5))>;
 659 def: Pat<(i1 (setule I32:$Rs, anyimm:$u5)),
 660          (C2_not (C2_cmpgtui I32:$Rs, imm:$u5))>;
 661
 662 class OpmR_RR_pat<PatFrag Output, PatFrag Op, ValueType ResType,
 663                   PatFrag RsPred, PatFrag RtPred = RsPred>
 664   : Pat<(ResType (Op RsPred:$Rs, RtPred:$Rt)),
 665         (Output RsPred:$Rs, RtPred:$Rt)>;
 666
 667 class Outn<InstHexagon MI>
 668   : OutPatFrag<(ops node:$Rs, node:$Rt),
 669                (C2_not (MI $Rs, $Rt))>;
 670
 671 def: OpmR_RR_pat<Outn<C2_cmpeq>,    setne,          i1,   I32>;
 672 def: OpmR_RR_pat<Outn<C2_cmpgt>,    setle,          i1,   I32>;
 673 def: OpmR_RR_pat<Outn<C2_cmpgtu>,   setule,         i1,   I32>;
 674 def: OpmR_RR_pat<Outn<C2_cmpgt>,    RevCmp<setge>,  i1,   I32>;
 675 def: OpmR_RR_pat<Outn<C2_cmpgtu>,   RevCmp<setuge>, i1,   I32>;
 676 def: OpmR_RR_pat<Outn<C2_cmpeqp>,   setne,          i1,   I64>;
 677 def: OpmR_RR_pat<Outn<C2_cmpgtp>,   setle,          i1,   I64>;
 678 def: OpmR_RR_pat<Outn<C2_cmpgtup>,  setule,         i1,   I64>;
 679 def: OpmR_RR_pat<Outn<C2_cmpgtp>,   RevCmp<setge>,  i1,   I64>;
 680 def: OpmR_RR_pat<Outn<C2_cmpgtup>,  RevCmp<setuge>, i1,   I64>;
 681 def: OpmR_RR_pat<Outn<A2_vcmpbeq>,  setne,          v8i1, V8I8>;
 682 def: OpmR_RR_pat<Outn<A4_vcmpbgt>,  setle,          v8i1, V8I8>;
 683 def: OpmR_RR_pat<Outn<A2_vcmpbgtu>, setule,         v8i1, V8I8>;
 684 def: OpmR_RR_pat<Outn<A4_vcmpbgt>,  RevCmp<setge>,  v8i1, V8I8>;
 685 def: OpmR_RR_pat<Outn<A2_vcmpbgtu>, RevCmp<setuge>, v8i1, V8I8>;
 686 def: OpmR_RR_pat<Outn<A2_vcmpheq>,  setne,          v4i1, V4I16>;
 687 def: OpmR_RR_pat<Outn<A2_vcmphgt>,  setle,          v4i1, V4I16>;
 688 def: OpmR_RR_pat<Outn<A2_vcmphgtu>, setule,         v4i1, V4I16>;
 689 def: OpmR_RR_pat<Outn<A2_vcmphgt>,  RevCmp<setge>,  v4i1, V4I16>;
 690 def: OpmR_RR_pat<Outn<A2_vcmphgtu>, RevCmp<setuge>, v4i1, V4I16>;
 691 def: OpmR_RR_pat<Outn<A2_vcmpweq>,  setne,          v2i1, V2I32>;
 692 def: OpmR_RR_pat<Outn<A2_vcmpwgt>,  setle,          v2i1, V2I32>;
 693 def: OpmR_RR_pat<Outn<A2_vcmpwgtu>, setule,         v2i1, V2I32>;
 694 def: OpmR_RR_pat<Outn<A2_vcmpwgt>,  RevCmp<setge>,  v2i1, V2I32>;
 695 def: OpmR_RR_pat<Outn<A2_vcmpwgtu>, RevCmp<setuge>, v2i1, V2I32>;
 696
 697 let AddedComplexity = 100 in {
 698   def: Pat<(i1 (seteq (and (xor I32:$Rs, I32:$Rt), 255), 0)),
 699            (A4_cmpbeq IntRegs:$Rs, IntRegs:$Rt)>;
 700   def: Pat<(i1 (setne (and (xor I32:$Rs, I32:$Rt), 255), 0)),
 701            (C2_not (A4_cmpbeq IntRegs:$Rs, IntRegs:$Rt))>;
 702   def: Pat<(i1 (seteq (and (xor I32:$Rs, I32:$Rt), 65535), 0)),
 703            (A4_cmpheq IntRegs:$Rs, IntRegs:$Rt)>;
 704   def: Pat<(i1 (setne (and (xor I32:$Rs, I32:$Rt), 65535), 0)),
 705            (C2_not (A4_cmpheq IntRegs:$Rs, IntRegs:$Rt))>;
 706 }
 707
 708 // PatFrag for AsserZext which takes the original type as a parameter.
 709 def SDTAssertZext: SDTypeProfile<1, 2, [SDTCisInt<0>, SDTCisSameAs<0,1>]>;
 710 def AssertZextSD: SDNode<"ISD::AssertZext", SDTAssertZext>;
 711 class AssertZext<ValueType T>: PatFrag<(ops node:$A), (AssertZextSD $A, T)>;
 712
 713 multiclass Cmpb_pat<InstHexagon MI, PatFrag Op, PatFrag AssertExt,
 714                       PatLeaf ImmPred, int Mask> {
 715   def: Pat<(i1 (Op (and I32:$Rs, Mask), ImmPred:$I)),
 716            (MI I32:$Rs, imm:$I)>;
 717   def: Pat<(i1 (Op (AssertExt I32:$Rs), ImmPred:$I)),
 718            (MI I32:$Rs, imm:$I)>;
 719 }
 720
 721 multiclass CmpbN_pat<InstHexagon MI, PatFrag Op, PatFrag AssertExt,
 722                      PatLeaf ImmPred, int Mask> {
 723   def: Pat<(i1 (Op (and I32:$Rs, Mask), ImmPred:$I)),
 724            (C2_not (MI I32:$Rs, imm:$I))>;
 725   def: Pat<(i1 (Op (AssertExt I32:$Rs), ImmPred:$I)),
 726            (C2_not (MI I32:$Rs, imm:$I))>;
 727 }
 728
 729 multiclass CmpbND_pat<InstHexagon MI, PatFrag Op, PatFrag AssertExt,
 730                       PatLeaf ImmPred, int Mask> {
 731   def: Pat<(i1 (Op (and I32:$Rs, Mask), ImmPred:$I)),
 732            (C2_not (MI I32:$Rs, (UDEC1 imm:$I)))>;
 733   def: Pat<(i1 (Op (AssertExt I32:$Rs), ImmPred:$I)),
 734            (C2_not (MI I32:$Rs, (UDEC1 imm:$I)))>;
 735 }
 736
 737 let AddedComplexity = 200 in {
 738   defm: Cmpb_pat  <A4_cmpbeqi,  seteq,  AssertZext<i8>,  IsUGT<8,31>,  255>;
 739   defm: CmpbN_pat <A4_cmpbeqi,  setne,  AssertZext<i8>,  IsUGT<8,31>,  255>;
 740   defm: Cmpb_pat  <A4_cmpbgtui, setugt, AssertZext<i8>,  IsUGT<32,31>, 255>;
 741   defm: CmpbN_pat <A4_cmpbgtui, setule, AssertZext<i8>,  IsUGT<32,31>, 255>;
 742   defm: Cmpb_pat  <A4_cmphgtui, setugt, AssertZext<i16>, IsUGT<32,31>, 65535>;
 743   defm: CmpbN_pat <A4_cmphgtui, setule, AssertZext<i16>, IsUGT<32,31>, 65535>;
 744   defm: CmpbND_pat<A4_cmpbgtui, setult, AssertZext<i8>,  IsUGT<32,32>, 255>;
 745   defm: CmpbND_pat<A4_cmphgtui, setult, AssertZext<i16>, IsUGT<32,32>, 65535>;
 746 }
 747
 748 def: Pat<(i32 (zext (i1 (seteq I32:$Rs, I32:$Rt)))),
 749          (A4_rcmpeq I32:$Rs, I32:$Rt)>;
 750 def: Pat<(i32 (zext (i1 (setne I32:$Rs, I32:$Rt)))),
 751          (A4_rcmpneq I32:$Rs, I32:$Rt)>;
 752 def: Pat<(i32 (zext (i1 (seteq I32:$Rs, anyimm:$s8)))),
 753          (A4_rcmpeqi I32:$Rs, imm:$s8)>;
 754 def: Pat<(i32 (zext (i1 (setne I32:$Rs, anyimm:$s8)))),
 755          (A4_rcmpneqi I32:$Rs, imm:$s8)>;
 756
 757 def: Pat<(i1 (seteq I1:$Ps, (i1 -1))), (I1:$Ps)>;
 758 def: Pat<(i1 (setne I1:$Ps, (i1 -1))), (C2_not I1:$Ps)>;
 759 def: Pat<(i1 (seteq I1:$Ps, I1:$Pt)),  (C2_xor I1:$Ps, (C2_not I1:$Pt))>;
 760 def: Pat<(i1 (setne I1:$Ps, I1:$Pt)),  (C2_xor I1:$Ps, I1:$Pt)>;
 761
 762 // Floating-point comparisons with checks for ordered/unordered status.
 763
 764 class T3<InstHexagon MI1, InstHexagon MI2, InstHexagon MI3>
 765   : OutPatFrag<(ops node:$Rs, node:$Rt),
 766                (MI1 (MI2 $Rs, $Rt), (MI3 $Rs, $Rt))>;
 767
 768 class Cmpuf<InstHexagon MI>:  T3<C2_or,  F2_sfcmpuo, MI>;
 769 class Cmpud<InstHexagon MI>:  T3<C2_or,  F2_dfcmpuo, MI>;
 770
 771 class Cmpufn<InstHexagon MI>: T3<C2_orn, F2_sfcmpuo, MI>;
 772 class Cmpudn<InstHexagon MI>: T3<C2_orn, F2_dfcmpuo, MI>;
 773
 774 def: OpmR_RR_pat<Cmpuf<F2_sfcmpeq>,  setueq,         i1, F32>;
 775 def: OpmR_RR_pat<Cmpuf<F2_sfcmpge>,  setuge,         i1, F32>;
 776 def: OpmR_RR_pat<Cmpuf<F2_sfcmpgt>,  setugt,         i1, F32>;
 777 def: OpmR_RR_pat<Cmpuf<F2_sfcmpge>,  RevCmp<setule>, i1, F32>;
 778 def: OpmR_RR_pat<Cmpuf<F2_sfcmpgt>,  RevCmp<setult>, i1, F32>;
 779 def: OpmR_RR_pat<Cmpufn<F2_sfcmpeq>, setune,         i1, F32>;
 780
 781 def: OpmR_RR_pat<Cmpud<F2_dfcmpeq>,  setueq,         i1, F64>;
 782 def: OpmR_RR_pat<Cmpud<F2_dfcmpge>,  setuge,         i1, F64>;
 783 def: OpmR_RR_pat<Cmpud<F2_dfcmpgt>,  setugt,         i1, F64>;
 784 def: OpmR_RR_pat<Cmpud<F2_dfcmpge>,  RevCmp<setule>, i1, F64>;
 785 def: OpmR_RR_pat<Cmpud<F2_dfcmpgt>,  RevCmp<setult>, i1, F64>;
 786 def: OpmR_RR_pat<Cmpudn<F2_dfcmpeq>, setune,         i1, F64>;
 787
 788 def: OpmR_RR_pat<Outn<F2_sfcmpeq>, setone, i1, F32>;
 789 def: OpmR_RR_pat<Outn<F2_sfcmpeq>, setne,  i1, F32>;
 790
 791 def: OpmR_RR_pat<Outn<F2_dfcmpeq>, setone, i1, F64>;
 792 def: OpmR_RR_pat<Outn<F2_dfcmpeq>, setne,  i1, F64>;
 793
 794 def: OpmR_RR_pat<Outn<F2_sfcmpuo>, seto,   i1, F32>;
 795 def: OpmR_RR_pat<Outn<F2_dfcmpuo>, seto,   i1, F64>;
 796
 797
 798 // --(6) Select ----------------------------------------------------------
 799 //
 800
 801 def: Pat<(select I1:$Pu, I32:$Rs, I32:$Rt),
 802          (C2_mux I1:$Pu, I32:$Rs, I32:$Rt)>;
 803 def: Pat<(select I1:$Pu, anyimm:$s8, I32:$Rs),
 804          (C2_muxri I1:$Pu, imm:$s8, I32:$Rs)>;
 805 def: Pat<(select I1:$Pu, I32:$Rs, anyimm:$s8),
 806          (C2_muxir I1:$Pu, I32:$Rs, imm:$s8)>;
 807 def: Pat<(select I1:$Pu, anyimm:$s8, s8_0ImmPred:$S8),
 808          (C2_muxii I1:$Pu, imm:$s8, imm:$S8)>;
 809
 810 def: Pat<(select (not I1:$Pu), I32:$Rs, I32:$Rt),
 811          (C2_mux I1:$Pu, I32:$Rt, I32:$Rs)>;
 812 def: Pat<(select (not I1:$Pu), s8_0ImmPred:$S8, anyimm:$s8),
 813          (C2_muxii I1:$Pu, imm:$s8, imm:$S8)>;
 814 def: Pat<(select (not I1:$Pu), anyimm:$s8, I32:$Rs),
 815          (C2_muxir I1:$Pu, I32:$Rs, imm:$s8)>;
 816 def: Pat<(select (not I1:$Pu), I32:$Rs, anyimm:$s8),
 817          (C2_muxri I1:$Pu, imm:$s8, I32:$Rs)>;
 818
 819 // Map from a 64-bit select to an emulated 64-bit mux.
 820 // Hexagon does not support 64-bit MUXes; so emulate with combines.
 821 def: Pat<(select I1:$Pu, I64:$Rs, I64:$Rt),
 822          (Combinew (C2_mux I1:$Pu, (HiReg $Rs), (HiReg $Rt)),
 823                    (C2_mux I1:$Pu, (LoReg $Rs), (LoReg $Rt)))>;
 824
 825 def: Pat<(select I1:$Pu, F32:$Rs, f32ImmPred:$I),
 826          (C2_muxir I1:$Pu, F32:$Rs, (ftoi $I))>;
 827 def: Pat<(select I1:$Pu, f32ImmPred:$I, F32:$Rt),
 828          (C2_muxri I1:$Pu, (ftoi $I), F32:$Rt)>;
 829 def: Pat<(select I1:$Pu, F32:$Rs, F32:$Rt),
 830          (C2_mux I1:$Pu, F32:$Rs, F32:$Rt)>;
 831 def: Pat<(select I1:$Pu, F64:$Rs, F64:$Rt),
 832          (Combinew (C2_mux I1:$Pu, (HiReg $Rs), (HiReg $Rt)),
 833                    (C2_mux I1:$Pu, (LoReg $Rs), (LoReg $Rt)))>;
 834
 835 def: Pat<(select (i1 (setult F32:$Ra, F32:$Rb)), F32:$Rs, F32:$Rt),
 836          (C2_mux (F2_sfcmpgt F32:$Rb, F32:$Ra), F32:$Rs, F32:$Rt)>;
 837 def: Pat<(select (i1 (setult F64:$Ra, F64:$Rb)), F64:$Rs, F64:$Rt),
 838          (C2_vmux (F2_dfcmpgt F64:$Rb, F64:$Ra), F64:$Rs, F64:$Rt)>;
 839
 840 def: Pat<(select (not I1:$Pu), f32ImmPred:$I, F32:$Rs),
 841          (C2_muxir I1:$Pu, F32:$Rs, (ftoi $I))>;
 842 def: Pat<(select (not I1:$Pu), F32:$Rt, f32ImmPred:$I),
 843          (C2_muxri I1:$Pu, (ftoi $I), F32:$Rt)>;
 844
 845 def: Pat<(vselect V8I1:$Pu, V8I8:$Rs, V8I8:$Rt),
 846          (C2_vmux V8I1:$Pu, V8I8:$Rs, V8I8:$Rt)>;
 847 def: Pat<(vselect V4I1:$Pu, V4I16:$Rs, V4I16:$Rt),
 848          (C2_vmux V4I1:$Pu, V4I16:$Rs, V4I16:$Rt)>;
 849 def: Pat<(vselect V2I1:$Pu, V2I32:$Rs, V2I32:$Rt),
 850          (C2_vmux V2I1:$Pu, V2I32:$Rs, V2I32:$Rt)>;
 851
 852 def: Pat<(vselect (pnot V8I1:$Pu), V8I8:$Rs, V8I8:$Rt),
 853          (C2_vmux V8I1:$Pu, V8I8:$Rt, V8I8:$Rs)>;
 854 def: Pat<(vselect (pnot V4I1:$Pu), V4I16:$Rs, V4I16:$Rt),
 855          (C2_vmux V4I1:$Pu, V4I16:$Rt, V4I16:$Rs)>;
 856 def: Pat<(vselect (pnot V2I1:$Pu), V2I32:$Rs, V2I32:$Rt),
 857          (C2_vmux V2I1:$Pu, V2I32:$Rt, V2I32:$Rs)>;
 858
 859
 860 // From LegalizeDAG.cpp: (Pu ? Pv : Pw) <=> (Pu & Pv) | (!Pu & Pw).
 861 def: Pat<(select I1:$Pu, I1:$Pv, I1:$Pw),
 862          (C2_or (C2_and  I1:$Pu, I1:$Pv),
 863                 (C2_andn I1:$Pw, I1:$Pu))>;
 864
 865
 866 def IsPosHalf : PatLeaf<(i32 IntRegs:$a), [{
 867   return isPositiveHalfWord(N);
 868 }]>;
 869
 870 multiclass SelMinMax16_pats<PatFrag CmpOp, InstHexagon InstA,
 871                             InstHexagon InstB> {
 872   def: Pat<(sext_inreg (select (i1 (CmpOp IsPosHalf:$Rs, IsPosHalf:$Rt)),
 873                                IsPosHalf:$Rs, IsPosHalf:$Rt), i16),
 874            (InstA IntRegs:$Rs, IntRegs:$Rt)>;
 875   def: Pat<(sext_inreg (select (i1 (CmpOp IsPosHalf:$Rs, IsPosHalf:$Rt)),
 876                                IsPosHalf:$Rt, IsPosHalf:$Rs), i16),
 877            (InstB IntRegs:$Rs, IntRegs:$Rt)>;
 878 }
 879
 880 let AddedComplexity = 200 in {
 881   defm: SelMinMax16_pats<setge,  A2_max,  A2_min>;
 882   defm: SelMinMax16_pats<setgt,  A2_max,  A2_min>;
 883   defm: SelMinMax16_pats<setle,  A2_min,  A2_max>;
 884   defm: SelMinMax16_pats<setlt,  A2_min,  A2_max>;
 885   defm: SelMinMax16_pats<setuge, A2_maxu, A2_minu>;
 886   defm: SelMinMax16_pats<setugt, A2_maxu, A2_minu>;
 887   defm: SelMinMax16_pats<setule, A2_minu, A2_maxu>;
 888   defm: SelMinMax16_pats<setult, A2_minu, A2_maxu>;
 889 }
 890
 891 let AddedComplexity = 200 in {
 892   defm: MinMax_pats<A2_min,   A2_max,   select,  setgt, i1, I32>;
 893   defm: MinMax_pats<A2_min,   A2_max,   select,  setge, i1, I32>;
 894   defm: MinMax_pats<A2_max,   A2_min,   select,  setlt, i1, I32>;
 895   defm: MinMax_pats<A2_max,   A2_min,   select,  setle, i1, I32>;
 896   defm: MinMax_pats<A2_minu,  A2_maxu,  select, setugt, i1, I32>;
 897   defm: MinMax_pats<A2_minu,  A2_maxu,  select, setuge, i1, I32>;
 898   defm: MinMax_pats<A2_maxu,  A2_minu,  select, setult, i1, I32>;
 899   defm: MinMax_pats<A2_maxu,  A2_minu,  select, setule, i1, I32>;
 900
 901   defm: MinMax_pats<A2_minp,  A2_maxp,  select,  setgt, i1, I64>;
 902   defm: MinMax_pats<A2_minp,  A2_maxp,  select,  setge, i1, I64>;
 903   defm: MinMax_pats<A2_maxp,  A2_minp,  select,  setlt, i1, I64>;
 904   defm: MinMax_pats<A2_maxp,  A2_minp,  select,  setle, i1, I64>;
 905   defm: MinMax_pats<A2_minup, A2_maxup, select, setugt, i1, I64>;
 906   defm: MinMax_pats<A2_minup, A2_maxup, select, setuge, i1, I64>;
 907   defm: MinMax_pats<A2_maxup, A2_minup, select, setult, i1, I64>;
 908   defm: MinMax_pats<A2_maxup, A2_minup, select, setule, i1, I64>;
 909 }
 910
 911 let AddedComplexity = 100 in {
 912   defm: MinMax_pats<F2_sfmin, F2_sfmax, select, setogt, i1, F32>;
 913   defm: MinMax_pats<F2_sfmin, F2_sfmax, select, setoge, i1, F32>;
 914   defm: MinMax_pats<F2_sfmax, F2_sfmin, select, setolt, i1, F32>;
 915   defm: MinMax_pats<F2_sfmax, F2_sfmin, select, setole, i1, F32>;
 916 }
 917
 918 defm: MinMax_pats<A2_vminb,  A2_vmaxb,  vselect,  setgt,  v8i1,  V8I8>;
 919 defm: MinMax_pats<A2_vminb,  A2_vmaxb,  vselect,  setge,  v8i1,  V8I8>;
 920 defm: MinMax_pats<A2_vminh,  A2_vmaxh,  vselect,  setgt,  v4i1, V4I16>;
 921 defm: MinMax_pats<A2_vminh,  A2_vmaxh,  vselect,  setge,  v4i1, V4I16>;
 922 defm: MinMax_pats<A2_vminw,  A2_vmaxw,  vselect,  setgt,  v2i1, V2I32>;
 923 defm: MinMax_pats<A2_vminw,  A2_vmaxw,  vselect,  setge,  v2i1, V2I32>;
 924 defm: MinMax_pats<A2_vminub, A2_vmaxub, vselect, setugt,  v8i1,  V8I8>;
 925 defm: MinMax_pats<A2_vminub, A2_vmaxub, vselect, setuge,  v8i1,  V8I8>;
 926 defm: MinMax_pats<A2_vminuh, A2_vmaxuh, vselect, setugt,  v4i1, V4I16>;
 927 defm: MinMax_pats<A2_vminuh, A2_vmaxuh, vselect, setuge,  v4i1, V4I16>;
 928 defm: MinMax_pats<A2_vminuw, A2_vmaxuw, vselect, setugt,  v2i1, V2I32>;
 929 defm: MinMax_pats<A2_vminuw, A2_vmaxuw, vselect, setuge,  v2i1, V2I32>;
 930
 931 // --(7) Insert/extract --------------------------------------------------
 932 //
 933
 934 def SDTHexagonINSERT:
 935   SDTypeProfile<1, 4, [SDTCisSameAs<0, 1>, SDTCisSameAs<0, 2>,
 936                        SDTCisInt<0>, SDTCisVT<3, i32>, SDTCisVT<4, i32>]>;
 937 def HexagonINSERT:    SDNode<"HexagonISD::INSERT",   SDTHexagonINSERT>;
 938
 939 let AddedComplexity = 10 in {
 940   def: Pat<(HexagonINSERT I32:$Rs, I32:$Rt, u5_0ImmPred:$u1, u5_0ImmPred:$u2),
 941            (S2_insert I32:$Rs, I32:$Rt, imm:$u1, imm:$u2)>;
 942   def: Pat<(HexagonINSERT I64:$Rs, I64:$Rt, u6_0ImmPred:$u1, u6_0ImmPred:$u2),
 943            (S2_insertp I64:$Rs, I64:$Rt, imm:$u1, imm:$u2)>;
 944 }
 945 def: Pat<(HexagonINSERT I32:$Rs, I32:$Rt, I32:$Width, I32:$Off),
 946          (S2_insert_rp I32:$Rs, I32:$Rt, (Combinew $Width, $Off))>;
 947 def: Pat<(HexagonINSERT I64:$Rs, I64:$Rt, I32:$Width, I32:$Off),
 948          (S2_insertp_rp I64:$Rs, I64:$Rt, (Combinew $Width, $Off))>;
 949
 950 def SDTHexagonEXTRACTU
 951   : SDTypeProfile<1, 3, [SDTCisSameAs<0, 1>, SDTCisInt<0>, SDTCisInt<1>,
 952                   SDTCisVT<2, i32>, SDTCisVT<3, i32>]>;
 953 def HexagonEXTRACTU:   SDNode<"HexagonISD::EXTRACTU",   SDTHexagonEXTRACTU>;
 954
 955 let AddedComplexity = 10 in {
 956   def: Pat<(HexagonEXTRACTU I32:$Rs, u5_0ImmPred:$u5, u5_0ImmPred:$U5),
 957            (S2_extractu I32:$Rs, imm:$u5, imm:$U5)>;
 958   def: Pat<(HexagonEXTRACTU I64:$Rs, u6_0ImmPred:$u6, u6_0ImmPred:$U6),
 959            (S2_extractup I64:$Rs, imm:$u6, imm:$U6)>;
 960 }
 961 def: Pat<(HexagonEXTRACTU I32:$Rs, I32:$Width, I32:$Off),
 962          (S2_extractu_rp I32:$Rs, (Combinew $Width, $Off))>;
 963 def: Pat<(HexagonEXTRACTU I64:$Rs, I32:$Width, I32:$Off),
 964          (S2_extractup_rp I64:$Rs, (Combinew $Width, $Off))>;
 965
 966 def SDTHexagonVSPLAT:
 967   SDTypeProfile<1, 1, [SDTCisVec<0>, SDTCisVT<1, i32>]>;
 968
 969 def HexagonVSPLAT: SDNode<"HexagonISD::VSPLAT", SDTHexagonVSPLAT>;
 970
 971 def: Pat<(v4i8  (HexagonVSPLAT I32:$Rs)), (S2_vsplatrb I32:$Rs)>;
 972 def: Pat<(v4i16 (HexagonVSPLAT I32:$Rs)), (S2_vsplatrh I32:$Rs)>;
 973 def: Pat<(v2i32 (HexagonVSPLAT s8_0ImmPred:$s8)),
 974          (A2_combineii imm:$s8, imm:$s8)>;
 975 def: Pat<(v2i32 (HexagonVSPLAT I32:$Rs)), (Combinew I32:$Rs, I32:$Rs)>;
 976
 977 let AddedComplexity = 10 in
 978 def: Pat<(v8i8 (HexagonVSPLAT I32:$Rs)), (S6_vsplatrbp I32:$Rs)>,
 979      Requires<[HasV62]>;
 980 def: Pat<(v8i8 (HexagonVSPLAT I32:$Rs)),
 981          (Combinew (S2_vsplatrb I32:$Rs), (S2_vsplatrb I32:$Rs))>;
 982
 983
 984 // --(8) Shift/permute ---------------------------------------------------
 985 //
 986
 987 def SDTHexagonI64I32I32: SDTypeProfile<1, 2,
 988   [SDTCisVT<0, i64>, SDTCisVT<1, i32>, SDTCisSameAs<1, 2>]>;
 989
 990 def HexagonCOMBINE:  SDNode<"HexagonISD::COMBINE",  SDTHexagonI64I32I32>;
 991
 992 def: Pat<(HexagonCOMBINE I32:$Rs, I32:$Rt), (Combinew $Rs, $Rt)>;
 993
 994 // The complexity of the combines involving immediates should be greater
 995 // than the complexity of the combine with two registers.
 996 let AddedComplexity = 50 in {
 997   def: Pat<(HexagonCOMBINE I32:$Rs, anyimm:$s8),
 998            (A4_combineri IntRegs:$Rs, imm:$s8)>;
 999   def: Pat<(HexagonCOMBINE anyimm:$s8, I32:$Rs),
1000            (A4_combineir imm:$s8, IntRegs:$Rs)>;
1001 }
1002
1003 // The complexity of the combine with two immediates should be greater than
1004 // the complexity of a combine involving a register.
1005 let AddedComplexity = 75 in {
1006   def: Pat<(HexagonCOMBINE s8_0ImmPred:$s8, anyimm:$u6),
1007            (A4_combineii imm:$s8, imm:$u6)>;
1008   def: Pat<(HexagonCOMBINE anyimm:$s8, s8_0ImmPred:$S8),
1009            (A2_combineii imm:$s8, imm:$S8)>;
1010 }
1011
1012 def: Pat<(bswap I32:$Rs),  (A2_swiz I32:$Rs)>;
1013 def: Pat<(bswap I64:$Rss), (Combinew (A2_swiz (LoReg $Rss)),
1014                                      (A2_swiz (HiReg $Rss)))>;
1015
1016 def: Pat<(shl s6_0ImmPred:$s6, I32:$Rt),  (S4_lsli imm:$s6, I32:$Rt)>;
1017 def: Pat<(shl I32:$Rs, (i32 16)),         (A2_aslh I32:$Rs)>;
1018 def: Pat<(sra I32:$Rs, (i32 16)),         (A2_asrh I32:$Rs)>;
1019
1020 def: OpR_RI_pat<S2_asr_i_r,  Sra, i32,   I32,   u5_0ImmPred>;
1021 def: OpR_RI_pat<S2_lsr_i_r,  Srl, i32,   I32,   u5_0ImmPred>;
1022 def: OpR_RI_pat<S2_asl_i_r,  Shl, i32,   I32,   u5_0ImmPred>;
1023 def: OpR_RI_pat<S2_asr_i_p,  Sra, i64,   I64,   u6_0ImmPred>;
1024 def: OpR_RI_pat<S2_lsr_i_p,  Srl, i64,   I64,   u6_0ImmPred>;
1025 def: OpR_RI_pat<S2_asl_i_p,  Shl, i64,   I64,   u6_0ImmPred>;
1026 def: OpR_RI_pat<S2_asr_i_vh, Sra, v4i16, V4I16, u4_0ImmPred>;
1027 def: OpR_RI_pat<S2_lsr_i_vh, Srl, v4i16, V4I16, u4_0ImmPred>;
1028 def: OpR_RI_pat<S2_asl_i_vh, Shl, v4i16, V4I16, u4_0ImmPred>;
1029 def: OpR_RI_pat<S2_asr_i_vh, Sra, v2i32, V2I32, u5_0ImmPred>;
1030 def: OpR_RI_pat<S2_lsr_i_vh, Srl, v2i32, V2I32, u5_0ImmPred>;
1031 def: OpR_RI_pat<S2_asl_i_vh, Shl, v2i32, V2I32, u5_0ImmPred>;
1032
1033 def: OpR_RR_pat<S2_asr_r_r, Sra, i32, I32, I32>;
1034 def: OpR_RR_pat<S2_lsr_r_r, Srl, i32, I32, I32>;
1035 def: OpR_RR_pat<S2_asl_r_r, Shl, i32, I32, I32>;
1036 def: OpR_RR_pat<S2_asr_r_p, Sra, i64, I64, I32>;
1037 def: OpR_RR_pat<S2_lsr_r_p, Srl, i64, I64, I32>;
1038 def: OpR_RR_pat<S2_asl_r_p, Shl, i64, I64, I32>;
1039
1040 // Funnel shifts.
1041 def IsMul8_U3: PatLeaf<(i32 imm), [{
1042   uint64_t V = N->getZExtValue();
1043   return V % 8 == 0 && isUInt<3>(V / 8);
1044 }]>;
1045
1046 def Divu8: SDNodeXForm<imm, [{
1047   return CurDAG->getTargetConstant(N->getZExtValue() / 8, SDLoc(N), MVT::i32);
1048 }]>;
1049
1050 // Funnel shift-left.
1051 def FShl32i: OutPatFrag<(ops node:$Rs, node:$Rt, node:$S),
1052   (HiReg (S2_asl_i_p (Combinew $Rs, $Rt), $S))>;
1053 def FShl32r: OutPatFrag<(ops node:$Rs, node:$Rt, node:$Ru),
1054   (HiReg (S2_asl_r_p (Combinew $Rs, $Rt), $Ru))>;
1055
1056 def FShl64i: OutPatFrag<(ops node:$Rs, node:$Rt, node:$S),
1057   (S2_lsr_i_p_or (S2_asl_i_p $Rt, $S),  $Rs, (Subi<64> $S))>;
1058 def FShl64r: OutPatFrag<(ops node:$Rs, node:$Rt, node:$Ru),
1059   (S2_lsr_r_p_or (S2_asl_r_p $Rt, $Ru), $Rs, (A2_subri 64, $Ru))>;
1060
1061 // Combined SDNodeXForm: (Divu8 (Subi<64> $S))
1062 def Divu64_8: SDNodeXForm<imm, [{
1063   return CurDAG->getTargetConstant((64 - N->getSExtValue()) / 8,
1064                                    SDLoc(N), MVT::i32);
1065 }]>;
1066
1067 // Special cases:
1068 let AddedComplexity = 100 in {
1069   def: Pat<(fshl I32:$Rs, I32:$Rt, (i32 16)),
1070            (A2_combine_hl I32:$Rs, I32:$Rt)>;
1071   def: Pat<(fshl I64:$Rs, I64:$Rt, IsMul8_U3:$S),
1072            (S2_valignib I64:$Rs, I64:$Rt, (Divu64_8 $S))>;
1073 }
1074
1075 let Predicates = [HasV60], AddedComplexity = 50 in {
1076   def: OpR_RI_pat<S6_rol_i_r, Rol, i32, I32, u5_0ImmPred>;
1077   def: OpR_RI_pat<S6_rol_i_p, Rol, i64, I64, u6_0ImmPred>;
1078 }
1079 let AddedComplexity = 30 in {
1080   def: Pat<(rotl I32:$Rs, u5_0ImmPred:$S),          (FShl32i $Rs, $Rs, imm:$S)>;
1081   def: Pat<(rotl I64:$Rs, u6_0ImmPred:$S),          (FShl64i $Rs, $Rs, imm:$S)>;
1082   def: Pat<(fshl I32:$Rs, I32:$Rt, u5_0ImmPred:$S), (FShl32i $Rs, $Rt, imm:$S)>;
1083   def: Pat<(fshl I64:$Rs, I64:$Rt, u6_0ImmPred:$S), (FShl64i $Rs, $Rt, imm:$S)>;
1084 }
1085 def: Pat<(rotl I32:$Rs, I32:$Rt),           (FShl32r $Rs, $Rs, $Rt)>;
1086 def: Pat<(rotl I64:$Rs, I32:$Rt),           (FShl64r $Rs, $Rs, $Rt)>;
1087 def: Pat<(fshl I32:$Rs, I32:$Rt, I32:$Ru),  (FShl32r $Rs, $Rt, $Ru)>;
1088 def: Pat<(fshl I64:$Rs, I64:$Rt, I32:$Ru),  (FShl64r $Rs, $Rt, $Ru)>;
1089
1090 // Funnel shift-right.
1091 def FShr32i: OutPatFrag<(ops node:$Rs, node:$Rt, node:$S),
1092   (LoReg (S2_lsr_i_p (Combinew $Rs, $Rt), $S))>;
1093 def FShr32r: OutPatFrag<(ops node:$Rs, node:$Rt, node:$Ru),
1094   (LoReg (S2_lsr_r_p (Combinew $Rs, $Rt), $Ru))>;
1095
1096 def FShr64i: OutPatFrag<(ops node:$Rs, node:$Rt, node:$S),
1097   (S2_asl_i_p_or (S2_lsr_i_p $Rt, $S),  $Rs, (Subi<64> $S))>;
1098 def FShr64r: OutPatFrag<(ops node:$Rs, node:$Rt, node:$Ru),
1099   (S2_asl_r_p_or (S2_lsr_r_p $Rt, $Ru), $Rs, (A2_subri 64, $Ru))>;
1100
1101 // Special cases:
1102 let AddedComplexity = 100 in {
1103   def: Pat<(fshr I32:$Rs, I32:$Rt, (i32 16)),
1104            (A2_combine_hl I32:$Rs, I32:$Rt)>;
1105   def: Pat<(fshr I64:$Rs, I64:$Rt, IsMul8_U3:$S),
1106            (S2_valignib I64:$Rs, I64:$Rt, (Divu8 $S))>;
1107 }
1108
1109 let Predicates = [HasV60], AddedComplexity = 50 in {
1110   def: Pat<(rotr I32:$Rs, u5_0ImmPred:$S), (S6_rol_i_r I32:$Rs, (Subi<32> $S))>;
1111   def: Pat<(rotr I64:$Rs, u6_0ImmPred:$S), (S6_rol_i_p I64:$Rs, (Subi<64> $S))>;
1112 }
1113 let AddedComplexity = 30 in {
1114   def: Pat<(rotr I32:$Rs, u5_0ImmPred:$S),          (FShr32i $Rs, $Rs, imm:$S)>;
1115   def: Pat<(rotr I64:$Rs, u6_0ImmPred:$S),          (FShr64i $Rs, $Rs, imm:$S)>;
1116   def: Pat<(fshr I32:$Rs, I32:$Rt, u5_0ImmPred:$S), (FShr32i $Rs, $Rt, imm:$S)>;
1117   def: Pat<(fshr I64:$Rs, I64:$Rt, u6_0ImmPred:$S), (FShr64i $Rs, $Rt, imm:$S)>;
1118 }
1119 def: Pat<(rotr I32:$Rs, I32:$Rt),           (FShr32r $Rs, $Rs, $Rt)>;
1120 def: Pat<(rotr I64:$Rs, I32:$Rt),           (FShr64r $Rs, $Rs, $Rt)>;
1121 def: Pat<(fshr I32:$Rs, I32:$Rt, I32:$Ru),  (FShr32r $Rs, $Rt, $Ru)>;
1122 def: Pat<(fshr I64:$Rs, I64:$Rt, I32:$Ru),  (FShr64r $Rs, $Rt, $Ru)>;
1123
1124
1125 def: Pat<(sra (add (sra I32:$Rs, u5_0ImmPred:$u5), 1), (i32 1)),
1126          (S2_asr_i_r_rnd I32:$Rs, imm:$u5)>;
1127 def: Pat<(sra (add (sra I64:$Rs, u6_0ImmPred:$u6), 1), (i32 1)),
1128          (S2_asr_i_p_rnd I64:$Rs, imm:$u6)>;
1129
1130 // Prefer S2_addasl_rrri over S2_asl_i_r_acc.
1131 let AddedComplexity = 120 in
1132 def: Pat<(add I32:$Rt, (shl I32:$Rs, u3_0ImmPred:$u3)),
1133          (S2_addasl_rrri IntRegs:$Rt, IntRegs:$Rs, imm:$u3)>;
1134
1135 let AddedComplexity = 100 in {
1136   def: AccRRI_pat<S2_asr_i_r_acc,   Add, Su<Sra>, I32, u5_0ImmPred>;
1137   def: AccRRI_pat<S2_asr_i_r_nac,   Sub, Su<Sra>, I32, u5_0ImmPred>;
1138   def: AccRRI_pat<S2_asr_i_r_and,   And, Su<Sra>, I32, u5_0ImmPred>;
1139   def: AccRRI_pat<S2_asr_i_r_or,    Or,  Su<Sra>, I32, u5_0ImmPred>;
1140
1141   def: AccRRI_pat<S2_asr_i_p_acc,   Add, Su<Sra>, I64, u6_0ImmPred>;
1142   def: AccRRI_pat<S2_asr_i_p_nac,   Sub, Su<Sra>, I64, u6_0ImmPred>;
1143   def: AccRRI_pat<S2_asr_i_p_and,   And, Su<Sra>, I64, u6_0ImmPred>;
1144   def: AccRRI_pat<S2_asr_i_p_or,    Or,  Su<Sra>, I64, u6_0ImmPred>;
1145
1146   def: AccRRI_pat<S2_lsr_i_r_acc,   Add, Su<Srl>, I32, u5_0ImmPred>;
1147   def: AccRRI_pat<S2_lsr_i_r_nac,   Sub, Su<Srl>, I32, u5_0ImmPred>;
1148   def: AccRRI_pat<S2_lsr_i_r_and,   And, Su<Srl>, I32, u5_0ImmPred>;
1149   def: AccRRI_pat<S2_lsr_i_r_or,    Or,  Su<Srl>, I32, u5_0ImmPred>;
1150   def: AccRRI_pat<S2_lsr_i_r_xacc,  Xor, Su<Srl>, I32, u5_0ImmPred>;
1151
1152   def: AccRRI_pat<S2_lsr_i_p_acc,   Add, Su<Srl>, I64, u6_0ImmPred>;
1153   def: AccRRI_pat<S2_lsr_i_p_nac,   Sub, Su<Srl>, I64, u6_0ImmPred>;
1154   def: AccRRI_pat<S2_lsr_i_p_and,   And, Su<Srl>, I64, u6_0ImmPred>;
1155   def: AccRRI_pat<S2_lsr_i_p_or,    Or,  Su<Srl>, I64, u6_0ImmPred>;
1156   def: AccRRI_pat<S2_lsr_i_p_xacc,  Xor, Su<Srl>, I64, u6_0ImmPred>;
1157
1158   def: AccRRI_pat<S2_asl_i_r_acc,   Add, Su<Shl>, I32, u5_0ImmPred>;
1159   def: AccRRI_pat<S2_asl_i_r_nac,   Sub, Su<Shl>, I32, u5_0ImmPred>;
1160   def: AccRRI_pat<S2_asl_i_r_and,   And, Su<Shl>, I32, u5_0ImmPred>;
1161   def: AccRRI_pat<S2_asl_i_r_or,    Or,  Su<Shl>, I32, u5_0ImmPred>;
1162   def: AccRRI_pat<S2_asl_i_r_xacc,  Xor, Su<Shl>, I32, u5_0ImmPred>;
1163
1164   def: AccRRI_pat<S2_asl_i_p_acc,   Add, Su<Shl>, I64, u6_0ImmPred>;
1165   def: AccRRI_pat<S2_asl_i_p_nac,   Sub, Su<Shl>, I64, u6_0ImmPred>;
1166   def: AccRRI_pat<S2_asl_i_p_and,   And, Su<Shl>, I64, u6_0ImmPred>;
1167   def: AccRRI_pat<S2_asl_i_p_or,    Or,  Su<Shl>, I64, u6_0ImmPred>;
1168   def: AccRRI_pat<S2_asl_i_p_xacc,  Xor, Su<Shl>, I64, u6_0ImmPred>;
1169
1170   let Predicates = [HasV60] in {
1171     def: AccRRI_pat<S6_rol_i_r_acc,   Add, Su<Rol>, I32, u5_0ImmPred>;
1172     def: AccRRI_pat<S6_rol_i_r_nac,   Sub, Su<Rol>, I32, u5_0ImmPred>;
1173     def: AccRRI_pat<S6_rol_i_r_and,   And, Su<Rol>, I32, u5_0ImmPred>;
1174     def: AccRRI_pat<S6_rol_i_r_or,    Or,  Su<Rol>, I32, u5_0ImmPred>;
1175     def: AccRRI_pat<S6_rol_i_r_xacc,  Xor, Su<Rol>, I32, u5_0ImmPred>;
1176
1177     def: AccRRI_pat<S6_rol_i_p_acc,   Add, Su<Rol>, I64, u6_0ImmPred>;
1178     def: AccRRI_pat<S6_rol_i_p_nac,   Sub, Su<Rol>, I64, u6_0ImmPred>;
1179     def: AccRRI_pat<S6_rol_i_p_and,   And, Su<Rol>, I64, u6_0ImmPred>;
1180     def: AccRRI_pat<S6_rol_i_p_or,    Or,  Su<Rol>, I64, u6_0ImmPred>;
1181     def: AccRRI_pat<S6_rol_i_p_xacc,  Xor, Su<Rol>, I64, u6_0ImmPred>;
1182   }
1183 }
1184
1185 let AddedComplexity = 100 in {
1186   def: AccRRR_pat<S2_asr_r_r_acc,   Add, Su<Sra>, I32, I32, I32>;
1187   def: AccRRR_pat<S2_asr_r_r_nac,   Sub, Su<Sra>, I32, I32, I32>;
1188   def: AccRRR_pat<S2_asr_r_r_and,   And, Su<Sra>, I32, I32, I32>;
1189   def: AccRRR_pat<S2_asr_r_r_or,    Or,  Su<Sra>, I32, I32, I32>;
1190
1191   def: AccRRR_pat<S2_asr_r_p_acc,   Add, Su<Sra>, I64, I64, I32>;
1192   def: AccRRR_pat<S2_asr_r_p_nac,   Sub, Su<Sra>, I64, I64, I32>;
1193   def: AccRRR_pat<S2_asr_r_p_and,   And, Su<Sra>, I64, I64, I32>;
1194   def: AccRRR_pat<S2_asr_r_p_or,    Or,  Su<Sra>, I64, I64, I32>;
1195   def: AccRRR_pat<S2_asr_r_p_xor,   Xor, Su<Sra>, I64, I64, I32>;
1196
1197   def: AccRRR_pat<S2_lsr_r_r_acc,   Add, Su<Srl>, I32, I32, I32>;
1198   def: AccRRR_pat<S2_lsr_r_r_nac,   Sub, Su<Srl>, I32, I32, I32>;
1199   def: AccRRR_pat<S2_lsr_r_r_and,   And, Su<Srl>, I32, I32, I32>;
1200   def: AccRRR_pat<S2_lsr_r_r_or,    Or,  Su<Srl>, I32, I32, I32>;
1201
1202   def: AccRRR_pat<S2_lsr_r_p_acc,   Add, Su<Srl>, I64, I64, I32>;
1203   def: AccRRR_pat<S2_lsr_r_p_nac,   Sub, Su<Srl>, I64, I64, I32>;
1204   def: AccRRR_pat<S2_lsr_r_p_and,   And, Su<Srl>, I64, I64, I32>;
1205   def: AccRRR_pat<S2_lsr_r_p_or,    Or,  Su<Srl>, I64, I64, I32>;
1206   def: AccRRR_pat<S2_lsr_r_p_xor,   Xor, Su<Srl>, I64, I64, I32>;
1207
1208   def: AccRRR_pat<S2_asl_r_r_acc,   Add, Su<Shl>, I32, I32, I32>;
1209   def: AccRRR_pat<S2_asl_r_r_nac,   Sub, Su<Shl>, I32, I32, I32>;
1210   def: AccRRR_pat<S2_asl_r_r_and,   And, Su<Shl>, I32, I32, I32>;
1211   def: AccRRR_pat<S2_asl_r_r_or,    Or,  Su<Shl>, I32, I32, I32>;
1212
1213   def: AccRRR_pat<S2_asl_r_p_acc,   Add, Su<Shl>, I64, I64, I32>;
1214   def: AccRRR_pat<S2_asl_r_p_nac,   Sub, Su<Shl>, I64, I64, I32>;
1215   def: AccRRR_pat<S2_asl_r_p_and,   And, Su<Shl>, I64, I64, I32>;
1216   def: AccRRR_pat<S2_asl_r_p_or,    Or,  Su<Shl>, I64, I64, I32>;
1217   def: AccRRR_pat<S2_asl_r_p_xor,   Xor, Su<Shl>, I64, I64, I32>;
1218 }
1219
1220
1221 class OpshIRI_pat<InstHexagon MI, PatFrag Op, PatFrag ShOp,
1222                   PatFrag RegPred, PatFrag ImmPred>
1223   : Pat<(Op anyimm:$u8, (ShOp RegPred:$Rs, ImmPred:$U5)),
1224         (MI anyimm:$u8, RegPred:$Rs, imm:$U5)>;
1225
1226 let AddedComplexity = 200 in {
1227   def: OpshIRI_pat<S4_addi_asl_ri,  Add, Su<Shl>, I32, u5_0ImmPred>;
1228   def: OpshIRI_pat<S4_addi_lsr_ri,  Add, Su<Srl>, I32, u5_0ImmPred>;
1229   def: OpshIRI_pat<S4_subi_asl_ri,  Sub, Su<Shl>, I32, u5_0ImmPred>;
1230   def: OpshIRI_pat<S4_subi_lsr_ri,  Sub, Su<Srl>, I32, u5_0ImmPred>;
1231   def: OpshIRI_pat<S4_andi_asl_ri,  And, Su<Shl>, I32, u5_0ImmPred>;
1232   def: OpshIRI_pat<S4_andi_lsr_ri,  And, Su<Srl>, I32, u5_0ImmPred>;
1233   def: OpshIRI_pat<S4_ori_asl_ri,   Or,  Su<Shl>, I32, u5_0ImmPred>;
1234   def: OpshIRI_pat<S4_ori_lsr_ri,   Or,  Su<Srl>, I32, u5_0ImmPred>;
1235 }
1236
1237 // Prefer this pattern to S2_asl_i_p_or for the special case of joining
1238 // two 32-bit words into a 64-bit word.
1239 let AddedComplexity = 200 in
1240 def: Pat<(or (shl (Aext64 I32:$a), (i32 32)), (Zext64 I32:$b)),
1241          (Combinew I32:$a, I32:$b)>;
1242
1243 def: Pat<(or (or (or (shl (Zext64 (and I32:$b, (i32 65535))), (i32 16)),
1244                      (Zext64 (and I32:$a, (i32 65535)))),
1245                  (shl (Aext64 (and I32:$c, (i32 65535))), (i32 32))),
1246              (shl (Aext64 I32:$d), (i32 48))),
1247          (Combinew (A2_combine_ll I32:$d, I32:$c),
1248                    (A2_combine_ll I32:$b, I32:$a))>;
1249
1250 let AddedComplexity = 200 in {
1251   def: Pat<(or (shl I32:$Rt, (i32 16)), (and I32:$Rs, (i32 65535))),
1252            (A2_combine_ll I32:$Rt, I32:$Rs)>;
1253   def: Pat<(or (shl I32:$Rt, (i32 16)), (srl I32:$Rs, (i32 16))),
1254            (A2_combine_lh I32:$Rt, I32:$Rs)>;
1255   def: Pat<(or (and I32:$Rt, (i32 268431360)), (and I32:$Rs, (i32 65535))),
1256            (A2_combine_hl I32:$Rt, I32:$Rs)>;
1257   def: Pat<(or (and I32:$Rt, (i32 268431360)), (srl I32:$Rs, (i32 16))),
1258            (A2_combine_hh I32:$Rt, I32:$Rs)>;
1259 }
1260
1261 def SDTHexagonVShift
1262   : SDTypeProfile<1, 2, [SDTCisSameAs<0, 1>, SDTCisVec<0>, SDTCisVT<2, i32>]>;
1263
1264 def HexagonVASL: SDNode<"HexagonISD::VASL", SDTHexagonVShift>;
1265 def HexagonVASR: SDNode<"HexagonISD::VASR", SDTHexagonVShift>;
1266 def HexagonVLSR: SDNode<"HexagonISD::VLSR", SDTHexagonVShift>;
1267
1268 def: OpR_RI_pat<S2_asl_i_vw, pf2<HexagonVASL>, v2i32, V2I32, u5_0ImmPred>;
1269 def: OpR_RI_pat<S2_asl_i_vh, pf2<HexagonVASL>, v4i16, V4I16, u4_0ImmPred>;
1270 def: OpR_RI_pat<S2_asr_i_vw, pf2<HexagonVASR>, v2i32, V2I32, u5_0ImmPred>;
1271 def: OpR_RI_pat<S2_asr_i_vh, pf2<HexagonVASR>, v4i16, V4I16, u4_0ImmPred>;
1272 def: OpR_RI_pat<S2_lsr_i_vw, pf2<HexagonVLSR>, v2i32, V2I32, u5_0ImmPred>;
1273 def: OpR_RI_pat<S2_lsr_i_vh, pf2<HexagonVLSR>, v4i16, V4I16, u4_0ImmPred>;
1274
1275 def: OpR_RR_pat<S2_asl_r_vw, pf2<HexagonVASL>, v2i32, V2I32, I32>;
1276 def: OpR_RR_pat<S2_asl_r_vh, pf2<HexagonVASL>, v4i16, V4I16, I32>;
1277 def: OpR_RR_pat<S2_asr_r_vw, pf2<HexagonVASR>, v2i32, V2I32, I32>;
1278 def: OpR_RR_pat<S2_asr_r_vh, pf2<HexagonVASR>, v4i16, V4I16, I32>;
1279 def: OpR_RR_pat<S2_lsr_r_vw, pf2<HexagonVLSR>, v2i32, V2I32, I32>;
1280 def: OpR_RR_pat<S2_lsr_r_vh, pf2<HexagonVLSR>, v4i16, V4I16, I32>;
1281
1282 def: Pat<(sra V2I32:$b, (v2i32 (HexagonVSPLAT u5_0ImmPred:$c))),
1283          (S2_asr_i_vw V2I32:$b, imm:$c)>;
1284 def: Pat<(srl V2I32:$b, (v2i32 (HexagonVSPLAT u5_0ImmPred:$c))),
1285          (S2_lsr_i_vw V2I32:$b, imm:$c)>;
1286 def: Pat<(shl V2I32:$b, (v2i32 (HexagonVSPLAT u5_0ImmPred:$c))),
1287          (S2_asl_i_vw V2I32:$b, imm:$c)>;
1288 def: Pat<(sra V4I16:$b, (v4i16 (HexagonVSPLAT u4_0ImmPred:$c))),
1289          (S2_asr_i_vh V4I16:$b, imm:$c)>;
1290 def: Pat<(srl V4I16:$b, (v4i16 (HexagonVSPLAT u4_0ImmPred:$c))),
1291          (S2_lsr_i_vh V4I16:$b, imm:$c)>;
1292 def: Pat<(shl V4I16:$b, (v4i16 (HexagonVSPLAT u4_0ImmPred:$c))),
1293          (S2_asl_i_vh V4I16:$b, imm:$c)>;
1294
1295 def: Pat<(HexagonVASR V2I16:$Rs, u4_0ImmPred:$S),
1296          (LoReg (S2_asr_i_vh (ToAext64 $Rs), imm:$S))>;
1297 def: Pat<(HexagonVASL V2I16:$Rs, u4_0ImmPred:$S),
1298          (LoReg (S2_asl_i_vh (ToAext64 $Rs), imm:$S))>;
1299 def: Pat<(HexagonVLSR V2I16:$Rs, u4_0ImmPred:$S),
1300          (LoReg (S2_lsr_i_vh (ToAext64 $Rs), imm:$S))>;
1301 def: Pat<(HexagonVASR V2I16:$Rs, I32:$Rt),
1302          (LoReg (S2_asr_i_vh (ToAext64 $Rs), I32:$Rt))>;
1303 def: Pat<(HexagonVASL V2I16:$Rs, I32:$Rt),
1304          (LoReg (S2_asl_i_vh (ToAext64 $Rs), I32:$Rt))>;
1305 def: Pat<(HexagonVLSR V2I16:$Rs, I32:$Rt),
1306          (LoReg (S2_lsr_i_vh (ToAext64 $Rs), I32:$Rt))>;
1307
1308
1309 // --(9) Arithmetic/bitwise ----------------------------------------------
1310 //
1311
1312 def: Pat<(abs  I32:$Rs), (A2_abs   I32:$Rs)>;
1313 def: Pat<(abs  I64:$Rs), (A2_absp  I64:$Rs)>;
1314 def: Pat<(not  I32:$Rs), (A2_subri -1, I32:$Rs)>;
1315 def: Pat<(not  I64:$Rs), (A2_notp  I64:$Rs)>;
1316 def: Pat<(ineg I64:$Rs), (A2_negp  I64:$Rs)>;
1317
1318 def: Pat<(fabs F32:$Rs), (S2_clrbit_i    F32:$Rs, 31)>;
1319 def: Pat<(fneg F32:$Rs), (S2_togglebit_i F32:$Rs, 31)>;
1320
1321 def: Pat<(fabs F64:$Rs),
1322          (Combinew (S2_clrbit_i (HiReg $Rs), 31),
1323                    (i32 (LoReg $Rs)))>;
1324 def: Pat<(fneg F64:$Rs),
1325          (Combinew (S2_togglebit_i (HiReg $Rs), 31),
1326                    (i32 (LoReg $Rs)))>;
1327
1328 def: Pat<(add I32:$Rs, anyimm:$s16),   (A2_addi   I32:$Rs,  imm:$s16)>;
1329 def: Pat<(or  I32:$Rs, anyimm:$s10),   (A2_orir   I32:$Rs,  imm:$s10)>;
1330 def: Pat<(and I32:$Rs, anyimm:$s10),   (A2_andir  I32:$Rs,  imm:$s10)>;
1331 def: Pat<(sub anyimm:$s10, I32:$Rs),   (A2_subri  imm:$s10, I32:$Rs)>;
1332
1333 def: OpR_RR_pat<A2_add,       Add,        i32,   I32>;
1334 def: OpR_RR_pat<A2_sub,       Sub,        i32,   I32>;
1335 def: OpR_RR_pat<A2_and,       And,        i32,   I32>;
1336 def: OpR_RR_pat<A2_or,        Or,         i32,   I32>;
1337 def: OpR_RR_pat<A2_xor,       Xor,        i32,   I32>;
1338 def: OpR_RR_pat<A2_addp,      Add,        i64,   I64>;
1339 def: OpR_RR_pat<A2_subp,      Sub,        i64,   I64>;
1340 def: OpR_RR_pat<A2_andp,      And,        i64,   I64>;
1341 def: OpR_RR_pat<A2_orp,       Or,         i64,   I64>;
1342 def: OpR_RR_pat<A2_xorp,      Xor,        i64,   I64>;
1343 def: OpR_RR_pat<A4_andnp,     Not2<And>,  i64,   I64>;
1344 def: OpR_RR_pat<A4_ornp,      Not2<Or>,   i64,   I64>;
1345
1346 def: OpR_RR_pat<A2_svaddh,    Add,        v2i16, V2I16>;
1347 def: OpR_RR_pat<A2_svsubh,    Sub,        v2i16, V2I16>;
1348
1349 def: OpR_RR_pat<A2_vaddub,    Add,        v8i8,  V8I8>;
1350 def: OpR_RR_pat<A2_vaddh,     Add,        v4i16, V4I16>;
1351 def: OpR_RR_pat<A2_vaddw,     Add,        v2i32, V2I32>;
1352 def: OpR_RR_pat<A2_vsubub,    Sub,        v8i8,  V8I8>;
1353 def: OpR_RR_pat<A2_vsubh,     Sub,        v4i16, V4I16>;
1354 def: OpR_RR_pat<A2_vsubw,     Sub,        v2i32, V2I32>;
1355
1356 def: OpR_RR_pat<A2_and,       And,        v4i8,  V4I8>;
1357 def: OpR_RR_pat<A2_xor,       Xor,        v4i8,  V4I8>;
1358 def: OpR_RR_pat<A2_or,        Or,         v4i8,  V4I8>;
1359 def: OpR_RR_pat<A2_and,       And,        v2i16, V2I16>;
1360 def: OpR_RR_pat<A2_xor,       Xor,        v2i16, V2I16>;
1361 def: OpR_RR_pat<A2_or,        Or,         v2i16, V2I16>;
1362 def: OpR_RR_pat<A2_andp,      And,        v8i8,  V8I8>;
1363 def: OpR_RR_pat<A2_orp,       Or,         v8i8,  V8I8>;
1364 def: OpR_RR_pat<A2_xorp,      Xor,        v8i8,  V8I8>;
1365 def: OpR_RR_pat<A2_andp,      And,        v4i16, V4I16>;
1366 def: OpR_RR_pat<A2_orp,       Or,         v4i16, V4I16>;
1367 def: OpR_RR_pat<A2_xorp,      Xor,        v4i16, V4I16>;
1368 def: OpR_RR_pat<A2_andp,      And,        v2i32, V2I32>;
1369 def: OpR_RR_pat<A2_orp,       Or,         v2i32, V2I32>;
1370 def: OpR_RR_pat<A2_xorp,      Xor,        v2i32, V2I32>;
1371
1372 def: OpR_RR_pat<M2_mpyi,      Mul,        i32,   I32>;
1373 def: OpR_RR_pat<M2_mpy_up,    pf2<mulhs>, i32,   I32>;
1374 def: OpR_RR_pat<M2_mpyu_up,   pf2<mulhu>, i32,   I32>;
1375 def: OpR_RI_pat<M2_mpysip,    Mul,        i32,   I32, u32_0ImmPred>;
1376 def: OpR_RI_pat<M2_mpysmi,    Mul,        i32,   I32, s32_0ImmPred>;
1377
1378 // Arithmetic on predicates.
1379 def: OpR_RR_pat<C2_xor,       Add,        i1,    I1>;
1380 def: OpR_RR_pat<C2_xor,       Add,        v2i1,  V2I1>;
1381 def: OpR_RR_pat<C2_xor,       Add,        v4i1,  V4I1>;
1382 def: OpR_RR_pat<C2_xor,       Add,        v8i1,  V8I1>;
1383 def: OpR_RR_pat<C2_xor,       Sub,        i1,    I1>;
1384 def: OpR_RR_pat<C2_xor,       Sub,        v2i1,  V2I1>;
1385 def: OpR_RR_pat<C2_xor,       Sub,        v4i1,  V4I1>;
1386 def: OpR_RR_pat<C2_xor,       Sub,        v8i1,  V8I1>;
1387 def: OpR_RR_pat<C2_and,       Mul,        i1,    I1>;
1388 def: OpR_RR_pat<C2_and,       Mul,        v2i1,  V2I1>;
1389 def: OpR_RR_pat<C2_and,       Mul,        v4i1,  V4I1>;
1390 def: OpR_RR_pat<C2_and,       Mul,        v8i1,  V8I1>;
1391
1392 def: OpR_RR_pat<F2_sfadd,     pf2<fadd>,    f32, F32>;
1393 def: OpR_RR_pat<F2_sfsub,     pf2<fsub>,    f32, F32>;
1394 def: OpR_RR_pat<F2_sfmpy,     pf2<fmul>,    f32, F32>;
1395 def: OpR_RR_pat<F2_sfmin,     pf2<fminnum>, f32, F32>;
1396 def: OpR_RR_pat<F2_sfmax,     pf2<fmaxnum>, f32, F32>;
1397
1398 let Predicates = [HasV66] in {
1399   def: OpR_RR_pat<F2_dfadd,     pf2<fadd>,    f64, F64>;
1400   def: OpR_RR_pat<F2_dfsub,     pf2<fsub>,    f64, F64>;
1401 }
1402
1403 // In expressions like a0*b0 + a1*b1 + ..., prefer to generate multiply-add,
1404 // over add-add with individual multiplies as inputs.
1405 let AddedComplexity = 10 in {
1406   def: AccRRI_pat<M2_macsip,    Add, Su<Mul>, I32, u32_0ImmPred>;
1407   def: AccRRI_pat<M2_macsin,    Sub, Su<Mul>, I32, u32_0ImmPred>;
1408   def: AccRRR_pat<M2_maci,      Add, Su<Mul>, I32, I32, I32>;
1409   let Predicates = [HasV66] in
1410   def: AccRRR_pat<M2_mnaci,     Sub, Su<Mul>, I32, I32, I32>;
1411 }
1412
1413 def: AccRRI_pat<M2_naccii,    Sub, Su<Add>, I32, s32_0ImmPred>;
1414 def: AccRRI_pat<M2_accii,     Add, Su<Add>, I32, s32_0ImmPred>;
1415 def: AccRRR_pat<M2_acci,      Add, Su<Add>, I32, I32, I32>;
1416
1417 // Mulh for vectors
1418 //
1419 def: Pat<(v2i32 (mulhu V2I32:$Rss, V2I32:$Rtt)),
1420          (Combinew (M2_mpyu_up (HiReg $Rss), (HiReg $Rtt)),
1421                    (M2_mpyu_up (LoReg $Rss), (LoReg $Rtt)))>;
1422
1423 def: Pat<(v2i32 (mulhs V2I32:$Rs, V2I32:$Rt)),
1424          (Combinew (M2_mpy_up (HiReg $Rs), (HiReg $Rt)),
1425                    (M2_mpy_up (LoReg $Rt), (LoReg $Rt)))>;
1426
1427 def Mulhub:
1428   OutPatFrag<(ops node:$Rss, node:$Rtt),
1429              (Combinew (S2_vtrunohb (M5_vmpybuu (HiReg $Rss), (HiReg $Rtt))),
1430                        (S2_vtrunohb (M5_vmpybuu (LoReg $Rss), (LoReg $Rtt))))>;
1431
1432 // Equivalent of byte-wise arithmetic shift right by 7 in v8i8.
1433 def Asr7:
1434   OutPatFrag<(ops node:$Rss), (C2_mask (C2_not (A4_vcmpbgti $Rss, 0)))>;
1435
1436 def: Pat<(v8i8 (mulhu V8I8:$Rss, V8I8:$Rtt)),
1437          (Mulhub $Rss, $Rtt)>;
1438
1439 def: Pat<(v8i8 (mulhs V8I8:$Rss, V8I8:$Rtt)),
1440          (A2_vsubub
1441            (Mulhub $Rss, $Rtt),
1442            (A2_vaddub (A2_andp V8I8:$Rss, (Asr7 $Rtt)),
1443                       (A2_andp V8I8:$Rtt, (Asr7 $Rss))))>;
1444
1445 def Mpysh:
1446   OutPatFrag<(ops node:$Rs, node:$Rt), (M2_vmpy2s_s0 $Rs, $Rt)>;
1447 def Mpyshh:
1448   OutPatFrag<(ops node:$Rss, node:$Rtt), (Mpysh (HiReg $Rss), (HiReg $Rtt))>;
1449 def Mpyshl:
1450   OutPatFrag<(ops node:$Rss, node:$Rtt), (Mpysh (LoReg $Rss), (LoReg $Rtt))>;
1451
1452 def Mulhsh:
1453   OutPatFrag<(ops node:$Rss, node:$Rtt),
1454              (Combinew (A2_combine_hh (HiReg (Mpyshh $Rss, $Rtt)),
1455                                       (LoReg (Mpyshh $Rss, $Rtt))),
1456                        (A2_combine_hh (HiReg (Mpyshl $Rss, $Rtt)),
1457                                       (LoReg (Mpyshl $Rss, $Rtt))))>;
1458
1459 def: Pat<(v4i16 (mulhs V4I16:$Rss, V4I16:$Rtt)), (Mulhsh $Rss, $Rtt)>;
1460
1461 def: Pat<(v4i16 (mulhu V4I16:$Rss, V4I16:$Rtt)),
1462          (A2_vaddh
1463            (Mulhsh $Rss, $Rtt),
1464            (A2_vaddh (A2_andp V4I16:$Rss, (S2_asr_i_vh $Rtt, 15)),
1465                      (A2_andp V4I16:$Rtt, (S2_asr_i_vh $Rss, 15))))>;
1466
1467
1468 def: Pat<(ineg (mul I32:$Rs, u8_0ImmPred:$u8)),
1469          (M2_mpysin IntRegs:$Rs, imm:$u8)>;
1470
1471 def n8_0ImmPred: PatLeaf<(i32 imm), [{
1472   int64_t V = N->getSExtValue();
1473   return -255 <= V && V <= 0;
1474 }]>;
1475
1476 // Change the sign of the immediate for Rd=-mpyi(Rs,#u8)
1477 def: Pat<(mul I32:$Rs, n8_0ImmPred:$n8),
1478          (M2_mpysin I32:$Rs, (NegImm8 imm:$n8))>;
1479
1480 def: Pat<(add Sext64:$Rs, I64:$Rt),
1481          (A2_addsp (LoReg Sext64:$Rs), I64:$Rt)>;
1482
1483 def: AccRRR_pat<M4_and_and,   And, Su_ni1<And>,  I32,  I32,  I32>;
1484 def: AccRRR_pat<M4_and_or,    And, Su_ni1<Or>,   I32,  I32,  I32>;
1485 def: AccRRR_pat<M4_and_xor,   And, Su<Xor>,      I32,  I32,  I32>;
1486 def: AccRRR_pat<M4_or_and,    Or,  Su_ni1<And>,  I32,  I32,  I32>;
1487 def: AccRRR_pat<M4_or_or,     Or,  Su_ni1<Or>,   I32,  I32,  I32>;
1488 def: AccRRR_pat<M4_or_xor,    Or,  Su<Xor>,      I32,  I32,  I32>;
1489 def: AccRRR_pat<M4_xor_and,   Xor, Su_ni1<And>,  I32,  I32,  I32>;
1490 def: AccRRR_pat<M4_xor_or,    Xor, Su_ni1<Or>,   I32,  I32,  I32>;
1491 def: AccRRR_pat<M2_xor_xacc,  Xor, Su<Xor>,      I32,  I32,  I32>;
1492 def: AccRRR_pat<M4_xor_xacc,  Xor, Su<Xor>,      I64,  I64,  I64>;
1493
1494 // For dags like (or (and (not _), _), (shl _, _)) where the "or" with
1495 // one argument matches the patterns below, and with the other argument
1496 // matches S2_asl_r_r_or, etc, prefer the patterns below.
1497 let AddedComplexity = 110 in {  // greater than S2_asl_r_r_and/or/xor.
1498   def: AccRRR_pat<M4_and_andn,  And, Su<Not2<And>>, I32,  I32,  I32>;
1499   def: AccRRR_pat<M4_or_andn,   Or,  Su<Not2<And>>, I32,  I32,  I32>;
1500   def: AccRRR_pat<M4_xor_andn,  Xor, Su<Not2<And>>, I32,  I32,  I32>;
1501 }
1502
1503 // S4_addaddi and S4_subaddi don't have tied operands, so give them
1504 // a bit of preference.
1505 let AddedComplexity = 30 in {
1506   def: Pat<(add I32:$Rs, (Su<Add> I32:$Ru, anyimm:$s6)),
1507            (S4_addaddi IntRegs:$Rs, IntRegs:$Ru, imm:$s6)>;
1508   def: Pat<(add anyimm:$s6, (Su<Add> I32:$Rs, I32:$Ru)),
1509            (S4_addaddi IntRegs:$Rs, IntRegs:$Ru, imm:$s6)>;
1510   def: Pat<(add I32:$Rs, (Su<Sub> anyimm:$s6, I32:$Ru)),
1511            (S4_subaddi IntRegs:$Rs, imm:$s6, IntRegs:$Ru)>;
1512   def: Pat<(sub (Su<Add> I32:$Rs, anyimm:$s6), I32:$Ru),
1513            (S4_subaddi IntRegs:$Rs, imm:$s6, IntRegs:$Ru)>;
1514   def: Pat<(add (Su<Sub> I32:$Rs, I32:$Ru), anyimm:$s6),
1515            (S4_subaddi IntRegs:$Rs, imm:$s6, IntRegs:$Ru)>;
1516 }
1517
1518 def: Pat<(or I32:$Ru, (Su<And> I32:$Rx, anyimm:$s10)),
1519          (S4_or_andix IntRegs:$Ru, IntRegs:$Rx, imm:$s10)>;
1520 def: Pat<(or I32:$Rx, (Su<And> I32:$Rs, anyimm:$s10)),
1521          (S4_or_andi IntRegs:$Rx, IntRegs:$Rs, imm:$s10)>;
1522 def: Pat<(or I32:$Rx, (Su<Or> I32:$Rs, anyimm:$s10)),
1523          (S4_or_ori IntRegs:$Rx, IntRegs:$Rs, imm:$s10)>;
1524
1525
1526 def: Pat<(i32 (trunc (sra (Su<Mul> Sext64:$Rs, Sext64:$Rt), (i32 32)))),
1527          (M2_mpy_up (LoReg Sext64:$Rs), (LoReg Sext64:$Rt))>;
1528 def: Pat<(i32 (trunc (srl (Su<Mul> Sext64:$Rs, Sext64:$Rt), (i32 32)))),
1529          (M2_mpy_up (LoReg Sext64:$Rs), (LoReg Sext64:$Rt))>;
1530
1531 def: Pat<(mul (Zext64 I32:$Rs), (Zext64 I32:$Rt)),
1532          (M2_dpmpyuu_s0 I32:$Rs, I32:$Rt)>;
1533 def: Pat<(mul (Aext64 I32:$Rs), (Aext64 I32:$Rt)),
1534          (M2_dpmpyuu_s0 I32:$Rs, I32:$Rt)>;
1535 def: Pat<(mul Sext64:$Rs, Sext64:$Rt),
1536          (M2_dpmpyss_s0 (LoReg Sext64:$Rs), (LoReg Sext64:$Rt))>;
1537
1538 def: Pat<(add I64:$Rx, (Su<Mul> Sext64:$Rs, Sext64:$Rt)),
1539          (M2_dpmpyss_acc_s0 I64:$Rx, (LoReg Sext64:$Rs), (LoReg Sext64:$Rt))>;
1540 def: Pat<(sub I64:$Rx, (Su<Mul> Sext64:$Rs, Sext64:$Rt)),
1541          (M2_dpmpyss_nac_s0 I64:$Rx, (LoReg Sext64:$Rs), (LoReg Sext64:$Rt))>;
1542 def: Pat<(add I64:$Rx, (Su<Mul> (Aext64 I32:$Rs), (Aext64 I32:$Rt))),
1543          (M2_dpmpyuu_acc_s0 I64:$Rx, I32:$Rs, I32:$Rt)>;
1544 def: Pat<(add I64:$Rx, (Su<Mul> (Zext64 I32:$Rs), (Zext64 I32:$Rt))),
1545          (M2_dpmpyuu_acc_s0 I64:$Rx, I32:$Rs, I32:$Rt)>;
1546 def: Pat<(sub I64:$Rx, (Su<Mul> (Aext64 I32:$Rs), (Aext64 I32:$Rt))),
1547          (M2_dpmpyuu_nac_s0 I64:$Rx, I32:$Rs, I32:$Rt)>;
1548 def: Pat<(sub I64:$Rx, (Su<Mul> (Zext64 I32:$Rs), (Zext64 I32:$Rt))),
1549          (M2_dpmpyuu_nac_s0 I64:$Rx, I32:$Rs, I32:$Rt)>;
1550
1551 // Add halfword.
1552 def: Pat<(sext_inreg (add I32:$Rt, I32:$Rs), i16),
1553          (A2_addh_l16_ll I32:$Rt, I32:$Rs)>;
1554 def: Pat<(sra (add (shl I32:$Rt, (i32 16)), I32:$Rs), (i32 16)),
1555          (A2_addh_l16_hl I32:$Rt, I32:$Rs)>;
1556 def: Pat<(shl (add I32:$Rt, I32:$Rs), (i32 16)),
1557          (A2_addh_h16_ll I32:$Rt, I32:$Rs)>;
1558
1559 // Subtract halfword.
1560 def: Pat<(sext_inreg (sub I32:$Rt, I32:$Rs), i16),
1561          (A2_subh_l16_ll I32:$Rt, I32:$Rs)>;
1562 def: Pat<(sra (add (shl I32:$Rt, (i32 16)), I32:$Rs), (i32 16)),
1563          (A2_addh_l16_hl I32:$Rt, I32:$Rs)>;
1564 def: Pat<(shl (sub I32:$Rt, I32:$Rs), (i32 16)),
1565          (A2_subh_h16_ll I32:$Rt, I32:$Rs)>;
1566
1567 def: Pat<(mul I64:$Rss, I64:$Rtt),
1568          (Combinew
1569            (M2_maci (M2_maci (HiReg (M2_dpmpyuu_s0 (LoReg $Rss), (LoReg $Rtt))),
1570                              (LoReg $Rss),
1571                              (HiReg $Rtt)),
1572                     (LoReg $Rtt),
1573                     (HiReg $Rss)),
1574            (i32 (LoReg (M2_dpmpyuu_s0 (LoReg $Rss), (LoReg $Rtt)))))>;
1575
1576 def MulHU : OutPatFrag<(ops node:$Rss, node:$Rtt),
1577   (A2_addp
1578     (M2_dpmpyuu_acc_s0
1579       (S2_lsr_i_p
1580         (A2_addp
1581           (M2_dpmpyuu_acc_s0
1582             (S2_lsr_i_p (M2_dpmpyuu_s0 (LoReg $Rss), (LoReg $Rtt)), 32),
1583             (HiReg $Rss),
1584             (LoReg $Rtt)),
1585           (A4_combineir 0, (LoReg (M2_dpmpyuu_s0 (LoReg $Rss), (HiReg $Rtt))))),
1586         32),
1587       (HiReg $Rss),
1588       (HiReg $Rtt)),
1589     (S2_lsr_i_p (M2_dpmpyuu_s0 (LoReg $Rss), (HiReg $Rtt)), 32))>;
1590
1591 // Multiply 64-bit unsigned and use upper result.
1592 def : Pat <(mulhu I64:$Rss, I64:$Rtt), (MulHU $Rss, $Rtt)>;
1593
1594 // Multiply 64-bit signed and use upper result.
1595 //
1596 // For two signed 64-bit integers A and B, let A' and B' denote A and B
1597 // with the sign bit cleared. Then A = -2^63*s(A) + A', where s(A) is the
1598 // sign bit of A (and identically for B). With this notation, the signed
1599 // product A*B can be written as:
1600 //   AB = (-2^63 s(A) + A') * (-2^63 s(B) + B')
1601 //      = 2^126 s(A)s(B) - 2^63 [s(A)B'+s(B)A'] + A'B'
1602 //      = 2^126 s(A)s(B) + 2^63 [s(A)B'+s(B)A'] + A'B' - 2*2^63 [s(A)B'+s(B)A']
1603 //      = (unsigned product AB) - 2^64 [s(A)B'+s(B)A']
1604
1605 // Clear the sign bit in a 64-bit register.
1606 def ClearSign : OutPatFrag<(ops node:$Rss),
1607   (Combinew (S2_clrbit_i (HiReg $Rss), 31), (i32 (LoReg $Rss)))>;
1608
1609 def : Pat <(mulhs I64:$Rss, I64:$Rtt),
1610   (A2_subp
1611     (MulHU $Rss, $Rtt),
1612     (A2_addp
1613       (A2_andp (S2_asr_i_p $Rss, 63), (ClearSign $Rtt)),
1614       (A2_andp (S2_asr_i_p $Rtt, 63), (ClearSign $Rss))))>;
1615
1616 // Prefer these instructions over M2_macsip/M2_macsin: the macsi* instructions
1617 // will put the immediate addend into a register, while these instructions will
1618 // use it directly. Such a construct does not appear in the middle of a gep,
1619 // where M2_macsip would be preferable.
1620 let AddedComplexity = 20 in {
1621   def: Pat<(add (Su<Mul> I32:$Rs, u6_0ImmPred:$U6), anyimm:$u6),
1622            (M4_mpyri_addi imm:$u6, IntRegs:$Rs, imm:$U6)>;
1623   def: Pat<(add (Su<Mul> I32:$Rs, I32:$Rt), anyimm:$u6),
1624            (M4_mpyrr_addi imm:$u6, IntRegs:$Rs, IntRegs:$Rt)>;
1625 }
1626
1627 // Keep these instructions less preferable to M2_macsip/M2_macsin.
1628 def: Pat<(add I32:$Ru, (Su<Mul> I32:$Rs, u6_2ImmPred:$u6_2)),
1629          (M4_mpyri_addr_u2 IntRegs:$Ru, imm:$u6_2, IntRegs:$Rs)>;
1630 def: Pat<(add I32:$Ru, (Su<Mul> I32:$Rs, anyimm:$u6)),
1631          (M4_mpyri_addr IntRegs:$Ru, IntRegs:$Rs, imm:$u6)>;
1632 def: Pat<(add I32:$Ru, (Su<Mul> I32:$Ry, I32:$Rs)),
1633          (M4_mpyrr_addr IntRegs:$Ru, IntRegs:$Ry, IntRegs:$Rs)>;
1634
1635
1636 def: Pat<(fma F32:$Rs, F32:$Rt, F32:$Rx),
1637          (F2_sffma F32:$Rx, F32:$Rs, F32:$Rt)>;
1638 def: Pat<(fma (fneg F32:$Rs), F32:$Rt, F32:$Rx),
1639          (F2_sffms F32:$Rx, F32:$Rs, F32:$Rt)>;
1640 def: Pat<(fma F32:$Rs, (fneg F32:$Rt), F32:$Rx),
1641          (F2_sffms F32:$Rx, F32:$Rs, F32:$Rt)>;
1642
1643
1644 def: Pat<(mul V2I32:$Rs, V2I32:$Rt),
1645          (PS_vmulw V2I32:$Rs, V2I32:$Rt)>;
1646 def: Pat<(add V2I32:$Rx, (mul V2I32:$Rs, V2I32:$Rt)),
1647          (PS_vmulw_acc V2I32:$Rx, V2I32:$Rs, V2I32:$Rt)>;
1648
1649 // Add/subtract two v4i8: Hexagon does not have an insn for this one, so
1650 // we use the double add v8i8, and use only the low part of the result.
1651 def: Pat<(add V4I8:$Rs, V4I8:$Rt),
1652          (LoReg (A2_vaddub (ToAext64 $Rs), (ToAext64 $Rt)))>;
1653 def: Pat<(sub V4I8:$Rs, V4I8:$Rt),
1654          (LoReg (A2_vsubub (ToAext64 $Rs), (ToAext64 $Rt)))>;
1655
1656 // Use M2_vmpy2s_s0 for half-word vector multiply. It multiplies two
1657 // half-words, and saturates the result to a 32-bit value, except the
1658 // saturation never happens (it can only occur with scaling).
1659 def: Pat<(v2i16 (mul V2I16:$Rs, V2I16:$Rt)),
1660          (LoReg (S2_vtrunewh (A2_combineii 0, 0),
1661                              (M2_vmpy2s_s0 V2I16:$Rs, V2I16:$Rt)))>;
1662 def: Pat<(v4i16 (mul V4I16:$Rs, V4I16:$Rt)),
1663          (S2_vtrunewh (M2_vmpy2s_s0 (HiReg $Rs), (HiReg $Rt)),
1664                       (M2_vmpy2s_s0 (LoReg $Rs), (LoReg $Rt)))>;
1665
1666 // Multiplies two v4i8 vectors.
1667 def: Pat<(v4i8 (mul V4I8:$Rs, V4I8:$Rt)),
1668          (S2_vtrunehb (M5_vmpybuu V4I8:$Rs, V4I8:$Rt))>;
1669
1670 // Multiplies two v8i8 vectors.
1671 def: Pat<(v8i8 (mul V8I8:$Rs, V8I8:$Rt)),
1672          (Combinew (S2_vtrunehb (M5_vmpybuu (HiReg $Rs), (HiReg $Rt))),
1673                    (S2_vtrunehb (M5_vmpybuu (LoReg $Rs), (LoReg $Rt))))>;
1674
1675
1676 // --(10) Bit ------------------------------------------------------------
1677 //
1678
1679 // Count leading zeros.
1680 def: Pat<(i32 (ctlz I32:$Rs)),                (S2_cl0 I32:$Rs)>;
1681 def: Pat<(i32 (trunc (ctlz I64:$Rss))),       (S2_cl0p I64:$Rss)>;
1682
1683 // Count trailing zeros.
1684 def: Pat<(i32 (cttz I32:$Rs)),                (S2_ct0 I32:$Rs)>;
1685 def: Pat<(i32 (trunc (cttz I64:$Rss))),       (S2_ct0p I64:$Rss)>;
1686
1687 // Count leading ones.
1688 def: Pat<(i32 (ctlz (not I32:$Rs))),          (S2_cl1 I32:$Rs)>;
1689 def: Pat<(i32 (trunc (ctlz (not I64:$Rss)))), (S2_cl1p I64:$Rss)>;
1690
1691 // Count trailing ones.
1692 def: Pat<(i32 (cttz (not I32:$Rs))),           (S2_ct1 I32:$Rs)>;
1693 def: Pat<(i32 (trunc (cttz (not I64:$Rss)))), (S2_ct1p I64:$Rss)>;
1694
1695 // Define leading/trailing patterns that require zero-extensions to 64 bits.
1696 def: Pat<(i64 (ctlz I64:$Rss)),               (ToZext64 (S2_cl0p I64:$Rss))>;
1697 def: Pat<(i64 (cttz I64:$Rss)),               (ToZext64 (S2_ct0p I64:$Rss))>;
1698 def: Pat<(i64 (ctlz (not I64:$Rss))),         (ToZext64 (S2_cl1p I64:$Rss))>;
1699 def: Pat<(i64 (cttz (not I64:$Rss))),         (ToZext64 (S2_ct1p I64:$Rss))>;
1700
1701 def: Pat<(i64 (ctpop I64:$Rss)),  (ToZext64 (S5_popcountp I64:$Rss))>;
1702 def: Pat<(i32 (ctpop I32:$Rs)),   (S5_popcountp (A4_combineir 0, I32:$Rs))>;
1703
1704 def: Pat<(bitreverse I32:$Rs),    (S2_brev I32:$Rs)>;
1705 def: Pat<(bitreverse I64:$Rss),   (S2_brevp I64:$Rss)>;
1706
1707 let AddedComplexity = 20 in { // Complexity greater than and/or/xor
1708   def: Pat<(and I32:$Rs, IsNPow2_32:$V),
1709            (S2_clrbit_i IntRegs:$Rs, (LogN2_32 $V))>;
1710   def: Pat<(or I32:$Rs, IsPow2_32:$V),
1711            (S2_setbit_i IntRegs:$Rs, (Log2_32 $V))>;
1712   def: Pat<(xor I32:$Rs, IsPow2_32:$V),
1713            (S2_togglebit_i IntRegs:$Rs, (Log2_32 $V))>;
1714
1715   def: Pat<(and I32:$Rs, (not (shl 1, I32:$Rt))),
1716            (S2_clrbit_r IntRegs:$Rs, IntRegs:$Rt)>;
1717   def: Pat<(or I32:$Rs, (shl 1, I32:$Rt)),
1718            (S2_setbit_r IntRegs:$Rs, IntRegs:$Rt)>;
1719   def: Pat<(xor I32:$Rs, (shl 1, I32:$Rt)),
1720            (S2_togglebit_r IntRegs:$Rs, IntRegs:$Rt)>;
1721 }
1722
1723 // Clr/set/toggle bit for 64-bit values with immediate bit index.
1724 let AddedComplexity = 20 in { // Complexity greater than and/or/xor
1725   def: Pat<(and I64:$Rss, IsNPow2_64L:$V),
1726            (Combinew (i32 (HiReg $Rss)),
1727                      (S2_clrbit_i (LoReg $Rss), (LogN2_64 $V)))>;
1728   def: Pat<(and I64:$Rss, IsNPow2_64H:$V),
1729            (Combinew (S2_clrbit_i (HiReg $Rss), (UDEC32 (i32 (LogN2_64 $V)))),
1730                      (i32 (LoReg $Rss)))>;
1731
1732   def: Pat<(or I64:$Rss, IsPow2_64L:$V),
1733            (Combinew (i32 (HiReg $Rss)),
1734                      (S2_setbit_i (LoReg $Rss), (Log2_64 $V)))>;
1735   def: Pat<(or I64:$Rss, IsPow2_64H:$V),
1736            (Combinew (S2_setbit_i (HiReg $Rss), (UDEC32 (i32 (Log2_64 $V)))),
1737                      (i32 (LoReg $Rss)))>;
1738
1739   def: Pat<(xor I64:$Rss, IsPow2_64L:$V),
1740            (Combinew (i32 (HiReg $Rss)),
1741                      (S2_togglebit_i (LoReg $Rss), (Log2_64 $V)))>;
1742   def: Pat<(xor I64:$Rss, IsPow2_64H:$V),
1743            (Combinew (S2_togglebit_i (HiReg $Rss), (UDEC32 (i32 (Log2_64 $V)))),
1744                      (i32 (LoReg $Rss)))>;
1745 }
1746
1747
1748 let AddedComplexity = 20 in { // Complexity greater than cmp reg-imm.
1749   def: Pat<(i1 (setne (and (shl 1, u5_0ImmPred:$u5), I32:$Rs), 0)),
1750            (S2_tstbit_i IntRegs:$Rs, imm:$u5)>;
1751   def: Pat<(i1 (setne (and (shl 1, I32:$Rt), I32:$Rs), 0)),
1752            (S2_tstbit_r IntRegs:$Rs, IntRegs:$Rt)>;
1753   def: Pat<(i1 (trunc I32:$Rs)),
1754            (S2_tstbit_i IntRegs:$Rs, 0)>;
1755   def: Pat<(i1 (trunc I64:$Rs)),
1756            (S2_tstbit_i (LoReg DoubleRegs:$Rs), 0)>;
1757 }
1758
1759 def: Pat<(and (srl I32:$Rs, u5_0ImmPred:$u5), 1),
1760          (I1toI32 (S2_tstbit_i I32:$Rs, imm:$u5))>;
1761 def: Pat<(and (srl I64:$Rss, IsULE<32,31>:$u6), 1),
1762          (ToZext64 (I1toI32 (S2_tstbit_i (LoReg $Rss), imm:$u6)))>;
1763 def: Pat<(and (srl I64:$Rss, IsUGT<32,31>:$u6), 1),
1764          (ToZext64 (I1toI32 (S2_tstbit_i (HiReg $Rss), (UDEC32 $u6))))>;
1765
1766 def: Pat<(and (not (srl I32:$Rs, u5_0ImmPred:$u5)), 1),
1767          (I1toI32 (S4_ntstbit_i I32:$Rs, imm:$u5))>;
1768 def: Pat<(and (not (srl I64:$Rss, IsULE<32,31>:$u6)), 1),
1769          (ToZext64 (I1toI32 (S4_ntstbit_i (LoReg $Rss), imm:$u6)))>;
1770 def: Pat<(and (not (srl I64:$Rss, IsUGT<32,31>:$u6)), 1),
1771          (ToZext64 (I1toI32 (S4_ntstbit_i (HiReg $Rss), (UDEC32 $u6))))>;
1772
1773 let AddedComplexity = 20 in { // Complexity greater than compare reg-imm.
1774   def: Pat<(i1 (seteq (and I32:$Rs, u6_0ImmPred:$u6), 0)),
1775            (C2_bitsclri IntRegs:$Rs, imm:$u6)>;
1776   def: Pat<(i1 (seteq (and I32:$Rs, I32:$Rt), 0)),
1777            (C2_bitsclr IntRegs:$Rs, IntRegs:$Rt)>;
1778 }
1779
1780 let AddedComplexity = 10 in   // Complexity greater than compare reg-reg.
1781 def: Pat<(i1 (seteq (and I32:$Rs, I32:$Rt), IntRegs:$Rt)),
1782          (C2_bitsset IntRegs:$Rs, IntRegs:$Rt)>;
1783
1784 def SDTTestBit:
1785   SDTypeProfile<1, 2, [SDTCisVT<0, i1>, SDTCisVT<1, i32>, SDTCisVT<2, i32>]>;
1786 def HexagonTSTBIT: SDNode<"HexagonISD::TSTBIT", SDTTestBit>;
1787
1788 def: Pat<(HexagonTSTBIT I32:$Rs, u5_0ImmPred:$u5),
1789          (S2_tstbit_i I32:$Rs, imm:$u5)>;
1790 def: Pat<(HexagonTSTBIT I32:$Rs, I32:$Rt),
1791          (S2_tstbit_r I32:$Rs, I32:$Rt)>;
1792
1793 // Add extra complexity to prefer these instructions over bitsset/bitsclr.
1794 // The reason is that tstbit/ntstbit can be folded into a compound instruction:
1795 //   if ([!]tstbit(...)) jump ...
1796 let AddedComplexity = 20 in {   // Complexity greater than cmp reg-imm.
1797   def: Pat<(i1 (seteq (and I32:$Rs, IsPow2_32:$u5), 0)),
1798            (S4_ntstbit_i I32:$Rs, (Log2_32 imm:$u5))>;
1799   def: Pat<(i1 (setne (and I32:$Rs, IsPow2_32:$u5), 0)),
1800            (S2_tstbit_i I32:$Rs, (Log2_32 imm:$u5))>;
1801   def: Pat<(i1 (seteq (and (shl 1, I32:$Rt), I32:$Rs), 0)),
1802            (S4_ntstbit_r I32:$Rs, I32:$Rt)>;
1803   def: Pat<(i1 (setne (and (shl 1, I32:$Rt), I32:$Rs), 0)),
1804            (S2_tstbit_r I32:$Rs, I32:$Rt)>;
1805 }
1806
1807 def: Pat<(i1 (seteq (and I64:$Rs, IsPow2_64L:$u6), 0)),
1808          (S4_ntstbit_i (LoReg $Rs), (Log2_64 $u6))>;
1809 def: Pat<(i1 (seteq (and I64:$Rs, IsPow2_64H:$u6), 0)),
1810          (S4_ntstbit_i (HiReg $Rs), (UDEC32 (i32 (Log2_64 $u6))))>;
1811 def: Pat<(i1 (setne (and I64:$Rs, IsPow2_64L:$u6), 0)),
1812          (S2_tstbit_i (LoReg $Rs), (Log2_32 imm:$u6))>;
1813 def: Pat<(i1 (setne (and I64:$Rs, IsPow2_64H:$u6), 0)),
1814          (S2_tstbit_i (HiReg $Rs), (UDEC32 (i32 (Log2_32 imm:$u6))))>;
1815
1816 // Do not increase complexity of these patterns. In the DAG, "cmp i8" may be
1817 // represented as a compare against "value & 0xFF", which is an exact match
1818 // for cmpb (same for cmph). The patterns below do not contain any additional
1819 // complexity that would make them preferable, and if they were actually used
1820 // instead of cmpb/cmph, they would result in a compare against register that
1821 // is loaded with the byte/half mask (i.e. 0xFF or 0xFFFF).
1822 def: Pat<(i1 (setne (and I32:$Rs, u6_0ImmPred:$u6), 0)),
1823          (C4_nbitsclri I32:$Rs, imm:$u6)>;
1824 def: Pat<(i1 (setne (and I32:$Rs, I32:$Rt), 0)),
1825          (C4_nbitsclr I32:$Rs, I32:$Rt)>;
1826 def: Pat<(i1 (setne (and I32:$Rs, I32:$Rt), I32:$Rt)),
1827          (C4_nbitsset I32:$Rs, I32:$Rt)>;
1828
1829 // Special patterns to address certain cases where the "top-down" matching
1830 // algorithm would cause suboptimal selection.
1831
1832 let AddedComplexity = 100 in {
1833   // Avoid A4_rcmp[n]eqi in these cases:
1834   def: Pat<(i32 (zext (i1 (seteq (and (shl 1, I32:$Rt), I32:$Rs), 0)))),
1835            (I1toI32 (S4_ntstbit_r IntRegs:$Rs, IntRegs:$Rt))>;
1836   def: Pat<(i32 (zext (i1 (setne (and (shl 1, I32:$Rt), I32:$Rs), 0)))),
1837            (I1toI32 (S2_tstbit_r IntRegs:$Rs, IntRegs:$Rt))>;
1838   def: Pat<(i32 (zext (i1 (seteq (and I32:$Rs, IsPow2_32:$u5), 0)))),
1839            (I1toI32 (S4_ntstbit_i I32:$Rs, (Log2_32 imm:$u5)))>;
1840   def: Pat<(i32 (zext (i1 (setne (and I32:$Rs, IsPow2_32:$u5), 0)))),
1841            (I1toI32 (S2_tstbit_i I32:$Rs, (Log2_32 imm:$u5)))>;
1842   def: Pat<(i32 (zext (i1 (seteq (and (shl 1, I32:$Rt), I32:$Rs), 0)))),
1843            (I1toI32 (S4_ntstbit_r I32:$Rs, I32:$Rt))>;
1844   def: Pat<(i32 (zext (i1 (setne (and (shl 1, I32:$Rt), I32:$Rs), 0)))),
1845            (I1toI32 (S2_tstbit_r I32:$Rs, I32:$Rt))>;
1846 }
1847
1848 // --(11) PIC ------------------------------------------------------------
1849 //
1850
1851 def SDT_HexagonAtGot
1852   : SDTypeProfile<1, 3, [SDTCisVT<0, i32>, SDTCisVT<1, i32>, SDTCisVT<2, i32>]>;
1853 def SDT_HexagonAtPcrel
1854   : SDTypeProfile<1, 1, [SDTCisVT<0, i32>, SDTCisVT<1, i32>]>;
1855
1856 // AT_GOT address-of-GOT, address-of-global, offset-in-global
1857 def HexagonAtGot       : SDNode<"HexagonISD::AT_GOT", SDT_HexagonAtGot>;
1858 // AT_PCREL address-of-global
1859 def HexagonAtPcrel     : SDNode<"HexagonISD::AT_PCREL", SDT_HexagonAtPcrel>;
1860
1861 def: Pat<(HexagonAtGot I32:$got, I32:$addr, (i32 0)),
1862          (L2_loadri_io I32:$got, imm:$addr)>;
1863 def: Pat<(HexagonAtGot I32:$got, I32:$addr, s30_2ImmPred:$off),
1864          (A2_addi (L2_loadri_io I32:$got, imm:$addr), imm:$off)>;
1865 def: Pat<(HexagonAtPcrel I32:$addr),
1866          (C4_addipc imm:$addr)>;
1867
1868 // The HVX load patterns also match AT_PCREL directly. Make sure that
1869 // if the selection of this opcode changes, it's updated in all places.
1870
1871
1872 // --(12) Load -----------------------------------------------------------
1873 //
1874
1875 def extloadv2i8: PatFrag<(ops node:$ptr), (extload node:$ptr), [{
1876   return cast<LoadSDNode>(N)->getMemoryVT() == MVT::v2i8;
1877 }]>;
1878 def extloadv4i8: PatFrag<(ops node:$ptr), (extload node:$ptr), [{
1879   return cast<LoadSDNode>(N)->getMemoryVT() == MVT::v4i8;
1880 }]>;
1881
1882 def zextloadv2i8: PatFrag<(ops node:$ptr), (zextload node:$ptr), [{
1883   return cast<LoadSDNode>(N)->getMemoryVT() == MVT::v2i8;
1884 }]>;
1885 def zextloadv4i8: PatFrag<(ops node:$ptr), (zextload node:$ptr), [{
1886   return cast<LoadSDNode>(N)->getMemoryVT() == MVT::v4i8;
1887 }]>;
1888
1889 def sextloadv2i8: PatFrag<(ops node:$ptr), (sextload node:$ptr), [{
1890   return cast<LoadSDNode>(N)->getMemoryVT() == MVT::v2i8;
1891 }]>;
1892 def sextloadv4i8: PatFrag<(ops node:$ptr), (sextload node:$ptr), [{
1893   return cast<LoadSDNode>(N)->getMemoryVT() == MVT::v4i8;
1894 }]>;
1895
1896 // Patterns to select load-indexed: Rs + Off.
1897 // - frameindex [+ imm],
1898 multiclass Loadxfi_pat<PatFrag Load, ValueType VT, PatLeaf ImmPred,
1899                        InstHexagon MI> {
1900   def: Pat<(VT (Load (add (i32 AddrFI:$fi), ImmPred:$Off))),
1901            (VT (MI AddrFI:$fi, imm:$Off))>;
1902   def: Pat<(VT (Load (IsOrAdd (i32 AddrFI:$fi), ImmPred:$Off))),
1903            (VT (MI AddrFI:$fi, imm:$Off))>;
1904   def: Pat<(VT (Load AddrFI:$fi)), (VT (MI AddrFI:$fi, 0))>;
1905 }
1906
1907 // Patterns to select load-indexed: Rs + Off.
1908 // - base reg [+ imm]
1909 multiclass Loadxgi_pat<PatFrag Load, ValueType VT, PatLeaf ImmPred,
1910                        InstHexagon MI> {
1911   def: Pat<(VT (Load (add I32:$Rs, ImmPred:$Off))),
1912            (VT (MI IntRegs:$Rs, imm:$Off))>;
1913   def: Pat<(VT (Load (IsOrAdd I32:$Rs, ImmPred:$Off))),
1914            (VT (MI IntRegs:$Rs, imm:$Off))>;
1915   def: Pat<(VT (Load I32:$Rs)), (VT (MI IntRegs:$Rs, 0))>;
1916 }
1917
1918 // Patterns to select load-indexed: Rs + Off. Combines Loadxfi + Loadxgi.
1919 multiclass Loadxi_pat<PatFrag Load, ValueType VT, PatLeaf ImmPred,
1920                       InstHexagon MI> {
1921   defm: Loadxfi_pat<Load, VT, ImmPred, MI>;
1922   defm: Loadxgi_pat<Load, VT, ImmPred, MI>;
1923 }
1924
1925 // Patterns to select load reg indexed: Rs + Off with a value modifier.
1926 // - frameindex [+ imm]
1927 multiclass Loadxfim_pat<PatFrag Load, ValueType VT, PatFrag ValueMod,
1928                         PatLeaf ImmPred, InstHexagon MI> {
1929   def: Pat<(VT (Load (add (i32 AddrFI:$fi), ImmPred:$Off))),
1930            (VT (ValueMod (MI AddrFI:$fi, imm:$Off)))>;
1931   def: Pat<(VT (Load (IsOrAdd (i32 AddrFI:$fi), ImmPred:$Off))),
1932            (VT (ValueMod (MI AddrFI:$fi, imm:$Off)))>;
1933   def: Pat<(VT (Load AddrFI:$fi)), (VT (ValueMod (MI AddrFI:$fi, 0)))>;
1934 }
1935
1936 // Patterns to select load reg indexed: Rs + Off with a value modifier.
1937 // - base reg [+ imm]
1938 multiclass Loadxgim_pat<PatFrag Load, ValueType VT, PatFrag ValueMod,
1939                         PatLeaf ImmPred, InstHexagon MI> {
1940   def: Pat<(VT (Load (add I32:$Rs, ImmPred:$Off))),
1941            (VT (ValueMod (MI IntRegs:$Rs, imm:$Off)))>;
1942   def: Pat<(VT (Load (IsOrAdd I32:$Rs, ImmPred:$Off))),
1943            (VT (ValueMod (MI IntRegs:$Rs, imm:$Off)))>;
1944   def: Pat<(VT (Load I32:$Rs)), (VT (ValueMod (MI IntRegs:$Rs, 0)))>;
1945 }
1946
1947 // Patterns to select load reg indexed: Rs + Off with a value modifier.
1948 // Combines Loadxfim + Loadxgim.
1949 multiclass Loadxim_pat<PatFrag Load, ValueType VT, PatFrag ValueMod,
1950                        PatLeaf ImmPred, InstHexagon MI> {
1951   defm: Loadxfim_pat<Load, VT, ValueMod, ImmPred, MI>;
1952   defm: Loadxgim_pat<Load, VT, ValueMod, ImmPred, MI>;
1953 }
1954
1955 // Pattern to select load reg reg-indexed: Rs + Rt<<u2.
1956 class Loadxr_shl_pat<PatFrag Load, ValueType VT, InstHexagon MI>
1957   : Pat<(VT (Load (add I32:$Rs, (i32 (shl I32:$Rt, u2_0ImmPred:$u2))))),
1958         (VT (MI IntRegs:$Rs, IntRegs:$Rt, imm:$u2))>;
1959
1960 // Pattern to select load reg reg-indexed: Rs + Rt<<0.
1961 class Loadxr_add_pat<PatFrag Load, ValueType VT, InstHexagon MI>
1962   : Pat<(VT (Load (add I32:$Rs, I32:$Rt))),
1963         (VT (MI IntRegs:$Rs, IntRegs:$Rt, 0))>;
1964
1965 // Pattern to select load reg reg-indexed: Rs + Rt<<u2 with value modifier.
1966 class Loadxrm_shl_pat<PatFrag Load, ValueType VT, PatFrag ValueMod,
1967                       InstHexagon MI>
1968   : Pat<(VT (Load (add I32:$Rs, (i32 (shl I32:$Rt, u2_0ImmPred:$u2))))),
1969         (VT (ValueMod (MI IntRegs:$Rs, IntRegs:$Rt, imm:$u2)))>;
1970
1971 // Pattern to select load reg reg-indexed: Rs + Rt<<0 with value modifier.
1972 class Loadxrm_add_pat<PatFrag Load, ValueType VT, PatFrag ValueMod,
1973                       InstHexagon MI>
1974   : Pat<(VT (Load (add I32:$Rs, I32:$Rt))),
1975         (VT (ValueMod (MI IntRegs:$Rs, IntRegs:$Rt, 0)))>;
1976
1977 // Pattern to select load long-offset reg-indexed: Addr + Rt<<u2.
1978 // Don't match for u2==0, instead use reg+imm for those cases.
1979 class Loadxu_pat<PatFrag Load, ValueType VT, PatFrag ImmPred, InstHexagon MI>
1980   : Pat<(VT (Load (add (shl IntRegs:$Rt, u2_0ImmPred:$u2), ImmPred:$Addr))),
1981         (VT (MI IntRegs:$Rt, imm:$u2, ImmPred:$Addr))>;
1982
1983 class Loadxum_pat<PatFrag Load, ValueType VT, PatFrag ImmPred, PatFrag ValueMod,
1984                   InstHexagon MI>
1985   : Pat<(VT (Load (add (shl IntRegs:$Rt, u2_0ImmPred:$u2), ImmPred:$Addr))),
1986         (VT (ValueMod (MI IntRegs:$Rt, imm:$u2, ImmPred:$Addr)))>;
1987
1988 // Pattern to select load absolute.
1989 class Loada_pat<PatFrag Load, ValueType VT, PatFrag Addr, InstHexagon MI>
1990   : Pat<(VT (Load Addr:$addr)), (MI Addr:$addr)>;
1991
1992 // Pattern to select load absolute with value modifier.
1993 class Loadam_pat<PatFrag Load, ValueType VT, PatFrag Addr, PatFrag ValueMod,
1994                  InstHexagon MI>
1995   : Pat<(VT (Load Addr:$addr)), (ValueMod (MI Addr:$addr))>;
1996
1997
1998 let AddedComplexity = 20 in {
1999   defm: Loadxi_pat<extloadi1,       i32,   anyimm0, L2_loadrub_io>;
2000   defm: Loadxi_pat<extloadi8,       i32,   anyimm0, L2_loadrub_io>;
2001   defm: Loadxi_pat<extloadi16,      i32,   anyimm1, L2_loadruh_io>;
2002   defm: Loadxi_pat<extloadv2i8,     v2i16, anyimm1, L2_loadbzw2_io>;
2003   defm: Loadxi_pat<extloadv4i8,     v4i16, anyimm2, L2_loadbzw4_io>;
2004   defm: Loadxi_pat<sextloadi8,      i32,   anyimm0, L2_loadrb_io>;
2005   defm: Loadxi_pat<sextloadi16,     i32,   anyimm1, L2_loadrh_io>;
2006   defm: Loadxi_pat<sextloadv2i8,    v2i16, anyimm1, L2_loadbsw2_io>;
2007   defm: Loadxi_pat<sextloadv4i8,    v4i16, anyimm2, L2_loadbzw4_io>;
2008   defm: Loadxi_pat<zextloadi1,      i32,   anyimm0, L2_loadrub_io>;
2009   defm: Loadxi_pat<zextloadi8,      i32,   anyimm0, L2_loadrub_io>;
2010   defm: Loadxi_pat<zextloadi16,     i32,   anyimm1, L2_loadruh_io>;
2011   defm: Loadxi_pat<zextloadv2i8,    v2i16, anyimm1, L2_loadbzw2_io>;
2012   defm: Loadxi_pat<zextloadv4i8,    v4i16, anyimm2, L2_loadbzw4_io>;
2013   defm: Loadxi_pat<load,            i32,   anyimm2, L2_loadri_io>;
2014   defm: Loadxi_pat<load,            v2i16, anyimm2, L2_loadri_io>;
2015   defm: Loadxi_pat<load,            v4i8,  anyimm2, L2_loadri_io>;
2016   defm: Loadxi_pat<load,            i64,   anyimm3, L2_loadrd_io>;
2017   defm: Loadxi_pat<load,            v2i32, anyimm3, L2_loadrd_io>;
2018   defm: Loadxi_pat<load,            v4i16, anyimm3, L2_loadrd_io>;
2019   defm: Loadxi_pat<load,            v8i8,  anyimm3, L2_loadrd_io>;
2020   defm: Loadxi_pat<load,            f32,   anyimm2, L2_loadri_io>;
2021   defm: Loadxi_pat<load,            f64,   anyimm3, L2_loadrd_io>;
2022   // No sextloadi1.
2023
2024   defm: Loadxi_pat<atomic_load_8 ,  i32, anyimm0, L2_loadrub_io>;
2025   defm: Loadxi_pat<atomic_load_16,  i32, anyimm1, L2_loadruh_io>;
2026   defm: Loadxi_pat<atomic_load_32,  i32, anyimm2, L2_loadri_io>;
2027   defm: Loadxi_pat<atomic_load_64,  i64, anyimm3, L2_loadrd_io>;
2028 }
2029
2030 let AddedComplexity = 30 in {
2031   defm: Loadxim_pat<extloadi1,    i64, ToAext64, anyimm0, L2_loadrub_io>;
2032   defm: Loadxim_pat<extloadi8,    i64, ToAext64, anyimm0, L2_loadrub_io>;
2033   defm: Loadxim_pat<extloadi16,   i64, ToAext64, anyimm1, L2_loadruh_io>;
2034   defm: Loadxim_pat<extloadi32,   i64, ToAext64, anyimm2, L2_loadri_io>;
2035   defm: Loadxim_pat<zextloadi1,   i64, ToZext64, anyimm0, L2_loadrub_io>;
2036   defm: Loadxim_pat<zextloadi8,   i64, ToZext64, anyimm0, L2_loadrub_io>;
2037   defm: Loadxim_pat<zextloadi16,  i64, ToZext64, anyimm1, L2_loadruh_io>;
2038   defm: Loadxim_pat<zextloadi32,  i64, ToZext64, anyimm2, L2_loadri_io>;
2039   defm: Loadxim_pat<sextloadi8,   i64, ToSext64, anyimm0, L2_loadrb_io>;
2040   defm: Loadxim_pat<sextloadi16,  i64, ToSext64, anyimm1, L2_loadrh_io>;
2041   defm: Loadxim_pat<sextloadi32,  i64, ToSext64, anyimm2, L2_loadri_io>;
2042 }
2043
2044 let AddedComplexity  = 60 in {
2045   def: Loadxu_pat<extloadi8,    i32,   anyimm0, L4_loadrub_ur>;
2046   def: Loadxu_pat<extloadi16,   i32,   anyimm1, L4_loadruh_ur>;
2047   def: Loadxu_pat<extloadv2i8,  v2i16, anyimm1, L4_loadbzw2_ur>;
2048   def: Loadxu_pat<extloadv4i8,  v4i16, anyimm2, L4_loadbzw4_ur>;
2049   def: Loadxu_pat<sextloadi8,   i32,   anyimm0, L4_loadrb_ur>;
2050   def: Loadxu_pat<sextloadi16,  i32,   anyimm1, L4_loadrh_ur>;
2051   def: Loadxu_pat<sextloadv2i8, v2i16, anyimm1, L4_loadbsw2_ur>;
2052   def: Loadxu_pat<sextloadv4i8, v4i16, anyimm2, L4_loadbzw4_ur>;
2053   def: Loadxu_pat<zextloadi8,   i32,   anyimm0, L4_loadrub_ur>;
2054   def: Loadxu_pat<zextloadi16,  i32,   anyimm1, L4_loadruh_ur>;
2055   def: Loadxu_pat<zextloadv2i8, v2i16, anyimm1, L4_loadbzw2_ur>;
2056   def: Loadxu_pat<zextloadv4i8, v4i16, anyimm2, L4_loadbzw4_ur>;
2057   def: Loadxu_pat<load,         i32,   anyimm2, L4_loadri_ur>;
2058   def: Loadxu_pat<load,         v2i16, anyimm2, L4_loadri_ur>;
2059   def: Loadxu_pat<load,         v4i8,  anyimm2, L4_loadri_ur>;
2060   def: Loadxu_pat<load,         i64,   anyimm3, L4_loadrd_ur>;
2061   def: Loadxu_pat<load,         v2i32, anyimm3, L4_loadrd_ur>;
2062   def: Loadxu_pat<load,         v4i16, anyimm3, L4_loadrd_ur>;
2063   def: Loadxu_pat<load,         v8i8,  anyimm3, L4_loadrd_ur>;
2064   def: Loadxu_pat<load,         f32,   anyimm2, L4_loadri_ur>;
2065   def: Loadxu_pat<load,         f64,   anyimm3, L4_loadrd_ur>;
2066
2067   def: Loadxum_pat<sextloadi8,  i64, anyimm0, ToSext64, L4_loadrb_ur>;
2068   def: Loadxum_pat<zextloadi8,  i64, anyimm0, ToZext64, L4_loadrub_ur>;
2069   def: Loadxum_pat<extloadi8,   i64, anyimm0, ToAext64, L4_loadrub_ur>;
2070   def: Loadxum_pat<sextloadi16, i64, anyimm1, ToSext64, L4_loadrh_ur>;
2071   def: Loadxum_pat<zextloadi16, i64, anyimm1, ToZext64, L4_loadruh_ur>;
2072   def: Loadxum_pat<extloadi16,  i64, anyimm1, ToAext64, L4_loadruh_ur>;
2073   def: Loadxum_pat<sextloadi32, i64, anyimm2, ToSext64, L4_loadri_ur>;
2074   def: Loadxum_pat<zextloadi32, i64, anyimm2, ToZext64, L4_loadri_ur>;
2075   def: Loadxum_pat<extloadi32,  i64, anyimm2, ToAext64, L4_loadri_ur>;
2076 }
2077
2078 let AddedComplexity = 40 in {
2079   def: Loadxr_shl_pat<extloadi8,     i32,   L4_loadrub_rr>;
2080   def: Loadxr_shl_pat<zextloadi8,    i32,   L4_loadrub_rr>;
2081   def: Loadxr_shl_pat<sextloadi8,    i32,   L4_loadrb_rr>;
2082   def: Loadxr_shl_pat<extloadi16,    i32,   L4_loadruh_rr>;
2083   def: Loadxr_shl_pat<zextloadi16,   i32,   L4_loadruh_rr>;
2084   def: Loadxr_shl_pat<sextloadi16,   i32,   L4_loadrh_rr>;
2085   def: Loadxr_shl_pat<load,          i32,   L4_loadri_rr>;
2086   def: Loadxr_shl_pat<load,          v2i16, L4_loadri_rr>;
2087   def: Loadxr_shl_pat<load,          v4i8,  L4_loadri_rr>;
2088   def: Loadxr_shl_pat<load,          i64,   L4_loadrd_rr>;
2089   def: Loadxr_shl_pat<load,          v2i32, L4_loadrd_rr>;
2090   def: Loadxr_shl_pat<load,          v4i16, L4_loadrd_rr>;
2091   def: Loadxr_shl_pat<load,          v8i8,  L4_loadrd_rr>;
2092   def: Loadxr_shl_pat<load,          f32,   L4_loadri_rr>;
2093   def: Loadxr_shl_pat<load,          f64,   L4_loadrd_rr>;
2094 }
2095
2096 let AddedComplexity = 20 in {
2097   def: Loadxr_add_pat<extloadi8,     i32,   L4_loadrub_rr>;
2098   def: Loadxr_add_pat<zextloadi8,    i32,   L4_loadrub_rr>;
2099   def: Loadxr_add_pat<sextloadi8,    i32,   L4_loadrb_rr>;
2100   def: Loadxr_add_pat<extloadi16,    i32,   L4_loadruh_rr>;
2101   def: Loadxr_add_pat<zextloadi16,   i32,   L4_loadruh_rr>;
2102   def: Loadxr_add_pat<sextloadi16,   i32,   L4_loadrh_rr>;
2103   def: Loadxr_add_pat<load,          i32,   L4_loadri_rr>;
2104   def: Loadxr_add_pat<load,          v2i16, L4_loadri_rr>;
2105   def: Loadxr_add_pat<load,          v4i8,  L4_loadri_rr>;
2106   def: Loadxr_add_pat<load,          i64,   L4_loadrd_rr>;
2107   def: Loadxr_add_pat<load,          v2i32, L4_loadrd_rr>;
2108   def: Loadxr_add_pat<load,          v4i16, L4_loadrd_rr>;
2109   def: Loadxr_add_pat<load,          v8i8,  L4_loadrd_rr>;
2110   def: Loadxr_add_pat<load,          f32,   L4_loadri_rr>;
2111   def: Loadxr_add_pat<load,          f64,   L4_loadrd_rr>;
2112 }
2113
2114 let AddedComplexity = 40 in {
2115   def: Loadxrm_shl_pat<extloadi8,    i64, ToAext64, L4_loadrub_rr>;
2116   def: Loadxrm_shl_pat<zextloadi8,   i64, ToZext64, L4_loadrub_rr>;
2117   def: Loadxrm_shl_pat<sextloadi8,   i64, ToSext64, L4_loadrb_rr>;
2118   def: Loadxrm_shl_pat<extloadi16,   i64, ToAext64, L4_loadruh_rr>;
2119   def: Loadxrm_shl_pat<zextloadi16,  i64, ToZext64, L4_loadruh_rr>;
2120   def: Loadxrm_shl_pat<sextloadi16,  i64, ToSext64, L4_loadrh_rr>;
2121   def: Loadxrm_shl_pat<extloadi32,   i64, ToAext64, L4_loadri_rr>;
2122   def: Loadxrm_shl_pat<zextloadi32,  i64, ToZext64, L4_loadri_rr>;
2123   def: Loadxrm_shl_pat<sextloadi32,  i64, ToSext64, L4_loadri_rr>;
2124 }
2125
2126 let AddedComplexity = 20 in {
2127   def: Loadxrm_add_pat<extloadi8,    i64, ToAext64, L4_loadrub_rr>;
2128   def: Loadxrm_add_pat<zextloadi8,   i64, ToZext64, L4_loadrub_rr>;
2129   def: Loadxrm_add_pat<sextloadi8,   i64, ToSext64, L4_loadrb_rr>;
2130   def: Loadxrm_add_pat<extloadi16,   i64, ToAext64, L4_loadruh_rr>;
2131   def: Loadxrm_add_pat<zextloadi16,  i64, ToZext64, L4_loadruh_rr>;
2132   def: Loadxrm_add_pat<sextloadi16,  i64, ToSext64, L4_loadrh_rr>;
2133   def: Loadxrm_add_pat<extloadi32,   i64, ToAext64, L4_loadri_rr>;
2134   def: Loadxrm_add_pat<zextloadi32,  i64, ToZext64, L4_loadri_rr>;
2135   def: Loadxrm_add_pat<sextloadi32,  i64, ToSext64, L4_loadri_rr>;
2136 }
2137
2138 // Absolute address
2139
2140 let AddedComplexity  = 60 in {
2141   def: Loada_pat<zextloadi1,      i32,   anyimm0, PS_loadrubabs>;
2142   def: Loada_pat<sextloadi8,      i32,   anyimm0, PS_loadrbabs>;
2143   def: Loada_pat<extloadi8,       i32,   anyimm0, PS_loadrubabs>;
2144   def: Loada_pat<zextloadi8,      i32,   anyimm0, PS_loadrubabs>;
2145   def: Loada_pat<sextloadi16,     i32,   anyimm1, PS_loadrhabs>;
2146   def: Loada_pat<extloadi16,      i32,   anyimm1, PS_loadruhabs>;
2147   def: Loada_pat<zextloadi16,     i32,   anyimm1, PS_loadruhabs>;
2148   def: Loada_pat<load,            i32,   anyimm2, PS_loadriabs>;
2149   def: Loada_pat<load,            v2i16, anyimm2, PS_loadriabs>;
2150   def: Loada_pat<load,            v4i8,  anyimm2, PS_loadriabs>;
2151   def: Loada_pat<load,            i64,   anyimm3, PS_loadrdabs>;
2152   def: Loada_pat<load,            v2i32, anyimm3, PS_loadrdabs>;
2153   def: Loada_pat<load,            v4i16, anyimm3, PS_loadrdabs>;
2154   def: Loada_pat<load,            v8i8,  anyimm3, PS_loadrdabs>;
2155   def: Loada_pat<load,            f32,   anyimm2, PS_loadriabs>;
2156   def: Loada_pat<load,            f64,   anyimm3, PS_loadrdabs>;
2157
2158   def: Loada_pat<atomic_load_8,   i32, anyimm0, PS_loadrubabs>;
2159   def: Loada_pat<atomic_load_16,  i32, anyimm1, PS_loadruhabs>;
2160   def: Loada_pat<atomic_load_32,  i32, anyimm2, PS_loadriabs>;
2161   def: Loada_pat<atomic_load_64,  i64, anyimm3, PS_loadrdabs>;
2162 }
2163
2164 let AddedComplexity  = 30 in {
2165   def: Loadam_pat<extloadi8,      i64, anyimm0, ToAext64, PS_loadrubabs>;
2166   def: Loadam_pat<sextloadi8,     i64, anyimm0, ToSext64, PS_loadrbabs>;
2167   def: Loadam_pat<zextloadi8,     i64, anyimm0, ToZext64, PS_loadrubabs>;
2168   def: Loadam_pat<extloadi16,     i64, anyimm1, ToAext64, PS_loadruhabs>;
2169   def: Loadam_pat<sextloadi16,    i64, anyimm1, ToSext64, PS_loadrhabs>;
2170   def: Loadam_pat<zextloadi16,    i64, anyimm1, ToZext64, PS_loadruhabs>;
2171   def: Loadam_pat<extloadi32,     i64, anyimm2, ToAext64, PS_loadriabs>;
2172   def: Loadam_pat<sextloadi32,    i64, anyimm2, ToSext64, PS_loadriabs>;
2173   def: Loadam_pat<zextloadi32,    i64, anyimm2, ToZext64, PS_loadriabs>;
2174
2175   def: Loadam_pat<load,           i1,  anyimm0, I32toI1,  PS_loadrubabs>;
2176   def: Loadam_pat<zextloadi1,     i64, anyimm0, ToZext64, PS_loadrubabs>;
2177 }
2178
2179 // GP-relative address
2180
2181 let AddedComplexity  = 100 in {
2182   def: Loada_pat<extloadi1,       i32,   addrgp,  L2_loadrubgp>;
2183   def: Loada_pat<zextloadi1,      i32,   addrgp,  L2_loadrubgp>;
2184   def: Loada_pat<extloadi8,       i32,   addrgp,  L2_loadrubgp>;
2185   def: Loada_pat<sextloadi8,      i32,   addrgp,  L2_loadrbgp>;
2186   def: Loada_pat<zextloadi8,      i32,   addrgp,  L2_loadrubgp>;
2187   def: Loada_pat<extloadi16,      i32,   addrgp,  L2_loadruhgp>;
2188   def: Loada_pat<sextloadi16,     i32,   addrgp,  L2_loadrhgp>;
2189   def: Loada_pat<zextloadi16,     i32,   addrgp,  L2_loadruhgp>;
2190   def: Loada_pat<load,            i32,   addrgp,  L2_loadrigp>;
2191   def: Loada_pat<load,            v2i16, addrgp,  L2_loadrigp>;
2192   def: Loada_pat<load,            v4i8,  addrgp,  L2_loadrigp>;
2193   def: Loada_pat<load,            i64,   addrgp,  L2_loadrdgp>;
2194   def: Loada_pat<load,            v2i32, addrgp,  L2_loadrdgp>;
2195   def: Loada_pat<load,            v4i16, addrgp,  L2_loadrdgp>;
2196   def: Loada_pat<load,            v8i8,  addrgp,  L2_loadrdgp>;
2197   def: Loada_pat<load,            f32,   addrgp,  L2_loadrigp>;
2198   def: Loada_pat<load,            f64,   addrgp,  L2_loadrdgp>;
2199
2200   def: Loada_pat<atomic_load_8,   i32, addrgp,  L2_loadrubgp>;
2201   def: Loada_pat<atomic_load_16,  i32, addrgp,  L2_loadruhgp>;
2202   def: Loada_pat<atomic_load_32,  i32, addrgp,  L2_loadrigp>;
2203   def: Loada_pat<atomic_load_64,  i64, addrgp,  L2_loadrdgp>;
2204 }
2205
2206 let AddedComplexity  = 70 in {
2207   def: Loadam_pat<extloadi8,      i64, addrgp,  ToAext64, L2_loadrubgp>;
2208   def: Loadam_pat<sextloadi8,     i64, addrgp,  ToSext64, L2_loadrbgp>;
2209   def: Loadam_pat<zextloadi8,     i64, addrgp,  ToZext64, L2_loadrubgp>;
2210   def: Loadam_pat<extloadi16,     i64, addrgp,  ToAext64, L2_loadruhgp>;
2211   def: Loadam_pat<sextloadi16,    i64, addrgp,  ToSext64, L2_loadrhgp>;
2212   def: Loadam_pat<zextloadi16,    i64, addrgp,  ToZext64, L2_loadruhgp>;
2213   def: Loadam_pat<extloadi32,     i64, addrgp,  ToAext64, L2_loadrigp>;
2214   def: Loadam_pat<sextloadi32,    i64, addrgp,  ToSext64, L2_loadrigp>;
2215   def: Loadam_pat<zextloadi32,    i64, addrgp,  ToZext64, L2_loadrigp>;
2216
2217   def: Loadam_pat<load,           i1,  addrgp,  I32toI1,  L2_loadrubgp>;
2218   def: Loadam_pat<zextloadi1,     i64, addrgp,  ToZext64, L2_loadrubgp>;
2219 }
2220
2221
2222 // Sign-extending loads of i1 need to replicate the lowest bit throughout
2223 // the 32-bit value. Since the loaded value can only be 0 or 1, 0-v should
2224 // do the trick.
2225 let AddedComplexity = 20 in
2226 def: Pat<(i32 (sextloadi1 I32:$Rs)),
2227          (A2_subri 0, (L2_loadrub_io IntRegs:$Rs, 0))>;
2228
2229 // Patterns for loads of i1:
2230 def: Pat<(i1 (load AddrFI:$fi)),
2231          (C2_tfrrp (L2_loadrub_io AddrFI:$fi, 0))>;
2232 def: Pat<(i1 (load (add I32:$Rs, anyimm0:$Off))),
2233          (C2_tfrrp (L2_loadrub_io IntRegs:$Rs, imm:$Off))>;
2234 def: Pat<(i1 (load I32:$Rs)),
2235          (C2_tfrrp (L2_loadrub_io IntRegs:$Rs, 0))>;
2236
2237
2238 // --(13) Store ----------------------------------------------------------
2239 //
2240
2241 class Storepi_pat<PatFrag Store, PatFrag Value, PatFrag Offset, InstHexagon MI>
2242   : Pat<(Store Value:$Rt, I32:$Rx, Offset:$s4),
2243         (MI I32:$Rx, imm:$s4, Value:$Rt)>;
2244
2245 def: Storepi_pat<post_truncsti8,  I32, s4_0ImmPred, S2_storerb_pi>;
2246 def: Storepi_pat<post_truncsti16, I32, s4_1ImmPred, S2_storerh_pi>;
2247 def: Storepi_pat<post_store,      I32, s4_2ImmPred, S2_storeri_pi>;
2248 def: Storepi_pat<post_store,      I64, s4_3ImmPred, S2_storerd_pi>;
2249
2250 // Patterns for generating stores, where the address takes different forms:
2251 // - frameindex,
2252 // - frameindex + offset,
2253 // - base + offset,
2254 // - simple (base address without offset).
2255 // These would usually be used together (via Storexi_pat defined below), but
2256 // in some cases one may want to apply different properties (such as
2257 // AddedComplexity) to the individual patterns.
2258 class Storexi_fi_pat<PatFrag Store, PatFrag Value, InstHexagon MI>
2259   : Pat<(Store Value:$Rs, AddrFI:$fi), (MI AddrFI:$fi, 0, Value:$Rs)>;
2260
2261 multiclass Storexi_fi_add_pat<PatFrag Store, PatFrag Value, PatFrag ImmPred,
2262                               InstHexagon MI> {
2263   def: Pat<(Store Value:$Rs, (add (i32 AddrFI:$fi), ImmPred:$Off)),
2264            (MI AddrFI:$fi, imm:$Off, Value:$Rs)>;
2265   def: Pat<(Store Value:$Rs, (IsOrAdd (i32 AddrFI:$fi), ImmPred:$Off)),
2266            (MI AddrFI:$fi, imm:$Off, Value:$Rs)>;
2267 }
2268
2269 multiclass Storexi_add_pat<PatFrag Store, PatFrag Value, PatFrag ImmPred,
2270                            InstHexagon MI> {
2271   def: Pat<(Store Value:$Rt, (add I32:$Rs, ImmPred:$Off)),
2272            (MI IntRegs:$Rs, imm:$Off, Value:$Rt)>;
2273   def: Pat<(Store Value:$Rt, (IsOrAdd I32:$Rs, ImmPred:$Off)),
2274            (MI IntRegs:$Rs, imm:$Off, Value:$Rt)>;
2275 }
2276
2277 class Storexi_base_pat<PatFrag Store, PatFrag Value, InstHexagon MI>
2278   : Pat<(Store Value:$Rt, I32:$Rs),
2279         (MI IntRegs:$Rs, 0, Value:$Rt)>;
2280
2281 // Patterns for generating stores, where the address takes different forms,
2282 // and where the value being stored is transformed through the value modifier
2283 // ValueMod.  The address forms are same as above.
2284 class Storexim_fi_pat<PatFrag Store, PatFrag Value, PatFrag ValueMod,
2285                       InstHexagon MI>
2286   : Pat<(Store Value:$Rs, AddrFI:$fi),
2287         (MI AddrFI:$fi, 0, (ValueMod Value:$Rs))>;
2288
2289 multiclass Storexim_fi_add_pat<PatFrag Store, PatFrag Value, PatFrag ImmPred,
2290                                PatFrag ValueMod, InstHexagon MI> {
2291   def: Pat<(Store Value:$Rs, (add (i32 AddrFI:$fi), ImmPred:$Off)),
2292            (MI AddrFI:$fi, imm:$Off, (ValueMod Value:$Rs))>;
2293   def: Pat<(Store Value:$Rs, (IsOrAdd (i32 AddrFI:$fi), ImmPred:$Off)),
2294            (MI AddrFI:$fi, imm:$Off, (ValueMod Value:$Rs))>;
2295 }
2296
2297 multiclass Storexim_add_pat<PatFrag Store, PatFrag Value, PatFrag ImmPred,
2298                             PatFrag ValueMod, InstHexagon MI> {
2299   def: Pat<(Store Value:$Rt, (add I32:$Rs, ImmPred:$Off)),
2300            (MI IntRegs:$Rs, imm:$Off, (ValueMod Value:$Rt))>;
2301   def: Pat<(Store Value:$Rt, (IsOrAdd I32:$Rs, ImmPred:$Off)),
2302            (MI IntRegs:$Rs, imm:$Off, (ValueMod Value:$Rt))>;
2303 }
2304
2305 class Storexim_base_pat<PatFrag Store, PatFrag Value, PatFrag ValueMod,
2306                         InstHexagon MI>
2307   : Pat<(Store Value:$Rt, I32:$Rs),
2308         (MI IntRegs:$Rs, 0, (ValueMod Value:$Rt))>;
2309
2310 multiclass Storexi_pat<PatFrag Store, PatFrag Value, PatLeaf ImmPred,
2311                        InstHexagon MI> {
2312   defm: Storexi_fi_add_pat <Store, Value, ImmPred, MI>;
2313   def:  Storexi_fi_pat     <Store, Value,          MI>;
2314   defm: Storexi_add_pat    <Store, Value, ImmPred, MI>;
2315 }
2316
2317 multiclass Storexim_pat<PatFrag Store, PatFrag Value, PatLeaf ImmPred,
2318                         PatFrag ValueMod, InstHexagon MI> {
2319   defm: Storexim_fi_add_pat <Store, Value, ImmPred, ValueMod, MI>;
2320   def:  Storexim_fi_pat     <Store, Value,          ValueMod, MI>;
2321   defm: Storexim_add_pat    <Store, Value, ImmPred, ValueMod, MI>;
2322 }
2323
2324 // Reg<<S + Imm
2325 class Storexu_shl_pat<PatFrag Store, PatFrag Value, PatFrag ImmPred, InstHexagon MI>
2326   : Pat<(Store Value:$Rt, (add (shl I32:$Ru, u2_0ImmPred:$u2), ImmPred:$A)),
2327         (MI IntRegs:$Ru, imm:$u2, ImmPred:$A, Value:$Rt)>;
2328
2329 // Reg<<S + Reg
2330 class Storexr_shl_pat<PatFrag Store, PatFrag Value, InstHexagon MI>
2331   : Pat<(Store Value:$Ru, (add I32:$Rs, (shl I32:$Rt, u2_0ImmPred:$u2))),
2332         (MI IntRegs:$Rs, IntRegs:$Rt, imm:$u2, Value:$Ru)>;
2333
2334 // Reg + Reg
2335 class Storexr_add_pat<PatFrag Store, PatFrag Value, InstHexagon MI>
2336   : Pat<(Store Value:$Ru, (add I32:$Rs, I32:$Rt)),
2337         (MI IntRegs:$Rs, IntRegs:$Rt, 0, Value:$Ru)>;
2338
2339 class Storea_pat<PatFrag Store, PatFrag Value, PatFrag Addr, InstHexagon MI>
2340   : Pat<(Store Value:$val, Addr:$addr), (MI Addr:$addr, Value:$val)>;
2341
2342 class Stoream_pat<PatFrag Store, PatFrag Value, PatFrag Addr, PatFrag ValueMod,
2343                   InstHexagon MI>
2344   : Pat<(Store Value:$val, Addr:$addr),
2345         (MI Addr:$addr, (ValueMod Value:$val))>;
2346
2347 // Regular stores in the DAG have two operands: value and address.
2348 // Atomic stores also have two, but they are reversed: address, value.
2349 // To use atomic stores with the patterns, they need to have their operands
2350 // swapped. This relies on the knowledge that the F.Fragment uses names
2351 // "ptr" and "val".
2352 class AtomSt<PatFrag F>
2353   : PatFrag<(ops node:$val, node:$ptr), !head(F.Fragments), F.PredicateCode,
2354             F.OperandTransform> {
2355   let IsAtomic = F.IsAtomic;
2356   let MemoryVT = F.MemoryVT;
2357 }
2358
2359
2360 def IMM_BYTE : SDNodeXForm<imm, [{
2361   // -1 can be represented as 255, etc.
2362   // assigning to a byte restores our desired signed value.
2363   int8_t imm = N->getSExtValue();
2364   return CurDAG->getTargetConstant(imm, SDLoc(N), MVT::i32);
2365 }]>;
2366
2367 def IMM_HALF : SDNodeXForm<imm, [{
2368   // -1 can be represented as 65535, etc.
2369   // assigning to a short restores our desired signed value.
2370   int16_t imm = N->getSExtValue();
2371   return CurDAG->getTargetConstant(imm, SDLoc(N), MVT::i32);
2372 }]>;
2373
2374 def IMM_WORD : SDNodeXForm<imm, [{
2375   // -1 can be represented as 4294967295, etc.
2376   // Currently, it's not doing this. But some optimization
2377   // might convert -1 to a large +ve number.
2378   // assigning to a word restores our desired signed value.
2379   int32_t imm = N->getSExtValue();
2380   return CurDAG->getTargetConstant(imm, SDLoc(N), MVT::i32);
2381 }]>;
2382
2383 def ToImmByte : OutPatFrag<(ops node:$R), (IMM_BYTE $R)>;
2384 def ToImmHalf : OutPatFrag<(ops node:$R), (IMM_HALF $R)>;
2385 def ToImmWord : OutPatFrag<(ops node:$R), (IMM_WORD $R)>;
2386
2387 // Even though the offset is not extendable in the store-immediate, we
2388 // can still generate the fi# in the base address. If the final offset
2389 // is not valid for the instruction, we will replace it with a scratch
2390 // register.
2391 class SmallStackStore<PatFrag Store>
2392   : PatFrag<(ops node:$Val, node:$Addr), (Store node:$Val, node:$Addr), [{
2393   return isSmallStackStore(cast<StoreSDNode>(N));
2394 }]>;
2395
2396 // This is the complement of SmallStackStore.
2397 class LargeStackStore<PatFrag Store>
2398   : PatFrag<(ops node:$Val, node:$Addr), (Store node:$Val, node:$Addr), [{
2399   return !isSmallStackStore(cast<StoreSDNode>(N));
2400 }]>;
2401
2402 // Preferred addressing modes for various combinations of stored value
2403 // and address computation.
2404 // For stores where the address and value are both immediates, prefer
2405 // store-immediate. The reason is that the constant-extender optimization
2406 // can replace store-immediate with a store-register, but there is nothing
2407 // to generate a store-immediate out of a store-register.
2408 //
2409 //         C     R     F    F+C   R+C   R+R   R<<S+C   R<<S+R
2410 // --+-------+-----+-----+------+-----+-----+--------+--------
2411 // C |   imm | imm | imm |  imm | imm |  rr |     ur |     rr
2412 // R |  abs* |  io |  io |   io |  io |  rr |     ur |     rr
2413 //
2414 // (*) Absolute or GP-relative.
2415 //
2416 // Note that any expression can be matched by Reg. In particular, an immediate
2417 // can always be placed in a register, so patterns checking for Imm should
2418 // have a higher priority than the ones involving Reg that could also match.
2419 // For example, *(p+4) could become r1=#4; memw(r0+r1<<#0) instead of the
2420 // preferred memw(r0+#4). Similarly Reg+Imm or Reg+Reg should be tried before
2421 // Reg alone.
2422 //
2423 // The order in which the different combinations are tried:
2424 //
2425 //         C     F     R    F+C   R+C   R+R   R<<S+C   R<<S+R
2426 // --+-------+-----+-----+------+-----+-----+--------+--------
2427 // C |     1 |   6 |   - |    5 |   9 |   - |      - |      -
2428 // R |     2 |   8 |  12 |    7 |  10 |  11 |      3 |      4
2429
2430
2431 // First, match the unusual case of doubleword store into Reg+Imm4, i.e.
2432 // a store where the offset Imm4 is a multiple of 4, but not of 8. This
2433 // implies that Reg is also a proper multiple of 4. To still generate a
2434 // doubleword store, add 4 to Reg, and subtract 4 from the offset.
2435
2436 def s30_2ProperPred  : PatLeaf<(i32 imm), [{
2437   int64_t v = (int64_t)N->getSExtValue();
2438   return isShiftedInt<30,2>(v) && !isShiftedInt<29,3>(v);
2439 }]>;
2440 def RoundTo8 : SDNodeXForm<imm, [{
2441   int32_t Imm = N->getSExtValue();
2442   return CurDAG->getTargetConstant(Imm & -8, SDLoc(N), MVT::i32);
2443 }]>;
2444
2445 let AddedComplexity = 150 in
2446 def: Pat<(store I64:$Ru, (add I32:$Rs, s30_2ProperPred:$Off)),
2447          (S2_storerd_io (A2_addi I32:$Rs, 4), (RoundTo8 $Off), I64:$Ru)>;
2448
2449 class Storexi_abs_pat<PatFrag Store, PatFrag Value, InstHexagon MI>
2450   : Pat<(Store Value:$val, anyimm:$addr),
2451         (MI (ToI32 $addr), 0, Value:$val)>;
2452 class Storexim_abs_pat<PatFrag Store, PatFrag Value, PatFrag ValueMod,
2453                        InstHexagon MI>
2454   : Pat<(Store Value:$val, anyimm:$addr),
2455         (MI (ToI32 $addr), 0, (ValueMod Value:$val))>;
2456
2457 let AddedComplexity = 140 in {
2458   def: Storexim_abs_pat<truncstorei8,  anyint, ToImmByte, S4_storeirb_io>;
2459   def: Storexim_abs_pat<truncstorei16, anyint, ToImmHalf, S4_storeirh_io>;
2460   def: Storexim_abs_pat<store,         anyint, ToImmWord, S4_storeiri_io>;
2461
2462   def: Storexi_abs_pat<truncstorei8,  anyimm, S4_storeirb_io>;
2463   def: Storexi_abs_pat<truncstorei16, anyimm, S4_storeirh_io>;
2464   def: Storexi_abs_pat<store,         anyimm, S4_storeiri_io>;
2465 }
2466
2467 // GP-relative address
2468 let AddedComplexity = 120 in {
2469   def: Storea_pat<truncstorei8,               I32, addrgp, S2_storerbgp>;
2470   def: Storea_pat<truncstorei16,              I32, addrgp, S2_storerhgp>;
2471   def: Storea_pat<store,                      I32, addrgp, S2_storerigp>;
2472   def: Storea_pat<store,                     V4I8, addrgp, S2_storerigp>;
2473   def: Storea_pat<store,                    V2I16, addrgp, S2_storerigp>;
2474   def: Storea_pat<store,                      I64, addrgp, S2_storerdgp>;
2475   def: Storea_pat<store,                     V8I8, addrgp, S2_storerdgp>;
2476   def: Storea_pat<store,                    V4I16, addrgp, S2_storerdgp>;
2477   def: Storea_pat<store,                    V2I32, addrgp, S2_storerdgp>;
2478   def: Storea_pat<store,                      F32, addrgp, S2_storerigp>;
2479   def: Storea_pat<store,                      F64, addrgp, S2_storerdgp>;
2480   def: Storea_pat<AtomSt<atomic_store_8>,     I32, addrgp, S2_storerbgp>;
2481   def: Storea_pat<AtomSt<atomic_store_16>,    I32, addrgp, S2_storerhgp>;
2482   def: Storea_pat<AtomSt<atomic_store_32>,    I32, addrgp, S2_storerigp>;
2483   def: Storea_pat<AtomSt<atomic_store_32>,   V4I8, addrgp, S2_storerigp>;
2484   def: Storea_pat<AtomSt<atomic_store_32>,  V2I16, addrgp, S2_storerigp>;
2485   def: Storea_pat<AtomSt<atomic_store_64>,    I64, addrgp, S2_storerdgp>;
2486   def: Storea_pat<AtomSt<atomic_store_64>,   V8I8, addrgp, S2_storerdgp>;
2487   def: Storea_pat<AtomSt<atomic_store_64>,  V4I16, addrgp, S2_storerdgp>;
2488   def: Storea_pat<AtomSt<atomic_store_64>,  V2I32, addrgp, S2_storerdgp>;
2489
2490   def: Stoream_pat<truncstorei8,  I64, addrgp, LoReg,    S2_storerbgp>;
2491   def: Stoream_pat<truncstorei16, I64, addrgp, LoReg,    S2_storerhgp>;
2492   def: Stoream_pat<truncstorei32, I64, addrgp, LoReg,    S2_storerigp>;
2493   def: Stoream_pat<store,         I1,  addrgp, I1toI32,  S2_storerbgp>;
2494 }
2495
2496 // Absolute address
2497 let AddedComplexity = 110 in {
2498   def: Storea_pat<truncstorei8,               I32, anyimm0, PS_storerbabs>;
2499   def: Storea_pat<truncstorei16,              I32, anyimm1, PS_storerhabs>;
2500   def: Storea_pat<store,                      I32, anyimm2, PS_storeriabs>;
2501   def: Storea_pat<store,                     V4I8, anyimm2, PS_storeriabs>;
2502   def: Storea_pat<store,                    V2I16, anyimm2, PS_storeriabs>;
2503   def: Storea_pat<store,                      I64, anyimm3, PS_storerdabs>;
2504   def: Storea_pat<store,                     V8I8, anyimm3, PS_storerdabs>;
2505   def: Storea_pat<store,                    V4I16, anyimm3, PS_storerdabs>;
2506   def: Storea_pat<store,                    V2I32, anyimm3, PS_storerdabs>;
2507   def: Storea_pat<store,                      F32, anyimm2, PS_storeriabs>;
2508   def: Storea_pat<store,                      F64, anyimm3, PS_storerdabs>;
2509   def: Storea_pat<AtomSt<atomic_store_8>,     I32, anyimm0, PS_storerbabs>;
2510   def: Storea_pat<AtomSt<atomic_store_16>,    I32, anyimm1, PS_storerhabs>;
2511   def: Storea_pat<AtomSt<atomic_store_32>,    I32, anyimm2, PS_storeriabs>;
2512   def: Storea_pat<AtomSt<atomic_store_32>,   V4I8, anyimm2, PS_storeriabs>;
2513   def: Storea_pat<AtomSt<atomic_store_32>,  V2I16, anyimm2, PS_storeriabs>;
2514   def: Storea_pat<AtomSt<atomic_store_64>,    I64, anyimm3, PS_storerdabs>;
2515   def: Storea_pat<AtomSt<atomic_store_64>,   V8I8, anyimm3, PS_storerdabs>;
2516   def: Storea_pat<AtomSt<atomic_store_64>,  V4I16, anyimm3, PS_storerdabs>;
2517   def: Storea_pat<AtomSt<atomic_store_64>,  V2I32, anyimm3, PS_storerdabs>;
2518
2519   def: Stoream_pat<truncstorei8,  I64, anyimm0, LoReg,    PS_storerbabs>;
2520   def: Stoream_pat<truncstorei16, I64, anyimm1, LoReg,    PS_storerhabs>;
2521   def: Stoream_pat<truncstorei32, I64, anyimm2, LoReg,    PS_storeriabs>;
2522   def: Stoream_pat<store,         I1,  anyimm0, I1toI32,  PS_storerbabs>;
2523 }
2524
2525 // Reg<<S + Imm
2526 let AddedComplexity = 100 in {
2527   def: Storexu_shl_pat<truncstorei8,    I32, anyimm0, S4_storerb_ur>;
2528   def: Storexu_shl_pat<truncstorei16,   I32, anyimm1, S4_storerh_ur>;
2529   def: Storexu_shl_pat<store,           I32, anyimm2, S4_storeri_ur>;
2530   def: Storexu_shl_pat<store,          V4I8, anyimm2, S4_storeri_ur>;
2531   def: Storexu_shl_pat<store,         V2I16, anyimm2, S4_storeri_ur>;
2532   def: Storexu_shl_pat<store,           I64, anyimm3, S4_storerd_ur>;
2533   def: Storexu_shl_pat<store,          V8I8, anyimm3, S4_storerd_ur>;
2534   def: Storexu_shl_pat<store,         V4I16, anyimm3, S4_storerd_ur>;
2535   def: Storexu_shl_pat<store,         V2I32, anyimm3, S4_storerd_ur>;
2536   def: Storexu_shl_pat<store,           F32, anyimm2, S4_storeri_ur>;
2537   def: Storexu_shl_pat<store,           F64, anyimm3, S4_storerd_ur>;
2538
2539   def: Pat<(store I1:$Pu, (add (shl I32:$Rs, u2_0ImmPred:$u2), anyimm:$A)),
2540            (S4_storerb_ur IntRegs:$Rs, imm:$u2, imm:$A, (I1toI32 I1:$Pu))>;
2541 }
2542
2543 // Reg<<S + Reg
2544 let AddedComplexity = 90 in {
2545   def: Storexr_shl_pat<truncstorei8,    I32, S4_storerb_rr>;
2546   def: Storexr_shl_pat<truncstorei16,   I32, S4_storerh_rr>;
2547   def: Storexr_shl_pat<store,           I32, S4_storeri_rr>;
2548   def: Storexr_shl_pat<store,          V4I8, S4_storeri_rr>;
2549   def: Storexr_shl_pat<store,         V2I16, S4_storeri_rr>;
2550   def: Storexr_shl_pat<store,           I64, S4_storerd_rr>;
2551   def: Storexr_shl_pat<store,          V8I8, S4_storerd_rr>;
2552   def: Storexr_shl_pat<store,         V4I16, S4_storerd_rr>;
2553   def: Storexr_shl_pat<store,         V2I32, S4_storerd_rr>;
2554   def: Storexr_shl_pat<store,           F32, S4_storeri_rr>;
2555   def: Storexr_shl_pat<store,           F64, S4_storerd_rr>;
2556
2557   def: Pat<(store I1:$Pu, (add (shl I32:$Rs, u2_0ImmPred:$u2), I32:$Rt)),
2558            (S4_storerb_ur IntRegs:$Rt, IntRegs:$Rs, imm:$u2, (I1toI32 I1:$Pu))>;
2559 }
2560
2561 class SS_<PatFrag F> : SmallStackStore<F>;
2562 class LS_<PatFrag F> : LargeStackStore<F>;
2563
2564 multiclass IMFA_<PatFrag S, PatFrag V, PatFrag O, PatFrag M, InstHexagon I> {
2565   defm: Storexim_fi_add_pat<S, V, O, M, I>;
2566 }
2567 multiclass IFA_<PatFrag S, PatFrag V, PatFrag O, InstHexagon I> {
2568   defm: Storexi_fi_add_pat<S, V, O, I>;
2569 }
2570
2571 // Fi+Imm, store-immediate
2572 let AddedComplexity = 80 in {
2573   defm: IMFA_<SS_<truncstorei8>,  anyint, u6_0ImmPred, ToImmByte, S4_storeirb_io>;
2574   defm: IMFA_<SS_<truncstorei16>, anyint, u6_1ImmPred, ToImmHalf, S4_storeirh_io>;
2575   defm: IMFA_<SS_<store>,         anyint, u6_2ImmPred, ToImmWord, S4_storeiri_io>;
2576
2577   defm: IFA_<SS_<truncstorei8>,   anyimm, u6_0ImmPred, S4_storeirb_io>;
2578   defm: IFA_<SS_<truncstorei16>,  anyimm, u6_1ImmPred, S4_storeirh_io>;
2579   defm: IFA_<SS_<store>,          anyimm, u6_2ImmPred, S4_storeiri_io>;
2580
2581   // For large-stack stores, generate store-register (prefer explicit Fi
2582   // in the address).
2583   defm: IMFA_<LS_<truncstorei8>,   anyimm, u6_0ImmPred, ToI32, S2_storerb_io>;
2584   defm: IMFA_<LS_<truncstorei16>,  anyimm, u6_1ImmPred, ToI32, S2_storerh_io>;
2585   defm: IMFA_<LS_<store>,          anyimm, u6_2ImmPred, ToI32, S2_storeri_io>;
2586 }
2587
2588 // Fi, store-immediate
2589 let AddedComplexity = 70 in {
2590   def: Storexim_fi_pat<SS_<truncstorei8>,  anyint, ToImmByte, S4_storeirb_io>;
2591   def: Storexim_fi_pat<SS_<truncstorei16>, anyint, ToImmHalf, S4_storeirh_io>;
2592   def: Storexim_fi_pat<SS_<store>,         anyint, ToImmWord, S4_storeiri_io>;
2593
2594   def: Storexi_fi_pat<SS_<truncstorei8>,   anyimm, S4_storeirb_io>;
2595   def: Storexi_fi_pat<SS_<truncstorei16>,  anyimm, S4_storeirh_io>;
2596   def: Storexi_fi_pat<SS_<store>,          anyimm, S4_storeiri_io>;
2597
2598   // For large-stack stores, generate store-register (prefer explicit Fi
2599   // in the address).
2600   def: Storexim_fi_pat<LS_<truncstorei8>,  anyimm, ToI32, S2_storerb_io>;
2601   def: Storexim_fi_pat<LS_<truncstorei16>, anyimm, ToI32, S2_storerh_io>;
2602   def: Storexim_fi_pat<LS_<store>,         anyimm, ToI32, S2_storeri_io>;
2603 }
2604
2605 // Fi+Imm, Fi, store-register
2606 let AddedComplexity = 60 in {
2607   defm: Storexi_fi_add_pat<truncstorei8,    I32, anyimm, S2_storerb_io>;
2608   defm: Storexi_fi_add_pat<truncstorei16,   I32, anyimm, S2_storerh_io>;
2609   defm: Storexi_fi_add_pat<store,           I32, anyimm, S2_storeri_io>;
2610   defm: Storexi_fi_add_pat<store,          V4I8, anyimm, S2_storeri_io>;
2611   defm: Storexi_fi_add_pat<store,         V2I16, anyimm, S2_storeri_io>;
2612   defm: Storexi_fi_add_pat<store,           I64, anyimm, S2_storerd_io>;
2613   defm: Storexi_fi_add_pat<store,          V8I8, anyimm, S2_storerd_io>;
2614   defm: Storexi_fi_add_pat<store,         V4I16, anyimm, S2_storerd_io>;
2615   defm: Storexi_fi_add_pat<store,         V2I32, anyimm, S2_storerd_io>;
2616   defm: Storexi_fi_add_pat<store,           F32, anyimm, S2_storeri_io>;
2617   defm: Storexi_fi_add_pat<store,           F64, anyimm, S2_storerd_io>;
2618   defm: Storexim_fi_add_pat<store, I1, anyimm, I1toI32, S2_storerb_io>;
2619
2620   def: Storexi_fi_pat<truncstorei8,     I32, S2_storerb_io>;
2621   def: Storexi_fi_pat<truncstorei16,    I32, S2_storerh_io>;
2622   def: Storexi_fi_pat<store,            I32, S2_storeri_io>;
2623   def: Storexi_fi_pat<store,           V4I8, S2_storeri_io>;
2624   def: Storexi_fi_pat<store,          V2I16, S2_storeri_io>;
2625   def: Storexi_fi_pat<store,            I64, S2_storerd_io>;
2626   def: Storexi_fi_pat<store,           V8I8, S2_storerd_io>;
2627   def: Storexi_fi_pat<store,          V4I16, S2_storerd_io>;
2628   def: Storexi_fi_pat<store,          V2I32, S2_storerd_io>;
2629   def: Storexi_fi_pat<store,            F32, S2_storeri_io>;
2630   def: Storexi_fi_pat<store,            F64, S2_storerd_io>;
2631   def: Storexim_fi_pat<store, I1, I1toI32, S2_storerb_io>;
2632 }
2633
2634
2635 multiclass IMRA_<PatFrag S, PatFrag V, PatFrag O, PatFrag M, InstHexagon I> {
2636   defm: Storexim_add_pat<S, V, O, M, I>;
2637 }
2638 multiclass IRA_<PatFrag S, PatFrag V, PatFrag O, InstHexagon I> {
2639   defm: Storexi_add_pat<S, V, O, I>;
2640 }
2641
2642 // Reg+Imm, store-immediate
2643 let AddedComplexity = 50 in {
2644   defm: IMRA_<truncstorei8,   anyint, u6_0ImmPred, ToImmByte, S4_storeirb_io>;
2645   defm: IMRA_<truncstorei16,  anyint, u6_1ImmPred, ToImmHalf, S4_storeirh_io>;
2646   defm: IMRA_<store,          anyint, u6_2ImmPred, ToImmWord, S4_storeiri_io>;
2647
2648   defm: IRA_<truncstorei8,    anyimm, u6_0ImmPred, S4_storeirb_io>;
2649   defm: IRA_<truncstorei16,   anyimm, u6_1ImmPred, S4_storeirh_io>;
2650   defm: IRA_<store,           anyimm, u6_2ImmPred, S4_storeiri_io>;
2651 }
2652
2653 // Reg+Imm, store-register
2654 let AddedComplexity = 40 in {
2655   defm: Storexi_pat<truncstorei8,     I32, anyimm0, S2_storerb_io>;
2656   defm: Storexi_pat<truncstorei16,    I32, anyimm1, S2_storerh_io>;
2657   defm: Storexi_pat<store,            I32, anyimm2, S2_storeri_io>;
2658   defm: Storexi_pat<store,           V4I8, anyimm2, S2_storeri_io>;
2659   defm: Storexi_pat<store,          V2I16, anyimm2, S2_storeri_io>;
2660   defm: Storexi_pat<store,            I64, anyimm3, S2_storerd_io>;
2661   defm: Storexi_pat<store,           V8I8, anyimm3, S2_storerd_io>;
2662   defm: Storexi_pat<store,          V4I16, anyimm3, S2_storerd_io>;
2663   defm: Storexi_pat<store,          V2I32, anyimm3, S2_storerd_io>;
2664   defm: Storexi_pat<store,            F32, anyimm2, S2_storeri_io>;
2665   defm: Storexi_pat<store,            F64, anyimm3, S2_storerd_io>;
2666
2667   defm: Storexim_pat<truncstorei8,  I64, anyimm0, LoReg,   S2_storerb_io>;
2668   defm: Storexim_pat<truncstorei16, I64, anyimm1, LoReg,   S2_storerh_io>;
2669   defm: Storexim_pat<truncstorei32, I64, anyimm2, LoReg,   S2_storeri_io>;
2670   defm: Storexim_pat<store,         I1,  anyimm0, I1toI32, S2_storerb_io>;
2671
2672   defm: Storexi_pat<AtomSt<atomic_store_8>,     I32, anyimm0, S2_storerb_io>;
2673   defm: Storexi_pat<AtomSt<atomic_store_16>,    I32, anyimm1, S2_storerh_io>;
2674   defm: Storexi_pat<AtomSt<atomic_store_32>,    I32, anyimm2, S2_storeri_io>;
2675   defm: Storexi_pat<AtomSt<atomic_store_32>,   V4I8, anyimm2, S2_storeri_io>;
2676   defm: Storexi_pat<AtomSt<atomic_store_32>,  V2I16, anyimm2, S2_storeri_io>;
2677   defm: Storexi_pat<AtomSt<atomic_store_64>,    I64, anyimm3, S2_storerd_io>;
2678   defm: Storexi_pat<AtomSt<atomic_store_64>,   V8I8, anyimm3, S2_storerd_io>;
2679   defm: Storexi_pat<AtomSt<atomic_store_64>,  V4I16, anyimm3, S2_storerd_io>;
2680   defm: Storexi_pat<AtomSt<atomic_store_64>,  V2I32, anyimm3, S2_storerd_io>;
2681 }
2682
2683 // Reg+Reg
2684 let AddedComplexity = 30 in {
2685   def: Storexr_add_pat<truncstorei8,    I32, S4_storerb_rr>;
2686   def: Storexr_add_pat<truncstorei16,   I32, S4_storerh_rr>;
2687   def: Storexr_add_pat<store,           I32, S4_storeri_rr>;
2688   def: Storexr_add_pat<store,          V4I8, S4_storeri_rr>;
2689   def: Storexr_add_pat<store,         V2I16, S4_storeri_rr>;
2690   def: Storexr_add_pat<store,           I64, S4_storerd_rr>;
2691   def: Storexr_add_pat<store,          V8I8, S4_storerd_rr>;
2692   def: Storexr_add_pat<store,         V4I16, S4_storerd_rr>;
2693   def: Storexr_add_pat<store,         V2I32, S4_storerd_rr>;
2694   def: Storexr_add_pat<store,           F32, S4_storeri_rr>;
2695   def: Storexr_add_pat<store,           F64, S4_storerd_rr>;
2696
2697   def: Pat<(store I1:$Pu, (add I32:$Rs, I32:$Rt)),
2698            (S4_storerb_rr IntRegs:$Rs, IntRegs:$Rt, 0, (I1toI32 I1:$Pu))>;
2699 }
2700
2701 // Reg, store-immediate
2702 let AddedComplexity = 20 in {
2703   def: Storexim_base_pat<truncstorei8,  anyint, ToImmByte, S4_storeirb_io>;
2704   def: Storexim_base_pat<truncstorei16, anyint, ToImmHalf, S4_storeirh_io>;
2705   def: Storexim_base_pat<store,         anyint, ToImmWord, S4_storeiri_io>;
2706
2707   def: Storexi_base_pat<truncstorei8,   anyimm, S4_storeirb_io>;
2708   def: Storexi_base_pat<truncstorei16,  anyimm, S4_storeirh_io>;
2709   def: Storexi_base_pat<store,          anyimm, S4_storeiri_io>;
2710 }
2711
2712 // Reg, store-register
2713 let AddedComplexity = 10 in {
2714   def: Storexi_base_pat<truncstorei8,     I32, S2_storerb_io>;
2715   def: Storexi_base_pat<truncstorei16,    I32, S2_storerh_io>;
2716   def: Storexi_base_pat<store,            I32, S2_storeri_io>;
2717   def: Storexi_base_pat<store,           V4I8, S2_storeri_io>;
2718   def: Storexi_base_pat<store,          V2I16, S2_storeri_io>;
2719   def: Storexi_base_pat<store,            I64, S2_storerd_io>;
2720   def: Storexi_base_pat<store,           V8I8, S2_storerd_io>;
2721   def: Storexi_base_pat<store,          V4I16, S2_storerd_io>;
2722   def: Storexi_base_pat<store,          V2I32, S2_storerd_io>;
2723   def: Storexi_base_pat<store,            F32, S2_storeri_io>;
2724   def: Storexi_base_pat<store,            F64, S2_storerd_io>;
2725
2726   def: Storexim_base_pat<truncstorei8,  I64, LoReg,   S2_storerb_io>;
2727   def: Storexim_base_pat<truncstorei16, I64, LoReg,   S2_storerh_io>;
2728   def: Storexim_base_pat<truncstorei32, I64, LoReg,   S2_storeri_io>;
2729   def: Storexim_base_pat<store,         I1,  I1toI32, S2_storerb_io>;
2730
2731   def: Storexi_base_pat<AtomSt<atomic_store_8>,     I32, S2_storerb_io>;
2732   def: Storexi_base_pat<AtomSt<atomic_store_16>,    I32, S2_storerh_io>;
2733   def: Storexi_base_pat<AtomSt<atomic_store_32>,    I32, S2_storeri_io>;
2734   def: Storexi_base_pat<AtomSt<atomic_store_32>,   V4I8, S2_storeri_io>;
2735   def: Storexi_base_pat<AtomSt<atomic_store_32>,  V2I16, S2_storeri_io>;
2736   def: Storexi_base_pat<AtomSt<atomic_store_64>,    I64, S2_storerd_io>;
2737   def: Storexi_base_pat<AtomSt<atomic_store_64>,   V8I8, S2_storerd_io>;
2738   def: Storexi_base_pat<AtomSt<atomic_store_64>,  V4I16, S2_storerd_io>;
2739   def: Storexi_base_pat<AtomSt<atomic_store_64>,  V2I32, S2_storerd_io>;
2740 }
2741
2742
2743 // --(14) Memop ----------------------------------------------------------
2744 //
2745
2746 def m5_0Imm8Pred : PatLeaf<(i32 imm), [{
2747   int8_t V = N->getSExtValue();
2748   return -32 < V && V <= -1;
2749 }]>;
2750
2751 def m5_0Imm16Pred : PatLeaf<(i32 imm), [{
2752   int16_t V = N->getSExtValue();
2753   return -32 < V && V <= -1;
2754 }]>;
2755
2756 def m5_0ImmPred  : PatLeaf<(i32 imm), [{
2757   int64_t V = N->getSExtValue();
2758   return -31 <= V && V <= -1;
2759 }]>;
2760
2761 def IsNPow2_8 : PatLeaf<(i32 imm), [{
2762   uint8_t NV = ~N->getZExtValue();
2763   return isPowerOf2_32(NV);
2764 }]>;
2765
2766 def IsNPow2_16 : PatLeaf<(i32 imm), [{
2767   uint16_t NV = ~N->getZExtValue();
2768   return isPowerOf2_32(NV);
2769 }]>;
2770
2771 def Log2_8 : SDNodeXForm<imm, [{
2772   uint8_t V = N->getZExtValue();
2773   return CurDAG->getTargetConstant(Log2_32(V), SDLoc(N), MVT::i32);
2774 }]>;
2775
2776 def Log2_16 : SDNodeXForm<imm, [{
2777   uint16_t V = N->getZExtValue();
2778   return CurDAG->getTargetConstant(Log2_32(V), SDLoc(N), MVT::i32);
2779 }]>;
2780
2781 def LogN2_8 : SDNodeXForm<imm, [{
2782   uint8_t NV = ~N->getZExtValue();
2783   return CurDAG->getTargetConstant(Log2_32(NV), SDLoc(N), MVT::i32);
2784 }]>;
2785
2786 def LogN2_16 : SDNodeXForm<imm, [{
2787   uint16_t NV = ~N->getZExtValue();
2788   return CurDAG->getTargetConstant(Log2_32(NV), SDLoc(N), MVT::i32);
2789 }]>;
2790
2791 def IdImm : SDNodeXForm<imm, [{ return SDValue(N, 0); }]>;
2792
2793 multiclass Memopxr_base_pat<PatFrag Load, PatFrag Store, SDNode Oper,
2794                             InstHexagon MI> {
2795   // Addr: i32
2796   def: Pat<(Store (Oper (Load I32:$Rs), I32:$A), I32:$Rs),
2797            (MI I32:$Rs, 0, I32:$A)>;
2798   // Addr: fi
2799   def: Pat<(Store (Oper (Load AddrFI:$Rs), I32:$A), AddrFI:$Rs),
2800            (MI AddrFI:$Rs, 0, I32:$A)>;
2801 }
2802
2803 multiclass Memopxr_add_pat<PatFrag Load, PatFrag Store, PatFrag ImmPred,
2804                            SDNode Oper, InstHexagon MI> {
2805   // Addr: i32
2806   def: Pat<(Store (Oper (Load (add I32:$Rs, ImmPred:$Off)), I32:$A),
2807                   (add I32:$Rs, ImmPred:$Off)),
2808            (MI I32:$Rs, imm:$Off, I32:$A)>;
2809   def: Pat<(Store (Oper (Load (IsOrAdd I32:$Rs, ImmPred:$Off)), I32:$A),
2810                   (IsOrAdd I32:$Rs, ImmPred:$Off)),
2811            (MI I32:$Rs, imm:$Off, I32:$A)>;
2812   // Addr: fi
2813   def: Pat<(Store (Oper (Load (add AddrFI:$Rs, ImmPred:$Off)), I32:$A),
2814                   (add AddrFI:$Rs, ImmPred:$Off)),
2815            (MI AddrFI:$Rs, imm:$Off, I32:$A)>;
2816   def: Pat<(Store (Oper (Load (IsOrAdd AddrFI:$Rs, ImmPred:$Off)), I32:$A),
2817                   (IsOrAdd AddrFI:$Rs, ImmPred:$Off)),
2818            (MI AddrFI:$Rs, imm:$Off, I32:$A)>;
2819 }
2820
2821 multiclass Memopxr_pat<PatFrag Load, PatFrag Store, PatFrag ImmPred,
2822                        SDNode Oper, InstHexagon MI> {
2823   let Predicates = [UseMEMOPS] in {
2824     defm: Memopxr_base_pat <Load, Store,          Oper, MI>;
2825     defm: Memopxr_add_pat  <Load, Store, ImmPred, Oper, MI>;
2826   }
2827 }
2828
2829 let AddedComplexity = 200 in {
2830   // add reg
2831   defm: Memopxr_pat<extloadi8, truncstorei8, u6_0ImmPred, add,
2832         /*anyext*/  L4_add_memopb_io>;
2833   defm: Memopxr_pat<sextloadi8, truncstorei8, u6_0ImmPred, add,
2834         /*sext*/    L4_add_memopb_io>;
2835   defm: Memopxr_pat<zextloadi8, truncstorei8, u6_0ImmPred, add,
2836         /*zext*/    L4_add_memopb_io>;
2837   defm: Memopxr_pat<extloadi16, truncstorei16, u6_1ImmPred, add,
2838         /*anyext*/  L4_add_memoph_io>;
2839   defm: Memopxr_pat<sextloadi16, truncstorei16, u6_1ImmPred, add,
2840         /*sext*/    L4_add_memoph_io>;
2841   defm: Memopxr_pat<zextloadi16, truncstorei16, u6_1ImmPred, add,
2842         /*zext*/    L4_add_memoph_io>;
2843   defm: Memopxr_pat<load, store, u6_2ImmPred, add, L4_add_memopw_io>;
2844
2845   // sub reg
2846   defm: Memopxr_pat<extloadi8, truncstorei8, u6_0ImmPred, sub,
2847         /*anyext*/  L4_sub_memopb_io>;
2848   defm: Memopxr_pat<sextloadi8, truncstorei8, u6_0ImmPred, sub,
2849         /*sext*/    L4_sub_memopb_io>;
2850   defm: Memopxr_pat<zextloadi8, truncstorei8, u6_0ImmPred, sub,
2851         /*zext*/    L4_sub_memopb_io>;
2852   defm: Memopxr_pat<extloadi16, truncstorei16, u6_1ImmPred, sub,
2853         /*anyext*/  L4_sub_memoph_io>;
2854   defm: Memopxr_pat<sextloadi16, truncstorei16, u6_1ImmPred, sub,
2855         /*sext*/    L4_sub_memoph_io>;
2856   defm: Memopxr_pat<zextloadi16, truncstorei16, u6_1ImmPred, sub,
2857         /*zext*/    L4_sub_memoph_io>;
2858   defm: Memopxr_pat<load, store, u6_2ImmPred, sub, L4_sub_memopw_io>;
2859
2860   // and reg
2861   defm: Memopxr_pat<extloadi8, truncstorei8, u6_0ImmPred, and,
2862         /*anyext*/  L4_and_memopb_io>;
2863   defm: Memopxr_pat<sextloadi8, truncstorei8, u6_0ImmPred, and,
2864         /*sext*/    L4_and_memopb_io>;
2865   defm: Memopxr_pat<zextloadi8, truncstorei8, u6_0ImmPred, and,
2866         /*zext*/    L4_and_memopb_io>;
2867   defm: Memopxr_pat<extloadi16, truncstorei16, u6_1ImmPred, and,
2868         /*anyext*/  L4_and_memoph_io>;
2869   defm: Memopxr_pat<sextloadi16, truncstorei16, u6_1ImmPred, and,
2870         /*sext*/    L4_and_memoph_io>;
2871   defm: Memopxr_pat<zextloadi16, truncstorei16, u6_1ImmPred, and,
2872         /*zext*/    L4_and_memoph_io>;
2873   defm: Memopxr_pat<load, store, u6_2ImmPred, and, L4_and_memopw_io>;
2874
2875   // or reg
2876   defm: Memopxr_pat<extloadi8, truncstorei8, u6_0ImmPred, or,
2877         /*anyext*/  L4_or_memopb_io>;
2878   defm: Memopxr_pat<sextloadi8, truncstorei8, u6_0ImmPred, or,
2879         /*sext*/    L4_or_memopb_io>;
2880   defm: Memopxr_pat<zextloadi8, truncstorei8, u6_0ImmPred, or,
2881         /*zext*/    L4_or_memopb_io>;
2882   defm: Memopxr_pat<extloadi16, truncstorei16, u6_1ImmPred, or,
2883         /*anyext*/  L4_or_memoph_io>;
2884   defm: Memopxr_pat<sextloadi16, truncstorei16, u6_1ImmPred, or,
2885         /*sext*/    L4_or_memoph_io>;
2886   defm: Memopxr_pat<zextloadi16, truncstorei16, u6_1ImmPred, or,
2887         /*zext*/    L4_or_memoph_io>;
2888   defm: Memopxr_pat<load, store, u6_2ImmPred, or, L4_or_memopw_io>;
2889 }
2890
2891
2892 multiclass Memopxi_base_pat<PatFrag Load, PatFrag Store, SDNode Oper,
2893                             PatFrag Arg, SDNodeXForm ArgMod, InstHexagon MI> {
2894   // Addr: i32
2895   def: Pat<(Store (Oper (Load I32:$Rs), Arg:$A), I32:$Rs),
2896            (MI I32:$Rs, 0, (ArgMod Arg:$A))>;
2897   // Addr: fi
2898   def: Pat<(Store (Oper (Load AddrFI:$Rs), Arg:$A), AddrFI:$Rs),
2899            (MI AddrFI:$Rs, 0, (ArgMod Arg:$A))>;
2900 }
2901
2902 multiclass Memopxi_add_pat<PatFrag Load, PatFrag Store, PatFrag ImmPred,
2903                            SDNode Oper, PatFrag Arg, SDNodeXForm ArgMod,
2904                            InstHexagon MI> {
2905   // Addr: i32
2906   def: Pat<(Store (Oper (Load (add I32:$Rs, ImmPred:$Off)), Arg:$A),
2907                   (add I32:$Rs, ImmPred:$Off)),
2908            (MI I32:$Rs, imm:$Off, (ArgMod Arg:$A))>;
2909   def: Pat<(Store (Oper (Load (IsOrAdd I32:$Rs, ImmPred:$Off)), Arg:$A),
2910                   (IsOrAdd I32:$Rs, ImmPred:$Off)),
2911            (MI I32:$Rs, imm:$Off, (ArgMod Arg:$A))>;
2912   // Addr: fi
2913   def: Pat<(Store (Oper (Load (add AddrFI:$Rs, ImmPred:$Off)), Arg:$A),
2914                   (add AddrFI:$Rs, ImmPred:$Off)),
2915            (MI AddrFI:$Rs, imm:$Off, (ArgMod Arg:$A))>;
2916   def: Pat<(Store (Oper (Load (IsOrAdd AddrFI:$Rs, ImmPred:$Off)), Arg:$A),
2917                   (IsOrAdd AddrFI:$Rs, ImmPred:$Off)),
2918            (MI AddrFI:$Rs, imm:$Off, (ArgMod Arg:$A))>;
2919 }
2920
2921 multiclass Memopxi_pat<PatFrag Load, PatFrag Store, PatFrag ImmPred,
2922                        SDNode Oper, PatFrag Arg, SDNodeXForm ArgMod,
2923                        InstHexagon MI> {
2924   let Predicates = [UseMEMOPS] in {
2925     defm: Memopxi_base_pat <Load, Store,          Oper, Arg, ArgMod, MI>;
2926     defm: Memopxi_add_pat  <Load, Store, ImmPred, Oper, Arg, ArgMod, MI>;
2927   }
2928 }
2929
2930 let AddedComplexity = 220 in {
2931   // add imm
2932   defm: Memopxi_pat<extloadi8, truncstorei8, u6_0ImmPred, add, u5_0ImmPred,
2933         /*anyext*/  IdImm, L4_iadd_memopb_io>;
2934   defm: Memopxi_pat<sextloadi8, truncstorei8, u6_0ImmPred, add, u5_0ImmPred,
2935         /*sext*/    IdImm, L4_iadd_memopb_io>;
2936   defm: Memopxi_pat<zextloadi8, truncstorei8, u6_0ImmPred, add, u5_0ImmPred,
2937         /*zext*/    IdImm, L4_iadd_memopb_io>;
2938   defm: Memopxi_pat<extloadi16, truncstorei16, u6_1ImmPred, add, u5_0ImmPred,
2939         /*anyext*/  IdImm, L4_iadd_memoph_io>;
2940   defm: Memopxi_pat<extloadi16, truncstorei16, u6_1ImmPred, add, u5_0ImmPred,
2941         /*sext*/    IdImm, L4_iadd_memoph_io>;
2942   defm: Memopxi_pat<extloadi16, truncstorei16, u6_1ImmPred, add, u5_0ImmPred,
2943         /*zext*/    IdImm, L4_iadd_memoph_io>;
2944   defm: Memopxi_pat<load, store, u6_2ImmPred, add, u5_0ImmPred, IdImm,
2945                     L4_iadd_memopw_io>;
2946   defm: Memopxi_pat<extloadi8, truncstorei8, u6_0ImmPred, sub, m5_0Imm8Pred,
2947         /*anyext*/  NegImm8, L4_iadd_memopb_io>;
2948   defm: Memopxi_pat<sextloadi8, truncstorei8, u6_0ImmPred, sub, m5_0Imm8Pred,
2949         /*sext*/    NegImm8, L4_iadd_memopb_io>;
2950   defm: Memopxi_pat<zextloadi8, truncstorei8, u6_0ImmPred, sub, m5_0Imm8Pred,
2951         /*zext*/    NegImm8, L4_iadd_memopb_io>;
2952   defm: Memopxi_pat<extloadi16, truncstorei16, u6_1ImmPred, sub, m5_0Imm16Pred,
2953         /*anyext*/  NegImm16, L4_iadd_memoph_io>;
2954   defm: Memopxi_pat<sextloadi16, truncstorei16, u6_1ImmPred, sub, m5_0Imm16Pred,
2955         /*sext*/    NegImm16, L4_iadd_memoph_io>;
2956   defm: Memopxi_pat<zextloadi16, truncstorei16, u6_1ImmPred, sub, m5_0Imm16Pred,
2957         /*zext*/    NegImm16, L4_iadd_memoph_io>;
2958   defm: Memopxi_pat<load, store, u6_2ImmPred, sub, m5_0ImmPred, NegImm32,
2959                     L4_iadd_memopw_io>;
2960
2961   // sub imm
2962   defm: Memopxi_pat<extloadi8, truncstorei8, u6_0ImmPred, sub, u5_0ImmPred,
2963         /*anyext*/  IdImm, L4_isub_memopb_io>;
2964   defm: Memopxi_pat<sextloadi8, truncstorei8, u6_0ImmPred, sub, u5_0ImmPred,
2965         /*sext*/    IdImm, L4_isub_memopb_io>;
2966   defm: Memopxi_pat<zextloadi8, truncstorei8, u6_0ImmPred, sub, u5_0ImmPred,
2967         /*zext*/    IdImm, L4_isub_memopb_io>;
2968   defm: Memopxi_pat<extloadi16, truncstorei16, u6_1ImmPred, sub, u5_0ImmPred,
2969         /*anyext*/  IdImm, L4_isub_memoph_io>;
2970   defm: Memopxi_pat<sextloadi16, truncstorei16, u6_1ImmPred, sub, u5_0ImmPred,
2971         /*sext*/    IdImm, L4_isub_memoph_io>;
2972   defm: Memopxi_pat<zextloadi16, truncstorei16, u6_1ImmPred, sub, u5_0ImmPred,
2973         /*zext*/    IdImm, L4_isub_memoph_io>;
2974   defm: Memopxi_pat<load, store, u6_2ImmPred, sub, u5_0ImmPred, IdImm,
2975                     L4_isub_memopw_io>;
2976   defm: Memopxi_pat<extloadi8, truncstorei8, u6_0ImmPred, add, m5_0Imm8Pred,
2977         /*anyext*/  NegImm8, L4_isub_memopb_io>;
2978   defm: Memopxi_pat<sextloadi8, truncstorei8, u6_0ImmPred, add, m5_0Imm8Pred,
2979         /*sext*/    NegImm8, L4_isub_memopb_io>;
2980   defm: Memopxi_pat<zextloadi8, truncstorei8, u6_0ImmPred, add, m5_0Imm8Pred,
2981         /*zext*/    NegImm8, L4_isub_memopb_io>;
2982   defm: Memopxi_pat<extloadi16, truncstorei16, u6_1ImmPred, add, m5_0Imm16Pred,
2983         /*anyext*/  NegImm16, L4_isub_memoph_io>;
2984   defm: Memopxi_pat<sextloadi16, truncstorei16, u6_1ImmPred, add, m5_0Imm16Pred,
2985         /*sext*/    NegImm16, L4_isub_memoph_io>;
2986   defm: Memopxi_pat<zextloadi16, truncstorei16, u6_1ImmPred, add, m5_0Imm16Pred,
2987         /*zext*/    NegImm16, L4_isub_memoph_io>;
2988   defm: Memopxi_pat<load, store, u6_2ImmPred, add, m5_0ImmPred, NegImm32,
2989                     L4_isub_memopw_io>;
2990
2991   // clrbit imm
2992   defm: Memopxi_pat<extloadi8, truncstorei8, u6_0ImmPred, and, IsNPow2_8,
2993         /*anyext*/  LogN2_8, L4_iand_memopb_io>;
2994   defm: Memopxi_pat<sextloadi8, truncstorei8, u6_0ImmPred, and, IsNPow2_8,
2995         /*sext*/    LogN2_8, L4_iand_memopb_io>;
2996   defm: Memopxi_pat<zextloadi8, truncstorei8, u6_0ImmPred, and, IsNPow2_8,
2997         /*zext*/    LogN2_8, L4_iand_memopb_io>;
2998   defm: Memopxi_pat<extloadi16, truncstorei16, u6_1ImmPred, and, IsNPow2_16,
2999         /*anyext*/  LogN2_16, L4_iand_memoph_io>;
3000   defm: Memopxi_pat<sextloadi16, truncstorei16, u6_1ImmPred, and, IsNPow2_16,
3001         /*sext*/    LogN2_16, L4_iand_memoph_io>;
3002   defm: Memopxi_pat<zextloadi16, truncstorei16, u6_1ImmPred, and, IsNPow2_16,
3003         /*zext*/    LogN2_16, L4_iand_memoph_io>;
3004   defm: Memopxi_pat<load, store, u6_2ImmPred, and, IsNPow2_32,
3005                     LogN2_32, L4_iand_memopw_io>;
3006
3007   // setbit imm
3008   defm: Memopxi_pat<extloadi8, truncstorei8, u6_0ImmPred, or, IsPow2_32,
3009         /*anyext*/  Log2_8, L4_ior_memopb_io>;
3010   defm: Memopxi_pat<sextloadi8, truncstorei8, u6_0ImmPred, or, IsPow2_32,
3011         /*sext*/    Log2_8, L4_ior_memopb_io>;
3012   defm: Memopxi_pat<zextloadi8, truncstorei8, u6_0ImmPred, or, IsPow2_32,
3013         /*zext*/    Log2_8, L4_ior_memopb_io>;
3014   defm: Memopxi_pat<extloadi16, truncstorei16, u6_1ImmPred, or, IsPow2_32,
3015         /*anyext*/  Log2_16, L4_ior_memoph_io>;
3016   defm: Memopxi_pat<sextloadi16, truncstorei16, u6_1ImmPred, or, IsPow2_32,
3017         /*sext*/    Log2_16, L4_ior_memoph_io>;
3018   defm: Memopxi_pat<zextloadi16, truncstorei16, u6_1ImmPred, or, IsPow2_32,
3019         /*zext*/    Log2_16, L4_ior_memoph_io>;
3020   defm: Memopxi_pat<load, store, u6_2ImmPred, or, IsPow2_32,
3021                     Log2_32, L4_ior_memopw_io>;
3022 }
3023
3024
3025 // --(15) Call -----------------------------------------------------------
3026 //
3027
3028 // Pseudo instructions.
3029 def SDT_SPCallSeqStart
3030   : SDCallSeqStart<[SDTCisVT<0, i32>, SDTCisVT<1, i32>]>;
3031 def SDT_SPCallSeqEnd
3032   : SDCallSeqEnd<[SDTCisVT<0, i32>, SDTCisVT<1, i32>]>;
3033
3034 def callseq_start: SDNode<"ISD::CALLSEQ_START", SDT_SPCallSeqStart,
3035                           [SDNPHasChain, SDNPOutGlue]>;
3036 def callseq_end:   SDNode<"ISD::CALLSEQ_END",   SDT_SPCallSeqEnd,
3037                           [SDNPHasChain, SDNPOptInGlue, SDNPOutGlue]>;
3038
3039 def SDT_SPCall: SDTypeProfile<0, 1, [SDTCisVT<0, i32>]>;
3040
3041 def HexagonTCRet: SDNode<"HexagonISD::TC_RETURN", SDT_SPCall,
3042                          [SDNPHasChain,  SDNPOptInGlue, SDNPVariadic]>;
3043 def callv3: SDNode<"HexagonISD::CALL", SDT_SPCall,
3044                    [SDNPHasChain, SDNPOptInGlue, SDNPOutGlue, SDNPVariadic]>;
3045 def callv3nr: SDNode<"HexagonISD::CALLnr", SDT_SPCall,
3046                      [SDNPHasChain, SDNPOptInGlue, SDNPOutGlue, SDNPVariadic]>;
3047
3048 def: Pat<(callseq_start timm:$amt, timm:$amt2),
3049          (ADJCALLSTACKDOWN imm:$amt, imm:$amt2)>;
3050 def: Pat<(callseq_end timm:$amt1, timm:$amt2),
3051          (ADJCALLSTACKUP imm:$amt1, imm:$amt2)>;
3052
3053 def: Pat<(HexagonTCRet tglobaladdr:$dst),   (PS_tailcall_i tglobaladdr:$dst)>;
3054 def: Pat<(HexagonTCRet texternalsym:$dst),  (PS_tailcall_i texternalsym:$dst)>;
3055 def: Pat<(HexagonTCRet I32:$dst),           (PS_tailcall_r I32:$dst)>;
3056
3057 def: Pat<(callv3 I32:$dst),                 (J2_callr I32:$dst)>;
3058 def: Pat<(callv3 tglobaladdr:$dst),         (J2_call tglobaladdr:$dst)>;
3059 def: Pat<(callv3 texternalsym:$dst),        (J2_call texternalsym:$dst)>;
3060 def: Pat<(callv3 tglobaltlsaddr:$dst),      (J2_call tglobaltlsaddr:$dst)>;
3061
3062 def: Pat<(callv3nr I32:$dst),               (PS_callr_nr I32:$dst)>;
3063 def: Pat<(callv3nr tglobaladdr:$dst),       (PS_call_nr tglobaladdr:$dst)>;
3064 def: Pat<(callv3nr texternalsym:$dst),      (PS_call_nr texternalsym:$dst)>;
3065
3066 def retflag : SDNode<"HexagonISD::RET_FLAG", SDTNone,
3067                      [SDNPHasChain, SDNPOptInGlue, SDNPVariadic]>;
3068 def eh_return: SDNode<"HexagonISD::EH_RETURN", SDTNone, [SDNPHasChain]>;
3069
3070 def: Pat<(retflag),   (PS_jmpret (i32 R31))>;
3071 def: Pat<(eh_return), (EH_RETURN_JMPR (i32 R31))>;
3072
3073
3074 // --(16) Branch ---------------------------------------------------------
3075 //
3076
3077 def: Pat<(br      bb:$dst),         (J2_jump  b30_2Imm:$dst)>;
3078 def: Pat<(brind   I32:$dst),        (J2_jumpr I32:$dst)>;
3079
3080 def: Pat<(brcond I1:$Pu, bb:$dst),
3081          (J2_jumpt I1:$Pu, bb:$dst)>;
3082 def: Pat<(brcond (not I1:$Pu), bb:$dst),
3083          (J2_jumpf I1:$Pu, bb:$dst)>;
3084 def: Pat<(brcond (i1 (setne I1:$Pu, -1)), bb:$dst),
3085          (J2_jumpf I1:$Pu, bb:$dst)>;
3086 def: Pat<(brcond (i1 (seteq I1:$Pu, 0)), bb:$dst),
3087          (J2_jumpf I1:$Pu, bb:$dst)>;
3088 def: Pat<(brcond (i1 (setne I1:$Pu, 0)), bb:$dst),
3089          (J2_jumpt I1:$Pu, bb:$dst)>;
3090
3091
3092 // --(17) Misc -----------------------------------------------------------
3093
3094
3095 // Generate code of the form 'C2_muxii(cmpbgtui(Rdd, C-1),0,1)'
3096 // for C code of the form r = (c>='0' && c<='9') ? 1 : 0.
3097 // The isdigit transformation relies on two 'clever' aspects:
3098 // 1) The data type is unsigned which allows us to eliminate a zero test after
3099 //    biasing the expression by 48. We are depending on the representation of
3100 //    the unsigned types, and semantics.
3101 // 2) The front end has converted <= 9 into < 10 on entry to LLVM.
3102 //
3103 // For the C code:
3104 //   retval = (c >= '0' && c <= '9') ? 1 : 0;
3105 // The code is transformed upstream of llvm into
3106 //   retval = (c-48) < 10 ? 1 : 0;
3107
3108 def u7_0PosImmPred : ImmLeaf<i32, [{
3109   // True if the immediate fits in an 7-bit unsigned field and is positive.
3110   return Imm > 0 && isUInt<7>(Imm);
3111 }]>;
3112
3113 let AddedComplexity = 139 in
3114 def: Pat<(i32 (zext (i1 (setult (and I32:$Rs, 255), u7_0PosImmPred:$u7)))),
3115          (C2_muxii (A4_cmpbgtui IntRegs:$Rs, (UDEC1 imm:$u7)), 0, 1)>;
3116
3117 let AddedComplexity = 100 in
3118 def: Pat<(or (or (shl (HexagonINSERT (i32 (zextloadi8 (add I32:$b, 2))),
3119                                      (i32 (extloadi8  (add I32:$b, 3))),
3120                                      24, 8),
3121                       (i32 16)),
3122                  (shl (i32 (zextloadi8 (add I32:$b, 1))), (i32 8))),
3123              (zextloadi8 I32:$b)),
3124          (A2_swiz (L2_loadri_io I32:$b, 0))>;
3125
3126
3127 // We need custom lowering of ISD::PREFETCH into HexagonISD::DCFETCH
3128 // because the SDNode ISD::PREFETCH has properties MayLoad and MayStore.
3129 // We don't really want either one here.
3130 def SDTHexagonDCFETCH: SDTypeProfile<0, 2, [SDTCisPtrTy<0>,SDTCisInt<1>]>;
3131 def HexagonDCFETCH: SDNode<"HexagonISD::DCFETCH", SDTHexagonDCFETCH,
3132                            [SDNPHasChain]>;
3133
3134 def: Pat<(HexagonDCFETCH IntRegs:$Rs, u11_3ImmPred:$u11_3),
3135          (Y2_dcfetchbo IntRegs:$Rs, imm:$u11_3)>;
3136 def: Pat<(HexagonDCFETCH (i32 (add IntRegs:$Rs, u11_3ImmPred:$u11_3)), (i32 0)),
3137          (Y2_dcfetchbo IntRegs:$Rs, imm:$u11_3)>;
3138
3139 def SDTHexagonALLOCA
3140   : SDTypeProfile<1, 2, [SDTCisVT<0, i32>, SDTCisVT<1, i32>]>;
3141 def HexagonALLOCA
3142   : SDNode<"HexagonISD::ALLOCA", SDTHexagonALLOCA, [SDNPHasChain]>;
3143
3144 def: Pat<(HexagonALLOCA I32:$Rs, (i32 imm:$A)),
3145          (PS_alloca IntRegs:$Rs, imm:$A)>;
3146
3147 def HexagonBARRIER: SDNode<"HexagonISD::BARRIER", SDTNone, [SDNPHasChain]>;
3148 def: Pat<(HexagonBARRIER), (Y2_barrier)>;
3149
3150 def: Pat<(trap), (PS_crash)>;
3151
3152 // Read cycle counter.
3153 def SDTInt64Leaf: SDTypeProfile<1, 0, [SDTCisVT<0, i64>]>;
3154 def HexagonREADCYCLE: SDNode<"HexagonISD::READCYCLE", SDTInt64Leaf,
3155   [SDNPHasChain]>;
3156
3157 def: Pat<(HexagonREADCYCLE), (A4_tfrcpp UPCYCLE)>;
3158
3159 // The declared return value of the store-locked intrinsics is i32, but
3160 // the instructions actually define i1. To avoid register copies from
3161 // IntRegs to PredRegs and back, fold the entire pattern checking the
3162 // result against true/false.
3163 let AddedComplexity = 100 in {
3164   def: Pat<(i1 (setne (int_hexagon_S2_storew_locked I32:$Rs, I32:$Rt), 0)),
3165            (S2_storew_locked I32:$Rs, I32:$Rt)>;
3166   def: Pat<(i1 (seteq (int_hexagon_S2_storew_locked I32:$Rs, I32:$Rt), 0)),
3167            (C2_not (S2_storew_locked I32:$Rs, I32:$Rt))>;
3168   def: Pat<(i1 (setne (int_hexagon_S4_stored_locked I32:$Rs, I64:$Rt), 0)),
3169            (S4_stored_locked I32:$Rs, I64:$Rt)>;
3170   def: Pat<(i1 (seteq (int_hexagon_S4_stored_locked I32:$Rs, I64:$Rt), 0)),
3171            (C2_not (S4_stored_locked I32:$Rs, I64:$Rt))>;
3172 }