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