lib/Target/ARM/ARMISelDAGToDAG.cpp

   1 //===-- ARMISelDAGToDAG.cpp - A dag to dag inst selector for ARM ----------===//
   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 defines an instruction selector for the ARM target.
  11 //
  12 //===----------------------------------------------------------------------===//
  13
  14 #include "ARM.h"
  15 #include "ARMAddressingModes.h"
  16 #include "ARMConstantPoolValue.h"
  17 #include "ARMISelLowering.h"
  18 #include "ARMTargetMachine.h"
  19 #include "llvm/CallingConv.h"
  20 #include "llvm/Constants.h"
  21 #include "llvm/DerivedTypes.h"
  22 #include "llvm/Function.h"
  23 #include "llvm/Intrinsics.h"
  24 #include "llvm/LLVMContext.h"
  25 #include "llvm/CodeGen/MachineFrameInfo.h"
  26 #include "llvm/CodeGen/MachineFunction.h"
  27 #include "llvm/CodeGen/MachineInstrBuilder.h"
  28 #include "llvm/CodeGen/SelectionDAG.h"
  29 #include "llvm/CodeGen/SelectionDAGISel.h"
  30 #include "llvm/Target/TargetLowering.h"
  31 #include "llvm/Target/TargetOptions.h"
  32 #include "llvm/Support/Compiler.h"
  33 #include "llvm/Support/Debug.h"
  34 #include "llvm/Support/ErrorHandling.h"
  35 #include "llvm/Support/raw_ostream.h"
  36
  37 using namespace llvm;
  38
  39 //===--------------------------------------------------------------------===//
  40 /// ARMDAGToDAGISel - ARM specific code to select ARM machine
  41 /// instructions for SelectionDAG operations.
  42 ///
  43 namespace {
  44 class ARMDAGToDAGISel : public SelectionDAGISel {
  45   ARMBaseTargetMachine &TM;
  46
  47   /// Subtarget - Keep a pointer to the ARMSubtarget around so that we can
  48   /// make the right decision when generating code for different targets.
  49   const ARMSubtarget *Subtarget;
  50
  51 public:
  52   explicit ARMDAGToDAGISel(ARMBaseTargetMachine &tm,
  53                            CodeGenOpt::Level OptLevel)
  54     : SelectionDAGISel(tm, OptLevel), TM(tm),
  55     Subtarget(&TM.getSubtarget<ARMSubtarget>()) {
  56   }
  57
  58   virtual const char *getPassName() const {
  59     return "ARM Instruction Selection";
  60   }
  61
  62  /// getI32Imm - Return a target constant with the specified value, of type i32.
  63   inline SDValue getI32Imm(unsigned Imm) {
  64     return CurDAG->getTargetConstant(Imm, MVT::i32);
  65   }
  66
  67   SDNode *Select(SDValue Op);
  68   virtual void InstructionSelect();
  69   bool SelectShifterOperandReg(SDValue Op, SDValue N, SDValue &A,
  70                                SDValue &B, SDValue &C);
  71   bool SelectAddrMode2(SDValue Op, SDValue N, SDValue &Base,
  72                        SDValue &Offset, SDValue &Opc);
  73   bool SelectAddrMode2Offset(SDValue Op, SDValue N,
  74                              SDValue &Offset, SDValue &Opc);
  75   bool SelectAddrMode3(SDValue Op, SDValue N, SDValue &Base,
  76                        SDValue &Offset, SDValue &Opc);
  77   bool SelectAddrMode3Offset(SDValue Op, SDValue N,
  78                              SDValue &Offset, SDValue &Opc);
  79   bool SelectAddrMode4(SDValue Op, SDValue N, SDValue &Addr,
  80                        SDValue &Mode);
  81   bool SelectAddrMode5(SDValue Op, SDValue N, SDValue &Base,
  82                        SDValue &Offset);
  83   bool SelectAddrMode6(SDValue Op, SDValue N, SDValue &Addr, SDValue &Update,
  84                        SDValue &Opc);
  85
  86   bool SelectAddrModePC(SDValue Op, SDValue N, SDValue &Offset,
  87                         SDValue &Label);
  88
  89   bool SelectThumbAddrModeRR(SDValue Op, SDValue N, SDValue &Base,
  90                              SDValue &Offset);
  91   bool SelectThumbAddrModeRI5(SDValue Op, SDValue N, unsigned Scale,
  92                               SDValue &Base, SDValue &OffImm,
  93                               SDValue &Offset);
  94   bool SelectThumbAddrModeS1(SDValue Op, SDValue N, SDValue &Base,
  95                              SDValue &OffImm, SDValue &Offset);
  96   bool SelectThumbAddrModeS2(SDValue Op, SDValue N, SDValue &Base,
  97                              SDValue &OffImm, SDValue &Offset);
  98   bool SelectThumbAddrModeS4(SDValue Op, SDValue N, SDValue &Base,
  99                              SDValue &OffImm, SDValue &Offset);
 100   bool SelectThumbAddrModeSP(SDValue Op, SDValue N, SDValue &Base,
 101                              SDValue &OffImm);
 102
 103   bool SelectT2ShifterOperandReg(SDValue Op, SDValue N,
 104                                  SDValue &BaseReg, SDValue &Opc);
 105   bool SelectT2AddrModeImm12(SDValue Op, SDValue N, SDValue &Base,
 106                              SDValue &OffImm);
 107   bool SelectT2AddrModeImm8(SDValue Op, SDValue N, SDValue &Base,
 108                             SDValue &OffImm);
 109   bool SelectT2AddrModeImm8Offset(SDValue Op, SDValue N,
 110                                  SDValue &OffImm);
 111   bool SelectT2AddrModeImm8s4(SDValue Op, SDValue N, SDValue &Base,
 112                               SDValue &OffImm);
 113   bool SelectT2AddrModeSoReg(SDValue Op, SDValue N, SDValue &Base,
 114                              SDValue &OffReg, SDValue &ShImm);
 115
 116   // Include the pieces autogenerated from the target description.
 117 #include "ARMGenDAGISel.inc"
 118
 119 private:
 120   /// SelectARMIndexedLoad - Indexed (pre/post inc/dec) load matching code for
 121   /// ARM.
 122   SDNode *SelectARMIndexedLoad(SDValue Op);
 123   SDNode *SelectT2IndexedLoad(SDValue Op);
 124
 125   /// SelectDYN_ALLOC - Select dynamic alloc for Thumb.
 126   SDNode *SelectDYN_ALLOC(SDValue Op);
 127
 128   /// SelectInlineAsmMemoryOperand - Implement addressing mode selection for
 129   /// inline asm expressions.
 130   virtual bool SelectInlineAsmMemoryOperand(const SDValue &Op,
 131                                             char ConstraintCode,
 132                                             std::vector<SDValue> &OutOps);
 133
 134   /// PairDRegs - Insert a pair of double registers into an implicit def to
 135   /// form a quad register.
 136   SDNode *PairDRegs(EVT VT, SDValue V0, SDValue V1);
 137 };
 138 }
 139
 140 void ARMDAGToDAGISel::InstructionSelect() {
 141   DEBUG(BB->dump());
 142
 143   SelectRoot(*CurDAG);
 144   CurDAG->RemoveDeadNodes();
 145 }
 146
 147 bool ARMDAGToDAGISel::SelectShifterOperandReg(SDValue Op,
 148                                               SDValue N,
 149                                               SDValue &BaseReg,
 150                                               SDValue &ShReg,
 151                                               SDValue &Opc) {
 152   ARM_AM::ShiftOpc ShOpcVal = ARM_AM::getShiftOpcForNode(N);
 153
 154   // Don't match base register only case. That is matched to a separate
 155   // lower complexity pattern with explicit register operand.
 156   if (ShOpcVal == ARM_AM::no_shift) return false;
 157
 158   BaseReg = N.getOperand(0);
 159   unsigned ShImmVal = 0;
 160   if (ConstantSDNode *RHS = dyn_cast<ConstantSDNode>(N.getOperand(1))) {
 161     ShReg = CurDAG->getRegister(0, MVT::i32);
 162     ShImmVal = RHS->getZExtValue() & 31;
 163   } else {
 164     ShReg = N.getOperand(1);
 165   }
 166   Opc = CurDAG->getTargetConstant(ARM_AM::getSORegOpc(ShOpcVal, ShImmVal),
 167                                   MVT::i32);
 168   return true;
 169 }
 170
 171 bool ARMDAGToDAGISel::SelectAddrMode2(SDValue Op, SDValue N,
 172                                       SDValue &Base, SDValue &Offset,
 173                                       SDValue &Opc) {
 174   if (N.getOpcode() == ISD::MUL) {
 175     if (ConstantSDNode *RHS = dyn_cast<ConstantSDNode>(N.getOperand(1))) {
 176       // X * [3,5,9] -> X + X * [2,4,8] etc.
 177       int RHSC = (int)RHS->getZExtValue();
 178       if (RHSC & 1) {
 179         RHSC = RHSC & ~1;
 180         ARM_AM::AddrOpc AddSub = ARM_AM::add;
 181         if (RHSC < 0) {
 182           AddSub = ARM_AM::sub;
 183           RHSC = - RHSC;
 184         }
 185         if (isPowerOf2_32(RHSC)) {
 186           unsigned ShAmt = Log2_32(RHSC);
 187           Base = Offset = N.getOperand(0);
 188           Opc = CurDAG->getTargetConstant(ARM_AM::getAM2Opc(AddSub, ShAmt,
 189                                                             ARM_AM::lsl),
 190                                           MVT::i32);
 191           return true;
 192         }
 193       }
 194     }
 195   }
 196
 197   if (N.getOpcode() != ISD::ADD && N.getOpcode() != ISD::SUB) {
 198     Base = N;
 199     if (N.getOpcode() == ISD::FrameIndex) {
 200       int FI = cast<FrameIndexSDNode>(N)->getIndex();
 201       Base = CurDAG->getTargetFrameIndex(FI, TLI.getPointerTy());
 202     } else if (N.getOpcode() == ARMISD::Wrapper) {
 203       Base = N.getOperand(0);
 204     }
 205     Offset = CurDAG->getRegister(0, MVT::i32);
 206     Opc = CurDAG->getTargetConstant(ARM_AM::getAM2Opc(ARM_AM::add, 0,
 207                                                       ARM_AM::no_shift),
 208                                     MVT::i32);
 209     return true;
 210   }
 211
 212   // Match simple R +/- imm12 operands.
 213   if (N.getOpcode() == ISD::ADD)
 214     if (ConstantSDNode *RHS = dyn_cast<ConstantSDNode>(N.getOperand(1))) {
 215       int RHSC = (int)RHS->getZExtValue();
 216       if ((RHSC >= 0 && RHSC < 0x1000) ||
 217           (RHSC < 0 && RHSC > -0x1000)) { // 12 bits.
 218         Base = N.getOperand(0);
 219         if (Base.getOpcode() == ISD::FrameIndex) {
 220           int FI = cast<FrameIndexSDNode>(Base)->getIndex();
 221           Base = CurDAG->getTargetFrameIndex(FI, TLI.getPointerTy());
 222         }
 223         Offset = CurDAG->getRegister(0, MVT::i32);
 224
 225         ARM_AM::AddrOpc AddSub = ARM_AM::add;
 226         if (RHSC < 0) {
 227           AddSub = ARM_AM::sub;
 228           RHSC = - RHSC;
 229         }
 230         Opc = CurDAG->getTargetConstant(ARM_AM::getAM2Opc(AddSub, RHSC,
 231                                                           ARM_AM::no_shift),
 232                                         MVT::i32);
 233         return true;
 234       }
 235     }
 236
 237   // Otherwise this is R +/- [possibly shifted] R
 238   ARM_AM::AddrOpc AddSub = N.getOpcode() == ISD::ADD ? ARM_AM::add:ARM_AM::sub;
 239   ARM_AM::ShiftOpc ShOpcVal = ARM_AM::getShiftOpcForNode(N.getOperand(1));
 240   unsigned ShAmt = 0;
 241
 242   Base   = N.getOperand(0);
 243   Offset = N.getOperand(1);
 244
 245   if (ShOpcVal != ARM_AM::no_shift) {
 246     // Check to see if the RHS of the shift is a constant, if not, we can't fold
 247     // it.
 248     if (ConstantSDNode *Sh =
 249            dyn_cast<ConstantSDNode>(N.getOperand(1).getOperand(1))) {
 250       ShAmt = Sh->getZExtValue();
 251       Offset = N.getOperand(1).getOperand(0);
 252     } else {
 253       ShOpcVal = ARM_AM::no_shift;
 254     }
 255   }
 256
 257   // Try matching (R shl C) + (R).
 258   if (N.getOpcode() == ISD::ADD && ShOpcVal == ARM_AM::no_shift) {
 259     ShOpcVal = ARM_AM::getShiftOpcForNode(N.getOperand(0));
 260     if (ShOpcVal != ARM_AM::no_shift) {
 261       // Check to see if the RHS of the shift is a constant, if not, we can't
 262       // fold it.
 263       if (ConstantSDNode *Sh =
 264           dyn_cast<ConstantSDNode>(N.getOperand(0).getOperand(1))) {
 265         ShAmt = Sh->getZExtValue();
 266         Offset = N.getOperand(0).getOperand(0);
 267         Base = N.getOperand(1);
 268       } else {
 269         ShOpcVal = ARM_AM::no_shift;
 270       }
 271     }
 272   }
 273
 274   Opc = CurDAG->getTargetConstant(ARM_AM::getAM2Opc(AddSub, ShAmt, ShOpcVal),
 275                                   MVT::i32);
 276   return true;
 277 }
 278
 279 bool ARMDAGToDAGISel::SelectAddrMode2Offset(SDValue Op, SDValue N,
 280                                             SDValue &Offset, SDValue &Opc) {
 281   unsigned Opcode = Op.getOpcode();
 282   ISD::MemIndexedMode AM = (Opcode == ISD::LOAD)
 283     ? cast<LoadSDNode>(Op)->getAddressingMode()
 284     : cast<StoreSDNode>(Op)->getAddressingMode();
 285   ARM_AM::AddrOpc AddSub = (AM == ISD::PRE_INC || AM == ISD::POST_INC)
 286     ? ARM_AM::add : ARM_AM::sub;
 287   if (ConstantSDNode *C = dyn_cast<ConstantSDNode>(N)) {
 288     int Val = (int)C->getZExtValue();
 289     if (Val >= 0 && Val < 0x1000) { // 12 bits.
 290       Offset = CurDAG->getRegister(0, MVT::i32);
 291       Opc = CurDAG->getTargetConstant(ARM_AM::getAM2Opc(AddSub, Val,
 292                                                         ARM_AM::no_shift),
 293                                       MVT::i32);
 294       return true;
 295     }
 296   }
 297
 298   Offset = N;
 299   ARM_AM::ShiftOpc ShOpcVal = ARM_AM::getShiftOpcForNode(N);
 300   unsigned ShAmt = 0;
 301   if (ShOpcVal != ARM_AM::no_shift) {
 302     // Check to see if the RHS of the shift is a constant, if not, we can't fold
 303     // it.
 304     if (ConstantSDNode *Sh = dyn_cast<ConstantSDNode>(N.getOperand(1))) {
 305       ShAmt = Sh->getZExtValue();
 306       Offset = N.getOperand(0);
 307     } else {
 308       ShOpcVal = ARM_AM::no_shift;
 309     }
 310   }
 311
 312   Opc = CurDAG->getTargetConstant(ARM_AM::getAM2Opc(AddSub, ShAmt, ShOpcVal),
 313                                   MVT::i32);
 314   return true;
 315 }
 316
 317
 318 bool ARMDAGToDAGISel::SelectAddrMode3(SDValue Op, SDValue N,
 319                                       SDValue &Base, SDValue &Offset,
 320                                       SDValue &Opc) {
 321   if (N.getOpcode() == ISD::SUB) {
 322     // X - C  is canonicalize to X + -C, no need to handle it here.
 323     Base = N.getOperand(0);
 324     Offset = N.getOperand(1);
 325     Opc = CurDAG->getTargetConstant(ARM_AM::getAM3Opc(ARM_AM::sub, 0),MVT::i32);
 326     return true;
 327   }
 328
 329   if (N.getOpcode() != ISD::ADD) {
 330     Base = N;
 331     if (N.getOpcode() == ISD::FrameIndex) {
 332       int FI = cast<FrameIndexSDNode>(N)->getIndex();
 333       Base = CurDAG->getTargetFrameIndex(FI, TLI.getPointerTy());
 334     }
 335     Offset = CurDAG->getRegister(0, MVT::i32);
 336     Opc = CurDAG->getTargetConstant(ARM_AM::getAM3Opc(ARM_AM::add, 0),MVT::i32);
 337     return true;
 338   }
 339
 340   // If the RHS is +/- imm8, fold into addr mode.
 341   if (ConstantSDNode *RHS = dyn_cast<ConstantSDNode>(N.getOperand(1))) {
 342     int RHSC = (int)RHS->getZExtValue();
 343     if ((RHSC >= 0 && RHSC < 256) ||
 344         (RHSC < 0 && RHSC > -256)) { // note -256 itself isn't allowed.
 345       Base = N.getOperand(0);
 346       if (Base.getOpcode() == ISD::FrameIndex) {
 347         int FI = cast<FrameIndexSDNode>(Base)->getIndex();
 348         Base = CurDAG->getTargetFrameIndex(FI, TLI.getPointerTy());
 349       }
 350       Offset = CurDAG->getRegister(0, MVT::i32);
 351
 352       ARM_AM::AddrOpc AddSub = ARM_AM::add;
 353       if (RHSC < 0) {
 354         AddSub = ARM_AM::sub;
 355         RHSC = - RHSC;
 356       }
 357       Opc = CurDAG->getTargetConstant(ARM_AM::getAM3Opc(AddSub, RHSC),MVT::i32);
 358       return true;
 359     }
 360   }
 361
 362   Base = N.getOperand(0);
 363   Offset = N.getOperand(1);
 364   Opc = CurDAG->getTargetConstant(ARM_AM::getAM3Opc(ARM_AM::add, 0), MVT::i32);
 365   return true;
 366 }
 367
 368 bool ARMDAGToDAGISel::SelectAddrMode3Offset(SDValue Op, SDValue N,
 369                                             SDValue &Offset, SDValue &Opc) {
 370   unsigned Opcode = Op.getOpcode();
 371   ISD::MemIndexedMode AM = (Opcode == ISD::LOAD)
 372     ? cast<LoadSDNode>(Op)->getAddressingMode()
 373     : cast<StoreSDNode>(Op)->getAddressingMode();
 374   ARM_AM::AddrOpc AddSub = (AM == ISD::PRE_INC || AM == ISD::POST_INC)
 375     ? ARM_AM::add : ARM_AM::sub;
 376   if (ConstantSDNode *C = dyn_cast<ConstantSDNode>(N)) {
 377     int Val = (int)C->getZExtValue();
 378     if (Val >= 0 && Val < 256) {
 379       Offset = CurDAG->getRegister(0, MVT::i32);
 380       Opc = CurDAG->getTargetConstant(ARM_AM::getAM3Opc(AddSub, Val), MVT::i32);
 381       return true;
 382     }
 383   }
 384
 385   Offset = N;
 386   Opc = CurDAG->getTargetConstant(ARM_AM::getAM3Opc(AddSub, 0), MVT::i32);
 387   return true;
 388 }
 389
 390 bool ARMDAGToDAGISel::SelectAddrMode4(SDValue Op, SDValue N,
 391                                       SDValue &Addr, SDValue &Mode) {
 392   Addr = N;
 393   Mode = CurDAG->getTargetConstant(0, MVT::i32);
 394   return true;
 395 }
 396
 397 bool ARMDAGToDAGISel::SelectAddrMode5(SDValue Op, SDValue N,
 398                                       SDValue &Base, SDValue &Offset) {
 399   if (N.getOpcode() != ISD::ADD) {
 400     Base = N;
 401     if (N.getOpcode() == ISD::FrameIndex) {
 402       int FI = cast<FrameIndexSDNode>(N)->getIndex();
 403       Base = CurDAG->getTargetFrameIndex(FI, TLI.getPointerTy());
 404     } else if (N.getOpcode() == ARMISD::Wrapper) {
 405       Base = N.getOperand(0);
 406     }
 407     Offset = CurDAG->getTargetConstant(ARM_AM::getAM5Opc(ARM_AM::add, 0),
 408                                        MVT::i32);
 409     return true;
 410   }
 411
 412   // If the RHS is +/- imm8, fold into addr mode.
 413   if (ConstantSDNode *RHS = dyn_cast<ConstantSDNode>(N.getOperand(1))) {
 414     int RHSC = (int)RHS->getZExtValue();
 415     if ((RHSC & 3) == 0) {  // The constant is implicitly multiplied by 4.
 416       RHSC >>= 2;
 417       if ((RHSC >= 0 && RHSC < 256) ||
 418           (RHSC < 0 && RHSC > -256)) { // note -256 itself isn't allowed.
 419         Base = N.getOperand(0);
 420         if (Base.getOpcode() == ISD::FrameIndex) {
 421           int FI = cast<FrameIndexSDNode>(Base)->getIndex();
 422           Base = CurDAG->getTargetFrameIndex(FI, TLI.getPointerTy());
 423         }
 424
 425         ARM_AM::AddrOpc AddSub = ARM_AM::add;
 426         if (RHSC < 0) {
 427           AddSub = ARM_AM::sub;
 428           RHSC = - RHSC;
 429         }
 430         Offset = CurDAG->getTargetConstant(ARM_AM::getAM5Opc(AddSub, RHSC),
 431                                            MVT::i32);
 432         return true;
 433       }
 434     }
 435   }
 436
 437   Base = N;
 438   Offset = CurDAG->getTargetConstant(ARM_AM::getAM5Opc(ARM_AM::add, 0),
 439                                      MVT::i32);
 440   return true;
 441 }
 442
 443 bool ARMDAGToDAGISel::SelectAddrMode6(SDValue Op, SDValue N,
 444                                       SDValue &Addr, SDValue &Update,
 445                                       SDValue &Opc) {
 446   Addr = N;
 447   // Default to no writeback.
 448   Update = CurDAG->getRegister(0, MVT::i32);
 449   Opc = CurDAG->getTargetConstant(ARM_AM::getAM6Opc(false), MVT::i32);
 450   return true;
 451 }
 452
 453 bool ARMDAGToDAGISel::SelectAddrModePC(SDValue Op, SDValue N,
 454                                        SDValue &Offset, SDValue &Label) {
 455   if (N.getOpcode() == ARMISD::PIC_ADD && N.hasOneUse()) {
 456     Offset = N.getOperand(0);
 457     SDValue N1 = N.getOperand(1);
 458     Label  = CurDAG->getTargetConstant(cast<ConstantSDNode>(N1)->getZExtValue(),
 459                                        MVT::i32);
 460     return true;
 461   }
 462   return false;
 463 }
 464
 465 bool ARMDAGToDAGISel::SelectThumbAddrModeRR(SDValue Op, SDValue N,
 466                                             SDValue &Base, SDValue &Offset){
 467   // FIXME dl should come from the parent load or store, not the address
 468   DebugLoc dl = Op.getDebugLoc();
 469   if (N.getOpcode() != ISD::ADD) {
 470     ConstantSDNode *NC = dyn_cast<ConstantSDNode>(N);
 471     if (!NC || NC->getZExtValue() != 0)
 472       return false;
 473
 474     Base = Offset = N;
 475     return true;
 476   }
 477
 478   Base = N.getOperand(0);
 479   Offset = N.getOperand(1);
 480   return true;
 481 }
 482
 483 bool
 484 ARMDAGToDAGISel::SelectThumbAddrModeRI5(SDValue Op, SDValue N,
 485                                         unsigned Scale, SDValue &Base,
 486                                         SDValue &OffImm, SDValue &Offset) {
 487   if (Scale == 4) {
 488     SDValue TmpBase, TmpOffImm;
 489     if (SelectThumbAddrModeSP(Op, N, TmpBase, TmpOffImm))
 490       return false;  // We want to select tLDRspi / tSTRspi instead.
 491     if (N.getOpcode() == ARMISD::Wrapper &&
 492         N.getOperand(0).getOpcode() == ISD::TargetConstantPool)
 493       return false;  // We want to select tLDRpci instead.
 494   }
 495
 496   if (N.getOpcode() != ISD::ADD) {
 497     Base = (N.getOpcode() == ARMISD::Wrapper) ? N.getOperand(0) : N;
 498     Offset = CurDAG->getRegister(0, MVT::i32);
 499     OffImm = CurDAG->getTargetConstant(0, MVT::i32);
 500     return true;
 501   }
 502
 503   // Thumb does not have [sp, r] address mode.
 504   RegisterSDNode *LHSR = dyn_cast<RegisterSDNode>(N.getOperand(0));
 505   RegisterSDNode *RHSR = dyn_cast<RegisterSDNode>(N.getOperand(1));
 506   if ((LHSR && LHSR->getReg() == ARM::SP) ||
 507       (RHSR && RHSR->getReg() == ARM::SP)) {
 508     Base = N;
 509     Offset = CurDAG->getRegister(0, MVT::i32);
 510     OffImm = CurDAG->getTargetConstant(0, MVT::i32);
 511     return true;
 512   }
 513
 514   // If the RHS is + imm5 * scale, fold into addr mode.
 515   if (ConstantSDNode *RHS = dyn_cast<ConstantSDNode>(N.getOperand(1))) {
 516     int RHSC = (int)RHS->getZExtValue();
 517     if ((RHSC & (Scale-1)) == 0) {  // The constant is implicitly multiplied.
 518       RHSC /= Scale;
 519       if (RHSC >= 0 && RHSC < 32) {
 520         Base = N.getOperand(0);
 521         Offset = CurDAG->getRegister(0, MVT::i32);
 522         OffImm = CurDAG->getTargetConstant(RHSC, MVT::i32);
 523         return true;
 524       }
 525     }
 526   }
 527
 528   Base = N.getOperand(0);
 529   Offset = N.getOperand(1);
 530   OffImm = CurDAG->getTargetConstant(0, MVT::i32);
 531   return true;
 532 }
 533
 534 bool ARMDAGToDAGISel::SelectThumbAddrModeS1(SDValue Op, SDValue N,
 535                                             SDValue &Base, SDValue &OffImm,
 536                                             SDValue &Offset) {
 537   return SelectThumbAddrModeRI5(Op, N, 1, Base, OffImm, Offset);
 538 }
 539
 540 bool ARMDAGToDAGISel::SelectThumbAddrModeS2(SDValue Op, SDValue N,
 541                                             SDValue &Base, SDValue &OffImm,
 542                                             SDValue &Offset) {
 543   return SelectThumbAddrModeRI5(Op, N, 2, Base, OffImm, Offset);
 544 }
 545
 546 bool ARMDAGToDAGISel::SelectThumbAddrModeS4(SDValue Op, SDValue N,
 547                                             SDValue &Base, SDValue &OffImm,
 548                                             SDValue &Offset) {
 549   return SelectThumbAddrModeRI5(Op, N, 4, Base, OffImm, Offset);
 550 }
 551
 552 bool ARMDAGToDAGISel::SelectThumbAddrModeSP(SDValue Op, SDValue N,
 553                                            SDValue &Base, SDValue &OffImm) {
 554   if (N.getOpcode() == ISD::FrameIndex) {
 555     int FI = cast<FrameIndexSDNode>(N)->getIndex();
 556     Base = CurDAG->getTargetFrameIndex(FI, TLI.getPointerTy());
 557     OffImm = CurDAG->getTargetConstant(0, MVT::i32);
 558     return true;
 559   }
 560
 561   if (N.getOpcode() != ISD::ADD)
 562     return false;
 563
 564   RegisterSDNode *LHSR = dyn_cast<RegisterSDNode>(N.getOperand(0));
 565   if (N.getOperand(0).getOpcode() == ISD::FrameIndex ||
 566       (LHSR && LHSR->getReg() == ARM::SP)) {
 567     // If the RHS is + imm8 * scale, fold into addr mode.
 568     if (ConstantSDNode *RHS = dyn_cast<ConstantSDNode>(N.getOperand(1))) {
 569       int RHSC = (int)RHS->getZExtValue();
 570       if ((RHSC & 3) == 0) {  // The constant is implicitly multiplied.
 571         RHSC >>= 2;
 572         if (RHSC >= 0 && RHSC < 256) {
 573           Base = N.getOperand(0);
 574           if (Base.getOpcode() == ISD::FrameIndex) {
 575             int FI = cast<FrameIndexSDNode>(Base)->getIndex();
 576             Base = CurDAG->getTargetFrameIndex(FI, TLI.getPointerTy());
 577           }
 578           OffImm = CurDAG->getTargetConstant(RHSC, MVT::i32);
 579           return true;
 580         }
 581       }
 582     }
 583   }
 584
 585   return false;
 586 }
 587
 588 bool ARMDAGToDAGISel::SelectT2ShifterOperandReg(SDValue Op, SDValue N,
 589                                                 SDValue &BaseReg,
 590                                                 SDValue &Opc) {
 591   ARM_AM::ShiftOpc ShOpcVal = ARM_AM::getShiftOpcForNode(N);
 592
 593   // Don't match base register only case. That is matched to a separate
 594   // lower complexity pattern with explicit register operand.
 595   if (ShOpcVal == ARM_AM::no_shift) return false;
 596
 597   BaseReg = N.getOperand(0);
 598   unsigned ShImmVal = 0;
 599   if (ConstantSDNode *RHS = dyn_cast<ConstantSDNode>(N.getOperand(1))) {
 600     ShImmVal = RHS->getZExtValue() & 31;
 601     Opc = getI32Imm(ARM_AM::getSORegOpc(ShOpcVal, ShImmVal));
 602     return true;
 603   }
 604
 605   return false;
 606 }
 607
 608 bool ARMDAGToDAGISel::SelectT2AddrModeImm12(SDValue Op, SDValue N,
 609                                             SDValue &Base, SDValue &OffImm) {
 610   // Match simple R + imm12 operands.
 611
 612   // Base only.
 613   if (N.getOpcode() != ISD::ADD && N.getOpcode() != ISD::SUB) {
 614     if (N.getOpcode() == ISD::FrameIndex) {
 615       // Match frame index...
 616       int FI = cast<FrameIndexSDNode>(N)->getIndex();
 617       Base = CurDAG->getTargetFrameIndex(FI, TLI.getPointerTy());
 618       OffImm  = CurDAG->getTargetConstant(0, MVT::i32);
 619       return true;
 620     } else if (N.getOpcode() == ARMISD::Wrapper) {
 621       Base = N.getOperand(0);
 622       if (Base.getOpcode() == ISD::TargetConstantPool)
 623         return false;  // We want to select t2LDRpci instead.
 624     } else
 625       Base = N;
 626     OffImm  = CurDAG->getTargetConstant(0, MVT::i32);
 627     return true;
 628   }
 629
 630   if (ConstantSDNode *RHS = dyn_cast<ConstantSDNode>(N.getOperand(1))) {
 631     if (SelectT2AddrModeImm8(Op, N, Base, OffImm))
 632       // Let t2LDRi8 handle (R - imm8).
 633       return false;
 634
 635     int RHSC = (int)RHS->getZExtValue();
 636     if (N.getOpcode() == ISD::SUB)
 637       RHSC = -RHSC;
 638
 639     if (RHSC >= 0 && RHSC < 0x1000) { // 12 bits (unsigned)
 640       Base   = N.getOperand(0);
 641       if (Base.getOpcode() == ISD::FrameIndex) {
 642         int FI = cast<FrameIndexSDNode>(Base)->getIndex();
 643         Base = CurDAG->getTargetFrameIndex(FI, TLI.getPointerTy());
 644       }
 645       OffImm = CurDAG->getTargetConstant(RHSC, MVT::i32);
 646       return true;
 647     }
 648   }
 649
 650   // Base only.
 651   Base = N;
 652   OffImm  = CurDAG->getTargetConstant(0, MVT::i32);
 653   return true;
 654 }
 655
 656 bool ARMDAGToDAGISel::SelectT2AddrModeImm8(SDValue Op, SDValue N,
 657                                            SDValue &Base, SDValue &OffImm) {
 658   // Match simple R - imm8 operands.
 659   if (N.getOpcode() == ISD::ADD || N.getOpcode() == ISD::SUB) {
 660     if (ConstantSDNode *RHS = dyn_cast<ConstantSDNode>(N.getOperand(1))) {
 661       int RHSC = (int)RHS->getSExtValue();
 662       if (N.getOpcode() == ISD::SUB)
 663         RHSC = -RHSC;
 664
 665       if ((RHSC >= -255) && (RHSC < 0)) { // 8 bits (always negative)
 666         Base = N.getOperand(0);
 667         if (Base.getOpcode() == ISD::FrameIndex) {
 668           int FI = cast<FrameIndexSDNode>(Base)->getIndex();
 669           Base = CurDAG->getTargetFrameIndex(FI, TLI.getPointerTy());
 670         }
 671         OffImm = CurDAG->getTargetConstant(RHSC, MVT::i32);
 672         return true;
 673       }
 674     }
 675   }
 676
 677   return false;
 678 }
 679
 680 bool ARMDAGToDAGISel::SelectT2AddrModeImm8Offset(SDValue Op, SDValue N,
 681                                                  SDValue &OffImm){
 682   unsigned Opcode = Op.getOpcode();
 683   ISD::MemIndexedMode AM = (Opcode == ISD::LOAD)
 684     ? cast<LoadSDNode>(Op)->getAddressingMode()
 685     : cast<StoreSDNode>(Op)->getAddressingMode();
 686   if (ConstantSDNode *RHS = dyn_cast<ConstantSDNode>(N)) {
 687     int RHSC = (int)RHS->getZExtValue();
 688     if (RHSC >= 0 && RHSC < 0x100) { // 8 bits.
 689       OffImm = ((AM == ISD::PRE_INC) || (AM == ISD::POST_INC))
 690         ? CurDAG->getTargetConstant(RHSC, MVT::i32)
 691         : CurDAG->getTargetConstant(-RHSC, MVT::i32);
 692       return true;
 693     }
 694   }
 695
 696   return false;
 697 }
 698
 699 bool ARMDAGToDAGISel::SelectT2AddrModeImm8s4(SDValue Op, SDValue N,
 700                                              SDValue &Base, SDValue &OffImm) {
 701   if (N.getOpcode() == ISD::ADD) {
 702     if (ConstantSDNode *RHS = dyn_cast<ConstantSDNode>(N.getOperand(1))) {
 703       int RHSC = (int)RHS->getZExtValue();
 704       if (((RHSC & 0x3) == 0) &&
 705           ((RHSC >= 0 && RHSC < 0x400) || (RHSC < 0 && RHSC > -0x400))) { // 8 bits.
 706         Base   = N.getOperand(0);
 707         OffImm = CurDAG->getTargetConstant(RHSC, MVT::i32);
 708         return true;
 709       }
 710     }
 711   } else if (N.getOpcode() == ISD::SUB) {
 712     if (ConstantSDNode *RHS = dyn_cast<ConstantSDNode>(N.getOperand(1))) {
 713       int RHSC = (int)RHS->getZExtValue();
 714       if (((RHSC & 0x3) == 0) && (RHSC >= 0 && RHSC < 0x400)) { // 8 bits.
 715         Base   = N.getOperand(0);
 716         OffImm = CurDAG->getTargetConstant(-RHSC, MVT::i32);
 717         return true;
 718       }
 719     }
 720   }
 721
 722   return false;
 723 }
 724
 725 bool ARMDAGToDAGISel::SelectT2AddrModeSoReg(SDValue Op, SDValue N,
 726                                             SDValue &Base,
 727                                             SDValue &OffReg, SDValue &ShImm) {
 728   // (R - imm8) should be handled by t2LDRi8. The rest are handled by t2LDRi12.
 729   if (N.getOpcode() != ISD::ADD)
 730     return false;
 731
 732   // Leave (R + imm12) for t2LDRi12, (R - imm8) for t2LDRi8.
 733   if (ConstantSDNode *RHS = dyn_cast<ConstantSDNode>(N.getOperand(1))) {
 734     int RHSC = (int)RHS->getZExtValue();
 735     if (RHSC >= 0 && RHSC < 0x1000) // 12 bits (unsigned)
 736       return false;
 737     else if (RHSC < 0 && RHSC >= -255) // 8 bits
 738       return false;
 739   }
 740
 741   // Look for (R + R) or (R + (R << [1,2,3])).
 742   unsigned ShAmt = 0;
 743   Base   = N.getOperand(0);
 744   OffReg = N.getOperand(1);
 745
 746   // Swap if it is ((R << c) + R).
 747   ARM_AM::ShiftOpc ShOpcVal = ARM_AM::getShiftOpcForNode(OffReg);
 748   if (ShOpcVal != ARM_AM::lsl) {
 749     ShOpcVal = ARM_AM::getShiftOpcForNode(Base);
 750     if (ShOpcVal == ARM_AM::lsl)
 751       std::swap(Base, OffReg);
 752   }
 753
 754   if (ShOpcVal == ARM_AM::lsl) {
 755     // Check to see if the RHS of the shift is a constant, if not, we can't fold
 756     // it.
 757     if (ConstantSDNode *Sh = dyn_cast<ConstantSDNode>(OffReg.getOperand(1))) {
 758       ShAmt = Sh->getZExtValue();
 759       if (ShAmt >= 4) {
 760         ShAmt = 0;
 761         ShOpcVal = ARM_AM::no_shift;
 762       } else
 763         OffReg = OffReg.getOperand(0);
 764     } else {
 765       ShOpcVal = ARM_AM::no_shift;
 766     }
 767   }
 768
 769   ShImm = CurDAG->getTargetConstant(ShAmt, MVT::i32);
 770
 771   return true;
 772 }
 773
 774 //===--------------------------------------------------------------------===//
 775
 776 /// getAL - Returns a ARMCC::AL immediate node.
 777 static inline SDValue getAL(SelectionDAG *CurDAG) {
 778   return CurDAG->getTargetConstant((uint64_t)ARMCC::AL, MVT::i32);
 779 }
 780
 781 SDNode *ARMDAGToDAGISel::SelectARMIndexedLoad(SDValue Op) {
 782   LoadSDNode *LD = cast<LoadSDNode>(Op);
 783   ISD::MemIndexedMode AM = LD->getAddressingMode();
 784   if (AM == ISD::UNINDEXED)
 785     return NULL;
 786
 787   EVT LoadedVT = LD->getMemoryVT();
 788   SDValue Offset, AMOpc;
 789   bool isPre = (AM == ISD::PRE_INC) || (AM == ISD::PRE_DEC);
 790   unsigned Opcode = 0;
 791   bool Match = false;
 792   if (LoadedVT == MVT::i32 &&
 793       SelectAddrMode2Offset(Op, LD->getOffset(), Offset, AMOpc)) {
 794     Opcode = isPre ? ARM::LDR_PRE : ARM::LDR_POST;
 795     Match = true;
 796   } else if (LoadedVT == MVT::i16 &&
 797              SelectAddrMode3Offset(Op, LD->getOffset(), Offset, AMOpc)) {
 798     Match = true;
 799     Opcode = (LD->getExtensionType() == ISD::SEXTLOAD)
 800       ? (isPre ? ARM::LDRSH_PRE : ARM::LDRSH_POST)
 801       : (isPre ? ARM::LDRH_PRE : ARM::LDRH_POST);
 802   } else if (LoadedVT == MVT::i8 || LoadedVT == MVT::i1) {
 803     if (LD->getExtensionType() == ISD::SEXTLOAD) {
 804       if (SelectAddrMode3Offset(Op, LD->getOffset(), Offset, AMOpc)) {
 805         Match = true;
 806         Opcode = isPre ? ARM::LDRSB_PRE : ARM::LDRSB_POST;
 807       }
 808     } else {
 809       if (SelectAddrMode2Offset(Op, LD->getOffset(), Offset, AMOpc)) {
 810         Match = true;
 811         Opcode = isPre ? ARM::LDRB_PRE : ARM::LDRB_POST;
 812       }
 813     }
 814   }
 815
 816   if (Match) {
 817     SDValue Chain = LD->getChain();
 818     SDValue Base = LD->getBasePtr();
 819     SDValue Ops[]= { Base, Offset, AMOpc, getAL(CurDAG),
 820                      CurDAG->getRegister(0, MVT::i32), Chain };
 821     return CurDAG->getMachineNode(Opcode, Op.getDebugLoc(), MVT::i32, MVT::i32,
 822                                   MVT::Other, Ops, 6);
 823   }
 824
 825   return NULL;
 826 }
 827
 828 SDNode *ARMDAGToDAGISel::SelectT2IndexedLoad(SDValue Op) {
 829   LoadSDNode *LD = cast<LoadSDNode>(Op);
 830   ISD::MemIndexedMode AM = LD->getAddressingMode();
 831   if (AM == ISD::UNINDEXED)
 832     return NULL;
 833
 834   EVT LoadedVT = LD->getMemoryVT();
 835   bool isSExtLd = LD->getExtensionType() == ISD::SEXTLOAD;
 836   SDValue Offset;
 837   bool isPre = (AM == ISD::PRE_INC) || (AM == ISD::PRE_DEC);
 838   unsigned Opcode = 0;
 839   bool Match = false;
 840   if (SelectT2AddrModeImm8Offset(Op, LD->getOffset(), Offset)) {
 841     switch (LoadedVT.getSimpleVT().SimpleTy) {
 842     case MVT::i32:
 843       Opcode = isPre ? ARM::t2LDR_PRE : ARM::t2LDR_POST;
 844       break;
 845     case MVT::i16:
 846       if (isSExtLd)
 847         Opcode = isPre ? ARM::t2LDRSH_PRE : ARM::t2LDRSH_POST;
 848       else
 849         Opcode = isPre ? ARM::t2LDRH_PRE : ARM::t2LDRH_POST;
 850       break;
 851     case MVT::i8:
 852     case MVT::i1:
 853       if (isSExtLd)
 854         Opcode = isPre ? ARM::t2LDRSB_PRE : ARM::t2LDRSB_POST;
 855       else
 856         Opcode = isPre ? ARM::t2LDRB_PRE : ARM::t2LDRB_POST;
 857       break;
 858     default:
 859       return NULL;
 860     }
 861     Match = true;
 862   }
 863
 864   if (Match) {
 865     SDValue Chain = LD->getChain();
 866     SDValue Base = LD->getBasePtr();
 867     SDValue Ops[]= { Base, Offset, getAL(CurDAG),
 868                      CurDAG->getRegister(0, MVT::i32), Chain };
 869     return CurDAG->getMachineNode(Opcode, Op.getDebugLoc(), MVT::i32, MVT::i32,
 870                                   MVT::Other, Ops, 5);
 871   }
 872
 873   return NULL;
 874 }
 875
 876 SDNode *ARMDAGToDAGISel::SelectDYN_ALLOC(SDValue Op) {
 877   SDNode *N = Op.getNode();
 878   DebugLoc dl = N->getDebugLoc();
 879   EVT VT = Op.getValueType();
 880   SDValue Chain = Op.getOperand(0);
 881   SDValue Size = Op.getOperand(1);
 882   SDValue Align = Op.getOperand(2);
 883   SDValue SP = CurDAG->getRegister(ARM::SP, MVT::i32);
 884   int32_t AlignVal = cast<ConstantSDNode>(Align)->getSExtValue();
 885   if (AlignVal < 0)
 886     // We need to align the stack. Use Thumb1 tAND which is the only thumb
 887     // instruction that can read and write SP. This matches to a pseudo
 888     // instruction that has a chain to ensure the result is written back to
 889     // the stack pointer.
 890     SP = SDValue(CurDAG->getMachineNode(ARM::tANDsp, dl, VT, SP, Align), 0);
 891
 892   bool isC = isa<ConstantSDNode>(Size);
 893   uint32_t C = isC ? cast<ConstantSDNode>(Size)->getZExtValue() : ~0UL;
 894   // Handle the most common case for both Thumb1 and Thumb2:
 895   // tSUBspi - immediate is between 0 ... 508 inclusive.
 896   if (C <= 508 && ((C & 3) == 0))
 897     // FIXME: tSUBspi encode scale 4 implicitly.
 898     return CurDAG->SelectNodeTo(N, ARM::tSUBspi_, VT, MVT::Other, SP,
 899                                 CurDAG->getTargetConstant(C/4, MVT::i32),
 900                                 Chain);
 901
 902   if (Subtarget->isThumb1Only()) {
 903     // Use tADDspr since Thumb1 does not have a sub r, sp, r. ARMISelLowering
 904     // should have negated the size operand already. FIXME: We can't insert
 905     // new target independent node at this stage so we are forced to negate
 906     // it earlier. Is there a better solution?
 907     return CurDAG->SelectNodeTo(N, ARM::tADDspr_, VT, MVT::Other, SP, Size,
 908                                 Chain);
 909   } else if (Subtarget->isThumb2()) {
 910     if (isC && Predicate_t2_so_imm(Size.getNode())) {
 911       // t2SUBrSPi
 912       SDValue Ops[] = { SP, CurDAG->getTargetConstant(C, MVT::i32), Chain };
 913       return CurDAG->SelectNodeTo(N, ARM::t2SUBrSPi_, VT, MVT::Other, Ops, 3);
 914     } else if (isC && Predicate_imm0_4095(Size.getNode())) {
 915       // t2SUBrSPi12
 916       SDValue Ops[] = { SP, CurDAG->getTargetConstant(C, MVT::i32), Chain };
 917       return CurDAG->SelectNodeTo(N, ARM::t2SUBrSPi12_, VT, MVT::Other, Ops, 3);
 918     } else {
 919       // t2SUBrSPs
 920       SDValue Ops[] = { SP, Size,
 921                         getI32Imm(ARM_AM::getSORegOpc(ARM_AM::lsl,0)), Chain };
 922       return CurDAG->SelectNodeTo(N, ARM::t2SUBrSPs_, VT, MVT::Other, Ops, 4);
 923     }
 924   }
 925
 926   // FIXME: Add ADD / SUB sp instructions for ARM.
 927   return 0;
 928 }
 929
 930 /// PairDRegs - Insert a pair of double registers into an implicit def to
 931 /// form a quad register.
 932 SDNode *ARMDAGToDAGISel::PairDRegs(EVT VT, SDValue V0, SDValue V1) {
 933   DebugLoc dl = V0.getNode()->getDebugLoc();
 934   SDValue Undef =
 935     SDValue(CurDAG->getMachineNode(TargetInstrInfo::IMPLICIT_DEF, dl, VT), 0);
 936   SDValue SubReg0 = CurDAG->getTargetConstant(ARM::DSUBREG_0, MVT::i32);
 937   SDValue SubReg1 = CurDAG->getTargetConstant(ARM::DSUBREG_1, MVT::i32);
 938   SDNode *Pair = CurDAG->getMachineNode(TargetInstrInfo::INSERT_SUBREG, dl,
 939                                         VT, Undef, V0, SubReg0);
 940   return CurDAG->getMachineNode(TargetInstrInfo::INSERT_SUBREG, dl,
 941                                 VT, SDValue(Pair, 0), V1, SubReg1);
 942 }
 943
 944 SDNode *ARMDAGToDAGISel::Select(SDValue Op) {
 945   SDNode *N = Op.getNode();
 946   DebugLoc dl = N->getDebugLoc();
 947
 948   if (N->isMachineOpcode())
 949     return NULL;   // Already selected.
 950
 951   switch (N->getOpcode()) {
 952   default: break;
 953   case ISD::Constant: {
 954     unsigned Val = cast<ConstantSDNode>(N)->getZExtValue();
 955     bool UseCP = true;
 956     if (Subtarget->hasThumb2())
 957       // Thumb2-aware targets have the MOVT instruction, so all immediates can
 958       // be done with MOV + MOVT, at worst.
 959       UseCP = 0;
 960     else {
 961       if (Subtarget->isThumb()) {
 962         UseCP = (Val > 255 &&                          // MOV
 963                  ~Val > 255 &&                         // MOV + MVN
 964                  !ARM_AM::isThumbImmShiftedVal(Val));  // MOV + LSL
 965       } else
 966         UseCP = (ARM_AM::getSOImmVal(Val) == -1 &&     // MOV
 967                  ARM_AM::getSOImmVal(~Val) == -1 &&    // MVN
 968                  !ARM_AM::isSOImmTwoPartVal(Val));     // two instrs.
 969     }
 970
 971     if (UseCP) {
 972       SDValue CPIdx =
 973         CurDAG->getTargetConstantPool(ConstantInt::get(
 974                                   Type::getInt32Ty(*CurDAG->getContext()), Val),
 975                                       TLI.getPointerTy());
 976
 977       SDNode *ResNode;
 978       if (Subtarget->isThumb1Only()) {
 979         SDValue Pred = CurDAG->getTargetConstant(0xEULL, MVT::i32);
 980         SDValue PredReg = CurDAG->getRegister(0, MVT::i32);
 981         SDValue Ops[] = { CPIdx, Pred, PredReg, CurDAG->getEntryNode() };
 982         ResNode = CurDAG->getMachineNode(ARM::tLDRcp, dl, MVT::i32, MVT::Other,
 983                                          Ops, 4);
 984       } else {
 985         SDValue Ops[] = {
 986           CPIdx,
 987           CurDAG->getRegister(0, MVT::i32),
 988           CurDAG->getTargetConstant(0, MVT::i32),
 989           getAL(CurDAG),
 990           CurDAG->getRegister(0, MVT::i32),
 991           CurDAG->getEntryNode()
 992         };
 993         ResNode=CurDAG->getMachineNode(ARM::LDRcp, dl, MVT::i32, MVT::Other,
 994                                        Ops, 6);
 995       }
 996       ReplaceUses(Op, SDValue(ResNode, 0));
 997       return NULL;
 998     }
 999
1000     // Other cases are autogenerated.
1001     break;
1002   }
1003   case ISD::FrameIndex: {
1004     // Selects to ADDri FI, 0 which in turn will become ADDri SP, imm.
1005     int FI = cast<FrameIndexSDNode>(N)->getIndex();
1006     SDValue TFI = CurDAG->getTargetFrameIndex(FI, TLI.getPointerTy());
1007     if (Subtarget->isThumb1Only()) {
1008       return CurDAG->SelectNodeTo(N, ARM::tADDrSPi, MVT::i32, TFI,
1009                                   CurDAG->getTargetConstant(0, MVT::i32));
1010     } else {
1011       unsigned Opc = ((Subtarget->isThumb() && Subtarget->hasThumb2()) ?
1012                       ARM::t2ADDri : ARM::ADDri);
1013       SDValue Ops[] = { TFI, CurDAG->getTargetConstant(0, MVT::i32),
1014                         getAL(CurDAG), CurDAG->getRegister(0, MVT::i32),
1015                         CurDAG->getRegister(0, MVT::i32) };
1016       return CurDAG->SelectNodeTo(N, Opc, MVT::i32, Ops, 5);
1017     }
1018   }
1019   case ARMISD::DYN_ALLOC:
1020     return SelectDYN_ALLOC(Op);
1021   case ISD::MUL:
1022     if (Subtarget->isThumb1Only())
1023       break;
1024     if (ConstantSDNode *C = dyn_cast<ConstantSDNode>(Op.getOperand(1))) {
1025       unsigned RHSV = C->getZExtValue();
1026       if (!RHSV) break;
1027       if (isPowerOf2_32(RHSV-1)) {  // 2^n+1?
1028         unsigned ShImm = Log2_32(RHSV-1);
1029         if (ShImm >= 32)
1030           break;
1031         SDValue V = Op.getOperand(0);
1032         ShImm = ARM_AM::getSORegOpc(ARM_AM::lsl, ShImm);
1033         SDValue ShImmOp = CurDAG->getTargetConstant(ShImm, MVT::i32);
1034         SDValue Reg0 = CurDAG->getRegister(0, MVT::i32);
1035         if (Subtarget->isThumb()) {
1036           SDValue Ops[] = { V, V, ShImmOp, getAL(CurDAG), Reg0, Reg0 };
1037           return CurDAG->SelectNodeTo(N, ARM::t2ADDrs, MVT::i32, Ops, 6);
1038         } else {
1039           SDValue Ops[] = { V, V, Reg0, ShImmOp, getAL(CurDAG), Reg0, Reg0 };
1040           return CurDAG->SelectNodeTo(N, ARM::ADDrs, MVT::i32, Ops, 7);
1041         }
1042       }
1043       if (isPowerOf2_32(RHSV+1)) {  // 2^n-1?
1044         unsigned ShImm = Log2_32(RHSV+1);
1045         if (ShImm >= 32)
1046           break;
1047         SDValue V = Op.getOperand(0);
1048         ShImm = ARM_AM::getSORegOpc(ARM_AM::lsl, ShImm);
1049         SDValue ShImmOp = CurDAG->getTargetConstant(ShImm, MVT::i32);
1050         SDValue Reg0 = CurDAG->getRegister(0, MVT::i32);
1051         if (Subtarget->isThumb()) {
1052           SDValue Ops[] = { V, V, ShImmOp, getAL(CurDAG), Reg0 };
1053           return CurDAG->SelectNodeTo(N, ARM::t2RSBrs, MVT::i32, Ops, 5);
1054         } else {
1055           SDValue Ops[] = { V, V, Reg0, ShImmOp, getAL(CurDAG), Reg0, Reg0 };
1056           return CurDAG->SelectNodeTo(N, ARM::RSBrs, MVT::i32, Ops, 7);
1057         }
1058       }
1059     }
1060     break;
1061   case ARMISD::FMRRD:
1062     return CurDAG->getMachineNode(ARM::FMRRD, dl, MVT::i32, MVT::i32,
1063                                   Op.getOperand(0), getAL(CurDAG),
1064                                   CurDAG->getRegister(0, MVT::i32));
1065   case ISD::UMUL_LOHI: {
1066     if (Subtarget->isThumb1Only())
1067       break;
1068     if (Subtarget->isThumb()) {
1069       SDValue Ops[] = { Op.getOperand(0), Op.getOperand(1),
1070                         getAL(CurDAG), CurDAG->getRegister(0, MVT::i32),
1071                         CurDAG->getRegister(0, MVT::i32) };
1072       return CurDAG->getMachineNode(ARM::t2UMULL, dl, MVT::i32, MVT::i32, Ops,4);
1073     } else {
1074       SDValue Ops[] = { Op.getOperand(0), Op.getOperand(1),
1075                         getAL(CurDAG), CurDAG->getRegister(0, MVT::i32),
1076                         CurDAG->getRegister(0, MVT::i32) };
1077       return CurDAG->getMachineNode(ARM::UMULL, dl, MVT::i32, MVT::i32, Ops, 5);
1078     }
1079   }
1080   case ISD::SMUL_LOHI: {
1081     if (Subtarget->isThumb1Only())
1082       break;
1083     if (Subtarget->isThumb()) {
1084       SDValue Ops[] = { Op.getOperand(0), Op.getOperand(1),
1085                         getAL(CurDAG), CurDAG->getRegister(0, MVT::i32) };
1086       return CurDAG->getMachineNode(ARM::t2SMULL, dl, MVT::i32, MVT::i32, Ops,4);
1087     } else {
1088       SDValue Ops[] = { Op.getOperand(0), Op.getOperand(1),
1089                         getAL(CurDAG), CurDAG->getRegister(0, MVT::i32),
1090                         CurDAG->getRegister(0, MVT::i32) };
1091       return CurDAG->getMachineNode(ARM::SMULL, dl, MVT::i32, MVT::i32, Ops, 5);
1092     }
1093   }
1094   case ISD::LOAD: {
1095     SDNode *ResNode = 0;
1096     if (Subtarget->isThumb() && Subtarget->hasThumb2())
1097       ResNode = SelectT2IndexedLoad(Op);
1098     else
1099       ResNode = SelectARMIndexedLoad(Op);
1100     if (ResNode)
1101       return ResNode;
1102     // Other cases are autogenerated.
1103     break;
1104   }
1105   case ARMISD::BRCOND: {
1106     // Pattern: (ARMbrcond:void (bb:Other):$dst, (imm:i32):$cc)
1107     // Emits: (Bcc:void (bb:Other):$dst, (imm:i32):$cc)
1108     // Pattern complexity = 6  cost = 1  size = 0
1109
1110     // Pattern: (ARMbrcond:void (bb:Other):$dst, (imm:i32):$cc)
1111     // Emits: (tBcc:void (bb:Other):$dst, (imm:i32):$cc)
1112     // Pattern complexity = 6  cost = 1  size = 0
1113
1114     // Pattern: (ARMbrcond:void (bb:Other):$dst, (imm:i32):$cc)
1115     // Emits: (t2Bcc:void (bb:Other):$dst, (imm:i32):$cc)
1116     // Pattern complexity = 6  cost = 1  size = 0
1117
1118     unsigned Opc = Subtarget->isThumb() ?
1119       ((Subtarget->hasThumb2()) ? ARM::t2Bcc : ARM::tBcc) : ARM::Bcc;
1120     SDValue Chain = Op.getOperand(0);
1121     SDValue N1 = Op.getOperand(1);
1122     SDValue N2 = Op.getOperand(2);
1123     SDValue N3 = Op.getOperand(3);
1124     SDValue InFlag = Op.getOperand(4);
1125     assert(N1.getOpcode() == ISD::BasicBlock);
1126     assert(N2.getOpcode() == ISD::Constant);
1127     assert(N3.getOpcode() == ISD::Register);
1128
1129     SDValue Tmp2 = CurDAG->getTargetConstant(((unsigned)
1130                                cast<ConstantSDNode>(N2)->getZExtValue()),
1131                                MVT::i32);
1132     SDValue Ops[] = { N1, Tmp2, N3, Chain, InFlag };
1133     SDNode *ResNode = CurDAG->getMachineNode(Opc, dl, MVT::Other,
1134                                              MVT::Flag, Ops, 5);
1135     Chain = SDValue(ResNode, 0);
1136     if (Op.getNode()->getNumValues() == 2) {
1137       InFlag = SDValue(ResNode, 1);
1138       ReplaceUses(SDValue(Op.getNode(), 1), InFlag);
1139     }
1140     ReplaceUses(SDValue(Op.getNode(), 0), SDValue(Chain.getNode(), Chain.getResNo()));
1141     return NULL;
1142   }
1143   case ARMISD::CMOV: {
1144     EVT VT = Op.getValueType();
1145     SDValue N0 = Op.getOperand(0);
1146     SDValue N1 = Op.getOperand(1);
1147     SDValue N2 = Op.getOperand(2);
1148     SDValue N3 = Op.getOperand(3);
1149     SDValue InFlag = Op.getOperand(4);
1150     assert(N2.getOpcode() == ISD::Constant);
1151     assert(N3.getOpcode() == ISD::Register);
1152
1153     if (!Subtarget->isThumb1Only() && VT == MVT::i32) {
1154       // Pattern: (ARMcmov:i32 GPR:i32:$false, so_reg:i32:$true, (imm:i32):$cc)
1155       // Emits: (MOVCCs:i32 GPR:i32:$false, so_reg:i32:$true, (imm:i32):$cc)
1156       // Pattern complexity = 18  cost = 1  size = 0
1157       SDValue CPTmp0;
1158       SDValue CPTmp1;
1159       SDValue CPTmp2;
1160       if (Subtarget->isThumb()) {
1161         if (SelectT2ShifterOperandReg(Op, N1, CPTmp0, CPTmp1)) {
1162           unsigned SOVal = cast<ConstantSDNode>(CPTmp1)->getZExtValue();
1163           unsigned SOShOp = ARM_AM::getSORegShOp(SOVal);
1164           unsigned Opc = 0;
1165           switch (SOShOp) {
1166           case ARM_AM::lsl: Opc = ARM::t2MOVCClsl; break;
1167           case ARM_AM::lsr: Opc = ARM::t2MOVCClsr; break;
1168           case ARM_AM::asr: Opc = ARM::t2MOVCCasr; break;
1169           case ARM_AM::ror: Opc = ARM::t2MOVCCror; break;
1170           default:
1171             llvm_unreachable("Unknown so_reg opcode!");
1172             break;
1173           }
1174           SDValue SOShImm =
1175             CurDAG->getTargetConstant(ARM_AM::getSORegOffset(SOVal), MVT::i32);
1176           SDValue Tmp2 = CurDAG->getTargetConstant(((unsigned)
1177                                    cast<ConstantSDNode>(N2)->getZExtValue()),
1178                                    MVT::i32);
1179           SDValue Ops[] = { N0, CPTmp0, SOShImm, Tmp2, N3, InFlag };
1180           return CurDAG->SelectNodeTo(Op.getNode(), Opc, MVT::i32,Ops, 6);
1181         }
1182       } else {
1183         if (SelectShifterOperandReg(Op, N1, CPTmp0, CPTmp1, CPTmp2)) {
1184           SDValue Tmp2 = CurDAG->getTargetConstant(((unsigned)
1185                                    cast<ConstantSDNode>(N2)->getZExtValue()),
1186                                    MVT::i32);
1187           SDValue Ops[] = { N0, CPTmp0, CPTmp1, CPTmp2, Tmp2, N3, InFlag };
1188           return CurDAG->SelectNodeTo(Op.getNode(),
1189                                       ARM::MOVCCs, MVT::i32, Ops, 7);
1190         }
1191       }
1192
1193       // Pattern: (ARMcmov:i32 GPR:i32:$false,
1194       //             (imm:i32)<<P:Predicate_so_imm>>:$true,
1195       //             (imm:i32):$cc)
1196       // Emits: (MOVCCi:i32 GPR:i32:$false,
1197       //           (so_imm:i32 (imm:i32):$true), (imm:i32):$cc)
1198       // Pattern complexity = 10  cost = 1  size = 0
1199       if (N3.getOpcode() == ISD::Constant) {
1200         if (Subtarget->isThumb()) {
1201           if (Predicate_t2_so_imm(N3.getNode())) {
1202             SDValue Tmp1 = CurDAG->getTargetConstant(((unsigned)
1203                                      cast<ConstantSDNode>(N1)->getZExtValue()),
1204                                      MVT::i32);
1205             SDValue Tmp2 = CurDAG->getTargetConstant(((unsigned)
1206                                      cast<ConstantSDNode>(N2)->getZExtValue()),
1207                                      MVT::i32);
1208             SDValue Ops[] = { N0, Tmp1, Tmp2, N3, InFlag };
1209             return CurDAG->SelectNodeTo(Op.getNode(),
1210                                         ARM::t2MOVCCi, MVT::i32, Ops, 5);
1211           }
1212         } else {
1213           if (Predicate_so_imm(N3.getNode())) {
1214             SDValue Tmp1 = CurDAG->getTargetConstant(((unsigned)
1215                                      cast<ConstantSDNode>(N1)->getZExtValue()),
1216                                      MVT::i32);
1217             SDValue Tmp2 = CurDAG->getTargetConstant(((unsigned)
1218                                      cast<ConstantSDNode>(N2)->getZExtValue()),
1219                                      MVT::i32);
1220             SDValue Ops[] = { N0, Tmp1, Tmp2, N3, InFlag };
1221             return CurDAG->SelectNodeTo(Op.getNode(),
1222                                         ARM::MOVCCi, MVT::i32, Ops, 5);
1223           }
1224         }
1225       }
1226     }
1227
1228     // Pattern: (ARMcmov:i32 GPR:i32:$false, GPR:i32:$true, (imm:i32):$cc)
1229     // Emits: (MOVCCr:i32 GPR:i32:$false, GPR:i32:$true, (imm:i32):$cc)
1230     // Pattern complexity = 6  cost = 1  size = 0
1231     //
1232     // Pattern: (ARMcmov:i32 GPR:i32:$false, GPR:i32:$true, (imm:i32):$cc)
1233     // Emits: (tMOVCCr:i32 GPR:i32:$false, GPR:i32:$true, (imm:i32):$cc)
1234     // Pattern complexity = 6  cost = 11  size = 0
1235     //
1236     // Also FCPYScc and FCPYDcc.
1237     SDValue Tmp2 = CurDAG->getTargetConstant(((unsigned)
1238                                cast<ConstantSDNode>(N2)->getZExtValue()),
1239                                MVT::i32);
1240     SDValue Ops[] = { N0, N1, Tmp2, N3, InFlag };
1241     unsigned Opc = 0;
1242     switch (VT.getSimpleVT().SimpleTy) {
1243     default: assert(false && "Illegal conditional move type!");
1244       break;
1245     case MVT::i32:
1246       Opc = Subtarget->isThumb()
1247         ? (Subtarget->hasThumb2() ? ARM::t2MOVCCr : ARM::tMOVCCr_pseudo)
1248         : ARM::MOVCCr;
1249       break;
1250     case MVT::f32:
1251       Opc = ARM::FCPYScc;
1252       break;
1253     case MVT::f64:
1254       Opc = ARM::FCPYDcc;
1255       break;
1256     }
1257     return CurDAG->SelectNodeTo(Op.getNode(), Opc, VT, Ops, 5);
1258   }
1259   case ARMISD::CNEG: {
1260     EVT VT = Op.getValueType();
1261     SDValue N0 = Op.getOperand(0);
1262     SDValue N1 = Op.getOperand(1);
1263     SDValue N2 = Op.getOperand(2);
1264     SDValue N3 = Op.getOperand(3);
1265     SDValue InFlag = Op.getOperand(4);
1266     assert(N2.getOpcode() == ISD::Constant);
1267     assert(N3.getOpcode() == ISD::Register);
1268
1269     SDValue Tmp2 = CurDAG->getTargetConstant(((unsigned)
1270                                cast<ConstantSDNode>(N2)->getZExtValue()),
1271                                MVT::i32);
1272     SDValue Ops[] = { N0, N1, Tmp2, N3, InFlag };
1273     unsigned Opc = 0;
1274     switch (VT.getSimpleVT().SimpleTy) {
1275     default: assert(false && "Illegal conditional move type!");
1276       break;
1277     case MVT::f32:
1278       Opc = ARM::FNEGScc;
1279       break;
1280     case MVT::f64:
1281       Opc = ARM::FNEGDcc;
1282       break;
1283     }
1284     return CurDAG->SelectNodeTo(Op.getNode(), Opc, VT, Ops, 5);
1285   }
1286
1287   case ARMISD::VZIP: {
1288     unsigned Opc = 0;
1289     EVT VT = N->getValueType(0);
1290     switch (VT.getSimpleVT().SimpleTy) {
1291     default: return NULL;
1292     case MVT::v8i8:  Opc = ARM::VZIPd8; break;
1293     case MVT::v4i16: Opc = ARM::VZIPd16; break;
1294     case MVT::v2f32:
1295     case MVT::v2i32: Opc = ARM::VZIPd32; break;
1296     case MVT::v16i8: Opc = ARM::VZIPq8; break;
1297     case MVT::v8i16: Opc = ARM::VZIPq16; break;
1298     case MVT::v4f32:
1299     case MVT::v4i32: Opc = ARM::VZIPq32; break;
1300     }
1301     return CurDAG->getMachineNode(Opc, dl, VT, VT,
1302                                   N->getOperand(0), N->getOperand(1));
1303   }
1304   case ARMISD::VUZP: {
1305     unsigned Opc = 0;
1306     EVT VT = N->getValueType(0);
1307     switch (VT.getSimpleVT().SimpleTy) {
1308     default: return NULL;
1309     case MVT::v8i8:  Opc = ARM::VUZPd8; break;
1310     case MVT::v4i16: Opc = ARM::VUZPd16; break;
1311     case MVT::v2f32:
1312     case MVT::v2i32: Opc = ARM::VUZPd32; break;
1313     case MVT::v16i8: Opc = ARM::VUZPq8; break;
1314     case MVT::v8i16: Opc = ARM::VUZPq16; break;
1315     case MVT::v4f32:
1316     case MVT::v4i32: Opc = ARM::VUZPq32; break;
1317     }
1318     return CurDAG->getMachineNode(Opc, dl, VT, VT,
1319                                   N->getOperand(0), N->getOperand(1));
1320   }
1321   case ARMISD::VTRN: {
1322     unsigned Opc = 0;
1323     EVT VT = N->getValueType(0);
1324     switch (VT.getSimpleVT().SimpleTy) {
1325     default: return NULL;
1326     case MVT::v8i8:  Opc = ARM::VTRNd8; break;
1327     case MVT::v4i16: Opc = ARM::VTRNd16; break;
1328     case MVT::v2f32:
1329     case MVT::v2i32: Opc = ARM::VTRNd32; break;
1330     case MVT::v16i8: Opc = ARM::VTRNq8; break;
1331     case MVT::v8i16: Opc = ARM::VTRNq16; break;
1332     case MVT::v4f32:
1333     case MVT::v4i32: Opc = ARM::VTRNq32; break;
1334     }
1335     return CurDAG->getMachineNode(Opc, dl, VT, VT,
1336                                   N->getOperand(0), N->getOperand(1));
1337   }
1338
1339   case ISD::INTRINSIC_VOID:
1340   case ISD::INTRINSIC_W_CHAIN: {
1341     unsigned IntNo = cast<ConstantSDNode>(N->getOperand(1))->getZExtValue();
1342     EVT VT = N->getValueType(0);
1343     unsigned Opc = 0;
1344
1345     switch (IntNo) {
1346     default:
1347       break;
1348
1349     case Intrinsic::arm_neon_vld2: {
1350       SDValue MemAddr, MemUpdate, MemOpc;
1351       if (!SelectAddrMode6(Op, N->getOperand(2), MemAddr, MemUpdate, MemOpc))
1352         return NULL;
1353       if (VT.is64BitVector()) {
1354         switch (VT.getSimpleVT().SimpleTy) {
1355         default: llvm_unreachable("unhandled vld2 type");
1356         case MVT::v8i8:  Opc = ARM::VLD2d8; break;
1357         case MVT::v4i16: Opc = ARM::VLD2d16; break;
1358         case MVT::v2f32:
1359         case MVT::v2i32: Opc = ARM::VLD2d32; break;
1360         }
1361         SDValue Chain = N->getOperand(0);
1362         const SDValue Ops[] = { MemAddr, MemUpdate, MemOpc, Chain };
1363         return CurDAG->getMachineNode(Opc, dl, VT, VT, MVT::Other, Ops, 4);
1364       }
1365       // Quad registers are loaded as pairs of double registers.
1366       EVT RegVT;
1367       switch (VT.getSimpleVT().SimpleTy) {
1368       default: llvm_unreachable("unhandled vld2 type");
1369       case MVT::v16i8: Opc = ARM::VLD2q8; RegVT = MVT::v8i8; break;
1370       case MVT::v8i16: Opc = ARM::VLD2q16; RegVT = MVT::v4i16; break;
1371       case MVT::v4f32: Opc = ARM::VLD2q32; RegVT = MVT::v2f32; break;
1372       case MVT::v4i32: Opc = ARM::VLD2q32; RegVT = MVT::v2i32; break;
1373       }
1374       SDValue Chain = N->getOperand(0);
1375       const SDValue Ops[] = { MemAddr, MemUpdate, MemOpc, Chain };
1376       std::vector<EVT> ResTys(4, RegVT);
1377       ResTys.push_back(MVT::Other);
1378       SDNode *VLd = CurDAG->getMachineNode(Opc, dl, ResTys, Ops, 4);
1379       SDNode *Q0 = PairDRegs(VT, SDValue(VLd, 0), SDValue(VLd, 1));
1380       SDNode *Q1 = PairDRegs(VT, SDValue(VLd, 2), SDValue(VLd, 3));
1381       ReplaceUses(SDValue(N, 0), SDValue(Q0, 0));
1382       ReplaceUses(SDValue(N, 1), SDValue(Q1, 0));
1383       ReplaceUses(SDValue(N, 2), SDValue(VLd, 4));
1384       return NULL;
1385     }
1386
1387     case Intrinsic::arm_neon_vld3: {
1388       SDValue MemAddr, MemUpdate, MemOpc;
1389       if (!SelectAddrMode6(Op, N->getOperand(2), MemAddr, MemUpdate, MemOpc))
1390         return NULL;
1391       if (VT.is64BitVector()) {
1392         switch (VT.getSimpleVT().SimpleTy) {
1393         default: llvm_unreachable("unhandled vld3 type");
1394         case MVT::v8i8:  Opc = ARM::VLD3d8; break;
1395         case MVT::v4i16: Opc = ARM::VLD3d16; break;
1396         case MVT::v2f32:
1397         case MVT::v2i32: Opc = ARM::VLD3d32; break;
1398         }
1399         SDValue Chain = N->getOperand(0);
1400         const SDValue Ops[] = { MemAddr, MemUpdate, MemOpc, Chain };
1401         return CurDAG->getMachineNode(Opc, dl, VT, VT, VT, MVT::Other, Ops, 4);
1402       }
1403       // Quad registers are loaded with two separate instructions, where one
1404       // loads the even registers and the other loads the odd registers.
1405       EVT RegVT = VT;
1406       unsigned Opc2 = 0;
1407       switch (VT.getSimpleVT().SimpleTy) {
1408       default: llvm_unreachable("unhandled vld3 type");
1409       case MVT::v16i8:
1410         Opc = ARM::VLD3q8a;  Opc2 = ARM::VLD3q8b;  RegVT = MVT::v8i8; break;
1411       case MVT::v8i16:
1412         Opc = ARM::VLD3q16a; Opc2 = ARM::VLD3q16b; RegVT = MVT::v4i16; break;
1413       case MVT::v4f32:
1414         Opc = ARM::VLD3q32a; Opc2 = ARM::VLD3q32b; RegVT = MVT::v2f32; break;
1415       case MVT::v4i32:
1416         Opc = ARM::VLD3q32a; Opc2 = ARM::VLD3q32b; RegVT = MVT::v2i32; break;
1417       }
1418       SDValue Chain = N->getOperand(0);
1419       // Enable writeback to the address register.
1420       MemOpc = CurDAG->getTargetConstant(ARM_AM::getAM6Opc(true), MVT::i32);
1421
1422       std::vector<EVT> ResTys(3, RegVT);
1423       ResTys.push_back(MemAddr.getValueType());
1424       ResTys.push_back(MVT::Other);
1425
1426       const SDValue OpsA[] = { MemAddr, MemUpdate, MemOpc, Chain };
1427       SDNode *VLdA = CurDAG->getMachineNode(Opc, dl, ResTys, OpsA, 4);
1428       Chain = SDValue(VLdA, 4);
1429
1430       const SDValue OpsB[] = { SDValue(VLdA, 3), MemUpdate, MemOpc, Chain };
1431       SDNode *VLdB = CurDAG->getMachineNode(Opc2, dl, ResTys, OpsB, 4);
1432       Chain = SDValue(VLdB, 4);
1433
1434       SDNode *Q0 = PairDRegs(VT, SDValue(VLdA, 0), SDValue(VLdB, 0));
1435       SDNode *Q1 = PairDRegs(VT, SDValue(VLdA, 1), SDValue(VLdB, 1));
1436       SDNode *Q2 = PairDRegs(VT, SDValue(VLdA, 2), SDValue(VLdB, 2));
1437       ReplaceUses(SDValue(N, 0), SDValue(Q0, 0));
1438       ReplaceUses(SDValue(N, 1), SDValue(Q1, 0));
1439       ReplaceUses(SDValue(N, 2), SDValue(Q2, 0));
1440       ReplaceUses(SDValue(N, 3), Chain);
1441       return NULL;
1442     }
1443
1444     case Intrinsic::arm_neon_vld4: {
1445       SDValue MemAddr, MemUpdate, MemOpc;
1446       if (!SelectAddrMode6(Op, N->getOperand(2), MemAddr, MemUpdate, MemOpc))
1447         return NULL;
1448       if (VT.is64BitVector()) {
1449         switch (VT.getSimpleVT().SimpleTy) {
1450         default: llvm_unreachable("unhandled vld4 type");
1451         case MVT::v8i8:  Opc = ARM::VLD4d8; break;
1452         case MVT::v4i16: Opc = ARM::VLD4d16; break;
1453         case MVT::v2f32:
1454         case MVT::v2i32: Opc = ARM::VLD4d32; break;
1455         }
1456         SDValue Chain = N->getOperand(0);
1457         const SDValue Ops[] = { MemAddr, MemUpdate, MemOpc, Chain };
1458         std::vector<EVT> ResTys(4, VT);
1459         ResTys.push_back(MVT::Other);
1460         return CurDAG->getMachineNode(Opc, dl, ResTys, Ops, 4);
1461       }
1462       // Quad registers are loaded with two separate instructions, where one
1463       // loads the even registers and the other loads the odd registers.
1464       EVT RegVT = VT;
1465       unsigned Opc2 = 0;
1466       switch (VT.getSimpleVT().SimpleTy) {
1467       default: llvm_unreachable("unhandled vld4 type");
1468       case MVT::v16i8:
1469         Opc = ARM::VLD4q8a;  Opc2 = ARM::VLD4q8b;  RegVT = MVT::v8i8; break;
1470       case MVT::v8i16:
1471         Opc = ARM::VLD4q16a; Opc2 = ARM::VLD4q16b; RegVT = MVT::v4i16; break;
1472       case MVT::v4f32:
1473         Opc = ARM::VLD4q32a; Opc2 = ARM::VLD4q32b; RegVT = MVT::v2f32; break;
1474       case MVT::v4i32:
1475         Opc = ARM::VLD4q32a; Opc2 = ARM::VLD4q32b; RegVT = MVT::v2i32; break;
1476       }
1477       SDValue Chain = N->getOperand(0);
1478       // Enable writeback to the address register.
1479       MemOpc = CurDAG->getTargetConstant(ARM_AM::getAM6Opc(true), MVT::i32);
1480
1481       std::vector<EVT> ResTys(4, RegVT);
1482       ResTys.push_back(MemAddr.getValueType());
1483       ResTys.push_back(MVT::Other);
1484
1485       const SDValue OpsA[] = { MemAddr, MemUpdate, MemOpc, Chain };
1486       SDNode *VLdA = CurDAG->getMachineNode(Opc, dl, ResTys, OpsA, 4);
1487       Chain = SDValue(VLdA, 5);
1488
1489       const SDValue OpsB[] = { SDValue(VLdA, 4), MemUpdate, MemOpc, Chain };
1490       SDNode *VLdB = CurDAG->getMachineNode(Opc2, dl, ResTys, OpsB, 4);
1491       Chain = SDValue(VLdB, 5);
1492
1493       SDNode *Q0 = PairDRegs(VT, SDValue(VLdA, 0), SDValue(VLdB, 0));
1494       SDNode *Q1 = PairDRegs(VT, SDValue(VLdA, 1), SDValue(VLdB, 1));
1495       SDNode *Q2 = PairDRegs(VT, SDValue(VLdA, 2), SDValue(VLdB, 2));
1496       SDNode *Q3 = PairDRegs(VT, SDValue(VLdA, 3), SDValue(VLdB, 3));
1497       ReplaceUses(SDValue(N, 0), SDValue(Q0, 0));
1498       ReplaceUses(SDValue(N, 1), SDValue(Q1, 0));
1499       ReplaceUses(SDValue(N, 2), SDValue(Q2, 0));
1500       ReplaceUses(SDValue(N, 3), SDValue(Q3, 0));
1501       ReplaceUses(SDValue(N, 4), Chain);
1502       return NULL;
1503     }
1504
1505     case Intrinsic::arm_neon_vld2lane: {
1506       SDValue MemAddr, MemUpdate, MemOpc;
1507       if (!SelectAddrMode6(Op, N->getOperand(2), MemAddr, MemUpdate, MemOpc))
1508         return NULL;
1509       switch (VT.getSimpleVT().SimpleTy) {
1510       default: llvm_unreachable("unhandled vld2lane type");
1511       case MVT::v8i8:  Opc = ARM::VLD2LNd8; break;
1512       case MVT::v4i16: Opc = ARM::VLD2LNd16; break;
1513       case MVT::v2f32:
1514       case MVT::v2i32: Opc = ARM::VLD2LNd32; break;
1515       }
1516       SDValue Chain = N->getOperand(0);
1517       const SDValue Ops[] = { MemAddr, MemUpdate, MemOpc,
1518                               N->getOperand(3), N->getOperand(4),
1519                               N->getOperand(5), Chain };
1520       return CurDAG->getMachineNode(Opc, dl, VT, VT, MVT::Other, Ops, 7);
1521     }
1522
1523     case Intrinsic::arm_neon_vld3lane: {
1524       SDValue MemAddr, MemUpdate, MemOpc;
1525       if (!SelectAddrMode6(Op, N->getOperand(2), MemAddr, MemUpdate, MemOpc))
1526         return NULL;
1527       switch (VT.getSimpleVT().SimpleTy) {
1528       default: llvm_unreachable("unhandled vld3lane type");
1529       case MVT::v8i8:  Opc = ARM::VLD3LNd8; break;
1530       case MVT::v4i16: Opc = ARM::VLD3LNd16; break;
1531       case MVT::v2f32:
1532       case MVT::v2i32: Opc = ARM::VLD3LNd32; break;
1533       }
1534       SDValue Chain = N->getOperand(0);
1535       const SDValue Ops[] = { MemAddr, MemUpdate, MemOpc,
1536                               N->getOperand(3), N->getOperand(4),
1537                               N->getOperand(5), N->getOperand(6), Chain };
1538       return CurDAG->getMachineNode(Opc, dl, VT, VT, VT, MVT::Other, Ops, 8);
1539     }
1540
1541     case Intrinsic::arm_neon_vld4lane: {
1542       SDValue MemAddr, MemUpdate, MemOpc;
1543       if (!SelectAddrMode6(Op, N->getOperand(2), MemAddr, MemUpdate, MemOpc))
1544         return NULL;
1545       switch (VT.getSimpleVT().SimpleTy) {
1546       default: llvm_unreachable("unhandled vld4lane type");
1547       case MVT::v8i8:  Opc = ARM::VLD4LNd8; break;
1548       case MVT::v4i16: Opc = ARM::VLD4LNd16; break;
1549       case MVT::v2f32:
1550       case MVT::v2i32: Opc = ARM::VLD4LNd32; break;
1551       }
1552       SDValue Chain = N->getOperand(0);
1553       const SDValue Ops[] = { MemAddr, MemUpdate, MemOpc,
1554                               N->getOperand(3), N->getOperand(4),
1555                               N->getOperand(5), N->getOperand(6),
1556                               N->getOperand(7), Chain };
1557       std::vector<EVT> ResTys(4, VT);
1558       ResTys.push_back(MVT::Other);
1559       return CurDAG->getMachineNode(Opc, dl, ResTys, Ops, 9);
1560     }
1561
1562     case Intrinsic::arm_neon_vst2: {
1563       SDValue MemAddr, MemUpdate, MemOpc;
1564       if (!SelectAddrMode6(Op, N->getOperand(2), MemAddr, MemUpdate, MemOpc))
1565         return NULL;
1566       VT = N->getOperand(3).getValueType();
1567       if (VT.is64BitVector()) {
1568         switch (VT.getSimpleVT().SimpleTy) {
1569         default: llvm_unreachable("unhandled vst2 type");
1570         case MVT::v8i8:  Opc = ARM::VST2d8; break;
1571         case MVT::v4i16: Opc = ARM::VST2d16; break;
1572         case MVT::v2f32:
1573         case MVT::v2i32: Opc = ARM::VST2d32; break;
1574         }
1575         SDValue Chain = N->getOperand(0);
1576         const SDValue Ops[] = { MemAddr, MemUpdate, MemOpc,
1577                                 N->getOperand(3), N->getOperand(4), Chain };
1578         return CurDAG->getMachineNode(Opc, dl, MVT::Other, Ops, 6);
1579       }
1580       // Quad registers are stored as pairs of double registers.
1581       EVT RegVT;
1582       switch (VT.getSimpleVT().SimpleTy) {
1583       default: llvm_unreachable("unhandled vst2 type");
1584       case MVT::v16i8: Opc = ARM::VST2q8; RegVT = MVT::v8i8; break;
1585       case MVT::v8i16: Opc = ARM::VST2q16; RegVT = MVT::v4i16; break;
1586       case MVT::v4f32: Opc = ARM::VST2q32; RegVT = MVT::v2f32; break;
1587       case MVT::v4i32: Opc = ARM::VST2q32; RegVT = MVT::v2i32; break;
1588       }
1589       SDValue Chain = N->getOperand(0);
1590       SDValue D0 = CurDAG->getTargetExtractSubreg(ARM::DSUBREG_0, dl, RegVT,
1591                                                   N->getOperand(3));
1592       SDValue D1 = CurDAG->getTargetExtractSubreg(ARM::DSUBREG_1, dl, RegVT,
1593                                                   N->getOperand(3));
1594       SDValue D2 = CurDAG->getTargetExtractSubreg(ARM::DSUBREG_0, dl, RegVT,
1595                                                   N->getOperand(4));
1596       SDValue D3 = CurDAG->getTargetExtractSubreg(ARM::DSUBREG_1, dl, RegVT,
1597                                                   N->getOperand(4));
1598       const SDValue Ops[] = { MemAddr, MemUpdate, MemOpc,
1599                               D0, D1, D2, D3, Chain };
1600       return CurDAG->getMachineNode(Opc, dl, MVT::Other, Ops, 8);
1601     }
1602
1603     case Intrinsic::arm_neon_vst3: {
1604       SDValue MemAddr, MemUpdate, MemOpc;
1605       if (!SelectAddrMode6(Op, N->getOperand(2), MemAddr, MemUpdate, MemOpc))
1606         return NULL;
1607       VT = N->getOperand(3).getValueType();
1608       if (VT.is64BitVector()) {
1609         switch (VT.getSimpleVT().SimpleTy) {
1610         default: llvm_unreachable("unhandled vst3 type");
1611         case MVT::v8i8:  Opc = ARM::VST3d8; break;
1612         case MVT::v4i16: Opc = ARM::VST3d16; break;
1613         case MVT::v2f32:
1614         case MVT::v2i32: Opc = ARM::VST3d32; break;
1615         }
1616         SDValue Chain = N->getOperand(0);
1617         const SDValue Ops[] = { MemAddr, MemUpdate, MemOpc,
1618                                 N->getOperand(3), N->getOperand(4),
1619                                 N->getOperand(5), Chain };
1620         return CurDAG->getMachineNode(Opc, dl, MVT::Other, Ops, 7);
1621       }
1622       // Quad registers are stored with two separate instructions, where one
1623       // stores the even registers and the other stores the odd registers.
1624       EVT RegVT;
1625       unsigned Opc2 = 0;
1626       switch (VT.getSimpleVT().SimpleTy) {
1627       default: llvm_unreachable("unhandled vst3 type");
1628       case MVT::v16i8:
1629         Opc = ARM::VST3q8a;  Opc2 = ARM::VST3q8b;  RegVT = MVT::v8i8; break;
1630       case MVT::v8i16:
1631         Opc = ARM::VST3q16a; Opc2 = ARM::VST3q16b; RegVT = MVT::v4i16; break;
1632       case MVT::v4f32:
1633         Opc = ARM::VST3q32a; Opc2 = ARM::VST3q32b; RegVT = MVT::v2f32; break;
1634       case MVT::v4i32:
1635         Opc = ARM::VST3q32a; Opc2 = ARM::VST3q32b; RegVT = MVT::v2i32; break;
1636       }
1637       SDValue Chain = N->getOperand(0);
1638       // Enable writeback to the address register.
1639       MemOpc = CurDAG->getTargetConstant(ARM_AM::getAM6Opc(true), MVT::i32);
1640
1641       SDValue D0 = CurDAG->getTargetExtractSubreg(ARM::DSUBREG_0, dl, RegVT,
1642                                                   N->getOperand(3));
1643       SDValue D2 = CurDAG->getTargetExtractSubreg(ARM::DSUBREG_0, dl, RegVT,
1644                                                   N->getOperand(4));
1645       SDValue D4 = CurDAG->getTargetExtractSubreg(ARM::DSUBREG_0, dl, RegVT,
1646                                                   N->getOperand(5));
1647       const SDValue OpsA[] = { MemAddr, MemUpdate, MemOpc, D0, D2, D4, Chain };
1648       SDNode *VStA = CurDAG->getMachineNode(Opc, dl, MemAddr.getValueType(),
1649                                             MVT::Other, OpsA, 7);
1650       Chain = SDValue(VStA, 1);
1651
1652       SDValue D1 = CurDAG->getTargetExtractSubreg(ARM::DSUBREG_1, dl, RegVT,
1653                                                   N->getOperand(3));
1654       SDValue D3 = CurDAG->getTargetExtractSubreg(ARM::DSUBREG_1, dl, RegVT,
1655                                                   N->getOperand(4));
1656       SDValue D5 = CurDAG->getTargetExtractSubreg(ARM::DSUBREG_1, dl, RegVT,
1657                                                   N->getOperand(5));
1658       MemAddr = SDValue(VStA, 0);
1659       const SDValue OpsB[] = { MemAddr, MemUpdate, MemOpc, D1, D3, D5, Chain };
1660       SDNode *VStB = CurDAG->getMachineNode(Opc2, dl, MemAddr.getValueType(),
1661                                             MVT::Other, OpsB, 7);
1662       Chain = SDValue(VStB, 1);
1663       ReplaceUses(SDValue(N, 0), Chain);
1664       return NULL;
1665     }
1666
1667     case Intrinsic::arm_neon_vst4: {
1668       SDValue MemAddr, MemUpdate, MemOpc;
1669       if (!SelectAddrMode6(Op, N->getOperand(2), MemAddr, MemUpdate, MemOpc))
1670         return NULL;
1671       VT = N->getOperand(3).getValueType();
1672       if (VT.is64BitVector()) {
1673         switch (VT.getSimpleVT().SimpleTy) {
1674         default: llvm_unreachable("unhandled vst4 type");
1675         case MVT::v8i8:  Opc = ARM::VST4d8; break;
1676         case MVT::v4i16: Opc = ARM::VST4d16; break;
1677         case MVT::v2f32:
1678         case MVT::v2i32: Opc = ARM::VST4d32; break;
1679         }
1680         SDValue Chain = N->getOperand(0);
1681         const SDValue Ops[] = { MemAddr, MemUpdate, MemOpc,
1682                                 N->getOperand(3), N->getOperand(4),
1683                                 N->getOperand(5), N->getOperand(6), Chain };
1684         return CurDAG->getMachineNode(Opc, dl, MVT::Other, Ops, 8);
1685       }
1686       // Quad registers are stored with two separate instructions, where one
1687       // stores the even registers and the other stores the odd registers.
1688       EVT RegVT;
1689       unsigned Opc2 = 0;
1690       switch (VT.getSimpleVT().SimpleTy) {
1691       default: llvm_unreachable("unhandled vst4 type");
1692       case MVT::v16i8:
1693         Opc = ARM::VST4q8a;  Opc2 = ARM::VST4q8b;  RegVT = MVT::v8i8; break;
1694       case MVT::v8i16:
1695         Opc = ARM::VST4q16a; Opc2 = ARM::VST4q16b; RegVT = MVT::v4i16; break;
1696       case MVT::v4f32:
1697         Opc = ARM::VST4q32a; Opc2 = ARM::VST4q32b; RegVT = MVT::v2f32; break;
1698       case MVT::v4i32:
1699         Opc = ARM::VST4q32a; Opc2 = ARM::VST4q32b; RegVT = MVT::v2i32; break;
1700       }
1701       SDValue Chain = N->getOperand(0);
1702       // Enable writeback to the address register.
1703       MemOpc = CurDAG->getTargetConstant(ARM_AM::getAM6Opc(true), MVT::i32);
1704
1705       SDValue D0 = CurDAG->getTargetExtractSubreg(ARM::DSUBREG_0, dl, RegVT,
1706                                                   N->getOperand(3));
1707       SDValue D2 = CurDAG->getTargetExtractSubreg(ARM::DSUBREG_0, dl, RegVT,
1708                                                   N->getOperand(4));
1709       SDValue D4 = CurDAG->getTargetExtractSubreg(ARM::DSUBREG_0, dl, RegVT,
1710                                                   N->getOperand(5));
1711       SDValue D6 = CurDAG->getTargetExtractSubreg(ARM::DSUBREG_0, dl, RegVT,
1712                                                   N->getOperand(6));
1713       const SDValue OpsA[] = { MemAddr, MemUpdate, MemOpc,
1714                                D0, D2, D4, D6, Chain };
1715       SDNode *VStA = CurDAG->getMachineNode(Opc, dl, MemAddr.getValueType(),
1716                                             MVT::Other, OpsA, 8);
1717       Chain = SDValue(VStA, 1);
1718
1719       SDValue D1 = CurDAG->getTargetExtractSubreg(ARM::DSUBREG_1, dl, RegVT,
1720                                                   N->getOperand(3));
1721       SDValue D3 = CurDAG->getTargetExtractSubreg(ARM::DSUBREG_1, dl, RegVT,
1722                                                   N->getOperand(4));
1723       SDValue D5 = CurDAG->getTargetExtractSubreg(ARM::DSUBREG_1, dl, RegVT,
1724                                                   N->getOperand(5));
1725       SDValue D7 = CurDAG->getTargetExtractSubreg(ARM::DSUBREG_1, dl, RegVT,
1726                                                   N->getOperand(6));
1727       MemAddr = SDValue(VStA, 0);
1728       const SDValue OpsB[] = { MemAddr, MemUpdate, MemOpc,
1729                                D1, D3, D5, D7, Chain };
1730       SDNode *VStB = CurDAG->getMachineNode(Opc2, dl, MemAddr.getValueType(),
1731                                             MVT::Other, OpsB, 8);
1732       Chain = SDValue(VStB, 1);
1733       ReplaceUses(SDValue(N, 0), Chain);
1734       return NULL;
1735     }
1736
1737     case Intrinsic::arm_neon_vst2lane: {
1738       SDValue MemAddr, MemUpdate, MemOpc;
1739       if (!SelectAddrMode6(Op, N->getOperand(2), MemAddr, MemUpdate, MemOpc))
1740         return NULL;
1741       switch (N->getOperand(3).getValueType().getSimpleVT().SimpleTy) {
1742       default: llvm_unreachable("unhandled vst2lane type");
1743       case MVT::v8i8:  Opc = ARM::VST2LNd8; break;
1744       case MVT::v4i16: Opc = ARM::VST2LNd16; break;
1745       case MVT::v2f32:
1746       case MVT::v2i32: Opc = ARM::VST2LNd32; break;
1747       }
1748       SDValue Chain = N->getOperand(0);
1749       const SDValue Ops[] = { MemAddr, MemUpdate, MemOpc,
1750                               N->getOperand(3), N->getOperand(4),
1751                               N->getOperand(5), Chain };
1752       return CurDAG->getMachineNode(Opc, dl, MVT::Other, Ops, 7);
1753     }
1754
1755     case Intrinsic::arm_neon_vst3lane: {
1756       SDValue MemAddr, MemUpdate, MemOpc;
1757       if (!SelectAddrMode6(Op, N->getOperand(2), MemAddr, MemUpdate, MemOpc))
1758         return NULL;
1759       switch (N->getOperand(3).getValueType().getSimpleVT().SimpleTy) {
1760       default: llvm_unreachable("unhandled vst3lane type");
1761       case MVT::v8i8:  Opc = ARM::VST3LNd8; break;
1762       case MVT::v4i16: Opc = ARM::VST3LNd16; break;
1763       case MVT::v2f32:
1764       case MVT::v2i32: Opc = ARM::VST3LNd32; break;
1765       }
1766       SDValue Chain = N->getOperand(0);
1767       const SDValue Ops[] = { MemAddr, MemUpdate, MemOpc,
1768                               N->getOperand(3), N->getOperand(4),
1769                               N->getOperand(5), N->getOperand(6), Chain };
1770       return CurDAG->getMachineNode(Opc, dl, MVT::Other, Ops, 8);
1771     }
1772
1773     case Intrinsic::arm_neon_vst4lane: {
1774       SDValue MemAddr, MemUpdate, MemOpc;
1775       if (!SelectAddrMode6(Op, N->getOperand(2), MemAddr, MemUpdate, MemOpc))
1776         return NULL;
1777       switch (N->getOperand(3).getValueType().getSimpleVT().SimpleTy) {
1778       default: llvm_unreachable("unhandled vst4lane type");
1779       case MVT::v8i8:  Opc = ARM::VST4LNd8; break;
1780       case MVT::v4i16: Opc = ARM::VST4LNd16; break;
1781       case MVT::v2f32:
1782       case MVT::v2i32: Opc = ARM::VST4LNd32; break;
1783       }
1784       SDValue Chain = N->getOperand(0);
1785       const SDValue Ops[] = { MemAddr, MemUpdate, MemOpc,
1786                               N->getOperand(3), N->getOperand(4),
1787                               N->getOperand(5), N->getOperand(6),
1788                               N->getOperand(7), Chain };
1789       return CurDAG->getMachineNode(Opc, dl, MVT::Other, Ops, 9);
1790     }
1791     }
1792   }
1793   }
1794
1795   return SelectCode(Op);
1796 }
1797
1798 bool ARMDAGToDAGISel::
1799 SelectInlineAsmMemoryOperand(const SDValue &Op, char ConstraintCode,
1800                              std::vector<SDValue> &OutOps) {
1801   assert(ConstraintCode == 'm' && "unexpected asm memory constraint");
1802
1803   SDValue Base, Offset, Opc;
1804   if (!SelectAddrMode2(Op, Op, Base, Offset, Opc))
1805     return true;
1806
1807   OutOps.push_back(Base);
1808   OutOps.push_back(Offset);
1809   OutOps.push_back(Opc);
1810   return false;
1811 }
1812
1813 /// createARMISelDag - This pass converts a legalized DAG into a
1814 /// ARM-specific DAG, ready for instruction scheduling.
1815 ///
1816 FunctionPass *llvm::createARMISelDag(ARMBaseTargetMachine &TM,
1817                                      CodeGenOpt::Level OptLevel) {
1818   return new ARMDAGToDAGISel(TM, OptLevel);
1819 }