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