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