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 def RSBri : AsI1<0b0011, (outs GPR:$dst), (ins GPR:$a, so_imm:$b), DPFrm,
1633                  IIC_iALUi, "rsb", "\t$dst, $a, $b",
1634                  [(set GPR:$dst, (sub so_imm:$b, GPR:$a))]> {
1635     let Inst{25} = 1;
1636 }
1637
1638 // The reg/reg form is only defined for the disassembler; for codegen it is
1639 // equivalent to SUBrr.
1640 def RSBrr : AsI1<0b0011, (outs GPR:$dst), (ins GPR:$a, GPR:$b), DPFrm,
1641                  IIC_iALUr, "rsb", "\t$dst, $a, $b",
1642                  [/* For disassembly only; pattern left blank */]> {
1643     let Inst{25} = 0;
1644     let Inst{11-4} = 0b00000000;
1645 }
1646
1647 def RSBrs : AsI1<0b0011, (outs GPR:$dst), (ins GPR:$a, so_reg:$b), DPSoRegFrm,
1648                  IIC_iALUsr, "rsb", "\t$dst, $a, $b",
1649                  [(set GPR:$dst, (sub so_reg:$b, GPR:$a))]> {
1650     let Inst{25} = 0;
1651 }
1652
1653 // RSB with 's' bit set.
1654 let Defs = [CPSR] in {
1655 def RSBSri : AI1<0b0011, (outs GPR:$dst), (ins GPR:$a, so_imm:$b), DPFrm,
1656                  IIC_iALUi, "rsbs", "\t$dst, $a, $b",
1657                  [(set GPR:$dst, (subc so_imm:$b, GPR:$a))]> {
1658     let Inst{20} = 1;
1659     let Inst{25} = 1;
1660 }
1661 def RSBSrs : AI1<0b0011, (outs GPR:$dst), (ins GPR:$a, so_reg:$b), DPSoRegFrm,
1662                  IIC_iALUsr, "rsbs", "\t$dst, $a, $b",
1663                  [(set GPR:$dst, (subc so_reg:$b, GPR:$a))]> {
1664     let Inst{20} = 1;
1665     let Inst{25} = 0;
1666 }
1667 }
1668
1669 let Uses = [CPSR] in {
1670 def RSCri : AsI1<0b0111, (outs GPR:$dst), (ins GPR:$a, so_imm:$b),
1671                  DPFrm, IIC_iALUi, "rsc", "\t$dst, $a, $b",
1672                  [(set GPR:$dst, (sube_dead_carry so_imm:$b, GPR:$a))]>,
1673                  Requires<[IsARM]> {
1674     let Inst{25} = 1;
1675 }
1676 // The reg/reg form is only defined for the disassembler; for codegen it is
1677 // equivalent to SUBrr.
1678 def RSCrr : AsI1<0b0111, (outs GPR:$dst), (ins GPR:$a, GPR:$b),
1679                  DPFrm, IIC_iALUr, "rsc", "\t$dst, $a, $b",
1680                  [/* For disassembly only; pattern left blank */]> {
1681     let Inst{25} = 0;
1682     let Inst{11-4} = 0b00000000;
1683 }
1684 def RSCrs : AsI1<0b0111, (outs GPR:$dst), (ins GPR:$a, so_reg:$b),
1685                  DPSoRegFrm, IIC_iALUsr, "rsc", "\t$dst, $a, $b",
1686                  [(set GPR:$dst, (sube_dead_carry so_reg:$b, GPR:$a))]>,
1687                  Requires<[IsARM]> {
1688     let Inst{25} = 0;
1689 }
1690 }
1691
1692 // FIXME: Allow these to be predicated.
1693 let Defs = [CPSR], Uses = [CPSR] in {
1694 def RSCSri : AXI1<0b0111, (outs GPR:$dst), (ins GPR:$a, so_imm:$b),
1695                   DPFrm, IIC_iALUi, "rscs\t$dst, $a, $b",
1696                   [(set GPR:$dst, (sube_dead_carry so_imm:$b, GPR:$a))]>,
1697                   Requires<[IsARM]> {
1698     let Inst{20} = 1;
1699     let Inst{25} = 1;
1700 }
1701 def RSCSrs : AXI1<0b0111, (outs GPR:$dst), (ins GPR:$a, so_reg:$b),
1702                   DPSoRegFrm, IIC_iALUsr, "rscs\t$dst, $a, $b",
1703                   [(set GPR:$dst, (sube_dead_carry so_reg:$b, GPR:$a))]>,
1704                   Requires<[IsARM]> {
1705     let Inst{20} = 1;
1706     let Inst{25} = 0;
1707 }
1708 }
1709
1710 // (sub X, imm) gets canonicalized to (add X, -imm).  Match this form.
1711 // The assume-no-carry-in form uses the negation of the input since add/sub
1712 // assume opposite meanings of the carry flag (i.e., carry == !borrow).
1713 // See the definition of AddWithCarry() in the ARM ARM A2.2.1 for the gory
1714 // details.
1715 def : ARMPat<(add    GPR:$src, so_imm_neg:$imm),
1716              (SUBri  GPR:$src, so_imm_neg:$imm)>;
1717 def : ARMPat<(addc   GPR:$src, so_imm_neg:$imm),
1718              (SUBSri GPR:$src, so_imm_neg:$imm)>;
1719 // The with-carry-in form matches bitwise not instead of the negation.
1720 // Effectively, the inverse interpretation of the carry flag already accounts
1721 // for part of the negation.
1722 def : ARMPat<(adde   GPR:$src, so_imm_not:$imm),
1723              (SBCri  GPR:$src, so_imm_not:$imm)>;
1724
1725 // Note: These are implemented in C++ code, because they have to generate
1726 // ADD/SUBrs instructions, which use a complex pattern that a xform function
1727 // cannot produce.
1728 // (mul X, 2^n+1) -> (add (X << n), X)
1729 // (mul X, 2^n-1) -> (rsb X, (X << n))
1730
1731 // ARM Arithmetic Instruction -- for disassembly only
1732 // GPR:$dst = GPR:$a op GPR:$b
1733 class AAI<bits<8> op27_20, bits<4> op7_4, string opc,
1734           list<dag> pattern = [/* For disassembly only; pattern left blank */]>
1735   : AI<(outs GPR:$dst), (ins GPR:$a, GPR:$b), DPFrm, IIC_iALUr,
1736        opc, "\t$dst, $a, $b", pattern> {
1737   let Inst{27-20} = op27_20;
1738   let Inst{7-4} = op7_4;
1739 }
1740
1741 // Saturating add/subtract -- for disassembly only
1742
1743 def QADD    : AAI<0b00010000, 0b0101, "qadd",
1744                   [(set GPR:$dst, (int_arm_qadd GPR:$a, GPR:$b))]>;
1745 def QADD16  : AAI<0b01100010, 0b0001, "qadd16">;
1746 def QADD8   : AAI<0b01100010, 0b1001, "qadd8">;
1747 def QASX    : AAI<0b01100010, 0b0011, "qasx">;
1748 def QDADD   : AAI<0b00010100, 0b0101, "qdadd">;
1749 def QDSUB   : AAI<0b00010110, 0b0101, "qdsub">;
1750 def QSAX    : AAI<0b01100010, 0b0101, "qsax">;
1751 def QSUB    : AAI<0b00010010, 0b0101, "qsub",
1752                   [(set GPR:$dst, (int_arm_qsub GPR:$a, GPR:$b))]>;
1753 def QSUB16  : AAI<0b01100010, 0b0111, "qsub16">;
1754 def QSUB8   : AAI<0b01100010, 0b1111, "qsub8">;
1755 def UQADD16 : AAI<0b01100110, 0b0001, "uqadd16">;
1756 def UQADD8  : AAI<0b01100110, 0b1001, "uqadd8">;
1757 def UQASX   : AAI<0b01100110, 0b0011, "uqasx">;
1758 def UQSAX   : AAI<0b01100110, 0b0101, "uqsax">;
1759 def UQSUB16 : AAI<0b01100110, 0b0111, "uqsub16">;
1760 def UQSUB8  : AAI<0b01100110, 0b1111, "uqsub8">;
1761
1762 // Signed/Unsigned add/subtract -- for disassembly only
1763
1764 def SASX   : AAI<0b01100001, 0b0011, "sasx">;
1765 def SADD16 : AAI<0b01100001, 0b0001, "sadd16">;
1766 def SADD8  : AAI<0b01100001, 0b1001, "sadd8">;
1767 def SSAX   : AAI<0b01100001, 0b0101, "ssax">;
1768 def SSUB16 : AAI<0b01100001, 0b0111, "ssub16">;
1769 def SSUB8  : AAI<0b01100001, 0b1111, "ssub8">;
1770 def UASX   : AAI<0b01100101, 0b0011, "uasx">;
1771 def UADD16 : AAI<0b01100101, 0b0001, "uadd16">;
1772 def UADD8  : AAI<0b01100101, 0b1001, "uadd8">;
1773 def USAX   : AAI<0b01100101, 0b0101, "usax">;
1774 def USUB16 : AAI<0b01100101, 0b0111, "usub16">;
1775 def USUB8  : AAI<0b01100101, 0b1111, "usub8">;
1776
1777 // Signed/Unsigned halving add/subtract -- for disassembly only
1778
1779 def SHASX   : AAI<0b01100011, 0b0011, "shasx">;
1780 def SHADD16 : AAI<0b01100011, 0b0001, "shadd16">;
1781 def SHADD8  : AAI<0b01100011, 0b1001, "shadd8">;
1782 def SHSAX   : AAI<0b01100011, 0b0101, "shsax">;
1783 def SHSUB16 : AAI<0b01100011, 0b0111, "shsub16">;
1784 def SHSUB8  : AAI<0b01100011, 0b1111, "shsub8">;
1785 def UHASX   : AAI<0b01100111, 0b0011, "uhasx">;
1786 def UHADD16 : AAI<0b01100111, 0b0001, "uhadd16">;
1787 def UHADD8  : AAI<0b01100111, 0b1001, "uhadd8">;
1788 def UHSAX   : AAI<0b01100111, 0b0101, "uhsax">;
1789 def UHSUB16 : AAI<0b01100111, 0b0111, "uhsub16">;
1790 def UHSUB8  : AAI<0b01100111, 0b1111, "uhsub8">;
1791
1792 // Unsigned Sum of Absolute Differences [and Accumulate] -- for disassembly only
1793
1794 def USAD8  : AI<(outs GPR:$dst), (ins GPR:$a, GPR:$b),
1795                 MulFrm /* for convenience */, NoItinerary, "usad8",
1796                 "\t$dst, $a, $b", []>,
1797              Requires<[IsARM, HasV6]> {
1798   let Inst{27-20} = 0b01111000;
1799   let Inst{15-12} = 0b1111;
1800   let Inst{7-4} = 0b0001;
1801 }
1802 def USADA8 : AI<(outs GPR:$dst), (ins GPR:$a, GPR:$b, GPR:$acc),
1803                 MulFrm /* for convenience */, NoItinerary, "usada8",
1804                 "\t$dst, $a, $b, $acc", []>,
1805              Requires<[IsARM, HasV6]> {
1806   let Inst{27-20} = 0b01111000;
1807   let Inst{7-4} = 0b0001;
1808 }
1809
1810 // Signed/Unsigned saturate -- for disassembly only
1811
1812 def SSATlsl : AI<(outs GPR:$dst), (ins i32imm:$bit_pos, GPR:$a, i32imm:$shamt),
1813                  SatFrm, NoItinerary,
1814                  "ssat", "\t$dst, $bit_pos, $a, lsl $shamt",
1815                  [/* For disassembly only; pattern left blank */]> {
1816   let Inst{27-21} = 0b0110101;
1817   let Inst{6-4} = 0b001;
1818 }
1819
1820 def SSATasr : AI<(outs GPR:$dst), (ins i32imm:$bit_pos, GPR:$a, i32imm:$shamt),
1821                  SatFrm, NoItinerary,
1822                  "ssat", "\t$dst, $bit_pos, $a, asr $shamt",
1823                  [/* For disassembly only; pattern left blank */]> {
1824   let Inst{27-21} = 0b0110101;
1825   let Inst{6-4} = 0b101;
1826 }
1827
1828 def SSAT16 : AI<(outs GPR:$dst), (ins i32imm:$bit_pos, GPR:$a), SatFrm,
1829                 NoItinerary, "ssat16", "\t$dst, $bit_pos, $a",
1830                 [/* For disassembly only; pattern left blank */]> {
1831   let Inst{27-20} = 0b01101010;
1832   let Inst{7-4} = 0b0011;
1833 }
1834
1835 def USATlsl : AI<(outs GPR:$dst), (ins i32imm:$bit_pos, GPR:$a, i32imm:$shamt),
1836                  SatFrm, NoItinerary,
1837                  "usat", "\t$dst, $bit_pos, $a, lsl $shamt",
1838                  [/* For disassembly only; pattern left blank */]> {
1839   let Inst{27-21} = 0b0110111;
1840   let Inst{6-4} = 0b001;
1841 }
1842
1843 def USATasr : AI<(outs GPR:$dst), (ins i32imm:$bit_pos, GPR:$a, i32imm:$shamt),
1844                  SatFrm, NoItinerary,
1845                  "usat", "\t$dst, $bit_pos, $a, asr $shamt",
1846                  [/* For disassembly only; pattern left blank */]> {
1847   let Inst{27-21} = 0b0110111;
1848   let Inst{6-4} = 0b101;
1849 }
1850
1851 def USAT16 : AI<(outs GPR:$dst), (ins i32imm:$bit_pos, GPR:$a), SatFrm,
1852                 NoItinerary, "usat16", "\t$dst, $bit_pos, $a",
1853                 [/* For disassembly only; pattern left blank */]> {
1854   let Inst{27-20} = 0b01101110;
1855   let Inst{7-4} = 0b0011;
1856 }
1857
1858 def : ARMV6Pat<(int_arm_ssat GPR:$a, imm:$pos), (SSATlsl imm:$pos, GPR:$a, 0)>;
1859 def : ARMV6Pat<(int_arm_usat GPR:$a, imm:$pos), (USATlsl imm:$pos, GPR:$a, 0)>;
1860
1861 //===----------------------------------------------------------------------===//
1862 //  Bitwise Instructions.
1863 //
1864
1865 defm AND   : AsI1_bin_irs<0b0000, "and",
1866                           BinOpFrag<(and node:$LHS, node:$RHS)>, 1>;
1867 defm ORR   : AsI1_bin_irs<0b1100, "orr",
1868                           BinOpFrag<(or  node:$LHS, node:$RHS)>, 1>;
1869 defm EOR   : AsI1_bin_irs<0b0001, "eor",
1870                           BinOpFrag<(xor node:$LHS, node:$RHS)>, 1>;
1871 defm BIC   : AsI1_bin_irs<0b1110, "bic",
1872                           BinOpFrag<(and node:$LHS, (not node:$RHS))>>;
1873
1874 def BFC    : I<(outs GPR:$dst), (ins GPR:$src, bf_inv_mask_imm:$imm),
1875                AddrMode1, Size4Bytes, IndexModeNone, DPFrm, IIC_iUNAsi,
1876                "bfc", "\t$dst, $imm", "$src = $dst",
1877                [(set GPR:$dst, (and GPR:$src, bf_inv_mask_imm:$imm))]>,
1878                Requires<[IsARM, HasV6T2]> {
1879   let Inst{27-21} = 0b0111110;
1880   let Inst{6-0}   = 0b0011111;
1881 }
1882
1883 // A8.6.18  BFI - Bitfield insert (Encoding A1)
1884 def BFI    : I<(outs GPR:$dst), (ins GPR:$src, GPR:$val, bf_inv_mask_imm:$imm),
1885                AddrMode1, Size4Bytes, IndexModeNone, DPFrm, IIC_iUNAsi,
1886                "bfi", "\t$dst, $val, $imm", "$src = $dst",
1887                [(set GPR:$dst, (ARMbfi GPR:$src, GPR:$val,
1888                                 bf_inv_mask_imm:$imm))]>,
1889                Requires<[IsARM, HasV6T2]> {
1890   let Inst{27-21} = 0b0111110;
1891   let Inst{6-4}   = 0b001; // Rn: Inst{3-0} != 15
1892 }
1893
1894 def  MVNr  : AsI1<0b1111, (outs GPR:$dst), (ins GPR:$src), DPFrm, IIC_iMOVr,
1895                   "mvn", "\t$dst, $src",
1896                   [(set GPR:$dst, (not GPR:$src))]>, UnaryDP {
1897   let Inst{25} = 0;
1898   let Inst{11-4} = 0b00000000;
1899 }
1900 def  MVNs  : AsI1<0b1111, (outs GPR:$dst), (ins so_reg:$src), DPSoRegFrm,
1901                   IIC_iMOVsr, "mvn", "\t$dst, $src",
1902                   [(set GPR:$dst, (not so_reg:$src))]>, UnaryDP {
1903   let Inst{25} = 0;
1904 }
1905 let isReMaterializable = 1, isAsCheapAsAMove = 1 in
1906 def  MVNi  : AsI1<0b1111, (outs GPR:$dst), (ins so_imm:$imm), DPFrm,
1907                   IIC_iMOVi, "mvn", "\t$dst, $imm",
1908                   [(set GPR:$dst, so_imm_not:$imm)]>,UnaryDP {
1909     let Inst{25} = 1;
1910 }
1911
1912 def : ARMPat<(and   GPR:$src, so_imm_not:$imm),
1913              (BICri GPR:$src, so_imm_not:$imm)>;
1914
1915 //===----------------------------------------------------------------------===//
1916 //  Multiply Instructions.
1917 //
1918
1919 let isCommutable = 1 in
1920 def MUL   : AsMul1I<0b0000000, (outs GPR:$dst), (ins GPR:$a, GPR:$b),
1921                    IIC_iMUL32, "mul", "\t$dst, $a, $b",
1922                    [(set GPR:$dst, (mul GPR:$a, GPR:$b))]>;
1923
1924 def MLA   : AsMul1I<0b0000001, (outs GPR:$dst), (ins GPR:$a, GPR:$b, GPR:$c),
1925                     IIC_iMAC32, "mla", "\t$dst, $a, $b, $c",
1926                    [(set GPR:$dst, (add (mul GPR:$a, GPR:$b), GPR:$c))]>;
1927
1928 def MLS   : AMul1I<0b0000011, (outs GPR:$dst), (ins GPR:$a, GPR:$b, GPR:$c),
1929                    IIC_iMAC32, "mls", "\t$dst, $a, $b, $c",
1930                    [(set GPR:$dst, (sub GPR:$c, (mul GPR:$a, GPR:$b)))]>,
1931                    Requires<[IsARM, HasV6T2]>;
1932
1933 // Extra precision multiplies with low / high results
1934 let neverHasSideEffects = 1 in {
1935 let isCommutable = 1 in {
1936 def SMULL : AsMul1I<0b0000110, (outs GPR:$ldst, GPR:$hdst),
1937                                (ins GPR:$a, GPR:$b), IIC_iMUL64,
1938                     "smull", "\t$ldst, $hdst, $a, $b", []>;
1939
1940 def UMULL : AsMul1I<0b0000100, (outs GPR:$ldst, GPR:$hdst),
1941                                (ins GPR:$a, GPR:$b), IIC_iMUL64,
1942                     "umull", "\t$ldst, $hdst, $a, $b", []>;
1943 }
1944
1945 // Multiply + accumulate
1946 def SMLAL : AsMul1I<0b0000111, (outs GPR:$ldst, GPR:$hdst),
1947                                (ins GPR:$a, GPR:$b), IIC_iMAC64,
1948                     "smlal", "\t$ldst, $hdst, $a, $b", []>;
1949
1950 def UMLAL : AsMul1I<0b0000101, (outs GPR:$ldst, GPR:$hdst),
1951                                (ins GPR:$a, GPR:$b), IIC_iMAC64,
1952                     "umlal", "\t$ldst, $hdst, $a, $b", []>;
1953
1954 def UMAAL : AMul1I <0b0000010, (outs GPR:$ldst, GPR:$hdst),
1955                                (ins GPR:$a, GPR:$b), IIC_iMAC64,
1956                     "umaal", "\t$ldst, $hdst, $a, $b", []>,
1957                     Requires<[IsARM, HasV6]>;
1958 } // neverHasSideEffects
1959
1960 // Most significant word multiply
1961 def SMMUL : AMul2I <0b0111010, (outs GPR:$dst), (ins GPR:$a, GPR:$b),
1962                IIC_iMUL32, "smmul", "\t$dst, $a, $b",
1963                [(set GPR:$dst, (mulhs GPR:$a, GPR:$b))]>,
1964             Requires<[IsARM, HasV6]> {
1965   let Inst{7-4}   = 0b0001;
1966   let Inst{15-12} = 0b1111;
1967 }
1968
1969 def SMMULR : AMul2I <0b0111010, (outs GPR:$dst), (ins GPR:$a, GPR:$b),
1970                IIC_iMUL32, "smmulr", "\t$dst, $a, $b",
1971                [/* For disassembly only; pattern left blank */]>,
1972             Requires<[IsARM, HasV6]> {
1973   let Inst{7-4}   = 0b0011; // R = 1
1974   let Inst{15-12} = 0b1111;
1975 }
1976
1977 def SMMLA : AMul2I <0b0111010, (outs GPR:$dst), (ins GPR:$a, GPR:$b, GPR:$c),
1978                IIC_iMAC32, "smmla", "\t$dst, $a, $b, $c",
1979                [(set GPR:$dst, (add (mulhs GPR:$a, GPR:$b), GPR:$c))]>,
1980             Requires<[IsARM, HasV6]> {
1981   let Inst{7-4}   = 0b0001;
1982 }
1983
1984 def SMMLAR : AMul2I <0b0111010, (outs GPR:$dst), (ins GPR:$a, GPR:$b, GPR:$c),
1985                IIC_iMAC32, "smmlar", "\t$dst, $a, $b, $c",
1986                [/* For disassembly only; pattern left blank */]>,
1987             Requires<[IsARM, HasV6]> {
1988   let Inst{7-4}   = 0b0011; // R = 1
1989 }
1990
1991 def SMMLS : AMul2I <0b0111010, (outs GPR:$dst), (ins GPR:$a, GPR:$b, GPR:$c),
1992                IIC_iMAC32, "smmls", "\t$dst, $a, $b, $c",
1993                [(set GPR:$dst, (sub GPR:$c, (mulhs GPR:$a, GPR:$b)))]>,
1994             Requires<[IsARM, HasV6]> {
1995   let Inst{7-4}   = 0b1101;
1996 }
1997
1998 def SMMLSR : AMul2I <0b0111010, (outs GPR:$dst), (ins GPR:$a, GPR:$b, GPR:$c),
1999                IIC_iMAC32, "smmlsr", "\t$dst, $a, $b, $c",
2000                [/* For disassembly only; pattern left blank */]>,
2001             Requires<[IsARM, HasV6]> {
2002   let Inst{7-4}   = 0b1111; // R = 1
2003 }
2004
2005 multiclass AI_smul<string opc, PatFrag opnode> {
2006   def BB : AMulxyI<0b0001011, (outs GPR:$dst), (ins GPR:$a, GPR:$b),
2007               IIC_iMUL32, !strconcat(opc, "bb"), "\t$dst, $a, $b",
2008               [(set GPR:$dst, (opnode (sext_inreg GPR:$a, i16),
2009                                       (sext_inreg GPR:$b, i16)))]>,
2010            Requires<[IsARM, HasV5TE]> {
2011              let Inst{5} = 0;
2012              let Inst{6} = 0;
2013            }
2014
2015   def BT : AMulxyI<0b0001011, (outs GPR:$dst), (ins GPR:$a, GPR:$b),
2016               IIC_iMUL32, !strconcat(opc, "bt"), "\t$dst, $a, $b",
2017               [(set GPR:$dst, (opnode (sext_inreg GPR:$a, i16),
2018                                       (sra GPR:$b, (i32 16))))]>,
2019            Requires<[IsARM, HasV5TE]> {
2020              let Inst{5} = 0;
2021              let Inst{6} = 1;
2022            }
2023
2024   def TB : AMulxyI<0b0001011, (outs GPR:$dst), (ins GPR:$a, GPR:$b),
2025               IIC_iMUL32, !strconcat(opc, "tb"), "\t$dst, $a, $b",
2026               [(set GPR:$dst, (opnode (sra GPR:$a, (i32 16)),
2027                                       (sext_inreg GPR:$b, i16)))]>,
2028            Requires<[IsARM, HasV5TE]> {
2029              let Inst{5} = 1;
2030              let Inst{6} = 0;
2031            }
2032
2033   def TT : AMulxyI<0b0001011, (outs GPR:$dst), (ins GPR:$a, GPR:$b),
2034               IIC_iMUL32, !strconcat(opc, "tt"), "\t$dst, $a, $b",
2035               [(set GPR:$dst, (opnode (sra GPR:$a, (i32 16)),
2036                                       (sra GPR:$b, (i32 16))))]>,
2037             Requires<[IsARM, HasV5TE]> {
2038              let Inst{5} = 1;
2039              let Inst{6} = 1;
2040            }
2041
2042   def WB : AMulxyI<0b0001001, (outs GPR:$dst), (ins GPR:$a, GPR:$b),
2043               IIC_iMUL16, !strconcat(opc, "wb"), "\t$dst, $a, $b",
2044               [(set GPR:$dst, (sra (opnode GPR:$a,
2045                                     (sext_inreg GPR:$b, i16)), (i32 16)))]>,
2046            Requires<[IsARM, HasV5TE]> {
2047              let Inst{5} = 1;
2048              let Inst{6} = 0;
2049            }
2050
2051   def WT : AMulxyI<0b0001001, (outs GPR:$dst), (ins GPR:$a, GPR:$b),
2052               IIC_iMUL16, !strconcat(opc, "wt"), "\t$dst, $a, $b",
2053               [(set GPR:$dst, (sra (opnode GPR:$a,
2054                                     (sra GPR:$b, (i32 16))), (i32 16)))]>,
2055             Requires<[IsARM, HasV5TE]> {
2056              let Inst{5} = 1;
2057              let Inst{6} = 1;
2058            }
2059 }
2060
2061
2062 multiclass AI_smla<string opc, PatFrag opnode> {
2063   def BB : AMulxyI<0b0001000, (outs GPR:$dst), (ins GPR:$a, GPR:$b, GPR:$acc),
2064               IIC_iMAC16, !strconcat(opc, "bb"), "\t$dst, $a, $b, $acc",
2065               [(set GPR:$dst, (add GPR:$acc,
2066                                (opnode (sext_inreg GPR:$a, i16),
2067                                        (sext_inreg GPR:$b, i16))))]>,
2068            Requires<[IsARM, HasV5TE]> {
2069              let Inst{5} = 0;
2070              let Inst{6} = 0;
2071            }
2072
2073   def BT : AMulxyI<0b0001000, (outs GPR:$dst), (ins GPR:$a, GPR:$b, GPR:$acc),
2074               IIC_iMAC16, !strconcat(opc, "bt"), "\t$dst, $a, $b, $acc",
2075               [(set GPR:$dst, (add GPR:$acc, (opnode (sext_inreg GPR:$a, i16),
2076                                                     (sra GPR:$b, (i32 16)))))]>,
2077            Requires<[IsARM, HasV5TE]> {
2078              let Inst{5} = 0;
2079              let Inst{6} = 1;
2080            }
2081
2082   def TB : AMulxyI<0b0001000, (outs GPR:$dst), (ins GPR:$a, GPR:$b, GPR:$acc),
2083               IIC_iMAC16, !strconcat(opc, "tb"), "\t$dst, $a, $b, $acc",
2084               [(set GPR:$dst, (add GPR:$acc, (opnode (sra GPR:$a, (i32 16)),
2085                                                  (sext_inreg GPR:$b, i16))))]>,
2086            Requires<[IsARM, HasV5TE]> {
2087              let Inst{5} = 1;
2088              let Inst{6} = 0;
2089            }
2090
2091   def TT : AMulxyI<0b0001000, (outs GPR:$dst), (ins GPR:$a, GPR:$b, GPR:$acc),
2092               IIC_iMAC16, !strconcat(opc, "tt"), "\t$dst, $a, $b, $acc",
2093              [(set GPR:$dst, (add GPR:$acc, (opnode (sra GPR:$a, (i32 16)),
2094                                                     (sra GPR:$b, (i32 16)))))]>,
2095             Requires<[IsARM, HasV5TE]> {
2096              let Inst{5} = 1;
2097              let Inst{6} = 1;
2098            }
2099
2100   def WB : AMulxyI<0b0001001, (outs GPR:$dst), (ins GPR:$a, GPR:$b, GPR:$acc),
2101               IIC_iMAC16, !strconcat(opc, "wb"), "\t$dst, $a, $b, $acc",
2102               [(set GPR:$dst, (add GPR:$acc, (sra (opnode GPR:$a,
2103                                        (sext_inreg GPR:$b, i16)), (i32 16))))]>,
2104            Requires<[IsARM, HasV5TE]> {
2105              let Inst{5} = 0;
2106              let Inst{6} = 0;
2107            }
2108
2109   def WT : AMulxyI<0b0001001, (outs GPR:$dst), (ins GPR:$a, GPR:$b, GPR:$acc),
2110               IIC_iMAC16, !strconcat(opc, "wt"), "\t$dst, $a, $b, $acc",
2111               [(set GPR:$dst, (add GPR:$acc, (sra (opnode GPR:$a,
2112                                          (sra GPR:$b, (i32 16))), (i32 16))))]>,
2113             Requires<[IsARM, HasV5TE]> {
2114              let Inst{5} = 0;
2115              let Inst{6} = 1;
2116            }
2117 }
2118
2119 defm SMUL : AI_smul<"smul", BinOpFrag<(mul node:$LHS, node:$RHS)>>;
2120 defm SMLA : AI_smla<"smla", BinOpFrag<(mul node:$LHS, node:$RHS)>>;
2121
2122 // Halfword multiply accumulate long: SMLAL<x><y> -- for disassembly only
2123 def SMLALBB : AMulxyI<0b0001010,(outs GPR:$ldst,GPR:$hdst),(ins GPR:$a,GPR:$b),
2124                       IIC_iMAC64, "smlalbb", "\t$ldst, $hdst, $a, $b",
2125                       [/* For disassembly only; pattern left blank */]>,
2126               Requires<[IsARM, HasV5TE]> {
2127   let Inst{5} = 0;
2128   let Inst{6} = 0;
2129 }
2130
2131 def SMLALBT : AMulxyI<0b0001010,(outs GPR:$ldst,GPR:$hdst),(ins GPR:$a,GPR:$b),
2132                       IIC_iMAC64, "smlalbt", "\t$ldst, $hdst, $a, $b",
2133                       [/* For disassembly only; pattern left blank */]>,
2134               Requires<[IsARM, HasV5TE]> {
2135   let Inst{5} = 0;
2136   let Inst{6} = 1;
2137 }
2138
2139 def SMLALTB : AMulxyI<0b0001010,(outs GPR:$ldst,GPR:$hdst),(ins GPR:$a,GPR:$b),
2140                       IIC_iMAC64, "smlaltb", "\t$ldst, $hdst, $a, $b",
2141                       [/* For disassembly only; pattern left blank */]>,
2142               Requires<[IsARM, HasV5TE]> {
2143   let Inst{5} = 1;
2144   let Inst{6} = 0;
2145 }
2146
2147 def SMLALTT : AMulxyI<0b0001010,(outs GPR:$ldst,GPR:$hdst),(ins GPR:$a,GPR:$b),
2148                       IIC_iMAC64, "smlaltt", "\t$ldst, $hdst, $a, $b",
2149                       [/* For disassembly only; pattern left blank */]>,
2150               Requires<[IsARM, HasV5TE]> {
2151   let Inst{5} = 1;
2152   let Inst{6} = 1;
2153 }
2154
2155 // Helper class for AI_smld -- for disassembly only
2156 class AMulDualI<bit long, bit sub, bit swap, dag oops, dag iops,
2157                 InstrItinClass itin, string opc, string asm>
2158   : AI<oops, iops, MulFrm, itin, opc, asm, []>, Requires<[IsARM, HasV6]> {
2159   let Inst{4}     = 1;
2160   let Inst{5}     = swap;
2161   let Inst{6}     = sub;
2162   let Inst{7}     = 0;
2163   let Inst{21-20} = 0b00;
2164   let Inst{22}    = long;
2165   let Inst{27-23} = 0b01110;
2166 }
2167
2168 multiclass AI_smld<bit sub, string opc> {
2169
2170   def D : AMulDualI<0, sub, 0, (outs GPR:$dst), (ins GPR:$a, GPR:$b, GPR:$acc),
2171                   NoItinerary, !strconcat(opc, "d"), "\t$dst, $a, $b, $acc">;
2172
2173   def DX : AMulDualI<0, sub, 1, (outs GPR:$dst), (ins GPR:$a, GPR:$b, GPR:$acc),
2174                   NoItinerary, !strconcat(opc, "dx"), "\t$dst, $a, $b, $acc">;
2175
2176   def LD : AMulDualI<1, sub, 0, (outs GPR:$ldst,GPR:$hdst), (ins GPR:$a,GPR:$b),
2177                   NoItinerary, !strconcat(opc, "ld"), "\t$ldst, $hdst, $a, $b">;
2178
2179   def LDX : AMulDualI<1, sub, 1, (outs GPR:$ldst,GPR:$hdst),(ins GPR:$a,GPR:$b),
2180                   NoItinerary, !strconcat(opc, "ldx"),"\t$ldst, $hdst, $a, $b">;
2181
2182 }
2183
2184 defm SMLA : AI_smld<0, "smla">;
2185 defm SMLS : AI_smld<1, "smls">;
2186
2187 multiclass AI_sdml<bit sub, string opc> {
2188
2189   def D : AMulDualI<0, sub, 0, (outs GPR:$dst), (ins GPR:$a, GPR:$b),
2190                     NoItinerary, !strconcat(opc, "d"), "\t$dst, $a, $b"> {
2191     let Inst{15-12} = 0b1111;
2192   }
2193
2194   def DX : AMulDualI<0, sub, 1, (outs GPR:$dst), (ins GPR:$a, GPR:$b),
2195                     NoItinerary, !strconcat(opc, "dx"), "\t$dst, $a, $b"> {
2196     let Inst{15-12} = 0b1111;
2197   }
2198
2199 }
2200
2201 defm SMUA : AI_sdml<0, "smua">;
2202 defm SMUS : AI_sdml<1, "smus">;
2203
2204 //===----------------------------------------------------------------------===//
2205 //  Misc. Arithmetic Instructions.
2206 //
2207
2208 def CLZ  : AMiscA1I<0b000010110, (outs GPR:$dst), (ins GPR:$src), IIC_iUNAr,
2209               "clz", "\t$dst, $src",
2210               [(set GPR:$dst, (ctlz GPR:$src))]>, Requires<[IsARM, HasV5T]> {
2211   let Inst{7-4}   = 0b0001;
2212   let Inst{11-8}  = 0b1111;
2213   let Inst{19-16} = 0b1111;
2214 }
2215
2216 def RBIT : AMiscA1I<0b01101111, (outs GPR:$dst), (ins GPR:$src), IIC_iUNAr,
2217               "rbit", "\t$dst, $src",
2218               [(set GPR:$dst, (ARMrbit GPR:$src))]>,
2219            Requires<[IsARM, HasV6T2]> {
2220   let Inst{7-4}   = 0b0011;
2221   let Inst{11-8}  = 0b1111;
2222   let Inst{19-16} = 0b1111;
2223 }
2224
2225 def REV  : AMiscA1I<0b01101011, (outs GPR:$dst), (ins GPR:$src), IIC_iUNAr,
2226               "rev", "\t$dst, $src",
2227               [(set GPR:$dst, (bswap GPR:$src))]>, Requires<[IsARM, HasV6]> {
2228   let Inst{7-4}   = 0b0011;
2229   let Inst{11-8}  = 0b1111;
2230   let Inst{19-16} = 0b1111;
2231 }
2232
2233 def REV16 : AMiscA1I<0b01101011, (outs GPR:$dst), (ins GPR:$src), IIC_iUNAr,
2234                "rev16", "\t$dst, $src",
2235                [(set GPR:$dst,
2236                    (or (and (srl GPR:$src, (i32 8)), 0xFF),
2237                        (or (and (shl GPR:$src, (i32 8)), 0xFF00),
2238                            (or (and (srl GPR:$src, (i32 8)), 0xFF0000),
2239                                (and (shl GPR:$src, (i32 8)), 0xFF000000)))))]>,
2240                Requires<[IsARM, HasV6]> {
2241   let Inst{7-4}   = 0b1011;
2242   let Inst{11-8}  = 0b1111;
2243   let Inst{19-16} = 0b1111;
2244 }
2245
2246 def REVSH : AMiscA1I<0b01101111, (outs GPR:$dst), (ins GPR:$src), IIC_iUNAr,
2247                "revsh", "\t$dst, $src",
2248                [(set GPR:$dst,
2249                   (sext_inreg
2250                     (or (srl (and GPR:$src, 0xFF00), (i32 8)),
2251                         (shl GPR:$src, (i32 8))), i16))]>,
2252                Requires<[IsARM, HasV6]> {
2253   let Inst{7-4}   = 0b1011;
2254   let Inst{11-8}  = 0b1111;
2255   let Inst{19-16} = 0b1111;
2256 }
2257
2258 def PKHBT : AMiscA1I<0b01101000, (outs GPR:$dst),
2259                                  (ins GPR:$src1, GPR:$src2, i32imm:$shamt),
2260                IIC_iALUsi, "pkhbt", "\t$dst, $src1, $src2, lsl $shamt",
2261                [(set GPR:$dst, (or (and GPR:$src1, 0xFFFF),
2262                                    (and (shl GPR:$src2, (i32 imm:$shamt)),
2263                                         0xFFFF0000)))]>,
2264                Requires<[IsARM, HasV6]> {
2265   let Inst{6-4} = 0b001;
2266 }
2267
2268 // Alternate cases for PKHBT where identities eliminate some nodes.
2269 def : ARMV6Pat<(or (and GPR:$src1, 0xFFFF), (and GPR:$src2, 0xFFFF0000)),
2270                (PKHBT GPR:$src1, GPR:$src2, 0)>;
2271 def : ARMV6Pat<(or (and GPR:$src1, 0xFFFF), (shl GPR:$src2, imm16_31:$shamt)),
2272                (PKHBT GPR:$src1, GPR:$src2, imm16_31:$shamt)>;
2273
2274
2275 def PKHTB : AMiscA1I<0b01101000, (outs GPR:$dst),
2276                                  (ins GPR:$src1, GPR:$src2, i32imm:$shamt),
2277                IIC_iALUsi, "pkhtb", "\t$dst, $src1, $src2, asr $shamt",
2278                [(set GPR:$dst, (or (and GPR:$src1, 0xFFFF0000),
2279                                    (and (sra GPR:$src2, imm16_31:$shamt),
2280                                         0xFFFF)))]>, Requires<[IsARM, HasV6]> {
2281   let Inst{6-4} = 0b101;
2282 }
2283
2284 // Alternate cases for PKHTB where identities eliminate some nodes.  Note that
2285 // a shift amount of 0 is *not legal* here, it is PKHBT instead.
2286 def : ARMV6Pat<(or (and GPR:$src1, 0xFFFF0000), (srl GPR:$src2, (i32 16))),
2287                (PKHTB GPR:$src1, GPR:$src2, 16)>;
2288 def : ARMV6Pat<(or (and GPR:$src1, 0xFFFF0000),
2289                    (and (srl GPR:$src2, imm1_15:$shamt), 0xFFFF)),
2290                (PKHTB GPR:$src1, GPR:$src2, imm1_15:$shamt)>;
2291
2292 //===----------------------------------------------------------------------===//
2293 //  Comparison Instructions...
2294 //
2295
2296 defm CMP  : AI1_cmp_irs<0b1010, "cmp",
2297                         BinOpFrag<(ARMcmp node:$LHS, node:$RHS)>>;
2298 //FIXME: Disable CMN, as CCodes are backwards from compare expectations
2299 //       Compare-to-zero still works out, just not the relationals
2300 //defm CMN  : AI1_cmp_irs<0b1011, "cmn",
2301 //                        BinOpFrag<(ARMcmp node:$LHS,(ineg node:$RHS))>>;
2302
2303 // Note that TST/TEQ don't set all the same flags that CMP does!
2304 defm TST  : AI1_cmp_irs<0b1000, "tst",
2305                         BinOpFrag<(ARMcmpZ (and node:$LHS, node:$RHS), 0)>, 1>;
2306 defm TEQ  : AI1_cmp_irs<0b1001, "teq",
2307                         BinOpFrag<(ARMcmpZ (xor node:$LHS, node:$RHS), 0)>, 1>;
2308
2309 defm CMPz  : AI1_cmp_irs<0b1010, "cmp",
2310                          BinOpFrag<(ARMcmpZ node:$LHS, node:$RHS)>>;
2311 defm CMNz  : AI1_cmp_irs<0b1011, "cmn",
2312                          BinOpFrag<(ARMcmpZ node:$LHS,(ineg node:$RHS))>>;
2313
2314 //def : ARMPat<(ARMcmp GPR:$src, so_imm_neg:$imm),
2315 //             (CMNri  GPR:$src, so_imm_neg:$imm)>;
2316
2317 def : ARMPat<(ARMcmpZ GPR:$src, so_imm_neg:$imm),
2318              (CMNzri  GPR:$src, so_imm_neg:$imm)>;
2319
2320 // Pseudo i64 compares for some floating point compares.
2321 let usesCustomInserter = 1, isBranch = 1, isTerminator = 1,
2322     Defs = [CPSR] in {
2323 def BCCi64 : PseudoInst<(outs),
2324      (ins i32imm:$cc, GPR:$lhs1, GPR:$lhs2, GPR:$rhs1, GPR:$rhs2, brtarget:$dst),
2325       IIC_Br,
2326      "${:comment} B\t$dst GPR:$lhs1, GPR:$lhs2, GPR:$rhs1, GPR:$rhs2, imm:$cc",
2327     [(ARMBcci64 imm:$cc, GPR:$lhs1, GPR:$lhs2, GPR:$rhs1, GPR:$rhs2, bb:$dst)]>;
2328
2329 def BCCZi64 : PseudoInst<(outs),
2330      (ins i32imm:$cc, GPR:$lhs1, GPR:$lhs2, brtarget:$dst),
2331       IIC_Br,
2332      "${:comment} B\t$dst GPR:$lhs1, GPR:$lhs2, 0, 0, imm:$cc",
2333     [(ARMBcci64 imm:$cc, GPR:$lhs1, GPR:$lhs2, 0, 0, bb:$dst)]>;
2334 } // usesCustomInserter
2335
2336
2337 // Conditional moves
2338 // FIXME: should be able to write a pattern for ARMcmov, but can't use
2339 // a two-value operand where a dag node expects two operands. :(
2340 let neverHasSideEffects = 1 in {
2341 def MOVCCr : AI1<0b1101, (outs GPR:$dst), (ins GPR:$false, GPR:$true), DPFrm,
2342                 IIC_iCMOVr, "mov", "\t$dst, $true",
2343       [/*(set GPR:$dst, (ARMcmov GPR:$false, GPR:$true, imm:$cc, CCR:$ccr))*/]>,
2344                 RegConstraint<"$false = $dst">, UnaryDP {
2345   let Inst{11-4} = 0b00000000;
2346   let Inst{25} = 0;
2347 }
2348
2349 def MOVCCs : AI1<0b1101, (outs GPR:$dst),
2350                         (ins GPR:$false, so_reg:$true), DPSoRegFrm, IIC_iCMOVsr,
2351                 "mov", "\t$dst, $true",
2352    [/*(set GPR:$dst, (ARMcmov GPR:$false, so_reg:$true, imm:$cc, CCR:$ccr))*/]>,
2353                 RegConstraint<"$false = $dst">, UnaryDP {
2354   let Inst{25} = 0;
2355 }
2356
2357 def MOVCCi : AI1<0b1101, (outs GPR:$dst),
2358                         (ins GPR:$false, so_imm:$true), DPFrm, IIC_iCMOVi,
2359                 "mov", "\t$dst, $true",
2360    [/*(set GPR:$dst, (ARMcmov GPR:$false, so_imm:$true, imm:$cc, CCR:$ccr))*/]>,
2361                 RegConstraint<"$false = $dst">, UnaryDP {
2362   let Inst{25} = 1;
2363 }
2364 } // neverHasSideEffects
2365
2366 //===----------------------------------------------------------------------===//
2367 // Atomic operations intrinsics
2368 //
2369
2370 // memory barriers protect the atomic sequences
2371 let hasSideEffects = 1 in {
2372 def Int_MemBarrierV7 : AInoP<(outs), (ins),
2373                         Pseudo, NoItinerary,
2374                         "dmb", "",
2375                         [(ARMMemBarrierV7)]>,
2376                         Requires<[IsARM, HasV7]> {
2377   let Inst{31-4} = 0xf57ff05;
2378   // FIXME: add support for options other than a full system DMB
2379   // See DMB disassembly-only variants below.
2380   let Inst{3-0} = 0b1111;
2381 }
2382
2383 def Int_SyncBarrierV7 : AInoP<(outs), (ins),
2384                         Pseudo, NoItinerary,
2385                         "dsb", "",
2386                         [(ARMSyncBarrierV7)]>,
2387                         Requires<[IsARM, HasV7]> {
2388   let Inst{31-4} = 0xf57ff04;
2389   // FIXME: add support for options other than a full system DSB
2390   // See DSB disassembly-only variants below.
2391   let Inst{3-0} = 0b1111;
2392 }
2393
2394 def Int_MemBarrierV6 : AInoP<(outs), (ins GPR:$zero),
2395                        Pseudo, NoItinerary,
2396                        "mcr", "\tp15, 0, $zero, c7, c10, 5",
2397                        [(ARMMemBarrierV6 GPR:$zero)]>,
2398                        Requires<[IsARM, HasV6]> {
2399   // FIXME: add support for options other than a full system DMB
2400   // FIXME: add encoding
2401 }
2402
2403 def Int_SyncBarrierV6 : AInoP<(outs), (ins GPR:$zero),
2404                         Pseudo, NoItinerary,
2405                         "mcr", "\tp15, 0, $zero, c7, c10, 4",
2406                         [(ARMSyncBarrierV6 GPR:$zero)]>,
2407                         Requires<[IsARM, HasV6]> {
2408   // FIXME: add support for options other than a full system DSB
2409   // FIXME: add encoding
2410 }
2411 }
2412
2413 // Helper class for multiclass MemB -- for disassembly only
2414 class AMBI<string opc, string asm>
2415   : AInoP<(outs), (ins), MiscFrm, NoItinerary, opc, asm,
2416           [/* For disassembly only; pattern left blank */]>,
2417     Requires<[IsARM, HasV7]> {
2418   let Inst{31-20} = 0xf57;
2419 }
2420
2421 multiclass MemB<bits<4> op7_4, string opc> {
2422
2423   def st : AMBI<opc, "\tst"> {
2424     let Inst{7-4} = op7_4;
2425     let Inst{3-0} = 0b1110;
2426   }
2427
2428   def ish : AMBI<opc, "\tish"> {
2429     let Inst{7-4} = op7_4;
2430     let Inst{3-0} = 0b1011;
2431   }
2432
2433   def ishst : AMBI<opc, "\tishst"> {
2434     let Inst{7-4} = op7_4;
2435     let Inst{3-0} = 0b1010;
2436   }
2437
2438   def nsh : AMBI<opc, "\tnsh"> {
2439     let Inst{7-4} = op7_4;
2440     let Inst{3-0} = 0b0111;
2441   }
2442
2443   def nshst : AMBI<opc, "\tnshst"> {
2444     let Inst{7-4} = op7_4;
2445     let Inst{3-0} = 0b0110;
2446   }
2447
2448   def osh : AMBI<opc, "\tosh"> {
2449     let Inst{7-4} = op7_4;
2450     let Inst{3-0} = 0b0011;
2451   }
2452
2453   def oshst : AMBI<opc, "\toshst"> {
2454     let Inst{7-4} = op7_4;
2455     let Inst{3-0} = 0b0010;
2456   }
2457 }
2458
2459 // These DMB variants are for disassembly only.
2460 defm DMB : MemB<0b0101, "dmb">;
2461
2462 // These DSB variants are for disassembly only.
2463 defm DSB : MemB<0b0100, "dsb">;
2464
2465 // ISB has only full system option -- for disassembly only
2466 def ISBsy : AMBI<"isb", ""> {
2467   let Inst{7-4} = 0b0110;
2468   let Inst{3-0} = 0b1111;
2469 }
2470
2471 let usesCustomInserter = 1 in {
2472   let Uses = [CPSR] in {
2473     def ATOMIC_LOAD_ADD_I8 : PseudoInst<
2474       (outs GPR:$dst), (ins GPR:$ptr, GPR:$incr), NoItinerary,
2475       "${:comment} ATOMIC_LOAD_ADD_I8 PSEUDO!",
2476       [(set GPR:$dst, (atomic_load_add_8 GPR:$ptr, GPR:$incr))]>;
2477     def ATOMIC_LOAD_SUB_I8 : PseudoInst<
2478       (outs GPR:$dst), (ins GPR:$ptr, GPR:$incr), NoItinerary,
2479       "${:comment} ATOMIC_LOAD_SUB_I8 PSEUDO!",
2480       [(set GPR:$dst, (atomic_load_sub_8 GPR:$ptr, GPR:$incr))]>;
2481     def ATOMIC_LOAD_AND_I8 : PseudoInst<
2482       (outs GPR:$dst), (ins GPR:$ptr, GPR:$incr), NoItinerary,
2483       "${:comment} ATOMIC_LOAD_AND_I8 PSEUDO!",
2484       [(set GPR:$dst, (atomic_load_and_8 GPR:$ptr, GPR:$incr))]>;
2485     def ATOMIC_LOAD_OR_I8 : PseudoInst<
2486       (outs GPR:$dst), (ins GPR:$ptr, GPR:$incr), NoItinerary,
2487       "${:comment} ATOMIC_LOAD_OR_I8 PSEUDO!",
2488       [(set GPR:$dst, (atomic_load_or_8 GPR:$ptr, GPR:$incr))]>;
2489     def ATOMIC_LOAD_XOR_I8 : PseudoInst<
2490       (outs GPR:$dst), (ins GPR:$ptr, GPR:$incr), NoItinerary,
2491       "${:comment} ATOMIC_LOAD_XOR_I8 PSEUDO!",
2492       [(set GPR:$dst, (atomic_load_xor_8 GPR:$ptr, GPR:$incr))]>;
2493     def ATOMIC_LOAD_NAND_I8 : PseudoInst<
2494       (outs GPR:$dst), (ins GPR:$ptr, GPR:$incr), NoItinerary,
2495       "${:comment} ATOMIC_LOAD_NAND_I8 PSEUDO!",
2496       [(set GPR:$dst, (atomic_load_nand_8 GPR:$ptr, GPR:$incr))]>;
2497     def ATOMIC_LOAD_ADD_I16 : PseudoInst<
2498       (outs GPR:$dst), (ins GPR:$ptr, GPR:$incr), NoItinerary,
2499       "${:comment} ATOMIC_LOAD_ADD_I16 PSEUDO!",
2500       [(set GPR:$dst, (atomic_load_add_16 GPR:$ptr, GPR:$incr))]>;
2501     def ATOMIC_LOAD_SUB_I16 : PseudoInst<
2502       (outs GPR:$dst), (ins GPR:$ptr, GPR:$incr), NoItinerary,
2503       "${:comment} ATOMIC_LOAD_SUB_I16 PSEUDO!",
2504       [(set GPR:$dst, (atomic_load_sub_16 GPR:$ptr, GPR:$incr))]>;
2505     def ATOMIC_LOAD_AND_I16 : PseudoInst<
2506       (outs GPR:$dst), (ins GPR:$ptr, GPR:$incr), NoItinerary,
2507       "${:comment} ATOMIC_LOAD_AND_I16 PSEUDO!",
2508       [(set GPR:$dst, (atomic_load_and_16 GPR:$ptr, GPR:$incr))]>;
2509     def ATOMIC_LOAD_OR_I16 : PseudoInst<
2510       (outs GPR:$dst), (ins GPR:$ptr, GPR:$incr), NoItinerary,
2511       "${:comment} ATOMIC_LOAD_OR_I16 PSEUDO!",
2512       [(set GPR:$dst, (atomic_load_or_16 GPR:$ptr, GPR:$incr))]>;
2513     def ATOMIC_LOAD_XOR_I16 : PseudoInst<
2514       (outs GPR:$dst), (ins GPR:$ptr, GPR:$incr), NoItinerary,
2515       "${:comment} ATOMIC_LOAD_XOR_I16 PSEUDO!",
2516       [(set GPR:$dst, (atomic_load_xor_16 GPR:$ptr, GPR:$incr))]>;
2517     def ATOMIC_LOAD_NAND_I16 : PseudoInst<
2518       (outs GPR:$dst), (ins GPR:$ptr, GPR:$incr), NoItinerary,
2519       "${:comment} ATOMIC_LOAD_NAND_I16 PSEUDO!",
2520       [(set GPR:$dst, (atomic_load_nand_16 GPR:$ptr, GPR:$incr))]>;
2521     def ATOMIC_LOAD_ADD_I32 : PseudoInst<
2522       (outs GPR:$dst), (ins GPR:$ptr, GPR:$incr), NoItinerary,
2523       "${:comment} ATOMIC_LOAD_ADD_I32 PSEUDO!",
2524       [(set GPR:$dst, (atomic_load_add_32 GPR:$ptr, GPR:$incr))]>;
2525     def ATOMIC_LOAD_SUB_I32 : PseudoInst<
2526       (outs GPR:$dst), (ins GPR:$ptr, GPR:$incr), NoItinerary,
2527       "${:comment} ATOMIC_LOAD_SUB_I32 PSEUDO!",
2528       [(set GPR:$dst, (atomic_load_sub_32 GPR:$ptr, GPR:$incr))]>;
2529     def ATOMIC_LOAD_AND_I32 : PseudoInst<
2530       (outs GPR:$dst), (ins GPR:$ptr, GPR:$incr), NoItinerary,
2531       "${:comment} ATOMIC_LOAD_AND_I32 PSEUDO!",
2532       [(set GPR:$dst, (atomic_load_and_32 GPR:$ptr, GPR:$incr))]>;
2533     def ATOMIC_LOAD_OR_I32 : PseudoInst<
2534       (outs GPR:$dst), (ins GPR:$ptr, GPR:$incr), NoItinerary,
2535       "${:comment} ATOMIC_LOAD_OR_I32 PSEUDO!",
2536       [(set GPR:$dst, (atomic_load_or_32 GPR:$ptr, GPR:$incr))]>;
2537     def ATOMIC_LOAD_XOR_I32 : PseudoInst<
2538       (outs GPR:$dst), (ins GPR:$ptr, GPR:$incr), NoItinerary,
2539       "${:comment} ATOMIC_LOAD_XOR_I32 PSEUDO!",
2540       [(set GPR:$dst, (atomic_load_xor_32 GPR:$ptr, GPR:$incr))]>;
2541     def ATOMIC_LOAD_NAND_I32 : PseudoInst<
2542       (outs GPR:$dst), (ins GPR:$ptr, GPR:$incr), NoItinerary,
2543       "${:comment} ATOMIC_LOAD_NAND_I32 PSEUDO!",
2544       [(set GPR:$dst, (atomic_load_nand_32 GPR:$ptr, GPR:$incr))]>;
2545
2546     def ATOMIC_SWAP_I8 : PseudoInst<
2547       (outs GPR:$dst), (ins GPR:$ptr, GPR:$new), NoItinerary,
2548       "${:comment} ATOMIC_SWAP_I8 PSEUDO!",
2549       [(set GPR:$dst, (atomic_swap_8 GPR:$ptr, GPR:$new))]>;
2550     def ATOMIC_SWAP_I16 : PseudoInst<
2551       (outs GPR:$dst), (ins GPR:$ptr, GPR:$new), NoItinerary,
2552       "${:comment} ATOMIC_SWAP_I16 PSEUDO!",
2553       [(set GPR:$dst, (atomic_swap_16 GPR:$ptr, GPR:$new))]>;
2554     def ATOMIC_SWAP_I32 : PseudoInst<
2555       (outs GPR:$dst), (ins GPR:$ptr, GPR:$new), NoItinerary,
2556       "${:comment} ATOMIC_SWAP_I32 PSEUDO!",
2557       [(set GPR:$dst, (atomic_swap_32 GPR:$ptr, GPR:$new))]>;
2558
2559     def ATOMIC_CMP_SWAP_I8 : PseudoInst<
2560       (outs GPR:$dst), (ins GPR:$ptr, GPR:$old, GPR:$new), NoItinerary,
2561       "${:comment} ATOMIC_CMP_SWAP_I8 PSEUDO!",
2562       [(set GPR:$dst, (atomic_cmp_swap_8 GPR:$ptr, GPR:$old, GPR:$new))]>;
2563     def ATOMIC_CMP_SWAP_I16 : PseudoInst<
2564       (outs GPR:$dst), (ins GPR:$ptr, GPR:$old, GPR:$new), NoItinerary,
2565       "${:comment} ATOMIC_CMP_SWAP_I16 PSEUDO!",
2566       [(set GPR:$dst, (atomic_cmp_swap_16 GPR:$ptr, GPR:$old, GPR:$new))]>;
2567     def ATOMIC_CMP_SWAP_I32 : PseudoInst<
2568       (outs GPR:$dst), (ins GPR:$ptr, GPR:$old, GPR:$new), NoItinerary,
2569       "${:comment} ATOMIC_CMP_SWAP_I32 PSEUDO!",
2570       [(set GPR:$dst, (atomic_cmp_swap_32 GPR:$ptr, GPR:$old, GPR:$new))]>;
2571 }
2572 }
2573
2574 let mayLoad = 1 in {
2575 def LDREXB : AIldrex<0b10, (outs GPR:$dest), (ins GPR:$ptr), NoItinerary,
2576                     "ldrexb", "\t$dest, [$ptr]",
2577                     []>;
2578 def LDREXH : AIldrex<0b11, (outs GPR:$dest), (ins GPR:$ptr), NoItinerary,
2579                     "ldrexh", "\t$dest, [$ptr]",
2580                     []>;
2581 def LDREX  : AIldrex<0b00, (outs GPR:$dest), (ins GPR:$ptr), NoItinerary,
2582                     "ldrex", "\t$dest, [$ptr]",
2583                     []>;
2584 def LDREXD : AIldrex<0b01, (outs GPR:$dest, GPR:$dest2), (ins GPR:$ptr),
2585                     NoItinerary,
2586                     "ldrexd", "\t$dest, $dest2, [$ptr]",
2587                     []>;
2588 }
2589
2590 let mayStore = 1, Constraints = "@earlyclobber $success" in {
2591 def STREXB : AIstrex<0b10, (outs GPR:$success), (ins GPR:$src, GPR:$ptr),
2592                     NoItinerary,
2593                     "strexb", "\t$success, $src, [$ptr]",
2594                     []>;
2595 def STREXH : AIstrex<0b11, (outs GPR:$success), (ins GPR:$src, GPR:$ptr),
2596                     NoItinerary,
2597                     "strexh", "\t$success, $src, [$ptr]",
2598                     []>;
2599 def STREX  : AIstrex<0b00, (outs GPR:$success), (ins GPR:$src, GPR:$ptr),
2600                     NoItinerary,
2601                     "strex", "\t$success, $src, [$ptr]",
2602                     []>;
2603 def STREXD : AIstrex<0b01, (outs GPR:$success),
2604                     (ins GPR:$src, GPR:$src2, GPR:$ptr),
2605                     NoItinerary,
2606                     "strexd", "\t$success, $src, $src2, [$ptr]",
2607                     []>;
2608 }
2609
2610 // Clear-Exclusive is for disassembly only.
2611 def CLREX : AXI<(outs), (ins), MiscFrm, NoItinerary, "clrex",
2612                 [/* For disassembly only; pattern left blank */]>,
2613             Requires<[IsARM, HasV7]>  {
2614   let Inst{31-20} = 0xf57;
2615   let Inst{7-4} = 0b0001;
2616 }
2617
2618 // SWP/SWPB are deprecated in V6/V7 and for disassembly only.
2619 let mayLoad = 1 in {
2620 def SWP : AI<(outs GPR:$dst), (ins GPR:$src, GPR:$ptr), LdStExFrm, NoItinerary,
2621              "swp", "\t$dst, $src, [$ptr]",
2622              [/* For disassembly only; pattern left blank */]> {
2623   let Inst{27-23} = 0b00010;
2624   let Inst{22} = 0; // B = 0
2625   let Inst{21-20} = 0b00;
2626   let Inst{7-4} = 0b1001;
2627 }
2628
2629 def SWPB : AI<(outs GPR:$dst), (ins GPR:$src, GPR:$ptr), LdStExFrm, NoItinerary,
2630              "swpb", "\t$dst, $src, [$ptr]",
2631              [/* For disassembly only; pattern left blank */]> {
2632   let Inst{27-23} = 0b00010;
2633   let Inst{22} = 1; // B = 1
2634   let Inst{21-20} = 0b00;
2635   let Inst{7-4} = 0b1001;
2636 }
2637 }
2638
2639 //===----------------------------------------------------------------------===//
2640 // TLS Instructions
2641 //
2642
2643 // __aeabi_read_tp preserves the registers r1-r3.
2644 let isCall = 1,
2645   Defs = [R0, R12, LR, CPSR] in {
2646   def TPsoft : ABXI<0b1011, (outs), (ins), IIC_Br,
2647                "bl\t__aeabi_read_tp",
2648                [(set R0, ARMthread_pointer)]>;
2649 }
2650
2651 //===----------------------------------------------------------------------===//
2652 // SJLJ Exception handling intrinsics
2653 //   eh_sjlj_setjmp() is an instruction sequence to store the return
2654 //   address and save #0 in R0 for the non-longjmp case.
2655 //   Since by its nature we may be coming from some other function to get
2656 //   here, and we're using the stack frame for the containing function to
2657 //   save/restore registers, we can't keep anything live in regs across
2658 //   the eh_sjlj_setjmp(), else it will almost certainly have been tromped upon
2659 //   when we get here from a longjmp(). We force everthing out of registers
2660 //   except for our own input by listing the relevant registers in Defs. By
2661 //   doing so, we also cause the prologue/epilogue code to actively preserve
2662 //   all of the callee-saved resgisters, which is exactly what we want.
2663 //   A constant value is passed in $val, and we use the location as a scratch.
2664 let Defs =
2665   [ R0,  R1,  R2,  R3,  R4,  R5,  R6,  R7,  R8,  R9,  R10, R11, R12, LR,  D0,
2666     D1,  D2,  D3,  D4,  D5,  D6,  D7,  D8,  D9,  D10, D11, D12, D13, D14, D15,
2667     D16, D17, D18, D19, D20, D21, D22, D23, D24, D25, D26, D27, D28, D29, D30,
2668     D31 ], hasSideEffects = 1, isBarrier = 1 in {
2669   def Int_eh_sjlj_setjmp : XI<(outs), (ins GPR:$src, GPR:$val),
2670                                AddrModeNone, SizeSpecial, IndexModeNone,
2671                                Pseudo, NoItinerary,
2672                            "add\t$val, pc, #8\t${:comment} eh_setjmp begin\n\t"
2673                            "str\t$val, [$src, #+4]\n\t"
2674                            "mov\tr0, #0\n\t"
2675                            "add\tpc, pc, #0\n\t"
2676                            "mov\tr0, #1 ${:comment} eh_setjmp end", "",
2677                          [(set R0, (ARMeh_sjlj_setjmp GPR:$src, GPR:$val))]>,
2678                            Requires<[IsARM, HasVFP2]>;
2679 }
2680
2681 let Defs =
2682   [ R0,  R1,  R2,  R3,  R4,  R5,  R6,  R7,  R8,  R9,  R10, R11, R12, LR ],
2683   hasSideEffects = 1, isBarrier = 1 in {
2684   def Int_eh_sjlj_setjmp_nofp : XI<(outs), (ins GPR:$src, GPR:$val),
2685                                    AddrModeNone, SizeSpecial, IndexModeNone,
2686                                    Pseudo, NoItinerary,
2687                            "add\t$val, pc, #8\n ${:comment} eh_setjmp begin\n\t"
2688                            "str\t$val, [$src, #+4]\n\t"
2689                            "mov\tr0, #0\n\t"
2690                            "add\tpc, pc, #0\n\t"
2691                            "mov\tr0, #1 ${:comment} eh_setjmp end", "",
2692                          [(set R0, (ARMeh_sjlj_setjmp GPR:$src, GPR:$val))]>,
2693                                 Requires<[IsARM, NoVFP]>;
2694 }
2695
2696 // FIXME: Non-Darwin version(s)
2697 let isBarrier = 1, hasSideEffects = 1, isTerminator = 1,
2698     Defs = [ R7, LR, SP ] in {
2699 def Int_eh_sjlj_longjmp : XI<(outs), (ins GPR:$src, GPR:$scratch),
2700                              AddrModeNone, SizeSpecial, IndexModeNone,
2701                              Pseudo, NoItinerary,
2702                              "ldr\tsp, [$src, #8]\n\t"
2703                              "ldr\t$scratch, [$src, #4]\n\t"
2704                              "ldr\tr7, [$src]\n\t"
2705                              "bx\t$scratch", "",
2706                          [(ARMeh_sjlj_longjmp GPR:$src, GPR:$scratch)]>,
2707                                 Requires<[IsARM, IsDarwin]>;
2708 }
2709
2710 //===----------------------------------------------------------------------===//
2711 // Non-Instruction Patterns
2712 //
2713
2714 // Large immediate handling.
2715
2716 // Two piece so_imms.
2717 let isReMaterializable = 1 in
2718 def MOVi2pieces : AI1x2<(outs GPR:$dst), (ins so_imm2part:$src),
2719                          Pseudo, IIC_iMOVi,
2720                          "mov", "\t$dst, $src",
2721                          [(set GPR:$dst, so_imm2part:$src)]>,
2722                   Requires<[IsARM, NoV6T2]>;
2723
2724 def : ARMPat<(or GPR:$LHS, so_imm2part:$RHS),
2725              (ORRri (ORRri GPR:$LHS, (so_imm2part_1 imm:$RHS)),
2726                     (so_imm2part_2 imm:$RHS))>;
2727 def : ARMPat<(xor GPR:$LHS, so_imm2part:$RHS),
2728              (EORri (EORri GPR:$LHS, (so_imm2part_1 imm:$RHS)),
2729                     (so_imm2part_2 imm:$RHS))>;
2730 def : ARMPat<(add GPR:$LHS, so_imm2part:$RHS),
2731              (ADDri (ADDri GPR:$LHS, (so_imm2part_1 imm:$RHS)),
2732                     (so_imm2part_2 imm:$RHS))>;
2733 def : ARMPat<(add GPR:$LHS, so_neg_imm2part:$RHS),
2734              (SUBri (SUBri GPR:$LHS, (so_neg_imm2part_1 imm:$RHS)),
2735                     (so_neg_imm2part_2 imm:$RHS))>;
2736
2737 // 32-bit immediate using movw + movt.
2738 // This is a single pseudo instruction, the benefit is that it can be remat'd
2739 // as a single unit instead of having to handle reg inputs.
2740 // FIXME: Remove this when we can do generalized remat.
2741 let isReMaterializable = 1 in
2742 def MOVi32imm : AI1x2<(outs GPR:$dst), (ins i32imm:$src), Pseudo, IIC_iMOVi,
2743                    "movw", "\t$dst, ${src:lo16}\n\tmovt${p}\t$dst, ${src:hi16}",
2744                      [(set GPR:$dst, (i32 imm:$src))]>,
2745                Requires<[IsARM, HasV6T2]>;
2746
2747 // ConstantPool, GlobalAddress, and JumpTable
2748 def : ARMPat<(ARMWrapper  tglobaladdr :$dst), (LEApcrel tglobaladdr :$dst)>,
2749             Requires<[IsARM, DontUseMovt]>;
2750 def : ARMPat<(ARMWrapper  tconstpool  :$dst), (LEApcrel tconstpool  :$dst)>;
2751 def : ARMPat<(ARMWrapper  tglobaladdr :$dst), (MOVi32imm tglobaladdr :$dst)>,
2752             Requires<[IsARM, UseMovt]>;
2753 def : ARMPat<(ARMWrapperJT tjumptable:$dst, imm:$id),
2754              (LEApcrelJT tjumptable:$dst, imm:$id)>;
2755
2756 // TODO: add,sub,and, 3-instr forms?
2757
2758 // Tail calls
2759 def : ARMPat<(ARMtcret tcGPR:$dst),
2760           (TCRETURNri tcGPR:$dst)>, Requires<[IsDarwin]>;
2761
2762 def : ARMPat<(ARMtcret (i32 tglobaladdr:$dst)),
2763           (TCRETURNdi texternalsym:$dst)>, Requires<[IsDarwin]>;
2764
2765 def : ARMPat<(ARMtcret (i32 texternalsym:$dst)),
2766           (TCRETURNdi texternalsym:$dst)>, Requires<[IsDarwin]>;
2767
2768 def : ARMPat<(ARMtcret tcGPR:$dst),
2769           (TCRETURNriND tcGPR:$dst)>, Requires<[IsNotDarwin]>;
2770
2771 def : ARMPat<(ARMtcret (i32 tglobaladdr:$dst)),
2772           (TCRETURNdiND texternalsym:$dst)>, Requires<[IsNotDarwin]>;
2773
2774 def : ARMPat<(ARMtcret (i32 texternalsym:$dst)),
2775           (TCRETURNdiND texternalsym:$dst)>, Requires<[IsNotDarwin]>;
2776
2777 // Direct calls
2778 def : ARMPat<(ARMcall texternalsym:$func), (BL texternalsym:$func)>,
2779       Requires<[IsARM, IsNotDarwin]>;
2780 def : ARMPat<(ARMcall texternalsym:$func), (BLr9 texternalsym:$func)>,
2781       Requires<[IsARM, IsDarwin]>;
2782
2783 // zextload i1 -> zextload i8
2784 def : ARMPat<(zextloadi1 addrmode2:$addr),  (LDRB addrmode2:$addr)>;
2785
2786 // extload -> zextload
2787 def : ARMPat<(extloadi1  addrmode2:$addr),  (LDRB addrmode2:$addr)>;
2788 def : ARMPat<(extloadi8  addrmode2:$addr),  (LDRB addrmode2:$addr)>;
2789 def : ARMPat<(extloadi16 addrmode3:$addr),  (LDRH addrmode3:$addr)>;
2790
2791 def : ARMPat<(extloadi8  addrmodepc:$addr), (PICLDRB addrmodepc:$addr)>;
2792 def : ARMPat<(extloadi16 addrmodepc:$addr), (PICLDRH addrmodepc:$addr)>;
2793
2794 // smul* and smla*
2795 def : ARMV5TEPat<(mul (sra (shl GPR:$a, (i32 16)), (i32 16)),
2796                       (sra (shl GPR:$b, (i32 16)), (i32 16))),
2797                  (SMULBB GPR:$a, GPR:$b)>;
2798 def : ARMV5TEPat<(mul sext_16_node:$a, sext_16_node:$b),
2799                  (SMULBB GPR:$a, GPR:$b)>;
2800 def : ARMV5TEPat<(mul (sra (shl GPR:$a, (i32 16)), (i32 16)),
2801                       (sra GPR:$b, (i32 16))),
2802                  (SMULBT GPR:$a, GPR:$b)>;
2803 def : ARMV5TEPat<(mul sext_16_node:$a, (sra GPR:$b, (i32 16))),
2804                  (SMULBT GPR:$a, GPR:$b)>;
2805 def : ARMV5TEPat<(mul (sra GPR:$a, (i32 16)),
2806                       (sra (shl GPR:$b, (i32 16)), (i32 16))),
2807                  (SMULTB GPR:$a, GPR:$b)>;
2808 def : ARMV5TEPat<(mul (sra GPR:$a, (i32 16)), sext_16_node:$b),
2809                 (SMULTB GPR:$a, GPR:$b)>;
2810 def : ARMV5TEPat<(sra (mul GPR:$a, (sra (shl GPR:$b, (i32 16)), (i32 16))),
2811                       (i32 16)),
2812                  (SMULWB GPR:$a, GPR:$b)>;
2813 def : ARMV5TEPat<(sra (mul GPR:$a, sext_16_node:$b), (i32 16)),
2814                  (SMULWB GPR:$a, GPR:$b)>;
2815
2816 def : ARMV5TEPat<(add GPR:$acc,
2817                       (mul (sra (shl GPR:$a, (i32 16)), (i32 16)),
2818                            (sra (shl GPR:$b, (i32 16)), (i32 16)))),
2819                  (SMLABB GPR:$a, GPR:$b, GPR:$acc)>;
2820 def : ARMV5TEPat<(add GPR:$acc,
2821                       (mul sext_16_node:$a, sext_16_node:$b)),
2822                  (SMLABB GPR:$a, GPR:$b, GPR:$acc)>;
2823 def : ARMV5TEPat<(add GPR:$acc,
2824                       (mul (sra (shl GPR:$a, (i32 16)), (i32 16)),
2825                            (sra GPR:$b, (i32 16)))),
2826                  (SMLABT GPR:$a, GPR:$b, GPR:$acc)>;
2827 def : ARMV5TEPat<(add GPR:$acc,
2828                       (mul sext_16_node:$a, (sra GPR:$b, (i32 16)))),
2829                  (SMLABT GPR:$a, GPR:$b, GPR:$acc)>;
2830 def : ARMV5TEPat<(add GPR:$acc,
2831                       (mul (sra GPR:$a, (i32 16)),
2832                            (sra (shl GPR:$b, (i32 16)), (i32 16)))),
2833                  (SMLATB GPR:$a, GPR:$b, GPR:$acc)>;
2834 def : ARMV5TEPat<(add GPR:$acc,
2835                       (mul (sra GPR:$a, (i32 16)), sext_16_node:$b)),
2836                  (SMLATB GPR:$a, GPR:$b, GPR:$acc)>;
2837 def : ARMV5TEPat<(add GPR:$acc,
2838                       (sra (mul GPR:$a, (sra (shl GPR:$b, (i32 16)), (i32 16))),
2839                            (i32 16))),
2840                  (SMLAWB GPR:$a, GPR:$b, GPR:$acc)>;
2841 def : ARMV5TEPat<(add GPR:$acc,
2842                       (sra (mul GPR:$a, sext_16_node:$b), (i32 16))),
2843                  (SMLAWB GPR:$a, GPR:$b, GPR:$acc)>;
2844
2845 //===----------------------------------------------------------------------===//
2846 // Thumb Support
2847 //
2848
2849 include "ARMInstrThumb.td"
2850
2851 //===----------------------------------------------------------------------===//
2852 // Thumb2 Support
2853 //
2854
2855 include "ARMInstrThumb2.td"
2856
2857 //===----------------------------------------------------------------------===//
2858 // Floating Point Support
2859 //
2860
2861 include "ARMInstrVFP.td"
2862
2863 //===----------------------------------------------------------------------===//
2864 // Advanced SIMD (NEON) Support
2865 //
2866
2867 include "ARMInstrNEON.td"
2868
2869 //===----------------------------------------------------------------------===//
2870 // Coprocessor Instructions.  For disassembly only.
2871 //
2872
2873 def CDP : ABI<0b1110, (outs), (ins nohash_imm:$cop, i32imm:$opc1,
2874             nohash_imm:$CRd, nohash_imm:$CRn, nohash_imm:$CRm, i32imm:$opc2),
2875             NoItinerary, "cdp", "\tp$cop, $opc1, cr$CRd, cr$CRn, cr$CRm, $opc2",
2876               [/* For disassembly only; pattern left blank */]> {
2877   let Inst{4} = 0;
2878 }
2879
2880 def CDP2 : ABXI<0b1110, (outs), (ins nohash_imm:$cop, i32imm:$opc1,
2881                nohash_imm:$CRd, nohash_imm:$CRn, nohash_imm:$CRm, i32imm:$opc2),
2882                NoItinerary, "cdp2\tp$cop, $opc1, cr$CRd, cr$CRn, cr$CRm, $opc2",
2883                [/* For disassembly only; pattern left blank */]> {
2884   let Inst{31-28} = 0b1111;
2885   let Inst{4} = 0;
2886 }
2887
2888 class ACI<dag oops, dag iops, string opc, string asm>
2889   : I<oops, iops, AddrModeNone, Size4Bytes, IndexModeNone, BrFrm, NoItinerary,
2890       opc, asm, "", [/* For disassembly only; pattern left blank */]> {
2891   let Inst{27-25} = 0b110;
2892 }
2893
2894 multiclass LdStCop<bits<4> op31_28, bit load, string opc> {
2895
2896   def _OFFSET : ACI<(outs),
2897       (ins nohash_imm:$cop, nohash_imm:$CRd, addrmode2:$addr),
2898       opc, "\tp$cop, cr$CRd, $addr"> {
2899     let Inst{31-28} = op31_28;
2900     let Inst{24} = 1; // P = 1
2901     let Inst{21} = 0; // W = 0
2902     let Inst{22} = 0; // D = 0
2903     let Inst{20} = load;
2904   }
2905
2906   def _PRE : ACI<(outs),
2907       (ins nohash_imm:$cop, nohash_imm:$CRd, addrmode2:$addr),
2908       opc, "\tp$cop, cr$CRd, $addr!"> {
2909     let Inst{31-28} = op31_28;
2910     let Inst{24} = 1; // P = 1
2911     let Inst{21} = 1; // W = 1
2912     let Inst{22} = 0; // D = 0
2913     let Inst{20} = load;
2914   }
2915
2916   def _POST : ACI<(outs),
2917       (ins nohash_imm:$cop, nohash_imm:$CRd, GPR:$base, am2offset:$offset),
2918       opc, "\tp$cop, cr$CRd, [$base], $offset"> {
2919     let Inst{31-28} = op31_28;
2920     let Inst{24} = 0; // P = 0
2921     let Inst{21} = 1; // W = 1
2922     let Inst{22} = 0; // D = 0
2923     let Inst{20} = load;
2924   }
2925
2926   def _OPTION : ACI<(outs),
2927       (ins nohash_imm:$cop, nohash_imm:$CRd, GPR:$base, i32imm:$option),
2928       opc, "\tp$cop, cr$CRd, [$base], $option"> {
2929     let Inst{31-28} = op31_28;
2930     let Inst{24} = 0; // P = 0
2931     let Inst{23} = 1; // U = 1
2932     let Inst{21} = 0; // W = 0
2933     let Inst{22} = 0; // D = 0
2934     let Inst{20} = load;
2935   }
2936
2937   def L_OFFSET : ACI<(outs),
2938       (ins nohash_imm:$cop, nohash_imm:$CRd, addrmode2:$addr),
2939       !strconcat(opc, "l"), "\tp$cop, cr$CRd, $addr"> {
2940     let Inst{31-28} = op31_28;
2941     let Inst{24} = 1; // P = 1
2942     let Inst{21} = 0; // W = 0
2943     let Inst{22} = 1; // D = 1
2944     let Inst{20} = load;
2945   }
2946
2947   def L_PRE : ACI<(outs),
2948       (ins nohash_imm:$cop, nohash_imm:$CRd, addrmode2:$addr),
2949       !strconcat(opc, "l"), "\tp$cop, cr$CRd, $addr!"> {
2950     let Inst{31-28} = op31_28;
2951     let Inst{24} = 1; // P = 1
2952     let Inst{21} = 1; // W = 1
2953     let Inst{22} = 1; // D = 1
2954     let Inst{20} = load;
2955   }
2956
2957   def L_POST : ACI<(outs),
2958       (ins nohash_imm:$cop, nohash_imm:$CRd, GPR:$base, am2offset:$offset),
2959       !strconcat(opc, "l"), "\tp$cop, cr$CRd, [$base], $offset"> {
2960     let Inst{31-28} = op31_28;
2961     let Inst{24} = 0; // P = 0
2962     let Inst{21} = 1; // W = 1
2963     let Inst{22} = 1; // D = 1
2964     let Inst{20} = load;
2965   }
2966
2967   def L_OPTION : ACI<(outs),
2968       (ins nohash_imm:$cop, nohash_imm:$CRd, GPR:$base, nohash_imm:$option),
2969       !strconcat(opc, "l"), "\tp$cop, cr$CRd, [$base], $option"> {
2970     let Inst{31-28} = op31_28;
2971     let Inst{24} = 0; // P = 0
2972     let Inst{23} = 1; // U = 1
2973     let Inst{21} = 0; // W = 0
2974     let Inst{22} = 1; // D = 1
2975     let Inst{20} = load;
2976   }
2977 }
2978
2979 defm LDC  : LdStCop<{?,?,?,?}, 1, "ldc">;
2980 defm LDC2 : LdStCop<0b1111,    1, "ldc2">;
2981 defm STC  : LdStCop<{?,?,?,?}, 0, "stc">;
2982 defm STC2 : LdStCop<0b1111,    0, "stc2">;
2983
2984 def MCR : ABI<0b1110, (outs), (ins nohash_imm:$cop, i32imm:$opc1,
2985               GPR:$Rt, nohash_imm:$CRn, nohash_imm:$CRm, i32imm:$opc2),
2986               NoItinerary, "mcr", "\tp$cop, $opc1, $Rt, cr$CRn, cr$CRm, $opc2",
2987               [/* For disassembly only; pattern left blank */]> {
2988   let Inst{20} = 0;
2989   let Inst{4} = 1;
2990 }
2991
2992 def MCR2 : ABXI<0b1110, (outs), (ins nohash_imm:$cop, i32imm:$opc1,
2993                 GPR:$Rt, nohash_imm:$CRn, nohash_imm:$CRm, i32imm:$opc2),
2994                 NoItinerary, "mcr2\tp$cop, $opc1, $Rt, cr$CRn, cr$CRm, $opc2",
2995                 [/* For disassembly only; pattern left blank */]> {
2996   let Inst{31-28} = 0b1111;
2997   let Inst{20} = 0;
2998   let Inst{4} = 1;
2999 }
3000
3001 def MRC : ABI<0b1110, (outs), (ins nohash_imm:$cop, i32imm:$opc1,
3002               GPR:$Rt, nohash_imm:$CRn, nohash_imm:$CRm, i32imm:$opc2),
3003               NoItinerary, "mrc", "\tp$cop, $opc1, $Rt, cr$CRn, cr$CRm, $opc2",
3004               [/* For disassembly only; pattern left blank */]> {
3005   let Inst{20} = 1;
3006   let Inst{4} = 1;
3007 }
3008
3009 def MRC2 : ABXI<0b1110, (outs), (ins nohash_imm:$cop, i32imm:$opc1,
3010                 GPR:$Rt, nohash_imm:$CRn, nohash_imm:$CRm, i32imm:$opc2),
3011                 NoItinerary, "mrc2\tp$cop, $opc1, $Rt, cr$CRn, cr$CRm, $opc2",
3012                 [/* For disassembly only; pattern left blank */]> {
3013   let Inst{31-28} = 0b1111;
3014   let Inst{20} = 1;
3015   let Inst{4} = 1;
3016 }
3017
3018 def MCRR : ABI<0b1100, (outs), (ins nohash_imm:$cop, i32imm:$opc,
3019                GPR:$Rt, GPR:$Rt2, nohash_imm:$CRm),
3020                NoItinerary, "mcrr", "\tp$cop, $opc, $Rt, $Rt2, cr$CRm",
3021                [/* For disassembly only; pattern left blank */]> {
3022   let Inst{23-20} = 0b0100;
3023 }
3024
3025 def MCRR2 : ABXI<0b1100, (outs), (ins nohash_imm:$cop, i32imm:$opc,
3026                  GPR:$Rt, GPR:$Rt2, nohash_imm:$CRm),
3027                  NoItinerary, "mcrr2\tp$cop, $opc, $Rt, $Rt2, cr$CRm",
3028                  [/* For disassembly only; pattern left blank */]> {
3029   let Inst{31-28} = 0b1111;
3030   let Inst{23-20} = 0b0100;
3031 }
3032
3033 def MRRC : ABI<0b1100, (outs), (ins nohash_imm:$cop, i32imm:$opc,
3034                GPR:$Rt, GPR:$Rt2, nohash_imm:$CRm),
3035                NoItinerary, "mrrc", "\tp$cop, $opc, $Rt, $Rt2, cr$CRm",
3036                [/* For disassembly only; pattern left blank */]> {
3037   let Inst{23-20} = 0b0101;
3038 }
3039
3040 def MRRC2 : ABXI<0b1100, (outs), (ins nohash_imm:$cop, i32imm:$opc,
3041                  GPR:$Rt, GPR:$Rt2, nohash_imm:$CRm),
3042                  NoItinerary, "mrrc2\tp$cop, $opc, $Rt, $Rt2, cr$CRm",
3043                  [/* For disassembly only; pattern left blank */]> {
3044   let Inst{31-28} = 0b1111;
3045   let Inst{23-20} = 0b0101;
3046 }
3047
3048 //===----------------------------------------------------------------------===//
3049 // Move between special register and ARM core register -- for disassembly only
3050 //
3051
3052 def MRS : ABI<0b0001,(outs GPR:$dst),(ins), NoItinerary, "mrs", "\t$dst, cpsr",
3053               [/* For disassembly only; pattern left blank */]> {
3054   let Inst{23-20} = 0b0000;
3055   let Inst{7-4} = 0b0000;
3056 }
3057
3058 def MRSsys : ABI<0b0001,(outs GPR:$dst),(ins), NoItinerary,"mrs","\t$dst, spsr",
3059               [/* For disassembly only; pattern left blank */]> {
3060   let Inst{23-20} = 0b0100;
3061   let Inst{7-4} = 0b0000;
3062 }
3063
3064 def MSR : ABI<0b0001, (outs), (ins GPR:$src, msr_mask:$mask), NoItinerary,
3065               "msr", "\tcpsr$mask, $src",
3066               [/* For disassembly only; pattern left blank */]> {
3067   let Inst{23-20} = 0b0010;
3068   let Inst{7-4} = 0b0000;
3069 }
3070
3071 def MSRi : ABI<0b0011, (outs), (ins so_imm:$a, msr_mask:$mask), NoItinerary,
3072               "msr", "\tcpsr$mask, $a",
3073               [/* For disassembly only; pattern left blank */]> {
3074   let Inst{23-20} = 0b0010;
3075   let Inst{7-4} = 0b0000;
3076 }
3077
3078 def MSRsys : ABI<0b0001, (outs), (ins GPR:$src, msr_mask:$mask), NoItinerary,
3079               "msr", "\tspsr$mask, $src",
3080               [/* For disassembly only; pattern left blank */]> {
3081   let Inst{23-20} = 0b0110;
3082   let Inst{7-4} = 0b0000;
3083 }
3084
3085 def MSRsysi : ABI<0b0011, (outs), (ins so_imm:$a, msr_mask:$mask), NoItinerary,
3086               "msr", "\tspsr$mask, $a",
3087               [/* For disassembly only; pattern left blank */]> {
3088   let Inst{23-20} = 0b0110;
3089   let Inst{7-4} = 0b0000;
3090 }