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