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(-(int)N->getZExtValue()) != -1;
 216   }], so_imm_neg_XFORM>;
 217
 218 def so_imm_not :
 219   PatLeaf<(imm), [{
 220     return ARM_AM::getSOImmVal(~(int)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<4> Rm;
2372   bits<12> shift;
2373   let Inst{25} = 0;
2374   let Inst{19-16} = 0b0000;
2375   let Inst{15-12} = Rd;
2376   let Inst{11-0} = shift;
2377 }
2378 let isReMaterializable = 1, isAsCheapAsAMove = 1 in
2379 def  MVNi  : AsI1<0b1111, (outs GPR:$Rd), (ins so_imm:$imm), DPFrm,
2380                   IIC_iMVNi, "mvn", "\t$Rd, $imm",
2381                   [(set GPR:$Rd, so_imm_not:$imm)]>,UnaryDP {
2382   bits<4> Rd;
2383   bits<4> Rm;
2384   bits<12> imm;
2385   let Inst{25} = 1;
2386   let Inst{19-16} = 0b0000;
2387   let Inst{15-12} = Rd;
2388   let Inst{11-0} = imm;
2389 }
2390
2391 def : ARMPat<(and   GPR:$src, so_imm_not:$imm),
2392              (BICri GPR:$src, so_imm_not:$imm)>;
2393
2394 //===----------------------------------------------------------------------===//
2395 //  Multiply Instructions.
2396 //
2397 class AsMul1I32<bits<7> opcod, dag oops, dag iops, InstrItinClass itin,
2398              string opc, string asm, list<dag> pattern>
2399   : AsMul1I<opcod, oops, iops, itin, opc, asm, pattern> {
2400   bits<4> Rd;
2401   bits<4> Rm;
2402   bits<4> Rn;
2403   let Inst{19-16} = Rd;
2404   let Inst{11-8}  = Rm;
2405   let Inst{3-0}   = Rn;
2406 }
2407 class AsMul1I64<bits<7> opcod, dag oops, dag iops, InstrItinClass itin,
2408              string opc, string asm, list<dag> pattern>
2409   : AsMul1I<opcod, oops, iops, itin, opc, asm, pattern> {
2410   bits<4> RdLo;
2411   bits<4> RdHi;
2412   bits<4> Rm;
2413   bits<4> Rn;
2414   let Inst{19-16} = RdHi;
2415   let Inst{15-12} = RdLo;
2416   let Inst{11-8}  = Rm;
2417   let Inst{3-0}   = Rn;
2418 }
2419
2420 let isCommutable = 1 in
2421 def MUL  : AsMul1I32<0b0000000, (outs GPR:$Rd), (ins GPR:$Rn, GPR:$Rm),
2422                    IIC_iMUL32, "mul", "\t$Rd, $Rn, $Rm",
2423                    [(set GPR:$Rd, (mul GPR:$Rn, GPR:$Rm))]>;
2424
2425 def MLA  : AsMul1I32<0b0000001, (outs GPR:$Rd), (ins GPR:$Rn, GPR:$Rm, GPR:$Ra),
2426                     IIC_iMAC32, "mla", "\t$Rd, $Rn, $Rm, $Ra",
2427                    [(set GPR:$Rd, (add (mul GPR:$Rn, GPR:$Rm), GPR:$Ra))]> {
2428   bits<4> Ra;
2429   let Inst{15-12} = Ra;
2430 }
2431
2432 def MLS  : AMul1I<0b0000011, (outs GPR:$dst), (ins GPR:$a, GPR:$b, GPR:$c),
2433                    IIC_iMAC32, "mls", "\t$dst, $a, $b, $c",
2434                    [(set GPR:$dst, (sub GPR:$c, (mul GPR:$a, GPR:$b)))]>,
2435                    Requires<[IsARM, HasV6T2]> {
2436   bits<4> Rd;
2437   bits<4> Rm;
2438   bits<4> Rn;
2439   let Inst{19-16} = Rd;
2440   let Inst{11-8}  = Rm;
2441   let Inst{3-0}   = Rn;
2442 }
2443
2444 // Extra precision multiplies with low / high results
2445
2446 let neverHasSideEffects = 1 in {
2447 let isCommutable = 1 in {
2448 def SMULL : AsMul1I64<0b0000110, (outs GPR:$RdLo, GPR:$RdHi),
2449                                (ins GPR:$Rn, GPR:$Rm), IIC_iMUL64,
2450                     "smull", "\t$RdLo, $RdHi, $Rn, $Rm", []>;
2451
2452 def UMULL : AsMul1I64<0b0000100, (outs GPR:$RdLo, GPR:$RdHi),
2453                                (ins GPR:$Rn, GPR:$Rm), IIC_iMUL64,
2454                     "umull", "\t$RdLo, $RdHi, $Rn, $Rm", []>;
2455 }
2456
2457 // Multiply + accumulate
2458 def SMLAL : AsMul1I64<0b0000111, (outs GPR:$RdLo, GPR:$RdHi),
2459                                (ins GPR:$Rn, GPR:$Rm), IIC_iMAC64,
2460                     "smlal", "\t$RdLo, $RdHi, $Rn, $Rm", []>;
2461
2462 def UMLAL : AsMul1I64<0b0000101, (outs GPR:$RdLo, GPR:$RdHi),
2463                                (ins GPR:$Rn, GPR:$Rm), IIC_iMAC64,
2464                     "umlal", "\t$RdLo, $RdHi, $Rn, $Rm", []>;
2465
2466 def UMAAL : AMul1I <0b0000010, (outs GPR:$RdLo, GPR:$RdHi),
2467                                (ins GPR:$Rn, GPR:$Rm), IIC_iMAC64,
2468                     "umaal", "\t$RdLo, $RdHi, $Rn, $Rm", []>,
2469                     Requires<[IsARM, HasV6]> {
2470   bits<4> RdLo;
2471   bits<4> RdHi;
2472   bits<4> Rm;
2473   bits<4> Rn;
2474   let Inst{19-16} = RdLo;
2475   let Inst{15-12} = RdHi;
2476   let Inst{11-8}  = Rm;
2477   let Inst{3-0}   = Rn;
2478 }
2479 } // neverHasSideEffects
2480
2481 // Most significant word multiply
2482 def SMMUL : AMul2I <0b0111010, 0b0001, (outs GPR:$Rd), (ins GPR:$Rn, GPR:$Rm),
2483                IIC_iMUL32, "smmul", "\t$Rd, $Rn, $Rm",
2484                [(set GPR:$Rd, (mulhs GPR:$Rn, GPR:$Rm))]>,
2485             Requires<[IsARM, HasV6]> {
2486   let Inst{15-12} = 0b1111;
2487 }
2488
2489 def SMMULR : AMul2I <0b0111010, 0b0011, (outs GPR:$Rd), (ins GPR:$Rn, GPR:$Rm),
2490                IIC_iMUL32, "smmulr", "\t$Rd, $Rn, $Rm",
2491                [/* For disassembly only; pattern left blank */]>,
2492             Requires<[IsARM, HasV6]> {
2493   let Inst{15-12} = 0b1111;
2494 }
2495
2496 def SMMLA : AMul2Ia <0b0111010, 0b0001, (outs GPR:$Rd),
2497                (ins GPR:$Rn, GPR:$Rm, GPR:$Ra),
2498                IIC_iMAC32, "smmla", "\t$Rd, $Rn, $Rm, $Ra",
2499                [(set GPR:$Rd, (add (mulhs GPR:$Rn, GPR:$Rm), GPR:$Ra))]>,
2500             Requires<[IsARM, HasV6]>;
2501
2502 def SMMLAR : AMul2Ia <0b0111010, 0b0011, (outs GPR:$Rd),
2503                (ins GPR:$Rn, GPR:$Rm, GPR:$Ra),
2504                IIC_iMAC32, "smmlar", "\t$Rd, $Rn, $Rm, $Ra",
2505                [/* For disassembly only; pattern left blank */]>,
2506             Requires<[IsARM, HasV6]>;
2507
2508 def SMMLS : AMul2Ia <0b0111010, 0b1101, (outs GPR:$Rd),
2509                (ins GPR:$Rn, GPR:$Rm, GPR:$Ra),
2510                IIC_iMAC32, "smmls", "\t$Rd, $Rn, $Rm, $Ra",
2511                [(set GPR:$Rd, (sub GPR:$Ra, (mulhs GPR:$Rn, GPR:$Rm)))]>,
2512             Requires<[IsARM, HasV6]>;
2513
2514 def SMMLSR : AMul2Ia <0b0111010, 0b1111, (outs GPR:$Rd),
2515                (ins GPR:$Rn, GPR:$Rm, GPR:$Ra),
2516                IIC_iMAC32, "smmlsr", "\t$Rd, $Rn, $Rm, $Ra",
2517                [/* For disassembly only; pattern left blank */]>,
2518             Requires<[IsARM, HasV6]>;
2519
2520 multiclass AI_smul<string opc, PatFrag opnode> {
2521   def BB : AMulxyI<0b0001011, 0b00, (outs GPR:$Rd), (ins GPR:$Rn, GPR:$Rm),
2522               IIC_iMUL16, !strconcat(opc, "bb"), "\t$Rd, $Rn, $Rm",
2523               [(set GPR:$Rd, (opnode (sext_inreg GPR:$Rn, i16),
2524                                       (sext_inreg GPR:$Rm, i16)))]>,
2525            Requires<[IsARM, HasV5TE]>;
2526
2527   def BT : AMulxyI<0b0001011, 0b10, (outs GPR:$Rd), (ins GPR:$Rn, GPR:$Rm),
2528               IIC_iMUL16, !strconcat(opc, "bt"), "\t$Rd, $Rn, $Rm",
2529               [(set GPR:$Rd, (opnode (sext_inreg GPR:$Rn, i16),
2530                                       (sra GPR:$Rm, (i32 16))))]>,
2531            Requires<[IsARM, HasV5TE]>;
2532
2533   def TB : AMulxyI<0b0001011, 0b01, (outs GPR:$Rd), (ins GPR:$Rn, GPR:$Rm),
2534               IIC_iMUL16, !strconcat(opc, "tb"), "\t$Rd, $Rn, $Rm",
2535               [(set GPR:$Rd, (opnode (sra GPR:$Rn, (i32 16)),
2536                                       (sext_inreg GPR:$Rm, i16)))]>,
2537            Requires<[IsARM, HasV5TE]>;
2538
2539   def TT : AMulxyI<0b0001011, 0b11, (outs GPR:$Rd), (ins GPR:$Rn, GPR:$Rm),
2540               IIC_iMUL16, !strconcat(opc, "tt"), "\t$Rd, $Rn, $Rm",
2541               [(set GPR:$Rd, (opnode (sra GPR:$Rn, (i32 16)),
2542                                       (sra GPR:$Rm, (i32 16))))]>,
2543             Requires<[IsARM, HasV5TE]>;
2544
2545   def WB : AMulxyI<0b0001001, 0b01, (outs GPR:$Rd), (ins GPR:$Rn, GPR:$Rm),
2546               IIC_iMUL16, !strconcat(opc, "wb"), "\t$Rd, $Rn, $Rm",
2547               [(set GPR:$Rd, (sra (opnode GPR:$Rn,
2548                                     (sext_inreg GPR:$Rm, i16)), (i32 16)))]>,
2549            Requires<[IsARM, HasV5TE]>;
2550
2551   def WT : AMulxyI<0b0001001, 0b11, (outs GPR:$Rd), (ins GPR:$Rn, GPR:$Rm),
2552               IIC_iMUL16, !strconcat(opc, "wt"), "\t$Rd, $Rn, $Rm",
2553               [(set GPR:$Rd, (sra (opnode GPR:$Rn,
2554                                     (sra GPR:$Rm, (i32 16))), (i32 16)))]>,
2555             Requires<[IsARM, HasV5TE]>;
2556 }
2557
2558
2559 multiclass AI_smla<string opc, PatFrag opnode> {
2560   def BB : AMulxyIa<0b0001000, 0b00, (outs GPR:$Rd),
2561               (ins GPR:$Rn, GPR:$Rm, GPR:$Ra),
2562               IIC_iMAC16, !strconcat(opc, "bb"), "\t$Rd, $Rn, $Rm, $Ra",
2563               [(set GPR:$Rd, (add GPR:$Ra,
2564                                (opnode (sext_inreg GPR:$Rn, i16),
2565                                        (sext_inreg GPR:$Rm, i16))))]>,
2566            Requires<[IsARM, HasV5TE]>;
2567
2568   def BT : AMulxyIa<0b0001000, 0b10, (outs GPR:$Rd),
2569               (ins GPR:$Rn, GPR:$Rm, GPR:$Ra),
2570               IIC_iMAC16, !strconcat(opc, "bt"), "\t$Rd, $Rn, $Rm, $Ra",
2571               [(set GPR:$Rd, (add GPR:$Ra, (opnode (sext_inreg GPR:$Rn, i16),
2572                                                    (sra GPR:$Rm, (i32 16)))))]>,
2573            Requires<[IsARM, HasV5TE]>;
2574
2575   def TB : AMulxyIa<0b0001000, 0b01, (outs GPR:$Rd),
2576               (ins GPR:$Rn, GPR:$Rm, GPR:$Ra),
2577               IIC_iMAC16, !strconcat(opc, "tb"), "\t$Rd, $Rn, $Rm, $Ra",
2578               [(set GPR:$Rd, (add GPR:$Ra, (opnode (sra GPR:$Rn, (i32 16)),
2579                                                 (sext_inreg GPR:$Rm, i16))))]>,
2580            Requires<[IsARM, HasV5TE]>;
2581
2582   def TT : AMulxyIa<0b0001000, 0b11, (outs GPR:$Rd),
2583               (ins GPR:$Rn, GPR:$Rm, GPR:$Ra),
2584               IIC_iMAC16, !strconcat(opc, "tt"), "\t$Rd, $Rn, $Rm, $Ra",
2585              [(set GPR:$Rd, (add GPR:$Ra, (opnode (sra GPR:$Rn, (i32 16)),
2586                                                    (sra GPR:$Rm, (i32 16)))))]>,
2587             Requires<[IsARM, HasV5TE]>;
2588
2589   def WB : AMulxyIa<0b0001001, 0b00, (outs GPR:$Rd),
2590               (ins GPR:$Rn, GPR:$Rm, GPR:$Ra),
2591               IIC_iMAC16, !strconcat(opc, "wb"), "\t$Rd, $Rn, $Rm, $Ra",
2592               [(set GPR:$Rd, (add GPR:$Ra, (sra (opnode GPR:$Rn,
2593                                       (sext_inreg GPR:$Rm, i16)), (i32 16))))]>,
2594            Requires<[IsARM, HasV5TE]>;
2595
2596   def WT : AMulxyIa<0b0001001, 0b10, (outs GPR:$Rd),
2597               (ins GPR:$Rn, GPR:$Rm, GPR:$Ra),
2598               IIC_iMAC16, !strconcat(opc, "wt"), "\t$Rd, $Rn, $Rm, $Ra",
2599               [(set GPR:$Rd, (add GPR:$Ra, (sra (opnode GPR:$Rn,
2600                                         (sra GPR:$Rm, (i32 16))), (i32 16))))]>,
2601             Requires<[IsARM, HasV5TE]>;
2602 }
2603
2604 defm SMUL : AI_smul<"smul", BinOpFrag<(mul node:$LHS, node:$RHS)>>;
2605 defm SMLA : AI_smla<"smla", BinOpFrag<(mul node:$LHS, node:$RHS)>>;
2606
2607 // Halfword multiply accumulate long: SMLAL<x><y> -- for disassembly only
2608 def SMLALBB : AMulxyI64<0b0001010, 0b00, (outs GPR:$RdLo, GPR:$RdHi),
2609                       (ins GPR:$Rn, GPR:$Rm),
2610                       IIC_iMAC64, "smlalbb", "\t$RdLo, $RdHi, $Rn, $Rm",
2611                       [/* For disassembly only; pattern left blank */]>,
2612               Requires<[IsARM, HasV5TE]>;
2613
2614 def SMLALBT : AMulxyI64<0b0001010, 0b10, (outs GPR:$RdLo, GPR:$RdHi),
2615                       (ins GPR:$Rn, GPR:$Rm),
2616                       IIC_iMAC64, "smlalbt", "\t$RdLo, $RdHi, $Rn, $Rm",
2617                       [/* For disassembly only; pattern left blank */]>,
2618               Requires<[IsARM, HasV5TE]>;
2619
2620 def SMLALTB : AMulxyI64<0b0001010, 0b01, (outs GPR:$RdLo, GPR:$RdHi),
2621                       (ins GPR:$Rn, GPR:$Rm),
2622                       IIC_iMAC64, "smlaltb", "\t$RdLo, $RdHi, $Rn, $Rm",
2623                       [/* For disassembly only; pattern left blank */]>,
2624               Requires<[IsARM, HasV5TE]>;
2625
2626 def SMLALTT : AMulxyI64<0b0001010, 0b11, (outs GPR:$RdLo, GPR:$RdHi),
2627                       (ins GPR:$Rn, GPR:$Rm),
2628                       IIC_iMAC64, "smlaltt", "\t$RdLo, $RdHi, $Rn, $Rm",
2629                       [/* For disassembly only; pattern left blank */]>,
2630               Requires<[IsARM, HasV5TE]>;
2631
2632 // Helper class for AI_smld -- for disassembly only
2633 class AMulDualIbase<bit long, bit sub, bit swap, dag oops, dag iops,
2634                     InstrItinClass itin, string opc, string asm>
2635   : AI<oops, iops, MulFrm, itin, opc, asm, []>, Requires<[IsARM, HasV6]> {
2636   bits<4> Rn;
2637   bits<4> Rm;
2638   let Inst{4}     = 1;
2639   let Inst{5}     = swap;
2640   let Inst{6}     = sub;
2641   let Inst{7}     = 0;
2642   let Inst{21-20} = 0b00;
2643   let Inst{22}    = long;
2644   let Inst{27-23} = 0b01110;
2645   let Inst{11-8}  = Rm;
2646   let Inst{3-0}   = Rn;
2647 }
2648 class AMulDualI<bit long, bit sub, bit swap, dag oops, dag iops,
2649                 InstrItinClass itin, string opc, string asm>
2650   : AMulDualIbase<long, sub, swap, oops, iops, itin, opc, asm> {
2651   bits<4> Rd;
2652   let Inst{15-12} = 0b1111;
2653   let Inst{19-16} = Rd;
2654 }
2655 class AMulDualIa<bit long, bit sub, bit swap, dag oops, dag iops,
2656                 InstrItinClass itin, string opc, string asm>
2657   : AMulDualIbase<long, sub, swap, oops, iops, itin, opc, asm> {
2658   bits<4> Ra;
2659   let Inst{15-12} = Ra;
2660 }
2661 class AMulDualI64<bit long, bit sub, bit swap, dag oops, dag iops,
2662                   InstrItinClass itin, string opc, string asm>
2663   : AMulDualIbase<long, sub, swap, oops, iops, itin, opc, asm> {
2664   bits<4> RdLo;
2665   bits<4> RdHi;
2666   let Inst{19-16} = RdHi;
2667   let Inst{15-12} = RdLo;
2668 }
2669
2670 multiclass AI_smld<bit sub, string opc> {
2671
2672   def D : AMulDualIa<0, sub, 0, (outs GPR:$Rd), (ins GPR:$Rn, GPR:$Rm, GPR:$Ra),
2673                   NoItinerary, !strconcat(opc, "d"), "\t$Rd, $Rn, $Rm, $Ra">;
2674
2675   def DX: AMulDualIa<0, sub, 1, (outs GPR:$Rd), (ins GPR:$Rn, GPR:$Rm, GPR:$Ra),
2676                   NoItinerary, !strconcat(opc, "dx"), "\t$Rd, $Rn, $Rm, $Ra">;
2677
2678   def LD: AMulDualI64<1, sub, 0, (outs GPR:$RdLo,GPR:$RdHi),
2679                   (ins GPR:$Rn, GPR:$Rm), NoItinerary,
2680                   !strconcat(opc, "ld"), "\t$RdLo, $RdHi, $Rn, $Rm">;
2681
2682   def LDX : AMulDualI64<1, sub, 1, (outs GPR:$RdLo,GPR:$RdHi),
2683                   (ins GPR:$Rn, GPR:$Rm), NoItinerary,
2684                   !strconcat(opc, "ldx"),"\t$RdLo, $RdHi, $Rn, $Rm">;
2685
2686 }
2687
2688 defm SMLA : AI_smld<0, "smla">;
2689 defm SMLS : AI_smld<1, "smls">;
2690
2691 multiclass AI_sdml<bit sub, string opc> {
2692
2693   def D : AMulDualI<0, sub, 0, (outs GPR:$Rd), (ins GPR:$Rn, GPR:$Rm),
2694                     NoItinerary, !strconcat(opc, "d"), "\t$Rd, $Rn, $Rm">;
2695   def DX : AMulDualI<0, sub, 1, (outs GPR:$Rd), (ins GPR:$Rn, GPR:$Rm),
2696                     NoItinerary, !strconcat(opc, "dx"), "\t$Rd, $Rn, $Rm">;
2697 }
2698
2699 defm SMUA : AI_sdml<0, "smua">;
2700 defm SMUS : AI_sdml<1, "smus">;
2701
2702 //===----------------------------------------------------------------------===//
2703 //  Misc. Arithmetic Instructions.
2704 //
2705
2706 def CLZ  : AMiscA1I<0b000010110, 0b0001, (outs GPR:$Rd), (ins GPR:$Rm),
2707               IIC_iUNAr, "clz", "\t$Rd, $Rm",
2708               [(set GPR:$Rd, (ctlz GPR:$Rm))]>, Requires<[IsARM, HasV5T]>;
2709
2710 def RBIT : AMiscA1I<0b01101111, 0b0011, (outs GPR:$Rd), (ins GPR:$Rm),
2711               IIC_iUNAr, "rbit", "\t$Rd, $Rm",
2712               [(set GPR:$Rd, (ARMrbit GPR:$Rm))]>,
2713            Requires<[IsARM, HasV6T2]>;
2714
2715 def REV  : AMiscA1I<0b01101011, 0b0011, (outs GPR:$Rd), (ins GPR:$Rm),
2716               IIC_iUNAr, "rev", "\t$Rd, $Rm",
2717               [(set GPR:$Rd, (bswap GPR:$Rm))]>, Requires<[IsARM, HasV6]>;
2718
2719 def REV16 : AMiscA1I<0b01101011, 0b1011, (outs GPR:$Rd), (ins GPR:$Rm),
2720                IIC_iUNAr, "rev16", "\t$Rd, $Rm",
2721                [(set GPR:$Rd,
2722                    (or (and (srl GPR:$Rm, (i32 8)), 0xFF),
2723                        (or (and (shl GPR:$Rm, (i32 8)), 0xFF00),
2724                            (or (and (srl GPR:$Rm, (i32 8)), 0xFF0000),
2725                                (and (shl GPR:$Rm, (i32 8)), 0xFF000000)))))]>,
2726                Requires<[IsARM, HasV6]>;
2727
2728 def REVSH : AMiscA1I<0b01101111, 0b1011, (outs GPR:$Rd), (ins GPR:$Rm),
2729                IIC_iUNAr, "revsh", "\t$Rd, $Rm",
2730                [(set GPR:$Rd,
2731                   (sext_inreg
2732                     (or (srl (and GPR:$Rm, 0xFF00), (i32 8)),
2733                         (shl GPR:$Rm, (i32 8))), i16))]>,
2734                Requires<[IsARM, HasV6]>;
2735
2736 def lsl_shift_imm : SDNodeXForm<imm, [{
2737   unsigned Sh = ARM_AM::getSORegOpc(ARM_AM::lsl, N->getZExtValue());
2738   return CurDAG->getTargetConstant(Sh, MVT::i32);
2739 }]>;
2740
2741 def lsl_amt : PatLeaf<(i32 imm), [{
2742   return (N->getZExtValue() < 32);
2743 }], lsl_shift_imm>;
2744
2745 def PKHBT : APKHI<0b01101000, 0, (outs GPR:$Rd),
2746                               (ins GPR:$Rn, GPR:$Rm, shift_imm:$sh),
2747                IIC_iALUsi, "pkhbt", "\t$Rd, $Rn, $Rm$sh",
2748                [(set GPR:$Rd, (or (and GPR:$Rn, 0xFFFF),
2749                                   (and (shl GPR:$Rm, lsl_amt:$sh),
2750                                        0xFFFF0000)))]>,
2751                Requires<[IsARM, HasV6]>;
2752
2753 // Alternate cases for PKHBT where identities eliminate some nodes.
2754 def : ARMV6Pat<(or (and GPR:$Rn, 0xFFFF), (and GPR:$Rm, 0xFFFF0000)),
2755                (PKHBT GPR:$Rn, GPR:$Rm, 0)>;
2756 def : ARMV6Pat<(or (and GPR:$Rn, 0xFFFF), (shl GPR:$Rm, imm16_31:$sh)),
2757                (PKHBT GPR:$Rn, GPR:$Rm, (lsl_shift_imm imm16_31:$sh))>;
2758
2759 def asr_shift_imm : SDNodeXForm<imm, [{
2760   unsigned Sh = ARM_AM::getSORegOpc(ARM_AM::asr, N->getZExtValue());
2761   return CurDAG->getTargetConstant(Sh, MVT::i32);
2762 }]>;
2763
2764 def asr_amt : PatLeaf<(i32 imm), [{
2765   return (N->getZExtValue() <= 32);
2766 }], asr_shift_imm>;
2767
2768 // Note: Shifts of 1-15 bits will be transformed to srl instead of sra and
2769 // will match the pattern below.
2770 def PKHTB : APKHI<0b01101000, 1, (outs GPR:$Rd),
2771                               (ins GPR:$Rn, GPR:$Rm, shift_imm:$sh),
2772                IIC_iBITsi, "pkhtb", "\t$Rd, $Rn, $Rm$sh",
2773                [(set GPR:$Rd, (or (and GPR:$Rn, 0xFFFF0000),
2774                                   (and (sra GPR:$Rm, asr_amt:$sh),
2775                                        0xFFFF)))]>,
2776                Requires<[IsARM, HasV6]>;
2777
2778 // Alternate cases for PKHTB where identities eliminate some nodes.  Note that
2779 // a shift amount of 0 is *not legal* here, it is PKHBT instead.
2780 def : ARMV6Pat<(or (and GPR:$src1, 0xFFFF0000), (srl GPR:$src2, imm16_31:$sh)),
2781                (PKHTB GPR:$src1, GPR:$src2, (asr_shift_imm imm16_31:$sh))>;
2782 def : ARMV6Pat<(or (and GPR:$src1, 0xFFFF0000),
2783                    (and (srl GPR:$src2, imm1_15:$sh), 0xFFFF)),
2784                (PKHTB GPR:$src1, GPR:$src2, (asr_shift_imm imm1_15:$sh))>;
2785
2786 //===----------------------------------------------------------------------===//
2787 //  Comparison Instructions...
2788 //
2789
2790 defm CMP  : AI1_cmp_irs<0b1010, "cmp",
2791                         IIC_iCMPi, IIC_iCMPr, IIC_iCMPsr,
2792                         BinOpFrag<(ARMcmp node:$LHS, node:$RHS)>>;
2793
2794 // FIXME: We have to be careful when using the CMN instruction and comparison
2795 // with 0. One would expect these two pieces of code should give identical
2796 // results:
2797 //
2798 //   rsbs r1, r1, 0
2799 //   cmp  r0, r1
2800 //   mov  r0, #0
2801 //   it   ls
2802 //   mov  r0, #1
2803 //
2804 // and:
2805 //
2806 //   cmn  r0, r1
2807 //   mov  r0, #0
2808 //   it   ls
2809 //   mov  r0, #1
2810 //
2811 // However, the CMN gives the *opposite* result when r1 is 0. This is because
2812 // the carry flag is set in the CMP case but not in the CMN case. In short, the
2813 // CMP instruction doesn't perform a truncate of the (logical) NOT of 0 plus the
2814 // value of r0 and the carry bit (because the "carry bit" parameter to
2815 // AddWithCarry is defined as 1 in this case, the carry flag will always be set
2816 // when r0 >= 0). The CMN instruction doesn't perform a NOT of 0 so there is
2817 // never a "carry" when this AddWithCarry is performed (because the "carry bit"
2818 // parameter to AddWithCarry is defined as 0).
2819 //
2820 // When x is 0 and unsigned:
2821 //
2822 //    x = 0
2823 //   ~x = 0xFFFF FFFF
2824 //   ~x + 1 = 0x1 0000 0000
2825 //   (-x = 0) != (0x1 0000 0000 = ~x + 1)
2826 //
2827 // Therefore, we should disable CMN when comparing against zero, until we can
2828 // limit when the CMN instruction is used (when we know that the RHS is not 0 or
2829 // when it's a comparison which doesn't look at the 'carry' flag).
2830 //
2831 // (See the ARM docs for the "AddWithCarry" pseudo-code.)
2832 //
2833 // This is related to <rdar://problem/7569620>.
2834 //
2835 //defm CMN  : AI1_cmp_irs<0b1011, "cmn",
2836 //                        BinOpFrag<(ARMcmp node:$LHS,(ineg node:$RHS))>>;
2837
2838 // Note that TST/TEQ don't set all the same flags that CMP does!
2839 defm TST  : AI1_cmp_irs<0b1000, "tst",
2840                         IIC_iTSTi, IIC_iTSTr, IIC_iTSTsr,
2841                         BinOpFrag<(ARMcmpZ (and node:$LHS, node:$RHS), 0)>, 1>;
2842 defm TEQ  : AI1_cmp_irs<0b1001, "teq",
2843                         IIC_iTSTi, IIC_iTSTr, IIC_iTSTsr,
2844                         BinOpFrag<(ARMcmpZ (xor node:$LHS, node:$RHS), 0)>, 1>;
2845
2846 defm CMPz  : AI1_cmp_irs<0b1010, "cmp",
2847                          IIC_iCMPi, IIC_iCMPr, IIC_iCMPsr,
2848                          BinOpFrag<(ARMcmpZ node:$LHS, node:$RHS)>>;
2849 defm CMNz  : AI1_cmp_irs<0b1011, "cmn",
2850                          IIC_iCMPi, IIC_iCMPr, IIC_iCMPsr,
2851                          BinOpFrag<(ARMcmpZ node:$LHS,(ineg node:$RHS))>>;
2852
2853 //def : ARMPat<(ARMcmp GPR:$src, so_imm_neg:$imm),
2854 //             (CMNri  GPR:$src, so_imm_neg:$imm)>;
2855
2856 def : ARMPat<(ARMcmpZ GPR:$src, so_imm_neg:$imm),
2857              (CMNzri  GPR:$src, so_imm_neg:$imm)>;
2858
2859 // Pseudo i64 compares for some floating point compares.
2860 let usesCustomInserter = 1, isBranch = 1, isTerminator = 1,
2861     Defs = [CPSR] in {
2862 def BCCi64 : PseudoInst<(outs),
2863     (ins i32imm:$cc, GPR:$lhs1, GPR:$lhs2, GPR:$rhs1, GPR:$rhs2, brtarget:$dst),
2864      IIC_Br, "",
2865     [(ARMBcci64 imm:$cc, GPR:$lhs1, GPR:$lhs2, GPR:$rhs1, GPR:$rhs2, bb:$dst)]>;
2866
2867 def BCCZi64 : PseudoInst<(outs),
2868      (ins i32imm:$cc, GPR:$lhs1, GPR:$lhs2, brtarget:$dst), IIC_Br, "",
2869     [(ARMBcci64 imm:$cc, GPR:$lhs1, GPR:$lhs2, 0, 0, bb:$dst)]>;
2870 } // usesCustomInserter
2871
2872
2873 // Conditional moves
2874 // FIXME: should be able to write a pattern for ARMcmov, but can't use
2875 // a two-value operand where a dag node expects two operands. :(
2876 // FIXME: These should all be pseudo-instructions that get expanded to
2877 //        the normal MOV instructions. That would fix the dependency on
2878 //        special casing them in tblgen.
2879 let neverHasSideEffects = 1 in {
2880 def MOVCCr : AI1<0b1101, (outs GPR:$Rd), (ins GPR:$false, GPR:$Rm), DPFrm,
2881                 IIC_iCMOVr, "mov", "\t$Rd, $Rm",
2882       [/*(set GPR:$Rd, (ARMcmov GPR:$false, GPR:$Rm, imm:$cc, CCR:$ccr))*/]>,
2883                 RegConstraint<"$false = $Rd">, UnaryDP {
2884   bits<4> Rd;
2885   bits<4> Rm;
2886   let Inst{25} = 0;
2887   let Inst{20} = 0;
2888   let Inst{15-12} = Rd;
2889   let Inst{11-4} = 0b00000000;
2890   let Inst{3-0} = Rm;
2891 }
2892
2893 def MOVCCs : AI1<0b1101, (outs GPR:$Rd),
2894                  (ins GPR:$false, so_reg:$shift), DPSoRegFrm, IIC_iCMOVsr,
2895                 "mov", "\t$Rd, $shift",
2896    [/*(set GPR:$Rd, (ARMcmov GPR:$false, so_reg:$shift, imm:$cc, CCR:$ccr))*/]>,
2897                 RegConstraint<"$false = $Rd">, UnaryDP {
2898   bits<4> Rd;
2899   bits<4> Rn;
2900   bits<12> shift;
2901   let Inst{25} = 0;
2902   let Inst{20} = 0;
2903   let Inst{19-16} = Rn;
2904   let Inst{15-12} = Rd;
2905   let Inst{11-0} = shift;
2906 }
2907
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 def MOVCCi : AI1<0b1101, (outs GPR:$Rd),
2924                          (ins GPR:$false, so_imm:$imm), DPFrm, IIC_iCMOVi,
2925                 "mov", "\t$Rd, $imm",
2926    [/*(set GPR:$Rd, (ARMcmov GPR:$false, so_imm:$imm, imm:$cc, CCR:$ccr))*/]>,
2927                 RegConstraint<"$false = $Rd">, UnaryDP {
2928   bits<4> Rd;
2929   bits<12> imm;
2930   let Inst{25} = 1;
2931   let Inst{20} = 0;
2932   let Inst{19-16} = 0b0000;
2933   let Inst{15-12} = Rd;
2934   let Inst{11-0} = imm;
2935 }
2936 } // neverHasSideEffects
2937
2938 //===----------------------------------------------------------------------===//
2939 // Atomic operations intrinsics
2940 //
2941
2942 def memb_opt : Operand<i32> {
2943   let PrintMethod = "printMemBOption";
2944 }
2945
2946 // memory barriers protect the atomic sequences
2947 let hasSideEffects = 1 in {
2948 def DMB : AInoP<(outs), (ins memb_opt:$opt), MiscFrm, NoItinerary,
2949                 "dmb", "\t$opt", [(ARMMemBarrier (i32 imm:$opt))]>,
2950                 Requires<[IsARM, HasDB]> {
2951   bits<4> opt;
2952   let Inst{31-4} = 0xf57ff05;
2953   let Inst{3-0} = opt;
2954 }
2955
2956 def DMB_MCR : AInoP<(outs), (ins GPR:$zero), MiscFrm, NoItinerary,
2957                        "mcr", "\tp15, 0, $zero, c7, c10, 5",
2958                        [(ARMMemBarrierMCR GPR:$zero)]>,
2959                        Requires<[IsARM, HasV6]> {
2960   // FIXME: add encoding
2961 }
2962 }
2963
2964 def DSB : AInoP<(outs), (ins memb_opt:$opt), MiscFrm, NoItinerary,
2965                 "dsb", "\t$opt",
2966                 [/* For disassembly only; pattern left blank */]>,
2967                 Requires<[IsARM, HasDB]> {
2968   bits<4> opt;
2969   let Inst{31-4} = 0xf57ff04;
2970   let Inst{3-0} = opt;
2971 }
2972
2973 // ISB has only full system option -- for disassembly only
2974 def ISB : AInoP<(outs), (ins), MiscFrm, NoItinerary, "isb", "", []>,
2975                 Requires<[IsARM, HasDB]> {
2976   let Inst{31-4} = 0xf57ff06;
2977   let Inst{3-0} = 0b1111;
2978 }
2979
2980 let usesCustomInserter = 1 in {
2981   let Uses = [CPSR] in {
2982     def ATOMIC_LOAD_ADD_I8 : PseudoInst<
2983       (outs GPR:$dst), (ins GPR:$ptr, GPR:$incr), NoItinerary, "",
2984       [(set GPR:$dst, (atomic_load_add_8 GPR:$ptr, GPR:$incr))]>;
2985     def ATOMIC_LOAD_SUB_I8 : PseudoInst<
2986       (outs GPR:$dst), (ins GPR:$ptr, GPR:$incr), NoItinerary, "",
2987       [(set GPR:$dst, (atomic_load_sub_8 GPR:$ptr, GPR:$incr))]>;
2988     def ATOMIC_LOAD_AND_I8 : PseudoInst<
2989       (outs GPR:$dst), (ins GPR:$ptr, GPR:$incr), NoItinerary, "",
2990       [(set GPR:$dst, (atomic_load_and_8 GPR:$ptr, GPR:$incr))]>;
2991     def ATOMIC_LOAD_OR_I8 : PseudoInst<
2992       (outs GPR:$dst), (ins GPR:$ptr, GPR:$incr), NoItinerary, "",
2993       [(set GPR:$dst, (atomic_load_or_8 GPR:$ptr, GPR:$incr))]>;
2994     def ATOMIC_LOAD_XOR_I8 : PseudoInst<
2995       (outs GPR:$dst), (ins GPR:$ptr, GPR:$incr), NoItinerary, "",
2996       [(set GPR:$dst, (atomic_load_xor_8 GPR:$ptr, GPR:$incr))]>;
2997     def ATOMIC_LOAD_NAND_I8 : PseudoInst<
2998       (outs GPR:$dst), (ins GPR:$ptr, GPR:$incr), NoItinerary, "",
2999       [(set GPR:$dst, (atomic_load_nand_8 GPR:$ptr, GPR:$incr))]>;
3000     def ATOMIC_LOAD_ADD_I16 : PseudoInst<
3001       (outs GPR:$dst), (ins GPR:$ptr, GPR:$incr), NoItinerary, "",
3002       [(set GPR:$dst, (atomic_load_add_16 GPR:$ptr, GPR:$incr))]>;
3003     def ATOMIC_LOAD_SUB_I16 : PseudoInst<
3004       (outs GPR:$dst), (ins GPR:$ptr, GPR:$incr), NoItinerary, "",
3005       [(set GPR:$dst, (atomic_load_sub_16 GPR:$ptr, GPR:$incr))]>;
3006     def ATOMIC_LOAD_AND_I16 : PseudoInst<
3007       (outs GPR:$dst), (ins GPR:$ptr, GPR:$incr), NoItinerary, "",
3008       [(set GPR:$dst, (atomic_load_and_16 GPR:$ptr, GPR:$incr))]>;
3009     def ATOMIC_LOAD_OR_I16 : PseudoInst<
3010       (outs GPR:$dst), (ins GPR:$ptr, GPR:$incr), NoItinerary, "",
3011       [(set GPR:$dst, (atomic_load_or_16 GPR:$ptr, GPR:$incr))]>;
3012     def ATOMIC_LOAD_XOR_I16 : PseudoInst<
3013       (outs GPR:$dst), (ins GPR:$ptr, GPR:$incr), NoItinerary, "",
3014       [(set GPR:$dst, (atomic_load_xor_16 GPR:$ptr, GPR:$incr))]>;
3015     def ATOMIC_LOAD_NAND_I16 : PseudoInst<
3016       (outs GPR:$dst), (ins GPR:$ptr, GPR:$incr), NoItinerary, "",
3017       [(set GPR:$dst, (atomic_load_nand_16 GPR:$ptr, GPR:$incr))]>;
3018     def ATOMIC_LOAD_ADD_I32 : PseudoInst<
3019       (outs GPR:$dst), (ins GPR:$ptr, GPR:$incr), NoItinerary, "",
3020       [(set GPR:$dst, (atomic_load_add_32 GPR:$ptr, GPR:$incr))]>;
3021     def ATOMIC_LOAD_SUB_I32 : PseudoInst<
3022       (outs GPR:$dst), (ins GPR:$ptr, GPR:$incr), NoItinerary, "",
3023       [(set GPR:$dst, (atomic_load_sub_32 GPR:$ptr, GPR:$incr))]>;
3024     def ATOMIC_LOAD_AND_I32 : PseudoInst<
3025       (outs GPR:$dst), (ins GPR:$ptr, GPR:$incr), NoItinerary, "",
3026       [(set GPR:$dst, (atomic_load_and_32 GPR:$ptr, GPR:$incr))]>;
3027     def ATOMIC_LOAD_OR_I32 : PseudoInst<
3028       (outs GPR:$dst), (ins GPR:$ptr, GPR:$incr), NoItinerary, "",
3029       [(set GPR:$dst, (atomic_load_or_32 GPR:$ptr, GPR:$incr))]>;
3030     def ATOMIC_LOAD_XOR_I32 : PseudoInst<
3031       (outs GPR:$dst), (ins GPR:$ptr, GPR:$incr), NoItinerary, "",
3032       [(set GPR:$dst, (atomic_load_xor_32 GPR:$ptr, GPR:$incr))]>;
3033     def ATOMIC_LOAD_NAND_I32 : PseudoInst<
3034       (outs GPR:$dst), (ins GPR:$ptr, GPR:$incr), NoItinerary, "",
3035       [(set GPR:$dst, (atomic_load_nand_32 GPR:$ptr, GPR:$incr))]>;
3036
3037     def ATOMIC_SWAP_I8 : PseudoInst<
3038       (outs GPR:$dst), (ins GPR:$ptr, GPR:$new), NoItinerary, "",
3039       [(set GPR:$dst, (atomic_swap_8 GPR:$ptr, GPR:$new))]>;
3040     def ATOMIC_SWAP_I16 : PseudoInst<
3041       (outs GPR:$dst), (ins GPR:$ptr, GPR:$new), NoItinerary, "",
3042       [(set GPR:$dst, (atomic_swap_16 GPR:$ptr, GPR:$new))]>;
3043     def ATOMIC_SWAP_I32 : PseudoInst<
3044       (outs GPR:$dst), (ins GPR:$ptr, GPR:$new), NoItinerary, "",
3045       [(set GPR:$dst, (atomic_swap_32 GPR:$ptr, GPR:$new))]>;
3046
3047     def ATOMIC_CMP_SWAP_I8 : PseudoInst<
3048       (outs GPR:$dst), (ins GPR:$ptr, GPR:$old, GPR:$new), NoItinerary, "",
3049       [(set GPR:$dst, (atomic_cmp_swap_8 GPR:$ptr, GPR:$old, GPR:$new))]>;
3050     def ATOMIC_CMP_SWAP_I16 : PseudoInst<
3051       (outs GPR:$dst), (ins GPR:$ptr, GPR:$old, GPR:$new), NoItinerary, "",
3052       [(set GPR:$dst, (atomic_cmp_swap_16 GPR:$ptr, GPR:$old, GPR:$new))]>;
3053     def ATOMIC_CMP_SWAP_I32 : PseudoInst<
3054       (outs GPR:$dst), (ins GPR:$ptr, GPR:$old, GPR:$new), NoItinerary, "",
3055       [(set GPR:$dst, (atomic_cmp_swap_32 GPR:$ptr, GPR:$old, GPR:$new))]>;
3056 }
3057 }
3058
3059 let mayLoad = 1 in {
3060 def LDREXB : AIldrex<0b10, (outs GPR:$Rt), (ins GPR:$Rn), NoItinerary,
3061                     "ldrexb", "\t$Rt, [$Rn]",
3062                     []>;
3063 def LDREXH : AIldrex<0b11, (outs GPR:$Rt), (ins GPR:$Rn), NoItinerary,
3064                     "ldrexh", "\t$Rt, [$Rn]",
3065                     []>;
3066 def LDREX  : AIldrex<0b00, (outs GPR:$Rt), (ins GPR:$Rn), NoItinerary,
3067                     "ldrex", "\t$Rt, [$Rn]",
3068                     []>;
3069 def LDREXD : AIldrex<0b01, (outs GPR:$Rt, GPR:$Rt2), (ins GPR:$Rn),
3070                     NoItinerary,
3071                     "ldrexd", "\t$Rt, $Rt2, [$Rn]",
3072                     []>;
3073 }
3074
3075 let mayStore = 1, Constraints = "@earlyclobber $Rd" in {
3076 def STREXB : AIstrex<0b10, (outs GPR:$Rd), (ins GPR:$src, GPR:$Rn),
3077                     NoItinerary,
3078                     "strexb", "\t$Rd, $src, [$Rn]",
3079                     []>;
3080 def STREXH : AIstrex<0b11, (outs GPR:$Rd), (ins GPR:$Rt, GPR:$Rn),
3081                     NoItinerary,
3082                     "strexh", "\t$Rd, $Rt, [$Rn]",
3083                     []>;
3084 def STREX  : AIstrex<0b00, (outs GPR:$Rd), (ins GPR:$Rt, GPR:$Rn),
3085                     NoItinerary,
3086                     "strex", "\t$Rd, $Rt, [$Rn]",
3087                     []>;
3088 def STREXD : AIstrex<0b01, (outs GPR:$Rd),
3089                     (ins GPR:$Rt, GPR:$Rt2, GPR:$Rn),
3090                     NoItinerary,
3091                     "strexd", "\t$Rd, $Rt, $Rt2, [$Rn]",
3092                     []>;
3093 }
3094
3095 // Clear-Exclusive is for disassembly only.
3096 def CLREX : AXI<(outs), (ins), MiscFrm, NoItinerary, "clrex",
3097                 [/* For disassembly only; pattern left blank */]>,
3098             Requires<[IsARM, HasV7]>  {
3099   let Inst{31-0} = 0b11110101011111111111000000011111;
3100 }
3101
3102 // SWP/SWPB are deprecated in V6/V7 and for disassembly only.
3103 let mayLoad = 1 in {
3104 def SWP  : AIswp<0, (outs GPR:$Rt), (ins GPR:$Rt2, GPR:$Rn), "swp",
3105              [/* For disassembly only; pattern left blank */]>;
3106 def SWPB : AIswp<1, (outs GPR:$Rt), (ins GPR:$Rt2, GPR:$Rn), "swpb",
3107              [/* For disassembly only; pattern left blank */]>;
3108 }
3109
3110 //===----------------------------------------------------------------------===//
3111 // TLS Instructions
3112 //
3113
3114 // __aeabi_read_tp preserves the registers r1-r3.
3115 // FIXME: This needs to be a pseudo of some sort so that we can get the
3116 // encoding right, complete with fixup for the aeabi_read_tp function.
3117 let isCall = 1,
3118   Defs = [R0, R12, LR, CPSR] in {
3119   def TPsoft : ABXI<0b1011, (outs), (ins), IIC_Br,
3120                "bl\t__aeabi_read_tp",
3121                [(set R0, ARMthread_pointer)]>;
3122 }
3123
3124 //===----------------------------------------------------------------------===//
3125 // SJLJ Exception handling intrinsics
3126 //   eh_sjlj_setjmp() is an instruction sequence to store the return
3127 //   address and save #0 in R0 for the non-longjmp case.
3128 //   Since by its nature we may be coming from some other function to get
3129 //   here, and we're using the stack frame for the containing function to
3130 //   save/restore registers, we can't keep anything live in regs across
3131 //   the eh_sjlj_setjmp(), else it will almost certainly have been tromped upon
3132 //   when we get here from a longjmp(). We force everthing out of registers
3133 //   except for our own input by listing the relevant registers in Defs. By
3134 //   doing so, we also cause the prologue/epilogue code to actively preserve
3135 //   all of the callee-saved resgisters, which is exactly what we want.
3136 //   A constant value is passed in $val, and we use the location as a scratch.
3137 //
3138 // These are pseudo-instructions and are lowered to individual MC-insts, so
3139 // no encoding information is necessary.
3140 let Defs =
3141   [ R0,  R1,  R2,  R3,  R4,  R5,  R6,  R7,  R8,  R9,  R10, R11, R12, LR,  D0,
3142     D1,  D2,  D3,  D4,  D5,  D6,  D7,  D8,  D9,  D10, D11, D12, D13, D14, D15,
3143     D16, D17, D18, D19, D20, D21, D22, D23, D24, D25, D26, D27, D28, D29, D30,
3144     D31 ], hasSideEffects = 1, isBarrier = 1 in {
3145   def Int_eh_sjlj_setjmp : XI<(outs), (ins GPR:$src, GPR:$val),
3146                                AddrModeNone, SizeSpecial, IndexModeNone,
3147                                Pseudo, NoItinerary, "", "",
3148                          [(set R0, (ARMeh_sjlj_setjmp GPR:$src, GPR:$val))]>,
3149                            Requires<[IsARM, HasVFP2]>;
3150 }
3151
3152 let Defs =
3153   [ R0,  R1,  R2,  R3,  R4,  R5,  R6,  R7,  R8,  R9,  R10, R11, R12, LR ],
3154   hasSideEffects = 1, isBarrier = 1 in {
3155   def Int_eh_sjlj_setjmp_nofp : XI<(outs), (ins GPR:$src, GPR:$val),
3156                                    AddrModeNone, SizeSpecial, IndexModeNone,
3157                                    Pseudo, NoItinerary, "", "",
3158                          [(set R0, (ARMeh_sjlj_setjmp GPR:$src, GPR:$val))]>,
3159                                 Requires<[IsARM, NoVFP]>;
3160 }
3161
3162 // FIXME: Non-Darwin version(s)
3163 let isBarrier = 1, hasSideEffects = 1, isTerminator = 1,
3164     Defs = [ R7, LR, SP ] in {
3165 def Int_eh_sjlj_longjmp : XI<(outs), (ins GPR:$src, GPR:$scratch),
3166                              AddrModeNone, SizeSpecial, IndexModeNone,
3167                              Pseudo, NoItinerary, "", "",
3168                          [(ARMeh_sjlj_longjmp GPR:$src, GPR:$scratch)]>,
3169                                 Requires<[IsARM, IsDarwin]>;
3170 }
3171
3172 // eh.sjlj.dispatchsetup pseudo-instruction.
3173 // This pseudo is used for ARM, Thumb1 and Thumb2. Any differences are
3174 // handled when the pseudo is expanded (which happens before any passes
3175 // that need the instruction size).
3176 let isBarrier = 1, hasSideEffects = 1 in
3177 def Int_eh_sjlj_dispatchsetup :
3178  PseudoInst<(outs), (ins GPR:$src), NoItinerary, "",
3179             [(ARMeh_sjlj_dispatchsetup GPR:$src)]>,
3180               Requires<[IsDarwin]>;
3181
3182 //===----------------------------------------------------------------------===//
3183 // Non-Instruction Patterns
3184 //
3185
3186 // Large immediate handling.
3187
3188 // Two piece so_imms.
3189 // FIXME: Remove this when we can do generalized remat.
3190 let isReMaterializable = 1 in
3191 def MOVi2pieces : PseudoInst<(outs GPR:$dst), (ins so_imm2part:$src),
3192                              IIC_iMOVix2, "",
3193                              [(set GPR:$dst, (so_imm2part:$src))]>,
3194                   Requires<[IsARM, NoV6T2]>;
3195
3196 def : ARMPat<(or GPR:$LHS, so_imm2part:$RHS),
3197              (ORRri (ORRri GPR:$LHS, (so_imm2part_1 imm:$RHS)),
3198                     (so_imm2part_2 imm:$RHS))>;
3199 def : ARMPat<(xor GPR:$LHS, so_imm2part:$RHS),
3200              (EORri (EORri GPR:$LHS, (so_imm2part_1 imm:$RHS)),
3201                     (so_imm2part_2 imm:$RHS))>;
3202 def : ARMPat<(add GPR:$LHS, so_imm2part:$RHS),
3203              (ADDri (ADDri GPR:$LHS, (so_imm2part_1 imm:$RHS)),
3204                     (so_imm2part_2 imm:$RHS))>;
3205 def : ARMPat<(add GPR:$LHS, so_neg_imm2part:$RHS),
3206              (SUBri (SUBri GPR:$LHS, (so_neg_imm2part_1 imm:$RHS)),
3207                     (so_neg_imm2part_2 imm:$RHS))>;
3208
3209 // 32-bit immediate using movw + movt.
3210 // This is a single pseudo instruction, the benefit is that it can be remat'd
3211 // as a single unit instead of having to handle reg inputs.
3212 // FIXME: Remove this when we can do generalized remat.
3213 let isReMaterializable = 1 in
3214 def MOVi32imm : PseudoInst<(outs GPR:$dst), (ins i32imm:$src), IIC_iMOVix2, "",
3215                            [(set GPR:$dst, (i32 imm:$src))]>,
3216                            Requires<[IsARM, HasV6T2]>;
3217
3218 // ConstantPool, GlobalAddress, and JumpTable
3219 def : ARMPat<(ARMWrapper  tglobaladdr :$dst), (LEApcrel tglobaladdr :$dst)>,
3220             Requires<[IsARM, DontUseMovt]>;
3221 def : ARMPat<(ARMWrapper  tconstpool  :$dst), (LEApcrel tconstpool  :$dst)>;
3222 def : ARMPat<(ARMWrapper  tglobaladdr :$dst), (MOVi32imm tglobaladdr :$dst)>,
3223             Requires<[IsARM, UseMovt]>;
3224 def : ARMPat<(ARMWrapperJT tjumptable:$dst, imm:$id),
3225              (LEApcrelJT tjumptable:$dst, imm:$id)>;
3226
3227 // TODO: add,sub,and, 3-instr forms?
3228
3229 // Tail calls
3230 def : ARMPat<(ARMtcret tcGPR:$dst),
3231           (TCRETURNri tcGPR:$dst)>, Requires<[IsDarwin]>;
3232
3233 def : ARMPat<(ARMtcret (i32 tglobaladdr:$dst)),
3234           (TCRETURNdi texternalsym:$dst)>, Requires<[IsDarwin]>;
3235
3236 def : ARMPat<(ARMtcret (i32 texternalsym:$dst)),
3237           (TCRETURNdi texternalsym:$dst)>, Requires<[IsDarwin]>;
3238
3239 def : ARMPat<(ARMtcret tcGPR:$dst),
3240           (TCRETURNriND tcGPR:$dst)>, Requires<[IsNotDarwin]>;
3241
3242 def : ARMPat<(ARMtcret (i32 tglobaladdr:$dst)),
3243           (TCRETURNdiND texternalsym:$dst)>, Requires<[IsNotDarwin]>;
3244
3245 def : ARMPat<(ARMtcret (i32 texternalsym:$dst)),
3246           (TCRETURNdiND texternalsym:$dst)>, Requires<[IsNotDarwin]>;
3247
3248 // Direct calls
3249 def : ARMPat<(ARMcall texternalsym:$func), (BL texternalsym:$func)>,
3250       Requires<[IsARM, IsNotDarwin]>;
3251 def : ARMPat<(ARMcall texternalsym:$func), (BLr9 texternalsym:$func)>,
3252       Requires<[IsARM, IsDarwin]>;
3253
3254 // zextload i1 -> zextload i8
3255 def : ARMPat<(zextloadi1 addrmode_imm12:$addr), (LDRBi12 addrmode_imm12:$addr)>;
3256 def : ARMPat<(zextloadi1 ldst_so_reg:$addr),    (LDRBrs ldst_so_reg:$addr)>;
3257
3258 // extload -> zextload
3259 def : ARMPat<(extloadi1 addrmode_imm12:$addr),  (LDRBi12 addrmode_imm12:$addr)>;
3260 def : ARMPat<(extloadi1 ldst_so_reg:$addr),     (LDRBrs ldst_so_reg:$addr)>;
3261 def : ARMPat<(extloadi8 addrmode_imm12:$addr),  (LDRBi12 addrmode_imm12:$addr)>;
3262 def : ARMPat<(extloadi8 ldst_so_reg:$addr),     (LDRBrs ldst_so_reg:$addr)>;
3263
3264 def : ARMPat<(extloadi16 addrmode3:$addr),  (LDRH addrmode3:$addr)>;
3265
3266 def : ARMPat<(extloadi8  addrmodepc:$addr), (PICLDRB addrmodepc:$addr)>;
3267 def : ARMPat<(extloadi16 addrmodepc:$addr), (PICLDRH addrmodepc:$addr)>;
3268
3269 // smul* and smla*
3270 def : ARMV5TEPat<(mul (sra (shl GPR:$a, (i32 16)), (i32 16)),
3271                       (sra (shl GPR:$b, (i32 16)), (i32 16))),
3272                  (SMULBB GPR:$a, GPR:$b)>;
3273 def : ARMV5TEPat<(mul sext_16_node:$a, sext_16_node:$b),
3274                  (SMULBB GPR:$a, GPR:$b)>;
3275 def : ARMV5TEPat<(mul (sra (shl GPR:$a, (i32 16)), (i32 16)),
3276                       (sra GPR:$b, (i32 16))),
3277                  (SMULBT GPR:$a, GPR:$b)>;
3278 def : ARMV5TEPat<(mul sext_16_node:$a, (sra GPR:$b, (i32 16))),
3279                  (SMULBT GPR:$a, GPR:$b)>;
3280 def : ARMV5TEPat<(mul (sra GPR:$a, (i32 16)),
3281                       (sra (shl GPR:$b, (i32 16)), (i32 16))),
3282                  (SMULTB GPR:$a, GPR:$b)>;
3283 def : ARMV5TEPat<(mul (sra GPR:$a, (i32 16)), sext_16_node:$b),
3284                 (SMULTB GPR:$a, GPR:$b)>;
3285 def : ARMV5TEPat<(sra (mul GPR:$a, (sra (shl GPR:$b, (i32 16)), (i32 16))),
3286                       (i32 16)),
3287                  (SMULWB GPR:$a, GPR:$b)>;
3288 def : ARMV5TEPat<(sra (mul GPR:$a, sext_16_node:$b), (i32 16)),
3289                  (SMULWB GPR:$a, GPR:$b)>;
3290
3291 def : ARMV5TEPat<(add GPR:$acc,
3292                       (mul (sra (shl GPR:$a, (i32 16)), (i32 16)),
3293                            (sra (shl GPR:$b, (i32 16)), (i32 16)))),
3294                  (SMLABB GPR:$a, GPR:$b, GPR:$acc)>;
3295 def : ARMV5TEPat<(add GPR:$acc,
3296                       (mul sext_16_node:$a, sext_16_node:$b)),
3297                  (SMLABB GPR:$a, GPR:$b, GPR:$acc)>;
3298 def : ARMV5TEPat<(add GPR:$acc,
3299                       (mul (sra (shl GPR:$a, (i32 16)), (i32 16)),
3300                            (sra GPR:$b, (i32 16)))),
3301                  (SMLABT GPR:$a, GPR:$b, GPR:$acc)>;
3302 def : ARMV5TEPat<(add GPR:$acc,
3303                       (mul sext_16_node:$a, (sra GPR:$b, (i32 16)))),
3304                  (SMLABT GPR:$a, GPR:$b, GPR:$acc)>;
3305 def : ARMV5TEPat<(add GPR:$acc,
3306                       (mul (sra GPR:$a, (i32 16)),
3307                            (sra (shl GPR:$b, (i32 16)), (i32 16)))),
3308                  (SMLATB GPR:$a, GPR:$b, GPR:$acc)>;
3309 def : ARMV5TEPat<(add GPR:$acc,
3310                       (mul (sra GPR:$a, (i32 16)), sext_16_node:$b)),
3311                  (SMLATB GPR:$a, GPR:$b, GPR:$acc)>;
3312 def : ARMV5TEPat<(add GPR:$acc,
3313                       (sra (mul GPR:$a, (sra (shl GPR:$b, (i32 16)), (i32 16))),
3314                            (i32 16))),
3315                  (SMLAWB GPR:$a, GPR:$b, GPR:$acc)>;
3316 def : ARMV5TEPat<(add GPR:$acc,
3317                       (sra (mul GPR:$a, sext_16_node:$b), (i32 16))),
3318                  (SMLAWB GPR:$a, GPR:$b, GPR:$acc)>;
3319
3320 //===----------------------------------------------------------------------===//
3321 // Thumb Support
3322 //
3323
3324 include "ARMInstrThumb.td"
3325
3326 //===----------------------------------------------------------------------===//
3327 // Thumb2 Support
3328 //
3329
3330 include "ARMInstrThumb2.td"
3331
3332 //===----------------------------------------------------------------------===//
3333 // Floating Point Support
3334 //
3335
3336 include "ARMInstrVFP.td"
3337
3338 //===----------------------------------------------------------------------===//
3339 // Advanced SIMD (NEON) Support
3340 //
3341
3342 include "ARMInstrNEON.td"
3343
3344 //===----------------------------------------------------------------------===//
3345 // Coprocessor Instructions.  For disassembly only.
3346 //
3347
3348 def CDP : ABI<0b1110, (outs), (ins nohash_imm:$cop, i32imm:$opc1,
3349             nohash_imm:$CRd, nohash_imm:$CRn, nohash_imm:$CRm, i32imm:$opc2),
3350             NoItinerary, "cdp", "\tp$cop, $opc1, cr$CRd, cr$CRn, cr$CRm, $opc2",
3351               [/* For disassembly only; pattern left blank */]> {
3352   let Inst{4} = 0;
3353 }
3354
3355 def CDP2 : ABXI<0b1110, (outs), (ins nohash_imm:$cop, i32imm:$opc1,
3356                nohash_imm:$CRd, nohash_imm:$CRn, nohash_imm:$CRm, i32imm:$opc2),
3357                NoItinerary, "cdp2\tp$cop, $opc1, cr$CRd, cr$CRn, cr$CRm, $opc2",
3358                [/* For disassembly only; pattern left blank */]> {
3359   let Inst{31-28} = 0b1111;
3360   let Inst{4} = 0;
3361 }
3362
3363 class ACI<dag oops, dag iops, string opc, string asm>
3364   : I<oops, iops, AddrModeNone, Size4Bytes, IndexModeNone, BrFrm, NoItinerary,
3365       opc, asm, "", [/* For disassembly only; pattern left blank */]> {
3366   let Inst{27-25} = 0b110;
3367 }
3368
3369 multiclass LdStCop<bits<4> op31_28, bit load, string opc> {
3370
3371   def _OFFSET : ACI<(outs),
3372       (ins nohash_imm:$cop, nohash_imm:$CRd, addrmode2:$addr),
3373       opc, "\tp$cop, cr$CRd, $addr"> {
3374     let Inst{31-28} = op31_28;
3375     let Inst{24} = 1; // P = 1
3376     let Inst{21} = 0; // W = 0
3377     let Inst{22} = 0; // D = 0
3378     let Inst{20} = load;
3379   }
3380
3381   def _PRE : ACI<(outs),
3382       (ins nohash_imm:$cop, nohash_imm:$CRd, addrmode2:$addr),
3383       opc, "\tp$cop, cr$CRd, $addr!"> {
3384     let Inst{31-28} = op31_28;
3385     let Inst{24} = 1; // P = 1
3386     let Inst{21} = 1; // W = 1
3387     let Inst{22} = 0; // D = 0
3388     let Inst{20} = load;
3389   }
3390
3391   def _POST : ACI<(outs),
3392       (ins nohash_imm:$cop, nohash_imm:$CRd, GPR:$base, am2offset:$offset),
3393       opc, "\tp$cop, cr$CRd, [$base], $offset"> {
3394     let Inst{31-28} = op31_28;
3395     let Inst{24} = 0; // P = 0
3396     let Inst{21} = 1; // W = 1
3397     let Inst{22} = 0; // D = 0
3398     let Inst{20} = load;
3399   }
3400
3401   def _OPTION : ACI<(outs),
3402       (ins nohash_imm:$cop, nohash_imm:$CRd, GPR:$base, i32imm:$option),
3403       opc, "\tp$cop, cr$CRd, [$base], $option"> {
3404     let Inst{31-28} = op31_28;
3405     let Inst{24} = 0; // P = 0
3406     let Inst{23} = 1; // U = 1
3407     let Inst{21} = 0; // W = 0
3408     let Inst{22} = 0; // D = 0
3409     let Inst{20} = load;
3410   }
3411
3412   def L_OFFSET : ACI<(outs),
3413       (ins nohash_imm:$cop, nohash_imm:$CRd, addrmode2:$addr),
3414       !strconcat(opc, "l"), "\tp$cop, cr$CRd, $addr"> {
3415     let Inst{31-28} = op31_28;
3416     let Inst{24} = 1; // P = 1
3417     let Inst{21} = 0; // W = 0
3418     let Inst{22} = 1; // D = 1
3419     let Inst{20} = load;
3420   }
3421
3422   def L_PRE : ACI<(outs),
3423       (ins nohash_imm:$cop, nohash_imm:$CRd, addrmode2:$addr),
3424       !strconcat(opc, "l"), "\tp$cop, cr$CRd, $addr!"> {
3425     let Inst{31-28} = op31_28;
3426     let Inst{24} = 1; // P = 1
3427     let Inst{21} = 1; // W = 1
3428     let Inst{22} = 1; // D = 1
3429     let Inst{20} = load;
3430   }
3431
3432   def L_POST : ACI<(outs),
3433       (ins nohash_imm:$cop, nohash_imm:$CRd, GPR:$base, am2offset:$offset),
3434       !strconcat(opc, "l"), "\tp$cop, cr$CRd, [$base], $offset"> {
3435     let Inst{31-28} = op31_28;
3436     let Inst{24} = 0; // P = 0
3437     let Inst{21} = 1; // W = 1
3438     let Inst{22} = 1; // D = 1
3439     let Inst{20} = load;
3440   }
3441
3442   def L_OPTION : ACI<(outs),
3443       (ins nohash_imm:$cop, nohash_imm:$CRd, GPR:$base, nohash_imm:$option),
3444       !strconcat(opc, "l"), "\tp$cop, cr$CRd, [$base], $option"> {
3445     let Inst{31-28} = op31_28;
3446     let Inst{24} = 0; // P = 0
3447     let Inst{23} = 1; // U = 1
3448     let Inst{21} = 0; // W = 0
3449     let Inst{22} = 1; // D = 1
3450     let Inst{20} = load;
3451   }
3452 }
3453
3454 defm LDC  : LdStCop<{?,?,?,?}, 1, "ldc">;
3455 defm LDC2 : LdStCop<0b1111,    1, "ldc2">;
3456 defm STC  : LdStCop<{?,?,?,?}, 0, "stc">;
3457 defm STC2 : LdStCop<0b1111,    0, "stc2">;
3458
3459 def MCR : ABI<0b1110, (outs), (ins nohash_imm:$cop, i32imm:$opc1,
3460               GPR:$Rt, nohash_imm:$CRn, nohash_imm:$CRm, i32imm:$opc2),
3461               NoItinerary, "mcr", "\tp$cop, $opc1, $Rt, cr$CRn, cr$CRm, $opc2",
3462               [/* For disassembly only; pattern left blank */]> {
3463   let Inst{20} = 0;
3464   let Inst{4} = 1;
3465 }
3466
3467 def MCR2 : ABXI<0b1110, (outs), (ins nohash_imm:$cop, i32imm:$opc1,
3468                 GPR:$Rt, nohash_imm:$CRn, nohash_imm:$CRm, i32imm:$opc2),
3469                 NoItinerary, "mcr2\tp$cop, $opc1, $Rt, cr$CRn, cr$CRm, $opc2",
3470                 [/* For disassembly only; pattern left blank */]> {
3471   let Inst{31-28} = 0b1111;
3472   let Inst{20} = 0;
3473   let Inst{4} = 1;
3474 }
3475
3476 def MRC : ABI<0b1110, (outs), (ins nohash_imm:$cop, i32imm:$opc1,
3477               GPR:$Rt, nohash_imm:$CRn, nohash_imm:$CRm, i32imm:$opc2),
3478               NoItinerary, "mrc", "\tp$cop, $opc1, $Rt, cr$CRn, cr$CRm, $opc2",
3479               [/* For disassembly only; pattern left blank */]> {
3480   let Inst{20} = 1;
3481   let Inst{4} = 1;
3482 }
3483
3484 def MRC2 : ABXI<0b1110, (outs), (ins nohash_imm:$cop, i32imm:$opc1,
3485                 GPR:$Rt, nohash_imm:$CRn, nohash_imm:$CRm, i32imm:$opc2),
3486                 NoItinerary, "mrc2\tp$cop, $opc1, $Rt, cr$CRn, cr$CRm, $opc2",
3487                 [/* For disassembly only; pattern left blank */]> {
3488   let Inst{31-28} = 0b1111;
3489   let Inst{20} = 1;
3490   let Inst{4} = 1;
3491 }
3492
3493 def MCRR : ABI<0b1100, (outs), (ins nohash_imm:$cop, i32imm:$opc,
3494                GPR:$Rt, GPR:$Rt2, nohash_imm:$CRm),
3495                NoItinerary, "mcrr", "\tp$cop, $opc, $Rt, $Rt2, cr$CRm",
3496                [/* For disassembly only; pattern left blank */]> {
3497   let Inst{23-20} = 0b0100;
3498 }
3499
3500 def MCRR2 : ABXI<0b1100, (outs), (ins nohash_imm:$cop, i32imm:$opc,
3501                  GPR:$Rt, GPR:$Rt2, nohash_imm:$CRm),
3502                  NoItinerary, "mcrr2\tp$cop, $opc, $Rt, $Rt2, cr$CRm",
3503                  [/* For disassembly only; pattern left blank */]> {
3504   let Inst{31-28} = 0b1111;
3505   let Inst{23-20} = 0b0100;
3506 }
3507
3508 def MRRC : ABI<0b1100, (outs), (ins nohash_imm:$cop, i32imm:$opc,
3509                GPR:$Rt, GPR:$Rt2, nohash_imm:$CRm),
3510                NoItinerary, "mrrc", "\tp$cop, $opc, $Rt, $Rt2, cr$CRm",
3511                [/* For disassembly only; pattern left blank */]> {
3512   let Inst{23-20} = 0b0101;
3513 }
3514
3515 def MRRC2 : ABXI<0b1100, (outs), (ins nohash_imm:$cop, i32imm:$opc,
3516                  GPR:$Rt, GPR:$Rt2, nohash_imm:$CRm),
3517                  NoItinerary, "mrrc2\tp$cop, $opc, $Rt, $Rt2, cr$CRm",
3518                  [/* For disassembly only; pattern left blank */]> {
3519   let Inst{31-28} = 0b1111;
3520   let Inst{23-20} = 0b0101;
3521 }
3522
3523 //===----------------------------------------------------------------------===//
3524 // Move between special register and ARM core register -- for disassembly only
3525 //
3526
3527 def MRS : ABI<0b0001,(outs GPR:$dst),(ins), NoItinerary, "mrs", "\t$dst, cpsr",
3528               [/* For disassembly only; pattern left blank */]> {
3529   let Inst{23-20} = 0b0000;
3530   let Inst{7-4} = 0b0000;
3531 }
3532
3533 def MRSsys : ABI<0b0001,(outs GPR:$dst),(ins), NoItinerary,"mrs","\t$dst, spsr",
3534               [/* For disassembly only; pattern left blank */]> {
3535   let Inst{23-20} = 0b0100;
3536   let Inst{7-4} = 0b0000;
3537 }
3538
3539 def MSR : ABI<0b0001, (outs), (ins GPR:$src, msr_mask:$mask), NoItinerary,
3540               "msr", "\tcpsr$mask, $src",
3541               [/* For disassembly only; pattern left blank */]> {
3542   let Inst{23-20} = 0b0010;
3543   let Inst{7-4} = 0b0000;
3544 }
3545
3546 def MSRi : ABI<0b0011, (outs), (ins so_imm:$a, msr_mask:$mask), NoItinerary,
3547               "msr", "\tcpsr$mask, $a",
3548               [/* For disassembly only; pattern left blank */]> {
3549   let Inst{23-20} = 0b0010;
3550   let Inst{7-4} = 0b0000;
3551 }
3552
3553 def MSRsys : ABI<0b0001, (outs), (ins GPR:$src, msr_mask:$mask), NoItinerary,
3554               "msr", "\tspsr$mask, $src",
3555               [/* For disassembly only; pattern left blank */]> {
3556   let Inst{23-20} = 0b0110;
3557   let Inst{7-4} = 0b0000;
3558 }
3559
3560 def MSRsysi : ABI<0b0011, (outs), (ins so_imm:$a, msr_mask:$mask), NoItinerary,
3561               "msr", "\tspsr$mask, $a",
3562               [/* For disassembly only; pattern left blank */]> {
3563   let Inst{23-20} = 0b0110;
3564   let Inst{7-4} = 0b0000;
3565 }