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 #define DEBUG_TYPE "arm-isel"
  15 #include "ARM.h"
  16 #include "ARMAddressingModes.h"
  17 #include "ARMTargetMachine.h"
  18 #include "llvm/CallingConv.h"
  19 #include "llvm/Constants.h"
  20 #include "llvm/DerivedTypes.h"
  21 #include "llvm/Function.h"
  22 #include "llvm/Intrinsics.h"
  23 #include "llvm/LLVMContext.h"
  24 #include "llvm/CodeGen/MachineFrameInfo.h"
  25 #include "llvm/CodeGen/MachineFunction.h"
  26 #include "llvm/CodeGen/MachineInstrBuilder.h"
  27 #include "llvm/CodeGen/SelectionDAG.h"
  28 #include "llvm/CodeGen/SelectionDAGISel.h"
  29 #include "llvm/Target/TargetLowering.h"
  30 #include "llvm/Target/TargetOptions.h"
  31 #include "llvm/Support/CommandLine.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 static cl::opt<bool>
  40 UseRegSeq("neon-reg-sequence", cl::Hidden,
  41           cl::desc("Use reg_sequence to model ld / st of multiple neon regs"),
  42           cl::init(true));
  43
  44 //===--------------------------------------------------------------------===//
  45 /// ARMDAGToDAGISel - ARM specific code to select ARM machine
  46 /// instructions for SelectionDAG operations.
  47 ///
  48 namespace {
  49 class ARMDAGToDAGISel : public SelectionDAGISel {
  50   ARMBaseTargetMachine &TM;
  51
  52   /// Subtarget - Keep a pointer to the ARMSubtarget around so that we can
  53   /// make the right decision when generating code for different targets.
  54   const ARMSubtarget *Subtarget;
  55
  56 public:
  57   explicit ARMDAGToDAGISel(ARMBaseTargetMachine &tm,
  58                            CodeGenOpt::Level OptLevel)
  59     : SelectionDAGISel(tm, OptLevel), TM(tm),
  60     Subtarget(&TM.getSubtarget<ARMSubtarget>()) {
  61   }
  62
  63   virtual const char *getPassName() const {
  64     return "ARM Instruction Selection";
  65   }
  66
  67   /// getI32Imm - Return a target constant of type i32 with the specified
  68   /// value.
  69   inline SDValue getI32Imm(unsigned Imm) {
  70     return CurDAG->getTargetConstant(Imm, MVT::i32);
  71   }
  72
  73   SDNode *Select(SDNode *N);
  74
  75   bool SelectShifterOperandReg(SDNode *Op, SDValue N, SDValue &A,
  76                                SDValue &B, SDValue &C);
  77   bool SelectAddrMode2(SDNode *Op, SDValue N, SDValue &Base,
  78                        SDValue &Offset, SDValue &Opc);
  79   bool SelectAddrMode2Offset(SDNode *Op, SDValue N,
  80                              SDValue &Offset, SDValue &Opc);
  81   bool SelectAddrMode3(SDNode *Op, SDValue N, SDValue &Base,
  82                        SDValue &Offset, SDValue &Opc);
  83   bool SelectAddrMode3Offset(SDNode *Op, SDValue N,
  84                              SDValue &Offset, SDValue &Opc);
  85   bool SelectAddrMode4(SDNode *Op, SDValue N, SDValue &Addr,
  86                        SDValue &Mode);
  87   bool SelectAddrMode5(SDNode *Op, SDValue N, SDValue &Base,
  88                        SDValue &Offset);
  89   bool SelectAddrMode6(SDNode *Op, SDValue N, SDValue &Addr, SDValue &Align);
  90
  91   bool SelectAddrModePC(SDNode *Op, SDValue N, SDValue &Offset,
  92                         SDValue &Label);
  93
  94   bool SelectThumbAddrModeRR(SDNode *Op, SDValue N, SDValue &Base,
  95                              SDValue &Offset);
  96   bool SelectThumbAddrModeRI5(SDNode *Op, SDValue N, unsigned Scale,
  97                               SDValue &Base, SDValue &OffImm,
  98                               SDValue &Offset);
  99   bool SelectThumbAddrModeS1(SDNode *Op, SDValue N, SDValue &Base,
 100                              SDValue &OffImm, SDValue &Offset);
 101   bool SelectThumbAddrModeS2(SDNode *Op, SDValue N, SDValue &Base,
 102                              SDValue &OffImm, SDValue &Offset);
 103   bool SelectThumbAddrModeS4(SDNode *Op, SDValue N, SDValue &Base,
 104                              SDValue &OffImm, SDValue &Offset);
 105   bool SelectThumbAddrModeSP(SDNode *Op, SDValue N, SDValue &Base,
 106                              SDValue &OffImm);
 107
 108   bool SelectT2ShifterOperandReg(SDNode *Op, SDValue N,
 109                                  SDValue &BaseReg, SDValue &Opc);
 110   bool SelectT2AddrModeImm12(SDNode *Op, SDValue N, SDValue &Base,
 111                              SDValue &OffImm);
 112   bool SelectT2AddrModeImm8(SDNode *Op, SDValue N, SDValue &Base,
 113                             SDValue &OffImm);
 114   bool SelectT2AddrModeImm8Offset(SDNode *Op, SDValue N,
 115                                  SDValue &OffImm);
 116   bool SelectT2AddrModeImm8s4(SDNode *Op, SDValue N, SDValue &Base,
 117                               SDValue &OffImm);
 118   bool SelectT2AddrModeSoReg(SDNode *Op, SDValue N, SDValue &Base,
 119                              SDValue &OffReg, SDValue &ShImm);
 120
 121   // Include the pieces autogenerated from the target description.
 122 #include "ARMGenDAGISel.inc"
 123
 124 private:
 125   /// SelectARMIndexedLoad - Indexed (pre/post inc/dec) load matching code for
 126   /// ARM.
 127   SDNode *SelectARMIndexedLoad(SDNode *N);
 128   SDNode *SelectT2IndexedLoad(SDNode *N);
 129
 130   /// SelectVLD - Select NEON load intrinsics.  NumVecs should be
 131   /// 1, 2, 3 or 4.  The opcode arrays specify the instructions used for
 132   /// loads of D registers and even subregs and odd subregs of Q registers.
 133   /// For NumVecs <= 2, QOpcodes1 is not used.
 134   SDNode *SelectVLD(SDNode *N, unsigned NumVecs, unsigned *DOpcodes,
 135                     unsigned *QOpcodes0, unsigned *QOpcodes1);
 136
 137   /// SelectVST - Select NEON store intrinsics.  NumVecs should
 138   /// be 1, 2, 3 or 4.  The opcode arrays specify the instructions used for
 139   /// stores of D registers and even subregs and odd subregs of Q registers.
 140   /// For NumVecs <= 2, QOpcodes1 is not used.
 141   SDNode *SelectVST(SDNode *N, unsigned NumVecs, unsigned *DOpcodes,
 142                     unsigned *QOpcodes0, unsigned *QOpcodes1);
 143
 144   /// SelectVLDSTLane - Select NEON load/store lane intrinsics.  NumVecs should
 145   /// be 2, 3 or 4.  The opcode arrays specify the instructions used for
 146   /// load/store of D registers and even subregs and odd subregs of Q registers.
 147   SDNode *SelectVLDSTLane(SDNode *N, bool IsLoad, unsigned NumVecs,
 148                           unsigned *DOpcodes, unsigned *QOpcodes0,
 149                           unsigned *QOpcodes1);
 150
 151   /// SelectV6T2BitfieldExtractOp - Select SBFX/UBFX instructions for ARM.
 152   SDNode *SelectV6T2BitfieldExtractOp(SDNode *N, bool isSigned);
 153
 154   /// SelectCMOVOp - Select CMOV instructions for ARM.
 155   SDNode *SelectCMOVOp(SDNode *N);
 156   SDNode *SelectT2CMOVShiftOp(SDNode *N, SDValue FalseVal, SDValue TrueVal,
 157                               ARMCC::CondCodes CCVal, SDValue CCR,
 158                               SDValue InFlag);
 159   SDNode *SelectARMCMOVShiftOp(SDNode *N, SDValue FalseVal, SDValue TrueVal,
 160                                ARMCC::CondCodes CCVal, SDValue CCR,
 161                                SDValue InFlag);
 162   SDNode *SelectT2CMOVSoImmOp(SDNode *N, SDValue FalseVal, SDValue TrueVal,
 163                               ARMCC::CondCodes CCVal, SDValue CCR,
 164                               SDValue InFlag);
 165   SDNode *SelectARMCMOVSoImmOp(SDNode *N, SDValue FalseVal, SDValue TrueVal,
 166                                ARMCC::CondCodes CCVal, SDValue CCR,
 167                                SDValue InFlag);
 168
 169   SDNode *SelectConcatVector(SDNode *N);
 170
 171   /// SelectInlineAsmMemoryOperand - Implement addressing mode selection for
 172   /// inline asm expressions.
 173   virtual bool SelectInlineAsmMemoryOperand(const SDValue &Op,
 174                                             char ConstraintCode,
 175                                             std::vector<SDValue> &OutOps);
 176
 177   // Form pairs of consecutive S, D, or Q registers.
 178   SDNode *PairSRegs(EVT VT, SDValue V0, SDValue V1);
 179   SDNode *PairDRegs(EVT VT, SDValue V0, SDValue V1);
 180   SDNode *PairQRegs(EVT VT, SDValue V0, SDValue V1);
 181
 182   // Form sequences of 4 consecutive S, D, or Q registers.
 183   SDNode *QuadSRegs(EVT VT, SDValue V0, SDValue V1, SDValue V2, SDValue V3);
 184   SDNode *QuadDRegs(EVT VT, SDValue V0, SDValue V1, SDValue V2, SDValue V3);
 185   SDNode *QuadQRegs(EVT VT, SDValue V0, SDValue V1, SDValue V2, SDValue V3);
 186
 187   // Form sequences of 8 consecutive D registers.
 188   SDNode *OctoDRegs(EVT VT, SDValue V0, SDValue V1, SDValue V2, SDValue V3,
 189                     SDValue V4, SDValue V5, SDValue V6, SDValue V7);
 190 };
 191 }
 192
 193 /// isInt32Immediate - This method tests to see if the node is a 32-bit constant
 194 /// operand. If so Imm will receive the 32-bit value.
 195 static bool isInt32Immediate(SDNode *N, unsigned &Imm) {
 196   if (N->getOpcode() == ISD::Constant && N->getValueType(0) == MVT::i32) {
 197     Imm = cast<ConstantSDNode>(N)->getZExtValue();
 198     return true;
 199   }
 200   return false;
 201 }
 202
 203 // isInt32Immediate - This method tests to see if a constant operand.
 204 // If so Imm will receive the 32 bit value.
 205 static bool isInt32Immediate(SDValue N, unsigned &Imm) {
 206   return isInt32Immediate(N.getNode(), Imm);
 207 }
 208
 209 // isOpcWithIntImmediate - This method tests to see if the node is a specific
 210 // opcode and that it has a immediate integer right operand.
 211 // If so Imm will receive the 32 bit value.
 212 static bool isOpcWithIntImmediate(SDNode *N, unsigned Opc, unsigned& Imm) {
 213   return N->getOpcode() == Opc &&
 214          isInt32Immediate(N->getOperand(1).getNode(), Imm);
 215 }
 216
 217
 218 bool ARMDAGToDAGISel::SelectShifterOperandReg(SDNode *Op,
 219                                               SDValue N,
 220                                               SDValue &BaseReg,
 221                                               SDValue &ShReg,
 222                                               SDValue &Opc) {
 223   ARM_AM::ShiftOpc ShOpcVal = ARM_AM::getShiftOpcForNode(N);
 224
 225   // Don't match base register only case. That is matched to a separate
 226   // lower complexity pattern with explicit register operand.
 227   if (ShOpcVal == ARM_AM::no_shift) return false;
 228
 229   BaseReg = N.getOperand(0);
 230   unsigned ShImmVal = 0;
 231   if (ConstantSDNode *RHS = dyn_cast<ConstantSDNode>(N.getOperand(1))) {
 232     ShReg = CurDAG->getRegister(0, MVT::i32);
 233     ShImmVal = RHS->getZExtValue() & 31;
 234   } else {
 235     ShReg = N.getOperand(1);
 236   }
 237   Opc = CurDAG->getTargetConstant(ARM_AM::getSORegOpc(ShOpcVal, ShImmVal),
 238                                   MVT::i32);
 239   return true;
 240 }
 241
 242 bool ARMDAGToDAGISel::SelectAddrMode2(SDNode *Op, SDValue N,
 243                                       SDValue &Base, SDValue &Offset,
 244                                       SDValue &Opc) {
 245   if (N.getOpcode() == ISD::MUL) {
 246     if (ConstantSDNode *RHS = dyn_cast<ConstantSDNode>(N.getOperand(1))) {
 247       // X * [3,5,9] -> X + X * [2,4,8] etc.
 248       int RHSC = (int)RHS->getZExtValue();
 249       if (RHSC & 1) {
 250         RHSC = RHSC & ~1;
 251         ARM_AM::AddrOpc AddSub = ARM_AM::add;
 252         if (RHSC < 0) {
 253           AddSub = ARM_AM::sub;
 254           RHSC = - RHSC;
 255         }
 256         if (isPowerOf2_32(RHSC)) {
 257           unsigned ShAmt = Log2_32(RHSC);
 258           Base = Offset = N.getOperand(0);
 259           Opc = CurDAG->getTargetConstant(ARM_AM::getAM2Opc(AddSub, ShAmt,
 260                                                             ARM_AM::lsl),
 261                                           MVT::i32);
 262           return true;
 263         }
 264       }
 265     }
 266   }
 267
 268   if (N.getOpcode() != ISD::ADD && N.getOpcode() != ISD::SUB) {
 269     Base = N;
 270     if (N.getOpcode() == ISD::FrameIndex) {
 271       int FI = cast<FrameIndexSDNode>(N)->getIndex();
 272       Base = CurDAG->getTargetFrameIndex(FI, TLI.getPointerTy());
 273     } else if (N.getOpcode() == ARMISD::Wrapper &&
 274                !(Subtarget->useMovt() &&
 275                  N.getOperand(0).getOpcode() == ISD::TargetGlobalAddress)) {
 276       Base = N.getOperand(0);
 277     }
 278     Offset = CurDAG->getRegister(0, MVT::i32);
 279     Opc = CurDAG->getTargetConstant(ARM_AM::getAM2Opc(ARM_AM::add, 0,
 280                                                       ARM_AM::no_shift),
 281                                     MVT::i32);
 282     return true;
 283   }
 284
 285   // Match simple R +/- imm12 operands.
 286   if (N.getOpcode() == ISD::ADD)
 287     if (ConstantSDNode *RHS = dyn_cast<ConstantSDNode>(N.getOperand(1))) {
 288       int RHSC = (int)RHS->getZExtValue();
 289       if ((RHSC >= 0 && RHSC < 0x1000) ||
 290           (RHSC < 0 && RHSC > -0x1000)) { // 12 bits.
 291         Base = N.getOperand(0);
 292         if (Base.getOpcode() == ISD::FrameIndex) {
 293           int FI = cast<FrameIndexSDNode>(Base)->getIndex();
 294           Base = CurDAG->getTargetFrameIndex(FI, TLI.getPointerTy());
 295         }
 296         Offset = CurDAG->getRegister(0, MVT::i32);
 297
 298         ARM_AM::AddrOpc AddSub = ARM_AM::add;
 299         if (RHSC < 0) {
 300           AddSub = ARM_AM::sub;
 301           RHSC = - RHSC;
 302         }
 303         Opc = CurDAG->getTargetConstant(ARM_AM::getAM2Opc(AddSub, RHSC,
 304                                                           ARM_AM::no_shift),
 305                                         MVT::i32);
 306         return true;
 307       }
 308     }
 309
 310   // Otherwise this is R +/- [possibly shifted] R.
 311   ARM_AM::AddrOpc AddSub = N.getOpcode() == ISD::ADD ? ARM_AM::add:ARM_AM::sub;
 312   ARM_AM::ShiftOpc ShOpcVal = ARM_AM::getShiftOpcForNode(N.getOperand(1));
 313   unsigned ShAmt = 0;
 314
 315   Base   = N.getOperand(0);
 316   Offset = N.getOperand(1);
 317
 318   if (ShOpcVal != ARM_AM::no_shift) {
 319     // Check to see if the RHS of the shift is a constant, if not, we can't fold
 320     // it.
 321     if (ConstantSDNode *Sh =
 322            dyn_cast<ConstantSDNode>(N.getOperand(1).getOperand(1))) {
 323       ShAmt = Sh->getZExtValue();
 324       Offset = N.getOperand(1).getOperand(0);
 325     } else {
 326       ShOpcVal = ARM_AM::no_shift;
 327     }
 328   }
 329
 330   // Try matching (R shl C) + (R).
 331   if (N.getOpcode() == ISD::ADD && ShOpcVal == ARM_AM::no_shift) {
 332     ShOpcVal = ARM_AM::getShiftOpcForNode(N.getOperand(0));
 333     if (ShOpcVal != ARM_AM::no_shift) {
 334       // Check to see if the RHS of the shift is a constant, if not, we can't
 335       // fold it.
 336       if (ConstantSDNode *Sh =
 337           dyn_cast<ConstantSDNode>(N.getOperand(0).getOperand(1))) {
 338         ShAmt = Sh->getZExtValue();
 339         Offset = N.getOperand(0).getOperand(0);
 340         Base = N.getOperand(1);
 341       } else {
 342         ShOpcVal = ARM_AM::no_shift;
 343       }
 344     }
 345   }
 346
 347   Opc = CurDAG->getTargetConstant(ARM_AM::getAM2Opc(AddSub, ShAmt, ShOpcVal),
 348                                   MVT::i32);
 349   return true;
 350 }
 351
 352 bool ARMDAGToDAGISel::SelectAddrMode2Offset(SDNode *Op, SDValue N,
 353                                             SDValue &Offset, SDValue &Opc) {
 354   unsigned Opcode = Op->getOpcode();
 355   ISD::MemIndexedMode AM = (Opcode == ISD::LOAD)
 356     ? cast<LoadSDNode>(Op)->getAddressingMode()
 357     : cast<StoreSDNode>(Op)->getAddressingMode();
 358   ARM_AM::AddrOpc AddSub = (AM == ISD::PRE_INC || AM == ISD::POST_INC)
 359     ? ARM_AM::add : ARM_AM::sub;
 360   if (ConstantSDNode *C = dyn_cast<ConstantSDNode>(N)) {
 361     int Val = (int)C->getZExtValue();
 362     if (Val >= 0 && Val < 0x1000) { // 12 bits.
 363       Offset = CurDAG->getRegister(0, MVT::i32);
 364       Opc = CurDAG->getTargetConstant(ARM_AM::getAM2Opc(AddSub, Val,
 365                                                         ARM_AM::no_shift),
 366                                       MVT::i32);
 367       return true;
 368     }
 369   }
 370
 371   Offset = N;
 372   ARM_AM::ShiftOpc ShOpcVal = ARM_AM::getShiftOpcForNode(N);
 373   unsigned ShAmt = 0;
 374   if (ShOpcVal != ARM_AM::no_shift) {
 375     // Check to see if the RHS of the shift is a constant, if not, we can't fold
 376     // it.
 377     if (ConstantSDNode *Sh = dyn_cast<ConstantSDNode>(N.getOperand(1))) {
 378       ShAmt = Sh->getZExtValue();
 379       Offset = N.getOperand(0);
 380     } else {
 381       ShOpcVal = ARM_AM::no_shift;
 382     }
 383   }
 384
 385   Opc = CurDAG->getTargetConstant(ARM_AM::getAM2Opc(AddSub, ShAmt, ShOpcVal),
 386                                   MVT::i32);
 387   return true;
 388 }
 389
 390
 391 bool ARMDAGToDAGISel::SelectAddrMode3(SDNode *Op, SDValue N,
 392                                       SDValue &Base, SDValue &Offset,
 393                                       SDValue &Opc) {
 394   if (N.getOpcode() == ISD::SUB) {
 395     // X - C  is canonicalize to X + -C, no need to handle it here.
 396     Base = N.getOperand(0);
 397     Offset = N.getOperand(1);
 398     Opc = CurDAG->getTargetConstant(ARM_AM::getAM3Opc(ARM_AM::sub, 0),MVT::i32);
 399     return true;
 400   }
 401
 402   if (N.getOpcode() != ISD::ADD) {
 403     Base = N;
 404     if (N.getOpcode() == ISD::FrameIndex) {
 405       int FI = cast<FrameIndexSDNode>(N)->getIndex();
 406       Base = CurDAG->getTargetFrameIndex(FI, TLI.getPointerTy());
 407     }
 408     Offset = CurDAG->getRegister(0, MVT::i32);
 409     Opc = CurDAG->getTargetConstant(ARM_AM::getAM3Opc(ARM_AM::add, 0),MVT::i32);
 410     return true;
 411   }
 412
 413   // If the RHS is +/- imm8, fold into addr mode.
 414   if (ConstantSDNode *RHS = dyn_cast<ConstantSDNode>(N.getOperand(1))) {
 415     int RHSC = (int)RHS->getZExtValue();
 416     if ((RHSC >= 0 && RHSC < 256) ||
 417         (RHSC < 0 && RHSC > -256)) { // note -256 itself isn't allowed.
 418       Base = N.getOperand(0);
 419       if (Base.getOpcode() == ISD::FrameIndex) {
 420         int FI = cast<FrameIndexSDNode>(Base)->getIndex();
 421         Base = CurDAG->getTargetFrameIndex(FI, TLI.getPointerTy());
 422       }
 423       Offset = CurDAG->getRegister(0, MVT::i32);
 424
 425       ARM_AM::AddrOpc AddSub = ARM_AM::add;
 426       if (RHSC < 0) {
 427         AddSub = ARM_AM::sub;
 428         RHSC = - RHSC;
 429       }
 430       Opc = CurDAG->getTargetConstant(ARM_AM::getAM3Opc(AddSub, RHSC),MVT::i32);
 431       return true;
 432     }
 433   }
 434
 435   Base = N.getOperand(0);
 436   Offset = N.getOperand(1);
 437   Opc = CurDAG->getTargetConstant(ARM_AM::getAM3Opc(ARM_AM::add, 0), MVT::i32);
 438   return true;
 439 }
 440
 441 bool ARMDAGToDAGISel::SelectAddrMode3Offset(SDNode *Op, SDValue N,
 442                                             SDValue &Offset, SDValue &Opc) {
 443   unsigned Opcode = Op->getOpcode();
 444   ISD::MemIndexedMode AM = (Opcode == ISD::LOAD)
 445     ? cast<LoadSDNode>(Op)->getAddressingMode()
 446     : cast<StoreSDNode>(Op)->getAddressingMode();
 447   ARM_AM::AddrOpc AddSub = (AM == ISD::PRE_INC || AM == ISD::POST_INC)
 448     ? ARM_AM::add : ARM_AM::sub;
 449   if (ConstantSDNode *C = dyn_cast<ConstantSDNode>(N)) {
 450     int Val = (int)C->getZExtValue();
 451     if (Val >= 0 && Val < 256) {
 452       Offset = CurDAG->getRegister(0, MVT::i32);
 453       Opc = CurDAG->getTargetConstant(ARM_AM::getAM3Opc(AddSub, Val), MVT::i32);
 454       return true;
 455     }
 456   }
 457
 458   Offset = N;
 459   Opc = CurDAG->getTargetConstant(ARM_AM::getAM3Opc(AddSub, 0), MVT::i32);
 460   return true;
 461 }
 462
 463 bool ARMDAGToDAGISel::SelectAddrMode4(SDNode *Op, SDValue N,
 464                                       SDValue &Addr, SDValue &Mode) {
 465   Addr = N;
 466   Mode = CurDAG->getTargetConstant(0, MVT::i32);
 467   return true;
 468 }
 469
 470 bool ARMDAGToDAGISel::SelectAddrMode5(SDNode *Op, SDValue N,
 471                                       SDValue &Base, SDValue &Offset) {
 472   if (N.getOpcode() != ISD::ADD) {
 473     Base = N;
 474     if (N.getOpcode() == ISD::FrameIndex) {
 475       int FI = cast<FrameIndexSDNode>(N)->getIndex();
 476       Base = CurDAG->getTargetFrameIndex(FI, TLI.getPointerTy());
 477     } else if (N.getOpcode() == ARMISD::Wrapper &&
 478                !(Subtarget->useMovt() &&
 479                  N.getOperand(0).getOpcode() == ISD::TargetGlobalAddress)) {
 480       Base = N.getOperand(0);
 481     }
 482     Offset = CurDAG->getTargetConstant(ARM_AM::getAM5Opc(ARM_AM::add, 0),
 483                                        MVT::i32);
 484     return true;
 485   }
 486
 487   // If the RHS is +/- imm8, fold into addr mode.
 488   if (ConstantSDNode *RHS = dyn_cast<ConstantSDNode>(N.getOperand(1))) {
 489     int RHSC = (int)RHS->getZExtValue();
 490     if ((RHSC & 3) == 0) {  // The constant is implicitly multiplied by 4.
 491       RHSC >>= 2;
 492       if ((RHSC >= 0 && RHSC < 256) ||
 493           (RHSC < 0 && RHSC > -256)) { // note -256 itself isn't allowed.
 494         Base = N.getOperand(0);
 495         if (Base.getOpcode() == ISD::FrameIndex) {
 496           int FI = cast<FrameIndexSDNode>(Base)->getIndex();
 497           Base = CurDAG->getTargetFrameIndex(FI, TLI.getPointerTy());
 498         }
 499
 500         ARM_AM::AddrOpc AddSub = ARM_AM::add;
 501         if (RHSC < 0) {
 502           AddSub = ARM_AM::sub;
 503           RHSC = - RHSC;
 504         }
 505         Offset = CurDAG->getTargetConstant(ARM_AM::getAM5Opc(AddSub, RHSC),
 506                                            MVT::i32);
 507         return true;
 508       }
 509     }
 510   }
 511
 512   Base = N;
 513   Offset = CurDAG->getTargetConstant(ARM_AM::getAM5Opc(ARM_AM::add, 0),
 514                                      MVT::i32);
 515   return true;
 516 }
 517
 518 bool ARMDAGToDAGISel::SelectAddrMode6(SDNode *Op, SDValue N,
 519                                       SDValue &Addr, SDValue &Align) {
 520   Addr = N;
 521   // Default to no alignment.
 522   Align = CurDAG->getTargetConstant(0, MVT::i32);
 523   return true;
 524 }
 525
 526 bool ARMDAGToDAGISel::SelectAddrModePC(SDNode *Op, SDValue N,
 527                                        SDValue &Offset, SDValue &Label) {
 528   if (N.getOpcode() == ARMISD::PIC_ADD && N.hasOneUse()) {
 529     Offset = N.getOperand(0);
 530     SDValue N1 = N.getOperand(1);
 531     Label  = CurDAG->getTargetConstant(cast<ConstantSDNode>(N1)->getZExtValue(),
 532                                        MVT::i32);
 533     return true;
 534   }
 535   return false;
 536 }
 537
 538 bool ARMDAGToDAGISel::SelectThumbAddrModeRR(SDNode *Op, SDValue N,
 539                                             SDValue &Base, SDValue &Offset){
 540   // FIXME dl should come from the parent load or store, not the address
 541   DebugLoc dl = Op->getDebugLoc();
 542   if (N.getOpcode() != ISD::ADD) {
 543     ConstantSDNode *NC = dyn_cast<ConstantSDNode>(N);
 544     if (!NC || NC->getZExtValue() != 0)
 545       return false;
 546
 547     Base = Offset = N;
 548     return true;
 549   }
 550
 551   Base = N.getOperand(0);
 552   Offset = N.getOperand(1);
 553   return true;
 554 }
 555
 556 bool
 557 ARMDAGToDAGISel::SelectThumbAddrModeRI5(SDNode *Op, SDValue N,
 558                                         unsigned Scale, SDValue &Base,
 559                                         SDValue &OffImm, SDValue &Offset) {
 560   if (Scale == 4) {
 561     SDValue TmpBase, TmpOffImm;
 562     if (SelectThumbAddrModeSP(Op, N, TmpBase, TmpOffImm))
 563       return false;  // We want to select tLDRspi / tSTRspi instead.
 564     if (N.getOpcode() == ARMISD::Wrapper &&
 565         N.getOperand(0).getOpcode() == ISD::TargetConstantPool)
 566       return false;  // We want to select tLDRpci instead.
 567   }
 568
 569   if (N.getOpcode() != ISD::ADD) {
 570     if (N.getOpcode() == ARMISD::Wrapper &&
 571         !(Subtarget->useMovt() &&
 572           N.getOperand(0).getOpcode() == ISD::TargetGlobalAddress)) {
 573       Base = N.getOperand(0);
 574     } else
 575       Base = N;
 576
 577     Offset = CurDAG->getRegister(0, MVT::i32);
 578     OffImm = CurDAG->getTargetConstant(0, MVT::i32);
 579     return true;
 580   }
 581
 582   // Thumb does not have [sp, r] address mode.
 583   RegisterSDNode *LHSR = dyn_cast<RegisterSDNode>(N.getOperand(0));
 584   RegisterSDNode *RHSR = dyn_cast<RegisterSDNode>(N.getOperand(1));
 585   if ((LHSR && LHSR->getReg() == ARM::SP) ||
 586       (RHSR && RHSR->getReg() == ARM::SP)) {
 587     Base = N;
 588     Offset = CurDAG->getRegister(0, MVT::i32);
 589     OffImm = CurDAG->getTargetConstant(0, MVT::i32);
 590     return true;
 591   }
 592
 593   // If the RHS is + imm5 * scale, fold into addr mode.
 594   if (ConstantSDNode *RHS = dyn_cast<ConstantSDNode>(N.getOperand(1))) {
 595     int RHSC = (int)RHS->getZExtValue();
 596     if ((RHSC & (Scale-1)) == 0) {  // The constant is implicitly multiplied.
 597       RHSC /= Scale;
 598       if (RHSC >= 0 && RHSC < 32) {
 599         Base = N.getOperand(0);
 600         Offset = CurDAG->getRegister(0, MVT::i32);
 601         OffImm = CurDAG->getTargetConstant(RHSC, MVT::i32);
 602         return true;
 603       }
 604     }
 605   }
 606
 607   Base = N.getOperand(0);
 608   Offset = N.getOperand(1);
 609   OffImm = CurDAG->getTargetConstant(0, MVT::i32);
 610   return true;
 611 }
 612
 613 bool ARMDAGToDAGISel::SelectThumbAddrModeS1(SDNode *Op, SDValue N,
 614                                             SDValue &Base, SDValue &OffImm,
 615                                             SDValue &Offset) {
 616   return SelectThumbAddrModeRI5(Op, N, 1, Base, OffImm, Offset);
 617 }
 618
 619 bool ARMDAGToDAGISel::SelectThumbAddrModeS2(SDNode *Op, SDValue N,
 620                                             SDValue &Base, SDValue &OffImm,
 621                                             SDValue &Offset) {
 622   return SelectThumbAddrModeRI5(Op, N, 2, Base, OffImm, Offset);
 623 }
 624
 625 bool ARMDAGToDAGISel::SelectThumbAddrModeS4(SDNode *Op, SDValue N,
 626                                             SDValue &Base, SDValue &OffImm,
 627                                             SDValue &Offset) {
 628   return SelectThumbAddrModeRI5(Op, N, 4, Base, OffImm, Offset);
 629 }
 630
 631 bool ARMDAGToDAGISel::SelectThumbAddrModeSP(SDNode *Op, SDValue N,
 632                                            SDValue &Base, SDValue &OffImm) {
 633   if (N.getOpcode() == ISD::FrameIndex) {
 634     int FI = cast<FrameIndexSDNode>(N)->getIndex();
 635     Base = CurDAG->getTargetFrameIndex(FI, TLI.getPointerTy());
 636     OffImm = CurDAG->getTargetConstant(0, MVT::i32);
 637     return true;
 638   }
 639
 640   if (N.getOpcode() != ISD::ADD)
 641     return false;
 642
 643   RegisterSDNode *LHSR = dyn_cast<RegisterSDNode>(N.getOperand(0));
 644   if (N.getOperand(0).getOpcode() == ISD::FrameIndex ||
 645       (LHSR && LHSR->getReg() == ARM::SP)) {
 646     // If the RHS is + imm8 * scale, fold into addr mode.
 647     if (ConstantSDNode *RHS = dyn_cast<ConstantSDNode>(N.getOperand(1))) {
 648       int RHSC = (int)RHS->getZExtValue();
 649       if ((RHSC & 3) == 0) {  // The constant is implicitly multiplied.
 650         RHSC >>= 2;
 651         if (RHSC >= 0 && RHSC < 256) {
 652           Base = N.getOperand(0);
 653           if (Base.getOpcode() == ISD::FrameIndex) {
 654             int FI = cast<FrameIndexSDNode>(Base)->getIndex();
 655             Base = CurDAG->getTargetFrameIndex(FI, TLI.getPointerTy());
 656           }
 657           OffImm = CurDAG->getTargetConstant(RHSC, MVT::i32);
 658           return true;
 659         }
 660       }
 661     }
 662   }
 663
 664   return false;
 665 }
 666
 667 bool ARMDAGToDAGISel::SelectT2ShifterOperandReg(SDNode *Op, SDValue N,
 668                                                 SDValue &BaseReg,
 669                                                 SDValue &Opc) {
 670   ARM_AM::ShiftOpc ShOpcVal = ARM_AM::getShiftOpcForNode(N);
 671
 672   // Don't match base register only case. That is matched to a separate
 673   // lower complexity pattern with explicit register operand.
 674   if (ShOpcVal == ARM_AM::no_shift) return false;
 675
 676   BaseReg = N.getOperand(0);
 677   unsigned ShImmVal = 0;
 678   if (ConstantSDNode *RHS = dyn_cast<ConstantSDNode>(N.getOperand(1))) {
 679     ShImmVal = RHS->getZExtValue() & 31;
 680     Opc = getI32Imm(ARM_AM::getSORegOpc(ShOpcVal, ShImmVal));
 681     return true;
 682   }
 683
 684   return false;
 685 }
 686
 687 bool ARMDAGToDAGISel::SelectT2AddrModeImm12(SDNode *Op, SDValue N,
 688                                             SDValue &Base, SDValue &OffImm) {
 689   // Match simple R + imm12 operands.
 690
 691   // Base only.
 692   if (N.getOpcode() != ISD::ADD && N.getOpcode() != ISD::SUB) {
 693     if (N.getOpcode() == ISD::FrameIndex) {
 694       // Match frame index...
 695       int FI = cast<FrameIndexSDNode>(N)->getIndex();
 696       Base = CurDAG->getTargetFrameIndex(FI, TLI.getPointerTy());
 697       OffImm  = CurDAG->getTargetConstant(0, MVT::i32);
 698       return true;
 699     } else if (N.getOpcode() == ARMISD::Wrapper &&
 700                !(Subtarget->useMovt() &&
 701                  N.getOperand(0).getOpcode() == ISD::TargetGlobalAddress)) {
 702       Base = N.getOperand(0);
 703       if (Base.getOpcode() == ISD::TargetConstantPool)
 704         return false;  // We want to select t2LDRpci instead.
 705     } else
 706       Base = N;
 707     OffImm  = CurDAG->getTargetConstant(0, MVT::i32);
 708     return true;
 709   }
 710
 711   if (ConstantSDNode *RHS = dyn_cast<ConstantSDNode>(N.getOperand(1))) {
 712     if (SelectT2AddrModeImm8(Op, N, Base, OffImm))
 713       // Let t2LDRi8 handle (R - imm8).
 714       return false;
 715
 716     int RHSC = (int)RHS->getZExtValue();
 717     if (N.getOpcode() == ISD::SUB)
 718       RHSC = -RHSC;
 719
 720     if (RHSC >= 0 && RHSC < 0x1000) { // 12 bits (unsigned)
 721       Base   = N.getOperand(0);
 722       if (Base.getOpcode() == ISD::FrameIndex) {
 723         int FI = cast<FrameIndexSDNode>(Base)->getIndex();
 724         Base = CurDAG->getTargetFrameIndex(FI, TLI.getPointerTy());
 725       }
 726       OffImm = CurDAG->getTargetConstant(RHSC, MVT::i32);
 727       return true;
 728     }
 729   }
 730
 731   // Base only.
 732   Base = N;
 733   OffImm  = CurDAG->getTargetConstant(0, MVT::i32);
 734   return true;
 735 }
 736
 737 bool ARMDAGToDAGISel::SelectT2AddrModeImm8(SDNode *Op, SDValue N,
 738                                            SDValue &Base, SDValue &OffImm) {
 739   // Match simple R - imm8 operands.
 740   if (N.getOpcode() == ISD::ADD || N.getOpcode() == ISD::SUB) {
 741     if (ConstantSDNode *RHS = dyn_cast<ConstantSDNode>(N.getOperand(1))) {
 742       int RHSC = (int)RHS->getSExtValue();
 743       if (N.getOpcode() == ISD::SUB)
 744         RHSC = -RHSC;
 745
 746       if ((RHSC >= -255) && (RHSC < 0)) { // 8 bits (always negative)
 747         Base = N.getOperand(0);
 748         if (Base.getOpcode() == ISD::FrameIndex) {
 749           int FI = cast<FrameIndexSDNode>(Base)->getIndex();
 750           Base = CurDAG->getTargetFrameIndex(FI, TLI.getPointerTy());
 751         }
 752         OffImm = CurDAG->getTargetConstant(RHSC, MVT::i32);
 753         return true;
 754       }
 755     }
 756   }
 757
 758   return false;
 759 }
 760
 761 bool ARMDAGToDAGISel::SelectT2AddrModeImm8Offset(SDNode *Op, SDValue N,
 762                                                  SDValue &OffImm){
 763   unsigned Opcode = Op->getOpcode();
 764   ISD::MemIndexedMode AM = (Opcode == ISD::LOAD)
 765     ? cast<LoadSDNode>(Op)->getAddressingMode()
 766     : cast<StoreSDNode>(Op)->getAddressingMode();
 767   if (ConstantSDNode *RHS = dyn_cast<ConstantSDNode>(N)) {
 768     int RHSC = (int)RHS->getZExtValue();
 769     if (RHSC >= 0 && RHSC < 0x100) { // 8 bits.
 770       OffImm = ((AM == ISD::PRE_INC) || (AM == ISD::POST_INC))
 771         ? CurDAG->getTargetConstant(RHSC, MVT::i32)
 772         : CurDAG->getTargetConstant(-RHSC, MVT::i32);
 773       return true;
 774     }
 775   }
 776
 777   return false;
 778 }
 779
 780 bool ARMDAGToDAGISel::SelectT2AddrModeImm8s4(SDNode *Op, SDValue N,
 781                                              SDValue &Base, SDValue &OffImm) {
 782   if (N.getOpcode() == ISD::ADD) {
 783     if (ConstantSDNode *RHS = dyn_cast<ConstantSDNode>(N.getOperand(1))) {
 784       int RHSC = (int)RHS->getZExtValue();
 785       // 8 bits.
 786       if (((RHSC & 0x3) == 0) &&
 787           ((RHSC >= 0 && RHSC < 0x400) || (RHSC < 0 && RHSC > -0x400))) {
 788         Base   = N.getOperand(0);
 789         OffImm = CurDAG->getTargetConstant(RHSC, MVT::i32);
 790         return true;
 791       }
 792     }
 793   } else if (N.getOpcode() == ISD::SUB) {
 794     if (ConstantSDNode *RHS = dyn_cast<ConstantSDNode>(N.getOperand(1))) {
 795       int RHSC = (int)RHS->getZExtValue();
 796       // 8 bits.
 797       if (((RHSC & 0x3) == 0) && (RHSC >= 0 && RHSC < 0x400)) {
 798         Base   = N.getOperand(0);
 799         OffImm = CurDAG->getTargetConstant(-RHSC, MVT::i32);
 800         return true;
 801       }
 802     }
 803   }
 804
 805   return false;
 806 }
 807
 808 bool ARMDAGToDAGISel::SelectT2AddrModeSoReg(SDNode *Op, SDValue N,
 809                                             SDValue &Base,
 810                                             SDValue &OffReg, SDValue &ShImm) {
 811   // (R - imm8) should be handled by t2LDRi8. The rest are handled by t2LDRi12.
 812   if (N.getOpcode() != ISD::ADD)
 813     return false;
 814
 815   // Leave (R + imm12) for t2LDRi12, (R - imm8) for t2LDRi8.
 816   if (ConstantSDNode *RHS = dyn_cast<ConstantSDNode>(N.getOperand(1))) {
 817     int RHSC = (int)RHS->getZExtValue();
 818     if (RHSC >= 0 && RHSC < 0x1000) // 12 bits (unsigned)
 819       return false;
 820     else if (RHSC < 0 && RHSC >= -255) // 8 bits
 821       return false;
 822   }
 823
 824   // Look for (R + R) or (R + (R << [1,2,3])).
 825   unsigned ShAmt = 0;
 826   Base   = N.getOperand(0);
 827   OffReg = N.getOperand(1);
 828
 829   // Swap if it is ((R << c) + R).
 830   ARM_AM::ShiftOpc ShOpcVal = ARM_AM::getShiftOpcForNode(OffReg);
 831   if (ShOpcVal != ARM_AM::lsl) {
 832     ShOpcVal = ARM_AM::getShiftOpcForNode(Base);
 833     if (ShOpcVal == ARM_AM::lsl)
 834       std::swap(Base, OffReg);
 835   }
 836
 837   if (ShOpcVal == ARM_AM::lsl) {
 838     // Check to see if the RHS of the shift is a constant, if not, we can't fold
 839     // it.
 840     if (ConstantSDNode *Sh = dyn_cast<ConstantSDNode>(OffReg.getOperand(1))) {
 841       ShAmt = Sh->getZExtValue();
 842       if (ShAmt >= 4) {
 843         ShAmt = 0;
 844         ShOpcVal = ARM_AM::no_shift;
 845       } else
 846         OffReg = OffReg.getOperand(0);
 847     } else {
 848       ShOpcVal = ARM_AM::no_shift;
 849     }
 850   }
 851
 852   ShImm = CurDAG->getTargetConstant(ShAmt, MVT::i32);
 853
 854   return true;
 855 }
 856
 857 //===--------------------------------------------------------------------===//
 858
 859 /// getAL - Returns a ARMCC::AL immediate node.
 860 static inline SDValue getAL(SelectionDAG *CurDAG) {
 861   return CurDAG->getTargetConstant((uint64_t)ARMCC::AL, MVT::i32);
 862 }
 863
 864 SDNode *ARMDAGToDAGISel::SelectARMIndexedLoad(SDNode *N) {
 865   LoadSDNode *LD = cast<LoadSDNode>(N);
 866   ISD::MemIndexedMode AM = LD->getAddressingMode();
 867   if (AM == ISD::UNINDEXED)
 868     return NULL;
 869
 870   EVT LoadedVT = LD->getMemoryVT();
 871   SDValue Offset, AMOpc;
 872   bool isPre = (AM == ISD::PRE_INC) || (AM == ISD::PRE_DEC);
 873   unsigned Opcode = 0;
 874   bool Match = false;
 875   if (LoadedVT == MVT::i32 &&
 876       SelectAddrMode2Offset(N, LD->getOffset(), Offset, AMOpc)) {
 877     Opcode = isPre ? ARM::LDR_PRE : ARM::LDR_POST;
 878     Match = true;
 879   } else if (LoadedVT == MVT::i16 &&
 880              SelectAddrMode3Offset(N, LD->getOffset(), Offset, AMOpc)) {
 881     Match = true;
 882     Opcode = (LD->getExtensionType() == ISD::SEXTLOAD)
 883       ? (isPre ? ARM::LDRSH_PRE : ARM::LDRSH_POST)
 884       : (isPre ? ARM::LDRH_PRE : ARM::LDRH_POST);
 885   } else if (LoadedVT == MVT::i8 || LoadedVT == MVT::i1) {
 886     if (LD->getExtensionType() == ISD::SEXTLOAD) {
 887       if (SelectAddrMode3Offset(N, LD->getOffset(), Offset, AMOpc)) {
 888         Match = true;
 889         Opcode = isPre ? ARM::LDRSB_PRE : ARM::LDRSB_POST;
 890       }
 891     } else {
 892       if (SelectAddrMode2Offset(N, LD->getOffset(), Offset, AMOpc)) {
 893         Match = true;
 894         Opcode = isPre ? ARM::LDRB_PRE : ARM::LDRB_POST;
 895       }
 896     }
 897   }
 898
 899   if (Match) {
 900     SDValue Chain = LD->getChain();
 901     SDValue Base = LD->getBasePtr();
 902     SDValue Ops[]= { Base, Offset, AMOpc, getAL(CurDAG),
 903                      CurDAG->getRegister(0, MVT::i32), Chain };
 904     return CurDAG->getMachineNode(Opcode, N->getDebugLoc(), MVT::i32, MVT::i32,
 905                                   MVT::Other, Ops, 6);
 906   }
 907
 908   return NULL;
 909 }
 910
 911 SDNode *ARMDAGToDAGISel::SelectT2IndexedLoad(SDNode *N) {
 912   LoadSDNode *LD = cast<LoadSDNode>(N);
 913   ISD::MemIndexedMode AM = LD->getAddressingMode();
 914   if (AM == ISD::UNINDEXED)
 915     return NULL;
 916
 917   EVT LoadedVT = LD->getMemoryVT();
 918   bool isSExtLd = LD->getExtensionType() == ISD::SEXTLOAD;
 919   SDValue Offset;
 920   bool isPre = (AM == ISD::PRE_INC) || (AM == ISD::PRE_DEC);
 921   unsigned Opcode = 0;
 922   bool Match = false;
 923   if (SelectT2AddrModeImm8Offset(N, LD->getOffset(), Offset)) {
 924     switch (LoadedVT.getSimpleVT().SimpleTy) {
 925     case MVT::i32:
 926       Opcode = isPre ? ARM::t2LDR_PRE : ARM::t2LDR_POST;
 927       break;
 928     case MVT::i16:
 929       if (isSExtLd)
 930         Opcode = isPre ? ARM::t2LDRSH_PRE : ARM::t2LDRSH_POST;
 931       else
 932         Opcode = isPre ? ARM::t2LDRH_PRE : ARM::t2LDRH_POST;
 933       break;
 934     case MVT::i8:
 935     case MVT::i1:
 936       if (isSExtLd)
 937         Opcode = isPre ? ARM::t2LDRSB_PRE : ARM::t2LDRSB_POST;
 938       else
 939         Opcode = isPre ? ARM::t2LDRB_PRE : ARM::t2LDRB_POST;
 940       break;
 941     default:
 942       return NULL;
 943     }
 944     Match = true;
 945   }
 946
 947   if (Match) {
 948     SDValue Chain = LD->getChain();
 949     SDValue Base = LD->getBasePtr();
 950     SDValue Ops[]= { Base, Offset, getAL(CurDAG),
 951                      CurDAG->getRegister(0, MVT::i32), Chain };
 952     return CurDAG->getMachineNode(Opcode, N->getDebugLoc(), MVT::i32, MVT::i32,
 953                                   MVT::Other, Ops, 5);
 954   }
 955
 956   return NULL;
 957 }
 958
 959 /// PairSRegs - Form a D register from a pair of S registers.
 960 ///
 961 SDNode *ARMDAGToDAGISel::PairSRegs(EVT VT, SDValue V0, SDValue V1) {
 962   DebugLoc dl = V0.getNode()->getDebugLoc();
 963   SDValue SubReg0 = CurDAG->getTargetConstant(ARM::ssub_0, MVT::i32);
 964   SDValue SubReg1 = CurDAG->getTargetConstant(ARM::ssub_1, MVT::i32);
 965   if (llvm::ModelWithRegSequence()) {
 966     const SDValue Ops[] = { V0, SubReg0, V1, SubReg1 };
 967     return CurDAG->getMachineNode(TargetOpcode::REG_SEQUENCE, dl, VT, Ops, 4);
 968   }
 969   SDValue Undef =
 970     SDValue(CurDAG->getMachineNode(TargetOpcode::IMPLICIT_DEF, dl, VT), 0);
 971   SDNode *Pair = CurDAG->getMachineNode(TargetOpcode::INSERT_SUBREG, dl,
 972                                         VT, Undef, V0, SubReg0);
 973   return CurDAG->getMachineNode(TargetOpcode::INSERT_SUBREG, dl,
 974                                 VT, SDValue(Pair, 0), V1, SubReg1);
 975 }
 976
 977 /// PairDRegs - Form a quad register from a pair of D registers.
 978 ///
 979 SDNode *ARMDAGToDAGISel::PairDRegs(EVT VT, SDValue V0, SDValue V1) {
 980   DebugLoc dl = V0.getNode()->getDebugLoc();
 981   SDValue SubReg0 = CurDAG->getTargetConstant(ARM::dsub_0, MVT::i32);
 982   SDValue SubReg1 = CurDAG->getTargetConstant(ARM::dsub_1, MVT::i32);
 983   if (llvm::ModelWithRegSequence()) {
 984     const SDValue Ops[] = { V0, SubReg0, V1, SubReg1 };
 985     return CurDAG->getMachineNode(TargetOpcode::REG_SEQUENCE, dl, VT, Ops, 4);
 986   }
 987   SDValue Undef =
 988     SDValue(CurDAG->getMachineNode(TargetOpcode::IMPLICIT_DEF, dl, VT), 0);
 989   SDNode *Pair = CurDAG->getMachineNode(TargetOpcode::INSERT_SUBREG, dl,
 990                                         VT, Undef, V0, SubReg0);
 991   return CurDAG->getMachineNode(TargetOpcode::INSERT_SUBREG, dl,
 992                                 VT, SDValue(Pair, 0), V1, SubReg1);
 993 }
 994
 995 /// PairQRegs - Form 4 consecutive D registers from a pair of Q registers.
 996 ///
 997 SDNode *ARMDAGToDAGISel::PairQRegs(EVT VT, SDValue V0, SDValue V1) {
 998   DebugLoc dl = V0.getNode()->getDebugLoc();
 999   SDValue SubReg0 = CurDAG->getTargetConstant(ARM::qsub_0, MVT::i32);
1000   SDValue SubReg1 = CurDAG->getTargetConstant(ARM::qsub_1, MVT::i32);
1001   const SDValue Ops[] = { V0, SubReg0, V1, SubReg1 };
1002   return CurDAG->getMachineNode(TargetOpcode::REG_SEQUENCE, dl, VT, Ops, 4);
1003 }
1004
1005 /// QuadSRegs - Form 4 consecutive S registers.
1006 ///
1007 SDNode *ARMDAGToDAGISel::QuadSRegs(EVT VT, SDValue V0, SDValue V1,
1008                                    SDValue V2, SDValue V3) {
1009   DebugLoc dl = V0.getNode()->getDebugLoc();
1010   SDValue SubReg0 = CurDAG->getTargetConstant(ARM::ssub_0, MVT::i32);
1011   SDValue SubReg1 = CurDAG->getTargetConstant(ARM::ssub_1, MVT::i32);
1012   SDValue SubReg2 = CurDAG->getTargetConstant(ARM::ssub_2, MVT::i32);
1013   SDValue SubReg3 = CurDAG->getTargetConstant(ARM::ssub_3, MVT::i32);
1014   const SDValue Ops[] = { V0, SubReg0, V1, SubReg1, V2, SubReg2, V3, SubReg3 };
1015   return CurDAG->getMachineNode(TargetOpcode::REG_SEQUENCE, dl, VT, Ops, 8);
1016 }
1017
1018 /// QuadDRegs - Form 4 consecutive D registers.
1019 ///
1020 SDNode *ARMDAGToDAGISel::QuadDRegs(EVT VT, SDValue V0, SDValue V1,
1021                                    SDValue V2, SDValue V3) {
1022   DebugLoc dl = V0.getNode()->getDebugLoc();
1023   SDValue SubReg0 = CurDAG->getTargetConstant(ARM::dsub_0, MVT::i32);
1024   SDValue SubReg1 = CurDAG->getTargetConstant(ARM::dsub_1, MVT::i32);
1025   SDValue SubReg2 = CurDAG->getTargetConstant(ARM::dsub_2, MVT::i32);
1026   SDValue SubReg3 = CurDAG->getTargetConstant(ARM::dsub_3, MVT::i32);
1027   const SDValue Ops[] = { V0, SubReg0, V1, SubReg1, V2, SubReg2, V3, SubReg3 };
1028   return CurDAG->getMachineNode(TargetOpcode::REG_SEQUENCE, dl, VT, Ops, 8);
1029 }
1030
1031 /// QuadQRegs - Form 4 consecutive Q registers.
1032 ///
1033 SDNode *ARMDAGToDAGISel::QuadQRegs(EVT VT, SDValue V0, SDValue V1,
1034                                    SDValue V2, SDValue V3) {
1035   DebugLoc dl = V0.getNode()->getDebugLoc();
1036   SDValue SubReg0 = CurDAG->getTargetConstant(ARM::qsub_0, MVT::i32);
1037   SDValue SubReg1 = CurDAG->getTargetConstant(ARM::qsub_1, MVT::i32);
1038   SDValue SubReg2 = CurDAG->getTargetConstant(ARM::qsub_2, MVT::i32);
1039   SDValue SubReg3 = CurDAG->getTargetConstant(ARM::qsub_3, MVT::i32);
1040   const SDValue Ops[] = { V0, SubReg0, V1, SubReg1, V2, SubReg2, V3, SubReg3 };
1041   return CurDAG->getMachineNode(TargetOpcode::REG_SEQUENCE, dl, VT, Ops, 8);
1042 }
1043
1044 /// OctoDRegs - Form 8 consecutive D registers.
1045 ///
1046 SDNode *ARMDAGToDAGISel::OctoDRegs(EVT VT, SDValue V0, SDValue V1,
1047                                    SDValue V2, SDValue V3,
1048                                    SDValue V4, SDValue V5,
1049                                    SDValue V6, SDValue V7) {
1050   DebugLoc dl = V0.getNode()->getDebugLoc();
1051   SDValue SubReg0 = CurDAG->getTargetConstant(ARM::dsub_0, MVT::i32);
1052   SDValue SubReg1 = CurDAG->getTargetConstant(ARM::dsub_1, MVT::i32);
1053   SDValue SubReg2 = CurDAG->getTargetConstant(ARM::dsub_2, MVT::i32);
1054   SDValue SubReg3 = CurDAG->getTargetConstant(ARM::dsub_3, MVT::i32);
1055   SDValue SubReg4 = CurDAG->getTargetConstant(ARM::dsub_4, MVT::i32);
1056   SDValue SubReg5 = CurDAG->getTargetConstant(ARM::dsub_5, MVT::i32);
1057   SDValue SubReg6 = CurDAG->getTargetConstant(ARM::dsub_6, MVT::i32);
1058   SDValue SubReg7 = CurDAG->getTargetConstant(ARM::dsub_7, MVT::i32);
1059   const SDValue Ops[] ={ V0, SubReg0, V1, SubReg1, V2, SubReg2, V3, SubReg3,
1060                          V4, SubReg4, V5, SubReg5, V6, SubReg6, V7, SubReg7 };
1061   return CurDAG->getMachineNode(TargetOpcode::REG_SEQUENCE, dl, VT, Ops, 16);
1062 }
1063
1064 /// GetNEONSubregVT - Given a type for a 128-bit NEON vector, return the type
1065 /// for a 64-bit subregister of the vector.
1066 static EVT GetNEONSubregVT(EVT VT) {
1067   switch (VT.getSimpleVT().SimpleTy) {
1068   default: llvm_unreachable("unhandled NEON type");
1069   case MVT::v16i8: return MVT::v8i8;
1070   case MVT::v8i16: return MVT::v4i16;
1071   case MVT::v4f32: return MVT::v2f32;
1072   case MVT::v4i32: return MVT::v2i32;
1073   case MVT::v2i64: return MVT::v1i64;
1074   }
1075 }
1076
1077 SDNode *ARMDAGToDAGISel::SelectVLD(SDNode *N, unsigned NumVecs,
1078                                    unsigned *DOpcodes, unsigned *QOpcodes0,
1079                                    unsigned *QOpcodes1) {
1080   assert(NumVecs >= 1 && NumVecs <= 4 && "VLD NumVecs out-of-range");
1081   DebugLoc dl = N->getDebugLoc();
1082
1083   SDValue MemAddr, Align;
1084   if (!SelectAddrMode6(N, N->getOperand(2), MemAddr, Align))
1085     return NULL;
1086
1087   SDValue Chain = N->getOperand(0);
1088   EVT VT = N->getValueType(0);
1089   bool is64BitVector = VT.is64BitVector();
1090
1091   unsigned OpcodeIndex;
1092   switch (VT.getSimpleVT().SimpleTy) {
1093   default: llvm_unreachable("unhandled vld type");
1094     // Double-register operations:
1095   case MVT::v8i8:  OpcodeIndex = 0; break;
1096   case MVT::v4i16: OpcodeIndex = 1; break;
1097   case MVT::v2f32:
1098   case MVT::v2i32: OpcodeIndex = 2; break;
1099   case MVT::v1i64: OpcodeIndex = 3; break;
1100     // Quad-register operations:
1101   case MVT::v16i8: OpcodeIndex = 0; break;
1102   case MVT::v8i16: OpcodeIndex = 1; break;
1103   case MVT::v4f32:
1104   case MVT::v4i32: OpcodeIndex = 2; break;
1105   case MVT::v2i64: OpcodeIndex = 3;
1106     assert(NumVecs == 1 && "v2i64 type only supported for VLD1");
1107     break;
1108   }
1109
1110   SDValue Pred = getAL(CurDAG);
1111   SDValue Reg0 = CurDAG->getRegister(0, MVT::i32);
1112   if (is64BitVector) {
1113     unsigned Opc = DOpcodes[OpcodeIndex];
1114     const SDValue Ops[] = { MemAddr, Align, Pred, Reg0, Chain };
1115     std::vector<EVT> ResTys(NumVecs, VT);
1116     ResTys.push_back(MVT::Other);
1117     SDNode *VLd = CurDAG->getMachineNode(Opc, dl, ResTys, Ops, 5);
1118     if (!llvm::ModelWithRegSequence() || NumVecs < 2)
1119       return VLd;
1120
1121     SDValue RegSeq;
1122     SDValue V0 = SDValue(VLd, 0);
1123     SDValue V1 = SDValue(VLd, 1);
1124
1125     // Form a REG_SEQUENCE to force register allocation.
1126     if (NumVecs == 2)
1127       RegSeq = SDValue(PairDRegs(MVT::v2i64, V0, V1), 0);
1128     else {
1129       SDValue V2 = SDValue(VLd, 2);
1130       // If it's a vld3, form a quad D-register but discard the last part.
1131       SDValue V3 = (NumVecs == 3)
1132           ? SDValue(CurDAG->getMachineNode(TargetOpcode::IMPLICIT_DEF,dl,VT), 0)
1133           : SDValue(VLd, 3);
1134       RegSeq = SDValue(QuadDRegs(MVT::v4i64, V0, V1, V2, V3), 0);
1135     }
1136
1137     assert(ARM::dsub_7 == ARM::dsub_0+7 && "Unexpected subreg numbering");
1138     for (unsigned Vec = 0; Vec < NumVecs; ++Vec) {
1139       SDValue D = CurDAG->getTargetExtractSubreg(ARM::dsub_0+Vec,
1140                                                  dl, VT, RegSeq);
1141       ReplaceUses(SDValue(N, Vec), D);
1142     }
1143     ReplaceUses(SDValue(N, NumVecs), SDValue(VLd, NumVecs));
1144     return NULL;
1145   }
1146
1147   EVT RegVT = GetNEONSubregVT(VT);
1148   if (NumVecs <= 2) {
1149     // Quad registers are directly supported for VLD1 and VLD2,
1150     // loading pairs of D regs.
1151     unsigned Opc = QOpcodes0[OpcodeIndex];
1152     const SDValue Ops[] = { MemAddr, Align, Pred, Reg0, Chain };
1153     std::vector<EVT> ResTys(2 * NumVecs, RegVT);
1154     ResTys.push_back(MVT::Other);
1155     SDNode *VLd = CurDAG->getMachineNode(Opc, dl, ResTys, Ops, 5);
1156     Chain = SDValue(VLd, 2 * NumVecs);
1157
1158     // Combine the even and odd subregs to produce the result.
1159     if (llvm::ModelWithRegSequence()) {
1160       if (NumVecs == 1) {
1161         SDNode *Q = PairDRegs(VT, SDValue(VLd, 0), SDValue(VLd, 1));
1162         ReplaceUses(SDValue(N, 0), SDValue(Q, 0));
1163       } else {
1164         SDValue QQ = SDValue(QuadDRegs(MVT::v4i64,
1165                                        SDValue(VLd, 0), SDValue(VLd, 1),
1166                                        SDValue(VLd, 2), SDValue(VLd, 3)), 0);
1167         SDValue Q0 = CurDAG->getTargetExtractSubreg(ARM::qsub_0, dl, VT, QQ);
1168         SDValue Q1 = CurDAG->getTargetExtractSubreg(ARM::qsub_1, dl, VT, QQ);
1169         ReplaceUses(SDValue(N, 0), Q0);
1170         ReplaceUses(SDValue(N, 1), Q1);
1171       }
1172     } else {
1173       for (unsigned Vec = 0; Vec < NumVecs; ++Vec) {
1174         SDNode *Q = PairDRegs(VT, SDValue(VLd, 2*Vec), SDValue(VLd, 2*Vec+1));
1175         ReplaceUses(SDValue(N, Vec), SDValue(Q, 0));
1176       }
1177     }
1178   } else {
1179     // Otherwise, quad registers are loaded with two separate instructions,
1180     // where one loads the even registers and the other loads the odd registers.
1181
1182     std::vector<EVT> ResTys(NumVecs, RegVT);
1183     ResTys.push_back(MemAddr.getValueType());
1184     ResTys.push_back(MVT::Other);
1185
1186     // Load the even subregs.
1187     unsigned Opc = QOpcodes0[OpcodeIndex];
1188     const SDValue OpsA[] = { MemAddr, Align, Reg0, Pred, Reg0, Chain };
1189     SDNode *VLdA = CurDAG->getMachineNode(Opc, dl, ResTys, OpsA, 6);
1190     Chain = SDValue(VLdA, NumVecs+1);
1191
1192     // Load the odd subregs.
1193     Opc = QOpcodes1[OpcodeIndex];
1194     const SDValue OpsB[] = { SDValue(VLdA, NumVecs),
1195                              Align, Reg0, Pred, Reg0, Chain };
1196     SDNode *VLdB = CurDAG->getMachineNode(Opc, dl, ResTys, OpsB, 6);
1197     Chain = SDValue(VLdB, NumVecs+1);
1198
1199     if (llvm::ModelWithRegSequence()) {
1200       SDValue V0 = SDValue(VLdA, 0);
1201       SDValue V1 = SDValue(VLdB, 0);
1202       SDValue V2 = SDValue(VLdA, 1);
1203       SDValue V3 = SDValue(VLdB, 1);
1204       SDValue V4 = SDValue(VLdA, 2);
1205       SDValue V5 = SDValue(VLdB, 2);
1206       SDValue V6 = (NumVecs == 3)
1207           ? SDValue(CurDAG->getMachineNode(TargetOpcode::IMPLICIT_DEF,dl,RegVT),
1208                     0)
1209           : SDValue(VLdA, 3);
1210       SDValue V7 = (NumVecs == 3)
1211           ? SDValue(CurDAG->getMachineNode(TargetOpcode::IMPLICIT_DEF,dl,RegVT),
1212                     0)
1213           : SDValue(VLdB, 3);
1214       SDValue RegSeq = SDValue(OctoDRegs(MVT::v8i64, V0, V1, V2, V3,
1215                                          V4, V5, V6, V7), 0);
1216
1217       // Extract out the 3 / 4 Q registers.
1218       assert(ARM::qsub_3 == ARM::qsub_0+3 && "Unexpected subreg numbering");
1219       for (unsigned Vec = 0; Vec < NumVecs; ++Vec) {
1220         SDValue Q = CurDAG->getTargetExtractSubreg(ARM::qsub_0+Vec,
1221                                                    dl, VT, RegSeq);
1222         ReplaceUses(SDValue(N, Vec), Q);
1223       }
1224     } else {
1225       // Combine the even and odd subregs to produce the result.
1226       for (unsigned Vec = 0; Vec < NumVecs; ++Vec) {
1227         SDNode *Q = PairDRegs(VT, SDValue(VLdA, Vec), SDValue(VLdB, Vec));
1228         ReplaceUses(SDValue(N, Vec), SDValue(Q, 0));
1229       }
1230     }
1231   }
1232   ReplaceUses(SDValue(N, NumVecs), Chain);
1233   return NULL;
1234 }
1235
1236 SDNode *ARMDAGToDAGISel::SelectVST(SDNode *N, unsigned NumVecs,
1237                                    unsigned *DOpcodes, unsigned *QOpcodes0,
1238                                    unsigned *QOpcodes1) {
1239   assert(NumVecs >=1 && NumVecs <= 4 && "VST NumVecs out-of-range");
1240   DebugLoc dl = N->getDebugLoc();
1241
1242   SDValue MemAddr, Align;
1243   if (!SelectAddrMode6(N, N->getOperand(2), MemAddr, Align))
1244     return NULL;
1245
1246   SDValue Chain = N->getOperand(0);
1247   EVT VT = N->getOperand(3).getValueType();
1248   bool is64BitVector = VT.is64BitVector();
1249
1250   unsigned OpcodeIndex;
1251   switch (VT.getSimpleVT().SimpleTy) {
1252   default: llvm_unreachable("unhandled vst type");
1253     // Double-register operations:
1254   case MVT::v8i8:  OpcodeIndex = 0; break;
1255   case MVT::v4i16: OpcodeIndex = 1; break;
1256   case MVT::v2f32:
1257   case MVT::v2i32: OpcodeIndex = 2; break;
1258   case MVT::v1i64: OpcodeIndex = 3; break;
1259     // Quad-register operations:
1260   case MVT::v16i8: OpcodeIndex = 0; break;
1261   case MVT::v8i16: OpcodeIndex = 1; break;
1262   case MVT::v4f32:
1263   case MVT::v4i32: OpcodeIndex = 2; break;
1264   case MVT::v2i64: OpcodeIndex = 3;
1265     assert(NumVecs == 1 && "v2i64 type only supported for VST1");
1266     break;
1267   }
1268
1269   SDValue Pred = getAL(CurDAG);
1270   SDValue Reg0 = CurDAG->getRegister(0, MVT::i32);
1271
1272   SmallVector<SDValue, 10> Ops;
1273   Ops.push_back(MemAddr);
1274   Ops.push_back(Align);
1275
1276   if (is64BitVector) {
1277     if (llvm::ModelWithRegSequence() && NumVecs >= 2) {
1278       SDValue RegSeq;
1279       SDValue V0 = N->getOperand(0+3);
1280       SDValue V1 = N->getOperand(1+3);
1281
1282       // Form a REG_SEQUENCE to force register allocation.
1283       if (NumVecs == 2)
1284         RegSeq = SDValue(PairDRegs(MVT::v2i64, V0, V1), 0);
1285       else {
1286         SDValue V2 = N->getOperand(2+3);
1287         // If it's a vld3, form a quad D-register and leave the last part as
1288         // an undef.
1289         SDValue V3 = (NumVecs == 3)
1290           ? SDValue(CurDAG->getMachineNode(TargetOpcode::IMPLICIT_DEF,dl,VT), 0)
1291           : N->getOperand(3+3);
1292         RegSeq = SDValue(QuadDRegs(MVT::v4i64, V0, V1, V2, V3), 0);
1293       }
1294
1295       // Now extract the D registers back out.
1296       Ops.push_back(CurDAG->getTargetExtractSubreg(ARM::dsub_0, dl, VT,
1297                                                    RegSeq));
1298       Ops.push_back(CurDAG->getTargetExtractSubreg(ARM::dsub_1, dl, VT,
1299                                                    RegSeq));
1300       if (NumVecs > 2)
1301         Ops.push_back(CurDAG->getTargetExtractSubreg(ARM::dsub_2, dl, VT,
1302                                                      RegSeq));
1303       if (NumVecs > 3)
1304         Ops.push_back(CurDAG->getTargetExtractSubreg(ARM::dsub_3, dl, VT,
1305                                                      RegSeq));
1306     } else {
1307       for (unsigned Vec = 0; Vec < NumVecs; ++Vec)
1308         Ops.push_back(N->getOperand(Vec+3));
1309     }
1310     Ops.push_back(Pred);
1311     Ops.push_back(Reg0); // predicate register
1312     Ops.push_back(Chain);
1313     unsigned Opc = DOpcodes[OpcodeIndex];
1314     return CurDAG->getMachineNode(Opc, dl, MVT::Other, Ops.data(), NumVecs+5);
1315   }
1316
1317   EVT RegVT = GetNEONSubregVT(VT);
1318   if (NumVecs <= 2) {
1319     // Quad registers are directly supported for VST1 and VST2,
1320     // storing pairs of D regs.
1321     unsigned Opc = QOpcodes0[OpcodeIndex];
1322     if (llvm::ModelWithRegSequence() && NumVecs == 2) {
1323       // First extract the pair of Q registers.
1324       SDValue Q0 = N->getOperand(3);
1325       SDValue Q1 = N->getOperand(4);
1326
1327       // Form a QQ register.
1328       SDValue QQ = SDValue(PairQRegs(MVT::v4i64, Q0, Q1), 0);
1329
1330       // Now extract the D registers back out.
1331       Ops.push_back(CurDAG->getTargetExtractSubreg(ARM::dsub_0, dl, RegVT,
1332                                                    QQ));
1333       Ops.push_back(CurDAG->getTargetExtractSubreg(ARM::dsub_1, dl, RegVT,
1334                                                    QQ));
1335       Ops.push_back(CurDAG->getTargetExtractSubreg(ARM::dsub_2, dl, RegVT,
1336                                                    QQ));
1337       Ops.push_back(CurDAG->getTargetExtractSubreg(ARM::dsub_3, dl, RegVT,
1338                                                    QQ));
1339       Ops.push_back(Pred);
1340       Ops.push_back(Reg0); // predicate register
1341       Ops.push_back(Chain);
1342       return CurDAG->getMachineNode(Opc, dl, MVT::Other, Ops.data(), 5 + 4);
1343     } else {
1344       for (unsigned Vec = 0; Vec < NumVecs; ++Vec) {
1345         Ops.push_back(CurDAG->getTargetExtractSubreg(ARM::dsub_0, dl, RegVT,
1346                                                      N->getOperand(Vec+3)));
1347         Ops.push_back(CurDAG->getTargetExtractSubreg(ARM::dsub_1, dl, RegVT,
1348                                                      N->getOperand(Vec+3)));
1349       }
1350       Ops.push_back(Pred);
1351       Ops.push_back(Reg0); // predicate register
1352       Ops.push_back(Chain);
1353       return CurDAG->getMachineNode(Opc, dl, MVT::Other, Ops.data(),
1354                                     5 + 2 * NumVecs);
1355     }
1356   }
1357
1358   // Otherwise, quad registers are stored with two separate instructions,
1359   // where one stores the even registers and the other stores the odd registers.
1360   if (llvm::ModelWithRegSequence()) {
1361     // Form the QQQQ REG_SEQUENCE.
1362     SDValue V[8];
1363     for (unsigned Vec = 0, i = 0; Vec < NumVecs; ++Vec, i+=2) {
1364       V[i]   = CurDAG->getTargetExtractSubreg(ARM::dsub_0, dl, RegVT,
1365                                               N->getOperand(Vec+3));
1366       V[i+1] = CurDAG->getTargetExtractSubreg(ARM::dsub_1, dl, RegVT,
1367                                               N->getOperand(Vec+3));
1368     }
1369     if (NumVecs == 3)
1370       V[6] = V[7] = SDValue(CurDAG->getMachineNode(TargetOpcode::IMPLICIT_DEF,
1371                                                    dl, RegVT), 0);
1372
1373     SDValue RegSeq = SDValue(OctoDRegs(MVT::v8i64, V[0], V[1], V[2], V[3],
1374                                        V[4], V[5], V[6], V[7]), 0);
1375
1376     // Store the even D registers.
1377     assert(ARM::dsub_7 == ARM::dsub_0+7 && "Unexpected subreg numbering");
1378     Ops.push_back(Reg0); // post-access address offset
1379     for (unsigned Vec = 0; Vec < NumVecs; ++Vec)
1380       Ops.push_back(CurDAG->getTargetExtractSubreg(ARM::dsub_0+Vec*2, dl,
1381                                                    RegVT, RegSeq));
1382     Ops.push_back(Pred);
1383     Ops.push_back(Reg0); // predicate register
1384     Ops.push_back(Chain);
1385     unsigned Opc = QOpcodes0[OpcodeIndex];
1386     SDNode *VStA = CurDAG->getMachineNode(Opc, dl, MemAddr.getValueType(),
1387                                           MVT::Other, Ops.data(), NumVecs+6);
1388     Chain = SDValue(VStA, 1);
1389
1390     // Store the odd D registers.
1391     Ops[0] = SDValue(VStA, 0); // MemAddr
1392     for (unsigned Vec = 0; Vec < NumVecs; ++Vec)
1393       Ops[Vec+3] = CurDAG->getTargetExtractSubreg(ARM::dsub_1+Vec*2, dl,
1394                                                   RegVT, RegSeq);
1395     Ops[NumVecs+5] = Chain;
1396     Opc = QOpcodes1[OpcodeIndex];
1397     SDNode *VStB = CurDAG->getMachineNode(Opc, dl, MemAddr.getValueType(),
1398                                           MVT::Other, Ops.data(), NumVecs+6);
1399     Chain = SDValue(VStB, 1);
1400     ReplaceUses(SDValue(N, 0), Chain);
1401     return NULL;
1402   } else {
1403     Ops.push_back(Reg0); // post-access address offset
1404
1405     // Store the even subregs.
1406     for (unsigned Vec = 0; Vec < NumVecs; ++Vec)
1407       Ops.push_back(CurDAG->getTargetExtractSubreg(ARM::dsub_0, dl, RegVT,
1408                                                    N->getOperand(Vec+3)));
1409     Ops.push_back(Pred);
1410     Ops.push_back(Reg0); // predicate register
1411     Ops.push_back(Chain);
1412     unsigned Opc = QOpcodes0[OpcodeIndex];
1413     SDNode *VStA = CurDAG->getMachineNode(Opc, dl, MemAddr.getValueType(),
1414                                           MVT::Other, Ops.data(), NumVecs+6);
1415     Chain = SDValue(VStA, 1);
1416
1417     // Store the odd subregs.
1418     Ops[0] = SDValue(VStA, 0); // MemAddr
1419     for (unsigned Vec = 0; Vec < NumVecs; ++Vec)
1420       Ops[Vec+3] = CurDAG->getTargetExtractSubreg(ARM::dsub_1, dl, RegVT,
1421                                                   N->getOperand(Vec+3));
1422     Ops[NumVecs+5] = Chain;
1423     Opc = QOpcodes1[OpcodeIndex];
1424     SDNode *VStB = CurDAG->getMachineNode(Opc, dl, MemAddr.getValueType(),
1425                                           MVT::Other, Ops.data(), NumVecs+6);
1426     Chain = SDValue(VStB, 1);
1427     ReplaceUses(SDValue(N, 0), Chain);
1428     return NULL;
1429   }
1430 }
1431
1432 SDNode *ARMDAGToDAGISel::SelectVLDSTLane(SDNode *N, bool IsLoad,
1433                                          unsigned NumVecs, unsigned *DOpcodes,
1434                                          unsigned *QOpcodes0,
1435                                          unsigned *QOpcodes1) {
1436   assert(NumVecs >=2 && NumVecs <= 4 && "VLDSTLane NumVecs out-of-range");
1437   DebugLoc dl = N->getDebugLoc();
1438
1439   SDValue MemAddr, Align;
1440   if (!SelectAddrMode6(N, N->getOperand(2), MemAddr, Align))
1441     return NULL;
1442
1443   SDValue Chain = N->getOperand(0);
1444   unsigned Lane =
1445     cast<ConstantSDNode>(N->getOperand(NumVecs+3))->getZExtValue();
1446   EVT VT = IsLoad ? N->getValueType(0) : N->getOperand(3).getValueType();
1447   bool is64BitVector = VT.is64BitVector();
1448
1449   // Quad registers are handled by load/store of subregs. Find the subreg info.
1450   unsigned NumElts = 0;
1451   int SubregIdx = 0;
1452   bool Even = false;
1453   EVT RegVT = VT;
1454   if (!is64BitVector) {
1455     RegVT = GetNEONSubregVT(VT);
1456     NumElts = RegVT.getVectorNumElements();
1457     SubregIdx = (Lane < NumElts) ? ARM::dsub_0 : ARM::dsub_1;
1458     Even = Lane < NumElts;
1459   }
1460
1461   unsigned OpcodeIndex;
1462   switch (VT.getSimpleVT().SimpleTy) {
1463   default: llvm_unreachable("unhandled vld/vst lane type");
1464     // Double-register operations:
1465   case MVT::v8i8:  OpcodeIndex = 0; break;
1466   case MVT::v4i16: OpcodeIndex = 1; break;
1467   case MVT::v2f32:
1468   case MVT::v2i32: OpcodeIndex = 2; break;
1469     // Quad-register operations:
1470   case MVT::v8i16: OpcodeIndex = 0; break;
1471   case MVT::v4f32:
1472   case MVT::v4i32: OpcodeIndex = 1; break;
1473   }
1474
1475   SDValue Pred = getAL(CurDAG);
1476   SDValue Reg0 = CurDAG->getRegister(0, MVT::i32);
1477
1478   SmallVector<SDValue, 10> Ops;
1479   Ops.push_back(MemAddr);
1480   Ops.push_back(Align);
1481
1482   unsigned Opc = 0;
1483   if (is64BitVector) {
1484     Opc = DOpcodes[OpcodeIndex];
1485     if (llvm::ModelWithRegSequence()) {
1486       SDValue RegSeq;
1487       SDValue V0 = N->getOperand(0+3);
1488       SDValue V1 = N->getOperand(1+3);
1489       if (NumVecs == 2) {
1490         RegSeq = SDValue(PairDRegs(MVT::v2i64, V0, V1), 0);
1491       } else {
1492         SDValue V2 = N->getOperand(2+3);
1493         SDValue V3 = (NumVecs == 3)
1494           ? SDValue(CurDAG->getMachineNode(TargetOpcode::IMPLICIT_DEF,dl,VT), 0)
1495           : N->getOperand(3+3);
1496         RegSeq = SDValue(QuadDRegs(MVT::v4i64, V0, V1, V2, V3), 0);
1497       }
1498
1499       // Now extract the D registers back out.
1500       Ops.push_back(CurDAG->getTargetExtractSubreg(ARM::dsub_0, dl, VT,
1501                                                    RegSeq));
1502       Ops.push_back(CurDAG->getTargetExtractSubreg(ARM::dsub_1, dl, VT,
1503                                                    RegSeq));
1504       if (NumVecs > 2)
1505         Ops.push_back(CurDAG->getTargetExtractSubreg(ARM::dsub_2, dl, VT,
1506                                                      RegSeq));
1507       if (NumVecs > 3)
1508         Ops.push_back(CurDAG->getTargetExtractSubreg(ARM::dsub_3, dl, VT,
1509                                                      RegSeq));
1510     } else {
1511       for (unsigned Vec = 0; Vec < NumVecs; ++Vec)
1512         Ops.push_back(N->getOperand(Vec+3));
1513     }
1514   } else {
1515     // Check if this is loading the even or odd subreg of a Q register.
1516     if (Lane < NumElts) {
1517       Opc = QOpcodes0[OpcodeIndex];
1518     } else {
1519       Lane -= NumElts;
1520       Opc = QOpcodes1[OpcodeIndex];
1521     }
1522
1523     if (llvm::ModelWithRegSequence()) {
1524       SDValue RegSeq;
1525       SDValue V0 = N->getOperand(0+3);
1526       SDValue V1 = N->getOperand(1+3);
1527       if (NumVecs == 2) {
1528         RegSeq = SDValue(PairQRegs(MVT::v4i64, V0, V1), 0);
1529       } else {
1530         SDValue V2 = N->getOperand(2+3);
1531         SDValue V3 = (NumVecs == 3)
1532           ? SDValue(CurDAG->getMachineNode(TargetOpcode::IMPLICIT_DEF,dl,VT), 0)
1533           : N->getOperand(3+3);
1534         RegSeq = SDValue(QuadQRegs(MVT::v8i64, V0, V1, V2, V3), 0);
1535       }
1536
1537       // Extract the subregs of the input vector.
1538       unsigned SubIdx = Even ? ARM::dsub_0 : ARM::dsub_1;
1539       for (unsigned Vec = 0; Vec < NumVecs; ++Vec)
1540         Ops.push_back(CurDAG->getTargetExtractSubreg(SubIdx+Vec*2, dl, RegVT,
1541                                                      RegSeq));
1542     } else {
1543       // Extract the subregs of the input vector.
1544       for (unsigned Vec = 0; Vec < NumVecs; ++Vec)
1545         Ops.push_back(CurDAG->getTargetExtractSubreg(SubregIdx, dl, RegVT,
1546                                                      N->getOperand(Vec+3)));
1547     }
1548   }
1549   Ops.push_back(getI32Imm(Lane));
1550   Ops.push_back(Pred);
1551   Ops.push_back(Reg0);
1552   Ops.push_back(Chain);
1553
1554   if (!IsLoad)
1555     return CurDAG->getMachineNode(Opc, dl, MVT::Other, Ops.data(), NumVecs+6);
1556
1557   std::vector<EVT> ResTys(NumVecs, RegVT);
1558   ResTys.push_back(MVT::Other);
1559   SDNode *VLdLn = CurDAG->getMachineNode(Opc, dl, ResTys, Ops.data(),NumVecs+6);
1560
1561   if (llvm::ModelWithRegSequence()) {
1562     // Form a REG_SEQUENCE to force register allocation.
1563     SDValue RegSeq;
1564     if (is64BitVector) {
1565       SDValue V0 = SDValue(VLdLn, 0);
1566       SDValue V1 = SDValue(VLdLn, 1);
1567       if (NumVecs == 2) {
1568         RegSeq = SDValue(PairDRegs(MVT::v2i64, V0, V1), 0);
1569       } else {
1570         SDValue V2 = SDValue(VLdLn, 2);
1571         // If it's a vld3, form a quad D-register but discard the last part.
1572         SDValue V3 = (NumVecs == 3)
1573           ? SDValue(CurDAG->getMachineNode(TargetOpcode::IMPLICIT_DEF,dl,VT), 0)
1574           : SDValue(VLdLn, 3);
1575         RegSeq = SDValue(QuadDRegs(MVT::v4i64, V0, V1, V2, V3), 0);
1576       }
1577     } else {
1578       // For 128-bit vectors, take the 64-bit results of the load and insert
1579       // them as subregs into the result.
1580       SDValue V[8];
1581       for (unsigned Vec = 0, i = 0; Vec < NumVecs; ++Vec, i+=2) {
1582         if (Even) {
1583           V[i]   = SDValue(VLdLn, Vec);
1584           V[i+1] = SDValue(CurDAG->getMachineNode(TargetOpcode::IMPLICIT_DEF,
1585                                                   dl, RegVT), 0);
1586         } else {
1587           V[i]   = SDValue(CurDAG->getMachineNode(TargetOpcode::IMPLICIT_DEF,
1588                                                   dl, RegVT), 0);
1589           V[i+1] = SDValue(VLdLn, Vec);
1590         }
1591       }
1592       if (NumVecs == 3)
1593         V[6] = V[7] = SDValue(CurDAG->getMachineNode(TargetOpcode::IMPLICIT_DEF,
1594                                                      dl, RegVT), 0);
1595
1596       if (NumVecs == 2)
1597         RegSeq = SDValue(QuadDRegs(MVT::v4i64, V[0], V[1], V[2], V[3]), 0);
1598       else
1599         RegSeq = SDValue(OctoDRegs(MVT::v8i64, V[0], V[1], V[2], V[3],
1600                                    V[4], V[5], V[6], V[7]), 0);
1601     }
1602
1603     assert(ARM::dsub_7 == ARM::dsub_0+7 && "Unexpected subreg numbering");
1604     assert(ARM::qsub_3 == ARM::qsub_0+3 && "Unexpected subreg numbering");
1605     unsigned SubIdx = is64BitVector ? ARM::dsub_0 : ARM::qsub_0;
1606     for (unsigned Vec = 0; Vec < NumVecs; ++Vec)
1607       ReplaceUses(SDValue(N, Vec),
1608                   CurDAG->getTargetExtractSubreg(SubIdx+Vec, dl, VT, RegSeq));
1609     ReplaceUses(SDValue(N, NumVecs), SDValue(VLdLn, NumVecs));
1610     return NULL;
1611   }
1612
1613   // For a 64-bit vector load to D registers, nothing more needs to be done.
1614   if (is64BitVector)
1615     return VLdLn;
1616
1617   // For 128-bit vectors, take the 64-bit results of the load and insert them
1618   // as subregs into the result.
1619   for (unsigned Vec = 0; Vec < NumVecs; ++Vec) {
1620     SDValue QuadVec = CurDAG->getTargetInsertSubreg(SubregIdx, dl, VT,
1621                                                     N->getOperand(Vec+3),
1622                                                     SDValue(VLdLn, Vec));
1623     ReplaceUses(SDValue(N, Vec), QuadVec);
1624   }
1625
1626   Chain = SDValue(VLdLn, NumVecs);
1627   ReplaceUses(SDValue(N, NumVecs), Chain);
1628   return NULL;
1629 }
1630
1631 SDNode *ARMDAGToDAGISel::SelectV6T2BitfieldExtractOp(SDNode *N,
1632                                                      bool isSigned) {
1633   if (!Subtarget->hasV6T2Ops())
1634     return NULL;
1635
1636   unsigned Opc = isSigned ? (Subtarget->isThumb() ? ARM::t2SBFX : ARM::SBFX)
1637     : (Subtarget->isThumb() ? ARM::t2UBFX : ARM::UBFX);
1638
1639
1640   // For unsigned extracts, check for a shift right and mask
1641   unsigned And_imm = 0;
1642   if (N->getOpcode() == ISD::AND) {
1643     if (isOpcWithIntImmediate(N, ISD::AND, And_imm)) {
1644
1645       // The immediate is a mask of the low bits iff imm & (imm+1) == 0
1646       if (And_imm & (And_imm + 1))
1647         return NULL;
1648
1649       unsigned Srl_imm = 0;
1650       if (isOpcWithIntImmediate(N->getOperand(0).getNode(), ISD::SRL,
1651                                 Srl_imm)) {
1652         assert(Srl_imm > 0 && Srl_imm < 32 && "bad amount in shift node!");
1653
1654         unsigned Width = CountTrailingOnes_32(And_imm);
1655         unsigned LSB = Srl_imm;
1656         SDValue Reg0 = CurDAG->getRegister(0, MVT::i32);
1657         SDValue Ops[] = { N->getOperand(0).getOperand(0),
1658                           CurDAG->getTargetConstant(LSB, MVT::i32),
1659                           CurDAG->getTargetConstant(Width, MVT::i32),
1660           getAL(CurDAG), Reg0 };
1661         return CurDAG->SelectNodeTo(N, Opc, MVT::i32, Ops, 5);
1662       }
1663     }
1664     return NULL;
1665   }
1666
1667   // Otherwise, we're looking for a shift of a shift
1668   unsigned Shl_imm = 0;
1669   if (isOpcWithIntImmediate(N->getOperand(0).getNode(), ISD::SHL, Shl_imm)) {
1670     assert(Shl_imm > 0 && Shl_imm < 32 && "bad amount in shift node!");
1671     unsigned Srl_imm = 0;
1672     if (isInt32Immediate(N->getOperand(1), Srl_imm)) {
1673       assert(Srl_imm > 0 && Srl_imm < 32 && "bad amount in shift node!");
1674       unsigned Width = 32 - Srl_imm;
1675       int LSB = Srl_imm - Shl_imm;
1676       if (LSB < 0)
1677         return NULL;
1678       SDValue Reg0 = CurDAG->getRegister(0, MVT::i32);
1679       SDValue Ops[] = { N->getOperand(0).getOperand(0),
1680                         CurDAG->getTargetConstant(LSB, MVT::i32),
1681                         CurDAG->getTargetConstant(Width, MVT::i32),
1682                         getAL(CurDAG), Reg0 };
1683       return CurDAG->SelectNodeTo(N, Opc, MVT::i32, Ops, 5);
1684     }
1685   }
1686   return NULL;
1687 }
1688
1689 SDNode *ARMDAGToDAGISel::
1690 SelectT2CMOVShiftOp(SDNode *N, SDValue FalseVal, SDValue TrueVal,
1691                     ARMCC::CondCodes CCVal, SDValue CCR, SDValue InFlag) {
1692   SDValue CPTmp0;
1693   SDValue CPTmp1;
1694   if (SelectT2ShifterOperandReg(N, TrueVal, CPTmp0, CPTmp1)) {
1695     unsigned SOVal = cast<ConstantSDNode>(CPTmp1)->getZExtValue();
1696     unsigned SOShOp = ARM_AM::getSORegShOp(SOVal);
1697     unsigned Opc = 0;
1698     switch (SOShOp) {
1699     case ARM_AM::lsl: Opc = ARM::t2MOVCClsl; break;
1700     case ARM_AM::lsr: Opc = ARM::t2MOVCClsr; break;
1701     case ARM_AM::asr: Opc = ARM::t2MOVCCasr; break;
1702     case ARM_AM::ror: Opc = ARM::t2MOVCCror; break;
1703     default:
1704       llvm_unreachable("Unknown so_reg opcode!");
1705       break;
1706     }
1707     SDValue SOShImm =
1708       CurDAG->getTargetConstant(ARM_AM::getSORegOffset(SOVal), MVT::i32);
1709     SDValue CC = CurDAG->getTargetConstant(CCVal, MVT::i32);
1710     SDValue Ops[] = { FalseVal, CPTmp0, SOShImm, CC, CCR, InFlag };
1711     return CurDAG->SelectNodeTo(N, Opc, MVT::i32,Ops, 6);
1712   }
1713   return 0;
1714 }
1715
1716 SDNode *ARMDAGToDAGISel::
1717 SelectARMCMOVShiftOp(SDNode *N, SDValue FalseVal, SDValue TrueVal,
1718                      ARMCC::CondCodes CCVal, SDValue CCR, SDValue InFlag) {
1719   SDValue CPTmp0;
1720   SDValue CPTmp1;
1721   SDValue CPTmp2;
1722   if (SelectShifterOperandReg(N, TrueVal, CPTmp0, CPTmp1, CPTmp2)) {
1723     SDValue CC = CurDAG->getTargetConstant(CCVal, MVT::i32);
1724     SDValue Ops[] = { FalseVal, CPTmp0, CPTmp1, CPTmp2, CC, CCR, InFlag };
1725     return CurDAG->SelectNodeTo(N, ARM::MOVCCs, MVT::i32, Ops, 7);
1726   }
1727   return 0;
1728 }
1729
1730 SDNode *ARMDAGToDAGISel::
1731 SelectT2CMOVSoImmOp(SDNode *N, SDValue FalseVal, SDValue TrueVal,
1732                     ARMCC::CondCodes CCVal, SDValue CCR, SDValue InFlag) {
1733   ConstantSDNode *T = dyn_cast<ConstantSDNode>(TrueVal);
1734   if (!T)
1735     return 0;
1736
1737   if (Predicate_t2_so_imm(TrueVal.getNode())) {
1738     SDValue True = CurDAG->getTargetConstant(T->getZExtValue(), MVT::i32);
1739     SDValue CC = CurDAG->getTargetConstant(CCVal, MVT::i32);
1740     SDValue Ops[] = { FalseVal, True, CC, CCR, InFlag };
1741     return CurDAG->SelectNodeTo(N,
1742                                 ARM::t2MOVCCi, MVT::i32, Ops, 5);
1743   }
1744   return 0;
1745 }
1746
1747 SDNode *ARMDAGToDAGISel::
1748 SelectARMCMOVSoImmOp(SDNode *N, SDValue FalseVal, SDValue TrueVal,
1749                      ARMCC::CondCodes CCVal, SDValue CCR, SDValue InFlag) {
1750   ConstantSDNode *T = dyn_cast<ConstantSDNode>(TrueVal);
1751   if (!T)
1752     return 0;
1753
1754   if (Predicate_so_imm(TrueVal.getNode())) {
1755     SDValue True = CurDAG->getTargetConstant(T->getZExtValue(), MVT::i32);
1756     SDValue CC = CurDAG->getTargetConstant(CCVal, MVT::i32);
1757     SDValue Ops[] = { FalseVal, True, CC, CCR, InFlag };
1758     return CurDAG->SelectNodeTo(N,
1759                                 ARM::MOVCCi, MVT::i32, Ops, 5);
1760   }
1761   return 0;
1762 }
1763
1764 SDNode *ARMDAGToDAGISel::SelectCMOVOp(SDNode *N) {
1765   EVT VT = N->getValueType(0);
1766   SDValue FalseVal = N->getOperand(0);
1767   SDValue TrueVal  = N->getOperand(1);
1768   SDValue CC = N->getOperand(2);
1769   SDValue CCR = N->getOperand(3);
1770   SDValue InFlag = N->getOperand(4);
1771   assert(CC.getOpcode() == ISD::Constant);
1772   assert(CCR.getOpcode() == ISD::Register);
1773   ARMCC::CondCodes CCVal =
1774     (ARMCC::CondCodes)cast<ConstantSDNode>(CC)->getZExtValue();
1775
1776   if (!Subtarget->isThumb1Only() && VT == MVT::i32) {
1777     // Pattern: (ARMcmov:i32 GPR:i32:$false, so_reg:i32:$true, (imm:i32):$cc)
1778     // Emits: (MOVCCs:i32 GPR:i32:$false, so_reg:i32:$true, (imm:i32):$cc)
1779     // Pattern complexity = 18  cost = 1  size = 0
1780     SDValue CPTmp0;
1781     SDValue CPTmp1;
1782     SDValue CPTmp2;
1783     if (Subtarget->isThumb()) {
1784       SDNode *Res = SelectT2CMOVShiftOp(N, FalseVal, TrueVal,
1785                                         CCVal, CCR, InFlag);
1786       if (!Res)
1787         Res = SelectT2CMOVShiftOp(N, TrueVal, FalseVal,
1788                                ARMCC::getOppositeCondition(CCVal), CCR, InFlag);
1789       if (Res)
1790         return Res;
1791     } else {
1792       SDNode *Res = SelectARMCMOVShiftOp(N, FalseVal, TrueVal,
1793                                          CCVal, CCR, InFlag);
1794       if (!Res)
1795         Res = SelectARMCMOVShiftOp(N, TrueVal, FalseVal,
1796                                ARMCC::getOppositeCondition(CCVal), CCR, InFlag);
1797       if (Res)
1798         return Res;
1799     }
1800
1801     // Pattern: (ARMcmov:i32 GPR:i32:$false,
1802     //             (imm:i32)<<P:Predicate_so_imm>>:$true,
1803     //             (imm:i32):$cc)
1804     // Emits: (MOVCCi:i32 GPR:i32:$false,
1805     //           (so_imm:i32 (imm:i32):$true), (imm:i32):$cc)
1806     // Pattern complexity = 10  cost = 1  size = 0
1807     if (Subtarget->isThumb()) {
1808       SDNode *Res = SelectT2CMOVSoImmOp(N, FalseVal, TrueVal,
1809                                         CCVal, CCR, InFlag);
1810       if (!Res)
1811         Res = SelectT2CMOVSoImmOp(N, TrueVal, FalseVal,
1812                                ARMCC::getOppositeCondition(CCVal), CCR, InFlag);
1813       if (Res)
1814         return Res;
1815     } else {
1816       SDNode *Res = SelectARMCMOVSoImmOp(N, FalseVal, TrueVal,
1817                                          CCVal, CCR, InFlag);
1818       if (!Res)
1819         Res = SelectARMCMOVSoImmOp(N, TrueVal, FalseVal,
1820                                ARMCC::getOppositeCondition(CCVal), CCR, InFlag);
1821       if (Res)
1822         return Res;
1823     }
1824   }
1825
1826   // Pattern: (ARMcmov:i32 GPR:i32:$false, GPR:i32:$true, (imm:i32):$cc)
1827   // Emits: (MOVCCr:i32 GPR:i32:$false, GPR:i32:$true, (imm:i32):$cc)
1828   // Pattern complexity = 6  cost = 1  size = 0
1829   //
1830   // Pattern: (ARMcmov:i32 GPR:i32:$false, GPR:i32:$true, (imm:i32):$cc)
1831   // Emits: (tMOVCCr:i32 GPR:i32:$false, GPR:i32:$true, (imm:i32):$cc)
1832   // Pattern complexity = 6  cost = 11  size = 0
1833   //
1834   // Also FCPYScc and FCPYDcc.
1835   SDValue Tmp2 = CurDAG->getTargetConstant(CCVal, MVT::i32);
1836   SDValue Ops[] = { FalseVal, TrueVal, Tmp2, CCR, InFlag };
1837   unsigned Opc = 0;
1838   switch (VT.getSimpleVT().SimpleTy) {
1839   default: assert(false && "Illegal conditional move type!");
1840     break;
1841   case MVT::i32:
1842     Opc = Subtarget->isThumb()
1843       ? (Subtarget->hasThumb2() ? ARM::t2MOVCCr : ARM::tMOVCCr_pseudo)
1844       : ARM::MOVCCr;
1845     break;
1846   case MVT::f32:
1847     Opc = ARM::VMOVScc;
1848     break;
1849   case MVT::f64:
1850     Opc = ARM::VMOVDcc;
1851     break;
1852   }
1853   return CurDAG->SelectNodeTo(N, Opc, VT, Ops, 5);
1854 }
1855
1856 SDNode *ARMDAGToDAGISel::SelectConcatVector(SDNode *N) {
1857   // The only time a CONCAT_VECTORS operation can have legal types is when
1858   // two 64-bit vectors are concatenated to a 128-bit vector.
1859   EVT VT = N->getValueType(0);
1860   if (!VT.is128BitVector() || N->getNumOperands() != 2)
1861     llvm_unreachable("unexpected CONCAT_VECTORS");
1862   DebugLoc dl = N->getDebugLoc();
1863   SDValue V0 = N->getOperand(0);
1864   SDValue V1 = N->getOperand(1);
1865   SDValue SubReg0 = CurDAG->getTargetConstant(ARM::dsub_0, MVT::i32);
1866   SDValue SubReg1 = CurDAG->getTargetConstant(ARM::dsub_1, MVT::i32);
1867   const SDValue Ops[] = { V0, SubReg0, V1, SubReg1 };
1868   return CurDAG->getMachineNode(TargetOpcode::REG_SEQUENCE, dl, VT, Ops, 4);
1869 }
1870
1871 SDNode *ARMDAGToDAGISel::Select(SDNode *N) {
1872   DebugLoc dl = N->getDebugLoc();
1873
1874   if (N->isMachineOpcode())
1875     return NULL;   // Already selected.
1876
1877   switch (N->getOpcode()) {
1878   default: break;
1879   case ISD::Constant: {
1880     unsigned Val = cast<ConstantSDNode>(N)->getZExtValue();
1881     bool UseCP = true;
1882     if (Subtarget->hasThumb2())
1883       // Thumb2-aware targets have the MOVT instruction, so all immediates can
1884       // be done with MOV + MOVT, at worst.
1885       UseCP = 0;
1886     else {
1887       if (Subtarget->isThumb()) {
1888         UseCP = (Val > 255 &&                          // MOV
1889                  ~Val > 255 &&                         // MOV + MVN
1890                  !ARM_AM::isThumbImmShiftedVal(Val));  // MOV + LSL
1891       } else
1892         UseCP = (ARM_AM::getSOImmVal(Val) == -1 &&     // MOV
1893                  ARM_AM::getSOImmVal(~Val) == -1 &&    // MVN
1894                  !ARM_AM::isSOImmTwoPartVal(Val));     // two instrs.
1895     }
1896
1897     if (UseCP) {
1898       SDValue CPIdx =
1899         CurDAG->getTargetConstantPool(ConstantInt::get(
1900                                   Type::getInt32Ty(*CurDAG->getContext()), Val),
1901                                       TLI.getPointerTy());
1902
1903       SDNode *ResNode;
1904       if (Subtarget->isThumb1Only()) {
1905         SDValue Pred = getAL(CurDAG);
1906         SDValue PredReg = CurDAG->getRegister(0, MVT::i32);
1907         SDValue Ops[] = { CPIdx, Pred, PredReg, CurDAG->getEntryNode() };
1908         ResNode = CurDAG->getMachineNode(ARM::tLDRcp, dl, MVT::i32, MVT::Other,
1909                                          Ops, 4);
1910       } else {
1911         SDValue Ops[] = {
1912           CPIdx,
1913           CurDAG->getRegister(0, MVT::i32),
1914           CurDAG->getTargetConstant(0, MVT::i32),
1915           getAL(CurDAG),
1916           CurDAG->getRegister(0, MVT::i32),
1917           CurDAG->getEntryNode()
1918         };
1919         ResNode=CurDAG->getMachineNode(ARM::LDRcp, dl, MVT::i32, MVT::Other,
1920                                        Ops, 6);
1921       }
1922       ReplaceUses(SDValue(N, 0), SDValue(ResNode, 0));
1923       return NULL;
1924     }
1925
1926     // Other cases are autogenerated.
1927     break;
1928   }
1929   case ISD::FrameIndex: {
1930     // Selects to ADDri FI, 0 which in turn will become ADDri SP, imm.
1931     int FI = cast<FrameIndexSDNode>(N)->getIndex();
1932     SDValue TFI = CurDAG->getTargetFrameIndex(FI, TLI.getPointerTy());
1933     if (Subtarget->isThumb1Only()) {
1934       return CurDAG->SelectNodeTo(N, ARM::tADDrSPi, MVT::i32, TFI,
1935                                   CurDAG->getTargetConstant(0, MVT::i32));
1936     } else {
1937       unsigned Opc = ((Subtarget->isThumb() && Subtarget->hasThumb2()) ?
1938                       ARM::t2ADDri : ARM::ADDri);
1939       SDValue Ops[] = { TFI, CurDAG->getTargetConstant(0, MVT::i32),
1940                         getAL(CurDAG), CurDAG->getRegister(0, MVT::i32),
1941                         CurDAG->getRegister(0, MVT::i32) };
1942       return CurDAG->SelectNodeTo(N, Opc, MVT::i32, Ops, 5);
1943     }
1944   }
1945   case ISD::SRL:
1946     if (SDNode *I = SelectV6T2BitfieldExtractOp(N, false))
1947       return I;
1948     break;
1949   case ISD::SRA:
1950     if (SDNode *I = SelectV6T2BitfieldExtractOp(N, true))
1951       return I;
1952     break;
1953   case ISD::MUL:
1954     if (Subtarget->isThumb1Only())
1955       break;
1956     if (ConstantSDNode *C = dyn_cast<ConstantSDNode>(N->getOperand(1))) {
1957       unsigned RHSV = C->getZExtValue();
1958       if (!RHSV) break;
1959       if (isPowerOf2_32(RHSV-1)) {  // 2^n+1?
1960         unsigned ShImm = Log2_32(RHSV-1);
1961         if (ShImm >= 32)
1962           break;
1963         SDValue V = N->getOperand(0);
1964         ShImm = ARM_AM::getSORegOpc(ARM_AM::lsl, ShImm);
1965         SDValue ShImmOp = CurDAG->getTargetConstant(ShImm, MVT::i32);
1966         SDValue Reg0 = CurDAG->getRegister(0, MVT::i32);
1967         if (Subtarget->isThumb()) {
1968           SDValue Ops[] = { V, V, ShImmOp, getAL(CurDAG), Reg0, Reg0 };
1969           return CurDAG->SelectNodeTo(N, ARM::t2ADDrs, MVT::i32, Ops, 6);
1970         } else {
1971           SDValue Ops[] = { V, V, Reg0, ShImmOp, getAL(CurDAG), Reg0, Reg0 };
1972           return CurDAG->SelectNodeTo(N, ARM::ADDrs, MVT::i32, Ops, 7);
1973         }
1974       }
1975       if (isPowerOf2_32(RHSV+1)) {  // 2^n-1?
1976         unsigned ShImm = Log2_32(RHSV+1);
1977         if (ShImm >= 32)
1978           break;
1979         SDValue V = N->getOperand(0);
1980         ShImm = ARM_AM::getSORegOpc(ARM_AM::lsl, ShImm);
1981         SDValue ShImmOp = CurDAG->getTargetConstant(ShImm, MVT::i32);
1982         SDValue Reg0 = CurDAG->getRegister(0, MVT::i32);
1983         if (Subtarget->isThumb()) {
1984           SDValue Ops[] = { V, V, ShImmOp, getAL(CurDAG), Reg0, Reg0 };
1985           return CurDAG->SelectNodeTo(N, ARM::t2RSBrs, MVT::i32, Ops, 6);
1986         } else {
1987           SDValue Ops[] = { V, V, Reg0, ShImmOp, getAL(CurDAG), Reg0, Reg0 };
1988           return CurDAG->SelectNodeTo(N, ARM::RSBrs, MVT::i32, Ops, 7);
1989         }
1990       }
1991     }
1992     break;
1993   case ISD::AND: {
1994     // Check for unsigned bitfield extract
1995     if (SDNode *I = SelectV6T2BitfieldExtractOp(N, false))
1996       return I;
1997
1998     // (and (or x, c2), c1) and top 16-bits of c1 and c2 match, lower 16-bits
1999     // of c1 are 0xffff, and lower 16-bit of c2 are 0. That is, the top 16-bits
2000     // are entirely contributed by c2 and lower 16-bits are entirely contributed
2001     // by x. That's equal to (or (and x, 0xffff), (and c1, 0xffff0000)).
2002     // Select it to: "movt x, ((c1 & 0xffff) >> 16)
2003     EVT VT = N->getValueType(0);
2004     if (VT != MVT::i32)
2005       break;
2006     unsigned Opc = (Subtarget->isThumb() && Subtarget->hasThumb2())
2007       ? ARM::t2MOVTi16
2008       : (Subtarget->hasV6T2Ops() ? ARM::MOVTi16 : 0);
2009     if (!Opc)
2010       break;
2011     SDValue N0 = N->getOperand(0), N1 = N->getOperand(1);
2012     ConstantSDNode *N1C = dyn_cast<ConstantSDNode>(N1);
2013     if (!N1C)
2014       break;
2015     if (N0.getOpcode() == ISD::OR && N0.getNode()->hasOneUse()) {
2016       SDValue N2 = N0.getOperand(1);
2017       ConstantSDNode *N2C = dyn_cast<ConstantSDNode>(N2);
2018       if (!N2C)
2019         break;
2020       unsigned N1CVal = N1C->getZExtValue();
2021       unsigned N2CVal = N2C->getZExtValue();
2022       if ((N1CVal & 0xffff0000U) == (N2CVal & 0xffff0000U) &&
2023           (N1CVal & 0xffffU) == 0xffffU &&
2024           (N2CVal & 0xffffU) == 0x0U) {
2025         SDValue Imm16 = CurDAG->getTargetConstant((N2CVal & 0xFFFF0000U) >> 16,
2026                                                   MVT::i32);
2027         SDValue Ops[] = { N0.getOperand(0), Imm16,
2028                           getAL(CurDAG), CurDAG->getRegister(0, MVT::i32) };
2029         return CurDAG->getMachineNode(Opc, dl, VT, Ops, 4);
2030       }
2031     }
2032     break;
2033   }
2034   case ARMISD::VMOVRRD:
2035     return CurDAG->getMachineNode(ARM::VMOVRRD, dl, MVT::i32, MVT::i32,
2036                                   N->getOperand(0), getAL(CurDAG),
2037                                   CurDAG->getRegister(0, MVT::i32));
2038   case ISD::UMUL_LOHI: {
2039     if (Subtarget->isThumb1Only())
2040       break;
2041     if (Subtarget->isThumb()) {
2042       SDValue Ops[] = { N->getOperand(0), N->getOperand(1),
2043                         getAL(CurDAG), CurDAG->getRegister(0, MVT::i32),
2044                         CurDAG->getRegister(0, MVT::i32) };
2045       return CurDAG->getMachineNode(ARM::t2UMULL, dl, MVT::i32, MVT::i32,Ops,4);
2046     } else {
2047       SDValue Ops[] = { N->getOperand(0), N->getOperand(1),
2048                         getAL(CurDAG), CurDAG->getRegister(0, MVT::i32),
2049                         CurDAG->getRegister(0, MVT::i32) };
2050       return CurDAG->getMachineNode(ARM::UMULL, dl, MVT::i32, MVT::i32, Ops, 5);
2051     }
2052   }
2053   case ISD::SMUL_LOHI: {
2054     if (Subtarget->isThumb1Only())
2055       break;
2056     if (Subtarget->isThumb()) {
2057       SDValue Ops[] = { N->getOperand(0), N->getOperand(1),
2058                         getAL(CurDAG), CurDAG->getRegister(0, MVT::i32) };
2059       return CurDAG->getMachineNode(ARM::t2SMULL, dl, MVT::i32, MVT::i32,Ops,4);
2060     } else {
2061       SDValue Ops[] = { N->getOperand(0), N->getOperand(1),
2062                         getAL(CurDAG), CurDAG->getRegister(0, MVT::i32),
2063                         CurDAG->getRegister(0, MVT::i32) };
2064       return CurDAG->getMachineNode(ARM::SMULL, dl, MVT::i32, MVT::i32, Ops, 5);
2065     }
2066   }
2067   case ISD::LOAD: {
2068     SDNode *ResNode = 0;
2069     if (Subtarget->isThumb() && Subtarget->hasThumb2())
2070       ResNode = SelectT2IndexedLoad(N);
2071     else
2072       ResNode = SelectARMIndexedLoad(N);
2073     if (ResNode)
2074       return ResNode;
2075
2076     // VLDMQ must be custom-selected for "v2f64 load" to set the AM5Opc value.
2077     if (Subtarget->hasVFP2() &&
2078         N->getValueType(0).getSimpleVT().SimpleTy == MVT::v2f64) {
2079       SDValue Chain = N->getOperand(0);
2080       SDValue AM5Opc =
2081         CurDAG->getTargetConstant(ARM_AM::getAM5Opc(ARM_AM::ia, 4), MVT::i32);
2082       SDValue Pred = getAL(CurDAG);
2083       SDValue PredReg = CurDAG->getRegister(0, MVT::i32);
2084       SDValue Ops[] = { N->getOperand(1), AM5Opc, Pred, PredReg, Chain };
2085       MachineSDNode::mmo_iterator MemOp = MF->allocateMemRefsArray(1);
2086       MemOp[0] = cast<MemSDNode>(N)->getMemOperand();
2087       SDNode *Ret = CurDAG->getMachineNode(ARM::VLDMQ, dl,
2088                                            MVT::v2f64, MVT::Other, Ops, 5);
2089       cast<MachineSDNode>(Ret)->setMemRefs(MemOp, MemOp + 1);
2090       return Ret;
2091     }
2092     // Other cases are autogenerated.
2093     break;
2094   }
2095   case ISD::STORE: {
2096     // VSTMQ must be custom-selected for "v2f64 store" to set the AM5Opc value.
2097     if (Subtarget->hasVFP2() &&
2098         N->getOperand(1).getValueType().getSimpleVT().SimpleTy == MVT::v2f64) {
2099       SDValue Chain = N->getOperand(0);
2100       SDValue AM5Opc =
2101         CurDAG->getTargetConstant(ARM_AM::getAM5Opc(ARM_AM::ia, 4), MVT::i32);
2102       SDValue Pred = getAL(CurDAG);
2103       SDValue PredReg = CurDAG->getRegister(0, MVT::i32);
2104       SDValue Ops[] = { N->getOperand(1), N->getOperand(2),
2105                         AM5Opc, Pred, PredReg, Chain };
2106       MachineSDNode::mmo_iterator MemOp = MF->allocateMemRefsArray(1);
2107       MemOp[0] = cast<MemSDNode>(N)->getMemOperand();
2108       SDNode *Ret = CurDAG->getMachineNode(ARM::VSTMQ, dl, MVT::Other, Ops, 6);
2109       cast<MachineSDNode>(Ret)->setMemRefs(MemOp, MemOp + 1);
2110       return Ret;
2111     }
2112     // Other cases are autogenerated.
2113     break;
2114   }
2115   case ARMISD::BRCOND: {
2116     // Pattern: (ARMbrcond:void (bb:Other):$dst, (imm:i32):$cc)
2117     // Emits: (Bcc:void (bb:Other):$dst, (imm:i32):$cc)
2118     // Pattern complexity = 6  cost = 1  size = 0
2119
2120     // Pattern: (ARMbrcond:void (bb:Other):$dst, (imm:i32):$cc)
2121     // Emits: (tBcc:void (bb:Other):$dst, (imm:i32):$cc)
2122     // Pattern complexity = 6  cost = 1  size = 0
2123
2124     // Pattern: (ARMbrcond:void (bb:Other):$dst, (imm:i32):$cc)
2125     // Emits: (t2Bcc:void (bb:Other):$dst, (imm:i32):$cc)
2126     // Pattern complexity = 6  cost = 1  size = 0
2127
2128     unsigned Opc = Subtarget->isThumb() ?
2129       ((Subtarget->hasThumb2()) ? ARM::t2Bcc : ARM::tBcc) : ARM::Bcc;
2130     SDValue Chain = N->getOperand(0);
2131     SDValue N1 = N->getOperand(1);
2132     SDValue N2 = N->getOperand(2);
2133     SDValue N3 = N->getOperand(3);
2134     SDValue InFlag = N->getOperand(4);
2135     assert(N1.getOpcode() == ISD::BasicBlock);
2136     assert(N2.getOpcode() == ISD::Constant);
2137     assert(N3.getOpcode() == ISD::Register);
2138
2139     SDValue Tmp2 = CurDAG->getTargetConstant(((unsigned)
2140                                cast<ConstantSDNode>(N2)->getZExtValue()),
2141                                MVT::i32);
2142     SDValue Ops[] = { N1, Tmp2, N3, Chain, InFlag };
2143     SDNode *ResNode = CurDAG->getMachineNode(Opc, dl, MVT::Other,
2144                                              MVT::Flag, Ops, 5);
2145     Chain = SDValue(ResNode, 0);
2146     if (N->getNumValues() == 2) {
2147       InFlag = SDValue(ResNode, 1);
2148       ReplaceUses(SDValue(N, 1), InFlag);
2149     }
2150     ReplaceUses(SDValue(N, 0),
2151                 SDValue(Chain.getNode(), Chain.getResNo()));
2152     return NULL;
2153   }
2154   case ARMISD::CMOV:
2155     return SelectCMOVOp(N);
2156   case ARMISD::CNEG: {
2157     EVT VT = N->getValueType(0);
2158     SDValue N0 = N->getOperand(0);
2159     SDValue N1 = N->getOperand(1);
2160     SDValue N2 = N->getOperand(2);
2161     SDValue N3 = N->getOperand(3);
2162     SDValue InFlag = N->getOperand(4);
2163     assert(N2.getOpcode() == ISD::Constant);
2164     assert(N3.getOpcode() == ISD::Register);
2165
2166     SDValue Tmp2 = CurDAG->getTargetConstant(((unsigned)
2167                                cast<ConstantSDNode>(N2)->getZExtValue()),
2168                                MVT::i32);
2169     SDValue Ops[] = { N0, N1, Tmp2, N3, InFlag };
2170     unsigned Opc = 0;
2171     switch (VT.getSimpleVT().SimpleTy) {
2172     default: assert(false && "Illegal conditional move type!");
2173       break;
2174     case MVT::f32:
2175       Opc = ARM::VNEGScc;
2176       break;
2177     case MVT::f64:
2178       Opc = ARM::VNEGDcc;
2179       break;
2180     }
2181     return CurDAG->SelectNodeTo(N, Opc, VT, Ops, 5);
2182   }
2183
2184   case ARMISD::VZIP: {
2185     unsigned Opc = 0;
2186     EVT VT = N->getValueType(0);
2187     switch (VT.getSimpleVT().SimpleTy) {
2188     default: return NULL;
2189     case MVT::v8i8:  Opc = ARM::VZIPd8; break;
2190     case MVT::v4i16: Opc = ARM::VZIPd16; break;
2191     case MVT::v2f32:
2192     case MVT::v2i32: Opc = ARM::VZIPd32; break;
2193     case MVT::v16i8: Opc = ARM::VZIPq8; break;
2194     case MVT::v8i16: Opc = ARM::VZIPq16; break;
2195     case MVT::v4f32:
2196     case MVT::v4i32: Opc = ARM::VZIPq32; break;
2197     }
2198     SDValue Pred = getAL(CurDAG);
2199     SDValue PredReg = CurDAG->getRegister(0, MVT::i32);
2200     SDValue Ops[] = { N->getOperand(0), N->getOperand(1), Pred, PredReg };
2201     return CurDAG->getMachineNode(Opc, dl, VT, VT, Ops, 4);
2202   }
2203   case ARMISD::VUZP: {
2204     unsigned Opc = 0;
2205     EVT VT = N->getValueType(0);
2206     switch (VT.getSimpleVT().SimpleTy) {
2207     default: return NULL;
2208     case MVT::v8i8:  Opc = ARM::VUZPd8; break;
2209     case MVT::v4i16: Opc = ARM::VUZPd16; break;
2210     case MVT::v2f32:
2211     case MVT::v2i32: Opc = ARM::VUZPd32; break;
2212     case MVT::v16i8: Opc = ARM::VUZPq8; break;
2213     case MVT::v8i16: Opc = ARM::VUZPq16; break;
2214     case MVT::v4f32:
2215     case MVT::v4i32: Opc = ARM::VUZPq32; break;
2216     }
2217     SDValue Pred = getAL(CurDAG);
2218     SDValue PredReg = CurDAG->getRegister(0, MVT::i32);
2219     SDValue Ops[] = { N->getOperand(0), N->getOperand(1), Pred, PredReg };
2220     return CurDAG->getMachineNode(Opc, dl, VT, VT, Ops, 4);
2221   }
2222   case ARMISD::VTRN: {
2223     unsigned Opc = 0;
2224     EVT VT = N->getValueType(0);
2225     switch (VT.getSimpleVT().SimpleTy) {
2226     default: return NULL;
2227     case MVT::v8i8:  Opc = ARM::VTRNd8; break;
2228     case MVT::v4i16: Opc = ARM::VTRNd16; break;
2229     case MVT::v2f32:
2230     case MVT::v2i32: Opc = ARM::VTRNd32; break;
2231     case MVT::v16i8: Opc = ARM::VTRNq8; break;
2232     case MVT::v8i16: Opc = ARM::VTRNq16; break;
2233     case MVT::v4f32:
2234     case MVT::v4i32: Opc = ARM::VTRNq32; break;
2235     }
2236     SDValue Pred = getAL(CurDAG);
2237     SDValue PredReg = CurDAG->getRegister(0, MVT::i32);
2238     SDValue Ops[] = { N->getOperand(0), N->getOperand(1), Pred, PredReg };
2239     return CurDAG->getMachineNode(Opc, dl, VT, VT, Ops, 4);
2240   }
2241   case ARMISD::BUILD_VECTOR: {
2242     EVT VecVT = N->getValueType(0);
2243     EVT EltVT = VecVT.getVectorElementType();
2244     unsigned NumElts = VecVT.getVectorNumElements();
2245     if (EltVT.getSimpleVT() == MVT::f64) {
2246       assert(NumElts == 2 && "unexpected type for BUILD_VECTOR");
2247       return PairDRegs(VecVT, N->getOperand(0), N->getOperand(1));
2248     }
2249     assert(EltVT.getSimpleVT() == MVT::f32 &&
2250            "unexpected type for BUILD_VECTOR");
2251     if (NumElts == 2)
2252       return PairSRegs(VecVT, N->getOperand(0), N->getOperand(1));
2253     assert(NumElts == 4 && "unexpected type for BUILD_VECTOR");
2254     return QuadSRegs(VecVT, N->getOperand(0), N->getOperand(1),
2255                      N->getOperand(2), N->getOperand(3));
2256   }
2257
2258   case ISD::INTRINSIC_VOID:
2259   case ISD::INTRINSIC_W_CHAIN: {
2260     unsigned IntNo = cast<ConstantSDNode>(N->getOperand(1))->getZExtValue();
2261     switch (IntNo) {
2262     default:
2263       break;
2264
2265     case Intrinsic::arm_neon_vld1: {
2266       unsigned DOpcodes[] = { ARM::VLD1d8, ARM::VLD1d16,
2267                               ARM::VLD1d32, ARM::VLD1d64 };
2268       unsigned QOpcodes[] = { ARM::VLD1q8, ARM::VLD1q16,
2269                               ARM::VLD1q32, ARM::VLD1q64 };
2270       return SelectVLD(N, 1, DOpcodes, QOpcodes, 0);
2271     }
2272
2273     case Intrinsic::arm_neon_vld2: {
2274       unsigned DOpcodes[] = { ARM::VLD2d8, ARM::VLD2d16,
2275                               ARM::VLD2d32, ARM::VLD1q64 };
2276       unsigned QOpcodes[] = { ARM::VLD2q8, ARM::VLD2q16, ARM::VLD2q32 };
2277       return SelectVLD(N, 2, DOpcodes, QOpcodes, 0);
2278     }
2279
2280     case Intrinsic::arm_neon_vld3: {
2281       unsigned DOpcodes[] = { ARM::VLD3d8, ARM::VLD3d16,
2282                               ARM::VLD3d32, ARM::VLD1d64T };
2283       unsigned QOpcodes0[] = { ARM::VLD3q8_UPD,
2284                                ARM::VLD3q16_UPD,
2285                                ARM::VLD3q32_UPD };
2286       unsigned QOpcodes1[] = { ARM::VLD3q8odd_UPD,
2287                                ARM::VLD3q16odd_UPD,
2288                                ARM::VLD3q32odd_UPD };
2289       return SelectVLD(N, 3, DOpcodes, QOpcodes0, QOpcodes1);
2290     }
2291
2292     case Intrinsic::arm_neon_vld4: {
2293       unsigned DOpcodes[] = { ARM::VLD4d8, ARM::VLD4d16,
2294                               ARM::VLD4d32, ARM::VLD1d64Q };
2295       unsigned QOpcodes0[] = { ARM::VLD4q8_UPD,
2296                                ARM::VLD4q16_UPD,
2297                                ARM::VLD4q32_UPD };
2298       unsigned QOpcodes1[] = { ARM::VLD4q8odd_UPD,
2299                                ARM::VLD4q16odd_UPD,
2300                                ARM::VLD4q32odd_UPD };
2301       return SelectVLD(N, 4, DOpcodes, QOpcodes0, QOpcodes1);
2302     }
2303
2304     case Intrinsic::arm_neon_vld2lane: {
2305       unsigned DOpcodes[] = { ARM::VLD2LNd8, ARM::VLD2LNd16, ARM::VLD2LNd32 };
2306       unsigned QOpcodes0[] = { ARM::VLD2LNq16, ARM::VLD2LNq32 };
2307       unsigned QOpcodes1[] = { ARM::VLD2LNq16odd, ARM::VLD2LNq32odd };
2308       return SelectVLDSTLane(N, true, 2, DOpcodes, QOpcodes0, QOpcodes1);
2309     }
2310
2311     case Intrinsic::arm_neon_vld3lane: {
2312       unsigned DOpcodes[] = { ARM::VLD3LNd8, ARM::VLD3LNd16, ARM::VLD3LNd32 };
2313       unsigned QOpcodes0[] = { ARM::VLD3LNq16, ARM::VLD3LNq32 };
2314       unsigned QOpcodes1[] = { ARM::VLD3LNq16odd, ARM::VLD3LNq32odd };
2315       return SelectVLDSTLane(N, true, 3, DOpcodes, QOpcodes0, QOpcodes1);
2316     }
2317
2318     case Intrinsic::arm_neon_vld4lane: {
2319       unsigned DOpcodes[] = { ARM::VLD4LNd8, ARM::VLD4LNd16, ARM::VLD4LNd32 };
2320       unsigned QOpcodes0[] = { ARM::VLD4LNq16, ARM::VLD4LNq32 };
2321       unsigned QOpcodes1[] = { ARM::VLD4LNq16odd, ARM::VLD4LNq32odd };
2322       return SelectVLDSTLane(N, true, 4, DOpcodes, QOpcodes0, QOpcodes1);
2323     }
2324
2325     case Intrinsic::arm_neon_vst1: {
2326       unsigned DOpcodes[] = { ARM::VST1d8, ARM::VST1d16,
2327                               ARM::VST1d32, ARM::VST1d64 };
2328       unsigned QOpcodes[] = { ARM::VST1q8, ARM::VST1q16,
2329                               ARM::VST1q32, ARM::VST1q64 };
2330       return SelectVST(N, 1, DOpcodes, QOpcodes, 0);
2331     }
2332
2333     case Intrinsic::arm_neon_vst2: {
2334       unsigned DOpcodes[] = { ARM::VST2d8, ARM::VST2d16,
2335                               ARM::VST2d32, ARM::VST1q64 };
2336       unsigned QOpcodes[] = { ARM::VST2q8, ARM::VST2q16, ARM::VST2q32 };
2337       return SelectVST(N, 2, DOpcodes, QOpcodes, 0);
2338     }
2339
2340     case Intrinsic::arm_neon_vst3: {
2341       unsigned DOpcodes[] = { ARM::VST3d8, ARM::VST3d16,
2342                               ARM::VST3d32, ARM::VST1d64T };
2343       unsigned QOpcodes0[] = { ARM::VST3q8_UPD,
2344                                ARM::VST3q16_UPD,
2345                                ARM::VST3q32_UPD };
2346       unsigned QOpcodes1[] = { ARM::VST3q8odd_UPD,
2347                                ARM::VST3q16odd_UPD,
2348                                ARM::VST3q32odd_UPD };
2349       return SelectVST(N, 3, DOpcodes, QOpcodes0, QOpcodes1);
2350     }
2351
2352     case Intrinsic::arm_neon_vst4: {
2353       unsigned DOpcodes[] = { ARM::VST4d8, ARM::VST4d16,
2354                               ARM::VST4d32, ARM::VST1d64Q };
2355       unsigned QOpcodes0[] = { ARM::VST4q8_UPD,
2356                                ARM::VST4q16_UPD,
2357                                ARM::VST4q32_UPD };
2358       unsigned QOpcodes1[] = { ARM::VST4q8odd_UPD,
2359                                ARM::VST4q16odd_UPD,
2360                                ARM::VST4q32odd_UPD };
2361       return SelectVST(N, 4, DOpcodes, QOpcodes0, QOpcodes1);
2362     }
2363
2364     case Intrinsic::arm_neon_vst2lane: {
2365       unsigned DOpcodes[] = { ARM::VST2LNd8, ARM::VST2LNd16, ARM::VST2LNd32 };
2366       unsigned QOpcodes0[] = { ARM::VST2LNq16, ARM::VST2LNq32 };
2367       unsigned QOpcodes1[] = { ARM::VST2LNq16odd, ARM::VST2LNq32odd };
2368       return SelectVLDSTLane(N, false, 2, DOpcodes, QOpcodes0, QOpcodes1);
2369     }
2370
2371     case Intrinsic::arm_neon_vst3lane: {
2372       unsigned DOpcodes[] = { ARM::VST3LNd8, ARM::VST3LNd16, ARM::VST3LNd32 };
2373       unsigned QOpcodes0[] = { ARM::VST3LNq16, ARM::VST3LNq32 };
2374       unsigned QOpcodes1[] = { ARM::VST3LNq16odd, ARM::VST3LNq32odd };
2375       return SelectVLDSTLane(N, false, 3, DOpcodes, QOpcodes0, QOpcodes1);
2376     }
2377
2378     case Intrinsic::arm_neon_vst4lane: {
2379       unsigned DOpcodes[] = { ARM::VST4LNd8, ARM::VST4LNd16, ARM::VST4LNd32 };
2380       unsigned QOpcodes0[] = { ARM::VST4LNq16, ARM::VST4LNq32 };
2381       unsigned QOpcodes1[] = { ARM::VST4LNq16odd, ARM::VST4LNq32odd };
2382       return SelectVLDSTLane(N, false, 4, DOpcodes, QOpcodes0, QOpcodes1);
2383     }
2384     }
2385     break;
2386   }
2387
2388   case ISD::CONCAT_VECTORS:
2389     return SelectConcatVector(N);
2390   }
2391
2392   return SelectCode(N);
2393 }
2394
2395 bool ARMDAGToDAGISel::
2396 SelectInlineAsmMemoryOperand(const SDValue &Op, char ConstraintCode,
2397                              std::vector<SDValue> &OutOps) {
2398   assert(ConstraintCode == 'm' && "unexpected asm memory constraint");
2399   // Require the address to be in a register.  That is safe for all ARM
2400   // variants and it is hard to do anything much smarter without knowing
2401   // how the operand is used.
2402   OutOps.push_back(Op);
2403   return false;
2404 }
2405
2406 /// createARMISelDag - This pass converts a legalized DAG into a
2407 /// ARM-specific DAG, ready for instruction scheduling.
2408 ///
2409 FunctionPass *llvm::createARMISelDag(ARMBaseTargetMachine &TM,
2410                                      CodeGenOpt::Level OptLevel) {
2411   return new ARMDAGToDAGISel(TM, OptLevel);
2412 }
2413
2414 /// ModelWithRegSequence - Return true if isel should use REG_SEQUENCE to model
2415 /// operations involving sub-registers.
2416 bool llvm::ModelWithRegSequence() {
2417   return UseRegSeq;
2418 }