lib/Target/ARM/ARMInstrInfo.td

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