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