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