lib/Target/ARM/ARMInstrInfo.td

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