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