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, [SDTCisInt<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_ARMCmp     : SDTypeProfile<0, 2, [SDTCisSameAs<0, 1>]>;
  38
  39 def SDT_ARMPICAdd  : SDTypeProfile<1, 2, [SDTCisSameAs<0, 1>,
  40                                           SDTCisPtrTy<1>, SDTCisVT<2, i32>]>;
  41
  42 def SDT_ARMThreadPointer : SDTypeProfile<1, 0, [SDTCisPtrTy<0>]>;
  43
  44 // Node definitions.
  45 def ARMWrapper       : SDNode<"ARMISD::Wrapper",     SDTIntUnaryOp>;
  46 def ARMWrapperJT     : SDNode<"ARMISD::WrapperJT",   SDTIntBinOp>;
  47
  48 def ARMcallseq_start : SDNode<"ISD::CALLSEQ_START", SDT_ARMCallSeqStart,
  49                               [SDNPHasChain, SDNPOutFlag]>;
  50 def ARMcallseq_end   : SDNode<"ISD::CALLSEQ_END",   SDT_ARMCallSeqEnd,
  51                               [SDNPHasChain, SDNPOptInFlag, SDNPOutFlag]>;
  52
  53 def ARMcall          : SDNode<"ARMISD::CALL", SDT_ARMcall,
  54                               [SDNPHasChain, SDNPOptInFlag, SDNPOutFlag]>;
  55 def ARMcall_pred    : SDNode<"ARMISD::CALL_PRED", SDT_ARMcall,
  56                               [SDNPHasChain, SDNPOptInFlag, SDNPOutFlag]>;
  57 def ARMcall_nolink   : SDNode<"ARMISD::CALL_NOLINK", SDT_ARMcall,
  58                               [SDNPHasChain, SDNPOptInFlag, SDNPOutFlag]>;
  59
  60 def ARMretflag       : SDNode<"ARMISD::RET_FLAG", SDTNone,
  61                               [SDNPHasChain, SDNPOptInFlag]>;
  62
  63 def ARMcmov          : SDNode<"ARMISD::CMOV", SDT_ARMCMov,
  64                               [SDNPInFlag]>;
  65 def ARMcneg          : SDNode<"ARMISD::CNEG", SDT_ARMCMov,
  66                               [SDNPInFlag]>;
  67
  68 def ARMbrcond        : SDNode<"ARMISD::BRCOND", SDT_ARMBrcond,
  69                               [SDNPHasChain, SDNPInFlag, SDNPOutFlag]>;
  70
  71 def ARMbrjt          : SDNode<"ARMISD::BR_JT", SDT_ARMBrJT,
  72                               [SDNPHasChain]>;
  73
  74 def ARMcmp           : SDNode<"ARMISD::CMP", SDT_ARMCmp,
  75                               [SDNPOutFlag]>;
  76
  77 def ARMcmpNZ         : SDNode<"ARMISD::CMPNZ", SDT_ARMCmp,
  78                               [SDNPOutFlag]>;
  79
  80 def ARMpic_add       : SDNode<"ARMISD::PIC_ADD", SDT_ARMPICAdd>;
  81
  82 def ARMsrl_flag      : SDNode<"ARMISD::SRL_FLAG", SDTIntUnaryOp, [SDNPOutFlag]>;
  83 def ARMsra_flag      : SDNode<"ARMISD::SRA_FLAG", SDTIntUnaryOp, [SDNPOutFlag]>;
  84 def ARMrrx           : SDNode<"ARMISD::RRX"     , SDTIntUnaryOp, [SDNPInFlag ]>;
  85
  86 def ARMthread_pointer: SDNode<"ARMISD::THREAD_POINTER", SDT_ARMThreadPointer>;
  87
  88 //===----------------------------------------------------------------------===//
  89 // ARM Instruction Predicate Definitions.
  90 //
  91 def HasV5T  : Predicate<"Subtarget->hasV5TOps()">;
  92 def HasV5TE : Predicate<"Subtarget->hasV5TEOps()">;
  93 def HasV6   : Predicate<"Subtarget->hasV6Ops()">;
  94 def IsThumb : Predicate<"Subtarget->isThumb()">;
  95 def IsARM   : Predicate<"!Subtarget->isThumb()">;
  96
  97 //===----------------------------------------------------------------------===//
  98 // ARM Flag Definitions.
  99
 100 class RegConstraint<string C> {
 101   string Constraints = C;
 102 }
 103
 104 //===----------------------------------------------------------------------===//
 105 //  ARM specific transformation functions and pattern fragments.
 106 //
 107
 108 // so_imm_XFORM - Return a so_imm value packed into the format described for
 109 // so_imm def below.
 110 def so_imm_XFORM : SDNodeXForm<imm, [{
 111   return CurDAG->getTargetConstant(ARM_AM::getSOImmVal(N->getZExtValue()),
 112                                    MVT::i32);
 113 }]>;
 114
 115 // so_imm_neg_XFORM - Return a so_imm value packed into the format described for
 116 // so_imm_neg def below.
 117 def so_imm_neg_XFORM : SDNodeXForm<imm, [{
 118   return CurDAG->getTargetConstant(ARM_AM::getSOImmVal(-(int)N->getZExtValue()),
 119                                    MVT::i32);
 120 }]>;
 121
 122 // so_imm_not_XFORM - Return a so_imm value packed into the format described for
 123 // so_imm_not def below.
 124 def so_imm_not_XFORM : SDNodeXForm<imm, [{
 125   return CurDAG->getTargetConstant(ARM_AM::getSOImmVal(~(int)N->getZExtValue()),
 126                                    MVT::i32);
 127 }]>;
 128
 129 // rot_imm predicate - True if the 32-bit immediate is equal to 8, 16, or 24.
 130 def rot_imm : PatLeaf<(i32 imm), [{
 131   int32_t v = (int32_t)N->getZExtValue();
 132   return v == 8 || v == 16 || v == 24;
 133 }]>;
 134
 135 /// imm1_15 predicate - True if the 32-bit immediate is in the range [1,15].
 136 def imm1_15 : PatLeaf<(i32 imm), [{
 137   return (int32_t)N->getZExtValue() >= 1 && (int32_t)N->getZExtValue() < 16;
 138 }]>;
 139
 140 /// imm16_31 predicate - True if the 32-bit immediate is in the range [16,31].
 141 def imm16_31 : PatLeaf<(i32 imm), [{
 142   return (int32_t)N->getZExtValue() >= 16 && (int32_t)N->getZExtValue() < 32;
 143 }]>;
 144
 145 def so_imm_neg :
 146   PatLeaf<(imm), [{
 147     return ARM_AM::getSOImmVal(-(int)N->getZExtValue()) != -1;
 148   }], so_imm_neg_XFORM>;
 149
 150 def so_imm_not :
 151   PatLeaf<(imm), [{
 152     return ARM_AM::getSOImmVal(~(int)N->getZExtValue()) != -1;
 153   }], so_imm_not_XFORM>;
 154
 155 // sext_16_node predicate - True if the SDNode is sign-extended 16 or more bits.
 156 def sext_16_node : PatLeaf<(i32 GPR:$a), [{
 157   return CurDAG->ComputeNumSignBits(SDValue(N,0)) >= 17;
 158 }]>;
 159
 160 class BinOpFrag<dag res> : PatFrag<(ops node:$LHS, node:$RHS), res>;
 161 class UnOpFrag <dag res> : PatFrag<(ops node:$Src), res>;
 162
 163 //===----------------------------------------------------------------------===//
 164 // Operand Definitions.
 165 //
 166
 167 // Branch target.
 168 def brtarget : Operand<OtherVT>;
 169
 170 // A list of registers separated by comma. Used by load/store multiple.
 171 def reglist : Operand<i32> {
 172   let PrintMethod = "printRegisterList";
 173 }
 174
 175 // An operand for the CONSTPOOL_ENTRY pseudo-instruction.
 176 def cpinst_operand : Operand<i32> {
 177   let PrintMethod = "printCPInstOperand";
 178 }
 179
 180 def jtblock_operand : Operand<i32> {
 181   let PrintMethod = "printJTBlockOperand";
 182 }
 183
 184 // Local PC labels.
 185 def pclabel : Operand<i32> {
 186   let PrintMethod = "printPCLabel";
 187 }
 188
 189 // shifter_operand operands: so_reg and so_imm.
 190 def so_reg : Operand<i32>,    // reg reg imm
 191             ComplexPattern<i32, 3, "SelectShifterOperandReg",
 192                             [shl,srl,sra,rotr]> {
 193   let PrintMethod = "printSORegOperand";
 194   let MIOperandInfo = (ops GPR, GPR, i32imm);
 195 }
 196
 197 // so_imm - Match a 32-bit shifter_operand immediate operand, which is an
 198 // 8-bit immediate rotated by an arbitrary number of bits.  so_imm values are
 199 // represented in the imm field in the same 12-bit form that they are encoded
 200 // into so_imm instructions: the 8-bit immediate is the least significant bits
 201 // [bits 0-7], the 4-bit shift amount is the next 4 bits [bits 8-11].
 202 def so_imm : Operand<i32>,
 203              PatLeaf<(imm),
 204                      [{ return ARM_AM::getSOImmVal(N->getZExtValue()) != -1; }],
 205                      so_imm_XFORM> {
 206   let PrintMethod = "printSOImmOperand";
 207 }
 208
 209 // Break so_imm's up into two pieces.  This handles immediates with up to 16
 210 // bits set in them.  This uses so_imm2part to match and so_imm2part_[12] to
 211 // get the first/second pieces.
 212 def so_imm2part : Operand<i32>,
 213                   PatLeaf<(imm), [{
 214       return ARM_AM::isSOImmTwoPartVal((unsigned)N->getZExtValue());
 215     }]> {
 216   let PrintMethod = "printSOImm2PartOperand";
 217 }
 218
 219 def so_imm2part_1 : SDNodeXForm<imm, [{
 220   unsigned V = ARM_AM::getSOImmTwoPartFirst((unsigned)N->getZExtValue());
 221   return CurDAG->getTargetConstant(ARM_AM::getSOImmVal(V), MVT::i32);
 222 }]>;
 223
 224 def so_imm2part_2 : SDNodeXForm<imm, [{
 225   unsigned V = ARM_AM::getSOImmTwoPartSecond((unsigned)N->getZExtValue());
 226   return CurDAG->getTargetConstant(ARM_AM::getSOImmVal(V), MVT::i32);
 227 }]>;
 228
 229
 230 // Define ARM specific addressing modes.
 231
 232 // addrmode2 := reg +/- reg shop imm
 233 // addrmode2 := reg +/- imm12
 234 //
 235 def addrmode2 : Operand<i32>,
 236                 ComplexPattern<i32, 3, "SelectAddrMode2", []> {
 237   let PrintMethod = "printAddrMode2Operand";
 238   let MIOperandInfo = (ops GPR:$base, GPR:$offsreg, i32imm:$offsimm);
 239 }
 240
 241 def am2offset : Operand<i32>,
 242                 ComplexPattern<i32, 2, "SelectAddrMode2Offset", []> {
 243   let PrintMethod = "printAddrMode2OffsetOperand";
 244   let MIOperandInfo = (ops GPR, i32imm);
 245 }
 246
 247 // addrmode3 := reg +/- reg
 248 // addrmode3 := reg +/- imm8
 249 //
 250 def addrmode3 : Operand<i32>,
 251                 ComplexPattern<i32, 3, "SelectAddrMode3", []> {
 252   let PrintMethod = "printAddrMode3Operand";
 253   let MIOperandInfo = (ops GPR:$base, GPR:$offsreg, i32imm:$offsimm);
 254 }
 255
 256 def am3offset : Operand<i32>,
 257                 ComplexPattern<i32, 2, "SelectAddrMode3Offset", []> {
 258   let PrintMethod = "printAddrMode3OffsetOperand";
 259   let MIOperandInfo = (ops GPR, i32imm);
 260 }
 261
 262 // addrmode4 := reg, <mode|W>
 263 //
 264 def addrmode4 : Operand<i32>,
 265                 ComplexPattern<i32, 2, "", []> {
 266   let PrintMethod = "printAddrMode4Operand";
 267   let MIOperandInfo = (ops GPR, i32imm);
 268 }
 269
 270 // addrmode5 := reg +/- imm8*4
 271 //
 272 def addrmode5 : Operand<i32>,
 273                 ComplexPattern<i32, 2, "SelectAddrMode5", []> {
 274   let PrintMethod = "printAddrMode5Operand";
 275   let MIOperandInfo = (ops GPR, i32imm);
 276 }
 277
 278 // addrmodepc := pc + reg
 279 //
 280 def addrmodepc : Operand<i32>,
 281                  ComplexPattern<i32, 2, "SelectAddrModePC", []> {
 282   let PrintMethod = "printAddrModePCOperand";
 283   let MIOperandInfo = (ops GPR, i32imm);
 284 }
 285
 286 // ARM Predicate operand. Default to 14 = always (AL). Second part is CC
 287 // register whose default is 0 (no register).
 288 def pred : PredicateOperand<OtherVT, (ops i32imm, CCR),
 289                                      (ops (i32 14), (i32 zero_reg))> {
 290   let PrintMethod = "printPredicateOperand";
 291 }
 292
 293 // Conditional code result for instructions whose 's' bit is set, e.g. subs.
 294 //
 295 def cc_out : OptionalDefOperand<OtherVT, (ops CCR), (ops (i32 zero_reg))> {
 296   let PrintMethod = "printSBitModifierOperand";
 297 }
 298
 299 //===----------------------------------------------------------------------===//
 300 // ARM Instruction flags.  These need to match ARMInstrInfo.h.
 301 //
 302
 303 // Addressing mode.
 304 class AddrMode<bits<4> val> {
 305   bits<4> Value = val;
 306 }
 307 def AddrModeNone : AddrMode<0>;
 308 def AddrMode1    : AddrMode<1>;
 309 def AddrMode2    : AddrMode<2>;
 310 def AddrMode3    : AddrMode<3>;
 311 def AddrMode4    : AddrMode<4>;
 312 def AddrMode5    : AddrMode<5>;
 313 def AddrMode6    : AddrMode<6>;
 314 def AddrModeT1   : AddrMode<7>;
 315 def AddrModeT2   : AddrMode<8>;
 316 def AddrModeT4   : AddrMode<9>;
 317 def AddrModeTs   : AddrMode<10>;
 318
 319 // Instruction size.
 320 class SizeFlagVal<bits<3> val> {
 321   bits<3> Value = val;
 322 }
 323 def SizeInvalid  : SizeFlagVal<0>;  // Unset.
 324 def SizeSpecial  : SizeFlagVal<1>;  // Pseudo or special.
 325 def Size8Bytes   : SizeFlagVal<2>;
 326 def Size4Bytes   : SizeFlagVal<3>;
 327 def Size2Bytes   : SizeFlagVal<4>;
 328
 329 // Load / store index mode.
 330 class IndexMode<bits<2> val> {
 331   bits<2> Value = val;
 332 }
 333 def IndexModeNone : IndexMode<0>;
 334 def IndexModePre  : IndexMode<1>;
 335 def IndexModePost : IndexMode<2>;
 336
 337 //===----------------------------------------------------------------------===//
 338
 339 include "ARMInstrFormats.td"
 340
 341 //===----------------------------------------------------------------------===//
 342 // Multiclass helpers...
 343 //
 344
 345 /// AsI1_bin_irs - Defines a set of (op r, {so_imm|r|so_reg}) patterns for a
 346 /// binop that produces a value.
 347 multiclass AsI1_bin_irs<bits<4> opcod, string opc, PatFrag opnode> {
 348   def ri : AsI1<opcod, (outs GPR:$dst), (ins GPR:$a, so_imm:$b), DPRIm,
 349                opc, " $dst, $a, $b",
 350                [(set GPR:$dst, (opnode GPR:$a, so_imm:$b))]>;
 351   def rr : AsI1<opcod, (outs GPR:$dst), (ins GPR:$a, GPR:$b), DPRReg,
 352                opc, " $dst, $a, $b",
 353                [(set GPR:$dst, (opnode GPR:$a, GPR:$b))]>;
 354   def rs : AsI1<opcod, (outs GPR:$dst), (ins GPR:$a, so_reg:$b), DPRSoReg,
 355                opc, " $dst, $a, $b",
 356                [(set GPR:$dst, (opnode GPR:$a, so_reg:$b))]>;
 357 }
 358
 359 /// ASI1_bin_s_irs - Similar to AsI1_bin_irs except it sets the 's' bit so the
 360 /// instruction modifies the CSPR register.
 361 let Defs = [CPSR] in {
 362 multiclass ASI1_bin_s_irs<bits<4> opcod, string opc, PatFrag opnode> {
 363   def ri : AI1<opcod, (outs GPR:$dst), (ins GPR:$a, so_imm:$b), DPRImS,
 364                opc, "s $dst, $a, $b",
 365                [(set GPR:$dst, (opnode GPR:$a, so_imm:$b))]>;
 366   def rr : AI1<opcod, (outs GPR:$dst), (ins GPR:$a, GPR:$b), DPRRegS,
 367                opc, "s $dst, $a, $b",
 368                [(set GPR:$dst, (opnode GPR:$a, GPR:$b))]>;
 369   def rs : AI1<opcod, (outs GPR:$dst), (ins GPR:$a, so_reg:$b), DPRSoRegS,
 370                opc, "s $dst, $a, $b",
 371                [(set GPR:$dst, (opnode GPR:$a, so_reg:$b))]>;
 372 }
 373 }
 374
 375 /// AI1_cmp_irs - Defines a set of (op r, {so_imm|r|so_reg}) cmp / test
 376 /// patterns. Similar to AsI1_bin_irs except the instruction does not produce
 377 /// a explicit result, only implicitly set CPSR.
 378 let Defs = [CPSR] in {
 379 multiclass AI1_cmp_irs<bits<4> opcod, string opc, PatFrag opnode> {
 380   def ri : AI1<opcod, (outs), (ins GPR:$a, so_imm:$b), DPRnIm,
 381                opc, " $a, $b",
 382                [(opnode GPR:$a, so_imm:$b)]>;
 383   def rr : AI1<opcod, (outs), (ins GPR:$a, GPR:$b), DPRnReg,
 384                opc, " $a, $b",
 385                [(opnode GPR:$a, GPR:$b)]>;
 386   def rs : AI1<opcod, (outs), (ins GPR:$a, so_reg:$b), DPRnSoReg,
 387                opc, " $a, $b",
 388                [(opnode GPR:$a, so_reg:$b)]>;
 389 }
 390 }
 391
 392 /// AI_unary_rrot - A unary operation with two forms: one whose operand is a
 393 /// register and one whose operand is a register rotated by 8/16/24.
 394 multiclass AI_unary_rrot<bits<4> opcod, string opc, PatFrag opnode> {
 395   def r     : AI<opcod, (outs GPR:$dst), (ins GPR:$Src), Pseudo,
 396                  opc, " $dst, $Src",
 397                  [(set GPR:$dst, (opnode GPR:$Src))]>, Requires<[IsARM, HasV6]>;
 398   def r_rot : AI<opcod, (outs GPR:$dst), (ins GPR:$Src, i32imm:$rot), Pseudo,
 399                  opc, " $dst, $Src, ror $rot",
 400                  [(set GPR:$dst, (opnode (rotr GPR:$Src, rot_imm:$rot)))]>,
 401               Requires<[IsARM, HasV6]>;
 402 }
 403
 404 /// AI_bin_rrot - A binary operation with two forms: one whose operand is a
 405 /// register and one whose operand is a register rotated by 8/16/24.
 406 multiclass AI_bin_rrot<bits<4> opcod, string opc, PatFrag opnode> {
 407   def rr     : AI<opcod, (outs GPR:$dst), (ins GPR:$LHS, GPR:$RHS),
 408                   Pseudo, opc, " $dst, $LHS, $RHS",
 409                   [(set GPR:$dst, (opnode GPR:$LHS, GPR:$RHS))]>,
 410                   Requires<[IsARM, HasV6]>;
 411   def rr_rot : AI<opcod, (outs GPR:$dst), (ins GPR:$LHS, GPR:$RHS, i32imm:$rot),
 412                   Pseudo, opc, " $dst, $LHS, $RHS, ror $rot",
 413                   [(set GPR:$dst, (opnode GPR:$LHS,
 414                                           (rotr GPR:$RHS, rot_imm:$rot)))]>,
 415                   Requires<[IsARM, HasV6]>;
 416 }
 417
 418 /// AsXI1_bin_c_irs - Same as AsI1_bin_irs but without the predicate operand and
 419 /// setting carry bit. But it can optionally set CPSR.
 420 let Uses = [CPSR] in {
 421 multiclass AsXI1_bin_c_irs<bits<4> opcod, string opc, PatFrag opnode> {
 422   def ri : AXI1<opcod, (outs GPR:$dst), (ins GPR:$a, so_imm:$b, cc_out:$s),
 423                 DPRIm, !strconcat(opc, "${s} $dst, $a, $b"),
 424                [(set GPR:$dst, (opnode GPR:$a, so_imm:$b))]>;
 425   def rr : AXI1<opcod, (outs GPR:$dst), (ins GPR:$a, GPR:$b, cc_out:$s),
 426                 DPRReg, !strconcat(opc, "${s} $dst, $a, $b"),
 427                [(set GPR:$dst, (opnode GPR:$a, GPR:$b))]>;
 428   def rs : AXI1<opcod, (outs GPR:$dst), (ins GPR:$a, so_reg:$b, cc_out:$s),
 429                 DPRSoReg, !strconcat(opc, "${s} $dst, $a, $b"),
 430                [(set GPR:$dst, (opnode GPR:$a, so_reg:$b))]>;
 431 }
 432 }
 433
 434 //===----------------------------------------------------------------------===//
 435 // Instructions
 436 //===----------------------------------------------------------------------===//
 437
 438 //===----------------------------------------------------------------------===//
 439 //  Miscellaneous Instructions.
 440 //
 441
 442 /// CONSTPOOL_ENTRY - This instruction represents a floating constant pool in
 443 /// the function.  The first operand is the ID# for this instruction, the second
 444 /// is the index into the MachineConstantPool that this is, the third is the
 445 /// size in bytes of this constant pool entry.
 446 let isNotDuplicable = 1 in
 447 def CONSTPOOL_ENTRY :
 448 PseudoInst<(outs), (ins cpinst_operand:$instid, cpinst_operand:$cpidx,
 449                         i32imm:$size),
 450            "${instid:label} ${cpidx:cpentry}", []>;
 451
 452 let Defs = [SP], Uses = [SP] in {
 453 def ADJCALLSTACKUP :
 454 PseudoInst<(outs), (ins i32imm:$amt1, i32imm:$amt2, pred:$p),
 455            "@ ADJCALLSTACKUP $amt1",
 456            [(ARMcallseq_end timm:$amt1, timm:$amt2)]>;
 457
 458 def ADJCALLSTACKDOWN :
 459 PseudoInst<(outs), (ins i32imm:$amt, pred:$p),
 460            "@ ADJCALLSTACKDOWN $amt",
 461            [(ARMcallseq_start timm:$amt)]>;
 462 }
 463
 464 def DWARF_LOC :
 465 PseudoInst<(outs), (ins i32imm:$line, i32imm:$col, i32imm:$file),
 466            ".loc $file, $line, $col",
 467            [(dwarf_loc (i32 imm:$line), (i32 imm:$col), (i32 imm:$file))]>;
 468
 469 let isNotDuplicable = 1 in {
 470 def PICADD : AXI1<0b0100, (outs GPR:$dst), (ins GPR:$a, pclabel:$cp, pred:$p),
 471                   Pseudo, "$cp:\n\tadd$p $dst, pc, $a",
 472                    [(set GPR:$dst, (ARMpic_add GPR:$a, imm:$cp))]>;
 473
 474 let AddedComplexity = 10 in {
 475 let isSimpleLoad = 1 in
 476 def PICLD   : AXI2ldw<0x0, (outs GPR:$dst), (ins addrmodepc:$addr, pred:$p),
 477                   Pseudo, "${addr:label}:\n\tldr$p $dst, $addr",
 478                   [(set GPR:$dst, (load addrmodepc:$addr))]>;
 479
 480 def PICLDZH : AXI3ldh<0x0, (outs GPR:$dst), (ins addrmodepc:$addr, pred:$p),
 481                   Pseudo, "${addr:label}:\n\tldr${p}h $dst, $addr",
 482                   [(set GPR:$dst, (zextloadi16 addrmodepc:$addr))]>;
 483
 484 def PICLDZB : AXI2ldb<0x0, (outs GPR:$dst), (ins addrmodepc:$addr, pred:$p),
 485                   Pseudo, "${addr:label}:\n\tldr${p}b $dst, $addr",
 486                   [(set GPR:$dst, (zextloadi8 addrmodepc:$addr))]>;
 487
 488 def PICLDH  : AXI3ldh<0x0, (outs GPR:$dst), (ins addrmodepc:$addr, pred:$p),
 489                   Pseudo, "${addr:label}:\n\tldr${p}h $dst, $addr",
 490                   [(set GPR:$dst, (extloadi16 addrmodepc:$addr))]>;
 491
 492 def PICLDB  : AXI2ldb<0x0, (outs GPR:$dst), (ins addrmodepc:$addr, pred:$p),
 493                   Pseudo, "${addr:label}:\n\tldr${p}b $dst, $addr",
 494                   [(set GPR:$dst, (extloadi8 addrmodepc:$addr))]>;
 495
 496 def PICLDSH : AXI3ldsh<0x0, (outs GPR:$dst), (ins addrmodepc:$addr, pred:$p),
 497                   Pseudo, "${addr:label}:\n\tldr${p}sh $dst, $addr",
 498                   [(set GPR:$dst, (sextloadi16 addrmodepc:$addr))]>;
 499
 500 def PICLDSB : AXI3ldsb<0x0, (outs GPR:$dst), (ins addrmodepc:$addr, pred:$p),
 501                   Pseudo, "${addr:label}:\n\tldr${p}sb $dst, $addr",
 502                   [(set GPR:$dst, (sextloadi8 addrmodepc:$addr))]>;
 503 }
 504 let AddedComplexity = 10 in {
 505 def PICSTR  : AXI2stw<0x0, (outs), (ins GPR:$src, addrmodepc:$addr, pred:$p),
 506                Pseudo, "${addr:label}:\n\tstr$p $src, $addr",
 507                [(store GPR:$src, addrmodepc:$addr)]>;
 508
 509 def PICSTRH : AXI3sth<0x0, (outs), (ins GPR:$src, addrmodepc:$addr, pred:$p),
 510                Pseudo, "${addr:label}:\n\tstr${p}h $src, $addr",
 511                [(truncstorei16 GPR:$src, addrmodepc:$addr)]>;
 512
 513 def PICSTRB : AXI2stb<0x0, (outs), (ins GPR:$src, addrmodepc:$addr, pred:$p),
 514                Pseudo, "${addr:label}:\n\tstr${p}b $src, $addr",
 515                [(truncstorei8 GPR:$src, addrmodepc:$addr)]>;
 516 }
 517 }
 518
 519 //===----------------------------------------------------------------------===//
 520 //  Control Flow Instructions.
 521 //
 522
 523 let isReturn = 1, isTerminator = 1 in
 524   def BX_RET : AI<0x0, (outs), (ins), BranchMisc, "bx", " lr", [(ARMretflag)]> {
 525   let Inst{7-4}   = 0b0001;
 526   let Inst{19-8}  = 0b111111111111;
 527   let Inst{27-20} = 0b00010010;
 528 }
 529
 530 // FIXME: remove when we have a way to marking a MI with these properties.
 531 // FIXME: $dst1 should be a def. But the extra ops must be in the end of the
 532 // operand list.
 533 let isReturn = 1, isTerminator = 1 in
 534   def LDM_RET : AXI4ldpc<0x0, (outs),
 535                     (ins addrmode4:$addr, pred:$p, reglist:$dst1, variable_ops),
 536                     LdFrm, "ldm${p}${addr:submode} $addr, $dst1",
 537                     []>;
 538
 539 let isCall = 1,
 540   Defs = [R0, R1, R2, R3, R12, LR,
 541           D0, D1, D2, D3, D4, D5, D6, D7, CPSR] in {
 542   def BL  : ABLI<0xB, (outs), (ins i32imm:$func, variable_ops), Branch,
 543                 "bl ${func:call}",
 544                 [(ARMcall tglobaladdr:$func)]>;
 545
 546   def BL_pred : ABLpredI<0xB, (outs), (ins i32imm:$func, variable_ops), Branch,
 547                    "bl", " ${func:call}",
 548                    [(ARMcall_pred tglobaladdr:$func)]>;
 549
 550   // ARMv5T and above
 551   def BLX : AXI<0x0, (outs), (ins GPR:$func, variable_ops), BranchMisc,
 552                 "blx $func",
 553                 [(ARMcall GPR:$func)]>, Requires<[IsARM, HasV5T]> {
 554     let Inst{7-4}   = 0b0011;
 555     let Inst{19-8}  = 0b111111111111;
 556     let Inst{27-20} = 0b00010010;
 557   }
 558
 559   let Uses = [LR] in {
 560     // ARMv4T
 561     def BX : AXIx2<0x0, (outs), (ins GPR:$func, variable_ops),
 562                    BranchMisc, "mov lr, pc\n\tbx $func",
 563                    [(ARMcall_nolink GPR:$func)]>;
 564   }
 565 }
 566
 567 let isBranch = 1, isTerminator = 1 in {
 568   // B is "predicable" since it can be xformed into a Bcc.
 569   let isBarrier = 1 in {
 570     let isPredicable = 1 in
 571     def B : ABI<0xA, (outs), (ins brtarget:$target), Branch, "b $target",
 572                 [(br bb:$target)]>;
 573
 574   let isNotDuplicable = 1, isIndirectBranch = 1 in {
 575   def BR_JTr : JTI<0b1101, (outs), (ins GPR:$target, jtblock_operand:$jt, i32imm:$id),
 576                     "mov pc, $target \n$jt",
 577                     [(ARMbrjt GPR:$target, tjumptable:$jt, imm:$id)]>;
 578   def BR_JTm : JTI2<0x0, (outs), (ins addrmode2:$target, jtblock_operand:$jt, i32imm:$id),
 579                      "ldr pc, $target \n$jt",
 580                      [(ARMbrjt (i32 (load addrmode2:$target)), tjumptable:$jt,
 581                        imm:$id)]>;
 582   def BR_JTadd : JTI1<0b0100, (outs), (ins GPR:$target, GPR:$idx, jtblock_operand:$jt,
 583                        i32imm:$id),
 584                        "add pc, $target, $idx \n$jt",
 585                        [(ARMbrjt (add GPR:$target, GPR:$idx), tjumptable:$jt,
 586                          imm:$id)]>;
 587   }
 588   }
 589
 590   // FIXME: should be able to write a pattern for ARMBrcond, but can't use
 591   // a two-value operand where a dag node expects two operands. :(
 592   def Bcc : ABccI<0xA, (outs), (ins brtarget:$target), Branch,
 593                "b", " $target",
 594                [/*(ARMbrcond bb:$target, imm:$cc, CCR:$ccr)*/]>;
 595 }
 596
 597 //===----------------------------------------------------------------------===//
 598 //  Load / store Instructions.
 599 //
 600
 601 // Load
 602 let isSimpleLoad = 1 in
 603 def LDR  : AI2ldw<0x0, (outs GPR:$dst), (ins addrmode2:$addr), LdFrm,
 604                "ldr", " $dst, $addr",
 605                [(set GPR:$dst, (load addrmode2:$addr))]>;
 606
 607 // Special LDR for loads from non-pc-relative constpools.
 608 let isSimpleLoad = 1, mayLoad = 1, isReMaterializable = 1 in
 609 def LDRcp : AI2ldw<0x0, (outs GPR:$dst), (ins addrmode2:$addr), LdFrm,
 610                  "ldr", " $dst, $addr", []>;
 611
 612 // Loads with zero extension
 613 def LDRH  : AI3ldh<0xB, (outs GPR:$dst), (ins addrmode3:$addr), LdFrm,
 614                  "ldr", "h $dst, $addr",
 615                 [(set GPR:$dst, (zextloadi16 addrmode3:$addr))]>;
 616
 617 def LDRB  : AI2ldb<0x1, (outs GPR:$dst), (ins addrmode2:$addr), LdFrm,
 618                  "ldr", "b $dst, $addr",
 619                 [(set GPR:$dst, (zextloadi8 addrmode2:$addr))]>;
 620
 621 // Loads with sign extension
 622 def LDRSH : AI3ldsh<0xE, (outs GPR:$dst), (ins addrmode3:$addr), LdFrm,
 623                  "ldr", "sh $dst, $addr",
 624                 [(set GPR:$dst, (sextloadi16 addrmode3:$addr))]>;
 625
 626 def LDRSB : AI3ldsb<0xD, (outs GPR:$dst), (ins addrmode3:$addr), LdFrm,
 627                  "ldr", "sb $dst, $addr",
 628                 [(set GPR:$dst, (sextloadi8 addrmode3:$addr))]>;
 629
 630 let mayLoad = 1 in {
 631 // Load doubleword
 632 def LDRD  : AI3ldd<0xD, (outs GPR:$dst), (ins addrmode3:$addr), LdFrm,
 633                  "ldr", "d $dst, $addr",
 634                 []>, Requires<[IsARM, HasV5T]>;
 635
 636 // Indexed loads
 637 def LDR_PRE  : AI2ldwpr<0x0, (outs GPR:$dst, GPR:$base_wb),
 638                      (ins addrmode2:$addr), LdFrm,
 639                      "ldr", " $dst, $addr!", "$addr.base = $base_wb", []>;
 640
 641 def LDR_POST : AI2ldwpo<0x0, (outs GPR:$dst, GPR:$base_wb),
 642                      (ins GPR:$base, am2offset:$offset), LdFrm,
 643                      "ldr", " $dst, [$base], $offset", "$base = $base_wb", []>;
 644
 645 def LDRH_PRE  : AI3ldhpr<0xB, (outs GPR:$dst, GPR:$base_wb),
 646                      (ins addrmode3:$addr), LdFrm,
 647                      "ldr", "h $dst, $addr!", "$addr.base = $base_wb", []>;
 648
 649 def LDRH_POST : AI3ldhpo<0xB, (outs GPR:$dst, GPR:$base_wb),
 650                      (ins GPR:$base,am3offset:$offset), LdFrm,
 651                      "ldr", "h $dst, [$base], $offset", "$base = $base_wb", []>;
 652
 653 def LDRB_PRE  : AI2ldbpr<0x1, (outs GPR:$dst, GPR:$base_wb),
 654                      (ins addrmode2:$addr), LdFrm,
 655                      "ldr", "b $dst, $addr!", "$addr.base = $base_wb", []>;
 656
 657 def LDRB_POST : AI2ldbpo<0x1, (outs GPR:$dst, GPR:$base_wb),
 658                      (ins GPR:$base,am2offset:$offset), LdFrm,
 659                      "ldr", "b $dst, [$base], $offset", "$base = $base_wb", []>;
 660
 661 def LDRSH_PRE : AI3ldshpr<0xE, (outs GPR:$dst, GPR:$base_wb),
 662                       (ins addrmode3:$addr), LdFrm,
 663                       "ldr", "sh $dst, $addr!", "$addr.base = $base_wb", []>;
 664
 665 def LDRSH_POST: AI3ldshpo<0xE, (outs GPR:$dst, GPR:$base_wb),
 666                       (ins GPR:$base,am3offset:$offset), LdFrm,
 667                       "ldr", "sh $dst, [$base], $offset", "$base = $base_wb", []>;
 668
 669 def LDRSB_PRE : AI3ldsbpr<0xD, (outs GPR:$dst, GPR:$base_wb),
 670                       (ins addrmode3:$addr), LdFrm,
 671                       "ldr", "sb $dst, $addr!", "$addr.base = $base_wb", []>;
 672
 673 def LDRSB_POST: AI3ldsbpo<0xD, (outs GPR:$dst, GPR:$base_wb),
 674                       (ins GPR:$base,am3offset:$offset), LdFrm,
 675                       "ldr", "sb $dst, [$base], $offset", "$base = $base_wb", []>;
 676 }
 677
 678 // Store
 679 def STR  : AI2stw<0x0, (outs), (ins GPR:$src, addrmode2:$addr), StFrm,
 680                "str", " $src, $addr",
 681                [(store GPR:$src, addrmode2:$addr)]>;
 682
 683 // Stores with truncate
 684 def STRH : AI3sth<0xB, (outs), (ins GPR:$src, addrmode3:$addr), StFrm,
 685                "str", "h $src, $addr",
 686                [(truncstorei16 GPR:$src, addrmode3:$addr)]>;
 687
 688 def STRB : AI2stb<0x1, (outs), (ins GPR:$src, addrmode2:$addr), StFrm,
 689                "str", "b $src, $addr",
 690                [(truncstorei8 GPR:$src, addrmode2:$addr)]>;
 691
 692 // Store doubleword
 693 let mayStore = 1 in
 694 def STRD : AI3std<0xF, (outs), (ins GPR:$src, addrmode3:$addr), StFrm,
 695                "str", "d $src, $addr",
 696                []>, Requires<[IsARM, HasV5T]>;
 697
 698 // Indexed stores
 699 def STR_PRE  : AI2stwpr<0x0, (outs GPR:$base_wb),
 700                      (ins GPR:$src, GPR:$base, am2offset:$offset), StFrm,
 701                     "str", " $src, [$base, $offset]!", "$base = $base_wb",
 702                     [(set GPR:$base_wb,
 703                       (pre_store GPR:$src, GPR:$base, am2offset:$offset))]>;
 704
 705 def STR_POST : AI2stwpo<0x0, (outs GPR:$base_wb),
 706                      (ins GPR:$src, GPR:$base,am2offset:$offset), StFrm,
 707                     "str", " $src, [$base], $offset", "$base = $base_wb",
 708                     [(set GPR:$base_wb,
 709                       (post_store GPR:$src, GPR:$base, am2offset:$offset))]>;
 710
 711 def STRH_PRE : AI3sthpr<0xB, (outs GPR:$base_wb),
 712                      (ins GPR:$src, GPR:$base,am3offset:$offset), StFrm,
 713                      "str", "h $src, [$base, $offset]!", "$base = $base_wb",
 714                     [(set GPR:$base_wb,
 715                       (pre_truncsti16 GPR:$src, GPR:$base,am3offset:$offset))]>;
 716
 717 def STRH_POST: AI3sthpo<0xB, (outs GPR:$base_wb),
 718                      (ins GPR:$src, GPR:$base,am3offset:$offset), StFrm,
 719                      "str", "h $src, [$base], $offset", "$base = $base_wb",
 720                     [(set GPR:$base_wb, (post_truncsti16 GPR:$src,
 721                                          GPR:$base, am3offset:$offset))]>;
 722
 723 def STRB_PRE : AI2stbpr<0x1, (outs GPR:$base_wb),
 724                      (ins GPR:$src, GPR:$base,am2offset:$offset), StFrm,
 725                      "str", "b $src, [$base, $offset]!", "$base = $base_wb",
 726                     [(set GPR:$base_wb, (pre_truncsti8 GPR:$src,
 727                                          GPR:$base, am2offset:$offset))]>;
 728
 729 def STRB_POST: AI2stbpo<0x1, (outs GPR:$base_wb),
 730                      (ins GPR:$src, GPR:$base,am2offset:$offset), StFrm,
 731                      "str", "b $src, [$base], $offset", "$base = $base_wb",
 732                     [(set GPR:$base_wb, (post_truncsti8 GPR:$src,
 733                                          GPR:$base, am2offset:$offset))]>;
 734
 735 //===----------------------------------------------------------------------===//
 736 //  Load / store multiple Instructions.
 737 //
 738
 739 // FIXME: $dst1 should be a def.
 740 let mayLoad = 1 in
 741 def LDM : AXI4ld<0x0, (outs),
 742                (ins addrmode4:$addr, pred:$p, reglist:$dst1, variable_ops),
 743                LdFrm, "ldm${p}${addr:submode} $addr, $dst1",
 744                []>;
 745
 746 let mayStore = 1 in
 747 def STM : AXI4st<0x0, (outs),
 748                (ins addrmode4:$addr, pred:$p, reglist:$src1, variable_ops),
 749                StFrm, "stm${p}${addr:submode} $addr, $src1",
 750                []>;
 751
 752 //===----------------------------------------------------------------------===//
 753 //  Move Instructions.
 754 //
 755
 756 def MOVr : AsI1<0b1101, (outs GPR:$dst), (ins GPR:$src), DPRdReg,
 757                  "mov", " $dst, $src", []>;
 758 def MOVs : AsI1<0b1101, (outs GPR:$dst), (ins so_reg:$src), DPRdSoReg,
 759                  "mov", " $dst, $src", [(set GPR:$dst, so_reg:$src)]>;
 760
 761 let isReMaterializable = 1 in
 762 def MOVi : AsI1<0b1101, (outs GPR:$dst), (ins so_imm:$src), DPRdIm,
 763                  "mov", " $dst, $src", [(set GPR:$dst, so_imm:$src)]>;
 764
 765 def MOVrx : AsI1<0b1101, (outs GPR:$dst), (ins GPR:$src), DPRdMisc,
 766                  "mov", " $dst, $src, rrx",
 767                  [(set GPR:$dst, (ARMrrx GPR:$src))]>;
 768
 769 // These aren't really mov instructions, but we have to define them this way
 770 // due to flag operands.
 771
 772 let Defs = [CPSR] in {
 773 def MOVsrl_flag : AI1<0b1101, (outs GPR:$dst), (ins GPR:$src), DPRdMisc,
 774                       "mov", "s $dst, $src, lsr #1",
 775                       [(set GPR:$dst, (ARMsrl_flag GPR:$src))]>;
 776 def MOVsra_flag : AI1<0b1101, (outs GPR:$dst), (ins GPR:$src), DPRdMisc,
 777                       "mov", "s $dst, $src, asr #1",
 778                       [(set GPR:$dst, (ARMsra_flag GPR:$src))]>;
 779 }
 780
 781 //===----------------------------------------------------------------------===//
 782 //  Extend Instructions.
 783 //
 784
 785 // Sign extenders
 786
 787 defm SXTB  : AI_unary_rrot<0x0, "sxtb", UnOpFrag<(sext_inreg node:$Src, i8)>>;
 788 defm SXTH  : AI_unary_rrot<0x0, "sxth", UnOpFrag<(sext_inreg node:$Src, i16)>>;
 789
 790 defm SXTAB : AI_bin_rrot<0x0, "sxtab",
 791                         BinOpFrag<(add node:$LHS, (sext_inreg node:$RHS, i8))>>;
 792 defm SXTAH : AI_bin_rrot<0x0, "sxtah",
 793                         BinOpFrag<(add node:$LHS, (sext_inreg node:$RHS,i16))>>;
 794
 795 // TODO: SXT(A){B|H}16
 796
 797 // Zero extenders
 798
 799 let AddedComplexity = 16 in {
 800 defm UXTB   : AI_unary_rrot<0x0, "uxtb"  , UnOpFrag<(and node:$Src, 0x000000FF)>>;
 801 defm UXTH   : AI_unary_rrot<0x0, "uxth"  , UnOpFrag<(and node:$Src, 0x0000FFFF)>>;
 802 defm UXTB16 : AI_unary_rrot<0x0, "uxtb16", UnOpFrag<(and node:$Src, 0x00FF00FF)>>;
 803
 804 def : ARMV6Pat<(and (shl GPR:$Src, 8), 0xFF00FF),
 805                (UXTB16r_rot GPR:$Src, 24)>;
 806 def : ARMV6Pat<(and (srl GPR:$Src, 8), 0xFF00FF),
 807                (UXTB16r_rot GPR:$Src, 8)>;
 808
 809 defm UXTAB : AI_bin_rrot<0x0, "uxtab",
 810                         BinOpFrag<(add node:$LHS, (and node:$RHS, 0x00FF))>>;
 811 defm UXTAH : AI_bin_rrot<0x0, "uxtah",
 812                         BinOpFrag<(add node:$LHS, (and node:$RHS, 0xFFFF))>>;
 813 }
 814
 815 // This isn't safe in general, the add is two 16-bit units, not a 32-bit add.
 816 //defm UXTAB16 : xxx<"uxtab16", 0xff00ff>;
 817
 818 // TODO: UXT(A){B|H}16
 819
 820 //===----------------------------------------------------------------------===//
 821 //  Arithmetic Instructions.
 822 //
 823
 824 defm ADD  : AsI1_bin_irs<0b0100, "add",
 825                          BinOpFrag<(add  node:$LHS, node:$RHS)>>;
 826 defm SUB  : AsI1_bin_irs<0b0010, "sub",
 827                          BinOpFrag<(sub  node:$LHS, node:$RHS)>>;
 828
 829 // ADD and SUB with 's' bit set.
 830 defm ADDS : ASI1_bin_s_irs<0b0100, "add",
 831                            BinOpFrag<(addc node:$LHS, node:$RHS)>>;
 832 defm SUBS : ASI1_bin_s_irs<0b0010, "sub",
 833                            BinOpFrag<(subc node:$LHS, node:$RHS)>>;
 834
 835 // FIXME: Do not allow ADC / SBC to be predicated for now.
 836 defm ADC  : AsXI1_bin_c_irs<0b0101, "adc",
 837                             BinOpFrag<(adde node:$LHS, node:$RHS)>>;
 838 defm SBC  : AsXI1_bin_c_irs<0b0110, "sbc",
 839                             BinOpFrag<(sube node:$LHS, node:$RHS)>>;
 840
 841 // These don't define reg/reg forms, because they are handled above.
 842 def RSBri : AsI1<0b0011, (outs GPR:$dst), (ins GPR:$a, so_imm:$b), DPRIm,
 843                   "rsb", " $dst, $a, $b",
 844                   [(set GPR:$dst, (sub so_imm:$b, GPR:$a))]>;
 845
 846 def RSBrs : AsI1<0b0011, (outs GPR:$dst), (ins GPR:$a, so_reg:$b), DPRSoReg,
 847                   "rsb", " $dst, $a, $b",
 848                   [(set GPR:$dst, (sub so_reg:$b, GPR:$a))]>;
 849
 850 // RSB with 's' bit set.
 851 let Defs = [CPSR] in {
 852 def RSBSri : AI1<0b0011, (outs GPR:$dst), (ins GPR:$a, so_imm:$b), DPRIm,
 853                  "rsb", "s $dst, $a, $b",
 854                  [(set GPR:$dst, (subc so_imm:$b, GPR:$a))]>;
 855 def RSBSrs : AI1<0b0011, (outs GPR:$dst), (ins GPR:$a, so_reg:$b), DPRSoReg,
 856                  "rsb", "s $dst, $a, $b",
 857                  [(set GPR:$dst, (subc so_reg:$b, GPR:$a))]>;
 858 }
 859
 860 // FIXME: Do not allow RSC to be predicated for now. But they can set CPSR.
 861 let Uses = [CPSR] in {
 862 def RSCri : AXI1<0b0111, (outs GPR:$dst), (ins GPR:$a, so_imm:$b, cc_out:$s),
 863                  DPRIm, "rsc${s} $dst, $a, $b",
 864                  [(set GPR:$dst, (sube so_imm:$b, GPR:$a))]>;
 865 def RSCrs : AXI1<0b0111, (outs GPR:$dst), (ins GPR:$a, so_reg:$b, cc_out:$s),
 866                  DPRSoReg, "rsc${s} $dst, $a, $b",
 867                  [(set GPR:$dst, (sube so_reg:$b, GPR:$a))]>;
 868 }
 869
 870 // (sub X, imm) gets canonicalized to (add X, -imm).  Match this form.
 871 def : ARMPat<(add    GPR:$src, so_imm_neg:$imm),
 872              (SUBri  GPR:$src, so_imm_neg:$imm)>;
 873
 874 //def : ARMPat<(addc   GPR:$src, so_imm_neg:$imm),
 875 //             (SUBSri GPR:$src, so_imm_neg:$imm)>;
 876 //def : ARMPat<(adde   GPR:$src, so_imm_neg:$imm),
 877 //             (SBCri  GPR:$src, so_imm_neg:$imm)>;
 878
 879 // Note: These are implemented in C++ code, because they have to generate
 880 // ADD/SUBrs instructions, which use a complex pattern that a xform function
 881 // cannot produce.
 882 // (mul X, 2^n+1) -> (add (X << n), X)
 883 // (mul X, 2^n-1) -> (rsb X, (X << n))
 884
 885
 886 //===----------------------------------------------------------------------===//
 887 //  Bitwise Instructions.
 888 //
 889
 890 defm AND   : AsI1_bin_irs<0b0000, "and",
 891                           BinOpFrag<(and node:$LHS, node:$RHS)>>;
 892 defm ORR   : AsI1_bin_irs<0b1100, "orr",
 893                           BinOpFrag<(or  node:$LHS, node:$RHS)>>;
 894 defm EOR   : AsI1_bin_irs<0b0001, "eor",
 895                           BinOpFrag<(xor node:$LHS, node:$RHS)>>;
 896 defm BIC   : AsI1_bin_irs<0b1110, "bic",
 897                           BinOpFrag<(and node:$LHS, (not node:$RHS))>>;
 898
 899 def  MVNr  : AsI1<0b1111, (outs GPR:$dst), (ins GPR:$src), DPRdReg,
 900                   "mvn", " $dst, $src", [(set GPR:$dst, (not GPR:$src))]>;
 901 def  MVNs  : AsI1<0b1111, (outs GPR:$dst), (ins so_reg:$src), DPRdSoReg,
 902                   "mvn", " $dst, $src", [(set GPR:$dst, (not so_reg:$src))]>;
 903 let isReMaterializable = 1 in
 904 def  MVNi  : AsI1<0b1111, (outs GPR:$dst), (ins so_imm:$imm), DPRdIm,
 905                   "mvn", " $dst, $imm", [(set GPR:$dst, so_imm_not:$imm)]>;
 906
 907 def : ARMPat<(and   GPR:$src, so_imm_not:$imm),
 908              (BICri GPR:$src, so_imm_not:$imm)>;
 909
 910 //===----------------------------------------------------------------------===//
 911 //  Multiply Instructions.
 912 //
 913
 914 def MUL   : AsI6<0b0000, (outs GPR:$dst), (ins GPR:$a, GPR:$b), MulFrm,
 915                  "mul", " $dst, $a, $b",
 916                  [(set GPR:$dst, (mul GPR:$a, GPR:$b))]>;
 917
 918 def MLA   : AsI6<0b0010, (outs GPR:$dst), (ins GPR:$a, GPR:$b, GPR:$c),
 919                  MulFrm, "mla", " $dst, $a, $b, $c",
 920                  [(set GPR:$dst, (add (mul GPR:$a, GPR:$b), GPR:$c))]>;
 921
 922 // Extra precision multiplies with low / high results
 923 def SMULL : AsI6<0b1100, (outs GPR:$ldst, GPR:$hdst), (ins GPR:$a, GPR:$b),
 924                  MulFrm, "smull", " $ldst, $hdst, $a, $b", []>;
 925
 926 def UMULL : AsI6<0b1000, (outs GPR:$ldst, GPR:$hdst), (ins GPR:$a, GPR:$b),
 927                  MulFrm, "umull", " $ldst, $hdst, $a, $b", []>;
 928
 929 // Multiply + accumulate
 930 def SMLAL : AsI6<0b1110, (outs GPR:$ldst, GPR:$hdst), (ins GPR:$a, GPR:$b),
 931                  MulFrm, "smlal", " $ldst, $hdst, $a, $b", []>;
 932
 933 def UMLAL : AsI6<0b1010, (outs GPR:$ldst, GPR:$hdst), (ins GPR:$a, GPR:$b),
 934                  MulFrm, "umlal", " $ldst, $hdst, $a, $b", []>;
 935
 936 def UMAAL : AI6 <0b0000, (outs GPR:$ldst, GPR:$hdst), (ins GPR:$a, GPR:$b),
 937                  MulFrm, "umaal", " $ldst, $hdst, $a, $b", []>,
 938                  Requires<[IsARM, HasV6]>;
 939
 940 // Most significant word multiply
 941 // FIXME: encoding
 942 def SMMUL : AI<0x0, (outs GPR:$dst), (ins GPR:$a, GPR:$b), MulFrm,
 943                "smmul", " $dst, $a, $b",
 944                [(set GPR:$dst, (mulhs GPR:$a, GPR:$b))]>,
 945             Requires<[IsARM, HasV6]>;
 946
 947 // FIXME: encoding
 948 def SMMLA : AI<0x0, (outs GPR:$dst), (ins GPR:$a, GPR:$b, GPR:$c), MulFrm,
 949                "smmla", " $dst, $a, $b, $c",
 950                [(set GPR:$dst, (add (mulhs GPR:$a, GPR:$b), GPR:$c))]>,
 951             Requires<[IsARM, HasV6]>;
 952
 953
 954 // FIXME: encoding
 955 def SMMLS : AI<0x0, (outs GPR:$dst), (ins GPR:$a, GPR:$b, GPR:$c), MulFrm,
 956                "smmls", " $dst, $a, $b, $c",
 957                [(set GPR:$dst, (sub GPR:$c, (mulhs GPR:$a, GPR:$b)))]>,
 958                Requires<[IsARM, HasV6]>;
 959
 960 // FIXME: encoding
 961 multiclass AI_smul<string opc, PatFrag opnode> {
 962   def BB : AI<0x8, (outs GPR:$dst), (ins GPR:$a, GPR:$b), MulSMUL,
 963               !strconcat(opc, "bb"), " $dst, $a, $b",
 964               [(set GPR:$dst, (opnode (sext_inreg GPR:$a, i16),
 965                                       (sext_inreg GPR:$b, i16)))]>,
 966            Requires<[IsARM, HasV5TE]>;
 967
 968   def BT : AI<0xC, (outs GPR:$dst), (ins GPR:$a, GPR:$b), MulSMUL,
 969               !strconcat(opc, "bt"), " $dst, $a, $b",
 970               [(set GPR:$dst, (opnode (sext_inreg GPR:$a, i16),
 971                                       (sra GPR:$b, 16)))]>,
 972            Requires<[IsARM, HasV5TE]>;
 973
 974   def TB : AI<0xA, (outs GPR:$dst), (ins GPR:$a, GPR:$b), MulSMUL,
 975               !strconcat(opc, "tb"), " $dst, $a, $b",
 976               [(set GPR:$dst, (opnode (sra GPR:$a, 16),
 977                                       (sext_inreg GPR:$b, i16)))]>,
 978            Requires<[IsARM, HasV5TE]>;
 979
 980   def TT : AI<0xE, (outs GPR:$dst), (ins GPR:$a, GPR:$b), MulSMUL,
 981               !strconcat(opc, "tt"), " $dst, $a, $b",
 982               [(set GPR:$dst, (opnode (sra GPR:$a, 16),
 983                                       (sra GPR:$b, 16)))]>,
 984             Requires<[IsARM, HasV5TE]>;
 985
 986   def WB : AI<0xA, (outs GPR:$dst), (ins GPR:$a, GPR:$b), MulSMULW,
 987               !strconcat(opc, "wb"), " $dst, $a, $b",
 988               [(set GPR:$dst, (sra (opnode GPR:$a,
 989                                     (sext_inreg GPR:$b, i16)), 16))]>,
 990            Requires<[IsARM, HasV5TE]>;
 991
 992   def WT : AI<0xE, (outs GPR:$dst), (ins GPR:$a, GPR:$b), MulSMULW,
 993               !strconcat(opc, "wt"), " $dst, $a, $b",
 994               [(set GPR:$dst, (sra (opnode GPR:$a,
 995                                     (sra GPR:$b, 16)), 16))]>,
 996             Requires<[IsARM, HasV5TE]>;
 997 }
 998
 999
1000 // FIXME: encoding
1001 multiclass AI_smla<string opc, PatFrag opnode> {
1002   def BB : AI<0x8, (outs GPR:$dst), (ins GPR:$a, GPR:$b, GPR:$acc), MulSMLA,
1003               !strconcat(opc, "bb"), " $dst, $a, $b, $acc",
1004               [(set GPR:$dst, (add GPR:$acc,
1005                                (opnode (sext_inreg GPR:$a, i16),
1006                                        (sext_inreg GPR:$b, i16))))]>,
1007            Requires<[IsARM, HasV5TE]>;
1008
1009   def BT : AI<0xC, (outs GPR:$dst), (ins GPR:$a, GPR:$b, GPR:$acc), MulSMLA,
1010               !strconcat(opc, "bt"), " $dst, $a, $b, $acc",
1011               [(set GPR:$dst, (add GPR:$acc, (opnode (sext_inreg GPR:$a, i16),
1012                                                      (sra GPR:$b, 16))))]>,
1013            Requires<[IsARM, HasV5TE]>;
1014
1015   def TB : AI<0xA, (outs GPR:$dst), (ins GPR:$a, GPR:$b, GPR:$acc), MulSMLA,
1016               !strconcat(opc, "tb"), " $dst, $a, $b, $acc",
1017               [(set GPR:$dst, (add GPR:$acc, (opnode (sra GPR:$a, 16),
1018                                                  (sext_inreg GPR:$b, i16))))]>,
1019            Requires<[IsARM, HasV5TE]>;
1020
1021   def TT : AI<0xE, (outs GPR:$dst), (ins GPR:$a, GPR:$b, GPR:$acc), MulSMLA,
1022               !strconcat(opc, "tt"), " $dst, $a, $b, $acc",
1023               [(set GPR:$dst, (add GPR:$acc, (opnode (sra GPR:$a, 16),
1024                                                      (sra GPR:$b, 16))))]>,
1025             Requires<[IsARM, HasV5TE]>;
1026
1027   def WB : AI<0xA, (outs GPR:$dst), (ins GPR:$a, GPR:$b, GPR:$acc), MulSMLAW,
1028               !strconcat(opc, "wb"), " $dst, $a, $b, $acc",
1029               [(set GPR:$dst, (add GPR:$acc, (sra (opnode GPR:$a,
1030                                             (sext_inreg GPR:$b, i16)), 16)))]>,
1031            Requires<[IsARM, HasV5TE]>;
1032
1033   def WT : AI<0xE, (outs GPR:$dst), (ins GPR:$a, GPR:$b, GPR:$acc), MulSMLAW,
1034               !strconcat(opc, "wt"), " $dst, $a, $b, $acc",
1035               [(set GPR:$dst, (add GPR:$acc, (sra (opnode GPR:$a,
1036                                                    (sra GPR:$b, 16)), 16)))]>,
1037             Requires<[IsARM, HasV5TE]>;
1038 }
1039
1040 // FIXME: encoding
1041 defm SMUL : AI_smul<"smul", BinOpFrag<(mul node:$LHS, node:$RHS)>>;
1042 // FIXME: encoding
1043 defm SMLA : AI_smla<"smla", BinOpFrag<(mul node:$LHS, node:$RHS)>>;
1044
1045 // TODO: Halfword multiple accumulate long: SMLAL<x><y>
1046 // TODO: Dual halfword multiple: SMUAD, SMUSD, SMLAD, SMLSD, SMLALD, SMLSLD
1047
1048 //===----------------------------------------------------------------------===//
1049 //  Misc. Arithmetic Instructions.
1050 //
1051
1052 def CLZ  : AI<0x0, (outs GPR:$dst), (ins GPR:$src), ArithMisc,
1053               "clz", " $dst, $src",
1054               [(set GPR:$dst, (ctlz GPR:$src))]>, Requires<[IsARM, HasV5T]>;
1055
1056 def REV  : AI<0x0, (outs GPR:$dst), (ins GPR:$src), ArithMisc,
1057               "rev", " $dst, $src",
1058               [(set GPR:$dst, (bswap GPR:$src))]>, Requires<[IsARM, HasV6]>;
1059
1060 def REV16 : AI<0x0, (outs GPR:$dst), (ins GPR:$src), ArithMisc,
1061                "rev16", " $dst, $src",
1062                [(set GPR:$dst,
1063                    (or (and (srl GPR:$src, 8), 0xFF),
1064                        (or (and (shl GPR:$src, 8), 0xFF00),
1065                            (or (and (srl GPR:$src, 8), 0xFF0000),
1066                                (and (shl GPR:$src, 8), 0xFF000000)))))]>,
1067                Requires<[IsARM, HasV6]>;
1068
1069 def REVSH : AI<0x0, (outs GPR:$dst), (ins GPR:$src), ArithMisc,
1070                "revsh", " $dst, $src",
1071                [(set GPR:$dst,
1072                   (sext_inreg
1073                     (or (srl (and GPR:$src, 0xFF00), 8),
1074                         (shl GPR:$src, 8)), i16))]>,
1075                Requires<[IsARM, HasV6]>;
1076
1077 def PKHBT : AI<0x0, (outs GPR:$dst), (ins GPR:$src1, GPR:$src2, i32imm:$shamt),
1078                Pseudo, "pkhbt", " $dst, $src1, $src2, LSL $shamt",
1079                [(set GPR:$dst, (or (and GPR:$src1, 0xFFFF),
1080                                    (and (shl GPR:$src2, (i32 imm:$shamt)),
1081                                         0xFFFF0000)))]>,
1082                Requires<[IsARM, HasV6]>;
1083
1084 // Alternate cases for PKHBT where identities eliminate some nodes.
1085 def : ARMV6Pat<(or (and GPR:$src1, 0xFFFF), (and GPR:$src2, 0xFFFF0000)),
1086                (PKHBT GPR:$src1, GPR:$src2, 0)>;
1087 def : ARMV6Pat<(or (and GPR:$src1, 0xFFFF), (shl GPR:$src2, imm16_31:$shamt)),
1088                (PKHBT GPR:$src1, GPR:$src2, imm16_31:$shamt)>;
1089
1090
1091 def PKHTB : AI<0x0, (outs GPR:$dst), (ins GPR:$src1, GPR:$src2, i32imm:$shamt),
1092                Pseudo, "pkhtb", " $dst, $src1, $src2, ASR $shamt",
1093                [(set GPR:$dst, (or (and GPR:$src1, 0xFFFF0000),
1094                                    (and (sra GPR:$src2, imm16_31:$shamt),
1095                                         0xFFFF)))]>, Requires<[IsARM, HasV6]>;
1096
1097 // Alternate cases for PKHTB where identities eliminate some nodes.  Note that
1098 // a shift amount of 0 is *not legal* here, it is PKHBT instead.
1099 def : ARMV6Pat<(or (and GPR:$src1, 0xFFFF0000), (srl GPR:$src2, 16)),
1100                (PKHTB GPR:$src1, GPR:$src2, 16)>;
1101 def : ARMV6Pat<(or (and GPR:$src1, 0xFFFF0000),
1102                    (and (srl GPR:$src2, imm1_15:$shamt), 0xFFFF)),
1103                (PKHTB GPR:$src1, GPR:$src2, imm1_15:$shamt)>;
1104
1105
1106 //===----------------------------------------------------------------------===//
1107 //  Comparison Instructions...
1108 //
1109
1110 defm CMP  : AI1_cmp_irs<0b1010, "cmp",
1111                         BinOpFrag<(ARMcmp node:$LHS, node:$RHS)>>;
1112 defm CMN  : AI1_cmp_irs<0b1011, "cmn",
1113                         BinOpFrag<(ARMcmp node:$LHS,(ineg node:$RHS))>>;
1114
1115 // Note that TST/TEQ don't set all the same flags that CMP does!
1116 defm TST  : AI1_cmp_irs<0x8, "tst",
1117                         BinOpFrag<(ARMcmpNZ (and node:$LHS, node:$RHS), 0)>>;
1118 defm TEQ  : AI1_cmp_irs<0x9, "teq",
1119                         BinOpFrag<(ARMcmpNZ (xor node:$LHS, node:$RHS), 0)>>;
1120
1121 defm CMPnz : AI1_cmp_irs<0b1010, "cmp",
1122                          BinOpFrag<(ARMcmpNZ node:$LHS, node:$RHS)>>;
1123 defm CMNnz : AI1_cmp_irs<0b1011, "cmn",
1124                          BinOpFrag<(ARMcmpNZ node:$LHS,(ineg node:$RHS))>>;
1125
1126 def : ARMPat<(ARMcmp GPR:$src, so_imm_neg:$imm),
1127              (CMNri  GPR:$src, so_imm_neg:$imm)>;
1128
1129 def : ARMPat<(ARMcmpNZ GPR:$src, so_imm_neg:$imm),
1130              (CMNri  GPR:$src, so_imm_neg:$imm)>;
1131
1132
1133 // Conditional moves
1134 // FIXME: should be able to write a pattern for ARMcmov, but can't use
1135 // a two-value operand where a dag node expects two operands. :(
1136 def MOVCCr : AI<0xD, (outs GPR:$dst), (ins GPR:$false, GPR:$true),
1137                 DPRdReg, "mov", " $dst, $true",
1138       [/*(set GPR:$dst, (ARMcmov GPR:$false, GPR:$true, imm:$cc, CCR:$ccr))*/]>,
1139                 RegConstraint<"$false = $dst">;
1140
1141 def MOVCCs : AI<0xD, (outs GPR:$dst), (ins GPR:$false, so_reg:$true),
1142                 DPRdSoReg, "mov", " $dst, $true",
1143    [/*(set GPR:$dst, (ARMcmov GPR:$false, so_reg:$true, imm:$cc, CCR:$ccr))*/]>,
1144                 RegConstraint<"$false = $dst">;
1145
1146 def MOVCCi : AI<0xD, (outs GPR:$dst), (ins GPR:$false, so_imm:$true),
1147                 DPRdIm, "mov", " $dst, $true",
1148    [/*(set GPR:$dst, (ARMcmov GPR:$false, so_imm:$true, imm:$cc, CCR:$ccr))*/]>,
1149                 RegConstraint<"$false = $dst">;
1150
1151
1152 // LEApcrel - Load a pc-relative address into a register without offending the
1153 // assembler.
1154 def LEApcrel : AXI1<0x0, (outs GPR:$dst), (ins i32imm:$label, pred:$p), Pseudo,
1155                    !strconcat(!strconcat(".set PCRELV${:uid}, ($label-(",
1156                                          "${:private}PCRELL${:uid}+8))\n"),
1157                               !strconcat("${:private}PCRELL${:uid}:\n\t",
1158                                          "add$p $dst, pc, #PCRELV${:uid}")),
1159                    []>;
1160
1161 def LEApcrelJT : AXI1<0x0, (outs GPR:$dst), (ins i32imm:$label, i32imm:$id, pred:$p),
1162           Pseudo,
1163           !strconcat(!strconcat(".set PCRELV${:uid}, (${label}_${id:no_hash}-(",
1164                                          "${:private}PCRELL${:uid}+8))\n"),
1165                               !strconcat("${:private}PCRELL${:uid}:\n\t",
1166                                          "add$p $dst, pc, #PCRELV${:uid}")),
1167                    []>;
1168
1169 //===----------------------------------------------------------------------===//
1170 // TLS Instructions
1171 //
1172
1173 // __aeabi_read_tp preserves the registers r1-r3.
1174 let isCall = 1,
1175   Defs = [R0, R12, LR, CPSR] in {
1176   def TPsoft : AXI<0x0, (outs), (ins), BranchMisc,
1177                "bl __aeabi_read_tp",
1178                [(set R0, ARMthread_pointer)]>;
1179 }
1180
1181 //===----------------------------------------------------------------------===//
1182 // Non-Instruction Patterns
1183 //
1184
1185 // ConstantPool, GlobalAddress, and JumpTable
1186 def : ARMPat<(ARMWrapper  tglobaladdr :$dst), (LEApcrel tglobaladdr :$dst)>;
1187 def : ARMPat<(ARMWrapper  tconstpool  :$dst), (LEApcrel tconstpool  :$dst)>;
1188 def : ARMPat<(ARMWrapperJT tjumptable:$dst, imm:$id),
1189              (LEApcrelJT tjumptable:$dst, imm:$id)>;
1190
1191 // Large immediate handling.
1192
1193 // Two piece so_imms.
1194 let isReMaterializable = 1 in
1195 def MOVi2pieces : AI1x2<0x0, (outs GPR:$dst), (ins so_imm2part:$src), DPRdMisc,
1196                          "mov", " $dst, $src",
1197                          [(set GPR:$dst, so_imm2part:$src)]>;
1198
1199 def : ARMPat<(or GPR:$LHS, so_imm2part:$RHS),
1200               (ORRri (ORRri GPR:$LHS, (so_imm2part_1 imm:$RHS)),
1201                      (so_imm2part_2 imm:$RHS))>;
1202 def : ARMPat<(xor GPR:$LHS, so_imm2part:$RHS),
1203               (EORri (EORri GPR:$LHS, (so_imm2part_1 imm:$RHS)),
1204                      (so_imm2part_2 imm:$RHS))>;
1205
1206 // TODO: add,sub,and, 3-instr forms?
1207
1208
1209 // Direct calls
1210 def : ARMPat<(ARMcall texternalsym:$func), (BL texternalsym:$func)>;
1211
1212 // zextload i1 -> zextload i8
1213 def : ARMPat<(zextloadi1 addrmode2:$addr),  (LDRB addrmode2:$addr)>;
1214
1215 // extload -> zextload
1216 def : ARMPat<(extloadi1  addrmode2:$addr),  (LDRB addrmode2:$addr)>;
1217 def : ARMPat<(extloadi8  addrmode2:$addr),  (LDRB addrmode2:$addr)>;
1218 def : ARMPat<(extloadi16 addrmode3:$addr),  (LDRH addrmode3:$addr)>;
1219
1220 // smul* and smla*
1221 def : ARMV5TEPat<(mul (sra (shl GPR:$a, 16), 16), (sra (shl GPR:$b, 16), 16)),
1222                  (SMULBB GPR:$a, GPR:$b)>;
1223 def : ARMV5TEPat<(mul sext_16_node:$a, sext_16_node:$b),
1224                  (SMULBB GPR:$a, GPR:$b)>;
1225 def : ARMV5TEPat<(mul (sra (shl GPR:$a, 16), 16), (sra GPR:$b, 16)),
1226                  (SMULBT GPR:$a, GPR:$b)>;
1227 def : ARMV5TEPat<(mul sext_16_node:$a, (sra GPR:$b, 16)),
1228                  (SMULBT GPR:$a, GPR:$b)>;
1229 def : ARMV5TEPat<(mul (sra GPR:$a, 16), (sra (shl GPR:$b, 16), 16)),
1230                  (SMULTB GPR:$a, GPR:$b)>;
1231 def : ARMV5TEPat<(mul (sra GPR:$a, 16), sext_16_node:$b),
1232                 (SMULTB GPR:$a, GPR:$b)>;
1233 def : ARMV5TEPat<(sra (mul GPR:$a, (sra (shl GPR:$b, 16), 16)), 16),
1234                  (SMULWB GPR:$a, GPR:$b)>;
1235 def : ARMV5TEPat<(sra (mul GPR:$a, sext_16_node:$b), 16),
1236                  (SMULWB GPR:$a, GPR:$b)>;
1237
1238 def : ARMV5TEPat<(add GPR:$acc,
1239                       (mul (sra (shl GPR:$a, 16), 16),
1240                            (sra (shl GPR:$b, 16), 16))),
1241                  (SMLABB GPR:$a, GPR:$b, GPR:$acc)>;
1242 def : ARMV5TEPat<(add GPR:$acc,
1243                       (mul sext_16_node:$a, sext_16_node:$b)),
1244                  (SMLABB GPR:$a, GPR:$b, GPR:$acc)>;
1245 def : ARMV5TEPat<(add GPR:$acc,
1246                       (mul (sra (shl GPR:$a, 16), 16), (sra GPR:$b, 16))),
1247                  (SMLABT GPR:$a, GPR:$b, GPR:$acc)>;
1248 def : ARMV5TEPat<(add GPR:$acc,
1249                       (mul sext_16_node:$a, (sra GPR:$b, 16))),
1250                  (SMLABT GPR:$a, GPR:$b, GPR:$acc)>;
1251 def : ARMV5TEPat<(add GPR:$acc,
1252                       (mul (sra GPR:$a, 16), (sra (shl GPR:$b, 16), 16))),
1253                  (SMLATB GPR:$a, GPR:$b, GPR:$acc)>;
1254 def : ARMV5TEPat<(add GPR:$acc,
1255                       (mul (sra GPR:$a, 16), sext_16_node:$b)),
1256                  (SMLATB GPR:$a, GPR:$b, GPR:$acc)>;
1257 def : ARMV5TEPat<(add GPR:$acc,
1258                       (sra (mul GPR:$a, (sra (shl GPR:$b, 16), 16)), 16)),
1259                  (SMLAWB GPR:$a, GPR:$b, GPR:$acc)>;
1260 def : ARMV5TEPat<(add GPR:$acc,
1261                       (sra (mul GPR:$a, sext_16_node:$b), 16)),
1262                  (SMLAWB GPR:$a, GPR:$b, GPR:$acc)>;
1263
1264 //===----------------------------------------------------------------------===//
1265 // Thumb Support
1266 //
1267
1268 include "ARMInstrThumb.td"
1269
1270 //===----------------------------------------------------------------------===//
1271 // Floating Point Support
1272 //
1273
1274 include "ARMInstrVFP.td"