lib/Target/Hexagon/HexagonInstrInfo.td

   1 //==- HexagonInstrInfo.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 // This file describes the Hexagon instructions in TableGen format.
  11 //
  12 //===----------------------------------------------------------------------===//
  13
  14 include "HexagonInstrFormats.td"
  15 include "HexagonOperands.td"
  16
  17 // Multi-class for logical operators.
  18 multiclass ALU32_rr_ri<string OpcStr, SDNode OpNode> {
  19   def rr : ALU32_rr<(outs IntRegs:$dst), (ins IntRegs:$b, IntRegs:$c),
  20                  !strconcat("$dst = ", !strconcat(OpcStr, "($b, $c)")),
  21                  [(set (i32 IntRegs:$dst), (OpNode (i32 IntRegs:$b),
  22                                                    (i32 IntRegs:$c)))]>;
  23   def ri : ALU32_ri<(outs IntRegs:$dst), (ins s10Imm:$b, IntRegs:$c),
  24                  !strconcat("$dst = ", !strconcat(OpcStr, "(#$b, $c)")),
  25                  [(set (i32 IntRegs:$dst), (OpNode s10Imm:$b,
  26                                                    (i32 IntRegs:$c)))]>;
  27 }
  28
  29 // Multi-class for compare ops.
  30 let isCompare = 1 in {
  31 multiclass CMP64_rr<string OpcStr, PatFrag OpNode> {
  32   def rr : ALU64_rr<(outs PredRegs:$dst), (ins DoubleRegs:$b, DoubleRegs:$c),
  33                  !strconcat("$dst = ", !strconcat(OpcStr, "($b, $c)")),
  34                  [(set (i1 PredRegs:$dst),
  35                        (OpNode (i64 DoubleRegs:$b), (i64 DoubleRegs:$c)))]>;
  36 }
  37 multiclass CMP32_rr<string OpcStr, PatFrag OpNode> {
  38   def rr : ALU32_rr<(outs PredRegs:$dst), (ins IntRegs:$b, IntRegs:$c),
  39                  !strconcat("$dst = ", !strconcat(OpcStr, "($b, $c)")),
  40                  [(set (i1 PredRegs:$dst),
  41                        (OpNode (i32 IntRegs:$b), (i32 IntRegs:$c)))]>;
  42 }
  43
  44 multiclass CMP32_rr_ri_s10<string OpcStr, string CextOp, PatFrag OpNode> {
  45   let CextOpcode = CextOp in {
  46     let InputType = "reg" in
  47     def rr : ALU32_rr<(outs PredRegs:$dst), (ins IntRegs:$b, IntRegs:$c),
  48                    !strconcat("$dst = ", !strconcat(OpcStr, "($b, $c)")),
  49                    [(set (i1 PredRegs:$dst),
  50                          (OpNode (i32 IntRegs:$b), (i32 IntRegs:$c)))]>;
  51
  52     let isExtendable = 1, opExtendable = 2, isExtentSigned = 1,
  53     opExtentBits = 10, InputType = "imm" in
  54     def ri : ALU32_ri<(outs PredRegs:$dst), (ins IntRegs:$b, s10Ext:$c),
  55                    !strconcat("$dst = ", !strconcat(OpcStr, "($b, #$c)")),
  56                    [(set (i1 PredRegs:$dst),
  57                          (OpNode (i32 IntRegs:$b), s10ExtPred:$c))]>;
  58   }
  59 }
  60
  61 multiclass CMP32_rr_ri_u9<string OpcStr, string CextOp, PatFrag OpNode> {
  62   let CextOpcode = CextOp in {
  63     let InputType = "reg" in
  64     def rr : ALU32_rr<(outs PredRegs:$dst), (ins IntRegs:$b, IntRegs:$c),
  65                    !strconcat("$dst = ", !strconcat(OpcStr, "($b, $c)")),
  66                    [(set (i1 PredRegs:$dst),
  67                          (OpNode (i32 IntRegs:$b), (i32 IntRegs:$c)))]>;
  68
  69     let isExtendable = 1, opExtendable = 2, isExtentSigned = 0,
  70     opExtentBits = 9, InputType = "imm" in
  71     def ri : ALU32_ri<(outs PredRegs:$dst), (ins IntRegs:$b, u9Ext:$c),
  72                    !strconcat("$dst = ", !strconcat(OpcStr, "($b, #$c)")),
  73                    [(set (i1 PredRegs:$dst),
  74                          (OpNode (i32 IntRegs:$b), u9ExtPred:$c))]>;
  75   }
  76 }
  77
  78 multiclass CMP32_ri_u8<string OpcStr, PatFrag OpNode> {
  79 let isExtendable = 1, opExtendable = 2, isExtentSigned = 0, opExtentBits = 8 in
  80   def ri : ALU32_ri<(outs PredRegs:$dst), (ins IntRegs:$b, u8Ext:$c),
  81                  !strconcat("$dst = ", !strconcat(OpcStr, "($b, #$c)")),
  82                  [(set (i1 PredRegs:$dst), (OpNode (i32 IntRegs:$b),
  83                                                    u8ExtPred:$c))]>;
  84 }
  85
  86 multiclass CMP32_ri_s8<string OpcStr, PatFrag OpNode> {
  87 let isExtendable = 1, opExtendable = 2, isExtentSigned = 1, opExtentBits = 8 in
  88   def ri : ALU32_ri<(outs PredRegs:$dst), (ins IntRegs:$b, s8Ext:$c),
  89                  !strconcat("$dst = ", !strconcat(OpcStr, "($b, #$c)")),
  90                  [(set (i1 PredRegs:$dst), (OpNode (i32 IntRegs:$b),
  91                                                    s8ExtPred:$c))]>;
  92 }
  93 }
  94
  95 //===----------------------------------------------------------------------===//
  96 // ALU32/ALU (Instructions with register-register form)
  97 //===----------------------------------------------------------------------===//
  98 multiclass ALU32_Pbase<string mnemonic, bit isNot,
  99                        bit isPredNew> {
 100   let isPredicatedNew = isPredNew in
 101   def NAME : ALU32_rr<(outs IntRegs:$dst),
 102             (ins PredRegs:$src1, IntRegs:$src2, IntRegs: $src3),
 103             !if(isNot, "if (!$src1", "if ($src1")#!if(isPredNew,".new) $dst = ",
 104             ") $dst = ")#mnemonic#"($src2, $src3)",
 105             []>;
 106 }
 107
 108 multiclass ALU32_Pred<string mnemonic, bit PredNot> {
 109   let isPredicatedFalse = PredNot in {
 110     defm _c#NAME : ALU32_Pbase<mnemonic, PredNot, 0>;
 111     // Predicate new
 112     defm _cdn#NAME : ALU32_Pbase<mnemonic, PredNot, 1>;
 113   }
 114 }
 115
 116 let InputType = "reg" in
 117 multiclass ALU32_base<string mnemonic, string CextOp, SDNode OpNode> {
 118   let CextOpcode = CextOp, BaseOpcode = CextOp#_rr in {
 119     let isPredicable = 1 in
 120     def NAME : ALU32_rr<(outs IntRegs:$dst),
 121             (ins IntRegs:$src1, IntRegs:$src2),
 122             "$dst = "#mnemonic#"($src1, $src2)",
 123             [(set (i32 IntRegs:$dst), (OpNode (i32 IntRegs:$src1),
 124                                               (i32 IntRegs:$src2)))]>;
 125
 126     let neverHasSideEffects = 1, isPredicated = 1 in {
 127       defm Pt : ALU32_Pred<mnemonic, 0>;
 128       defm NotPt : ALU32_Pred<mnemonic, 1>;
 129     }
 130   }
 131 }
 132
 133 let isCommutable = 1 in {
 134   defm ADD_rr : ALU32_base<"add", "ADD", add>, ImmRegRel, PredNewRel;
 135   defm AND_rr : ALU32_base<"and", "AND", and>, ImmRegRel, PredNewRel;
 136   defm XOR_rr : ALU32_base<"xor", "XOR", xor>, ImmRegRel, PredNewRel;
 137   defm OR_rr  : ALU32_base<"or", "OR", or>, ImmRegRel, PredNewRel;
 138 }
 139
 140 defm SUB_rr : ALU32_base<"sub", "SUB", sub>, ImmRegRel, PredNewRel;
 141
 142 //===----------------------------------------------------------------------===//
 143 // ALU32/ALU (ADD with register-immediate form)
 144 //===----------------------------------------------------------------------===//
 145 multiclass ALU32ri_Pbase<string mnemonic, bit isNot, bit isPredNew> {
 146   let isPredicatedNew = isPredNew in
 147   def NAME : ALU32_ri<(outs IntRegs:$dst),
 148             (ins PredRegs:$src1, IntRegs:$src2, s8Ext: $src3),
 149             !if(isNot, "if (!$src1", "if ($src1")#!if(isPredNew,".new) $dst = ",
 150             ") $dst = ")#mnemonic#"($src2, #$src3)",
 151             []>;
 152 }
 153
 154 multiclass ALU32ri_Pred<string mnemonic, bit PredNot> {
 155   let isPredicatedFalse = PredNot in {
 156     defm _c#NAME : ALU32ri_Pbase<mnemonic, PredNot, 0>;
 157     // Predicate new
 158     defm _cdn#NAME : ALU32ri_Pbase<mnemonic, PredNot, 1>;
 159   }
 160 }
 161
 162 let isExtendable = 1, InputType = "imm" in
 163 multiclass ALU32ri_base<string mnemonic, string CextOp, SDNode OpNode> {
 164   let CextOpcode = CextOp, BaseOpcode = CextOp#_ri in {
 165     let opExtendable = 2, isExtentSigned = 1, opExtentBits = 16,
 166     isPredicable = 1 in
 167     def NAME : ALU32_ri<(outs IntRegs:$dst),
 168             (ins IntRegs:$src1, s16Ext:$src2),
 169             "$dst = "#mnemonic#"($src1, #$src2)",
 170             [(set (i32 IntRegs:$dst), (OpNode (i32 IntRegs:$src1),
 171                                               (s16ExtPred:$src2)))]>;
 172
 173     let opExtendable = 3, isExtentSigned = 1, opExtentBits = 8,
 174     neverHasSideEffects = 1, isPredicated = 1 in {
 175       defm Pt : ALU32ri_Pred<mnemonic, 0>;
 176       defm NotPt : ALU32ri_Pred<mnemonic, 1>;
 177     }
 178   }
 179 }
 180
 181 defm ADD_ri : ALU32ri_base<"add", "ADD", add>, ImmRegRel, PredNewRel;
 182
 183 let isExtendable = 1, opExtendable = 2, isExtentSigned = 1, opExtentBits = 10,
 184 CextOpcode = "OR", InputType = "imm" in
 185 def OR_ri : ALU32_ri<(outs IntRegs:$dst),
 186             (ins IntRegs:$src1, s10Ext:$src2),
 187             "$dst = or($src1, #$src2)",
 188             [(set (i32 IntRegs:$dst), (or (i32 IntRegs:$src1),
 189                                           s10ExtPred:$src2))]>, ImmRegRel;
 190
 191 def NOT_rr : ALU32_rr<(outs IntRegs:$dst),
 192             (ins IntRegs:$src1),
 193             "$dst = not($src1)",
 194             [(set (i32 IntRegs:$dst), (not (i32 IntRegs:$src1)))]>;
 195
 196 let isExtendable = 1, opExtendable = 2, isExtentSigned = 1, opExtentBits = 10,
 197 InputType = "imm", CextOpcode = "AND" in
 198 def AND_ri : ALU32_ri<(outs IntRegs:$dst),
 199             (ins IntRegs:$src1, s10Ext:$src2),
 200             "$dst = and($src1, #$src2)",
 201             [(set (i32 IntRegs:$dst), (and (i32 IntRegs:$src1),
 202                                            s10ExtPred:$src2))]>, ImmRegRel;
 203 // Negate.
 204 def NEG : ALU32_rr<(outs IntRegs:$dst), (ins IntRegs:$src1),
 205           "$dst = neg($src1)",
 206           [(set (i32 IntRegs:$dst), (ineg (i32 IntRegs:$src1)))]>;
 207 // Nop.
 208 let neverHasSideEffects = 1 in
 209 def NOP : ALU32_rr<(outs), (ins),
 210           "nop",
 211           []>;
 212
 213 // Rd32=sub(#s10,Rs32)
 214 let isExtendable = 1, opExtendable = 1, isExtentSigned = 1, opExtentBits = 10,
 215 CextOpcode = "SUB", InputType = "imm" in
 216 def SUB_ri : ALU32_ri<(outs IntRegs:$dst),
 217             (ins s10Ext:$src1, IntRegs:$src2),
 218             "$dst = sub(#$src1, $src2)",
 219             [(set IntRegs:$dst, (sub s10ExtPred:$src1, IntRegs:$src2))]>,
 220             ImmRegRel;
 221
 222
 223 multiclass TFR_Pred<bit PredNot> {
 224   let isPredicatedFalse = PredNot in {
 225     def _c#NAME : ALU32_rr<(outs IntRegs:$dst),
 226                            (ins PredRegs:$src1, IntRegs:$src2),
 227             !if(PredNot, "if (!$src1", "if ($src1")#") $dst = $src2",
 228             []>;
 229     // Predicate new
 230     let isPredicatedNew = 1 in
 231     def _cdn#NAME : ALU32_rr<(outs IntRegs:$dst),
 232                              (ins PredRegs:$src1, IntRegs:$src2),
 233             !if(PredNot, "if (!$src1", "if ($src1")#".new) $dst = $src2",
 234             []>;
 235   }
 236 }
 237
 238 let InputType = "reg", neverHasSideEffects = 1 in
 239 multiclass TFR_base<string CextOp> {
 240   let CextOpcode = CextOp, BaseOpcode = CextOp in {
 241     let isPredicable = 1 in
 242     def NAME : ALU32_rr<(outs IntRegs:$dst), (ins IntRegs:$src1),
 243             "$dst = $src1",
 244             []>;
 245
 246     let  isPredicated = 1 in {
 247       defm Pt : TFR_Pred<0>;
 248       defm NotPt : TFR_Pred<1>;
 249     }
 250   }
 251 }
 252
 253 class T_TFR64_Pred<bit PredNot, bit isPredNew>
 254             : ALU32_rr<(outs DoubleRegs:$dst),
 255                        (ins PredRegs:$src1, DoubleRegs:$src2),
 256             !if(PredNot, "if (!$src1", "if ($src1")#
 257             !if(isPredNew, ".new) ", ") ")#"$dst = $src2", []>
 258 {
 259     bits<5> dst;
 260     bits<2> src1;
 261     bits<5> src2;
 262
 263     let IClass = 0b1111;
 264     let Inst{27-24} = 0b1101;
 265     let Inst{13} = isPredNew;
 266     let Inst{7} = PredNot;
 267     let Inst{4-0} = dst;
 268     let Inst{6-5} = src1;
 269     let Inst{20-17} = src2{4-1};
 270     let Inst{16} = 0b1;
 271     let Inst{12-9} = src2{4-1};
 272     let Inst{8} = 0b0;
 273 }
 274
 275 multiclass TFR64_Pred<bit PredNot> {
 276   let isPredicatedFalse = PredNot in {
 277     def _c#NAME : T_TFR64_Pred<PredNot, 0>;
 278
 279     let isPredicatedNew = 1 in
 280     def _cdn#NAME : T_TFR64_Pred<PredNot, 1>; // Predicate new
 281   }
 282 }
 283
 284 let neverHasSideEffects = 1 in
 285 multiclass TFR64_base<string BaseName> {
 286   let BaseOpcode = BaseName in {
 287     let isPredicable = 1 in
 288     def NAME : ALU32Inst <(outs DoubleRegs:$dst),
 289                           (ins DoubleRegs:$src1),
 290                           "$dst = $src1" > {
 291         bits<5> dst;
 292         bits<5> src1;
 293
 294         let IClass = 0b1111;
 295         let Inst{27-23} = 0b01010;
 296         let Inst{4-0} = dst;
 297         let Inst{20-17} = src1{4-1};
 298         let Inst{16} = 0b1;
 299         let Inst{12-9} = src1{4-1};
 300         let Inst{8} = 0b0;
 301     }
 302
 303     let  isPredicated = 1 in {
 304       defm Pt : TFR64_Pred<0>;
 305       defm NotPt : TFR64_Pred<1>;
 306     }
 307   }
 308 }
 309
 310 multiclass TFRI_Pred<bit PredNot> {
 311   let isMoveImm = 1, isPredicatedFalse = PredNot in {
 312     def _c#NAME : ALU32_ri<(outs IntRegs:$dst),
 313                            (ins PredRegs:$src1, s12Ext:$src2),
 314             !if(PredNot, "if (!$src1", "if ($src1")#") $dst = #$src2",
 315             []>;
 316
 317     // Predicate new
 318     let isPredicatedNew = 1 in
 319     def _cdn#NAME : ALU32_rr<(outs IntRegs:$dst),
 320                              (ins PredRegs:$src1, s12Ext:$src2),
 321             !if(PredNot, "if (!$src1", "if ($src1")#".new) $dst = #$src2",
 322             []>;
 323   }
 324 }
 325
 326 let InputType = "imm", isExtendable = 1, isExtentSigned = 1 in
 327 multiclass TFRI_base<string CextOp> {
 328   let CextOpcode = CextOp, BaseOpcode = CextOp#I in {
 329     let isAsCheapAsAMove = 1 , opExtendable = 1, opExtentBits = 16,
 330     isMoveImm = 1, isPredicable = 1, isReMaterializable = 1 in
 331     def NAME : ALU32_ri<(outs IntRegs:$dst), (ins s16Ext:$src1),
 332             "$dst = #$src1",
 333             [(set (i32 IntRegs:$dst), s16ExtPred:$src1)]>;
 334
 335     let opExtendable = 2,  opExtentBits = 12, neverHasSideEffects = 1,
 336     isPredicated = 1 in {
 337       defm Pt    : TFRI_Pred<0>;
 338       defm NotPt : TFRI_Pred<1>;
 339     }
 340   }
 341 }
 342
 343 defm TFRI : TFRI_base<"TFR">, ImmRegRel, PredNewRel;
 344 defm TFR : TFR_base<"TFR">, ImmRegRel, PredNewRel;
 345 defm TFR64 : TFR64_base<"TFR64">, PredNewRel;
 346
 347 // Transfer control register.
 348 let neverHasSideEffects = 1 in
 349 def TFCR : CRInst<(outs CRRegs:$dst), (ins IntRegs:$src1),
 350            "$dst = $src1",
 351            []>;
 352 //===----------------------------------------------------------------------===//
 353 // ALU32/ALU -
 354 //===----------------------------------------------------------------------===//
 355
 356
 357 //===----------------------------------------------------------------------===//
 358 // ALU32/PERM +
 359 //===----------------------------------------------------------------------===//
 360
 361 // Combine.
 362
 363 def SDTHexagonI64I32I32 : SDTypeProfile<1, 2,
 364   [SDTCisVT<0, i64>, SDTCisVT<1, i32>, SDTCisSameAs<1, 2>]>;
 365
 366 def HexagonWrapperCombineII :
 367   SDNode<"HexagonISD::WrapperCombineII", SDTHexagonI64I32I32>;
 368 def HexagonWrapperCombineRR :
 369   SDNode<"HexagonISD::WrapperCombineRR", SDTHexagonI64I32I32>;
 370
 371 // Combines the two integer registers SRC1 and SRC2 into a double register.
 372 let isPredicable = 1 in
 373 def COMBINE_rr : ALU32_rr<(outs DoubleRegs:$dst), (ins IntRegs:$src1,
 374                                                        IntRegs:$src2),
 375   "$dst = combine($src1, $src2)",
 376   [(set (i64 DoubleRegs:$dst),
 377         (i64 (HexagonWrapperCombineRR (i32 IntRegs:$src1),
 378                                       (i32 IntRegs:$src2))))]>;
 379
 380 // Rd=combine(Rt.[HL], Rs.[HL])
 381 class COMBINE_halves<string A, string B>: ALU32_rr<(outs IntRegs:$dst),
 382                                                    (ins IntRegs:$src1,
 383                                                         IntRegs:$src2),
 384   "$dst = combine($src1."# A #", $src2."# B #")", []>;
 385
 386 let isPredicable = 1 in {
 387   def COMBINE_hh : COMBINE_halves<"H", "H">;
 388   def COMBINE_hl : COMBINE_halves<"H", "L">;
 389   def COMBINE_lh : COMBINE_halves<"L", "H">;
 390   def COMBINE_ll : COMBINE_halves<"L", "L">;
 391 }
 392
 393 def : Pat<(i32 (trunc (i64 (srl (i64 DoubleRegs:$a), (i32 16))))),
 394   (COMBINE_lh (EXTRACT_SUBREG (i64 DoubleRegs:$a), subreg_hireg),
 395               (EXTRACT_SUBREG (i64 DoubleRegs:$a), subreg_loreg))>;
 396
 397 // Combines the two immediates SRC1 and SRC2 into a double register.
 398 class COMBINE_imm<Operand imm1, Operand imm2, PatLeaf pat1, PatLeaf pat2> :
 399   ALU32_ii<(outs DoubleRegs:$dst), (ins imm1:$src1, imm2:$src2),
 400   "$dst = combine(#$src1, #$src2)",
 401   [(set (i64 DoubleRegs:$dst),
 402         (i64 (HexagonWrapperCombineII (i32 pat1:$src1), (i32 pat2:$src2))))]>;
 403
 404 let isExtendable = 1, opExtendable = 1, isExtentSigned = 1, opExtentBits = 8 in
 405 def COMBINE_Ii : COMBINE_imm<s8Ext, s8Imm, s8ExtPred, s8ImmPred>;
 406
 407 // Mux.
 408 def VMUX_prr64 : ALU64_rr<(outs DoubleRegs:$dst), (ins PredRegs:$src1,
 409                                                    DoubleRegs:$src2,
 410                                                    DoubleRegs:$src3),
 411             "$dst = vmux($src1, $src2, $src3)",
 412             []>;
 413
 414 let CextOpcode = "MUX", InputType = "reg" in
 415 def MUX_rr : ALU32_rr<(outs IntRegs:$dst), (ins PredRegs:$src1,
 416                                             IntRegs:$src2, IntRegs:$src3),
 417              "$dst = mux($src1, $src2, $src3)",
 418              [(set (i32 IntRegs:$dst),
 419                    (i32 (select (i1 PredRegs:$src1), (i32 IntRegs:$src2),
 420                                 (i32 IntRegs:$src3))))]>, ImmRegRel;
 421
 422 let isExtendable = 1, opExtendable = 2, isExtentSigned = 1, opExtentBits = 8,
 423 CextOpcode = "MUX", InputType = "imm" in
 424 def MUX_ir : ALU32_ir<(outs IntRegs:$dst), (ins PredRegs:$src1, s8Ext:$src2,
 425                                                 IntRegs:$src3),
 426              "$dst = mux($src1, #$src2, $src3)",
 427              [(set (i32 IntRegs:$dst),
 428                    (i32 (select (i1 PredRegs:$src1), s8ExtPred:$src2,
 429                                 (i32 IntRegs:$src3))))]>, ImmRegRel;
 430
 431 let isExtendable = 1, opExtendable = 3, isExtentSigned = 1, opExtentBits = 8,
 432 CextOpcode = "MUX", InputType = "imm" in
 433 def MUX_ri : ALU32_ri<(outs IntRegs:$dst), (ins PredRegs:$src1, IntRegs:$src2,
 434                                                 s8Ext:$src3),
 435              "$dst = mux($src1, $src2, #$src3)",
 436              [(set (i32 IntRegs:$dst),
 437                    (i32 (select (i1 PredRegs:$src1), (i32 IntRegs:$src2),
 438                                  s8ExtPred:$src3)))]>, ImmRegRel;
 439
 440 let isExtendable = 1, opExtendable = 2, isExtentSigned = 1, opExtentBits = 8 in
 441 def MUX_ii : ALU32_ii<(outs IntRegs:$dst), (ins PredRegs:$src1, s8Ext:$src2,
 442                                                 s8Imm:$src3),
 443              "$dst = mux($src1, #$src2, #$src3)",
 444              [(set (i32 IntRegs:$dst), (i32 (select (i1 PredRegs:$src1),
 445                                                     s8ExtPred:$src2,
 446                                                     s8ImmPred:$src3)))]>;
 447
 448 // ALU32 - aslh, asrh, sxtb, sxth, zxtb, zxth
 449 multiclass ALU32_2op_Pbase<string mnemonic, bit isNot, bit isPredNew> {
 450   let isPredicatedNew = isPredNew in
 451   def NAME : ALU32Inst<(outs IntRegs:$dst),
 452                        (ins PredRegs:$src1, IntRegs:$src2),
 453             !if(isNot, "if (!$src1", "if ($src1")#!if(isPredNew,".new) $dst = ",
 454             ") $dst = ")#mnemonic#"($src2)">,
 455             Requires<[HasV4T]>;
 456 }
 457
 458 multiclass ALU32_2op_Pred<string mnemonic, bit PredNot> {
 459   let isPredicatedFalse = PredNot in {
 460     defm _c#NAME : ALU32_2op_Pbase<mnemonic, PredNot, 0>;
 461     // Predicate new
 462     defm _cdn#NAME : ALU32_2op_Pbase<mnemonic, PredNot, 1>;
 463   }
 464 }
 465
 466 multiclass ALU32_2op_base<string mnemonic> {
 467   let BaseOpcode = mnemonic in {
 468     let isPredicable = 1, neverHasSideEffects = 1 in
 469     def NAME : ALU32Inst<(outs IntRegs:$dst),
 470                          (ins IntRegs:$src1),
 471             "$dst = "#mnemonic#"($src1)">;
 472
 473     let Predicates = [HasV4T], validSubTargets = HasV4SubT, isPredicated = 1,
 474     neverHasSideEffects = 1 in {
 475       defm Pt_V4    : ALU32_2op_Pred<mnemonic, 0>;
 476       defm NotPt_V4 : ALU32_2op_Pred<mnemonic, 1>;
 477     }
 478   }
 479 }
 480
 481 defm ASLH : ALU32_2op_base<"aslh">, PredNewRel;
 482 defm ASRH : ALU32_2op_base<"asrh">, PredNewRel;
 483 defm SXTB : ALU32_2op_base<"sxtb">, PredNewRel;
 484 defm SXTH : ALU32_2op_base<"sxth">,  PredNewRel;
 485 defm ZXTB : ALU32_2op_base<"zxtb">, PredNewRel;
 486 defm ZXTH : ALU32_2op_base<"zxth">,  PredNewRel;
 487
 488 def : Pat <(shl (i32 IntRegs:$src1), (i32 16)),
 489            (ASLH IntRegs:$src1)>;
 490
 491 def : Pat <(sra (i32 IntRegs:$src1), (i32 16)),
 492            (ASRH IntRegs:$src1)>;
 493
 494 def : Pat <(sext_inreg (i32 IntRegs:$src1), i8),
 495            (SXTB IntRegs:$src1)>;
 496
 497 def : Pat <(sext_inreg (i32 IntRegs:$src1), i16),
 498            (SXTH IntRegs:$src1)>;
 499
 500 //===----------------------------------------------------------------------===//
 501 // ALU32/PERM -
 502 //===----------------------------------------------------------------------===//
 503
 504
 505 //===----------------------------------------------------------------------===//
 506 // ALU32/PRED +
 507 //===----------------------------------------------------------------------===//
 508
 509 // Conditional combine.
 510 let neverHasSideEffects = 1, isPredicated = 1 in {
 511 def COMBINE_rr_cPt : ALU32_rr<(outs DoubleRegs:$dst),
 512             (ins PredRegs:$src1, IntRegs:$src2, IntRegs:$src3),
 513             "if ($src1) $dst = combine($src2, $src3)",
 514             []>;
 515
 516 let isPredicatedFalse = 1 in
 517 def COMBINE_rr_cNotPt : ALU32_rr<(outs DoubleRegs:$dst),
 518             (ins PredRegs:$src1, IntRegs:$src2, IntRegs:$src3),
 519             "if (!$src1) $dst = combine($src2, $src3)",
 520             []>;
 521
 522 let isPredicatedNew = 1 in
 523 def COMBINE_rr_cdnPt : ALU32_rr<(outs DoubleRegs:$dst),
 524             (ins PredRegs:$src1, IntRegs:$src2, IntRegs:$src3),
 525             "if ($src1.new) $dst = combine($src2, $src3)",
 526             []>;
 527
 528 let isPredicatedNew = 1, isPredicatedFalse = 1 in
 529 def COMBINE_rr_cdnNotPt : ALU32_rr<(outs DoubleRegs:$dst),
 530             (ins PredRegs:$src1, IntRegs:$src2, IntRegs:$src3),
 531             "if (!$src1.new) $dst = combine($src2, $src3)",
 532             []>;
 533 }
 534
 535 // Compare.
 536 defm CMPGTU : CMP32_rr_ri_u9<"cmp.gtu", "CMPGTU", setugt>, ImmRegRel;
 537 defm CMPGT : CMP32_rr_ri_s10<"cmp.gt", "CMPGT", setgt>, ImmRegRel;
 538 defm CMPLT : CMP32_rr<"cmp.lt", setlt>;
 539 defm CMPLTU : CMP32_rr<"cmp.ltu", setult>;
 540 defm CMPEQ : CMP32_rr_ri_s10<"cmp.eq", "CMPEQ", seteq>, ImmRegRel;
 541 defm CMPGE : CMP32_ri_s8<"cmp.ge", setge>;
 542 defm CMPGEU : CMP32_ri_u8<"cmp.geu", setuge>;
 543
 544 def CTLZ_rr : SInst<(outs IntRegs:$dst), (ins IntRegs:$src1),
 545     "$dst = cl0($src1)",
 546     [(set (i32 IntRegs:$dst), (ctlz (i32 IntRegs:$src1)))]>;
 547
 548 def CTTZ_rr : SInst<(outs IntRegs:$dst), (ins IntRegs:$src1),
 549     "$dst = ct0($src1)",
 550     [(set (i32 IntRegs:$dst), (cttz (i32 IntRegs:$src1)))]>;
 551
 552 def CTLZ64_rr : SInst<(outs IntRegs:$dst), (ins DoubleRegs:$src1),
 553     "$dst = cl0($src1)",
 554     [(set (i32 IntRegs:$dst), (i32 (trunc (ctlz (i64 DoubleRegs:$src1)))))]>;
 555
 556 def CTTZ64_rr : SInst<(outs IntRegs:$dst), (ins DoubleRegs:$src1),
 557     "$dst = ct0($src1)",
 558     [(set (i32 IntRegs:$dst), (i32 (trunc (cttz (i64 DoubleRegs:$src1)))))]>;
 559
 560 def TSTBIT_rr : SInst<(outs PredRegs:$dst), (ins IntRegs:$src1, IntRegs:$src2),
 561     "$dst = tstbit($src1, $src2)",
 562     [(set (i1 PredRegs:$dst),
 563           (setne (and (shl 1, (i32 IntRegs:$src2)), (i32 IntRegs:$src1)), 0))]>;
 564
 565 def TSTBIT_ri : SInst<(outs PredRegs:$dst), (ins IntRegs:$src1, u5Imm:$src2),
 566     "$dst = tstbit($src1, $src2)",
 567     [(set (i1 PredRegs:$dst),
 568           (setne (and (shl 1, (u5ImmPred:$src2)), (i32 IntRegs:$src1)), 0))]>;
 569
 570 //===----------------------------------------------------------------------===//
 571 // ALU32/PRED -
 572 //===----------------------------------------------------------------------===//
 573
 574
 575 //===----------------------------------------------------------------------===//
 576 // ALU64/ALU +
 577 //===----------------------------------------------------------------------===//
 578 // Add.
 579 def ADD64_rr : ALU64_rr<(outs DoubleRegs:$dst), (ins DoubleRegs:$src1,
 580                                                      DoubleRegs:$src2),
 581                "$dst = add($src1, $src2)",
 582                [(set (i64 DoubleRegs:$dst), (add (i64 DoubleRegs:$src1),
 583                                                  (i64 DoubleRegs:$src2)))]>;
 584
 585 // Add halfword.
 586
 587 // Compare.
 588 defm CMPEHexagon4 : CMP64_rr<"cmp.eq", seteq>;
 589 defm CMPGT64 : CMP64_rr<"cmp.gt", setgt>;
 590 defm CMPGTU64 : CMP64_rr<"cmp.gtu", setugt>;
 591
 592 // Logical operations.
 593 def AND_rr64 : ALU64_rr<(outs DoubleRegs:$dst), (ins DoubleRegs:$src1,
 594                                                      DoubleRegs:$src2),
 595                "$dst = and($src1, $src2)",
 596                [(set (i64 DoubleRegs:$dst), (and (i64 DoubleRegs:$src1),
 597                                                  (i64 DoubleRegs:$src2)))]>;
 598
 599 def OR_rr64 : ALU64_rr<(outs DoubleRegs:$dst), (ins DoubleRegs:$src1,
 600                                                     DoubleRegs:$src2),
 601               "$dst = or($src1, $src2)",
 602               [(set (i64 DoubleRegs:$dst), (or (i64 DoubleRegs:$src1),
 603                                                (i64 DoubleRegs:$src2)))]>;
 604
 605 def XOR_rr64 : ALU64_rr<(outs DoubleRegs:$dst), (ins DoubleRegs:$src1,
 606                                                      DoubleRegs:$src2),
 607                "$dst = xor($src1, $src2)",
 608                [(set (i64 DoubleRegs:$dst), (xor (i64 DoubleRegs:$src1),
 609                                                  (i64 DoubleRegs:$src2)))]>;
 610
 611 // Maximum.
 612 def MAXw_rr : ALU64_rr<(outs IntRegs:$dst), (ins IntRegs:$src1, IntRegs:$src2),
 613               "$dst = max($src2, $src1)",
 614               [(set (i32 IntRegs:$dst),
 615                     (i32 (select (i1 (setlt (i32 IntRegs:$src2),
 616                                             (i32 IntRegs:$src1))),
 617                                  (i32 IntRegs:$src1), (i32 IntRegs:$src2))))]>;
 618
 619 def MAXUw_rr : ALU64_rr<(outs IntRegs:$dst), (ins IntRegs:$src1, IntRegs:$src2),
 620               "$dst = maxu($src2, $src1)",
 621               [(set (i32 IntRegs:$dst),
 622                     (i32 (select (i1 (setult (i32 IntRegs:$src2),
 623                                              (i32 IntRegs:$src1))),
 624                                  (i32 IntRegs:$src1), (i32 IntRegs:$src2))))]>;
 625
 626 def MAXd_rr : ALU64_rr<(outs DoubleRegs:$dst), (ins DoubleRegs:$src1,
 627                                                     DoubleRegs:$src2),
 628               "$dst = max($src2, $src1)",
 629               [(set (i64 DoubleRegs:$dst),
 630                     (i64 (select (i1 (setlt (i64 DoubleRegs:$src2),
 631                                             (i64 DoubleRegs:$src1))),
 632                                  (i64 DoubleRegs:$src1),
 633                                  (i64 DoubleRegs:$src2))))]>;
 634
 635 def MAXUd_rr : ALU64_rr<(outs DoubleRegs:$dst), (ins DoubleRegs:$src1,
 636                                                      DoubleRegs:$src2),
 637               "$dst = maxu($src2, $src1)",
 638               [(set (i64 DoubleRegs:$dst),
 639                     (i64 (select (i1 (setult (i64 DoubleRegs:$src2),
 640                                              (i64 DoubleRegs:$src1))),
 641                                  (i64 DoubleRegs:$src1),
 642                                  (i64 DoubleRegs:$src2))))]>;
 643
 644 // Minimum.
 645 def MINw_rr : ALU64_rr<(outs IntRegs:$dst), (ins IntRegs:$src1, IntRegs:$src2),
 646               "$dst = min($src2, $src1)",
 647               [(set (i32 IntRegs:$dst),
 648                     (i32 (select (i1 (setgt (i32 IntRegs:$src2),
 649                                             (i32 IntRegs:$src1))),
 650                                  (i32 IntRegs:$src1), (i32 IntRegs:$src2))))]>;
 651
 652 def MINUw_rr : ALU64_rr<(outs IntRegs:$dst), (ins IntRegs:$src1, IntRegs:$src2),
 653               "$dst = minu($src2, $src1)",
 654               [(set (i32 IntRegs:$dst),
 655                     (i32 (select (i1 (setugt (i32 IntRegs:$src2),
 656                                              (i32 IntRegs:$src1))),
 657                                  (i32 IntRegs:$src1), (i32 IntRegs:$src2))))]>;
 658
 659 def MINd_rr : ALU64_rr<(outs DoubleRegs:$dst), (ins DoubleRegs:$src1,
 660                                                     DoubleRegs:$src2),
 661               "$dst = min($src2, $src1)",
 662               [(set (i64 DoubleRegs:$dst),
 663                     (i64 (select (i1 (setgt (i64 DoubleRegs:$src2),
 664                                             (i64 DoubleRegs:$src1))),
 665                                  (i64 DoubleRegs:$src1),
 666                                  (i64 DoubleRegs:$src2))))]>;
 667
 668 def MINUd_rr : ALU64_rr<(outs DoubleRegs:$dst), (ins DoubleRegs:$src1,
 669                                                      DoubleRegs:$src2),
 670               "$dst = minu($src2, $src1)",
 671               [(set (i64 DoubleRegs:$dst),
 672                     (i64 (select (i1 (setugt (i64 DoubleRegs:$src2),
 673                                              (i64 DoubleRegs:$src1))),
 674                                  (i64 DoubleRegs:$src1),
 675                                  (i64 DoubleRegs:$src2))))]>;
 676
 677 // Subtract.
 678 def SUB64_rr : ALU64_rr<(outs DoubleRegs:$dst), (ins DoubleRegs:$src1,
 679                                                      DoubleRegs:$src2),
 680                "$dst = sub($src1, $src2)",
 681                [(set (i64 DoubleRegs:$dst), (sub (i64 DoubleRegs:$src1),
 682                                                  (i64 DoubleRegs:$src2)))]>;
 683
 684 // Subtract halfword.
 685
 686 //===----------------------------------------------------------------------===//
 687 // ALU64/ALU -
 688 //===----------------------------------------------------------------------===//
 689
 690 //===----------------------------------------------------------------------===//
 691 // ALU64/BIT +
 692 //===----------------------------------------------------------------------===//
 693 //
 694 //===----------------------------------------------------------------------===//
 695 // ALU64/BIT -
 696 //===----------------------------------------------------------------------===//
 697
 698 //===----------------------------------------------------------------------===//
 699 // ALU64/PERM +
 700 //===----------------------------------------------------------------------===//
 701 //
 702 //===----------------------------------------------------------------------===//
 703 // ALU64/PERM -
 704 //===----------------------------------------------------------------------===//
 705
 706 //===----------------------------------------------------------------------===//
 707 // CR +
 708 //===----------------------------------------------------------------------===//
 709 // Logical reductions on predicates.
 710
 711 // Looping instructions.
 712
 713 // Pipelined looping instructions.
 714
 715 // Logical operations on predicates.
 716 def AND_pp : SInst<(outs PredRegs:$dst), (ins PredRegs:$src1, PredRegs:$src2),
 717              "$dst = and($src1, $src2)",
 718              [(set (i1 PredRegs:$dst), (and (i1 PredRegs:$src1),
 719                                             (i1 PredRegs:$src2)))]>;
 720
 721 let neverHasSideEffects = 1 in
 722 def AND_pnotp : SInst<(outs PredRegs:$dst), (ins PredRegs:$src1,
 723                                                  PredRegs:$src2),
 724                 "$dst = and($src1, !$src2)",
 725                 []>;
 726
 727 def ANY_pp : SInst<(outs PredRegs:$dst), (ins PredRegs:$src1),
 728              "$dst = any8($src1)",
 729              []>;
 730
 731 def ALL_pp : SInst<(outs PredRegs:$dst), (ins PredRegs:$src1),
 732              "$dst = all8($src1)",
 733              []>;
 734
 735 def VITPACK_pp : SInst<(outs IntRegs:$dst), (ins PredRegs:$src1,
 736                                                  PredRegs:$src2),
 737              "$dst = vitpack($src1, $src2)",
 738              []>;
 739
 740 def VALIGN_rrp : SInst<(outs DoubleRegs:$dst), (ins DoubleRegs:$src1,
 741                                                     DoubleRegs:$src2,
 742                                                     PredRegs:$src3),
 743              "$dst = valignb($src1, $src2, $src3)",
 744              []>;
 745
 746 def VSPLICE_rrp : SInst<(outs DoubleRegs:$dst), (ins DoubleRegs:$src1,
 747                                                      DoubleRegs:$src2,
 748                                                      PredRegs:$src3),
 749              "$dst = vspliceb($src1, $src2, $src3)",
 750              []>;
 751
 752 def MASK_p : SInst<(outs DoubleRegs:$dst), (ins PredRegs:$src1),
 753              "$dst = mask($src1)",
 754              []>;
 755
 756 def NOT_p : SInst<(outs PredRegs:$dst), (ins PredRegs:$src1),
 757              "$dst = not($src1)",
 758              [(set (i1 PredRegs:$dst), (not (i1 PredRegs:$src1)))]>;
 759
 760 def OR_pp : SInst<(outs PredRegs:$dst), (ins PredRegs:$src1, PredRegs:$src2),
 761             "$dst = or($src1, $src2)",
 762             [(set (i1 PredRegs:$dst), (or (i1 PredRegs:$src1),
 763                                           (i1 PredRegs:$src2)))]>;
 764
 765 def XOR_pp : SInst<(outs PredRegs:$dst), (ins PredRegs:$src1, PredRegs:$src2),
 766              "$dst = xor($src1, $src2)",
 767              [(set (i1 PredRegs:$dst), (xor (i1 PredRegs:$src1),
 768                                             (i1 PredRegs:$src2)))]>;
 769
 770
 771 // User control register transfer.
 772 //===----------------------------------------------------------------------===//
 773 // CR -
 774 //===----------------------------------------------------------------------===//
 775
 776
 777 //===----------------------------------------------------------------------===//
 778 // J +
 779 //===----------------------------------------------------------------------===//
 780 // Jump to address.
 781 let isBranch = 1, isTerminator=1, isBarrier = 1, isPredicable = 1 in {
 782   def JMP : JInst< (outs),
 783             (ins brtarget:$offset),
 784             "jump $offset",
 785             [(br bb:$offset)]>;
 786 }
 787
 788 // if (p0) jump
 789 let isBranch = 1, isTerminator=1, Defs = [PC],
 790     isPredicated = 1 in {
 791   def JMP_c : JInst< (outs),
 792                  (ins PredRegs:$src, brtarget:$offset),
 793                  "if ($src) jump $offset",
 794                  [(brcond (i1 PredRegs:$src), bb:$offset)]>;
 795 }
 796
 797 // if (!p0) jump
 798 let isBranch = 1, isTerminator=1, neverHasSideEffects = 1, Defs = [PC],
 799     isPredicated = 1 in {
 800   def JMP_cNot : JInst< (outs),
 801                     (ins PredRegs:$src, brtarget:$offset),
 802                     "if (!$src) jump $offset",
 803                     []>;
 804 }
 805
 806 let isTerminator = 1, isBranch = 1, neverHasSideEffects = 1, Defs = [PC],
 807     isPredicated = 1 in {
 808   def BRCOND : JInst < (outs), (ins PredRegs:$pred, brtarget:$dst),
 809                "if ($pred) jump $dst",
 810                []>;
 811 }
 812
 813 // Jump to address conditioned on new predicate.
 814 // if (p0) jump:t
 815 let isBranch = 1, isTerminator=1, neverHasSideEffects = 1, Defs = [PC],
 816     isPredicated = 1 in {
 817   def JMP_cdnPt : JInst< (outs),
 818                    (ins PredRegs:$src, brtarget:$offset),
 819                    "if ($src.new) jump:t $offset",
 820                    []>;
 821 }
 822
 823 // if (!p0) jump:t
 824 let isBranch = 1, isTerminator=1, neverHasSideEffects = 1, Defs = [PC],
 825     isPredicated = 1 in {
 826   def JMP_cdnNotPt : JInst< (outs),
 827                       (ins PredRegs:$src, brtarget:$offset),
 828                       "if (!$src.new) jump:t $offset",
 829                       []>;
 830 }
 831
 832 // Not taken.
 833 let isBranch = 1, isTerminator=1, neverHasSideEffects = 1, Defs = [PC],
 834     isPredicated = 1 in {
 835   def JMP_cdnPnt : JInst< (outs),
 836                     (ins PredRegs:$src, brtarget:$offset),
 837                     "if ($src.new) jump:nt $offset",
 838                     []>;
 839 }
 840
 841 // Not taken.
 842 let isBranch = 1, isTerminator=1, neverHasSideEffects = 1, Defs = [PC],
 843     isPredicated = 1 in {
 844   def JMP_cdnNotPnt : JInst< (outs),
 845                        (ins PredRegs:$src, brtarget:$offset),
 846                        "if (!$src.new) jump:nt $offset",
 847                        []>;
 848 }
 849 //===----------------------------------------------------------------------===//
 850 // J -
 851 //===----------------------------------------------------------------------===//
 852
 853 //===----------------------------------------------------------------------===//
 854 // JR +
 855 //===----------------------------------------------------------------------===//
 856 def retflag : SDNode<"HexagonISD::RET_FLAG", SDTNone,
 857                                [SDNPHasChain, SDNPOptInGlue, SDNPVariadic]>;
 858
 859 // Jump to address from register.
 860 let isPredicable =1, isReturn = 1, isTerminator = 1, isBarrier = 1,
 861   Defs = [PC], Uses = [R31] in {
 862   def JMPR: JRInst<(outs), (ins),
 863                    "jumpr r31",
 864                    [(retflag)]>;
 865 }
 866
 867 // Jump to address from register.
 868 let isReturn = 1, isTerminator = 1, isBarrier = 1, isPredicated = 1,
 869   Defs = [PC], Uses = [R31] in {
 870   def JMPR_cPt: JRInst<(outs), (ins PredRegs:$src1),
 871                        "if ($src1) jumpr r31",
 872                        []>;
 873 }
 874
 875 // Jump to address from register.
 876 let isReturn = 1, isTerminator = 1, isBarrier = 1, isPredicated = 1,
 877   Defs = [PC], Uses = [R31] in {
 878   def JMPR_cNotPt: JRInst<(outs), (ins PredRegs:$src1),
 879                           "if (!$src1) jumpr r31",
 880                           []>;
 881 }
 882
 883 //===----------------------------------------------------------------------===//
 884 // JR -
 885 //===----------------------------------------------------------------------===//
 886
 887 //===----------------------------------------------------------------------===//
 888 // LD +
 889 //===----------------------------------------------------------------------===//
 890 ///
 891 // Load -- MEMri operand
 892 multiclass LD_MEMri_Pbase<string mnemonic, RegisterClass RC,
 893                           bit isNot, bit isPredNew> {
 894   let isPredicatedNew = isPredNew in
 895   def NAME : LDInst2<(outs RC:$dst),
 896                        (ins PredRegs:$src1, MEMri:$addr),
 897             !if(isNot, "if (!$src1", "if ($src1")#!if(isPredNew, ".new) ",
 898             ") ")#"$dst = "#mnemonic#"($addr)",
 899             []>;
 900 }
 901
 902 multiclass LD_MEMri_Pred<string mnemonic, RegisterClass RC, bit PredNot> {
 903   let isPredicatedFalse = PredNot in {
 904     defm _c#NAME : LD_MEMri_Pbase<mnemonic, RC, PredNot, 0>;
 905     // Predicate new
 906     defm _cdn#NAME : LD_MEMri_Pbase<mnemonic, RC, PredNot, 1>;
 907   }
 908 }
 909
 910 let isExtendable = 1, neverHasSideEffects = 1 in
 911 multiclass LD_MEMri<string mnemonic, string CextOp, RegisterClass RC,
 912                     bits<5> ImmBits, bits<5> PredImmBits> {
 913
 914   let CextOpcode = CextOp, BaseOpcode = CextOp in {
 915     let opExtendable = 2, isExtentSigned = 1, opExtentBits = ImmBits,
 916         isPredicable = 1 in
 917       def NAME : LDInst2<(outs RC:$dst), (ins MEMri:$addr),
 918                    "$dst = "#mnemonic#"($addr)",
 919                    []>;
 920
 921     let opExtendable = 3, isExtentSigned = 0, opExtentBits = PredImmBits,
 922         isPredicated = 1 in {
 923       defm Pt : LD_MEMri_Pred<mnemonic, RC, 0 >;
 924       defm NotPt : LD_MEMri_Pred<mnemonic, RC, 1 >;
 925     }
 926   }
 927 }
 928
 929 let addrMode = BaseImmOffset, isMEMri = "true" in {
 930   defm LDrib: LD_MEMri < "memb", "LDrib", IntRegs, 11, 6>, AddrModeRel;
 931   defm LDriub: LD_MEMri < "memub" , "LDriub", IntRegs, 11, 6>, AddrModeRel;
 932   defm LDrih: LD_MEMri < "memh", "LDrih", IntRegs, 12, 7>, AddrModeRel;
 933   defm LDriuh: LD_MEMri < "memuh", "LDriuh", IntRegs, 12, 7>, AddrModeRel;
 934   defm LDriw: LD_MEMri < "memw", "LDriw", IntRegs, 13, 8>, AddrModeRel;
 935   defm LDrid: LD_MEMri < "memd", "LDrid", DoubleRegs, 14, 9>, AddrModeRel;
 936 }
 937
 938 def : Pat < (i32 (sextloadi8 ADDRriS11_0:$addr)),
 939             (LDrib ADDRriS11_0:$addr) >;
 940
 941 def : Pat < (i32 (zextloadi8 ADDRriS11_0:$addr)),
 942             (LDriub ADDRriS11_0:$addr) >;
 943
 944 def : Pat < (i32 (sextloadi16 ADDRriS11_1:$addr)),
 945             (LDrih ADDRriS11_1:$addr) >;
 946
 947 def : Pat < (i32 (zextloadi16 ADDRriS11_1:$addr)),
 948             (LDriuh ADDRriS11_1:$addr) >;
 949
 950 def : Pat < (i32 (load ADDRriS11_2:$addr)),
 951             (LDriw ADDRriS11_2:$addr) >;
 952
 953 def : Pat < (i64 (load ADDRriS11_3:$addr)),
 954             (LDrid ADDRriS11_3:$addr) >;
 955
 956
 957 // Load - Base with Immediate offset addressing mode
 958 multiclass LD_Idxd_Pbase<string mnemonic, RegisterClass RC, Operand predImmOp,
 959                         bit isNot, bit isPredNew> {
 960   let isPredicatedNew = isPredNew in
 961   def NAME : LDInst2<(outs RC:$dst),
 962                      (ins PredRegs:$src1, IntRegs:$src2, predImmOp:$src3),
 963             !if(isNot, "if (!$src1", "if ($src1")#!if(isPredNew, ".new) ",
 964             ") ")#"$dst = "#mnemonic#"($src2+#$src3)",
 965             []>;
 966 }
 967
 968 multiclass LD_Idxd_Pred<string mnemonic, RegisterClass RC, Operand predImmOp,
 969                         bit PredNot> {
 970   let isPredicatedFalse = PredNot in {
 971     defm _c#NAME : LD_Idxd_Pbase<mnemonic, RC, predImmOp, PredNot, 0>;
 972     // Predicate new
 973     defm _cdn#NAME : LD_Idxd_Pbase<mnemonic, RC, predImmOp, PredNot, 1>;
 974   }
 975 }
 976
 977 let isExtendable = 1, neverHasSideEffects = 1 in
 978 multiclass LD_Idxd<string mnemonic, string CextOp, RegisterClass RC,
 979                    Operand ImmOp, Operand predImmOp, bits<5> ImmBits,
 980                    bits<5> PredImmBits> {
 981
 982   let CextOpcode = CextOp, BaseOpcode = CextOp#_indexed in {
 983     let opExtendable = 2, isExtentSigned = 1, opExtentBits = ImmBits,
 984         isPredicable = 1, AddedComplexity = 20 in
 985       def NAME : LDInst2<(outs RC:$dst), (ins IntRegs:$src1, ImmOp:$offset),
 986                    "$dst = "#mnemonic#"($src1+#$offset)",
 987                    []>;
 988
 989     let opExtendable = 3, isExtentSigned = 0, opExtentBits = PredImmBits,
 990         isPredicated = 1 in {
 991       defm Pt : LD_Idxd_Pred<mnemonic, RC, predImmOp, 0 >;
 992       defm NotPt : LD_Idxd_Pred<mnemonic, RC, predImmOp, 1 >;
 993     }
 994   }
 995 }
 996
 997 let addrMode = BaseImmOffset in {
 998   defm LDrib_indexed: LD_Idxd <"memb", "LDrib", IntRegs, s11_0Ext, u6_0Ext,
 999                                11, 6>, AddrModeRel;
1000   defm LDriub_indexed: LD_Idxd <"memub" , "LDriub", IntRegs, s11_0Ext, u6_0Ext,
1001                                 11, 6>, AddrModeRel;
1002   defm LDrih_indexed: LD_Idxd <"memh", "LDrih", IntRegs, s11_1Ext, u6_1Ext,
1003                                12, 7>, AddrModeRel;
1004   defm LDriuh_indexed: LD_Idxd <"memuh", "LDriuh", IntRegs, s11_1Ext, u6_1Ext,
1005                                 12, 7>, AddrModeRel;
1006   defm LDriw_indexed: LD_Idxd <"memw", "LDriw", IntRegs, s11_2Ext, u6_2Ext,
1007                                13, 8>, AddrModeRel;
1008   defm LDrid_indexed: LD_Idxd <"memd", "LDrid", DoubleRegs, s11_3Ext, u6_3Ext,
1009                                14, 9>, AddrModeRel;
1010 }
1011
1012 let AddedComplexity = 20 in {
1013 def : Pat < (i32 (sextloadi8 (add IntRegs:$src1, s11_0ExtPred:$offset))),
1014             (LDrib_indexed IntRegs:$src1, s11_0ExtPred:$offset) >;
1015
1016 def : Pat < (i32 (zextloadi8 (add IntRegs:$src1, s11_0ExtPred:$offset))),
1017             (LDriub_indexed IntRegs:$src1, s11_0ExtPred:$offset) >;
1018
1019 def : Pat < (i32 (sextloadi16 (add IntRegs:$src1, s11_1ExtPred:$offset))),
1020             (LDrih_indexed IntRegs:$src1, s11_1ExtPred:$offset) >;
1021
1022 def : Pat < (i32 (zextloadi16 (add IntRegs:$src1, s11_1ExtPred:$offset))),
1023             (LDriuh_indexed IntRegs:$src1, s11_1ExtPred:$offset) >;
1024
1025 def : Pat < (i32 (load (add IntRegs:$src1, s11_2ExtPred:$offset))),
1026             (LDriw_indexed IntRegs:$src1, s11_2ExtPred:$offset) >;
1027
1028 def : Pat < (i64 (load (add IntRegs:$src1, s11_3ExtPred:$offset))),
1029             (LDrid_indexed IntRegs:$src1, s11_3ExtPred:$offset) >;
1030 }
1031
1032 //===----------------------------------------------------------------------===//
1033 // Post increment load
1034 // Make sure that in post increment load, the first operand is always the post
1035 // increment operand.
1036 //===----------------------------------------------------------------------===//
1037
1038 multiclass LD_PostInc_Pbase<string mnemonic, RegisterClass RC, Operand ImmOp,
1039                             bit isNot, bit isPredNew> {
1040   let isPredicatedNew = isPredNew in
1041   def NAME : LDInst2PI<(outs RC:$dst, IntRegs:$dst2),
1042                        (ins PredRegs:$src1, IntRegs:$src2, ImmOp:$offset),
1043             !if(isNot, "if (!$src1", "if ($src1")#!if(isPredNew, ".new) ",
1044             ") ")#"$dst = "#mnemonic#"($src2++#$offset)",
1045             [],
1046             "$src2 = $dst2">;
1047 }
1048
1049 multiclass LD_PostInc_Pred<string mnemonic, RegisterClass RC,
1050                            Operand ImmOp, bit PredNot> {
1051   let isPredicatedFalse = PredNot in {
1052     defm _c#NAME : LD_PostInc_Pbase<mnemonic, RC, ImmOp, PredNot, 0>;
1053     // Predicate new
1054     let Predicates = [HasV4T], validSubTargets = HasV4SubT in
1055     defm _cdn#NAME#_V4 : LD_PostInc_Pbase<mnemonic, RC, ImmOp, PredNot, 1>;
1056   }
1057 }
1058
1059 multiclass LD_PostInc<string mnemonic, string BaseOp, RegisterClass RC,
1060                       Operand ImmOp> {
1061
1062   let BaseOpcode = "POST_"#BaseOp in {
1063     let isPredicable = 1 in
1064     def NAME : LDInst2PI<(outs RC:$dst, IntRegs:$dst2),
1065                          (ins IntRegs:$src1, ImmOp:$offset),
1066                  "$dst = "#mnemonic#"($src1++#$offset)",
1067                  [],
1068                  "$src1 = $dst2">;
1069
1070     let isPredicated = 1 in {
1071       defm Pt : LD_PostInc_Pred<mnemonic, RC, ImmOp, 0 >;
1072       defm NotPt : LD_PostInc_Pred<mnemonic, RC, ImmOp, 1 >;
1073     }
1074   }
1075 }
1076
1077 let hasCtrlDep = 1, neverHasSideEffects = 1 in {
1078   defm POST_LDrib : LD_PostInc<"memb", "LDrib", IntRegs, s4_0Imm>,
1079                     PredNewRel;
1080   defm POST_LDriub : LD_PostInc<"memub", "LDriub", IntRegs, s4_0Imm>,
1081                     PredNewRel;
1082   defm POST_LDrih : LD_PostInc<"memh", "LDrih", IntRegs, s4_1Imm>,
1083                     PredNewRel;
1084   defm POST_LDriuh : LD_PostInc<"memuh", "LDriuh", IntRegs, s4_1Imm>,
1085                     PredNewRel;
1086   defm POST_LDriw : LD_PostInc<"memw", "LDriw", IntRegs, s4_2Imm>,
1087                     PredNewRel;
1088   defm POST_LDrid : LD_PostInc<"memd", "LDrid", DoubleRegs, s4_3Imm>,
1089                     PredNewRel;
1090 }
1091
1092 def : Pat< (i32 (extloadi1 ADDRriS11_0:$addr)),
1093            (i32 (LDrib ADDRriS11_0:$addr)) >;
1094
1095 // Load byte any-extend.
1096 def : Pat < (i32 (extloadi8 ADDRriS11_0:$addr)),
1097             (i32 (LDrib ADDRriS11_0:$addr)) >;
1098
1099 // Indexed load byte any-extend.
1100 let AddedComplexity = 20 in
1101 def : Pat < (i32 (extloadi8 (add IntRegs:$src1, s11_0ImmPred:$offset))),
1102             (i32 (LDrib_indexed IntRegs:$src1, s11_0ImmPred:$offset)) >;
1103
1104 def : Pat < (i32 (extloadi16 ADDRriS11_1:$addr)),
1105             (i32 (LDrih ADDRriS11_1:$addr))>;
1106
1107 let AddedComplexity = 20 in
1108 def : Pat < (i32 (extloadi16 (add IntRegs:$src1, s11_1ImmPred:$offset))),
1109             (i32 (LDrih_indexed IntRegs:$src1, s11_1ImmPred:$offset)) >;
1110
1111 let AddedComplexity = 10 in
1112 def : Pat < (i32 (zextloadi1 ADDRriS11_0:$addr)),
1113             (i32 (LDriub ADDRriS11_0:$addr))>;
1114
1115 let AddedComplexity = 20 in
1116 def : Pat < (i32 (zextloadi1 (add IntRegs:$src1, s11_0ImmPred:$offset))),
1117             (i32 (LDriub_indexed IntRegs:$src1, s11_0ImmPred:$offset))>;
1118
1119 // Load predicate.
1120 let isExtendable = 1, opExtendable = 2, isExtentSigned = 1, opExtentBits = 13,
1121 isPseudo = 1, Defs = [R10,R11,D5], neverHasSideEffects = 1 in
1122 def LDriw_pred : LDInst2<(outs PredRegs:$dst),
1123             (ins MEMri:$addr),
1124             "Error; should not emit",
1125             []>;
1126
1127 // Deallocate stack frame.
1128 let Defs = [R29, R30, R31], Uses = [R29], neverHasSideEffects = 1 in {
1129   def DEALLOCFRAME : LDInst2<(outs), (ins),
1130                      "deallocframe",
1131                      []>;
1132 }
1133
1134 // Load and unpack bytes to halfwords.
1135 //===----------------------------------------------------------------------===//
1136 // LD -
1137 //===----------------------------------------------------------------------===//
1138
1139 //===----------------------------------------------------------------------===//
1140 // MTYPE/ALU +
1141 //===----------------------------------------------------------------------===//
1142 //===----------------------------------------------------------------------===//
1143 // MTYPE/ALU -
1144 //===----------------------------------------------------------------------===//
1145
1146 //===----------------------------------------------------------------------===//
1147 // MTYPE/COMPLEX +
1148 //===----------------------------------------------------------------------===//
1149 //===----------------------------------------------------------------------===//
1150 // MTYPE/COMPLEX -
1151 //===----------------------------------------------------------------------===//
1152
1153 //===----------------------------------------------------------------------===//
1154 // MTYPE/MPYH +
1155 //===----------------------------------------------------------------------===//
1156 // Multiply and use lower result.
1157 // Rd=+mpyi(Rs,#u8)
1158 let isExtendable = 1, opExtendable = 2, isExtentSigned = 0, opExtentBits = 8 in
1159 def MPYI_riu : MInst<(outs IntRegs:$dst), (ins IntRegs:$src1, u8Ext:$src2),
1160               "$dst =+ mpyi($src1, #$src2)",
1161               [(set (i32 IntRegs:$dst), (mul (i32 IntRegs:$src1),
1162                                              u8ExtPred:$src2))]>;
1163
1164 // Rd=-mpyi(Rs,#u8)
1165 def MPYI_rin : MInst<(outs IntRegs:$dst), (ins IntRegs:$src1, u8Imm:$src2),
1166               "$dst =- mpyi($src1, #$src2)",
1167               [(set (i32 IntRegs:$dst), (ineg (mul (i32 IntRegs:$src1),
1168                                                    u8ImmPred:$src2)))]>;
1169
1170 // Rd=mpyi(Rs,#m9)
1171 // s9 is NOT the same as m9 - but it works.. so far.
1172 // Assembler maps to either Rd=+mpyi(Rs,#u8 or Rd=-mpyi(Rs,#u8)
1173 // depending on the value of m9. See Arch Spec.
1174 let isExtendable = 1, opExtendable = 2, isExtentSigned = 1, opExtentBits = 9,
1175 CextOpcode = "MPYI", InputType = "imm" in
1176 def MPYI_ri : MInst<(outs IntRegs:$dst), (ins IntRegs:$src1, s9Ext:$src2),
1177               "$dst = mpyi($src1, #$src2)",
1178               [(set (i32 IntRegs:$dst), (mul (i32 IntRegs:$src1),
1179                                              s9ExtPred:$src2))]>, ImmRegRel;
1180
1181 // Rd=mpyi(Rs,Rt)
1182 let CextOpcode = "MPYI", InputType = "reg" in
1183 def MPYI : MInst<(outs IntRegs:$dst), (ins IntRegs:$src1, IntRegs:$src2),
1184            "$dst = mpyi($src1, $src2)",
1185            [(set (i32 IntRegs:$dst), (mul (i32 IntRegs:$src1),
1186                                           (i32 IntRegs:$src2)))]>, ImmRegRel;
1187
1188 // Rx+=mpyi(Rs,#u8)
1189 let isExtendable = 1, opExtendable = 3, isExtentSigned = 0, opExtentBits = 8,
1190 CextOpcode = "MPYI_acc", InputType = "imm" in
1191 def MPYI_acc_ri : MInst_acc<(outs IntRegs:$dst),
1192             (ins IntRegs:$src1, IntRegs:$src2, u8Ext:$src3),
1193             "$dst += mpyi($src2, #$src3)",
1194             [(set (i32 IntRegs:$dst),
1195                   (add (mul (i32 IntRegs:$src2), u8ExtPred:$src3),
1196                        (i32 IntRegs:$src1)))],
1197             "$src1 = $dst">, ImmRegRel;
1198
1199 // Rx+=mpyi(Rs,Rt)
1200 let CextOpcode = "MPYI_acc", InputType = "reg" in
1201 def MPYI_acc_rr : MInst_acc<(outs IntRegs:$dst),
1202             (ins IntRegs:$src1, IntRegs:$src2, IntRegs:$src3),
1203             "$dst += mpyi($src2, $src3)",
1204             [(set (i32 IntRegs:$dst),
1205                   (add (mul (i32 IntRegs:$src2), (i32 IntRegs:$src3)),
1206                        (i32 IntRegs:$src1)))],
1207             "$src1 = $dst">, ImmRegRel;
1208
1209 // Rx-=mpyi(Rs,#u8)
1210 let isExtendable = 1, opExtendable = 3, isExtentSigned = 0, opExtentBits = 8 in
1211 def MPYI_sub_ri : MInst_acc<(outs IntRegs:$dst),
1212             (ins IntRegs:$src1, IntRegs:$src2, u8Ext:$src3),
1213             "$dst -= mpyi($src2, #$src3)",
1214             [(set (i32 IntRegs:$dst),
1215                   (sub (i32 IntRegs:$src1), (mul (i32 IntRegs:$src2),
1216                                                  u8ExtPred:$src3)))],
1217             "$src1 = $dst">;
1218
1219 // Multiply and use upper result.
1220 // Rd=mpy(Rs,Rt.H):<<1:rnd:sat
1221 // Rd=mpy(Rs,Rt.L):<<1:rnd:sat
1222 // Rd=mpy(Rs,Rt)
1223 def MPY : MInst<(outs IntRegs:$dst), (ins IntRegs:$src1, IntRegs:$src2),
1224           "$dst = mpy($src1, $src2)",
1225           [(set (i32 IntRegs:$dst), (mulhs (i32 IntRegs:$src1),
1226                                            (i32 IntRegs:$src2)))]>;
1227
1228 // Rd=mpy(Rs,Rt):rnd
1229 // Rd=mpyu(Rs,Rt)
1230 def MPYU : MInst<(outs IntRegs:$dst), (ins IntRegs:$src1, IntRegs:$src2),
1231            "$dst = mpyu($src1, $src2)",
1232            [(set (i32 IntRegs:$dst), (mulhu (i32 IntRegs:$src1),
1233                                             (i32 IntRegs:$src2)))]>;
1234
1235 // Multiply and use full result.
1236 // Rdd=mpyu(Rs,Rt)
1237 def MPYU64 : MInst<(outs DoubleRegs:$dst), (ins IntRegs:$src1, IntRegs:$src2),
1238              "$dst = mpyu($src1, $src2)",
1239              [(set (i64 DoubleRegs:$dst),
1240                    (mul (i64 (anyext (i32 IntRegs:$src1))),
1241                         (i64 (anyext (i32 IntRegs:$src2)))))]>;
1242
1243 // Rdd=mpy(Rs,Rt)
1244 def MPY64 : MInst<(outs DoubleRegs:$dst), (ins IntRegs:$src1, IntRegs:$src2),
1245              "$dst = mpy($src1, $src2)",
1246              [(set (i64 DoubleRegs:$dst),
1247                    (mul (i64 (sext (i32 IntRegs:$src1))),
1248                         (i64 (sext (i32 IntRegs:$src2)))))]>;
1249
1250 // Multiply and accumulate, use full result.
1251 // Rxx[+-]=mpy(Rs,Rt)
1252 // Rxx+=mpy(Rs,Rt)
1253 def MPY64_acc : MInst_acc<(outs DoubleRegs:$dst),
1254             (ins DoubleRegs:$src1, IntRegs:$src2, IntRegs:$src3),
1255             "$dst += mpy($src2, $src3)",
1256             [(set (i64 DoubleRegs:$dst),
1257             (add (mul (i64 (sext (i32 IntRegs:$src2))),
1258                       (i64 (sext (i32 IntRegs:$src3)))),
1259                  (i64 DoubleRegs:$src1)))],
1260             "$src1 = $dst">;
1261
1262 // Rxx-=mpy(Rs,Rt)
1263 def MPY64_sub : MInst_acc<(outs DoubleRegs:$dst),
1264             (ins DoubleRegs:$src1, IntRegs:$src2, IntRegs:$src3),
1265             "$dst -= mpy($src2, $src3)",
1266             [(set (i64 DoubleRegs:$dst),
1267                   (sub (i64 DoubleRegs:$src1),
1268                        (mul (i64 (sext (i32 IntRegs:$src2))),
1269                             (i64 (sext (i32 IntRegs:$src3))))))],
1270             "$src1 = $dst">;
1271
1272 // Rxx[+-]=mpyu(Rs,Rt)
1273 // Rxx+=mpyu(Rs,Rt)
1274 def MPYU64_acc : MInst_acc<(outs DoubleRegs:$dst), (ins DoubleRegs:$src1,
1275                             IntRegs:$src2, IntRegs:$src3),
1276              "$dst += mpyu($src2, $src3)",
1277              [(set (i64 DoubleRegs:$dst),
1278                    (add (mul (i64 (anyext (i32 IntRegs:$src2))),
1279                              (i64 (anyext (i32 IntRegs:$src3)))),
1280                         (i64 DoubleRegs:$src1)))], "$src1 = $dst">;
1281
1282 // Rxx-=mpyu(Rs,Rt)
1283 def MPYU64_sub : MInst_acc<(outs DoubleRegs:$dst),
1284             (ins DoubleRegs:$src1, IntRegs:$src2, IntRegs:$src3),
1285             "$dst -= mpyu($src2, $src3)",
1286             [(set (i64 DoubleRegs:$dst),
1287                   (sub (i64 DoubleRegs:$src1),
1288                        (mul (i64 (anyext (i32 IntRegs:$src2))),
1289                             (i64 (anyext (i32 IntRegs:$src3))))))],
1290             "$src1 = $dst">;
1291
1292
1293 let InputType = "reg", CextOpcode = "ADD_acc" in
1294 def ADDrr_acc : MInst_acc<(outs IntRegs: $dst), (ins IntRegs:$src1,
1295                             IntRegs:$src2, IntRegs:$src3),
1296              "$dst += add($src2, $src3)",
1297              [(set (i32 IntRegs:$dst), (add (add (i32 IntRegs:$src2),
1298                                                  (i32 IntRegs:$src3)),
1299                                             (i32 IntRegs:$src1)))],
1300              "$src1 = $dst">, ImmRegRel;
1301
1302 let isExtendable = 1, opExtendable = 3, isExtentSigned = 1, opExtentBits = 8,
1303 InputType = "imm", CextOpcode = "ADD_acc" in
1304 def ADDri_acc : MInst_acc<(outs IntRegs: $dst), (ins IntRegs:$src1,
1305                             IntRegs:$src2, s8Ext:$src3),
1306              "$dst += add($src2, #$src3)",
1307              [(set (i32 IntRegs:$dst), (add (add (i32 IntRegs:$src2),
1308                                                  s8_16ExtPred:$src3),
1309                                             (i32 IntRegs:$src1)))],
1310              "$src1 = $dst">, ImmRegRel;
1311
1312 let CextOpcode = "SUB_acc", InputType = "reg" in
1313 def SUBrr_acc : MInst_acc<(outs IntRegs: $dst), (ins IntRegs:$src1,
1314                             IntRegs:$src2, IntRegs:$src3),
1315              "$dst -= add($src2, $src3)",
1316              [(set (i32 IntRegs:$dst),
1317                    (sub (i32 IntRegs:$src1), (add (i32 IntRegs:$src2),
1318                                                   (i32 IntRegs:$src3))))],
1319              "$src1 = $dst">, ImmRegRel;
1320
1321 let isExtendable = 1, opExtendable = 3, isExtentSigned = 1, opExtentBits = 8,
1322 CextOpcode = "SUB_acc", InputType = "imm" in
1323 def SUBri_acc : MInst_acc<(outs IntRegs: $dst), (ins IntRegs:$src1,
1324                             IntRegs:$src2, s8Ext:$src3),
1325              "$dst -= add($src2, #$src3)",
1326              [(set (i32 IntRegs:$dst), (sub (i32 IntRegs:$src1),
1327                                             (add (i32 IntRegs:$src2),
1328                                                  s8_16ExtPred:$src3)))],
1329              "$src1 = $dst">, ImmRegRel;
1330
1331 //===----------------------------------------------------------------------===//
1332 // MTYPE/MPYH -
1333 //===----------------------------------------------------------------------===//
1334
1335 //===----------------------------------------------------------------------===//
1336 // MTYPE/MPYS +
1337 //===----------------------------------------------------------------------===//
1338 //===----------------------------------------------------------------------===//
1339 // MTYPE/MPYS -
1340 //===----------------------------------------------------------------------===//
1341
1342 //===----------------------------------------------------------------------===//
1343 // MTYPE/VB +
1344 //===----------------------------------------------------------------------===//
1345 //===----------------------------------------------------------------------===//
1346 // MTYPE/VB -
1347 //===----------------------------------------------------------------------===//
1348
1349 //===----------------------------------------------------------------------===//
1350 // MTYPE/VH  +
1351 //===----------------------------------------------------------------------===//
1352 //===----------------------------------------------------------------------===//
1353 // MTYPE/VH  -
1354 //===----------------------------------------------------------------------===//
1355
1356 //===----------------------------------------------------------------------===//
1357 // ST +
1358 //===----------------------------------------------------------------------===//
1359 ///
1360 // Store doubleword.
1361
1362 //===----------------------------------------------------------------------===//
1363 // Post increment store
1364 //===----------------------------------------------------------------------===//
1365
1366 multiclass ST_PostInc_Pbase<string mnemonic, RegisterClass RC, Operand ImmOp,
1367                             bit isNot, bit isPredNew> {
1368   let isPredicatedNew = isPredNew in
1369   def NAME : STInst2PI<(outs IntRegs:$dst),
1370             (ins PredRegs:$src1, IntRegs:$src2, ImmOp:$offset, RC:$src3),
1371             !if(isNot, "if (!$src1", "if ($src1")#!if(isPredNew, ".new) ",
1372             ") ")#mnemonic#"($src2++#$offset) = $src3",
1373             [],
1374             "$src2 = $dst">;
1375 }
1376
1377 multiclass ST_PostInc_Pred<string mnemonic, RegisterClass RC,
1378                            Operand ImmOp, bit PredNot> {
1379   let isPredicatedFalse = PredNot in {
1380     defm _c#NAME# : ST_PostInc_Pbase<mnemonic, RC, ImmOp, PredNot, 0>;
1381     // Predicate new
1382     let Predicates = [HasV4T], validSubTargets = HasV4SubT in
1383     defm _cdn#NAME#_V4 : ST_PostInc_Pbase<mnemonic, RC, ImmOp, PredNot, 1>;
1384   }
1385 }
1386
1387 let hasCtrlDep = 1, isNVStorable = 1, neverHasSideEffects = 1 in
1388 multiclass ST_PostInc<string mnemonic, string BaseOp, RegisterClass RC,
1389                       Operand ImmOp> {
1390
1391   let hasCtrlDep = 1, BaseOpcode = "POST_"#BaseOp in {
1392     let isPredicable = 1 in
1393     def NAME : STInst2PI<(outs IntRegs:$dst),
1394                 (ins IntRegs:$src1, ImmOp:$offset, RC:$src2),
1395                 #mnemonic#"($src1++#$offset) = $src2",
1396                 [],
1397                 "$src1 = $dst">;
1398
1399     let isPredicated = 1 in {
1400       defm Pt : ST_PostInc_Pred<mnemonic, RC, ImmOp, 0 >;
1401       defm NotPt : ST_PostInc_Pred<mnemonic, RC, ImmOp, 1 >;
1402     }
1403   }
1404 }
1405
1406 defm POST_STbri: ST_PostInc <"memb", "STrib", IntRegs, s4_0Imm>, AddrModeRel;
1407 defm POST_SThri: ST_PostInc <"memh", "STrih", IntRegs, s4_1Imm>, AddrModeRel;
1408 defm POST_STwri: ST_PostInc <"memw", "STriw", IntRegs, s4_2Imm>, AddrModeRel;
1409
1410 let isNVStorable = 0 in
1411 defm POST_STdri: ST_PostInc <"memd", "STrid", DoubleRegs, s4_3Imm>, AddrModeRel;
1412
1413 def : Pat<(post_truncsti8 (i32 IntRegs:$src1), IntRegs:$src2,
1414                            s4_3ImmPred:$offset),
1415           (POST_STbri IntRegs:$src2, s4_0ImmPred:$offset, IntRegs:$src1)>;
1416
1417 def : Pat<(post_truncsti16 (i32 IntRegs:$src1), IntRegs:$src2,
1418                             s4_3ImmPred:$offset),
1419           (POST_SThri IntRegs:$src2, s4_1ImmPred:$offset, IntRegs:$src1)>;
1420
1421 def : Pat<(post_store (i32 IntRegs:$src1), IntRegs:$src2, s4_2ImmPred:$offset),
1422           (POST_STwri IntRegs:$src2, s4_1ImmPred:$offset, IntRegs:$src1)>;
1423
1424 def : Pat<(post_store (i64 DoubleRegs:$src1), IntRegs:$src2,
1425                        s4_3ImmPred:$offset),
1426           (POST_STdri IntRegs:$src2, s4_3ImmPred:$offset, DoubleRegs:$src1)>;
1427
1428 //===----------------------------------------------------------------------===//
1429 // multiclass for the store instructions with MEMri operand.
1430 //===----------------------------------------------------------------------===//
1431 multiclass ST_MEMri_Pbase<string mnemonic, RegisterClass RC, bit isNot,
1432                           bit isPredNew> {
1433   let isPredicatedNew = isPredNew in
1434   def NAME : STInst2<(outs),
1435             (ins PredRegs:$src1, MEMri:$addr, RC: $src2),
1436             !if(isNot, "if (!$src1", "if ($src1")#!if(isPredNew, ".new) ",
1437             ") ")#mnemonic#"($addr) = $src2",
1438             []>;
1439 }
1440
1441 multiclass ST_MEMri_Pred<string mnemonic, RegisterClass RC, bit PredNot> {
1442   let isPredicatedFalse = PredNot in {
1443     defm _c#NAME : ST_MEMri_Pbase<mnemonic, RC, PredNot, 0>;
1444
1445     // Predicate new
1446     let validSubTargets = HasV4SubT, Predicates = [HasV4T] in
1447     defm _cdn#NAME#_V4 : ST_MEMri_Pbase<mnemonic, RC, PredNot, 1>;
1448   }
1449 }
1450
1451 let isExtendable = 1, isNVStorable = 1, neverHasSideEffects = 1 in
1452 multiclass ST_MEMri<string mnemonic, string CextOp, RegisterClass RC,
1453                     bits<5> ImmBits, bits<5> PredImmBits> {
1454
1455   let CextOpcode = CextOp, BaseOpcode = CextOp in {
1456     let opExtendable = 1, isExtentSigned = 1, opExtentBits = ImmBits,
1457          isPredicable = 1 in
1458     def NAME : STInst2<(outs),
1459             (ins MEMri:$addr, RC:$src),
1460             mnemonic#"($addr) = $src",
1461             []>;
1462
1463     let opExtendable = 2, isExtentSigned = 0, opExtentBits = PredImmBits,
1464         isPredicated = 1 in {
1465       defm Pt : ST_MEMri_Pred<mnemonic, RC, 0>;
1466       defm NotPt : ST_MEMri_Pred<mnemonic, RC, 1>;
1467     }
1468   }
1469 }
1470
1471 let addrMode = BaseImmOffset, isMEMri = "true" in {
1472   defm STrib: ST_MEMri < "memb", "STrib", IntRegs, 11, 6>, AddrModeRel;
1473   defm STrih: ST_MEMri < "memh", "STrih", IntRegs, 12, 7>, AddrModeRel;
1474   defm STriw: ST_MEMri < "memw", "STriw", IntRegs, 13, 8>, AddrModeRel;
1475
1476   let isNVStorable = 0 in
1477   defm STrid: ST_MEMri < "memd", "STrid", DoubleRegs, 14, 9>, AddrModeRel;
1478 }
1479
1480 def : Pat<(truncstorei8 (i32 IntRegs:$src1), ADDRriS11_0:$addr),
1481           (STrib ADDRriS11_0:$addr, (i32 IntRegs:$src1))>;
1482
1483 def : Pat<(truncstorei16 (i32 IntRegs:$src1), ADDRriS11_1:$addr),
1484           (STrih ADDRriS11_1:$addr, (i32 IntRegs:$src1))>;
1485
1486 def : Pat<(store (i32 IntRegs:$src1), ADDRriS11_2:$addr),
1487           (STriw ADDRriS11_2:$addr, (i32 IntRegs:$src1))>;
1488
1489 def : Pat<(store (i64 DoubleRegs:$src1), ADDRriS11_3:$addr),
1490           (STrid ADDRriS11_3:$addr, (i64 DoubleRegs:$src1))>;
1491
1492
1493 //===----------------------------------------------------------------------===//
1494 // multiclass for the store instructions with base+immediate offset
1495 // addressing mode
1496 //===----------------------------------------------------------------------===//
1497 multiclass ST_Idxd_Pbase<string mnemonic, RegisterClass RC, Operand predImmOp,
1498                         bit isNot, bit isPredNew> {
1499   let isPredicatedNew = isPredNew in
1500   def NAME : STInst2<(outs),
1501             (ins PredRegs:$src1, IntRegs:$src2, predImmOp:$src3, RC: $src4),
1502             !if(isNot, "if (!$src1", "if ($src1")#!if(isPredNew, ".new) ",
1503             ") ")#mnemonic#"($src2+#$src3) = $src4",
1504             []>;
1505 }
1506
1507 multiclass ST_Idxd_Pred<string mnemonic, RegisterClass RC, Operand predImmOp,
1508                         bit PredNot> {
1509   let isPredicatedFalse = PredNot, isPredicated = 1 in {
1510     defm _c#NAME : ST_Idxd_Pbase<mnemonic, RC, predImmOp, PredNot, 0>;
1511
1512     // Predicate new
1513     let validSubTargets = HasV4SubT, Predicates = [HasV4T] in
1514     defm _cdn#NAME#_V4 : ST_Idxd_Pbase<mnemonic, RC, predImmOp, PredNot, 1>;
1515   }
1516 }
1517
1518 let isExtendable = 1, isNVStorable = 1, neverHasSideEffects = 1 in
1519 multiclass ST_Idxd<string mnemonic, string CextOp, RegisterClass RC,
1520                    Operand ImmOp, Operand predImmOp, bits<5> ImmBits,
1521                    bits<5> PredImmBits> {
1522
1523   let CextOpcode = CextOp, BaseOpcode = CextOp#_indexed in {
1524     let opExtendable = 1, isExtentSigned = 1, opExtentBits = ImmBits,
1525          isPredicable = 1 in
1526     def NAME : STInst2<(outs),
1527             (ins IntRegs:$src1, ImmOp:$src2, RC:$src3),
1528             mnemonic#"($src1+#$src2) = $src3",
1529             []>;
1530
1531     let opExtendable = 2, isExtentSigned = 0, opExtentBits = PredImmBits in {
1532       defm Pt : ST_Idxd_Pred<mnemonic, RC, predImmOp, 0>;
1533       defm NotPt : ST_Idxd_Pred<mnemonic, RC, predImmOp, 1>;
1534     }
1535   }
1536 }
1537
1538 let addrMode = BaseImmOffset, InputType = "reg" in {
1539   defm STrib_indexed: ST_Idxd < "memb", "STrib", IntRegs, s11_0Ext,
1540                                 u6_0Ext, 11, 6>, AddrModeRel, ImmRegRel;
1541   defm STrih_indexed: ST_Idxd < "memh", "STrih", IntRegs, s11_1Ext,
1542                                 u6_1Ext, 12, 7>, AddrModeRel, ImmRegRel;
1543   defm STriw_indexed: ST_Idxd < "memw", "STriw", IntRegs, s11_2Ext,
1544                                 u6_2Ext, 13, 8>, AddrModeRel, ImmRegRel;
1545   let isNVStorable = 0 in
1546   defm STrid_indexed: ST_Idxd < "memd", "STrid", DoubleRegs, s11_3Ext,
1547                                 u6_3Ext, 14, 9>, AddrModeRel;
1548 }
1549
1550 let AddedComplexity = 10 in {
1551 def : Pat<(truncstorei8 (i32 IntRegs:$src1), (add IntRegs:$src2,
1552                                                   s11_0ExtPred:$offset)),
1553           (STrib_indexed IntRegs:$src2, s11_0ImmPred:$offset,
1554                          (i32 IntRegs:$src1))>;
1555
1556 def : Pat<(truncstorei16 (i32 IntRegs:$src1), (add IntRegs:$src2,
1557                                                    s11_1ExtPred:$offset)),
1558           (STrih_indexed IntRegs:$src2, s11_1ImmPred:$offset,
1559                          (i32 IntRegs:$src1))>;
1560
1561 def : Pat<(store (i32 IntRegs:$src1), (add IntRegs:$src2,
1562                                            s11_2ExtPred:$offset)),
1563           (STriw_indexed IntRegs:$src2, s11_2ImmPred:$offset,
1564                          (i32 IntRegs:$src1))>;
1565
1566 def : Pat<(store (i64 DoubleRegs:$src1), (add IntRegs:$src2,
1567                                               s11_3ExtPred:$offset)),
1568           (STrid_indexed IntRegs:$src2, s11_3ImmPred:$offset,
1569                          (i64 DoubleRegs:$src1))>;
1570 }
1571
1572 // memh(Rx++#s4:1)=Rt.H
1573
1574 // Store word.
1575 // Store predicate.
1576 let Defs = [R10,R11,D5], neverHasSideEffects = 1 in
1577 def STriw_pred : STInst2<(outs),
1578             (ins MEMri:$addr, PredRegs:$src1),
1579             "Error; should not emit",
1580             []>;
1581
1582 // Allocate stack frame.
1583 let Defs = [R29, R30], Uses = [R31, R30], neverHasSideEffects = 1 in {
1584   def ALLOCFRAME : STInst2<(outs),
1585              (ins i32imm:$amt),
1586              "allocframe(#$amt)",
1587              []>;
1588 }
1589 //===----------------------------------------------------------------------===//
1590 // ST -
1591 //===----------------------------------------------------------------------===//
1592
1593 //===----------------------------------------------------------------------===//
1594 // STYPE/ALU +
1595 //===----------------------------------------------------------------------===//
1596 // Logical NOT.
1597 def NOT_rr64 : ALU64_rr<(outs DoubleRegs:$dst), (ins DoubleRegs:$src1),
1598                "$dst = not($src1)",
1599                [(set (i64 DoubleRegs:$dst), (not (i64 DoubleRegs:$src1)))]>;
1600
1601
1602 // Sign extend word to doubleword.
1603 def SXTW : ALU64_rr<(outs DoubleRegs:$dst), (ins IntRegs:$src1),
1604            "$dst = sxtw($src1)",
1605            [(set (i64 DoubleRegs:$dst), (sext (i32 IntRegs:$src1)))]>;
1606 //===----------------------------------------------------------------------===//
1607 // STYPE/ALU -
1608 //===----------------------------------------------------------------------===//
1609
1610 //===----------------------------------------------------------------------===//
1611 // STYPE/BIT +
1612 //===----------------------------------------------------------------------===//
1613 // clrbit.
1614 def CLRBIT : ALU64_rr<(outs IntRegs:$dst), (ins IntRegs:$src1, u5Imm:$src2),
1615             "$dst = clrbit($src1, #$src2)",
1616             [(set (i32 IntRegs:$dst), (and (i32 IntRegs:$src1),
1617                                            (not
1618                                               (shl 1, u5ImmPred:$src2))))]>;
1619
1620 def CLRBIT_31 : ALU64_rr<(outs IntRegs:$dst), (ins IntRegs:$src1, u5Imm:$src2),
1621             "$dst = clrbit($src1, #$src2)",
1622             []>;
1623
1624 // Map from r0 = and(r1, 2147483647) to r0 = clrbit(r1, #31).
1625 def : Pat <(and (i32 IntRegs:$src1), 2147483647),
1626       (CLRBIT_31 (i32 IntRegs:$src1), 31)>;
1627
1628 // setbit.
1629 def SETBIT : ALU64_rr<(outs IntRegs:$dst), (ins IntRegs:$src1, u5Imm:$src2),
1630             "$dst = setbit($src1, #$src2)",
1631             [(set (i32 IntRegs:$dst), (or (i32 IntRegs:$src1),
1632                                           (shl 1, u5ImmPred:$src2)))]>;
1633
1634 // Map from r0 = or(r1, -2147483648) to r0 = setbit(r1, #31).
1635 def SETBIT_31 : ALU64_rr<(outs IntRegs:$dst), (ins IntRegs:$src1, u5Imm:$src2),
1636             "$dst = setbit($src1, #$src2)",
1637             []>;
1638
1639 def : Pat <(or (i32 IntRegs:$src1), -2147483648),
1640       (SETBIT_31 (i32 IntRegs:$src1), 31)>;
1641
1642 // togglebit.
1643 def TOGBIT : ALU64_rr<(outs IntRegs:$dst), (ins IntRegs:$src1, u5Imm:$src2),
1644             "$dst = setbit($src1, #$src2)",
1645             [(set (i32 IntRegs:$dst), (xor (i32 IntRegs:$src1),
1646                                           (shl 1, u5ImmPred:$src2)))]>;
1647
1648 // Map from r0 = xor(r1, -2147483648) to r0 = togglebit(r1, #31).
1649 def TOGBIT_31 : ALU64_rr<(outs IntRegs:$dst), (ins IntRegs:$src1, u5Imm:$src2),
1650             "$dst = togglebit($src1, #$src2)",
1651             []>;
1652
1653 def : Pat <(xor (i32 IntRegs:$src1), -2147483648),
1654       (TOGBIT_31 (i32 IntRegs:$src1), 31)>;
1655
1656 // Predicate transfer.
1657 let neverHasSideEffects = 1 in
1658 def TFR_RsPd : SInst<(outs IntRegs:$dst), (ins PredRegs:$src1),
1659                "$dst = $src1  /* Should almost never emit this. */",
1660                []>;
1661
1662 def TFR_PdRs : SInst<(outs PredRegs:$dst), (ins IntRegs:$src1),
1663                "$dst = $src1  /* Should almost never emit this. */",
1664                [(set (i1 PredRegs:$dst), (trunc (i32 IntRegs:$src1)))]>;
1665 //===----------------------------------------------------------------------===//
1666 // STYPE/PRED -
1667 //===----------------------------------------------------------------------===//
1668
1669 //===----------------------------------------------------------------------===//
1670 // STYPE/SHIFT +
1671 //===----------------------------------------------------------------------===//
1672 // Shift by immediate.
1673 def ASR_ri : SInst<(outs IntRegs:$dst), (ins IntRegs:$src1, u5Imm:$src2),
1674              "$dst = asr($src1, #$src2)",
1675              [(set (i32 IntRegs:$dst), (sra (i32 IntRegs:$src1),
1676                                             u5ImmPred:$src2))]>;
1677
1678 def ASRd_ri : SInst<(outs DoubleRegs:$dst), (ins DoubleRegs:$src1, u6Imm:$src2),
1679               "$dst = asr($src1, #$src2)",
1680               [(set (i64 DoubleRegs:$dst), (sra (i64 DoubleRegs:$src1),
1681                                                 u6ImmPred:$src2))]>;
1682
1683 def ASL : SInst<(outs IntRegs:$dst), (ins IntRegs:$src1, u5Imm:$src2),
1684           "$dst = asl($src1, #$src2)",
1685           [(set (i32 IntRegs:$dst), (shl (i32 IntRegs:$src1),
1686                                          u5ImmPred:$src2))]>;
1687
1688 def ASLd_ri : SInst<(outs DoubleRegs:$dst), (ins DoubleRegs:$src1, u6Imm:$src2),
1689               "$dst = asl($src1, #$src2)",
1690               [(set (i64 DoubleRegs:$dst), (shl (i64 DoubleRegs:$src1),
1691                                                 u6ImmPred:$src2))]>;
1692
1693 def LSR_ri : SInst<(outs IntRegs:$dst), (ins IntRegs:$src1, u5Imm:$src2),
1694              "$dst = lsr($src1, #$src2)",
1695              [(set (i32 IntRegs:$dst), (srl (i32 IntRegs:$src1),
1696                                             u5ImmPred:$src2))]>;
1697
1698 def LSRd_ri : SInst<(outs DoubleRegs:$dst), (ins DoubleRegs:$src1, u6Imm:$src2),
1699               "$dst = lsr($src1, #$src2)",
1700               [(set (i64 DoubleRegs:$dst), (srl (i64 DoubleRegs:$src1),
1701                                                 u6ImmPred:$src2))]>;
1702
1703 // Shift by immediate and add.
1704 let AddedComplexity = 100 in
1705 def ADDASL : SInst<(outs IntRegs:$dst), (ins IntRegs:$src1, IntRegs:$src2,
1706                                              u3Imm:$src3),
1707              "$dst = addasl($src1, $src2, #$src3)",
1708              [(set (i32 IntRegs:$dst), (add (i32 IntRegs:$src1),
1709                                        (shl (i32 IntRegs:$src2),
1710                                             u3ImmPred:$src3)))]>;
1711
1712 // Shift by register.
1713 def ASL_rr : SInst<(outs IntRegs:$dst), (ins IntRegs:$src1, IntRegs:$src2),
1714              "$dst = asl($src1, $src2)",
1715              [(set (i32 IntRegs:$dst), (shl (i32 IntRegs:$src1),
1716                                             (i32 IntRegs:$src2)))]>;
1717
1718 def ASR_rr : SInst<(outs IntRegs:$dst), (ins IntRegs:$src1, IntRegs:$src2),
1719              "$dst = asr($src1, $src2)",
1720              [(set (i32 IntRegs:$dst), (sra (i32 IntRegs:$src1),
1721                                             (i32 IntRegs:$src2)))]>;
1722
1723 def LSL_rr : SInst<(outs IntRegs:$dst), (ins IntRegs:$src1, IntRegs:$src2),
1724              "$dst = lsl($src1, $src2)",
1725              [(set (i32 IntRegs:$dst), (shl (i32 IntRegs:$src1),
1726                                             (i32 IntRegs:$src2)))]>;
1727
1728 def LSR_rr : SInst<(outs IntRegs:$dst), (ins IntRegs:$src1, IntRegs:$src2),
1729              "$dst = lsr($src1, $src2)",
1730              [(set (i32 IntRegs:$dst), (srl (i32 IntRegs:$src1),
1731                                             (i32 IntRegs:$src2)))]>;
1732
1733 def ASLd : SInst<(outs DoubleRegs:$dst), (ins DoubleRegs:$src1, IntRegs:$src2),
1734            "$dst = asl($src1, $src2)",
1735            [(set (i64 DoubleRegs:$dst), (shl (i64 DoubleRegs:$src1),
1736                                              (i32 IntRegs:$src2)))]>;
1737
1738 def LSLd : SInst<(outs DoubleRegs:$dst), (ins DoubleRegs:$src1, IntRegs:$src2),
1739            "$dst = lsl($src1, $src2)",
1740            [(set (i64 DoubleRegs:$dst), (shl (i64 DoubleRegs:$src1),
1741                                              (i32 IntRegs:$src2)))]>;
1742
1743 def ASRd_rr : SInst<(outs DoubleRegs:$dst), (ins DoubleRegs:$src1,
1744                                                  IntRegs:$src2),
1745               "$dst = asr($src1, $src2)",
1746               [(set (i64 DoubleRegs:$dst), (sra (i64 DoubleRegs:$src1),
1747                                                 (i32 IntRegs:$src2)))]>;
1748
1749 def LSRd_rr : SInst<(outs DoubleRegs:$dst), (ins DoubleRegs:$src1,
1750                                                  IntRegs:$src2),
1751               "$dst = lsr($src1, $src2)",
1752               [(set (i64 DoubleRegs:$dst), (srl (i64 DoubleRegs:$src1),
1753                                                 (i32 IntRegs:$src2)))]>;
1754
1755 //===----------------------------------------------------------------------===//
1756 // STYPE/SHIFT -
1757 //===----------------------------------------------------------------------===//
1758
1759 //===----------------------------------------------------------------------===//
1760 // STYPE/VH +
1761 //===----------------------------------------------------------------------===//
1762 //===----------------------------------------------------------------------===//
1763 // STYPE/VH -
1764 //===----------------------------------------------------------------------===//
1765
1766 //===----------------------------------------------------------------------===//
1767 // STYPE/VW +
1768 //===----------------------------------------------------------------------===//
1769 //===----------------------------------------------------------------------===//
1770 // STYPE/VW -
1771 //===----------------------------------------------------------------------===//
1772
1773 //===----------------------------------------------------------------------===//
1774 // SYSTEM/SUPER +
1775 //===----------------------------------------------------------------------===//
1776
1777 //===----------------------------------------------------------------------===//
1778 // SYSTEM/USER +
1779 //===----------------------------------------------------------------------===//
1780 def SDHexagonBARRIER: SDTypeProfile<0, 0, []>;
1781 def HexagonBARRIER: SDNode<"HexagonISD::BARRIER", SDHexagonBARRIER,
1782                            [SDNPHasChain]>;
1783
1784 let hasSideEffects = 1, isSolo = 1 in
1785 def BARRIER : SYSInst<(outs), (ins),
1786                      "barrier",
1787                      [(HexagonBARRIER)]>;
1788
1789 //===----------------------------------------------------------------------===//
1790 // SYSTEM/SUPER -
1791 //===----------------------------------------------------------------------===//
1792
1793 // TFRI64 - assembly mapped.
1794 let isReMaterializable = 1 in
1795 def TFRI64 : ALU64_rr<(outs DoubleRegs:$dst), (ins s8Imm64:$src1),
1796              "$dst = #$src1",
1797              [(set (i64 DoubleRegs:$dst), s8Imm64Pred:$src1)]>;
1798
1799 // Pseudo instruction to encode a set of conditional transfers.
1800 // This instruction is used instead of a mux and trades-off codesize
1801 // for performance. We conduct this transformation optimistically in
1802 // the hope that these instructions get promoted to dot-new transfers.
1803 let AddedComplexity = 100, isPredicated = 1 in
1804 def TFR_condset_rr : ALU32_rr<(outs IntRegs:$dst), (ins PredRegs:$src1,
1805                                                         IntRegs:$src2,
1806                                                         IntRegs:$src3),
1807                      "Error; should not emit",
1808                      [(set (i32 IntRegs:$dst),
1809                            (i32 (select (i1 PredRegs:$src1),
1810                                         (i32 IntRegs:$src2),
1811                                         (i32 IntRegs:$src3))))]>;
1812 let AddedComplexity = 100, isPredicated = 1 in
1813 def TFR_condset_ri : ALU32_rr<(outs IntRegs:$dst),
1814             (ins PredRegs:$src1, IntRegs:$src2, s12Imm:$src3),
1815             "Error; should not emit",
1816             [(set (i32 IntRegs:$dst),
1817              (i32 (select (i1 PredRegs:$src1), (i32 IntRegs:$src2),
1818                           s12ImmPred:$src3)))]>;
1819
1820 let AddedComplexity = 100, isPredicated = 1 in
1821 def TFR_condset_ir : ALU32_rr<(outs IntRegs:$dst),
1822             (ins PredRegs:$src1, s12Imm:$src2, IntRegs:$src3),
1823             "Error; should not emit",
1824             [(set (i32 IntRegs:$dst),
1825              (i32 (select (i1 PredRegs:$src1), s12ImmPred:$src2,
1826                           (i32 IntRegs:$src3))))]>;
1827
1828 let AddedComplexity = 100, isPredicated = 1 in
1829 def TFR_condset_ii : ALU32_rr<(outs IntRegs:$dst),
1830                               (ins PredRegs:$src1, s12Imm:$src2, s12Imm:$src3),
1831                      "Error; should not emit",
1832                      [(set (i32 IntRegs:$dst),
1833                            (i32 (select (i1 PredRegs:$src1), s12ImmPred:$src2,
1834                                         s12ImmPred:$src3)))]>;
1835
1836 // Generate frameindex addresses.
1837 let isReMaterializable = 1 in
1838 def TFR_FI : ALU32_ri<(outs IntRegs:$dst), (ins FrameIndex:$src1),
1839              "$dst = add($src1)",
1840              [(set (i32 IntRegs:$dst), ADDRri:$src1)]>;
1841
1842 //
1843 // CR - Type.
1844 //
1845 let neverHasSideEffects = 1, Defs = [SA0, LC0] in {
1846 def LOOP0_i : CRInst<(outs), (ins brtarget:$offset, u10Imm:$src2),
1847                       "loop0($offset, #$src2)",
1848                       []>;
1849 }
1850
1851 let neverHasSideEffects = 1, Defs = [SA0, LC0] in {
1852 def LOOP0_r : CRInst<(outs), (ins brtarget:$offset, IntRegs:$src2),
1853                       "loop0($offset, $src2)",
1854                       []>;
1855 }
1856
1857 let isBranch = 1, isTerminator = 1, neverHasSideEffects = 1,
1858     Defs = [PC, LC0], Uses = [SA0, LC0] in {
1859 def ENDLOOP0 : Endloop<(outs), (ins brtarget:$offset),
1860                        ":endloop0",
1861                        []>;
1862 }
1863
1864 // Support for generating global address.
1865 // Taken from X86InstrInfo.td.
1866 def SDTHexagonCONST32 : SDTypeProfile<1, 1, [
1867                                             SDTCisVT<0, i32>,
1868                                             SDTCisVT<1, i32>,
1869                                             SDTCisPtrTy<0>]>;
1870 def HexagonCONST32 : SDNode<"HexagonISD::CONST32",     SDTHexagonCONST32>;
1871 def HexagonCONST32_GP : SDNode<"HexagonISD::CONST32_GP",     SDTHexagonCONST32>;
1872
1873 // HI/LO Instructions
1874 let isReMaterializable = 1, isMoveImm = 1, neverHasSideEffects = 1 in
1875 def LO : ALU32_ri<(outs IntRegs:$dst), (ins globaladdress:$global),
1876                   "$dst.l = #LO($global)",
1877                   []>;
1878
1879 let isReMaterializable = 1, isMoveImm = 1, neverHasSideEffects = 1 in
1880 def HI : ALU32_ri<(outs IntRegs:$dst), (ins globaladdress:$global),
1881                   "$dst.h = #HI($global)",
1882                   []>;
1883
1884 let isReMaterializable = 1, isMoveImm = 1, neverHasSideEffects = 1 in
1885 def LOi : ALU32_ri<(outs IntRegs:$dst), (ins i32imm:$imm_value),
1886                   "$dst.l = #LO($imm_value)",
1887                   []>;
1888
1889
1890 let isReMaterializable = 1, isMoveImm = 1, neverHasSideEffects = 1 in
1891 def HIi : ALU32_ri<(outs IntRegs:$dst), (ins i32imm:$imm_value),
1892                   "$dst.h = #HI($imm_value)",
1893                   []>;
1894
1895 let isReMaterializable = 1, isMoveImm = 1, neverHasSideEffects = 1 in
1896 def LO_jt : ALU32_ri<(outs IntRegs:$dst), (ins jumptablebase:$jt),
1897                   "$dst.l = #LO($jt)",
1898                   []>;
1899
1900 let isReMaterializable = 1, isMoveImm = 1, neverHasSideEffects = 1 in
1901 def HI_jt : ALU32_ri<(outs IntRegs:$dst), (ins jumptablebase:$jt),
1902                   "$dst.h = #HI($jt)",
1903                   []>;
1904
1905
1906 let isReMaterializable = 1, isMoveImm = 1, neverHasSideEffects = 1 in
1907 def LO_label : ALU32_ri<(outs IntRegs:$dst), (ins bblabel:$label),
1908                   "$dst.l = #LO($label)",
1909                   []>;
1910
1911 let isReMaterializable = 1, isMoveImm = 1 , neverHasSideEffects = 1 in
1912 def HI_label : ALU32_ri<(outs IntRegs:$dst), (ins bblabel:$label),
1913                   "$dst.h = #HI($label)",
1914                   []>;
1915
1916 // This pattern is incorrect. When we add small data, we should change
1917 // this pattern to use memw(#foo).
1918 // This is for sdata.
1919 let isMoveImm = 1 in
1920 def CONST32 : LDInst<(outs IntRegs:$dst), (ins globaladdress:$global),
1921               "$dst = CONST32(#$global)",
1922               [(set (i32 IntRegs:$dst),
1923                     (load (HexagonCONST32 tglobaltlsaddr:$global)))]>;
1924
1925 // This is for non-sdata.
1926 let isReMaterializable = 1, isMoveImm = 1 in
1927 def CONST32_set : LDInst2<(outs IntRegs:$dst), (ins globaladdress:$global),
1928                   "$dst = CONST32(#$global)",
1929                   [(set (i32 IntRegs:$dst),
1930                         (HexagonCONST32 tglobaladdr:$global))]>;
1931
1932 let isReMaterializable = 1, isMoveImm = 1 in
1933 def CONST32_set_jt : LDInst2<(outs IntRegs:$dst), (ins jumptablebase:$jt),
1934                      "$dst = CONST32(#$jt)",
1935                      [(set (i32 IntRegs:$dst),
1936                            (HexagonCONST32 tjumptable:$jt))]>;
1937
1938 let isReMaterializable = 1, isMoveImm = 1 in
1939 def CONST32GP_set : LDInst2<(outs IntRegs:$dst), (ins globaladdress:$global),
1940                     "$dst = CONST32(#$global)",
1941                     [(set (i32 IntRegs:$dst),
1942                           (HexagonCONST32_GP tglobaladdr:$global))]>;
1943
1944 let isReMaterializable = 1, isMoveImm = 1 in
1945 def CONST32_Int_Real : LDInst2<(outs IntRegs:$dst), (ins i32imm:$global),
1946                        "$dst = CONST32(#$global)",
1947                        [(set (i32 IntRegs:$dst), imm:$global) ]>;
1948
1949 // Map BlockAddress lowering to CONST32_Int_Real
1950 def : Pat<(HexagonCONST32_GP tblockaddress:$addr),
1951           (CONST32_Int_Real tblockaddress:$addr)>;
1952
1953 let isReMaterializable = 1, isMoveImm = 1 in
1954 def CONST32_Label : LDInst2<(outs IntRegs:$dst), (ins bblabel:$label),
1955                     "$dst = CONST32($label)",
1956                     [(set (i32 IntRegs:$dst), (HexagonCONST32 bbl:$label))]>;
1957
1958 let isReMaterializable = 1, isMoveImm = 1 in
1959 def CONST64_Int_Real : LDInst2<(outs DoubleRegs:$dst), (ins i64imm:$global),
1960                        "$dst = CONST64(#$global)",
1961                        [(set (i64 DoubleRegs:$dst), imm:$global) ]>;
1962
1963 def TFR_PdFalse : SInst<(outs PredRegs:$dst), (ins),
1964                   "$dst = xor($dst, $dst)",
1965                   [(set (i1 PredRegs:$dst), 0)]>;
1966
1967 def MPY_trsext : MInst<(outs IntRegs:$dst), (ins IntRegs:$src1, IntRegs:$src2),
1968        "$dst = mpy($src1, $src2)",
1969        [(set (i32 IntRegs:$dst),
1970              (trunc (i64 (srl (i64 (mul (i64 (sext (i32 IntRegs:$src1))),
1971                                         (i64 (sext (i32 IntRegs:$src2))))),
1972                               (i32 32)))))]>;
1973
1974 // Pseudo instructions.
1975 def SDT_SPCallSeqStart : SDCallSeqStart<[ SDTCisVT<0, i32> ]>;
1976
1977 def SDT_SPCallSeqEnd : SDCallSeqEnd<[ SDTCisVT<0, i32>,
1978                                         SDTCisVT<1, i32> ]>;
1979
1980 def callseq_end : SDNode<"ISD::CALLSEQ_END",   SDT_SPCallSeqEnd,
1981                   [SDNPHasChain, SDNPOptInGlue, SDNPOutGlue]>;
1982
1983 def callseq_start : SDNode<"ISD::CALLSEQ_START", SDT_SPCallSeqStart,
1984                     [SDNPHasChain, SDNPOutGlue]>;
1985
1986 def SDT_SPCall : SDTypeProfile<0, 1, [SDTCisVT<0, i32>]>;
1987
1988 def call : SDNode<"HexagonISD::CALL", SDT_SPCall,
1989            [SDNPHasChain, SDNPOptInGlue, SDNPOutGlue, SDNPVariadic]>;
1990
1991 // For tailcalls a HexagonTCRet SDNode has 3 SDNode Properties - a chain,
1992 // Optional Flag and Variable Arguments.
1993 // Its 1 Operand has pointer type.
1994 def HexagonTCRet    : SDNode<"HexagonISD::TC_RETURN", SDT_SPCall,
1995                      [SDNPHasChain,  SDNPOptInGlue, SDNPVariadic]>;
1996
1997 let Defs = [R29, R30], Uses = [R31, R30, R29] in {
1998  def ADJCALLSTACKDOWN : Pseudo<(outs), (ins i32imm:$amt),
1999                         "Should never be emitted",
2000                         [(callseq_start timm:$amt)]>;
2001 }
2002
2003 let Defs = [R29, R30, R31], Uses = [R29] in {
2004  def ADJCALLSTACKUP : Pseudo<(outs), (ins i32imm:$amt1, i32imm:$amt2),
2005                       "Should never be emitted",
2006                       [(callseq_end timm:$amt1, timm:$amt2)]>;
2007 }
2008 // Call subroutine.
2009 let isCall = 1, neverHasSideEffects = 1,
2010   Defs = [D0, D1, D2, D3, D4, D5, D6, D7, D8, D9, D10,
2011           R22, R23, R28, R31, P0, P1, P2, P3, LC0, LC1, SA0, SA1] in {
2012   def CALL : JInst<(outs), (ins calltarget:$dst),
2013              "call $dst", []>;
2014 }
2015
2016 // Call subroutine from register.
2017 let isCall = 1, neverHasSideEffects = 1,
2018   Defs = [D0, D1, D2, D3, D4, D5, D6, D7, D8, D9, D10,
2019           R22, R23, R28, R31, P0, P1, P2, P3, LC0, LC1, SA0, SA1] in {
2020   def CALLR : JRInst<(outs), (ins IntRegs:$dst),
2021               "callr $dst",
2022               []>;
2023  }
2024
2025 // Tail Calls.
2026 let isCall = 1, isBarrier = 1, isReturn = 1, isTerminator = 1 in {
2027   def TCRETURNtg : JInst<(outs), (ins calltarget:$dst),
2028              "jump $dst // TAILCALL", []>;
2029 }
2030 let isCall = 1, isBarrier = 1, isReturn = 1, isTerminator = 1 in {
2031   def TCRETURNtext : JInst<(outs), (ins calltarget:$dst),
2032              "jump $dst // TAILCALL", []>;
2033 }
2034
2035 let isCall = 1, isBarrier = 1, isReturn = 1, isTerminator = 1 in {
2036   def TCRETURNR : JInst<(outs), (ins IntRegs:$dst),
2037              "jumpr $dst // TAILCALL", []>;
2038 }
2039 // Map call instruction.
2040 def : Pat<(call (i32 IntRegs:$dst)),
2041       (CALLR (i32 IntRegs:$dst))>, Requires<[HasV2TOnly]>;
2042 def : Pat<(call tglobaladdr:$dst),
2043       (CALL tglobaladdr:$dst)>, Requires<[HasV2TOnly]>;
2044 def : Pat<(call texternalsym:$dst),
2045       (CALL texternalsym:$dst)>, Requires<[HasV2TOnly]>;
2046 //Tail calls.
2047 def : Pat<(HexagonTCRet tglobaladdr:$dst),
2048       (TCRETURNtg tglobaladdr:$dst)>;
2049 def : Pat<(HexagonTCRet texternalsym:$dst),
2050       (TCRETURNtext texternalsym:$dst)>;
2051 def : Pat<(HexagonTCRet (i32 IntRegs:$dst)),
2052       (TCRETURNR (i32 IntRegs:$dst))>;
2053
2054 // Atomic load and store support
2055 // 8 bit atomic load
2056 def : Pat<(atomic_load_8 ADDRriS11_0:$src1),
2057           (i32 (LDriub ADDRriS11_0:$src1))>;
2058
2059 def : Pat<(atomic_load_8 (add (i32 IntRegs:$src1), s11_0ImmPred:$offset)),
2060           (i32 (LDriub_indexed (i32 IntRegs:$src1), s11_0ImmPred:$offset))>;
2061
2062 // 16 bit atomic load
2063 def : Pat<(atomic_load_16 ADDRriS11_1:$src1),
2064           (i32 (LDriuh ADDRriS11_1:$src1))>;
2065
2066 def : Pat<(atomic_load_16 (add (i32 IntRegs:$src1), s11_1ImmPred:$offset)),
2067           (i32 (LDriuh_indexed (i32 IntRegs:$src1), s11_1ImmPred:$offset))>;
2068
2069 def : Pat<(atomic_load_32 ADDRriS11_2:$src1),
2070           (i32 (LDriw ADDRriS11_2:$src1))>;
2071
2072 def : Pat<(atomic_load_32 (add (i32 IntRegs:$src1), s11_2ImmPred:$offset)),
2073           (i32 (LDriw_indexed (i32 IntRegs:$src1), s11_2ImmPred:$offset))>;
2074
2075 // 64 bit atomic load
2076 def : Pat<(atomic_load_64 ADDRriS11_3:$src1),
2077           (i64 (LDrid ADDRriS11_3:$src1))>;
2078
2079 def : Pat<(atomic_load_64 (add (i32 IntRegs:$src1), s11_3ImmPred:$offset)),
2080           (i64 (LDrid_indexed (i32 IntRegs:$src1), s11_3ImmPred:$offset))>;
2081
2082
2083 def : Pat<(atomic_store_8 ADDRriS11_0:$src2, (i32 IntRegs:$src1)),
2084           (STrib ADDRriS11_0:$src2, (i32 IntRegs:$src1))>;
2085
2086 def : Pat<(atomic_store_8 (add (i32 IntRegs:$src2), s11_0ImmPred:$offset),
2087                           (i32 IntRegs:$src1)),
2088           (STrib_indexed (i32 IntRegs:$src2), s11_0ImmPred:$offset,
2089                          (i32 IntRegs:$src1))>;
2090
2091
2092 def : Pat<(atomic_store_16 ADDRriS11_1:$src2, (i32 IntRegs:$src1)),
2093           (STrih ADDRriS11_1:$src2, (i32 IntRegs:$src1))>;
2094
2095 def : Pat<(atomic_store_16 (i32 IntRegs:$src1),
2096                           (add (i32 IntRegs:$src2), s11_1ImmPred:$offset)),
2097           (STrih_indexed (i32 IntRegs:$src2), s11_1ImmPred:$offset,
2098                          (i32 IntRegs:$src1))>;
2099
2100 def : Pat<(atomic_store_32 ADDRriS11_2:$src2, (i32 IntRegs:$src1)),
2101           (STriw ADDRriS11_2:$src2, (i32 IntRegs:$src1))>;
2102
2103 def : Pat<(atomic_store_32 (add (i32 IntRegs:$src2), s11_2ImmPred:$offset),
2104                            (i32 IntRegs:$src1)),
2105           (STriw_indexed (i32 IntRegs:$src2), s11_2ImmPred:$offset,
2106                          (i32 IntRegs:$src1))>;
2107
2108
2109
2110
2111 def : Pat<(atomic_store_64 ADDRriS11_3:$src2, (i64 DoubleRegs:$src1)),
2112           (STrid ADDRriS11_3:$src2, (i64 DoubleRegs:$src1))>;
2113
2114 def : Pat<(atomic_store_64 (add (i32 IntRegs:$src2), s11_3ImmPred:$offset),
2115                            (i64 DoubleRegs:$src1)),
2116           (STrid_indexed (i32 IntRegs:$src2), s11_3ImmPred:$offset,
2117                          (i64 DoubleRegs:$src1))>;
2118
2119 // Map from r0 = and(r1, 65535) to r0 = zxth(r1)
2120 def : Pat <(and (i32 IntRegs:$src1), 65535),
2121       (ZXTH (i32 IntRegs:$src1))>;
2122
2123 // Map from r0 = and(r1, 255) to r0 = zxtb(r1).
2124 def : Pat <(and (i32 IntRegs:$src1), 255),
2125       (ZXTB (i32 IntRegs:$src1))>;
2126
2127 // Map Add(p1, true) to p1 = not(p1).
2128 //     Add(p1, false) should never be produced,
2129 //     if it does, it got to be mapped to NOOP.
2130 def : Pat <(add (i1 PredRegs:$src1), -1),
2131       (NOT_p (i1 PredRegs:$src1))>;
2132
2133 // Map from p0 = setlt(r0, r1) r2 = mux(p0, r3, r4) =>
2134 //   p0 = cmp.lt(r0, r1), r0 = mux(p0, r2, r1).
2135 def : Pat <(select (i1 (setlt (i32 IntRegs:$src1), (i32 IntRegs:$src2))),
2136                    (i32 IntRegs:$src3),
2137                    (i32 IntRegs:$src4)),
2138       (i32 (TFR_condset_rr (CMPLTrr (i32 IntRegs:$src1), (i32 IntRegs:$src2)),
2139                            (i32 IntRegs:$src4), (i32 IntRegs:$src3)))>,
2140       Requires<[HasV2TOnly]>;
2141
2142 // Map from p0 = pnot(p0); r0 = mux(p0, #i, #j) => r0 = mux(p0, #j, #i).
2143 def : Pat <(select (not (i1 PredRegs:$src1)), s8ImmPred:$src2, s8ImmPred:$src3),
2144       (i32 (TFR_condset_ii (i1 PredRegs:$src1), s8ImmPred:$src3,
2145                            s8ImmPred:$src2))>;
2146
2147 // Map from p0 = pnot(p0); r0 = select(p0, #i, r1)
2148 // => r0 = TFR_condset_ri(p0, r1, #i)
2149 def : Pat <(select (not (i1 PredRegs:$src1)), s12ImmPred:$src2,
2150                    (i32 IntRegs:$src3)),
2151       (i32 (TFR_condset_ri (i1 PredRegs:$src1), (i32 IntRegs:$src3),
2152                            s12ImmPred:$src2))>;
2153
2154 // Map from p0 = pnot(p0); r0 = mux(p0, r1, #i)
2155 // => r0 = TFR_condset_ir(p0, #i, r1)
2156 def : Pat <(select (not PredRegs:$src1), IntRegs:$src2, s12ImmPred:$src3),
2157       (i32 (TFR_condset_ir (i1 PredRegs:$src1), s12ImmPred:$src3,
2158                            (i32 IntRegs:$src2)))>;
2159
2160 // Map from p0 = pnot(p0); if (p0) jump => if (!p0) jump.
2161 def : Pat <(brcond (not PredRegs:$src1), bb:$offset),
2162       (JMP_cNot (i1 PredRegs:$src1), bb:$offset)>;
2163
2164 // Map from p2 = pnot(p2); p1 = and(p0, p2) => p1 = and(p0, !p2).
2165 def : Pat <(and PredRegs:$src1, (not PredRegs:$src2)),
2166       (i1 (AND_pnotp (i1 PredRegs:$src1), (i1 PredRegs:$src2)))>;
2167
2168 // Map from i1 loads to 32 bits. This assumes that the i1* is byte aligned.
2169 let AddedComplexity = 10 in
2170 def : Pat <(i32 (zextloadi1 ADDRriS11_0:$addr)),
2171       (i32 (AND_rr (i32 (LDrib ADDRriS11_0:$addr)), (TFRI 0x1)))>;
2172
2173 // Map from Rdd = sign_extend_inreg(Rss, i32) -> Rdd = SXTW(Rss.lo).
2174 def : Pat <(i64 (sext_inreg (i64 DoubleRegs:$src1), i32)),
2175       (i64 (SXTW (i32 (EXTRACT_SUBREG (i64 DoubleRegs:$src1), subreg_loreg))))>;
2176
2177 // Map from Rdd = sign_extend_inreg(Rss, i16) -> Rdd = SXTW(SXTH(Rss.lo)).
2178 def : Pat <(i64 (sext_inreg (i64 DoubleRegs:$src1), i16)),
2179       (i64 (SXTW (i32 (SXTH (i32 (EXTRACT_SUBREG (i64 DoubleRegs:$src1),
2180                                                  subreg_loreg))))))>;
2181
2182 // Map from Rdd = sign_extend_inreg(Rss, i8) -> Rdd = SXTW(SXTB(Rss.lo)).
2183 def : Pat <(i64 (sext_inreg (i64 DoubleRegs:$src1), i8)),
2184       (i64 (SXTW (i32 (SXTB (i32 (EXTRACT_SUBREG (i64 DoubleRegs:$src1),
2185                                                  subreg_loreg))))))>;
2186
2187 // We want to prevent emitting pnot's as much as possible.
2188 // Map brcond with an unsupported setcc to a JMP_cNot.
2189 def : Pat <(brcond (i1 (setne (i32 IntRegs:$src1), (i32 IntRegs:$src2))),
2190                         bb:$offset),
2191       (JMP_cNot (CMPEQrr (i32 IntRegs:$src1), (i32 IntRegs:$src2)),
2192                 bb:$offset)>;
2193
2194 def : Pat <(brcond (i1 (setne (i32 IntRegs:$src1), s10ImmPred:$src2)),
2195                         bb:$offset),
2196       (JMP_cNot (CMPEQri (i32 IntRegs:$src1), s10ImmPred:$src2), bb:$offset)>;
2197
2198 def : Pat <(brcond (i1 (setne (i1 PredRegs:$src1), (i1 -1))), bb:$offset),
2199       (JMP_cNot (i1 PredRegs:$src1), bb:$offset)>;
2200
2201 def : Pat <(brcond (i1 (setne (i1 PredRegs:$src1), (i1 0))), bb:$offset),
2202       (JMP_c (i1 PredRegs:$src1), bb:$offset)>;
2203
2204 def : Pat <(brcond (i1 (setlt (i32 IntRegs:$src1), s8ImmPred:$src2)),
2205                         bb:$offset),
2206       (JMP_cNot (CMPGEri (i32 IntRegs:$src1), s8ImmPred:$src2), bb:$offset)>;
2207
2208 def : Pat <(brcond (i1 (setlt (i32 IntRegs:$src1), (i32 IntRegs:$src2))),
2209                         bb:$offset),
2210       (JMP_c (CMPLTrr (i32 IntRegs:$src1), (i32 IntRegs:$src2)), bb:$offset)>;
2211
2212 def : Pat <(brcond (i1 (setuge (i64 DoubleRegs:$src1), (i64 DoubleRegs:$src2))),
2213                    bb:$offset),
2214       (JMP_cNot (CMPGTU64rr (i64 DoubleRegs:$src2), (i64 DoubleRegs:$src1)),
2215                    bb:$offset)>;
2216
2217 def : Pat <(brcond (i1 (setule (i32 IntRegs:$src1), (i32 IntRegs:$src2))),
2218                         bb:$offset),
2219       (JMP_cNot (CMPGTUrr (i32 IntRegs:$src1), (i32 IntRegs:$src2)),
2220                 bb:$offset)>;
2221
2222 def : Pat <(brcond (i1 (setule (i64 DoubleRegs:$src1), (i64 DoubleRegs:$src2))),
2223                    bb:$offset),
2224       (JMP_cNot (CMPGTU64rr (i64 DoubleRegs:$src1), (i64 DoubleRegs:$src2)),
2225                 bb:$offset)>;
2226
2227 // Map from a 64-bit select to an emulated 64-bit mux.
2228 // Hexagon does not support 64-bit MUXes; so emulate with combines.
2229 def : Pat <(select (i1 PredRegs:$src1), (i64 DoubleRegs:$src2),
2230                    (i64 DoubleRegs:$src3)),
2231       (i64 (COMBINE_rr (i32 (MUX_rr (i1 PredRegs:$src1),
2232                                     (i32 (EXTRACT_SUBREG (i64 DoubleRegs:$src2),
2233                                                          subreg_hireg)),
2234                                     (i32 (EXTRACT_SUBREG (i64 DoubleRegs:$src3),
2235                                                          subreg_hireg)))),
2236                        (i32 (MUX_rr (i1 PredRegs:$src1),
2237                                     (i32 (EXTRACT_SUBREG (i64 DoubleRegs:$src2),
2238                                                          subreg_loreg)),
2239                                     (i32 (EXTRACT_SUBREG (i64 DoubleRegs:$src3),
2240                                                          subreg_loreg))))))>;
2241
2242 // Map from a 1-bit select to logical ops.
2243 // From LegalizeDAG.cpp: (B1 ? B2 : B3) <=> (B1 & B2)|(!B1&B3).
2244 def : Pat <(select (i1 PredRegs:$src1), (i1 PredRegs:$src2),
2245                    (i1 PredRegs:$src3)),
2246       (OR_pp (AND_pp (i1 PredRegs:$src1), (i1 PredRegs:$src2)),
2247              (AND_pp (NOT_p (i1 PredRegs:$src1)), (i1 PredRegs:$src3)))>;
2248
2249 // Map Pd = load(addr) -> Rs = load(addr); Pd = Rs.
2250 def : Pat<(i1 (load ADDRriS11_2:$addr)),
2251       (i1 (TFR_PdRs (i32 (LDrib ADDRriS11_2:$addr))))>;
2252
2253 // Map for truncating from 64 immediates to 32 bit immediates.
2254 def : Pat<(i32 (trunc (i64 DoubleRegs:$src))),
2255       (i32 (EXTRACT_SUBREG (i64 DoubleRegs:$src), subreg_loreg))>;
2256
2257 // Map for truncating from i64 immediates to i1 bit immediates.
2258 def :  Pat<(i1 (trunc (i64 DoubleRegs:$src))),
2259        (i1 (TFR_PdRs (i32 (EXTRACT_SUBREG (i64 DoubleRegs:$src),
2260                                           subreg_loreg))))>;
2261
2262 // Map memb(Rs) = Rdd -> memb(Rs) = Rt.
2263 def : Pat<(truncstorei8 (i64 DoubleRegs:$src), ADDRriS11_0:$addr),
2264       (STrib ADDRriS11_0:$addr, (i32 (EXTRACT_SUBREG (i64 DoubleRegs:$src),
2265                                                      subreg_loreg)))>;
2266
2267 // Map memh(Rs) = Rdd -> memh(Rs) = Rt.
2268 def : Pat<(truncstorei16 (i64 DoubleRegs:$src), ADDRriS11_0:$addr),
2269       (STrih ADDRriS11_0:$addr, (i32 (EXTRACT_SUBREG (i64 DoubleRegs:$src),
2270                                                      subreg_loreg)))>;
2271 // Map memw(Rs) = Rdd -> memw(Rs) = Rt
2272 def : Pat<(truncstorei32 (i64  DoubleRegs:$src), ADDRriS11_0:$addr),
2273       (STriw ADDRriS11_0:$addr, (i32 (EXTRACT_SUBREG (i64 DoubleRegs:$src),
2274                                                      subreg_loreg)))>;
2275
2276 // Map memw(Rs) = Rdd -> memw(Rs) = Rt.
2277 def : Pat<(truncstorei32 (i64 DoubleRegs:$src), ADDRriS11_0:$addr),
2278       (STriw ADDRriS11_0:$addr, (i32 (EXTRACT_SUBREG (i64 DoubleRegs:$src),
2279                                                      subreg_loreg)))>;
2280
2281 // Map from i1 = constant<-1>; memw(addr) = i1 -> r0 = 1; memw(addr) = r0.
2282 def : Pat<(store (i1 -1), ADDRriS11_2:$addr),
2283       (STrib ADDRriS11_2:$addr, (TFRI 1))>;
2284
2285
2286 // Map from i1 = constant<-1>; store i1 -> r0 = 1; store r0.
2287 def : Pat<(store (i1 -1), ADDRriS11_2:$addr),
2288       (STrib ADDRriS11_2:$addr, (TFRI 1))>;
2289
2290 // Map from memb(Rs) = Pd -> Rt = mux(Pd, #0, #1); store Rt.
2291 def : Pat<(store (i1 PredRegs:$src1), ADDRriS11_2:$addr),
2292       (STrib ADDRriS11_2:$addr, (i32 (MUX_ii (i1 PredRegs:$src1), 1, 0)) )>;
2293
2294 // Map Rdd = anyext(Rs) -> Rdd = sxtw(Rs).
2295 // Hexagon_TODO: We can probably use combine but that will cost 2 instructions.
2296 // Better way to do this?
2297 def : Pat<(i64 (anyext (i32 IntRegs:$src1))),
2298       (i64 (SXTW (i32 IntRegs:$src1)))>;
2299
2300 // Map cmple -> cmpgt.
2301 // rs <= rt -> !(rs > rt).
2302 def : Pat<(i1 (setle (i32 IntRegs:$src1), s10ImmPred:$src2)),
2303       (i1 (NOT_p (CMPGTri (i32 IntRegs:$src1), s10ImmPred:$src2)))>;
2304
2305 // rs <= rt -> !(rs > rt).
2306 def : Pat<(i1 (setle (i32 IntRegs:$src1), (i32 IntRegs:$src2))),
2307       (i1 (NOT_p (CMPGTrr (i32 IntRegs:$src1), (i32 IntRegs:$src2))))>;
2308
2309 // Rss <= Rtt -> !(Rss > Rtt).
2310 def : Pat<(i1 (setle (i64 DoubleRegs:$src1), (i64 DoubleRegs:$src2))),
2311       (i1 (NOT_p (CMPGT64rr (i64 DoubleRegs:$src1), (i64 DoubleRegs:$src2))))>;
2312
2313 // Map cmpne -> cmpeq.
2314 // Hexagon_TODO: We should improve on this.
2315 // rs != rt -> !(rs == rt).
2316 def : Pat <(i1 (setne (i32 IntRegs:$src1), s10ImmPred:$src2)),
2317       (i1 (NOT_p(i1 (CMPEQri (i32 IntRegs:$src1), s10ImmPred:$src2))))>;
2318
2319 // Map cmpne(Rs) -> !cmpeqe(Rs).
2320 // rs != rt -> !(rs == rt).
2321 def : Pat <(i1 (setne (i32 IntRegs:$src1), (i32 IntRegs:$src2))),
2322       (i1 (NOT_p (i1 (CMPEQrr (i32 IntRegs:$src1), (i32 IntRegs:$src2)))))>;
2323
2324 // Convert setne back to xor for hexagon since we compute w/ pred registers.
2325 def : Pat <(i1 (setne (i1 PredRegs:$src1), (i1 PredRegs:$src2))),
2326       (i1 (XOR_pp (i1 PredRegs:$src1), (i1 PredRegs:$src2)))>;
2327
2328 // Map cmpne(Rss) -> !cmpew(Rss).
2329 // rs != rt -> !(rs == rt).
2330 def : Pat <(i1 (setne (i64 DoubleRegs:$src1), (i64 DoubleRegs:$src2))),
2331       (i1 (NOT_p (i1 (CMPEHexagon4rr (i64 DoubleRegs:$src1),
2332                                      (i64 DoubleRegs:$src2)))))>;
2333
2334 // Map cmpge(Rs, Rt) -> !(cmpgt(Rs, Rt).
2335 // rs >= rt -> !(rt > rs).
2336 def : Pat <(i1 (setge (i32 IntRegs:$src1), (i32 IntRegs:$src2))),
2337       (i1 (NOT_p (i1 (CMPGTrr (i32 IntRegs:$src2), (i32 IntRegs:$src1)))))>;
2338
2339 def : Pat <(i1 (setge (i32 IntRegs:$src1), s8ImmPred:$src2)),
2340       (i1 (CMPGEri (i32 IntRegs:$src1), s8ImmPred:$src2))>;
2341
2342 // Map cmpge(Rss, Rtt) -> !cmpgt(Rtt, Rss).
2343 // rss >= rtt -> !(rtt > rss).
2344 def : Pat <(i1 (setge (i64 DoubleRegs:$src1), (i64 DoubleRegs:$src2))),
2345       (i1 (NOT_p (i1 (CMPGT64rr (i64 DoubleRegs:$src2),
2346                                 (i64 DoubleRegs:$src1)))))>;
2347
2348 // Map cmplt(Rs, Imm) -> !cmpge(Rs, Imm).
2349 // rs < rt -> !(rs >= rt).
2350 def : Pat <(i1 (setlt (i32 IntRegs:$src1), s8ImmPred:$src2)),
2351       (i1 (NOT_p (CMPGEri (i32 IntRegs:$src1), s8ImmPred:$src2)))>;
2352
2353 // Map cmplt(Rs, Rt) -> cmpgt(Rt, Rs).
2354 // rs < rt -> rt > rs.
2355 // We can let assembler map it, or we can do in the compiler itself.
2356 def : Pat <(i1 (setlt (i32 IntRegs:$src1), (i32 IntRegs:$src2))),
2357       (i1 (CMPGTrr (i32 IntRegs:$src2), (i32 IntRegs:$src1)))>;
2358
2359 // Map cmplt(Rss, Rtt) -> cmpgt(Rtt, Rss).
2360 // rss < rtt -> (rtt > rss).
2361 def : Pat <(i1 (setlt (i64 DoubleRegs:$src1), (i64 DoubleRegs:$src2))),
2362       (i1 (CMPGT64rr (i64 DoubleRegs:$src2), (i64 DoubleRegs:$src1)))>;
2363
2364 // Map from cmpltu(Rs, Rd) -> cmpgtu(Rd, Rs)
2365 // rs < rt -> rt > rs.
2366 // We can let assembler map it, or we can do in the compiler itself.
2367 def : Pat <(i1 (setult (i32 IntRegs:$src1), (i32 IntRegs:$src2))),
2368       (i1 (CMPGTUrr (i32 IntRegs:$src2), (i32 IntRegs:$src1)))>;
2369
2370 // Map from cmpltu(Rss, Rdd) -> cmpgtu(Rdd, Rss).
2371 // rs < rt -> rt > rs.
2372 def : Pat <(i1 (setult (i64 DoubleRegs:$src1), (i64 DoubleRegs:$src2))),
2373       (i1 (CMPGTU64rr (i64 DoubleRegs:$src2), (i64 DoubleRegs:$src1)))>;
2374
2375 // Generate cmpgeu(Rs, #u8)
2376 def : Pat <(i1 (setuge (i32 IntRegs:$src1), u8ImmPred:$src2)),
2377       (i1 (CMPGEUri (i32 IntRegs:$src1), u8ImmPred:$src2))>;
2378
2379 // Generate cmpgtu(Rs, #u9)
2380 def : Pat <(i1 (setugt (i32 IntRegs:$src1), u9ImmPred:$src2)),
2381       (i1 (CMPGTUri (i32 IntRegs:$src1), u9ImmPred:$src2))>;
2382
2383 // Map from Rs >= Rt -> !(Rt > Rs).
2384 // rs >= rt -> !(rt > rs).
2385 def : Pat <(i1 (setuge (i32 IntRegs:$src1), (i32 IntRegs:$src2))),
2386       (i1 (NOT_p (CMPGTUrr (i32 IntRegs:$src2), (i32 IntRegs:$src1))))>;
2387
2388 // Map from Rs >= Rt -> !(Rt > Rs).
2389 // rs >= rt -> !(rt > rs).
2390 def : Pat <(i1 (setuge (i64 DoubleRegs:$src1), (i64 DoubleRegs:$src2))),
2391       (i1 (NOT_p (CMPGTU64rr (i64 DoubleRegs:$src2), (i64 DoubleRegs:$src1))))>;
2392
2393 // Map from cmpleu(Rs, Rs) -> !cmpgtu(Rs, Rs).
2394 // Map from (Rs <= Rt) -> !(Rs > Rt).
2395 def : Pat <(i1 (setule (i32 IntRegs:$src1), (i32 IntRegs:$src2))),
2396       (i1 (NOT_p (CMPGTUrr (i32 IntRegs:$src1), (i32 IntRegs:$src2))))>;
2397
2398 // Map from cmpleu(Rss, Rtt) -> !cmpgtu(Rss, Rtt-1).
2399 // Map from (Rs <= Rt) -> !(Rs > Rt).
2400 def : Pat <(i1 (setule (i64 DoubleRegs:$src1), (i64 DoubleRegs:$src2))),
2401       (i1 (NOT_p (CMPGTU64rr (i64 DoubleRegs:$src1), (i64 DoubleRegs:$src2))))>;
2402
2403 // Sign extends.
2404 // i1 -> i32
2405 def : Pat <(i32 (sext (i1 PredRegs:$src1))),
2406       (i32 (MUX_ii (i1 PredRegs:$src1), -1, 0))>;
2407
2408 // i1 -> i64
2409 def : Pat <(i64 (sext (i1 PredRegs:$src1))),
2410       (i64 (COMBINE_rr (TFRI -1), (MUX_ii (i1 PredRegs:$src1), -1, 0)))>;
2411
2412 // Convert sign-extended load back to load and sign extend.
2413 // i8 -> i64
2414 def:  Pat <(i64 (sextloadi8 ADDRriS11_0:$src1)),
2415       (i64 (SXTW (LDrib ADDRriS11_0:$src1)))>;
2416
2417 // Convert any-extended load back to load and sign extend.
2418 // i8 -> i64
2419 def:  Pat <(i64 (extloadi8 ADDRriS11_0:$src1)),
2420       (i64 (SXTW (LDrib ADDRriS11_0:$src1)))>;
2421
2422 // Convert sign-extended load back to load and sign extend.
2423 // i16 -> i64
2424 def:  Pat <(i64 (sextloadi16 ADDRriS11_1:$src1)),
2425       (i64 (SXTW (LDrih ADDRriS11_1:$src1)))>;
2426
2427 // Convert sign-extended load back to load and sign extend.
2428 // i32 -> i64
2429 def:  Pat <(i64 (sextloadi32 ADDRriS11_2:$src1)),
2430       (i64 (SXTW (LDriw ADDRriS11_2:$src1)))>;
2431
2432
2433 // Zero extends.
2434 // i1 -> i32
2435 def : Pat <(i32 (zext (i1 PredRegs:$src1))),
2436       (i32 (MUX_ii (i1 PredRegs:$src1), 1, 0))>;
2437
2438 // i1 -> i64
2439 def : Pat <(i64 (zext (i1 PredRegs:$src1))),
2440       (i64 (COMBINE_rr (TFRI 0), (MUX_ii (i1 PredRegs:$src1), 1, 0)))>,
2441       Requires<[NoV4T]>;
2442
2443 // i32 -> i64
2444 def : Pat <(i64 (zext (i32 IntRegs:$src1))),
2445       (i64 (COMBINE_rr (TFRI 0), (i32 IntRegs:$src1)))>,
2446       Requires<[NoV4T]>;
2447
2448 // i8 -> i64
2449 def:  Pat <(i64 (zextloadi8 ADDRriS11_0:$src1)),
2450       (i64 (COMBINE_rr (TFRI 0), (LDriub ADDRriS11_0:$src1)))>,
2451       Requires<[NoV4T]>;
2452
2453 let AddedComplexity = 20 in
2454 def:  Pat <(i64 (zextloadi8 (add (i32 IntRegs:$src1),
2455                                 s11_0ExtPred:$offset))),
2456       (i64 (COMBINE_rr (TFRI 0), (LDriub_indexed IntRegs:$src1,
2457                                   s11_0ExtPred:$offset)))>,
2458       Requires<[NoV4T]>;
2459
2460 // i1 -> i64
2461 def:  Pat <(i64 (zextloadi1 ADDRriS11_0:$src1)),
2462       (i64 (COMBINE_rr (TFRI 0), (LDriub ADDRriS11_0:$src1)))>,
2463       Requires<[NoV4T]>;
2464
2465 let AddedComplexity = 20 in
2466 def:  Pat <(i64 (zextloadi1 (add (i32 IntRegs:$src1),
2467                                 s11_0ExtPred:$offset))),
2468       (i64 (COMBINE_rr (TFRI 0), (LDriub_indexed IntRegs:$src1,
2469                                   s11_0ExtPred:$offset)))>,
2470       Requires<[NoV4T]>;
2471
2472 // i16 -> i64
2473 def:  Pat <(i64 (zextloadi16 ADDRriS11_1:$src1)),
2474       (i64 (COMBINE_rr (TFRI 0), (LDriuh ADDRriS11_1:$src1)))>,
2475       Requires<[NoV4T]>;
2476
2477 let AddedComplexity = 20 in
2478 def:  Pat <(i64 (zextloadi16 (add (i32 IntRegs:$src1),
2479                                   s11_1ExtPred:$offset))),
2480       (i64 (COMBINE_rr (TFRI 0), (LDriuh_indexed IntRegs:$src1,
2481                                   s11_1ExtPred:$offset)))>,
2482       Requires<[NoV4T]>;
2483
2484 // i32 -> i64
2485 def:  Pat <(i64 (zextloadi32 ADDRriS11_2:$src1)),
2486       (i64 (COMBINE_rr (TFRI 0), (LDriw ADDRriS11_2:$src1)))>,
2487       Requires<[NoV4T]>;
2488
2489 def:  Pat <(i32 (zextloadi1 ADDRriS11_0:$src1)),
2490       (i32 (LDriw ADDRriS11_0:$src1))>;
2491
2492 // Map from Rs = Pd to Pd = mux(Pd, #1, #0)
2493 def : Pat <(i32 (zext (i1 PredRegs:$src1))),
2494       (i32 (MUX_ii (i1 PredRegs:$src1), 1, 0))>;
2495
2496 // Map from Rs = Pd to Pd = mux(Pd, #1, #0)
2497 def : Pat <(i32 (anyext (i1 PredRegs:$src1))),
2498       (i32 (MUX_ii (i1 PredRegs:$src1), 1, 0))>;
2499
2500 // Map from Rss = Pd to Rdd = sxtw (mux(Pd, #1, #0))
2501 def : Pat <(i64 (anyext (i1 PredRegs:$src1))),
2502       (i64 (SXTW (i32 (MUX_ii (i1 PredRegs:$src1), 1, 0))))>;
2503
2504
2505 // Any extended 64-bit load.
2506 // anyext i32 -> i64
2507 def:  Pat <(i64 (extloadi32 ADDRriS11_2:$src1)),
2508       (i64 (COMBINE_rr (TFRI 0), (LDriw ADDRriS11_2:$src1)))>,
2509       Requires<[NoV4T]>;
2510
2511 // When there is an offset we should prefer the pattern below over the pattern above.
2512 // The complexity of the above is 13 (gleaned from HexagonGenDAGIsel.inc)
2513 // So this complexity below is comfortably higher to allow for choosing the below.
2514 // If this is not done then we generate addresses such as
2515 // ********************************************
2516 //        r1 = add (r0, #4)
2517 //        r1 = memw(r1 + #0)
2518 //  instead of
2519 //        r1 = memw(r0 + #4)
2520 // ********************************************
2521 let AddedComplexity = 100 in
2522 def:  Pat <(i64 (extloadi32 (i32 (add IntRegs:$src1, s11_2ExtPred:$offset)))),
2523       (i64 (COMBINE_rr (TFRI 0), (LDriw_indexed IntRegs:$src1,
2524                                   s11_2ExtPred:$offset)))>,
2525       Requires<[NoV4T]>;
2526
2527 // anyext i16 -> i64.
2528 def:  Pat <(i64 (extloadi16 ADDRriS11_2:$src1)),
2529       (i64 (COMBINE_rr (TFRI 0), (LDrih ADDRriS11_2:$src1)))>,
2530       Requires<[NoV4T]>;
2531
2532 let AddedComplexity = 20 in
2533 def:  Pat <(i64 (extloadi16 (add (i32 IntRegs:$src1),
2534                                   s11_1ExtPred:$offset))),
2535       (i64 (COMBINE_rr (TFRI 0), (LDrih_indexed IntRegs:$src1,
2536                                   s11_1ExtPred:$offset)))>,
2537       Requires<[NoV4T]>;
2538
2539 // Map from Rdd = zxtw(Rs) -> Rdd = combine(0, Rs).
2540 def : Pat<(i64 (zext (i32 IntRegs:$src1))),
2541       (i64 (COMBINE_rr (TFRI 0), (i32 IntRegs:$src1)))>,
2542       Requires<[NoV4T]>;
2543
2544 // Multiply 64-bit unsigned and use upper result.
2545 def : Pat <(mulhu (i64 DoubleRegs:$src1), (i64 DoubleRegs:$src2)),
2546       (i64
2547        (MPYU64_acc
2548         (i64
2549          (COMBINE_rr
2550           (TFRI 0),
2551            (i32
2552             (EXTRACT_SUBREG
2553              (i64
2554               (LSRd_ri
2555                (i64
2556                 (MPYU64_acc
2557                  (i64
2558                   (MPYU64_acc
2559                    (i64
2560                     (COMBINE_rr (TFRI 0),
2561                      (i32
2562                       (EXTRACT_SUBREG
2563                        (i64
2564                         (LSRd_ri
2565                          (i64
2566                           (MPYU64 (i32 (EXTRACT_SUBREG (i64 DoubleRegs:$src1),
2567                                                        subreg_loreg)),
2568                                   (i32 (EXTRACT_SUBREG (i64 DoubleRegs:$src2),
2569                                                        subreg_loreg)))), 32)),
2570                        subreg_loreg)))),
2571                   (i32 (EXTRACT_SUBREG (i64 DoubleRegs:$src1), subreg_hireg)),
2572                   (i32 (EXTRACT_SUBREG (i64 DoubleRegs:$src2), subreg_loreg)))),
2573                  (i32 (EXTRACT_SUBREG (i64 DoubleRegs:$src1), subreg_loreg)),
2574                  (i32 (EXTRACT_SUBREG (i64 DoubleRegs:$src2), subreg_hireg)))),
2575                32)), subreg_loreg)))),
2576         (i32 (EXTRACT_SUBREG (i64 DoubleRegs:$src1), subreg_hireg)),
2577         (i32 (EXTRACT_SUBREG (i64 DoubleRegs:$src2), subreg_hireg))))>;
2578
2579 // Multiply 64-bit signed and use upper result.
2580 def : Pat <(mulhs (i64 DoubleRegs:$src1), (i64 DoubleRegs:$src2)),
2581       (i64
2582        (MPY64_acc
2583         (i64
2584          (COMBINE_rr (TFRI 0),
2585           (i32
2586            (EXTRACT_SUBREG
2587             (i64
2588              (LSRd_ri
2589               (i64
2590                (MPY64_acc
2591                 (i64
2592                  (MPY64_acc
2593                   (i64
2594                    (COMBINE_rr (TFRI 0),
2595                     (i32
2596                      (EXTRACT_SUBREG
2597                       (i64
2598                        (LSRd_ri
2599                         (i64
2600                          (MPYU64 (i32 (EXTRACT_SUBREG (i64 DoubleRegs:$src1),
2601                                                       subreg_loreg)),
2602                                  (i32 (EXTRACT_SUBREG (i64 DoubleRegs:$src2),
2603                                                       subreg_loreg)))), 32)),
2604                       subreg_loreg)))),
2605                   (i32 (EXTRACT_SUBREG (i64 DoubleRegs:$src1), subreg_hireg)),
2606                   (i32 (EXTRACT_SUBREG (i64 DoubleRegs:$src2), subreg_loreg)))),
2607                 (i32 (EXTRACT_SUBREG (i64 DoubleRegs:$src1), subreg_loreg)),
2608                 (i32 (EXTRACT_SUBREG (i64 DoubleRegs:$src2), subreg_hireg)))),
2609               32)), subreg_loreg)))),
2610         (i32 (EXTRACT_SUBREG (i64 DoubleRegs:$src1), subreg_hireg)),
2611         (i32 (EXTRACT_SUBREG (i64 DoubleRegs:$src2), subreg_hireg))))>;
2612
2613 // Hexagon specific ISD nodes.
2614 //def SDTHexagonADJDYNALLOC : SDTypeProfile<1, 2, [SDTCisSameAs<0, 1>]>;
2615 def SDTHexagonADJDYNALLOC : SDTypeProfile<1, 2,
2616                                   [SDTCisVT<0, i32>, SDTCisVT<1, i32>]>;
2617 def Hexagon_ADJDYNALLOC : SDNode<"HexagonISD::ADJDYNALLOC",
2618                                   SDTHexagonADJDYNALLOC>;
2619 // Needed to tag these instructions for stack layout.
2620 let usesCustomInserter = 1 in
2621 def ADJDYNALLOC : ALU32_ri<(outs IntRegs:$dst), (ins IntRegs:$src1,
2622                                                      s16Imm:$src2),
2623                   "$dst = add($src1, #$src2)",
2624                   [(set (i32 IntRegs:$dst),
2625                         (Hexagon_ADJDYNALLOC (i32 IntRegs:$src1),
2626                                              s16ImmPred:$src2))]>;
2627
2628 def SDTHexagonARGEXTEND : SDTypeProfile<1, 1, [SDTCisVT<0, i32>]>;
2629 def Hexagon_ARGEXTEND : SDNode<"HexagonISD::ARGEXTEND", SDTHexagonARGEXTEND>;
2630 def ARGEXTEND : ALU32_rr <(outs IntRegs:$dst), (ins IntRegs:$src1),
2631                 "$dst = $src1",
2632                 [(set (i32 IntRegs:$dst),
2633                       (Hexagon_ARGEXTEND (i32 IntRegs:$src1)))]>;
2634
2635 let AddedComplexity = 100 in
2636 def : Pat<(i32 (sext_inreg (Hexagon_ARGEXTEND (i32 IntRegs:$src1)), i16)),
2637       (COPY (i32 IntRegs:$src1))>;
2638
2639 def SDHexagonBR_JT: SDTypeProfile<0, 1, [SDTCisVT<0, i32>]>;
2640 def HexagonBR_JT: SDNode<"HexagonISD::BR_JT", SDHexagonBR_JT, [SDNPHasChain]>;
2641
2642 let isBranch=1, isIndirectBranch=1, isTerminator=1, isBarrier = 1 in
2643 def BR_JT : JRInst<(outs), (ins IntRegs:$src),
2644                    "jumpr $src",
2645                    [(HexagonBR_JT (i32 IntRegs:$src))]>;
2646
2647 let isBranch=1, isIndirectBranch=1, isTerminator=1 in
2648 def BRIND : JRInst<(outs), (ins IntRegs:$src),
2649                    "jumpr $src",
2650                    [(brind (i32 IntRegs:$src))]>;
2651
2652 def HexagonWrapperJT: SDNode<"HexagonISD::WrapperJT", SDTIntUnaryOp>;
2653
2654 def : Pat<(HexagonWrapperJT tjumptable:$dst),
2655           (i32 (CONST32_set_jt tjumptable:$dst))>;
2656
2657 // XTYPE/SHIFT
2658
2659 // Multi-class for logical operators :
2660 // Shift by immediate/register and accumulate/logical
2661 multiclass xtype_imm<string OpcStr, SDNode OpNode1, SDNode OpNode2> {
2662   def _ri : SInst_acc<(outs IntRegs:$dst),
2663             (ins IntRegs:$src1, IntRegs:$src2, u5Imm:$src3),
2664             !strconcat("$dst ", !strconcat(OpcStr, "($src2, #$src3)")),
2665             [(set (i32 IntRegs:$dst),
2666                   (OpNode2 (i32 IntRegs:$src1),
2667                            (OpNode1 (i32 IntRegs:$src2),
2668                                     u5ImmPred:$src3)))],
2669             "$src1 = $dst">;
2670
2671   def d_ri : SInst_acc<(outs DoubleRegs:$dst),
2672             (ins DoubleRegs:$src1, DoubleRegs:$src2, u6Imm:$src3),
2673             !strconcat("$dst ", !strconcat(OpcStr, "($src2, #$src3)")),
2674             [(set (i64 DoubleRegs:$dst), (OpNode2 (i64 DoubleRegs:$src1),
2675                           (OpNode1 (i64 DoubleRegs:$src2), u6ImmPred:$src3)))],
2676             "$src1 = $dst">;
2677 }
2678
2679 // Multi-class for logical operators :
2680 // Shift by register and accumulate/logical (32/64 bits)
2681 multiclass xtype_reg<string OpcStr, SDNode OpNode1, SDNode OpNode2> {
2682   def _rr : SInst_acc<(outs IntRegs:$dst),
2683             (ins IntRegs:$src1, IntRegs:$src2, IntRegs:$src3),
2684             !strconcat("$dst ", !strconcat(OpcStr, "($src2, $src3)")),
2685             [(set (i32 IntRegs:$dst),
2686                   (OpNode2 (i32 IntRegs:$src1),
2687                            (OpNode1 (i32 IntRegs:$src2),
2688                                     (i32 IntRegs:$src3))))],
2689             "$src1 = $dst">;
2690
2691   def d_rr : SInst_acc<(outs DoubleRegs:$dst),
2692             (ins DoubleRegs:$src1, DoubleRegs:$src2, IntRegs:$src3),
2693             !strconcat("$dst ", !strconcat(OpcStr, "($src2, $src3)")),
2694             [(set (i64 DoubleRegs:$dst),
2695                   (OpNode2 (i64 DoubleRegs:$src1),
2696                            (OpNode1 (i64 DoubleRegs:$src2),
2697                                     (i32 IntRegs:$src3))))],
2698             "$src1 = $dst">;
2699
2700 }
2701
2702 multiclass basic_xtype_imm<string OpcStr, SDNode OpNode> {
2703 let AddedComplexity = 100 in
2704   defm _ADD : xtype_imm< !strconcat("+= ", OpcStr), OpNode, add>;
2705   defm _SUB : xtype_imm< !strconcat("-= ", OpcStr), OpNode, sub>;
2706   defm _AND : xtype_imm< !strconcat("&= ", OpcStr), OpNode, and>;
2707   defm _OR  : xtype_imm< !strconcat("|= ", OpcStr), OpNode, or>;
2708 }
2709
2710 multiclass basic_xtype_reg<string OpcStr, SDNode OpNode> {
2711 let AddedComplexity = 100 in
2712   defm _ADD : xtype_reg< !strconcat("+= ", OpcStr), OpNode, add>;
2713   defm _SUB : xtype_reg< !strconcat("-= ", OpcStr), OpNode, sub>;
2714   defm _AND : xtype_reg< !strconcat("&= ", OpcStr), OpNode, and>;
2715   defm _OR  : xtype_reg< !strconcat("|= ", OpcStr), OpNode, or>;
2716 }
2717
2718 multiclass xtype_xor_imm<string OpcStr, SDNode OpNode> {
2719 let AddedComplexity = 100 in
2720   defm _XOR : xtype_imm< !strconcat("^= ", OpcStr), OpNode, xor>;
2721 }
2722
2723 defm ASL : basic_xtype_imm<"asl", shl>, basic_xtype_reg<"asl", shl>,
2724            xtype_xor_imm<"asl", shl>;
2725
2726 defm LSR : basic_xtype_imm<"lsr", srl>, basic_xtype_reg<"lsr", srl>,
2727            xtype_xor_imm<"lsr", srl>;
2728
2729 defm ASR : basic_xtype_imm<"asr", sra>, basic_xtype_reg<"asr", sra>;
2730 defm LSL : basic_xtype_reg<"lsl", shl>;
2731
2732 // Change the sign of the immediate for Rd=-mpyi(Rs,#u8)
2733 def : Pat <(mul (i32 IntRegs:$src1), (ineg n8ImmPred:$src2)),
2734       (i32 (MPYI_rin (i32 IntRegs:$src1), u8ImmPred:$src2))>;
2735
2736 //===----------------------------------------------------------------------===//
2737 // V3 Instructions +
2738 //===----------------------------------------------------------------------===//
2739
2740 include "HexagonInstrInfoV3.td"
2741
2742 //===----------------------------------------------------------------------===//
2743 // V3 Instructions -
2744 //===----------------------------------------------------------------------===//
2745
2746 //===----------------------------------------------------------------------===//
2747 // V4 Instructions +
2748 //===----------------------------------------------------------------------===//
2749
2750 include "HexagonInstrInfoV4.td"
2751
2752 //===----------------------------------------------------------------------===//
2753 // V4 Instructions -
2754 //===----------------------------------------------------------------------===//
2755
2756 //===----------------------------------------------------------------------===//
2757 // V5 Instructions +
2758 //===----------------------------------------------------------------------===//
2759
2760 include "HexagonInstrInfoV5.td"
2761
2762 //===----------------------------------------------------------------------===//
2763 // V5 Instructions -
2764 //===----------------------------------------------------------------------===//