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