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