contrib/llvm/lib/Target/Hexagon/HexagonPatterns.td

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