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