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