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