lib/Target/ARM/ARMInstrInfo.td

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