lib/Target/ARM/ARMInstrThumb2.td

   1 //===- ARMInstrThumb2.td - Thumb2 support for ARM -------------------------===//
   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 Thumb2 instruction set.
  11 //
  12 //===----------------------------------------------------------------------===//
  13
  14 // IT block predicate field
  15 def it_pred : Operand<i32> {
  16   let PrintMethod = "printMandatoryPredicateOperand";
  17 }
  18
  19 // IT block condition mask
  20 def it_mask : Operand<i32> {
  21   let PrintMethod = "printThumbITMask";
  22 }
  23
  24 // Shifted operands. No register controlled shifts for Thumb2.
  25 // Note: We do not support rrx shifted operands yet.
  26 def t2_so_reg : Operand<i32>,    // reg imm
  27                 ComplexPattern<i32, 2, "SelectT2ShifterOperandReg",
  28                                [shl,srl,sra,rotr]> {
  29   let EncoderMethod = "getT2SORegOpValue";
  30   let PrintMethod = "printT2SOOperand";
  31   let MIOperandInfo = (ops rGPR, i32imm);
  32 }
  33
  34 // t2_so_imm_not_XFORM - Return the complement of a t2_so_imm value
  35 def t2_so_imm_not_XFORM : SDNodeXForm<imm, [{
  36   return CurDAG->getTargetConstant(~((uint32_t)N->getZExtValue()), MVT::i32);
  37 }]>;
  38
  39 // t2_so_imm_neg_XFORM - Return the negation of a t2_so_imm value
  40 def t2_so_imm_neg_XFORM : SDNodeXForm<imm, [{
  41   return CurDAG->getTargetConstant(-((int)N->getZExtValue()), MVT::i32);
  42 }]>;
  43
  44 // t2_so_imm - Match a 32-bit immediate operand, which is an
  45 // 8-bit immediate rotated by an arbitrary number of bits, or an 8-bit
  46 // immediate splatted into multiple bytes of the word. t2_so_imm values are
  47 // represented in the imm field in the same 12-bit form that they are encoded
  48 // into t2_so_imm instructions: the 8-bit immediate is the least significant
  49 // bits [bits 0-7], the 4-bit shift/splat amount is the next 4 bits [bits 8-11].
  50 def t2_so_imm : Operand<i32>, PatLeaf<(imm), [{ return Pred_t2_so_imm(N); }]> {
  51   let EncoderMethod = "getT2SOImmOpValue";
  52 }
  53
  54 // t2_so_imm_not - Match an immediate that is a complement
  55 // of a t2_so_imm.
  56 def t2_so_imm_not : Operand<i32>,
  57                     PatLeaf<(imm), [{
  58   return ARM_AM::getT2SOImmVal(~((uint32_t)N->getZExtValue())) != -1;
  59 }], t2_so_imm_not_XFORM>;
  60
  61 // t2_so_imm_neg - Match an immediate that is a negation of a t2_so_imm.
  62 def t2_so_imm_neg : Operand<i32>,
  63                     PatLeaf<(imm), [{
  64   return ARM_AM::getT2SOImmVal(-((uint32_t)N->getZExtValue())) != -1;
  65 }], t2_so_imm_neg_XFORM>;
  66
  67 // Break t2_so_imm's up into two pieces.  This handles immediates with up to 16
  68 // bits set in them.  This uses t2_so_imm2part to match and t2_so_imm2part_[12]
  69 // to get the first/second pieces.
  70 def t2_so_imm2part : Operand<i32>,
  71                   PatLeaf<(imm), [{
  72       return ARM_AM::isT2SOImmTwoPartVal((unsigned)N->getZExtValue());
  73     }]> {
  74 }
  75
  76 def t2_so_imm2part_1 : SDNodeXForm<imm, [{
  77   unsigned V = ARM_AM::getT2SOImmTwoPartFirst((unsigned)N->getZExtValue());
  78   return CurDAG->getTargetConstant(V, MVT::i32);
  79 }]>;
  80
  81 def t2_so_imm2part_2 : SDNodeXForm<imm, [{
  82   unsigned V = ARM_AM::getT2SOImmTwoPartSecond((unsigned)N->getZExtValue());
  83   return CurDAG->getTargetConstant(V, MVT::i32);
  84 }]>;
  85
  86 def t2_so_neg_imm2part : Operand<i32>, PatLeaf<(imm), [{
  87       return ARM_AM::isT2SOImmTwoPartVal(-(int)N->getZExtValue());
  88     }]> {
  89 }
  90
  91 def t2_so_neg_imm2part_1 : SDNodeXForm<imm, [{
  92   unsigned V = ARM_AM::getT2SOImmTwoPartFirst(-(int)N->getZExtValue());
  93   return CurDAG->getTargetConstant(V, MVT::i32);
  94 }]>;
  95
  96 def t2_so_neg_imm2part_2 : SDNodeXForm<imm, [{
  97   unsigned V = ARM_AM::getT2SOImmTwoPartSecond(-(int)N->getZExtValue());
  98   return CurDAG->getTargetConstant(V, MVT::i32);
  99 }]>;
 100
 101 /// imm1_31 predicate - True if the 32-bit immediate is in the range [1,31].
 102 def imm1_31 : PatLeaf<(i32 imm), [{
 103   return (int32_t)N->getZExtValue() >= 1 && (int32_t)N->getZExtValue() < 32;
 104 }]>;
 105
 106 /// imm0_4095 predicate - True if the 32-bit immediate is in the range [0.4095].
 107 def imm0_4095 : Operand<i32>,
 108                 PatLeaf<(i32 imm), [{
 109   return (uint32_t)N->getZExtValue() < 4096;
 110 }]>;
 111
 112 def imm0_4095_neg : PatLeaf<(i32 imm), [{
 113  return (uint32_t)(-N->getZExtValue()) < 4096;
 114 }], imm_neg_XFORM>;
 115
 116 def imm0_255_neg : PatLeaf<(i32 imm), [{
 117   return (uint32_t)(-N->getZExtValue()) < 255;
 118 }], imm_neg_XFORM>;
 119
 120 def imm0_255_not : PatLeaf<(i32 imm), [{
 121   return (uint32_t)(~N->getZExtValue()) < 255;
 122 }], imm_comp_XFORM>;
 123
 124 // Define Thumb2 specific addressing modes.
 125
 126 // t2addrmode_imm12  := reg + imm12
 127 def t2addrmode_imm12 : Operand<i32>,
 128                        ComplexPattern<i32, 2, "SelectT2AddrModeImm12", []> {
 129   let PrintMethod = "printAddrModeImm12Operand";
 130   string EncoderMethod = "getAddrModeImm12OpValue";
 131   let MIOperandInfo = (ops GPR:$base, i32imm:$offsimm);
 132 }
 133
 134 // t2addrmode_imm8  := reg +/- imm8
 135 def t2addrmode_imm8 : Operand<i32>,
 136                       ComplexPattern<i32, 2, "SelectT2AddrModeImm8", []> {
 137   let PrintMethod = "printT2AddrModeImm8Operand";
 138   string EncoderMethod = "getT2AddrModeImm8OpValue";
 139   let MIOperandInfo = (ops GPR:$base, i32imm:$offsimm);
 140 }
 141
 142 def t2am_imm8_offset : Operand<i32>,
 143                        ComplexPattern<i32, 1, "SelectT2AddrModeImm8Offset",
 144                                       [], [SDNPWantRoot]> {
 145   let PrintMethod = "printT2AddrModeImm8OffsetOperand";
 146   string EncoderMethod = "getT2AddrModeImm8OffsetOpValue";
 147 }
 148
 149 // t2addrmode_imm8s4  := reg +/- (imm8 << 2)
 150 def t2addrmode_imm8s4 : Operand<i32> {
 151   let PrintMethod = "printT2AddrModeImm8s4Operand";
 152   let MIOperandInfo = (ops GPR:$base, i32imm:$offsimm);
 153 }
 154
 155 def t2am_imm8s4_offset : Operand<i32> {
 156   let PrintMethod = "printT2AddrModeImm8s4OffsetOperand";
 157 }
 158
 159 // t2addrmode_so_reg  := reg + (reg << imm2)
 160 def t2addrmode_so_reg : Operand<i32>,
 161                         ComplexPattern<i32, 3, "SelectT2AddrModeSoReg", []> {
 162   let PrintMethod = "printT2AddrModeSoRegOperand";
 163   string EncoderMethod = "getT2AddrModeSORegOpValue";
 164   let MIOperandInfo = (ops GPR:$base, rGPR:$offsreg, i32imm:$offsimm);
 165 }
 166
 167
 168 //===----------------------------------------------------------------------===//
 169 // Multiclass helpers...
 170 //
 171
 172
 173 class T2OneRegImm<dag oops, dag iops, InstrItinClass itin,
 174            string opc, string asm, list<dag> pattern>
 175   : T2I<oops, iops, itin, opc, asm, pattern> {
 176   bits<4> Rd;
 177   bits<12> imm;
 178
 179   let Inst{11-8}  = Rd{3-0};
 180   let Inst{26}    = imm{11};
 181   let Inst{14-12} = imm{10-8};
 182   let Inst{7-0}   = imm{7-0};
 183 }
 184
 185
 186 class T2sOneRegImm<dag oops, dag iops, InstrItinClass itin,
 187            string opc, string asm, list<dag> pattern>
 188   : T2sI<oops, iops, itin, opc, asm, pattern> {
 189   bits<4> Rd;
 190   bits<4> Rn;
 191   bits<12> imm;
 192
 193   let Inst{11-8}  = Rd{3-0};
 194   let Inst{26}    = imm{11};
 195   let Inst{14-12} = imm{10-8};
 196   let Inst{7-0}   = imm{7-0};
 197 }
 198
 199 class T2OneRegCmpImm<dag oops, dag iops, InstrItinClass itin,
 200            string opc, string asm, list<dag> pattern>
 201   : T2I<oops, iops, itin, opc, asm, pattern> {
 202   bits<4> Rn;
 203   bits<12> imm;
 204
 205   let Inst{19-16}  = Rn{3-0};
 206   let Inst{26}    = imm{11};
 207   let Inst{14-12} = imm{10-8};
 208   let Inst{7-0}   = imm{7-0};
 209 }
 210
 211
 212 class T2OneRegShiftedReg<dag oops, dag iops, InstrItinClass itin,
 213            string opc, string asm, list<dag> pattern>
 214   : T2I<oops, iops, itin, opc, asm, pattern> {
 215   bits<4> Rd;
 216   bits<12> ShiftedRm;
 217
 218   let Inst{11-8}  = Rd{3-0};
 219   let Inst{3-0}   = ShiftedRm{3-0};
 220   let Inst{5-4}   = ShiftedRm{6-5};
 221   let Inst{14-12} = ShiftedRm{11-9};
 222   let Inst{7-6}   = ShiftedRm{8-7};
 223 }
 224
 225 class T2sOneRegShiftedReg<dag oops, dag iops, InstrItinClass itin,
 226            string opc, string asm, list<dag> pattern>
 227   : T2I<oops, iops, itin, opc, asm, pattern> {
 228   bits<4> Rd;
 229   bits<12> ShiftedRm;
 230
 231   let Inst{11-8}  = Rd{3-0};
 232   let Inst{3-0}   = ShiftedRm{3-0};
 233   let Inst{5-4}   = ShiftedRm{6-5};
 234   let Inst{14-12} = ShiftedRm{11-9};
 235   let Inst{7-6}   = ShiftedRm{8-7};
 236 }
 237
 238 class T2OneRegCmpShiftedReg<dag oops, dag iops, InstrItinClass itin,
 239            string opc, string asm, list<dag> pattern>
 240   : T2I<oops, iops, itin, opc, asm, pattern> {
 241   bits<4> Rn;
 242   bits<12> ShiftedRm;
 243
 244   let Inst{19-16} = Rn{3-0};
 245   let Inst{3-0}   = ShiftedRm{3-0};
 246   let Inst{5-4}   = ShiftedRm{6-5};
 247   let Inst{14-12} = ShiftedRm{11-9};
 248   let Inst{7-6}   = ShiftedRm{8-7};
 249 }
 250
 251 class T2TwoReg<dag oops, dag iops, InstrItinClass itin,
 252            string opc, string asm, list<dag> pattern>
 253   : T2I<oops, iops, itin, opc, asm, pattern> {
 254   bits<4> Rd;
 255   bits<4> Rm;
 256
 257   let Inst{11-8}  = Rd{3-0};
 258   let Inst{3-0}   = Rm{3-0};
 259 }
 260
 261 class T2sTwoReg<dag oops, dag iops, InstrItinClass itin,
 262            string opc, string asm, list<dag> pattern>
 263   : T2sI<oops, iops, itin, opc, asm, pattern> {
 264   bits<4> Rd;
 265   bits<4> Rm;
 266
 267   let Inst{11-8}  = Rd{3-0};
 268   let Inst{3-0}   = Rm{3-0};
 269 }
 270
 271 class T2TwoRegCmp<dag oops, dag iops, InstrItinClass itin,
 272            string opc, string asm, list<dag> pattern>
 273   : T2I<oops, iops, itin, opc, asm, pattern> {
 274   bits<4> Rn;
 275   bits<4> Rm;
 276
 277   let Inst{19-16} = Rn{3-0};
 278   let Inst{3-0}   = Rm{3-0};
 279 }
 280
 281
 282 class T2TwoRegImm<dag oops, dag iops, InstrItinClass itin,
 283            string opc, string asm, list<dag> pattern>
 284   : T2I<oops, iops, itin, opc, asm, pattern> {
 285   bits<4> Rd;
 286   bits<4> Rm;
 287
 288   let Inst{11-8}  = Rd{3-0};
 289   let Inst{3-0}   = Rm{3-0};
 290 }
 291
 292 class T2sTwoRegImm<dag oops, dag iops, InstrItinClass itin,
 293            string opc, string asm, list<dag> pattern>
 294   : T2sI<oops, iops, itin, opc, asm, pattern> {
 295   bits<4> Rd;
 296   bits<4> Rn;
 297   bits<12> imm;
 298
 299   let Inst{11-8}  = Rd{3-0};
 300   let Inst{19-16} = Rn{3-0};
 301   let Inst{26}    = imm{11};
 302   let Inst{14-12} = imm{10-8};
 303   let Inst{7-0}   = imm{7-0};
 304 }
 305
 306 class T2TwoRegShiftImm<dag oops, dag iops, InstrItinClass itin,
 307            string opc, string asm, list<dag> pattern>
 308   : T2I<oops, iops, itin, opc, asm, pattern> {
 309   bits<4> Rd;
 310   bits<4> Rm;
 311   bits<5> imm;
 312
 313   let Inst{11-8}  = Rd{3-0};
 314   let Inst{3-0}   = Rm{3-0};
 315   let Inst{14-12} = imm{4-2};
 316   let Inst{7-6}   = imm{1-0};
 317 }
 318
 319 class T2sTwoRegShiftImm<dag oops, dag iops, InstrItinClass itin,
 320            string opc, string asm, list<dag> pattern>
 321   : T2sI<oops, iops, itin, opc, asm, pattern> {
 322   bits<4> Rd;
 323   bits<4> Rm;
 324   bits<5> imm;
 325
 326   let Inst{11-8}  = Rd{3-0};
 327   let Inst{3-0}   = Rm{3-0};
 328   let Inst{14-12} = imm{4-2};
 329   let Inst{7-6}   = imm{1-0};
 330 }
 331
 332 class T2ThreeReg<dag oops, dag iops, InstrItinClass itin,
 333            string opc, string asm, list<dag> pattern>
 334   : T2I<oops, iops, itin, opc, asm, pattern> {
 335   bits<4> Rd;
 336   bits<4> Rn;
 337   bits<4> Rm;
 338
 339   let Inst{11-8}  = Rd{3-0};
 340   let Inst{19-16} = Rn{3-0};
 341   let Inst{3-0}   = Rm{3-0};
 342 }
 343
 344 class T2sThreeReg<dag oops, dag iops, InstrItinClass itin,
 345            string opc, string asm, list<dag> pattern>
 346   : T2sI<oops, iops, itin, opc, asm, pattern> {
 347   bits<4> Rd;
 348   bits<4> Rn;
 349   bits<4> Rm;
 350
 351   let Inst{11-8}  = Rd{3-0};
 352   let Inst{19-16} = Rn{3-0};
 353   let Inst{3-0}   = Rm{3-0};
 354 }
 355
 356 class T2TwoRegShiftedReg<dag oops, dag iops, InstrItinClass itin,
 357            string opc, string asm, list<dag> pattern>
 358   : T2I<oops, iops, itin, opc, asm, pattern> {
 359   bits<4> Rd;
 360   bits<4> Rn;
 361   bits<12> ShiftedRm;
 362
 363   let Inst{11-8}  = Rd{3-0};
 364   let Inst{19-16} = Rn{3-0};
 365   let Inst{3-0}   = ShiftedRm{3-0};
 366   let Inst{5-4}   = ShiftedRm{6-5};
 367   let Inst{14-12} = ShiftedRm{11-9};
 368   let Inst{7-6}   = ShiftedRm{8-7};
 369 }
 370
 371 class T2sTwoRegShiftedReg<dag oops, dag iops, InstrItinClass itin,
 372            string opc, string asm, list<dag> pattern>
 373   : T2sI<oops, iops, itin, opc, asm, pattern> {
 374   bits<4> Rd;
 375   bits<4> Rn;
 376   bits<12> ShiftedRm;
 377
 378   let Inst{11-8}  = Rd{3-0};
 379   let Inst{19-16} = Rn{3-0};
 380   let Inst{3-0}   = ShiftedRm{3-0};
 381   let Inst{5-4}   = ShiftedRm{6-5};
 382   let Inst{14-12} = ShiftedRm{11-9};
 383   let Inst{7-6}   = ShiftedRm{8-7};
 384 }
 385
 386 class T2FourReg<dag oops, dag iops, InstrItinClass itin,
 387            string opc, string asm, list<dag> pattern>
 388   : T2I<oops, iops, itin, opc, asm, pattern> {
 389   bits<4> Rd;
 390   bits<4> Rn;
 391   bits<4> Rm;
 392   bits<4> Ra;
 393
 394   let Inst{11-8}  = Rd{3-0};
 395   let Inst{19-16} = Rn{3-0};
 396   let Inst{3-0}   = Rm{3-0};
 397   let Inst{15-12} = Ra{3-0};
 398 }
 399
 400
 401 /// T2I_un_irs - Defines a set of (op reg, {so_imm|r|so_reg}) patterns for a
 402 /// unary operation that produces a value. These are predicable and can be
 403 /// changed to modify CPSR.
 404 multiclass T2I_un_irs<bits<4> opcod, string opc,
 405                      InstrItinClass iii, InstrItinClass iir, InstrItinClass iis,
 406                       PatFrag opnode, bit Cheap = 0, bit ReMat = 0> {
 407    // shifted imm
 408    def i : T2sOneRegImm<(outs rGPR:$Rd), (ins t2_so_imm:$imm), iii,
 409                 opc, "\t$Rd, $imm",
 410                 [(set rGPR:$Rd, (opnode t2_so_imm:$imm))]> {
 411      let isAsCheapAsAMove = Cheap;
 412      let isReMaterializable = ReMat;
 413      let Inst{31-27} = 0b11110;
 414      let Inst{25} = 0;
 415      let Inst{24-21} = opcod;
 416      let Inst{20} = ?; // The S bit.
 417      let Inst{19-16} = 0b1111; // Rn
 418      let Inst{15} = 0;
 419    }
 420    // register
 421    def r : T2sTwoReg<(outs rGPR:$Rd), (ins rGPR:$Rm), iir,
 422                 opc, ".w\t$Rd, $Rm",
 423                 [(set rGPR:$Rd, (opnode rGPR:$Rm))]> {
 424      let Inst{31-27} = 0b11101;
 425      let Inst{26-25} = 0b01;
 426      let Inst{24-21} = opcod;
 427      let Inst{20} = ?; // The S bit.
 428      let Inst{19-16} = 0b1111; // Rn
 429      let Inst{14-12} = 0b000; // imm3
 430      let Inst{7-6} = 0b00; // imm2
 431      let Inst{5-4} = 0b00; // type
 432    }
 433    // shifted register
 434    def s : T2sOneRegShiftedReg<(outs rGPR:$Rd), (ins t2_so_reg:$ShiftedRm), iis,
 435                 opc, ".w\t$Rd, $ShiftedRm",
 436                 [(set rGPR:$Rd, (opnode t2_so_reg:$ShiftedRm))]> {
 437      let Inst{31-27} = 0b11101;
 438      let Inst{26-25} = 0b01;
 439      let Inst{24-21} = opcod;
 440      let Inst{20} = ?; // The S bit.
 441      let Inst{19-16} = 0b1111; // Rn
 442    }
 443 }
 444
 445 /// T2I_bin_irs - Defines a set of (op reg, {so_imm|r|so_reg}) patterns for a
 446 /// binary operation that produces a value. These are predicable and can be
 447 /// changed to modify CPSR.
 448 multiclass T2I_bin_irs<bits<4> opcod, string opc,
 449                      InstrItinClass iii, InstrItinClass iir, InstrItinClass iis,
 450                        PatFrag opnode, bit Commutable = 0, string wide = ""> {
 451    // shifted imm
 452    def ri : T2sTwoRegImm<
 453                 (outs rGPR:$Rd), (ins rGPR:$Rn, t2_so_imm:$imm), iii,
 454                  opc, "\t$Rd, $Rn, $imm",
 455                  [(set rGPR:$Rd, (opnode rGPR:$Rn, t2_so_imm:$imm))]> {
 456      let Inst{31-27} = 0b11110;
 457      let Inst{25} = 0;
 458      let Inst{24-21} = opcod;
 459      let Inst{20} = ?; // The S bit.
 460      let Inst{15} = 0;
 461    }
 462    // register
 463    def rr : T2sThreeReg<(outs rGPR:$Rd), (ins rGPR:$Rn, rGPR:$Rm), iir,
 464                  opc, !strconcat(wide, "\t$Rd, $Rn, $Rm"),
 465                  [(set rGPR:$Rd, (opnode rGPR:$Rn, rGPR:$Rm))]> {
 466      let isCommutable = Commutable;
 467      let Inst{31-27} = 0b11101;
 468      let Inst{26-25} = 0b01;
 469      let Inst{24-21} = opcod;
 470      let Inst{20} = ?; // The S bit.
 471      let Inst{14-12} = 0b000; // imm3
 472      let Inst{7-6} = 0b00; // imm2
 473      let Inst{5-4} = 0b00; // type
 474    }
 475    // shifted register
 476    def rs : T2sTwoRegShiftedReg<
 477                  (outs rGPR:$Rd), (ins rGPR:$Rn, t2_so_reg:$ShiftedRm), iis,
 478                  opc, !strconcat(wide, "\t$Rd, $Rn, $ShiftedRm"),
 479                  [(set rGPR:$Rd, (opnode rGPR:$Rn, t2_so_reg:$ShiftedRm))]> {
 480      let Inst{31-27} = 0b11101;
 481      let Inst{26-25} = 0b01;
 482      let Inst{24-21} = opcod;
 483      let Inst{20} = ?; // The S bit.
 484    }
 485 }
 486
 487 /// T2I_bin_w_irs - Same as T2I_bin_irs except these operations need
 488 //  the ".w" prefix to indicate that they are wide.
 489 multiclass T2I_bin_w_irs<bits<4> opcod, string opc,
 490                      InstrItinClass iii, InstrItinClass iir, InstrItinClass iis,
 491                          PatFrag opnode, bit Commutable = 0> :
 492     T2I_bin_irs<opcod, opc, iii, iir, iis, opnode, Commutable, ".w">;
 493
 494 /// T2I_rbin_is - Same as T2I_bin_irs except the order of operands are
 495 /// reversed.  The 'rr' form is only defined for the disassembler; for codegen
 496 /// it is equivalent to the T2I_bin_irs counterpart.
 497 multiclass T2I_rbin_irs<bits<4> opcod, string opc, PatFrag opnode> {
 498    // shifted imm
 499    def ri : T2sTwoRegImm<
 500                  (outs rGPR:$Rd), (ins rGPR:$Rn, t2_so_imm:$imm), IIC_iALUi,
 501                  opc, ".w\t$Rd, $Rn, $imm",
 502                  [(set rGPR:$Rd, (opnode t2_so_imm:$imm, rGPR:$Rn))]> {
 503      let Inst{31-27} = 0b11110;
 504      let Inst{25} = 0;
 505      let Inst{24-21} = opcod;
 506      let Inst{20} = ?; // The S bit.
 507      let Inst{15} = 0;
 508    }
 509    // register
 510    def rr : T2sThreeReg<
 511                  (outs rGPR:$Rd), (ins rGPR:$Rn, rGPR:$Rm), IIC_iALUr,
 512                  opc, "\t$Rd, $Rn, $Rm",
 513                  [/* For disassembly only; pattern left blank */]> {
 514      let Inst{31-27} = 0b11101;
 515      let Inst{26-25} = 0b01;
 516      let Inst{24-21} = opcod;
 517      let Inst{20} = ?; // The S bit.
 518      let Inst{14-12} = 0b000; // imm3
 519      let Inst{7-6} = 0b00; // imm2
 520      let Inst{5-4} = 0b00; // type
 521    }
 522    // shifted register
 523    def rs : T2sTwoRegShiftedReg<
 524                  (outs rGPR:$Rd), (ins rGPR:$Rn, t2_so_reg:$ShiftedRm),
 525                  IIC_iALUsir, opc, "\t$Rd, $Rn, $ShiftedRm",
 526                  [(set rGPR:$Rd, (opnode t2_so_reg:$ShiftedRm, rGPR:$Rn))]> {
 527      let Inst{31-27} = 0b11101;
 528      let Inst{26-25} = 0b01;
 529      let Inst{24-21} = opcod;
 530      let Inst{20} = ?; // The S bit.
 531    }
 532 }
 533
 534 /// T2I_bin_s_irs - Similar to T2I_bin_irs except it sets the 's' bit so the
 535 /// instruction modifies the CPSR register.
 536 let Defs = [CPSR] in {
 537 multiclass T2I_bin_s_irs<bits<4> opcod, string opc,
 538                      InstrItinClass iii, InstrItinClass iir, InstrItinClass iis,
 539                          PatFrag opnode, bit Commutable = 0> {
 540    // shifted imm
 541    def ri : T2TwoRegImm<
 542                 (outs rGPR:$Rd), (ins GPR:$Rn, t2_so_imm:$imm), iii,
 543                 !strconcat(opc, "s"), ".w\t$Rd, $Rn, $imm",
 544                 [(set rGPR:$Rd, (opnode GPR:$Rn, t2_so_imm:$imm))]> {
 545      let Inst{31-27} = 0b11110;
 546      let Inst{25} = 0;
 547      let Inst{24-21} = opcod;
 548      let Inst{20} = 1; // The S bit.
 549      let Inst{15} = 0;
 550    }
 551    // register
 552    def rr : T2ThreeReg<
 553                 (outs rGPR:$Rd), (ins GPR:$Rn, rGPR:$Rm), iir,
 554                 !strconcat(opc, "s"), ".w\t$Rd, $Rn, $Rm",
 555                 [(set rGPR:$Rd, (opnode GPR:$Rn, rGPR:$Rm))]> {
 556      let isCommutable = Commutable;
 557      let Inst{31-27} = 0b11101;
 558      let Inst{26-25} = 0b01;
 559      let Inst{24-21} = opcod;
 560      let Inst{20} = 1; // The S bit.
 561      let Inst{14-12} = 0b000; // imm3
 562      let Inst{7-6} = 0b00; // imm2
 563      let Inst{5-4} = 0b00; // type
 564    }
 565    // shifted register
 566    def rs : T2TwoRegShiftedReg<
 567                 (outs rGPR:$Rd), (ins GPR:$Rn, t2_so_reg:$ShiftedRm), iis,
 568                 !strconcat(opc, "s"), ".w\t$Rd, $Rn, $ShiftedRm",
 569                 [(set rGPR:$Rd, (opnode GPR:$Rn, t2_so_reg:$ShiftedRm))]> {
 570      let Inst{31-27} = 0b11101;
 571      let Inst{26-25} = 0b01;
 572      let Inst{24-21} = opcod;
 573      let Inst{20} = 1; // The S bit.
 574    }
 575 }
 576 }
 577
 578 /// T2I_bin_ii12rs - Defines a set of (op reg, {so_imm|imm0_4095|r|so_reg})
 579 /// patterns for a binary operation that produces a value.
 580 multiclass T2I_bin_ii12rs<bits<3> op23_21, string opc, PatFrag opnode,
 581                           bit Commutable = 0> {
 582    // shifted imm
 583    // The register-immediate version is re-materializable. This is useful
 584    // in particular for taking the address of a local.
 585    let isReMaterializable = 1 in {
 586    def ri : T2sTwoRegImm<
 587                  (outs rGPR:$Rd), (ins GPR:$Rn, t2_so_imm:$imm), IIC_iALUi,
 588                  opc, ".w\t$Rd, $Rn, $imm",
 589                  [(set rGPR:$Rd, (opnode GPR:$Rn, t2_so_imm:$imm))]> {
 590      let Inst{31-27} = 0b11110;
 591      let Inst{25} = 0;
 592      let Inst{24} = 1;
 593      let Inst{23-21} = op23_21;
 594      let Inst{20} = 0; // The S bit.
 595      let Inst{15} = 0;
 596    }
 597    }
 598    // 12-bit imm
 599    def ri12 : T2TwoRegImm<
 600                   (outs rGPR:$Rd), (ins GPR:$Rn, imm0_4095:$imm), IIC_iALUi,
 601                   !strconcat(opc, "w"), "\t$Rd, $Rn, $imm",
 602                   [(set rGPR:$Rd, (opnode GPR:$Rn, imm0_4095:$imm))]> {
 603      let Inst{31-27} = 0b11110;
 604      let Inst{25} = 1;
 605      let Inst{24} = 0;
 606      let Inst{23-21} = op23_21;
 607      let Inst{20} = 0; // The S bit.
 608      let Inst{15} = 0;
 609    }
 610    // register
 611    def rr : T2sThreeReg<(outs rGPR:$Rd), (ins GPR:$Rn, rGPR:$Rm), IIC_iALUr,
 612                  opc, ".w\t$Rd, $Rn, $Rm",
 613                  [(set rGPR:$Rd, (opnode GPR:$Rn, rGPR:$Rm))]> {
 614      let isCommutable = Commutable;
 615      let Inst{31-27} = 0b11101;
 616      let Inst{26-25} = 0b01;
 617      let Inst{24} = 1;
 618      let Inst{23-21} = op23_21;
 619      let Inst{20} = 0; // The S bit.
 620      let Inst{14-12} = 0b000; // imm3
 621      let Inst{7-6} = 0b00; // imm2
 622      let Inst{5-4} = 0b00; // type
 623    }
 624    // shifted register
 625    def rs : T2sTwoRegShiftedReg<
 626                  (outs rGPR:$Rd), (ins GPR:$Rn, t2_so_reg:$ShiftedRm),
 627                  IIC_iALUsi, opc, ".w\t$Rd, $Rn, $ShiftedRm",
 628                  [(set rGPR:$Rd, (opnode GPR:$Rn, t2_so_reg:$ShiftedRm))]> {
 629      let Inst{31-27} = 0b11101;
 630      let Inst{26-25} = 0b01;
 631      let Inst{24} = 1;
 632      let Inst{23-21} = op23_21;
 633      let Inst{20} = 0; // The S bit.
 634    }
 635 }
 636
 637 /// T2I_adde_sube_irs - Defines a set of (op reg, {so_imm|r|so_reg}) patterns
 638 /// for a binary operation that produces a value and use the carry
 639 /// bit. It's not predicable.
 640 let Uses = [CPSR] in {
 641 multiclass T2I_adde_sube_irs<bits<4> opcod, string opc, PatFrag opnode,
 642                              bit Commutable = 0> {
 643    // shifted imm
 644    def ri : T2sTwoRegImm<(outs rGPR:$Rd), (ins rGPR:$Rn, t2_so_imm:$imm),
 645                  IIC_iALUi, opc, "\t$Rd, $Rn, $imm",
 646                  [(set rGPR:$Rd, (opnode rGPR:$Rn, t2_so_imm:$imm))]>,
 647                  Requires<[IsThumb2]> {
 648      let Inst{31-27} = 0b11110;
 649      let Inst{25} = 0;
 650      let Inst{24-21} = opcod;
 651      let Inst{20} = 0; // The S bit.
 652      let Inst{15} = 0;
 653    }
 654    // register
 655    def rr : T2sThreeReg<(outs rGPR:$Rd), (ins rGPR:$Rn, rGPR:$Rm), IIC_iALUr,
 656                  opc, ".w\t$Rd, $Rn, $Rm",
 657                  [(set rGPR:$Rd, (opnode rGPR:$Rn, rGPR:$Rm))]>,
 658                  Requires<[IsThumb2]> {
 659      let isCommutable = Commutable;
 660      let Inst{31-27} = 0b11101;
 661      let Inst{26-25} = 0b01;
 662      let Inst{24-21} = opcod;
 663      let Inst{20} = 0; // The S bit.
 664      let Inst{14-12} = 0b000; // imm3
 665      let Inst{7-6} = 0b00; // imm2
 666      let Inst{5-4} = 0b00; // type
 667    }
 668    // shifted register
 669    def rs : T2sTwoRegShiftedReg<
 670                  (outs rGPR:$Rd), (ins rGPR:$Rn, t2_so_reg:$ShiftedRm),
 671                  IIC_iALUsi, opc, ".w\t$Rd, $Rn, $ShiftedRm",
 672                  [(set rGPR:$Rd, (opnode rGPR:$Rn, t2_so_reg:$ShiftedRm))]>,
 673                  Requires<[IsThumb2]> {
 674      let Inst{31-27} = 0b11101;
 675      let Inst{26-25} = 0b01;
 676      let Inst{24-21} = opcod;
 677      let Inst{20} = 0; // The S bit.
 678    }
 679 }
 680
 681 // Carry setting variants
 682 let Defs = [CPSR] in {
 683 multiclass T2I_adde_sube_s_irs<bits<4> opcod, string opc, PatFrag opnode,
 684                                bit Commutable = 0> {
 685    // shifted imm
 686    def ri : T2sTwoRegImm<
 687                  (outs rGPR:$Rd), (ins rGPR:$Rn, t2_so_imm:$imm), IIC_iALUi,
 688                  opc, "\t$Rd, $Rn, $imm",
 689                  [(set rGPR:$Rd, (opnode rGPR:$Rn, t2_so_imm:$imm))]>,
 690                  Requires<[IsThumb2]> {
 691      let Inst{31-27} = 0b11110;
 692      let Inst{25} = 0;
 693      let Inst{24-21} = opcod;
 694      let Inst{20} = 1; // The S bit.
 695      let Inst{15} = 0;
 696    }
 697    // register
 698    def rr : T2sThreeReg<(outs rGPR:$Rd), (ins rGPR:$Rn, rGPR:$Rm), IIC_iALUr,
 699                  opc, ".w\t$Rd, $Rn, $Rm",
 700                  [(set rGPR:$Rd, (opnode rGPR:$Rn, rGPR:$Rm))]>,
 701                  Requires<[IsThumb2]> {
 702      let isCommutable = Commutable;
 703      let Inst{31-27} = 0b11101;
 704      let Inst{26-25} = 0b01;
 705      let Inst{24-21} = opcod;
 706      let Inst{20} = 1; // The S bit.
 707      let Inst{14-12} = 0b000; // imm3
 708      let Inst{7-6} = 0b00; // imm2
 709      let Inst{5-4} = 0b00; // type
 710    }
 711    // shifted register
 712    def rs : T2sTwoRegShiftedReg<
 713                  (outs rGPR:$Rd), (ins rGPR:$Rn, t2_so_reg:$ShiftedRm),
 714                  IIC_iALUsi, opc, ".w\t$Rd, $Rn, $ShiftedRm",
 715                  [(set rGPR:$Rd, (opnode rGPR:$Rn, t2_so_reg:$ShiftedRm))]>,
 716                  Requires<[IsThumb2]> {
 717      let Inst{31-27} = 0b11101;
 718      let Inst{26-25} = 0b01;
 719      let Inst{24-21} = opcod;
 720      let Inst{20} = 1; // The S bit.
 721    }
 722 }
 723 }
 724 }
 725
 726 /// T2I_rbin_s_is - Same as T2I_rbin_irs except sets 's' bit and the register
 727 /// version is not needed since this is only for codegen.
 728 let Defs = [CPSR] in {
 729 multiclass T2I_rbin_s_is<bits<4> opcod, string opc, PatFrag opnode> {
 730    // shifted imm
 731    def ri : T2TwoRegImm<
 732                 (outs rGPR:$Rd), (ins rGPR:$Rn, t2_so_imm:$imm), IIC_iALUi,
 733                 !strconcat(opc, "s"), ".w\t$Rd, $Rn, $imm",
 734                 [(set rGPR:$Rd, (opnode t2_so_imm:$imm, rGPR:$Rn))]> {
 735      let Inst{31-27} = 0b11110;
 736      let Inst{25} = 0;
 737      let Inst{24-21} = opcod;
 738      let Inst{20} = 1; // The S bit.
 739      let Inst{15} = 0;
 740    }
 741    // shifted register
 742    def rs : T2TwoRegShiftedReg<
 743                 (outs rGPR:$Rd), (ins rGPR:$Rn, t2_so_reg:$ShiftedRm),
 744                 IIC_iALUsi, !strconcat(opc, "s"), "\t$Rd, $Rn, $ShiftedRm",
 745                 [(set rGPR:$Rd, (opnode t2_so_reg:$ShiftedRm, rGPR:$Rn))]> {
 746      let Inst{31-27} = 0b11101;
 747      let Inst{26-25} = 0b01;
 748      let Inst{24-21} = opcod;
 749      let Inst{20} = 1; // The S bit.
 750    }
 751 }
 752 }
 753
 754 /// T2I_sh_ir - Defines a set of (op reg, {so_imm|r}) patterns for a shift /
 755 //  rotate operation that produces a value.
 756 multiclass T2I_sh_ir<bits<2> opcod, string opc, PatFrag opnode> {
 757    // 5-bit imm
 758    def ri : T2sTwoRegShiftImm<
 759                  (outs rGPR:$Rd), (ins rGPR:$Rm, i32imm:$imm), IIC_iMOVsi,
 760                  opc, ".w\t$Rd, $Rm, $imm",
 761                  [(set rGPR:$Rd, (opnode rGPR:$Rm, imm1_31:$imm))]> {
 762      let Inst{31-27} = 0b11101;
 763      let Inst{26-21} = 0b010010;
 764      let Inst{19-16} = 0b1111; // Rn
 765      let Inst{5-4} = opcod;
 766    }
 767    // register
 768    def rr : T2sThreeReg<
 769                  (outs rGPR:$Rd), (ins rGPR:$Rn, rGPR:$Rm), IIC_iMOVsr,
 770                  opc, ".w\t$Rd, $Rn, $Rm",
 771                  [(set rGPR:$Rd, (opnode rGPR:$Rn, rGPR:$Rm))]> {
 772      let Inst{31-27} = 0b11111;
 773      let Inst{26-23} = 0b0100;
 774      let Inst{22-21} = opcod;
 775      let Inst{15-12} = 0b1111;
 776      let Inst{7-4} = 0b0000;
 777    }
 778 }
 779
 780 /// T2I_cmp_irs - Defines a set of (op r, {so_imm|r|so_reg}) cmp / test
 781 /// patterns. Similar to T2I_bin_irs except the instruction does not produce
 782 /// a explicit result, only implicitly set CPSR.
 783 let isCompare = 1, Defs = [CPSR] in {
 784 multiclass T2I_cmp_irs<bits<4> opcod, string opc,
 785                      InstrItinClass iii, InstrItinClass iir, InstrItinClass iis,
 786                        PatFrag opnode> {
 787    // shifted imm
 788    def ri : T2OneRegCmpImm<
 789                 (outs), (ins GPR:$Rn, t2_so_imm:$imm), iii,
 790                 opc, ".w\t$Rn, $imm",
 791                 [(opnode GPR:$Rn, t2_so_imm:$imm)]> {
 792      let Inst{31-27} = 0b11110;
 793      let Inst{25} = 0;
 794      let Inst{24-21} = opcod;
 795      let Inst{20} = 1; // The S bit.
 796      let Inst{15} = 0;
 797      let Inst{11-8} = 0b1111; // Rd
 798    }
 799    // register
 800    def rr : T2TwoRegCmp<
 801                 (outs), (ins GPR:$lhs, rGPR:$rhs), iir,
 802                 opc, ".w\t$lhs, $rhs",
 803                 [(opnode GPR:$lhs, rGPR:$rhs)]> {
 804      let Inst{31-27} = 0b11101;
 805      let Inst{26-25} = 0b01;
 806      let Inst{24-21} = opcod;
 807      let Inst{20} = 1; // The S bit.
 808      let Inst{14-12} = 0b000; // imm3
 809      let Inst{11-8} = 0b1111; // Rd
 810      let Inst{7-6} = 0b00; // imm2
 811      let Inst{5-4} = 0b00; // type
 812    }
 813    // shifted register
 814    def rs : T2OneRegCmpShiftedReg<
 815                 (outs), (ins GPR:$Rn, t2_so_reg:$ShiftedRm), iis,
 816                 opc, ".w\t$Rn, $ShiftedRm",
 817                 [(opnode GPR:$Rn, t2_so_reg:$ShiftedRm)]> {
 818      let Inst{31-27} = 0b11101;
 819      let Inst{26-25} = 0b01;
 820      let Inst{24-21} = opcod;
 821      let Inst{20} = 1; // The S bit.
 822      let Inst{11-8} = 0b1111; // Rd
 823    }
 824 }
 825 }
 826
 827 /// T2I_ld - Defines a set of (op r, {imm12|imm8|so_reg}) load patterns.
 828 multiclass T2I_ld<bit signed, bits<2> opcod, string opc,
 829                   InstrItinClass iii, InstrItinClass iis, PatFrag opnode> {
 830   def i12 : T2Ii12<(outs GPR:$Rt), (ins t2addrmode_imm12:$addr), iii,
 831                    opc, ".w\t$Rt, $addr",
 832                    [(set GPR:$Rt, (opnode t2addrmode_imm12:$addr))]> {
 833     let Inst{31-27} = 0b11111;
 834     let Inst{26-25} = 0b00;
 835     let Inst{24} = signed;
 836     let Inst{23} = 1;
 837     let Inst{22-21} = opcod;
 838     let Inst{20} = 1; // load
 839
 840     bits<4> Rt;
 841     let Inst{15-12} = Rt{3-0};
 842
 843     bits<17> addr;
 844     let Inst{19-16} = addr{16-13}; // Rn
 845     let Inst{23}    = addr{12};    // U
 846     let Inst{11-0}  = addr{11-0};  // imm
 847   }
 848   def i8  : T2Ii8 <(outs GPR:$Rt), (ins t2addrmode_imm8:$addr), iii,
 849                    opc, "\t$Rt, $addr",
 850                    [(set GPR:$Rt, (opnode t2addrmode_imm8:$addr))]> {
 851     let Inst{31-27} = 0b11111;
 852     let Inst{26-25} = 0b00;
 853     let Inst{24} = signed;
 854     let Inst{23} = 0;
 855     let Inst{22-21} = opcod;
 856     let Inst{20} = 1; // load
 857     let Inst{11} = 1;
 858     // Offset: index==TRUE, wback==FALSE
 859     let Inst{10} = 1; // The P bit.
 860     let Inst{8} = 0; // The W bit.
 861
 862     bits<4> Rt;
 863     let Inst{15-12} = Rt{3-0};
 864
 865     bits<13> addr;
 866     let Inst{19-16} = addr{12-9}; // Rn
 867     let Inst{9}     = addr{8};    // U
 868     let Inst{7-0}   = addr{7-0};  // imm
 869   }
 870   def s   : T2Iso <(outs GPR:$Rt), (ins t2addrmode_so_reg:$addr), iis,
 871                    opc, ".w\t$Rt, $addr",
 872                    [(set GPR:$Rt, (opnode t2addrmode_so_reg:$addr))]> {
 873     let Inst{31-27} = 0b11111;
 874     let Inst{26-25} = 0b00;
 875     let Inst{24} = signed;
 876     let Inst{23} = 0;
 877     let Inst{22-21} = opcod;
 878     let Inst{20} = 1; // load
 879     let Inst{11-6} = 0b000000;
 880
 881     bits<4> Rt;
 882     let Inst{15-12} = Rt{3-0};
 883
 884     bits<10> addr;
 885     let Inst{19-16} = addr{9-6}; // Rn
 886     let Inst{3-0}   = addr{5-2}; // Rm
 887     let Inst{5-4}   = addr{1-0}; // imm
 888   }
 889
 890   // FIXME: Is the pci variant actually needed?
 891   def pci : T2Ipc <(outs GPR:$Rt), (ins i32imm:$addr), iii,
 892                    opc, ".w\t$Rt, $addr",
 893                    [(set GPR:$Rt, (opnode (ARMWrapper tconstpool:$addr)))]> {
 894     let isReMaterializable = 1;
 895     let Inst{31-27} = 0b11111;
 896     let Inst{26-25} = 0b00;
 897     let Inst{24} = signed;
 898     let Inst{23} = ?; // add = (U == '1')
 899     let Inst{22-21} = opcod;
 900     let Inst{20} = 1; // load
 901     let Inst{19-16} = 0b1111; // Rn
 902
 903     bits<4> Rt;
 904     bits<12> addr;
 905     let Inst{15-12} = Rt{3-0};
 906     let Inst{11-0}  = addr{11-0};
 907   }
 908 }
 909
 910 /// T2I_st - Defines a set of (op r, {imm12|imm8|so_reg}) store patterns.
 911 multiclass T2I_st<bits<2> opcod, string opc,
 912                   InstrItinClass iii, InstrItinClass iis, PatFrag opnode> {
 913   def i12 : T2Ii12<(outs), (ins GPR:$Rt, t2addrmode_imm12:$addr), iii,
 914                    opc, ".w\t$Rt, $addr",
 915                    [(opnode GPR:$Rt, t2addrmode_imm12:$addr)]> {
 916     let Inst{31-27} = 0b11111;
 917     let Inst{26-23} = 0b0001;
 918     let Inst{22-21} = opcod;
 919     let Inst{20} = 0; // !load
 920
 921     bits<4> Rt;
 922     let Inst{15-12} = Rt{3-0};
 923
 924     bits<17> addr;
 925     let Inst{19-16} = addr{16-13}; // Rn
 926     let Inst{23}    = addr{12};    // U
 927     let Inst{11-0}  = addr{11-0};  // imm
 928   }
 929   def i8  : T2Ii8 <(outs), (ins GPR:$Rt, t2addrmode_imm8:$addr), iii,
 930                    opc, "\t$Rt, $addr",
 931                    [(opnode GPR:$Rt, t2addrmode_imm8:$addr)]> {
 932     let Inst{31-27} = 0b11111;
 933     let Inst{26-23} = 0b0000;
 934     let Inst{22-21} = opcod;
 935     let Inst{20} = 0; // !load
 936     let Inst{11} = 1;
 937     // Offset: index==TRUE, wback==FALSE
 938     let Inst{10} = 1; // The P bit.
 939     let Inst{8} = 0; // The W bit.
 940
 941     bits<4> Rt;
 942     let Inst{15-12} = Rt{3-0};
 943
 944     bits<13> addr;
 945     let Inst{19-16} = addr{12-9}; // Rn
 946     let Inst{9}     = addr{8};    // U
 947     let Inst{7-0}   = addr{7-0};  // imm
 948   }
 949   def s   : T2Iso <(outs), (ins GPR:$Rt, t2addrmode_so_reg:$addr), iis,
 950                    opc, ".w\t$Rt, $addr",
 951                    [(opnode GPR:$Rt, t2addrmode_so_reg:$addr)]> {
 952     let Inst{31-27} = 0b11111;
 953     let Inst{26-23} = 0b0000;
 954     let Inst{22-21} = opcod;
 955     let Inst{20} = 0; // !load
 956     let Inst{11-6} = 0b000000;
 957
 958     bits<4> Rt;
 959     let Inst{15-12} = Rt{3-0};
 960
 961     bits<10> addr;
 962     let Inst{19-16}   = addr{9-6}; // Rn
 963     let Inst{3-0} = addr{5-2}; // Rm
 964     let Inst{5-4}   = addr{1-0}; // imm
 965   }
 966 }
 967
 968 /// T2I_ext_rrot - A unary operation with two forms: one whose operand is a
 969 /// register and one whose operand is a register rotated by 8/16/24.
 970 multiclass T2I_ext_rrot<bits<3> opcod, string opc, PatFrag opnode> {
 971   def r     : T2TwoReg<(outs rGPR:$Rd), (ins rGPR:$Rm), IIC_iEXTr,
 972                   opc, ".w\t$Rd, $Rm",
 973                  [(set rGPR:$Rd, (opnode rGPR:$Rm))]> {
 974      let Inst{31-27} = 0b11111;
 975      let Inst{26-23} = 0b0100;
 976      let Inst{22-20} = opcod;
 977      let Inst{19-16} = 0b1111; // Rn
 978      let Inst{15-12} = 0b1111;
 979      let Inst{7} = 1;
 980      let Inst{5-4} = 0b00; // rotate
 981    }
 982   def r_rot : T2TwoReg<(outs rGPR:$Rd), (ins rGPR:$Rm, i32imm:$rot), IIC_iEXTr,
 983                   opc, ".w\t$Rd, $Rm, ror $rot",
 984                  [(set rGPR:$Rd, (opnode (rotr rGPR:$Rm, rot_imm:$rot)))]> {
 985      let Inst{31-27} = 0b11111;
 986      let Inst{26-23} = 0b0100;
 987      let Inst{22-20} = opcod;
 988      let Inst{19-16} = 0b1111; // Rn
 989      let Inst{15-12} = 0b1111;
 990      let Inst{7} = 1;
 991
 992      bits<2> rot;
 993      let Inst{5-4} = rot{1-0}; // rotate
 994    }
 995 }
 996
 997 // UXTB16 - Requres T2ExtractPack, does not need the .w qualifier.
 998 multiclass T2I_ext_rrot_uxtb16<bits<3> opcod, string opc, PatFrag opnode> {
 999   def r     : T2TwoReg<(outs rGPR:$Rd), (ins rGPR:$Rm), IIC_iEXTr,
1000                   opc, "\t$Rd, $Rm",
1001                  [(set rGPR:$Rd, (opnode rGPR:$Rm))]>,
1002                  Requires<[HasT2ExtractPack, IsThumb2]> {
1003      let Inst{31-27} = 0b11111;
1004      let Inst{26-23} = 0b0100;
1005      let Inst{22-20} = opcod;
1006      let Inst{19-16} = 0b1111; // Rn
1007      let Inst{15-12} = 0b1111;
1008      let Inst{7} = 1;
1009      let Inst{5-4} = 0b00; // rotate
1010    }
1011   def r_rot : T2TwoReg<(outs rGPR:$dst), (ins rGPR:$Rm, i32imm:$rot), IIC_iEXTr,
1012                   opc, "\t$dst, $Rm, ror $rot",
1013                  [(set rGPR:$dst, (opnode (rotr rGPR:$Rm, rot_imm:$rot)))]>,
1014                  Requires<[HasT2ExtractPack, IsThumb2]> {
1015      let Inst{31-27} = 0b11111;
1016      let Inst{26-23} = 0b0100;
1017      let Inst{22-20} = opcod;
1018      let Inst{19-16} = 0b1111; // Rn
1019      let Inst{15-12} = 0b1111;
1020      let Inst{7} = 1;
1021
1022      bits<2> rot;
1023      let Inst{5-4} = rot{1-0}; // rotate
1024    }
1025 }
1026
1027 // SXTB16 - Requres T2ExtractPack, does not need the .w qualifier, no pattern
1028 // supported yet.
1029 multiclass T2I_ext_rrot_sxtb16<bits<3> opcod, string opc> {
1030   def r     : T2TwoReg<(outs rGPR:$Rd), (ins rGPR:$Rm), IIC_iEXTr,
1031                   opc, "\t$Rd, $Rm", []> {
1032      let Inst{31-27} = 0b11111;
1033      let Inst{26-23} = 0b0100;
1034      let Inst{22-20} = opcod;
1035      let Inst{19-16} = 0b1111; // Rn
1036      let Inst{15-12} = 0b1111;
1037      let Inst{7} = 1;
1038      let Inst{5-4} = 0b00; // rotate
1039    }
1040   def r_rot : T2TwoReg<(outs rGPR:$Rd), (ins rGPR:$Rm, i32imm:$rot), IIC_iEXTr,
1041                   opc, "\t$Rd, $Rm, ror $rot", []> {
1042      let Inst{31-27} = 0b11111;
1043      let Inst{26-23} = 0b0100;
1044      let Inst{22-20} = opcod;
1045      let Inst{19-16} = 0b1111; // Rn
1046      let Inst{15-12} = 0b1111;
1047      let Inst{7} = 1;
1048
1049       bits<2> rot;
1050       let Inst{5-4} = rot{1-0}; // rotate
1051    }
1052 }
1053
1054 /// T2I_exta_rrot - A binary operation with two forms: one whose operand is a
1055 /// register and one whose operand is a register rotated by 8/16/24.
1056 multiclass T2I_exta_rrot<bits<3> opcod, string opc, PatFrag opnode> {
1057   def rr     : T2ThreeReg<(outs rGPR:$Rd), (ins rGPR:$Rn, rGPR:$Rm), IIC_iEXTAr,
1058                   opc, "\t$Rd, $Rn, $Rm",
1059                   [(set rGPR:$Rd, (opnode rGPR:$Rn, rGPR:$Rm))]>,
1060                   Requires<[HasT2ExtractPack, IsThumb2]> {
1061      let Inst{31-27} = 0b11111;
1062      let Inst{26-23} = 0b0100;
1063      let Inst{22-20} = opcod;
1064      let Inst{15-12} = 0b1111;
1065      let Inst{7} = 1;
1066      let Inst{5-4} = 0b00; // rotate
1067    }
1068   def rr_rot : T2ThreeReg<(outs rGPR:$Rd), (ins rGPR:$Rn, rGPR:$Rm, i32imm:$rot),
1069                   IIC_iEXTAsr, opc, "\t$Rd, $Rn, $Rm, ror $rot",
1070                   [(set rGPR:$Rd, (opnode rGPR:$Rn,
1071                                           (rotr rGPR:$Rm, rot_imm:$rot)))]>,
1072                   Requires<[HasT2ExtractPack, IsThumb2]> {
1073      let Inst{31-27} = 0b11111;
1074      let Inst{26-23} = 0b0100;
1075      let Inst{22-20} = opcod;
1076      let Inst{15-12} = 0b1111;
1077      let Inst{7} = 1;
1078
1079      bits<2> rot;
1080      let Inst{5-4} = rot{1-0}; // rotate
1081    }
1082 }
1083
1084 // DO variant - disassembly only, no pattern
1085
1086 multiclass T2I_exta_rrot_DO<bits<3> opcod, string opc> {
1087   def rr     : T2ThreeReg<(outs rGPR:$Rd), (ins rGPR:$Rn, rGPR:$Rm), IIC_iEXTAr,
1088                   opc, "\t$Rd, $Rn, $Rm", []> {
1089      let Inst{31-27} = 0b11111;
1090      let Inst{26-23} = 0b0100;
1091      let Inst{22-20} = opcod;
1092      let Inst{15-12} = 0b1111;
1093      let Inst{7} = 1;
1094      let Inst{5-4} = 0b00; // rotate
1095    }
1096   def rr_rot : T2ThreeReg<(outs rGPR:$Rd), (ins rGPR:$Rn, rGPR:$Rm, i32imm:$rot),
1097                   IIC_iEXTAsr, opc, "\t$Rd, $Rn, $Rm, ror $rot", []> {
1098      let Inst{31-27} = 0b11111;
1099      let Inst{26-23} = 0b0100;
1100      let Inst{22-20} = opcod;
1101      let Inst{15-12} = 0b1111;
1102      let Inst{7} = 1;
1103
1104      bits<2> rot;
1105      let Inst{5-4} = rot{1-0}; // rotate
1106    }
1107 }
1108
1109 //===----------------------------------------------------------------------===//
1110 // Instructions
1111 //===----------------------------------------------------------------------===//
1112
1113 //===----------------------------------------------------------------------===//
1114 //  Miscellaneous Instructions.
1115 //
1116
1117 class T2PCOneRegImm<dag oops, dag iops, InstrItinClass itin,
1118            string asm, list<dag> pattern>
1119   : T2XI<oops, iops, itin, asm, pattern> {
1120   bits<4> Rd;
1121   bits<12> label;
1122
1123   let Inst{11-8}  = Rd{3-0};
1124   let Inst{26}    = label{11};
1125   let Inst{14-12} = label{10-8};
1126   let Inst{7-0}   = label{7-0};
1127 }
1128
1129 // LEApcrel - Load a pc-relative address into a register without offending the
1130 // assembler.
1131 let neverHasSideEffects = 1 in {
1132 let isReMaterializable = 1 in
1133 def t2LEApcrel : T2PCOneRegImm<(outs rGPR:$Rd), (ins i32imm:$label, pred:$p), IIC_iALUi,
1134                       "adr${p}.w\t$Rd, #$label", []> {
1135   let Inst{31-27} = 0b11110;
1136   let Inst{25-24} = 0b10;
1137   // Inst{23:21} = '11' (add = FALSE) or '00' (add = TRUE)
1138   let Inst{22} = 0;
1139   let Inst{20} = 0;
1140   let Inst{19-16} = 0b1111; // Rn
1141   let Inst{15} = 0;
1142
1143
1144 }
1145 } // neverHasSideEffects
1146 def t2LEApcrelJT : T2PCOneRegImm<(outs rGPR:$Rd),
1147                         (ins i32imm:$label, nohash_imm:$id, pred:$p), IIC_iALUi,
1148                         "adr${p}.w\t$Rd, #${label}_${id}", []> {
1149   let Inst{31-27} = 0b11110;
1150   let Inst{25-24} = 0b10;
1151   // Inst{23:21} = '11' (add = FALSE) or '00' (add = TRUE)
1152   let Inst{22} = 0;
1153   let Inst{20} = 0;
1154   let Inst{19-16} = 0b1111; // Rn
1155   let Inst{15} = 0;
1156 }
1157
1158 // ADD r, sp, {so_imm|i12}
1159 def t2ADDrSPi   : T2sTwoRegImm<(outs GPR:$Rd), (ins GPR:$sp, t2_so_imm:$imm),
1160                         IIC_iALUi, "add", ".w\t$Rd, $sp, $imm", []> {
1161   let Inst{31-27} = 0b11110;
1162   let Inst{25} = 0;
1163   let Inst{24-21} = 0b1000;
1164   let Inst{20} = ?; // The S bit.
1165   let Inst{19-16} = 0b1101; // Rn = sp
1166   let Inst{15} = 0;
1167 }
1168 def t2ADDrSPi12 : T2TwoRegImm<(outs GPR:$Rd), (ins GPR:$sp, imm0_4095:$imm),
1169                        IIC_iALUi, "addw", "\t$Rd, $sp, $imm", []> {
1170   let Inst{31-27} = 0b11110;
1171   let Inst{25} = 1;
1172   let Inst{24-21} = 0b0000;
1173   let Inst{20} = 0; // The S bit.
1174   let Inst{19-16} = 0b1101; // Rn = sp
1175   let Inst{15} = 0;
1176 }
1177
1178 // ADD r, sp, so_reg
1179 def t2ADDrSPs   : T2sTwoRegShiftedReg<
1180                         (outs GPR:$Rd), (ins GPR:$sp, t2_so_reg:$ShiftedRm),
1181                         IIC_iALUsi, "add", ".w\t$Rd, $sp, $ShiftedRm", []> {
1182   let Inst{31-27} = 0b11101;
1183   let Inst{26-25} = 0b01;
1184   let Inst{24-21} = 0b1000;
1185   let Inst{20} = ?; // The S bit.
1186   let Inst{19-16} = 0b1101; // Rn = sp
1187   let Inst{15} = 0;
1188 }
1189
1190 // SUB r, sp, {so_imm|i12}
1191 def t2SUBrSPi   : T2sTwoRegImm<(outs GPR:$Rd), (ins GPR:$sp, t2_so_imm:$imm),
1192                         IIC_iALUi, "sub", ".w\t$Rd, $sp, $imm", []> {
1193   let Inst{31-27} = 0b11110;
1194   let Inst{25} = 0;
1195   let Inst{24-21} = 0b1101;
1196   let Inst{20} = ?; // The S bit.
1197   let Inst{19-16} = 0b1101; // Rn = sp
1198   let Inst{15} = 0;
1199 }
1200 def t2SUBrSPi12 : T2TwoRegImm<(outs GPR:$Rd), (ins GPR:$sp, imm0_4095:$imm),
1201                        IIC_iALUi, "subw", "\t$Rd, $sp, $imm", []> {
1202   let Inst{31-27} = 0b11110;
1203   let Inst{25} = 1;
1204   let Inst{24-21} = 0b0101;
1205   let Inst{20} = 0; // The S bit.
1206   let Inst{19-16} = 0b1101; // Rn = sp
1207   let Inst{15} = 0;
1208 }
1209
1210 // SUB r, sp, so_reg
1211 def t2SUBrSPs   : T2sTwoRegImm<(outs GPR:$Rd), (ins GPR:$sp, t2_so_reg:$imm),
1212                        IIC_iALUsi,
1213                        "sub", "\t$Rd, $sp, $imm", []> {
1214   let Inst{31-27} = 0b11101;
1215   let Inst{26-25} = 0b01;
1216   let Inst{24-21} = 0b1101;
1217   let Inst{20} = ?; // The S bit.
1218   let Inst{19-16} = 0b1101; // Rn = sp
1219   let Inst{15} = 0;
1220 }
1221
1222 // Signed and unsigned division on v7-M
1223 def t2SDIV : T2ThreeReg<(outs rGPR:$Rd), (ins rGPR:$Rn, rGPR:$Rm), IIC_iALUi,
1224                  "sdiv", "\t$Rd, $Rn, $Rm",
1225                  [(set rGPR:$Rd, (sdiv rGPR:$Rn, rGPR:$Rm))]>,
1226                  Requires<[HasDivide, IsThumb2]> {
1227   let Inst{31-27} = 0b11111;
1228   let Inst{26-21} = 0b011100;
1229   let Inst{20} = 0b1;
1230   let Inst{15-12} = 0b1111;
1231   let Inst{7-4} = 0b1111;
1232 }
1233
1234 def t2UDIV : T2ThreeReg<(outs rGPR:$Rd), (ins rGPR:$Rn, rGPR:$Rm), IIC_iALUi,
1235                  "udiv", "\t$Rd, $Rn, $Rm",
1236                  [(set rGPR:$Rd, (udiv rGPR:$Rn, rGPR:$Rm))]>,
1237                  Requires<[HasDivide, IsThumb2]> {
1238   let Inst{31-27} = 0b11111;
1239   let Inst{26-21} = 0b011101;
1240   let Inst{20} = 0b1;
1241   let Inst{15-12} = 0b1111;
1242   let Inst{7-4} = 0b1111;
1243 }
1244
1245 //===----------------------------------------------------------------------===//
1246 //  Load / store Instructions.
1247 //
1248
1249 // Load
1250 let canFoldAsLoad = 1, isReMaterializable = 1  in
1251 defm t2LDR   : T2I_ld<0, 0b10, "ldr", IIC_iLoad_i, IIC_iLoad_si,
1252                       UnOpFrag<(load node:$Src)>>;
1253
1254 // Loads with zero extension
1255 defm t2LDRH  : T2I_ld<0, 0b01, "ldrh", IIC_iLoad_bh_i, IIC_iLoad_bh_si,
1256                       UnOpFrag<(zextloadi16 node:$Src)>>;
1257 defm t2LDRB  : T2I_ld<0, 0b00, "ldrb", IIC_iLoad_bh_i, IIC_iLoad_bh_si,
1258                       UnOpFrag<(zextloadi8  node:$Src)>>;
1259
1260 // Loads with sign extension
1261 defm t2LDRSH : T2I_ld<1, 0b01, "ldrsh", IIC_iLoad_bh_i, IIC_iLoad_bh_si,
1262                       UnOpFrag<(sextloadi16 node:$Src)>>;
1263 defm t2LDRSB : T2I_ld<1, 0b00, "ldrsb", IIC_iLoad_bh_i, IIC_iLoad_bh_si,
1264                       UnOpFrag<(sextloadi8  node:$Src)>>;
1265
1266 let mayLoad = 1, neverHasSideEffects = 1, hasExtraDefRegAllocReq = 1,
1267     isCodeGenOnly = 1 in { // $dst doesn't exist in asmstring?
1268 // Load doubleword
1269 def t2LDRDi8  : T2Ii8s4<1, 0, 1, (outs rGPR:$dst1, rGPR:$dst2),
1270                         (ins t2addrmode_imm8s4:$addr),
1271                         IIC_iLoad_d_i, "ldrd", "\t$dst1, $addr", []>;
1272 def t2LDRDpci : T2Ii8s4<1, 0, 1, (outs rGPR:$dst1, rGPR:$dst2),
1273                         (ins i32imm:$addr), IIC_iLoad_d_i,
1274                        "ldrd", "\t$dst1, $addr", []> {
1275   let Inst{19-16} = 0b1111; // Rn
1276 }
1277 } // mayLoad = 1, neverHasSideEffects = 1, hasExtraDefRegAllocReq = 1
1278
1279 // zextload i1 -> zextload i8
1280 def : T2Pat<(zextloadi1 t2addrmode_imm12:$addr),
1281             (t2LDRBi12  t2addrmode_imm12:$addr)>;
1282 def : T2Pat<(zextloadi1 t2addrmode_imm8:$addr),
1283             (t2LDRBi8   t2addrmode_imm8:$addr)>;
1284 def : T2Pat<(zextloadi1 t2addrmode_so_reg:$addr),
1285             (t2LDRBs    t2addrmode_so_reg:$addr)>;
1286 def : T2Pat<(zextloadi1 (ARMWrapper tconstpool:$addr)),
1287             (t2LDRBpci  tconstpool:$addr)>;
1288
1289 // extload -> zextload
1290 // FIXME: Reduce the number of patterns by legalizing extload to zextload
1291 // earlier?
1292 def : T2Pat<(extloadi1  t2addrmode_imm12:$addr),
1293             (t2LDRBi12  t2addrmode_imm12:$addr)>;
1294 def : T2Pat<(extloadi1  t2addrmode_imm8:$addr),
1295             (t2LDRBi8   t2addrmode_imm8:$addr)>;
1296 def : T2Pat<(extloadi1  t2addrmode_so_reg:$addr),
1297             (t2LDRBs    t2addrmode_so_reg:$addr)>;
1298 def : T2Pat<(extloadi1  (ARMWrapper tconstpool:$addr)),
1299             (t2LDRBpci  tconstpool:$addr)>;
1300
1301 def : T2Pat<(extloadi8  t2addrmode_imm12:$addr),
1302             (t2LDRBi12  t2addrmode_imm12:$addr)>;
1303 def : T2Pat<(extloadi8  t2addrmode_imm8:$addr),
1304             (t2LDRBi8   t2addrmode_imm8:$addr)>;
1305 def : T2Pat<(extloadi8  t2addrmode_so_reg:$addr),
1306             (t2LDRBs    t2addrmode_so_reg:$addr)>;
1307 def : T2Pat<(extloadi8  (ARMWrapper tconstpool:$addr)),
1308             (t2LDRBpci  tconstpool:$addr)>;
1309
1310 def : T2Pat<(extloadi16 t2addrmode_imm12:$addr),
1311             (t2LDRHi12  t2addrmode_imm12:$addr)>;
1312 def : T2Pat<(extloadi16 t2addrmode_imm8:$addr),
1313             (t2LDRHi8   t2addrmode_imm8:$addr)>;
1314 def : T2Pat<(extloadi16 t2addrmode_so_reg:$addr),
1315             (t2LDRHs    t2addrmode_so_reg:$addr)>;
1316 def : T2Pat<(extloadi16 (ARMWrapper tconstpool:$addr)),
1317             (t2LDRHpci  tconstpool:$addr)>;
1318
1319 // FIXME: The destination register of the loads and stores can't be PC, but
1320 //        can be SP. We need another regclass (similar to rGPR) to represent
1321 //        that. Not a pressing issue since these are selected manually,
1322 //        not via pattern.
1323
1324 // Indexed loads
1325
1326 class T2Iidxld<bit signed, bits<2> opcod, bit pre,
1327                  dag oops, dag iops,
1328                  AddrMode am, IndexMode im, InstrItinClass itin,
1329                  string opc, string asm, string cstr, list<dag> pattern>
1330   : T2Iidxldst<signed, opcod, 1, pre, oops,
1331                iops, am,im,itin, opc, asm, cstr, pattern>;
1332 class T2Iidxst<bit signed, bits<2> opcod, bit pre,
1333                  dag oops, dag iops,
1334                  AddrMode am, IndexMode im, InstrItinClass itin,
1335                  string opc, string asm, string cstr, list<dag> pattern>
1336   : T2Iidxldst<signed, opcod, 0, pre, oops,
1337                iops, am,im,itin, opc, asm, cstr, pattern>;
1338
1339 let mayLoad = 1, neverHasSideEffects = 1 in {
1340 def t2LDR_PRE  : T2Iidxld<0, 0b10, 1, (outs GPR:$Rt, GPR:$Rn),
1341                             (ins t2addrmode_imm8:$addr),
1342                             AddrModeT2_i8, IndexModePre, IIC_iLoad_iu,
1343                             "ldr", "\t$Rt, $addr!", "$addr.base = $Rn",
1344                             []>;
1345
1346 def t2LDR_POST : T2Iidxld<0, 0b10, 0, (outs GPR:$Rt, GPR:$Rn),
1347                             (ins GPR:$base, t2am_imm8_offset:$offset),
1348                             AddrModeT2_i8, IndexModePost, IIC_iLoad_iu,
1349                           "ldr", "\t$Rt, [$Rn], $offset", "$base = $Rn",
1350                             []>;
1351
1352 def t2LDRB_PRE : T2Iidxld<0, 0b00, 1, (outs GPR:$Rt, GPR:$Rn),
1353                             (ins t2addrmode_imm8:$addr),
1354                             AddrModeT2_i8, IndexModePre, IIC_iLoad_bh_iu,
1355                             "ldrb", "\t$Rt, $addr!", "$addr.base = $Rn",
1356                             []>;
1357 def t2LDRB_POST : T2Iidxld<0, 0b00, 0, (outs GPR:$Rt, GPR:$Rn),
1358                             (ins GPR:$base, t2am_imm8_offset:$offset),
1359                             AddrModeT2_i8, IndexModePost, IIC_iLoad_bh_iu,
1360                          "ldrb", "\t$Rt, [$Rn], $offset", "$base = $Rn",
1361                             []>;
1362
1363 def t2LDRH_PRE : T2Iidxld<0, 0b01, 1, (outs GPR:$Rt, GPR:$Rn),
1364                             (ins t2addrmode_imm8:$addr),
1365                             AddrModeT2_i8, IndexModePre, IIC_iLoad_bh_iu,
1366                             "ldrh", "\t$Rt, $addr!", "$addr.base = $Rn",
1367                             []>;
1368 def t2LDRH_POST : T2Iidxld<0, 0b01, 0, (outs GPR:$Rt, GPR:$Rn),
1369                             (ins GPR:$base, t2am_imm8_offset:$offset),
1370                             AddrModeT2_i8, IndexModePost, IIC_iLoad_bh_iu,
1371                          "ldrh", "\t$Rt, [$Rn], $offset", "$base = $Rn",
1372                             []>;
1373
1374 def t2LDRSB_PRE : T2Iidxld<1, 0b00, 1, (outs GPR:$Rt, GPR:$Rn),
1375                             (ins t2addrmode_imm8:$addr),
1376                             AddrModeT2_i8, IndexModePre, IIC_iLoad_bh_iu,
1377                             "ldrsb", "\t$Rt, $addr!", "$addr.base = $Rn",
1378                             []>;
1379 def t2LDRSB_POST : T2Iidxld<1, 0b00, 0, (outs GPR:$Rt, GPR:$Rn),
1380                             (ins GPR:$base, t2am_imm8_offset:$offset),
1381                             AddrModeT2_i8, IndexModePost, IIC_iLoad_bh_iu,
1382                         "ldrsb", "\t$Rt, [$Rn], $offset", "$base = $Rn",
1383                             []>;
1384
1385 def t2LDRSH_PRE : T2Iidxld<1, 0b01, 1, (outs GPR:$Rt, GPR:$Rn),
1386                             (ins t2addrmode_imm8:$addr),
1387                             AddrModeT2_i8, IndexModePre, IIC_iLoad_bh_iu,
1388                             "ldrsh", "\t$Rt, $addr!", "$addr.base = $Rn",
1389                             []>;
1390 def t2LDRSH_POST : T2Iidxld<1, 0b01, 0, (outs GPR:$dst, GPR:$Rn),
1391                             (ins GPR:$base, t2am_imm8_offset:$offset),
1392                             AddrModeT2_i8, IndexModePost, IIC_iLoad_bh_iu,
1393                         "ldrsh", "\t$dst, [$Rn], $offset", "$base = $Rn",
1394                             []>;
1395 } // mayLoad = 1, neverHasSideEffects = 1
1396
1397 // LDRT, LDRBT, LDRHT, LDRSBT, LDRSHT all have offset mode (PUW=0b110) and are
1398 // for disassembly only.
1399 // Ref: A8.6.57 LDR (immediate, Thumb) Encoding T4
1400 class T2IldT<bit signed, bits<2> type, string opc, InstrItinClass ii>
1401   : T2Ii8<(outs GPR:$Rt), (ins t2addrmode_imm8:$addr), ii, opc,
1402           "\t$Rt, $addr", []> {
1403   let Inst{31-27} = 0b11111;
1404   let Inst{26-25} = 0b00;
1405   let Inst{24} = signed;
1406   let Inst{23} = 0;
1407   let Inst{22-21} = type;
1408   let Inst{20} = 1; // load
1409   let Inst{11} = 1;
1410   let Inst{10-8} = 0b110; // PUW.
1411
1412   bits<4> Rt;
1413   bits<13> addr;
1414   let Inst{15-12} = Rt{3-0};
1415   let Inst{19-16} = addr{12-9};
1416   let Inst{7-0}   = addr{7-0};
1417 }
1418
1419 def t2LDRT   : T2IldT<0, 0b10, "ldrt", IIC_iLoad_i>;
1420 def t2LDRBT  : T2IldT<0, 0b00, "ldrbt", IIC_iLoad_bh_i>;
1421 def t2LDRHT  : T2IldT<0, 0b01, "ldrht", IIC_iLoad_bh_i>;
1422 def t2LDRSBT : T2IldT<1, 0b00, "ldrsbt", IIC_iLoad_bh_i>;
1423 def t2LDRSHT : T2IldT<1, 0b01, "ldrsht", IIC_iLoad_bh_i>;
1424
1425 // Store
1426 defm t2STR :T2I_st<0b10,"str", IIC_iStore_i, IIC_iStore_si,
1427                    BinOpFrag<(store node:$LHS, node:$RHS)>>;
1428 defm t2STRB:T2I_st<0b00,"strb", IIC_iStore_bh_i, IIC_iStore_bh_si,
1429                    BinOpFrag<(truncstorei8 node:$LHS, node:$RHS)>>;
1430 defm t2STRH:T2I_st<0b01,"strh", IIC_iStore_bh_i, IIC_iStore_bh_si,
1431                    BinOpFrag<(truncstorei16 node:$LHS, node:$RHS)>>;
1432
1433 // Store doubleword
1434 let mayLoad = 1, neverHasSideEffects = 1, hasExtraSrcRegAllocReq = 1,
1435     isCodeGenOnly = 1 in  // $src2 doesn't exist in asm string
1436 def t2STRDi8 : T2Ii8s4<1, 0, 0, (outs),
1437                        (ins GPR:$src1, GPR:$src2, t2addrmode_imm8s4:$addr),
1438                IIC_iStore_d_r, "strd", "\t$src1, $addr", []>;
1439
1440 // Indexed stores
1441 def t2STR_PRE  : T2Iidxst<0, 0b10, 1, (outs GPR:$base_wb),
1442                             (ins GPR:$Rt, GPR:$Rn, t2am_imm8_offset:$addr),
1443                             AddrModeT2_i8, IndexModePre, IIC_iStore_iu,
1444                          "str", "\t$Rt, [$Rn, $addr]!", "$Rn = $base_wb",
1445              [(set GPR:$base_wb,
1446                    (pre_store GPR:$Rt, GPR:$Rn, t2am_imm8_offset:$addr))]>;
1447
1448 def t2STR_POST : T2Iidxst<0, 0b10, 0, (outs GPR:$base_wb),
1449                             (ins GPR:$Rt, GPR:$Rn, t2am_imm8_offset:$addr),
1450                             AddrModeT2_i8, IndexModePost, IIC_iStore_iu,
1451                           "str", "\t$Rt, [$Rn], $addr", "$Rn = $base_wb",
1452              [(set GPR:$base_wb,
1453                   (post_store GPR:$Rt, GPR:$Rn, t2am_imm8_offset:$addr))]>;
1454
1455 def t2STRH_PRE  : T2Iidxst<0, 0b01, 1, (outs GPR:$base_wb),
1456                             (ins GPR:$Rt, GPR:$Rn, t2am_imm8_offset:$addr),
1457                             AddrModeT2_i8, IndexModePre, IIC_iStore_iu,
1458                         "strh", "\t$Rt, [$Rn, $addr]!", "$Rn = $base_wb",
1459         [(set GPR:$base_wb,
1460               (pre_truncsti16 GPR:$Rt, GPR:$Rn, t2am_imm8_offset:$addr))]>;
1461
1462 def t2STRH_POST : T2Iidxst<0, 0b01, 0, (outs GPR:$base_wb),
1463                             (ins GPR:$Rt, GPR:$Rn, t2am_imm8_offset:$addr),
1464                             AddrModeT2_i8, IndexModePost, IIC_iStore_bh_iu,
1465                          "strh", "\t$Rt, [$Rn], $addr", "$Rn = $base_wb",
1466        [(set GPR:$base_wb,
1467              (post_truncsti16 GPR:$Rt, GPR:$Rn, t2am_imm8_offset:$addr))]>;
1468
1469 def t2STRB_PRE  : T2Iidxst<0, 0b00, 1, (outs GPR:$base_wb),
1470                             (ins GPR:$Rt, GPR:$Rn, t2am_imm8_offset:$addr),
1471                             AddrModeT2_i8, IndexModePre, IIC_iStore_bh_iu,
1472                         "strb", "\t$Rt, [$Rn, $addr]!", "$Rn = $base_wb",
1473          [(set GPR:$base_wb,
1474                (pre_truncsti8 GPR:$Rt, GPR:$Rn, t2am_imm8_offset:$addr))]>;
1475
1476 def t2STRB_POST : T2Iidxst<0, 0b00, 0, (outs GPR:$base_wb),
1477                             (ins GPR:$Rt, GPR:$Rn, t2am_imm8_offset:$addr),
1478                             AddrModeT2_i8, IndexModePost, IIC_iStore_bh_iu,
1479                          "strb", "\t$Rt, [$Rn], $addr", "$Rn = $base_wb",
1480         [(set GPR:$base_wb,
1481               (post_truncsti8 GPR:$Rt, GPR:$Rn, t2am_imm8_offset:$addr))]>;
1482
1483 // STRT, STRBT, STRHT all have offset mode (PUW=0b110) and are for disassembly
1484 // only.
1485 // Ref: A8.6.193 STR (immediate, Thumb) Encoding T4
1486 class T2IstT<bits<2> type, string opc, InstrItinClass ii>
1487   : T2Ii8<(outs GPR:$Rt), (ins t2addrmode_imm8:$addr), ii, opc,
1488           "\t$Rt, $addr", []> {
1489   let Inst{31-27} = 0b11111;
1490   let Inst{26-25} = 0b00;
1491   let Inst{24} = 0; // not signed
1492   let Inst{23} = 0;
1493   let Inst{22-21} = type;
1494   let Inst{20} = 0; // store
1495   let Inst{11} = 1;
1496   let Inst{10-8} = 0b110; // PUW
1497
1498   bits<4> Rt;
1499   bits<13> addr;
1500   let Inst{15-12} = Rt{3-0};
1501   let Inst{19-16} = addr{12-9};
1502   let Inst{7-0}   = addr{7-0};
1503 }
1504
1505 def t2STRT   : T2IstT<0b10, "strt", IIC_iStore_i>;
1506 def t2STRBT  : T2IstT<0b00, "strbt", IIC_iStore_bh_i>;
1507 def t2STRHT  : T2IstT<0b01, "strht", IIC_iStore_bh_i>;
1508
1509 // ldrd / strd pre / post variants
1510 // For disassembly only.
1511
1512 def t2LDRD_PRE  : T2Ii8s4<1, 1, 1, (outs GPR:$dst1, GPR:$dst2),
1513                  (ins GPR:$base, t2am_imm8s4_offset:$imm), IIC_iLoad_d_ru,
1514                  "ldrd", "\t$dst1, $dst2, [$base, $imm]!", []>;
1515
1516 def t2LDRD_POST : T2Ii8s4<0, 1, 1, (outs GPR:$dst1, GPR:$dst2),
1517                  (ins GPR:$base, t2am_imm8s4_offset:$imm), IIC_iLoad_d_ru,
1518                  "ldrd", "\t$dst1, $dst2, [$base], $imm", []>;
1519
1520 def t2STRD_PRE  : T2Ii8s4<1, 1, 0, (outs),
1521                  (ins GPR:$src1, GPR:$src2, GPR:$base, t2am_imm8s4_offset:$imm),
1522                  IIC_iStore_d_ru, "strd", "\t$src1, $src2, [$base, $imm]!", []>;
1523
1524 def t2STRD_POST : T2Ii8s4<0, 1, 0, (outs),
1525                  (ins GPR:$src1, GPR:$src2, GPR:$base, t2am_imm8s4_offset:$imm),
1526                  IIC_iStore_d_ru, "strd", "\t$src1, $src2, [$base], $imm", []>;
1527
1528 // T2Ipl (Preload Data/Instruction) signals the memory system of possible future
1529 // data/instruction access.  These are for disassembly only.
1530 // instr_write is inverted for Thumb mode: (prefetch 3) -> (preload 0),
1531 // (prefetch 1) -> (preload 2),  (prefetch 2) -> (preload 1).
1532 multiclass T2Ipl<bits<1> write, bits<1> instr, string opc> {
1533
1534   def i12 : T2Ii12<(outs), (ins t2addrmode_imm12:$addr), IIC_Preload, opc,
1535                 "\t$addr",
1536               [(ARMPreload t2addrmode_imm12:$addr, (i32 write), (i32 instr))]> {
1537     let Inst{31-25} = 0b1111100;
1538     let Inst{24} = instr;
1539     let Inst{22} = 0;
1540     let Inst{21} = write;
1541     let Inst{20} = 1;
1542     let Inst{15-12} = 0b1111;
1543
1544     bits<17> addr;
1545     let Inst{19-16} = addr{16-13}; // Rn
1546     let Inst{23}    = addr{12};    // U
1547     let Inst{11-0}  = addr{11-0};  // imm12
1548   }
1549
1550   def i8 : T2Ii8<(outs), (ins t2addrmode_imm8:$addr), IIC_Preload, opc,
1551                 "\t$addr",
1552                [(ARMPreload t2addrmode_imm8:$addr, (i32 write), (i32 instr))]> {
1553     let Inst{31-25} = 0b1111100;
1554     let Inst{24} = instr;
1555     let Inst{23} = 0; // U = 0
1556     let Inst{22} = 0;
1557     let Inst{21} = write;
1558     let Inst{20} = 1;
1559     let Inst{15-12} = 0b1111;
1560     let Inst{11-8} = 0b1100;
1561
1562     bits<13> addr;
1563     let Inst{19-16} = addr{12-9}; // Rn
1564     let Inst{7-0}   = addr{7-0};  // imm8
1565   }
1566
1567   def s : T2Iso<(outs), (ins t2addrmode_so_reg:$addr), IIC_Preload, opc,
1568                "\t$addr",
1569              [(ARMPreload t2addrmode_so_reg:$addr, (i32 write), (i32 instr))]> {
1570     let Inst{31-25} = 0b1111100;
1571     let Inst{24} = instr;
1572     let Inst{23} = 0; // add = TRUE for T1
1573     let Inst{22} = 0;
1574     let Inst{21} = write;
1575     let Inst{20} = 1;
1576     let Inst{15-12} = 0b1111;
1577     let Inst{11-6} = 0000000;
1578
1579     bits<10> addr;
1580     let Inst{19-16} = addr{9-6}; // Rn
1581     let Inst{3-0}   = addr{5-2}; // Rm
1582     let Inst{5-4}   = addr{1-0}; // imm2
1583   }
1584 }
1585
1586 defm t2PLD  : T2Ipl<0, 0, "pld">,  Requires<[IsThumb2]>;
1587 defm t2PLDW : T2Ipl<1, 0, "pldw">, Requires<[IsThumb2,HasV7,HasMP]>;
1588 defm t2PLI  : T2Ipl<0, 1, "pli">,  Requires<[IsThumb2,HasV7]>;
1589
1590 //===----------------------------------------------------------------------===//
1591 //  Load / store multiple Instructions.
1592 //
1593
1594 multiclass thumb2_ldst_mult<string asm, InstrItinClass itin,
1595                             InstrItinClass itin_upd, bit L_bit> {
1596   def IA :
1597     T2XI<(outs), (ins GPR:$Rn, pred:$p, reglist:$regs, variable_ops),
1598          itin, !strconcat(asm, "ia${p}.w\t$Rn, $regs"), []> {
1599     bits<4>  Rn;
1600     bits<16> regs;
1601
1602     let Inst{31-27} = 0b11101;
1603     let Inst{26-25} = 0b00;
1604     let Inst{24-23} = 0b01;     // Increment After
1605     let Inst{22}    = 0;
1606     let Inst{21}    = 0;        // No writeback
1607     let Inst{20}    = L_bit;
1608     let Inst{19-16} = Rn;
1609     let Inst{15-0}  = regs;
1610   }
1611   def IA_UPD :
1612     T2XIt<(outs GPR:$wb), (ins GPR:$Rn, pred:$p, reglist:$regs, variable_ops),
1613           itin_upd, !strconcat(asm, "ia${p}.w\t$Rn!, $regs"), "$Rn = $wb", []> {
1614     bits<4>  Rn;
1615     bits<16> regs;
1616
1617     let Inst{31-27} = 0b11101;
1618     let Inst{26-25} = 0b00;
1619     let Inst{24-23} = 0b01;     // Increment After
1620     let Inst{22}    = 0;
1621     let Inst{21}    = 1;        // Writeback
1622     let Inst{20}    = L_bit;
1623     let Inst{19-16} = Rn;
1624     let Inst{15-0}  = regs;
1625   }
1626   def DB :
1627     T2XI<(outs), (ins GPR:$Rn, pred:$p, reglist:$regs, variable_ops),
1628          itin, !strconcat(asm, "db${p}.w\t$Rn, $regs"), []> {
1629     bits<4>  Rn;
1630     bits<16> regs;
1631
1632     let Inst{31-27} = 0b11101;
1633     let Inst{26-25} = 0b00;
1634     let Inst{24-23} = 0b10;     // Decrement Before
1635     let Inst{22}    = 0;
1636     let Inst{21}    = 0;        // No writeback
1637     let Inst{20}    = L_bit;
1638     let Inst{19-16} = Rn;
1639     let Inst{15-0}  = regs;
1640   }
1641   def DB_UPD :
1642     T2XIt<(outs GPR:$wb), (ins GPR:$Rn, pred:$p, reglist:$regs, variable_ops),
1643           itin_upd, !strconcat(asm, "db${p}.w\t$Rn, $regs"), "$Rn = $wb", []> {
1644     bits<4>  Rn;
1645     bits<16> regs;
1646
1647     let Inst{31-27} = 0b11101;
1648     let Inst{26-25} = 0b00;
1649     let Inst{24-23} = 0b10;     // Decrement Before
1650     let Inst{22}    = 0;
1651     let Inst{21}    = 1;        // Writeback
1652     let Inst{20}    = L_bit;
1653     let Inst{19-16} = Rn;
1654     let Inst{15-0}  = regs;
1655   }
1656 }
1657
1658 let neverHasSideEffects = 1 in {
1659
1660 let mayLoad = 1, hasExtraDefRegAllocReq = 1 in
1661 defm t2LDM : thumb2_ldst_mult<"ldm", IIC_iLoad_m, IIC_iLoad_mu, 1>;
1662
1663 let mayStore = 1, hasExtraSrcRegAllocReq = 1 in
1664 defm t2STM : thumb2_ldst_mult<"stm", IIC_iStore_m, IIC_iStore_mu, 0>;
1665
1666 } // neverHasSideEffects
1667
1668
1669 //===----------------------------------------------------------------------===//
1670 //  Move Instructions.
1671 //
1672
1673 let neverHasSideEffects = 1 in
1674 def t2MOVr : T2sTwoReg<(outs GPR:$Rd), (ins GPR:$Rm), IIC_iMOVr,
1675                    "mov", ".w\t$Rd, $Rm", []> {
1676   let Inst{31-27} = 0b11101;
1677   let Inst{26-25} = 0b01;
1678   let Inst{24-21} = 0b0010;
1679   let Inst{20} = ?; // The S bit.
1680   let Inst{19-16} = 0b1111; // Rn
1681   let Inst{14-12} = 0b000;
1682   let Inst{7-4} = 0b0000;
1683 }
1684
1685 // AddedComplexity to ensure isel tries t2MOVi before t2MOVi16.
1686 let isReMaterializable = 1, isAsCheapAsAMove = 1, isMoveImm = 1,
1687     AddedComplexity = 1 in
1688 def t2MOVi : T2sOneRegImm<(outs rGPR:$Rd), (ins t2_so_imm:$imm), IIC_iMOVi,
1689                    "mov", ".w\t$Rd, $imm",
1690                    [(set rGPR:$Rd, t2_so_imm:$imm)]> {
1691   let Inst{31-27} = 0b11110;
1692   let Inst{25} = 0;
1693   let Inst{24-21} = 0b0010;
1694   let Inst{20} = ?; // The S bit.
1695   let Inst{19-16} = 0b1111; // Rn
1696   let Inst{15} = 0;
1697 }
1698
1699 let isReMaterializable = 1, isAsCheapAsAMove = 1, isMoveImm = 1 in
1700 def t2MOVi16 : T2I<(outs rGPR:$Rd), (ins i32imm:$imm), IIC_iMOVi,
1701                    "movw", "\t$Rd, $imm",
1702                    [(set rGPR:$Rd, imm0_65535:$imm)]> {
1703   let Inst{31-27} = 0b11110;
1704   let Inst{25} = 1;
1705   let Inst{24-21} = 0b0010;
1706   let Inst{20} = 0; // The S bit.
1707   let Inst{15} = 0;
1708
1709   bits<4> Rd;
1710   bits<16> imm;
1711
1712   let Inst{11-8}  = Rd{3-0};
1713   let Inst{19-16} = imm{15-12};
1714   let Inst{26}    = imm{11};
1715   let Inst{14-12} = imm{10-8};
1716   let Inst{7-0}   = imm{7-0};
1717 }
1718
1719 let Constraints = "$src = $Rd" in
1720 def t2MOVTi16 : T2I<(outs rGPR:$Rd), (ins rGPR:$src, i32imm:$imm), IIC_iMOVi,
1721                     "movt", "\t$Rd, $imm",
1722                     [(set rGPR:$Rd,
1723                           (or (and rGPR:$src, 0xffff), lo16AllZero:$imm))]> {
1724   let Inst{31-27} = 0b11110;
1725   let Inst{25} = 1;
1726   let Inst{24-21} = 0b0110;
1727   let Inst{20} = 0; // The S bit.
1728   let Inst{15} = 0;
1729
1730   bits<4> Rd;
1731   bits<16> imm;
1732
1733   let Inst{11-8}  = Rd{3-0};
1734   let Inst{19-16} = imm{15-12};
1735   let Inst{26}    = imm{11};
1736   let Inst{14-12} = imm{10-8};
1737   let Inst{7-0}   = imm{7-0};
1738 }
1739
1740 def : T2Pat<(or rGPR:$src, 0xffff0000), (t2MOVTi16 rGPR:$src, 0xffff)>;
1741
1742 //===----------------------------------------------------------------------===//
1743 //  Extend Instructions.
1744 //
1745
1746 // Sign extenders
1747
1748 defm t2SXTB  : T2I_ext_rrot<0b100, "sxtb",
1749                               UnOpFrag<(sext_inreg node:$Src, i8)>>;
1750 defm t2SXTH  : T2I_ext_rrot<0b000, "sxth",
1751                               UnOpFrag<(sext_inreg node:$Src, i16)>>;
1752 defm t2SXTB16 : T2I_ext_rrot_sxtb16<0b010, "sxtb16">;
1753
1754 defm t2SXTAB : T2I_exta_rrot<0b100, "sxtab",
1755                         BinOpFrag<(add node:$LHS, (sext_inreg node:$RHS, i8))>>;
1756 defm t2SXTAH : T2I_exta_rrot<0b000, "sxtah",
1757                         BinOpFrag<(add node:$LHS, (sext_inreg node:$RHS,i16))>>;
1758 defm t2SXTAB16 : T2I_exta_rrot_DO<0b010, "sxtab16">;
1759
1760 // TODO: SXT(A){B|H}16 - done for disassembly only
1761
1762 // Zero extenders
1763
1764 let AddedComplexity = 16 in {
1765 defm t2UXTB   : T2I_ext_rrot<0b101, "uxtb",
1766                                UnOpFrag<(and node:$Src, 0x000000FF)>>;
1767 defm t2UXTH   : T2I_ext_rrot<0b001, "uxth",
1768                                UnOpFrag<(and node:$Src, 0x0000FFFF)>>;
1769 defm t2UXTB16 : T2I_ext_rrot_uxtb16<0b011, "uxtb16",
1770                                UnOpFrag<(and node:$Src, 0x00FF00FF)>>;
1771
1772 // FIXME: This pattern incorrectly assumes the shl operator is a rotate.
1773 //        The transformation should probably be done as a combiner action
1774 //        instead so we can include a check for masking back in the upper
1775 //        eight bits of the source into the lower eight bits of the result.
1776 //def : T2Pat<(and (shl rGPR:$Src, (i32 8)), 0xFF00FF),
1777 //            (t2UXTB16r_rot rGPR:$Src, 24)>,
1778 //          Requires<[HasT2ExtractPack, IsThumb2]>;
1779 def : T2Pat<(and (srl rGPR:$Src, (i32 8)), 0xFF00FF),
1780             (t2UXTB16r_rot rGPR:$Src, 8)>,
1781         Requires<[HasT2ExtractPack, IsThumb2]>;
1782
1783 defm t2UXTAB : T2I_exta_rrot<0b101, "uxtab",
1784                            BinOpFrag<(add node:$LHS, (and node:$RHS, 0x00FF))>>;
1785 defm t2UXTAH : T2I_exta_rrot<0b001, "uxtah",
1786                            BinOpFrag<(add node:$LHS, (and node:$RHS, 0xFFFF))>>;
1787 defm t2UXTAB16 : T2I_exta_rrot_DO<0b011, "uxtab16">;
1788 }
1789
1790 //===----------------------------------------------------------------------===//
1791 //  Arithmetic Instructions.
1792 //
1793
1794 defm t2ADD  : T2I_bin_ii12rs<0b000, "add",
1795                              BinOpFrag<(add  node:$LHS, node:$RHS)>, 1>;
1796 defm t2SUB  : T2I_bin_ii12rs<0b101, "sub",
1797                              BinOpFrag<(sub  node:$LHS, node:$RHS)>>;
1798
1799 // ADD and SUB with 's' bit set. No 12-bit immediate (T4) variants.
1800 defm t2ADDS : T2I_bin_s_irs <0b1000, "add",
1801                              IIC_iALUi, IIC_iALUr, IIC_iALUsi,
1802                              BinOpFrag<(addc node:$LHS, node:$RHS)>, 1>;
1803 defm t2SUBS : T2I_bin_s_irs <0b1101, "sub",
1804                              IIC_iALUi, IIC_iALUr, IIC_iALUsi,
1805                              BinOpFrag<(subc node:$LHS, node:$RHS)>>;
1806
1807 defm t2ADC  : T2I_adde_sube_irs<0b1010, "adc",
1808                           BinOpFrag<(adde_dead_carry node:$LHS, node:$RHS)>, 1>;
1809 defm t2SBC  : T2I_adde_sube_irs<0b1011, "sbc",
1810                           BinOpFrag<(sube_dead_carry node:$LHS, node:$RHS)>>;
1811 defm t2ADCS : T2I_adde_sube_s_irs<0b1010, "adc",
1812                           BinOpFrag<(adde_live_carry node:$LHS, node:$RHS)>, 1>;
1813 defm t2SBCS : T2I_adde_sube_s_irs<0b1011, "sbc",
1814                           BinOpFrag<(sube_live_carry node:$LHS, node:$RHS)>>;
1815
1816 // RSB
1817 defm t2RSB  : T2I_rbin_irs  <0b1110, "rsb",
1818                              BinOpFrag<(sub  node:$LHS, node:$RHS)>>;
1819 defm t2RSBS : T2I_rbin_s_is <0b1110, "rsb",
1820                              BinOpFrag<(subc node:$LHS, node:$RHS)>>;
1821
1822 // (sub X, imm) gets canonicalized to (add X, -imm).  Match this form.
1823 // The assume-no-carry-in form uses the negation of the input since add/sub
1824 // assume opposite meanings of the carry flag (i.e., carry == !borrow).
1825 // See the definition of AddWithCarry() in the ARM ARM A2.2.1 for the gory
1826 // details.
1827 // The AddedComplexity preferences the first variant over the others since
1828 // it can be shrunk to a 16-bit wide encoding, while the others cannot.
1829 let AddedComplexity = 1 in
1830 def : T2Pat<(add        GPR:$src, imm0_255_neg:$imm),
1831             (t2SUBri    GPR:$src, imm0_255_neg:$imm)>;
1832 def : T2Pat<(add        GPR:$src, t2_so_imm_neg:$imm),
1833             (t2SUBri    GPR:$src, t2_so_imm_neg:$imm)>;
1834 def : T2Pat<(add        GPR:$src, imm0_4095_neg:$imm),
1835             (t2SUBri12  GPR:$src, imm0_4095_neg:$imm)>;
1836 let AddedComplexity = 1 in
1837 def : T2Pat<(addc       rGPR:$src, imm0_255_neg:$imm),
1838             (t2SUBSri   rGPR:$src, imm0_255_neg:$imm)>;
1839 def : T2Pat<(addc       rGPR:$src, t2_so_imm_neg:$imm),
1840             (t2SUBSri   rGPR:$src, t2_so_imm_neg:$imm)>;
1841 // The with-carry-in form matches bitwise not instead of the negation.
1842 // Effectively, the inverse interpretation of the carry flag already accounts
1843 // for part of the negation.
1844 let AddedComplexity = 1 in
1845 def : T2Pat<(adde       rGPR:$src, imm0_255_not:$imm),
1846             (t2SBCSri   rGPR:$src, imm0_255_not:$imm)>;
1847 def : T2Pat<(adde       rGPR:$src, t2_so_imm_not:$imm),
1848             (t2SBCSri   rGPR:$src, t2_so_imm_not:$imm)>;
1849
1850 // Select Bytes -- for disassembly only
1851
1852 def t2SEL : T2ThreeReg<(outs GPR:$Rd), (ins GPR:$Rn, GPR:$Rm),
1853                 NoItinerary, "sel", "\t$Rd, $Rn, $Rm", []> {
1854   let Inst{31-27} = 0b11111;
1855   let Inst{26-24} = 0b010;
1856   let Inst{23} = 0b1;
1857   let Inst{22-20} = 0b010;
1858   let Inst{15-12} = 0b1111;
1859   let Inst{7} = 0b1;
1860   let Inst{6-4} = 0b000;
1861 }
1862
1863 // A6.3.13, A6.3.14, A6.3.15 Parallel addition and subtraction (signed/unsigned)
1864 // And Miscellaneous operations -- for disassembly only
1865 class T2I_pam<bits<3> op22_20, bits<4> op7_4, string opc,
1866               list<dag> pat = [/* For disassembly only; pattern left blank */]>
1867   : T2I<(outs rGPR:$Rd), (ins rGPR:$Rn, rGPR:$Rm), NoItinerary, opc,
1868         "\t$Rd, $Rn, $Rm", pat> {
1869   let Inst{31-27} = 0b11111;
1870   let Inst{26-23} = 0b0101;
1871   let Inst{22-20} = op22_20;
1872   let Inst{15-12} = 0b1111;
1873   let Inst{7-4} = op7_4;
1874
1875   bits<4> Rd;
1876   bits<4> Rn;
1877   bits<4> Rm;
1878
1879   let Inst{11-8}  = Rd{3-0};
1880   let Inst{19-16} = Rn{3-0};
1881   let Inst{3-0}   = Rm{3-0};
1882 }
1883
1884 // Saturating add/subtract -- for disassembly only
1885
1886 def t2QADD    : T2I_pam<0b000, 0b1000, "qadd",
1887                         [(set rGPR:$Rd, (int_arm_qadd rGPR:$Rn, rGPR:$Rm))]>;
1888 def t2QADD16  : T2I_pam<0b001, 0b0001, "qadd16">;
1889 def t2QADD8   : T2I_pam<0b000, 0b0001, "qadd8">;
1890 def t2QASX    : T2I_pam<0b010, 0b0001, "qasx">;
1891 def t2QDADD   : T2I_pam<0b000, 0b1001, "qdadd">;
1892 def t2QDSUB   : T2I_pam<0b000, 0b1011, "qdsub">;
1893 def t2QSAX    : T2I_pam<0b110, 0b0001, "qsax">;
1894 def t2QSUB    : T2I_pam<0b000, 0b1010, "qsub",
1895                         [(set rGPR:$Rd, (int_arm_qsub rGPR:$Rn, rGPR:$Rm))]>;
1896 def t2QSUB16  : T2I_pam<0b101, 0b0001, "qsub16">;
1897 def t2QSUB8   : T2I_pam<0b100, 0b0001, "qsub8">;
1898 def t2UQADD16 : T2I_pam<0b001, 0b0101, "uqadd16">;
1899 def t2UQADD8  : T2I_pam<0b000, 0b0101, "uqadd8">;
1900 def t2UQASX   : T2I_pam<0b010, 0b0101, "uqasx">;
1901 def t2UQSAX   : T2I_pam<0b110, 0b0101, "uqsax">;
1902 def t2UQSUB16 : T2I_pam<0b101, 0b0101, "uqsub16">;
1903 def t2UQSUB8  : T2I_pam<0b100, 0b0101, "uqsub8">;
1904
1905 // Signed/Unsigned add/subtract -- for disassembly only
1906
1907 def t2SASX    : T2I_pam<0b010, 0b0000, "sasx">;
1908 def t2SADD16  : T2I_pam<0b001, 0b0000, "sadd16">;
1909 def t2SADD8   : T2I_pam<0b000, 0b0000, "sadd8">;
1910 def t2SSAX    : T2I_pam<0b110, 0b0000, "ssax">;
1911 def t2SSUB16  : T2I_pam<0b101, 0b0000, "ssub16">;
1912 def t2SSUB8   : T2I_pam<0b100, 0b0000, "ssub8">;
1913 def t2UASX    : T2I_pam<0b010, 0b0100, "uasx">;
1914 def t2UADD16  : T2I_pam<0b001, 0b0100, "uadd16">;
1915 def t2UADD8   : T2I_pam<0b000, 0b0100, "uadd8">;
1916 def t2USAX    : T2I_pam<0b110, 0b0100, "usax">;
1917 def t2USUB16  : T2I_pam<0b101, 0b0100, "usub16">;
1918 def t2USUB8   : T2I_pam<0b100, 0b0100, "usub8">;
1919
1920 // Signed/Unsigned halving add/subtract -- for disassembly only
1921
1922 def t2SHASX   : T2I_pam<0b010, 0b0010, "shasx">;
1923 def t2SHADD16 : T2I_pam<0b001, 0b0010, "shadd16">;
1924 def t2SHADD8  : T2I_pam<0b000, 0b0010, "shadd8">;
1925 def t2SHSAX   : T2I_pam<0b110, 0b0010, "shsax">;
1926 def t2SHSUB16 : T2I_pam<0b101, 0b0010, "shsub16">;
1927 def t2SHSUB8  : T2I_pam<0b100, 0b0010, "shsub8">;
1928 def t2UHASX   : T2I_pam<0b010, 0b0110, "uhasx">;
1929 def t2UHADD16 : T2I_pam<0b001, 0b0110, "uhadd16">;
1930 def t2UHADD8  : T2I_pam<0b000, 0b0110, "uhadd8">;
1931 def t2UHSAX   : T2I_pam<0b110, 0b0110, "uhsax">;
1932 def t2UHSUB16 : T2I_pam<0b101, 0b0110, "uhsub16">;
1933 def t2UHSUB8  : T2I_pam<0b100, 0b0110, "uhsub8">;
1934
1935 // Helper class for disassembly only
1936 // A6.3.16 & A6.3.17
1937 // T2Imac - Thumb2 multiply [accumulate, and absolute difference] instructions.
1938 class T2ThreeReg_mac<bit long, bits<3> op22_20, bits<4> op7_4, dag oops,
1939   dag iops, InstrItinClass itin, string opc, string asm, list<dag> pattern>
1940   : T2ThreeReg<oops, iops, itin, opc, asm, pattern> {
1941   let Inst{31-27} = 0b11111;
1942   let Inst{26-24} = 0b011;
1943   let Inst{23}    = long;
1944   let Inst{22-20} = op22_20;
1945   let Inst{7-4}   = op7_4;
1946 }
1947
1948 class T2FourReg_mac<bit long, bits<3> op22_20, bits<4> op7_4, dag oops,
1949   dag iops, InstrItinClass itin, string opc, string asm, list<dag> pattern>
1950   : T2FourReg<oops, iops, itin, opc, asm, pattern> {
1951   let Inst{31-27} = 0b11111;
1952   let Inst{26-24} = 0b011;
1953   let Inst{23}    = long;
1954   let Inst{22-20} = op22_20;
1955   let Inst{7-4}   = op7_4;
1956 }
1957
1958 // Unsigned Sum of Absolute Differences [and Accumulate] -- for disassembly only
1959
1960 def t2USAD8   : T2ThreeReg_mac<0, 0b111, 0b0000, (outs rGPR:$Rd),
1961                                            (ins rGPR:$Rn, rGPR:$Rm),
1962                         NoItinerary, "usad8", "\t$Rd, $Rn, $Rm", []> {
1963   let Inst{15-12} = 0b1111;
1964 }
1965 def t2USADA8  : T2FourReg_mac<0, 0b111, 0b0000, (outs rGPR:$Rd),
1966                        (ins rGPR:$Rn, rGPR:$Rm, rGPR:$Ra), NoItinerary,
1967                         "usada8", "\t$Rd, $Rn, $Rm, $Ra", []>;
1968
1969 // Signed/Unsigned saturate -- for disassembly only
1970
1971 class T2SatI<dag oops, dag iops, InstrItinClass itin,
1972            string opc, string asm, list<dag> pattern>
1973   : T2I<oops, iops, itin, opc, asm, pattern> {
1974   bits<4> Rd;
1975   bits<4> Rn;
1976   bits<5> sat_imm;
1977   bits<7> sh;
1978
1979   let Inst{11-8}  = Rd{3-0};
1980   let Inst{19-16} = Rn{3-0};
1981   let Inst{4-0}   = sat_imm{4-0};
1982   let Inst{21}    = sh{6};
1983   let Inst{14-12} = sh{4-2};
1984   let Inst{7-6}   = sh{1-0};
1985 }
1986
1987 def t2SSAT: T2SatI<
1988                 (outs rGPR:$Rd), (ins i32imm:$sat_imm, rGPR:$Rn, shift_imm:$sh),
1989                 NoItinerary, "ssat", "\t$Rd, $sat_imm, $Rn$sh",
1990                 [/* For disassembly only; pattern left blank */]> {
1991   let Inst{31-27} = 0b11110;
1992   let Inst{25-22} = 0b1100;
1993   let Inst{20} = 0;
1994   let Inst{15} = 0;
1995 }
1996
1997 def t2SSAT16: T2SatI<
1998                    (outs rGPR:$Rd), (ins i32imm:$sat_imm, rGPR:$Rn), NoItinerary,
1999                    "ssat16", "\t$Rd, $sat_imm, $Rn",
2000                    [/* For disassembly only; pattern left blank */]> {
2001   let Inst{31-27} = 0b11110;
2002   let Inst{25-22} = 0b1100;
2003   let Inst{20} = 0;
2004   let Inst{15} = 0;
2005   let Inst{21} = 1;        // sh = '1'
2006   let Inst{14-12} = 0b000; // imm3 = '000'
2007   let Inst{7-6} = 0b00;    // imm2 = '00'
2008 }
2009
2010 def t2USAT: T2SatI<
2011                 (outs rGPR:$Rd), (ins i32imm:$sat_imm, rGPR:$Rn, shift_imm:$sh),
2012                 NoItinerary, "usat", "\t$Rd, $sat_imm, $Rn$sh",
2013                 [/* For disassembly only; pattern left blank */]> {
2014   let Inst{31-27} = 0b11110;
2015   let Inst{25-22} = 0b1110;
2016   let Inst{20} = 0;
2017   let Inst{15} = 0;
2018 }
2019
2020 def t2USAT16: T2SatI<
2021                     (outs rGPR:$dst), (ins i32imm:$sat_imm, rGPR:$Rn), NoItinerary,
2022                    "usat16", "\t$dst, $sat_imm, $Rn",
2023                    [/* For disassembly only; pattern left blank */]> {
2024   let Inst{31-27} = 0b11110;
2025   let Inst{25-22} = 0b1110;
2026   let Inst{20} = 0;
2027   let Inst{15} = 0;
2028   let Inst{21} = 1;        // sh = '1'
2029   let Inst{14-12} = 0b000; // imm3 = '000'
2030   let Inst{7-6} = 0b00;    // imm2 = '00'
2031 }
2032
2033 def : T2Pat<(int_arm_ssat GPR:$a, imm:$pos), (t2SSAT imm:$pos, GPR:$a, 0)>;
2034 def : T2Pat<(int_arm_usat GPR:$a, imm:$pos), (t2USAT imm:$pos, GPR:$a, 0)>;
2035
2036 //===----------------------------------------------------------------------===//
2037 //  Shift and rotate Instructions.
2038 //
2039
2040 defm t2LSL  : T2I_sh_ir<0b00, "lsl", BinOpFrag<(shl  node:$LHS, node:$RHS)>>;
2041 defm t2LSR  : T2I_sh_ir<0b01, "lsr", BinOpFrag<(srl  node:$LHS, node:$RHS)>>;
2042 defm t2ASR  : T2I_sh_ir<0b10, "asr", BinOpFrag<(sra  node:$LHS, node:$RHS)>>;
2043 defm t2ROR  : T2I_sh_ir<0b11, "ror", BinOpFrag<(rotr node:$LHS, node:$RHS)>>;
2044
2045 let Uses = [CPSR] in {
2046 def t2RRX : T2sTwoReg<(outs rGPR:$Rd), (ins rGPR:$Rm), IIC_iMOVsi,
2047                    "rrx", "\t$Rd, $Rm",
2048                    [(set rGPR:$Rd, (ARMrrx rGPR:$Rm))]> {
2049   let Inst{31-27} = 0b11101;
2050   let Inst{26-25} = 0b01;
2051   let Inst{24-21} = 0b0010;
2052   let Inst{20} = ?; // The S bit.
2053   let Inst{19-16} = 0b1111; // Rn
2054   let Inst{14-12} = 0b000;
2055   let Inst{7-4} = 0b0011;
2056 }
2057 }
2058
2059 let Defs = [CPSR] in {
2060 def t2MOVsrl_flag : T2TwoRegShiftImm<
2061                         (outs rGPR:$Rd), (ins rGPR:$Rm), IIC_iMOVsi,
2062                         "lsrs", ".w\t$Rd, $Rm, #1",
2063                         [(set rGPR:$Rd, (ARMsrl_flag rGPR:$Rm))]> {
2064   let Inst{31-27} = 0b11101;
2065   let Inst{26-25} = 0b01;
2066   let Inst{24-21} = 0b0010;
2067   let Inst{20} = 1; // The S bit.
2068   let Inst{19-16} = 0b1111; // Rn
2069   let Inst{5-4} = 0b01; // Shift type.
2070   // Shift amount = Inst{14-12:7-6} = 1.
2071   let Inst{14-12} = 0b000;
2072   let Inst{7-6} = 0b01;
2073 }
2074 def t2MOVsra_flag : T2TwoRegShiftImm<
2075                         (outs rGPR:$Rd), (ins rGPR:$Rm), IIC_iMOVsi,
2076                         "asrs", ".w\t$Rd, $Rm, #1",
2077                         [(set rGPR:$Rd, (ARMsra_flag rGPR:$Rm))]> {
2078   let Inst{31-27} = 0b11101;
2079   let Inst{26-25} = 0b01;
2080   let Inst{24-21} = 0b0010;
2081   let Inst{20} = 1; // The S bit.
2082   let Inst{19-16} = 0b1111; // Rn
2083   let Inst{5-4} = 0b10; // Shift type.
2084   // Shift amount = Inst{14-12:7-6} = 1.
2085   let Inst{14-12} = 0b000;
2086   let Inst{7-6} = 0b01;
2087 }
2088 }
2089
2090 //===----------------------------------------------------------------------===//
2091 //  Bitwise Instructions.
2092 //
2093
2094 defm t2AND  : T2I_bin_w_irs<0b0000, "and",
2095                             IIC_iBITi, IIC_iBITr, IIC_iBITsi,
2096                             BinOpFrag<(and node:$LHS, node:$RHS)>, 1>;
2097 defm t2ORR  : T2I_bin_w_irs<0b0010, "orr",
2098                             IIC_iBITi, IIC_iBITr, IIC_iBITsi,
2099                             BinOpFrag<(or  node:$LHS, node:$RHS)>, 1>;
2100 defm t2EOR  : T2I_bin_w_irs<0b0100, "eor",
2101                             IIC_iBITi, IIC_iBITr, IIC_iBITsi,
2102                             BinOpFrag<(xor node:$LHS, node:$RHS)>, 1>;
2103
2104 defm t2BIC  : T2I_bin_w_irs<0b0001, "bic",
2105                             IIC_iBITi, IIC_iBITr, IIC_iBITsi,
2106                             BinOpFrag<(and node:$LHS, (not node:$RHS))>>;
2107
2108 class T2BitFI<dag oops, dag iops, InstrItinClass itin,
2109               string opc, string asm, list<dag> pattern>
2110     : T2I<oops, iops, itin, opc, asm, pattern> {
2111   bits<4> Rd;
2112   bits<5> msb;
2113   bits<5> lsb;
2114
2115   let Inst{11-8}  = Rd{3-0};
2116   let Inst{4-0}   = msb{4-0};
2117   let Inst{14-12} = lsb{4-2};
2118   let Inst{7-6}   = lsb{1-0};
2119 }
2120
2121 class T2TwoRegBitFI<dag oops, dag iops, InstrItinClass itin,
2122               string opc, string asm, list<dag> pattern>
2123     : T2BitFI<oops, iops, itin, opc, asm, pattern> {
2124   bits<4> Rn;
2125
2126   let Inst{19-16} = Rn{3-0};
2127 }
2128
2129 let Constraints = "$src = $Rd" in
2130 def t2BFC : T2BitFI<(outs rGPR:$Rd), (ins rGPR:$src, bf_inv_mask_imm:$imm),
2131                 IIC_iUNAsi, "bfc", "\t$Rd, $imm",
2132                 [(set rGPR:$Rd, (and rGPR:$src, bf_inv_mask_imm:$imm))]> {
2133   let Inst{31-27} = 0b11110;
2134   let Inst{25} = 1;
2135   let Inst{24-20} = 0b10110;
2136   let Inst{19-16} = 0b1111; // Rn
2137   let Inst{15} = 0;
2138
2139   bits<10> imm;
2140   let msb{4-0} = imm{9-5};
2141   let lsb{4-0} = imm{4-0};
2142 }
2143
2144 def t2SBFX: T2TwoRegBitFI<
2145                 (outs rGPR:$Rd), (ins rGPR:$Rn, imm0_31:$lsb, imm0_31_m1:$msb),
2146                  IIC_iUNAsi, "sbfx", "\t$Rd, $Rn, $lsb, $msb", []> {
2147   let Inst{31-27} = 0b11110;
2148   let Inst{25} = 1;
2149   let Inst{24-20} = 0b10100;
2150   let Inst{15} = 0;
2151 }
2152
2153 def t2UBFX: T2TwoRegBitFI<
2154                 (outs rGPR:$Rd), (ins rGPR:$Rn, imm0_31:$lsb, imm0_31_m1:$msb),
2155                  IIC_iUNAsi, "ubfx", "\t$Rd, $Rn, $lsb, $msb", []> {
2156   let Inst{31-27} = 0b11110;
2157   let Inst{25} = 1;
2158   let Inst{24-20} = 0b11100;
2159   let Inst{15} = 0;
2160 }
2161
2162 // A8.6.18  BFI - Bitfield insert (Encoding T1)
2163 let Constraints = "$src = $Rd" in
2164 def t2BFI : T2TwoRegBitFI<(outs rGPR:$Rd),
2165                 (ins rGPR:$src, rGPR:$Rn, bf_inv_mask_imm:$imm),
2166                 IIC_iBITi, "bfi", "\t$Rd, $Rn, $imm",
2167                 [(set rGPR:$Rd, (ARMbfi rGPR:$src, rGPR:$Rn,
2168                                  bf_inv_mask_imm:$imm))]> {
2169   let Inst{31-27} = 0b11110;
2170   let Inst{25} = 1;
2171   let Inst{24-20} = 0b10110;
2172   let Inst{15} = 0;
2173
2174   bits<10> imm;
2175   let msb{4-0} = imm{9-5};
2176   let lsb{4-0} = imm{4-0};
2177 }
2178
2179 defm t2ORN  : T2I_bin_irs<0b0011, "orn",
2180                           IIC_iBITi, IIC_iBITr, IIC_iBITsi,
2181                           BinOpFrag<(or  node:$LHS, (not node:$RHS))>, 0, "">;
2182
2183 // Prefer over of t2EORri ra, rb, -1 because mvn has 16-bit version
2184 let AddedComplexity = 1 in
2185 defm t2MVN  : T2I_un_irs <0b0011, "mvn",
2186                           IIC_iMVNi, IIC_iMVNr, IIC_iMVNsi,
2187                           UnOpFrag<(not node:$Src)>, 1, 1>;
2188
2189
2190 let AddedComplexity = 1 in
2191 def : T2Pat<(and     rGPR:$src, t2_so_imm_not:$imm),
2192             (t2BICri rGPR:$src, t2_so_imm_not:$imm)>;
2193
2194 // FIXME: Disable this pattern on Darwin to workaround an assembler bug.
2195 def : T2Pat<(or      rGPR:$src, t2_so_imm_not:$imm),
2196             (t2ORNri rGPR:$src, t2_so_imm_not:$imm)>,
2197             Requires<[IsThumb2]>;
2198
2199 def : T2Pat<(t2_so_imm_not:$src),
2200             (t2MVNi t2_so_imm_not:$src)>;
2201
2202 //===----------------------------------------------------------------------===//
2203 //  Multiply Instructions.
2204 //
2205 let isCommutable = 1 in
2206 def t2MUL: T2ThreeReg<(outs rGPR:$Rd), (ins rGPR:$Rn, rGPR:$Rm), IIC_iMUL32,
2207                 "mul", "\t$Rd, $Rn, $Rm",
2208                 [(set rGPR:$Rd, (mul rGPR:$Rn, rGPR:$Rm))]> {
2209   let Inst{31-27} = 0b11111;
2210   let Inst{26-23} = 0b0110;
2211   let Inst{22-20} = 0b000;
2212   let Inst{15-12} = 0b1111; // Ra = 0b1111 (no accumulate)
2213   let Inst{7-4} = 0b0000; // Multiply
2214 }
2215
2216 def t2MLA: T2FourReg<
2217                 (outs rGPR:$Rd), (ins rGPR:$Rn, rGPR:$Rm, rGPR:$Ra), IIC_iMAC32,
2218                 "mla", "\t$Rd, $Rn, $Rm, $Ra",
2219                 [(set rGPR:$Rd, (add (mul rGPR:$Rn, rGPR:$Rm), rGPR:$Ra))]> {
2220   let Inst{31-27} = 0b11111;
2221   let Inst{26-23} = 0b0110;
2222   let Inst{22-20} = 0b000;
2223   let Inst{7-4} = 0b0000; // Multiply
2224 }
2225
2226 def t2MLS: T2FourReg<
2227                 (outs rGPR:$Rd), (ins rGPR:$Rn, rGPR:$Rm, rGPR:$Ra), IIC_iMAC32,
2228                 "mls", "\t$Rd, $Rn, $Rm, $Ra",
2229                 [(set rGPR:$Rd, (sub rGPR:$Ra, (mul rGPR:$Rn, rGPR:$Rm)))]> {
2230   let Inst{31-27} = 0b11111;
2231   let Inst{26-23} = 0b0110;
2232   let Inst{22-20} = 0b000;
2233   let Inst{7-4} = 0b0001; // Multiply and Subtract
2234 }
2235
2236 // Extra precision multiplies with low / high results
2237 let neverHasSideEffects = 1 in {
2238 let isCommutable = 1 in {
2239 def t2SMULL : T2FourReg<
2240                   (outs rGPR:$Rd, rGPR:$Ra),
2241                   (ins rGPR:$Rn, rGPR:$Rm), IIC_iMUL64,
2242                    "smull", "\t$Rd, $Ra, $Rn, $Rm", []> {
2243   let Inst{31-27} = 0b11111;
2244   let Inst{26-23} = 0b0111;
2245   let Inst{22-20} = 0b000;
2246   let Inst{7-4} = 0b0000;
2247 }
2248
2249 def t2UMULL : T2FourReg<
2250                   (outs rGPR:$Rd, rGPR:$Ra),
2251                   (ins rGPR:$Rn, rGPR:$Rm), IIC_iMUL64,
2252                    "umull", "\t$Rd, $Ra, $Rn, $Rm", []> {
2253   let Inst{31-27} = 0b11111;
2254   let Inst{26-23} = 0b0111;
2255   let Inst{22-20} = 0b010;
2256   let Inst{7-4} = 0b0000;
2257 }
2258 } // isCommutable
2259
2260 // Multiply + accumulate
2261 def t2SMLAL : T2FourReg<(outs rGPR:$Ra, rGPR:$Rd),
2262                   (ins rGPR:$Rn, rGPR:$Rm), IIC_iMAC64,
2263                   "smlal", "\t$Ra, $Rd, $Rn, $Rm", []>{
2264   let Inst{31-27} = 0b11111;
2265   let Inst{26-23} = 0b0111;
2266   let Inst{22-20} = 0b100;
2267   let Inst{7-4} = 0b0000;
2268 }
2269
2270 def t2UMLAL : T2FourReg<(outs rGPR:$Ra, rGPR:$Rd),
2271                   (ins rGPR:$Rn, rGPR:$Rm), IIC_iMAC64,
2272                   "umlal", "\t$Ra, $Rd, $Rn, $Rm", []>{
2273   let Inst{31-27} = 0b11111;
2274   let Inst{26-23} = 0b0111;
2275   let Inst{22-20} = 0b110;
2276   let Inst{7-4} = 0b0000;
2277 }
2278
2279 def t2UMAAL : T2FourReg<(outs rGPR:$Ra, rGPR:$Rd),
2280                   (ins rGPR:$Rn, rGPR:$Rm), IIC_iMAC64,
2281                   "umaal", "\t$Ra, $Rd, $Rn, $Rm", []>{
2282   let Inst{31-27} = 0b11111;
2283   let Inst{26-23} = 0b0111;
2284   let Inst{22-20} = 0b110;
2285   let Inst{7-4} = 0b0110;
2286 }
2287 } // neverHasSideEffects
2288
2289 // Rounding variants of the below included for disassembly only
2290
2291 // Most significant word multiply
2292 def t2SMMUL : T2ThreeReg<(outs rGPR:$Rd), (ins rGPR:$Rn, rGPR:$Rm), IIC_iMUL32,
2293                   "smmul", "\t$Rd, $Rn, $Rm",
2294                   [(set rGPR:$Rd, (mulhs rGPR:$Rn, rGPR:$Rm))]> {
2295   let Inst{31-27} = 0b11111;
2296   let Inst{26-23} = 0b0110;
2297   let Inst{22-20} = 0b101;
2298   let Inst{15-12} = 0b1111; // Ra = 0b1111 (no accumulate)
2299   let Inst{7-4} = 0b0000; // No Rounding (Inst{4} = 0)
2300 }
2301
2302 def t2SMMULR : T2ThreeReg<(outs rGPR:$Rd), (ins rGPR:$Rn, rGPR:$Rm), IIC_iMUL32,
2303                   "smmulr", "\t$Rd, $Rn, $Rm", []> {
2304   let Inst{31-27} = 0b11111;
2305   let Inst{26-23} = 0b0110;
2306   let Inst{22-20} = 0b101;
2307   let Inst{15-12} = 0b1111; // Ra = 0b1111 (no accumulate)
2308   let Inst{7-4} = 0b0001; // Rounding (Inst{4} = 1)
2309 }
2310
2311 def t2SMMLA : T2FourReg<
2312         (outs rGPR:$Rd), (ins rGPR:$Rn, rGPR:$Rm, rGPR:$Ra), IIC_iMAC32,
2313                 "smmla", "\t$Rd, $Rn, $Rm, $Ra",
2314                 [(set rGPR:$Rd, (add (mulhs rGPR:$Rm, rGPR:$Rn), rGPR:$Ra))]> {
2315   let Inst{31-27} = 0b11111;
2316   let Inst{26-23} = 0b0110;
2317   let Inst{22-20} = 0b101;
2318   let Inst{7-4} = 0b0000; // No Rounding (Inst{4} = 0)
2319 }
2320
2321 def t2SMMLAR: T2FourReg<
2322         (outs rGPR:$Rd), (ins rGPR:$Rn, rGPR:$Rm, rGPR:$Ra), IIC_iMAC32,
2323                   "smmlar", "\t$Rd, $Rn, $Rm, $Ra", []> {
2324   let Inst{31-27} = 0b11111;
2325   let Inst{26-23} = 0b0110;
2326   let Inst{22-20} = 0b101;
2327   let Inst{7-4} = 0b0001; // Rounding (Inst{4} = 1)
2328 }
2329
2330 def t2SMMLS: T2FourReg<
2331         (outs rGPR:$Rd), (ins rGPR:$Rn, rGPR:$Rm, rGPR:$Ra), IIC_iMAC32,
2332                 "smmls", "\t$Rd, $Rn, $Rm, $Ra",
2333                 [(set rGPR:$Rd, (sub rGPR:$Ra, (mulhs rGPR:$Rn, rGPR:$Rm)))]> {
2334   let Inst{31-27} = 0b11111;
2335   let Inst{26-23} = 0b0110;
2336   let Inst{22-20} = 0b110;
2337   let Inst{7-4} = 0b0000; // No Rounding (Inst{4} = 0)
2338 }
2339
2340 def t2SMMLSR:T2FourReg<
2341         (outs rGPR:$Rd), (ins rGPR:$Rn, rGPR:$Rm, rGPR:$Ra), IIC_iMAC32,
2342                 "smmlsr", "\t$Rd, $Rn, $Rm, $Ra", []> {
2343   let Inst{31-27} = 0b11111;
2344   let Inst{26-23} = 0b0110;
2345   let Inst{22-20} = 0b110;
2346   let Inst{7-4} = 0b0001; // Rounding (Inst{4} = 1)
2347 }
2348
2349 multiclass T2I_smul<string opc, PatFrag opnode> {
2350   def BB : T2ThreeReg<(outs rGPR:$Rd), (ins rGPR:$Rn, rGPR:$Rm), IIC_iMUL16,
2351               !strconcat(opc, "bb"), "\t$Rd, $Rn, $Rm",
2352               [(set rGPR:$Rd, (opnode (sext_inreg rGPR:$Rn, i16),
2353                                       (sext_inreg rGPR:$Rm, i16)))]> {
2354     let Inst{31-27} = 0b11111;
2355     let Inst{26-23} = 0b0110;
2356     let Inst{22-20} = 0b001;
2357     let Inst{15-12} = 0b1111; // Ra = 0b1111 (no accumulate)
2358     let Inst{7-6} = 0b00;
2359     let Inst{5-4} = 0b00;
2360   }
2361
2362   def BT : T2ThreeReg<(outs rGPR:$Rd), (ins rGPR:$Rn, rGPR:$Rm), IIC_iMUL16,
2363               !strconcat(opc, "bt"), "\t$Rd, $Rn, $Rm",
2364               [(set rGPR:$Rd, (opnode (sext_inreg rGPR:$Rn, i16),
2365                                       (sra rGPR:$Rm, (i32 16))))]> {
2366     let Inst{31-27} = 0b11111;
2367     let Inst{26-23} = 0b0110;
2368     let Inst{22-20} = 0b001;
2369     let Inst{15-12} = 0b1111; // Ra = 0b1111 (no accumulate)
2370     let Inst{7-6} = 0b00;
2371     let Inst{5-4} = 0b01;
2372   }
2373
2374   def TB : T2ThreeReg<(outs rGPR:$Rd), (ins rGPR:$Rn, rGPR:$Rm), IIC_iMUL16,
2375               !strconcat(opc, "tb"), "\t$Rd, $Rn, $Rm",
2376               [(set rGPR:$Rd, (opnode (sra rGPR:$Rn, (i32 16)),
2377                                       (sext_inreg rGPR:$Rm, i16)))]> {
2378     let Inst{31-27} = 0b11111;
2379     let Inst{26-23} = 0b0110;
2380     let Inst{22-20} = 0b001;
2381     let Inst{15-12} = 0b1111; // Ra = 0b1111 (no accumulate)
2382     let Inst{7-6} = 0b00;
2383     let Inst{5-4} = 0b10;
2384   }
2385
2386   def TT : T2ThreeReg<(outs rGPR:$Rd), (ins rGPR:$Rn, rGPR:$Rm), IIC_iMUL16,
2387               !strconcat(opc, "tt"), "\t$Rd, $Rn, $Rm",
2388               [(set rGPR:$Rd, (opnode (sra rGPR:$Rn, (i32 16)),
2389                                       (sra rGPR:$Rm, (i32 16))))]> {
2390     let Inst{31-27} = 0b11111;
2391     let Inst{26-23} = 0b0110;
2392     let Inst{22-20} = 0b001;
2393     let Inst{15-12} = 0b1111; // Ra = 0b1111 (no accumulate)
2394     let Inst{7-6} = 0b00;
2395     let Inst{5-4} = 0b11;
2396   }
2397
2398   def WB : T2ThreeReg<(outs rGPR:$Rd), (ins rGPR:$Rn, rGPR:$Rm), IIC_iMUL16,
2399               !strconcat(opc, "wb"), "\t$Rd, $Rn, $Rm",
2400               [(set rGPR:$Rd, (sra (opnode rGPR:$Rn,
2401                                     (sext_inreg rGPR:$Rm, i16)), (i32 16)))]> {
2402     let Inst{31-27} = 0b11111;
2403     let Inst{26-23} = 0b0110;
2404     let Inst{22-20} = 0b011;
2405     let Inst{15-12} = 0b1111; // Ra = 0b1111 (no accumulate)
2406     let Inst{7-6} = 0b00;
2407     let Inst{5-4} = 0b00;
2408   }
2409
2410   def WT : T2ThreeReg<(outs rGPR:$Rd), (ins rGPR:$Rn, rGPR:$Rm), IIC_iMUL16,
2411               !strconcat(opc, "wt"), "\t$Rd, $Rn, $Rm",
2412               [(set rGPR:$Rd, (sra (opnode rGPR:$Rn,
2413                                     (sra rGPR:$Rm, (i32 16))), (i32 16)))]> {
2414     let Inst{31-27} = 0b11111;
2415     let Inst{26-23} = 0b0110;
2416     let Inst{22-20} = 0b011;
2417     let Inst{15-12} = 0b1111; // Ra = 0b1111 (no accumulate)
2418     let Inst{7-6} = 0b00;
2419     let Inst{5-4} = 0b01;
2420   }
2421 }
2422
2423
2424 multiclass T2I_smla<string opc, PatFrag opnode> {
2425   def BB : T2FourReg<
2426         (outs rGPR:$Rd), (ins rGPR:$Rn, rGPR:$Rm, rGPR:$Ra), IIC_iMAC16,
2427               !strconcat(opc, "bb"), "\t$Rd, $Rn, $Rm, $Ra",
2428               [(set rGPR:$Rd, (add rGPR:$Ra,
2429                                (opnode (sext_inreg rGPR:$Rn, i16),
2430                                        (sext_inreg rGPR:$Rm, i16))))]> {
2431     let Inst{31-27} = 0b11111;
2432     let Inst{26-23} = 0b0110;
2433     let Inst{22-20} = 0b001;
2434     let Inst{7-6} = 0b00;
2435     let Inst{5-4} = 0b00;
2436   }
2437
2438   def BT : T2FourReg<
2439        (outs rGPR:$Rd), (ins rGPR:$Rn, rGPR:$Rm, rGPR:$Ra), IIC_iMAC16,
2440              !strconcat(opc, "bt"), "\t$Rd, $Rn, $Rm, $Ra",
2441              [(set rGPR:$Rd, (add rGPR:$Ra, (opnode (sext_inreg rGPR:$Rn, i16),
2442                                                  (sra rGPR:$Rm, (i32 16)))))]> {
2443     let Inst{31-27} = 0b11111;
2444     let Inst{26-23} = 0b0110;
2445     let Inst{22-20} = 0b001;
2446     let Inst{7-6} = 0b00;
2447     let Inst{5-4} = 0b01;
2448   }
2449
2450   def TB : T2FourReg<
2451         (outs rGPR:$Rd), (ins rGPR:$Rn, rGPR:$Rm, rGPR:$Ra), IIC_iMAC16,
2452               !strconcat(opc, "tb"), "\t$Rd, $Rn, $Rm, $Ra",
2453               [(set rGPR:$Rd, (add rGPR:$Ra, (opnode (sra rGPR:$Rn, (i32 16)),
2454                                                (sext_inreg rGPR:$Rm, i16))))]> {
2455     let Inst{31-27} = 0b11111;
2456     let Inst{26-23} = 0b0110;
2457     let Inst{22-20} = 0b001;
2458     let Inst{7-6} = 0b00;
2459     let Inst{5-4} = 0b10;
2460   }
2461
2462   def TT : T2FourReg<
2463         (outs rGPR:$Rd), (ins rGPR:$Rn, rGPR:$Rm, rGPR:$Ra), IIC_iMAC16,
2464               !strconcat(opc, "tt"), "\t$Rd, $Rn, $Rm, $Ra",
2465              [(set rGPR:$Rd, (add rGPR:$Ra, (opnode (sra rGPR:$Rn, (i32 16)),
2466                                                  (sra rGPR:$Rm, (i32 16)))))]> {
2467     let Inst{31-27} = 0b11111;
2468     let Inst{26-23} = 0b0110;
2469     let Inst{22-20} = 0b001;
2470     let Inst{7-6} = 0b00;
2471     let Inst{5-4} = 0b11;
2472   }
2473
2474   def WB : T2FourReg<
2475         (outs rGPR:$Rd), (ins rGPR:$Rn, rGPR:$Rm, rGPR:$Ra), IIC_iMAC16,
2476               !strconcat(opc, "wb"), "\t$Rd, $Rn, $Rm, $Ra",
2477               [(set rGPR:$Rd, (add rGPR:$Ra, (sra (opnode rGPR:$Rn,
2478                                     (sext_inreg rGPR:$Rm, i16)), (i32 16))))]> {
2479     let Inst{31-27} = 0b11111;
2480     let Inst{26-23} = 0b0110;
2481     let Inst{22-20} = 0b011;
2482     let Inst{7-6} = 0b00;
2483     let Inst{5-4} = 0b00;
2484   }
2485
2486   def WT : T2FourReg<
2487         (outs rGPR:$Rd), (ins rGPR:$Rn, rGPR:$Rm, rGPR:$Ra), IIC_iMAC16,
2488               !strconcat(opc, "wt"), "\t$Rd, $Rn, $Rm, $Ra",
2489               [(set rGPR:$Rd, (add rGPR:$Ra, (sra (opnode rGPR:$Rn,
2490                                       (sra rGPR:$Rm, (i32 16))), (i32 16))))]> {
2491     let Inst{31-27} = 0b11111;
2492     let Inst{26-23} = 0b0110;
2493     let Inst{22-20} = 0b011;
2494     let Inst{7-6} = 0b00;
2495     let Inst{5-4} = 0b01;
2496   }
2497 }
2498
2499 defm t2SMUL : T2I_smul<"smul", BinOpFrag<(mul node:$LHS, node:$RHS)>>;
2500 defm t2SMLA : T2I_smla<"smla", BinOpFrag<(mul node:$LHS, node:$RHS)>>;
2501
2502 // Halfword multiple accumulate long: SMLAL<x><y> -- for disassembly only
2503 def t2SMLALBB : T2FourReg_mac<1, 0b100, 0b1000, (outs rGPR:$Ra,rGPR:$Rd),
2504          (ins rGPR:$Rn,rGPR:$Rm), IIC_iMAC64, "smlalbb", "\t$Ra, $Rd, $Rn, $Rm",
2505            [/* For disassembly only; pattern left blank */]>;
2506 def t2SMLALBT : T2FourReg_mac<1, 0b100, 0b1001, (outs rGPR:$Ra,rGPR:$Rd),
2507          (ins rGPR:$Rn,rGPR:$Rm), IIC_iMAC64, "smlalbt", "\t$Ra, $Rd, $Rn, $Rm",
2508            [/* For disassembly only; pattern left blank */]>;
2509 def t2SMLALTB : T2FourReg_mac<1, 0b100, 0b1010, (outs rGPR:$Ra,rGPR:$Rd),
2510          (ins rGPR:$Rn,rGPR:$Rm), IIC_iMAC64, "smlaltb", "\t$Ra, $Rd, $Rn, $Rm",
2511            [/* For disassembly only; pattern left blank */]>;
2512 def t2SMLALTT : T2FourReg_mac<1, 0b100, 0b1011, (outs rGPR:$Ra,rGPR:$Rd),
2513          (ins rGPR:$Rn,rGPR:$Rm), IIC_iMAC64, "smlaltt", "\t$Ra, $Rd, $Rn, $Rm",
2514            [/* For disassembly only; pattern left blank */]>;
2515
2516 // Dual halfword multiple: SMUAD, SMUSD, SMLAD, SMLSD, SMLALD, SMLSLD
2517 // These are for disassembly only.
2518
2519 def t2SMUAD: T2ThreeReg_mac<
2520             0, 0b010, 0b0000, (outs rGPR:$Rd), (ins rGPR:$Rn, rGPR:$Rm),
2521             IIC_iMAC32, "smuad", "\t$Rd, $Rn, $Rm", []> {
2522   let Inst{15-12} = 0b1111;
2523 }
2524 def t2SMUADX:T2ThreeReg_mac<
2525             0, 0b010, 0b0001, (outs rGPR:$Rd), (ins rGPR:$Rn, rGPR:$Rm),
2526             IIC_iMAC32, "smuadx", "\t$Rd, $Rn, $Rm", []> {
2527   let Inst{15-12} = 0b1111;
2528 }
2529 def t2SMUSD: T2ThreeReg_mac<
2530             0, 0b100, 0b0000, (outs rGPR:$Rd), (ins rGPR:$Rn, rGPR:$Rm),
2531             IIC_iMAC32, "smusd", "\t$Rd, $Rn, $Rm", []> {
2532   let Inst{15-12} = 0b1111;
2533 }
2534 def t2SMUSDX:T2ThreeReg_mac<
2535             0, 0b100, 0b0001, (outs rGPR:$Rd), (ins rGPR:$Rn, rGPR:$Rm),
2536             IIC_iMAC32, "smusdx", "\t$Rd, $Rn, $Rm", []> {
2537   let Inst{15-12} = 0b1111;
2538 }
2539 def t2SMLAD   : T2ThreeReg_mac<
2540             0, 0b010, 0b0000, (outs rGPR:$Rd),
2541             (ins rGPR:$Rn, rGPR:$Rm, rGPR:$Ra), IIC_iMAC32, "smlad",
2542             "\t$Rd, $Rn, $Rm, $Ra", []>;
2543 def t2SMLADX  : T2FourReg_mac<
2544             0, 0b010, 0b0001, (outs rGPR:$Rd),
2545             (ins rGPR:$Rn, rGPR:$Rm, rGPR:$Ra), IIC_iMAC32, "smladx",
2546             "\t$Rd, $Rn, $Rm, $Ra", []>;
2547 def t2SMLSD   : T2FourReg_mac<0, 0b100, 0b0000, (outs rGPR:$Rd),
2548             (ins rGPR:$Rn, rGPR:$Rm, rGPR:$Ra), IIC_iMAC32, "smlsd",
2549             "\t$Rd, $Rn, $Rm, $Ra", []>;
2550 def t2SMLSDX  : T2FourReg_mac<0, 0b100, 0b0001, (outs rGPR:$Rd),
2551             (ins rGPR:$Rn, rGPR:$Rm, rGPR:$Ra), IIC_iMAC32, "smlsdx",
2552             "\t$Rd, $Rn, $Rm, $Ra", []>;
2553 def t2SMLALD  : T2FourReg_mac<1, 0b100, 0b1100, (outs rGPR:$Ra,rGPR:$Rd),
2554                         (ins rGPR:$Rm, rGPR:$Rn), IIC_iMAC64, "smlald",
2555                         "\t$Ra, $Rd, $Rm, $Rn", []>;
2556 def t2SMLALDX : T2FourReg_mac<1, 0b100, 0b1101, (outs rGPR:$Ra,rGPR:$Rd),
2557                         (ins rGPR:$Rm,rGPR:$Rn), IIC_iMAC64, "smlaldx",
2558                         "\t$Ra, $Rd, $Rm, $Rn", []>;
2559 def t2SMLSLD  : T2FourReg_mac<1, 0b101, 0b1100, (outs rGPR:$Ra,rGPR:$Rd),
2560                         (ins rGPR:$Rm,rGPR:$Rn), IIC_iMAC64, "smlsld",
2561                         "\t$Ra, $Rd, $Rm, $Rn", []>;
2562 def t2SMLSLDX : T2FourReg_mac<1, 0b101, 0b1101, (outs rGPR:$Ra,rGPR:$Rd),
2563                         (ins rGPR:$Rm,rGPR:$Rn), IIC_iMAC64, "smlsldx",
2564                         "\t$Ra, $Rd, $Rm, $Rn", []>;
2565
2566 //===----------------------------------------------------------------------===//
2567 //  Misc. Arithmetic Instructions.
2568 //
2569
2570 class T2I_misc<bits<2> op1, bits<2> op2, dag oops, dag iops,
2571       InstrItinClass itin, string opc, string asm, list<dag> pattern>
2572   : T2ThreeReg<oops, iops, itin, opc, asm, pattern> {
2573   let Inst{31-27} = 0b11111;
2574   let Inst{26-22} = 0b01010;
2575   let Inst{21-20} = op1;
2576   let Inst{15-12} = 0b1111;
2577   let Inst{7-6} = 0b10;
2578   let Inst{5-4} = op2;
2579   let Rn{3-0} = Rm{3-0};
2580 }
2581
2582 def t2CLZ : T2I_misc<0b11, 0b00, (outs rGPR:$Rd), (ins rGPR:$Rm), IIC_iUNAr,
2583                     "clz", "\t$Rd, $Rm", [(set rGPR:$Rd, (ctlz rGPR:$Rm))]>;
2584
2585 def t2RBIT : T2I_misc<0b01, 0b10, (outs rGPR:$Rd), (ins rGPR:$Rm), IIC_iUNAr,
2586                       "rbit", "\t$Rd, $Rm",
2587                       [(set rGPR:$Rd, (ARMrbit rGPR:$Rm))]>;
2588
2589 def t2REV : T2I_misc<0b01, 0b00, (outs rGPR:$Rd), (ins rGPR:$Rm), IIC_iUNAr,
2590                  "rev", ".w\t$Rd, $Rm", [(set rGPR:$Rd, (bswap rGPR:$Rm))]>;
2591
2592 def t2REV16 : T2I_misc<0b01, 0b01, (outs rGPR:$Rd), (ins rGPR:$Rm), IIC_iUNAr,
2593                        "rev16", ".w\t$Rd, $Rm",
2594                 [(set rGPR:$Rd,
2595                     (or (and (srl rGPR:$Rm, (i32 8)), 0xFF),
2596                         (or (and (shl rGPR:$Rm, (i32 8)), 0xFF00),
2597                             (or (and (srl rGPR:$Rm, (i32 8)), 0xFF0000),
2598                                (and (shl rGPR:$Rm, (i32 8)), 0xFF000000)))))]>;
2599
2600 def t2REVSH : T2I_misc<0b01, 0b11, (outs rGPR:$Rd), (ins rGPR:$Rm), IIC_iUNAr,
2601                        "revsh", ".w\t$Rd, $Rm",
2602                  [(set rGPR:$Rd,
2603                     (sext_inreg
2604                       (or (srl (and rGPR:$Rm, 0xFF00), (i32 8)),
2605                           (shl rGPR:$Rm, (i32 8))), i16))]>;
2606
2607 def t2PKHBT : T2ThreeReg<
2608             (outs rGPR:$Rd), (ins rGPR:$Rn, rGPR:$Rm, shift_imm:$sh),
2609                   IIC_iBITsi, "pkhbt", "\t$Rd, $Rn, $Rm$sh",
2610                   [(set rGPR:$Rd, (or (and rGPR:$Rn, 0xFFFF),
2611                                       (and (shl rGPR:$Rm, lsl_amt:$sh),
2612                                            0xFFFF0000)))]>,
2613                   Requires<[HasT2ExtractPack, IsThumb2]> {
2614   let Inst{31-27} = 0b11101;
2615   let Inst{26-25} = 0b01;
2616   let Inst{24-20} = 0b01100;
2617   let Inst{5} = 0; // BT form
2618   let Inst{4} = 0;
2619
2620   bits<8> sh;
2621   let Inst{14-12} = sh{7-5};
2622   let Inst{7-6}   = sh{4-3};
2623 }
2624
2625 // Alternate cases for PKHBT where identities eliminate some nodes.
2626 def : T2Pat<(or (and rGPR:$src1, 0xFFFF), (and rGPR:$src2, 0xFFFF0000)),
2627             (t2PKHBT rGPR:$src1, rGPR:$src2, 0)>,
2628             Requires<[HasT2ExtractPack, IsThumb2]>;
2629 def : T2Pat<(or (and rGPR:$src1, 0xFFFF), (shl rGPR:$src2, imm16_31:$sh)),
2630             (t2PKHBT rGPR:$src1, rGPR:$src2, (lsl_shift_imm imm16_31:$sh))>,
2631             Requires<[HasT2ExtractPack, IsThumb2]>;
2632
2633 // Note: Shifts of 1-15 bits will be transformed to srl instead of sra and
2634 // will match the pattern below.
2635 def t2PKHTB : T2ThreeReg<
2636                   (outs rGPR:$Rd), (ins rGPR:$Rn, rGPR:$Rm, shift_imm:$sh),
2637                   IIC_iBITsi, "pkhtb", "\t$Rd, $Rn, $Rm$sh",
2638                   [(set rGPR:$Rd, (or (and rGPR:$Rn, 0xFFFF0000),
2639                                        (and (sra rGPR:$Rm, asr_amt:$sh),
2640                                             0xFFFF)))]>,
2641                   Requires<[HasT2ExtractPack, IsThumb2]> {
2642   let Inst{31-27} = 0b11101;
2643   let Inst{26-25} = 0b01;
2644   let Inst{24-20} = 0b01100;
2645   let Inst{5} = 1; // TB form
2646   let Inst{4} = 0;
2647
2648   bits<8> sh;
2649   let Inst{14-12} = sh{7-5};
2650   let Inst{7-6}   = sh{4-3};
2651 }
2652
2653 // Alternate cases for PKHTB where identities eliminate some nodes.  Note that
2654 // a shift amount of 0 is *not legal* here, it is PKHBT instead.
2655 def : T2Pat<(or (and rGPR:$src1, 0xFFFF0000), (srl rGPR:$src2, imm16_31:$sh)),
2656             (t2PKHTB rGPR:$src1, rGPR:$src2, (asr_shift_imm imm16_31:$sh))>,
2657             Requires<[HasT2ExtractPack, IsThumb2]>;
2658 def : T2Pat<(or (and rGPR:$src1, 0xFFFF0000),
2659                 (and (srl rGPR:$src2, imm1_15:$sh), 0xFFFF)),
2660             (t2PKHTB rGPR:$src1, rGPR:$src2, (asr_shift_imm imm1_15:$sh))>,
2661             Requires<[HasT2ExtractPack, IsThumb2]>;
2662
2663 //===----------------------------------------------------------------------===//
2664 //  Comparison Instructions...
2665 //
2666 defm t2CMP  : T2I_cmp_irs<0b1101, "cmp",
2667                           IIC_iCMPi, IIC_iCMPr, IIC_iCMPsi,
2668                           BinOpFrag<(ARMcmp node:$LHS, node:$RHS)>>;
2669 defm t2CMPz : T2I_cmp_irs<0b1101, "cmp",
2670                           IIC_iCMPi, IIC_iCMPr, IIC_iCMPsi,
2671                           BinOpFrag<(ARMcmpZ node:$LHS, node:$RHS)>>;
2672
2673 //FIXME: Disable CMN, as CCodes are backwards from compare expectations
2674 //       Compare-to-zero still works out, just not the relationals
2675 //defm t2CMN  : T2I_cmp_irs<0b1000, "cmn",
2676 //                          BinOpFrag<(ARMcmp node:$LHS,(ineg node:$RHS))>>;
2677 defm t2CMNz : T2I_cmp_irs<0b1000, "cmn",
2678                           IIC_iCMPi, IIC_iCMPr, IIC_iCMPsi,
2679                           BinOpFrag<(ARMcmpZ node:$LHS,(ineg node:$RHS))>>;
2680
2681 //def : T2Pat<(ARMcmp  GPR:$src, t2_so_imm_neg:$imm),
2682 //            (t2CMNri GPR:$src, t2_so_imm_neg:$imm)>;
2683
2684 def : T2Pat<(ARMcmpZ  GPR:$src, t2_so_imm_neg:$imm),
2685             (t2CMNzri GPR:$src, t2_so_imm_neg:$imm)>;
2686
2687 defm t2TST  : T2I_cmp_irs<0b0000, "tst",
2688                           IIC_iTSTi, IIC_iTSTr, IIC_iTSTsi,
2689                          BinOpFrag<(ARMcmpZ (and_su node:$LHS, node:$RHS), 0)>>;
2690 defm t2TEQ  : T2I_cmp_irs<0b0100, "teq",
2691                           IIC_iTSTi, IIC_iTSTr, IIC_iTSTsi,
2692                          BinOpFrag<(ARMcmpZ (xor_su node:$LHS, node:$RHS), 0)>>;
2693
2694 // Conditional moves
2695 // FIXME: should be able to write a pattern for ARMcmov, but can't use
2696 // a two-value operand where a dag node expects two operands. :(
2697 let neverHasSideEffects = 1 in {
2698 def t2MOVCCr : T2TwoReg<
2699                    (outs rGPR:$Rd), (ins rGPR:$false, rGPR:$Rm), IIC_iCMOVr,
2700                    "mov", ".w\t$Rd, $Rm",
2701    [/*(set rGPR:$Rd, (ARMcmov rGPR:$false, rGPR:$Rm, imm:$cc, CCR:$ccr))*/]>,
2702                 RegConstraint<"$false = $Rd"> {
2703   let Inst{31-27} = 0b11101;
2704   let Inst{26-25} = 0b01;
2705   let Inst{24-21} = 0b0010;
2706   let Inst{20} = 0; // The S bit.
2707   let Inst{19-16} = 0b1111; // Rn
2708   let Inst{14-12} = 0b000;
2709   let Inst{7-4} = 0b0000;
2710 }
2711
2712 let isMoveImm = 1 in
2713 def t2MOVCCi : T2OneRegImm<(outs rGPR:$Rd), (ins rGPR:$false, t2_so_imm:$imm),
2714                    IIC_iCMOVi, "mov", ".w\t$Rd, $imm",
2715 [/*(set rGPR:$Rd,(ARMcmov rGPR:$false,t2_so_imm:$imm, imm:$cc, CCR:$ccr))*/]>,
2716                    RegConstraint<"$false = $Rd"> {
2717   let Inst{31-27} = 0b11110;
2718   let Inst{25} = 0;
2719   let Inst{24-21} = 0b0010;
2720   let Inst{20} = 0; // The S bit.
2721   let Inst{19-16} = 0b1111; // Rn
2722   let Inst{15} = 0;
2723 }
2724
2725 let isMoveImm = 1 in
2726 def t2MOVCCi16 : T2I<(outs rGPR:$Rd), (ins rGPR:$false, i32imm:$imm),
2727                       IIC_iCMOVi,
2728                       "movw", "\t$Rd, $imm", []>,
2729                       RegConstraint<"$false = $Rd"> {
2730   let Inst{31-27} = 0b11110;
2731   let Inst{25} = 1;
2732   let Inst{24-21} = 0b0010;
2733   let Inst{20} = 0; // The S bit.
2734   let Inst{15} = 0;
2735
2736   bits<4> Rd;
2737   bits<16> imm;
2738
2739   let Inst{11-8}  = Rd{3-0};
2740   let Inst{19-16} = imm{15-12};
2741   let Inst{26}    = imm{11};
2742   let Inst{14-12} = imm{10-8};
2743   let Inst{7-0}   = imm{7-0};
2744 }
2745
2746 let isMoveImm = 1 in
2747 def t2MOVCCi32imm : PseudoInst<(outs rGPR:$dst),
2748                                (ins rGPR:$false, i32imm:$src, pred:$p),
2749                     IIC_iCMOVix2, []>, RegConstraint<"$false = $dst">;
2750
2751 let isMoveImm = 1 in
2752 def t2MVNCCi : T2OneRegImm<(outs rGPR:$Rd), (ins rGPR:$false, t2_so_imm:$imm),
2753                    IIC_iCMOVi, "mvn", ".w\t$Rd, $imm",
2754 [/*(set rGPR:$Rd,(ARMcmov rGPR:$false,t2_so_imm_not:$imm,
2755                    imm:$cc, CCR:$ccr))*/]>,
2756                    RegConstraint<"$false = $Rd"> {
2757   let Inst{31-27} = 0b11110;
2758   let Inst{25} = 0;
2759   let Inst{24-21} = 0b0011;
2760   let Inst{20} = 0; // The S bit.
2761   let Inst{19-16} = 0b1111; // Rn
2762   let Inst{15} = 0;
2763 }
2764
2765 class T2I_movcc_sh<bits<2> opcod, dag oops, dag iops, InstrItinClass itin,
2766                    string opc, string asm, list<dag> pattern>
2767   : T2TwoRegShiftImm<oops, iops, itin, opc, asm, pattern> {
2768   let Inst{31-27} = 0b11101;
2769   let Inst{26-25} = 0b01;
2770   let Inst{24-21} = 0b0010;
2771   let Inst{20} = 0; // The S bit.
2772   let Inst{19-16} = 0b1111; // Rn
2773   let Inst{5-4} = opcod; // Shift type.
2774 }
2775 def t2MOVCClsl : T2I_movcc_sh<0b00, (outs rGPR:$Rd),
2776                              (ins rGPR:$false, rGPR:$Rm, i32imm:$imm),
2777                              IIC_iCMOVsi, "lsl", ".w\t$Rd, $Rm, $imm", []>,
2778                  RegConstraint<"$false = $Rd">;
2779 def t2MOVCClsr : T2I_movcc_sh<0b01, (outs rGPR:$Rd),
2780                              (ins rGPR:$false, rGPR:$Rm, i32imm:$imm),
2781                              IIC_iCMOVsi, "lsr", ".w\t$Rd, $Rm, $imm", []>,
2782                  RegConstraint<"$false = $Rd">;
2783 def t2MOVCCasr : T2I_movcc_sh<0b10, (outs rGPR:$Rd),
2784                              (ins rGPR:$false, rGPR:$Rm, i32imm:$imm),
2785                              IIC_iCMOVsi, "asr", ".w\t$Rd, $Rm, $imm", []>,
2786                  RegConstraint<"$false = $Rd">;
2787 def t2MOVCCror : T2I_movcc_sh<0b11, (outs rGPR:$Rd),
2788                              (ins rGPR:$false, rGPR:$Rm, i32imm:$imm),
2789                              IIC_iCMOVsi, "ror", ".w\t$Rd, $Rm, $imm", []>,
2790                  RegConstraint<"$false = $Rd">;
2791 } // neverHasSideEffects
2792
2793 //===----------------------------------------------------------------------===//
2794 // Atomic operations intrinsics
2795 //
2796
2797 // memory barriers protect the atomic sequences
2798 let hasSideEffects = 1 in {
2799 def t2DMB : AInoP<(outs), (ins memb_opt:$opt), ThumbFrm, NoItinerary,
2800                   "dmb", "\t$opt", [(ARMMemBarrier (i32 imm:$opt))]>,
2801                   Requires<[IsThumb, HasDB]> {
2802   bits<4> opt;
2803   let Inst{31-4} = 0xf3bf8f5;
2804   let Inst{3-0} = opt;
2805 }
2806 }
2807
2808 def t2DSB : AInoP<(outs), (ins memb_opt:$opt), ThumbFrm, NoItinerary,
2809                   "dsb", "\t$opt",
2810                   [/* For disassembly only; pattern left blank */]>,
2811                   Requires<[IsThumb, HasDB]> {
2812   bits<4> opt;
2813   let Inst{31-4} = 0xf3bf8f4;
2814   let Inst{3-0} = opt;
2815 }
2816
2817 // ISB has only full system option -- for disassembly only
2818 def t2ISB : T2I<(outs), (ins), NoItinerary, "isb", "",
2819                   [/* For disassembly only; pattern left blank */]>,
2820                   Requires<[IsThumb2, HasV7]> {
2821   let Inst{31-4} = 0xf3bf8f6;
2822   let Inst{3-0} = 0b1111;
2823 }
2824
2825 class T2I_ldrex<bits<2> opcod, dag oops, dag iops, AddrMode am, SizeFlagVal sz,
2826                 InstrItinClass itin, string opc, string asm, string cstr,
2827                 list<dag> pattern, bits<4> rt2 = 0b1111>
2828   : Thumb2I<oops, iops, am, sz, itin, opc, asm, cstr, pattern> {
2829   let Inst{31-27} = 0b11101;
2830   let Inst{26-20} = 0b0001101;
2831   let Inst{11-8} = rt2;
2832   let Inst{7-6} = 0b01;
2833   let Inst{5-4} = opcod;
2834   let Inst{3-0} = 0b1111;
2835
2836   bits<4> Rn;
2837   bits<4> Rt;
2838   let Inst{19-16} = Rn{3-0};
2839   let Inst{15-12} = Rt{3-0};
2840 }
2841 class T2I_strex<bits<2> opcod, dag oops, dag iops, AddrMode am, SizeFlagVal sz,
2842                 InstrItinClass itin, string opc, string asm, string cstr,
2843                 list<dag> pattern, bits<4> rt2 = 0b1111>
2844   : Thumb2I<oops, iops, am, sz, itin, opc, asm, cstr, pattern> {
2845   let Inst{31-27} = 0b11101;
2846   let Inst{26-20} = 0b0001100;
2847   let Inst{11-8} = rt2;
2848   let Inst{7-6} = 0b01;
2849   let Inst{5-4} = opcod;
2850
2851   bits<4> Rd;
2852   bits<4> Rn;
2853   bits<4> Rt;
2854   let Inst{11-8}  = Rd{3-0};
2855   let Inst{19-16} = Rn{3-0};
2856   let Inst{15-12} = Rt{3-0};
2857 }
2858
2859 let mayLoad = 1 in {
2860 def t2LDREXB : T2I_ldrex<0b00, (outs rGPR:$Rt), (ins rGPR:$Rn), AddrModeNone,
2861                          Size4Bytes, NoItinerary, "ldrexb", "\t$Rt, [$Rn]",
2862                          "", []>;
2863 def t2LDREXH : T2I_ldrex<0b01, (outs rGPR:$Rt), (ins rGPR:$Rn), AddrModeNone,
2864                          Size4Bytes, NoItinerary, "ldrexh", "\t$Rt, [$Rn]",
2865                          "", []>;
2866 def t2LDREX  : Thumb2I<(outs rGPR:$Rt), (ins rGPR:$Rn), AddrModeNone,
2867                        Size4Bytes, NoItinerary,
2868                        "ldrex", "\t$Rt, [$Rn]", "",
2869                       []> {
2870   let Inst{31-27} = 0b11101;
2871   let Inst{26-20} = 0b0000101;
2872   let Inst{11-8} = 0b1111;
2873   let Inst{7-0} = 0b00000000; // imm8 = 0
2874 }
2875 def t2LDREXD : T2I_ldrex<0b11, (outs rGPR:$Rt, rGPR:$Rt2), (ins rGPR:$Rn),
2876                          AddrModeNone, Size4Bytes, NoItinerary,
2877                          "ldrexd", "\t$Rt, $Rt2, [$Rn]", "",
2878                          [], {?, ?, ?, ?}> {
2879   bits<4> Rt2;
2880   let Inst{11-8} = Rt2{3-0};
2881 }
2882 }
2883
2884 let mayStore = 1, Constraints = "@earlyclobber $Rd" in {
2885 def t2STREXB : T2I_strex<0b00, (outs rGPR:$Rd), (ins rGPR:$Rt, rGPR:$Rn),
2886                          AddrModeNone, Size4Bytes, NoItinerary,
2887                          "strexb", "\t$Rd, $Rt, [$Rn]", "", []>;
2888 def t2STREXH : T2I_strex<0b01, (outs rGPR:$Rd), (ins rGPR:$Rt, rGPR:$Rn),
2889                          AddrModeNone, Size4Bytes, NoItinerary,
2890                          "strexh", "\t$Rd, $Rt, [$Rn]", "", []>;
2891 def t2STREX  : Thumb2I<(outs rGPR:$Rd), (ins rGPR:$Rt, rGPR:$Rn),
2892                        AddrModeNone, Size4Bytes, NoItinerary,
2893                        "strex", "\t$Rd, $Rt, [$Rn]", "",
2894                       []> {
2895   let Inst{31-27} = 0b11101;
2896   let Inst{26-20} = 0b0000100;
2897   let Inst{7-0} = 0b00000000; // imm8 = 0
2898 }
2899 def t2STREXD : T2I_strex<0b11, (outs rGPR:$Rd),
2900                          (ins rGPR:$Rt, rGPR:$Rt2, rGPR:$Rn),
2901                          AddrModeNone, Size4Bytes, NoItinerary,
2902                          "strexd", "\t$Rd, $Rt, $Rt2, [$Rn]", "", [],
2903                          {?, ?, ?, ?}> {
2904   bits<4> Rt2;
2905   let Inst{11-8} = Rt2{3-0};
2906 }
2907 }
2908
2909 // Clear-Exclusive is for disassembly only.
2910 def t2CLREX : T2I<(outs), (ins), NoItinerary, "clrex", "",
2911                   [/* For disassembly only; pattern left blank */]>,
2912             Requires<[IsARM, HasV7]>  {
2913   let Inst{31-20} = 0xf3b;
2914   let Inst{15-14} = 0b10;
2915   let Inst{12} = 0;
2916   let Inst{7-4} = 0b0010;
2917 }
2918
2919 //===----------------------------------------------------------------------===//
2920 // TLS Instructions
2921 //
2922
2923 // __aeabi_read_tp preserves the registers r1-r3.
2924 let isCall = 1,
2925   Defs = [R0, R12, LR, CPSR], Uses = [SP] in {
2926   def t2TPsoft : T2XI<(outs), (ins), IIC_Br,
2927                      "bl\t__aeabi_read_tp",
2928                      [(set R0, ARMthread_pointer)]> {
2929     let Inst{31-27} = 0b11110;
2930     let Inst{15-14} = 0b11;
2931     let Inst{12} = 1;
2932   }
2933 }
2934
2935 //===----------------------------------------------------------------------===//
2936 // SJLJ Exception handling intrinsics
2937 //   eh_sjlj_setjmp() is an instruction sequence to store the return
2938 //   address and save #0 in R0 for the non-longjmp case.
2939 //   Since by its nature we may be coming from some other function to get
2940 //   here, and we're using the stack frame for the containing function to
2941 //   save/restore registers, we can't keep anything live in regs across
2942 //   the eh_sjlj_setjmp(), else it will almost certainly have been tromped upon
2943 //   when we get here from a longjmp(). We force everthing out of registers
2944 //   except for our own input by listing the relevant registers in Defs. By
2945 //   doing so, we also cause the prologue/epilogue code to actively preserve
2946 //   all of the callee-saved resgisters, which is exactly what we want.
2947 //   $val is a scratch register for our use.
2948 let Defs =
2949   [ R0,  R1,  R2,  R3,  R4,  R5,  R6,  R7,  R8,  R9,  R10, R11, R12, LR,  D0,
2950     D1,  D2,  D3,  D4,  D5,  D6,  D7,  D8,  D9,  D10, D11, D12, D13, D14, D15,
2951     D16, D17, D18, D19, D20, D21, D22, D23, D24, D25, D26, D27, D28, D29, D30,
2952     D31 ], hasSideEffects = 1, isBarrier = 1, isCodeGenOnly = 1 in {
2953   def t2Int_eh_sjlj_setjmp : Thumb2XI<(outs), (ins tGPR:$src, tGPR:$val),
2954                                AddrModeNone, SizeSpecial, NoItinerary, "", "",
2955                           [(set R0, (ARMeh_sjlj_setjmp tGPR:$src, tGPR:$val))]>,
2956                              Requires<[IsThumb2, HasVFP2]>;
2957 }
2958
2959 let Defs =
2960   [ R0,  R1,  R2,  R3,  R4,  R5,  R6,  R7,  R8,  R9,  R10, R11, R12, LR ],
2961   hasSideEffects = 1, isBarrier = 1, isCodeGenOnly = 1 in {
2962   def t2Int_eh_sjlj_setjmp_nofp : Thumb2XI<(outs), (ins tGPR:$src, tGPR:$val),
2963                                AddrModeNone, SizeSpecial, NoItinerary, "", "",
2964                           [(set R0, (ARMeh_sjlj_setjmp tGPR:$src, tGPR:$val))]>,
2965                                   Requires<[IsThumb2, NoVFP]>;
2966 }
2967
2968
2969 //===----------------------------------------------------------------------===//
2970 // Control-Flow Instructions
2971 //
2972
2973 // FIXME: remove when we have a way to marking a MI with these properties.
2974 // FIXME: $dst1 should be a def. But the extra ops must be in the end of the
2975 // operand list.
2976 // FIXME: Should pc be an implicit operand like PICADD, etc?
2977 let isReturn = 1, isTerminator = 1, isBarrier = 1, mayLoad = 1,
2978     hasExtraDefRegAllocReq = 1, isCodeGenOnly = 1 in
2979 def t2LDMIA_RET: T2XIt<(outs GPR:$wb), (ins GPR:$Rn, pred:$p,
2980                                         reglist:$regs, variable_ops),
2981                         IIC_iLoad_mBr,
2982                         "ldmia${p}.w\t$Rn!, $regs",
2983                         "$Rn = $wb", []> {
2984   bits<4>  Rn;
2985   bits<16> regs;
2986
2987   let Inst{31-27} = 0b11101;
2988   let Inst{26-25} = 0b00;
2989   let Inst{24-23} = 0b01;     // Increment After
2990   let Inst{22}    = 0;
2991   let Inst{21}    = 1;        // Writeback
2992   let Inst{20}    = 1;
2993   let Inst{19-16} = Rn;
2994   let Inst{15-0}  = regs;
2995 }
2996
2997 let isBranch = 1, isTerminator = 1, isBarrier = 1 in {
2998 let isPredicable = 1 in
2999 def t2B   : T2XI<(outs), (ins brtarget:$target), IIC_Br,
3000                  "b.w\t$target",
3001                  [(br bb:$target)]> {
3002   let Inst{31-27} = 0b11110;
3003   let Inst{15-14} = 0b10;
3004   let Inst{12} = 1;
3005
3006   bits<20> target;
3007   let Inst{26} = target{19};
3008   let Inst{11} = target{18};
3009   let Inst{13} = target{17};
3010   let Inst{21-16} = target{16-11};
3011   let Inst{10-0} = target{10-0};
3012 }
3013
3014 let isNotDuplicable = 1, isIndirectBranch = 1 in {
3015 def t2BR_JT : tPseudoInst<(outs),
3016           (ins GPR:$target, GPR:$index, i32imm:$jt, i32imm:$id),
3017            SizeSpecial, IIC_Br,
3018           [(ARMbr2jt GPR:$target, GPR:$index, tjumptable:$jt, imm:$id)]>;
3019
3020 // FIXME: Add a non-pc based case that can be predicated.
3021 def t2TBB_JT : tPseudoInst<(outs),
3022         (ins GPR:$index, i32imm:$jt, i32imm:$id),
3023          SizeSpecial, IIC_Br, []>;
3024
3025 def t2TBH_JT : tPseudoInst<(outs),
3026         (ins GPR:$index, i32imm:$jt, i32imm:$id),
3027          SizeSpecial, IIC_Br, []>;
3028
3029 def t2TBB : T2I<(outs), (ins GPR:$Rn, GPR:$Rm), IIC_Br,
3030                     "tbb", "\t[$Rn, $Rm]", []> {
3031   bits<4> Rn;
3032   bits<4> Rm;
3033   let Inst{27-20} = 0b10001101;
3034   let Inst{19-16} = Rn;
3035   let Inst{15-5} = 0b11110000000;
3036   let Inst{4} = 0; // B form
3037   let Inst{3-0} = Rm;
3038 }
3039
3040 def t2TBH : T2I<(outs), (ins GPR:$Rn, GPR:$Rm), IIC_Br,
3041                    "tbh", "\t[$Rn, $Rm, lsl #1]", []> {
3042   bits<4> Rn;
3043   bits<4> Rm;
3044   let Inst{27-20} = 0b10001101;
3045   let Inst{19-16} = Rn;
3046   let Inst{15-5} = 0b11110000000;
3047   let Inst{4} = 1; // H form
3048   let Inst{3-0} = Rm;
3049 }
3050 } // isNotDuplicable, isIndirectBranch
3051
3052 } // isBranch, isTerminator, isBarrier
3053
3054 // FIXME: should be able to write a pattern for ARMBrcond, but can't use
3055 // a two-value operand where a dag node expects two operands. :(
3056 let isBranch = 1, isTerminator = 1 in
3057 def t2Bcc : T2I<(outs), (ins brtarget:$target), IIC_Br,
3058                 "b", ".w\t$target",
3059                 [/*(ARMbrcond bb:$target, imm:$cc)*/]> {
3060   let Inst{31-27} = 0b11110;
3061   let Inst{15-14} = 0b10;
3062   let Inst{12} = 0;
3063
3064   bits<20> target;
3065   let Inst{26} = target{19};
3066   let Inst{11} = target{18};
3067   let Inst{13} = target{17};
3068   let Inst{21-16} = target{16-11};
3069   let Inst{10-0} = target{10-0};
3070 }
3071
3072
3073 // IT block
3074 let Defs = [ITSTATE] in
3075 def t2IT : Thumb2XI<(outs), (ins it_pred:$cc, it_mask:$mask),
3076                     AddrModeNone, Size2Bytes,  IIC_iALUx,
3077                     "it$mask\t$cc", "", []> {
3078   // 16-bit instruction.
3079   let Inst{31-16} = 0x0000;
3080   let Inst{15-8} = 0b10111111;
3081
3082   bits<4> cc;
3083   bits<4> mask;
3084   let Inst{7-4} = cc{3-0};
3085   let Inst{3-0} = mask{3-0};
3086 }
3087
3088 // Branch and Exchange Jazelle -- for disassembly only
3089 // Rm = Inst{19-16}
3090 def t2BXJ : T2I<(outs), (ins rGPR:$func), NoItinerary, "bxj", "\t$func",
3091               [/* For disassembly only; pattern left blank */]> {
3092   let Inst{31-27} = 0b11110;
3093   let Inst{26} = 0;
3094   let Inst{25-20} = 0b111100;
3095   let Inst{15-14} = 0b10;
3096   let Inst{12} = 0;
3097
3098   bits<4> func;
3099   let Inst{19-16} = func{3-0};
3100 }
3101
3102 // Change Processor State is a system instruction -- for disassembly only.
3103 // The singleton $opt operand contains the following information:
3104 // opt{4-0} = mode from Inst{4-0}
3105 // opt{5} = changemode from Inst{17}
3106 // opt{8-6} = AIF from Inst{8-6}
3107 // opt{10-9} = imod from Inst{19-18} with 0b10 as enable and 0b11 as disable
3108 def t2CPS : T2XI<(outs),(ins cps_opt:$opt), NoItinerary, "cps$opt",
3109                  [/* For disassembly only; pattern left blank */]> {
3110   let Inst{31-27} = 0b11110;
3111   let Inst{26} = 0;
3112   let Inst{25-20} = 0b111010;
3113   let Inst{15-14} = 0b10;
3114   let Inst{12} = 0;
3115
3116   bits<11> opt;
3117
3118   // mode number
3119   let Inst{4-0} = opt{4-0};
3120
3121   // M flag
3122   let Inst{8} = opt{5};
3123
3124   // F flag
3125   let Inst{5} = opt{6};
3126
3127   // I flag
3128   let Inst{6} = opt{7};
3129
3130   // A flag
3131   let Inst{7} = opt{8};
3132
3133   // imod flag
3134   let Inst{10-9} = opt{10-9};
3135 }
3136
3137 // A6.3.4 Branches and miscellaneous control
3138 // Table A6-14 Change Processor State, and hint instructions
3139 // Helper class for disassembly only.
3140 class T2I_hint<bits<8> op7_0, string opc, string asm>
3141   : T2I<(outs), (ins), NoItinerary, opc, asm,
3142         [/* For disassembly only; pattern left blank */]> {
3143   let Inst{31-20} = 0xf3a;
3144   let Inst{15-14} = 0b10;
3145   let Inst{12} = 0;
3146   let Inst{10-8} = 0b000;
3147   let Inst{7-0} = op7_0;
3148 }
3149
3150 def t2NOP   : T2I_hint<0b00000000, "nop",   ".w">;
3151 def t2YIELD : T2I_hint<0b00000001, "yield", ".w">;
3152 def t2WFE   : T2I_hint<0b00000010, "wfe",   ".w">;
3153 def t2WFI   : T2I_hint<0b00000011, "wfi",   ".w">;
3154 def t2SEV   : T2I_hint<0b00000100, "sev",   ".w">;
3155
3156 def t2DBG : T2I<(outs),(ins i32imm:$opt), NoItinerary, "dbg", "\t$opt",
3157                 [/* For disassembly only; pattern left blank */]> {
3158   let Inst{31-20} = 0xf3a;
3159   let Inst{15-14} = 0b10;
3160   let Inst{12} = 0;
3161   let Inst{10-8} = 0b000;
3162   let Inst{7-4} = 0b1111;
3163
3164   bits<4> opt;
3165   let Inst{3-0} = opt{3-0};
3166 }
3167
3168 // Secure Monitor Call is a system instruction -- for disassembly only
3169 // Option = Inst{19-16}
3170 def t2SMC : T2I<(outs), (ins i32imm:$opt), NoItinerary, "smc", "\t$opt",
3171                 [/* For disassembly only; pattern left blank */]> {
3172   let Inst{31-27} = 0b11110;
3173   let Inst{26-20} = 0b1111111;
3174   let Inst{15-12} = 0b1000;
3175
3176   bits<4> opt;
3177   let Inst{19-16} = opt{3-0};
3178 }
3179
3180 class T2SRS<bits<12> op31_20,
3181            dag oops, dag iops, InstrItinClass itin,
3182           string opc, string asm, list<dag> pattern>
3183   : T2I<oops, iops, itin, opc, asm, pattern> {
3184   let Inst{31-20} = op31_20{11-0};
3185
3186   bits<5> mode;
3187   let Inst{4-0} = mode{4-0};
3188 }
3189
3190 // Store Return State is a system instruction -- for disassembly only
3191 def t2SRSDBW : T2SRS<0b111010000010,
3192                    (outs),(ins i32imm:$mode),NoItinerary,"srsdb","\tsp!, $mode",
3193                    [/* For disassembly only; pattern left blank */]>;
3194 def t2SRSDB  : T2SRS<0b111010000000,
3195                    (outs),(ins i32imm:$mode),NoItinerary,"srsdb","\tsp, $mode",
3196                    [/* For disassembly only; pattern left blank */]>;
3197 def t2SRSIAW : T2SRS<0b111010011010,
3198                    (outs),(ins i32imm:$mode),NoItinerary,"srsia","\tsp!, $mode",
3199                    [/* For disassembly only; pattern left blank */]>;
3200 def t2SRSIA  : T2SRS<0b111010011000,
3201                    (outs), (ins i32imm:$mode),NoItinerary,"srsia","\tsp, $mode",
3202                    [/* For disassembly only; pattern left blank */]>;
3203
3204 // Return From Exception is a system instruction -- for disassembly only
3205
3206 class T2RFE<bits<12> op31_20, dag oops, dag iops, InstrItinClass itin,
3207           string opc, string asm, list<dag> pattern>
3208   : T2I<oops, iops, itin, opc, asm, pattern> {
3209   let Inst{31-20} = op31_20{11-0};
3210
3211   bits<4> Rn;
3212   let Inst{19-16} = Rn{3-0};
3213 }
3214
3215 def t2RFEDBW : T2RFE<0b111010000011,
3216                    (outs), (ins rGPR:$Rn), NoItinerary, "rfedb", "\t$Rn!",
3217                    [/* For disassembly only; pattern left blank */]>;
3218 def t2RFEDB  : T2RFE<0b111010000001,
3219                    (outs), (ins rGPR:$Rn), NoItinerary, "rfeab", "\t$Rn",
3220                    [/* For disassembly only; pattern left blank */]>;
3221 def t2RFEIAW : T2RFE<0b111010011011,
3222                    (outs), (ins rGPR:$Rn), NoItinerary, "rfeia", "\t$Rn!",
3223                    [/* For disassembly only; pattern left blank */]>;
3224 def t2RFEIA  : T2RFE<0b111010011001,
3225                    (outs), (ins rGPR:$Rn), NoItinerary, "rfeia", "\t$Rn",
3226                    [/* For disassembly only; pattern left blank */]>;
3227
3228 //===----------------------------------------------------------------------===//
3229 // Non-Instruction Patterns
3230 //
3231
3232 // 32-bit immediate using movw + movt.
3233 // This is a single pseudo instruction to make it re-materializable.
3234 // FIXME: Remove this when we can do generalized remat.
3235 let isReMaterializable = 1, isMoveImm = 1 in
3236 def t2MOVi32imm : PseudoInst<(outs rGPR:$dst), (ins i32imm:$src), IIC_iMOVix2,
3237                             [(set rGPR:$dst, (i32 imm:$src))]>,
3238                             Requires<[IsThumb, HasV6T2]>;
3239
3240 // ConstantPool, GlobalAddress, and JumpTable
3241 def : T2Pat<(ARMWrapper  tglobaladdr :$dst), (t2LEApcrel tglobaladdr :$dst)>,
3242            Requires<[IsThumb2, DontUseMovt]>;
3243 def : T2Pat<(ARMWrapper  tconstpool  :$dst), (t2LEApcrel tconstpool  :$dst)>;
3244 def : T2Pat<(ARMWrapper  tglobaladdr :$dst), (t2MOVi32imm tglobaladdr :$dst)>,
3245            Requires<[IsThumb2, UseMovt]>;
3246
3247 def : T2Pat<(ARMWrapperJT tjumptable:$dst, imm:$id),
3248             (t2LEApcrelJT tjumptable:$dst, imm:$id)>;
3249
3250 // Pseudo instruction that combines ldr from constpool and add pc. This should
3251 // be expanded into two instructions late to allow if-conversion and
3252 // scheduling.
3253 let canFoldAsLoad = 1, isReMaterializable = 1 in
3254 def t2LDRpci_pic : PseudoInst<(outs GPR:$dst), (ins i32imm:$addr, pclabel:$cp),
3255                    IIC_iLoadiALU,
3256                [(set GPR:$dst, (ARMpic_add (load (ARMWrapper tconstpool:$addr)),
3257                                            imm:$cp))]>,
3258                Requires<[IsThumb2]>;
3259
3260 //===----------------------------------------------------------------------===//
3261 // Move between special register and ARM core register -- for disassembly only
3262 //
3263
3264 class T2SpecialReg<bits<12> op31_20, bits<2> op15_14, bits<1> op12,
3265           dag oops, dag iops, InstrItinClass itin,
3266           string opc, string asm, list<dag> pattern>
3267   : T2I<oops, iops, itin, opc, asm, pattern> {
3268   let Inst{31-20} = op31_20{11-0};
3269   let Inst{15-14} = op15_14{1-0};
3270   let Inst{12} = op12{0};
3271 }
3272
3273 class T2MRS<bits<12> op31_20, bits<2> op15_14, bits<1> op12,
3274           dag oops, dag iops, InstrItinClass itin,
3275           string opc, string asm, list<dag> pattern>
3276   : T2SpecialReg<op31_20, op15_14, op12, oops, iops, itin, opc, asm, pattern> {
3277   bits<4> Rd;
3278   let Inst{11-8} = Rd{3-0};
3279 }
3280
3281 def t2MRS : T2MRS<0b111100111110, 0b10, 0,
3282                 (outs rGPR:$Rd), (ins), NoItinerary, "mrs", "\t$Rd, cpsr",
3283                 [/* For disassembly only; pattern left blank */]>;
3284 def t2MRSsys : T2MRS<0b111100111111, 0b10, 0,
3285                    (outs rGPR:$Rd), (ins), NoItinerary, "mrs", "\t$Rd, spsr",
3286                    [/* For disassembly only; pattern left blank */]>;
3287
3288 class T2MSR<bits<12> op31_20, bits<2> op15_14, bits<1> op12,
3289             dag oops, dag iops, InstrItinClass itin,
3290           string opc, string asm, list<dag> pattern>
3291   : T2SpecialReg<op31_20, op15_14, op12, oops, iops, itin, opc, asm, pattern> {
3292   bits<4> Rn;
3293   bits<4> mask;
3294   let Inst{19-16} = Rn{3-0};
3295   let Inst{11-8} = mask{3-0};
3296 }
3297
3298 def t2MSR : T2MSR<0b111100111000, 0b10, 0,
3299                 (outs), (ins rGPR:$Rn, msr_mask:$mask), NoItinerary, "msr",
3300                 "\tcpsr$mask, $Rn",
3301                 [/* For disassembly only; pattern left blank */]>;
3302 def t2MSRsys : T2MSR<0b111100111001, 0b10, 0,
3303                    (outs), (ins rGPR:$Rn, msr_mask:$mask), NoItinerary, "msr",
3304                    "\tspsr$mask, $Rn",
3305                    [/* For disassembly only; pattern left blank */]>;