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