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