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 tGPR:$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\t$dst  @ TAILCALL",
1053                  []>, Requires<[IsDarwin]>;
1054
1055   def TAILJMPr : AXI<(outs), (ins tGPR:$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<[IsNotDarwin]>;
1089
1090   def TAILJMPrND : AXI<(outs), (ins tGPR:$dst, variable_ops),
1091                    BrMiscFrm, IIC_Br, "bx\t$dst  @ TAILCALL",
1092                  []>, Requires<[IsNotDarwin]> {
1093                  let Inst{7-4}   = 0b0001;
1094                  let Inst{19-8}  = 0b111111111111;
1095                  let Inst{27-20} = 0b00010010;
1096                  let Inst{31-28} = 0b1110;
1097   }
1098
1099   // FIXME: This is a hack so that MCInst lowering can preserve the TAILCALL
1100   // marker on instructions, while still being able to relax.
1101 //  let isCodeGenOnly = 1 in {
1102 //    def TAILJMP_1ND : Ii8PCRel<0xEB, RawFrm, (outs), (ins brtarget8:$dst),
1103 //                         "jmp\t$dst  @ TAILCALL", []>,
1104 //                         Requires<[IsARM, IsNotDarwin]>;
1105   }
1106 }
1107
1108 let isBranch = 1, isTerminator = 1 in {
1109   // B is "predicable" since it can be xformed into a Bcc.
1110   let isBarrier = 1 in {
1111     let isPredicable = 1 in
1112     def B : ABXI<0b1010, (outs), (ins brtarget:$target), IIC_Br,
1113                 "b\t$target", [(br bb:$target)]>;
1114
1115   let isNotDuplicable = 1, isIndirectBranch = 1 in {
1116   def BR_JTr : JTI<(outs), (ins GPR:$target, jtblock_operand:$jt, i32imm:$id),
1117                     IIC_Br, "mov\tpc, $target \n$jt",
1118                     [(ARMbrjt GPR:$target, tjumptable:$jt, imm:$id)]> {
1119     let Inst{11-4}  = 0b00000000;
1120     let Inst{15-12} = 0b1111;
1121     let Inst{20}    = 0; // S Bit
1122     let Inst{24-21} = 0b1101;
1123     let Inst{27-25} = 0b000;
1124   }
1125   def BR_JTm : JTI<(outs),
1126                    (ins addrmode2:$target, jtblock_operand:$jt, i32imm:$id),
1127                    IIC_Br, "ldr\tpc, $target \n$jt",
1128                    [(ARMbrjt (i32 (load addrmode2:$target)), tjumptable:$jt,
1129                      imm:$id)]> {
1130     let Inst{15-12} = 0b1111;
1131     let Inst{20}    = 1; // L bit
1132     let Inst{21}    = 0; // W bit
1133     let Inst{22}    = 0; // B bit
1134     let Inst{24}    = 1; // P bit
1135     let Inst{27-25} = 0b011;
1136   }
1137   def BR_JTadd : JTI<(outs),
1138                    (ins GPR:$target, GPR:$idx, jtblock_operand:$jt, i32imm:$id),
1139                     IIC_Br, "add\tpc, $target, $idx \n$jt",
1140                     [(ARMbrjt (add GPR:$target, GPR:$idx), tjumptable:$jt,
1141                       imm:$id)]> {
1142     let Inst{15-12} = 0b1111;
1143     let Inst{20}    = 0; // S bit
1144     let Inst{24-21} = 0b0100;
1145     let Inst{27-25} = 0b000;
1146   }
1147   } // isNotDuplicable = 1, isIndirectBranch = 1
1148   } // isBarrier = 1
1149
1150   // FIXME: should be able to write a pattern for ARMBrcond, but can't use
1151   // a two-value operand where a dag node expects two operands. :(
1152   def Bcc : ABI<0b1010, (outs), (ins brtarget:$target),
1153                IIC_Br, "b", "\t$target",
1154                [/*(ARMbrcond bb:$target, imm:$cc, CCR:$ccr)*/]>;
1155 }
1156
1157 // Branch and Exchange Jazelle -- for disassembly only
1158 def BXJ : ABI<0b0001, (outs), (ins GPR:$func), NoItinerary, "bxj", "\t$func",
1159               [/* For disassembly only; pattern left blank */]> {
1160   let Inst{23-20} = 0b0010;
1161   //let Inst{19-8} = 0xfff;
1162   let Inst{7-4} = 0b0010;
1163 }
1164
1165 // Secure Monitor Call is a system instruction -- for disassembly only
1166 def SMC : ABI<0b0001, (outs), (ins i32imm:$opt), NoItinerary, "smc", "\t$opt",
1167               [/* For disassembly only; pattern left blank */]> {
1168   let Inst{23-20} = 0b0110;
1169   let Inst{7-4} = 0b0111;
1170 }
1171
1172 // Supervisor Call (Software Interrupt) -- for disassembly only
1173 let isCall = 1 in {
1174 def SVC : ABI<0b1111, (outs), (ins i32imm:$svc), IIC_Br, "svc", "\t$svc",
1175               [/* For disassembly only; pattern left blank */]>;
1176 }
1177
1178 // Store Return State is a system instruction -- for disassembly only
1179 def SRSW : ABXI<{1,0,0,?}, (outs), (ins addrmode4:$addr, i32imm:$mode),
1180                 NoItinerary, "srs${addr:submode}\tsp!, $mode",
1181                 [/* For disassembly only; pattern left blank */]> {
1182   let Inst{31-28} = 0b1111;
1183   let Inst{22-20} = 0b110; // W = 1
1184 }
1185
1186 def SRS  : ABXI<{1,0,0,?}, (outs), (ins addrmode4:$addr, i32imm:$mode),
1187                 NoItinerary, "srs${addr:submode}\tsp, $mode",
1188                 [/* For disassembly only; pattern left blank */]> {
1189   let Inst{31-28} = 0b1111;
1190   let Inst{22-20} = 0b100; // W = 0
1191 }
1192
1193 // Return From Exception is a system instruction -- for disassembly only
1194 def RFEW : ABXI<{1,0,0,?}, (outs), (ins addrmode4:$addr, GPR:$base),
1195                 NoItinerary, "rfe${addr:submode}\t$base!",
1196                 [/* For disassembly only; pattern left blank */]> {
1197   let Inst{31-28} = 0b1111;
1198   let Inst{22-20} = 0b011; // W = 1
1199 }
1200
1201 def RFE  : ABXI<{1,0,0,?}, (outs), (ins addrmode4:$addr, GPR:$base),
1202                 NoItinerary, "rfe${addr:submode}\t$base",
1203                 [/* For disassembly only; pattern left blank */]> {
1204   let Inst{31-28} = 0b1111;
1205   let Inst{22-20} = 0b001; // W = 0
1206 }
1207
1208 //===----------------------------------------------------------------------===//
1209 //  Load / store Instructions.
1210 //
1211
1212 // Load
1213 let canFoldAsLoad = 1, isReMaterializable = 1 in
1214 def LDR  : AI2ldw<(outs GPR:$dst), (ins addrmode2:$addr), LdFrm, IIC_iLoadr,
1215                "ldr", "\t$dst, $addr",
1216                [(set GPR:$dst, (load addrmode2:$addr))]>;
1217
1218 // Special LDR for loads from non-pc-relative constpools.
1219 let canFoldAsLoad = 1, mayLoad = 1, neverHasSideEffects = 1,
1220     isReMaterializable = 1 in
1221 def LDRcp : AI2ldw<(outs GPR:$dst), (ins addrmode2:$addr), LdFrm, IIC_iLoadr,
1222                  "ldr", "\t$dst, $addr", []>;
1223
1224 // Loads with zero extension
1225 def LDRH  : AI3ldh<(outs GPR:$dst), (ins addrmode3:$addr), LdMiscFrm,
1226                   IIC_iLoadr, "ldrh", "\t$dst, $addr",
1227                   [(set GPR:$dst, (zextloadi16 addrmode3:$addr))]>;
1228
1229 def LDRB  : AI2ldb<(outs GPR:$dst), (ins addrmode2:$addr), LdFrm,
1230                   IIC_iLoadr, "ldrb", "\t$dst, $addr",
1231                   [(set GPR:$dst, (zextloadi8 addrmode2:$addr))]>;
1232
1233 // Loads with sign extension
1234 def LDRSH : AI3ldsh<(outs GPR:$dst), (ins addrmode3:$addr), LdMiscFrm,
1235                    IIC_iLoadr, "ldrsh", "\t$dst, $addr",
1236                    [(set GPR:$dst, (sextloadi16 addrmode3:$addr))]>;
1237
1238 def LDRSB : AI3ldsb<(outs GPR:$dst), (ins addrmode3:$addr), LdMiscFrm,
1239                    IIC_iLoadr, "ldrsb", "\t$dst, $addr",
1240                    [(set GPR:$dst, (sextloadi8 addrmode3:$addr))]>;
1241
1242 let mayLoad = 1, neverHasSideEffects = 1, hasExtraDefRegAllocReq = 1 in {
1243 // Load doubleword
1244 def LDRD : AI3ldd<(outs GPR:$dst1, GPR:$dst2), (ins addrmode3:$addr), LdMiscFrm,
1245                  IIC_iLoadr, "ldrd", "\t$dst1, $addr",
1246                  []>, Requires<[IsARM, HasV5TE]>;
1247
1248 // Indexed loads
1249 def LDR_PRE  : AI2ldwpr<(outs GPR:$dst, GPR:$base_wb),
1250                      (ins addrmode2:$addr), LdFrm, IIC_iLoadru,
1251                      "ldr", "\t$dst, $addr!", "$addr.base = $base_wb", []>;
1252
1253 def LDR_POST : AI2ldwpo<(outs GPR:$dst, GPR:$base_wb),
1254                      (ins GPR:$base, am2offset:$offset), LdFrm, IIC_iLoadru,
1255                      "ldr", "\t$dst, [$base], $offset", "$base = $base_wb", []>;
1256
1257 def LDRH_PRE  : AI3ldhpr<(outs GPR:$dst, GPR:$base_wb),
1258                      (ins addrmode3:$addr), LdMiscFrm, IIC_iLoadru,
1259                      "ldrh", "\t$dst, $addr!", "$addr.base = $base_wb", []>;
1260
1261 def LDRH_POST : AI3ldhpo<(outs GPR:$dst, GPR:$base_wb),
1262                      (ins GPR:$base,am3offset:$offset), LdMiscFrm, IIC_iLoadru,
1263                     "ldrh", "\t$dst, [$base], $offset", "$base = $base_wb", []>;
1264
1265 def LDRB_PRE  : AI2ldbpr<(outs GPR:$dst, GPR:$base_wb),
1266                      (ins addrmode2:$addr), LdFrm, IIC_iLoadru,
1267                      "ldrb", "\t$dst, $addr!", "$addr.base = $base_wb", []>;
1268
1269 def LDRB_POST : AI2ldbpo<(outs GPR:$dst, GPR:$base_wb),
1270                      (ins GPR:$base,am2offset:$offset), LdFrm, IIC_iLoadru,
1271                     "ldrb", "\t$dst, [$base], $offset", "$base = $base_wb", []>;
1272
1273 def LDRSH_PRE : AI3ldshpr<(outs GPR:$dst, GPR:$base_wb),
1274                       (ins addrmode3:$addr), LdMiscFrm, IIC_iLoadru,
1275                       "ldrsh", "\t$dst, $addr!", "$addr.base = $base_wb", []>;
1276
1277 def LDRSH_POST: AI3ldshpo<(outs GPR:$dst, GPR:$base_wb),
1278                       (ins GPR:$base,am3offset:$offset), LdMiscFrm, IIC_iLoadru,
1279                    "ldrsh", "\t$dst, [$base], $offset", "$base = $base_wb", []>;
1280
1281 def LDRSB_PRE : AI3ldsbpr<(outs GPR:$dst, GPR:$base_wb),
1282                       (ins addrmode3:$addr), LdMiscFrm, IIC_iLoadru,
1283                       "ldrsb", "\t$dst, $addr!", "$addr.base = $base_wb", []>;
1284
1285 def LDRSB_POST: AI3ldsbpo<(outs GPR:$dst, GPR:$base_wb),
1286                       (ins GPR:$base,am3offset:$offset), LdMiscFrm, IIC_iLoadru,
1287                    "ldrsb", "\t$dst, [$base], $offset", "$base = $base_wb", []>;
1288
1289 // For disassembly only
1290 def LDRD_PRE : AI3lddpr<(outs GPR:$dst1, GPR:$dst2, GPR:$base_wb),
1291                         (ins addrmode3:$addr), LdMiscFrm, IIC_iLoadr,
1292                  "ldrd", "\t$dst1, $dst2, $addr!", "$addr.base = $base_wb", []>,
1293                 Requires<[IsARM, HasV5TE]>;
1294
1295 // For disassembly only
1296 def LDRD_POST : AI3lddpo<(outs GPR:$dst1, GPR:$dst2, GPR:$base_wb),
1297                        (ins GPR:$base,am3offset:$offset), LdMiscFrm, IIC_iLoadr,
1298             "ldrd", "\t$dst1, $dst2, [$base], $offset", "$base = $base_wb", []>,
1299                 Requires<[IsARM, HasV5TE]>;
1300
1301 } // mayLoad = 1, neverHasSideEffects = 1, hasExtraDefRegAllocReq = 1
1302
1303 // LDRT, LDRBT, LDRSBT, LDRHT, LDRSHT are for disassembly only.
1304
1305 def LDRT : AI2ldwpo<(outs GPR:$dst, GPR:$base_wb),
1306                    (ins GPR:$base, am2offset:$offset), LdFrm, IIC_iLoadru,
1307                    "ldrt", "\t$dst, [$base], $offset", "$base = $base_wb", []> {
1308   let Inst{21} = 1; // overwrite
1309 }
1310
1311 def LDRBT : AI2ldbpo<(outs GPR:$dst, GPR:$base_wb),
1312                   (ins GPR:$base,am2offset:$offset), LdFrm, IIC_iLoadru,
1313                   "ldrbt", "\t$dst, [$base], $offset", "$base = $base_wb", []> {
1314   let Inst{21} = 1; // overwrite
1315 }
1316
1317 def LDRSBT : AI3ldsbpo<(outs GPR:$dst, GPR:$base_wb),
1318                  (ins GPR:$base,am3offset:$offset), LdMiscFrm, IIC_iLoadru,
1319                  "ldrsbt", "\t$dst, [$base], $offset", "$base = $base_wb", []> {
1320   let Inst{21} = 1; // overwrite
1321 }
1322
1323 def LDRHT : AI3ldhpo<(outs GPR:$dst, GPR:$base_wb),
1324                   (ins GPR:$base, am3offset:$offset), LdMiscFrm, IIC_iLoadru,
1325                   "ldrht", "\t$dst, [$base], $offset", "$base = $base_wb", []> {
1326   let Inst{21} = 1; // overwrite
1327 }
1328
1329 def LDRSHT : AI3ldshpo<(outs GPR:$dst, GPR:$base_wb),
1330                  (ins GPR:$base,am3offset:$offset), LdMiscFrm, IIC_iLoadru,
1331                  "ldrsht", "\t$dst, [$base], $offset", "$base = $base_wb", []> {
1332   let Inst{21} = 1; // overwrite
1333 }
1334
1335 // Store
1336 def STR  : AI2stw<(outs), (ins GPR:$src, addrmode2:$addr), StFrm, IIC_iStorer,
1337                "str", "\t$src, $addr",
1338                [(store GPR:$src, addrmode2:$addr)]>;
1339
1340 // Stores with truncate
1341 def STRH : AI3sth<(outs), (ins GPR:$src, addrmode3:$addr), StMiscFrm,
1342                IIC_iStorer, "strh", "\t$src, $addr",
1343                [(truncstorei16 GPR:$src, addrmode3:$addr)]>;
1344
1345 def STRB : AI2stb<(outs), (ins GPR:$src, addrmode2:$addr), StFrm, IIC_iStorer,
1346                "strb", "\t$src, $addr",
1347                [(truncstorei8 GPR:$src, addrmode2:$addr)]>;
1348
1349 // Store doubleword
1350 let mayStore = 1, neverHasSideEffects = 1, hasExtraSrcRegAllocReq = 1 in
1351 def STRD : AI3std<(outs), (ins GPR:$src1, GPR:$src2, addrmode3:$addr),
1352                StMiscFrm, IIC_iStorer,
1353                "strd", "\t$src1, $addr", []>, Requires<[IsARM, HasV5TE]>;
1354
1355 // Indexed stores
1356 def STR_PRE  : AI2stwpr<(outs GPR:$base_wb),
1357                      (ins GPR:$src, GPR:$base, am2offset:$offset),
1358                      StFrm, IIC_iStoreru,
1359                     "str", "\t$src, [$base, $offset]!", "$base = $base_wb",
1360                     [(set GPR:$base_wb,
1361                       (pre_store GPR:$src, GPR:$base, am2offset:$offset))]>;
1362
1363 def STR_POST : AI2stwpo<(outs GPR:$base_wb),
1364                      (ins GPR:$src, GPR:$base,am2offset:$offset),
1365                      StFrm, IIC_iStoreru,
1366                     "str", "\t$src, [$base], $offset", "$base = $base_wb",
1367                     [(set GPR:$base_wb,
1368                       (post_store GPR:$src, GPR:$base, am2offset:$offset))]>;
1369
1370 def STRH_PRE : AI3sthpr<(outs GPR:$base_wb),
1371                      (ins GPR:$src, GPR:$base,am3offset:$offset),
1372                      StMiscFrm, IIC_iStoreru,
1373                      "strh", "\t$src, [$base, $offset]!", "$base = $base_wb",
1374                     [(set GPR:$base_wb,
1375                       (pre_truncsti16 GPR:$src, GPR:$base,am3offset:$offset))]>;
1376
1377 def STRH_POST: AI3sthpo<(outs GPR:$base_wb),
1378                      (ins GPR:$src, GPR:$base,am3offset:$offset),
1379                      StMiscFrm, IIC_iStoreru,
1380                      "strh", "\t$src, [$base], $offset", "$base = $base_wb",
1381                     [(set GPR:$base_wb, (post_truncsti16 GPR:$src,
1382                                          GPR:$base, am3offset:$offset))]>;
1383
1384 def STRB_PRE : AI2stbpr<(outs GPR:$base_wb),
1385                      (ins GPR:$src, GPR:$base,am2offset:$offset),
1386                      StFrm, IIC_iStoreru,
1387                      "strb", "\t$src, [$base, $offset]!", "$base = $base_wb",
1388                     [(set GPR:$base_wb, (pre_truncsti8 GPR:$src,
1389                                          GPR:$base, am2offset:$offset))]>;
1390
1391 def STRB_POST: AI2stbpo<(outs GPR:$base_wb),
1392                      (ins GPR:$src, GPR:$base,am2offset:$offset),
1393                      StFrm, IIC_iStoreru,
1394                      "strb", "\t$src, [$base], $offset", "$base = $base_wb",
1395                     [(set GPR:$base_wb, (post_truncsti8 GPR:$src,
1396                                          GPR:$base, am2offset:$offset))]>;
1397
1398 // For disassembly only
1399 def STRD_PRE : AI3stdpr<(outs GPR:$base_wb),
1400                      (ins GPR:$src1, GPR:$src2, GPR:$base, am3offset:$offset),
1401                      StMiscFrm, IIC_iStoreru,
1402                      "strd", "\t$src1, $src2, [$base, $offset]!",
1403                      "$base = $base_wb", []>;
1404
1405 // For disassembly only
1406 def STRD_POST: AI3stdpo<(outs GPR:$base_wb),
1407                      (ins GPR:$src1, GPR:$src2, GPR:$base, am3offset:$offset),
1408                      StMiscFrm, IIC_iStoreru,
1409                      "strd", "\t$src1, $src2, [$base], $offset",
1410                      "$base = $base_wb", []>;
1411
1412 // STRT, STRBT, and STRHT are for disassembly only.
1413
1414 def STRT : AI2stwpo<(outs GPR:$base_wb),
1415                     (ins GPR:$src, GPR:$base,am2offset:$offset),
1416                     StFrm, IIC_iStoreru,
1417                     "strt", "\t$src, [$base], $offset", "$base = $base_wb",
1418                     [/* For disassembly only; pattern left blank */]> {
1419   let Inst{21} = 1; // overwrite
1420 }
1421
1422 def STRBT : AI2stbpo<(outs GPR:$base_wb),
1423                      (ins GPR:$src, GPR:$base,am2offset:$offset),
1424                      StFrm, IIC_iStoreru,
1425                      "strbt", "\t$src, [$base], $offset", "$base = $base_wb",
1426                      [/* For disassembly only; pattern left blank */]> {
1427   let Inst{21} = 1; // overwrite
1428 }
1429
1430 def STRHT: AI3sthpo<(outs GPR:$base_wb),
1431                     (ins GPR:$src, GPR:$base,am3offset:$offset),
1432                     StMiscFrm, IIC_iStoreru,
1433                     "strht", "\t$src, [$base], $offset", "$base = $base_wb",
1434                     [/* For disassembly only; pattern left blank */]> {
1435   let Inst{21} = 1; // overwrite
1436 }
1437
1438 //===----------------------------------------------------------------------===//
1439 //  Load / store multiple Instructions.
1440 //
1441
1442 let mayLoad = 1, neverHasSideEffects = 1, hasExtraDefRegAllocReq = 1 in {
1443 def LDM : AXI4ld<(outs), (ins addrmode4:$addr, pred:$p,
1444                           reglist:$dsts, variable_ops),
1445                  IndexModeNone, LdStMulFrm, IIC_iLoadm,
1446                  "ldm${addr:submode}${p}\t$addr, $dsts", "", []>;
1447
1448 def LDM_UPD : AXI4ld<(outs GPR:$wb), (ins addrmode4:$addr, pred:$p,
1449                                       reglist:$dsts, variable_ops),
1450                      IndexModeUpd, LdStMulFrm, IIC_iLoadm,
1451                      "ldm${addr:submode}${p}\t$addr!, $dsts",
1452                      "$addr.addr = $wb", []>;
1453 } // mayLoad, neverHasSideEffects, hasExtraDefRegAllocReq
1454
1455 let mayStore = 1, neverHasSideEffects = 1, hasExtraSrcRegAllocReq = 1 in {
1456 def STM : AXI4st<(outs), (ins addrmode4:$addr, pred:$p,
1457                           reglist:$srcs, variable_ops),
1458                  IndexModeNone, LdStMulFrm, IIC_iStorem,
1459                  "stm${addr:submode}${p}\t$addr, $srcs", "", []>;
1460
1461 def STM_UPD : AXI4st<(outs GPR:$wb), (ins addrmode4:$addr, pred:$p,
1462                                       reglist:$srcs, variable_ops),
1463                      IndexModeUpd, LdStMulFrm, IIC_iStorem,
1464                      "stm${addr:submode}${p}\t$addr!, $srcs",
1465                      "$addr.addr = $wb", []>;
1466 } // mayStore, neverHasSideEffects, hasExtraSrcRegAllocReq
1467
1468 //===----------------------------------------------------------------------===//
1469 //  Move Instructions.
1470 //
1471
1472 let neverHasSideEffects = 1 in
1473 def MOVr : AsI1<0b1101, (outs GPR:$dst), (ins GPR:$src), DPFrm, IIC_iMOVr,
1474                 "mov", "\t$dst, $src", []>, UnaryDP {
1475   let Inst{11-4} = 0b00000000;
1476   let Inst{25} = 0;
1477 }
1478
1479 def MOVs : AsI1<0b1101, (outs GPR:$dst), (ins so_reg:$src),
1480                 DPSoRegFrm, IIC_iMOVsr,
1481                 "mov", "\t$dst, $src", [(set GPR:$dst, so_reg:$src)]>, UnaryDP {
1482   let Inst{25} = 0;
1483 }
1484
1485 let isReMaterializable = 1, isAsCheapAsAMove = 1 in
1486 def MOVi : AsI1<0b1101, (outs GPR:$dst), (ins so_imm:$src), DPFrm, IIC_iMOVi,
1487                 "mov", "\t$dst, $src", [(set GPR:$dst, so_imm:$src)]>, UnaryDP {
1488   let Inst{25} = 1;
1489 }
1490
1491 let isReMaterializable = 1, isAsCheapAsAMove = 1 in
1492 def MOVi16 : AI1<0b1000, (outs GPR:$dst), (ins i32imm:$src),
1493                  DPFrm, IIC_iMOVi,
1494                  "movw", "\t$dst, $src",
1495                  [(set GPR:$dst, imm0_65535:$src)]>,
1496                  Requires<[IsARM, HasV6T2]>, UnaryDP {
1497   let Inst{20} = 0;
1498   let Inst{25} = 1;
1499 }
1500
1501 let Constraints = "$src = $dst" in
1502 def MOVTi16 : AI1<0b1010, (outs GPR:$dst), (ins GPR:$src, i32imm:$imm),
1503                   DPFrm, IIC_iMOVi,
1504                   "movt", "\t$dst, $imm",
1505                   [(set GPR:$dst,
1506                         (or (and GPR:$src, 0xffff),
1507                             lo16AllZero:$imm))]>, UnaryDP,
1508                   Requires<[IsARM, HasV6T2]> {
1509   let Inst{20} = 0;
1510   let Inst{25} = 1;
1511 }
1512
1513 def : ARMPat<(or GPR:$src, 0xffff0000), (MOVTi16 GPR:$src, 0xffff)>,
1514       Requires<[IsARM, HasV6T2]>;
1515
1516 let Uses = [CPSR] in
1517 def MOVrx : AsI1<0b1101, (outs GPR:$dst), (ins GPR:$src), Pseudo, IIC_iMOVsi,
1518                  "mov", "\t$dst, $src, rrx",
1519                  [(set GPR:$dst, (ARMrrx GPR:$src))]>, UnaryDP;
1520
1521 // These aren't really mov instructions, but we have to define them this way
1522 // due to flag operands.
1523
1524 let Defs = [CPSR] in {
1525 def MOVsrl_flag : AI1<0b1101, (outs GPR:$dst), (ins GPR:$src), Pseudo,
1526                       IIC_iMOVsi, "movs", "\t$dst, $src, lsr #1",
1527                       [(set GPR:$dst, (ARMsrl_flag GPR:$src))]>, UnaryDP;
1528 def MOVsra_flag : AI1<0b1101, (outs GPR:$dst), (ins GPR:$src), Pseudo,
1529                       IIC_iMOVsi, "movs", "\t$dst, $src, asr #1",
1530                       [(set GPR:$dst, (ARMsra_flag GPR:$src))]>, UnaryDP;
1531 }
1532
1533 //===----------------------------------------------------------------------===//
1534 //  Extend Instructions.
1535 //
1536
1537 // Sign extenders
1538
1539 defm SXTB  : AI_unary_rrot<0b01101010,
1540                            "sxtb", UnOpFrag<(sext_inreg node:$Src, i8)>>;
1541 defm SXTH  : AI_unary_rrot<0b01101011,
1542                            "sxth", UnOpFrag<(sext_inreg node:$Src, i16)>>;
1543
1544 defm SXTAB : AI_bin_rrot<0b01101010,
1545                "sxtab", BinOpFrag<(add node:$LHS, (sext_inreg node:$RHS, i8))>>;
1546 defm SXTAH : AI_bin_rrot<0b01101011,
1547                "sxtah", BinOpFrag<(add node:$LHS, (sext_inreg node:$RHS,i16))>>;
1548
1549 // For disassembly only
1550 defm SXTB16  : AI_unary_rrot_np<0b01101000, "sxtb16">;
1551
1552 // For disassembly only
1553 defm SXTAB16 : AI_bin_rrot_np<0b01101000, "sxtab16">;
1554
1555 // Zero extenders
1556
1557 let AddedComplexity = 16 in {
1558 defm UXTB   : AI_unary_rrot<0b01101110,
1559                             "uxtb"  , UnOpFrag<(and node:$Src, 0x000000FF)>>;
1560 defm UXTH   : AI_unary_rrot<0b01101111,
1561                             "uxth"  , UnOpFrag<(and node:$Src, 0x0000FFFF)>>;
1562 defm UXTB16 : AI_unary_rrot<0b01101100,
1563                             "uxtb16", UnOpFrag<(and node:$Src, 0x00FF00FF)>>;
1564
1565 def : ARMV6Pat<(and (shl GPR:$Src, (i32 8)), 0xFF00FF),
1566                (UXTB16r_rot GPR:$Src, 24)>;
1567 def : ARMV6Pat<(and (srl GPR:$Src, (i32 8)), 0xFF00FF),
1568                (UXTB16r_rot GPR:$Src, 8)>;
1569
1570 defm UXTAB : AI_bin_rrot<0b01101110, "uxtab",
1571                         BinOpFrag<(add node:$LHS, (and node:$RHS, 0x00FF))>>;
1572 defm UXTAH : AI_bin_rrot<0b01101111, "uxtah",
1573                         BinOpFrag<(add node:$LHS, (and node:$RHS, 0xFFFF))>>;
1574 }
1575
1576 // This isn't safe in general, the add is two 16-bit units, not a 32-bit add.
1577 // For disassembly only
1578 defm UXTAB16 : AI_bin_rrot_np<0b01101100, "uxtab16">;
1579
1580
1581 def SBFX  : I<(outs GPR:$dst),
1582               (ins GPR:$src, imm0_31:$lsb, imm0_31:$width),
1583                AddrMode1, Size4Bytes, IndexModeNone, DPFrm, IIC_iALUi,
1584                "sbfx", "\t$dst, $src, $lsb, $width", "", []>,
1585                Requires<[IsARM, HasV6T2]> {
1586   let Inst{27-21} = 0b0111101;
1587   let Inst{6-4}   = 0b101;
1588 }
1589
1590 def UBFX  : I<(outs GPR:$dst),
1591               (ins GPR:$src, imm0_31:$lsb, imm0_31:$width),
1592                AddrMode1, Size4Bytes, IndexModeNone, DPFrm, IIC_iALUi,
1593                "ubfx", "\t$dst, $src, $lsb, $width", "", []>,
1594                Requires<[IsARM, HasV6T2]> {
1595   let Inst{27-21} = 0b0111111;
1596   let Inst{6-4}   = 0b101;
1597 }
1598
1599 //===----------------------------------------------------------------------===//
1600 //  Arithmetic Instructions.
1601 //
1602
1603 defm ADD  : AsI1_bin_irs<0b0100, "add",
1604                          BinOpFrag<(add  node:$LHS, node:$RHS)>, 1>;
1605 defm SUB  : AsI1_bin_irs<0b0010, "sub",
1606                          BinOpFrag<(sub  node:$LHS, node:$RHS)>>;
1607
1608 // ADD and SUB with 's' bit set.
1609 defm ADDS : AI1_bin_s_irs<0b0100, "adds",
1610                           BinOpFrag<(addc node:$LHS, node:$RHS)>, 1>;
1611 defm SUBS : AI1_bin_s_irs<0b0010, "subs",
1612                           BinOpFrag<(subc node:$LHS, node:$RHS)>>;
1613
1614 defm ADC : AI1_adde_sube_irs<0b0101, "adc",
1615                           BinOpFrag<(adde_dead_carry node:$LHS, node:$RHS)>, 1>;
1616 defm SBC : AI1_adde_sube_irs<0b0110, "sbc",
1617                           BinOpFrag<(sube_dead_carry node:$LHS, node:$RHS)>>;
1618 defm ADCS : AI1_adde_sube_s_irs<0b0101, "adcs",
1619                           BinOpFrag<(adde_live_carry node:$LHS, node:$RHS)>, 1>;
1620 defm SBCS : AI1_adde_sube_s_irs<0b0110, "sbcs",
1621                           BinOpFrag<(sube_live_carry node:$LHS, node:$RHS) >>;
1622
1623 // These don't define reg/reg forms, because they are handled above.
1624 def RSBri : AsI1<0b0011, (outs GPR:$dst), (ins GPR:$a, so_imm:$b), DPFrm,
1625                   IIC_iALUi, "rsb", "\t$dst, $a, $b",
1626                   [(set GPR:$dst, (sub so_imm:$b, GPR:$a))]> {
1627     let Inst{25} = 1;
1628 }
1629
1630 def RSBrs : AsI1<0b0011, (outs GPR:$dst), (ins GPR:$a, so_reg:$b), DPSoRegFrm,
1631                   IIC_iALUsr, "rsb", "\t$dst, $a, $b",
1632                   [(set GPR:$dst, (sub so_reg:$b, GPR:$a))]> {
1633     let Inst{25} = 0;
1634 }
1635
1636 // RSB with 's' bit set.
1637 let Defs = [CPSR] in {
1638 def RSBSri : AI1<0b0011, (outs GPR:$dst), (ins GPR:$a, so_imm:$b), DPFrm,
1639                  IIC_iALUi, "rsbs", "\t$dst, $a, $b",
1640                  [(set GPR:$dst, (subc so_imm:$b, GPR:$a))]> {
1641     let Inst{20} = 1;
1642     let Inst{25} = 1;
1643 }
1644 def RSBSrs : AI1<0b0011, (outs GPR:$dst), (ins GPR:$a, so_reg:$b), DPSoRegFrm,
1645                  IIC_iALUsr, "rsbs", "\t$dst, $a, $b",
1646                  [(set GPR:$dst, (subc so_reg:$b, GPR:$a))]> {
1647     let Inst{20} = 1;
1648     let Inst{25} = 0;
1649 }
1650 }
1651
1652 let Uses = [CPSR] in {
1653 def RSCri : AsI1<0b0111, (outs GPR:$dst), (ins GPR:$a, so_imm:$b),
1654                  DPFrm, IIC_iALUi, "rsc", "\t$dst, $a, $b",
1655                  [(set GPR:$dst, (sube_dead_carry so_imm:$b, GPR:$a))]>,
1656                  Requires<[IsARM]> {
1657     let Inst{25} = 1;
1658 }
1659 def RSCrs : AsI1<0b0111, (outs GPR:$dst), (ins GPR:$a, so_reg:$b),
1660                  DPSoRegFrm, IIC_iALUsr, "rsc", "\t$dst, $a, $b",
1661                  [(set GPR:$dst, (sube_dead_carry so_reg:$b, GPR:$a))]>,
1662                  Requires<[IsARM]> {
1663     let Inst{25} = 0;
1664 }
1665 }
1666
1667 // FIXME: Allow these to be predicated.
1668 let Defs = [CPSR], Uses = [CPSR] in {
1669 def RSCSri : AXI1<0b0111, (outs GPR:$dst), (ins GPR:$a, so_imm:$b),
1670                   DPFrm, IIC_iALUi, "rscs\t$dst, $a, $b",
1671                   [(set GPR:$dst, (sube_dead_carry so_imm:$b, GPR:$a))]>,
1672                   Requires<[IsARM]> {
1673     let Inst{20} = 1;
1674     let Inst{25} = 1;
1675 }
1676 def RSCSrs : AXI1<0b0111, (outs GPR:$dst), (ins GPR:$a, so_reg:$b),
1677                   DPSoRegFrm, IIC_iALUsr, "rscs\t$dst, $a, $b",
1678                   [(set GPR:$dst, (sube_dead_carry so_reg:$b, GPR:$a))]>,
1679                   Requires<[IsARM]> {
1680     let Inst{20} = 1;
1681     let Inst{25} = 0;
1682 }
1683 }
1684
1685 // (sub X, imm) gets canonicalized to (add X, -imm).  Match this form.
1686 def : ARMPat<(add    GPR:$src, so_imm_neg:$imm),
1687              (SUBri  GPR:$src, so_imm_neg:$imm)>;
1688
1689 //def : ARMPat<(addc   GPR:$src, so_imm_neg:$imm),
1690 //             (SUBSri GPR:$src, so_imm_neg:$imm)>;
1691 //def : ARMPat<(adde   GPR:$src, so_imm_neg:$imm),
1692 //             (SBCri  GPR:$src, so_imm_neg:$imm)>;
1693
1694 // Note: These are implemented in C++ code, because they have to generate
1695 // ADD/SUBrs instructions, which use a complex pattern that a xform function
1696 // cannot produce.
1697 // (mul X, 2^n+1) -> (add (X << n), X)
1698 // (mul X, 2^n-1) -> (rsb X, (X << n))
1699
1700 // ARM Arithmetic Instruction -- for disassembly only
1701 // GPR:$dst = GPR:$a op GPR:$b
1702 class AAI<bits<8> op27_20, bits<4> op7_4, string opc>
1703   : AI<(outs GPR:$dst), (ins GPR:$a, GPR:$b), DPFrm, IIC_iALUr,
1704        opc, "\t$dst, $a, $b",
1705        [/* For disassembly only; pattern left blank */]> {
1706   let Inst{27-20} = op27_20;
1707   let Inst{7-4} = op7_4;
1708 }
1709
1710 // Saturating add/subtract -- for disassembly only
1711
1712 def QADD    : AAI<0b00010000, 0b0101, "qadd">;
1713 def QADD16  : AAI<0b01100010, 0b0001, "qadd16">;
1714 def QADD8   : AAI<0b01100010, 0b1001, "qadd8">;
1715 def QASX    : AAI<0b01100010, 0b0011, "qasx">;
1716 def QDADD   : AAI<0b00010100, 0b0101, "qdadd">;
1717 def QDSUB   : AAI<0b00010110, 0b0101, "qdsub">;
1718 def QSAX    : AAI<0b01100010, 0b0101, "qsax">;
1719 def QSUB    : AAI<0b00010010, 0b0101, "qsub">;
1720 def QSUB16  : AAI<0b01100010, 0b0111, "qsub16">;
1721 def QSUB8   : AAI<0b01100010, 0b1111, "qsub8">;
1722 def UQADD16 : AAI<0b01100110, 0b0001, "uqadd16">;
1723 def UQADD8  : AAI<0b01100110, 0b1001, "uqadd8">;
1724 def UQASX   : AAI<0b01100110, 0b0011, "uqasx">;
1725 def UQSAX   : AAI<0b01100110, 0b0101, "uqsax">;
1726 def UQSUB16 : AAI<0b01100110, 0b0111, "uqsub16">;
1727 def UQSUB8  : AAI<0b01100110, 0b1111, "uqsub8">;
1728
1729 // Signed/Unsigned add/subtract -- for disassembly only
1730
1731 def SASX   : AAI<0b01100001, 0b0011, "sasx">;
1732 def SADD16 : AAI<0b01100001, 0b0001, "sadd16">;
1733 def SADD8  : AAI<0b01100001, 0b1001, "sadd8">;
1734 def SSAX   : AAI<0b01100001, 0b0101, "ssax">;
1735 def SSUB16 : AAI<0b01100001, 0b0111, "ssub16">;
1736 def SSUB8  : AAI<0b01100001, 0b1111, "ssub8">;
1737 def UASX   : AAI<0b01100101, 0b0011, "uasx">;
1738 def UADD16 : AAI<0b01100101, 0b0001, "uadd16">;
1739 def UADD8  : AAI<0b01100101, 0b1001, "uadd8">;
1740 def USAX   : AAI<0b01100101, 0b0101, "usax">;
1741 def USUB16 : AAI<0b01100101, 0b0111, "usub16">;
1742 def USUB8  : AAI<0b01100101, 0b1111, "usub8">;
1743
1744 // Signed/Unsigned halving add/subtract -- for disassembly only
1745
1746 def SHASX   : AAI<0b01100011, 0b0011, "shasx">;
1747 def SHADD16 : AAI<0b01100011, 0b0001, "shadd16">;
1748 def SHADD8  : AAI<0b01100011, 0b1001, "shadd8">;
1749 def SHSAX   : AAI<0b01100011, 0b0101, "shsax">;
1750 def SHSUB16 : AAI<0b01100011, 0b0111, "shsub16">;
1751 def SHSUB8  : AAI<0b01100011, 0b1111, "shsub8">;
1752 def UHASX   : AAI<0b01100111, 0b0011, "uhasx">;
1753 def UHADD16 : AAI<0b01100111, 0b0001, "uhadd16">;
1754 def UHADD8  : AAI<0b01100111, 0b1001, "uhadd8">;
1755 def UHSAX   : AAI<0b01100111, 0b0101, "uhsax">;
1756 def UHSUB16 : AAI<0b01100111, 0b0111, "uhsub16">;
1757 def UHSUB8  : AAI<0b01100111, 0b1111, "uhsub8">;
1758
1759 // Unsigned Sum of Absolute Differences [and Accumulate] -- for disassembly only
1760
1761 def USAD8  : AI<(outs GPR:$dst), (ins GPR:$a, GPR:$b),
1762                 MulFrm /* for convenience */, NoItinerary, "usad8",
1763                 "\t$dst, $a, $b", []>,
1764              Requires<[IsARM, HasV6]> {
1765   let Inst{27-20} = 0b01111000;
1766   let Inst{15-12} = 0b1111;
1767   let Inst{7-4} = 0b0001;
1768 }
1769 def USADA8 : AI<(outs GPR:$dst), (ins GPR:$a, GPR:$b, GPR:$acc),
1770                 MulFrm /* for convenience */, NoItinerary, "usada8",
1771                 "\t$dst, $a, $b, $acc", []>,
1772              Requires<[IsARM, HasV6]> {
1773   let Inst{27-20} = 0b01111000;
1774   let Inst{7-4} = 0b0001;
1775 }
1776
1777 // Signed/Unsigned saturate -- for disassembly only
1778
1779 def SSATlsl : AI<(outs GPR:$dst), (ins i32imm:$bit_pos, GPR:$a, i32imm:$shamt),
1780                  DPFrm, NoItinerary, "ssat", "\t$dst, $bit_pos, $a, lsl $shamt",
1781                  [/* For disassembly only; pattern left blank */]> {
1782   let Inst{27-21} = 0b0110101;
1783   let Inst{6-4} = 0b001;
1784 }
1785
1786 def SSATasr : AI<(outs GPR:$dst), (ins i32imm:$bit_pos, GPR:$a, i32imm:$shamt),
1787                  DPFrm, NoItinerary, "ssat", "\t$dst, $bit_pos, $a, asr $shamt",
1788                  [/* For disassembly only; pattern left blank */]> {
1789   let Inst{27-21} = 0b0110101;
1790   let Inst{6-4} = 0b101;
1791 }
1792
1793 def SSAT16 : AI<(outs GPR:$dst), (ins i32imm:$bit_pos, GPR:$a), DPFrm,
1794                 NoItinerary, "ssat16", "\t$dst, $bit_pos, $a",
1795                 [/* For disassembly only; pattern left blank */]> {
1796   let Inst{27-20} = 0b01101010;
1797   let Inst{7-4} = 0b0011;
1798 }
1799
1800 def USATlsl : AI<(outs GPR:$dst), (ins i32imm:$bit_pos, GPR:$a, i32imm:$shamt),
1801                  DPFrm, NoItinerary, "usat", "\t$dst, $bit_pos, $a, lsl $shamt",
1802                  [/* For disassembly only; pattern left blank */]> {
1803   let Inst{27-21} = 0b0110111;
1804   let Inst{6-4} = 0b001;
1805 }
1806
1807 def USATasr : AI<(outs GPR:$dst), (ins i32imm:$bit_pos, GPR:$a, i32imm:$shamt),
1808                  DPFrm, NoItinerary, "usat", "\t$dst, $bit_pos, $a, asr $shamt",
1809                  [/* For disassembly only; pattern left blank */]> {
1810   let Inst{27-21} = 0b0110111;
1811   let Inst{6-4} = 0b101;
1812 }
1813
1814 def USAT16 : AI<(outs GPR:$dst), (ins i32imm:$bit_pos, GPR:$a), DPFrm,
1815                 NoItinerary, "usat16", "\t$dst, $bit_pos, $a",
1816                 [/* For disassembly only; pattern left blank */]> {
1817   let Inst{27-20} = 0b01101110;
1818   let Inst{7-4} = 0b0011;
1819 }
1820
1821 //===----------------------------------------------------------------------===//
1822 //  Bitwise Instructions.
1823 //
1824
1825 defm AND   : AsI1_bin_irs<0b0000, "and",
1826                           BinOpFrag<(and node:$LHS, node:$RHS)>, 1>;
1827 defm ORR   : AsI1_bin_irs<0b1100, "orr",
1828                           BinOpFrag<(or  node:$LHS, node:$RHS)>, 1>;
1829 defm EOR   : AsI1_bin_irs<0b0001, "eor",
1830                           BinOpFrag<(xor node:$LHS, node:$RHS)>, 1>;
1831 defm BIC   : AsI1_bin_irs<0b1110, "bic",
1832                           BinOpFrag<(and node:$LHS, (not node:$RHS))>>;
1833
1834 def BFC    : I<(outs GPR:$dst), (ins GPR:$src, bf_inv_mask_imm:$imm),
1835                AddrMode1, Size4Bytes, IndexModeNone, DPFrm, IIC_iUNAsi,
1836                "bfc", "\t$dst, $imm", "$src = $dst",
1837                [(set GPR:$dst, (and GPR:$src, bf_inv_mask_imm:$imm))]>,
1838                Requires<[IsARM, HasV6T2]> {
1839   let Inst{27-21} = 0b0111110;
1840   let Inst{6-0}   = 0b0011111;
1841 }
1842
1843 // A8.6.18  BFI - Bitfield insert (Encoding A1)
1844 // Added for disassembler with the pattern field purposely left blank.
1845 def BFI    : I<(outs GPR:$dst), (ins GPR:$src, bf_inv_mask_imm:$imm),
1846                AddrMode1, Size4Bytes, IndexModeNone, DPFrm, IIC_iUNAsi,
1847                "bfi", "\t$dst, $src, $imm", "",
1848                [/* For disassembly only; pattern left blank */]>,
1849                Requires<[IsARM, HasV6T2]> {
1850   let Inst{27-21} = 0b0111110;
1851   let Inst{6-4}   = 0b001; // Rn: Inst{3-0} != 15
1852 }
1853
1854 def  MVNr  : AsI1<0b1111, (outs GPR:$dst), (ins GPR:$src), DPFrm, IIC_iMOVr,
1855                   "mvn", "\t$dst, $src",
1856                   [(set GPR:$dst, (not GPR:$src))]>, UnaryDP {
1857   let Inst{25} = 0;
1858   let Inst{11-4} = 0b00000000;
1859 }
1860 def  MVNs  : AsI1<0b1111, (outs GPR:$dst), (ins so_reg:$src), DPSoRegFrm,
1861                   IIC_iMOVsr, "mvn", "\t$dst, $src",
1862                   [(set GPR:$dst, (not so_reg:$src))]>, UnaryDP {
1863   let Inst{25} = 0;
1864 }
1865 let isReMaterializable = 1, isAsCheapAsAMove = 1 in
1866 def  MVNi  : AsI1<0b1111, (outs GPR:$dst), (ins so_imm:$imm), DPFrm,
1867                   IIC_iMOVi, "mvn", "\t$dst, $imm",
1868                   [(set GPR:$dst, so_imm_not:$imm)]>,UnaryDP {
1869     let Inst{25} = 1;
1870 }
1871
1872 def : ARMPat<(and   GPR:$src, so_imm_not:$imm),
1873              (BICri GPR:$src, so_imm_not:$imm)>;
1874
1875 //===----------------------------------------------------------------------===//
1876 //  Multiply Instructions.
1877 //
1878
1879 let isCommutable = 1 in
1880 def MUL   : AsMul1I<0b0000000, (outs GPR:$dst), (ins GPR:$a, GPR:$b),
1881                    IIC_iMUL32, "mul", "\t$dst, $a, $b",
1882                    [(set GPR:$dst, (mul GPR:$a, GPR:$b))]>;
1883
1884 def MLA   : AsMul1I<0b0000001, (outs GPR:$dst), (ins GPR:$a, GPR:$b, GPR:$c),
1885                     IIC_iMAC32, "mla", "\t$dst, $a, $b, $c",
1886                    [(set GPR:$dst, (add (mul GPR:$a, GPR:$b), GPR:$c))]>;
1887
1888 def MLS   : AMul1I<0b0000011, (outs GPR:$dst), (ins GPR:$a, GPR:$b, GPR:$c),
1889                    IIC_iMAC32, "mls", "\t$dst, $a, $b, $c",
1890                    [(set GPR:$dst, (sub GPR:$c, (mul GPR:$a, GPR:$b)))]>,
1891                    Requires<[IsARM, HasV6T2]>;
1892
1893 // Extra precision multiplies with low / high results
1894 let neverHasSideEffects = 1 in {
1895 let isCommutable = 1 in {
1896 def SMULL : AsMul1I<0b0000110, (outs GPR:$ldst, GPR:$hdst),
1897                                (ins GPR:$a, GPR:$b), IIC_iMUL64,
1898                     "smull", "\t$ldst, $hdst, $a, $b", []>;
1899
1900 def UMULL : AsMul1I<0b0000100, (outs GPR:$ldst, GPR:$hdst),
1901                                (ins GPR:$a, GPR:$b), IIC_iMUL64,
1902                     "umull", "\t$ldst, $hdst, $a, $b", []>;
1903 }
1904
1905 // Multiply + accumulate
1906 def SMLAL : AsMul1I<0b0000111, (outs GPR:$ldst, GPR:$hdst),
1907                                (ins GPR:$a, GPR:$b), IIC_iMAC64,
1908                     "smlal", "\t$ldst, $hdst, $a, $b", []>;
1909
1910 def UMLAL : AsMul1I<0b0000101, (outs GPR:$ldst, GPR:$hdst),
1911                                (ins GPR:$a, GPR:$b), IIC_iMAC64,
1912                     "umlal", "\t$ldst, $hdst, $a, $b", []>;
1913
1914 def UMAAL : AMul1I <0b0000010, (outs GPR:$ldst, GPR:$hdst),
1915                                (ins GPR:$a, GPR:$b), IIC_iMAC64,
1916                     "umaal", "\t$ldst, $hdst, $a, $b", []>,
1917                     Requires<[IsARM, HasV6]>;
1918 } // neverHasSideEffects
1919
1920 // Most significant word multiply
1921 def SMMUL : AMul2I <0b0111010, (outs GPR:$dst), (ins GPR:$a, GPR:$b),
1922                IIC_iMUL32, "smmul", "\t$dst, $a, $b",
1923                [(set GPR:$dst, (mulhs GPR:$a, GPR:$b))]>,
1924             Requires<[IsARM, HasV6]> {
1925   let Inst{7-4}   = 0b0001;
1926   let Inst{15-12} = 0b1111;
1927 }
1928
1929 def SMMULR : AMul2I <0b0111010, (outs GPR:$dst), (ins GPR:$a, GPR:$b),
1930                IIC_iMUL32, "smmulr", "\t$dst, $a, $b",
1931                [/* For disassembly only; pattern left blank */]>,
1932             Requires<[IsARM, HasV6]> {
1933   let Inst{7-4}   = 0b0011; // R = 1
1934   let Inst{15-12} = 0b1111;
1935 }
1936
1937 def SMMLA : AMul2I <0b0111010, (outs GPR:$dst), (ins GPR:$a, GPR:$b, GPR:$c),
1938                IIC_iMAC32, "smmla", "\t$dst, $a, $b, $c",
1939                [(set GPR:$dst, (add (mulhs GPR:$a, GPR:$b), GPR:$c))]>,
1940             Requires<[IsARM, HasV6]> {
1941   let Inst{7-4}   = 0b0001;
1942 }
1943
1944 def SMMLAR : AMul2I <0b0111010, (outs GPR:$dst), (ins GPR:$a, GPR:$b, GPR:$c),
1945                IIC_iMAC32, "smmlar", "\t$dst, $a, $b, $c",
1946                [/* For disassembly only; pattern left blank */]>,
1947             Requires<[IsARM, HasV6]> {
1948   let Inst{7-4}   = 0b0011; // R = 1
1949 }
1950
1951 def SMMLS : AMul2I <0b0111010, (outs GPR:$dst), (ins GPR:$a, GPR:$b, GPR:$c),
1952                IIC_iMAC32, "smmls", "\t$dst, $a, $b, $c",
1953                [(set GPR:$dst, (sub GPR:$c, (mulhs GPR:$a, GPR:$b)))]>,
1954             Requires<[IsARM, HasV6]> {
1955   let Inst{7-4}   = 0b1101;
1956 }
1957
1958 def SMMLSR : AMul2I <0b0111010, (outs GPR:$dst), (ins GPR:$a, GPR:$b, GPR:$c),
1959                IIC_iMAC32, "smmlsr", "\t$dst, $a, $b, $c",
1960                [/* For disassembly only; pattern left blank */]>,
1961             Requires<[IsARM, HasV6]> {
1962   let Inst{7-4}   = 0b1111; // R = 1
1963 }
1964
1965 multiclass AI_smul<string opc, PatFrag opnode> {
1966   def BB : AMulxyI<0b0001011, (outs GPR:$dst), (ins GPR:$a, GPR:$b),
1967               IIC_iMUL32, !strconcat(opc, "bb"), "\t$dst, $a, $b",
1968               [(set GPR:$dst, (opnode (sext_inreg GPR:$a, i16),
1969                                       (sext_inreg GPR:$b, i16)))]>,
1970            Requires<[IsARM, HasV5TE]> {
1971              let Inst{5} = 0;
1972              let Inst{6} = 0;
1973            }
1974
1975   def BT : AMulxyI<0b0001011, (outs GPR:$dst), (ins GPR:$a, GPR:$b),
1976               IIC_iMUL32, !strconcat(opc, "bt"), "\t$dst, $a, $b",
1977               [(set GPR:$dst, (opnode (sext_inreg GPR:$a, i16),
1978                                       (sra GPR:$b, (i32 16))))]>,
1979            Requires<[IsARM, HasV5TE]> {
1980              let Inst{5} = 0;
1981              let Inst{6} = 1;
1982            }
1983
1984   def TB : AMulxyI<0b0001011, (outs GPR:$dst), (ins GPR:$a, GPR:$b),
1985               IIC_iMUL32, !strconcat(opc, "tb"), "\t$dst, $a, $b",
1986               [(set GPR:$dst, (opnode (sra GPR:$a, (i32 16)),
1987                                       (sext_inreg GPR:$b, i16)))]>,
1988            Requires<[IsARM, HasV5TE]> {
1989              let Inst{5} = 1;
1990              let Inst{6} = 0;
1991            }
1992
1993   def TT : AMulxyI<0b0001011, (outs GPR:$dst), (ins GPR:$a, GPR:$b),
1994               IIC_iMUL32, !strconcat(opc, "tt"), "\t$dst, $a, $b",
1995               [(set GPR:$dst, (opnode (sra GPR:$a, (i32 16)),
1996                                       (sra GPR:$b, (i32 16))))]>,
1997             Requires<[IsARM, HasV5TE]> {
1998              let Inst{5} = 1;
1999              let Inst{6} = 1;
2000            }
2001
2002   def WB : AMulxyI<0b0001001, (outs GPR:$dst), (ins GPR:$a, GPR:$b),
2003               IIC_iMUL16, !strconcat(opc, "wb"), "\t$dst, $a, $b",
2004               [(set GPR:$dst, (sra (opnode GPR:$a,
2005                                     (sext_inreg GPR:$b, i16)), (i32 16)))]>,
2006            Requires<[IsARM, HasV5TE]> {
2007              let Inst{5} = 1;
2008              let Inst{6} = 0;
2009            }
2010
2011   def WT : AMulxyI<0b0001001, (outs GPR:$dst), (ins GPR:$a, GPR:$b),
2012               IIC_iMUL16, !strconcat(opc, "wt"), "\t$dst, $a, $b",
2013               [(set GPR:$dst, (sra (opnode GPR:$a,
2014                                     (sra GPR:$b, (i32 16))), (i32 16)))]>,
2015             Requires<[IsARM, HasV5TE]> {
2016              let Inst{5} = 1;
2017              let Inst{6} = 1;
2018            }
2019 }
2020
2021
2022 multiclass AI_smla<string opc, PatFrag opnode> {
2023   def BB : AMulxyI<0b0001000, (outs GPR:$dst), (ins GPR:$a, GPR:$b, GPR:$acc),
2024               IIC_iMAC16, !strconcat(opc, "bb"), "\t$dst, $a, $b, $acc",
2025               [(set GPR:$dst, (add GPR:$acc,
2026                                (opnode (sext_inreg GPR:$a, i16),
2027                                        (sext_inreg GPR:$b, i16))))]>,
2028            Requires<[IsARM, HasV5TE]> {
2029              let Inst{5} = 0;
2030              let Inst{6} = 0;
2031            }
2032
2033   def BT : AMulxyI<0b0001000, (outs GPR:$dst), (ins GPR:$a, GPR:$b, GPR:$acc),
2034               IIC_iMAC16, !strconcat(opc, "bt"), "\t$dst, $a, $b, $acc",
2035               [(set GPR:$dst, (add GPR:$acc, (opnode (sext_inreg GPR:$a, i16),
2036                                                     (sra GPR:$b, (i32 16)))))]>,
2037            Requires<[IsARM, HasV5TE]> {
2038              let Inst{5} = 0;
2039              let Inst{6} = 1;
2040            }
2041
2042   def TB : AMulxyI<0b0001000, (outs GPR:$dst), (ins GPR:$a, GPR:$b, GPR:$acc),
2043               IIC_iMAC16, !strconcat(opc, "tb"), "\t$dst, $a, $b, $acc",
2044               [(set GPR:$dst, (add GPR:$acc, (opnode (sra GPR:$a, (i32 16)),
2045                                                  (sext_inreg GPR:$b, i16))))]>,
2046            Requires<[IsARM, HasV5TE]> {
2047              let Inst{5} = 1;
2048              let Inst{6} = 0;
2049            }
2050
2051   def TT : AMulxyI<0b0001000, (outs GPR:$dst), (ins GPR:$a, GPR:$b, GPR:$acc),
2052               IIC_iMAC16, !strconcat(opc, "tt"), "\t$dst, $a, $b, $acc",
2053              [(set GPR:$dst, (add GPR:$acc, (opnode (sra GPR:$a, (i32 16)),
2054                                                     (sra GPR:$b, (i32 16)))))]>,
2055             Requires<[IsARM, HasV5TE]> {
2056              let Inst{5} = 1;
2057              let Inst{6} = 1;
2058            }
2059
2060   def WB : AMulxyI<0b0001001, (outs GPR:$dst), (ins GPR:$a, GPR:$b, GPR:$acc),
2061               IIC_iMAC16, !strconcat(opc, "wb"), "\t$dst, $a, $b, $acc",
2062               [(set GPR:$dst, (add GPR:$acc, (sra (opnode GPR:$a,
2063                                        (sext_inreg GPR:$b, i16)), (i32 16))))]>,
2064            Requires<[IsARM, HasV5TE]> {
2065              let Inst{5} = 0;
2066              let Inst{6} = 0;
2067            }
2068
2069   def WT : AMulxyI<0b0001001, (outs GPR:$dst), (ins GPR:$a, GPR:$b, GPR:$acc),
2070               IIC_iMAC16, !strconcat(opc, "wt"), "\t$dst, $a, $b, $acc",
2071               [(set GPR:$dst, (add GPR:$acc, (sra (opnode GPR:$a,
2072                                          (sra GPR:$b, (i32 16))), (i32 16))))]>,
2073             Requires<[IsARM, HasV5TE]> {
2074              let Inst{5} = 0;
2075              let Inst{6} = 1;
2076            }
2077 }
2078
2079 defm SMUL : AI_smul<"smul", BinOpFrag<(mul node:$LHS, node:$RHS)>>;
2080 defm SMLA : AI_smla<"smla", BinOpFrag<(mul node:$LHS, node:$RHS)>>;
2081
2082 // Halfword multiply accumulate long: SMLAL<x><y> -- for disassembly only
2083 def SMLALBB : AMulxyI<0b0001010,(outs GPR:$ldst,GPR:$hdst),(ins GPR:$a,GPR:$b),
2084                       IIC_iMAC64, "smlalbb", "\t$ldst, $hdst, $a, $b",
2085                       [/* For disassembly only; pattern left blank */]>,
2086               Requires<[IsARM, HasV5TE]> {
2087   let Inst{5} = 0;
2088   let Inst{6} = 0;
2089 }
2090
2091 def SMLALBT : AMulxyI<0b0001010,(outs GPR:$ldst,GPR:$hdst),(ins GPR:$a,GPR:$b),
2092                       IIC_iMAC64, "smlalbt", "\t$ldst, $hdst, $a, $b",
2093                       [/* For disassembly only; pattern left blank */]>,
2094               Requires<[IsARM, HasV5TE]> {
2095   let Inst{5} = 0;
2096   let Inst{6} = 1;
2097 }
2098
2099 def SMLALTB : AMulxyI<0b0001010,(outs GPR:$ldst,GPR:$hdst),(ins GPR:$a,GPR:$b),
2100                       IIC_iMAC64, "smlaltb", "\t$ldst, $hdst, $a, $b",
2101                       [/* For disassembly only; pattern left blank */]>,
2102               Requires<[IsARM, HasV5TE]> {
2103   let Inst{5} = 1;
2104   let Inst{6} = 0;
2105 }
2106
2107 def SMLALTT : AMulxyI<0b0001010,(outs GPR:$ldst,GPR:$hdst),(ins GPR:$a,GPR:$b),
2108                       IIC_iMAC64, "smlaltt", "\t$ldst, $hdst, $a, $b",
2109                       [/* For disassembly only; pattern left blank */]>,
2110               Requires<[IsARM, HasV5TE]> {
2111   let Inst{5} = 1;
2112   let Inst{6} = 1;
2113 }
2114
2115 // Helper class for AI_smld -- for disassembly only
2116 class AMulDualI<bit long, bit sub, bit swap, dag oops, dag iops,
2117                 InstrItinClass itin, string opc, string asm>
2118   : AI<oops, iops, MulFrm, itin, opc, asm, []>, Requires<[IsARM, HasV6]> {
2119   let Inst{4}     = 1;
2120   let Inst{5}     = swap;
2121   let Inst{6}     = sub;
2122   let Inst{7}     = 0;
2123   let Inst{21-20} = 0b00;
2124   let Inst{22}    = long;
2125   let Inst{27-23} = 0b01110;
2126 }
2127
2128 multiclass AI_smld<bit sub, string opc> {
2129
2130   def D : AMulDualI<0, sub, 0, (outs GPR:$dst), (ins GPR:$a, GPR:$b, GPR:$acc),
2131                   NoItinerary, !strconcat(opc, "d"), "\t$dst, $a, $b, $acc">;
2132
2133   def DX : AMulDualI<0, sub, 1, (outs GPR:$dst), (ins GPR:$a, GPR:$b, GPR:$acc),
2134                   NoItinerary, !strconcat(opc, "dx"), "\t$dst, $a, $b, $acc">;
2135
2136   def LD : AMulDualI<1, sub, 0, (outs GPR:$ldst,GPR:$hdst), (ins GPR:$a,GPR:$b),
2137                   NoItinerary, !strconcat(opc, "ld"), "\t$ldst, $hdst, $a, $b">;
2138
2139   def LDX : AMulDualI<1, sub, 1, (outs GPR:$ldst,GPR:$hdst),(ins GPR:$a,GPR:$b),
2140                   NoItinerary, !strconcat(opc, "ldx"),"\t$ldst, $hdst, $a, $b">;
2141
2142 }
2143
2144 defm SMLA : AI_smld<0, "smla">;
2145 defm SMLS : AI_smld<1, "smls">;
2146
2147 multiclass AI_sdml<bit sub, string opc> {
2148
2149   def D : AMulDualI<0, sub, 0, (outs GPR:$dst), (ins GPR:$a, GPR:$b),
2150                     NoItinerary, !strconcat(opc, "d"), "\t$dst, $a, $b"> {
2151     let Inst{15-12} = 0b1111;
2152   }
2153
2154   def DX : AMulDualI<0, sub, 1, (outs GPR:$dst), (ins GPR:$a, GPR:$b),
2155                     NoItinerary, !strconcat(opc, "dx"), "\t$dst, $a, $b"> {
2156     let Inst{15-12} = 0b1111;
2157   }
2158
2159 }
2160
2161 defm SMUA : AI_sdml<0, "smua">;
2162 defm SMUS : AI_sdml<1, "smus">;
2163
2164 //===----------------------------------------------------------------------===//
2165 //  Misc. Arithmetic Instructions.
2166 //
2167
2168 def CLZ  : AMiscA1I<0b000010110, (outs GPR:$dst), (ins GPR:$src), IIC_iUNAr,
2169               "clz", "\t$dst, $src",
2170               [(set GPR:$dst, (ctlz GPR:$src))]>, Requires<[IsARM, HasV5T]> {
2171   let Inst{7-4}   = 0b0001;
2172   let Inst{11-8}  = 0b1111;
2173   let Inst{19-16} = 0b1111;
2174 }
2175
2176 def RBIT : AMiscA1I<0b01101111, (outs GPR:$dst), (ins GPR:$src), IIC_iUNAr,
2177               "rbit", "\t$dst, $src",
2178               [(set GPR:$dst, (ARMrbit GPR:$src))]>,
2179            Requires<[IsARM, HasV6T2]> {
2180   let Inst{7-4}   = 0b0011;
2181   let Inst{11-8}  = 0b1111;
2182   let Inst{19-16} = 0b1111;
2183 }
2184
2185 def REV  : AMiscA1I<0b01101011, (outs GPR:$dst), (ins GPR:$src), IIC_iUNAr,
2186               "rev", "\t$dst, $src",
2187               [(set GPR:$dst, (bswap GPR:$src))]>, Requires<[IsARM, HasV6]> {
2188   let Inst{7-4}   = 0b0011;
2189   let Inst{11-8}  = 0b1111;
2190   let Inst{19-16} = 0b1111;
2191 }
2192
2193 def REV16 : AMiscA1I<0b01101011, (outs GPR:$dst), (ins GPR:$src), IIC_iUNAr,
2194                "rev16", "\t$dst, $src",
2195                [(set GPR:$dst,
2196                    (or (and (srl GPR:$src, (i32 8)), 0xFF),
2197                        (or (and (shl GPR:$src, (i32 8)), 0xFF00),
2198                            (or (and (srl GPR:$src, (i32 8)), 0xFF0000),
2199                                (and (shl GPR:$src, (i32 8)), 0xFF000000)))))]>,
2200                Requires<[IsARM, HasV6]> {
2201   let Inst{7-4}   = 0b1011;
2202   let Inst{11-8}  = 0b1111;
2203   let Inst{19-16} = 0b1111;
2204 }
2205
2206 def REVSH : AMiscA1I<0b01101111, (outs GPR:$dst), (ins GPR:$src), IIC_iUNAr,
2207                "revsh", "\t$dst, $src",
2208                [(set GPR:$dst,
2209                   (sext_inreg
2210                     (or (srl (and GPR:$src, 0xFF00), (i32 8)),
2211                         (shl GPR:$src, (i32 8))), i16))]>,
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 PKHBT : AMiscA1I<0b01101000, (outs GPR:$dst),
2219                                  (ins GPR:$src1, GPR:$src2, i32imm:$shamt),
2220                IIC_iALUsi, "pkhbt", "\t$dst, $src1, $src2, lsl $shamt",
2221                [(set GPR:$dst, (or (and GPR:$src1, 0xFFFF),
2222                                    (and (shl GPR:$src2, (i32 imm:$shamt)),
2223                                         0xFFFF0000)))]>,
2224                Requires<[IsARM, HasV6]> {
2225   let Inst{6-4} = 0b001;
2226 }
2227
2228 // Alternate cases for PKHBT where identities eliminate some nodes.
2229 def : ARMV6Pat<(or (and GPR:$src1, 0xFFFF), (and GPR:$src2, 0xFFFF0000)),
2230                (PKHBT GPR:$src1, GPR:$src2, 0)>;
2231 def : ARMV6Pat<(or (and GPR:$src1, 0xFFFF), (shl GPR:$src2, imm16_31:$shamt)),
2232                (PKHBT GPR:$src1, GPR:$src2, imm16_31:$shamt)>;
2233
2234
2235 def PKHTB : AMiscA1I<0b01101000, (outs GPR:$dst),
2236                                  (ins GPR:$src1, GPR:$src2, i32imm:$shamt),
2237                IIC_iALUsi, "pkhtb", "\t$dst, $src1, $src2, asr $shamt",
2238                [(set GPR:$dst, (or (and GPR:$src1, 0xFFFF0000),
2239                                    (and (sra GPR:$src2, imm16_31:$shamt),
2240                                         0xFFFF)))]>, Requires<[IsARM, HasV6]> {
2241   let Inst{6-4} = 0b101;
2242 }
2243
2244 // Alternate cases for PKHTB where identities eliminate some nodes.  Note that
2245 // a shift amount of 0 is *not legal* here, it is PKHBT instead.
2246 def : ARMV6Pat<(or (and GPR:$src1, 0xFFFF0000), (srl GPR:$src2, (i32 16))),
2247                (PKHTB GPR:$src1, GPR:$src2, 16)>;
2248 def : ARMV6Pat<(or (and GPR:$src1, 0xFFFF0000),
2249                    (and (srl GPR:$src2, imm1_15:$shamt), 0xFFFF)),
2250                (PKHTB GPR:$src1, GPR:$src2, imm1_15:$shamt)>;
2251
2252 //===----------------------------------------------------------------------===//
2253 //  Comparison Instructions...
2254 //
2255
2256 defm CMP  : AI1_cmp_irs<0b1010, "cmp",
2257                         BinOpFrag<(ARMcmp node:$LHS, node:$RHS)>>;
2258 //FIXME: Disable CMN, as CCodes are backwards from compare expectations
2259 //       Compare-to-zero still works out, just not the relationals
2260 //defm CMN  : AI1_cmp_irs<0b1011, "cmn",
2261 //                        BinOpFrag<(ARMcmp node:$LHS,(ineg node:$RHS))>>;
2262
2263 // Note that TST/TEQ don't set all the same flags that CMP does!
2264 defm TST  : AI1_cmp_irs<0b1000, "tst",
2265                         BinOpFrag<(ARMcmpZ (and node:$LHS, node:$RHS), 0)>, 1>;
2266 defm TEQ  : AI1_cmp_irs<0b1001, "teq",
2267                         BinOpFrag<(ARMcmpZ (xor node:$LHS, node:$RHS), 0)>, 1>;
2268
2269 defm CMPz  : AI1_cmp_irs<0b1010, "cmp",
2270                          BinOpFrag<(ARMcmpZ node:$LHS, node:$RHS)>>;
2271 defm CMNz  : AI1_cmp_irs<0b1011, "cmn",
2272                          BinOpFrag<(ARMcmpZ node:$LHS,(ineg node:$RHS))>>;
2273
2274 //def : ARMPat<(ARMcmp GPR:$src, so_imm_neg:$imm),
2275 //             (CMNri  GPR:$src, so_imm_neg:$imm)>;
2276
2277 def : ARMPat<(ARMcmpZ GPR:$src, so_imm_neg:$imm),
2278              (CMNzri  GPR:$src, so_imm_neg:$imm)>;
2279
2280
2281 // Conditional moves
2282 // FIXME: should be able to write a pattern for ARMcmov, but can't use
2283 // a two-value operand where a dag node expects two operands. :(
2284 let neverHasSideEffects = 1 in {
2285 def MOVCCr : AI1<0b1101, (outs GPR:$dst), (ins GPR:$false, GPR:$true), DPFrm,
2286                 IIC_iCMOVr, "mov", "\t$dst, $true",
2287       [/*(set GPR:$dst, (ARMcmov GPR:$false, GPR:$true, imm:$cc, CCR:$ccr))*/]>,
2288                 RegConstraint<"$false = $dst">, UnaryDP {
2289   let Inst{11-4} = 0b00000000;
2290   let Inst{25} = 0;
2291 }
2292
2293 def MOVCCs : AI1<0b1101, (outs GPR:$dst),
2294                         (ins GPR:$false, so_reg:$true), DPSoRegFrm, IIC_iCMOVsr,
2295                 "mov", "\t$dst, $true",
2296    [/*(set GPR:$dst, (ARMcmov GPR:$false, so_reg:$true, imm:$cc, CCR:$ccr))*/]>,
2297                 RegConstraint<"$false = $dst">, UnaryDP {
2298   let Inst{25} = 0;
2299 }
2300
2301 def MOVCCi : AI1<0b1101, (outs GPR:$dst),
2302                         (ins GPR:$false, so_imm:$true), DPFrm, IIC_iCMOVi,
2303                 "mov", "\t$dst, $true",
2304    [/*(set GPR:$dst, (ARMcmov GPR:$false, so_imm:$true, imm:$cc, CCR:$ccr))*/]>,
2305                 RegConstraint<"$false = $dst">, UnaryDP {
2306   let Inst{25} = 1;
2307 }
2308 } // neverHasSideEffects
2309
2310 //===----------------------------------------------------------------------===//
2311 // Atomic operations intrinsics
2312 //
2313
2314 // memory barriers protect the atomic sequences
2315 let hasSideEffects = 1 in {
2316 def Int_MemBarrierV7 : AInoP<(outs), (ins),
2317                         Pseudo, NoItinerary,
2318                         "dmb", "",
2319                         [(ARMMemBarrierV7)]>,
2320                         Requires<[IsARM, HasV7]> {
2321   let Inst{31-4} = 0xf57ff05;
2322   // FIXME: add support for options other than a full system DMB
2323   // See DMB disassembly-only variants below.
2324   let Inst{3-0} = 0b1111;
2325 }
2326
2327 def Int_SyncBarrierV7 : AInoP<(outs), (ins),
2328                         Pseudo, NoItinerary,
2329                         "dsb", "",
2330                         [(ARMSyncBarrierV7)]>,
2331                         Requires<[IsARM, HasV7]> {
2332   let Inst{31-4} = 0xf57ff04;
2333   // FIXME: add support for options other than a full system DSB
2334   // See DSB disassembly-only variants below.
2335   let Inst{3-0} = 0b1111;
2336 }
2337
2338 def Int_MemBarrierV6 : AInoP<(outs), (ins GPR:$zero),
2339                        Pseudo, NoItinerary,
2340                        "mcr", "\tp15, 0, $zero, c7, c10, 5",
2341                        [(ARMMemBarrierV6 GPR:$zero)]>,
2342                        Requires<[IsARM, HasV6]> {
2343   // FIXME: add support for options other than a full system DMB
2344   // FIXME: add encoding
2345 }
2346
2347 def Int_SyncBarrierV6 : AInoP<(outs), (ins GPR:$zero),
2348                         Pseudo, NoItinerary,
2349                         "mcr", "\tp15, 0, $zero, c7, c10, 4",
2350                         [(ARMSyncBarrierV6 GPR:$zero)]>,
2351                         Requires<[IsARM, HasV6]> {
2352   // FIXME: add support for options other than a full system DSB
2353   // FIXME: add encoding
2354 }
2355 }
2356
2357 // Helper class for multiclass MemB -- for disassembly only
2358 class AMBI<string opc, string asm>
2359   : AInoP<(outs), (ins), MiscFrm, NoItinerary, opc, asm,
2360           [/* For disassembly only; pattern left blank */]>,
2361     Requires<[IsARM, HasV7]> {
2362   let Inst{31-20} = 0xf57;
2363 }
2364
2365 multiclass MemB<bits<4> op7_4, string opc> {
2366
2367   def st : AMBI<opc, "\tst"> {
2368     let Inst{7-4} = op7_4;
2369     let Inst{3-0} = 0b1110;
2370   }
2371
2372   def ish : AMBI<opc, "\tish"> {
2373     let Inst{7-4} = op7_4;
2374     let Inst{3-0} = 0b1011;
2375   }
2376
2377   def ishst : AMBI<opc, "\tishst"> {
2378     let Inst{7-4} = op7_4;
2379     let Inst{3-0} = 0b1010;
2380   }
2381
2382   def nsh : AMBI<opc, "\tnsh"> {
2383     let Inst{7-4} = op7_4;
2384     let Inst{3-0} = 0b0111;
2385   }
2386
2387   def nshst : AMBI<opc, "\tnshst"> {
2388     let Inst{7-4} = op7_4;
2389     let Inst{3-0} = 0b0110;
2390   }
2391
2392   def osh : AMBI<opc, "\tosh"> {
2393     let Inst{7-4} = op7_4;
2394     let Inst{3-0} = 0b0011;
2395   }
2396
2397   def oshst : AMBI<opc, "\toshst"> {
2398     let Inst{7-4} = op7_4;
2399     let Inst{3-0} = 0b0010;
2400   }
2401 }
2402
2403 // These DMB variants are for disassembly only.
2404 defm DMB : MemB<0b0101, "dmb">;
2405
2406 // These DSB variants are for disassembly only.
2407 defm DSB : MemB<0b0100, "dsb">;
2408
2409 // ISB has only full system option -- for disassembly only
2410 def ISBsy : AMBI<"isb", ""> {
2411   let Inst{7-4} = 0b0110;
2412   let Inst{3-0} = 0b1111;
2413 }
2414
2415 let usesCustomInserter = 1 in {
2416   let Uses = [CPSR] in {
2417     def ATOMIC_LOAD_ADD_I8 : PseudoInst<
2418       (outs GPR:$dst), (ins GPR:$ptr, GPR:$incr), NoItinerary,
2419       "${:comment} ATOMIC_LOAD_ADD_I8 PSEUDO!",
2420       [(set GPR:$dst, (atomic_load_add_8 GPR:$ptr, GPR:$incr))]>;
2421     def ATOMIC_LOAD_SUB_I8 : PseudoInst<
2422       (outs GPR:$dst), (ins GPR:$ptr, GPR:$incr), NoItinerary,
2423       "${:comment} ATOMIC_LOAD_SUB_I8 PSEUDO!",
2424       [(set GPR:$dst, (atomic_load_sub_8 GPR:$ptr, GPR:$incr))]>;
2425     def ATOMIC_LOAD_AND_I8 : PseudoInst<
2426       (outs GPR:$dst), (ins GPR:$ptr, GPR:$incr), NoItinerary,
2427       "${:comment} ATOMIC_LOAD_AND_I8 PSEUDO!",
2428       [(set GPR:$dst, (atomic_load_and_8 GPR:$ptr, GPR:$incr))]>;
2429     def ATOMIC_LOAD_OR_I8 : PseudoInst<
2430       (outs GPR:$dst), (ins GPR:$ptr, GPR:$incr), NoItinerary,
2431       "${:comment} ATOMIC_LOAD_OR_I8 PSEUDO!",
2432       [(set GPR:$dst, (atomic_load_or_8 GPR:$ptr, GPR:$incr))]>;
2433     def ATOMIC_LOAD_XOR_I8 : PseudoInst<
2434       (outs GPR:$dst), (ins GPR:$ptr, GPR:$incr), NoItinerary,
2435       "${:comment} ATOMIC_LOAD_XOR_I8 PSEUDO!",
2436       [(set GPR:$dst, (atomic_load_xor_8 GPR:$ptr, GPR:$incr))]>;
2437     def ATOMIC_LOAD_NAND_I8 : PseudoInst<
2438       (outs GPR:$dst), (ins GPR:$ptr, GPR:$incr), NoItinerary,
2439       "${:comment} ATOMIC_LOAD_NAND_I8 PSEUDO!",
2440       [(set GPR:$dst, (atomic_load_nand_8 GPR:$ptr, GPR:$incr))]>;
2441     def ATOMIC_LOAD_ADD_I16 : PseudoInst<
2442       (outs GPR:$dst), (ins GPR:$ptr, GPR:$incr), NoItinerary,
2443       "${:comment} ATOMIC_LOAD_ADD_I16 PSEUDO!",
2444       [(set GPR:$dst, (atomic_load_add_16 GPR:$ptr, GPR:$incr))]>;
2445     def ATOMIC_LOAD_SUB_I16 : PseudoInst<
2446       (outs GPR:$dst), (ins GPR:$ptr, GPR:$incr), NoItinerary,
2447       "${:comment} ATOMIC_LOAD_SUB_I16 PSEUDO!",
2448       [(set GPR:$dst, (atomic_load_sub_16 GPR:$ptr, GPR:$incr))]>;
2449     def ATOMIC_LOAD_AND_I16 : PseudoInst<
2450       (outs GPR:$dst), (ins GPR:$ptr, GPR:$incr), NoItinerary,
2451       "${:comment} ATOMIC_LOAD_AND_I16 PSEUDO!",
2452       [(set GPR:$dst, (atomic_load_and_16 GPR:$ptr, GPR:$incr))]>;
2453     def ATOMIC_LOAD_OR_I16 : PseudoInst<
2454       (outs GPR:$dst), (ins GPR:$ptr, GPR:$incr), NoItinerary,
2455       "${:comment} ATOMIC_LOAD_OR_I16 PSEUDO!",
2456       [(set GPR:$dst, (atomic_load_or_16 GPR:$ptr, GPR:$incr))]>;
2457     def ATOMIC_LOAD_XOR_I16 : PseudoInst<
2458       (outs GPR:$dst), (ins GPR:$ptr, GPR:$incr), NoItinerary,
2459       "${:comment} ATOMIC_LOAD_XOR_I16 PSEUDO!",
2460       [(set GPR:$dst, (atomic_load_xor_16 GPR:$ptr, GPR:$incr))]>;
2461     def ATOMIC_LOAD_NAND_I16 : PseudoInst<
2462       (outs GPR:$dst), (ins GPR:$ptr, GPR:$incr), NoItinerary,
2463       "${:comment} ATOMIC_LOAD_NAND_I16 PSEUDO!",
2464       [(set GPR:$dst, (atomic_load_nand_16 GPR:$ptr, GPR:$incr))]>;
2465     def ATOMIC_LOAD_ADD_I32 : PseudoInst<
2466       (outs GPR:$dst), (ins GPR:$ptr, GPR:$incr), NoItinerary,
2467       "${:comment} ATOMIC_LOAD_ADD_I32 PSEUDO!",
2468       [(set GPR:$dst, (atomic_load_add_32 GPR:$ptr, GPR:$incr))]>;
2469     def ATOMIC_LOAD_SUB_I32 : PseudoInst<
2470       (outs GPR:$dst), (ins GPR:$ptr, GPR:$incr), NoItinerary,
2471       "${:comment} ATOMIC_LOAD_SUB_I32 PSEUDO!",
2472       [(set GPR:$dst, (atomic_load_sub_32 GPR:$ptr, GPR:$incr))]>;
2473     def ATOMIC_LOAD_AND_I32 : PseudoInst<
2474       (outs GPR:$dst), (ins GPR:$ptr, GPR:$incr), NoItinerary,
2475       "${:comment} ATOMIC_LOAD_AND_I32 PSEUDO!",
2476       [(set GPR:$dst, (atomic_load_and_32 GPR:$ptr, GPR:$incr))]>;
2477     def ATOMIC_LOAD_OR_I32 : PseudoInst<
2478       (outs GPR:$dst), (ins GPR:$ptr, GPR:$incr), NoItinerary,
2479       "${:comment} ATOMIC_LOAD_OR_I32 PSEUDO!",
2480       [(set GPR:$dst, (atomic_load_or_32 GPR:$ptr, GPR:$incr))]>;
2481     def ATOMIC_LOAD_XOR_I32 : PseudoInst<
2482       (outs GPR:$dst), (ins GPR:$ptr, GPR:$incr), NoItinerary,
2483       "${:comment} ATOMIC_LOAD_XOR_I32 PSEUDO!",
2484       [(set GPR:$dst, (atomic_load_xor_32 GPR:$ptr, GPR:$incr))]>;
2485     def ATOMIC_LOAD_NAND_I32 : PseudoInst<
2486       (outs GPR:$dst), (ins GPR:$ptr, GPR:$incr), NoItinerary,
2487       "${:comment} ATOMIC_LOAD_NAND_I32 PSEUDO!",
2488       [(set GPR:$dst, (atomic_load_nand_32 GPR:$ptr, GPR:$incr))]>;
2489
2490     def ATOMIC_SWAP_I8 : PseudoInst<
2491       (outs GPR:$dst), (ins GPR:$ptr, GPR:$new), NoItinerary,
2492       "${:comment} ATOMIC_SWAP_I8 PSEUDO!",
2493       [(set GPR:$dst, (atomic_swap_8 GPR:$ptr, GPR:$new))]>;
2494     def ATOMIC_SWAP_I16 : PseudoInst<
2495       (outs GPR:$dst), (ins GPR:$ptr, GPR:$new), NoItinerary,
2496       "${:comment} ATOMIC_SWAP_I16 PSEUDO!",
2497       [(set GPR:$dst, (atomic_swap_16 GPR:$ptr, GPR:$new))]>;
2498     def ATOMIC_SWAP_I32 : PseudoInst<
2499       (outs GPR:$dst), (ins GPR:$ptr, GPR:$new), NoItinerary,
2500       "${:comment} ATOMIC_SWAP_I32 PSEUDO!",
2501       [(set GPR:$dst, (atomic_swap_32 GPR:$ptr, GPR:$new))]>;
2502
2503     def ATOMIC_CMP_SWAP_I8 : PseudoInst<
2504       (outs GPR:$dst), (ins GPR:$ptr, GPR:$old, GPR:$new), NoItinerary,
2505       "${:comment} ATOMIC_CMP_SWAP_I8 PSEUDO!",
2506       [(set GPR:$dst, (atomic_cmp_swap_8 GPR:$ptr, GPR:$old, GPR:$new))]>;
2507     def ATOMIC_CMP_SWAP_I16 : PseudoInst<
2508       (outs GPR:$dst), (ins GPR:$ptr, GPR:$old, GPR:$new), NoItinerary,
2509       "${:comment} ATOMIC_CMP_SWAP_I16 PSEUDO!",
2510       [(set GPR:$dst, (atomic_cmp_swap_16 GPR:$ptr, GPR:$old, GPR:$new))]>;
2511     def ATOMIC_CMP_SWAP_I32 : PseudoInst<
2512       (outs GPR:$dst), (ins GPR:$ptr, GPR:$old, GPR:$new), NoItinerary,
2513       "${:comment} ATOMIC_CMP_SWAP_I32 PSEUDO!",
2514       [(set GPR:$dst, (atomic_cmp_swap_32 GPR:$ptr, GPR:$old, GPR:$new))]>;
2515 }
2516 }
2517
2518 let mayLoad = 1 in {
2519 def LDREXB : AIldrex<0b10, (outs GPR:$dest), (ins GPR:$ptr), NoItinerary,
2520                     "ldrexb", "\t$dest, [$ptr]",
2521                     []>;
2522 def LDREXH : AIldrex<0b11, (outs GPR:$dest), (ins GPR:$ptr), NoItinerary,
2523                     "ldrexh", "\t$dest, [$ptr]",
2524                     []>;
2525 def LDREX  : AIldrex<0b00, (outs GPR:$dest), (ins GPR:$ptr), NoItinerary,
2526                     "ldrex", "\t$dest, [$ptr]",
2527                     []>;
2528 def LDREXD : AIldrex<0b01, (outs GPR:$dest, GPR:$dest2), (ins GPR:$ptr),
2529                     NoItinerary,
2530                     "ldrexd", "\t$dest, $dest2, [$ptr]",
2531                     []>;
2532 }
2533
2534 let mayStore = 1, Constraints = "@earlyclobber $success" in {
2535 def STREXB : AIstrex<0b10, (outs GPR:$success), (ins GPR:$src, GPR:$ptr),
2536                     NoItinerary,
2537                     "strexb", "\t$success, $src, [$ptr]",
2538                     []>;
2539 def STREXH : AIstrex<0b11, (outs GPR:$success), (ins GPR:$src, GPR:$ptr),
2540                     NoItinerary,
2541                     "strexh", "\t$success, $src, [$ptr]",
2542                     []>;
2543 def STREX  : AIstrex<0b00, (outs GPR:$success), (ins GPR:$src, GPR:$ptr),
2544                     NoItinerary,
2545                     "strex", "\t$success, $src, [$ptr]",
2546                     []>;
2547 def STREXD : AIstrex<0b01, (outs GPR:$success),
2548                     (ins GPR:$src, GPR:$src2, GPR:$ptr),
2549                     NoItinerary,
2550                     "strexd", "\t$success, $src, $src2, [$ptr]",
2551                     []>;
2552 }
2553
2554 // Clear-Exclusive is for disassembly only.
2555 def CLREX : AXI<(outs), (ins), MiscFrm, NoItinerary, "clrex",
2556                 [/* For disassembly only; pattern left blank */]>,
2557             Requires<[IsARM, HasV7]>  {
2558   let Inst{31-20} = 0xf57;
2559   let Inst{7-4} = 0b0001;
2560 }
2561
2562 // SWP/SWPB are deprecated in V6/V7 and for disassembly only.
2563 let mayLoad = 1 in {
2564 def SWP : AI<(outs GPR:$dst), (ins GPR:$src, GPR:$ptr), LdStExFrm, NoItinerary,
2565              "swp", "\t$dst, $src, [$ptr]",
2566              [/* For disassembly only; pattern left blank */]> {
2567   let Inst{27-23} = 0b00010;
2568   let Inst{22} = 0; // B = 0
2569   let Inst{21-20} = 0b00;
2570   let Inst{7-4} = 0b1001;
2571 }
2572
2573 def SWPB : AI<(outs GPR:$dst), (ins GPR:$src, GPR:$ptr), LdStExFrm, NoItinerary,
2574              "swpb", "\t$dst, $src, [$ptr]",
2575              [/* For disassembly only; pattern left blank */]> {
2576   let Inst{27-23} = 0b00010;
2577   let Inst{22} = 1; // B = 1
2578   let Inst{21-20} = 0b00;
2579   let Inst{7-4} = 0b1001;
2580 }
2581 }
2582
2583 //===----------------------------------------------------------------------===//
2584 // TLS Instructions
2585 //
2586
2587 // __aeabi_read_tp preserves the registers r1-r3.
2588 let isCall = 1,
2589   Defs = [R0, R12, LR, CPSR] in {
2590   def TPsoft : ABXI<0b1011, (outs), (ins), IIC_Br,
2591                "bl\t__aeabi_read_tp",
2592                [(set R0, ARMthread_pointer)]>;
2593 }
2594
2595 //===----------------------------------------------------------------------===//
2596 // SJLJ Exception handling intrinsics
2597 //   eh_sjlj_setjmp() is an instruction sequence to store the return
2598 //   address and save #0 in R0 for the non-longjmp case.
2599 //   Since by its nature we may be coming from some other function to get
2600 //   here, and we're using the stack frame for the containing function to
2601 //   save/restore registers, we can't keep anything live in regs across
2602 //   the eh_sjlj_setjmp(), else it will almost certainly have been tromped upon
2603 //   when we get here from a longjmp(). We force everthing out of registers
2604 //   except for our own input by listing the relevant registers in Defs. By
2605 //   doing so, we also cause the prologue/epilogue code to actively preserve
2606 //   all of the callee-saved resgisters, which is exactly what we want.
2607 //   A constant value is passed in $val, and we use the location as a scratch.
2608 let Defs =
2609   [ R0,  R1,  R2,  R3,  R4,  R5,  R6,  R7,  R8,  R9,  R10, R11, R12, LR,  D0,
2610     D1,  D2,  D3,  D4,  D5,  D6,  D7,  D8,  D9,  D10, D11, D12, D13, D14, D15,
2611     D16, D17, D18, D19, D20, D21, D22, D23, D24, D25, D26, D27, D28, D29, D30,
2612     D31 ], hasSideEffects = 1, isBarrier = 1 in {
2613   def Int_eh_sjlj_setjmp : XI<(outs), (ins GPR:$src, GPR:$val),
2614                                AddrModeNone, SizeSpecial, IndexModeNone,
2615                                Pseudo, NoItinerary,
2616                            "add\t$val, pc, #8\t${:comment} eh_setjmp begin\n\t"
2617                            "str\t$val, [$src, #+4]\n\t"
2618                            "mov\tr0, #0\n\t"
2619                            "add\tpc, pc, #0\n\t"
2620                            "mov\tr0, #1 ${:comment} eh_setjmp end", "",
2621                          [(set R0, (ARMeh_sjlj_setjmp GPR:$src, GPR:$val))]>,
2622                            Requires<[IsARM, HasVFP2]>;
2623 }
2624
2625 let Defs =
2626   [ R0,  R1,  R2,  R3,  R4,  R5,  R6,  R7,  R8,  R9,  R10, R11, R12, LR ],
2627   hasSideEffects = 1, isBarrier = 1 in {
2628   def Int_eh_sjlj_setjmp_nofp : XI<(outs), (ins GPR:$src, GPR:$val),
2629                                    AddrModeNone, SizeSpecial, IndexModeNone,
2630                                    Pseudo, NoItinerary,
2631                            "add\t$val, pc, #8\n ${:comment} eh_setjmp begin\n\t"
2632                            "str\t$val, [$src, #+4]\n\t"
2633                            "mov\tr0, #0\n\t"
2634                            "add\tpc, pc, #0\n\t"
2635                            "mov\tr0, #1 ${:comment} eh_setjmp end", "",
2636                          [(set R0, (ARMeh_sjlj_setjmp GPR:$src, GPR:$val))]>,
2637                                 Requires<[IsARM, NoVFP]>;
2638 }
2639
2640 // FIXME: Non-Darwin version(s)
2641 let isBarrier = 1, hasSideEffects = 1, isTerminator = 1,
2642     Defs = [ R7, LR, SP ] in {
2643 def Int_eh_sjlj_longjmp : XI<(outs), (ins GPR:$src, GPR:$scratch),
2644                              AddrModeNone, SizeSpecial, IndexModeNone,
2645                              Pseudo, NoItinerary,
2646                              "ldr\tsp, [$src, #8]\n\t"
2647                              "ldr\t$scratch, [$src, #4]\n\t"
2648                              "ldr\tr7, [$src]\n\t"
2649                              "bx\t$scratch", "",
2650                          [(ARMeh_sjlj_longjmp GPR:$src, GPR:$scratch)]>,
2651                                 Requires<[IsARM, IsDarwin]>;
2652 }
2653
2654 //===----------------------------------------------------------------------===//
2655 // Non-Instruction Patterns
2656 //
2657
2658 // Large immediate handling.
2659
2660 // Two piece so_imms.
2661 let isReMaterializable = 1 in
2662 def MOVi2pieces : AI1x2<(outs GPR:$dst), (ins so_imm2part:$src),
2663                          Pseudo, IIC_iMOVi,
2664                          "mov", "\t$dst, $src",
2665                          [(set GPR:$dst, so_imm2part:$src)]>,
2666                   Requires<[IsARM, NoV6T2]>;
2667
2668 def : ARMPat<(or GPR:$LHS, so_imm2part:$RHS),
2669              (ORRri (ORRri GPR:$LHS, (so_imm2part_1 imm:$RHS)),
2670                     (so_imm2part_2 imm:$RHS))>;
2671 def : ARMPat<(xor GPR:$LHS, so_imm2part:$RHS),
2672              (EORri (EORri GPR:$LHS, (so_imm2part_1 imm:$RHS)),
2673                     (so_imm2part_2 imm:$RHS))>;
2674 def : ARMPat<(add GPR:$LHS, so_imm2part:$RHS),
2675              (ADDri (ADDri GPR:$LHS, (so_imm2part_1 imm:$RHS)),
2676                     (so_imm2part_2 imm:$RHS))>;
2677 def : ARMPat<(add GPR:$LHS, so_neg_imm2part:$RHS),
2678              (SUBri (SUBri GPR:$LHS, (so_neg_imm2part_1 imm:$RHS)),
2679                     (so_neg_imm2part_2 imm:$RHS))>;
2680
2681 // 32-bit immediate using movw + movt.
2682 // This is a single pseudo instruction, the benefit is that it can be remat'd
2683 // as a single unit instead of having to handle reg inputs.
2684 // FIXME: Remove this when we can do generalized remat.
2685 let isReMaterializable = 1 in
2686 def MOVi32imm : AI1x2<(outs GPR:$dst), (ins i32imm:$src), Pseudo, IIC_iMOVi,
2687                    "movw", "\t$dst, ${src:lo16}\n\tmovt${p}\t$dst, ${src:hi16}",
2688                      [(set GPR:$dst, (i32 imm:$src))]>,
2689                Requires<[IsARM, HasV6T2]>;
2690
2691 // ConstantPool, GlobalAddress, and JumpTable
2692 def : ARMPat<(ARMWrapper  tglobaladdr :$dst), (LEApcrel tglobaladdr :$dst)>,
2693             Requires<[IsARM, DontUseMovt]>;
2694 def : ARMPat<(ARMWrapper  tconstpool  :$dst), (LEApcrel tconstpool  :$dst)>;
2695 def : ARMPat<(ARMWrapper  tglobaladdr :$dst), (MOVi32imm tglobaladdr :$dst)>,
2696             Requires<[IsARM, UseMovt]>;
2697 def : ARMPat<(ARMWrapperJT tjumptable:$dst, imm:$id),
2698              (LEApcrelJT tjumptable:$dst, imm:$id)>;
2699
2700 // TODO: add,sub,and, 3-instr forms?
2701
2702 // Tail calls
2703 def : ARMPat<(ARMtcret tGPR:$dst),
2704           (TCRETURNri tGPR:$dst)>, Requires<[IsDarwin]>;
2705
2706 def : ARMPat<(ARMtcret (i32 tglobaladdr:$dst)),
2707           (TCRETURNdi texternalsym:$dst)>, Requires<[IsDarwin]>;
2708
2709 def : ARMPat<(ARMtcret (i32 texternalsym:$dst)),
2710           (TCRETURNdi texternalsym:$dst)>, Requires<[IsDarwin]>;
2711
2712 def : ARMPat<(ARMtcret tGPR:$dst),
2713           (TCRETURNriND tGPR:$dst)>, Requires<[IsNotDarwin]>;
2714
2715 def : ARMPat<(ARMtcret (i32 tglobaladdr:$dst)),
2716           (TCRETURNdiND texternalsym:$dst)>, Requires<[IsNotDarwin]>;
2717
2718 def : ARMPat<(ARMtcret (i32 texternalsym:$dst)),
2719           (TCRETURNdiND texternalsym:$dst)>, Requires<[IsNotDarwin]>;
2720
2721 // Direct calls
2722 def : ARMPat<(ARMcall texternalsym:$func), (BL texternalsym:$func)>,
2723       Requires<[IsARM, IsNotDarwin]>;
2724 def : ARMPat<(ARMcall texternalsym:$func), (BLr9 texternalsym:$func)>,
2725       Requires<[IsARM, IsDarwin]>;
2726
2727 // zextload i1 -> zextload i8
2728 def : ARMPat<(zextloadi1 addrmode2:$addr),  (LDRB addrmode2:$addr)>;
2729
2730 // extload -> zextload
2731 def : ARMPat<(extloadi1  addrmode2:$addr),  (LDRB addrmode2:$addr)>;
2732 def : ARMPat<(extloadi8  addrmode2:$addr),  (LDRB addrmode2:$addr)>;
2733 def : ARMPat<(extloadi16 addrmode3:$addr),  (LDRH addrmode3:$addr)>;
2734
2735 def : ARMPat<(extloadi8  addrmodepc:$addr), (PICLDRB addrmodepc:$addr)>;
2736 def : ARMPat<(extloadi16 addrmodepc:$addr), (PICLDRH addrmodepc:$addr)>;
2737
2738 // smul* and smla*
2739 def : ARMV5TEPat<(mul (sra (shl GPR:$a, (i32 16)), (i32 16)),
2740                       (sra (shl GPR:$b, (i32 16)), (i32 16))),
2741                  (SMULBB GPR:$a, GPR:$b)>;
2742 def : ARMV5TEPat<(mul sext_16_node:$a, sext_16_node:$b),
2743                  (SMULBB GPR:$a, GPR:$b)>;
2744 def : ARMV5TEPat<(mul (sra (shl GPR:$a, (i32 16)), (i32 16)),
2745                       (sra GPR:$b, (i32 16))),
2746                  (SMULBT GPR:$a, GPR:$b)>;
2747 def : ARMV5TEPat<(mul sext_16_node:$a, (sra GPR:$b, (i32 16))),
2748                  (SMULBT GPR:$a, GPR:$b)>;
2749 def : ARMV5TEPat<(mul (sra GPR:$a, (i32 16)),
2750                       (sra (shl GPR:$b, (i32 16)), (i32 16))),
2751                  (SMULTB GPR:$a, GPR:$b)>;
2752 def : ARMV5TEPat<(mul (sra GPR:$a, (i32 16)), sext_16_node:$b),
2753                 (SMULTB GPR:$a, GPR:$b)>;
2754 def : ARMV5TEPat<(sra (mul GPR:$a, (sra (shl GPR:$b, (i32 16)), (i32 16))),
2755                       (i32 16)),
2756                  (SMULWB GPR:$a, GPR:$b)>;
2757 def : ARMV5TEPat<(sra (mul GPR:$a, sext_16_node:$b), (i32 16)),
2758                  (SMULWB GPR:$a, GPR:$b)>;
2759
2760 def : ARMV5TEPat<(add GPR:$acc,
2761                       (mul (sra (shl GPR:$a, (i32 16)), (i32 16)),
2762                            (sra (shl GPR:$b, (i32 16)), (i32 16)))),
2763                  (SMLABB GPR:$a, GPR:$b, GPR:$acc)>;
2764 def : ARMV5TEPat<(add GPR:$acc,
2765                       (mul sext_16_node:$a, sext_16_node:$b)),
2766                  (SMLABB GPR:$a, GPR:$b, GPR:$acc)>;
2767 def : ARMV5TEPat<(add GPR:$acc,
2768                       (mul (sra (shl GPR:$a, (i32 16)), (i32 16)),
2769                            (sra GPR:$b, (i32 16)))),
2770                  (SMLABT GPR:$a, GPR:$b, GPR:$acc)>;
2771 def : ARMV5TEPat<(add GPR:$acc,
2772                       (mul sext_16_node:$a, (sra GPR:$b, (i32 16)))),
2773                  (SMLABT GPR:$a, GPR:$b, GPR:$acc)>;
2774 def : ARMV5TEPat<(add GPR:$acc,
2775                       (mul (sra GPR:$a, (i32 16)),
2776                            (sra (shl GPR:$b, (i32 16)), (i32 16)))),
2777                  (SMLATB GPR:$a, GPR:$b, GPR:$acc)>;
2778 def : ARMV5TEPat<(add GPR:$acc,
2779                       (mul (sra GPR:$a, (i32 16)), sext_16_node:$b)),
2780                  (SMLATB GPR:$a, GPR:$b, GPR:$acc)>;
2781 def : ARMV5TEPat<(add GPR:$acc,
2782                       (sra (mul GPR:$a, (sra (shl GPR:$b, (i32 16)), (i32 16))),
2783                            (i32 16))),
2784                  (SMLAWB GPR:$a, GPR:$b, GPR:$acc)>;
2785 def : ARMV5TEPat<(add GPR:$acc,
2786                       (sra (mul GPR:$a, sext_16_node:$b), (i32 16))),
2787                  (SMLAWB GPR:$a, GPR:$b, GPR:$acc)>;
2788
2789 //===----------------------------------------------------------------------===//
2790 // Thumb Support
2791 //
2792
2793 include "ARMInstrThumb.td"
2794
2795 //===----------------------------------------------------------------------===//
2796 // Thumb2 Support
2797 //
2798
2799 include "ARMInstrThumb2.td"
2800
2801 //===----------------------------------------------------------------------===//
2802 // Floating Point Support
2803 //
2804
2805 include "ARMInstrVFP.td"
2806
2807 //===----------------------------------------------------------------------===//
2808 // Advanced SIMD (NEON) Support
2809 //
2810
2811 include "ARMInstrNEON.td"
2812
2813 //===----------------------------------------------------------------------===//
2814 // Coprocessor Instructions.  For disassembly only.
2815 //
2816
2817 def CDP : ABI<0b1110, (outs), (ins nohash_imm:$cop, i32imm:$opc1,
2818             nohash_imm:$CRd, nohash_imm:$CRn, nohash_imm:$CRm, i32imm:$opc2),
2819             NoItinerary, "cdp", "\tp$cop, $opc1, cr$CRd, cr$CRn, cr$CRm, $opc2",
2820               [/* For disassembly only; pattern left blank */]> {
2821   let Inst{4} = 0;
2822 }
2823
2824 def CDP2 : ABXI<0b1110, (outs), (ins nohash_imm:$cop, i32imm:$opc1,
2825                nohash_imm:$CRd, nohash_imm:$CRn, nohash_imm:$CRm, i32imm:$opc2),
2826                NoItinerary, "cdp2\tp$cop, $opc1, cr$CRd, cr$CRn, cr$CRm, $opc2",
2827                [/* For disassembly only; pattern left blank */]> {
2828   let Inst{31-28} = 0b1111;
2829   let Inst{4} = 0;
2830 }
2831
2832 class ACI<dag oops, dag iops, string opc, string asm>
2833   : I<oops, iops, AddrModeNone, Size4Bytes, IndexModeNone, BrFrm, NoItinerary,
2834       opc, asm, "", [/* For disassembly only; pattern left blank */]> {
2835   let Inst{27-25} = 0b110;
2836 }
2837
2838 multiclass LdStCop<bits<4> op31_28, bit load, string opc> {
2839
2840   def _OFFSET : ACI<(outs),
2841       (ins nohash_imm:$cop, nohash_imm:$CRd, addrmode2:$addr),
2842       opc, "\tp$cop, cr$CRd, $addr"> {
2843     let Inst{31-28} = op31_28;
2844     let Inst{24} = 1; // P = 1
2845     let Inst{21} = 0; // W = 0
2846     let Inst{22} = 0; // D = 0
2847     let Inst{20} = load;
2848   }
2849
2850   def _PRE : ACI<(outs),
2851       (ins nohash_imm:$cop, nohash_imm:$CRd, addrmode2:$addr),
2852       opc, "\tp$cop, cr$CRd, $addr!"> {
2853     let Inst{31-28} = op31_28;
2854     let Inst{24} = 1; // P = 1
2855     let Inst{21} = 1; // W = 1
2856     let Inst{22} = 0; // D = 0
2857     let Inst{20} = load;
2858   }
2859
2860   def _POST : ACI<(outs),
2861       (ins nohash_imm:$cop, nohash_imm:$CRd, GPR:$base, am2offset:$offset),
2862       opc, "\tp$cop, cr$CRd, [$base], $offset"> {
2863     let Inst{31-28} = op31_28;
2864     let Inst{24} = 0; // P = 0
2865     let Inst{21} = 1; // W = 1
2866     let Inst{22} = 0; // D = 0
2867     let Inst{20} = load;
2868   }
2869
2870   def _OPTION : ACI<(outs),
2871       (ins nohash_imm:$cop, nohash_imm:$CRd, GPR:$base, i32imm:$option),
2872       opc, "\tp$cop, cr$CRd, [$base], $option"> {
2873     let Inst{31-28} = op31_28;
2874     let Inst{24} = 0; // P = 0
2875     let Inst{23} = 1; // U = 1
2876     let Inst{21} = 0; // W = 0
2877     let Inst{22} = 0; // D = 0
2878     let Inst{20} = load;
2879   }
2880
2881   def L_OFFSET : ACI<(outs),
2882       (ins nohash_imm:$cop, nohash_imm:$CRd, addrmode2:$addr),
2883       !strconcat(opc, "l"), "\tp$cop, cr$CRd, $addr"> {
2884     let Inst{31-28} = op31_28;
2885     let Inst{24} = 1; // P = 1
2886     let Inst{21} = 0; // W = 0
2887     let Inst{22} = 1; // D = 1
2888     let Inst{20} = load;
2889   }
2890
2891   def L_PRE : ACI<(outs),
2892       (ins nohash_imm:$cop, nohash_imm:$CRd, addrmode2:$addr),
2893       !strconcat(opc, "l"), "\tp$cop, cr$CRd, $addr!"> {
2894     let Inst{31-28} = op31_28;
2895     let Inst{24} = 1; // P = 1
2896     let Inst{21} = 1; // W = 1
2897     let Inst{22} = 1; // D = 1
2898     let Inst{20} = load;
2899   }
2900
2901   def L_POST : ACI<(outs),
2902       (ins nohash_imm:$cop, nohash_imm:$CRd, GPR:$base, am2offset:$offset),
2903       !strconcat(opc, "l"), "\tp$cop, cr$CRd, [$base], $offset"> {
2904     let Inst{31-28} = op31_28;
2905     let Inst{24} = 0; // P = 0
2906     let Inst{21} = 1; // W = 1
2907     let Inst{22} = 1; // D = 1
2908     let Inst{20} = load;
2909   }
2910
2911   def L_OPTION : ACI<(outs),
2912       (ins nohash_imm:$cop, nohash_imm:$CRd, GPR:$base, nohash_imm:$option),
2913       !strconcat(opc, "l"), "\tp$cop, cr$CRd, [$base], $option"> {
2914     let Inst{31-28} = op31_28;
2915     let Inst{24} = 0; // P = 0
2916     let Inst{23} = 1; // U = 1
2917     let Inst{21} = 0; // W = 0
2918     let Inst{22} = 1; // D = 1
2919     let Inst{20} = load;
2920   }
2921 }
2922
2923 defm LDC  : LdStCop<{?,?,?,?}, 1, "ldc">;
2924 defm LDC2 : LdStCop<0b1111,    1, "ldc2">;
2925 defm STC  : LdStCop<{?,?,?,?}, 0, "stc">;
2926 defm STC2 : LdStCop<0b1111,    0, "stc2">;
2927
2928 def MCR : ABI<0b1110, (outs), (ins nohash_imm:$cop, i32imm:$opc1,
2929               GPR:$Rt, nohash_imm:$CRn, nohash_imm:$CRm, i32imm:$opc2),
2930               NoItinerary, "mcr", "\tp$cop, $opc1, $Rt, cr$CRn, cr$CRm, $opc2",
2931               [/* For disassembly only; pattern left blank */]> {
2932   let Inst{20} = 0;
2933   let Inst{4} = 1;
2934 }
2935
2936 def MCR2 : ABXI<0b1110, (outs), (ins nohash_imm:$cop, i32imm:$opc1,
2937                 GPR:$Rt, nohash_imm:$CRn, nohash_imm:$CRm, i32imm:$opc2),
2938                 NoItinerary, "mcr2\tp$cop, $opc1, $Rt, cr$CRn, cr$CRm, $opc2",
2939                 [/* For disassembly only; pattern left blank */]> {
2940   let Inst{31-28} = 0b1111;
2941   let Inst{20} = 0;
2942   let Inst{4} = 1;
2943 }
2944
2945 def MRC : ABI<0b1110, (outs), (ins nohash_imm:$cop, i32imm:$opc1,
2946               GPR:$Rt, nohash_imm:$CRn, nohash_imm:$CRm, i32imm:$opc2),
2947               NoItinerary, "mrc", "\tp$cop, $opc1, $Rt, cr$CRn, cr$CRm, $opc2",
2948               [/* For disassembly only; pattern left blank */]> {
2949   let Inst{20} = 1;
2950   let Inst{4} = 1;
2951 }
2952
2953 def MRC2 : ABXI<0b1110, (outs), (ins nohash_imm:$cop, i32imm:$opc1,
2954                 GPR:$Rt, nohash_imm:$CRn, nohash_imm:$CRm, i32imm:$opc2),
2955                 NoItinerary, "mrc2\tp$cop, $opc1, $Rt, cr$CRn, cr$CRm, $opc2",
2956                 [/* For disassembly only; pattern left blank */]> {
2957   let Inst{31-28} = 0b1111;
2958   let Inst{20} = 1;
2959   let Inst{4} = 1;
2960 }
2961
2962 def MCRR : ABI<0b1100, (outs), (ins nohash_imm:$cop, i32imm:$opc,
2963                GPR:$Rt, GPR:$Rt2, nohash_imm:$CRm),
2964                NoItinerary, "mcrr", "\tp$cop, $opc, $Rt, $Rt2, cr$CRm",
2965                [/* For disassembly only; pattern left blank */]> {
2966   let Inst{23-20} = 0b0100;
2967 }
2968
2969 def MCRR2 : ABXI<0b1100, (outs), (ins nohash_imm:$cop, i32imm:$opc,
2970                  GPR:$Rt, GPR:$Rt2, nohash_imm:$CRm),
2971                  NoItinerary, "mcrr2\tp$cop, $opc, $Rt, $Rt2, cr$CRm",
2972                  [/* For disassembly only; pattern left blank */]> {
2973   let Inst{31-28} = 0b1111;
2974   let Inst{23-20} = 0b0100;
2975 }
2976
2977 def MRRC : ABI<0b1100, (outs), (ins nohash_imm:$cop, i32imm:$opc,
2978                GPR:$Rt, GPR:$Rt2, nohash_imm:$CRm),
2979                NoItinerary, "mrrc", "\tp$cop, $opc, $Rt, $Rt2, cr$CRm",
2980                [/* For disassembly only; pattern left blank */]> {
2981   let Inst{23-20} = 0b0101;
2982 }
2983
2984 def MRRC2 : ABXI<0b1100, (outs), (ins nohash_imm:$cop, i32imm:$opc,
2985                  GPR:$Rt, GPR:$Rt2, nohash_imm:$CRm),
2986                  NoItinerary, "mrrc2\tp$cop, $opc, $Rt, $Rt2, cr$CRm",
2987                  [/* For disassembly only; pattern left blank */]> {
2988   let Inst{31-28} = 0b1111;
2989   let Inst{23-20} = 0b0101;
2990 }
2991
2992 //===----------------------------------------------------------------------===//
2993 // Move between special register and ARM core register -- for disassembly only
2994 //
2995
2996 def MRS : ABI<0b0001,(outs GPR:$dst),(ins), NoItinerary, "mrs", "\t$dst, cpsr",
2997               [/* For disassembly only; pattern left blank */]> {
2998   let Inst{23-20} = 0b0000;
2999   let Inst{7-4} = 0b0000;
3000 }
3001
3002 def MRSsys : ABI<0b0001,(outs GPR:$dst),(ins), NoItinerary,"mrs","\t$dst, spsr",
3003               [/* For disassembly only; pattern left blank */]> {
3004   let Inst{23-20} = 0b0100;
3005   let Inst{7-4} = 0b0000;
3006 }
3007
3008 def MSR : ABI<0b0001, (outs), (ins GPR:$src, msr_mask:$mask), NoItinerary,
3009               "msr", "\tcpsr$mask, $src",
3010               [/* For disassembly only; pattern left blank */]> {
3011   let Inst{23-20} = 0b0010;
3012   let Inst{7-4} = 0b0000;
3013 }
3014
3015 def MSRi : ABI<0b0011, (outs), (ins so_imm:$a, msr_mask:$mask), NoItinerary,
3016               "msr", "\tcpsr$mask, $a",
3017               [/* For disassembly only; pattern left blank */]> {
3018   let Inst{23-20} = 0b0010;
3019   let Inst{7-4} = 0b0000;
3020 }
3021
3022 def MSRsys : ABI<0b0001, (outs), (ins GPR:$src, msr_mask:$mask), NoItinerary,
3023               "msr", "\tspsr$mask, $src",
3024               [/* For disassembly only; pattern left blank */]> {
3025   let Inst{23-20} = 0b0110;
3026   let Inst{7-4} = 0b0000;
3027 }
3028
3029 def MSRsysi : ABI<0b0011, (outs), (ins so_imm:$a, msr_mask:$mask), NoItinerary,
3030               "msr", "\tspsr$mask, $a",
3031               [/* For disassembly only; pattern left blank */]> {
3032   let Inst{23-20} = 0b0110;
3033   let Inst{7-4} = 0b0000;
3034 }