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) && (RHSC < 0 && RHSC > -0x400)) { // 8 bits.
 665         Base   = N.getOperand(0);
 666         OffImm = CurDAG->getTargetConstant(RHSC, MVT::i32);
 667         return true;
 668       }
 669     }
 670   } else if (N.getOpcode() == ISD::SUB) {
 671     if (ConstantSDNode *RHS = dyn_cast<ConstantSDNode>(N.getOperand(1))) {
 672       int RHSC = (int)RHS->getZExtValue();
 673       if (((RHSC & 0x3) == 0) && (RHSC >= 0 && RHSC < 0x400)) { // 8 bits.
 674         Base   = N.getOperand(0);
 675         OffImm = CurDAG->getTargetConstant(-RHSC, MVT::i32);
 676         return true;
 677       }
 678     }
 679   }
 680
 681   return false;
 682 }
 683
 684 bool ARMDAGToDAGISel::SelectT2AddrModeSoReg(SDValue Op, SDValue N,
 685                                             SDValue &Base,
 686                                             SDValue &OffReg, SDValue &ShImm) {
 687   // Base only.
 688   if (N.getOpcode() != ISD::ADD && N.getOpcode() != ISD::SUB) {
 689     Base = N;
 690     if (N.getOpcode() == ISD::FrameIndex) {
 691       int FI = cast<FrameIndexSDNode>(N)->getIndex();
 692       Base = CurDAG->getTargetFrameIndex(FI, TLI.getPointerTy());
 693     } else if (N.getOpcode() == ARMISD::Wrapper) {
 694       Base = N.getOperand(0);
 695       if (Base.getOpcode() == ISD::TargetConstantPool)
 696         return false;  // We want to select t2LDRpci instead.
 697     }
 698     OffReg = CurDAG->getRegister(0, MVT::i32);
 699     ShImm  = CurDAG->getTargetConstant(0, MVT::i32);
 700     return true;
 701   }
 702
 703   // Look for (R + R) or (R + (R << [1,2,3])).
 704   unsigned ShAmt = 0;
 705   Base   = N.getOperand(0);
 706   OffReg = N.getOperand(1);
 707
 708   // Swap if it is ((R << c) + R).
 709   ARM_AM::ShiftOpc ShOpcVal = ARM_AM::getShiftOpcForNode(OffReg);
 710   if (ShOpcVal != ARM_AM::lsl) {
 711     ShOpcVal = ARM_AM::getShiftOpcForNode(Base);
 712     if (ShOpcVal == ARM_AM::lsl)
 713       std::swap(Base, OffReg);
 714   }
 715
 716   if (ShOpcVal == ARM_AM::lsl) {
 717     // Check to see if the RHS of the shift is a constant, if not, we can't fold
 718     // it.
 719     if (ConstantSDNode *Sh = dyn_cast<ConstantSDNode>(OffReg.getOperand(1))) {
 720       ShAmt = Sh->getZExtValue();
 721       if (ShAmt >= 4) {
 722         ShAmt = 0;
 723         ShOpcVal = ARM_AM::no_shift;
 724       } else
 725         OffReg = OffReg.getOperand(0);
 726     } else {
 727       ShOpcVal = ARM_AM::no_shift;
 728     }
 729   } else if (SelectT2AddrModeImm12(Op, N, Base, ShImm) ||
 730              SelectT2AddrModeImm8 (Op, N, Base, ShImm))
 731     // Don't match if it's possible to match to one of the r +/- imm cases.
 732     return false;
 733
 734   ShImm = CurDAG->getTargetConstant(ShAmt, MVT::i32);
 735
 736   return true;
 737 }
 738
 739 //===--------------------------------------------------------------------===//
 740
 741 /// getAL - Returns a ARMCC::AL immediate node.
 742 static inline SDValue getAL(SelectionDAG *CurDAG) {
 743   return CurDAG->getTargetConstant((uint64_t)ARMCC::AL, MVT::i32);
 744 }
 745
 746 SDNode *ARMDAGToDAGISel::SelectARMIndexedLoad(SDValue Op) {
 747   LoadSDNode *LD = cast<LoadSDNode>(Op);
 748   ISD::MemIndexedMode AM = LD->getAddressingMode();
 749   if (AM == ISD::UNINDEXED)
 750     return NULL;
 751
 752   MVT LoadedVT = LD->getMemoryVT();
 753   SDValue Offset, AMOpc;
 754   bool isPre = (AM == ISD::PRE_INC) || (AM == ISD::PRE_DEC);
 755   unsigned Opcode = 0;
 756   bool Match = false;
 757   if (LoadedVT == MVT::i32 &&
 758       SelectAddrMode2Offset(Op, LD->getOffset(), Offset, AMOpc)) {
 759     Opcode = isPre ? ARM::LDR_PRE : ARM::LDR_POST;
 760     Match = true;
 761   } else if (LoadedVT == MVT::i16 &&
 762              SelectAddrMode3Offset(Op, LD->getOffset(), Offset, AMOpc)) {
 763     Match = true;
 764     Opcode = (LD->getExtensionType() == ISD::SEXTLOAD)
 765       ? (isPre ? ARM::LDRSH_PRE : ARM::LDRSH_POST)
 766       : (isPre ? ARM::LDRH_PRE : ARM::LDRH_POST);
 767   } else if (LoadedVT == MVT::i8 || LoadedVT == MVT::i1) {
 768     if (LD->getExtensionType() == ISD::SEXTLOAD) {
 769       if (SelectAddrMode3Offset(Op, LD->getOffset(), Offset, AMOpc)) {
 770         Match = true;
 771         Opcode = isPre ? ARM::LDRSB_PRE : ARM::LDRSB_POST;
 772       }
 773     } else {
 774       if (SelectAddrMode2Offset(Op, LD->getOffset(), Offset, AMOpc)) {
 775         Match = true;
 776         Opcode = isPre ? ARM::LDRB_PRE : ARM::LDRB_POST;
 777       }
 778     }
 779   }
 780
 781   if (Match) {
 782     SDValue Chain = LD->getChain();
 783     SDValue Base = LD->getBasePtr();
 784     SDValue Ops[]= { Base, Offset, AMOpc, getAL(CurDAG),
 785                      CurDAG->getRegister(0, MVT::i32), Chain };
 786     return CurDAG->getTargetNode(Opcode, Op.getDebugLoc(), MVT::i32, MVT::i32,
 787                                  MVT::Other, Ops, 6);
 788   }
 789
 790   return NULL;
 791 }
 792
 793 SDNode *ARMDAGToDAGISel::SelectT2IndexedLoad(SDValue Op) {
 794   LoadSDNode *LD = cast<LoadSDNode>(Op);
 795   ISD::MemIndexedMode AM = LD->getAddressingMode();
 796   if (AM == ISD::UNINDEXED)
 797     return NULL;
 798
 799   MVT LoadedVT = LD->getMemoryVT();
 800   bool isSExtLd = LD->getExtensionType() == ISD::SEXTLOAD;
 801   SDValue Offset;
 802   bool isPre = (AM == ISD::PRE_INC) || (AM == ISD::PRE_DEC);
 803   unsigned Opcode = 0;
 804   bool Match = false;
 805   if (SelectT2AddrModeImm8Offset(Op, LD->getOffset(), Offset)) {
 806     switch (LoadedVT.getSimpleVT()) {
 807     case MVT::i32:
 808       Opcode = isPre ? ARM::t2LDR_PRE : ARM::t2LDR_POST;
 809       break;
 810     case MVT::i16:
 811       if (isSExtLd)
 812         Opcode = isPre ? ARM::t2LDRSH_PRE : ARM::t2LDRSH_POST;
 813       else
 814         Opcode = isPre ? ARM::t2LDRH_PRE : ARM::t2LDRH_POST;
 815       break;
 816     case MVT::i8:
 817     case MVT::i1:
 818       if (isSExtLd)
 819         Opcode = isPre ? ARM::t2LDRSB_PRE : ARM::t2LDRSB_POST;
 820       else
 821         Opcode = isPre ? ARM::t2LDRB_PRE : ARM::t2LDRB_POST;
 822       break;
 823     default:
 824       return NULL;
 825     }
 826     Match = true;
 827   }
 828
 829   if (Match) {
 830     SDValue Chain = LD->getChain();
 831     SDValue Base = LD->getBasePtr();
 832     SDValue Ops[]= { Base, Offset, getAL(CurDAG),
 833                      CurDAG->getRegister(0, MVT::i32), Chain };
 834     return CurDAG->getTargetNode(Opcode, Op.getDebugLoc(), MVT::i32, MVT::i32,
 835                                  MVT::Other, Ops, 5);
 836   }
 837
 838   return NULL;
 839 }
 840
 841
 842 SDNode *ARMDAGToDAGISel::Select(SDValue Op) {
 843   SDNode *N = Op.getNode();
 844   DebugLoc dl = N->getDebugLoc();
 845
 846   if (N->isMachineOpcode())
 847     return NULL;   // Already selected.
 848
 849   switch (N->getOpcode()) {
 850   default: break;
 851   case ISD::Constant: {
 852     unsigned Val = cast<ConstantSDNode>(N)->getZExtValue();
 853     bool UseCP = true;
 854     if (Subtarget->isThumb()) {
 855       if (Subtarget->hasThumb2())
 856         // Thumb2 has the MOVT instruction, so all immediates can
 857         // be done with MOV + MOVT, at worst.
 858         UseCP = 0;
 859       else
 860         UseCP = (Val > 255 &&                          // MOV
 861                  ~Val > 255 &&                         // MOV + MVN
 862                  !ARM_AM::isThumbImmShiftedVal(Val));  // MOV + LSL
 863     } else
 864       UseCP = (ARM_AM::getSOImmVal(Val) == -1 &&     // MOV
 865                ARM_AM::getSOImmVal(~Val) == -1 &&    // MVN
 866                !ARM_AM::isSOImmTwoPartVal(Val));     // two instrs.
 867     if (UseCP) {
 868       SDValue CPIdx =
 869         CurDAG->getTargetConstantPool(ConstantInt::get(Type::Int32Ty, Val),
 870                                       TLI.getPointerTy());
 871
 872       SDNode *ResNode;
 873       if (Subtarget->isThumb())
 874         ResNode = CurDAG->getTargetNode(ARM::tLDRcp, dl, MVT::i32, MVT::Other,
 875                                         CPIdx, CurDAG->getEntryNode());
 876       else {
 877         SDValue Ops[] = {
 878           CPIdx,
 879           CurDAG->getRegister(0, MVT::i32),
 880           CurDAG->getTargetConstant(0, MVT::i32),
 881           getAL(CurDAG),
 882           CurDAG->getRegister(0, MVT::i32),
 883           CurDAG->getEntryNode()
 884         };
 885         ResNode=CurDAG->getTargetNode(ARM::LDRcp, dl, MVT::i32, MVT::Other,
 886                                       Ops, 6);
 887       }
 888       ReplaceUses(Op, SDValue(ResNode, 0));
 889       return NULL;
 890     }
 891
 892     // Other cases are autogenerated.
 893     break;
 894   }
 895   case ISD::FrameIndex: {
 896     // Selects to ADDri FI, 0 which in turn will become ADDri SP, imm.
 897     int FI = cast<FrameIndexSDNode>(N)->getIndex();
 898     SDValue TFI = CurDAG->getTargetFrameIndex(FI, TLI.getPointerTy());
 899     if (Subtarget->isThumb()) {
 900       return CurDAG->SelectNodeTo(N, ARM::tADDrSPi, MVT::i32, TFI,
 901                                   CurDAG->getTargetConstant(0, MVT::i32));
 902     } else {
 903       SDValue Ops[] = { TFI, CurDAG->getTargetConstant(0, MVT::i32),
 904                           getAL(CurDAG), CurDAG->getRegister(0, MVT::i32),
 905                           CurDAG->getRegister(0, MVT::i32) };
 906       return CurDAG->SelectNodeTo(N, ARM::ADDri, MVT::i32, Ops, 5);
 907     }
 908   }
 909   case ISD::ADD: {
 910     if (!Subtarget->isThumb())
 911       break;
 912     // Select add sp, c to tADDhirr.
 913     SDValue N0 = Op.getOperand(0);
 914     SDValue N1 = Op.getOperand(1);
 915     RegisterSDNode *LHSR = dyn_cast<RegisterSDNode>(Op.getOperand(0));
 916     RegisterSDNode *RHSR = dyn_cast<RegisterSDNode>(Op.getOperand(1));
 917     if (LHSR && LHSR->getReg() == ARM::SP) {
 918       std::swap(N0, N1);
 919       std::swap(LHSR, RHSR);
 920     }
 921     if (RHSR && RHSR->getReg() == ARM::SP) {
 922       SDValue Val = SDValue(CurDAG->getTargetNode(ARM::tMOVlor2hir, dl,
 923                                   Op.getValueType(), N0, N0), 0);
 924       return CurDAG->SelectNodeTo(N, ARM::tADDhirr, Op.getValueType(), Val, N1);
 925     }
 926     break;
 927   }
 928   case ISD::MUL:
 929     if (Subtarget->isThumb1Only())
 930       break;
 931     if (ConstantSDNode *C = dyn_cast<ConstantSDNode>(Op.getOperand(1))) {
 932       unsigned RHSV = C->getZExtValue();
 933       if (!RHSV) break;
 934       if (isPowerOf2_32(RHSV-1)) {  // 2^n+1?
 935         SDValue V = Op.getOperand(0);
 936         unsigned ShImm = ARM_AM::getSORegOpc(ARM_AM::lsl, Log2_32(RHSV-1));
 937         SDValue Ops[] = { V, V, CurDAG->getRegister(0, MVT::i32),
 938                             CurDAG->getTargetConstant(ShImm, MVT::i32),
 939                             getAL(CurDAG), CurDAG->getRegister(0, MVT::i32),
 940                             CurDAG->getRegister(0, MVT::i32) };
 941         return CurDAG->SelectNodeTo(N, ARM::ADDrs, MVT::i32, Ops, 7);
 942       }
 943       if (isPowerOf2_32(RHSV+1)) {  // 2^n-1?
 944         SDValue V = Op.getOperand(0);
 945         unsigned ShImm = ARM_AM::getSORegOpc(ARM_AM::lsl, Log2_32(RHSV+1));
 946         SDValue Ops[] = { V, V, CurDAG->getRegister(0, MVT::i32),
 947                             CurDAG->getTargetConstant(ShImm, MVT::i32),
 948                             getAL(CurDAG), CurDAG->getRegister(0, MVT::i32),
 949                             CurDAG->getRegister(0, MVT::i32) };
 950         return CurDAG->SelectNodeTo(N, ARM::RSBrs, MVT::i32, Ops, 7);
 951       }
 952     }
 953     break;
 954   case ARMISD::FMRRD:
 955     return CurDAG->getTargetNode(ARM::FMRRD, dl, MVT::i32, MVT::i32,
 956                                  Op.getOperand(0), getAL(CurDAG),
 957                                  CurDAG->getRegister(0, MVT::i32));
 958   case ISD::UMUL_LOHI: {
 959     if (Subtarget->isThumb1Only())
 960       break;
 961     if (Subtarget->isThumb()) {
 962       SDValue Ops[] = { Op.getOperand(0), Op.getOperand(1),
 963                         getAL(CurDAG), CurDAG->getRegister(0, MVT::i32),
 964                         CurDAG->getRegister(0, MVT::i32) };
 965       return CurDAG->getTargetNode(ARM::t2UMULL, dl, MVT::i32, MVT::i32, Ops,4);
 966     } else {
 967       SDValue Ops[] = { Op.getOperand(0), Op.getOperand(1),
 968                         getAL(CurDAG), CurDAG->getRegister(0, MVT::i32),
 969                         CurDAG->getRegister(0, MVT::i32) };
 970       return CurDAG->getTargetNode(ARM::UMULL, dl, MVT::i32, MVT::i32, Ops, 5);
 971     }
 972   }
 973   case ISD::SMUL_LOHI: {
 974     if (Subtarget->isThumb1Only())
 975       break;
 976     if (Subtarget->isThumb()) {
 977       SDValue Ops[] = { Op.getOperand(0), Op.getOperand(1),
 978                         getAL(CurDAG), CurDAG->getRegister(0, MVT::i32) };
 979       return CurDAG->getTargetNode(ARM::t2SMULL, dl, MVT::i32, MVT::i32, Ops,4);
 980     } else {
 981       SDValue Ops[] = { Op.getOperand(0), Op.getOperand(1),
 982                         getAL(CurDAG), CurDAG->getRegister(0, MVT::i32),
 983                         CurDAG->getRegister(0, MVT::i32) };
 984       return CurDAG->getTargetNode(ARM::SMULL, dl, MVT::i32, MVT::i32, Ops, 5);
 985     }
 986   }
 987   case ISD::LOAD: {
 988     SDNode *ResNode = 0;
 989     if (Subtarget->isThumb() && Subtarget->hasThumb2())
 990       ResNode = SelectT2IndexedLoad(Op);
 991     else
 992       ResNode = SelectARMIndexedLoad(Op);
 993     if (ResNode)
 994       return ResNode;
 995     // Other cases are autogenerated.
 996     break;
 997   }
 998   case ARMISD::BRCOND: {
 999     // Pattern: (ARMbrcond:void (bb:Other):$dst, (imm:i32):$cc)
1000     // Emits: (Bcc:void (bb:Other):$dst, (imm:i32):$cc)
1001     // Pattern complexity = 6  cost = 1  size = 0
1002
1003     // Pattern: (ARMbrcond:void (bb:Other):$dst, (imm:i32):$cc)
1004     // Emits: (tBcc: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: (t2Bcc:void (bb:Other):$dst, (imm:i32):$cc)
1009     // Pattern complexity = 6  cost = 1  size = 0
1010
1011     unsigned Opc = Subtarget->isThumb() ?
1012       ((Subtarget->hasThumb2()) ? ARM::t2Bcc : ARM::tBcc) : ARM::Bcc;
1013     SDValue Chain = Op.getOperand(0);
1014     SDValue N1 = Op.getOperand(1);
1015     SDValue N2 = Op.getOperand(2);
1016     SDValue N3 = Op.getOperand(3);
1017     SDValue InFlag = Op.getOperand(4);
1018     assert(N1.getOpcode() == ISD::BasicBlock);
1019     assert(N2.getOpcode() == ISD::Constant);
1020     assert(N3.getOpcode() == ISD::Register);
1021
1022     SDValue Tmp2 = CurDAG->getTargetConstant(((unsigned)
1023                                cast<ConstantSDNode>(N2)->getZExtValue()),
1024                                MVT::i32);
1025     SDValue Ops[] = { N1, Tmp2, N3, Chain, InFlag };
1026     SDNode *ResNode = CurDAG->getTargetNode(Opc, dl, MVT::Other,
1027                                             MVT::Flag, Ops, 5);
1028     Chain = SDValue(ResNode, 0);
1029     if (Op.getNode()->getNumValues() == 2) {
1030       InFlag = SDValue(ResNode, 1);
1031       ReplaceUses(SDValue(Op.getNode(), 1), InFlag);
1032     }
1033     ReplaceUses(SDValue(Op.getNode(), 0), SDValue(Chain.getNode(), Chain.getResNo()));
1034     return NULL;
1035   }
1036   case ARMISD::CMOV: {
1037     MVT VT = Op.getValueType();
1038     SDValue N0 = Op.getOperand(0);
1039     SDValue N1 = Op.getOperand(1);
1040     SDValue N2 = Op.getOperand(2);
1041     SDValue N3 = Op.getOperand(3);
1042     SDValue InFlag = Op.getOperand(4);
1043     assert(N2.getOpcode() == ISD::Constant);
1044     assert(N3.getOpcode() == ISD::Register);
1045
1046     if (!Subtarget->isThumb1Only() && VT == MVT::i32) {
1047       // Pattern: (ARMcmov:i32 GPR:i32:$false, so_reg:i32:$true, (imm:i32):$cc)
1048       // Emits: (MOVCCs:i32 GPR:i32:$false, so_reg:i32:$true, (imm:i32):$cc)
1049       // Pattern complexity = 18  cost = 1  size = 0
1050       SDValue CPTmp0;
1051       SDValue CPTmp1;
1052       SDValue CPTmp2;
1053       if (Subtarget->isThumb()) {
1054         if (SelectT2ShifterOperandReg(Op, N1, CPTmp0, CPTmp1)) {
1055           SDValue Tmp2 = CurDAG->getTargetConstant(((unsigned)
1056                                    cast<ConstantSDNode>(N2)->getZExtValue()),
1057                                    MVT::i32);
1058           SDValue Ops[] = { N0, CPTmp0, CPTmp1, Tmp2, N3, InFlag };
1059           return CurDAG->SelectNodeTo(Op.getNode(),
1060                                       ARM::t2MOVCCs, MVT::i32,Ops, 6);
1061         }
1062       } else {
1063         if (SelectShifterOperandReg(Op, N1, CPTmp0, CPTmp1, CPTmp2)) {
1064           SDValue Tmp2 = CurDAG->getTargetConstant(((unsigned)
1065                                    cast<ConstantSDNode>(N2)->getZExtValue()),
1066                                    MVT::i32);
1067           SDValue Ops[] = { N0, CPTmp0, CPTmp1, CPTmp2, Tmp2, N3, InFlag };
1068           return CurDAG->SelectNodeTo(Op.getNode(),
1069                                       ARM::MOVCCs, MVT::i32, Ops, 7);
1070         }
1071       }
1072
1073       // Pattern: (ARMcmov:i32 GPR:i32:$false,
1074       //             (imm:i32)<<P:Predicate_so_imm>><<X:so_imm_XFORM>>:$true,
1075       //             (imm:i32):$cc)
1076       // Emits: (MOVCCi:i32 GPR:i32:$false,
1077       //           (so_imm_XFORM:i32 (imm:i32):$true), (imm:i32):$cc)
1078       // Pattern complexity = 10  cost = 1  size = 0
1079       if (N3.getOpcode() == ISD::Constant) {
1080         if (Subtarget->isThumb()) {
1081           if (Predicate_t2_so_imm(N3.getNode())) {
1082             SDValue Tmp1 = CurDAG->getTargetConstant(((unsigned)
1083                                      cast<ConstantSDNode>(N1)->getZExtValue()),
1084                                      MVT::i32);
1085             Tmp1 = Transform_t2_so_imm_XFORM(Tmp1.getNode());
1086             SDValue Tmp2 = CurDAG->getTargetConstant(((unsigned)
1087                                      cast<ConstantSDNode>(N2)->getZExtValue()),
1088                                      MVT::i32);
1089             SDValue Ops[] = { N0, Tmp1, Tmp2, N3, InFlag };
1090             return CurDAG->SelectNodeTo(Op.getNode(),
1091                                         ARM::t2MOVCCi, MVT::i32, Ops, 5);
1092           }
1093         } else {
1094           if (Predicate_so_imm(N3.getNode())) {
1095             SDValue Tmp1 = CurDAG->getTargetConstant(((unsigned)
1096                                      cast<ConstantSDNode>(N1)->getZExtValue()),
1097                                      MVT::i32);
1098             Tmp1 = Transform_so_imm_XFORM(Tmp1.getNode());
1099             SDValue Tmp2 = CurDAG->getTargetConstant(((unsigned)
1100                                      cast<ConstantSDNode>(N2)->getZExtValue()),
1101                                      MVT::i32);
1102             SDValue Ops[] = { N0, Tmp1, Tmp2, N3, InFlag };
1103             return CurDAG->SelectNodeTo(Op.getNode(),
1104                                         ARM::MOVCCi, MVT::i32, Ops, 5);
1105           }
1106         }
1107       }
1108     }
1109
1110     // Pattern: (ARMcmov:i32 GPR:i32:$false, GPR:i32:$true, (imm:i32):$cc)
1111     // Emits: (MOVCCr:i32 GPR:i32:$false, GPR:i32:$true, (imm:i32):$cc)
1112     // Pattern complexity = 6  cost = 1  size = 0
1113     //
1114     // Pattern: (ARMcmov:i32 GPR:i32:$false, GPR:i32:$true, (imm:i32):$cc)
1115     // Emits: (tMOVCCr:i32 GPR:i32:$false, GPR:i32:$true, (imm:i32):$cc)
1116     // Pattern complexity = 6  cost = 11  size = 0
1117     //
1118     // Also FCPYScc and FCPYDcc.
1119     SDValue Tmp2 = CurDAG->getTargetConstant(((unsigned)
1120                                cast<ConstantSDNode>(N2)->getZExtValue()),
1121                                MVT::i32);
1122     SDValue Ops[] = { N0, N1, Tmp2, N3, InFlag };
1123     unsigned Opc = 0;
1124     switch (VT.getSimpleVT()) {
1125     default: assert(false && "Illegal conditional move type!");
1126       break;
1127     case MVT::i32:
1128       Opc = Subtarget->isThumb()
1129         ? (Subtarget->hasThumb2() ? ARM::t2MOVCCr : ARM::tMOVCCr)
1130         : ARM::MOVCCr;
1131       break;
1132     case MVT::f32:
1133       Opc = ARM::FCPYScc;
1134       break;
1135     case MVT::f64:
1136       Opc = ARM::FCPYDcc;
1137       break;
1138     }
1139     return CurDAG->SelectNodeTo(Op.getNode(), Opc, VT, Ops, 5);
1140   }
1141   case ARMISD::CNEG: {
1142     MVT VT = Op.getValueType();
1143     SDValue N0 = Op.getOperand(0);
1144     SDValue N1 = Op.getOperand(1);
1145     SDValue N2 = Op.getOperand(2);
1146     SDValue N3 = Op.getOperand(3);
1147     SDValue InFlag = Op.getOperand(4);
1148     assert(N2.getOpcode() == ISD::Constant);
1149     assert(N3.getOpcode() == ISD::Register);
1150
1151     SDValue Tmp2 = CurDAG->getTargetConstant(((unsigned)
1152                                cast<ConstantSDNode>(N2)->getZExtValue()),
1153                                MVT::i32);
1154     SDValue Ops[] = { N0, N1, Tmp2, N3, InFlag };
1155     unsigned Opc = 0;
1156     switch (VT.getSimpleVT()) {
1157     default: assert(false && "Illegal conditional move type!");
1158       break;
1159     case MVT::f32:
1160       Opc = ARM::FNEGScc;
1161       break;
1162     case MVT::f64:
1163       Opc = ARM::FNEGDcc;
1164       break;
1165     }
1166     return CurDAG->SelectNodeTo(Op.getNode(), Opc, VT, Ops, 5);
1167   }
1168
1169   case ISD::DECLARE: {
1170     SDValue Chain = Op.getOperand(0);
1171     SDValue N1 = Op.getOperand(1);
1172     SDValue N2 = Op.getOperand(2);
1173     FrameIndexSDNode *FINode = dyn_cast<FrameIndexSDNode>(N1);
1174     // FIXME: handle VLAs.
1175     if (!FINode) {
1176       ReplaceUses(Op.getValue(0), Chain);
1177       return NULL;
1178     }
1179     if (N2.getOpcode() == ARMISD::PIC_ADD && isa<LoadSDNode>(N2.getOperand(0)))
1180       N2 = N2.getOperand(0);
1181     LoadSDNode *Ld = dyn_cast<LoadSDNode>(N2);
1182     if (!Ld) {
1183       ReplaceUses(Op.getValue(0), Chain);
1184       return NULL;
1185     }
1186     SDValue BasePtr = Ld->getBasePtr();
1187     assert(BasePtr.getOpcode() == ARMISD::Wrapper &&
1188            isa<ConstantPoolSDNode>(BasePtr.getOperand(0)) &&
1189            "llvm.dbg.variable should be a constantpool node");
1190     ConstantPoolSDNode *CP = cast<ConstantPoolSDNode>(BasePtr.getOperand(0));
1191     GlobalValue *GV = 0;
1192     if (CP->isMachineConstantPoolEntry()) {
1193       ARMConstantPoolValue *ACPV = (ARMConstantPoolValue*)CP->getMachineCPVal();
1194       GV = ACPV->getGV();
1195     } else
1196       GV = dyn_cast<GlobalValue>(CP->getConstVal());
1197     if (!GV) {
1198       ReplaceUses(Op.getValue(0), Chain);
1199       return NULL;
1200     }
1201
1202     SDValue Tmp1 = CurDAG->getTargetFrameIndex(FINode->getIndex(),
1203                                                TLI.getPointerTy());
1204     SDValue Tmp2 = CurDAG->getTargetGlobalAddress(GV, TLI.getPointerTy());
1205     SDValue Ops[] = { Tmp1, Tmp2, Chain };
1206     return CurDAG->getTargetNode(TargetInstrInfo::DECLARE, dl,
1207                                  MVT::Other, Ops, 3);
1208   }
1209
1210   case ISD::CONCAT_VECTORS: {
1211     MVT VT = Op.getValueType();
1212     assert(VT.is128BitVector() && Op.getNumOperands() == 2 &&
1213            "unexpected CONCAT_VECTORS");
1214     SDValue N0 = Op.getOperand(0);
1215     SDValue N1 = Op.getOperand(1);
1216     SDNode *Result =
1217       CurDAG->getTargetNode(TargetInstrInfo::IMPLICIT_DEF, dl, VT);
1218     if (N0.getOpcode() != ISD::UNDEF)
1219       Result = CurDAG->getTargetNode(TargetInstrInfo::INSERT_SUBREG, dl, VT,
1220                                      SDValue(Result, 0), N0,
1221                                      CurDAG->getTargetConstant(arm_dsubreg_0,
1222                                                                MVT::i32));
1223     if (N1.getOpcode() != ISD::UNDEF)
1224       Result = CurDAG->getTargetNode(TargetInstrInfo::INSERT_SUBREG, dl, VT,
1225                                      SDValue(Result, 0), N1,
1226                                      CurDAG->getTargetConstant(arm_dsubreg_1,
1227                                                                MVT::i32));
1228     return Result;
1229   }
1230
1231   case ISD::VECTOR_SHUFFLE: {
1232     MVT VT = Op.getValueType();
1233
1234     // Match 128-bit splat to VDUPLANEQ.  (This could be done with a Pat in
1235     // ARMInstrNEON.td but it is awkward because the shuffle mask needs to be
1236     // transformed first into a lane number and then to both a subregister
1237     // index and an adjusted lane number.)  If the source operand is a
1238     // SCALAR_TO_VECTOR, leave it so it will be matched later as a VDUP.
1239     ShuffleVectorSDNode *SVOp = cast<ShuffleVectorSDNode>(N);
1240     if (VT.is128BitVector() && SVOp->isSplat() &&
1241         Op.getOperand(0).getOpcode() != ISD::SCALAR_TO_VECTOR &&
1242         Op.getOperand(1).getOpcode() == ISD::UNDEF) {
1243       unsigned LaneVal = SVOp->getSplatIndex();
1244
1245       MVT HalfVT;
1246       unsigned Opc = 0;
1247       switch (VT.getVectorElementType().getSimpleVT()) {
1248       default: assert(false && "unhandled VDUP splat type");
1249       case MVT::i8:  Opc = ARM::VDUPLN8q;  HalfVT = MVT::v8i8; break;
1250       case MVT::i16: Opc = ARM::VDUPLN16q; HalfVT = MVT::v4i16; break;
1251       case MVT::i32: Opc = ARM::VDUPLN32q; HalfVT = MVT::v2i32; break;
1252       case MVT::f32: Opc = ARM::VDUPLNfq;  HalfVT = MVT::v2f32; break;
1253       }
1254
1255       // The source operand needs to be changed to a subreg of the original
1256       // 128-bit operand, and the lane number needs to be adjusted accordingly.
1257       unsigned NumElts = VT.getVectorNumElements() / 2;
1258       unsigned SRVal = (LaneVal < NumElts ? arm_dsubreg_0 : arm_dsubreg_1);
1259       SDValue SR = CurDAG->getTargetConstant(SRVal, MVT::i32);
1260       SDValue NewLane = CurDAG->getTargetConstant(LaneVal % NumElts, MVT::i32);
1261       SDNode *SubReg = CurDAG->getTargetNode(TargetInstrInfo::EXTRACT_SUBREG,
1262                                              dl, HalfVT, N->getOperand(0), SR);
1263       return CurDAG->SelectNodeTo(N, Opc, VT, SDValue(SubReg, 0), NewLane);
1264     }
1265
1266     break;
1267   }
1268   }
1269
1270   return SelectCode(Op);
1271 }
1272
1273 bool ARMDAGToDAGISel::
1274 SelectInlineAsmMemoryOperand(const SDValue &Op, char ConstraintCode,
1275                              std::vector<SDValue> &OutOps) {
1276   assert(ConstraintCode == 'm' && "unexpected asm memory constraint");
1277
1278   SDValue Base, Offset, Opc;
1279   if (!SelectAddrMode2(Op, Op, Base, Offset, Opc))
1280     return true;
1281
1282   OutOps.push_back(Base);
1283   OutOps.push_back(Offset);
1284   OutOps.push_back(Opc);
1285   return false;
1286 }
1287
1288 /// createARMISelDag - This pass converts a legalized DAG into a
1289 /// ARM-specific DAG, ready for instruction scheduling.
1290 ///
1291 FunctionPass *llvm::createARMISelDag(ARMBaseTargetMachine &TM) {
1292   return new ARMDAGToDAGISel(TM);
1293 }