lib/Target/ARM/ARMInstrThumb2.td

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