lib/Target/Hexagon/HexagonInstrInfo.td

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