LLVM API Documentation

ARMISelDAGToDAG.cpp

Go to the documentation of this file.
00001 //===-- ARMISelDAGToDAG.cpp - A dag to dag inst selector for ARM ----------===//
00002 //
00003 //                     The LLVM Compiler Infrastructure
00004 //
00005 // This file is distributed under the University of Illinois Open Source
00006 // License. See LICENSE.TXT for details.
00007 //
00008 //===----------------------------------------------------------------------===//
00009 //
00010 // This file defines an instruction selector for the ARM target.
00011 //
00012 //===----------------------------------------------------------------------===//
00013 
00014 #include "ARM.h"
00015 #include "ARMAddressingModes.h"
00016 #include "ARMConstantPoolValue.h"
00017 #include "ARMISelLowering.h"
00018 #include "ARMTargetMachine.h"
00019 #include "llvm/CallingConv.h"
00020 #include "llvm/Constants.h"
00021 #include "llvm/DerivedTypes.h"
00022 #include "llvm/Function.h"
00023 #include "llvm/Intrinsics.h"
00024 #include "llvm/LLVMContext.h"
00025 #include "llvm/CodeGen/MachineFrameInfo.h"
00026 #include "llvm/CodeGen/MachineFunction.h"
00027 #include "llvm/CodeGen/MachineInstrBuilder.h"
00028 #include "llvm/CodeGen/SelectionDAG.h"
00029 #include "llvm/CodeGen/SelectionDAGISel.h"
00030 #include "llvm/Target/TargetLowering.h"
00031 #include "llvm/Target/TargetOptions.h"
00032 #include "llvm/Support/Compiler.h"
00033 #include "llvm/Support/Debug.h"
00034 #include "llvm/Support/ErrorHandling.h"
00035 #include "llvm/Support/raw_ostream.h"
00036 
00037 using namespace llvm;
00038 
00039 //===--------------------------------------------------------------------===//
00040 /// ARMDAGToDAGISel - ARM specific code to select ARM machine
00041 /// instructions for SelectionDAG operations.
00042 ///
00043 namespace {
00044 class ARMDAGToDAGISel : public SelectionDAGISel {
00045   ARMBaseTargetMachine &TM;
00046 
00047   /// Subtarget - Keep a pointer to the ARMSubtarget around so that we can
00048   /// make the right decision when generating code for different targets.
00049   const ARMSubtarget *Subtarget;
00050 
00051 public:
00052   explicit ARMDAGToDAGISel(ARMBaseTargetMachine &tm)
00053     : SelectionDAGISel(tm), TM(tm),
00054     Subtarget(&TM.getSubtarget<ARMSubtarget>()) {
00055   }
00056 
00057   virtual const char *getPassName() const {
00058     return "ARM Instruction Selection";
00059   }
00060 
00061  /// getI32Imm - Return a target constant with the specified value, of type i32.
00062   inline SDValue getI32Imm(unsigned Imm) {
00063     return CurDAG->getTargetConstant(Imm, MVT::i32);
00064   }
00065 
00066   SDNode *Select(SDValue Op);
00067   virtual void InstructionSelect();
00068   bool SelectShifterOperandReg(SDValue Op, SDValue N, SDValue &A,
00069                                SDValue &B, SDValue &C);
00070   bool SelectAddrMode2(SDValue Op, SDValue N, SDValue &Base,
00071                        SDValue &Offset, SDValue &Opc);
00072   bool SelectAddrMode2Offset(SDValue Op, SDValue N,
00073                              SDValue &Offset, SDValue &Opc);
00074   bool SelectAddrMode3(SDValue Op, SDValue N, SDValue &Base,
00075                        SDValue &Offset, SDValue &Opc);
00076   bool SelectAddrMode3Offset(SDValue Op, SDValue N,
00077                              SDValue &Offset, SDValue &Opc);
00078   bool SelectAddrMode4(SDValue Op, SDValue N, SDValue &Addr,
00079                        SDValue &Mode);
00080   bool SelectAddrMode5(SDValue Op, SDValue N, SDValue &Base,
00081                        SDValue &Offset);
00082   bool SelectAddrMode6(SDValue Op, SDValue N, SDValue &Addr, SDValue &Update,
00083                        SDValue &Opc);
00084 
00085   bool SelectAddrModePC(SDValue Op, SDValue N, SDValue &Offset,
00086                         SDValue &Label);
00087 
00088   bool SelectThumbAddrModeRR(SDValue Op, SDValue N, SDValue &Base,
00089                              SDValue &Offset);
00090   bool SelectThumbAddrModeRI5(SDValue Op, SDValue N, unsigned Scale,
00091                               SDValue &Base, SDValue &OffImm,
00092                               SDValue &Offset);
00093   bool SelectThumbAddrModeS1(SDValue Op, SDValue N, SDValue &Base,
00094                              SDValue &OffImm, SDValue &Offset);
00095   bool SelectThumbAddrModeS2(SDValue Op, SDValue N, SDValue &Base,
00096                              SDValue &OffImm, SDValue &Offset);
00097   bool SelectThumbAddrModeS4(SDValue Op, SDValue N, SDValue &Base,
00098                              SDValue &OffImm, SDValue &Offset);
00099   bool SelectThumbAddrModeSP(SDValue Op, SDValue N, SDValue &Base,
00100                              SDValue &OffImm);
00101 
00102   bool SelectT2ShifterOperandReg(SDValue Op, SDValue N,
00103                                  SDValue &BaseReg, SDValue &Opc);
00104   bool SelectT2AddrModeImm12(SDValue Op, SDValue N, SDValue &Base,
00105                              SDValue &OffImm);
00106   bool SelectT2AddrModeImm8(SDValue Op, SDValue N, SDValue &Base,
00107                             SDValue &OffImm);
00108   bool SelectT2AddrModeImm8Offset(SDValue Op, SDValue N,
00109                                  SDValue &OffImm);
00110   bool SelectT2AddrModeImm8s4(SDValue Op, SDValue N, SDValue &Base,
00111                               SDValue &OffImm);
00112   bool SelectT2AddrModeSoReg(SDValue Op, SDValue N, SDValue &Base,
00113                              SDValue &OffReg, SDValue &ShImm);
00114 
00115   // Include the pieces autogenerated from the target description.
00116 #include "ARMGenDAGISel.inc"
00117 
00118 private:
00119   /// SelectARMIndexedLoad - Indexed (pre/post inc/dec) load matching code for
00120   /// ARM.
00121   SDNode *SelectARMIndexedLoad(SDValue Op);
00122   SDNode *SelectT2IndexedLoad(SDValue Op);
00123 
00124   /// SelectDYN_ALLOC - Select dynamic alloc for Thumb.
00125   SDNode *SelectDYN_ALLOC(SDValue Op);
00126 
00127   /// SelectInlineAsmMemoryOperand - Implement addressing mode selection for
00128   /// inline asm expressions.
00129   virtual bool SelectInlineAsmMemoryOperand(const SDValue &Op,
00130                                             char ConstraintCode,
00131                                             std::vector<SDValue> &OutOps);
00132 };
00133 }
00134 
00135 void ARMDAGToDAGISel::InstructionSelect() {
00136   DEBUG(BB->dump());
00137 
00138   SelectRoot(*CurDAG);
00139   CurDAG->RemoveDeadNodes();
00140 }
00141 
00142 bool ARMDAGToDAGISel::SelectShifterOperandReg(SDValue Op,
00143                                               SDValue N,
00144                                               SDValue &BaseReg,
00145                                               SDValue &ShReg,
00146                                               SDValue &Opc) {
00147   ARM_AM::ShiftOpc ShOpcVal = ARM_AM::getShiftOpcForNode(N);
00148 
00149   // Don't match base register only case. That is matched to a separate
00150   // lower complexity pattern with explicit register operand.
00151   if (ShOpcVal == ARM_AM::no_shift) return false;
00152 
00153   BaseReg = N.getOperand(0);
00154   unsigned ShImmVal = 0;
00155   if (ConstantSDNode *RHS = dyn_cast<ConstantSDNode>(N.getOperand(1))) {
00156     ShReg = CurDAG->getRegister(0, MVT::i32);
00157     ShImmVal = RHS->getZExtValue() & 31;
00158   } else {
00159     ShReg = N.getOperand(1);
00160   }
00161   Opc = CurDAG->getTargetConstant(ARM_AM::getSORegOpc(ShOpcVal, ShImmVal),
00162                                   MVT::i32);
00163   return true;
00164 }
00165 
00166 bool ARMDAGToDAGISel::SelectAddrMode2(SDValue Op, SDValue N,
00167                                       SDValue &Base, SDValue &Offset,
00168                                       SDValue &Opc) {
00169   if (N.getOpcode() == ISD::MUL) {
00170     if (ConstantSDNode *RHS = dyn_cast<ConstantSDNode>(N.getOperand(1))) {
00171       // X * [3,5,9] -> X + X * [2,4,8] etc.
00172       int RHSC = (int)RHS->getZExtValue();
00173       if (RHSC & 1) {
00174         RHSC = RHSC & ~1;
00175         ARM_AM::AddrOpc AddSub = ARM_AM::add;
00176         if (RHSC < 0) {
00177           AddSub = ARM_AM::sub;
00178           RHSC = - RHSC;
00179         }
00180         if (isPowerOf2_32(RHSC)) {
00181           unsigned ShAmt = Log2_32(RHSC);
00182           Base = Offset = N.getOperand(0);
00183           Opc = CurDAG->getTargetConstant(ARM_AM::getAM2Opc(AddSub, ShAmt,
00184                                                             ARM_AM::lsl),
00185                                           MVT::i32);
00186           return true;
00187         }
00188       }
00189     }
00190   }
00191 
00192   if (N.getOpcode() != ISD::ADD && N.getOpcode() != ISD::SUB) {
00193     Base = N;
00194     if (N.getOpcode() == ISD::FrameIndex) {
00195       int FI = cast<FrameIndexSDNode>(N)->getIndex();
00196       Base = CurDAG->getTargetFrameIndex(FI, TLI.getPointerTy());
00197     } else if (N.getOpcode() == ARMISD::Wrapper) {
00198       Base = N.getOperand(0);
00199     }
00200     Offset = CurDAG->getRegister(0, MVT::i32);
00201     Opc = CurDAG->getTargetConstant(ARM_AM::getAM2Opc(ARM_AM::add, 0,
00202                                                       ARM_AM::no_shift),
00203                                     MVT::i32);
00204     return true;
00205   }
00206 
00207   // Match simple R +/- imm12 operands.
00208   if (N.getOpcode() == ISD::ADD)
00209     if (ConstantSDNode *RHS = dyn_cast<ConstantSDNode>(N.getOperand(1))) {
00210       int RHSC = (int)RHS->getZExtValue();
00211       if ((RHSC >= 0 && RHSC < 0x1000) ||
00212           (RHSC < 0 && RHSC > -0x1000)) { // 12 bits.
00213         Base = N.getOperand(0);
00214         if (Base.getOpcode() == ISD::FrameIndex) {
00215           int FI = cast<FrameIndexSDNode>(Base)->getIndex();
00216           Base = CurDAG->getTargetFrameIndex(FI, TLI.getPointerTy());
00217         }
00218         Offset = CurDAG->getRegister(0, MVT::i32);
00219 
00220         ARM_AM::AddrOpc AddSub = ARM_AM::add;
00221         if (RHSC < 0) {
00222           AddSub = ARM_AM::sub;
00223           RHSC = - RHSC;
00224         }
00225         Opc = CurDAG->getTargetConstant(ARM_AM::getAM2Opc(AddSub, RHSC,
00226                                                           ARM_AM::no_shift),
00227                                         MVT::i32);
00228         return true;
00229       }
00230     }
00231 
00232   // Otherwise this is R +/- [possibly shifted] R
00233   ARM_AM::AddrOpc AddSub = N.getOpcode() == ISD::ADD ? ARM_AM::add:ARM_AM::sub;
00234   ARM_AM::ShiftOpc ShOpcVal = ARM_AM::getShiftOpcForNode(N.getOperand(1));
00235   unsigned ShAmt = 0;
00236 
00237   Base   = N.getOperand(0);
00238   Offset = N.getOperand(1);
00239 
00240   if (ShOpcVal != ARM_AM::no_shift) {
00241     // Check to see if the RHS of the shift is a constant, if not, we can't fold
00242     // it.
00243     if (ConstantSDNode *Sh =
00244            dyn_cast<ConstantSDNode>(N.getOperand(1).getOperand(1))) {
00245       ShAmt = Sh->getZExtValue();
00246       Offset = N.getOperand(1).getOperand(0);
00247     } else {
00248       ShOpcVal = ARM_AM::no_shift;
00249     }
00250   }
00251 
00252   // Try matching (R shl C) + (R).
00253   if (N.getOpcode() == ISD::ADD && ShOpcVal == ARM_AM::no_shift) {
00254     ShOpcVal = ARM_AM::getShiftOpcForNode(N.getOperand(0));
00255     if (ShOpcVal != ARM_AM::no_shift) {
00256       // Check to see if the RHS of the shift is a constant, if not, we can't
00257       // fold it.
00258       if (ConstantSDNode *Sh =
00259           dyn_cast<ConstantSDNode>(N.getOperand(0).getOperand(1))) {
00260         ShAmt = Sh->getZExtValue();
00261         Offset = N.getOperand(0).getOperand(0);
00262         Base = N.getOperand(1);
00263       } else {
00264         ShOpcVal = ARM_AM::no_shift;
00265       }
00266     }
00267   }
00268 
00269   Opc = CurDAG->getTargetConstant(ARM_AM::getAM2Opc(AddSub, ShAmt, ShOpcVal),
00270                                   MVT::i32);
00271   return true;
00272 }
00273 
00274 bool ARMDAGToDAGISel::SelectAddrMode2Offset(SDValue Op, SDValue N,
00275                                             SDValue &Offset, SDValue &Opc) {
00276   unsigned Opcode = Op.getOpcode();
00277   ISD::MemIndexedMode AM = (Opcode == ISD::LOAD)
00278     ? cast<LoadSDNode>(Op)->getAddressingMode()
00279     : cast<StoreSDNode>(Op)->getAddressingMode();
00280   ARM_AM::AddrOpc AddSub = (AM == ISD::PRE_INC || AM == ISD::POST_INC)
00281     ? ARM_AM::add : ARM_AM::sub;
00282   if (ConstantSDNode *C = dyn_cast<ConstantSDNode>(N)) {
00283     int Val = (int)C->getZExtValue();
00284     if (Val >= 0 && Val < 0x1000) { // 12 bits.
00285       Offset = CurDAG->getRegister(0, MVT::i32);
00286       Opc = CurDAG->getTargetConstant(ARM_AM::getAM2Opc(AddSub, Val,
00287                                                         ARM_AM::no_shift),
00288                                       MVT::i32);
00289       return true;
00290     }
00291   }
00292 
00293   Offset = N;
00294   ARM_AM::ShiftOpc ShOpcVal = ARM_AM::getShiftOpcForNode(N);
00295   unsigned ShAmt = 0;
00296   if (ShOpcVal != ARM_AM::no_shift) {
00297     // Check to see if the RHS of the shift is a constant, if not, we can't fold
00298     // it.
00299     if (ConstantSDNode *Sh = dyn_cast<ConstantSDNode>(N.getOperand(1))) {
00300       ShAmt = Sh->getZExtValue();
00301       Offset = N.getOperand(0);
00302     } else {
00303       ShOpcVal = ARM_AM::no_shift;
00304     }
00305   }
00306 
00307   Opc = CurDAG->getTargetConstant(ARM_AM::getAM2Opc(AddSub, ShAmt, ShOpcVal),
00308                                   MVT::i32);
00309   return true;
00310 }
00311 
00312 
00313 bool ARMDAGToDAGISel::SelectAddrMode3(SDValue Op, SDValue N,
00314                                       SDValue &Base, SDValue &Offset,
00315                                       SDValue &Opc) {
00316   if (N.getOpcode() == ISD::SUB) {
00317     // X - C  is canonicalize to X + -C, no need to handle it here.
00318     Base = N.getOperand(0);
00319     Offset = N.getOperand(1);
00320     Opc = CurDAG->getTargetConstant(ARM_AM::getAM3Opc(ARM_AM::sub, 0),MVT::i32);
00321     return true;
00322   }
00323 
00324   if (N.getOpcode() != ISD::ADD) {
00325     Base = N;
00326     if (N.getOpcode() == ISD::FrameIndex) {
00327       int FI = cast<FrameIndexSDNode>(N)->getIndex();
00328       Base = CurDAG->getTargetFrameIndex(FI, TLI.getPointerTy());
00329     }
00330     Offset = CurDAG->getRegister(0, MVT::i32);
00331     Opc = CurDAG->getTargetConstant(ARM_AM::getAM3Opc(ARM_AM::add, 0),MVT::i32);
00332     return true;
00333   }
00334 
00335   // If the RHS is +/- imm8, fold into addr mode.
00336   if (ConstantSDNode *RHS = dyn_cast<ConstantSDNode>(N.getOperand(1))) {
00337     int RHSC = (int)RHS->getZExtValue();
00338     if ((RHSC >= 0 && RHSC < 256) ||
00339         (RHSC < 0 && RHSC > -256)) { // note -256 itself isn't allowed.
00340       Base = N.getOperand(0);
00341       if (Base.getOpcode() == ISD::FrameIndex) {
00342         int FI = cast<FrameIndexSDNode>(Base)->getIndex();
00343         Base = CurDAG->getTargetFrameIndex(FI, TLI.getPointerTy());
00344       }
00345       Offset = CurDAG->getRegister(0, MVT::i32);
00346 
00347       ARM_AM::AddrOpc AddSub = ARM_AM::add;
00348       if (RHSC < 0) {
00349         AddSub = ARM_AM::sub;
00350         RHSC = - RHSC;
00351       }
00352       Opc = CurDAG->getTargetConstant(ARM_AM::getAM3Opc(AddSub, RHSC),MVT::i32);
00353       return true;
00354     }
00355   }
00356 
00357   Base = N.getOperand(0);
00358   Offset = N.getOperand(1);
00359   Opc = CurDAG->getTargetConstant(ARM_AM::getAM3Opc(ARM_AM::add, 0), MVT::i32);
00360   return true;
00361 }
00362 
00363 bool ARMDAGToDAGISel::SelectAddrMode3Offset(SDValue Op, SDValue N,
00364                                             SDValue &Offset, SDValue &Opc) {
00365   unsigned Opcode = Op.getOpcode();
00366   ISD::MemIndexedMode AM = (Opcode == ISD::LOAD)
00367     ? cast<LoadSDNode>(Op)->getAddressingMode()
00368     : cast<StoreSDNode>(Op)->getAddressingMode();
00369   ARM_AM::AddrOpc AddSub = (AM == ISD::PRE_INC || AM == ISD::POST_INC)
00370     ? ARM_AM::add : ARM_AM::sub;
00371   if (ConstantSDNode *C = dyn_cast<ConstantSDNode>(N)) {
00372     int Val = (int)C->getZExtValue();
00373     if (Val >= 0 && Val < 256) {
00374       Offset = CurDAG->getRegister(0, MVT::i32);
00375       Opc = CurDAG->getTargetConstant(ARM_AM::getAM3Opc(AddSub, Val), MVT::i32);
00376       return true;
00377     }
00378   }
00379 
00380   Offset = N;
00381   Opc = CurDAG->getTargetConstant(ARM_AM::getAM3Opc(AddSub, 0), MVT::i32);
00382   return true;
00383 }
00384 
00385 bool ARMDAGToDAGISel::SelectAddrMode4(SDValue Op, SDValue N,
00386                                       SDValue &Addr, SDValue &Mode) {
00387   Addr = N;
00388   Mode = CurDAG->getTargetConstant(0, MVT::i32);
00389   return true;
00390 }
00391 
00392 bool ARMDAGToDAGISel::SelectAddrMode5(SDValue Op, SDValue N,
00393                                       SDValue &Base, SDValue &Offset) {
00394   if (N.getOpcode() != ISD::ADD) {
00395     Base = N;
00396     if (N.getOpcode() == ISD::FrameIndex) {
00397       int FI = cast<FrameIndexSDNode>(N)->getIndex();
00398       Base = CurDAG->getTargetFrameIndex(FI, TLI.getPointerTy());
00399     } else if (N.getOpcode() == ARMISD::Wrapper) {
00400       Base = N.getOperand(0);
00401     }
00402     Offset = CurDAG->getTargetConstant(ARM_AM::getAM5Opc(ARM_AM::add, 0),
00403                                        MVT::i32);
00404     return true;
00405   }
00406 
00407   // If the RHS is +/- imm8, fold into addr mode.
00408   if (ConstantSDNode *RHS = dyn_cast<ConstantSDNode>(N.getOperand(1))) {
00409     int RHSC = (int)RHS->getZExtValue();
00410     if ((RHSC & 3) == 0) {  // The constant is implicitly multiplied by 4.
00411       RHSC >>= 2;
00412       if ((RHSC >= 0 && RHSC < 256) ||
00413           (RHSC < 0 && RHSC > -256)) { // note -256 itself isn't allowed.
00414         Base = N.getOperand(0);
00415         if (Base.getOpcode() == ISD::FrameIndex) {
00416           int FI = cast<FrameIndexSDNode>(Base)->getIndex();
00417           Base = CurDAG->getTargetFrameIndex(FI, TLI.getPointerTy());
00418         }
00419 
00420         ARM_AM::AddrOpc AddSub = ARM_AM::add;
00421         if (RHSC < 0) {
00422           AddSub = ARM_AM::sub;
00423           RHSC = - RHSC;
00424         }
00425         Offset = CurDAG->getTargetConstant(ARM_AM::getAM5Opc(AddSub, RHSC),
00426                                            MVT::i32);
00427         return true;
00428       }
00429     }
00430   }
00431 
00432   Base = N;
00433   Offset = CurDAG->getTargetConstant(ARM_AM::getAM5Opc(ARM_AM::add, 0),
00434                                      MVT::i32);
00435   return true;
00436 }
00437 
00438 bool ARMDAGToDAGISel::SelectAddrMode6(SDValue Op, SDValue N,
00439                                       SDValue &Addr, SDValue &Update,
00440                                       SDValue &Opc) {
00441   Addr = N;
00442   // The optional writeback is handled in ARMLoadStoreOpt.
00443   Update = CurDAG->getRegister(0, MVT::i32);
00444   Opc = CurDAG->getTargetConstant(ARM_AM::getAM6Opc(false), MVT::i32);
00445   return true;
00446 }
00447 
00448 bool ARMDAGToDAGISel::SelectAddrModePC(SDValue Op, SDValue N,
00449                                        SDValue &Offset, SDValue &Label) {
00450   if (N.getOpcode() == ARMISD::PIC_ADD && N.hasOneUse()) {
00451     Offset = N.getOperand(0);
00452     SDValue N1 = N.getOperand(1);
00453     Label  = CurDAG->getTargetConstant(cast<ConstantSDNode>(N1)->getZExtValue(),
00454                                        MVT::i32);
00455     return true;
00456   }
00457   return false;
00458 }
00459 
00460 bool ARMDAGToDAGISel::SelectThumbAddrModeRR(SDValue Op, SDValue N,
00461                                             SDValue &Base, SDValue &Offset){
00462   // FIXME dl should come from the parent load or store, not the address
00463   DebugLoc dl = Op.getDebugLoc();
00464   if (N.getOpcode() != ISD::ADD) {
00465     ConstantSDNode *NC = dyn_cast<ConstantSDNode>(N);
00466     if (!NC || NC->getZExtValue() != 0)
00467       return false;
00468 
00469     Base = Offset = N;
00470     return true;
00471   }
00472 
00473   Base = N.getOperand(0);
00474   Offset = N.getOperand(1);
00475   return true;
00476 }
00477 
00478 bool
00479 ARMDAGToDAGISel::SelectThumbAddrModeRI5(SDValue Op, SDValue N,
00480                                         unsigned Scale, SDValue &Base,
00481                                         SDValue &OffImm, SDValue &Offset) {
00482   if (Scale == 4) {
00483     SDValue TmpBase, TmpOffImm;
00484     if (SelectThumbAddrModeSP(Op, N, TmpBase, TmpOffImm))
00485       return false;  // We want to select tLDRspi / tSTRspi instead.
00486     if (N.getOpcode() == ARMISD::Wrapper &&
00487         N.getOperand(0).getOpcode() == ISD::TargetConstantPool)
00488       return false;  // We want to select tLDRpci instead.
00489   }
00490 
00491   if (N.getOpcode() != ISD::ADD) {
00492     Base = (N.getOpcode() == ARMISD::Wrapper) ? N.getOperand(0) : N;
00493     Offset = CurDAG->getRegister(0, MVT::i32);
00494     OffImm = CurDAG->getTargetConstant(0, MVT::i32);
00495     return true;
00496   }
00497 
00498   // Thumb does not have [sp, r] address mode.
00499   RegisterSDNode *LHSR = dyn_cast<RegisterSDNode>(N.getOperand(0));
00500   RegisterSDNode *RHSR = dyn_cast<RegisterSDNode>(N.getOperand(1));
00501   if ((LHSR && LHSR->getReg() == ARM::SP) ||
00502       (RHSR && RHSR->getReg() == ARM::SP)) {
00503     Base = N;
00504     Offset = CurDAG->getRegister(0, MVT::i32);
00505     OffImm = CurDAG->getTargetConstant(0, MVT::i32);
00506     return true;
00507   }
00508 
00509   // If the RHS is + imm5 * scale, fold into addr mode.
00510   if (ConstantSDNode *RHS = dyn_cast<ConstantSDNode>(N.getOperand(1))) {
00511     int RHSC = (int)RHS->getZExtValue();
00512     if ((RHSC & (Scale-1)) == 0) {  // The constant is implicitly multiplied.
00513       RHSC /= Scale;
00514       if (RHSC >= 0 && RHSC < 32) {
00515         Base = N.getOperand(0);
00516         Offset = CurDAG->getRegister(0, MVT::i32);
00517         OffImm = CurDAG->getTargetConstant(RHSC, MVT::i32);
00518         return true;
00519       }
00520     }
00521   }
00522 
00523   Base = N.getOperand(0);
00524   Offset = N.getOperand(1);
00525   OffImm = CurDAG->getTargetConstant(0, MVT::i32);
00526   return true;
00527 }
00528 
00529 bool ARMDAGToDAGISel::SelectThumbAddrModeS1(SDValue Op, SDValue N,
00530                                             SDValue &Base, SDValue &OffImm,
00531                                             SDValue &Offset) {
00532   return SelectThumbAddrModeRI5(Op, N, 1, Base, OffImm, Offset);
00533 }
00534 
00535 bool ARMDAGToDAGISel::SelectThumbAddrModeS2(SDValue Op, SDValue N,
00536                                             SDValue &Base, SDValue &OffImm,
00537                                             SDValue &Offset) {
00538   return SelectThumbAddrModeRI5(Op, N, 2, Base, OffImm, Offset);
00539 }
00540 
00541 bool ARMDAGToDAGISel::SelectThumbAddrModeS4(SDValue Op, SDValue N,
00542                                             SDValue &Base, SDValue &OffImm,
00543                                             SDValue &Offset) {
00544   return SelectThumbAddrModeRI5(Op, N, 4, Base, OffImm, Offset);
00545 }
00546 
00547 bool ARMDAGToDAGISel::SelectThumbAddrModeSP(SDValue Op, SDValue N,
00548                                            SDValue &Base, SDValue &OffImm) {
00549   if (N.getOpcode() == ISD::FrameIndex) {
00550     int FI = cast<FrameIndexSDNode>(N)->getIndex();
00551     Base = CurDAG->getTargetFrameIndex(FI, TLI.getPointerTy());
00552     OffImm = CurDAG->getTargetConstant(0, MVT::i32);
00553     return true;
00554   }
00555 
00556   if (N.getOpcode() != ISD::ADD)
00557     return false;
00558 
00559   RegisterSDNode *LHSR = dyn_cast<RegisterSDNode>(N.getOperand(0));
00560   if (N.getOperand(0).getOpcode() == ISD::FrameIndex ||
00561       (LHSR && LHSR->getReg() == ARM::SP)) {
00562     // If the RHS is + imm8 * scale, fold into addr mode.
00563     if (ConstantSDNode *RHS = dyn_cast<ConstantSDNode>(N.getOperand(1))) {
00564       int RHSC = (int)RHS->getZExtValue();
00565       if ((RHSC & 3) == 0) {  // The constant is implicitly multiplied.
00566         RHSC >>= 2;
00567         if (RHSC >= 0 && RHSC < 256) {
00568           Base = N.getOperand(0);
00569           if (Base.getOpcode() == ISD::FrameIndex) {
00570             int FI = cast<FrameIndexSDNode>(Base)->getIndex();
00571             Base = CurDAG->getTargetFrameIndex(FI, TLI.getPointerTy());
00572           }
00573           OffImm = CurDAG->getTargetConstant(RHSC, MVT::i32);
00574           return true;
00575         }
00576       }
00577     }
00578   }
00579 
00580   return false;
00581 }
00582 
00583 bool ARMDAGToDAGISel::SelectT2ShifterOperandReg(SDValue Op, SDValue N,
00584                                                 SDValue &BaseReg,
00585                                                 SDValue &Opc) {
00586   ARM_AM::ShiftOpc ShOpcVal = ARM_AM::getShiftOpcForNode(N);
00587 
00588   // Don't match base register only case. That is matched to a separate
00589   // lower complexity pattern with explicit register operand.
00590   if (ShOpcVal == ARM_AM::no_shift) return false;
00591 
00592   BaseReg = N.getOperand(0);
00593   unsigned ShImmVal = 0;
00594   if (ConstantSDNode *RHS = dyn_cast<ConstantSDNode>(N.getOperand(1))) {
00595     ShImmVal = RHS->getZExtValue() & 31;
00596     Opc = getI32Imm(ARM_AM::getSORegOpc(ShOpcVal, ShImmVal));
00597     return true;
00598   }
00599 
00600   return false;
00601 }
00602 
00603 bool ARMDAGToDAGISel::SelectT2AddrModeImm12(SDValue Op, SDValue N,
00604                                             SDValue &Base, SDValue &OffImm) {
00605   // Match simple R + imm12 operands.
00606 
00607   // Base only.
00608   if (N.getOpcode() != ISD::ADD && N.getOpcode() != ISD::SUB) {
00609     if (N.getOpcode() == ISD::FrameIndex) {
00610       // Match frame index...
00611       int FI = cast<FrameIndexSDNode>(N)->getIndex();
00612       Base = CurDAG->getTargetFrameIndex(FI, TLI.getPointerTy());
00613       OffImm  = CurDAG->getTargetConstant(0, MVT::i32);
00614       return true;
00615     } else if (N.getOpcode() == ARMISD::Wrapper) {
00616       Base = N.getOperand(0);
00617       if (Base.getOpcode() == ISD::TargetConstantPool)
00618         return false;  // We want to select t2LDRpci instead.
00619     } else
00620       Base = N;
00621     OffImm  = CurDAG->getTargetConstant(0, MVT::i32);
00622     return true;
00623   }
00624 
00625   if (ConstantSDNode *RHS = dyn_cast<ConstantSDNode>(N.getOperand(1))) {
00626     if (SelectT2AddrModeImm8(Op, N, Base, OffImm))
00627       // Let t2LDRi8 handle (R - imm8).
00628       return false;
00629 
00630     int RHSC = (int)RHS->getZExtValue();
00631     if (N.getOpcode() == ISD::SUB)
00632       RHSC = -RHSC;
00633 
00634     if (RHSC >= 0 && RHSC < 0x1000) { // 12 bits (unsigned)
00635       Base   = N.getOperand(0);
00636       if (Base.getOpcode() == ISD::FrameIndex) {
00637         int FI = cast<FrameIndexSDNode>(Base)->getIndex();
00638         Base = CurDAG->getTargetFrameIndex(FI, TLI.getPointerTy());
00639       }
00640       OffImm = CurDAG->getTargetConstant(RHSC, MVT::i32);
00641       return true;
00642     }
00643   }
00644 
00645   // Base only.
00646   Base = N;
00647   OffImm  = CurDAG->getTargetConstant(0, MVT::i32);
00648   return true;
00649 }
00650 
00651 bool ARMDAGToDAGISel::SelectT2AddrModeImm8(SDValue Op, SDValue N,
00652                                            SDValue &Base, SDValue &OffImm) {
00653   // Match simple R - imm8 operands.
00654   if (N.getOpcode() == ISD::ADD || N.getOpcode() == ISD::SUB) {
00655     if (ConstantSDNode *RHS = dyn_cast<ConstantSDNode>(N.getOperand(1))) {
00656       int RHSC = (int)RHS->getSExtValue();
00657       if (N.getOpcode() == ISD::SUB)
00658         RHSC = -RHSC;
00659 
00660       if ((RHSC >= -255) && (RHSC < 0)) { // 8 bits (always negative)
00661         Base = N.getOperand(0);
00662         if (Base.getOpcode() == ISD::FrameIndex) {
00663           int FI = cast<FrameIndexSDNode>(Base)->getIndex();
00664           Base = CurDAG->getTargetFrameIndex(FI, TLI.getPointerTy());
00665         }
00666         OffImm = CurDAG->getTargetConstant(RHSC, MVT::i32);
00667         return true;
00668       }
00669     }
00670   }
00671 
00672   return false;
00673 }
00674 
00675 bool ARMDAGToDAGISel::SelectT2AddrModeImm8Offset(SDValue Op, SDValue N,
00676                                                  SDValue &OffImm){
00677   unsigned Opcode = Op.getOpcode();
00678   ISD::MemIndexedMode AM = (Opcode == ISD::LOAD)
00679     ? cast<LoadSDNode>(Op)->getAddressingMode()
00680     : cast<StoreSDNode>(Op)->getAddressingMode();
00681   if (ConstantSDNode *RHS = dyn_cast<ConstantSDNode>(N)) {
00682     int RHSC = (int)RHS->getZExtValue();
00683     if (RHSC >= 0 && RHSC < 0x100) { // 8 bits.
00684       OffImm = ((AM == ISD::PRE_INC) || (AM == ISD::POST_INC))
00685         ? CurDAG->getTargetConstant(RHSC, MVT::i32)
00686         : CurDAG->getTargetConstant(-RHSC, MVT::i32);
00687       return true;
00688     }
00689   }
00690 
00691   return false;
00692 }
00693 
00694 bool ARMDAGToDAGISel::SelectT2AddrModeImm8s4(SDValue Op, SDValue N,
00695                                              SDValue &Base, SDValue &OffImm) {
00696   if (N.getOpcode() == ISD::ADD) {
00697     if (ConstantSDNode *RHS = dyn_cast<ConstantSDNode>(N.getOperand(1))) {
00698       int RHSC = (int)RHS->getZExtValue();
00699       if (((RHSC & 0x3) == 0) &&
00700           ((RHSC >= 0 && RHSC < 0x400) || (RHSC < 0 && RHSC > -0x400))) { // 8 bits.
00701         Base   = N.getOperand(0);
00702         OffImm = CurDAG->getTargetConstant(RHSC, MVT::i32);
00703         return true;
00704       }
00705     }
00706   } else if (N.getOpcode() == ISD::SUB) {
00707     if (ConstantSDNode *RHS = dyn_cast<ConstantSDNode>(N.getOperand(1))) {
00708       int RHSC = (int)RHS->getZExtValue();
00709       if (((RHSC & 0x3) == 0) && (RHSC >= 0 && RHSC < 0x400)) { // 8 bits.
00710         Base   = N.getOperand(0);
00711         OffImm = CurDAG->getTargetConstant(-RHSC, MVT::i32);
00712         return true;
00713       }
00714     }
00715   }
00716 
00717   return false;
00718 }
00719 
00720 bool ARMDAGToDAGISel::SelectT2AddrModeSoReg(SDValue Op, SDValue N,
00721                                             SDValue &Base,
00722                                             SDValue &OffReg, SDValue &ShImm) {
00723   // (R - imm8) should be handled by t2LDRi8. The rest are handled by t2LDRi12.
00724   if (N.getOpcode() != ISD::ADD)
00725     return false;
00726 
00727   // Leave (R + imm12) for t2LDRi12, (R - imm8) for t2LDRi8.
00728   if (ConstantSDNode *RHS = dyn_cast<ConstantSDNode>(N.getOperand(1))) {
00729     int RHSC = (int)RHS->getZExtValue();
00730     if (RHSC >= 0 && RHSC < 0x1000) // 12 bits (unsigned)
00731       return false;
00732     else if (RHSC < 0 && RHSC >= -255) // 8 bits
00733       return false;
00734   }
00735 
00736   // Look for (R + R) or (R + (R << [1,2,3])).
00737   unsigned ShAmt = 0;
00738   Base   = N.getOperand(0);
00739   OffReg = N.getOperand(1);
00740 
00741   // Swap if it is ((R << c) + R).
00742   ARM_AM::ShiftOpc ShOpcVal = ARM_AM::getShiftOpcForNode(OffReg);
00743   if (ShOpcVal != ARM_AM::lsl) {
00744     ShOpcVal = ARM_AM::getShiftOpcForNode(Base);
00745     if (ShOpcVal == ARM_AM::lsl)
00746       std::swap(Base, OffReg);
00747   }
00748 
00749   if (ShOpcVal == ARM_AM::lsl) {
00750     // Check to see if the RHS of the shift is a constant, if not, we can't fold
00751     // it.
00752     if (ConstantSDNode *Sh = dyn_cast<ConstantSDNode>(OffReg.getOperand(1))) {
00753       ShAmt = Sh->getZExtValue();
00754       if (ShAmt >= 4) {
00755         ShAmt = 0;
00756         ShOpcVal = ARM_AM::no_shift;
00757       } else
00758         OffReg = OffReg.getOperand(0);
00759     } else {
00760       ShOpcVal = ARM_AM::no_shift;
00761     }
00762   }
00763 
00764   ShImm = CurDAG->getTargetConstant(ShAmt, MVT::i32);
00765 
00766   return true;
00767 }
00768 
00769 //===--------------------------------------------------------------------===//
00770 
00771 /// getAL - Returns a ARMCC::AL immediate node.
00772 static inline SDValue getAL(SelectionDAG *CurDAG) {
00773   return CurDAG->getTargetConstant((uint64_t)ARMCC::AL, MVT::i32);
00774 }
00775 
00776 SDNode *ARMDAGToDAGISel::SelectARMIndexedLoad(SDValue Op) {
00777   LoadSDNode *LD = cast<LoadSDNode>(Op);
00778   ISD::MemIndexedMode AM = LD->getAddressingMode();
00779   if (AM == ISD::UNINDEXED)
00780     return NULL;
00781 
00782   EVT LoadedVT = LD->getMemoryVT();
00783   SDValue Offset, AMOpc;
00784   bool isPre = (AM == ISD::PRE_INC) || (AM == ISD::PRE_DEC);
00785   unsigned Opcode = 0;
00786   bool Match = false;
00787   if (LoadedVT == MVT::i32 &&
00788       SelectAddrMode2Offset(Op, LD->getOffset(), Offset, AMOpc)) {
00789     Opcode = isPre ? ARM::LDR_PRE : ARM::LDR_POST;
00790     Match = true;
00791   } else if (LoadedVT == MVT::i16 &&
00792              SelectAddrMode3Offset(Op, LD->getOffset(), Offset, AMOpc)) {
00793     Match = true;
00794     Opcode = (LD->getExtensionType() == ISD::SEXTLOAD)
00795       ? (isPre ? ARM::LDRSH_PRE : ARM::LDRSH_POST)
00796       : (isPre ? ARM::LDRH_PRE : ARM::LDRH_POST);
00797   } else if (LoadedVT == MVT::i8 || LoadedVT == MVT::i1) {
00798     if (LD->getExtensionType() == ISD::SEXTLOAD) {
00799       if (SelectAddrMode3Offset(Op, LD->getOffset(), Offset, AMOpc)) {
00800         Match = true;
00801         Opcode = isPre ? ARM::LDRSB_PRE : ARM::LDRSB_POST;
00802       }
00803     } else {
00804       if (SelectAddrMode2Offset(Op, LD->getOffset(), Offset, AMOpc)) {
00805         Match = true;
00806         Opcode = isPre ? ARM::LDRB_PRE : ARM::LDRB_POST;
00807       }
00808     }
00809   }
00810 
00811   if (Match) {
00812     SDValue Chain = LD->getChain();
00813     SDValue Base = LD->getBasePtr();
00814     SDValue Ops[]= { Base, Offset, AMOpc, getAL(CurDAG),
00815                      CurDAG->getRegister(0, MVT::i32), Chain };
00816     return CurDAG->getTargetNode(Opcode, Op.getDebugLoc(), MVT::i32, MVT::i32,
00817                                  MVT::Other, Ops, 6);
00818   }
00819 
00820   return NULL;
00821 }
00822 
00823 SDNode *ARMDAGToDAGISel::SelectT2IndexedLoad(SDValue Op) {
00824   LoadSDNode *LD = cast<LoadSDNode>(Op);
00825   ISD::MemIndexedMode AM = LD->getAddressingMode();
00826   if (AM == ISD::UNINDEXED)
00827     return NULL;
00828 
00829   EVT LoadedVT = LD->getMemoryVT();
00830   bool isSExtLd = LD->getExtensionType() == ISD::SEXTLOAD;
00831   SDValue Offset;
00832   bool isPre = (AM == ISD::PRE_INC) || (AM == ISD::PRE_DEC);
00833   unsigned Opcode = 0;
00834   bool Match = false;
00835   if (SelectT2AddrModeImm8Offset(Op, LD->getOffset(), Offset)) {
00836     switch (LoadedVT.getSimpleVT().SimpleTy) {
00837     case MVT::i32:
00838       Opcode = isPre ? ARM::t2LDR_PRE : ARM::t2LDR_POST;
00839       break;
00840     case MVT::i16:
00841       if (isSExtLd)
00842         Opcode = isPre ? ARM::t2LDRSH_PRE : ARM::t2LDRSH_POST;
00843       else
00844         Opcode = isPre ? ARM::t2LDRH_PRE : ARM::t2LDRH_POST;
00845       break;
00846     case MVT::i8:
00847     case MVT::i1:
00848       if (isSExtLd)
00849         Opcode = isPre ? ARM::t2LDRSB_PRE : ARM::t2LDRSB_POST;
00850       else
00851         Opcode = isPre ? ARM::t2LDRB_PRE : ARM::t2LDRB_POST;
00852       break;
00853     default:
00854       return NULL;
00855     }
00856     Match = true;
00857   }
00858 
00859   if (Match) {
00860     SDValue Chain = LD->getChain();
00861     SDValue Base = LD->getBasePtr();
00862     SDValue Ops[]= { Base, Offset, getAL(CurDAG),
00863                      CurDAG->getRegister(0, MVT::i32), Chain };
00864     return CurDAG->getTargetNode(Opcode, Op.getDebugLoc(), MVT::i32, MVT::i32,
00865                                  MVT::Other, Ops, 5);
00866   }
00867 
00868   return NULL;
00869 }
00870 
00871 SDNode *ARMDAGToDAGISel::SelectDYN_ALLOC(SDValue Op) {
00872   SDNode *N = Op.getNode();
00873   DebugLoc dl = N->getDebugLoc();
00874   EVT VT = Op.getValueType();
00875   SDValue Chain = Op.getOperand(0);
00876   SDValue Size = Op.getOperand(1);
00877   SDValue Align = Op.getOperand(2);
00878   SDValue SP = CurDAG->getRegister(ARM::SP, MVT::i32);
00879   int32_t AlignVal = cast<ConstantSDNode>(Align)->getSExtValue();
00880   if (AlignVal < 0)
00881     // We need to align the stack. Use Thumb1 tAND which is the only thumb
00882     // instruction that can read and write SP. This matches to a pseudo
00883     // instruction that has a chain to ensure the result is written back to
00884     // the stack pointer.
00885     SP = SDValue(CurDAG->getTargetNode(ARM::tANDsp, dl, VT, SP, Align), 0);
00886 
00887   bool isC = isa<ConstantSDNode>(Size);
00888   uint32_t C = isC ? cast<ConstantSDNode>(Size)->getZExtValue() : ~0UL;
00889   // Handle the most common case for both Thumb1 and Thumb2:
00890   // tSUBspi - immediate is between 0 ... 508 inclusive.
00891   if (C <= 508 && ((C & 3) == 0))
00892     // FIXME: tSUBspi encode scale 4 implicitly.
00893     return CurDAG->SelectNodeTo(N, ARM::tSUBspi_, VT, MVT::Other, SP,
00894                                 CurDAG->getTargetConstant(C/4, MVT::i32),
00895                                 Chain);
00896 
00897   if (Subtarget->isThumb1Only()) {
00898     // Use tADDspr since Thumb1 does not have a sub r, sp, r. ARMISelLowering
00899     // should have negated the size operand already. FIXME: We can't insert
00900     // new target independent node at this stage so we are forced to negate
00901     // it earlier. Is there a better solution?
00902     return CurDAG->SelectNodeTo(N, ARM::tADDspr_, VT, MVT::Other, SP, Size,
00903                                 Chain);
00904   } else if (Subtarget->isThumb2()) {
00905     if (isC && Predicate_t2_so_imm(Size.getNode())) {
00906       // t2SUBrSPi
00907       SDValue Ops[] = { SP, CurDAG->getTargetConstant(C, MVT::i32), Chain };
00908       return CurDAG->SelectNodeTo(N, ARM::t2SUBrSPi_, VT, MVT::Other, Ops, 3);
00909     } else if (isC && Predicate_imm0_4095(Size.getNode())) {
00910       // t2SUBrSPi12
00911       SDValue Ops[] = { SP, CurDAG->getTargetConstant(C, MVT::i32), Chain };
00912       return CurDAG->SelectNodeTo(N, ARM::t2SUBrSPi12_, VT, MVT::Other, Ops, 3);
00913     } else {
00914       // t2SUBrSPs
00915       SDValue Ops[] = { SP, Size,
00916                         getI32Imm(ARM_AM::getSORegOpc(ARM_AM::lsl,0)), Chain };
00917       return CurDAG->SelectNodeTo(N, ARM::t2SUBrSPs_, VT, MVT::Other, Ops, 4);
00918     }
00919   }
00920 
00921   // FIXME: Add ADD / SUB sp instructions for ARM.
00922   return 0;
00923 }
00924 
00925 SDNode *ARMDAGToDAGISel::Select(SDValue Op) {
00926   SDNode *N = Op.getNode();
00927   DebugLoc dl = N->getDebugLoc();
00928 
00929   if (N->isMachineOpcode())
00930     return NULL;   // Already selected.
00931 
00932   switch (N->getOpcode()) {
00933   default: break;
00934   case ISD::Constant: {
00935     unsigned Val = cast<ConstantSDNode>(N)->getZExtValue();
00936     bool UseCP = true;
00937     if (Subtarget->isThumb()) {
00938       if (Subtarget->hasThumb2())
00939         // Thumb2 has the MOVT instruction, so all immediates can
00940         // be done with MOV + MOVT, at worst.
00941         UseCP = 0;
00942       else
00943         UseCP = (Val > 255 &&                          // MOV
00944                  ~Val > 255 &&                         // MOV + MVN
00945                  !ARM_AM::isThumbImmShiftedVal(Val));  // MOV + LSL
00946     } else
00947       UseCP = (ARM_AM::getSOImmVal(Val) == -1 &&     // MOV
00948                ARM_AM::getSOImmVal(~Val) == -1 &&    // MVN
00949                !ARM_AM::isSOImmTwoPartVal(Val));     // two instrs.
00950     if (UseCP) {
00951       SDValue CPIdx =
00952         CurDAG->getTargetConstantPool(ConstantInt::get(
00953                                   Type::getInt32Ty(*CurDAG->getContext()), Val),
00954                                       TLI.getPointerTy());
00955 
00956       SDNode *ResNode;
00957       if (Subtarget->isThumb1Only()) {
00958         SDValue Pred = CurDAG->getTargetConstant(0xEULL, MVT::i32);
00959         SDValue PredReg = CurDAG->getRegister(0, MVT::i32);
00960         SDValue Ops[] = { CPIdx, Pred, PredReg, CurDAG->getEntryNode() };
00961         ResNode = CurDAG->getTargetNode(ARM::tLDRcp, dl, MVT::i32, MVT::Other,
00962                                         Ops, 4);
00963       } else {
00964         SDValue Ops[] = {
00965           CPIdx,
00966           CurDAG->getRegister(0, MVT::i32),
00967           CurDAG->getTargetConstant(0, MVT::i32),
00968           getAL(CurDAG),
00969           CurDAG->getRegister(0, MVT::i32),
00970           CurDAG->getEntryNode()
00971         };
00972         ResNode=CurDAG->getTargetNode(ARM::LDRcp, dl, MVT::i32, MVT::Other,
00973                                       Ops, 6);
00974       }
00975       ReplaceUses(Op, SDValue(ResNode, 0));
00976       return NULL;
00977     }
00978 
00979     // Other cases are autogenerated.
00980     break;
00981   }
00982   case ISD::FrameIndex: {
00983     // Selects to ADDri FI, 0 which in turn will become ADDri SP, imm.
00984     int FI = cast<FrameIndexSDNode>(N)->getIndex();
00985     SDValue TFI = CurDAG->getTargetFrameIndex(FI, TLI.getPointerTy());
00986     if (Subtarget->isThumb1Only()) {
00987       return CurDAG->SelectNodeTo(N, ARM::tADDrSPi, MVT::i32, TFI,
00988                                   CurDAG->getTargetConstant(0, MVT::i32));
00989     } else {
00990       unsigned Opc = ((Subtarget->isThumb() && Subtarget->hasThumb2()) ?
00991                       ARM::t2ADDri : ARM::ADDri);
00992       SDValue Ops[] = { TFI, CurDAG->getTargetConstant(0, MVT::i32),
00993                         getAL(CurDAG), CurDAG->getRegister(0, MVT::i32),
00994                         CurDAG->getRegister(0, MVT::i32) };
00995       return CurDAG->SelectNodeTo(N, Opc, MVT::i32, Ops, 5);
00996     }
00997   }
00998   case ARMISD::DYN_ALLOC:
00999     return SelectDYN_ALLOC(Op);
01000   case ISD::MUL:
01001     if (Subtarget->isThumb1Only())
01002       break;
01003     if (ConstantSDNode *C = dyn_cast<ConstantSDNode>(Op.getOperand(1))) {
01004       unsigned RHSV = C->getZExtValue();
01005       if (!RHSV) break;
01006       if (isPowerOf2_32(RHSV-1)) {  // 2^n+1?
01007         unsigned ShImm = Log2_32(RHSV-1);
01008         if (ShImm >= 32)
01009           break;
01010         SDValue V = Op.getOperand(0);
01011         ShImm = ARM_AM::getSORegOpc(ARM_AM::lsl, ShImm);
01012         SDValue ShImmOp = CurDAG->getTargetConstant(ShImm, MVT::i32);
01013         SDValue Reg0 = CurDAG->getRegister(0, MVT::i32);
01014         if (Subtarget->isThumb()) {
01015           SDValue Ops[] = { V, V, ShImmOp, getAL(CurDAG), Reg0, Reg0 };
01016           return CurDAG->SelectNodeTo(N, ARM::t2ADDrs, MVT::i32, Ops, 6);
01017         } else {
01018           SDValue Ops[] = { V, V, Reg0, ShImmOp, getAL(CurDAG), Reg0, Reg0 };
01019           return CurDAG->SelectNodeTo(N, ARM::ADDrs, MVT::i32, Ops, 7);
01020         }
01021       }
01022       if (isPowerOf2_32(RHSV+1)) {  // 2^n-1?
01023         unsigned ShImm = Log2_32(RHSV+1);
01024         if (ShImm >= 32)
01025           break;
01026         SDValue V = Op.getOperand(0);
01027         ShImm = ARM_AM::getSORegOpc(ARM_AM::lsl, ShImm);
01028         SDValue ShImmOp = CurDAG->getTargetConstant(ShImm, MVT::i32);
01029         SDValue Reg0 = CurDAG->getRegister(0, MVT::i32);
01030         if (Subtarget->isThumb()) {
01031           SDValue Ops[] = { V, V, ShImmOp, getAL(CurDAG), Reg0 };
01032           return CurDAG->SelectNodeTo(N, ARM::t2RSBrs, MVT::i32, Ops, 5);
01033         } else {
01034           SDValue Ops[] = { V, V, Reg0, ShImmOp, getAL(CurDAG), Reg0, Reg0 };
01035           return CurDAG->SelectNodeTo(N, ARM::RSBrs, MVT::i32, Ops, 7);
01036         }
01037       }
01038     }
01039     break;
01040   case ARMISD::FMRRD:
01041     return CurDAG->getTargetNode(ARM::FMRRD, dl, MVT::i32, MVT::i32,
01042                                  Op.getOperand(0), getAL(CurDAG),
01043                                  CurDAG->getRegister(0, MVT::i32));
01044   case ISD::UMUL_LOHI: {
01045     if (Subtarget->isThumb1Only())
01046       break;
01047     if (Subtarget->isThumb()) {
01048       SDValue Ops[] = { Op.getOperand(0), Op.getOperand(1),
01049                         getAL(CurDAG), CurDAG->getRegister(0, MVT::i32),
01050                         CurDAG->getRegister(0, MVT::i32) };
01051       return CurDAG->getTargetNode(ARM::t2UMULL, dl, MVT::i32, MVT::i32, Ops,4);
01052     } else {
01053       SDValue Ops[] = { Op.getOperand(0), Op.getOperand(1),
01054                         getAL(CurDAG), CurDAG->getRegister(0, MVT::i32),
01055                         CurDAG->getRegister(0, MVT::i32) };
01056       return CurDAG->getTargetNode(ARM::UMULL, dl, MVT::i32, MVT::i32, Ops, 5);
01057     }
01058   }
01059   case ISD::SMUL_LOHI: {
01060     if (Subtarget->isThumb1Only())
01061       break;
01062     if (Subtarget->isThumb()) {
01063       SDValue Ops[] = { Op.getOperand(0), Op.getOperand(1),
01064                         getAL(CurDAG), CurDAG->getRegister(0, MVT::i32) };
01065       return CurDAG->getTargetNode(ARM::t2SMULL, dl, MVT::i32, MVT::i32, Ops,4);
01066     } else {
01067       SDValue Ops[] = { Op.getOperand(0), Op.getOperand(1),
01068                         getAL(CurDAG), CurDAG->getRegister(0, MVT::i32),
01069                         CurDAG->getRegister(0, MVT::i32) };
01070       return CurDAG->getTargetNode(ARM::SMULL, dl, MVT::i32, MVT::i32, Ops, 5);
01071     }
01072   }
01073   case ISD::LOAD: {
01074     SDNode *ResNode = 0;
01075     if (Subtarget->isThumb() && Subtarget->hasThumb2())
01076       ResNode = SelectT2IndexedLoad(Op);
01077     else
01078       ResNode = SelectARMIndexedLoad(Op);
01079     if (ResNode)
01080       return ResNode;
01081     // Other cases are autogenerated.
01082     break;
01083   }
01084   case ARMISD::BRCOND: {
01085     // Pattern: (ARMbrcond:void (bb:Other):$dst, (imm:i32):$cc)
01086     // Emits: (Bcc:void (bb:Other):$dst, (imm:i32):$cc)
01087     // Pattern complexity = 6  cost = 1  size = 0
01088 
01089     // Pattern: (ARMbrcond:void (bb:Other):$dst, (imm:i32):$cc)
01090     // Emits: (tBcc:void (bb:Other):$dst, (imm:i32):$cc)
01091     // Pattern complexity = 6  cost = 1  size = 0
01092 
01093     // Pattern: (ARMbrcond:void (bb:Other):$dst, (imm:i32):$cc)
01094     // Emits: (t2Bcc:void (bb:Other):$dst, (imm:i32):$cc)
01095     // Pattern complexity = 6  cost = 1  size = 0
01096 
01097     unsigned Opc = Subtarget->isThumb() ?
01098       ((Subtarget->hasThumb2()) ? ARM::t2Bcc : ARM::tBcc) : ARM::Bcc;
01099     SDValue Chain = Op.getOperand(0);
01100     SDValue N1 = Op.getOperand(1);
01101     SDValue N2 = Op.getOperand(2);
01102     SDValue N3 = Op.getOperand(3);
01103     SDValue InFlag = Op.getOperand(4);
01104     assert(N1.getOpcode() == ISD::BasicBlock);
01105     assert(N2.getOpcode() == ISD::Constant);
01106     assert(N3.getOpcode() == ISD::Register);
01107 
01108     SDValue Tmp2 = CurDAG->getTargetConstant(((unsigned)
01109                                cast<ConstantSDNode>(N2)->getZExtValue()),
01110                                MVT::i32);
01111     SDValue Ops[] = { N1, Tmp2, N3, Chain, InFlag };
01112     SDNode *ResNode = CurDAG->getTargetNode(Opc, dl, MVT::Other,
01113                                             MVT::Flag, Ops, 5);
01114     Chain = SDValue(ResNode, 0);
01115     if (Op.getNode()->getNumValues() == 2) {
01116       InFlag = SDValue(ResNode, 1);
01117       ReplaceUses(SDValue(Op.getNode(), 1), InFlag);
01118     }
01119     ReplaceUses(SDValue(Op.getNode(), 0), SDValue(Chain.getNode(), Chain.getResNo()));
01120     return NULL;
01121   }
01122   case ARMISD::CMOV: {
01123     EVT VT = Op.getValueType();
01124     SDValue N0 = Op.getOperand(0);
01125     SDValue N1 = Op.getOperand(1);
01126     SDValue N2 = Op.getOperand(2);
01127     SDValue N3 = Op.getOperand(3);
01128     SDValue InFlag = Op.getOperand(4);
01129     assert(N2.getOpcode() == ISD::Constant);
01130     assert(N3.getOpcode() == ISD::Register);
01131 
01132     if (!Subtarget->isThumb1Only() && VT == MVT::i32) {
01133       // Pattern: (ARMcmov:i32 GPR:i32:$false, so_reg:i32:$true, (imm:i32):$cc)
01134       // Emits: (MOVCCs:i32 GPR:i32:$false, so_reg:i32:$true, (imm:i32):$cc)
01135       // Pattern complexity = 18  cost = 1  size = 0
01136       SDValue CPTmp0;
01137       SDValue CPTmp1;
01138       SDValue CPTmp2;
01139       if (Subtarget->isThumb()) {
01140         if (SelectT2ShifterOperandReg(Op, N1, CPTmp0, CPTmp1)) {
01141           unsigned SOVal = cast<ConstantSDNode>(CPTmp1)->getZExtValue();
01142           unsigned SOShOp = ARM_AM::getSORegShOp(SOVal);
01143           unsigned Opc = 0;
01144           switch (SOShOp) {
01145           case ARM_AM::lsl: Opc = ARM::t2MOVCClsl; break;
01146           case ARM_AM::lsr: Opc = ARM::t2MOVCClsr; break;
01147           case ARM_AM::asr: Opc = ARM::t2MOVCCasr; break;
01148           case ARM_AM::ror: Opc = ARM::t2MOVCCror; break;
01149           default:
01150             llvm_unreachable("Unknown so_reg opcode!");
01151             break;
01152           }
01153           SDValue SOShImm =
01154             CurDAG->getTargetConstant(ARM_AM::getSORegOffset(SOVal), MVT::i32);
01155           SDValue Tmp2 = CurDAG->getTargetConstant(((unsigned)
01156                                    cast<ConstantSDNode>(N2)->getZExtValue()),
01157                                    MVT::i32);
01158           SDValue Ops[] = { N0, CPTmp0, SOShImm, Tmp2, N3, InFlag };
01159           return CurDAG->SelectNodeTo(Op.getNode(), Opc, MVT::i32,Ops, 6);
01160         }
01161       } else {
01162         if (SelectShifterOperandReg(Op, N1, CPTmp0, CPTmp1, CPTmp2)) {
01163           SDValue Tmp2 = CurDAG->getTargetConstant(((unsigned)
01164                                    cast<ConstantSDNode>(N2)->getZExtValue()),
01165                                    MVT::i32);
01166           SDValue Ops[] = { N0, CPTmp0, CPTmp1, CPTmp2, Tmp2, N3, InFlag };
01167           return CurDAG->SelectNodeTo(Op.getNode(),
01168                                       ARM::MOVCCs, MVT::i32, Ops, 7);
01169         }
01170       }
01171 
01172       // Pattern: (ARMcmov:i32 GPR:i32:$false,
01173       //             (imm:i32)<<P:Predicate_so_imm>>:$true,
01174       //             (imm:i32):$cc)
01175       // Emits: (MOVCCi:i32 GPR:i32:$false,
01176       //           (so_imm:i32 (imm:i32):$true), (imm:i32):$cc)
01177       // Pattern complexity = 10  cost = 1  size = 0
01178       if (N3.getOpcode() == ISD::Constant) {
01179         if (Subtarget->isThumb()) {
01180           if (Predicate_t2_so_imm(N3.getNode())) {
01181             SDValue Tmp1 = CurDAG->getTargetConstant(((unsigned)
01182                                      cast<ConstantSDNode>(N1)->getZExtValue()),
01183                                      MVT::i32);
01184             SDValue Tmp2 = CurDAG->getTargetConstant(((unsigned)
01185                                      cast<ConstantSDNode>(N2)->getZExtValue()),
01186                                      MVT::i32);
01187             SDValue Ops[] = { N0, Tmp1, Tmp2, N3, InFlag };
01188             return CurDAG->SelectNodeTo(Op.getNode(),
01189                                         ARM::t2MOVCCi, MVT::i32, Ops, 5);
01190           }
01191         } else {
01192           if (Predicate_so_imm(N3.getNode())) {
01193             SDValue Tmp1 = CurDAG->getTargetConstant(((unsigned)
01194                                      cast<ConstantSDNode>(N1)->getZExtValue()),
01195                                      MVT::i32);
01196             SDValue Tmp2 = CurDAG->getTargetConstant(((unsigned)
01197                                      cast<ConstantSDNode>(N2)->getZExtValue()),
01198                                      MVT::i32);
01199             SDValue Ops[] = { N0, Tmp1, Tmp2, N3, InFlag };
01200             return CurDAG->SelectNodeTo(Op.getNode(),
01201                                         ARM::MOVCCi, MVT::i32, Ops, 5);
01202           }
01203         }
01204       }
01205     }
01206 
01207     // Pattern: (ARMcmov:i32 GPR:i32:$false, GPR:i32:$true, (imm:i32):$cc)
01208     // Emits: (MOVCCr:i32 GPR:i32:$false, GPR:i32:$true, (imm:i32):$cc)
01209     // Pattern complexity = 6  cost = 1  size = 0
01210     //
01211     // Pattern: (ARMcmov:i32 GPR:i32:$false, GPR:i32:$true, (imm:i32):$cc)
01212     // Emits: (tMOVCCr:i32 GPR:i32:$false, GPR:i32:$true, (imm:i32):$cc)
01213     // Pattern complexity = 6  cost = 11  size = 0
01214     //
01215     // Also FCPYScc and FCPYDcc.
01216     SDValue Tmp2 = CurDAG->getTargetConstant(((unsigned)
01217                                cast<ConstantSDNode>(N2)->getZExtValue()),
01218                                MVT::i32);
01219     SDValue Ops[] = { N0, N1, Tmp2, N3, InFlag };
01220     unsigned Opc = 0;
01221     switch (VT.getSimpleVT().SimpleTy) {
01222     default: assert(false && "Illegal conditional move type!");
01223       break;
01224     case MVT::i32:
01225       Opc = Subtarget->isThumb()
01226         ? (Subtarget->hasThumb2() ? ARM::t2MOVCCr : ARM::tMOVCCr_pseudo)
01227         : ARM::MOVCCr;
01228       break;
01229     case MVT::f32:
01230       Opc = ARM::FCPYScc;
01231       break;
01232     case MVT::f64:
01233       Opc = ARM::FCPYDcc;
01234       break;
01235     }
01236     return CurDAG->SelectNodeTo(Op.getNode(), Opc, VT, Ops, 5);
01237   }
01238   case ARMISD::CNEG: {
01239     EVT VT = Op.getValueType();
01240     SDValue N0 = Op.getOperand(0);
01241     SDValue N1 = Op.getOperand(1);
01242     SDValue N2 = Op.getOperand(2);
01243     SDValue N3 = Op.getOperand(3);
01244     SDValue InFlag = Op.getOperand(4);
01245     assert(N2.getOpcode() == ISD::Constant);
01246     assert(N3.getOpcode() == ISD::Register);
01247 
01248     SDValue Tmp2 = CurDAG->getTargetConstant(((unsigned)
01249                                cast<ConstantSDNode>(N2)->getZExtValue()),
01250                                MVT::i32);
01251     SDValue Ops[] = { N0, N1, Tmp2, N3, InFlag };
01252     unsigned Opc = 0;
01253     switch (VT.getSimpleVT().SimpleTy) {
01254     default: assert(false && "Illegal conditional move type!");
01255       break;
01256     case MVT::f32:
01257       Opc = ARM::FNEGScc;
01258       break;
01259     case MVT::f64:
01260       Opc = ARM::FNEGDcc;
01261       break;
01262     }
01263     return CurDAG->SelectNodeTo(Op.getNode(), Opc, VT, Ops, 5);
01264   }
01265 
01266   case ISD::DECLARE: {
01267     SDValue Chain = Op.getOperand(0);
01268     SDValue N1 = Op.getOperand(1);
01269     SDValue N2 = Op.getOperand(2);
01270     FrameIndexSDNode *FINode = dyn_cast<FrameIndexSDNode>(N1);
01271     // FIXME: handle VLAs.
01272     if (!FINode) {
01273       ReplaceUses(Op.getValue(0), Chain);
01274       return NULL;
01275     }
01276     if (N2.getOpcode() == ARMISD::PIC_ADD && isa<LoadSDNode>(N2.getOperand(0)))
01277       N2 = N2.getOperand(0);
01278     LoadSDNode *Ld = dyn_cast<LoadSDNode>(N2);
01279     if (!Ld) {
01280       ReplaceUses(Op.getValue(0), Chain);
01281       return NULL;
01282     }
01283     SDValue BasePtr = Ld->getBasePtr();
01284     assert(BasePtr.getOpcode() == ARMISD::Wrapper &&
01285            isa<ConstantPoolSDNode>(BasePtr.getOperand(0)) &&
01286            "llvm.dbg.variable should be a constantpool node");
01287     ConstantPoolSDNode *CP = cast<ConstantPoolSDNode>(BasePtr.getOperand(0));
01288     GlobalValue *GV = 0;
01289     if (CP->isMachineConstantPoolEntry()) {
01290       ARMConstantPoolValue *ACPV = (ARMConstantPoolValue*)CP->getMachineCPVal();
01291       GV = ACPV->getGV();
01292     } else
01293       GV = dyn_cast<GlobalValue>(CP->getConstVal());
01294     if (!GV) {
01295       ReplaceUses(Op.getValue(0), Chain);
01296       return NULL;
01297     }
01298 
01299     SDValue Tmp1 = CurDAG->getTargetFrameIndex(FINode->getIndex(),
01300                                                TLI.getPointerTy());
01301     SDValue Tmp2 = CurDAG->getTargetGlobalAddress(GV, TLI.getPointerTy());
01302     SDValue Ops[] = { Tmp1, Tmp2, Chain };
01303     return CurDAG->getTargetNode(TargetInstrInfo::DECLARE, dl,
01304                                  MVT::Other, Ops, 3);
01305   }
01306 
01307   case ARMISD::VLD2D: {
01308     SDValue MemAddr, MemUpdate, MemOpc;
01309     if (!SelectAddrMode6(Op, N->getOperand(1), MemAddr, MemUpdate, MemOpc))
01310         return NULL;
01311     unsigned Opc = 0;
01312     EVT VT = Op.getValueType();
01313     switch (VT.getSimpleVT().SimpleTy) {
01314     default: llvm_unreachable("unhandled VLD2D type");
01315     case MVT::v8i8:  Opc = ARM::VLD2d8; break;
01316     case MVT::v4i16: Opc = ARM::VLD2d16; break;
01317     case MVT::v2f32:
01318     case MVT::v2i32: Opc = ARM::VLD2d32; break;
01319     }
01320     SDValue Chain = N->getOperand(0);
01321     const SDValue Ops[] = { MemAddr, MemUpdate, MemOpc, Chain };
01322     return CurDAG->getTargetNode(Opc, dl, VT, VT, MVT::Other, Ops, 4);
01323   }
01324 
01325   case ARMISD::VLD3D: {
01326     SDValue MemAddr, MemUpdate, MemOpc;
01327     if (!SelectAddrMode6(Op, N->getOperand(1), MemAddr, MemUpdate, MemOpc))
01328         return NULL;
01329     unsigned Opc = 0;
01330     EVT VT = Op.getValueType();
01331     switch (VT.getSimpleVT().SimpleTy) {
01332     default: llvm_unreachable("unhandled VLD3D type");
01333     case MVT::v8i8:  Opc = ARM::VLD3d8; break;
01334     case MVT::v4i16: Opc = ARM::VLD3d16; break;
01335     case MVT::v2f32:
01336     case MVT::v2i32: Opc = ARM::VLD3d32; break;
01337     }
01338     SDValue Chain = N->getOperand(0);
01339     const SDValue Ops[] = { MemAddr, MemUpdate, MemOpc, Chain };
01340     return CurDAG->getTargetNode(Opc, dl, VT, VT, VT, MVT::Other, Ops, 4);
01341   }
01342 
01343   case ARMISD::VLD4D: {
01344     SDValue MemAddr, MemUpdate, MemOpc;
01345     if (!SelectAddrMode6(Op, N->getOperand(1), MemAddr, MemUpdate, MemOpc))
01346         return NULL;
01347     unsigned Opc = 0;
01348     EVT VT = Op.getValueType();
01349     switch (VT.getSimpleVT().SimpleTy) {
01350     default: llvm_unreachable("unhandled VLD4D type");
01351     case MVT::v8i8:  Opc = ARM::VLD4d8; break;
01352     case MVT::v4i16: Opc = ARM::VLD4d16; break;
01353     case MVT::v2f32:
01354     case MVT::v2i32: Opc = ARM::VLD4d32; break;
01355     }
01356     SDValue Chain = N->getOperand(0);
01357     const SDValue Ops[] = { MemAddr, MemUpdate, MemOpc, Chain };
01358     std::vector<EVT> ResTys(4, VT);
01359     ResTys.push_back(MVT::Other);
01360     return CurDAG->getTargetNode(Opc, dl, ResTys, Ops, 4);
01361   }
01362 
01363   case ARMISD::VST2D: {
01364     SDValue MemAddr, MemUpdate, MemOpc;
01365     if (!SelectAddrMode6(Op, N->getOperand(1), MemAddr, MemUpdate, MemOpc))
01366         return NULL;
01367     unsigned Opc = 0;
01368     switch (N->getOperand(2).getValueType().getSimpleVT().SimpleTy) {
01369     default: llvm_unreachable("unhandled VST2D type");
01370     case MVT::v8i8:  Opc = ARM::VST2d8; break;
01371     case MVT::v4i16: Opc = ARM::VST2d16; break;
01372     case MVT::v2f32:
01373     case MVT::v2i32: Opc = ARM::VST2d32; break;
01374     }
01375     SDValue Chain = N->getOperand(0);
01376     const SDValue Ops[] = { MemAddr, MemUpdate, MemOpc,
01377                             N->getOperand(2), N->getOperand(3), Chain };
01378     return CurDAG->getTargetNode(Opc, dl, MVT::Other, Ops, 6);
01379   }
01380 
01381   case ARMISD::VST3D: {
01382     SDValue MemAddr, MemUpdate, MemOpc;
01383     if (!SelectAddrMode6(Op, N->getOperand(1), MemAddr, MemUpdate, MemOpc))
01384         return NULL;
01385     unsigned Opc = 0;
01386     switch (N->getOperand(2).getValueType().getSimpleVT().SimpleTy) {
01387     default: llvm_unreachable("unhandled VST3D type");
01388     case MVT::v8i8:  Opc = ARM::VST3d8; break;
01389     case MVT::v4i16: Opc = ARM::VST3d16; break;
01390     case MVT::v2f32:
01391     case MVT::v2i32: Opc = ARM::VST3d32; break;
01392     }
01393     SDValue Chain = N->getOperand(0);
01394     const SDValue Ops[] = { MemAddr, MemUpdate, MemOpc,
01395                             N->getOperand(2), N->getOperand(3),
01396                             N->getOperand(4), Chain };
01397     return CurDAG->getTargetNode(Opc, dl, MVT::Other, Ops, 7);
01398   }
01399 
01400   case ARMISD::VST4D: {
01401     SDValue MemAddr, MemUpdate, MemOpc;
01402     if (!SelectAddrMode6(Op, N->getOperand(1), MemAddr, MemUpdate, MemOpc))
01403         return NULL;
01404     unsigned Opc = 0;
01405     switch (N->getOperand(2).getValueType().getSimpleVT().SimpleTy) {
01406     default: llvm_unreachable("unhandled VST4D type");
01407     case MVT::v8i8:  Opc = ARM::VST4d8; break;
01408     case MVT::v4i16: Opc = ARM::VST4d16; break;
01409     case MVT::v2f32:
01410     case MVT::v2i32: Opc = ARM::VST4d32; break;
01411     }
01412     SDValue Chain = N->getOperand(0);
01413     const SDValue Ops[] = { MemAddr, MemUpdate, MemOpc,
01414                             N->getOperand(2), N->getOperand(3),
01415                             N->getOperand(4), N->getOperand(5), Chain };
01416     return CurDAG->getTargetNode(Opc, dl, MVT::Other, Ops, 8);
01417   }
01418   case ARMISD::VZIP: {
01419     unsigned Opc = 0;
01420     EVT VT = N->getValueType(0);
01421     switch (VT.getSimpleVT().SimpleTy) {
01422     default: return NULL;
01423     case MVT::v8i8:  Opc = ARM::VZIPd8; break;
01424     case MVT::v4i16: Opc = ARM::VZIPd16; break;
01425     case MVT::v2f32:
01426     case MVT::v2i32: Opc = ARM::VZIPd32; break;
01427     case MVT::v16i8: Opc = ARM::VZIPq8; break;
01428     case MVT::v8i16: Opc = ARM::VZIPq16; break;
01429     case MVT::v4f32:
01430     case MVT::v4i32: Opc = ARM::VZIPq32; break;
01431     }
01432     return CurDAG->getTargetNode(Opc, dl, VT, VT,
01433                                  N->getOperand(0), N->getOperand(1));
01434   }
01435   case ARMISD::VUZP: {
01436     unsigned Opc = 0;
01437     EVT VT = N->getValueType(0);
01438     switch (VT.getSimpleVT().SimpleTy) {
01439     default: return NULL;
01440     case MVT::v8i8:  Opc = ARM::VUZPd8; break;
01441     case MVT::v4i16: Opc = ARM::VUZPd16; break;
01442     case MVT::v2f32:
01443     case MVT::v2i32: Opc = ARM::VUZPd32; break;
01444     case MVT::v16i8: Opc = ARM::VUZPq8; break;
01445     case MVT::v8i16: Opc = ARM::VUZPq16; break;
01446     case MVT::v4f32:
01447     case MVT::v4i32: Opc = ARM::VUZPq32; break;
01448     }
01449     return CurDAG->getTargetNode(Opc, dl, VT, VT,
01450                                  N->getOperand(0), N->getOperand(1));
01451   }
01452   case ARMISD::VTRN: {
01453     unsigned Opc = 0;
01454     EVT VT = N->getValueType(0);
01455     switch (VT.getSimpleVT().SimpleTy) {
01456     default: return NULL;
01457     case MVT::v8i8:  Opc = ARM::VTRNd8; break;
01458     case MVT::v4i16: Opc = ARM::VTRNd16; break;
01459     case MVT::v2f32:
01460     case MVT::v2i32: Opc = ARM::VTRNd32; break;
01461     case MVT::v16i8: Opc = ARM::VTRNq8; break;
01462     case MVT::v8i16: Opc = ARM::VTRNq16; break;
01463     case MVT::v4f32:
01464     case MVT::v4i32: Opc = ARM::VTRNq32; break;
01465     }
01466     return CurDAG->getTargetNode(Opc, dl, VT, VT,
01467                                  N->getOperand(0), N->getOperand(1));
01468   }
01469   }
01470 
01471   return SelectCode(Op);
01472 }
01473 
01474 bool ARMDAGToDAGISel::
01475 SelectInlineAsmMemoryOperand(const SDValue &Op, char ConstraintCode,
01476                              std::vector<SDValue> &OutOps) {
01477   assert(ConstraintCode == 'm' && "unexpected asm memory constraint");
01478 
01479   SDValue Base, Offset, Opc;
01480   if (!SelectAddrMode2(Op, Op, Base, Offset, Opc))
01481     return true;
01482 
01483   OutOps.push_back(Base);
01484   OutOps.push_back(Offset);
01485   OutOps.push_back(Opc);
01486   return false;
01487 }
01488 
01489 /// createARMISelDag - This pass converts a legalized DAG into a
01490 /// ARM-specific DAG, ready for instruction scheduling.
01491 ///
01492 FunctionPass *llvm::createARMISelDag(ARMBaseTargetMachine &TM) {
01493   return new ARMDAGToDAGISel(TM);
01494 }