lib/Target/ARM/ARMISelDAGToDAG.cpp

   1 //===-- ARMISelDAGToDAG.cpp - A dag to dag inst selector for ARM ----------===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9 //
  10 // This file defines an instruction selector for the ARM target.
  11 //
  12 //===----------------------------------------------------------------------===//
  13
  14 #include "ARM.h"
  15 #include "ARMAddressingModes.h"
  16 #include "ARMConstantPoolValue.h"
  17 #include "ARMISelLowering.h"
  18 #include "ARMTargetMachine.h"
  19 #include "llvm/CallingConv.h"
  20 #include "llvm/Constants.h"
  21 #include "llvm/DerivedTypes.h"
  22 #include "llvm/Function.h"
  23 #include "llvm/Intrinsics.h"
  24 #include "llvm/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/Compiler.h"
  32 #include "llvm/Support/Debug.h"
  33 #include "llvm/Support/ErrorHandling.h"
  34 #include "llvm/Support/raw_ostream.h"
  35
  36 using namespace llvm;
  37
  38 static const unsigned arm_dsubreg_0 = 5;
  39 static const unsigned arm_dsubreg_1 = 6;
  40
  41 //===--------------------------------------------------------------------===//
  42 /// ARMDAGToDAGISel - ARM specific code to select ARM machine
  43 /// instructions for SelectionDAG operations.
  44 ///
  45 namespace {
  46 class ARMDAGToDAGISel : public SelectionDAGISel {
  47   ARMBaseTargetMachine &TM;
  48
  49   /// Subtarget - Keep a pointer to the ARMSubtarget around so that we can
  50   /// make the right decision when generating code for different targets.
  51   const ARMSubtarget *Subtarget;
  52
  53 public:
  54   explicit ARMDAGToDAGISel(ARMBaseTargetMachine &tm)
  55     : SelectionDAGISel(tm), TM(tm),
  56     Subtarget(&TM.getSubtarget<ARMSubtarget>()) {
  57   }
  58
  59   virtual const char *getPassName() const {
  60     return "ARM Instruction Selection";
  61   }
  62
  63  /// getI32Imm - Return a target constant with the specified value, of type i32.
  64   inline SDValue getI32Imm(unsigned Imm) {
  65     return CurDAG->getTargetConstant(Imm, MVT::i32);
  66   }
  67
  68   SDNode *Select(SDValue Op);
  69   virtual void InstructionSelect();
  70   bool SelectShifterOperandReg(SDValue Op, SDValue N, SDValue &A,
  71                                SDValue &B, SDValue &C);
  72   bool SelectAddrMode2(SDValue Op, SDValue N, SDValue &Base,
  73                        SDValue &Offset, SDValue &Opc);
  74   bool SelectAddrMode2Offset(SDValue Op, SDValue N,
  75                              SDValue &Offset, SDValue &Opc);
  76   bool SelectAddrMode3(SDValue Op, SDValue N, SDValue &Base,
  77                        SDValue &Offset, SDValue &Opc);
  78   bool SelectAddrMode3Offset(SDValue Op, SDValue N,
  79                              SDValue &Offset, SDValue &Opc);
  80   bool SelectAddrMode5(SDValue Op, SDValue N, SDValue &Base,
  81                        SDValue &Offset);
  82   bool SelectAddrMode6(SDValue Op, SDValue N, SDValue &Addr, SDValue &Update,
  83                        SDValue &Opc);
  84
  85   bool SelectAddrModePC(SDValue Op, SDValue N, SDValue &Offset,
  86                         SDValue &Label);
  87
  88   bool SelectThumbAddrModeRR(SDValue Op, SDValue N, SDValue &Base,
  89                              SDValue &Offset);
  90   bool SelectThumbAddrModeRI5(SDValue Op, SDValue N, unsigned Scale,
  91                               SDValue &Base, SDValue &OffImm,
  92                               SDValue &Offset);
  93   bool SelectThumbAddrModeS1(SDValue Op, SDValue N, SDValue &Base,
  94                              SDValue &OffImm, SDValue &Offset);
  95   bool SelectThumbAddrModeS2(SDValue Op, SDValue N, SDValue &Base,
  96                              SDValue &OffImm, SDValue &Offset);
  97   bool SelectThumbAddrModeS4(SDValue Op, SDValue N, SDValue &Base,
  98                              SDValue &OffImm, SDValue &Offset);
  99   bool SelectThumbAddrModeSP(SDValue Op, SDValue N, SDValue &Base,
 100                              SDValue &OffImm);
 101
 102   bool SelectT2ShifterOperandReg(SDValue Op, SDValue N,
 103                                  SDValue &BaseReg, SDValue &Opc);
 104   bool SelectT2AddrModeImm12(SDValue Op, SDValue N, SDValue &Base,
 105                              SDValue &OffImm);
 106   bool SelectT2AddrModeImm8(SDValue Op, SDValue N, SDValue &Base,
 107                             SDValue &OffImm);
 108   bool SelectT2AddrModeImm8Offset(SDValue Op, SDValue N,
 109                                  SDValue &OffImm);
 110   bool SelectT2AddrModeImm8s4(SDValue Op, SDValue N, SDValue &Base,
 111                               SDValue &OffImm);
 112   bool SelectT2AddrModeSoReg(SDValue Op, SDValue N, SDValue &Base,
 113                              SDValue &OffReg, SDValue &ShImm);
 114
 115   // Include the pieces autogenerated from the target description.
 116 #include "ARMGenDAGISel.inc"
 117
 118 private:
 119   /// SelectARMIndexedLoad - Indexed (pre/post inc/dec) load matching code for
 120   /// ARM.
 121   SDNode *SelectARMIndexedLoad(SDValue Op);
 122   SDNode *SelectT2IndexedLoad(SDValue Op);
 123
 124
 125   /// SelectInlineAsmMemoryOperand - Implement addressing mode selection for
 126   /// inline asm expressions.
 127   virtual bool SelectInlineAsmMemoryOperand(const SDValue &Op,
 128                                             char ConstraintCode,
 129                                             std::vector<SDValue> &OutOps);
 130 };
 131 }
 132
 133 void ARMDAGToDAGISel::InstructionSelect() {
 134   DEBUG(BB->dump());
 135
 136   SelectRoot(*CurDAG);
 137   CurDAG->RemoveDeadNodes();
 138 }
 139
 140 bool ARMDAGToDAGISel::SelectShifterOperandReg(SDValue Op,
 141                                               SDValue N,
 142                                               SDValue &BaseReg,
 143                                               SDValue &ShReg,
 144                                               SDValue &Opc) {
 145   ARM_AM::ShiftOpc ShOpcVal = ARM_AM::getShiftOpcForNode(N);
 146
 147   // Don't match base register only case. That is matched to a separate
 148   // lower complexity pattern with explicit register operand.
 149   if (ShOpcVal == ARM_AM::no_shift) return false;
 150
 151   BaseReg = N.getOperand(0);
 152   unsigned ShImmVal = 0;
 153   if (ConstantSDNode *RHS = dyn_cast<ConstantSDNode>(N.getOperand(1))) {
 154     ShReg = CurDAG->getRegister(0, MVT::i32);
 155     ShImmVal = RHS->getZExtValue() & 31;
 156   } else {
 157     ShReg = N.getOperand(1);
 158   }
 159   Opc = CurDAG->getTargetConstant(ARM_AM::getSORegOpc(ShOpcVal, ShImmVal),
 160                                   MVT::i32);
 161   return true;
 162 }
 163
 164 bool ARMDAGToDAGISel::SelectAddrMode2(SDValue Op, SDValue N,
 165                                       SDValue &Base, SDValue &Offset,
 166                                       SDValue &Opc) {
 167   if (N.getOpcode() == ISD::MUL) {
 168     if (ConstantSDNode *RHS = dyn_cast<ConstantSDNode>(N.getOperand(1))) {
 169       // X * [3,5,9] -> X + X * [2,4,8] etc.
 170       int RHSC = (int)RHS->getZExtValue();
 171       if (RHSC & 1) {
 172         RHSC = RHSC & ~1;
 173         ARM_AM::AddrOpc AddSub = ARM_AM::add;
 174         if (RHSC < 0) {
 175           AddSub = ARM_AM::sub;
 176           RHSC = - RHSC;
 177         }
 178         if (isPowerOf2_32(RHSC)) {
 179           unsigned ShAmt = Log2_32(RHSC);
 180           Base = Offset = N.getOperand(0);
 181           Opc = CurDAG->getTargetConstant(ARM_AM::getAM2Opc(AddSub, ShAmt,
 182                                                             ARM_AM::lsl),
 183                                           MVT::i32);
 184           return true;
 185         }
 186       }
 187     }
 188   }
 189
 190   if (N.getOpcode() != ISD::ADD && N.getOpcode() != ISD::SUB) {
 191     Base = N;
 192     if (N.getOpcode() == ISD::FrameIndex) {
 193       int FI = cast<FrameIndexSDNode>(N)->getIndex();
 194       Base = CurDAG->getTargetFrameIndex(FI, TLI.getPointerTy());
 195     } else if (N.getOpcode() == ARMISD::Wrapper) {
 196       Base = N.getOperand(0);
 197     }
 198     Offset = CurDAG->getRegister(0, MVT::i32);
 199     Opc = CurDAG->getTargetConstant(ARM_AM::getAM2Opc(ARM_AM::add, 0,
 200                                                       ARM_AM::no_shift),
 201                                     MVT::i32);
 202     return true;
 203   }
 204
 205   // Match simple R +/- imm12 operands.
 206   if (N.getOpcode() == ISD::ADD)
 207     if (ConstantSDNode *RHS = dyn_cast<ConstantSDNode>(N.getOperand(1))) {
 208       int RHSC = (int)RHS->getZExtValue();
 209       if ((RHSC >= 0 && RHSC < 0x1000) ||
 210           (RHSC < 0 && RHSC > -0x1000)) { // 12 bits.
 211         Base = N.getOperand(0);
 212         if (Base.getOpcode() == ISD::FrameIndex) {
 213           int FI = cast<FrameIndexSDNode>(Base)->getIndex();
 214           Base = CurDAG->getTargetFrameIndex(FI, TLI.getPointerTy());
 215         }
 216         Offset = CurDAG->getRegister(0, MVT::i32);
 217
 218         ARM_AM::AddrOpc AddSub = ARM_AM::add;
 219         if (RHSC < 0) {
 220           AddSub = ARM_AM::sub;
 221           RHSC = - RHSC;
 222         }
 223         Opc = CurDAG->getTargetConstant(ARM_AM::getAM2Opc(AddSub, RHSC,
 224                                                           ARM_AM::no_shift),
 225                                         MVT::i32);
 226         return true;
 227       }
 228     }
 229
 230   // Otherwise this is R +/- [possibly shifted] R
 231   ARM_AM::AddrOpc AddSub = N.getOpcode() == ISD::ADD ? ARM_AM::add:ARM_AM::sub;
 232   ARM_AM::ShiftOpc ShOpcVal = ARM_AM::getShiftOpcForNode(N.getOperand(1));
 233   unsigned ShAmt = 0;
 234
 235   Base   = N.getOperand(0);
 236   Offset = N.getOperand(1);
 237
 238   if (ShOpcVal != ARM_AM::no_shift) {
 239     // Check to see if the RHS of the shift is a constant, if not, we can't fold
 240     // it.
 241     if (ConstantSDNode *Sh =
 242            dyn_cast<ConstantSDNode>(N.getOperand(1).getOperand(1))) {
 243       ShAmt = Sh->getZExtValue();
 244       Offset = N.getOperand(1).getOperand(0);
 245     } else {
 246       ShOpcVal = ARM_AM::no_shift;
 247     }
 248   }
 249
 250   // Try matching (R shl C) + (R).
 251   if (N.getOpcode() == ISD::ADD && ShOpcVal == ARM_AM::no_shift) {
 252     ShOpcVal = ARM_AM::getShiftOpcForNode(N.getOperand(0));
 253     if (ShOpcVal != ARM_AM::no_shift) {
 254       // Check to see if the RHS of the shift is a constant, if not, we can't
 255       // fold it.
 256       if (ConstantSDNode *Sh =
 257           dyn_cast<ConstantSDNode>(N.getOperand(0).getOperand(1))) {
 258         ShAmt = Sh->getZExtValue();
 259         Offset = N.getOperand(0).getOperand(0);
 260         Base = N.getOperand(1);
 261       } else {
 262         ShOpcVal = ARM_AM::no_shift;
 263       }
 264     }
 265   }
 266
 267   Opc = CurDAG->getTargetConstant(ARM_AM::getAM2Opc(AddSub, ShAmt, ShOpcVal),
 268                                   MVT::i32);
 269   return true;
 270 }
 271
 272 bool ARMDAGToDAGISel::SelectAddrMode2Offset(SDValue Op, SDValue N,
 273                                             SDValue &Offset, SDValue &Opc) {
 274   unsigned Opcode = Op.getOpcode();
 275   ISD::MemIndexedMode AM = (Opcode == ISD::LOAD)
 276     ? cast<LoadSDNode>(Op)->getAddressingMode()
 277     : cast<StoreSDNode>(Op)->getAddressingMode();
 278   ARM_AM::AddrOpc AddSub = (AM == ISD::PRE_INC || AM == ISD::POST_INC)
 279     ? ARM_AM::add : ARM_AM::sub;
 280   if (ConstantSDNode *C = dyn_cast<ConstantSDNode>(N)) {
 281     int Val = (int)C->getZExtValue();
 282     if (Val >= 0 && Val < 0x1000) { // 12 bits.
 283       Offset = CurDAG->getRegister(0, MVT::i32);
 284       Opc = CurDAG->getTargetConstant(ARM_AM::getAM2Opc(AddSub, Val,
 285                                                         ARM_AM::no_shift),
 286                                       MVT::i32);
 287       return true;
 288     }
 289   }
 290
 291   Offset = N;
 292   ARM_AM::ShiftOpc ShOpcVal = ARM_AM::getShiftOpcForNode(N);
 293   unsigned ShAmt = 0;
 294   if (ShOpcVal != ARM_AM::no_shift) {
 295     // Check to see if the RHS of the shift is a constant, if not, we can't fold
 296     // it.
 297     if (ConstantSDNode *Sh = dyn_cast<ConstantSDNode>(N.getOperand(1))) {
 298       ShAmt = Sh->getZExtValue();
 299       Offset = N.getOperand(0);
 300     } else {
 301       ShOpcVal = ARM_AM::no_shift;
 302     }
 303   }
 304
 305   Opc = CurDAG->getTargetConstant(ARM_AM::getAM2Opc(AddSub, ShAmt, ShOpcVal),
 306                                   MVT::i32);
 307   return true;
 308 }
 309
 310
 311 bool ARMDAGToDAGISel::SelectAddrMode3(SDValue Op, SDValue N,
 312                                       SDValue &Base, SDValue &Offset,
 313                                       SDValue &Opc) {
 314   if (N.getOpcode() == ISD::SUB) {
 315     // X - C  is canonicalize to X + -C, no need to handle it here.
 316     Base = N.getOperand(0);
 317     Offset = N.getOperand(1);
 318     Opc = CurDAG->getTargetConstant(ARM_AM::getAM3Opc(ARM_AM::sub, 0),MVT::i32);
 319     return true;
 320   }
 321
 322   if (N.getOpcode() != ISD::ADD) {
 323     Base = N;
 324     if (N.getOpcode() == ISD::FrameIndex) {
 325       int FI = cast<FrameIndexSDNode>(N)->getIndex();
 326       Base = CurDAG->getTargetFrameIndex(FI, TLI.getPointerTy());
 327     }
 328     Offset = CurDAG->getRegister(0, MVT::i32);
 329     Opc = CurDAG->getTargetConstant(ARM_AM::getAM3Opc(ARM_AM::add, 0),MVT::i32);
 330     return true;
 331   }
 332
 333   // If the RHS is +/- imm8, fold into addr mode.
 334   if (ConstantSDNode *RHS = dyn_cast<ConstantSDNode>(N.getOperand(1))) {
 335     int RHSC = (int)RHS->getZExtValue();
 336     if ((RHSC >= 0 && RHSC < 256) ||
 337         (RHSC < 0 && RHSC > -256)) { // note -256 itself isn't allowed.
 338       Base = N.getOperand(0);
 339       if (Base.getOpcode() == ISD::FrameIndex) {
 340         int FI = cast<FrameIndexSDNode>(Base)->getIndex();
 341         Base = CurDAG->getTargetFrameIndex(FI, TLI.getPointerTy());
 342       }
 343       Offset = CurDAG->getRegister(0, MVT::i32);
 344
 345       ARM_AM::AddrOpc AddSub = ARM_AM::add;
 346       if (RHSC < 0) {
 347         AddSub = ARM_AM::sub;
 348         RHSC = - RHSC;
 349       }
 350       Opc = CurDAG->getTargetConstant(ARM_AM::getAM3Opc(AddSub, RHSC),MVT::i32);
 351       return true;
 352     }
 353   }
 354
 355   Base = N.getOperand(0);
 356   Offset = N.getOperand(1);
 357   Opc = CurDAG->getTargetConstant(ARM_AM::getAM3Opc(ARM_AM::add, 0), MVT::i32);
 358   return true;
 359 }
 360
 361 bool ARMDAGToDAGISel::SelectAddrMode3Offset(SDValue Op, SDValue N,
 362                                             SDValue &Offset, SDValue &Opc) {
 363   unsigned Opcode = Op.getOpcode();
 364   ISD::MemIndexedMode AM = (Opcode == ISD::LOAD)
 365     ? cast<LoadSDNode>(Op)->getAddressingMode()
 366     : cast<StoreSDNode>(Op)->getAddressingMode();
 367   ARM_AM::AddrOpc AddSub = (AM == ISD::PRE_INC || AM == ISD::POST_INC)
 368     ? ARM_AM::add : ARM_AM::sub;
 369   if (ConstantSDNode *C = dyn_cast<ConstantSDNode>(N)) {
 370     int Val = (int)C->getZExtValue();
 371     if (Val >= 0 && Val < 256) {
 372       Offset = CurDAG->getRegister(0, MVT::i32);
 373       Opc = CurDAG->getTargetConstant(ARM_AM::getAM3Opc(AddSub, Val), MVT::i32);
 374       return true;
 375     }
 376   }
 377
 378   Offset = N;
 379   Opc = CurDAG->getTargetConstant(ARM_AM::getAM3Opc(AddSub, 0), MVT::i32);
 380   return true;
 381 }
 382
 383
 384 bool ARMDAGToDAGISel::SelectAddrMode5(SDValue Op, SDValue N,
 385                                       SDValue &Base, SDValue &Offset) {
 386   if (N.getOpcode() != ISD::ADD) {
 387     Base = N;
 388     if (N.getOpcode() == ISD::FrameIndex) {
 389       int FI = cast<FrameIndexSDNode>(N)->getIndex();
 390       Base = CurDAG->getTargetFrameIndex(FI, TLI.getPointerTy());
 391     } else if (N.getOpcode() == ARMISD::Wrapper) {
 392       Base = N.getOperand(0);
 393     }
 394     Offset = CurDAG->getTargetConstant(ARM_AM::getAM5Opc(ARM_AM::add, 0),
 395                                        MVT::i32);
 396     return true;
 397   }
 398
 399   // If the RHS is +/- imm8, fold into addr mode.
 400   if (ConstantSDNode *RHS = dyn_cast<ConstantSDNode>(N.getOperand(1))) {
 401     int RHSC = (int)RHS->getZExtValue();
 402     if ((RHSC & 3) == 0) {  // The constant is implicitly multiplied by 4.
 403       RHSC >>= 2;
 404       if ((RHSC >= 0 && RHSC < 256) ||
 405           (RHSC < 0 && RHSC > -256)) { // note -256 itself isn't allowed.
 406         Base = N.getOperand(0);
 407         if (Base.getOpcode() == ISD::FrameIndex) {
 408           int FI = cast<FrameIndexSDNode>(Base)->getIndex();
 409           Base = CurDAG->getTargetFrameIndex(FI, TLI.getPointerTy());
 410         }
 411
 412         ARM_AM::AddrOpc AddSub = ARM_AM::add;
 413         if (RHSC < 0) {
 414           AddSub = ARM_AM::sub;
 415           RHSC = - RHSC;
 416         }
 417         Offset = CurDAG->getTargetConstant(ARM_AM::getAM5Opc(AddSub, RHSC),
 418                                            MVT::i32);
 419         return true;
 420       }
 421     }
 422   }
 423
 424   Base = N;
 425   Offset = CurDAG->getTargetConstant(ARM_AM::getAM5Opc(ARM_AM::add, 0),
 426                                      MVT::i32);
 427   return true;
 428 }
 429
 430 bool ARMDAGToDAGISel::SelectAddrMode6(SDValue Op, SDValue N,
 431                                       SDValue &Addr, SDValue &Update,
 432                                       SDValue &Opc) {
 433   Addr = N;
 434   // The optional writeback is handled in ARMLoadStoreOpt.
 435   Update = CurDAG->getRegister(0, MVT::i32);
 436   Opc = CurDAG->getTargetConstant(ARM_AM::getAM6Opc(false), MVT::i32);
 437   return true;
 438 }
 439
 440 bool ARMDAGToDAGISel::SelectAddrModePC(SDValue Op, SDValue N,
 441                                         SDValue &Offset, SDValue &Label) {
 442   if (N.getOpcode() == ARMISD::PIC_ADD && N.hasOneUse()) {
 443     Offset = N.getOperand(0);
 444     SDValue N1 = N.getOperand(1);
 445     Label  = CurDAG->getTargetConstant(cast<ConstantSDNode>(N1)->getZExtValue(),
 446                                        MVT::i32);
 447     return true;
 448   }
 449   return false;
 450 }
 451
 452 bool ARMDAGToDAGISel::SelectThumbAddrModeRR(SDValue Op, SDValue N,
 453                                             SDValue &Base, SDValue &Offset){
 454   // FIXME dl should come from the parent load or store, not the address
 455   DebugLoc dl = Op.getDebugLoc();
 456   if (N.getOpcode() != ISD::ADD) {
 457     Base = N;
 458     // We must materialize a zero in a reg! Returning a constant here
 459     // wouldn't work without additional code to position the node within
 460     // ISel's topological ordering in a place where ISel will process it
 461     // normally.  Instead, just explicitly issue a tMOVri8 node!
 462     Offset = SDValue(CurDAG->getTargetNode(ARM::tMOVi8, dl, MVT::i32,
 463                                     CurDAG->getTargetConstant(0, MVT::i32)), 0);
 464     return true;
 465   }
 466
 467   Base = N.getOperand(0);
 468   Offset = N.getOperand(1);
 469   return true;
 470 }
 471
 472 bool
 473 ARMDAGToDAGISel::SelectThumbAddrModeRI5(SDValue Op, SDValue N,
 474                                         unsigned Scale, SDValue &Base,
 475                                         SDValue &OffImm, SDValue &Offset) {
 476   if (Scale == 4) {
 477     SDValue TmpBase, TmpOffImm;
 478     if (SelectThumbAddrModeSP(Op, N, TmpBase, TmpOffImm))
 479       return false;  // We want to select tLDRspi / tSTRspi instead.
 480     if (N.getOpcode() == ARMISD::Wrapper &&
 481         N.getOperand(0).getOpcode() == ISD::TargetConstantPool)
 482       return false;  // We want to select tLDRpci instead.
 483   }
 484
 485   if (N.getOpcode() != ISD::ADD) {
 486     Base = (N.getOpcode() == ARMISD::Wrapper) ? N.getOperand(0) : N;
 487     Offset = CurDAG->getRegister(0, MVT::i32);
 488     OffImm = CurDAG->getTargetConstant(0, MVT::i32);
 489     return true;
 490   }
 491
 492   // Thumb does not have [sp, r] address mode.
 493   RegisterSDNode *LHSR = dyn_cast<RegisterSDNode>(N.getOperand(0));
 494   RegisterSDNode *RHSR = dyn_cast<RegisterSDNode>(N.getOperand(1));
 495   if ((LHSR && LHSR->getReg() == ARM::SP) ||
 496       (RHSR && RHSR->getReg() == ARM::SP)) {
 497     Base = N;
 498     Offset = CurDAG->getRegister(0, MVT::i32);
 499     OffImm = CurDAG->getTargetConstant(0, MVT::i32);
 500     return true;
 501   }
 502
 503   // If the RHS is + imm5 * scale, fold into addr mode.
 504   if (ConstantSDNode *RHS = dyn_cast<ConstantSDNode>(N.getOperand(1))) {
 505     int RHSC = (int)RHS->getZExtValue();
 506     if ((RHSC & (Scale-1)) == 0) {  // The constant is implicitly multiplied.
 507       RHSC /= Scale;
 508       if (RHSC >= 0 && RHSC < 32) {
 509         Base = N.getOperand(0);
 510         Offset = CurDAG->getRegister(0, MVT::i32);
 511         OffImm = CurDAG->getTargetConstant(RHSC, MVT::i32);
 512         return true;
 513       }
 514     }
 515   }
 516
 517   Base = N.getOperand(0);
 518   Offset = N.getOperand(1);
 519   OffImm = CurDAG->getTargetConstant(0, MVT::i32);
 520   return true;
 521 }
 522
 523 bool ARMDAGToDAGISel::SelectThumbAddrModeS1(SDValue Op, SDValue N,
 524                                             SDValue &Base, SDValue &OffImm,
 525                                             SDValue &Offset) {
 526   return SelectThumbAddrModeRI5(Op, N, 1, Base, OffImm, Offset);
 527 }
 528
 529 bool ARMDAGToDAGISel::SelectThumbAddrModeS2(SDValue Op, SDValue N,
 530                                             SDValue &Base, SDValue &OffImm,
 531                                             SDValue &Offset) {
 532   return SelectThumbAddrModeRI5(Op, N, 2, Base, OffImm, Offset);
 533 }
 534
 535 bool ARMDAGToDAGISel::SelectThumbAddrModeS4(SDValue Op, SDValue N,
 536                                             SDValue &Base, SDValue &OffImm,
 537                                             SDValue &Offset) {
 538   return SelectThumbAddrModeRI5(Op, N, 4, Base, OffImm, Offset);
 539 }
 540
 541 bool ARMDAGToDAGISel::SelectThumbAddrModeSP(SDValue Op, SDValue N,
 542                                            SDValue &Base, SDValue &OffImm) {
 543   if (N.getOpcode() == ISD::FrameIndex) {
 544     int FI = cast<FrameIndexSDNode>(N)->getIndex();
 545     Base = CurDAG->getTargetFrameIndex(FI, TLI.getPointerTy());
 546     OffImm = CurDAG->getTargetConstant(0, MVT::i32);
 547     return true;
 548   }
 549
 550   if (N.getOpcode() != ISD::ADD)
 551     return false;
 552
 553   RegisterSDNode *LHSR = dyn_cast<RegisterSDNode>(N.getOperand(0));
 554   if (N.getOperand(0).getOpcode() == ISD::FrameIndex ||
 555       (LHSR && LHSR->getReg() == ARM::SP)) {
 556     // If the RHS is + imm8 * scale, fold into addr mode.
 557     if (ConstantSDNode *RHS = dyn_cast<ConstantSDNode>(N.getOperand(1))) {
 558       int RHSC = (int)RHS->getZExtValue();
 559       if ((RHSC & 3) == 0) {  // The constant is implicitly multiplied.
 560         RHSC >>= 2;
 561         if (RHSC >= 0 && RHSC < 256) {
 562           Base = N.getOperand(0);
 563           if (Base.getOpcode() == ISD::FrameIndex) {
 564             int FI = cast<FrameIndexSDNode>(Base)->getIndex();
 565             Base = CurDAG->getTargetFrameIndex(FI, TLI.getPointerTy());
 566           }
 567           OffImm = CurDAG->getTargetConstant(RHSC, MVT::i32);
 568           return true;
 569         }
 570       }
 571     }
 572   }
 573
 574   return false;
 575 }
 576
 577 bool ARMDAGToDAGISel::SelectT2ShifterOperandReg(SDValue Op, SDValue N,
 578                                                 SDValue &BaseReg,
 579                                                 SDValue &Opc) {
 580   ARM_AM::ShiftOpc ShOpcVal = ARM_AM::getShiftOpcForNode(N);
 581
 582   // Don't match base register only case. That is matched to a separate
 583   // lower complexity pattern with explicit register operand.
 584   if (ShOpcVal == ARM_AM::no_shift) return false;
 585
 586   BaseReg = N.getOperand(0);
 587   unsigned ShImmVal = 0;
 588   if (ConstantSDNode *RHS = dyn_cast<ConstantSDNode>(N.getOperand(1))) {
 589     ShImmVal = RHS->getZExtValue() & 31;
 590     Opc = getI32Imm(ARM_AM::getSORegOpc(ShOpcVal, ShImmVal));
 591     return true;
 592   }
 593
 594   return false;
 595 }
 596
 597 bool ARMDAGToDAGISel::SelectT2AddrModeImm12(SDValue Op, SDValue N,
 598                                             SDValue &Base, SDValue &OffImm) {
 599   // Match simple R + imm12 operands.
 600   if (N.getOpcode() != ISD::ADD)
 601     return false;
 602
 603   if (ConstantSDNode *RHS = dyn_cast<ConstantSDNode>(N.getOperand(1))) {
 604     int RHSC = (int)RHS->getZExtValue();
 605     if (RHSC >= 0 && RHSC < 0x1000) { // 12 bits.
 606       Base   = N.getOperand(0);
 607       OffImm = CurDAG->getTargetConstant(RHSC, MVT::i32);
 608       return true;
 609     }
 610   }
 611
 612   return false;
 613 }
 614
 615 bool ARMDAGToDAGISel::SelectT2AddrModeImm8(SDValue Op, SDValue N,
 616                                            SDValue &Base, SDValue &OffImm) {
 617   if (N.getOpcode() == ISD::ADD) {
 618     if (ConstantSDNode *RHS = dyn_cast<ConstantSDNode>(N.getOperand(1))) {
 619       int RHSC = (int)RHS->getZExtValue();
 620       if (RHSC < 0 && RHSC > -0x100) { // 8 bits.
 621         Base   = N.getOperand(0);
 622         OffImm = CurDAG->getTargetConstant(RHSC, MVT::i32);
 623         return true;
 624       }
 625     }
 626   } else if (N.getOpcode() == ISD::SUB) {
 627     if (ConstantSDNode *RHS = dyn_cast<ConstantSDNode>(N.getOperand(1))) {
 628       int RHSC = (int)RHS->getZExtValue();
 629       if (RHSC >= 0 && RHSC < 0x100) { // 8 bits.
 630         Base   = N.getOperand(0);
 631         OffImm = CurDAG->getTargetConstant(-RHSC, MVT::i32);
 632         return true;
 633       }
 634     }
 635   }
 636
 637   return false;
 638 }
 639
 640 bool ARMDAGToDAGISel::SelectT2AddrModeImm8Offset(SDValue Op, SDValue N,
 641                                                  SDValue &OffImm){
 642   unsigned Opcode = Op.getOpcode();
 643   ISD::MemIndexedMode AM = (Opcode == ISD::LOAD)
 644     ? cast<LoadSDNode>(Op)->getAddressingMode()
 645     : cast<StoreSDNode>(Op)->getAddressingMode();
 646   if (ConstantSDNode *RHS = dyn_cast<ConstantSDNode>(N)) {
 647     int RHSC = (int)RHS->getZExtValue();
 648     if (RHSC >= 0 && RHSC < 0x100) { // 8 bits.
 649       OffImm = (AM == ISD::PRE_INC)
 650         ? CurDAG->getTargetConstant(RHSC, MVT::i32)
 651         : CurDAG->getTargetConstant(-RHSC, MVT::i32);
 652       return true;
 653     }
 654   }
 655
 656   return false;
 657 }
 658
 659 bool ARMDAGToDAGISel::SelectT2AddrModeImm8s4(SDValue Op, SDValue N,
 660                                              SDValue &Base, SDValue &OffImm) {
 661   if (N.getOpcode() == ISD::ADD) {
 662     if (ConstantSDNode *RHS = dyn_cast<ConstantSDNode>(N.getOperand(1))) {
 663       int RHSC = (int)RHS->getZExtValue();
 664       if (((RHSC & 0x3) == 0) &&
 665           ((RHSC >= 0 && RHSC < 0x400) || (RHSC < 0 && RHSC > -0x400))) { // 8 bits.
 666         Base   = N.getOperand(0);
 667         OffImm = CurDAG->getTargetConstant(RHSC, MVT::i32);
 668         return true;
 669       }
 670     }
 671   } else if (N.getOpcode() == ISD::SUB) {
 672     if (ConstantSDNode *RHS = dyn_cast<ConstantSDNode>(N.getOperand(1))) {
 673       int RHSC = (int)RHS->getZExtValue();
 674       if (((RHSC & 0x3) == 0) && (RHSC >= 0 && RHSC < 0x400)) { // 8 bits.
 675         Base   = N.getOperand(0);
 676         OffImm = CurDAG->getTargetConstant(-RHSC, MVT::i32);
 677         return true;
 678       }
 679     }
 680   }
 681
 682   return false;
 683 }
 684
 685 bool ARMDAGToDAGISel::SelectT2AddrModeSoReg(SDValue Op, SDValue N,
 686                                             SDValue &Base,
 687                                             SDValue &OffReg, SDValue &ShImm) {
 688   // Base only.
 689   if (N.getOpcode() != ISD::ADD && N.getOpcode() != ISD::SUB) {
 690     Base = N;
 691     if (N.getOpcode() == ISD::FrameIndex) {
 692       int FI = cast<FrameIndexSDNode>(N)->getIndex();
 693       Base = CurDAG->getTargetFrameIndex(FI, TLI.getPointerTy());
 694     } else if (N.getOpcode() == ARMISD::Wrapper) {
 695       Base = N.getOperand(0);
 696       if (Base.getOpcode() == ISD::TargetConstantPool)
 697         return false;  // We want to select t2LDRpci instead.
 698     }
 699     OffReg = CurDAG->getRegister(0, MVT::i32);
 700     ShImm  = CurDAG->getTargetConstant(0, MVT::i32);
 701     return true;
 702   }
 703
 704   // Look for (R + R) or (R + (R << [1,2,3])).
 705   unsigned ShAmt = 0;
 706   Base   = N.getOperand(0);
 707   OffReg = N.getOperand(1);
 708
 709   // Swap if it is ((R << c) + R).
 710   ARM_AM::ShiftOpc ShOpcVal = ARM_AM::getShiftOpcForNode(OffReg);
 711   if (ShOpcVal != ARM_AM::lsl) {
 712     ShOpcVal = ARM_AM::getShiftOpcForNode(Base);
 713     if (ShOpcVal == ARM_AM::lsl)
 714       std::swap(Base, OffReg);
 715   }
 716
 717   if (ShOpcVal == ARM_AM::lsl) {
 718     // Check to see if the RHS of the shift is a constant, if not, we can't fold
 719     // it.
 720     if (ConstantSDNode *Sh = dyn_cast<ConstantSDNode>(OffReg.getOperand(1))) {
 721       ShAmt = Sh->getZExtValue();
 722       if (ShAmt >= 4) {
 723         ShAmt = 0;
 724         ShOpcVal = ARM_AM::no_shift;
 725       } else
 726         OffReg = OffReg.getOperand(0);
 727     } else {
 728       ShOpcVal = ARM_AM::no_shift;
 729     }
 730   } else if (SelectT2AddrModeImm12(Op, N, Base, ShImm) ||
 731              SelectT2AddrModeImm8 (Op, N, Base, ShImm))
 732     // Don't match if it's possible to match to one of the r +/- imm cases.
 733     return false;
 734
 735   ShImm = CurDAG->getTargetConstant(ShAmt, MVT::i32);
 736
 737   return true;
 738 }
 739
 740 //===--------------------------------------------------------------------===//
 741
 742 /// getAL - Returns a ARMCC::AL immediate node.
 743 static inline SDValue getAL(SelectionDAG *CurDAG) {
 744   return CurDAG->getTargetConstant((uint64_t)ARMCC::AL, MVT::i32);
 745 }
 746
 747 SDNode *ARMDAGToDAGISel::SelectARMIndexedLoad(SDValue Op) {
 748   LoadSDNode *LD = cast<LoadSDNode>(Op);
 749   ISD::MemIndexedMode AM = LD->getAddressingMode();
 750   if (AM == ISD::UNINDEXED)
 751     return NULL;
 752
 753   MVT LoadedVT = LD->getMemoryVT();
 754   SDValue Offset, AMOpc;
 755   bool isPre = (AM == ISD::PRE_INC) || (AM == ISD::PRE_DEC);
 756   unsigned Opcode = 0;
 757   bool Match = false;
 758   if (LoadedVT == MVT::i32 &&
 759       SelectAddrMode2Offset(Op, LD->getOffset(), Offset, AMOpc)) {
 760     Opcode = isPre ? ARM::LDR_PRE : ARM::LDR_POST;
 761     Match = true;
 762   } else if (LoadedVT == MVT::i16 &&
 763              SelectAddrMode3Offset(Op, LD->getOffset(), Offset, AMOpc)) {
 764     Match = true;
 765     Opcode = (LD->getExtensionType() == ISD::SEXTLOAD)
 766       ? (isPre ? ARM::LDRSH_PRE : ARM::LDRSH_POST)
 767       : (isPre ? ARM::LDRH_PRE : ARM::LDRH_POST);
 768   } else if (LoadedVT == MVT::i8 || LoadedVT == MVT::i1) {
 769     if (LD->getExtensionType() == ISD::SEXTLOAD) {
 770       if (SelectAddrMode3Offset(Op, LD->getOffset(), Offset, AMOpc)) {
 771         Match = true;
 772         Opcode = isPre ? ARM::LDRSB_PRE : ARM::LDRSB_POST;
 773       }
 774     } else {
 775       if (SelectAddrMode2Offset(Op, LD->getOffset(), Offset, AMOpc)) {
 776         Match = true;
 777         Opcode = isPre ? ARM::LDRB_PRE : ARM::LDRB_POST;
 778       }
 779     }
 780   }
 781
 782   if (Match) {
 783     SDValue Chain = LD->getChain();
 784     SDValue Base = LD->getBasePtr();
 785     SDValue Ops[]= { Base, Offset, AMOpc, getAL(CurDAG),
 786                      CurDAG->getRegister(0, MVT::i32), Chain };
 787     return CurDAG->getTargetNode(Opcode, Op.getDebugLoc(), MVT::i32, MVT::i32,
 788                                  MVT::Other, Ops, 6);
 789   }
 790
 791   return NULL;
 792 }
 793
 794 SDNode *ARMDAGToDAGISel::SelectT2IndexedLoad(SDValue Op) {
 795   LoadSDNode *LD = cast<LoadSDNode>(Op);
 796   ISD::MemIndexedMode AM = LD->getAddressingMode();
 797   if (AM == ISD::UNINDEXED)
 798     return NULL;
 799
 800   MVT LoadedVT = LD->getMemoryVT();
 801   bool isSExtLd = LD->getExtensionType() == ISD::SEXTLOAD;
 802   SDValue Offset;
 803   bool isPre = (AM == ISD::PRE_INC) || (AM == ISD::PRE_DEC);
 804   unsigned Opcode = 0;
 805   bool Match = false;
 806   if (SelectT2AddrModeImm8Offset(Op, LD->getOffset(), Offset)) {
 807     switch (LoadedVT.getSimpleVT()) {
 808     case MVT::i32:
 809       Opcode = isPre ? ARM::t2LDR_PRE : ARM::t2LDR_POST;
 810       break;
 811     case MVT::i16:
 812       if (isSExtLd)
 813         Opcode = isPre ? ARM::t2LDRSH_PRE : ARM::t2LDRSH_POST;
 814       else
 815         Opcode = isPre ? ARM::t2LDRH_PRE : ARM::t2LDRH_POST;
 816       break;
 817     case MVT::i8:
 818     case MVT::i1:
 819       if (isSExtLd)
 820         Opcode = isPre ? ARM::t2LDRSB_PRE : ARM::t2LDRSB_POST;
 821       else
 822         Opcode = isPre ? ARM::t2LDRB_PRE : ARM::t2LDRB_POST;
 823       break;
 824     default:
 825       return NULL;
 826     }
 827     Match = true;
 828   }
 829
 830   if (Match) {
 831     SDValue Chain = LD->getChain();
 832     SDValue Base = LD->getBasePtr();
 833     SDValue Ops[]= { Base, Offset, getAL(CurDAG),
 834                      CurDAG->getRegister(0, MVT::i32), Chain };
 835     return CurDAG->getTargetNode(Opcode, Op.getDebugLoc(), MVT::i32, MVT::i32,
 836                                  MVT::Other, Ops, 5);
 837   }
 838
 839   return NULL;
 840 }
 841
 842
 843 SDNode *ARMDAGToDAGISel::Select(SDValue Op) {
 844   SDNode *N = Op.getNode();
 845   DebugLoc dl = N->getDebugLoc();
 846
 847   if (N->isMachineOpcode())
 848     return NULL;   // Already selected.
 849
 850   switch (N->getOpcode()) {
 851   default: break;
 852   case ISD::Constant: {
 853     unsigned Val = cast<ConstantSDNode>(N)->getZExtValue();
 854     bool UseCP = true;
 855     if (Subtarget->isThumb()) {
 856       if (Subtarget->hasThumb2())
 857         // Thumb2 has the MOVT instruction, so all immediates can
 858         // be done with MOV + MOVT, at worst.
 859         UseCP = 0;
 860       else
 861         UseCP = (Val > 255 &&                          // MOV
 862                  ~Val > 255 &&                         // MOV + MVN
 863                  !ARM_AM::isThumbImmShiftedVal(Val));  // MOV + LSL
 864     } else
 865       UseCP = (ARM_AM::getSOImmVal(Val) == -1 &&     // MOV
 866                ARM_AM::getSOImmVal(~Val) == -1 &&    // MVN
 867                !ARM_AM::isSOImmTwoPartVal(Val));     // two instrs.
 868     if (UseCP) {
 869       SDValue CPIdx =
 870         CurDAG->getTargetConstantPool(ConstantInt::get(Type::Int32Ty, Val),
 871                                       TLI.getPointerTy());
 872
 873       SDNode *ResNode;
 874       if (Subtarget->isThumb1Only())
 875         ResNode = CurDAG->getTargetNode(ARM::tLDRcp, dl, MVT::i32, MVT::Other,
 876                                         CPIdx, CurDAG->getEntryNode());
 877       else {
 878         SDValue Ops[] = {
 879           CPIdx,
 880           CurDAG->getRegister(0, MVT::i32),
 881           CurDAG->getTargetConstant(0, MVT::i32),
 882           getAL(CurDAG),
 883           CurDAG->getRegister(0, MVT::i32),
 884           CurDAG->getEntryNode()
 885         };
 886         ResNode=CurDAG->getTargetNode(ARM::LDRcp, dl, MVT::i32, MVT::Other,
 887                                       Ops, 6);
 888       }
 889       ReplaceUses(Op, SDValue(ResNode, 0));
 890       return NULL;
 891     }
 892
 893     // Other cases are autogenerated.
 894     break;
 895   }
 896   case ISD::FrameIndex: {
 897     // Selects to ADDri FI, 0 which in turn will become ADDri SP, imm.
 898     int FI = cast<FrameIndexSDNode>(N)->getIndex();
 899     SDValue TFI = CurDAG->getTargetFrameIndex(FI, TLI.getPointerTy());
 900     if (Subtarget->isThumb1Only()) {
 901       return CurDAG->SelectNodeTo(N, ARM::tADDrSPi, MVT::i32, TFI,
 902                                   CurDAG->getTargetConstant(0, MVT::i32));
 903     } else {
 904       SDValue Ops[] = { TFI, CurDAG->getTargetConstant(0, MVT::i32),
 905                           getAL(CurDAG), CurDAG->getRegister(0, MVT::i32),
 906                           CurDAG->getRegister(0, MVT::i32) };
 907       return CurDAG->SelectNodeTo(N, (Subtarget->hasThumb2()) ? ARM::t2ADDri : ARM::ADDri,
 908                                   MVT::i32, Ops, 5);
 909     }
 910   }
 911   case ISD::ADD: {
 912     if (!Subtarget->isThumb1Only())
 913       break;
 914     // Select add sp, c to tADDhirr.
 915     SDValue N0 = Op.getOperand(0);
 916     SDValue N1 = Op.getOperand(1);
 917     RegisterSDNode *LHSR = dyn_cast<RegisterSDNode>(Op.getOperand(0));
 918     RegisterSDNode *RHSR = dyn_cast<RegisterSDNode>(Op.getOperand(1));
 919     if (LHSR && LHSR->getReg() == ARM::SP) {
 920       std::swap(N0, N1);
 921       std::swap(LHSR, RHSR);
 922     }
 923     if (RHSR && RHSR->getReg() == ARM::SP) {
 924       SDValue Val = SDValue(CurDAG->getTargetNode(ARM::tMOVlor2hir, dl,
 925                                   Op.getValueType(), N0, N0), 0);
 926       return CurDAG->SelectNodeTo(N, ARM::tADDhirr, Op.getValueType(), Val, N1);
 927     }
 928     break;
 929   }
 930   case ISD::MUL:
 931     if (Subtarget->isThumb1Only())
 932       break;
 933     if (ConstantSDNode *C = dyn_cast<ConstantSDNode>(Op.getOperand(1))) {
 934       unsigned RHSV = C->getZExtValue();
 935       if (!RHSV) break;
 936       if (isPowerOf2_32(RHSV-1)) {  // 2^n+1?
 937         SDValue V = Op.getOperand(0);
 938         unsigned ShImm = ARM_AM::getSORegOpc(ARM_AM::lsl, Log2_32(RHSV-1));
 939         SDValue Ops[] = { V, V, CurDAG->getRegister(0, MVT::i32),
 940                             CurDAG->getTargetConstant(ShImm, MVT::i32),
 941                             getAL(CurDAG), CurDAG->getRegister(0, MVT::i32),
 942                             CurDAG->getRegister(0, MVT::i32) };
 943         return CurDAG->SelectNodeTo(N, (Subtarget->hasThumb2()) ?
 944                                     ARM::t2ADDrs : ARM::ADDrs, MVT::i32, Ops, 7);
 945       }
 946       if (isPowerOf2_32(RHSV+1)) {  // 2^n-1?
 947         SDValue V = Op.getOperand(0);
 948         unsigned ShImm = ARM_AM::getSORegOpc(ARM_AM::lsl, Log2_32(RHSV+1));
 949         SDValue Ops[] = { V, V, CurDAG->getRegister(0, MVT::i32),
 950                             CurDAG->getTargetConstant(ShImm, MVT::i32),
 951                             getAL(CurDAG), CurDAG->getRegister(0, MVT::i32),
 952                             CurDAG->getRegister(0, MVT::i32) };
 953         return CurDAG->SelectNodeTo(N, (Subtarget->hasThumb2()) ?
 954                                     ARM::t2RSBrs : ARM::RSBrs, MVT::i32, Ops, 7);
 955       }
 956     }
 957     break;
 958   case ARMISD::FMRRD:
 959     return CurDAG->getTargetNode(ARM::FMRRD, dl, MVT::i32, MVT::i32,
 960                                  Op.getOperand(0), getAL(CurDAG),
 961                                  CurDAG->getRegister(0, MVT::i32));
 962   case ISD::UMUL_LOHI: {
 963     if (Subtarget->isThumb1Only())
 964       break;
 965     if (Subtarget->isThumb()) {
 966       SDValue Ops[] = { Op.getOperand(0), Op.getOperand(1),
 967                         getAL(CurDAG), CurDAG->getRegister(0, MVT::i32),
 968                         CurDAG->getRegister(0, MVT::i32) };
 969       return CurDAG->getTargetNode(ARM::t2UMULL, dl, MVT::i32, MVT::i32, Ops,4);
 970     } else {
 971       SDValue Ops[] = { Op.getOperand(0), Op.getOperand(1),
 972                         getAL(CurDAG), CurDAG->getRegister(0, MVT::i32),
 973                         CurDAG->getRegister(0, MVT::i32) };
 974       return CurDAG->getTargetNode(ARM::UMULL, dl, MVT::i32, MVT::i32, Ops, 5);
 975     }
 976   }
 977   case ISD::SMUL_LOHI: {
 978     if (Subtarget->isThumb1Only())
 979       break;
 980     if (Subtarget->isThumb()) {
 981       SDValue Ops[] = { Op.getOperand(0), Op.getOperand(1),
 982                         getAL(CurDAG), CurDAG->getRegister(0, MVT::i32) };
 983       return CurDAG->getTargetNode(ARM::t2SMULL, dl, MVT::i32, MVT::i32, Ops,4);
 984     } else {
 985       SDValue Ops[] = { Op.getOperand(0), Op.getOperand(1),
 986                         getAL(CurDAG), CurDAG->getRegister(0, MVT::i32),
 987                         CurDAG->getRegister(0, MVT::i32) };
 988       return CurDAG->getTargetNode(ARM::SMULL, dl, MVT::i32, MVT::i32, Ops, 5);
 989     }
 990   }
 991   case ISD::LOAD: {
 992     SDNode *ResNode = 0;
 993     if (Subtarget->isThumb() && Subtarget->hasThumb2())
 994       ResNode = SelectT2IndexedLoad(Op);
 995     else
 996       ResNode = SelectARMIndexedLoad(Op);
 997     if (ResNode)
 998       return ResNode;
 999     // Other cases are autogenerated.
1000     break;
1001   }
1002   case ARMISD::BRCOND: {
1003     // Pattern: (ARMbrcond:void (bb:Other):$dst, (imm:i32):$cc)
1004     // Emits: (Bcc:void (bb:Other):$dst, (imm:i32):$cc)
1005     // Pattern complexity = 6  cost = 1  size = 0
1006
1007     // Pattern: (ARMbrcond:void (bb:Other):$dst, (imm:i32):$cc)
1008     // Emits: (tBcc:void (bb:Other):$dst, (imm:i32):$cc)
1009     // Pattern complexity = 6  cost = 1  size = 0
1010
1011     // Pattern: (ARMbrcond:void (bb:Other):$dst, (imm:i32):$cc)
1012     // Emits: (t2Bcc:void (bb:Other):$dst, (imm:i32):$cc)
1013     // Pattern complexity = 6  cost = 1  size = 0
1014
1015     unsigned Opc = Subtarget->isThumb() ?
1016       ((Subtarget->hasThumb2()) ? ARM::t2Bcc : ARM::tBcc) : ARM::Bcc;
1017     SDValue Chain = Op.getOperand(0);
1018     SDValue N1 = Op.getOperand(1);
1019     SDValue N2 = Op.getOperand(2);
1020     SDValue N3 = Op.getOperand(3);
1021     SDValue InFlag = Op.getOperand(4);
1022     assert(N1.getOpcode() == ISD::BasicBlock);
1023     assert(N2.getOpcode() == ISD::Constant);
1024     assert(N3.getOpcode() == ISD::Register);
1025
1026     SDValue Tmp2 = CurDAG->getTargetConstant(((unsigned)
1027                                cast<ConstantSDNode>(N2)->getZExtValue()),
1028                                MVT::i32);
1029     SDValue Ops[] = { N1, Tmp2, N3, Chain, InFlag };
1030     SDNode *ResNode = CurDAG->getTargetNode(Opc, dl, MVT::Other,
1031                                             MVT::Flag, Ops, 5);
1032     Chain = SDValue(ResNode, 0);
1033     if (Op.getNode()->getNumValues() == 2) {
1034       InFlag = SDValue(ResNode, 1);
1035       ReplaceUses(SDValue(Op.getNode(), 1), InFlag);
1036     }
1037     ReplaceUses(SDValue(Op.getNode(), 0), SDValue(Chain.getNode(), Chain.getResNo()));
1038     return NULL;
1039   }
1040   case ARMISD::CMOV: {
1041     MVT VT = Op.getValueType();
1042     SDValue N0 = Op.getOperand(0);
1043     SDValue N1 = Op.getOperand(1);
1044     SDValue N2 = Op.getOperand(2);
1045     SDValue N3 = Op.getOperand(3);
1046     SDValue InFlag = Op.getOperand(4);
1047     assert(N2.getOpcode() == ISD::Constant);
1048     assert(N3.getOpcode() == ISD::Register);
1049
1050     if (!Subtarget->isThumb1Only() && VT == MVT::i32) {
1051       // Pattern: (ARMcmov:i32 GPR:i32:$false, so_reg:i32:$true, (imm:i32):$cc)
1052       // Emits: (MOVCCs:i32 GPR:i32:$false, so_reg:i32:$true, (imm:i32):$cc)
1053       // Pattern complexity = 18  cost = 1  size = 0
1054       SDValue CPTmp0;
1055       SDValue CPTmp1;
1056       SDValue CPTmp2;
1057       if (Subtarget->isThumb()) {
1058         if (SelectT2ShifterOperandReg(Op, N1, CPTmp0, CPTmp1)) {
1059           SDValue Tmp2 = CurDAG->getTargetConstant(((unsigned)
1060                                    cast<ConstantSDNode>(N2)->getZExtValue()),
1061                                    MVT::i32);
1062           SDValue Ops[] = { N0, CPTmp0, CPTmp1, Tmp2, N3, InFlag };
1063           return CurDAG->SelectNodeTo(Op.getNode(),
1064                                       ARM::t2MOVCCs, MVT::i32,Ops, 6);
1065         }
1066       } else {
1067         if (SelectShifterOperandReg(Op, N1, CPTmp0, CPTmp1, CPTmp2)) {
1068           SDValue Tmp2 = CurDAG->getTargetConstant(((unsigned)
1069                                    cast<ConstantSDNode>(N2)->getZExtValue()),
1070                                    MVT::i32);
1071           SDValue Ops[] = { N0, CPTmp0, CPTmp1, CPTmp2, Tmp2, N3, InFlag };
1072           return CurDAG->SelectNodeTo(Op.getNode(),
1073                                       ARM::MOVCCs, MVT::i32, Ops, 7);
1074         }
1075       }
1076
1077       // Pattern: (ARMcmov:i32 GPR:i32:$false,
1078       //             (imm:i32)<<P:Predicate_so_imm>>:$true,
1079       //             (imm:i32):$cc)
1080       // Emits: (MOVCCi:i32 GPR:i32:$false,
1081       //           (so_imm:i32 (imm:i32):$true), (imm:i32):$cc)
1082       // Pattern complexity = 10  cost = 1  size = 0
1083       if (N3.getOpcode() == ISD::Constant) {
1084         if (Subtarget->isThumb()) {
1085           if (Predicate_t2_so_imm(N3.getNode())) {
1086             SDValue Tmp1 = CurDAG->getTargetConstant(((unsigned)
1087                                      cast<ConstantSDNode>(N1)->getZExtValue()),
1088                                      MVT::i32);
1089             SDValue Tmp2 = CurDAG->getTargetConstant(((unsigned)
1090                                      cast<ConstantSDNode>(N2)->getZExtValue()),
1091                                      MVT::i32);
1092             SDValue Ops[] = { N0, Tmp1, Tmp2, N3, InFlag };
1093             return CurDAG->SelectNodeTo(Op.getNode(),
1094                                         ARM::t2MOVCCi, MVT::i32, Ops, 5);
1095           }
1096         } else {
1097           if (Predicate_so_imm(N3.getNode())) {
1098             SDValue Tmp1 = CurDAG->getTargetConstant(((unsigned)
1099                                      cast<ConstantSDNode>(N1)->getZExtValue()),
1100                                      MVT::i32);
1101             SDValue Tmp2 = CurDAG->getTargetConstant(((unsigned)
1102                                      cast<ConstantSDNode>(N2)->getZExtValue()),
1103                                      MVT::i32);
1104             SDValue Ops[] = { N0, Tmp1, Tmp2, N3, InFlag };
1105             return CurDAG->SelectNodeTo(Op.getNode(),
1106                                         ARM::MOVCCi, MVT::i32, Ops, 5);
1107           }
1108         }
1109       }
1110     }
1111
1112     // Pattern: (ARMcmov:i32 GPR:i32:$false, GPR:i32:$true, (imm:i32):$cc)
1113     // Emits: (MOVCCr:i32 GPR:i32:$false, GPR:i32:$true, (imm:i32):$cc)
1114     // Pattern complexity = 6  cost = 1  size = 0
1115     //
1116     // Pattern: (ARMcmov:i32 GPR:i32:$false, GPR:i32:$true, (imm:i32):$cc)
1117     // Emits: (tMOVCCr:i32 GPR:i32:$false, GPR:i32:$true, (imm:i32):$cc)
1118     // Pattern complexity = 6  cost = 11  size = 0
1119     //
1120     // Also FCPYScc and FCPYDcc.
1121     SDValue Tmp2 = CurDAG->getTargetConstant(((unsigned)
1122                                cast<ConstantSDNode>(N2)->getZExtValue()),
1123                                MVT::i32);
1124     SDValue Ops[] = { N0, N1, Tmp2, N3, InFlag };
1125     unsigned Opc = 0;
1126     switch (VT.getSimpleVT()) {
1127     default: assert(false && "Illegal conditional move type!");
1128       break;
1129     case MVT::i32:
1130       Opc = Subtarget->isThumb()
1131         ? (Subtarget->hasThumb2() ? ARM::t2MOVCCr : ARM::tMOVCCr)
1132         : ARM::MOVCCr;
1133       break;
1134     case MVT::f32:
1135       Opc = ARM::FCPYScc;
1136       break;
1137     case MVT::f64:
1138       Opc = ARM::FCPYDcc;
1139       break;
1140     }
1141     return CurDAG->SelectNodeTo(Op.getNode(), Opc, VT, Ops, 5);
1142   }
1143   case ARMISD::CNEG: {
1144     MVT VT = Op.getValueType();
1145     SDValue N0 = Op.getOperand(0);
1146     SDValue N1 = Op.getOperand(1);
1147     SDValue N2 = Op.getOperand(2);
1148     SDValue N3 = Op.getOperand(3);
1149     SDValue InFlag = Op.getOperand(4);
1150     assert(N2.getOpcode() == ISD::Constant);
1151     assert(N3.getOpcode() == ISD::Register);
1152
1153     SDValue Tmp2 = CurDAG->getTargetConstant(((unsigned)
1154                                cast<ConstantSDNode>(N2)->getZExtValue()),
1155                                MVT::i32);
1156     SDValue Ops[] = { N0, N1, Tmp2, N3, InFlag };
1157     unsigned Opc = 0;
1158     switch (VT.getSimpleVT()) {
1159     default: assert(false && "Illegal conditional move type!");
1160       break;
1161     case MVT::f32:
1162       Opc = ARM::FNEGScc;
1163       break;
1164     case MVT::f64:
1165       Opc = ARM::FNEGDcc;
1166       break;
1167     }
1168     return CurDAG->SelectNodeTo(Op.getNode(), Opc, VT, Ops, 5);
1169   }
1170
1171   case ISD::DECLARE: {
1172     SDValue Chain = Op.getOperand(0);
1173     SDValue N1 = Op.getOperand(1);
1174     SDValue N2 = Op.getOperand(2);
1175     FrameIndexSDNode *FINode = dyn_cast<FrameIndexSDNode>(N1);
1176     // FIXME: handle VLAs.
1177     if (!FINode) {
1178       ReplaceUses(Op.getValue(0), Chain);
1179       return NULL;
1180     }
1181     if (N2.getOpcode() == ARMISD::PIC_ADD && isa<LoadSDNode>(N2.getOperand(0)))
1182       N2 = N2.getOperand(0);
1183     LoadSDNode *Ld = dyn_cast<LoadSDNode>(N2);
1184     if (!Ld) {
1185       ReplaceUses(Op.getValue(0), Chain);
1186       return NULL;
1187     }
1188     SDValue BasePtr = Ld->getBasePtr();
1189     assert(BasePtr.getOpcode() == ARMISD::Wrapper &&
1190            isa<ConstantPoolSDNode>(BasePtr.getOperand(0)) &&
1191            "llvm.dbg.variable should be a constantpool node");
1192     ConstantPoolSDNode *CP = cast<ConstantPoolSDNode>(BasePtr.getOperand(0));
1193     GlobalValue *GV = 0;
1194     if (CP->isMachineConstantPoolEntry()) {
1195       ARMConstantPoolValue *ACPV = (ARMConstantPoolValue*)CP->getMachineCPVal();
1196       GV = ACPV->getGV();
1197     } else
1198       GV = dyn_cast<GlobalValue>(CP->getConstVal());
1199     if (!GV) {
1200       ReplaceUses(Op.getValue(0), Chain);
1201       return NULL;
1202     }
1203
1204     SDValue Tmp1 = CurDAG->getTargetFrameIndex(FINode->getIndex(),
1205                                                TLI.getPointerTy());
1206     SDValue Tmp2 = CurDAG->getTargetGlobalAddress(GV, TLI.getPointerTy());
1207     SDValue Ops[] = { Tmp1, Tmp2, Chain };
1208     return CurDAG->getTargetNode(TargetInstrInfo::DECLARE, dl,
1209                                  MVT::Other, Ops, 3);
1210   }
1211
1212   case ISD::CONCAT_VECTORS: {
1213     MVT VT = Op.getValueType();
1214     assert(VT.is128BitVector() && Op.getNumOperands() == 2 &&
1215            "unexpected CONCAT_VECTORS");
1216     SDValue N0 = Op.getOperand(0);
1217     SDValue N1 = Op.getOperand(1);
1218     SDNode *Result =
1219       CurDAG->getTargetNode(TargetInstrInfo::IMPLICIT_DEF, dl, VT);
1220     if (N0.getOpcode() != ISD::UNDEF)
1221       Result = CurDAG->getTargetNode(TargetInstrInfo::INSERT_SUBREG, dl, VT,
1222                                      SDValue(Result, 0), N0,
1223                                      CurDAG->getTargetConstant(arm_dsubreg_0,
1224                                                                MVT::i32));
1225     if (N1.getOpcode() != ISD::UNDEF)
1226       Result = CurDAG->getTargetNode(TargetInstrInfo::INSERT_SUBREG, dl, VT,
1227                                      SDValue(Result, 0), N1,
1228                                      CurDAG->getTargetConstant(arm_dsubreg_1,
1229                                                                MVT::i32));
1230     return Result;
1231   }
1232
1233   case ISD::VECTOR_SHUFFLE: {
1234     MVT VT = Op.getValueType();
1235
1236     // Match 128-bit splat to VDUPLANEQ.  (This could be done with a Pat in
1237     // ARMInstrNEON.td but it is awkward because the shuffle mask needs to be
1238     // transformed first into a lane number and then to both a subregister
1239     // index and an adjusted lane number.)  If the source operand is a
1240     // SCALAR_TO_VECTOR, leave it so it will be matched later as a VDUP.
1241     ShuffleVectorSDNode *SVOp = cast<ShuffleVectorSDNode>(N);
1242     if (VT.is128BitVector() && SVOp->isSplat() &&
1243         Op.getOperand(0).getOpcode() != ISD::SCALAR_TO_VECTOR &&
1244         Op.getOperand(1).getOpcode() == ISD::UNDEF) {
1245       unsigned LaneVal = SVOp->getSplatIndex();
1246
1247       MVT HalfVT;
1248       unsigned Opc = 0;
1249       switch (VT.getVectorElementType().getSimpleVT()) {
1250       default: assert(false && "unhandled VDUP splat type");
1251       case MVT::i8:  Opc = ARM::VDUPLN8q;  HalfVT = MVT::v8i8; break;
1252       case MVT::i16: Opc = ARM::VDUPLN16q; HalfVT = MVT::v4i16; break;
1253       case MVT::i32: Opc = ARM::VDUPLN32q; HalfVT = MVT::v2i32; break;
1254       case MVT::f32: Opc = ARM::VDUPLNfq;  HalfVT = MVT::v2f32; break;
1255       }
1256
1257       // The source operand needs to be changed to a subreg of the original
1258       // 128-bit operand, and the lane number needs to be adjusted accordingly.
1259       unsigned NumElts = VT.getVectorNumElements() / 2;
1260       unsigned SRVal = (LaneVal < NumElts ? arm_dsubreg_0 : arm_dsubreg_1);
1261       SDValue SR = CurDAG->getTargetConstant(SRVal, MVT::i32);
1262       SDValue NewLane = CurDAG->getTargetConstant(LaneVal % NumElts, MVT::i32);
1263       SDNode *SubReg = CurDAG->getTargetNode(TargetInstrInfo::EXTRACT_SUBREG,
1264                                              dl, HalfVT, N->getOperand(0), SR);
1265       return CurDAG->SelectNodeTo(N, Opc, VT, SDValue(SubReg, 0), NewLane);
1266     }
1267
1268     break;
1269   }
1270   }
1271
1272   return SelectCode(Op);
1273 }
1274
1275 bool ARMDAGToDAGISel::
1276 SelectInlineAsmMemoryOperand(const SDValue &Op, char ConstraintCode,
1277                              std::vector<SDValue> &OutOps) {
1278   assert(ConstraintCode == 'm' && "unexpected asm memory constraint");
1279
1280   SDValue Base, Offset, Opc;
1281   if (!SelectAddrMode2(Op, Op, Base, Offset, Opc))
1282     return true;
1283
1284   OutOps.push_back(Base);
1285   OutOps.push_back(Offset);
1286   OutOps.push_back(Opc);
1287   return false;
1288 }
1289
1290 /// createARMISelDag - This pass converts a legalized DAG into a
1291 /// ARM-specific DAG, ready for instruction scheduling.
1292 ///
1293 FunctionPass *llvm::createARMISelDag(ARMBaseTargetMachine &TM) {
1294   return new ARMDAGToDAGISel(TM);
1295 }