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