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