lib/Target/ARM/ARMInstrInfo.td

   1 //===- ARMInstrInfo.td - Target Description for ARM Target -*- tablegen -*-===//
   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 ARM instructions in TableGen format.
  11 //
  12 //===----------------------------------------------------------------------===//
  13
  14 //===----------------------------------------------------------------------===//
  15 // ARM specific DAG Nodes.
  16 //
  17
  18 // Type profiles.
  19 def SDT_ARMCallSeqStart : SDCallSeqStart<[ SDTCisVT<0, i32> ]>;
  20 def SDT_ARMCallSeqEnd   : SDCallSeqEnd<[ SDTCisVT<0, i32>, SDTCisVT<1, i32> ]>;
  21
  22 def SDT_ARMSaveCallPC : SDTypeProfile<0, 1, []>;
  23
  24 def SDT_ARMcall    : SDTypeProfile<0, -1, [SDTCisPtrTy<0>]>;
  25
  26 def SDT_ARMCMov    : SDTypeProfile<1, 3,
  27                                    [SDTCisSameAs<0, 1>, SDTCisSameAs<0, 2>,
  28                                     SDTCisVT<3, i32>]>;
  29
  30 def SDT_ARMBrcond  : SDTypeProfile<0, 2,
  31                                    [SDTCisVT<0, OtherVT>, SDTCisVT<1, i32>]>;
  32
  33 def SDT_ARMBrJT    : SDTypeProfile<0, 3,
  34                                   [SDTCisPtrTy<0>, SDTCisVT<1, i32>,
  35                                    SDTCisVT<2, i32>]>;
  36
  37 def SDT_ARMBr2JT   : SDTypeProfile<0, 4,
  38                                   [SDTCisPtrTy<0>, SDTCisVT<1, i32>,
  39                                    SDTCisVT<2, i32>, SDTCisVT<3, i32>]>;
  40
  41 def SDT_ARMCmp     : SDTypeProfile<0, 2, [SDTCisSameAs<0, 1>]>;
  42
  43 def SDT_ARMPICAdd  : SDTypeProfile<1, 2, [SDTCisSameAs<0, 1>,
  44                                           SDTCisPtrTy<1>, SDTCisVT<2, i32>]>;
  45
  46 def SDT_ARMThreadPointer : SDTypeProfile<1, 0, [SDTCisPtrTy<0>]>;
  47 def SDT_ARMEH_SJLJ_Setjmp : SDTypeProfile<1, 2, [SDTCisInt<0>, SDTCisPtrTy<1>,
  48                                                  SDTCisInt<2>]>;
  49
  50 def SDT_ARMMEMBARRIERV7  : SDTypeProfile<0, 0, []>;
  51 def SDT_ARMSYNCBARRIERV7 : SDTypeProfile<0, 0, []>;
  52 def SDT_ARMMEMBARRIERV6  : SDTypeProfile<0, 1, [SDTCisInt<0>]>;
  53 def SDT_ARMSYNCBARRIERV6 : SDTypeProfile<0, 1, [SDTCisInt<0>]>;
  54
  55 // Node definitions.
  56 def ARMWrapper       : SDNode<"ARMISD::Wrapper",     SDTIntUnaryOp>;
  57 def ARMWrapperJT     : SDNode<"ARMISD::WrapperJT",   SDTIntBinOp>;
  58
  59 def ARMcallseq_start : SDNode<"ISD::CALLSEQ_START", SDT_ARMCallSeqStart,
  60                               [SDNPHasChain, SDNPOutFlag]>;
  61 def ARMcallseq_end   : SDNode<"ISD::CALLSEQ_END",   SDT_ARMCallSeqEnd,
  62                               [SDNPHasChain, SDNPOptInFlag, SDNPOutFlag]>;
  63
  64 def ARMcall          : SDNode<"ARMISD::CALL", SDT_ARMcall,
  65                               [SDNPHasChain, SDNPOptInFlag, SDNPOutFlag]>;
  66 def ARMcall_pred    : SDNode<"ARMISD::CALL_PRED", SDT_ARMcall,
  67                               [SDNPHasChain, SDNPOptInFlag, SDNPOutFlag]>;
  68 def ARMcall_nolink   : SDNode<"ARMISD::CALL_NOLINK", SDT_ARMcall,
  69                               [SDNPHasChain, SDNPOptInFlag, SDNPOutFlag]>;
  70
  71 def ARMretflag       : SDNode<"ARMISD::RET_FLAG", SDTNone,
  72                               [SDNPHasChain, SDNPOptInFlag]>;
  73
  74 def ARMcmov          : SDNode<"ARMISD::CMOV", SDT_ARMCMov,
  75                               [SDNPInFlag]>;
  76 def ARMcneg          : SDNode<"ARMISD::CNEG", SDT_ARMCMov,
  77                               [SDNPInFlag]>;
  78
  79 def ARMbrcond        : SDNode<"ARMISD::BRCOND", SDT_ARMBrcond,
  80                               [SDNPHasChain, SDNPInFlag, SDNPOutFlag]>;
  81
  82 def ARMbrjt          : SDNode<"ARMISD::BR_JT", SDT_ARMBrJT,
  83                               [SDNPHasChain]>;
  84 def ARMbr2jt         : SDNode<"ARMISD::BR2_JT", SDT_ARMBr2JT,
  85                               [SDNPHasChain]>;
  86
  87 def ARMcmp           : SDNode<"ARMISD::CMP", SDT_ARMCmp,
  88                               [SDNPOutFlag]>;
  89
  90 def ARMcmpZ          : SDNode<"ARMISD::CMPZ", SDT_ARMCmp,
  91                               [SDNPOutFlag,SDNPCommutative]>;
  92
  93 def ARMpic_add       : SDNode<"ARMISD::PIC_ADD", SDT_ARMPICAdd>;
  94
  95 def ARMsrl_flag      : SDNode<"ARMISD::SRL_FLAG", SDTIntUnaryOp, [SDNPOutFlag]>;
  96 def ARMsra_flag      : SDNode<"ARMISD::SRA_FLAG", SDTIntUnaryOp, [SDNPOutFlag]>;
  97 def ARMrrx           : SDNode<"ARMISD::RRX"     , SDTIntUnaryOp, [SDNPInFlag ]>;
  98
  99 def ARMthread_pointer: SDNode<"ARMISD::THREAD_POINTER", SDT_ARMThreadPointer>;
 100 def ARMeh_sjlj_setjmp: SDNode<"ARMISD::EH_SJLJ_SETJMP", SDT_ARMEH_SJLJ_Setjmp>;
 101
 102 def ARMMemBarrierV7  : SDNode<"ARMISD::MEMBARRIER", SDT_ARMMEMBARRIERV7,
 103                               [SDNPHasChain]>;
 104 def ARMSyncBarrierV7 : SDNode<"ARMISD::SYNCBARRIER", SDT_ARMMEMBARRIERV7,
 105                               [SDNPHasChain]>;
 106 def ARMMemBarrierV6  : SDNode<"ARMISD::MEMBARRIER", SDT_ARMMEMBARRIERV6,
 107                               [SDNPHasChain]>;
 108 def ARMSyncBarrierV6 : SDNode<"ARMISD::SYNCBARRIER", SDT_ARMMEMBARRIERV6,
 109                               [SDNPHasChain]>;
 110
 111 def ARMrbit          : SDNode<"ARMISD::RBIT", SDTIntUnaryOp>;
 112
 113 //===----------------------------------------------------------------------===//
 114 // ARM Instruction Predicate Definitions.
 115 //
 116 def HasV4T    : Predicate<"Subtarget->hasV4TOps()">;
 117 def NoV4T     : Predicate<"!Subtarget->hasV4TOps()">;
 118 def HasV5T    : Predicate<"Subtarget->hasV5TOps()">;
 119 def HasV5TE   : Predicate<"Subtarget->hasV5TEOps()">;
 120 def HasV6     : Predicate<"Subtarget->hasV6Ops()">;
 121 def HasV6T2   : Predicate<"Subtarget->hasV6T2Ops()">;
 122 def NoV6T2    : Predicate<"!Subtarget->hasV6T2Ops()">;
 123 def HasV7     : Predicate<"Subtarget->hasV7Ops()">;
 124 def HasVFP2   : Predicate<"Subtarget->hasVFP2()">;
 125 def HasVFP3   : Predicate<"Subtarget->hasVFP3()">;
 126 def HasNEON   : Predicate<"Subtarget->hasNEON()">;
 127 def UseNEONForFP : Predicate<"Subtarget->useNEONForSinglePrecisionFP()">;
 128 def DontUseNEONForFP : Predicate<"!Subtarget->useNEONForSinglePrecisionFP()">;
 129 def IsThumb   : Predicate<"Subtarget->isThumb()">;
 130 def IsThumb1Only : Predicate<"Subtarget->isThumb1Only()">;
 131 def IsThumb2  : Predicate<"Subtarget->isThumb2()">;
 132 def IsARM     : Predicate<"!Subtarget->isThumb()">;
 133 def IsDarwin    : Predicate<"Subtarget->isTargetDarwin()">;
 134 def IsNotDarwin : Predicate<"!Subtarget->isTargetDarwin()">;
 135
 136 // FIXME: Eventually this will be just "hasV6T2Ops".
 137 def UseMovt   : Predicate<"Subtarget->useMovt()">;
 138 def DontUseMovt : Predicate<"!Subtarget->useMovt()">;
 139
 140 //===----------------------------------------------------------------------===//
 141 // ARM Flag Definitions.
 142
 143 class RegConstraint<string C> {
 144   string Constraints = C;
 145 }
 146
 147 //===----------------------------------------------------------------------===//
 148 //  ARM specific transformation functions and pattern fragments.
 149 //
 150
 151 // so_imm_neg_XFORM - Return a so_imm value packed into the format described for
 152 // so_imm_neg def below.
 153 def so_imm_neg_XFORM : SDNodeXForm<imm, [{
 154   return CurDAG->getTargetConstant(-(int)N->getZExtValue(), MVT::i32);
 155 }]>;
 156
 157 // so_imm_not_XFORM - Return a so_imm value packed into the format described for
 158 // so_imm_not def below.
 159 def so_imm_not_XFORM : SDNodeXForm<imm, [{
 160   return CurDAG->getTargetConstant(~(int)N->getZExtValue(), MVT::i32);
 161 }]>;
 162
 163 // rot_imm predicate - True if the 32-bit immediate is equal to 8, 16, or 24.
 164 def rot_imm : PatLeaf<(i32 imm), [{
 165   int32_t v = (int32_t)N->getZExtValue();
 166   return v == 8 || v == 16 || v == 24;
 167 }]>;
 168
 169 /// imm1_15 predicate - True if the 32-bit immediate is in the range [1,15].
 170 def imm1_15 : PatLeaf<(i32 imm), [{
 171   return (int32_t)N->getZExtValue() >= 1 && (int32_t)N->getZExtValue() < 16;
 172 }]>;
 173
 174 /// imm16_31 predicate - True if the 32-bit immediate is in the range [16,31].
 175 def imm16_31 : PatLeaf<(i32 imm), [{
 176   return (int32_t)N->getZExtValue() >= 16 && (int32_t)N->getZExtValue() < 32;
 177 }]>;
 178
 179 def so_imm_neg :
 180   PatLeaf<(imm), [{
 181     return ARM_AM::getSOImmVal(-(int)N->getZExtValue()) != -1;
 182   }], so_imm_neg_XFORM>;
 183
 184 def so_imm_not :
 185   PatLeaf<(imm), [{
 186     return ARM_AM::getSOImmVal(~(int)N->getZExtValue()) != -1;
 187   }], so_imm_not_XFORM>;
 188
 189 // sext_16_node predicate - True if the SDNode is sign-extended 16 or more bits.
 190 def sext_16_node : PatLeaf<(i32 GPR:$a), [{
 191   return CurDAG->ComputeNumSignBits(SDValue(N,0)) >= 17;
 192 }]>;
 193
 194 /// bf_inv_mask_imm predicate - An AND mask to clear an arbitrary width bitfield
 195 /// e.g., 0xf000ffff
 196 def bf_inv_mask_imm : Operand<i32>,
 197                       PatLeaf<(imm), [{
 198   uint32_t v = (uint32_t)N->getZExtValue();
 199   if (v == 0xffffffff)
 200     return 0;
 201   // there can be 1's on either or both "outsides", all the "inside"
 202   // bits must be 0's
 203   unsigned int lsb = 0, msb = 31;
 204   while (v & (1 << msb)) --msb;
 205   while (v & (1 << lsb)) ++lsb;
 206   for (unsigned int i = lsb; i <= msb; ++i) {
 207     if (v & (1 << i))
 208       return 0;
 209   }
 210   return 1;
 211 }] > {
 212   let PrintMethod = "printBitfieldInvMaskImmOperand";
 213 }
 214
 215 /// Split a 32-bit immediate into two 16 bit parts.
 216 def lo16 : SDNodeXForm<imm, [{
 217   return CurDAG->getTargetConstant((uint32_t)N->getZExtValue() & 0xffff,
 218                                    MVT::i32);
 219 }]>;
 220
 221 def hi16 : SDNodeXForm<imm, [{
 222   return CurDAG->getTargetConstant((uint32_t)N->getZExtValue() >> 16, MVT::i32);
 223 }]>;
 224
 225 def lo16AllZero : PatLeaf<(i32 imm), [{
 226   // Returns true if all low 16-bits are 0.
 227   return (((uint32_t)N->getZExtValue()) & 0xFFFFUL) == 0;
 228 }], hi16>;
 229
 230 /// imm0_65535 predicate - True if the 32-bit immediate is in the range
 231 /// [0.65535].
 232 def imm0_65535 : PatLeaf<(i32 imm), [{
 233   return (uint32_t)N->getZExtValue() < 65536;
 234 }]>;
 235
 236 class BinOpFrag<dag res> : PatFrag<(ops node:$LHS, node:$RHS), res>;
 237 class UnOpFrag <dag res> : PatFrag<(ops node:$Src), res>;
 238
 239 /// adde and sube predicates - True based on whether the carry flag output
 240 /// will be needed or not.
 241 def adde_dead_carry :
 242   PatFrag<(ops node:$LHS, node:$RHS), (adde node:$LHS, node:$RHS),
 243   [{return !N->hasAnyUseOfValue(1);}]>;
 244 def sube_dead_carry :
 245   PatFrag<(ops node:$LHS, node:$RHS), (sube node:$LHS, node:$RHS),
 246   [{return !N->hasAnyUseOfValue(1);}]>;
 247 def adde_live_carry :
 248   PatFrag<(ops node:$LHS, node:$RHS), (adde node:$LHS, node:$RHS),
 249   [{return N->hasAnyUseOfValue(1);}]>;
 250 def sube_live_carry :
 251   PatFrag<(ops node:$LHS, node:$RHS), (sube node:$LHS, node:$RHS),
 252   [{return N->hasAnyUseOfValue(1);}]>;
 253
 254 //===----------------------------------------------------------------------===//
 255 // Operand Definitions.
 256 //
 257
 258 // Branch target.
 259 def brtarget : Operand<OtherVT>;
 260
 261 // A list of registers separated by comma. Used by load/store multiple.
 262 def reglist : Operand<i32> {
 263   let PrintMethod = "printRegisterList";
 264 }
 265
 266 // An operand for the CONSTPOOL_ENTRY pseudo-instruction.
 267 def cpinst_operand : Operand<i32> {
 268   let PrintMethod = "printCPInstOperand";
 269 }
 270
 271 def jtblock_operand : Operand<i32> {
 272   let PrintMethod = "printJTBlockOperand";
 273 }
 274 def jt2block_operand : Operand<i32> {
 275   let PrintMethod = "printJT2BlockOperand";
 276 }
 277
 278 // Local PC labels.
 279 def pclabel : Operand<i32> {
 280   let PrintMethod = "printPCLabel";
 281 }
 282
 283 // shifter_operand operands: so_reg and so_imm.
 284 def so_reg : Operand<i32>,    // reg reg imm
 285             ComplexPattern<i32, 3, "SelectShifterOperandReg",
 286                             [shl,srl,sra,rotr]> {
 287   let PrintMethod = "printSORegOperand";
 288   let MIOperandInfo = (ops GPR, GPR, i32imm);
 289 }
 290
 291 // so_imm - Match a 32-bit shifter_operand immediate operand, which is an
 292 // 8-bit immediate rotated by an arbitrary number of bits.  so_imm values are
 293 // represented in the imm field in the same 12-bit form that they are encoded
 294 // into so_imm instructions: the 8-bit immediate is the least significant bits
 295 // [bits 0-7], the 4-bit shift amount is the next 4 bits [bits 8-11].
 296 def so_imm : Operand<i32>,
 297              PatLeaf<(imm), [{
 298       return ARM_AM::getSOImmVal(N->getZExtValue()) != -1;
 299     }]> {
 300   let PrintMethod = "printSOImmOperand";
 301 }
 302
 303 // Break so_imm's up into two pieces.  This handles immediates with up to 16
 304 // bits set in them.  This uses so_imm2part to match and so_imm2part_[12] to
 305 // get the first/second pieces.
 306 def so_imm2part : Operand<i32>,
 307                   PatLeaf<(imm), [{
 308       return ARM_AM::isSOImmTwoPartVal((unsigned)N->getZExtValue());
 309     }]> {
 310   let PrintMethod = "printSOImm2PartOperand";
 311 }
 312
 313 def so_imm2part_1 : SDNodeXForm<imm, [{
 314   unsigned V = ARM_AM::getSOImmTwoPartFirst((unsigned)N->getZExtValue());
 315   return CurDAG->getTargetConstant(V, MVT::i32);
 316 }]>;
 317
 318 def so_imm2part_2 : SDNodeXForm<imm, [{
 319   unsigned V = ARM_AM::getSOImmTwoPartSecond((unsigned)N->getZExtValue());
 320   return CurDAG->getTargetConstant(V, MVT::i32);
 321 }]>;
 322
 323 def so_neg_imm2part : Operand<i32>, PatLeaf<(imm), [{
 324       return ARM_AM::isSOImmTwoPartVal(-(int)N->getZExtValue());
 325     }]> {
 326   let PrintMethod = "printSOImm2PartOperand";
 327 }
 328
 329 def so_neg_imm2part_1 : SDNodeXForm<imm, [{
 330   unsigned V = ARM_AM::getSOImmTwoPartFirst(-(int)N->getZExtValue());
 331   return CurDAG->getTargetConstant(V, MVT::i32);
 332 }]>;
 333
 334 def so_neg_imm2part_2 : SDNodeXForm<imm, [{
 335   unsigned V = ARM_AM::getSOImmTwoPartSecond(-(int)N->getZExtValue());
 336   return CurDAG->getTargetConstant(V, MVT::i32);
 337 }]>;
 338
 339 /// imm0_31 predicate - True if the 32-bit immediate is in the range [0,31].
 340 def imm0_31 : Operand<i32>, PatLeaf<(imm), [{
 341   return (int32_t)N->getZExtValue() < 32;
 342 }]>;
 343
 344 // Define ARM specific addressing modes.
 345
 346 // addrmode2 := reg +/- reg shop imm
 347 // addrmode2 := reg +/- imm12
 348 //
 349 def addrmode2 : Operand<i32>,
 350                 ComplexPattern<i32, 3, "SelectAddrMode2", []> {
 351   let PrintMethod = "printAddrMode2Operand";
 352   let MIOperandInfo = (ops GPR:$base, GPR:$offsreg, i32imm:$offsimm);
 353 }
 354
 355 def am2offset : Operand<i32>,
 356                 ComplexPattern<i32, 2, "SelectAddrMode2Offset", []> {
 357   let PrintMethod = "printAddrMode2OffsetOperand";
 358   let MIOperandInfo = (ops GPR, i32imm);
 359 }
 360
 361 // addrmode3 := reg +/- reg
 362 // addrmode3 := reg +/- imm8
 363 //
 364 def addrmode3 : Operand<i32>,
 365                 ComplexPattern<i32, 3, "SelectAddrMode3", []> {
 366   let PrintMethod = "printAddrMode3Operand";
 367   let MIOperandInfo = (ops GPR:$base, GPR:$offsreg, i32imm:$offsimm);
 368 }
 369
 370 def am3offset : Operand<i32>,
 371                 ComplexPattern<i32, 2, "SelectAddrMode3Offset", []> {
 372   let PrintMethod = "printAddrMode3OffsetOperand";
 373   let MIOperandInfo = (ops GPR, i32imm);
 374 }
 375
 376 // addrmode4 := reg, <mode|W>
 377 //
 378 def addrmode4 : Operand<i32>,
 379                 ComplexPattern<i32, 2, "SelectAddrMode4", []> {
 380   let PrintMethod = "printAddrMode4Operand";
 381   let MIOperandInfo = (ops GPR, i32imm);
 382 }
 383
 384 // addrmode5 := reg +/- imm8*4
 385 //
 386 def addrmode5 : Operand<i32>,
 387                 ComplexPattern<i32, 2, "SelectAddrMode5", []> {
 388   let PrintMethod = "printAddrMode5Operand";
 389   let MIOperandInfo = (ops GPR, i32imm);
 390 }
 391
 392 // addrmode6 := reg with optional writeback
 393 //
 394 def addrmode6 : Operand<i32>,
 395                 ComplexPattern<i32, 4, "SelectAddrMode6", []> {
 396   let PrintMethod = "printAddrMode6Operand";
 397   let MIOperandInfo = (ops GPR:$addr, GPR:$upd, i32imm, i32imm);
 398 }
 399
 400 // addrmodepc := pc + reg
 401 //
 402 def addrmodepc : Operand<i32>,
 403                  ComplexPattern<i32, 2, "SelectAddrModePC", []> {
 404   let PrintMethod = "printAddrModePCOperand";
 405   let MIOperandInfo = (ops GPR, i32imm);
 406 }
 407
 408 def nohash_imm : Operand<i32> {
 409   let PrintMethod = "printNoHashImmediate";
 410 }
 411
 412 //===----------------------------------------------------------------------===//
 413
 414 include "ARMInstrFormats.td"
 415
 416 //===----------------------------------------------------------------------===//
 417 // Multiclass helpers...
 418 //
 419
 420 /// AsI1_bin_irs - Defines a set of (op r, {so_imm|r|so_reg}) patterns for a
 421 /// binop that produces a value.
 422 multiclass AsI1_bin_irs<bits<4> opcod, string opc, PatFrag opnode,
 423                         bit Commutable = 0> {
 424   def ri : AsI1<opcod, (outs GPR:$dst), (ins GPR:$a, so_imm:$b), DPFrm,
 425                IIC_iALUi, opc, "\t$dst, $a, $b",
 426                [(set GPR:$dst, (opnode GPR:$a, so_imm:$b))]> {
 427     let Inst{25} = 1;
 428   }
 429   def rr : AsI1<opcod, (outs GPR:$dst), (ins GPR:$a, GPR:$b), DPFrm,
 430                IIC_iALUr, opc, "\t$dst, $a, $b",
 431                [(set GPR:$dst, (opnode GPR:$a, GPR:$b))]> {
 432     let Inst{11-4} = 0b00000000;
 433     let Inst{25} = 0;
 434     let isCommutable = Commutable;
 435   }
 436   def rs : AsI1<opcod, (outs GPR:$dst), (ins GPR:$a, so_reg:$b), DPSoRegFrm,
 437                IIC_iALUsr, opc, "\t$dst, $a, $b",
 438                [(set GPR:$dst, (opnode GPR:$a, so_reg:$b))]> {
 439     let Inst{25} = 0;
 440   }
 441 }
 442
 443 /// AI1_bin_s_irs - Similar to AsI1_bin_irs except it sets the 's' bit so the
 444 /// instruction modifies the CPSR register.
 445 let Defs = [CPSR] in {
 446 multiclass AI1_bin_s_irs<bits<4> opcod, string opc, PatFrag opnode,
 447                          bit Commutable = 0> {
 448   def ri : AI1<opcod, (outs GPR:$dst), (ins GPR:$a, so_imm:$b), DPFrm,
 449                IIC_iALUi, opc, "\t$dst, $a, $b",
 450                [(set GPR:$dst, (opnode GPR:$a, so_imm:$b))]> {
 451     let Inst{20} = 1;
 452     let Inst{25} = 1;
 453   }
 454   def rr : AI1<opcod, (outs GPR:$dst), (ins GPR:$a, GPR:$b), DPFrm,
 455                IIC_iALUr, opc, "\t$dst, $a, $b",
 456                [(set GPR:$dst, (opnode GPR:$a, GPR:$b))]> {
 457     let isCommutable = Commutable;
 458     let Inst{11-4} = 0b00000000;
 459     let Inst{20} = 1;
 460     let Inst{25} = 0;
 461   }
 462   def rs : AI1<opcod, (outs GPR:$dst), (ins GPR:$a, so_reg:$b), DPSoRegFrm,
 463                IIC_iALUsr, opc, "\t$dst, $a, $b",
 464                [(set GPR:$dst, (opnode GPR:$a, so_reg:$b))]> {
 465     let Inst{20} = 1;
 466     let Inst{25} = 0;
 467   }
 468 }
 469 }
 470
 471 /// AI1_cmp_irs - Defines a set of (op r, {so_imm|r|so_reg}) cmp / test
 472 /// patterns. Similar to AsI1_bin_irs except the instruction does not produce
 473 /// a explicit result, only implicitly set CPSR.
 474 let Defs = [CPSR] in {
 475 multiclass AI1_cmp_irs<bits<4> opcod, string opc, PatFrag opnode,
 476                        bit Commutable = 0> {
 477   def ri : AI1<opcod, (outs), (ins GPR:$a, so_imm:$b), DPFrm, IIC_iCMPi,
 478                opc, "\t$a, $b",
 479                [(opnode GPR:$a, so_imm:$b)]> {
 480     let Inst{20} = 1;
 481     let Inst{25} = 1;
 482   }
 483   def rr : AI1<opcod, (outs), (ins GPR:$a, GPR:$b), DPFrm, IIC_iCMPr,
 484                opc, "\t$a, $b",
 485                [(opnode GPR:$a, GPR:$b)]> {
 486     let Inst{11-4} = 0b00000000;
 487     let Inst{20} = 1;
 488     let Inst{25} = 0;
 489     let isCommutable = Commutable;
 490   }
 491   def rs : AI1<opcod, (outs), (ins GPR:$a, so_reg:$b), DPSoRegFrm, IIC_iCMPsr,
 492                opc, "\t$a, $b",
 493                [(opnode GPR:$a, so_reg:$b)]> {
 494     let Inst{20} = 1;
 495     let Inst{25} = 0;
 496   }
 497 }
 498 }
 499
 500 /// AI_unary_rrot - A unary operation with two forms: one whose operand is a
 501 /// register and one whose operand is a register rotated by 8/16/24.
 502 /// FIXME: Remove the 'r' variant. Its rot_imm is zero.
 503 multiclass AI_unary_rrot<bits<8> opcod, string opc, PatFrag opnode> {
 504   def r     : AExtI<opcod, (outs GPR:$dst), (ins GPR:$src),
 505                  IIC_iUNAr, opc, "\t$dst, $src",
 506                  [(set GPR:$dst, (opnode GPR:$src))]>,
 507               Requires<[IsARM, HasV6]> {
 508     let Inst{11-10} = 0b00;
 509     let Inst{19-16} = 0b1111;
 510   }
 511   def r_rot : AExtI<opcod, (outs GPR:$dst), (ins GPR:$src, i32imm:$rot),
 512                  IIC_iUNAsi, opc, "\t$dst, $src, ror $rot",
 513                  [(set GPR:$dst, (opnode (rotr GPR:$src, rot_imm:$rot)))]>,
 514               Requires<[IsARM, HasV6]> {
 515     let Inst{19-16} = 0b1111;
 516   }
 517 }
 518
 519 multiclass AI_unary_rrot_np<bits<8> opcod, string opc> {
 520   def r     : AExtI<opcod, (outs GPR:$dst), (ins GPR:$src),
 521                  IIC_iUNAr, opc, "\t$dst, $src",
 522                  [/* For disassembly only; pattern left blank */]>,
 523               Requires<[IsARM, HasV6]> {
 524     let Inst{11-10} = 0b00;
 525     let Inst{19-16} = 0b1111;
 526   }
 527   def r_rot : AExtI<opcod, (outs GPR:$dst), (ins GPR:$src, i32imm:$rot),
 528                  IIC_iUNAsi, opc, "\t$dst, $src, ror $rot",
 529                  [/* For disassembly only; pattern left blank */]>,
 530               Requires<[IsARM, HasV6]> {
 531     let Inst{19-16} = 0b1111;
 532   }
 533 }
 534
 535 /// AI_bin_rrot - A binary operation with two forms: one whose operand is a
 536 /// register and one whose operand is a register rotated by 8/16/24.
 537 multiclass AI_bin_rrot<bits<8> opcod, string opc, PatFrag opnode> {
 538   def rr     : AExtI<opcod, (outs GPR:$dst), (ins GPR:$LHS, GPR:$RHS),
 539                   IIC_iALUr, opc, "\t$dst, $LHS, $RHS",
 540                   [(set GPR:$dst, (opnode GPR:$LHS, GPR:$RHS))]>,
 541                Requires<[IsARM, HasV6]> {
 542     let Inst{11-10} = 0b00;
 543   }
 544   def rr_rot : AExtI<opcod, (outs GPR:$dst), (ins GPR:$LHS, GPR:$RHS,
 545                                               i32imm:$rot),
 546                   IIC_iALUsi, opc, "\t$dst, $LHS, $RHS, ror $rot",
 547                   [(set GPR:$dst, (opnode GPR:$LHS,
 548                                           (rotr GPR:$RHS, rot_imm:$rot)))]>,
 549                   Requires<[IsARM, HasV6]>;
 550 }
 551
 552 // For disassembly only.
 553 multiclass AI_bin_rrot_np<bits<8> opcod, string opc> {
 554   def rr     : AExtI<opcod, (outs GPR:$dst), (ins GPR:$LHS, GPR:$RHS),
 555                   IIC_iALUr, opc, "\t$dst, $LHS, $RHS",
 556                   [/* For disassembly only; pattern left blank */]>,
 557                Requires<[IsARM, HasV6]> {
 558     let Inst{11-10} = 0b00;
 559   }
 560   def rr_rot : AExtI<opcod, (outs GPR:$dst), (ins GPR:$LHS, GPR:$RHS,
 561                                               i32imm:$rot),
 562                   IIC_iALUsi, opc, "\t$dst, $LHS, $RHS, ror $rot",
 563                   [/* For disassembly only; pattern left blank */]>,
 564                   Requires<[IsARM, HasV6]>;
 565 }
 566
 567 /// AI1_adde_sube_irs - Define instructions and patterns for adde and sube.
 568 let Uses = [CPSR] in {
 569 multiclass AI1_adde_sube_irs<bits<4> opcod, string opc, PatFrag opnode,
 570                              bit Commutable = 0> {
 571   def ri : AsI1<opcod, (outs GPR:$dst), (ins GPR:$a, so_imm:$b),
 572                 DPFrm, IIC_iALUi, opc, "\t$dst, $a, $b",
 573                [(set GPR:$dst, (opnode GPR:$a, so_imm:$b))]>,
 574                Requires<[IsARM]> {
 575     let Inst{25} = 1;
 576   }
 577   def rr : AsI1<opcod, (outs GPR:$dst), (ins GPR:$a, GPR:$b),
 578                 DPFrm, IIC_iALUr, opc, "\t$dst, $a, $b",
 579                [(set GPR:$dst, (opnode GPR:$a, GPR:$b))]>,
 580                Requires<[IsARM]> {
 581     let isCommutable = Commutable;
 582     let Inst{11-4} = 0b00000000;
 583     let Inst{25} = 0;
 584   }
 585   def rs : AsI1<opcod, (outs GPR:$dst), (ins GPR:$a, so_reg:$b),
 586                 DPSoRegFrm, IIC_iALUsr, opc, "\t$dst, $a, $b",
 587                [(set GPR:$dst, (opnode GPR:$a, so_reg:$b))]>,
 588                Requires<[IsARM]> {
 589     let Inst{25} = 0;
 590   }
 591 }
 592 // Carry setting variants
 593 let Defs = [CPSR] in {
 594 multiclass AI1_adde_sube_s_irs<bits<4> opcod, string opc, PatFrag opnode,
 595                              bit Commutable = 0> {
 596   def Sri : AXI1<opcod, (outs GPR:$dst), (ins GPR:$a, so_imm:$b),
 597                 DPFrm, IIC_iALUi, !strconcat(opc, "\t$dst, $a, $b"),
 598                [(set GPR:$dst, (opnode GPR:$a, so_imm:$b))]>,
 599                Requires<[IsARM]> {
 600     let Inst{20} = 1;
 601     let Inst{25} = 1;
 602   }
 603   def Srr : AXI1<opcod, (outs GPR:$dst), (ins GPR:$a, GPR:$b),
 604                 DPFrm, IIC_iALUr, !strconcat(opc, "\t$dst, $a, $b"),
 605                [(set GPR:$dst, (opnode GPR:$a, GPR:$b))]>,
 606                Requires<[IsARM]> {
 607     let Inst{11-4} = 0b00000000;
 608     let Inst{20} = 1;
 609     let Inst{25} = 0;
 610   }
 611   def Srs : AXI1<opcod, (outs GPR:$dst), (ins GPR:$a, so_reg:$b),
 612                 DPSoRegFrm, IIC_iALUsr, !strconcat(opc, "\t$dst, $a, $b"),
 613                [(set GPR:$dst, (opnode GPR:$a, so_reg:$b))]>,
 614                Requires<[IsARM]> {
 615     let Inst{20} = 1;
 616     let Inst{25} = 0;
 617   }
 618 }
 619 }
 620 }
 621
 622 //===----------------------------------------------------------------------===//
 623 // Instructions
 624 //===----------------------------------------------------------------------===//
 625
 626 //===----------------------------------------------------------------------===//
 627 //  Miscellaneous Instructions.
 628 //
 629
 630 /// CONSTPOOL_ENTRY - This instruction represents a floating constant pool in
 631 /// the function.  The first operand is the ID# for this instruction, the second
 632 /// is the index into the MachineConstantPool that this is, the third is the
 633 /// size in bytes of this constant pool entry.
 634 let neverHasSideEffects = 1, isNotDuplicable = 1 in
 635 def CONSTPOOL_ENTRY :
 636 PseudoInst<(outs), (ins cpinst_operand:$instid, cpinst_operand:$cpidx,
 637                     i32imm:$size), NoItinerary,
 638            "${instid:label} ${cpidx:cpentry}", []>;
 639
 640 // FIXME: Marking these as hasSideEffects is necessary to prevent machine DCE
 641 // from removing one half of the matched pairs. That breaks PEI, which assumes
 642 // these will always be in pairs, and asserts if it finds otherwise. Better way?
 643 let Defs = [SP], Uses = [SP], hasSideEffects = 1 in {
 644 def ADJCALLSTACKUP :
 645 PseudoInst<(outs), (ins i32imm:$amt1, i32imm:$amt2, pred:$p), NoItinerary,
 646            "@ ADJCALLSTACKUP $amt1",
 647            [(ARMcallseq_end timm:$amt1, timm:$amt2)]>;
 648
 649 def ADJCALLSTACKDOWN :
 650 PseudoInst<(outs), (ins i32imm:$amt, pred:$p), NoItinerary,
 651            "@ ADJCALLSTACKDOWN $amt",
 652            [(ARMcallseq_start timm:$amt)]>;
 653 }
 654
 655 def NOP : AI<(outs), (ins), MiscFrm, NoItinerary, "nop", "",
 656              [/* For disassembly only; pattern left blank */]>,
 657           Requires<[IsARM, HasV6T2]> {
 658   let Inst{27-16} = 0b001100100000;
 659   let Inst{7-0} = 0b00000000;
 660 }
 661
 662 def YIELD : AI<(outs), (ins), MiscFrm, NoItinerary, "yield", "",
 663              [/* For disassembly only; pattern left blank */]>,
 664           Requires<[IsARM, HasV6T2]> {
 665   let Inst{27-16} = 0b001100100000;
 666   let Inst{7-0} = 0b00000001;
 667 }
 668
 669 def WFE : AI<(outs), (ins), MiscFrm, NoItinerary, "wfe", "",
 670              [/* For disassembly only; pattern left blank */]>,
 671           Requires<[IsARM, HasV6T2]> {
 672   let Inst{27-16} = 0b001100100000;
 673   let Inst{7-0} = 0b00000010;
 674 }
 675
 676 def WFI : AI<(outs), (ins), MiscFrm, NoItinerary, "wfi", "",
 677              [/* For disassembly only; pattern left blank */]>,
 678           Requires<[IsARM, HasV6T2]> {
 679   let Inst{27-16} = 0b001100100000;
 680   let Inst{7-0} = 0b00000011;
 681 }
 682
 683 def SEL : AI<(outs GPR:$dst), (ins GPR:$a, GPR:$b), DPFrm, NoItinerary, "sel",
 684              "\t$dst, $a, $b",
 685              [/* For disassembly only; pattern left blank */]>,
 686           Requires<[IsARM, HasV6]> {
 687   let Inst{27-20} = 0b01101000;
 688   let Inst{7-4} = 0b1011;
 689 }
 690
 691 def SEV : AI<(outs), (ins), MiscFrm, NoItinerary, "sev", "",
 692              [/* For disassembly only; pattern left blank */]>,
 693           Requires<[IsARM, HasV6T2]> {
 694   let Inst{27-16} = 0b001100100000;
 695   let Inst{7-0} = 0b00000100;
 696 }
 697
 698 // The i32imm operand $val can be used by a debugger to store more information
 699 // about the breakpoint.
 700 def BKPT : AI<(outs), (ins i32imm:$val), MiscFrm, NoItinerary, "bkpt", "\t$val",
 701               [/* For disassembly only; pattern left blank */]>,
 702            Requires<[IsARM]> {
 703   let Inst{27-20} = 0b00010010;
 704   let Inst{7-4} = 0b0111;
 705 }
 706
 707 // Change Processor State is a system instruction -- for disassembly only.
 708 // The singleton $opt operand contains the following information:
 709 // opt{4-0} = mode from Inst{4-0}
 710 // opt{5} = changemode from Inst{17}
 711 // opt{8-6} = AIF from Inst{8-6}
 712 // opt{10-9} = imod from Inst{19-18} with 0b10 as enable and 0b11 as disable
 713 def CPS : AXI<(outs), (ins cps_opt:$opt), MiscFrm, NoItinerary, "cps$opt",
 714               [/* For disassembly only; pattern left blank */]>,
 715           Requires<[IsARM]> {
 716   let Inst{31-28} = 0b1111;
 717   let Inst{27-20} = 0b00010000;
 718   let Inst{16} = 0;
 719   let Inst{5} = 0;
 720 }
 721
 722 // Preload signals the memory system of possible future data/instruction access.
 723 // These are for disassembly only.
 724 //
 725 // A8.6.117, A8.6.118.  Different instructions are generated for #0 and #-0.
 726 // The neg_zero operand translates -0 to -1, -1 to -2, ..., etc.
 727 multiclass APreLoad<bit data, bit read, string opc> {
 728
 729   def i : AXI<(outs), (ins GPR:$base, neg_zero:$imm), MiscFrm, NoItinerary,
 730                !strconcat(opc, "\t[$base, $imm]"), []> {
 731     let Inst{31-26} = 0b111101;
 732     let Inst{25} = 0; // 0 for immediate form
 733     let Inst{24} = data;
 734     let Inst{22} = read;
 735     let Inst{21-20} = 0b01;
 736   }
 737
 738   def r : AXI<(outs), (ins addrmode2:$addr), MiscFrm, NoItinerary,
 739                !strconcat(opc, "\t$addr"), []> {
 740     let Inst{31-26} = 0b111101;
 741     let Inst{25} = 1; // 1 for register form
 742     let Inst{24} = data;
 743     let Inst{22} = read;
 744     let Inst{21-20} = 0b01;
 745     let Inst{4} = 0;
 746   }
 747 }
 748
 749 defm PLD  : APreLoad<1, 1, "pld">;
 750 defm PLDW : APreLoad<1, 0, "pldw">;
 751 defm PLI  : APreLoad<0, 1, "pli">;
 752
 753 def SETENDBE : AXI<(outs),(ins), MiscFrm, NoItinerary, "setend\tbe",
 754                    [/* For disassembly only; pattern left blank */]>,
 755                Requires<[IsARM]> {
 756   let Inst{31-28} = 0b1111;
 757   let Inst{27-20} = 0b00010000;
 758   let Inst{16} = 1;
 759   let Inst{9} = 1;
 760   let Inst{7-4} = 0b0000;
 761 }
 762
 763 def SETENDLE : AXI<(outs),(ins), MiscFrm, NoItinerary, "setend\tle",
 764                    [/* For disassembly only; pattern left blank */]>,
 765                Requires<[IsARM]> {
 766   let Inst{31-28} = 0b1111;
 767   let Inst{27-20} = 0b00010000;
 768   let Inst{16} = 1;
 769   let Inst{9} = 0;
 770   let Inst{7-4} = 0b0000;
 771 }
 772
 773 def DBG : AI<(outs), (ins i32imm:$opt), MiscFrm, NoItinerary, "dbg", "\t$opt",
 774              [/* For disassembly only; pattern left blank */]>,
 775           Requires<[IsARM, HasV7]> {
 776   let Inst{27-16} = 0b001100100000;
 777   let Inst{7-4} = 0b1111;
 778 }
 779
 780 // A5.4 Permanently UNDEFINED instructions.
 781 def TRAP : AI<(outs), (ins), MiscFrm, NoItinerary, "trap", "",
 782               [/* For disassembly only; pattern left blank */]>,
 783            Requires<[IsARM]> {
 784   let Inst{27-25} = 0b011;
 785   let Inst{24-20} = 0b11111;
 786   let Inst{7-5} = 0b111;
 787   let Inst{4} = 0b1;
 788 }
 789
 790 // Address computation and loads and stores in PIC mode.
 791 let isNotDuplicable = 1 in {
 792 def PICADD : AXI1<0b0100, (outs GPR:$dst), (ins GPR:$a, pclabel:$cp, pred:$p),
 793                   Pseudo, IIC_iALUr, "\n$cp:\n\tadd$p\t$dst, pc, $a",
 794                    [(set GPR:$dst, (ARMpic_add GPR:$a, imm:$cp))]>;
 795
 796 let AddedComplexity = 10 in {
 797 def PICLDR  : AXI2ldw<(outs GPR:$dst), (ins addrmodepc:$addr, pred:$p),
 798                   Pseudo, IIC_iLoadr, "\n${addr:label}:\n\tldr$p\t$dst, $addr",
 799                   [(set GPR:$dst, (load addrmodepc:$addr))]>;
 800
 801 def PICLDRH : AXI3ldh<(outs GPR:$dst), (ins addrmodepc:$addr, pred:$p),
 802                 Pseudo, IIC_iLoadr, "\n${addr:label}:\n\tldrh${p}\t$dst, $addr",
 803                   [(set GPR:$dst, (zextloadi16 addrmodepc:$addr))]>;
 804
 805 def PICLDRB : AXI2ldb<(outs GPR:$dst), (ins addrmodepc:$addr, pred:$p),
 806                 Pseudo, IIC_iLoadr, "\n${addr:label}:\n\tldrb${p}\t$dst, $addr",
 807                   [(set GPR:$dst, (zextloadi8 addrmodepc:$addr))]>;
 808
 809 def PICLDRSH : AXI3ldsh<(outs GPR:$dst), (ins addrmodepc:$addr, pred:$p),
 810                Pseudo, IIC_iLoadr, "\n${addr:label}:\n\tldrsh${p}\t$dst, $addr",
 811                   [(set GPR:$dst, (sextloadi16 addrmodepc:$addr))]>;
 812
 813 def PICLDRSB : AXI3ldsb<(outs GPR:$dst), (ins addrmodepc:$addr, pred:$p),
 814                Pseudo, IIC_iLoadr, "\n${addr:label}:\n\tldrsb${p}\t$dst, $addr",
 815                   [(set GPR:$dst, (sextloadi8 addrmodepc:$addr))]>;
 816 }
 817 let AddedComplexity = 10 in {
 818 def PICSTR  : AXI2stw<(outs), (ins GPR:$src, addrmodepc:$addr, pred:$p),
 819                Pseudo, IIC_iStorer, "\n${addr:label}:\n\tstr$p\t$src, $addr",
 820                [(store GPR:$src, addrmodepc:$addr)]>;
 821
 822 def PICSTRH : AXI3sth<(outs), (ins GPR:$src, addrmodepc:$addr, pred:$p),
 823                Pseudo, IIC_iStorer, "\n${addr:label}:\n\tstrh${p}\t$src, $addr",
 824                [(truncstorei16 GPR:$src, addrmodepc:$addr)]>;
 825
 826 def PICSTRB : AXI2stb<(outs), (ins GPR:$src, addrmodepc:$addr, pred:$p),
 827                Pseudo, IIC_iStorer, "\n${addr:label}:\n\tstrb${p}\t$src, $addr",
 828                [(truncstorei8 GPR:$src, addrmodepc:$addr)]>;
 829 }
 830 } // isNotDuplicable = 1
 831
 832
 833 // LEApcrel - Load a pc-relative address into a register without offending the
 834 // assembler.
 835 def LEApcrel : AXI1<0x0, (outs GPR:$dst), (ins i32imm:$label, pred:$p),
 836                     Pseudo, IIC_iALUi,
 837            !strconcat(!strconcat(".set ${:private}PCRELV${:uid}, ($label-(",
 838                                  "${:private}PCRELL${:uid}+8))\n"),
 839                       !strconcat("${:private}PCRELL${:uid}:\n\t",
 840                                  "add$p\t$dst, pc, #${:private}PCRELV${:uid}")),
 841                    []>;
 842
 843 def LEApcrelJT : AXI1<0x0, (outs GPR:$dst),
 844                            (ins i32imm:$label, nohash_imm:$id, pred:$p),
 845           Pseudo, IIC_iALUi,
 846    !strconcat(!strconcat(".set ${:private}PCRELV${:uid}, "
 847                          "(${label}_${id}-(",
 848                                   "${:private}PCRELL${:uid}+8))\n"),
 849                        !strconcat("${:private}PCRELL${:uid}:\n\t",
 850                                  "add$p\t$dst, pc, #${:private}PCRELV${:uid}")),
 851                    []> {
 852     let Inst{25} = 1;
 853 }
 854
 855 //===----------------------------------------------------------------------===//
 856 //  Control Flow Instructions.
 857 //
 858
 859 let isReturn = 1, isTerminator = 1, isBarrier = 1 in {
 860   // ARMV4T and above
 861   def BX_RET : AI<(outs), (ins), BrMiscFrm, IIC_Br,
 862                   "bx", "\tlr", [(ARMretflag)]>,
 863                Requires<[IsARM, HasV4T]> {
 864     let Inst{3-0}   = 0b1110;
 865     let Inst{7-4}   = 0b0001;
 866     let Inst{19-8}  = 0b111111111111;
 867     let Inst{27-20} = 0b00010010;
 868   }
 869
 870   // ARMV4 only
 871   def MOVPCLR : AI<(outs), (ins), BrMiscFrm, IIC_Br,
 872                   "mov", "\tpc, lr", [(ARMretflag)]>,
 873                Requires<[IsARM, NoV4T]> {
 874     let Inst{11-0}  = 0b000000001110;
 875     let Inst{15-12} = 0b1111;
 876     let Inst{19-16} = 0b0000;
 877     let Inst{27-20} = 0b00011010;
 878   }
 879 }
 880
 881 // Indirect branches
 882 let isBranch = 1, isTerminator = 1, isBarrier = 1, isIndirectBranch = 1 in {
 883   // ARMV4T and above
 884   def BRIND : AXI<(outs), (ins GPR:$dst), BrMiscFrm, IIC_Br, "bx\t$dst",
 885                   [(brind GPR:$dst)]>,
 886               Requires<[IsARM, HasV4T]> {
 887     let Inst{7-4}   = 0b0001;
 888     let Inst{19-8}  = 0b111111111111;
 889     let Inst{27-20} = 0b00010010;
 890     let Inst{31-28} = 0b1110;
 891   }
 892
 893   // ARMV4 only
 894   def MOVPCRX : AXI<(outs), (ins GPR:$dst), BrMiscFrm, IIC_Br, "mov\tpc, $dst",
 895                   [(brind GPR:$dst)]>,
 896               Requires<[IsARM, NoV4T]> {
 897     let Inst{11-4}  = 0b00000000;
 898     let Inst{15-12} = 0b1111;
 899     let Inst{19-16} = 0b0000;
 900     let Inst{27-20} = 0b00011010;
 901     let Inst{31-28} = 0b1110;
 902   }
 903 }
 904
 905 // FIXME: remove when we have a way to marking a MI with these properties.
 906 // FIXME: Should pc be an implicit operand like PICADD, etc?
 907 let isReturn = 1, isTerminator = 1, isBarrier = 1, mayLoad = 1,
 908     hasExtraDefRegAllocReq = 1 in
 909   def LDM_RET : AXI4ld<(outs),
 910                     (ins addrmode4:$addr, pred:$p, reglist:$wb, variable_ops),
 911                     LdStMulFrm, IIC_Br, "ldm${addr:submode}${p}\t$addr, $wb",
 912                     []>;
 913
 914 // On non-Darwin platforms R9 is callee-saved.
 915 let isCall = 1,
 916   Defs = [R0,  R1,  R2,  R3,  R12, LR,
 917           D0,  D1,  D2,  D3,  D4,  D5,  D6,  D7,
 918           D16, D17, D18, D19, D20, D21, D22, D23,
 919           D24, D25, D26, D27, D28, D29, D30, D31, CPSR, FPSCR] in {
 920   def BL  : ABXI<0b1011, (outs), (ins i32imm:$func, variable_ops),
 921                 IIC_Br, "bl\t${func:call}",
 922                 [(ARMcall tglobaladdr:$func)]>,
 923             Requires<[IsARM, IsNotDarwin]> {
 924     let Inst{31-28} = 0b1110;
 925   }
 926
 927   def BL_pred : ABI<0b1011, (outs), (ins i32imm:$func, variable_ops),
 928                    IIC_Br, "bl", "\t${func:call}",
 929                    [(ARMcall_pred tglobaladdr:$func)]>,
 930                 Requires<[IsARM, IsNotDarwin]>;
 931
 932   // ARMv5T and above
 933   def BLX : AXI<(outs), (ins GPR:$func, variable_ops), BrMiscFrm,
 934                 IIC_Br, "blx\t$func",
 935                 [(ARMcall GPR:$func)]>,
 936             Requires<[IsARM, HasV5T, IsNotDarwin]> {
 937     let Inst{7-4}   = 0b0011;
 938     let Inst{19-8}  = 0b111111111111;
 939     let Inst{27-20} = 0b00010010;
 940   }
 941
 942   // ARMv4T
 943   // Note: Restrict $func to the tGPR regclass to prevent it being in LR.
 944   def BX : ABXIx2<(outs), (ins tGPR:$func, variable_ops),
 945                   IIC_Br, "mov\tlr, pc\n\tbx\t$func",
 946                   [(ARMcall_nolink tGPR:$func)]>,
 947            Requires<[IsARM, HasV4T, IsNotDarwin]> {
 948     let Inst{7-4}   = 0b0001;
 949     let Inst{19-8}  = 0b111111111111;
 950     let Inst{27-20} = 0b00010010;
 951   }
 952
 953   // ARMv4
 954   def BMOVPCRX : ABXIx2<(outs), (ins tGPR:$func, variable_ops),
 955                  IIC_Br, "mov\tlr, pc\n\tmov\tpc, $func",
 956                  [(ARMcall_nolink tGPR:$func)]>,
 957            Requires<[IsARM, NoV4T, IsNotDarwin]> {
 958     let Inst{11-4}  = 0b00000000;
 959     let Inst{15-12} = 0b1111;
 960     let Inst{19-16} = 0b0000;
 961     let Inst{27-20} = 0b00011010;
 962   }
 963 }
 964
 965 // On Darwin R9 is call-clobbered.
 966 let isCall = 1,
 967   Defs = [R0,  R1,  R2,  R3,  R9,  R12, LR,
 968           D0,  D1,  D2,  D3,  D4,  D5,  D6,  D7,
 969           D16, D17, D18, D19, D20, D21, D22, D23,
 970           D24, D25, D26, D27, D28, D29, D30, D31, CPSR, FPSCR] in {
 971   def BLr9  : ABXI<0b1011, (outs), (ins i32imm:$func, variable_ops),
 972                 IIC_Br, "bl\t${func:call}",
 973                 [(ARMcall tglobaladdr:$func)]>, Requires<[IsARM, IsDarwin]> {
 974     let Inst{31-28} = 0b1110;
 975   }
 976
 977   def BLr9_pred : ABI<0b1011, (outs), (ins i32imm:$func, variable_ops),
 978                    IIC_Br, "bl", "\t${func:call}",
 979                    [(ARMcall_pred tglobaladdr:$func)]>,
 980                   Requires<[IsARM, IsDarwin]>;
 981
 982   // ARMv5T and above
 983   def BLXr9 : AXI<(outs), (ins GPR:$func, variable_ops), BrMiscFrm,
 984                 IIC_Br, "blx\t$func",
 985                 [(ARMcall GPR:$func)]>, Requires<[IsARM, HasV5T, IsDarwin]> {
 986     let Inst{7-4}   = 0b0011;
 987     let Inst{19-8}  = 0b111111111111;
 988     let Inst{27-20} = 0b00010010;
 989   }
 990
 991   // ARMv4T
 992   // Note: Restrict $func to the tGPR regclass to prevent it being in LR.
 993   def BXr9 : ABXIx2<(outs), (ins tGPR:$func, variable_ops),
 994                   IIC_Br, "mov\tlr, pc\n\tbx\t$func",
 995                   [(ARMcall_nolink tGPR:$func)]>,
 996              Requires<[IsARM, HasV4T, IsDarwin]> {
 997     let Inst{7-4}   = 0b0001;
 998     let Inst{19-8}  = 0b111111111111;
 999     let Inst{27-20} = 0b00010010;
1000   }
1001
1002   // ARMv4
1003   def BMOVPCRXr9 : ABXIx2<(outs), (ins tGPR:$func, variable_ops),
1004                  IIC_Br, "mov\tlr, pc\n\tmov\tpc, $func",
1005                  [(ARMcall_nolink tGPR:$func)]>,
1006            Requires<[IsARM, NoV4T, IsDarwin]> {
1007     let Inst{11-4}  = 0b00000000;
1008     let Inst{15-12} = 0b1111;
1009     let Inst{19-16} = 0b0000;
1010     let Inst{27-20} = 0b00011010;
1011   }
1012 }
1013
1014 let isBranch = 1, isTerminator = 1 in {
1015   // B is "predicable" since it can be xformed into a Bcc.
1016   let isBarrier = 1 in {
1017     let isPredicable = 1 in
1018     def B : ABXI<0b1010, (outs), (ins brtarget:$target), IIC_Br,
1019                 "b\t$target", [(br bb:$target)]>;
1020
1021   let isNotDuplicable = 1, isIndirectBranch = 1 in {
1022   def BR_JTr : JTI<(outs), (ins GPR:$target, jtblock_operand:$jt, i32imm:$id),
1023                     IIC_Br, "mov\tpc, $target \n$jt",
1024                     [(ARMbrjt GPR:$target, tjumptable:$jt, imm:$id)]> {
1025     let Inst{11-4}  = 0b00000000;
1026     let Inst{15-12} = 0b1111;
1027     let Inst{20}    = 0; // S Bit
1028     let Inst{24-21} = 0b1101;
1029     let Inst{27-25} = 0b000;
1030   }
1031   def BR_JTm : JTI<(outs),
1032                    (ins addrmode2:$target, jtblock_operand:$jt, i32imm:$id),
1033                    IIC_Br, "ldr\tpc, $target \n$jt",
1034                    [(ARMbrjt (i32 (load addrmode2:$target)), tjumptable:$jt,
1035                      imm:$id)]> {
1036     let Inst{15-12} = 0b1111;
1037     let Inst{20}    = 1; // L bit
1038     let Inst{21}    = 0; // W bit
1039     let Inst{22}    = 0; // B bit
1040     let Inst{24}    = 1; // P bit
1041     let Inst{27-25} = 0b011;
1042   }
1043   def BR_JTadd : JTI<(outs),
1044                    (ins GPR:$target, GPR:$idx, jtblock_operand:$jt, i32imm:$id),
1045                     IIC_Br, "add\tpc, $target, $idx \n$jt",
1046                     [(ARMbrjt (add GPR:$target, GPR:$idx), tjumptable:$jt,
1047                       imm:$id)]> {
1048     let Inst{15-12} = 0b1111;
1049     let Inst{20}    = 0; // S bit
1050     let Inst{24-21} = 0b0100;
1051     let Inst{27-25} = 0b000;
1052   }
1053   } // isNotDuplicable = 1, isIndirectBranch = 1
1054   } // isBarrier = 1
1055
1056   // FIXME: should be able to write a pattern for ARMBrcond, but can't use
1057   // a two-value operand where a dag node expects two operands. :(
1058   def Bcc : ABI<0b1010, (outs), (ins brtarget:$target),
1059                IIC_Br, "b", "\t$target",
1060                [/*(ARMbrcond bb:$target, imm:$cc, CCR:$ccr)*/]>;
1061 }
1062
1063 // Branch and Exchange Jazelle -- for disassembly only
1064 def BXJ : ABI<0b0001, (outs), (ins GPR:$func), NoItinerary, "bxj", "\t$func",
1065               [/* For disassembly only; pattern left blank */]> {
1066   let Inst{23-20} = 0b0010;
1067   //let Inst{19-8} = 0xfff;
1068   let Inst{7-4} = 0b0010;
1069 }
1070
1071 // Secure Monitor Call is a system instruction -- for disassembly only
1072 def SMC : ABI<0b0001, (outs), (ins i32imm:$opt), NoItinerary, "smc", "\t$opt",
1073               [/* For disassembly only; pattern left blank */]> {
1074   let Inst{23-20} = 0b0110;
1075   let Inst{7-4} = 0b0111;
1076 }
1077
1078 // Supervisor Call (Software Interrupt) -- for disassembly only
1079 let isCall = 1 in {
1080 def SVC : ABI<0b1111, (outs), (ins i32imm:$svc), IIC_Br, "svc", "\t$svc",
1081               [/* For disassembly only; pattern left blank */]>;
1082 }
1083
1084 // Store Return State is a system instruction -- for disassembly only
1085 def SRSW : ABXI<{1,0,0,?}, (outs), (ins addrmode4:$addr, i32imm:$mode),
1086                 NoItinerary, "srs${addr:submode}\tsp!, $mode",
1087                 [/* For disassembly only; pattern left blank */]> {
1088   let Inst{31-28} = 0b1111;
1089   let Inst{22-20} = 0b110; // W = 1
1090 }
1091
1092 def SRS  : ABXI<{1,0,0,?}, (outs), (ins addrmode4:$addr, i32imm:$mode),
1093                 NoItinerary, "srs${addr:submode}\tsp, $mode",
1094                 [/* For disassembly only; pattern left blank */]> {
1095   let Inst{31-28} = 0b1111;
1096   let Inst{22-20} = 0b100; // W = 0
1097 }
1098
1099 // Return From Exception is a system instruction -- for disassembly only
1100 def RFEW : ABXI<{1,0,0,?}, (outs), (ins addrmode4:$addr, GPR:$base),
1101                 NoItinerary, "rfe${addr:submode}\t$base!",
1102                 [/* For disassembly only; pattern left blank */]> {
1103   let Inst{31-28} = 0b1111;
1104   let Inst{22-20} = 0b011; // W = 1
1105 }
1106
1107 def RFE  : ABXI<{1,0,0,?}, (outs), (ins addrmode4:$addr, GPR:$base),
1108                 NoItinerary, "rfe${addr:submode}\t$base",
1109                 [/* For disassembly only; pattern left blank */]> {
1110   let Inst{31-28} = 0b1111;
1111   let Inst{22-20} = 0b001; // W = 0
1112 }
1113
1114 //===----------------------------------------------------------------------===//
1115 //  Load / store Instructions.
1116 //
1117
1118 // Load
1119 let canFoldAsLoad = 1, isReMaterializable = 1 in
1120 def LDR  : AI2ldw<(outs GPR:$dst), (ins addrmode2:$addr), LdFrm, IIC_iLoadr,
1121                "ldr", "\t$dst, $addr",
1122                [(set GPR:$dst, (load addrmode2:$addr))]>;
1123
1124 // Special LDR for loads from non-pc-relative constpools.
1125 let canFoldAsLoad = 1, mayLoad = 1, isReMaterializable = 1 in
1126 def LDRcp : AI2ldw<(outs GPR:$dst), (ins addrmode2:$addr), LdFrm, IIC_iLoadr,
1127                  "ldr", "\t$dst, $addr", []>;
1128
1129 // Loads with zero extension
1130 def LDRH  : AI3ldh<(outs GPR:$dst), (ins addrmode3:$addr), LdMiscFrm,
1131                   IIC_iLoadr, "ldrh", "\t$dst, $addr",
1132                   [(set GPR:$dst, (zextloadi16 addrmode3:$addr))]>;
1133
1134 def LDRB  : AI2ldb<(outs GPR:$dst), (ins addrmode2:$addr), LdFrm,
1135                   IIC_iLoadr, "ldrb", "\t$dst, $addr",
1136                   [(set GPR:$dst, (zextloadi8 addrmode2:$addr))]>;
1137
1138 // Loads with sign extension
1139 def LDRSH : AI3ldsh<(outs GPR:$dst), (ins addrmode3:$addr), LdMiscFrm,
1140                    IIC_iLoadr, "ldrsh", "\t$dst, $addr",
1141                    [(set GPR:$dst, (sextloadi16 addrmode3:$addr))]>;
1142
1143 def LDRSB : AI3ldsb<(outs GPR:$dst), (ins addrmode3:$addr), LdMiscFrm,
1144                    IIC_iLoadr, "ldrsb", "\t$dst, $addr",
1145                    [(set GPR:$dst, (sextloadi8 addrmode3:$addr))]>;
1146
1147 let mayLoad = 1, hasExtraDefRegAllocReq = 1 in {
1148 // Load doubleword
1149 def LDRD : AI3ldd<(outs GPR:$dst1, GPR:$dst2), (ins addrmode3:$addr), LdMiscFrm,
1150                  IIC_iLoadr, "ldrd", "\t$dst1, $addr",
1151                  []>, Requires<[IsARM, HasV5TE]>;
1152
1153 // Indexed loads
1154 def LDR_PRE  : AI2ldwpr<(outs GPR:$dst, GPR:$base_wb),
1155                      (ins addrmode2:$addr), LdFrm, IIC_iLoadru,
1156                      "ldr", "\t$dst, $addr!", "$addr.base = $base_wb", []>;
1157
1158 def LDR_POST : AI2ldwpo<(outs GPR:$dst, GPR:$base_wb),
1159                      (ins GPR:$base, am2offset:$offset), LdFrm, IIC_iLoadru,
1160                      "ldr", "\t$dst, [$base], $offset", "$base = $base_wb", []>;
1161
1162 def LDRH_PRE  : AI3ldhpr<(outs GPR:$dst, GPR:$base_wb),
1163                      (ins addrmode3:$addr), LdMiscFrm, IIC_iLoadru,
1164                      "ldrh", "\t$dst, $addr!", "$addr.base = $base_wb", []>;
1165
1166 def LDRH_POST : AI3ldhpo<(outs GPR:$dst, GPR:$base_wb),
1167                      (ins GPR:$base,am3offset:$offset), LdMiscFrm, IIC_iLoadru,
1168                     "ldrh", "\t$dst, [$base], $offset", "$base = $base_wb", []>;
1169
1170 def LDRB_PRE  : AI2ldbpr<(outs GPR:$dst, GPR:$base_wb),
1171                      (ins addrmode2:$addr), LdFrm, IIC_iLoadru,
1172                      "ldrb", "\t$dst, $addr!", "$addr.base = $base_wb", []>;
1173
1174 def LDRB_POST : AI2ldbpo<(outs GPR:$dst, GPR:$base_wb),
1175                      (ins GPR:$base,am2offset:$offset), LdFrm, IIC_iLoadru,
1176                     "ldrb", "\t$dst, [$base], $offset", "$base = $base_wb", []>;
1177
1178 def LDRSH_PRE : AI3ldshpr<(outs GPR:$dst, GPR:$base_wb),
1179                       (ins addrmode3:$addr), LdMiscFrm, IIC_iLoadru,
1180                       "ldrsh", "\t$dst, $addr!", "$addr.base = $base_wb", []>;
1181
1182 def LDRSH_POST: AI3ldshpo<(outs GPR:$dst, GPR:$base_wb),
1183                       (ins GPR:$base,am3offset:$offset), LdMiscFrm, IIC_iLoadru,
1184                    "ldrsh", "\t$dst, [$base], $offset", "$base = $base_wb", []>;
1185
1186 def LDRSB_PRE : AI3ldsbpr<(outs GPR:$dst, GPR:$base_wb),
1187                       (ins addrmode3:$addr), LdMiscFrm, IIC_iLoadru,
1188                       "ldrsb", "\t$dst, $addr!", "$addr.base = $base_wb", []>;
1189
1190 def LDRSB_POST: AI3ldsbpo<(outs GPR:$dst, GPR:$base_wb),
1191                       (ins GPR:$base,am3offset:$offset), LdMiscFrm, IIC_iLoadru,
1192                    "ldrsb", "\t$dst, [$base], $offset", "$base = $base_wb", []>;
1193
1194 // For disassembly only
1195 def LDRD_PRE : AI3lddpr<(outs GPR:$dst1, GPR:$dst2, GPR:$base_wb),
1196                         (ins addrmode3:$addr), LdMiscFrm, IIC_iLoadr,
1197                  "ldrd", "\t$dst1, $dst2, $addr!", "$addr.base = $base_wb", []>,
1198                 Requires<[IsARM, HasV5TE]>;
1199
1200 // For disassembly only
1201 def LDRD_POST : AI3lddpo<(outs GPR:$dst1, GPR:$dst2, GPR:$base_wb),
1202                        (ins GPR:$base,am3offset:$offset), LdMiscFrm, IIC_iLoadr,
1203             "ldrd", "\t$dst1, $dst2, [$base], $offset", "$base = $base_wb", []>,
1204                 Requires<[IsARM, HasV5TE]>;
1205
1206 }
1207
1208 // LDRT, LDRBT, LDRSBT, LDRHT, LDRSHT are for disassembly only.
1209
1210 def LDRT : AI2ldwpo<(outs GPR:$dst, GPR:$base_wb),
1211                    (ins GPR:$base, am2offset:$offset), LdFrm, IIC_iLoadru,
1212                    "ldrt", "\t$dst, [$base], $offset", "$base = $base_wb", []> {
1213   let Inst{21} = 1; // overwrite
1214 }
1215
1216 def LDRBT : AI2ldbpo<(outs GPR:$dst, GPR:$base_wb),
1217                   (ins GPR:$base,am2offset:$offset), LdFrm, IIC_iLoadru,
1218                   "ldrbt", "\t$dst, [$base], $offset", "$base = $base_wb", []> {
1219   let Inst{21} = 1; // overwrite
1220 }
1221
1222 def LDRSBT : AI3ldsbpo<(outs GPR:$dst, GPR:$base_wb),
1223                  (ins GPR:$base,am2offset:$offset), LdMiscFrm, IIC_iLoadru,
1224                  "ldrsbt", "\t$dst, [$base], $offset", "$base = $base_wb", []> {
1225   let Inst{21} = 1; // overwrite
1226 }
1227
1228 def LDRHT : AI3ldhpo<(outs GPR:$dst, GPR:$base_wb),
1229                   (ins GPR:$base, am3offset:$offset), LdMiscFrm, IIC_iLoadru,
1230                   "ldrht", "\t$dst, [$base], $offset", "$base = $base_wb", []> {
1231   let Inst{21} = 1; // overwrite
1232 }
1233
1234 def LDRSHT : AI3ldshpo<(outs GPR:$dst, GPR:$base_wb),
1235                  (ins GPR:$base,am3offset:$offset), LdMiscFrm, IIC_iLoadru,
1236                  "ldrsht", "\t$dst, [$base], $offset", "$base = $base_wb", []> {
1237   let Inst{21} = 1; // overwrite
1238 }
1239
1240 // Store
1241 def STR  : AI2stw<(outs), (ins GPR:$src, addrmode2:$addr), StFrm, IIC_iStorer,
1242                "str", "\t$src, $addr",
1243                [(store GPR:$src, addrmode2:$addr)]>;
1244
1245 // Stores with truncate
1246 def STRH : AI3sth<(outs), (ins GPR:$src, addrmode3:$addr), StMiscFrm,
1247                IIC_iStorer, "strh", "\t$src, $addr",
1248                [(truncstorei16 GPR:$src, addrmode3:$addr)]>;
1249
1250 def STRB : AI2stb<(outs), (ins GPR:$src, addrmode2:$addr), StFrm, IIC_iStorer,
1251                "strb", "\t$src, $addr",
1252                [(truncstorei8 GPR:$src, addrmode2:$addr)]>;
1253
1254 // Store doubleword
1255 let mayStore = 1, hasExtraSrcRegAllocReq = 1 in
1256 def STRD : AI3std<(outs), (ins GPR:$src1, GPR:$src2, addrmode3:$addr),
1257                StMiscFrm, IIC_iStorer,
1258                "strd", "\t$src1, $addr", []>, Requires<[IsARM, HasV5TE]>;
1259
1260 // Indexed stores
1261 def STR_PRE  : AI2stwpr<(outs GPR:$base_wb),
1262                      (ins GPR:$src, GPR:$base, am2offset:$offset),
1263                      StFrm, IIC_iStoreru,
1264                     "str", "\t$src, [$base, $offset]!", "$base = $base_wb",
1265                     [(set GPR:$base_wb,
1266                       (pre_store GPR:$src, GPR:$base, am2offset:$offset))]>;
1267
1268 def STR_POST : AI2stwpo<(outs GPR:$base_wb),
1269                      (ins GPR:$src, GPR:$base,am2offset:$offset),
1270                      StFrm, IIC_iStoreru,
1271                     "str", "\t$src, [$base], $offset", "$base = $base_wb",
1272                     [(set GPR:$base_wb,
1273                       (post_store GPR:$src, GPR:$base, am2offset:$offset))]>;
1274
1275 def STRH_PRE : AI3sthpr<(outs GPR:$base_wb),
1276                      (ins GPR:$src, GPR:$base,am3offset:$offset),
1277                      StMiscFrm, IIC_iStoreru,
1278                      "strh", "\t$src, [$base, $offset]!", "$base = $base_wb",
1279                     [(set GPR:$base_wb,
1280                       (pre_truncsti16 GPR:$src, GPR:$base,am3offset:$offset))]>;
1281
1282 def STRH_POST: AI3sthpo<(outs GPR:$base_wb),
1283                      (ins GPR:$src, GPR:$base,am3offset:$offset),
1284                      StMiscFrm, IIC_iStoreru,
1285                      "strh", "\t$src, [$base], $offset", "$base = $base_wb",
1286                     [(set GPR:$base_wb, (post_truncsti16 GPR:$src,
1287                                          GPR:$base, am3offset:$offset))]>;
1288
1289 def STRB_PRE : AI2stbpr<(outs GPR:$base_wb),
1290                      (ins GPR:$src, GPR:$base,am2offset:$offset),
1291                      StFrm, IIC_iStoreru,
1292                      "strb", "\t$src, [$base, $offset]!", "$base = $base_wb",
1293                     [(set GPR:$base_wb, (pre_truncsti8 GPR:$src,
1294                                          GPR:$base, am2offset:$offset))]>;
1295
1296 def STRB_POST: AI2stbpo<(outs GPR:$base_wb),
1297                      (ins GPR:$src, GPR:$base,am2offset:$offset),
1298                      StFrm, IIC_iStoreru,
1299                      "strb", "\t$src, [$base], $offset", "$base = $base_wb",
1300                     [(set GPR:$base_wb, (post_truncsti8 GPR:$src,
1301                                          GPR:$base, am2offset:$offset))]>;
1302
1303 // For disassembly only
1304 def STRD_PRE : AI3stdpr<(outs GPR:$base_wb),
1305                      (ins GPR:$src1, GPR:$src2, GPR:$base, am3offset:$offset),
1306                      StMiscFrm, IIC_iStoreru,
1307                      "strd", "\t$src1, $src2, [$base, $offset]!",
1308                      "$base = $base_wb", []>;
1309
1310 // For disassembly only
1311 def STRD_POST: AI3stdpo<(outs GPR:$base_wb),
1312                      (ins GPR:$src1, GPR:$src2, GPR:$base, am3offset:$offset),
1313                      StMiscFrm, IIC_iStoreru,
1314                      "strd", "\t$src1, $src2, [$base], $offset",
1315                      "$base = $base_wb", []>;
1316
1317 // STRT, STRBT, and STRHT are for disassembly only.
1318
1319 def STRT : AI2stwpo<(outs GPR:$base_wb),
1320                     (ins GPR:$src, GPR:$base,am2offset:$offset),
1321                     StFrm, IIC_iStoreru,
1322                     "strt", "\t$src, [$base], $offset", "$base = $base_wb",
1323                     [/* For disassembly only; pattern left blank */]> {
1324   let Inst{21} = 1; // overwrite
1325 }
1326
1327 def STRBT : AI2stbpo<(outs GPR:$base_wb),
1328                      (ins GPR:$src, GPR:$base,am2offset:$offset),
1329                      StFrm, IIC_iStoreru,
1330                      "strbt", "\t$src, [$base], $offset", "$base = $base_wb",
1331                      [/* For disassembly only; pattern left blank */]> {
1332   let Inst{21} = 1; // overwrite
1333 }
1334
1335 def STRHT: AI3sthpo<(outs GPR:$base_wb),
1336                     (ins GPR:$src, GPR:$base,am3offset:$offset),
1337                     StMiscFrm, IIC_iStoreru,
1338                     "strht", "\t$src, [$base], $offset", "$base = $base_wb",
1339                     [/* For disassembly only; pattern left blank */]> {
1340   let Inst{21} = 1; // overwrite
1341 }
1342
1343 //===----------------------------------------------------------------------===//
1344 //  Load / store multiple Instructions.
1345 //
1346
1347 let mayLoad = 1, hasExtraDefRegAllocReq = 1 in
1348 def LDM : AXI4ld<(outs),
1349                (ins addrmode4:$addr, pred:$p, reglist:$wb, variable_ops),
1350                LdStMulFrm, IIC_iLoadm, "ldm${addr:submode}${p}\t$addr, $wb",
1351                []>;
1352
1353 let mayStore = 1, hasExtraSrcRegAllocReq = 1 in
1354 def STM : AXI4st<(outs),
1355                (ins addrmode4:$addr, pred:$p, reglist:$wb, variable_ops),
1356                LdStMulFrm, IIC_iStorem, "stm${addr:submode}${p}\t$addr, $wb",
1357                []>;
1358
1359 //===----------------------------------------------------------------------===//
1360 //  Move Instructions.
1361 //
1362
1363 let neverHasSideEffects = 1 in
1364 def MOVr : AsI1<0b1101, (outs GPR:$dst), (ins GPR:$src), DPFrm, IIC_iMOVr,
1365                 "mov", "\t$dst, $src", []>, UnaryDP {
1366   let Inst{11-4} = 0b00000000;
1367   let Inst{25} = 0;
1368 }
1369
1370 def MOVs : AsI1<0b1101, (outs GPR:$dst), (ins so_reg:$src),
1371                 DPSoRegFrm, IIC_iMOVsr,
1372                 "mov", "\t$dst, $src", [(set GPR:$dst, so_reg:$src)]>, UnaryDP {
1373   let Inst{25} = 0;
1374 }
1375
1376 let isReMaterializable = 1, isAsCheapAsAMove = 1 in
1377 def MOVi : AsI1<0b1101, (outs GPR:$dst), (ins so_imm:$src), DPFrm, IIC_iMOVi,
1378                 "mov", "\t$dst, $src", [(set GPR:$dst, so_imm:$src)]>, UnaryDP {
1379   let Inst{25} = 1;
1380 }
1381
1382 let isReMaterializable = 1, isAsCheapAsAMove = 1 in
1383 def MOVi16 : AI1<0b1000, (outs GPR:$dst), (ins i32imm:$src),
1384                  DPFrm, IIC_iMOVi,
1385                  "movw", "\t$dst, $src",
1386                  [(set GPR:$dst, imm0_65535:$src)]>,
1387                  Requires<[IsARM, HasV6T2]>, UnaryDP {
1388   let Inst{20} = 0;
1389   let Inst{25} = 1;
1390 }
1391
1392 let Constraints = "$src = $dst" in
1393 def MOVTi16 : AI1<0b1010, (outs GPR:$dst), (ins GPR:$src, i32imm:$imm),
1394                   DPFrm, IIC_iMOVi,
1395                   "movt", "\t$dst, $imm",
1396                   [(set GPR:$dst,
1397                         (or (and GPR:$src, 0xffff),
1398                             lo16AllZero:$imm))]>, UnaryDP,
1399                   Requires<[IsARM, HasV6T2]> {
1400   let Inst{20} = 0;
1401   let Inst{25} = 1;
1402 }
1403
1404 def : ARMPat<(or GPR:$src, 0xffff0000), (MOVTi16 GPR:$src, 0xffff)>,
1405       Requires<[IsARM, HasV6T2]>;
1406
1407 let Uses = [CPSR] in
1408 def MOVrx : AsI1<0b1101, (outs GPR:$dst), (ins GPR:$src), Pseudo, IIC_iMOVsi,
1409                  "mov", "\t$dst, $src, rrx",
1410                  [(set GPR:$dst, (ARMrrx GPR:$src))]>, UnaryDP;
1411
1412 // These aren't really mov instructions, but we have to define them this way
1413 // due to flag operands.
1414
1415 let Defs = [CPSR] in {
1416 def MOVsrl_flag : AI1<0b1101, (outs GPR:$dst), (ins GPR:$src), Pseudo,
1417                       IIC_iMOVsi, "movs", "\t$dst, $src, lsr #1",
1418                       [(set GPR:$dst, (ARMsrl_flag GPR:$src))]>, UnaryDP;
1419 def MOVsra_flag : AI1<0b1101, (outs GPR:$dst), (ins GPR:$src), Pseudo,
1420                       IIC_iMOVsi, "movs", "\t$dst, $src, asr #1",
1421                       [(set GPR:$dst, (ARMsra_flag GPR:$src))]>, UnaryDP;
1422 }
1423
1424 //===----------------------------------------------------------------------===//
1425 //  Extend Instructions.
1426 //
1427
1428 // Sign extenders
1429
1430 defm SXTB  : AI_unary_rrot<0b01101010,
1431                            "sxtb", UnOpFrag<(sext_inreg node:$Src, i8)>>;
1432 defm SXTH  : AI_unary_rrot<0b01101011,
1433                            "sxth", UnOpFrag<(sext_inreg node:$Src, i16)>>;
1434
1435 defm SXTAB : AI_bin_rrot<0b01101010,
1436                "sxtab", BinOpFrag<(add node:$LHS, (sext_inreg node:$RHS, i8))>>;
1437 defm SXTAH : AI_bin_rrot<0b01101011,
1438                "sxtah", BinOpFrag<(add node:$LHS, (sext_inreg node:$RHS,i16))>>;
1439
1440 // For disassembly only
1441 defm SXTB16  : AI_unary_rrot_np<0b01101000, "sxtb16">;
1442
1443 // For disassembly only
1444 defm SXTAB16 : AI_bin_rrot_np<0b01101000, "sxtab16">;
1445
1446 // Zero extenders
1447
1448 let AddedComplexity = 16 in {
1449 defm UXTB   : AI_unary_rrot<0b01101110,
1450                             "uxtb"  , UnOpFrag<(and node:$Src, 0x000000FF)>>;
1451 defm UXTH   : AI_unary_rrot<0b01101111,
1452                             "uxth"  , UnOpFrag<(and node:$Src, 0x0000FFFF)>>;
1453 defm UXTB16 : AI_unary_rrot<0b01101100,
1454                             "uxtb16", UnOpFrag<(and node:$Src, 0x00FF00FF)>>;
1455
1456 def : ARMV6Pat<(and (shl GPR:$Src, (i32 8)), 0xFF00FF),
1457                (UXTB16r_rot GPR:$Src, 24)>;
1458 def : ARMV6Pat<(and (srl GPR:$Src, (i32 8)), 0xFF00FF),
1459                (UXTB16r_rot GPR:$Src, 8)>;
1460
1461 defm UXTAB : AI_bin_rrot<0b01101110, "uxtab",
1462                         BinOpFrag<(add node:$LHS, (and node:$RHS, 0x00FF))>>;
1463 defm UXTAH : AI_bin_rrot<0b01101111, "uxtah",
1464                         BinOpFrag<(add node:$LHS, (and node:$RHS, 0xFFFF))>>;
1465 }
1466
1467 // This isn't safe in general, the add is two 16-bit units, not a 32-bit add.
1468 // For disassembly only
1469 defm UXTAB16 : AI_bin_rrot_np<0b01101100, "uxtab16">;
1470
1471
1472 def SBFX  : I<(outs GPR:$dst),
1473               (ins GPR:$src, imm0_31:$lsb, imm0_31:$width),
1474                AddrMode1, Size4Bytes, IndexModeNone, DPFrm, IIC_iALUi,
1475                "sbfx", "\t$dst, $src, $lsb, $width", "", []>,
1476                Requires<[IsARM, HasV6T2]> {
1477   let Inst{27-21} = 0b0111101;
1478   let Inst{6-4}   = 0b101;
1479 }
1480
1481 def UBFX  : I<(outs GPR:$dst),
1482               (ins GPR:$src, imm0_31:$lsb, imm0_31:$width),
1483                AddrMode1, Size4Bytes, IndexModeNone, DPFrm, IIC_iALUi,
1484                "ubfx", "\t$dst, $src, $lsb, $width", "", []>,
1485                Requires<[IsARM, HasV6T2]> {
1486   let Inst{27-21} = 0b0111111;
1487   let Inst{6-4}   = 0b101;
1488 }
1489
1490 //===----------------------------------------------------------------------===//
1491 //  Arithmetic Instructions.
1492 //
1493
1494 defm ADD  : AsI1_bin_irs<0b0100, "add",
1495                          BinOpFrag<(add  node:$LHS, node:$RHS)>, 1>;
1496 defm SUB  : AsI1_bin_irs<0b0010, "sub",
1497                          BinOpFrag<(sub  node:$LHS, node:$RHS)>>;
1498
1499 // ADD and SUB with 's' bit set.
1500 defm ADDS : AI1_bin_s_irs<0b0100, "adds",
1501                           BinOpFrag<(addc node:$LHS, node:$RHS)>, 1>;
1502 defm SUBS : AI1_bin_s_irs<0b0010, "subs",
1503                           BinOpFrag<(subc node:$LHS, node:$RHS)>>;
1504
1505 defm ADC : AI1_adde_sube_irs<0b0101, "adc",
1506                           BinOpFrag<(adde_dead_carry node:$LHS, node:$RHS)>, 1>;
1507 defm SBC : AI1_adde_sube_irs<0b0110, "sbc",
1508                           BinOpFrag<(sube_dead_carry node:$LHS, node:$RHS)>>;
1509 defm ADCS : AI1_adde_sube_s_irs<0b0101, "adcs",
1510                           BinOpFrag<(adde_live_carry node:$LHS, node:$RHS)>, 1>;
1511 defm SBCS : AI1_adde_sube_s_irs<0b0110, "sbcs",
1512                           BinOpFrag<(sube_live_carry node:$LHS, node:$RHS) >>;
1513
1514 // These don't define reg/reg forms, because they are handled above.
1515 def RSBri : AsI1<0b0011, (outs GPR:$dst), (ins GPR:$a, so_imm:$b), DPFrm,
1516                   IIC_iALUi, "rsb", "\t$dst, $a, $b",
1517                   [(set GPR:$dst, (sub so_imm:$b, GPR:$a))]> {
1518     let Inst{25} = 1;
1519 }
1520
1521 def RSBrs : AsI1<0b0011, (outs GPR:$dst), (ins GPR:$a, so_reg:$b), DPSoRegFrm,
1522                   IIC_iALUsr, "rsb", "\t$dst, $a, $b",
1523                   [(set GPR:$dst, (sub so_reg:$b, GPR:$a))]> {
1524     let Inst{25} = 0;
1525 }
1526
1527 // RSB with 's' bit set.
1528 let Defs = [CPSR] in {
1529 def RSBSri : AI1<0b0011, (outs GPR:$dst), (ins GPR:$a, so_imm:$b), DPFrm,
1530                  IIC_iALUi, "rsbs", "\t$dst, $a, $b",
1531                  [(set GPR:$dst, (subc so_imm:$b, GPR:$a))]> {
1532     let Inst{20} = 1;
1533     let Inst{25} = 1;
1534 }
1535 def RSBSrs : AI1<0b0011, (outs GPR:$dst), (ins GPR:$a, so_reg:$b), DPSoRegFrm,
1536                  IIC_iALUsr, "rsbs", "\t$dst, $a, $b",
1537                  [(set GPR:$dst, (subc so_reg:$b, GPR:$a))]> {
1538     let Inst{20} = 1;
1539     let Inst{25} = 0;
1540 }
1541 }
1542
1543 let Uses = [CPSR] in {
1544 def RSCri : AsI1<0b0111, (outs GPR:$dst), (ins GPR:$a, so_imm:$b),
1545                  DPFrm, IIC_iALUi, "rsc", "\t$dst, $a, $b",
1546                  [(set GPR:$dst, (sube_dead_carry so_imm:$b, GPR:$a))]>,
1547                  Requires<[IsARM]> {
1548     let Inst{25} = 1;
1549 }
1550 def RSCrs : AsI1<0b0111, (outs GPR:$dst), (ins GPR:$a, so_reg:$b),
1551                  DPSoRegFrm, IIC_iALUsr, "rsc", "\t$dst, $a, $b",
1552                  [(set GPR:$dst, (sube_dead_carry so_reg:$b, GPR:$a))]>,
1553                  Requires<[IsARM]> {
1554     let Inst{25} = 0;
1555 }
1556 }
1557
1558 // FIXME: Allow these to be predicated.
1559 let Defs = [CPSR], Uses = [CPSR] in {
1560 def RSCSri : AXI1<0b0111, (outs GPR:$dst), (ins GPR:$a, so_imm:$b),
1561                   DPFrm, IIC_iALUi, "rscs\t$dst, $a, $b",
1562                   [(set GPR:$dst, (sube_dead_carry so_imm:$b, GPR:$a))]>,
1563                   Requires<[IsARM]> {
1564     let Inst{20} = 1;
1565     let Inst{25} = 1;
1566 }
1567 def RSCSrs : AXI1<0b0111, (outs GPR:$dst), (ins GPR:$a, so_reg:$b),
1568                   DPSoRegFrm, IIC_iALUsr, "rscs\t$dst, $a, $b",
1569                   [(set GPR:$dst, (sube_dead_carry so_reg:$b, GPR:$a))]>,
1570                   Requires<[IsARM]> {
1571     let Inst{20} = 1;
1572     let Inst{25} = 0;
1573 }
1574 }
1575
1576 // (sub X, imm) gets canonicalized to (add X, -imm).  Match this form.
1577 def : ARMPat<(add    GPR:$src, so_imm_neg:$imm),
1578              (SUBri  GPR:$src, so_imm_neg:$imm)>;
1579
1580 //def : ARMPat<(addc   GPR:$src, so_imm_neg:$imm),
1581 //             (SUBSri GPR:$src, so_imm_neg:$imm)>;
1582 //def : ARMPat<(adde   GPR:$src, so_imm_neg:$imm),
1583 //             (SBCri  GPR:$src, so_imm_neg:$imm)>;
1584
1585 // Note: These are implemented in C++ code, because they have to generate
1586 // ADD/SUBrs instructions, which use a complex pattern that a xform function
1587 // cannot produce.
1588 // (mul X, 2^n+1) -> (add (X << n), X)
1589 // (mul X, 2^n-1) -> (rsb X, (X << n))
1590
1591 // ARM Arithmetic Instruction -- for disassembly only
1592 // GPR:$dst = GPR:$a op GPR:$b
1593 class AAI<bits<8> op27_20, bits<4> op7_4, string opc>
1594   : AI<(outs GPR:$dst), (ins GPR:$a, GPR:$b), DPFrm, IIC_iALUr,
1595        opc, "\t$dst, $a, $b",
1596        [/* For disassembly only; pattern left blank */]> {
1597   let Inst{27-20} = op27_20;
1598   let Inst{7-4} = op7_4;
1599 }
1600
1601 // Saturating add/subtract -- for disassembly only
1602
1603 def QADD    : AAI<0b00010000, 0b0101, "qadd">;
1604 def QADD16  : AAI<0b01100010, 0b0001, "qadd16">;
1605 def QADD8   : AAI<0b01100010, 0b1001, "qadd8">;
1606 def QASX    : AAI<0b01100010, 0b0011, "qasx">;
1607 def QDADD   : AAI<0b00010100, 0b0101, "qdadd">;
1608 def QDSUB   : AAI<0b00010110, 0b0101, "qdsub">;
1609 def QSAX    : AAI<0b01100010, 0b0101, "qsax">;
1610 def QSUB    : AAI<0b00010010, 0b0101, "qsub">;
1611 def QSUB16  : AAI<0b01100010, 0b0111, "qsub16">;
1612 def QSUB8   : AAI<0b01100010, 0b1111, "qsub8">;
1613 def UQADD16 : AAI<0b01100110, 0b0001, "uqadd16">;
1614 def UQADD8  : AAI<0b01100110, 0b1001, "uqadd8">;
1615 def UQASX   : AAI<0b01100110, 0b0011, "uqasx">;
1616 def UQSAX   : AAI<0b01100110, 0b0101, "uqsax">;
1617 def UQSUB16 : AAI<0b01100110, 0b0111, "uqsub16">;
1618 def UQSUB8  : AAI<0b01100110, 0b1111, "uqsub8">;
1619
1620 // Signed/Unsigned add/subtract -- for disassembly only
1621
1622 def SASX   : AAI<0b01100001, 0b0011, "sasx">;
1623 def SADD16 : AAI<0b01100001, 0b0001, "sadd16">;
1624 def SADD8  : AAI<0b01100001, 0b1001, "sadd8">;
1625 def SSAX   : AAI<0b01100001, 0b0101, "ssax">;
1626 def SSUB16 : AAI<0b01100001, 0b0111, "ssub16">;
1627 def SSUB8  : AAI<0b01100001, 0b1111, "ssub8">;
1628 def UASX   : AAI<0b01100101, 0b0011, "uasx">;
1629 def UADD16 : AAI<0b01100101, 0b0001, "uadd16">;
1630 def UADD8  : AAI<0b01100101, 0b1001, "uadd8">;
1631 def USAX   : AAI<0b01100101, 0b0101, "usax">;
1632 def USUB16 : AAI<0b01100101, 0b0111, "usub16">;
1633 def USUB8  : AAI<0b01100101, 0b1111, "usub8">;
1634
1635 // Signed/Unsigned halving add/subtract -- for disassembly only
1636
1637 def SHASX   : AAI<0b01100011, 0b0011, "shasx">;
1638 def SHADD16 : AAI<0b01100011, 0b0001, "shadd16">;
1639 def SHADD8  : AAI<0b01100011, 0b1001, "shadd8">;
1640 def SHSAX   : AAI<0b01100011, 0b0101, "shsax">;
1641 def SHSUB16 : AAI<0b01100011, 0b0111, "shsub16">;
1642 def SHSUB8  : AAI<0b01100011, 0b1111, "shsub8">;
1643 def UHASX   : AAI<0b01100111, 0b0011, "uhasx">;
1644 def UHADD16 : AAI<0b01100111, 0b0001, "uhadd16">;
1645 def UHADD8  : AAI<0b01100111, 0b1001, "uhadd8">;
1646 def UHSAX   : AAI<0b01100111, 0b0101, "uhsax">;
1647 def UHSUB16 : AAI<0b01100111, 0b0111, "uhsub16">;
1648 def UHSUB8  : AAI<0b01100111, 0b1111, "uhsub8">;
1649
1650 // Unsigned Sum of Absolute Differences [and Accumulate] -- for disassembly only
1651
1652 def USAD8  : AI<(outs GPR:$dst), (ins GPR:$a, GPR:$b),
1653                 MulFrm /* for convenience */, NoItinerary, "usad8",
1654                 "\t$dst, $a, $b", []>,
1655              Requires<[IsARM, HasV6]> {
1656   let Inst{27-20} = 0b01111000;
1657   let Inst{15-12} = 0b1111;
1658   let Inst{7-4} = 0b0001;
1659 }
1660 def USADA8 : AI<(outs GPR:$dst), (ins GPR:$a, GPR:$b, GPR:$acc),
1661                 MulFrm /* for convenience */, NoItinerary, "usada8",
1662                 "\t$dst, $a, $b, $acc", []>,
1663              Requires<[IsARM, HasV6]> {
1664   let Inst{27-20} = 0b01111000;
1665   let Inst{7-4} = 0b0001;
1666 }
1667
1668 // Signed/Unsigned saturate -- for disassembly only
1669
1670 def SSATlsl : AI<(outs GPR:$dst), (ins i32imm:$bit_pos, GPR:$a, i32imm:$shamt),
1671                  DPFrm, NoItinerary, "ssat", "\t$dst, $bit_pos, $a, lsl $shamt",
1672                  [/* For disassembly only; pattern left blank */]> {
1673   let Inst{27-21} = 0b0110101;
1674   let Inst{6-4} = 0b001;
1675 }
1676
1677 def SSATasr : AI<(outs GPR:$dst), (ins i32imm:$bit_pos, GPR:$a, i32imm:$shamt),
1678                  DPFrm, NoItinerary, "ssat", "\t$dst, $bit_pos, $a, asr $shamt",
1679                  [/* For disassembly only; pattern left blank */]> {
1680   let Inst{27-21} = 0b0110101;
1681   let Inst{6-4} = 0b101;
1682 }
1683
1684 def SSAT16 : AI<(outs GPR:$dst), (ins i32imm:$bit_pos, GPR:$a), DPFrm,
1685                 NoItinerary, "ssat16", "\t$dst, $bit_pos, $a",
1686                 [/* For disassembly only; pattern left blank */]> {
1687   let Inst{27-20} = 0b01101010;
1688   let Inst{7-4} = 0b0011;
1689 }
1690
1691 def USATlsl : AI<(outs GPR:$dst), (ins i32imm:$bit_pos, GPR:$a, i32imm:$shamt),
1692                  DPFrm, NoItinerary, "usat", "\t$dst, $bit_pos, $a, lsl $shamt",
1693                  [/* For disassembly only; pattern left blank */]> {
1694   let Inst{27-21} = 0b0110111;
1695   let Inst{6-4} = 0b001;
1696 }
1697
1698 def USATasr : AI<(outs GPR:$dst), (ins i32imm:$bit_pos, GPR:$a, i32imm:$shamt),
1699                  DPFrm, NoItinerary, "usat", "\t$dst, $bit_pos, $a, asr $shamt",
1700                  [/* For disassembly only; pattern left blank */]> {
1701   let Inst{27-21} = 0b0110111;
1702   let Inst{6-4} = 0b101;
1703 }
1704
1705 def USAT16 : AI<(outs GPR:$dst), (ins i32imm:$bit_pos, GPR:$a), DPFrm,
1706                 NoItinerary, "usat16", "\t$dst, $bit_pos, $a",
1707                 [/* For disassembly only; pattern left blank */]> {
1708   let Inst{27-20} = 0b01101110;
1709   let Inst{7-4} = 0b0011;
1710 }
1711
1712 //===----------------------------------------------------------------------===//
1713 //  Bitwise Instructions.
1714 //
1715
1716 defm AND   : AsI1_bin_irs<0b0000, "and",
1717                           BinOpFrag<(and node:$LHS, node:$RHS)>, 1>;
1718 defm ORR   : AsI1_bin_irs<0b1100, "orr",
1719                           BinOpFrag<(or  node:$LHS, node:$RHS)>, 1>;
1720 defm EOR   : AsI1_bin_irs<0b0001, "eor",
1721                           BinOpFrag<(xor node:$LHS, node:$RHS)>, 1>;
1722 defm BIC   : AsI1_bin_irs<0b1110, "bic",
1723                           BinOpFrag<(and node:$LHS, (not node:$RHS))>>;
1724
1725 def BFC    : I<(outs GPR:$dst), (ins GPR:$src, bf_inv_mask_imm:$imm),
1726                AddrMode1, Size4Bytes, IndexModeNone, DPFrm, IIC_iUNAsi,
1727                "bfc", "\t$dst, $imm", "$src = $dst",
1728                [(set GPR:$dst, (and GPR:$src, bf_inv_mask_imm:$imm))]>,
1729                Requires<[IsARM, HasV6T2]> {
1730   let Inst{27-21} = 0b0111110;
1731   let Inst{6-0}   = 0b0011111;
1732 }
1733
1734 // A8.6.18  BFI - Bitfield insert (Encoding A1)
1735 // Added for disassembler with the pattern field purposely left blank.
1736 def BFI    : I<(outs GPR:$dst), (ins GPR:$src, bf_inv_mask_imm:$imm),
1737                AddrMode1, Size4Bytes, IndexModeNone, DPFrm, IIC_iUNAsi,
1738                "bfi", "\t$dst, $src, $imm", "",
1739                [/* For disassembly only; pattern left blank */]>,
1740                Requires<[IsARM, HasV6T2]> {
1741   let Inst{27-21} = 0b0111110;
1742   let Inst{6-4}   = 0b001; // Rn: Inst{3-0} != 15
1743 }
1744
1745 def  MVNr  : AsI1<0b1111, (outs GPR:$dst), (ins GPR:$src), DPFrm, IIC_iMOVr,
1746                   "mvn", "\t$dst, $src",
1747                   [(set GPR:$dst, (not GPR:$src))]>, UnaryDP {
1748   let Inst{25} = 0;
1749   let Inst{11-4} = 0b00000000;
1750 }
1751 def  MVNs  : AsI1<0b1111, (outs GPR:$dst), (ins so_reg:$src), DPSoRegFrm,
1752                   IIC_iMOVsr, "mvn", "\t$dst, $src",
1753                   [(set GPR:$dst, (not so_reg:$src))]>, UnaryDP {
1754   let Inst{25} = 0;
1755 }
1756 let isReMaterializable = 1, isAsCheapAsAMove = 1 in
1757 def  MVNi  : AsI1<0b1111, (outs GPR:$dst), (ins so_imm:$imm), DPFrm,
1758                   IIC_iMOVi, "mvn", "\t$dst, $imm",
1759                   [(set GPR:$dst, so_imm_not:$imm)]>,UnaryDP {
1760     let Inst{25} = 1;
1761 }
1762
1763 def : ARMPat<(and   GPR:$src, so_imm_not:$imm),
1764              (BICri GPR:$src, so_imm_not:$imm)>;
1765
1766 //===----------------------------------------------------------------------===//
1767 //  Multiply Instructions.
1768 //
1769
1770 let isCommutable = 1 in
1771 def MUL   : AsMul1I<0b0000000, (outs GPR:$dst), (ins GPR:$a, GPR:$b),
1772                    IIC_iMUL32, "mul", "\t$dst, $a, $b",
1773                    [(set GPR:$dst, (mul GPR:$a, GPR:$b))]>;
1774
1775 def MLA   : AsMul1I<0b0000001, (outs GPR:$dst), (ins GPR:$a, GPR:$b, GPR:$c),
1776                     IIC_iMAC32, "mla", "\t$dst, $a, $b, $c",
1777                    [(set GPR:$dst, (add (mul GPR:$a, GPR:$b), GPR:$c))]>;
1778
1779 def MLS   : AMul1I<0b0000011, (outs GPR:$dst), (ins GPR:$a, GPR:$b, GPR:$c),
1780                    IIC_iMAC32, "mls", "\t$dst, $a, $b, $c",
1781                    [(set GPR:$dst, (sub GPR:$c, (mul GPR:$a, GPR:$b)))]>,
1782                    Requires<[IsARM, HasV6T2]>;
1783
1784 // Extra precision multiplies with low / high results
1785 let neverHasSideEffects = 1 in {
1786 let isCommutable = 1 in {
1787 def SMULL : AsMul1I<0b0000110, (outs GPR:$ldst, GPR:$hdst),
1788                                (ins GPR:$a, GPR:$b), IIC_iMUL64,
1789                     "smull", "\t$ldst, $hdst, $a, $b", []>;
1790
1791 def UMULL : AsMul1I<0b0000100, (outs GPR:$ldst, GPR:$hdst),
1792                                (ins GPR:$a, GPR:$b), IIC_iMUL64,
1793                     "umull", "\t$ldst, $hdst, $a, $b", []>;
1794 }
1795
1796 // Multiply + accumulate
1797 def SMLAL : AsMul1I<0b0000111, (outs GPR:$ldst, GPR:$hdst),
1798                                (ins GPR:$a, GPR:$b), IIC_iMAC64,
1799                     "smlal", "\t$ldst, $hdst, $a, $b", []>;
1800
1801 def UMLAL : AsMul1I<0b0000101, (outs GPR:$ldst, GPR:$hdst),
1802                                (ins GPR:$a, GPR:$b), IIC_iMAC64,
1803                     "umlal", "\t$ldst, $hdst, $a, $b", []>;
1804
1805 def UMAAL : AMul1I <0b0000010, (outs GPR:$ldst, GPR:$hdst),
1806                                (ins GPR:$a, GPR:$b), IIC_iMAC64,
1807                     "umaal", "\t$ldst, $hdst, $a, $b", []>,
1808                     Requires<[IsARM, HasV6]>;
1809 } // neverHasSideEffects
1810
1811 // Most significant word multiply
1812 def SMMUL : AMul2I <0b0111010, (outs GPR:$dst), (ins GPR:$a, GPR:$b),
1813                IIC_iMUL32, "smmul", "\t$dst, $a, $b",
1814                [(set GPR:$dst, (mulhs GPR:$a, GPR:$b))]>,
1815             Requires<[IsARM, HasV6]> {
1816   let Inst{7-4}   = 0b0001;
1817   let Inst{15-12} = 0b1111;
1818 }
1819
1820 def SMMULR : AMul2I <0b0111010, (outs GPR:$dst), (ins GPR:$a, GPR:$b),
1821                IIC_iMUL32, "smmulr", "\t$dst, $a, $b",
1822                [/* For disassembly only; pattern left blank */]>,
1823             Requires<[IsARM, HasV6]> {
1824   let Inst{7-4}   = 0b0011; // R = 1
1825   let Inst{15-12} = 0b1111;
1826 }
1827
1828 def SMMLA : AMul2I <0b0111010, (outs GPR:$dst), (ins GPR:$a, GPR:$b, GPR:$c),
1829                IIC_iMAC32, "smmla", "\t$dst, $a, $b, $c",
1830                [(set GPR:$dst, (add (mulhs GPR:$a, GPR:$b), GPR:$c))]>,
1831             Requires<[IsARM, HasV6]> {
1832   let Inst{7-4}   = 0b0001;
1833 }
1834
1835 def SMMLAR : AMul2I <0b0111010, (outs GPR:$dst), (ins GPR:$a, GPR:$b, GPR:$c),
1836                IIC_iMAC32, "smmlar", "\t$dst, $a, $b, $c",
1837                [/* For disassembly only; pattern left blank */]>,
1838             Requires<[IsARM, HasV6]> {
1839   let Inst{7-4}   = 0b0011; // R = 1
1840 }
1841
1842 def SMMLS : AMul2I <0b0111010, (outs GPR:$dst), (ins GPR:$a, GPR:$b, GPR:$c),
1843                IIC_iMAC32, "smmls", "\t$dst, $a, $b, $c",
1844                [(set GPR:$dst, (sub GPR:$c, (mulhs GPR:$a, GPR:$b)))]>,
1845             Requires<[IsARM, HasV6]> {
1846   let Inst{7-4}   = 0b1101;
1847 }
1848
1849 def SMMLSR : AMul2I <0b0111010, (outs GPR:$dst), (ins GPR:$a, GPR:$b, GPR:$c),
1850                IIC_iMAC32, "smmlsr", "\t$dst, $a, $b, $c",
1851                [/* For disassembly only; pattern left blank */]>,
1852             Requires<[IsARM, HasV6]> {
1853   let Inst{7-4}   = 0b1111; // R = 1
1854 }
1855
1856 multiclass AI_smul<string opc, PatFrag opnode> {
1857   def BB : AMulxyI<0b0001011, (outs GPR:$dst), (ins GPR:$a, GPR:$b),
1858               IIC_iMUL32, !strconcat(opc, "bb"), "\t$dst, $a, $b",
1859               [(set GPR:$dst, (opnode (sext_inreg GPR:$a, i16),
1860                                       (sext_inreg GPR:$b, i16)))]>,
1861            Requires<[IsARM, HasV5TE]> {
1862              let Inst{5} = 0;
1863              let Inst{6} = 0;
1864            }
1865
1866   def BT : AMulxyI<0b0001011, (outs GPR:$dst), (ins GPR:$a, GPR:$b),
1867               IIC_iMUL32, !strconcat(opc, "bt"), "\t$dst, $a, $b",
1868               [(set GPR:$dst, (opnode (sext_inreg GPR:$a, i16),
1869                                       (sra GPR:$b, (i32 16))))]>,
1870            Requires<[IsARM, HasV5TE]> {
1871              let Inst{5} = 0;
1872              let Inst{6} = 1;
1873            }
1874
1875   def TB : AMulxyI<0b0001011, (outs GPR:$dst), (ins GPR:$a, GPR:$b),
1876               IIC_iMUL32, !strconcat(opc, "tb"), "\t$dst, $a, $b",
1877               [(set GPR:$dst, (opnode (sra GPR:$a, (i32 16)),
1878                                       (sext_inreg GPR:$b, i16)))]>,
1879            Requires<[IsARM, HasV5TE]> {
1880              let Inst{5} = 1;
1881              let Inst{6} = 0;
1882            }
1883
1884   def TT : AMulxyI<0b0001011, (outs GPR:$dst), (ins GPR:$a, GPR:$b),
1885               IIC_iMUL32, !strconcat(opc, "tt"), "\t$dst, $a, $b",
1886               [(set GPR:$dst, (opnode (sra GPR:$a, (i32 16)),
1887                                       (sra GPR:$b, (i32 16))))]>,
1888             Requires<[IsARM, HasV5TE]> {
1889              let Inst{5} = 1;
1890              let Inst{6} = 1;
1891            }
1892
1893   def WB : AMulxyI<0b0001001, (outs GPR:$dst), (ins GPR:$a, GPR:$b),
1894               IIC_iMUL16, !strconcat(opc, "wb"), "\t$dst, $a, $b",
1895               [(set GPR:$dst, (sra (opnode GPR:$a,
1896                                     (sext_inreg GPR:$b, i16)), (i32 16)))]>,
1897            Requires<[IsARM, HasV5TE]> {
1898              let Inst{5} = 1;
1899              let Inst{6} = 0;
1900            }
1901
1902   def WT : AMulxyI<0b0001001, (outs GPR:$dst), (ins GPR:$a, GPR:$b),
1903               IIC_iMUL16, !strconcat(opc, "wt"), "\t$dst, $a, $b",
1904               [(set GPR:$dst, (sra (opnode GPR:$a,
1905                                     (sra GPR:$b, (i32 16))), (i32 16)))]>,
1906             Requires<[IsARM, HasV5TE]> {
1907              let Inst{5} = 1;
1908              let Inst{6} = 1;
1909            }
1910 }
1911
1912
1913 multiclass AI_smla<string opc, PatFrag opnode> {
1914   def BB : AMulxyI<0b0001000, (outs GPR:$dst), (ins GPR:$a, GPR:$b, GPR:$acc),
1915               IIC_iMAC16, !strconcat(opc, "bb"), "\t$dst, $a, $b, $acc",
1916               [(set GPR:$dst, (add GPR:$acc,
1917                                (opnode (sext_inreg GPR:$a, i16),
1918                                        (sext_inreg GPR:$b, i16))))]>,
1919            Requires<[IsARM, HasV5TE]> {
1920              let Inst{5} = 0;
1921              let Inst{6} = 0;
1922            }
1923
1924   def BT : AMulxyI<0b0001000, (outs GPR:$dst), (ins GPR:$a, GPR:$b, GPR:$acc),
1925               IIC_iMAC16, !strconcat(opc, "bt"), "\t$dst, $a, $b, $acc",
1926               [(set GPR:$dst, (add GPR:$acc, (opnode (sext_inreg GPR:$a, i16),
1927                                                     (sra GPR:$b, (i32 16)))))]>,
1928            Requires<[IsARM, HasV5TE]> {
1929              let Inst{5} = 0;
1930              let Inst{6} = 1;
1931            }
1932
1933   def TB : AMulxyI<0b0001000, (outs GPR:$dst), (ins GPR:$a, GPR:$b, GPR:$acc),
1934               IIC_iMAC16, !strconcat(opc, "tb"), "\t$dst, $a, $b, $acc",
1935               [(set GPR:$dst, (add GPR:$acc, (opnode (sra GPR:$a, (i32 16)),
1936                                                  (sext_inreg GPR:$b, i16))))]>,
1937            Requires<[IsARM, HasV5TE]> {
1938              let Inst{5} = 1;
1939              let Inst{6} = 0;
1940            }
1941
1942   def TT : AMulxyI<0b0001000, (outs GPR:$dst), (ins GPR:$a, GPR:$b, GPR:$acc),
1943               IIC_iMAC16, !strconcat(opc, "tt"), "\t$dst, $a, $b, $acc",
1944              [(set GPR:$dst, (add GPR:$acc, (opnode (sra GPR:$a, (i32 16)),
1945                                                     (sra GPR:$b, (i32 16)))))]>,
1946             Requires<[IsARM, HasV5TE]> {
1947              let Inst{5} = 1;
1948              let Inst{6} = 1;
1949            }
1950
1951   def WB : AMulxyI<0b0001001, (outs GPR:$dst), (ins GPR:$a, GPR:$b, GPR:$acc),
1952               IIC_iMAC16, !strconcat(opc, "wb"), "\t$dst, $a, $b, $acc",
1953               [(set GPR:$dst, (add GPR:$acc, (sra (opnode GPR:$a,
1954                                        (sext_inreg GPR:$b, i16)), (i32 16))))]>,
1955            Requires<[IsARM, HasV5TE]> {
1956              let Inst{5} = 0;
1957              let Inst{6} = 0;
1958            }
1959
1960   def WT : AMulxyI<0b0001001, (outs GPR:$dst), (ins GPR:$a, GPR:$b, GPR:$acc),
1961               IIC_iMAC16, !strconcat(opc, "wt"), "\t$dst, $a, $b, $acc",
1962               [(set GPR:$dst, (add GPR:$acc, (sra (opnode GPR:$a,
1963                                          (sra GPR:$b, (i32 16))), (i32 16))))]>,
1964             Requires<[IsARM, HasV5TE]> {
1965              let Inst{5} = 0;
1966              let Inst{6} = 1;
1967            }
1968 }
1969
1970 defm SMUL : AI_smul<"smul", BinOpFrag<(mul node:$LHS, node:$RHS)>>;
1971 defm SMLA : AI_smla<"smla", BinOpFrag<(mul node:$LHS, node:$RHS)>>;
1972
1973 // Halfword multiply accumulate long: SMLAL<x><y> -- for disassembly only
1974 def SMLALBB : AMulxyI<0b0001010,(outs GPR:$ldst,GPR:$hdst),(ins GPR:$a,GPR:$b),
1975                       IIC_iMAC64, "smlalbb", "\t$ldst, $hdst, $a, $b",
1976                       [/* For disassembly only; pattern left blank */]>,
1977               Requires<[IsARM, HasV5TE]> {
1978   let Inst{5} = 0;
1979   let Inst{6} = 0;
1980 }
1981
1982 def SMLALBT : AMulxyI<0b0001010,(outs GPR:$ldst,GPR:$hdst),(ins GPR:$a,GPR:$b),
1983                       IIC_iMAC64, "smlalbt", "\t$ldst, $hdst, $a, $b",
1984                       [/* For disassembly only; pattern left blank */]>,
1985               Requires<[IsARM, HasV5TE]> {
1986   let Inst{5} = 0;
1987   let Inst{6} = 1;
1988 }
1989
1990 def SMLALTB : AMulxyI<0b0001010,(outs GPR:$ldst,GPR:$hdst),(ins GPR:$a,GPR:$b),
1991                       IIC_iMAC64, "smlaltb", "\t$ldst, $hdst, $a, $b",
1992                       [/* For disassembly only; pattern left blank */]>,
1993               Requires<[IsARM, HasV5TE]> {
1994   let Inst{5} = 1;
1995   let Inst{6} = 0;
1996 }
1997
1998 def SMLALTT : AMulxyI<0b0001010,(outs GPR:$ldst,GPR:$hdst),(ins GPR:$a,GPR:$b),
1999                       IIC_iMAC64, "smlaltt", "\t$ldst, $hdst, $a, $b",
2000                       [/* For disassembly only; pattern left blank */]>,
2001               Requires<[IsARM, HasV5TE]> {
2002   let Inst{5} = 1;
2003   let Inst{6} = 1;
2004 }
2005
2006 // Helper class for AI_smld -- for disassembly only
2007 class AMulDualI<bit long, bit sub, bit swap, dag oops, dag iops,
2008                 InstrItinClass itin, string opc, string asm>
2009   : AI<oops, iops, MulFrm, itin, opc, asm, []>, Requires<[IsARM, HasV6]> {
2010   let Inst{4}     = 1;
2011   let Inst{5}     = swap;
2012   let Inst{6}     = sub;
2013   let Inst{7}     = 0;
2014   let Inst{21-20} = 0b00;
2015   let Inst{22}    = long;
2016   let Inst{27-23} = 0b01110;
2017 }
2018
2019 multiclass AI_smld<bit sub, string opc> {
2020
2021   def D : AMulDualI<0, sub, 0, (outs GPR:$dst), (ins GPR:$a, GPR:$b, GPR:$acc),
2022                   NoItinerary, !strconcat(opc, "d"), "\t$dst, $a, $b, $acc">;
2023
2024   def DX : AMulDualI<0, sub, 1, (outs GPR:$dst), (ins GPR:$a, GPR:$b, GPR:$acc),
2025                   NoItinerary, !strconcat(opc, "dx"), "\t$dst, $a, $b, $acc">;
2026
2027   def LD : AMulDualI<1, sub, 0, (outs GPR:$ldst,GPR:$hdst), (ins GPR:$a,GPR:$b),
2028                   NoItinerary, !strconcat(opc, "ld"), "\t$ldst, $hdst, $a, $b">;
2029
2030   def LDX : AMulDualI<1, sub, 1, (outs GPR:$ldst,GPR:$hdst),(ins GPR:$a,GPR:$b),
2031                   NoItinerary, !strconcat(opc, "ldx"),"\t$ldst, $hdst, $a, $b">;
2032
2033 }
2034
2035 defm SMLA : AI_smld<0, "smla">;
2036 defm SMLS : AI_smld<1, "smls">;
2037
2038 multiclass AI_sdml<bit sub, string opc> {
2039
2040   def D : AMulDualI<0, sub, 0, (outs GPR:$dst), (ins GPR:$a, GPR:$b),
2041                     NoItinerary, !strconcat(opc, "d"), "\t$dst, $a, $b"> {
2042     let Inst{15-12} = 0b1111;
2043   }
2044
2045   def DX : AMulDualI<0, sub, 1, (outs GPR:$dst), (ins GPR:$a, GPR:$b),
2046                     NoItinerary, !strconcat(opc, "dx"), "\t$dst, $a, $b"> {
2047     let Inst{15-12} = 0b1111;
2048   }
2049
2050 }
2051
2052 defm SMUA : AI_sdml<0, "smua">;
2053 defm SMUS : AI_sdml<1, "smus">;
2054
2055 //===----------------------------------------------------------------------===//
2056 //  Misc. Arithmetic Instructions.
2057 //
2058
2059 def CLZ  : AMiscA1I<0b000010110, (outs GPR:$dst), (ins GPR:$src), IIC_iUNAr,
2060               "clz", "\t$dst, $src",
2061               [(set GPR:$dst, (ctlz GPR:$src))]>, Requires<[IsARM, HasV5T]> {
2062   let Inst{7-4}   = 0b0001;
2063   let Inst{11-8}  = 0b1111;
2064   let Inst{19-16} = 0b1111;
2065 }
2066
2067 def RBIT : AMiscA1I<0b01101111, (outs GPR:$dst), (ins GPR:$src), IIC_iUNAr,
2068               "rbit", "\t$dst, $src",
2069               [(set GPR:$dst, (ARMrbit GPR:$src))]>,
2070            Requires<[IsARM, HasV6T2]> {
2071   let Inst{7-4}   = 0b0011;
2072   let Inst{11-8}  = 0b1111;
2073   let Inst{19-16} = 0b1111;
2074 }
2075
2076 def REV  : AMiscA1I<0b01101011, (outs GPR:$dst), (ins GPR:$src), IIC_iUNAr,
2077               "rev", "\t$dst, $src",
2078               [(set GPR:$dst, (bswap GPR:$src))]>, Requires<[IsARM, HasV6]> {
2079   let Inst{7-4}   = 0b0011;
2080   let Inst{11-8}  = 0b1111;
2081   let Inst{19-16} = 0b1111;
2082 }
2083
2084 def REV16 : AMiscA1I<0b01101011, (outs GPR:$dst), (ins GPR:$src), IIC_iUNAr,
2085                "rev16", "\t$dst, $src",
2086                [(set GPR:$dst,
2087                    (or (and (srl GPR:$src, (i32 8)), 0xFF),
2088                        (or (and (shl GPR:$src, (i32 8)), 0xFF00),
2089                            (or (and (srl GPR:$src, (i32 8)), 0xFF0000),
2090                                (and (shl GPR:$src, (i32 8)), 0xFF000000)))))]>,
2091                Requires<[IsARM, HasV6]> {
2092   let Inst{7-4}   = 0b1011;
2093   let Inst{11-8}  = 0b1111;
2094   let Inst{19-16} = 0b1111;
2095 }
2096
2097 def REVSH : AMiscA1I<0b01101111, (outs GPR:$dst), (ins GPR:$src), IIC_iUNAr,
2098                "revsh", "\t$dst, $src",
2099                [(set GPR:$dst,
2100                   (sext_inreg
2101                     (or (srl (and GPR:$src, 0xFF00), (i32 8)),
2102                         (shl GPR:$src, (i32 8))), i16))]>,
2103                Requires<[IsARM, HasV6]> {
2104   let Inst{7-4}   = 0b1011;
2105   let Inst{11-8}  = 0b1111;
2106   let Inst{19-16} = 0b1111;
2107 }
2108
2109 def PKHBT : AMiscA1I<0b01101000, (outs GPR:$dst),
2110                                  (ins GPR:$src1, GPR:$src2, i32imm:$shamt),
2111                IIC_iALUsi, "pkhbt", "\t$dst, $src1, $src2, lsl $shamt",
2112                [(set GPR:$dst, (or (and GPR:$src1, 0xFFFF),
2113                                    (and (shl GPR:$src2, (i32 imm:$shamt)),
2114                                         0xFFFF0000)))]>,
2115                Requires<[IsARM, HasV6]> {
2116   let Inst{6-4} = 0b001;
2117 }
2118
2119 // Alternate cases for PKHBT where identities eliminate some nodes.
2120 def : ARMV6Pat<(or (and GPR:$src1, 0xFFFF), (and GPR:$src2, 0xFFFF0000)),
2121                (PKHBT GPR:$src1, GPR:$src2, 0)>;
2122 def : ARMV6Pat<(or (and GPR:$src1, 0xFFFF), (shl GPR:$src2, imm16_31:$shamt)),
2123                (PKHBT GPR:$src1, GPR:$src2, imm16_31:$shamt)>;
2124
2125
2126 def PKHTB : AMiscA1I<0b01101000, (outs GPR:$dst),
2127                                  (ins GPR:$src1, GPR:$src2, i32imm:$shamt),
2128                IIC_iALUsi, "pkhtb", "\t$dst, $src1, $src2, asr $shamt",
2129                [(set GPR:$dst, (or (and GPR:$src1, 0xFFFF0000),
2130                                    (and (sra GPR:$src2, imm16_31:$shamt),
2131                                         0xFFFF)))]>, Requires<[IsARM, HasV6]> {
2132   let Inst{6-4} = 0b101;
2133 }
2134
2135 // Alternate cases for PKHTB where identities eliminate some nodes.  Note that
2136 // a shift amount of 0 is *not legal* here, it is PKHBT instead.
2137 def : ARMV6Pat<(or (and GPR:$src1, 0xFFFF0000), (srl GPR:$src2, (i32 16))),
2138                (PKHTB GPR:$src1, GPR:$src2, 16)>;
2139 def : ARMV6Pat<(or (and GPR:$src1, 0xFFFF0000),
2140                    (and (srl GPR:$src2, imm1_15:$shamt), 0xFFFF)),
2141                (PKHTB GPR:$src1, GPR:$src2, imm1_15:$shamt)>;
2142
2143 //===----------------------------------------------------------------------===//
2144 //  Comparison Instructions...
2145 //
2146
2147 defm CMP  : AI1_cmp_irs<0b1010, "cmp",
2148                         BinOpFrag<(ARMcmp node:$LHS, node:$RHS)>>;
2149 //FIXME: Disable CMN, as CCodes are backwards from compare expectations
2150 //       Compare-to-zero still works out, just not the relationals
2151 //defm CMN  : AI1_cmp_irs<0b1011, "cmn",
2152 //                        BinOpFrag<(ARMcmp node:$LHS,(ineg node:$RHS))>>;
2153
2154 // Note that TST/TEQ don't set all the same flags that CMP does!
2155 defm TST  : AI1_cmp_irs<0b1000, "tst",
2156                         BinOpFrag<(ARMcmpZ (and node:$LHS, node:$RHS), 0)>, 1>;
2157 defm TEQ  : AI1_cmp_irs<0b1001, "teq",
2158                         BinOpFrag<(ARMcmpZ (xor node:$LHS, node:$RHS), 0)>, 1>;
2159
2160 defm CMPz  : AI1_cmp_irs<0b1010, "cmp",
2161                          BinOpFrag<(ARMcmpZ node:$LHS, node:$RHS)>>;
2162 defm CMNz  : AI1_cmp_irs<0b1011, "cmn",
2163                          BinOpFrag<(ARMcmpZ node:$LHS,(ineg node:$RHS))>>;
2164
2165 //def : ARMPat<(ARMcmp GPR:$src, so_imm_neg:$imm),
2166 //             (CMNri  GPR:$src, so_imm_neg:$imm)>;
2167
2168 def : ARMPat<(ARMcmpZ GPR:$src, so_imm_neg:$imm),
2169              (CMNzri  GPR:$src, so_imm_neg:$imm)>;
2170
2171
2172 // Conditional moves
2173 // FIXME: should be able to write a pattern for ARMcmov, but can't use
2174 // a two-value operand where a dag node expects two operands. :(
2175 def MOVCCr : AI1<0b1101, (outs GPR:$dst), (ins GPR:$false, GPR:$true), DPFrm,
2176                 IIC_iCMOVr, "mov", "\t$dst, $true",
2177       [/*(set GPR:$dst, (ARMcmov GPR:$false, GPR:$true, imm:$cc, CCR:$ccr))*/]>,
2178                 RegConstraint<"$false = $dst">, UnaryDP {
2179   let Inst{11-4} = 0b00000000;
2180   let Inst{25} = 0;
2181 }
2182
2183 def MOVCCs : AI1<0b1101, (outs GPR:$dst),
2184                         (ins GPR:$false, so_reg:$true), DPSoRegFrm, IIC_iCMOVsr,
2185                 "mov", "\t$dst, $true",
2186    [/*(set GPR:$dst, (ARMcmov GPR:$false, so_reg:$true, imm:$cc, CCR:$ccr))*/]>,
2187                 RegConstraint<"$false = $dst">, UnaryDP {
2188   let Inst{25} = 0;
2189 }
2190
2191 def MOVCCi : AI1<0b1101, (outs GPR:$dst),
2192                         (ins GPR:$false, so_imm:$true), DPFrm, IIC_iCMOVi,
2193                 "mov", "\t$dst, $true",
2194    [/*(set GPR:$dst, (ARMcmov GPR:$false, so_imm:$true, imm:$cc, CCR:$ccr))*/]>,
2195                 RegConstraint<"$false = $dst">, UnaryDP {
2196   let Inst{25} = 1;
2197 }
2198
2199 //===----------------------------------------------------------------------===//
2200 // Atomic operations intrinsics
2201 //
2202
2203 // memory barriers protect the atomic sequences
2204 let hasSideEffects = 1 in {
2205 def Int_MemBarrierV7 : AInoP<(outs), (ins),
2206                         Pseudo, NoItinerary,
2207                         "dmb", "",
2208                         [(ARMMemBarrierV7)]>,
2209                         Requires<[IsARM, HasV7]> {
2210   let Inst{31-4} = 0xf57ff05;
2211   // FIXME: add support for options other than a full system DMB
2212   // See DMB disassembly-only variants below.
2213   let Inst{3-0} = 0b1111;
2214 }
2215
2216 def Int_SyncBarrierV7 : AInoP<(outs), (ins),
2217                         Pseudo, NoItinerary,
2218                         "dsb", "",
2219                         [(ARMSyncBarrierV7)]>,
2220                         Requires<[IsARM, HasV7]> {
2221   let Inst{31-4} = 0xf57ff04;
2222   // FIXME: add support for options other than a full system DSB
2223   // See DSB disassembly-only variants below.
2224   let Inst{3-0} = 0b1111;
2225 }
2226
2227 def Int_MemBarrierV6 : AInoP<(outs), (ins GPR:$zero),
2228                        Pseudo, NoItinerary,
2229                        "mcr", "\tp15, 0, $zero, c7, c10, 5",
2230                        [(ARMMemBarrierV6 GPR:$zero)]>,
2231                        Requires<[IsARM, HasV6]> {
2232   // FIXME: add support for options other than a full system DMB
2233   // FIXME: add encoding
2234 }
2235
2236 def Int_SyncBarrierV6 : AInoP<(outs), (ins GPR:$zero),
2237                         Pseudo, NoItinerary,
2238                         "mcr", "\tp15, 0, $zero, c7, c10, 4",
2239                         [(ARMSyncBarrierV6 GPR:$zero)]>,
2240                         Requires<[IsARM, HasV6]> {
2241   // FIXME: add support for options other than a full system DSB
2242   // FIXME: add encoding
2243 }
2244 }
2245
2246 // Helper class for multiclass MemB -- for disassembly only
2247 class AMBI<string opc, string asm>
2248   : AInoP<(outs), (ins), MiscFrm, NoItinerary, opc, asm,
2249           [/* For disassembly only; pattern left blank */]>,
2250     Requires<[IsARM, HasV7]> {
2251   let Inst{31-20} = 0xf57;
2252 }
2253
2254 multiclass MemB<bits<4> op7_4, string opc> {
2255
2256   def st : AMBI<opc, "\tst"> {
2257     let Inst{7-4} = op7_4;
2258     let Inst{3-0} = 0b1110;
2259   }
2260
2261   def ish : AMBI<opc, "\tish"> {
2262     let Inst{7-4} = op7_4;
2263     let Inst{3-0} = 0b1011;
2264   }
2265
2266   def ishst : AMBI<opc, "\tishst"> {
2267     let Inst{7-4} = op7_4;
2268     let Inst{3-0} = 0b1010;
2269   }
2270
2271   def nsh : AMBI<opc, "\tnsh"> {
2272     let Inst{7-4} = op7_4;
2273     let Inst{3-0} = 0b0111;
2274   }
2275
2276   def nshst : AMBI<opc, "\tnshst"> {
2277     let Inst{7-4} = op7_4;
2278     let Inst{3-0} = 0b0110;
2279   }
2280
2281   def osh : AMBI<opc, "\tosh"> {
2282     let Inst{7-4} = op7_4;
2283     let Inst{3-0} = 0b0011;
2284   }
2285
2286   def oshst : AMBI<opc, "\toshst"> {
2287     let Inst{7-4} = op7_4;
2288     let Inst{3-0} = 0b0010;
2289   }
2290 }
2291
2292 // These DMB variants are for disassembly only.
2293 defm DMB : MemB<0b0101, "dmb">;
2294
2295 // These DSB variants are for disassembly only.
2296 defm DSB : MemB<0b0100, "dsb">;
2297
2298 // ISB has only full system option -- for disassembly only
2299 def ISBsy : AMBI<"isb", ""> {
2300   let Inst{7-4} = 0b0110;
2301   let Inst{3-0} = 0b1111;
2302 }
2303
2304 let usesCustomInserter = 1 in {
2305   let Uses = [CPSR] in {
2306     def ATOMIC_LOAD_ADD_I8 : PseudoInst<
2307       (outs GPR:$dst), (ins GPR:$ptr, GPR:$incr), NoItinerary,
2308       "${:comment} ATOMIC_LOAD_ADD_I8 PSEUDO!",
2309       [(set GPR:$dst, (atomic_load_add_8 GPR:$ptr, GPR:$incr))]>;
2310     def ATOMIC_LOAD_SUB_I8 : PseudoInst<
2311       (outs GPR:$dst), (ins GPR:$ptr, GPR:$incr), NoItinerary,
2312       "${:comment} ATOMIC_LOAD_SUB_I8 PSEUDO!",
2313       [(set GPR:$dst, (atomic_load_sub_8 GPR:$ptr, GPR:$incr))]>;
2314     def ATOMIC_LOAD_AND_I8 : PseudoInst<
2315       (outs GPR:$dst), (ins GPR:$ptr, GPR:$incr), NoItinerary,
2316       "${:comment} ATOMIC_LOAD_AND_I8 PSEUDO!",
2317       [(set GPR:$dst, (atomic_load_and_8 GPR:$ptr, GPR:$incr))]>;
2318     def ATOMIC_LOAD_OR_I8 : PseudoInst<
2319       (outs GPR:$dst), (ins GPR:$ptr, GPR:$incr), NoItinerary,
2320       "${:comment} ATOMIC_LOAD_OR_I8 PSEUDO!",
2321       [(set GPR:$dst, (atomic_load_or_8 GPR:$ptr, GPR:$incr))]>;
2322     def ATOMIC_LOAD_XOR_I8 : PseudoInst<
2323       (outs GPR:$dst), (ins GPR:$ptr, GPR:$incr), NoItinerary,
2324       "${:comment} ATOMIC_LOAD_XOR_I8 PSEUDO!",
2325       [(set GPR:$dst, (atomic_load_xor_8 GPR:$ptr, GPR:$incr))]>;
2326     def ATOMIC_LOAD_NAND_I8 : PseudoInst<
2327       (outs GPR:$dst), (ins GPR:$ptr, GPR:$incr), NoItinerary,
2328       "${:comment} ATOMIC_LOAD_NAND_I8 PSEUDO!",
2329       [(set GPR:$dst, (atomic_load_nand_8 GPR:$ptr, GPR:$incr))]>;
2330     def ATOMIC_LOAD_ADD_I16 : PseudoInst<
2331       (outs GPR:$dst), (ins GPR:$ptr, GPR:$incr), NoItinerary,
2332       "${:comment} ATOMIC_LOAD_ADD_I16 PSEUDO!",
2333       [(set GPR:$dst, (atomic_load_add_16 GPR:$ptr, GPR:$incr))]>;
2334     def ATOMIC_LOAD_SUB_I16 : PseudoInst<
2335       (outs GPR:$dst), (ins GPR:$ptr, GPR:$incr), NoItinerary,
2336       "${:comment} ATOMIC_LOAD_SUB_I16 PSEUDO!",
2337       [(set GPR:$dst, (atomic_load_sub_16 GPR:$ptr, GPR:$incr))]>;
2338     def ATOMIC_LOAD_AND_I16 : PseudoInst<
2339       (outs GPR:$dst), (ins GPR:$ptr, GPR:$incr), NoItinerary,
2340       "${:comment} ATOMIC_LOAD_AND_I16 PSEUDO!",
2341       [(set GPR:$dst, (atomic_load_and_16 GPR:$ptr, GPR:$incr))]>;
2342     def ATOMIC_LOAD_OR_I16 : PseudoInst<
2343       (outs GPR:$dst), (ins GPR:$ptr, GPR:$incr), NoItinerary,
2344       "${:comment} ATOMIC_LOAD_OR_I16 PSEUDO!",
2345       [(set GPR:$dst, (atomic_load_or_16 GPR:$ptr, GPR:$incr))]>;
2346     def ATOMIC_LOAD_XOR_I16 : PseudoInst<
2347       (outs GPR:$dst), (ins GPR:$ptr, GPR:$incr), NoItinerary,
2348       "${:comment} ATOMIC_LOAD_XOR_I16 PSEUDO!",
2349       [(set GPR:$dst, (atomic_load_xor_16 GPR:$ptr, GPR:$incr))]>;
2350     def ATOMIC_LOAD_NAND_I16 : PseudoInst<
2351       (outs GPR:$dst), (ins GPR:$ptr, GPR:$incr), NoItinerary,
2352       "${:comment} ATOMIC_LOAD_NAND_I16 PSEUDO!",
2353       [(set GPR:$dst, (atomic_load_nand_16 GPR:$ptr, GPR:$incr))]>;
2354     def ATOMIC_LOAD_ADD_I32 : PseudoInst<
2355       (outs GPR:$dst), (ins GPR:$ptr, GPR:$incr), NoItinerary,
2356       "${:comment} ATOMIC_LOAD_ADD_I32 PSEUDO!",
2357       [(set GPR:$dst, (atomic_load_add_32 GPR:$ptr, GPR:$incr))]>;
2358     def ATOMIC_LOAD_SUB_I32 : PseudoInst<
2359       (outs GPR:$dst), (ins GPR:$ptr, GPR:$incr), NoItinerary,
2360       "${:comment} ATOMIC_LOAD_SUB_I32 PSEUDO!",
2361       [(set GPR:$dst, (atomic_load_sub_32 GPR:$ptr, GPR:$incr))]>;
2362     def ATOMIC_LOAD_AND_I32 : PseudoInst<
2363       (outs GPR:$dst), (ins GPR:$ptr, GPR:$incr), NoItinerary,
2364       "${:comment} ATOMIC_LOAD_AND_I32 PSEUDO!",
2365       [(set GPR:$dst, (atomic_load_and_32 GPR:$ptr, GPR:$incr))]>;
2366     def ATOMIC_LOAD_OR_I32 : PseudoInst<
2367       (outs GPR:$dst), (ins GPR:$ptr, GPR:$incr), NoItinerary,
2368       "${:comment} ATOMIC_LOAD_OR_I32 PSEUDO!",
2369       [(set GPR:$dst, (atomic_load_or_32 GPR:$ptr, GPR:$incr))]>;
2370     def ATOMIC_LOAD_XOR_I32 : PseudoInst<
2371       (outs GPR:$dst), (ins GPR:$ptr, GPR:$incr), NoItinerary,
2372       "${:comment} ATOMIC_LOAD_XOR_I32 PSEUDO!",
2373       [(set GPR:$dst, (atomic_load_xor_32 GPR:$ptr, GPR:$incr))]>;
2374     def ATOMIC_LOAD_NAND_I32 : PseudoInst<
2375       (outs GPR:$dst), (ins GPR:$ptr, GPR:$incr), NoItinerary,
2376       "${:comment} ATOMIC_LOAD_NAND_I32 PSEUDO!",
2377       [(set GPR:$dst, (atomic_load_nand_32 GPR:$ptr, GPR:$incr))]>;
2378
2379     def ATOMIC_SWAP_I8 : PseudoInst<
2380       (outs GPR:$dst), (ins GPR:$ptr, GPR:$new), NoItinerary,
2381       "${:comment} ATOMIC_SWAP_I8 PSEUDO!",
2382       [(set GPR:$dst, (atomic_swap_8 GPR:$ptr, GPR:$new))]>;
2383     def ATOMIC_SWAP_I16 : PseudoInst<
2384       (outs GPR:$dst), (ins GPR:$ptr, GPR:$new), NoItinerary,
2385       "${:comment} ATOMIC_SWAP_I16 PSEUDO!",
2386       [(set GPR:$dst, (atomic_swap_16 GPR:$ptr, GPR:$new))]>;
2387     def ATOMIC_SWAP_I32 : PseudoInst<
2388       (outs GPR:$dst), (ins GPR:$ptr, GPR:$new), NoItinerary,
2389       "${:comment} ATOMIC_SWAP_I32 PSEUDO!",
2390       [(set GPR:$dst, (atomic_swap_32 GPR:$ptr, GPR:$new))]>;
2391
2392     def ATOMIC_CMP_SWAP_I8 : PseudoInst<
2393       (outs GPR:$dst), (ins GPR:$ptr, GPR:$old, GPR:$new), NoItinerary,
2394       "${:comment} ATOMIC_CMP_SWAP_I8 PSEUDO!",
2395       [(set GPR:$dst, (atomic_cmp_swap_8 GPR:$ptr, GPR:$old, GPR:$new))]>;
2396     def ATOMIC_CMP_SWAP_I16 : PseudoInst<
2397       (outs GPR:$dst), (ins GPR:$ptr, GPR:$old, GPR:$new), NoItinerary,
2398       "${:comment} ATOMIC_CMP_SWAP_I16 PSEUDO!",
2399       [(set GPR:$dst, (atomic_cmp_swap_16 GPR:$ptr, GPR:$old, GPR:$new))]>;
2400     def ATOMIC_CMP_SWAP_I32 : PseudoInst<
2401       (outs GPR:$dst), (ins GPR:$ptr, GPR:$old, GPR:$new), NoItinerary,
2402       "${:comment} ATOMIC_CMP_SWAP_I32 PSEUDO!",
2403       [(set GPR:$dst, (atomic_cmp_swap_32 GPR:$ptr, GPR:$old, GPR:$new))]>;
2404 }
2405 }
2406
2407 let mayLoad = 1 in {
2408 def LDREXB : AIldrex<0b10, (outs GPR:$dest), (ins GPR:$ptr), NoItinerary,
2409                     "ldrexb", "\t$dest, [$ptr]",
2410                     []>;
2411 def LDREXH : AIldrex<0b11, (outs GPR:$dest), (ins GPR:$ptr), NoItinerary,
2412                     "ldrexh", "\t$dest, [$ptr]",
2413                     []>;
2414 def LDREX  : AIldrex<0b00, (outs GPR:$dest), (ins GPR:$ptr), NoItinerary,
2415                     "ldrex", "\t$dest, [$ptr]",
2416                     []>;
2417 def LDREXD : AIldrex<0b01, (outs GPR:$dest, GPR:$dest2), (ins GPR:$ptr),
2418                     NoItinerary,
2419                     "ldrexd", "\t$dest, $dest2, [$ptr]",
2420                     []>;
2421 }
2422
2423 let mayStore = 1, Constraints = "@earlyclobber $success" in {
2424 def STREXB : AIstrex<0b10, (outs GPR:$success), (ins GPR:$src, GPR:$ptr),
2425                     NoItinerary,
2426                     "strexb", "\t$success, $src, [$ptr]",
2427                     []>;
2428 def STREXH : AIstrex<0b11, (outs GPR:$success), (ins GPR:$src, GPR:$ptr),
2429                     NoItinerary,
2430                     "strexh", "\t$success, $src, [$ptr]",
2431                     []>;
2432 def STREX  : AIstrex<0b00, (outs GPR:$success), (ins GPR:$src, GPR:$ptr),
2433                     NoItinerary,
2434                     "strex", "\t$success, $src, [$ptr]",
2435                     []>;
2436 def STREXD : AIstrex<0b01, (outs GPR:$success),
2437                     (ins GPR:$src, GPR:$src2, GPR:$ptr),
2438                     NoItinerary,
2439                     "strexd", "\t$success, $src, $src2, [$ptr]",
2440                     []>;
2441 }
2442
2443 // Clear-Exclusive is for disassembly only.
2444 def CLREX : AXI<(outs), (ins), MiscFrm, NoItinerary, "clrex",
2445                 [/* For disassembly only; pattern left blank */]>,
2446             Requires<[IsARM, HasV7]>  {
2447   let Inst{31-20} = 0xf57;
2448   let Inst{7-4} = 0b0001;
2449 }
2450
2451 // SWP/SWPB are deprecated in V6/V7 and for disassembly only.
2452 let mayLoad = 1 in {
2453 def SWP : AI<(outs GPR:$dst), (ins GPR:$src, GPR:$ptr), LdStExFrm, NoItinerary,
2454              "swp", "\t$dst, $src, [$ptr]",
2455              [/* For disassembly only; pattern left blank */]> {
2456   let Inst{27-23} = 0b00010;
2457   let Inst{22} = 0; // B = 0
2458   let Inst{21-20} = 0b00;
2459   let Inst{7-4} = 0b1001;
2460 }
2461
2462 def SWPB : AI<(outs GPR:$dst), (ins GPR:$src, GPR:$ptr), LdStExFrm, NoItinerary,
2463              "swpb", "\t$dst, $src, [$ptr]",
2464              [/* For disassembly only; pattern left blank */]> {
2465   let Inst{27-23} = 0b00010;
2466   let Inst{22} = 1; // B = 1
2467   let Inst{21-20} = 0b00;
2468   let Inst{7-4} = 0b1001;
2469 }
2470 }
2471
2472 //===----------------------------------------------------------------------===//
2473 // TLS Instructions
2474 //
2475
2476 // __aeabi_read_tp preserves the registers r1-r3.
2477 let isCall = 1,
2478   Defs = [R0, R12, LR, CPSR] in {
2479   def TPsoft : ABXI<0b1011, (outs), (ins), IIC_Br,
2480                "bl\t__aeabi_read_tp",
2481                [(set R0, ARMthread_pointer)]>;
2482 }
2483
2484 //===----------------------------------------------------------------------===//
2485 // SJLJ Exception handling intrinsics
2486 //   eh_sjlj_setjmp() is an instruction sequence to store the return
2487 //   address and save #0 in R0 for the non-longjmp case.
2488 //   Since by its nature we may be coming from some other function to get
2489 //   here, and we're using the stack frame for the containing function to
2490 //   save/restore registers, we can't keep anything live in regs across
2491 //   the eh_sjlj_setjmp(), else it will almost certainly have been tromped upon
2492 //   when we get here from a longjmp(). We force everthing out of registers
2493 //   except for our own input by listing the relevant registers in Defs. By
2494 //   doing so, we also cause the prologue/epilogue code to actively preserve
2495 //   all of the callee-saved resgisters, which is exactly what we want.
2496 //   A constant value is passed in $val, and we use the location as a scratch.
2497 let Defs =
2498   [ R0,  R1,  R2,  R3,  R4,  R5,  R6,  R7,  R8,  R9,  R10, R11, R12, LR,  D0,
2499     D1,  D2,  D3,  D4,  D5,  D6,  D7,  D8,  D9,  D10, D11, D12, D13, D14, D15,
2500     D16, D17, D18, D19, D20, D21, D22, D23, D24, D25, D26, D27, D28, D29, D30,
2501     D31 ] in {
2502   def Int_eh_sjlj_setjmp : XI<(outs), (ins GPR:$src, GPR:$val),
2503                                AddrModeNone, SizeSpecial, IndexModeNone,
2504                                Pseudo, NoItinerary,
2505                                "str\tsp, [$src, #+8] @ eh_setjmp begin\n\t"
2506                                "add\t$val, pc, #8\n\t"
2507                                "str\t$val, [$src, #+4]\n\t"
2508                                "mov\tr0, #0\n\t"
2509                                "add\tpc, pc, #0\n\t"
2510                                "mov\tr0, #1 @ eh_setjmp end", "",
2511                          [(set R0, (ARMeh_sjlj_setjmp GPR:$src, GPR:$val))]>;
2512 }
2513
2514 //===----------------------------------------------------------------------===//
2515 // Non-Instruction Patterns
2516 //
2517
2518 // Large immediate handling.
2519
2520 // Two piece so_imms.
2521 let isReMaterializable = 1 in
2522 def MOVi2pieces : AI1x2<(outs GPR:$dst), (ins so_imm2part:$src),
2523                          Pseudo, IIC_iMOVi,
2524                          "mov", "\t$dst, $src",
2525                          [(set GPR:$dst, so_imm2part:$src)]>,
2526                   Requires<[IsARM, NoV6T2]>;
2527
2528 def : ARMPat<(or GPR:$LHS, so_imm2part:$RHS),
2529              (ORRri (ORRri GPR:$LHS, (so_imm2part_1 imm:$RHS)),
2530                     (so_imm2part_2 imm:$RHS))>;
2531 def : ARMPat<(xor GPR:$LHS, so_imm2part:$RHS),
2532              (EORri (EORri GPR:$LHS, (so_imm2part_1 imm:$RHS)),
2533                     (so_imm2part_2 imm:$RHS))>;
2534 def : ARMPat<(add GPR:$LHS, so_imm2part:$RHS),
2535              (ADDri (ADDri GPR:$LHS, (so_imm2part_1 imm:$RHS)),
2536                     (so_imm2part_2 imm:$RHS))>;
2537 def : ARMPat<(add GPR:$LHS, so_neg_imm2part:$RHS),
2538              (SUBri (SUBri GPR:$LHS, (so_neg_imm2part_1 imm:$RHS)),
2539                     (so_neg_imm2part_2 imm:$RHS))>;
2540
2541 // 32-bit immediate using movw + movt.
2542 // This is a single pseudo instruction, the benefit is that it can be remat'd
2543 // as a single unit instead of having to handle reg inputs.
2544 // FIXME: Remove this when we can do generalized remat.
2545 let isReMaterializable = 1 in
2546 def MOVi32imm : AI1x2<(outs GPR:$dst), (ins i32imm:$src), Pseudo, IIC_iMOVi,
2547                    "movw", "\t$dst, ${src:lo16}\n\tmovt${p}\t$dst, ${src:hi16}",
2548                      [(set GPR:$dst, (i32 imm:$src))]>,
2549                Requires<[IsARM, HasV6T2]>;
2550
2551 // ConstantPool, GlobalAddress, and JumpTable
2552 def : ARMPat<(ARMWrapper  tglobaladdr :$dst), (LEApcrel tglobaladdr :$dst)>,
2553             Requires<[IsARM, DontUseMovt]>;
2554 def : ARMPat<(ARMWrapper  tconstpool  :$dst), (LEApcrel tconstpool  :$dst)>;
2555 def : ARMPat<(ARMWrapper  tglobaladdr :$dst), (MOVi32imm tglobaladdr :$dst)>,
2556             Requires<[IsARM, UseMovt]>;
2557 def : ARMPat<(ARMWrapperJT tjumptable:$dst, imm:$id),
2558              (LEApcrelJT tjumptable:$dst, imm:$id)>;
2559
2560 // TODO: add,sub,and, 3-instr forms?
2561
2562
2563 // Direct calls
2564 def : ARMPat<(ARMcall texternalsym:$func), (BL texternalsym:$func)>,
2565       Requires<[IsARM, IsNotDarwin]>;
2566 def : ARMPat<(ARMcall texternalsym:$func), (BLr9 texternalsym:$func)>,
2567       Requires<[IsARM, IsDarwin]>;
2568
2569 // zextload i1 -> zextload i8
2570 def : ARMPat<(zextloadi1 addrmode2:$addr),  (LDRB addrmode2:$addr)>;
2571
2572 // extload -> zextload
2573 def : ARMPat<(extloadi1  addrmode2:$addr),  (LDRB addrmode2:$addr)>;
2574 def : ARMPat<(extloadi8  addrmode2:$addr),  (LDRB addrmode2:$addr)>;
2575 def : ARMPat<(extloadi16 addrmode3:$addr),  (LDRH addrmode3:$addr)>;
2576
2577 def : ARMPat<(extloadi8  addrmodepc:$addr), (PICLDRB addrmodepc:$addr)>;
2578 def : ARMPat<(extloadi16 addrmodepc:$addr), (PICLDRH addrmodepc:$addr)>;
2579
2580 // smul* and smla*
2581 def : ARMV5TEPat<(mul (sra (shl GPR:$a, (i32 16)), (i32 16)),
2582                       (sra (shl GPR:$b, (i32 16)), (i32 16))),
2583                  (SMULBB GPR:$a, GPR:$b)>;
2584 def : ARMV5TEPat<(mul sext_16_node:$a, sext_16_node:$b),
2585                  (SMULBB GPR:$a, GPR:$b)>;
2586 def : ARMV5TEPat<(mul (sra (shl GPR:$a, (i32 16)), (i32 16)),
2587                       (sra GPR:$b, (i32 16))),
2588                  (SMULBT GPR:$a, GPR:$b)>;
2589 def : ARMV5TEPat<(mul sext_16_node:$a, (sra GPR:$b, (i32 16))),
2590                  (SMULBT GPR:$a, GPR:$b)>;
2591 def : ARMV5TEPat<(mul (sra GPR:$a, (i32 16)),
2592                       (sra (shl GPR:$b, (i32 16)), (i32 16))),
2593                  (SMULTB GPR:$a, GPR:$b)>;
2594 def : ARMV5TEPat<(mul (sra GPR:$a, (i32 16)), sext_16_node:$b),
2595                 (SMULTB GPR:$a, GPR:$b)>;
2596 def : ARMV5TEPat<(sra (mul GPR:$a, (sra (shl GPR:$b, (i32 16)), (i32 16))),
2597                       (i32 16)),
2598                  (SMULWB GPR:$a, GPR:$b)>;
2599 def : ARMV5TEPat<(sra (mul GPR:$a, sext_16_node:$b), (i32 16)),
2600                  (SMULWB GPR:$a, GPR:$b)>;
2601
2602 def : ARMV5TEPat<(add GPR:$acc,
2603                       (mul (sra (shl GPR:$a, (i32 16)), (i32 16)),
2604                            (sra (shl GPR:$b, (i32 16)), (i32 16)))),
2605                  (SMLABB GPR:$a, GPR:$b, GPR:$acc)>;
2606 def : ARMV5TEPat<(add GPR:$acc,
2607                       (mul sext_16_node:$a, sext_16_node:$b)),
2608                  (SMLABB GPR:$a, GPR:$b, GPR:$acc)>;
2609 def : ARMV5TEPat<(add GPR:$acc,
2610                       (mul (sra (shl GPR:$a, (i32 16)), (i32 16)),
2611                            (sra GPR:$b, (i32 16)))),
2612                  (SMLABT GPR:$a, GPR:$b, GPR:$acc)>;
2613 def : ARMV5TEPat<(add GPR:$acc,
2614                       (mul sext_16_node:$a, (sra GPR:$b, (i32 16)))),
2615                  (SMLABT GPR:$a, GPR:$b, GPR:$acc)>;
2616 def : ARMV5TEPat<(add GPR:$acc,
2617                       (mul (sra GPR:$a, (i32 16)),
2618                            (sra (shl GPR:$b, (i32 16)), (i32 16)))),
2619                  (SMLATB GPR:$a, GPR:$b, GPR:$acc)>;
2620 def : ARMV5TEPat<(add GPR:$acc,
2621                       (mul (sra GPR:$a, (i32 16)), sext_16_node:$b)),
2622                  (SMLATB GPR:$a, GPR:$b, GPR:$acc)>;
2623 def : ARMV5TEPat<(add GPR:$acc,
2624                       (sra (mul GPR:$a, (sra (shl GPR:$b, (i32 16)), (i32 16))),
2625                            (i32 16))),
2626                  (SMLAWB GPR:$a, GPR:$b, GPR:$acc)>;
2627 def : ARMV5TEPat<(add GPR:$acc,
2628                       (sra (mul GPR:$a, sext_16_node:$b), (i32 16))),
2629                  (SMLAWB GPR:$a, GPR:$b, GPR:$acc)>;
2630
2631 //===----------------------------------------------------------------------===//
2632 // Thumb Support
2633 //
2634
2635 include "ARMInstrThumb.td"
2636
2637 //===----------------------------------------------------------------------===//
2638 // Thumb2 Support
2639 //
2640
2641 include "ARMInstrThumb2.td"
2642
2643 //===----------------------------------------------------------------------===//
2644 // Floating Point Support
2645 //
2646
2647 include "ARMInstrVFP.td"
2648
2649 //===----------------------------------------------------------------------===//
2650 // Advanced SIMD (NEON) Support
2651 //
2652
2653 include "ARMInstrNEON.td"
2654
2655 //===----------------------------------------------------------------------===//
2656 // Coprocessor Instructions.  For disassembly only.
2657 //
2658
2659 def CDP : ABI<0b1110, (outs), (ins nohash_imm:$cop, i32imm:$opc1,
2660             nohash_imm:$CRd, nohash_imm:$CRn, nohash_imm:$CRm, i32imm:$opc2),
2661             NoItinerary, "cdp", "\tp$cop, $opc1, cr$CRd, cr$CRn, cr$CRm, $opc2",
2662               [/* For disassembly only; pattern left blank */]> {
2663   let Inst{4} = 0;
2664 }
2665
2666 def CDP2 : ABXI<0b1110, (outs), (ins nohash_imm:$cop, i32imm:$opc1,
2667                nohash_imm:$CRd, nohash_imm:$CRn, nohash_imm:$CRm, i32imm:$opc2),
2668                NoItinerary, "cdp2\tp$cop, $opc1, cr$CRd, cr$CRn, cr$CRm, $opc2",
2669                [/* For disassembly only; pattern left blank */]> {
2670   let Inst{31-28} = 0b1111;
2671   let Inst{4} = 0;
2672 }
2673
2674 class ACI<dag oops, dag iops, string opc, string asm>
2675   : I<oops, iops, AddrModeNone, Size4Bytes, IndexModeNone, BrFrm, NoItinerary,
2676       opc, asm, "", [/* For disassembly only; pattern left blank */]> {
2677   let Inst{27-25} = 0b110;
2678 }
2679
2680 multiclass LdStCop<bits<4> op31_28, bit load, string opc> {
2681
2682   def _OFFSET : ACI<(outs),
2683       (ins nohash_imm:$cop, nohash_imm:$CRd, addrmode2:$addr),
2684       opc, "\tp$cop, cr$CRd, $addr"> {
2685     let Inst{31-28} = op31_28;
2686     let Inst{24} = 1; // P = 1
2687     let Inst{21} = 0; // W = 0
2688     let Inst{22} = 0; // D = 0
2689     let Inst{20} = load;
2690   }
2691
2692   def _PRE : ACI<(outs),
2693       (ins nohash_imm:$cop, nohash_imm:$CRd, addrmode2:$addr),
2694       opc, "\tp$cop, cr$CRd, $addr!"> {
2695     let Inst{31-28} = op31_28;
2696     let Inst{24} = 1; // P = 1
2697     let Inst{21} = 1; // W = 1
2698     let Inst{22} = 0; // D = 0
2699     let Inst{20} = load;
2700   }
2701
2702   def _POST : ACI<(outs),
2703       (ins nohash_imm:$cop, nohash_imm:$CRd, GPR:$base, am2offset:$offset),
2704       opc, "\tp$cop, cr$CRd, [$base], $offset"> {
2705     let Inst{31-28} = op31_28;
2706     let Inst{24} = 0; // P = 0
2707     let Inst{21} = 1; // W = 1
2708     let Inst{22} = 0; // D = 0
2709     let Inst{20} = load;
2710   }
2711
2712   def _OPTION : ACI<(outs),
2713       (ins nohash_imm:$cop, nohash_imm:$CRd, GPR:$base, i32imm:$option),
2714       opc, "\tp$cop, cr$CRd, [$base], $option"> {
2715     let Inst{31-28} = op31_28;
2716     let Inst{24} = 0; // P = 0
2717     let Inst{23} = 1; // U = 1
2718     let Inst{21} = 0; // W = 0
2719     let Inst{22} = 0; // D = 0
2720     let Inst{20} = load;
2721   }
2722
2723   def L_OFFSET : ACI<(outs),
2724       (ins nohash_imm:$cop, nohash_imm:$CRd, addrmode2:$addr),
2725       opc, "l\tp$cop, cr$CRd, $addr"> {
2726     let Inst{31-28} = op31_28;
2727     let Inst{24} = 1; // P = 1
2728     let Inst{21} = 0; // W = 0
2729     let Inst{22} = 1; // D = 1
2730     let Inst{20} = load;
2731   }
2732
2733   def L_PRE : ACI<(outs),
2734       (ins nohash_imm:$cop, nohash_imm:$CRd, addrmode2:$addr),
2735       opc, "l\tp$cop, cr$CRd, $addr!"> {
2736     let Inst{31-28} = op31_28;
2737     let Inst{24} = 1; // P = 1
2738     let Inst{21} = 1; // W = 1
2739     let Inst{22} = 1; // D = 1
2740     let Inst{20} = load;
2741   }
2742
2743   def L_POST : ACI<(outs),
2744       (ins nohash_imm:$cop, nohash_imm:$CRd, GPR:$base, am2offset:$offset),
2745       opc, "l\tp$cop, cr$CRd, [$base], $offset"> {
2746     let Inst{31-28} = op31_28;
2747     let Inst{24} = 0; // P = 0
2748     let Inst{21} = 1; // W = 1
2749     let Inst{22} = 1; // D = 1
2750     let Inst{20} = load;
2751   }
2752
2753   def L_OPTION : ACI<(outs),
2754       (ins nohash_imm:$cop, nohash_imm:$CRd, GPR:$base, nohash_imm:$option),
2755       opc, "l\tp$cop, cr$CRd, [$base], $option"> {
2756     let Inst{31-28} = op31_28;
2757     let Inst{24} = 0; // P = 0
2758     let Inst{23} = 1; // U = 1
2759     let Inst{21} = 0; // W = 0
2760     let Inst{22} = 1; // D = 1
2761     let Inst{20} = load;
2762   }
2763 }
2764
2765 defm LDC  : LdStCop<{?,?,?,?}, 1, "ldc">;
2766 defm LDC2 : LdStCop<0b1111,    1, "ldc2">;
2767 defm STC  : LdStCop<{?,?,?,?}, 0, "stc">;
2768 defm STC2 : LdStCop<0b1111,    0, "stc2">;
2769
2770 def MCR : ABI<0b1110, (outs), (ins nohash_imm:$cop, i32imm:$opc1,
2771               GPR:$Rt, nohash_imm:$CRn, nohash_imm:$CRm, i32imm:$opc2),
2772               NoItinerary, "mcr", "\tp$cop, $opc1, $Rt, cr$CRn, cr$CRm, $opc2",
2773               [/* For disassembly only; pattern left blank */]> {
2774   let Inst{20} = 0;
2775   let Inst{4} = 1;
2776 }
2777
2778 def MCR2 : ABXI<0b1110, (outs), (ins nohash_imm:$cop, i32imm:$opc1,
2779                 GPR:$Rt, nohash_imm:$CRn, nohash_imm:$CRm, i32imm:$opc2),
2780                 NoItinerary, "mcr2\tp$cop, $opc1, $Rt, cr$CRn, cr$CRm, $opc2",
2781                 [/* For disassembly only; pattern left blank */]> {
2782   let Inst{31-28} = 0b1111;
2783   let Inst{20} = 0;
2784   let Inst{4} = 1;
2785 }
2786
2787 def MRC : ABI<0b1110, (outs), (ins nohash_imm:$cop, i32imm:$opc1,
2788               GPR:$Rt, nohash_imm:$CRn, nohash_imm:$CRm, i32imm:$opc2),
2789               NoItinerary, "mrc", "\tp$cop, $opc1, $Rt, cr$CRn, cr$CRm, $opc2",
2790               [/* For disassembly only; pattern left blank */]> {
2791   let Inst{20} = 1;
2792   let Inst{4} = 1;
2793 }
2794
2795 def MRC2 : ABXI<0b1110, (outs), (ins nohash_imm:$cop, i32imm:$opc1,
2796                 GPR:$Rt, nohash_imm:$CRn, nohash_imm:$CRm, i32imm:$opc2),
2797                 NoItinerary, "mrc2\tp$cop, $opc1, $Rt, cr$CRn, cr$CRm, $opc2",
2798                 [/* For disassembly only; pattern left blank */]> {
2799   let Inst{31-28} = 0b1111;
2800   let Inst{20} = 1;
2801   let Inst{4} = 1;
2802 }
2803
2804 def MCRR : ABI<0b1100, (outs), (ins nohash_imm:$cop, i32imm:$opc,
2805                GPR:$Rt, GPR:$Rt2, nohash_imm:$CRm),
2806                NoItinerary, "mcrr", "\tp$cop, $opc, $Rt, $Rt2, cr$CRm",
2807                [/* For disassembly only; pattern left blank */]> {
2808   let Inst{23-20} = 0b0100;
2809 }
2810
2811 def MCRR2 : ABXI<0b1100, (outs), (ins nohash_imm:$cop, i32imm:$opc,
2812                  GPR:$Rt, GPR:$Rt2, nohash_imm:$CRm),
2813                  NoItinerary, "mcrr2\tp$cop, $opc, $Rt, $Rt2, cr$CRm",
2814                  [/* For disassembly only; pattern left blank */]> {
2815   let Inst{31-28} = 0b1111;
2816   let Inst{23-20} = 0b0100;
2817 }
2818
2819 def MRRC : ABI<0b1100, (outs), (ins nohash_imm:$cop, i32imm:$opc,
2820                GPR:$Rt, GPR:$Rt2, nohash_imm:$CRm),
2821                NoItinerary, "mrrc", "\tp$cop, $opc, $Rt, $Rt2, cr$CRm",
2822                [/* For disassembly only; pattern left blank */]> {
2823   let Inst{23-20} = 0b0101;
2824 }
2825
2826 def MRRC2 : ABXI<0b1100, (outs), (ins nohash_imm:$cop, i32imm:$opc,
2827                  GPR:$Rt, GPR:$Rt2, nohash_imm:$CRm),
2828                  NoItinerary, "mrrc2\tp$cop, $opc, $Rt, $Rt2, cr$CRm",
2829                  [/* For disassembly only; pattern left blank */]> {
2830   let Inst{31-28} = 0b1111;
2831   let Inst{23-20} = 0b0101;
2832 }
2833
2834 //===----------------------------------------------------------------------===//
2835 // Move between special register and ARM core register -- for disassembly only
2836 //
2837
2838 def MRS : ABI<0b0001,(outs GPR:$dst),(ins), NoItinerary, "mrs", "\t$dst, cpsr",
2839               [/* For disassembly only; pattern left blank */]> {
2840   let Inst{23-20} = 0b0000;
2841   let Inst{7-4} = 0b0000;
2842 }
2843
2844 def MRSsys : ABI<0b0001,(outs GPR:$dst),(ins), NoItinerary,"mrs","\t$dst, spsr",
2845               [/* For disassembly only; pattern left blank */]> {
2846   let Inst{23-20} = 0b0100;
2847   let Inst{7-4} = 0b0000;
2848 }
2849
2850 def MSR : ABI<0b0001, (outs), (ins GPR:$src, msr_mask:$mask), NoItinerary,
2851               "msr", "\tcpsr$mask, $src",
2852               [/* For disassembly only; pattern left blank */]> {
2853   let Inst{23-20} = 0b0010;
2854   let Inst{7-4} = 0b0000;
2855 }
2856
2857 def MSRi : ABI<0b0011, (outs), (ins so_imm:$a, msr_mask:$mask), NoItinerary,
2858               "msr", "\tcpsr$mask, $a",
2859               [/* For disassembly only; pattern left blank */]> {
2860   let Inst{23-20} = 0b0010;
2861   let Inst{7-4} = 0b0000;
2862 }
2863
2864 def MSRsys : ABI<0b0001, (outs), (ins GPR:$src, msr_mask:$mask), NoItinerary,
2865               "msr", "\tspsr$mask, $src",
2866               [/* For disassembly only; pattern left blank */]> {
2867   let Inst{23-20} = 0b0110;
2868   let Inst{7-4} = 0b0000;
2869 }
2870
2871 def MSRsysi : ABI<0b0011, (outs), (ins so_imm:$a, msr_mask:$mask), NoItinerary,
2872               "msr", "\tspsr$mask, $a",
2873               [/* For disassembly only; pattern left blank */]> {
2874   let Inst{23-20} = 0b0110;
2875   let Inst{7-4} = 0b0000;
2876 }