lib/Target/ARM/ARMInstrThumb2.td

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