lib/Target/ARM/ARMInstrThumb2.td

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