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