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