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