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