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