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