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