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