lib/Target/Hexagon/HexagonInstrInfo.td

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