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