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