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