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