lib/Target/ARM/ARMInstrInfo.td

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