lib/Target/ARM/ARMISelLowering.cpp

   1 //===-- ARMISelLowering.cpp - ARM DAG Lowering Implementation -------------===//
   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 the interfaces that ARM uses to lower LLVM code into a
  11 // selection DAG.
  12 //
  13 //===----------------------------------------------------------------------===//
  14
  15 #define DEBUG_TYPE "arm-isel"
  16 #include "ARM.h"
  17 #include "ARMAddressingModes.h"
  18 #include "ARMCallingConv.h"
  19 #include "ARMConstantPoolValue.h"
  20 #include "ARMISelLowering.h"
  21 #include "ARMMachineFunctionInfo.h"
  22 #include "ARMPerfectShuffle.h"
  23 #include "ARMRegisterInfo.h"
  24 #include "ARMSubtarget.h"
  25 #include "ARMTargetMachine.h"
  26 #include "ARMTargetObjectFile.h"
  27 #include "llvm/CallingConv.h"
  28 #include "llvm/Constants.h"
  29 #include "llvm/Function.h"
  30 #include "llvm/GlobalValue.h"
  31 #include "llvm/Instruction.h"
  32 #include "llvm/Intrinsics.h"
  33 #include "llvm/Type.h"
  34 #include "llvm/CodeGen/CallingConvLower.h"
  35 #include "llvm/CodeGen/MachineBasicBlock.h"
  36 #include "llvm/CodeGen/MachineFrameInfo.h"
  37 #include "llvm/CodeGen/MachineFunction.h"
  38 #include "llvm/CodeGen/MachineInstrBuilder.h"
  39 #include "llvm/CodeGen/MachineRegisterInfo.h"
  40 #include "llvm/CodeGen/PseudoSourceValue.h"
  41 #include "llvm/CodeGen/SelectionDAG.h"
  42 #include "llvm/MC/MCSectionMachO.h"
  43 #include "llvm/Target/TargetOptions.h"
  44 #include "llvm/ADT/VectorExtras.h"
  45 #include "llvm/ADT/Statistic.h"
  46 #include "llvm/Support/CommandLine.h"
  47 #include "llvm/Support/ErrorHandling.h"
  48 #include "llvm/Support/MathExtras.h"
  49 #include "llvm/Support/raw_ostream.h"
  50 #include <sstream>
  51 using namespace llvm;
  52
  53 STATISTIC(NumTailCalls, "Number of tail calls");
  54
  55 // This option should go away when tail calls fully work.
  56 static cl::opt<bool>
  57 EnableARMTailCalls("arm-tail-calls", cl::Hidden,
  58   cl::desc("Generate tail calls (TEMPORARY OPTION)."),
  59   cl::init(false));
  60
  61 // This option should go away when Machine LICM is smart enough to hoist a
  62 // reg-to-reg VDUP.
  63 static cl::opt<bool>
  64 EnableARMVDUPsplat("arm-vdup-splat", cl::Hidden,
  65   cl::desc("Generate VDUP for integer constant splats (TEMPORARY OPTION)."),
  66   cl::init(false));
  67
  68 static cl::opt<bool>
  69 EnableARMLongCalls("arm-long-calls", cl::Hidden,
  70   cl::desc("Generate calls via indirect call instructions"),
  71   cl::init(false));
  72
  73 static cl::opt<bool>
  74 ARMInterworking("arm-interworking", cl::Hidden,
  75   cl::desc("Enable / disable ARM interworking (for debugging only)"),
  76   cl::init(true));
  77
  78 static cl::opt<bool>
  79 EnableARMCodePlacement("arm-code-placement", cl::Hidden,
  80   cl::desc("Enable code placement pass for ARM"),
  81   cl::init(false));
  82
  83 void ARMTargetLowering::addTypeForNEON(EVT VT, EVT PromotedLdStVT,
  84                                        EVT PromotedBitwiseVT) {
  85   if (VT != PromotedLdStVT) {
  86     setOperationAction(ISD::LOAD, VT.getSimpleVT(), Promote);
  87     AddPromotedToType (ISD::LOAD, VT.getSimpleVT(),
  88                        PromotedLdStVT.getSimpleVT());
  89
  90     setOperationAction(ISD::STORE, VT.getSimpleVT(), Promote);
  91     AddPromotedToType (ISD::STORE, VT.getSimpleVT(),
  92                        PromotedLdStVT.getSimpleVT());
  93   }
  94
  95   EVT ElemTy = VT.getVectorElementType();
  96   if (ElemTy != MVT::i64 && ElemTy != MVT::f64)
  97     setOperationAction(ISD::VSETCC, VT.getSimpleVT(), Custom);
  98   if (ElemTy == MVT::i8 || ElemTy == MVT::i16)
  99     setOperationAction(ISD::EXTRACT_VECTOR_ELT, VT.getSimpleVT(), Custom);
 100   if (ElemTy != MVT::i32) {
 101     setOperationAction(ISD::SINT_TO_FP, VT.getSimpleVT(), Expand);
 102     setOperationAction(ISD::UINT_TO_FP, VT.getSimpleVT(), Expand);
 103     setOperationAction(ISD::FP_TO_SINT, VT.getSimpleVT(), Expand);
 104     setOperationAction(ISD::FP_TO_UINT, VT.getSimpleVT(), Expand);
 105   }
 106   setOperationAction(ISD::BUILD_VECTOR, VT.getSimpleVT(), Custom);
 107   setOperationAction(ISD::VECTOR_SHUFFLE, VT.getSimpleVT(), Custom);
 108   setOperationAction(ISD::CONCAT_VECTORS, VT.getSimpleVT(), Legal);
 109   setOperationAction(ISD::EXTRACT_SUBVECTOR, VT.getSimpleVT(), Expand);
 110   setOperationAction(ISD::SELECT, VT.getSimpleVT(), Expand);
 111   setOperationAction(ISD::SELECT_CC, VT.getSimpleVT(), Expand);
 112   if (VT.isInteger()) {
 113     setOperationAction(ISD::SHL, VT.getSimpleVT(), Custom);
 114     setOperationAction(ISD::SRA, VT.getSimpleVT(), Custom);
 115     setOperationAction(ISD::SRL, VT.getSimpleVT(), Custom);
 116     setLoadExtAction(ISD::SEXTLOAD, VT.getSimpleVT(), Expand);
 117     setLoadExtAction(ISD::ZEXTLOAD, VT.getSimpleVT(), Expand);
 118   }
 119   setLoadExtAction(ISD::EXTLOAD, VT.getSimpleVT(), Expand);
 120
 121   // Promote all bit-wise operations.
 122   if (VT.isInteger() && VT != PromotedBitwiseVT) {
 123     setOperationAction(ISD::AND, VT.getSimpleVT(), Promote);
 124     AddPromotedToType (ISD::AND, VT.getSimpleVT(),
 125                        PromotedBitwiseVT.getSimpleVT());
 126     setOperationAction(ISD::OR,  VT.getSimpleVT(), Promote);
 127     AddPromotedToType (ISD::OR,  VT.getSimpleVT(),
 128                        PromotedBitwiseVT.getSimpleVT());
 129     setOperationAction(ISD::XOR, VT.getSimpleVT(), Promote);
 130     AddPromotedToType (ISD::XOR, VT.getSimpleVT(),
 131                        PromotedBitwiseVT.getSimpleVT());
 132   }
 133
 134   // Neon does not support vector divide/remainder operations.
 135   setOperationAction(ISD::SDIV, VT.getSimpleVT(), Expand);
 136   setOperationAction(ISD::UDIV, VT.getSimpleVT(), Expand);
 137   setOperationAction(ISD::FDIV, VT.getSimpleVT(), Expand);
 138   setOperationAction(ISD::SREM, VT.getSimpleVT(), Expand);
 139   setOperationAction(ISD::UREM, VT.getSimpleVT(), Expand);
 140   setOperationAction(ISD::FREM, VT.getSimpleVT(), Expand);
 141 }
 142
 143 void ARMTargetLowering::addDRTypeForNEON(EVT VT) {
 144   addRegisterClass(VT, ARM::DPRRegisterClass);
 145   addTypeForNEON(VT, MVT::f64, MVT::v2i32);
 146 }
 147
 148 void ARMTargetLowering::addQRTypeForNEON(EVT VT) {
 149   addRegisterClass(VT, ARM::QPRRegisterClass);
 150   addTypeForNEON(VT, MVT::v2f64, MVT::v4i32);
 151 }
 152
 153 static TargetLoweringObjectFile *createTLOF(TargetMachine &TM) {
 154   if (TM.getSubtarget<ARMSubtarget>().isTargetDarwin())
 155     return new TargetLoweringObjectFileMachO();
 156
 157   return new ARMElfTargetObjectFile();
 158 }
 159
 160 ARMTargetLowering::ARMTargetLowering(TargetMachine &TM)
 161     : TargetLowering(TM, createTLOF(TM)) {
 162   Subtarget = &TM.getSubtarget<ARMSubtarget>();
 163   RegInfo = TM.getRegisterInfo();
 164   Itins = TM.getInstrItineraryData();
 165
 166   if (Subtarget->isTargetDarwin()) {
 167     // Uses VFP for Thumb libfuncs if available.
 168     if (Subtarget->isThumb() && Subtarget->hasVFP2()) {
 169       // Single-precision floating-point arithmetic.
 170       setLibcallName(RTLIB::ADD_F32, "__addsf3vfp");
 171       setLibcallName(RTLIB::SUB_F32, "__subsf3vfp");
 172       setLibcallName(RTLIB::MUL_F32, "__mulsf3vfp");
 173       setLibcallName(RTLIB::DIV_F32, "__divsf3vfp");
 174
 175       // Double-precision floating-point arithmetic.
 176       setLibcallName(RTLIB::ADD_F64, "__adddf3vfp");
 177       setLibcallName(RTLIB::SUB_F64, "__subdf3vfp");
 178       setLibcallName(RTLIB::MUL_F64, "__muldf3vfp");
 179       setLibcallName(RTLIB::DIV_F64, "__divdf3vfp");
 180
 181       // Single-precision comparisons.
 182       setLibcallName(RTLIB::OEQ_F32, "__eqsf2vfp");
 183       setLibcallName(RTLIB::UNE_F32, "__nesf2vfp");
 184       setLibcallName(RTLIB::OLT_F32, "__ltsf2vfp");
 185       setLibcallName(RTLIB::OLE_F32, "__lesf2vfp");
 186       setLibcallName(RTLIB::OGE_F32, "__gesf2vfp");
 187       setLibcallName(RTLIB::OGT_F32, "__gtsf2vfp");
 188       setLibcallName(RTLIB::UO_F32,  "__unordsf2vfp");
 189       setLibcallName(RTLIB::O_F32,   "__unordsf2vfp");
 190
 191       setCmpLibcallCC(RTLIB::OEQ_F32, ISD::SETNE);
 192       setCmpLibcallCC(RTLIB::UNE_F32, ISD::SETNE);
 193       setCmpLibcallCC(RTLIB::OLT_F32, ISD::SETNE);
 194       setCmpLibcallCC(RTLIB::OLE_F32, ISD::SETNE);
 195       setCmpLibcallCC(RTLIB::OGE_F32, ISD::SETNE);
 196       setCmpLibcallCC(RTLIB::OGT_F32, ISD::SETNE);
 197       setCmpLibcallCC(RTLIB::UO_F32,  ISD::SETNE);
 198       setCmpLibcallCC(RTLIB::O_F32,   ISD::SETEQ);
 199
 200       // Double-precision comparisons.
 201       setLibcallName(RTLIB::OEQ_F64, "__eqdf2vfp");
 202       setLibcallName(RTLIB::UNE_F64, "__nedf2vfp");
 203       setLibcallName(RTLIB::OLT_F64, "__ltdf2vfp");
 204       setLibcallName(RTLIB::OLE_F64, "__ledf2vfp");
 205       setLibcallName(RTLIB::OGE_F64, "__gedf2vfp");
 206       setLibcallName(RTLIB::OGT_F64, "__gtdf2vfp");
 207       setLibcallName(RTLIB::UO_F64,  "__unorddf2vfp");
 208       setLibcallName(RTLIB::O_F64,   "__unorddf2vfp");
 209
 210       setCmpLibcallCC(RTLIB::OEQ_F64, ISD::SETNE);
 211       setCmpLibcallCC(RTLIB::UNE_F64, ISD::SETNE);
 212       setCmpLibcallCC(RTLIB::OLT_F64, ISD::SETNE);
 213       setCmpLibcallCC(RTLIB::OLE_F64, ISD::SETNE);
 214       setCmpLibcallCC(RTLIB::OGE_F64, ISD::SETNE);
 215       setCmpLibcallCC(RTLIB::OGT_F64, ISD::SETNE);
 216       setCmpLibcallCC(RTLIB::UO_F64,  ISD::SETNE);
 217       setCmpLibcallCC(RTLIB::O_F64,   ISD::SETEQ);
 218
 219       // Floating-point to integer conversions.
 220       // i64 conversions are done via library routines even when generating VFP
 221       // instructions, so use the same ones.
 222       setLibcallName(RTLIB::FPTOSINT_F64_I32, "__fixdfsivfp");
 223       setLibcallName(RTLIB::FPTOUINT_F64_I32, "__fixunsdfsivfp");
 224       setLibcallName(RTLIB::FPTOSINT_F32_I32, "__fixsfsivfp");
 225       setLibcallName(RTLIB::FPTOUINT_F32_I32, "__fixunssfsivfp");
 226
 227       // Conversions between floating types.
 228       setLibcallName(RTLIB::FPROUND_F64_F32, "__truncdfsf2vfp");
 229       setLibcallName(RTLIB::FPEXT_F32_F64,   "__extendsfdf2vfp");
 230
 231       // Integer to floating-point conversions.
 232       // i64 conversions are done via library routines even when generating VFP
 233       // instructions, so use the same ones.
 234       // FIXME: There appears to be some naming inconsistency in ARM libgcc:
 235       // e.g., __floatunsidf vs. __floatunssidfvfp.
 236       setLibcallName(RTLIB::SINTTOFP_I32_F64, "__floatsidfvfp");
 237       setLibcallName(RTLIB::UINTTOFP_I32_F64, "__floatunssidfvfp");
 238       setLibcallName(RTLIB::SINTTOFP_I32_F32, "__floatsisfvfp");
 239       setLibcallName(RTLIB::UINTTOFP_I32_F32, "__floatunssisfvfp");
 240     }
 241   }
 242
 243   // These libcalls are not available in 32-bit.
 244   setLibcallName(RTLIB::SHL_I128, 0);
 245   setLibcallName(RTLIB::SRL_I128, 0);
 246   setLibcallName(RTLIB::SRA_I128, 0);
 247
 248   // Libcalls should use the AAPCS base standard ABI, even if hard float
 249   // is in effect, as per the ARM RTABI specification, section 4.1.2.
 250   if (Subtarget->isAAPCS_ABI()) {
 251     for (int i = 0; i < RTLIB::UNKNOWN_LIBCALL; ++i) {
 252       setLibcallCallingConv(static_cast<RTLIB::Libcall>(i),
 253                             CallingConv::ARM_AAPCS);
 254     }
 255   }
 256
 257   if (Subtarget->isThumb1Only())
 258     addRegisterClass(MVT::i32, ARM::tGPRRegisterClass);
 259   else
 260     addRegisterClass(MVT::i32, ARM::GPRRegisterClass);
 261   if (!UseSoftFloat && Subtarget->hasVFP2() && !Subtarget->isThumb1Only()) {
 262     addRegisterClass(MVT::f32, ARM::SPRRegisterClass);
 263     if (!Subtarget->isFPOnlySP())
 264       addRegisterClass(MVT::f64, ARM::DPRRegisterClass);
 265
 266     setTruncStoreAction(MVT::f64, MVT::f32, Expand);
 267   }
 268
 269   if (Subtarget->hasNEON()) {
 270     addDRTypeForNEON(MVT::v2f32);
 271     addDRTypeForNEON(MVT::v8i8);
 272     addDRTypeForNEON(MVT::v4i16);
 273     addDRTypeForNEON(MVT::v2i32);
 274     addDRTypeForNEON(MVT::v1i64);
 275
 276     addQRTypeForNEON(MVT::v4f32);
 277     addQRTypeForNEON(MVT::v2f64);
 278     addQRTypeForNEON(MVT::v16i8);
 279     addQRTypeForNEON(MVT::v8i16);
 280     addQRTypeForNEON(MVT::v4i32);
 281     addQRTypeForNEON(MVT::v2i64);
 282
 283     // v2f64 is legal so that QR subregs can be extracted as f64 elements, but
 284     // neither Neon nor VFP support any arithmetic operations on it.
 285     setOperationAction(ISD::FADD, MVT::v2f64, Expand);
 286     setOperationAction(ISD::FSUB, MVT::v2f64, Expand);
 287     setOperationAction(ISD::FMUL, MVT::v2f64, Expand);
 288     setOperationAction(ISD::FDIV, MVT::v2f64, Expand);
 289     setOperationAction(ISD::FREM, MVT::v2f64, Expand);
 290     setOperationAction(ISD::FCOPYSIGN, MVT::v2f64, Expand);
 291     setOperationAction(ISD::VSETCC, MVT::v2f64, Expand);
 292     setOperationAction(ISD::FNEG, MVT::v2f64, Expand);
 293     setOperationAction(ISD::FABS, MVT::v2f64, Expand);
 294     setOperationAction(ISD::FSQRT, MVT::v2f64, Expand);
 295     setOperationAction(ISD::FSIN, MVT::v2f64, Expand);
 296     setOperationAction(ISD::FCOS, MVT::v2f64, Expand);
 297     setOperationAction(ISD::FPOWI, MVT::v2f64, Expand);
 298     setOperationAction(ISD::FPOW, MVT::v2f64, Expand);
 299     setOperationAction(ISD::FLOG, MVT::v2f64, Expand);
 300     setOperationAction(ISD::FLOG2, MVT::v2f64, Expand);
 301     setOperationAction(ISD::FLOG10, MVT::v2f64, Expand);
 302     setOperationAction(ISD::FEXP, MVT::v2f64, Expand);
 303     setOperationAction(ISD::FEXP2, MVT::v2f64, Expand);
 304     setOperationAction(ISD::FCEIL, MVT::v2f64, Expand);
 305     setOperationAction(ISD::FTRUNC, MVT::v2f64, Expand);
 306     setOperationAction(ISD::FRINT, MVT::v2f64, Expand);
 307     setOperationAction(ISD::FNEARBYINT, MVT::v2f64, Expand);
 308     setOperationAction(ISD::FFLOOR, MVT::v2f64, Expand);
 309
 310     setTruncStoreAction(MVT::v2f64, MVT::v2f32, Expand);
 311
 312     // Neon does not support some operations on v1i64 and v2i64 types.
 313     setOperationAction(ISD::MUL, MVT::v1i64, Expand);
 314     // Custom handling for some quad-vector types to detect VMULL.
 315     setOperationAction(ISD::MUL, MVT::v8i16, Custom);
 316     setOperationAction(ISD::MUL, MVT::v4i32, Custom);
 317     setOperationAction(ISD::MUL, MVT::v2i64, Custom);
 318     setOperationAction(ISD::VSETCC, MVT::v1i64, Expand);
 319     setOperationAction(ISD::VSETCC, MVT::v2i64, Expand);
 320
 321     setTargetDAGCombine(ISD::INTRINSIC_WO_CHAIN);
 322     setTargetDAGCombine(ISD::SHL);
 323     setTargetDAGCombine(ISD::SRL);
 324     setTargetDAGCombine(ISD::SRA);
 325     setTargetDAGCombine(ISD::SIGN_EXTEND);
 326     setTargetDAGCombine(ISD::ZERO_EXTEND);
 327     setTargetDAGCombine(ISD::ANY_EXTEND);
 328     setTargetDAGCombine(ISD::SELECT_CC);
 329     setTargetDAGCombine(ISD::BUILD_VECTOR);
 330   }
 331
 332   computeRegisterProperties();
 333
 334   // ARM does not have f32 extending load.
 335   setLoadExtAction(ISD::EXTLOAD, MVT::f32, Expand);
 336
 337   // ARM does not have i1 sign extending load.
 338   setLoadExtAction(ISD::SEXTLOAD, MVT::i1, Promote);
 339
 340   // ARM supports all 4 flavors of integer indexed load / store.
 341   if (!Subtarget->isThumb1Only()) {
 342     for (unsigned im = (unsigned)ISD::PRE_INC;
 343          im != (unsigned)ISD::LAST_INDEXED_MODE; ++im) {
 344       setIndexedLoadAction(im,  MVT::i1,  Legal);
 345       setIndexedLoadAction(im,  MVT::i8,  Legal);
 346       setIndexedLoadAction(im,  MVT::i16, Legal);
 347       setIndexedLoadAction(im,  MVT::i32, Legal);
 348       setIndexedStoreAction(im, MVT::i1,  Legal);
 349       setIndexedStoreAction(im, MVT::i8,  Legal);
 350       setIndexedStoreAction(im, MVT::i16, Legal);
 351       setIndexedStoreAction(im, MVT::i32, Legal);
 352     }
 353   }
 354
 355   // i64 operation support.
 356   if (Subtarget->isThumb1Only()) {
 357     setOperationAction(ISD::MUL,     MVT::i64, Expand);
 358     setOperationAction(ISD::MULHU,   MVT::i32, Expand);
 359     setOperationAction(ISD::MULHS,   MVT::i32, Expand);
 360     setOperationAction(ISD::UMUL_LOHI, MVT::i32, Expand);
 361     setOperationAction(ISD::SMUL_LOHI, MVT::i32, Expand);
 362   } else {
 363     setOperationAction(ISD::MUL,     MVT::i64, Expand);
 364     setOperationAction(ISD::MULHU,   MVT::i32, Expand);
 365     if (!Subtarget->hasV6Ops())
 366       setOperationAction(ISD::MULHS, MVT::i32, Expand);
 367   }
 368   setOperationAction(ISD::SHL_PARTS, MVT::i32, Custom);
 369   setOperationAction(ISD::SRA_PARTS, MVT::i32, Custom);
 370   setOperationAction(ISD::SRL_PARTS, MVT::i32, Custom);
 371   setOperationAction(ISD::SRL,       MVT::i64, Custom);
 372   setOperationAction(ISD::SRA,       MVT::i64, Custom);
 373
 374   // ARM does not have ROTL.
 375   setOperationAction(ISD::ROTL,  MVT::i32, Expand);
 376   setOperationAction(ISD::CTTZ,  MVT::i32, Custom);
 377   setOperationAction(ISD::CTPOP, MVT::i32, Expand);
 378   if (!Subtarget->hasV5TOps() || Subtarget->isThumb1Only())
 379     setOperationAction(ISD::CTLZ, MVT::i32, Expand);
 380
 381   // Only ARMv6 has BSWAP.
 382   if (!Subtarget->hasV6Ops())
 383     setOperationAction(ISD::BSWAP, MVT::i32, Expand);
 384
 385   // These are expanded into libcalls.
 386   if (!Subtarget->hasDivide()) {
 387     // v7M has a hardware divider
 388     setOperationAction(ISD::SDIV,  MVT::i32, Expand);
 389     setOperationAction(ISD::UDIV,  MVT::i32, Expand);
 390   }
 391   setOperationAction(ISD::SREM,  MVT::i32, Expand);
 392   setOperationAction(ISD::UREM,  MVT::i32, Expand);
 393   setOperationAction(ISD::SDIVREM, MVT::i32, Expand);
 394   setOperationAction(ISD::UDIVREM, MVT::i32, Expand);
 395
 396   setOperationAction(ISD::GlobalAddress, MVT::i32,   Custom);
 397   setOperationAction(ISD::ConstantPool,  MVT::i32,   Custom);
 398   setOperationAction(ISD::GLOBAL_OFFSET_TABLE, MVT::i32, Custom);
 399   setOperationAction(ISD::GlobalTLSAddress, MVT::i32, Custom);
 400   setOperationAction(ISD::BlockAddress, MVT::i32, Custom);
 401
 402   setOperationAction(ISD::TRAP, MVT::Other, Legal);
 403
 404   // Use the default implementation.
 405   setOperationAction(ISD::VASTART,            MVT::Other, Custom);
 406   setOperationAction(ISD::VAARG,              MVT::Other, Expand);
 407   setOperationAction(ISD::VACOPY,             MVT::Other, Expand);
 408   setOperationAction(ISD::VAEND,              MVT::Other, Expand);
 409   setOperationAction(ISD::STACKSAVE,          MVT::Other, Expand);
 410   setOperationAction(ISD::STACKRESTORE,       MVT::Other, Expand);
 411   setOperationAction(ISD::EHSELECTION,        MVT::i32,   Expand);
 412   // FIXME: Shouldn't need this, since no register is used, but the legalizer
 413   // doesn't yet know how to not do that for SjLj.
 414   setExceptionSelectorRegister(ARM::R0);
 415   setOperationAction(ISD::DYNAMIC_STACKALLOC, MVT::i32, Expand);
 416   // ARMv6 Thumb1 (except for CPUs that support dmb / dsb) and earlier use
 417   // the default expansion.
 418   if (Subtarget->hasDataBarrier() ||
 419       (Subtarget->hasV6Ops() && !Subtarget->isThumb1Only())) {
 420     // membarrier needs custom lowering; the rest are legal and handled
 421     // normally.
 422     setOperationAction(ISD::MEMBARRIER, MVT::Other, Custom);
 423   } else {
 424     // Set them all for expansion, which will force libcalls.
 425     setOperationAction(ISD::MEMBARRIER, MVT::Other, Expand);
 426     setOperationAction(ISD::ATOMIC_CMP_SWAP,  MVT::i8,  Expand);
 427     setOperationAction(ISD::ATOMIC_CMP_SWAP,  MVT::i16, Expand);
 428     setOperationAction(ISD::ATOMIC_CMP_SWAP,  MVT::i32, Expand);
 429     setOperationAction(ISD::ATOMIC_SWAP,      MVT::i8,  Expand);
 430     setOperationAction(ISD::ATOMIC_SWAP,      MVT::i16, Expand);
 431     setOperationAction(ISD::ATOMIC_SWAP,      MVT::i32, Expand);
 432     setOperationAction(ISD::ATOMIC_LOAD_ADD,  MVT::i8,  Expand);
 433     setOperationAction(ISD::ATOMIC_LOAD_ADD,  MVT::i16, Expand);
 434     setOperationAction(ISD::ATOMIC_LOAD_ADD,  MVT::i32, Expand);
 435     setOperationAction(ISD::ATOMIC_LOAD_SUB,  MVT::i8,  Expand);
 436     setOperationAction(ISD::ATOMIC_LOAD_SUB,  MVT::i16, Expand);
 437     setOperationAction(ISD::ATOMIC_LOAD_SUB,  MVT::i32, Expand);
 438     setOperationAction(ISD::ATOMIC_LOAD_AND,  MVT::i8,  Expand);
 439     setOperationAction(ISD::ATOMIC_LOAD_AND,  MVT::i16, Expand);
 440     setOperationAction(ISD::ATOMIC_LOAD_AND,  MVT::i32, Expand);
 441     setOperationAction(ISD::ATOMIC_LOAD_OR,   MVT::i8,  Expand);
 442     setOperationAction(ISD::ATOMIC_LOAD_OR,   MVT::i16, Expand);
 443     setOperationAction(ISD::ATOMIC_LOAD_OR,   MVT::i32, Expand);
 444     setOperationAction(ISD::ATOMIC_LOAD_XOR,  MVT::i8,  Expand);
 445     setOperationAction(ISD::ATOMIC_LOAD_XOR,  MVT::i16, Expand);
 446     setOperationAction(ISD::ATOMIC_LOAD_XOR,  MVT::i32, Expand);
 447     setOperationAction(ISD::ATOMIC_LOAD_NAND, MVT::i8,  Expand);
 448     setOperationAction(ISD::ATOMIC_LOAD_NAND, MVT::i16, Expand);
 449     setOperationAction(ISD::ATOMIC_LOAD_NAND, MVT::i32, Expand);
 450     // Since the libcalls include locking, fold in the fences
 451     setShouldFoldAtomicFences(true);
 452   }
 453   // 64-bit versions are always libcalls (for now)
 454   setOperationAction(ISD::ATOMIC_CMP_SWAP,  MVT::i64, Expand);
 455   setOperationAction(ISD::ATOMIC_SWAP,      MVT::i64, Expand);
 456   setOperationAction(ISD::ATOMIC_LOAD_ADD,  MVT::i64, Expand);
 457   setOperationAction(ISD::ATOMIC_LOAD_SUB,  MVT::i64, Expand);
 458   setOperationAction(ISD::ATOMIC_LOAD_AND,  MVT::i64, Expand);
 459   setOperationAction(ISD::ATOMIC_LOAD_OR,   MVT::i64, Expand);
 460   setOperationAction(ISD::ATOMIC_LOAD_XOR,  MVT::i64, Expand);
 461   setOperationAction(ISD::ATOMIC_LOAD_NAND, MVT::i64, Expand);
 462
 463   // Requires SXTB/SXTH, available on v6 and up in both ARM and Thumb modes.
 464   if (!Subtarget->hasV6Ops()) {
 465     setOperationAction(ISD::SIGN_EXTEND_INREG, MVT::i16, Expand);
 466     setOperationAction(ISD::SIGN_EXTEND_INREG, MVT::i8,  Expand);
 467   }
 468   setOperationAction(ISD::SIGN_EXTEND_INREG, MVT::i1, Expand);
 469
 470   if (!UseSoftFloat && Subtarget->hasVFP2() && !Subtarget->isThumb1Only()) {
 471     // Turn f64->i64 into VMOVRRD, i64 -> f64 to VMOVDRR
 472     // iff target supports vfp2.
 473     setOperationAction(ISD::BIT_CONVERT, MVT::i64, Custom);
 474     setOperationAction(ISD::FLT_ROUNDS_, MVT::i32, Custom);
 475   }
 476
 477   // We want to custom lower some of our intrinsics.
 478   setOperationAction(ISD::INTRINSIC_WO_CHAIN, MVT::Other, Custom);
 479   if (Subtarget->isTargetDarwin()) {
 480     setOperationAction(ISD::EH_SJLJ_SETJMP, MVT::i32, Custom);
 481     setOperationAction(ISD::EH_SJLJ_LONGJMP, MVT::Other, Custom);
 482   }
 483
 484   setOperationAction(ISD::SETCC,     MVT::i32, Expand);
 485   setOperationAction(ISD::SETCC,     MVT::f32, Expand);
 486   setOperationAction(ISD::SETCC,     MVT::f64, Expand);
 487   setOperationAction(ISD::SELECT,    MVT::i32, Custom);
 488   setOperationAction(ISD::SELECT,    MVT::f32, Custom);
 489   setOperationAction(ISD::SELECT,    MVT::f64, Custom);
 490   setOperationAction(ISD::SELECT_CC, MVT::i32, Custom);
 491   setOperationAction(ISD::SELECT_CC, MVT::f32, Custom);
 492   setOperationAction(ISD::SELECT_CC, MVT::f64, Custom);
 493
 494   setOperationAction(ISD::BRCOND,    MVT::Other, Expand);
 495   setOperationAction(ISD::BR_CC,     MVT::i32,   Custom);
 496   setOperationAction(ISD::BR_CC,     MVT::f32,   Custom);
 497   setOperationAction(ISD::BR_CC,     MVT::f64,   Custom);
 498   setOperationAction(ISD::BR_JT,     MVT::Other, Custom);
 499
 500   // We don't support sin/cos/fmod/copysign/pow
 501   setOperationAction(ISD::FSIN,      MVT::f64, Expand);
 502   setOperationAction(ISD::FSIN,      MVT::f32, Expand);
 503   setOperationAction(ISD::FCOS,      MVT::f32, Expand);
 504   setOperationAction(ISD::FCOS,      MVT::f64, Expand);
 505   setOperationAction(ISD::FREM,      MVT::f64, Expand);
 506   setOperationAction(ISD::FREM,      MVT::f32, Expand);
 507   if (!UseSoftFloat && Subtarget->hasVFP2() && !Subtarget->isThumb1Only()) {
 508     setOperationAction(ISD::FCOPYSIGN, MVT::f64, Custom);
 509     setOperationAction(ISD::FCOPYSIGN, MVT::f32, Custom);
 510   }
 511   setOperationAction(ISD::FPOW,      MVT::f64, Expand);
 512   setOperationAction(ISD::FPOW,      MVT::f32, Expand);
 513
 514   // Various VFP goodness
 515   if (!UseSoftFloat && !Subtarget->isThumb1Only()) {
 516     // int <-> fp are custom expanded into bit_convert + ARMISD ops.
 517     if (Subtarget->hasVFP2()) {
 518       setOperationAction(ISD::SINT_TO_FP, MVT::i32, Custom);
 519       setOperationAction(ISD::UINT_TO_FP, MVT::i32, Custom);
 520       setOperationAction(ISD::FP_TO_UINT, MVT::i32, Custom);
 521       setOperationAction(ISD::FP_TO_SINT, MVT::i32, Custom);
 522     }
 523     // Special handling for half-precision FP.
 524     if (!Subtarget->hasFP16()) {
 525       setOperationAction(ISD::FP16_TO_FP32, MVT::f32, Expand);
 526       setOperationAction(ISD::FP32_TO_FP16, MVT::i32, Expand);
 527     }
 528   }
 529
 530   // We have target-specific dag combine patterns for the following nodes:
 531   // ARMISD::VMOVRRD  - No need to call setTargetDAGCombine
 532   setTargetDAGCombine(ISD::ADD);
 533   setTargetDAGCombine(ISD::SUB);
 534   setTargetDAGCombine(ISD::MUL);
 535
 536   if (Subtarget->hasV6T2Ops())
 537     setTargetDAGCombine(ISD::OR);
 538
 539   setStackPointerRegisterToSaveRestore(ARM::SP);
 540
 541   if (UseSoftFloat || Subtarget->isThumb1Only() || !Subtarget->hasVFP2())
 542     setSchedulingPreference(Sched::RegPressure);
 543   else
 544     setSchedulingPreference(Sched::Hybrid);
 545
 546   maxStoresPerMemcpy = 1;   //// temporary - rewrite interface to use type
 547
 548   // On ARM arguments smaller than 4 bytes are extended, so all arguments
 549   // are at least 4 bytes aligned.
 550   setMinStackArgumentAlignment(4);
 551
 552   if (EnableARMCodePlacement)
 553     benefitFromCodePlacementOpt = true;
 554 }
 555
 556 std::pair<const TargetRegisterClass*, uint8_t>
 557 ARMTargetLowering::findRepresentativeClass(EVT VT) const{
 558   const TargetRegisterClass *RRC = 0;
 559   uint8_t Cost = 1;
 560   switch (VT.getSimpleVT().SimpleTy) {
 561   default:
 562     return TargetLowering::findRepresentativeClass(VT);
 563   // Use DPR as representative register class for all floating point
 564   // and vector types. Since there are 32 SPR registers and 32 DPR registers so
 565   // the cost is 1 for both f32 and f64.
 566   case MVT::f32: case MVT::f64: case MVT::v8i8: case MVT::v4i16:
 567   case MVT::v2i32: case MVT::v1i64: case MVT::v2f32:
 568     RRC = ARM::DPRRegisterClass;
 569     break;
 570   case MVT::v16i8: case MVT::v8i16: case MVT::v4i32: case MVT::v2i64:
 571   case MVT::v4f32: case MVT::v2f64:
 572     RRC = ARM::DPRRegisterClass;
 573     Cost = 2;
 574     break;
 575   case MVT::v4i64:
 576     RRC = ARM::DPRRegisterClass;
 577     Cost = 4;
 578     break;
 579   case MVT::v8i64:
 580     RRC = ARM::DPRRegisterClass;
 581     Cost = 8;
 582     break;
 583   }
 584   return std::make_pair(RRC, Cost);
 585 }
 586
 587 const char *ARMTargetLowering::getTargetNodeName(unsigned Opcode) const {
 588   switch (Opcode) {
 589   default: return 0;
 590   case ARMISD::Wrapper:       return "ARMISD::Wrapper";
 591   case ARMISD::WrapperJT:     return "ARMISD::WrapperJT";
 592   case ARMISD::CALL:          return "ARMISD::CALL";
 593   case ARMISD::CALL_PRED:     return "ARMISD::CALL_PRED";
 594   case ARMISD::CALL_NOLINK:   return "ARMISD::CALL_NOLINK";
 595   case ARMISD::tCALL:         return "ARMISD::tCALL";
 596   case ARMISD::BRCOND:        return "ARMISD::BRCOND";
 597   case ARMISD::BR_JT:         return "ARMISD::BR_JT";
 598   case ARMISD::BR2_JT:        return "ARMISD::BR2_JT";
 599   case ARMISD::RET_FLAG:      return "ARMISD::RET_FLAG";
 600   case ARMISD::PIC_ADD:       return "ARMISD::PIC_ADD";
 601   case ARMISD::AND:           return "ARMISD::AND";
 602   case ARMISD::CMP:           return "ARMISD::CMP";
 603   case ARMISD::CMPZ:          return "ARMISD::CMPZ";
 604   case ARMISD::CMPFP:         return "ARMISD::CMPFP";
 605   case ARMISD::CMPFPw0:       return "ARMISD::CMPFPw0";
 606   case ARMISD::BCC_i64:       return "ARMISD::BCC_i64";
 607   case ARMISD::FMSTAT:        return "ARMISD::FMSTAT";
 608   case ARMISD::CMOV:          return "ARMISD::CMOV";
 609   case ARMISD::CNEG:          return "ARMISD::CNEG";
 610
 611   case ARMISD::RBIT:          return "ARMISD::RBIT";
 612
 613   case ARMISD::FTOSI:         return "ARMISD::FTOSI";
 614   case ARMISD::FTOUI:         return "ARMISD::FTOUI";
 615   case ARMISD::SITOF:         return "ARMISD::SITOF";
 616   case ARMISD::UITOF:         return "ARMISD::UITOF";
 617
 618   case ARMISD::SRL_FLAG:      return "ARMISD::SRL_FLAG";
 619   case ARMISD::SRA_FLAG:      return "ARMISD::SRA_FLAG";
 620   case ARMISD::RRX:           return "ARMISD::RRX";
 621
 622   case ARMISD::VMOVRRD:         return "ARMISD::VMOVRRD";
 623   case ARMISD::VMOVDRR:         return "ARMISD::VMOVDRR";
 624
 625   case ARMISD::EH_SJLJ_SETJMP: return "ARMISD::EH_SJLJ_SETJMP";
 626   case ARMISD::EH_SJLJ_LONGJMP:return "ARMISD::EH_SJLJ_LONGJMP";
 627
 628   case ARMISD::TC_RETURN:     return "ARMISD::TC_RETURN";
 629
 630   case ARMISD::THREAD_POINTER:return "ARMISD::THREAD_POINTER";
 631
 632   case ARMISD::DYN_ALLOC:     return "ARMISD::DYN_ALLOC";
 633
 634   case ARMISD::MEMBARRIER:    return "ARMISD::MEMBARRIER";
 635   case ARMISD::SYNCBARRIER:   return "ARMISD::SYNCBARRIER";
 636
 637   case ARMISD::VCEQ:          return "ARMISD::VCEQ";
 638   case ARMISD::VCGE:          return "ARMISD::VCGE";
 639   case ARMISD::VCGEU:         return "ARMISD::VCGEU";
 640   case ARMISD::VCGT:          return "ARMISD::VCGT";
 641   case ARMISD::VCGTU:         return "ARMISD::VCGTU";
 642   case ARMISD::VTST:          return "ARMISD::VTST";
 643
 644   case ARMISD::VSHL:          return "ARMISD::VSHL";
 645   case ARMISD::VSHRs:         return "ARMISD::VSHRs";
 646   case ARMISD::VSHRu:         return "ARMISD::VSHRu";
 647   case ARMISD::VSHLLs:        return "ARMISD::VSHLLs";
 648   case ARMISD::VSHLLu:        return "ARMISD::VSHLLu";
 649   case ARMISD::VSHLLi:        return "ARMISD::VSHLLi";
 650   case ARMISD::VSHRN:         return "ARMISD::VSHRN";
 651   case ARMISD::VRSHRs:        return "ARMISD::VRSHRs";
 652   case ARMISD::VRSHRu:        return "ARMISD::VRSHRu";
 653   case ARMISD::VRSHRN:        return "ARMISD::VRSHRN";
 654   case ARMISD::VQSHLs:        return "ARMISD::VQSHLs";
 655   case ARMISD::VQSHLu:        return "ARMISD::VQSHLu";
 656   case ARMISD::VQSHLsu:       return "ARMISD::VQSHLsu";
 657   case ARMISD::VQSHRNs:       return "ARMISD::VQSHRNs";
 658   case ARMISD::VQSHRNu:       return "ARMISD::VQSHRNu";
 659   case ARMISD::VQSHRNsu:      return "ARMISD::VQSHRNsu";
 660   case ARMISD::VQRSHRNs:      return "ARMISD::VQRSHRNs";
 661   case ARMISD::VQRSHRNu:      return "ARMISD::VQRSHRNu";
 662   case ARMISD::VQRSHRNsu:     return "ARMISD::VQRSHRNsu";
 663   case ARMISD::VGETLANEu:     return "ARMISD::VGETLANEu";
 664   case ARMISD::VGETLANEs:     return "ARMISD::VGETLANEs";
 665   case ARMISD::VMOVIMM:       return "ARMISD::VMOVIMM";
 666   case ARMISD::VMVNIMM:       return "ARMISD::VMVNIMM";
 667   case ARMISD::VDUP:          return "ARMISD::VDUP";
 668   case ARMISD::VDUPLANE:      return "ARMISD::VDUPLANE";
 669   case ARMISD::VEXT:          return "ARMISD::VEXT";
 670   case ARMISD::VREV64:        return "ARMISD::VREV64";
 671   case ARMISD::VREV32:        return "ARMISD::VREV32";
 672   case ARMISD::VREV16:        return "ARMISD::VREV16";
 673   case ARMISD::VZIP:          return "ARMISD::VZIP";
 674   case ARMISD::VUZP:          return "ARMISD::VUZP";
 675   case ARMISD::VTRN:          return "ARMISD::VTRN";
 676   case ARMISD::VMULLs:        return "ARMISD::VMULLs";
 677   case ARMISD::VMULLu:        return "ARMISD::VMULLu";
 678   case ARMISD::BUILD_VECTOR:  return "ARMISD::BUILD_VECTOR";
 679   case ARMISD::FMAX:          return "ARMISD::FMAX";
 680   case ARMISD::FMIN:          return "ARMISD::FMIN";
 681   case ARMISD::BFI:           return "ARMISD::BFI";
 682   }
 683 }
 684
 685 /// getRegClassFor - Return the register class that should be used for the
 686 /// specified value type.
 687 TargetRegisterClass *ARMTargetLowering::getRegClassFor(EVT VT) const {
 688   // Map v4i64 to QQ registers but do not make the type legal. Similarly map
 689   // v8i64 to QQQQ registers. v4i64 and v8i64 are only used for REG_SEQUENCE to
 690   // load / store 4 to 8 consecutive D registers.
 691   if (Subtarget->hasNEON()) {
 692     if (VT == MVT::v4i64)
 693       return ARM::QQPRRegisterClass;
 694     else if (VT == MVT::v8i64)
 695       return ARM::QQQQPRRegisterClass;
 696   }
 697   return TargetLowering::getRegClassFor(VT);
 698 }
 699
 700 // Create a fast isel object.
 701 FastISel *
 702 ARMTargetLowering::createFastISel(FunctionLoweringInfo &funcInfo) const {
 703   return ARM::createFastISel(funcInfo);
 704 }
 705
 706 /// getFunctionAlignment - Return the Log2 alignment of this function.
 707 unsigned ARMTargetLowering::getFunctionAlignment(const Function *F) const {
 708   return getTargetMachine().getSubtarget<ARMSubtarget>().isThumb() ? 1 : 2;
 709 }
 710
 711 /// getMaximalGlobalOffset - Returns the maximal possible offset which can
 712 /// be used for loads / stores from the global.
 713 unsigned ARMTargetLowering::getMaximalGlobalOffset() const {
 714   return (Subtarget->isThumb1Only() ? 127 : 4095);
 715 }
 716
 717 Sched::Preference ARMTargetLowering::getSchedulingPreference(SDNode *N) const {
 718   unsigned NumVals = N->getNumValues();
 719   if (!NumVals)
 720     return Sched::RegPressure;
 721
 722   for (unsigned i = 0; i != NumVals; ++i) {
 723     EVT VT = N->getValueType(i);
 724     if (VT.isFloatingPoint() || VT.isVector())
 725       return Sched::Latency;
 726   }
 727
 728   if (!N->isMachineOpcode())
 729     return Sched::RegPressure;
 730
 731   // Load are scheduled for latency even if there instruction itinerary
 732   // is not available.
 733   const TargetInstrInfo *TII = getTargetMachine().getInstrInfo();
 734   const TargetInstrDesc &TID = TII->get(N->getMachineOpcode());
 735   if (TID.mayLoad())
 736     return Sched::Latency;
 737
 738   if (!Itins->isEmpty() && Itins->getStageLatency(TID.getSchedClass()) > 2)
 739     return Sched::Latency;
 740   return Sched::RegPressure;
 741 }
 742
 743 unsigned
 744 ARMTargetLowering::getRegPressureLimit(const TargetRegisterClass *RC,
 745                                        MachineFunction &MF) const {
 746   switch (RC->getID()) {
 747   default:
 748     return 0;
 749   case ARM::tGPRRegClassID:
 750     return RegInfo->hasFP(MF) ? 4 : 5;
 751   case ARM::GPRRegClassID: {
 752     unsigned FP = RegInfo->hasFP(MF) ? 1 : 0;
 753     return 10 - FP - (Subtarget->isR9Reserved() ? 1 : 0);
 754   }
 755   case ARM::SPRRegClassID:  // Currently not used as 'rep' register class.
 756   case ARM::DPRRegClassID:
 757     return 32 - 10;
 758   }
 759 }
 760
 761 //===----------------------------------------------------------------------===//
 762 // Lowering Code
 763 //===----------------------------------------------------------------------===//
 764
 765 /// IntCCToARMCC - Convert a DAG integer condition code to an ARM CC
 766 static ARMCC::CondCodes IntCCToARMCC(ISD::CondCode CC) {
 767   switch (CC) {
 768   default: llvm_unreachable("Unknown condition code!");
 769   case ISD::SETNE:  return ARMCC::NE;
 770   case ISD::SETEQ:  return ARMCC::EQ;
 771   case ISD::SETGT:  return ARMCC::GT;
 772   case ISD::SETGE:  return ARMCC::GE;
 773   case ISD::SETLT:  return ARMCC::LT;
 774   case ISD::SETLE:  return ARMCC::LE;
 775   case ISD::SETUGT: return ARMCC::HI;
 776   case ISD::SETUGE: return ARMCC::HS;
 777   case ISD::SETULT: return ARMCC::LO;
 778   case ISD::SETULE: return ARMCC::LS;
 779   }
 780 }
 781
 782 /// FPCCToARMCC - Convert a DAG fp condition code to an ARM CC.
 783 static void FPCCToARMCC(ISD::CondCode CC, ARMCC::CondCodes &CondCode,
 784                         ARMCC::CondCodes &CondCode2) {
 785   CondCode2 = ARMCC::AL;
 786   switch (CC) {
 787   default: llvm_unreachable("Unknown FP condition!");
 788   case ISD::SETEQ:
 789   case ISD::SETOEQ: CondCode = ARMCC::EQ; break;
 790   case ISD::SETGT:
 791   case ISD::SETOGT: CondCode = ARMCC::GT; break;
 792   case ISD::SETGE:
 793   case ISD::SETOGE: CondCode = ARMCC::GE; break;
 794   case ISD::SETOLT: CondCode = ARMCC::MI; break;
 795   case ISD::SETOLE: CondCode = ARMCC::LS; break;
 796   case ISD::SETONE: CondCode = ARMCC::MI; CondCode2 = ARMCC::GT; break;
 797   case ISD::SETO:   CondCode = ARMCC::VC; break;
 798   case ISD::SETUO:  CondCode = ARMCC::VS; break;
 799   case ISD::SETUEQ: CondCode = ARMCC::EQ; CondCode2 = ARMCC::VS; break;
 800   case ISD::SETUGT: CondCode = ARMCC::HI; break;
 801   case ISD::SETUGE: CondCode = ARMCC::PL; break;
 802   case ISD::SETLT:
 803   case ISD::SETULT: CondCode = ARMCC::LT; break;
 804   case ISD::SETLE:
 805   case ISD::SETULE: CondCode = ARMCC::LE; break;
 806   case ISD::SETNE:
 807   case ISD::SETUNE: CondCode = ARMCC::NE; break;
 808   }
 809 }
 810
 811 //===----------------------------------------------------------------------===//
 812 //                      Calling Convention Implementation
 813 //===----------------------------------------------------------------------===//
 814
 815 #include "ARMGenCallingConv.inc"
 816
 817 /// CCAssignFnForNode - Selects the correct CCAssignFn for a the
 818 /// given CallingConvention value.
 819 CCAssignFn *ARMTargetLowering::CCAssignFnForNode(CallingConv::ID CC,
 820                                                  bool Return,
 821                                                  bool isVarArg) const {
 822   switch (CC) {
 823   default:
 824     llvm_unreachable("Unsupported calling convention");
 825   case CallingConv::C:
 826   case CallingConv::Fast:
 827     // Use target triple & subtarget features to do actual dispatch.
 828     if (Subtarget->isAAPCS_ABI()) {
 829       if (Subtarget->hasVFP2() &&
 830           FloatABIType == FloatABI::Hard && !isVarArg)
 831         return (Return ? RetCC_ARM_AAPCS_VFP: CC_ARM_AAPCS_VFP);
 832       else
 833         return (Return ? RetCC_ARM_AAPCS: CC_ARM_AAPCS);
 834     } else
 835         return (Return ? RetCC_ARM_APCS: CC_ARM_APCS);
 836   case CallingConv::ARM_AAPCS_VFP:
 837     return (Return ? RetCC_ARM_AAPCS_VFP: CC_ARM_AAPCS_VFP);
 838   case CallingConv::ARM_AAPCS:
 839     return (Return ? RetCC_ARM_AAPCS: CC_ARM_AAPCS);
 840   case CallingConv::ARM_APCS:
 841     return (Return ? RetCC_ARM_APCS: CC_ARM_APCS);
 842   }
 843 }
 844
 845 /// LowerCallResult - Lower the result values of a call into the
 846 /// appropriate copies out of appropriate physical registers.
 847 SDValue
 848 ARMTargetLowering::LowerCallResult(SDValue Chain, SDValue InFlag,
 849                                    CallingConv::ID CallConv, bool isVarArg,
 850                                    const SmallVectorImpl<ISD::InputArg> &Ins,
 851                                    DebugLoc dl, SelectionDAG &DAG,
 852                                    SmallVectorImpl<SDValue> &InVals) const {
 853
 854   // Assign locations to each value returned by this call.
 855   SmallVector<CCValAssign, 16> RVLocs;
 856   CCState CCInfo(CallConv, isVarArg, getTargetMachine(),
 857                  RVLocs, *DAG.getContext());
 858   CCInfo.AnalyzeCallResult(Ins,
 859                            CCAssignFnForNode(CallConv, /* Return*/ true,
 860                                              isVarArg));
 861
 862   // Copy all of the result registers out of their specified physreg.
 863   for (unsigned i = 0; i != RVLocs.size(); ++i) {
 864     CCValAssign VA = RVLocs[i];
 865
 866     SDValue Val;
 867     if (VA.needsCustom()) {
 868       // Handle f64 or half of a v2f64.
 869       SDValue Lo = DAG.getCopyFromReg(Chain, dl, VA.getLocReg(), MVT::i32,
 870                                       InFlag);
 871       Chain = Lo.getValue(1);
 872       InFlag = Lo.getValue(2);
 873       VA = RVLocs[++i]; // skip ahead to next loc
 874       SDValue Hi = DAG.getCopyFromReg(Chain, dl, VA.getLocReg(), MVT::i32,
 875                                       InFlag);
 876       Chain = Hi.getValue(1);
 877       InFlag = Hi.getValue(2);
 878       Val = DAG.getNode(ARMISD::VMOVDRR, dl, MVT::f64, Lo, Hi);
 879
 880       if (VA.getLocVT() == MVT::v2f64) {
 881         SDValue Vec = DAG.getNode(ISD::UNDEF, dl, MVT::v2f64);
 882         Vec = DAG.getNode(ISD::INSERT_VECTOR_ELT, dl, MVT::v2f64, Vec, Val,
 883                           DAG.getConstant(0, MVT::i32));
 884
 885         VA = RVLocs[++i]; // skip ahead to next loc
 886         Lo = DAG.getCopyFromReg(Chain, dl, VA.getLocReg(), MVT::i32, InFlag);
 887         Chain = Lo.getValue(1);
 888         InFlag = Lo.getValue(2);
 889         VA = RVLocs[++i]; // skip ahead to next loc
 890         Hi = DAG.getCopyFromReg(Chain, dl, VA.getLocReg(), MVT::i32, InFlag);
 891         Chain = Hi.getValue(1);
 892         InFlag = Hi.getValue(2);
 893         Val = DAG.getNode(ARMISD::VMOVDRR, dl, MVT::f64, Lo, Hi);
 894         Val = DAG.getNode(ISD::INSERT_VECTOR_ELT, dl, MVT::v2f64, Vec, Val,
 895                           DAG.getConstant(1, MVT::i32));
 896       }
 897     } else {
 898       Val = DAG.getCopyFromReg(Chain, dl, VA.getLocReg(), VA.getLocVT(),
 899                                InFlag);
 900       Chain = Val.getValue(1);
 901       InFlag = Val.getValue(2);
 902     }
 903
 904     switch (VA.getLocInfo()) {
 905     default: llvm_unreachable("Unknown loc info!");
 906     case CCValAssign::Full: break;
 907     case CCValAssign::BCvt:
 908       Val = DAG.getNode(ISD::BIT_CONVERT, dl, VA.getValVT(), Val);
 909       break;
 910     }
 911
 912     InVals.push_back(Val);
 913   }
 914
 915   return Chain;
 916 }
 917
 918 /// CreateCopyOfByValArgument - Make a copy of an aggregate at address specified
 919 /// by "Src" to address "Dst" of size "Size".  Alignment information is
 920 /// specified by the specific parameter attribute.  The copy will be passed as
 921 /// a byval function parameter.
 922 /// Sometimes what we are copying is the end of a larger object, the part that
 923 /// does not fit in registers.
 924 static SDValue
 925 CreateCopyOfByValArgument(SDValue Src, SDValue Dst, SDValue Chain,
 926                           ISD::ArgFlagsTy Flags, SelectionDAG &DAG,
 927                           DebugLoc dl) {
 928   SDValue SizeNode = DAG.getConstant(Flags.getByValSize(), MVT::i32);
 929   return DAG.getMemcpy(Chain, dl, Dst, Src, SizeNode, Flags.getByValAlign(),
 930                        /*isVolatile=*/false, /*AlwaysInline=*/false,
 931                        MachinePointerInfo(0), MachinePointerInfo(0));
 932 }
 933
 934 /// LowerMemOpCallTo - Store the argument to the stack.
 935 SDValue
 936 ARMTargetLowering::LowerMemOpCallTo(SDValue Chain,
 937                                     SDValue StackPtr, SDValue Arg,
 938                                     DebugLoc dl, SelectionDAG &DAG,
 939                                     const CCValAssign &VA,
 940                                     ISD::ArgFlagsTy Flags) const {
 941   unsigned LocMemOffset = VA.getLocMemOffset();
 942   SDValue PtrOff = DAG.getIntPtrConstant(LocMemOffset);
 943   PtrOff = DAG.getNode(ISD::ADD, dl, getPointerTy(), StackPtr, PtrOff);
 944   if (Flags.isByVal()) {
 945     return CreateCopyOfByValArgument(Arg, PtrOff, Chain, Flags, DAG, dl);
 946   }
 947   return DAG.getStore(Chain, dl, Arg, PtrOff,
 948                       PseudoSourceValue::getStack(), LocMemOffset,
 949                       false, false, 0);
 950 }
 951
 952 void ARMTargetLowering::PassF64ArgInRegs(DebugLoc dl, SelectionDAG &DAG,
 953                                          SDValue Chain, SDValue &Arg,
 954                                          RegsToPassVector &RegsToPass,
 955                                          CCValAssign &VA, CCValAssign &NextVA,
 956                                          SDValue &StackPtr,
 957                                          SmallVector<SDValue, 8> &MemOpChains,
 958                                          ISD::ArgFlagsTy Flags) const {
 959
 960   SDValue fmrrd = DAG.getNode(ARMISD::VMOVRRD, dl,
 961                               DAG.getVTList(MVT::i32, MVT::i32), Arg);
 962   RegsToPass.push_back(std::make_pair(VA.getLocReg(), fmrrd));
 963
 964   if (NextVA.isRegLoc())
 965     RegsToPass.push_back(std::make_pair(NextVA.getLocReg(), fmrrd.getValue(1)));
 966   else {
 967     assert(NextVA.isMemLoc());
 968     if (StackPtr.getNode() == 0)
 969       StackPtr = DAG.getCopyFromReg(Chain, dl, ARM::SP, getPointerTy());
 970
 971     MemOpChains.push_back(LowerMemOpCallTo(Chain, StackPtr, fmrrd.getValue(1),
 972                                            dl, DAG, NextVA,
 973                                            Flags));
 974   }
 975 }
 976
 977 /// LowerCall - Lowering a call into a callseq_start <-
 978 /// ARMISD:CALL <- callseq_end chain. Also add input and output parameter
 979 /// nodes.
 980 SDValue
 981 ARMTargetLowering::LowerCall(SDValue Chain, SDValue Callee,
 982                              CallingConv::ID CallConv, bool isVarArg,
 983                              bool &isTailCall,
 984                              const SmallVectorImpl<ISD::OutputArg> &Outs,
 985                              const SmallVectorImpl<SDValue> &OutVals,
 986                              const SmallVectorImpl<ISD::InputArg> &Ins,
 987                              DebugLoc dl, SelectionDAG &DAG,
 988                              SmallVectorImpl<SDValue> &InVals) const {
 989   MachineFunction &MF = DAG.getMachineFunction();
 990   bool IsStructRet    = (Outs.empty()) ? false : Outs[0].Flags.isSRet();
 991   bool IsSibCall = false;
 992   // Temporarily disable tail calls so things don't break.
 993   if (!EnableARMTailCalls)
 994     isTailCall = false;
 995   if (isTailCall) {
 996     // Check if it's really possible to do a tail call.
 997     isTailCall = IsEligibleForTailCallOptimization(Callee, CallConv,
 998                     isVarArg, IsStructRet, MF.getFunction()->hasStructRetAttr(),
 999                                                    Outs, OutVals, Ins, DAG);
1000     // We don't support GuaranteedTailCallOpt for ARM, only automatically
1001     // detected sibcalls.
1002     if (isTailCall) {
1003       ++NumTailCalls;
1004       IsSibCall = true;
1005     }
1006   }
1007
1008   // Analyze operands of the call, assigning locations to each operand.
1009   SmallVector<CCValAssign, 16> ArgLocs;
1010   CCState CCInfo(CallConv, isVarArg, getTargetMachine(), ArgLocs,
1011                  *DAG.getContext());
1012   CCInfo.AnalyzeCallOperands(Outs,
1013                              CCAssignFnForNode(CallConv, /* Return*/ false,
1014                                                isVarArg));
1015
1016   // Get a count of how many bytes are to be pushed on the stack.
1017   unsigned NumBytes = CCInfo.getNextStackOffset();
1018
1019   // For tail calls, memory operands are available in our caller's stack.
1020   if (IsSibCall)
1021     NumBytes = 0;
1022
1023   // Adjust the stack pointer for the new arguments...
1024   // These operations are automatically eliminated by the prolog/epilog pass
1025   if (!IsSibCall)
1026     Chain = DAG.getCALLSEQ_START(Chain, DAG.getIntPtrConstant(NumBytes, true));
1027
1028   SDValue StackPtr = DAG.getCopyFromReg(Chain, dl, ARM::SP, getPointerTy());
1029
1030   RegsToPassVector RegsToPass;
1031   SmallVector<SDValue, 8> MemOpChains;
1032
1033   // Walk the register/memloc assignments, inserting copies/loads.  In the case
1034   // of tail call optimization, arguments are handled later.
1035   for (unsigned i = 0, realArgIdx = 0, e = ArgLocs.size();
1036        i != e;
1037        ++i, ++realArgIdx) {
1038     CCValAssign &VA = ArgLocs[i];
1039     SDValue Arg = OutVals[realArgIdx];
1040     ISD::ArgFlagsTy Flags = Outs[realArgIdx].Flags;
1041
1042     // Promote the value if needed.
1043     switch (VA.getLocInfo()) {
1044     default: llvm_unreachable("Unknown loc info!");
1045     case CCValAssign::Full: break;
1046     case CCValAssign::SExt:
1047       Arg = DAG.getNode(ISD::SIGN_EXTEND, dl, VA.getLocVT(), Arg);
1048       break;
1049     case CCValAssign::ZExt:
1050       Arg = DAG.getNode(ISD::ZERO_EXTEND, dl, VA.getLocVT(), Arg);
1051       break;
1052     case CCValAssign::AExt:
1053       Arg = DAG.getNode(ISD::ANY_EXTEND, dl, VA.getLocVT(), Arg);
1054       break;
1055     case CCValAssign::BCvt:
1056       Arg = DAG.getNode(ISD::BIT_CONVERT, dl, VA.getLocVT(), Arg);
1057       break;
1058     }
1059
1060     // f64 and v2f64 might be passed in i32 pairs and must be split into pieces
1061     if (VA.needsCustom()) {
1062       if (VA.getLocVT() == MVT::v2f64) {
1063         SDValue Op0 = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, MVT::f64, Arg,
1064                                   DAG.getConstant(0, MVT::i32));
1065         SDValue Op1 = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, MVT::f64, Arg,
1066                                   DAG.getConstant(1, MVT::i32));
1067
1068         PassF64ArgInRegs(dl, DAG, Chain, Op0, RegsToPass,
1069                          VA, ArgLocs[++i], StackPtr, MemOpChains, Flags);
1070
1071         VA = ArgLocs[++i]; // skip ahead to next loc
1072         if (VA.isRegLoc()) {
1073           PassF64ArgInRegs(dl, DAG, Chain, Op1, RegsToPass,
1074                            VA, ArgLocs[++i], StackPtr, MemOpChains, Flags);
1075         } else {
1076           assert(VA.isMemLoc());
1077
1078           MemOpChains.push_back(LowerMemOpCallTo(Chain, StackPtr, Op1,
1079                                                  dl, DAG, VA, Flags));
1080         }
1081       } else {
1082         PassF64ArgInRegs(dl, DAG, Chain, Arg, RegsToPass, VA, ArgLocs[++i],
1083                          StackPtr, MemOpChains, Flags);
1084       }
1085     } else if (VA.isRegLoc()) {
1086       RegsToPass.push_back(std::make_pair(VA.getLocReg(), Arg));
1087     } else if (!IsSibCall) {
1088       assert(VA.isMemLoc());
1089
1090       MemOpChains.push_back(LowerMemOpCallTo(Chain, StackPtr, Arg,
1091                                              dl, DAG, VA, Flags));
1092     }
1093   }
1094
1095   if (!MemOpChains.empty())
1096     Chain = DAG.getNode(ISD::TokenFactor, dl, MVT::Other,
1097                         &MemOpChains[0], MemOpChains.size());
1098
1099   // Build a sequence of copy-to-reg nodes chained together with token chain
1100   // and flag operands which copy the outgoing args into the appropriate regs.
1101   SDValue InFlag;
1102   // Tail call byval lowering might overwrite argument registers so in case of
1103   // tail call optimization the copies to registers are lowered later.
1104   if (!isTailCall)
1105     for (unsigned i = 0, e = RegsToPass.size(); i != e; ++i) {
1106       Chain = DAG.getCopyToReg(Chain, dl, RegsToPass[i].first,
1107                                RegsToPass[i].second, InFlag);
1108       InFlag = Chain.getValue(1);
1109     }
1110
1111   // For tail calls lower the arguments to the 'real' stack slot.
1112   if (isTailCall) {
1113     // Force all the incoming stack arguments to be loaded from the stack
1114     // before any new outgoing arguments are stored to the stack, because the
1115     // outgoing stack slots may alias the incoming argument stack slots, and
1116     // the alias isn't otherwise explicit. This is slightly more conservative
1117     // than necessary, because it means that each store effectively depends
1118     // on every argument instead of just those arguments it would clobber.
1119
1120     // Do not flag preceeding copytoreg stuff together with the following stuff.
1121     InFlag = SDValue();
1122     for (unsigned i = 0, e = RegsToPass.size(); i != e; ++i) {
1123       Chain = DAG.getCopyToReg(Chain, dl, RegsToPass[i].first,
1124                                RegsToPass[i].second, InFlag);
1125       InFlag = Chain.getValue(1);
1126     }
1127     InFlag =SDValue();
1128   }
1129
1130   // If the callee is a GlobalAddress/ExternalSymbol node (quite common, every
1131   // direct call is) turn it into a TargetGlobalAddress/TargetExternalSymbol
1132   // node so that legalize doesn't hack it.
1133   bool isDirect = false;
1134   bool isARMFunc = false;
1135   bool isLocalARMFunc = false;
1136   ARMFunctionInfo *AFI = MF.getInfo<ARMFunctionInfo>();
1137
1138   if (EnableARMLongCalls) {
1139     assert (getTargetMachine().getRelocationModel() == Reloc::Static
1140             && "long-calls with non-static relocation model!");
1141     // Handle a global address or an external symbol. If it's not one of
1142     // those, the target's already in a register, so we don't need to do
1143     // anything extra.
1144     if (GlobalAddressSDNode *G = dyn_cast<GlobalAddressSDNode>(Callee)) {
1145       const GlobalValue *GV = G->getGlobal();
1146       // Create a constant pool entry for the callee address
1147       unsigned ARMPCLabelIndex = AFI->createConstPoolEntryUId();
1148       ARMConstantPoolValue *CPV = new ARMConstantPoolValue(GV,
1149                                                            ARMPCLabelIndex,
1150                                                            ARMCP::CPValue, 0);
1151       // Get the address of the callee into a register
1152       SDValue CPAddr = DAG.getTargetConstantPool(CPV, getPointerTy(), 4);
1153       CPAddr = DAG.getNode(ARMISD::Wrapper, dl, MVT::i32, CPAddr);
1154       Callee = DAG.getLoad(getPointerTy(), dl,
1155                            DAG.getEntryNode(), CPAddr,
1156                            MachinePointerInfo::getConstantPool(),
1157                            false, false, 0);
1158     } else if (ExternalSymbolSDNode *S=dyn_cast<ExternalSymbolSDNode>(Callee)) {
1159       const char *Sym = S->getSymbol();
1160
1161       // Create a constant pool entry for the callee address
1162       unsigned ARMPCLabelIndex = AFI->createConstPoolEntryUId();
1163       ARMConstantPoolValue *CPV = new ARMConstantPoolValue(*DAG.getContext(),
1164                                                        Sym, ARMPCLabelIndex, 0);
1165       // Get the address of the callee into a register
1166       SDValue CPAddr = DAG.getTargetConstantPool(CPV, getPointerTy(), 4);
1167       CPAddr = DAG.getNode(ARMISD::Wrapper, dl, MVT::i32, CPAddr);
1168       Callee = DAG.getLoad(getPointerTy(), dl,
1169                            DAG.getEntryNode(), CPAddr,
1170                            MachinePointerInfo::getConstantPool(),
1171                            false, false, 0);
1172     }
1173   } else if (GlobalAddressSDNode *G = dyn_cast<GlobalAddressSDNode>(Callee)) {
1174     const GlobalValue *GV = G->getGlobal();
1175     isDirect = true;
1176     bool isExt = GV->isDeclaration() || GV->isWeakForLinker();
1177     bool isStub = (isExt && Subtarget->isTargetDarwin()) &&
1178                    getTargetMachine().getRelocationModel() != Reloc::Static;
1179     isARMFunc = !Subtarget->isThumb() || isStub;
1180     // ARM call to a local ARM function is predicable.
1181     isLocalARMFunc = !Subtarget->isThumb() && (!isExt || !ARMInterworking);
1182     // tBX takes a register source operand.
1183     if (isARMFunc && Subtarget->isThumb1Only() && !Subtarget->hasV5TOps()) {
1184       unsigned ARMPCLabelIndex = AFI->createConstPoolEntryUId();
1185       ARMConstantPoolValue *CPV = new ARMConstantPoolValue(GV,
1186                                                            ARMPCLabelIndex,
1187                                                            ARMCP::CPValue, 4);
1188       SDValue CPAddr = DAG.getTargetConstantPool(CPV, getPointerTy(), 4);
1189       CPAddr = DAG.getNode(ARMISD::Wrapper, dl, MVT::i32, CPAddr);
1190       Callee = DAG.getLoad(getPointerTy(), dl,
1191                            DAG.getEntryNode(), CPAddr,
1192                            MachinePointerInfo::getConstantPool(),
1193                            false, false, 0);
1194       SDValue PICLabel = DAG.getConstant(ARMPCLabelIndex, MVT::i32);
1195       Callee = DAG.getNode(ARMISD::PIC_ADD, dl,
1196                            getPointerTy(), Callee, PICLabel);
1197     } else
1198       Callee = DAG.getTargetGlobalAddress(GV, dl, getPointerTy());
1199   } else if (ExternalSymbolSDNode *S = dyn_cast<ExternalSymbolSDNode>(Callee)) {
1200     isDirect = true;
1201     bool isStub = Subtarget->isTargetDarwin() &&
1202                   getTargetMachine().getRelocationModel() != Reloc::Static;
1203     isARMFunc = !Subtarget->isThumb() || isStub;
1204     // tBX takes a register source operand.
1205     const char *Sym = S->getSymbol();
1206     if (isARMFunc && Subtarget->isThumb1Only() && !Subtarget->hasV5TOps()) {
1207       unsigned ARMPCLabelIndex = AFI->createConstPoolEntryUId();
1208       ARMConstantPoolValue *CPV = new ARMConstantPoolValue(*DAG.getContext(),
1209                                                        Sym, ARMPCLabelIndex, 4);
1210       SDValue CPAddr = DAG.getTargetConstantPool(CPV, getPointerTy(), 4);
1211       CPAddr = DAG.getNode(ARMISD::Wrapper, dl, MVT::i32, CPAddr);
1212       Callee = DAG.getLoad(getPointerTy(), dl,
1213                            DAG.getEntryNode(), CPAddr,
1214                            MachinePointerInfo::getConstantPool(),
1215                            false, false, 0);
1216       SDValue PICLabel = DAG.getConstant(ARMPCLabelIndex, MVT::i32);
1217       Callee = DAG.getNode(ARMISD::PIC_ADD, dl,
1218                            getPointerTy(), Callee, PICLabel);
1219     } else
1220       Callee = DAG.getTargetExternalSymbol(Sym, getPointerTy());
1221   }
1222
1223   // FIXME: handle tail calls differently.
1224   unsigned CallOpc;
1225   if (Subtarget->isThumb()) {
1226     if ((!isDirect || isARMFunc) && !Subtarget->hasV5TOps())
1227       CallOpc = ARMISD::CALL_NOLINK;
1228     else
1229       CallOpc = isARMFunc ? ARMISD::CALL : ARMISD::tCALL;
1230   } else {
1231     CallOpc = (isDirect || Subtarget->hasV5TOps())
1232       ? (isLocalARMFunc ? ARMISD::CALL_PRED : ARMISD::CALL)
1233       : ARMISD::CALL_NOLINK;
1234   }
1235
1236   std::vector<SDValue> Ops;
1237   Ops.push_back(Chain);
1238   Ops.push_back(Callee);
1239
1240   // Add argument registers to the end of the list so that they are known live
1241   // into the call.
1242   for (unsigned i = 0, e = RegsToPass.size(); i != e; ++i)
1243     Ops.push_back(DAG.getRegister(RegsToPass[i].first,
1244                                   RegsToPass[i].second.getValueType()));
1245
1246   if (InFlag.getNode())
1247     Ops.push_back(InFlag);
1248
1249   SDVTList NodeTys = DAG.getVTList(MVT::Other, MVT::Flag);
1250   if (isTailCall)
1251     return DAG.getNode(ARMISD::TC_RETURN, dl, NodeTys, &Ops[0], Ops.size());
1252
1253   // Returns a chain and a flag for retval copy to use.
1254   Chain = DAG.getNode(CallOpc, dl, NodeTys, &Ops[0], Ops.size());
1255   InFlag = Chain.getValue(1);
1256
1257   Chain = DAG.getCALLSEQ_END(Chain, DAG.getIntPtrConstant(NumBytes, true),
1258                              DAG.getIntPtrConstant(0, true), InFlag);
1259   if (!Ins.empty())
1260     InFlag = Chain.getValue(1);
1261
1262   // Handle result values, copying them out of physregs into vregs that we
1263   // return.
1264   return LowerCallResult(Chain, InFlag, CallConv, isVarArg, Ins,
1265                          dl, DAG, InVals);
1266 }
1267
1268 /// MatchingStackOffset - Return true if the given stack call argument is
1269 /// already available in the same position (relatively) of the caller's
1270 /// incoming argument stack.
1271 static
1272 bool MatchingStackOffset(SDValue Arg, unsigned Offset, ISD::ArgFlagsTy Flags,
1273                          MachineFrameInfo *MFI, const MachineRegisterInfo *MRI,
1274                          const ARMInstrInfo *TII) {
1275   unsigned Bytes = Arg.getValueType().getSizeInBits() / 8;
1276   int FI = INT_MAX;
1277   if (Arg.getOpcode() == ISD::CopyFromReg) {
1278     unsigned VR = cast<RegisterSDNode>(Arg.getOperand(1))->getReg();
1279     if (!VR || TargetRegisterInfo::isPhysicalRegister(VR))
1280       return false;
1281     MachineInstr *Def = MRI->getVRegDef(VR);
1282     if (!Def)
1283       return false;
1284     if (!Flags.isByVal()) {
1285       if (!TII->isLoadFromStackSlot(Def, FI))
1286         return false;
1287     } else {
1288       return false;
1289     }
1290   } else if (LoadSDNode *Ld = dyn_cast<LoadSDNode>(Arg)) {
1291     if (Flags.isByVal())
1292       // ByVal argument is passed in as a pointer but it's now being
1293       // dereferenced. e.g.
1294       // define @foo(%struct.X* %A) {
1295       //   tail call @bar(%struct.X* byval %A)
1296       // }
1297       return false;
1298     SDValue Ptr = Ld->getBasePtr();
1299     FrameIndexSDNode *FINode = dyn_cast<FrameIndexSDNode>(Ptr);
1300     if (!FINode)
1301       return false;
1302     FI = FINode->getIndex();
1303   } else
1304     return false;
1305
1306   assert(FI != INT_MAX);
1307   if (!MFI->isFixedObjectIndex(FI))
1308     return false;
1309   return Offset == MFI->getObjectOffset(FI) && Bytes == MFI->getObjectSize(FI);
1310 }
1311
1312 /// IsEligibleForTailCallOptimization - Check whether the call is eligible
1313 /// for tail call optimization. Targets which want to do tail call
1314 /// optimization should implement this function.
1315 bool
1316 ARMTargetLowering::IsEligibleForTailCallOptimization(SDValue Callee,
1317                                                      CallingConv::ID CalleeCC,
1318                                                      bool isVarArg,
1319                                                      bool isCalleeStructRet,
1320                                                      bool isCallerStructRet,
1321                                     const SmallVectorImpl<ISD::OutputArg> &Outs,
1322                                     const SmallVectorImpl<SDValue> &OutVals,
1323                                     const SmallVectorImpl<ISD::InputArg> &Ins,
1324                                                      SelectionDAG& DAG) const {
1325   const Function *CallerF = DAG.getMachineFunction().getFunction();
1326   CallingConv::ID CallerCC = CallerF->getCallingConv();
1327   bool CCMatch = CallerCC == CalleeCC;
1328
1329   // Look for obvious safe cases to perform tail call optimization that do not
1330   // require ABI changes. This is what gcc calls sibcall.
1331
1332   // Do not sibcall optimize vararg calls unless the call site is not passing
1333   // any arguments.
1334   if (isVarArg && !Outs.empty())
1335     return false;
1336
1337   // Also avoid sibcall optimization if either caller or callee uses struct
1338   // return semantics.
1339   if (isCalleeStructRet || isCallerStructRet)
1340     return false;
1341
1342   // FIXME: Completely disable sibcall for Thumb1 since Thumb1RegisterInfo::
1343   // emitEpilogue is not ready for them.
1344   // Doing this is tricky, since the LDM/POP instruction on Thumb doesn't take
1345   // LR.  This means if we need to reload LR, it takes an extra instructions,
1346   // which outweighs the value of the tail call; but here we don't know yet
1347   // whether LR is going to be used.  Probably the right approach is to
1348   // generate the tail call here and turn it back into CALL/RET in
1349   // emitEpilogue if LR is used.
1350   if (Subtarget->isThumb1Only())
1351     return false;
1352
1353   // For the moment, we can only do this to functions defined in this
1354   // compilation, or to indirect calls.  A Thumb B to an ARM function,
1355   // or vice versa, is not easily fixed up in the linker unlike BL.
1356   // (We could do this by loading the address of the callee into a register;
1357   // that is an extra instruction over the direct call and burns a register
1358   // as well, so is not likely to be a win.)
1359
1360   // It might be safe to remove this restriction on non-Darwin.
1361
1362   // Thumb1 PIC calls to external symbols use BX, so they can be tail calls,
1363   // but we need to make sure there are enough registers; the only valid
1364   // registers are the 4 used for parameters.  We don't currently do this
1365   // case.
1366   if (isa<ExternalSymbolSDNode>(Callee))
1367       return false;
1368
1369   if (GlobalAddressSDNode *G = dyn_cast<GlobalAddressSDNode>(Callee)) {
1370     const GlobalValue *GV = G->getGlobal();
1371     if (GV->isDeclaration() || GV->isWeakForLinker())
1372       return false;
1373   }
1374
1375   // If the calling conventions do not match, then we'd better make sure the
1376   // results are returned in the same way as what the caller expects.
1377   if (!CCMatch) {
1378     SmallVector<CCValAssign, 16> RVLocs1;
1379     CCState CCInfo1(CalleeCC, false, getTargetMachine(),
1380                     RVLocs1, *DAG.getContext());
1381     CCInfo1.AnalyzeCallResult(Ins, CCAssignFnForNode(CalleeCC, true, isVarArg));
1382
1383     SmallVector<CCValAssign, 16> RVLocs2;
1384     CCState CCInfo2(CallerCC, false, getTargetMachine(),
1385                     RVLocs2, *DAG.getContext());
1386     CCInfo2.AnalyzeCallResult(Ins, CCAssignFnForNode(CallerCC, true, isVarArg));
1387
1388     if (RVLocs1.size() != RVLocs2.size())
1389       return false;
1390     for (unsigned i = 0, e = RVLocs1.size(); i != e; ++i) {
1391       if (RVLocs1[i].isRegLoc() != RVLocs2[i].isRegLoc())
1392         return false;
1393       if (RVLocs1[i].getLocInfo() != RVLocs2[i].getLocInfo())
1394         return false;
1395       if (RVLocs1[i].isRegLoc()) {
1396         if (RVLocs1[i].getLocReg() != RVLocs2[i].getLocReg())
1397           return false;
1398       } else {
1399         if (RVLocs1[i].getLocMemOffset() != RVLocs2[i].getLocMemOffset())
1400           return false;
1401       }
1402     }
1403   }
1404
1405   // If the callee takes no arguments then go on to check the results of the
1406   // call.
1407   if (!Outs.empty()) {
1408     // Check if stack adjustment is needed. For now, do not do this if any
1409     // argument is passed on the stack.
1410     SmallVector<CCValAssign, 16> ArgLocs;
1411     CCState CCInfo(CalleeCC, isVarArg, getTargetMachine(),
1412                    ArgLocs, *DAG.getContext());
1413     CCInfo.AnalyzeCallOperands(Outs,
1414                                CCAssignFnForNode(CalleeCC, false, isVarArg));
1415     if (CCInfo.getNextStackOffset()) {
1416       MachineFunction &MF = DAG.getMachineFunction();
1417
1418       // Check if the arguments are already laid out in the right way as
1419       // the caller's fixed stack objects.
1420       MachineFrameInfo *MFI = MF.getFrameInfo();
1421       const MachineRegisterInfo *MRI = &MF.getRegInfo();
1422       const ARMInstrInfo *TII =
1423         ((ARMTargetMachine&)getTargetMachine()).getInstrInfo();
1424       for (unsigned i = 0, realArgIdx = 0, e = ArgLocs.size();
1425            i != e;
1426            ++i, ++realArgIdx) {
1427         CCValAssign &VA = ArgLocs[i];
1428         EVT RegVT = VA.getLocVT();
1429         SDValue Arg = OutVals[realArgIdx];
1430         ISD::ArgFlagsTy Flags = Outs[realArgIdx].Flags;
1431         if (VA.getLocInfo() == CCValAssign::Indirect)
1432           return false;
1433         if (VA.needsCustom()) {
1434           // f64 and vector types are split into multiple registers or
1435           // register/stack-slot combinations.  The types will not match
1436           // the registers; give up on memory f64 refs until we figure
1437           // out what to do about this.
1438           if (!VA.isRegLoc())
1439             return false;
1440           if (!ArgLocs[++i].isRegLoc())
1441             return false;
1442           if (RegVT == MVT::v2f64) {
1443             if (!ArgLocs[++i].isRegLoc())
1444               return false;
1445             if (!ArgLocs[++i].isRegLoc())
1446               return false;
1447           }
1448         } else if (!VA.isRegLoc()) {
1449           if (!MatchingStackOffset(Arg, VA.getLocMemOffset(), Flags,
1450                                    MFI, MRI, TII))
1451             return false;
1452         }
1453       }
1454     }
1455   }
1456
1457   return true;
1458 }
1459
1460 SDValue
1461 ARMTargetLowering::LowerReturn(SDValue Chain,
1462                                CallingConv::ID CallConv, bool isVarArg,
1463                                const SmallVectorImpl<ISD::OutputArg> &Outs,
1464                                const SmallVectorImpl<SDValue> &OutVals,
1465                                DebugLoc dl, SelectionDAG &DAG) const {
1466
1467   // CCValAssign - represent the assignment of the return value to a location.
1468   SmallVector<CCValAssign, 16> RVLocs;
1469
1470   // CCState - Info about the registers and stack slots.
1471   CCState CCInfo(CallConv, isVarArg, getTargetMachine(), RVLocs,
1472                  *DAG.getContext());
1473
1474   // Analyze outgoing return values.
1475   CCInfo.AnalyzeReturn(Outs, CCAssignFnForNode(CallConv, /* Return */ true,
1476                                                isVarArg));
1477
1478   // If this is the first return lowered for this function, add
1479   // the regs to the liveout set for the function.
1480   if (DAG.getMachineFunction().getRegInfo().liveout_empty()) {
1481     for (unsigned i = 0; i != RVLocs.size(); ++i)
1482       if (RVLocs[i].isRegLoc())
1483         DAG.getMachineFunction().getRegInfo().addLiveOut(RVLocs[i].getLocReg());
1484   }
1485
1486   SDValue Flag;
1487
1488   // Copy the result values into the output registers.
1489   for (unsigned i = 0, realRVLocIdx = 0;
1490        i != RVLocs.size();
1491        ++i, ++realRVLocIdx) {
1492     CCValAssign &VA = RVLocs[i];
1493     assert(VA.isRegLoc() && "Can only return in registers!");
1494
1495     SDValue Arg = OutVals[realRVLocIdx];
1496
1497     switch (VA.getLocInfo()) {
1498     default: llvm_unreachable("Unknown loc info!");
1499     case CCValAssign::Full: break;
1500     case CCValAssign::BCvt:
1501       Arg = DAG.getNode(ISD::BIT_CONVERT, dl, VA.getLocVT(), Arg);
1502       break;
1503     }
1504
1505     if (VA.needsCustom()) {
1506       if (VA.getLocVT() == MVT::v2f64) {
1507         // Extract the first half and return it in two registers.
1508         SDValue Half = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, MVT::f64, Arg,
1509                                    DAG.getConstant(0, MVT::i32));
1510         SDValue HalfGPRs = DAG.getNode(ARMISD::VMOVRRD, dl,
1511                                        DAG.getVTList(MVT::i32, MVT::i32), Half);
1512
1513         Chain = DAG.getCopyToReg(Chain, dl, VA.getLocReg(), HalfGPRs, Flag);
1514         Flag = Chain.getValue(1);
1515         VA = RVLocs[++i]; // skip ahead to next loc
1516         Chain = DAG.getCopyToReg(Chain, dl, VA.getLocReg(),
1517                                  HalfGPRs.getValue(1), Flag);
1518         Flag = Chain.getValue(1);
1519         VA = RVLocs[++i]; // skip ahead to next loc
1520
1521         // Extract the 2nd half and fall through to handle it as an f64 value.
1522         Arg = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, MVT::f64, Arg,
1523                           DAG.getConstant(1, MVT::i32));
1524       }
1525       // Legalize ret f64 -> ret 2 x i32.  We always have fmrrd if f64 is
1526       // available.
1527       SDValue fmrrd = DAG.getNode(ARMISD::VMOVRRD, dl,
1528                                   DAG.getVTList(MVT::i32, MVT::i32), &Arg, 1);
1529       Chain = DAG.getCopyToReg(Chain, dl, VA.getLocReg(), fmrrd, Flag);
1530       Flag = Chain.getValue(1);
1531       VA = RVLocs[++i]; // skip ahead to next loc
1532       Chain = DAG.getCopyToReg(Chain, dl, VA.getLocReg(), fmrrd.getValue(1),
1533                                Flag);
1534     } else
1535       Chain = DAG.getCopyToReg(Chain, dl, VA.getLocReg(), Arg, Flag);
1536
1537     // Guarantee that all emitted copies are
1538     // stuck together, avoiding something bad.
1539     Flag = Chain.getValue(1);
1540   }
1541
1542   SDValue result;
1543   if (Flag.getNode())
1544     result = DAG.getNode(ARMISD::RET_FLAG, dl, MVT::Other, Chain, Flag);
1545   else // Return Void
1546     result = DAG.getNode(ARMISD::RET_FLAG, dl, MVT::Other, Chain);
1547
1548   return result;
1549 }
1550
1551 // ConstantPool, JumpTable, GlobalAddress, and ExternalSymbol are lowered as
1552 // their target counterpart wrapped in the ARMISD::Wrapper node. Suppose N is
1553 // one of the above mentioned nodes. It has to be wrapped because otherwise
1554 // Select(N) returns N. So the raw TargetGlobalAddress nodes, etc. can only
1555 // be used to form addressing mode. These wrapped nodes will be selected
1556 // into MOVi.
1557 static SDValue LowerConstantPool(SDValue Op, SelectionDAG &DAG) {
1558   EVT PtrVT = Op.getValueType();
1559   // FIXME there is no actual debug info here
1560   DebugLoc dl = Op.getDebugLoc();
1561   ConstantPoolSDNode *CP = cast<ConstantPoolSDNode>(Op);
1562   SDValue Res;
1563   if (CP->isMachineConstantPoolEntry())
1564     Res = DAG.getTargetConstantPool(CP->getMachineCPVal(), PtrVT,
1565                                     CP->getAlignment());
1566   else
1567     Res = DAG.getTargetConstantPool(CP->getConstVal(), PtrVT,
1568                                     CP->getAlignment());
1569   return DAG.getNode(ARMISD::Wrapper, dl, MVT::i32, Res);
1570 }
1571
1572 unsigned ARMTargetLowering::getJumpTableEncoding() const {
1573   return MachineJumpTableInfo::EK_Inline;
1574 }
1575
1576 SDValue ARMTargetLowering::LowerBlockAddress(SDValue Op,
1577                                              SelectionDAG &DAG) const {
1578   MachineFunction &MF = DAG.getMachineFunction();
1579   ARMFunctionInfo *AFI = MF.getInfo<ARMFunctionInfo>();
1580   unsigned ARMPCLabelIndex = 0;
1581   DebugLoc DL = Op.getDebugLoc();
1582   EVT PtrVT = getPointerTy();
1583   const BlockAddress *BA = cast<BlockAddressSDNode>(Op)->getBlockAddress();
1584   Reloc::Model RelocM = getTargetMachine().getRelocationModel();
1585   SDValue CPAddr;
1586   if (RelocM == Reloc::Static) {
1587     CPAddr = DAG.getTargetConstantPool(BA, PtrVT, 4);
1588   } else {
1589     unsigned PCAdj = Subtarget->isThumb() ? 4 : 8;
1590     ARMPCLabelIndex = AFI->createConstPoolEntryUId();
1591     ARMConstantPoolValue *CPV = new ARMConstantPoolValue(BA, ARMPCLabelIndex,
1592                                                          ARMCP::CPBlockAddress,
1593                                                          PCAdj);
1594     CPAddr = DAG.getTargetConstantPool(CPV, PtrVT, 4);
1595   }
1596   CPAddr = DAG.getNode(ARMISD::Wrapper, DL, PtrVT, CPAddr);
1597   SDValue Result = DAG.getLoad(PtrVT, DL, DAG.getEntryNode(), CPAddr,
1598                                MachinePointerInfo::getConstantPool(),
1599                                false, false, 0);
1600   if (RelocM == Reloc::Static)
1601     return Result;
1602   SDValue PICLabel = DAG.getConstant(ARMPCLabelIndex, MVT::i32);
1603   return DAG.getNode(ARMISD::PIC_ADD, DL, PtrVT, Result, PICLabel);
1604 }
1605
1606 // Lower ISD::GlobalTLSAddress using the "general dynamic" model
1607 SDValue
1608 ARMTargetLowering::LowerToTLSGeneralDynamicModel(GlobalAddressSDNode *GA,
1609                                                  SelectionDAG &DAG) const {
1610   DebugLoc dl = GA->getDebugLoc();
1611   EVT PtrVT = getPointerTy();
1612   unsigned char PCAdj = Subtarget->isThumb() ? 4 : 8;
1613   MachineFunction &MF = DAG.getMachineFunction();
1614   ARMFunctionInfo *AFI = MF.getInfo<ARMFunctionInfo>();
1615   unsigned ARMPCLabelIndex = AFI->createConstPoolEntryUId();
1616   ARMConstantPoolValue *CPV =
1617     new ARMConstantPoolValue(GA->getGlobal(), ARMPCLabelIndex,
1618                              ARMCP::CPValue, PCAdj, "tlsgd", true);
1619   SDValue Argument = DAG.getTargetConstantPool(CPV, PtrVT, 4);
1620   Argument = DAG.getNode(ARMISD::Wrapper, dl, MVT::i32, Argument);
1621   Argument = DAG.getLoad(PtrVT, dl, DAG.getEntryNode(), Argument,
1622                          MachinePointerInfo::getConstantPool(),
1623                          false, false, 0);
1624   SDValue Chain = Argument.getValue(1);
1625
1626   SDValue PICLabel = DAG.getConstant(ARMPCLabelIndex, MVT::i32);
1627   Argument = DAG.getNode(ARMISD::PIC_ADD, dl, PtrVT, Argument, PICLabel);
1628
1629   // call __tls_get_addr.
1630   ArgListTy Args;
1631   ArgListEntry Entry;
1632   Entry.Node = Argument;
1633   Entry.Ty = (const Type *) Type::getInt32Ty(*DAG.getContext());
1634   Args.push_back(Entry);
1635   // FIXME: is there useful debug info available here?
1636   std::pair<SDValue, SDValue> CallResult =
1637     LowerCallTo(Chain, (const Type *) Type::getInt32Ty(*DAG.getContext()),
1638                 false, false, false, false,
1639                 0, CallingConv::C, false, /*isReturnValueUsed=*/true,
1640                 DAG.getExternalSymbol("__tls_get_addr", PtrVT), Args, DAG, dl);
1641   return CallResult.first;
1642 }
1643
1644 // Lower ISD::GlobalTLSAddress using the "initial exec" or
1645 // "local exec" model.
1646 SDValue
1647 ARMTargetLowering::LowerToTLSExecModels(GlobalAddressSDNode *GA,
1648                                         SelectionDAG &DAG) const {
1649   const GlobalValue *GV = GA->getGlobal();
1650   DebugLoc dl = GA->getDebugLoc();
1651   SDValue Offset;
1652   SDValue Chain = DAG.getEntryNode();
1653   EVT PtrVT = getPointerTy();
1654   // Get the Thread Pointer
1655   SDValue ThreadPointer = DAG.getNode(ARMISD::THREAD_POINTER, dl, PtrVT);
1656
1657   if (GV->isDeclaration()) {
1658     MachineFunction &MF = DAG.getMachineFunction();
1659     ARMFunctionInfo *AFI = MF.getInfo<ARMFunctionInfo>();
1660     unsigned ARMPCLabelIndex = AFI->createConstPoolEntryUId();
1661     // Initial exec model.
1662     unsigned char PCAdj = Subtarget->isThumb() ? 4 : 8;
1663     ARMConstantPoolValue *CPV =
1664       new ARMConstantPoolValue(GA->getGlobal(), ARMPCLabelIndex,
1665                                ARMCP::CPValue, PCAdj, "gottpoff", true);
1666     Offset = DAG.getTargetConstantPool(CPV, PtrVT, 4);
1667     Offset = DAG.getNode(ARMISD::Wrapper, dl, MVT::i32, Offset);
1668     Offset = DAG.getLoad(PtrVT, dl, Chain, Offset,
1669                          MachinePointerInfo::getConstantPool(),
1670                          false, false, 0);
1671     Chain = Offset.getValue(1);
1672
1673     SDValue PICLabel = DAG.getConstant(ARMPCLabelIndex, MVT::i32);
1674     Offset = DAG.getNode(ARMISD::PIC_ADD, dl, PtrVT, Offset, PICLabel);
1675
1676     Offset = DAG.getLoad(PtrVT, dl, Chain, Offset,
1677                          MachinePointerInfo::getConstantPool(),
1678                          false, false, 0);
1679   } else {
1680     // local exec model
1681     ARMConstantPoolValue *CPV = new ARMConstantPoolValue(GV, "tpoff");
1682     Offset = DAG.getTargetConstantPool(CPV, PtrVT, 4);
1683     Offset = DAG.getNode(ARMISD::Wrapper, dl, MVT::i32, Offset);
1684     Offset = DAG.getLoad(PtrVT, dl, Chain, Offset,
1685                          MachinePointerInfo::getConstantPool(),
1686                          false, false, 0);
1687   }
1688
1689   // The address of the thread local variable is the add of the thread
1690   // pointer with the offset of the variable.
1691   return DAG.getNode(ISD::ADD, dl, PtrVT, ThreadPointer, Offset);
1692 }
1693
1694 SDValue
1695 ARMTargetLowering::LowerGlobalTLSAddress(SDValue Op, SelectionDAG &DAG) const {
1696   // TODO: implement the "local dynamic" model
1697   assert(Subtarget->isTargetELF() &&
1698          "TLS not implemented for non-ELF targets");
1699   GlobalAddressSDNode *GA = cast<GlobalAddressSDNode>(Op);
1700   // If the relocation model is PIC, use the "General Dynamic" TLS Model,
1701   // otherwise use the "Local Exec" TLS Model
1702   if (getTargetMachine().getRelocationModel() == Reloc::PIC_)
1703     return LowerToTLSGeneralDynamicModel(GA, DAG);
1704   else
1705     return LowerToTLSExecModels(GA, DAG);
1706 }
1707
1708 SDValue ARMTargetLowering::LowerGlobalAddressELF(SDValue Op,
1709                                                  SelectionDAG &DAG) const {
1710   EVT PtrVT = getPointerTy();
1711   DebugLoc dl = Op.getDebugLoc();
1712   const GlobalValue *GV = cast<GlobalAddressSDNode>(Op)->getGlobal();
1713   Reloc::Model RelocM = getTargetMachine().getRelocationModel();
1714   if (RelocM == Reloc::PIC_) {
1715     bool UseGOTOFF = GV->hasLocalLinkage() || GV->hasHiddenVisibility();
1716     ARMConstantPoolValue *CPV =
1717       new ARMConstantPoolValue(GV, UseGOTOFF ? "GOTOFF" : "GOT");
1718     SDValue CPAddr = DAG.getTargetConstantPool(CPV, PtrVT, 4);
1719     CPAddr = DAG.getNode(ARMISD::Wrapper, dl, MVT::i32, CPAddr);
1720     SDValue Result = DAG.getLoad(PtrVT, dl, DAG.getEntryNode(),
1721                                  CPAddr,
1722                                  MachinePointerInfo::getConstantPool(),
1723                                  false, false, 0);
1724     SDValue Chain = Result.getValue(1);
1725     SDValue GOT = DAG.getGLOBAL_OFFSET_TABLE(PtrVT);
1726     Result = DAG.getNode(ISD::ADD, dl, PtrVT, Result, GOT);
1727     if (!UseGOTOFF)
1728       Result = DAG.getLoad(PtrVT, dl, Chain, Result,
1729                            MachinePointerInfo::getGOT(), false, false, 0);
1730     return Result;
1731   } else {
1732     // If we have T2 ops, we can materialize the address directly via movt/movw
1733     // pair. This is always cheaper.
1734     if (Subtarget->useMovt()) {
1735       return DAG.getNode(ARMISD::Wrapper, dl, PtrVT,
1736                          DAG.getTargetGlobalAddress(GV, dl, PtrVT));
1737     } else {
1738       SDValue CPAddr = DAG.getTargetConstantPool(GV, PtrVT, 4);
1739       CPAddr = DAG.getNode(ARMISD::Wrapper, dl, MVT::i32, CPAddr);
1740       return DAG.getLoad(PtrVT, dl, DAG.getEntryNode(), CPAddr,
1741                          MachinePointerInfo::getConstantPool(),
1742                          false, false, 0);
1743     }
1744   }
1745 }
1746
1747 SDValue ARMTargetLowering::LowerGlobalAddressDarwin(SDValue Op,
1748                                                     SelectionDAG &DAG) const {
1749   MachineFunction &MF = DAG.getMachineFunction();
1750   ARMFunctionInfo *AFI = MF.getInfo<ARMFunctionInfo>();
1751   unsigned ARMPCLabelIndex = 0;
1752   EVT PtrVT = getPointerTy();
1753   DebugLoc dl = Op.getDebugLoc();
1754   const GlobalValue *GV = cast<GlobalAddressSDNode>(Op)->getGlobal();
1755   Reloc::Model RelocM = getTargetMachine().getRelocationModel();
1756   SDValue CPAddr;
1757   if (RelocM == Reloc::Static)
1758     CPAddr = DAG.getTargetConstantPool(GV, PtrVT, 4);
1759   else {
1760     ARMPCLabelIndex = AFI->createConstPoolEntryUId();
1761     unsigned PCAdj = (RelocM != Reloc::PIC_) ? 0 : (Subtarget->isThumb()?4:8);
1762     ARMConstantPoolValue *CPV =
1763       new ARMConstantPoolValue(GV, ARMPCLabelIndex, ARMCP::CPValue, PCAdj);
1764     CPAddr = DAG.getTargetConstantPool(CPV, PtrVT, 4);
1765   }
1766   CPAddr = DAG.getNode(ARMISD::Wrapper, dl, MVT::i32, CPAddr);
1767
1768   SDValue Result = DAG.getLoad(PtrVT, dl, DAG.getEntryNode(), CPAddr,
1769                                MachinePointerInfo::getConstantPool(),
1770                                false, false, 0);
1771   SDValue Chain = Result.getValue(1);
1772
1773   if (RelocM == Reloc::PIC_) {
1774     SDValue PICLabel = DAG.getConstant(ARMPCLabelIndex, MVT::i32);
1775     Result = DAG.getNode(ARMISD::PIC_ADD, dl, PtrVT, Result, PICLabel);
1776   }
1777
1778   if (Subtarget->GVIsIndirectSymbol(GV, RelocM))
1779     Result = DAG.getLoad(PtrVT, dl, Chain, Result, MachinePointerInfo::getGOT(),
1780                          false, false, 0);
1781
1782   return Result;
1783 }
1784
1785 SDValue ARMTargetLowering::LowerGLOBAL_OFFSET_TABLE(SDValue Op,
1786                                                     SelectionDAG &DAG) const {
1787   assert(Subtarget->isTargetELF() &&
1788          "GLOBAL OFFSET TABLE not implemented for non-ELF targets");
1789   MachineFunction &MF = DAG.getMachineFunction();
1790   ARMFunctionInfo *AFI = MF.getInfo<ARMFunctionInfo>();
1791   unsigned ARMPCLabelIndex = AFI->createConstPoolEntryUId();
1792   EVT PtrVT = getPointerTy();
1793   DebugLoc dl = Op.getDebugLoc();
1794   unsigned PCAdj = Subtarget->isThumb() ? 4 : 8;
1795   ARMConstantPoolValue *CPV = new ARMConstantPoolValue(*DAG.getContext(),
1796                                                        "_GLOBAL_OFFSET_TABLE_",
1797                                                        ARMPCLabelIndex, PCAdj);
1798   SDValue CPAddr = DAG.getTargetConstantPool(CPV, PtrVT, 4);
1799   CPAddr = DAG.getNode(ARMISD::Wrapper, dl, MVT::i32, CPAddr);
1800   SDValue Result = DAG.getLoad(PtrVT, dl, DAG.getEntryNode(), CPAddr,
1801                                MachinePointerInfo::getConstantPool(),
1802                                false, false, 0);
1803   SDValue PICLabel = DAG.getConstant(ARMPCLabelIndex, MVT::i32);
1804   return DAG.getNode(ARMISD::PIC_ADD, dl, PtrVT, Result, PICLabel);
1805 }
1806
1807 SDValue
1808 ARMTargetLowering::LowerEH_SJLJ_SETJMP(SDValue Op, SelectionDAG &DAG) const {
1809   DebugLoc dl = Op.getDebugLoc();
1810   SDValue Val = DAG.getConstant(0, MVT::i32);
1811   return DAG.getNode(ARMISD::EH_SJLJ_SETJMP, dl, MVT::i32, Op.getOperand(0),
1812                      Op.getOperand(1), Val);
1813 }
1814
1815 SDValue
1816 ARMTargetLowering::LowerEH_SJLJ_LONGJMP(SDValue Op, SelectionDAG &DAG) const {
1817   DebugLoc dl = Op.getDebugLoc();
1818   return DAG.getNode(ARMISD::EH_SJLJ_LONGJMP, dl, MVT::Other, Op.getOperand(0),
1819                      Op.getOperand(1), DAG.getConstant(0, MVT::i32));
1820 }
1821
1822 SDValue
1823 ARMTargetLowering::LowerINTRINSIC_WO_CHAIN(SDValue Op, SelectionDAG &DAG,
1824                                           const ARMSubtarget *Subtarget) const {
1825   unsigned IntNo = cast<ConstantSDNode>(Op.getOperand(0))->getZExtValue();
1826   DebugLoc dl = Op.getDebugLoc();
1827   switch (IntNo) {
1828   default: return SDValue();    // Don't custom lower most intrinsics.
1829   case Intrinsic::arm_thread_pointer: {
1830     EVT PtrVT = DAG.getTargetLoweringInfo().getPointerTy();
1831     return DAG.getNode(ARMISD::THREAD_POINTER, dl, PtrVT);
1832   }
1833   case Intrinsic::eh_sjlj_lsda: {
1834     MachineFunction &MF = DAG.getMachineFunction();
1835     ARMFunctionInfo *AFI = MF.getInfo<ARMFunctionInfo>();
1836     unsigned ARMPCLabelIndex = AFI->createConstPoolEntryUId();
1837     EVT PtrVT = getPointerTy();
1838     DebugLoc dl = Op.getDebugLoc();
1839     Reloc::Model RelocM = getTargetMachine().getRelocationModel();
1840     SDValue CPAddr;
1841     unsigned PCAdj = (RelocM != Reloc::PIC_)
1842       ? 0 : (Subtarget->isThumb() ? 4 : 8);
1843     ARMConstantPoolValue *CPV =
1844       new ARMConstantPoolValue(MF.getFunction(), ARMPCLabelIndex,
1845                                ARMCP::CPLSDA, PCAdj);
1846     CPAddr = DAG.getTargetConstantPool(CPV, PtrVT, 4);
1847     CPAddr = DAG.getNode(ARMISD::Wrapper, dl, MVT::i32, CPAddr);
1848     SDValue Result =
1849       DAG.getLoad(PtrVT, dl, DAG.getEntryNode(), CPAddr,
1850                   MachinePointerInfo::getConstantPool(),
1851                   false, false, 0);
1852
1853     if (RelocM == Reloc::PIC_) {
1854       SDValue PICLabel = DAG.getConstant(ARMPCLabelIndex, MVT::i32);
1855       Result = DAG.getNode(ARMISD::PIC_ADD, dl, PtrVT, Result, PICLabel);
1856     }
1857     return Result;
1858   }
1859   }
1860 }
1861
1862 static SDValue LowerMEMBARRIER(SDValue Op, SelectionDAG &DAG,
1863                                const ARMSubtarget *Subtarget) {
1864   DebugLoc dl = Op.getDebugLoc();
1865   SDValue Op5 = Op.getOperand(5);
1866   unsigned isDeviceBarrier = cast<ConstantSDNode>(Op5)->getZExtValue();
1867   // Some subtargets which have dmb and dsb instructions can handle barriers
1868   // directly. Some ARMv6 cpus can support them with the help of mcr
1869   // instruction. Thumb1 and pre-v6 ARM mode use a libcall instead and should
1870   // never get here.
1871   unsigned Opc = isDeviceBarrier ? ARMISD::SYNCBARRIER : ARMISD::MEMBARRIER;
1872   if (Subtarget->hasDataBarrier())
1873     return DAG.getNode(Opc, dl, MVT::Other, Op.getOperand(0));
1874   else {
1875     assert(Subtarget->hasV6Ops() && !Subtarget->isThumb1Only() &&
1876            "Unexpected ISD::MEMBARRIER encountered. Should be libcall!");
1877     return DAG.getNode(Opc, dl, MVT::Other, Op.getOperand(0),
1878                        DAG.getConstant(0, MVT::i32));
1879   }
1880 }
1881
1882 static SDValue LowerVASTART(SDValue Op, SelectionDAG &DAG) {
1883   MachineFunction &MF = DAG.getMachineFunction();
1884   ARMFunctionInfo *FuncInfo = MF.getInfo<ARMFunctionInfo>();
1885
1886   // vastart just stores the address of the VarArgsFrameIndex slot into the
1887   // memory location argument.
1888   DebugLoc dl = Op.getDebugLoc();
1889   EVT PtrVT = DAG.getTargetLoweringInfo().getPointerTy();
1890   SDValue FR = DAG.getFrameIndex(FuncInfo->getVarArgsFrameIndex(), PtrVT);
1891   const Value *SV = cast<SrcValueSDNode>(Op.getOperand(2))->getValue();
1892   return DAG.getStore(Op.getOperand(0), dl, FR, Op.getOperand(1), SV, 0,
1893                       false, false, 0);
1894 }
1895
1896 SDValue
1897 ARMTargetLowering::GetF64FormalArgument(CCValAssign &VA, CCValAssign &NextVA,
1898                                         SDValue &Root, SelectionDAG &DAG,
1899                                         DebugLoc dl) const {
1900   MachineFunction &MF = DAG.getMachineFunction();
1901   ARMFunctionInfo *AFI = MF.getInfo<ARMFunctionInfo>();
1902
1903   TargetRegisterClass *RC;
1904   if (AFI->isThumb1OnlyFunction())
1905     RC = ARM::tGPRRegisterClass;
1906   else
1907     RC = ARM::GPRRegisterClass;
1908
1909   // Transform the arguments stored in physical registers into virtual ones.
1910   unsigned Reg = MF.addLiveIn(VA.getLocReg(), RC);
1911   SDValue ArgValue = DAG.getCopyFromReg(Root, dl, Reg, MVT::i32);
1912
1913   SDValue ArgValue2;
1914   if (NextVA.isMemLoc()) {
1915     MachineFrameInfo *MFI = MF.getFrameInfo();
1916     int FI = MFI->CreateFixedObject(4, NextVA.getLocMemOffset(), true);
1917
1918     // Create load node to retrieve arguments from the stack.
1919     SDValue FIN = DAG.getFrameIndex(FI, getPointerTy());
1920     ArgValue2 = DAG.getLoad(MVT::i32, dl, Root, FIN,
1921                             MachinePointerInfo::getFixedStack(FI),
1922                             false, false, 0);
1923   } else {
1924     Reg = MF.addLiveIn(NextVA.getLocReg(), RC);
1925     ArgValue2 = DAG.getCopyFromReg(Root, dl, Reg, MVT::i32);
1926   }
1927
1928   return DAG.getNode(ARMISD::VMOVDRR, dl, MVT::f64, ArgValue, ArgValue2);
1929 }
1930
1931 SDValue
1932 ARMTargetLowering::LowerFormalArguments(SDValue Chain,
1933                                         CallingConv::ID CallConv, bool isVarArg,
1934                                         const SmallVectorImpl<ISD::InputArg>
1935                                           &Ins,
1936                                         DebugLoc dl, SelectionDAG &DAG,
1937                                         SmallVectorImpl<SDValue> &InVals)
1938                                           const {
1939
1940   MachineFunction &MF = DAG.getMachineFunction();
1941   MachineFrameInfo *MFI = MF.getFrameInfo();
1942
1943   ARMFunctionInfo *AFI = MF.getInfo<ARMFunctionInfo>();
1944
1945   // Assign locations to all of the incoming arguments.
1946   SmallVector<CCValAssign, 16> ArgLocs;
1947   CCState CCInfo(CallConv, isVarArg, getTargetMachine(), ArgLocs,
1948                  *DAG.getContext());
1949   CCInfo.AnalyzeFormalArguments(Ins,
1950                                 CCAssignFnForNode(CallConv, /* Return*/ false,
1951                                                   isVarArg));
1952
1953   SmallVector<SDValue, 16> ArgValues;
1954
1955   for (unsigned i = 0, e = ArgLocs.size(); i != e; ++i) {
1956     CCValAssign &VA = ArgLocs[i];
1957
1958     // Arguments stored in registers.
1959     if (VA.isRegLoc()) {
1960       EVT RegVT = VA.getLocVT();
1961
1962       SDValue ArgValue;
1963       if (VA.needsCustom()) {
1964         // f64 and vector types are split up into multiple registers or
1965         // combinations of registers and stack slots.
1966         if (VA.getLocVT() == MVT::v2f64) {
1967           SDValue ArgValue1 = GetF64FormalArgument(VA, ArgLocs[++i],
1968                                                    Chain, DAG, dl);
1969           VA = ArgLocs[++i]; // skip ahead to next loc
1970           SDValue ArgValue2;
1971           if (VA.isMemLoc()) {
1972             int FI = MFI->CreateFixedObject(8, VA.getLocMemOffset(), true);
1973             SDValue FIN = DAG.getFrameIndex(FI, getPointerTy());
1974             ArgValue2 = DAG.getLoad(MVT::f64, dl, Chain, FIN,
1975                                     MachinePointerInfo::getFixedStack(FI),
1976                                     false, false, 0);
1977           } else {
1978             ArgValue2 = GetF64FormalArgument(VA, ArgLocs[++i],
1979                                              Chain, DAG, dl);
1980           }
1981           ArgValue = DAG.getNode(ISD::UNDEF, dl, MVT::v2f64);
1982           ArgValue = DAG.getNode(ISD::INSERT_VECTOR_ELT, dl, MVT::v2f64,
1983                                  ArgValue, ArgValue1, DAG.getIntPtrConstant(0));
1984           ArgValue = DAG.getNode(ISD::INSERT_VECTOR_ELT, dl, MVT::v2f64,
1985                                  ArgValue, ArgValue2, DAG.getIntPtrConstant(1));
1986         } else
1987           ArgValue = GetF64FormalArgument(VA, ArgLocs[++i], Chain, DAG, dl);
1988
1989       } else {
1990         TargetRegisterClass *RC;
1991
1992         if (RegVT == MVT::f32)
1993           RC = ARM::SPRRegisterClass;
1994         else if (RegVT == MVT::f64)
1995           RC = ARM::DPRRegisterClass;
1996         else if (RegVT == MVT::v2f64)
1997           RC = ARM::QPRRegisterClass;
1998         else if (RegVT == MVT::i32)
1999           RC = (AFI->isThumb1OnlyFunction() ?
2000                 ARM::tGPRRegisterClass : ARM::GPRRegisterClass);
2001         else
2002           llvm_unreachable("RegVT not supported by FORMAL_ARGUMENTS Lowering");
2003
2004         // Transform the arguments in physical registers into virtual ones.
2005         unsigned Reg = MF.addLiveIn(VA.getLocReg(), RC);
2006         ArgValue = DAG.getCopyFromReg(Chain, dl, Reg, RegVT);
2007       }
2008
2009       // If this is an 8 or 16-bit value, it is really passed promoted
2010       // to 32 bits.  Insert an assert[sz]ext to capture this, then
2011       // truncate to the right size.
2012       switch (VA.getLocInfo()) {
2013       default: llvm_unreachable("Unknown loc info!");
2014       case CCValAssign::Full: break;
2015       case CCValAssign::BCvt:
2016         ArgValue = DAG.getNode(ISD::BIT_CONVERT, dl, VA.getValVT(), ArgValue);
2017         break;
2018       case CCValAssign::SExt:
2019         ArgValue = DAG.getNode(ISD::AssertSext, dl, RegVT, ArgValue,
2020                                DAG.getValueType(VA.getValVT()));
2021         ArgValue = DAG.getNode(ISD::TRUNCATE, dl, VA.getValVT(), ArgValue);
2022         break;
2023       case CCValAssign::ZExt:
2024         ArgValue = DAG.getNode(ISD::AssertZext, dl, RegVT, ArgValue,
2025                                DAG.getValueType(VA.getValVT()));
2026         ArgValue = DAG.getNode(ISD::TRUNCATE, dl, VA.getValVT(), ArgValue);
2027         break;
2028       }
2029
2030       InVals.push_back(ArgValue);
2031
2032     } else { // VA.isRegLoc()
2033
2034       // sanity check
2035       assert(VA.isMemLoc());
2036       assert(VA.getValVT() != MVT::i64 && "i64 should already be lowered");
2037
2038       unsigned ArgSize = VA.getLocVT().getSizeInBits()/8;
2039       int FI = MFI->CreateFixedObject(ArgSize, VA.getLocMemOffset(), true);
2040
2041       // Create load nodes to retrieve arguments from the stack.
2042       SDValue FIN = DAG.getFrameIndex(FI, getPointerTy());
2043       InVals.push_back(DAG.getLoad(VA.getValVT(), dl, Chain, FIN,
2044                                    MachinePointerInfo::getFixedStack(FI),
2045                                    false, false, 0));
2046     }
2047   }
2048
2049   // varargs
2050   if (isVarArg) {
2051     static const unsigned GPRArgRegs[] = {
2052       ARM::R0, ARM::R1, ARM::R2, ARM::R3
2053     };
2054
2055     unsigned NumGPRs = CCInfo.getFirstUnallocated
2056       (GPRArgRegs, sizeof(GPRArgRegs) / sizeof(GPRArgRegs[0]));
2057
2058     unsigned Align = MF.getTarget().getFrameInfo()->getStackAlignment();
2059     unsigned VARegSize = (4 - NumGPRs) * 4;
2060     unsigned VARegSaveSize = (VARegSize + Align - 1) & ~(Align - 1);
2061     unsigned ArgOffset = CCInfo.getNextStackOffset();
2062     if (VARegSaveSize) {
2063       // If this function is vararg, store any remaining integer argument regs
2064       // to their spots on the stack so that they may be loaded by deferencing
2065       // the result of va_next.
2066       AFI->setVarArgsRegSaveSize(VARegSaveSize);
2067       AFI->setVarArgsFrameIndex(
2068         MFI->CreateFixedObject(VARegSaveSize,
2069                                ArgOffset + VARegSaveSize - VARegSize,
2070                                true));
2071       SDValue FIN = DAG.getFrameIndex(AFI->getVarArgsFrameIndex(),
2072                                       getPointerTy());
2073
2074       SmallVector<SDValue, 4> MemOps;
2075       for (; NumGPRs < 4; ++NumGPRs) {
2076         TargetRegisterClass *RC;
2077         if (AFI->isThumb1OnlyFunction())
2078           RC = ARM::tGPRRegisterClass;
2079         else
2080           RC = ARM::GPRRegisterClass;
2081
2082         unsigned VReg = MF.addLiveIn(GPRArgRegs[NumGPRs], RC);
2083         SDValue Val = DAG.getCopyFromReg(Chain, dl, VReg, MVT::i32);
2084         SDValue Store =
2085           DAG.getStore(Val.getValue(1), dl, Val, FIN,
2086                PseudoSourceValue::getFixedStack(AFI->getVarArgsFrameIndex()),
2087                0, false, false, 0);
2088         MemOps.push_back(Store);
2089         FIN = DAG.getNode(ISD::ADD, dl, getPointerTy(), FIN,
2090                           DAG.getConstant(4, getPointerTy()));
2091       }
2092       if (!MemOps.empty())
2093         Chain = DAG.getNode(ISD::TokenFactor, dl, MVT::Other,
2094                             &MemOps[0], MemOps.size());
2095     } else
2096       // This will point to the next argument passed via stack.
2097       AFI->setVarArgsFrameIndex(MFI->CreateFixedObject(4, ArgOffset, true));
2098   }
2099
2100   return Chain;
2101 }
2102
2103 /// isFloatingPointZero - Return true if this is +0.0.
2104 static bool isFloatingPointZero(SDValue Op) {
2105   if (ConstantFPSDNode *CFP = dyn_cast<ConstantFPSDNode>(Op))
2106     return CFP->getValueAPF().isPosZero();
2107   else if (ISD::isEXTLoad(Op.getNode()) || ISD::isNON_EXTLoad(Op.getNode())) {
2108     // Maybe this has already been legalized into the constant pool?
2109     if (Op.getOperand(1).getOpcode() == ARMISD::Wrapper) {
2110       SDValue WrapperOp = Op.getOperand(1).getOperand(0);
2111       if (ConstantPoolSDNode *CP = dyn_cast<ConstantPoolSDNode>(WrapperOp))
2112         if (const ConstantFP *CFP = dyn_cast<ConstantFP>(CP->getConstVal()))
2113           return CFP->getValueAPF().isPosZero();
2114     }
2115   }
2116   return false;
2117 }
2118
2119 /// Returns appropriate ARM CMP (cmp) and corresponding condition code for
2120 /// the given operands.
2121 SDValue
2122 ARMTargetLowering::getARMCmp(SDValue LHS, SDValue RHS, ISD::CondCode CC,
2123                              SDValue &ARMcc, SelectionDAG &DAG,
2124                              DebugLoc dl) const {
2125   if (ConstantSDNode *RHSC = dyn_cast<ConstantSDNode>(RHS.getNode())) {
2126     unsigned C = RHSC->getZExtValue();
2127     if (!isLegalICmpImmediate(C)) {
2128       // Constant does not fit, try adjusting it by one?
2129       switch (CC) {
2130       default: break;
2131       case ISD::SETLT:
2132       case ISD::SETGE:
2133         if (C != 0x80000000 && isLegalICmpImmediate(C-1)) {
2134           CC = (CC == ISD::SETLT) ? ISD::SETLE : ISD::SETGT;
2135           RHS = DAG.getConstant(C-1, MVT::i32);
2136         }
2137         break;
2138       case ISD::SETULT:
2139       case ISD::SETUGE:
2140         if (C != 0 && isLegalICmpImmediate(C-1)) {
2141           CC = (CC == ISD::SETULT) ? ISD::SETULE : ISD::SETUGT;
2142           RHS = DAG.getConstant(C-1, MVT::i32);
2143         }
2144         break;
2145       case ISD::SETLE:
2146       case ISD::SETGT:
2147         if (C != 0x7fffffff && isLegalICmpImmediate(C+1)) {
2148           CC = (CC == ISD::SETLE) ? ISD::SETLT : ISD::SETGE;
2149           RHS = DAG.getConstant(C+1, MVT::i32);
2150         }
2151         break;
2152       case ISD::SETULE:
2153       case ISD::SETUGT:
2154         if (C != 0xffffffff && isLegalICmpImmediate(C+1)) {
2155           CC = (CC == ISD::SETULE) ? ISD::SETULT : ISD::SETUGE;
2156           RHS = DAG.getConstant(C+1, MVT::i32);
2157         }
2158         break;
2159       }
2160     }
2161   }
2162
2163   ARMCC::CondCodes CondCode = IntCCToARMCC(CC);
2164   ARMISD::NodeType CompareType;
2165   switch (CondCode) {
2166   default:
2167     CompareType = ARMISD::CMP;
2168     break;
2169   case ARMCC::EQ:
2170   case ARMCC::NE:
2171     // Uses only Z Flag
2172     CompareType = ARMISD::CMPZ;
2173     break;
2174   }
2175   ARMcc = DAG.getConstant(CondCode, MVT::i32);
2176   return DAG.getNode(CompareType, dl, MVT::Flag, LHS, RHS);
2177 }
2178
2179 /// Returns a appropriate VFP CMP (fcmp{s|d}+fmstat) for the given operands.
2180 SDValue
2181 ARMTargetLowering::getVFPCmp(SDValue LHS, SDValue RHS, SelectionDAG &DAG,
2182                              DebugLoc dl) const {
2183   SDValue Cmp;
2184   if (!isFloatingPointZero(RHS))
2185     Cmp = DAG.getNode(ARMISD::CMPFP, dl, MVT::Flag, LHS, RHS);
2186   else
2187     Cmp = DAG.getNode(ARMISD::CMPFPw0, dl, MVT::Flag, LHS);
2188   return DAG.getNode(ARMISD::FMSTAT, dl, MVT::Flag, Cmp);
2189 }
2190
2191 SDValue ARMTargetLowering::LowerSELECT(SDValue Op, SelectionDAG &DAG) const {
2192   SDValue Cond = Op.getOperand(0);
2193   SDValue SelectTrue = Op.getOperand(1);
2194   SDValue SelectFalse = Op.getOperand(2);
2195   DebugLoc dl = Op.getDebugLoc();
2196
2197   // Convert:
2198   //
2199   //   (select (cmov 1, 0, cond), t, f) -> (cmov t, f, cond)
2200   //   (select (cmov 0, 1, cond), t, f) -> (cmov f, t, cond)
2201   //
2202   if (Cond.getOpcode() == ARMISD::CMOV && Cond.hasOneUse()) {
2203     const ConstantSDNode *CMOVTrue =
2204       dyn_cast<ConstantSDNode>(Cond.getOperand(0));
2205     const ConstantSDNode *CMOVFalse =
2206       dyn_cast<ConstantSDNode>(Cond.getOperand(1));
2207
2208     if (CMOVTrue && CMOVFalse) {
2209       unsigned CMOVTrueVal = CMOVTrue->getZExtValue();
2210       unsigned CMOVFalseVal = CMOVFalse->getZExtValue();
2211
2212       SDValue True;
2213       SDValue False;
2214       if (CMOVTrueVal == 1 && CMOVFalseVal == 0) {
2215         True = SelectTrue;
2216         False = SelectFalse;
2217       } else if (CMOVTrueVal == 0 && CMOVFalseVal == 1) {
2218         True = SelectFalse;
2219         False = SelectTrue;
2220       }
2221
2222       if (True.getNode() && False.getNode()) {
2223         EVT VT = Cond.getValueType();
2224         SDValue ARMcc = Cond.getOperand(2);
2225         SDValue CCR = Cond.getOperand(3);
2226         SDValue Cmp = Cond.getOperand(4);
2227         return DAG.getNode(ARMISD::CMOV, dl, VT, True, False, ARMcc, CCR, Cmp);
2228       }
2229     }
2230   }
2231
2232   return DAG.getSelectCC(dl, Cond,
2233                          DAG.getConstant(0, Cond.getValueType()),
2234                          SelectTrue, SelectFalse, ISD::SETNE);
2235 }
2236
2237 SDValue ARMTargetLowering::LowerSELECT_CC(SDValue Op, SelectionDAG &DAG) const {
2238   EVT VT = Op.getValueType();
2239   SDValue LHS = Op.getOperand(0);
2240   SDValue RHS = Op.getOperand(1);
2241   ISD::CondCode CC = cast<CondCodeSDNode>(Op.getOperand(4))->get();
2242   SDValue TrueVal = Op.getOperand(2);
2243   SDValue FalseVal = Op.getOperand(3);
2244   DebugLoc dl = Op.getDebugLoc();
2245
2246   if (LHS.getValueType() == MVT::i32) {
2247     SDValue ARMcc;
2248     SDValue CCR = DAG.getRegister(ARM::CPSR, MVT::i32);
2249     SDValue Cmp = getARMCmp(LHS, RHS, CC, ARMcc, DAG, dl);
2250     return DAG.getNode(ARMISD::CMOV, dl, VT, FalseVal, TrueVal, ARMcc, CCR,Cmp);
2251   }
2252
2253   ARMCC::CondCodes CondCode, CondCode2;
2254   FPCCToARMCC(CC, CondCode, CondCode2);
2255
2256   SDValue ARMcc = DAG.getConstant(CondCode, MVT::i32);
2257   SDValue Cmp = getVFPCmp(LHS, RHS, DAG, dl);
2258   SDValue CCR = DAG.getRegister(ARM::CPSR, MVT::i32);
2259   SDValue Result = DAG.getNode(ARMISD::CMOV, dl, VT, FalseVal, TrueVal,
2260                                ARMcc, CCR, Cmp);
2261   if (CondCode2 != ARMCC::AL) {
2262     SDValue ARMcc2 = DAG.getConstant(CondCode2, MVT::i32);
2263     // FIXME: Needs another CMP because flag can have but one use.
2264     SDValue Cmp2 = getVFPCmp(LHS, RHS, DAG, dl);
2265     Result = DAG.getNode(ARMISD::CMOV, dl, VT,
2266                          Result, TrueVal, ARMcc2, CCR, Cmp2);
2267   }
2268   return Result;
2269 }
2270
2271 /// canChangeToInt - Given the fp compare operand, return true if it is suitable
2272 /// to morph to an integer compare sequence.
2273 static bool canChangeToInt(SDValue Op, bool &SeenZero,
2274                            const ARMSubtarget *Subtarget) {
2275   SDNode *N = Op.getNode();
2276   if (!N->hasOneUse())
2277     // Otherwise it requires moving the value from fp to integer registers.
2278     return false;
2279   if (!N->getNumValues())
2280     return false;
2281   EVT VT = Op.getValueType();
2282   if (VT != MVT::f32 && !Subtarget->isFPBrccSlow())
2283     // f32 case is generally profitable. f64 case only makes sense when vcmpe +
2284     // vmrs are very slow, e.g. cortex-a8.
2285     return false;
2286
2287   if (isFloatingPointZero(Op)) {
2288     SeenZero = true;
2289     return true;
2290   }
2291   return ISD::isNormalLoad(N);
2292 }
2293
2294 static SDValue bitcastf32Toi32(SDValue Op, SelectionDAG &DAG) {
2295   if (isFloatingPointZero(Op))
2296     return DAG.getConstant(0, MVT::i32);
2297
2298   if (LoadSDNode *Ld = dyn_cast<LoadSDNode>(Op))
2299     return DAG.getLoad(MVT::i32, Op.getDebugLoc(),
2300                        Ld->getChain(), Ld->getBasePtr(), Ld->getPointerInfo(),
2301                        Ld->isVolatile(), Ld->isNonTemporal(),
2302                        Ld->getAlignment());
2303
2304   llvm_unreachable("Unknown VFP cmp argument!");
2305 }
2306
2307 static void expandf64Toi32(SDValue Op, SelectionDAG &DAG,
2308                            SDValue &RetVal1, SDValue &RetVal2) {
2309   if (isFloatingPointZero(Op)) {
2310     RetVal1 = DAG.getConstant(0, MVT::i32);
2311     RetVal2 = DAG.getConstant(0, MVT::i32);
2312     return;
2313   }
2314
2315   if (LoadSDNode *Ld = dyn_cast<LoadSDNode>(Op)) {
2316     SDValue Ptr = Ld->getBasePtr();
2317     RetVal1 = DAG.getLoad(MVT::i32, Op.getDebugLoc(),
2318                           Ld->getChain(), Ptr,
2319                           Ld->getPointerInfo(),
2320                           Ld->isVolatile(), Ld->isNonTemporal(),
2321                           Ld->getAlignment());
2322
2323     EVT PtrType = Ptr.getValueType();
2324     unsigned NewAlign = MinAlign(Ld->getAlignment(), 4);
2325     SDValue NewPtr = DAG.getNode(ISD::ADD, Op.getDebugLoc(),
2326                                  PtrType, Ptr, DAG.getConstant(4, PtrType));
2327     RetVal2 = DAG.getLoad(MVT::i32, Op.getDebugLoc(),
2328                           Ld->getChain(), NewPtr,
2329                           Ld->getPointerInfo().getWithOffset(4),
2330                           Ld->isVolatile(), Ld->isNonTemporal(),
2331                           NewAlign);
2332     return;
2333   }
2334
2335   llvm_unreachable("Unknown VFP cmp argument!");
2336 }
2337
2338 /// OptimizeVFPBrcond - With -enable-unsafe-fp-math, it's legal to optimize some
2339 /// f32 and even f64 comparisons to integer ones.
2340 SDValue
2341 ARMTargetLowering::OptimizeVFPBrcond(SDValue Op, SelectionDAG &DAG) const {
2342   SDValue Chain = Op.getOperand(0);
2343   ISD::CondCode CC = cast<CondCodeSDNode>(Op.getOperand(1))->get();
2344   SDValue LHS = Op.getOperand(2);
2345   SDValue RHS = Op.getOperand(3);
2346   SDValue Dest = Op.getOperand(4);
2347   DebugLoc dl = Op.getDebugLoc();
2348
2349   bool SeenZero = false;
2350   if (canChangeToInt(LHS, SeenZero, Subtarget) &&
2351       canChangeToInt(RHS, SeenZero, Subtarget) &&
2352       // If one of the operand is zero, it's safe to ignore the NaN case since
2353       // we only care about equality comparisons.
2354       (SeenZero || (DAG.isKnownNeverNaN(LHS) && DAG.isKnownNeverNaN(RHS)))) {
2355     // If unsafe fp math optimization is enabled and there are no othter uses of
2356     // the CMP operands, and the condition code is EQ oe NE, we can optimize it
2357     // to an integer comparison.
2358     if (CC == ISD::SETOEQ)
2359       CC = ISD::SETEQ;
2360     else if (CC == ISD::SETUNE)
2361       CC = ISD::SETNE;
2362
2363     SDValue ARMcc;
2364     if (LHS.getValueType() == MVT::f32) {
2365       LHS = bitcastf32Toi32(LHS, DAG);
2366       RHS = bitcastf32Toi32(RHS, DAG);
2367       SDValue Cmp = getARMCmp(LHS, RHS, CC, ARMcc, DAG, dl);
2368       SDValue CCR = DAG.getRegister(ARM::CPSR, MVT::i32);
2369       return DAG.getNode(ARMISD::BRCOND, dl, MVT::Other,
2370                          Chain, Dest, ARMcc, CCR, Cmp);
2371     }
2372
2373     SDValue LHS1, LHS2;
2374     SDValue RHS1, RHS2;
2375     expandf64Toi32(LHS, DAG, LHS1, LHS2);
2376     expandf64Toi32(RHS, DAG, RHS1, RHS2);
2377     ARMCC::CondCodes CondCode = IntCCToARMCC(CC);
2378     ARMcc = DAG.getConstant(CondCode, MVT::i32);
2379     SDVTList VTList = DAG.getVTList(MVT::Other, MVT::Flag);
2380     SDValue Ops[] = { Chain, ARMcc, LHS1, LHS2, RHS1, RHS2, Dest };
2381     return DAG.getNode(ARMISD::BCC_i64, dl, VTList, Ops, 7);
2382   }
2383
2384   return SDValue();
2385 }
2386
2387 SDValue ARMTargetLowering::LowerBR_CC(SDValue Op, SelectionDAG &DAG) const {
2388   SDValue Chain = Op.getOperand(0);
2389   ISD::CondCode CC = cast<CondCodeSDNode>(Op.getOperand(1))->get();
2390   SDValue LHS = Op.getOperand(2);
2391   SDValue RHS = Op.getOperand(3);
2392   SDValue Dest = Op.getOperand(4);
2393   DebugLoc dl = Op.getDebugLoc();
2394
2395   if (LHS.getValueType() == MVT::i32) {
2396     SDValue ARMcc;
2397     SDValue Cmp = getARMCmp(LHS, RHS, CC, ARMcc, DAG, dl);
2398     SDValue CCR = DAG.getRegister(ARM::CPSR, MVT::i32);
2399     return DAG.getNode(ARMISD::BRCOND, dl, MVT::Other,
2400                        Chain, Dest, ARMcc, CCR, Cmp);
2401   }
2402
2403   assert(LHS.getValueType() == MVT::f32 || LHS.getValueType() == MVT::f64);
2404
2405   if (UnsafeFPMath &&
2406       (CC == ISD::SETEQ || CC == ISD::SETOEQ ||
2407        CC == ISD::SETNE || CC == ISD::SETUNE)) {
2408     SDValue Result = OptimizeVFPBrcond(Op, DAG);
2409     if (Result.getNode())
2410       return Result;
2411   }
2412
2413   ARMCC::CondCodes CondCode, CondCode2;
2414   FPCCToARMCC(CC, CondCode, CondCode2);
2415
2416   SDValue ARMcc = DAG.getConstant(CondCode, MVT::i32);
2417   SDValue Cmp = getVFPCmp(LHS, RHS, DAG, dl);
2418   SDValue CCR = DAG.getRegister(ARM::CPSR, MVT::i32);
2419   SDVTList VTList = DAG.getVTList(MVT::Other, MVT::Flag);
2420   SDValue Ops[] = { Chain, Dest, ARMcc, CCR, Cmp };
2421   SDValue Res = DAG.getNode(ARMISD::BRCOND, dl, VTList, Ops, 5);
2422   if (CondCode2 != ARMCC::AL) {
2423     ARMcc = DAG.getConstant(CondCode2, MVT::i32);
2424     SDValue Ops[] = { Res, Dest, ARMcc, CCR, Res.getValue(1) };
2425     Res = DAG.getNode(ARMISD::BRCOND, dl, VTList, Ops, 5);
2426   }
2427   return Res;
2428 }
2429
2430 SDValue ARMTargetLowering::LowerBR_JT(SDValue Op, SelectionDAG &DAG) const {
2431   SDValue Chain = Op.getOperand(0);
2432   SDValue Table = Op.getOperand(1);
2433   SDValue Index = Op.getOperand(2);
2434   DebugLoc dl = Op.getDebugLoc();
2435
2436   EVT PTy = getPointerTy();
2437   JumpTableSDNode *JT = cast<JumpTableSDNode>(Table);
2438   ARMFunctionInfo *AFI = DAG.getMachineFunction().getInfo<ARMFunctionInfo>();
2439   SDValue UId = DAG.getConstant(AFI->createJumpTableUId(), PTy);
2440   SDValue JTI = DAG.getTargetJumpTable(JT->getIndex(), PTy);
2441   Table = DAG.getNode(ARMISD::WrapperJT, dl, MVT::i32, JTI, UId);
2442   Index = DAG.getNode(ISD::MUL, dl, PTy, Index, DAG.getConstant(4, PTy));
2443   SDValue Addr = DAG.getNode(ISD::ADD, dl, PTy, Index, Table);
2444   if (Subtarget->isThumb2()) {
2445     // Thumb2 uses a two-level jump. That is, it jumps into the jump table
2446     // which does another jump to the destination. This also makes it easier
2447     // to translate it to TBB / TBH later.
2448     // FIXME: This might not work if the function is extremely large.
2449     return DAG.getNode(ARMISD::BR2_JT, dl, MVT::Other, Chain,
2450                        Addr, Op.getOperand(2), JTI, UId);
2451   }
2452   if (getTargetMachine().getRelocationModel() == Reloc::PIC_) {
2453     Addr = DAG.getLoad((EVT)MVT::i32, dl, Chain, Addr,
2454                        MachinePointerInfo::getJumpTable(),
2455                        false, false, 0);
2456     Chain = Addr.getValue(1);
2457     Addr = DAG.getNode(ISD::ADD, dl, PTy, Addr, Table);
2458     return DAG.getNode(ARMISD::BR_JT, dl, MVT::Other, Chain, Addr, JTI, UId);
2459   } else {
2460     Addr = DAG.getLoad(PTy, dl, Chain, Addr,
2461                        MachinePointerInfo::getJumpTable(), false, false, 0);
2462     Chain = Addr.getValue(1);
2463     return DAG.getNode(ARMISD::BR_JT, dl, MVT::Other, Chain, Addr, JTI, UId);
2464   }
2465 }
2466
2467 static SDValue LowerFP_TO_INT(SDValue Op, SelectionDAG &DAG) {
2468   DebugLoc dl = Op.getDebugLoc();
2469   unsigned Opc;
2470
2471   switch (Op.getOpcode()) {
2472   default:
2473     assert(0 && "Invalid opcode!");
2474   case ISD::FP_TO_SINT:
2475     Opc = ARMISD::FTOSI;
2476     break;
2477   case ISD::FP_TO_UINT:
2478     Opc = ARMISD::FTOUI;
2479     break;
2480   }
2481   Op = DAG.getNode(Opc, dl, MVT::f32, Op.getOperand(0));
2482   return DAG.getNode(ISD::BIT_CONVERT, dl, MVT::i32, Op);
2483 }
2484
2485 static SDValue LowerINT_TO_FP(SDValue Op, SelectionDAG &DAG) {
2486   EVT VT = Op.getValueType();
2487   DebugLoc dl = Op.getDebugLoc();
2488   unsigned Opc;
2489
2490   switch (Op.getOpcode()) {
2491   default:
2492     assert(0 && "Invalid opcode!");
2493   case ISD::SINT_TO_FP:
2494     Opc = ARMISD::SITOF;
2495     break;
2496   case ISD::UINT_TO_FP:
2497     Opc = ARMISD::UITOF;
2498     break;
2499   }
2500
2501   Op = DAG.getNode(ISD::BIT_CONVERT, dl, MVT::f32, Op.getOperand(0));
2502   return DAG.getNode(Opc, dl, VT, Op);
2503 }
2504
2505 SDValue ARMTargetLowering::LowerFCOPYSIGN(SDValue Op, SelectionDAG &DAG) const {
2506   // Implement fcopysign with a fabs and a conditional fneg.
2507   SDValue Tmp0 = Op.getOperand(0);
2508   SDValue Tmp1 = Op.getOperand(1);
2509   DebugLoc dl = Op.getDebugLoc();
2510   EVT VT = Op.getValueType();
2511   EVT SrcVT = Tmp1.getValueType();
2512   SDValue AbsVal = DAG.getNode(ISD::FABS, dl, VT, Tmp0);
2513   SDValue ARMcc = DAG.getConstant(ARMCC::LT, MVT::i32);
2514   SDValue FP0 = DAG.getConstantFP(0.0, SrcVT);
2515   SDValue Cmp = getVFPCmp(Tmp1, FP0, DAG, dl);
2516   SDValue CCR = DAG.getRegister(ARM::CPSR, MVT::i32);
2517   return DAG.getNode(ARMISD::CNEG, dl, VT, AbsVal, AbsVal, ARMcc, CCR, Cmp);
2518 }
2519
2520 SDValue ARMTargetLowering::LowerRETURNADDR(SDValue Op, SelectionDAG &DAG) const{
2521   MachineFunction &MF = DAG.getMachineFunction();
2522   MachineFrameInfo *MFI = MF.getFrameInfo();
2523   MFI->setReturnAddressIsTaken(true);
2524
2525   EVT VT = Op.getValueType();
2526   DebugLoc dl = Op.getDebugLoc();
2527   unsigned Depth = cast<ConstantSDNode>(Op.getOperand(0))->getZExtValue();
2528   if (Depth) {
2529     SDValue FrameAddr = LowerFRAMEADDR(Op, DAG);
2530     SDValue Offset = DAG.getConstant(4, MVT::i32);
2531     return DAG.getLoad(VT, dl, DAG.getEntryNode(),
2532                        DAG.getNode(ISD::ADD, dl, VT, FrameAddr, Offset),
2533                        MachinePointerInfo(), false, false, 0);
2534   }
2535
2536   // Return LR, which contains the return address. Mark it an implicit live-in.
2537   unsigned Reg = MF.addLiveIn(ARM::LR, getRegClassFor(MVT::i32));
2538   return DAG.getCopyFromReg(DAG.getEntryNode(), dl, Reg, VT);
2539 }
2540
2541 SDValue ARMTargetLowering::LowerFRAMEADDR(SDValue Op, SelectionDAG &DAG) const {
2542   MachineFrameInfo *MFI = DAG.getMachineFunction().getFrameInfo();
2543   MFI->setFrameAddressIsTaken(true);
2544
2545   EVT VT = Op.getValueType();
2546   DebugLoc dl = Op.getDebugLoc();  // FIXME probably not meaningful
2547   unsigned Depth = cast<ConstantSDNode>(Op.getOperand(0))->getZExtValue();
2548   unsigned FrameReg = (Subtarget->isThumb() || Subtarget->isTargetDarwin())
2549     ? ARM::R7 : ARM::R11;
2550   SDValue FrameAddr = DAG.getCopyFromReg(DAG.getEntryNode(), dl, FrameReg, VT);
2551   while (Depth--)
2552     FrameAddr = DAG.getLoad(VT, dl, DAG.getEntryNode(), FrameAddr,
2553                             MachinePointerInfo(),
2554                             false, false, 0);
2555   return FrameAddr;
2556 }
2557
2558 /// ExpandBIT_CONVERT - If the target supports VFP, this function is called to
2559 /// expand a bit convert where either the source or destination type is i64 to
2560 /// use a VMOVDRR or VMOVRRD node.  This should not be done when the non-i64
2561 /// operand type is illegal (e.g., v2f32 for a target that doesn't support
2562 /// vectors), since the legalizer won't know what to do with that.
2563 static SDValue ExpandBIT_CONVERT(SDNode *N, SelectionDAG &DAG) {
2564   const TargetLowering &TLI = DAG.getTargetLoweringInfo();
2565   DebugLoc dl = N->getDebugLoc();
2566   SDValue Op = N->getOperand(0);
2567
2568   // This function is only supposed to be called for i64 types, either as the
2569   // source or destination of the bit convert.
2570   EVT SrcVT = Op.getValueType();
2571   EVT DstVT = N->getValueType(0);
2572   assert((SrcVT == MVT::i64 || DstVT == MVT::i64) &&
2573          "ExpandBIT_CONVERT called for non-i64 type");
2574
2575   // Turn i64->f64 into VMOVDRR.
2576   if (SrcVT == MVT::i64 && TLI.isTypeLegal(DstVT)) {
2577     SDValue Lo = DAG.getNode(ISD::EXTRACT_ELEMENT, dl, MVT::i32, Op,
2578                              DAG.getConstant(0, MVT::i32));
2579     SDValue Hi = DAG.getNode(ISD::EXTRACT_ELEMENT, dl, MVT::i32, Op,
2580                              DAG.getConstant(1, MVT::i32));
2581     return DAG.getNode(ISD::BIT_CONVERT, dl, DstVT,
2582                        DAG.getNode(ARMISD::VMOVDRR, dl, MVT::f64, Lo, Hi));
2583   }
2584
2585   // Turn f64->i64 into VMOVRRD.
2586   if (DstVT == MVT::i64 && TLI.isTypeLegal(SrcVT)) {
2587     SDValue Cvt = DAG.getNode(ARMISD::VMOVRRD, dl,
2588                               DAG.getVTList(MVT::i32, MVT::i32), &Op, 1);
2589     // Merge the pieces into a single i64 value.
2590     return DAG.getNode(ISD::BUILD_PAIR, dl, MVT::i64, Cvt, Cvt.getValue(1));
2591   }
2592
2593   return SDValue();
2594 }
2595
2596 /// getZeroVector - Returns a vector of specified type with all zero elements.
2597 /// Zero vectors are used to represent vector negation and in those cases
2598 /// will be implemented with the NEON VNEG instruction.  However, VNEG does
2599 /// not support i64 elements, so sometimes the zero vectors will need to be
2600 /// explicitly constructed.  Regardless, use a canonical VMOV to create the
2601 /// zero vector.
2602 static SDValue getZeroVector(EVT VT, SelectionDAG &DAG, DebugLoc dl) {
2603   assert(VT.isVector() && "Expected a vector type");
2604   // The canonical modified immediate encoding of a zero vector is....0!
2605   SDValue EncodedVal = DAG.getTargetConstant(0, MVT::i32);
2606   EVT VmovVT = VT.is128BitVector() ? MVT::v4i32 : MVT::v2i32;
2607   SDValue Vmov = DAG.getNode(ARMISD::VMOVIMM, dl, VmovVT, EncodedVal);
2608   return DAG.getNode(ISD::BIT_CONVERT, dl, VT, Vmov);
2609 }
2610
2611 /// LowerShiftRightParts - Lower SRA_PARTS, which returns two
2612 /// i32 values and take a 2 x i32 value to shift plus a shift amount.
2613 SDValue ARMTargetLowering::LowerShiftRightParts(SDValue Op,
2614                                                 SelectionDAG &DAG) const {
2615   assert(Op.getNumOperands() == 3 && "Not a double-shift!");
2616   EVT VT = Op.getValueType();
2617   unsigned VTBits = VT.getSizeInBits();
2618   DebugLoc dl = Op.getDebugLoc();
2619   SDValue ShOpLo = Op.getOperand(0);
2620   SDValue ShOpHi = Op.getOperand(1);
2621   SDValue ShAmt  = Op.getOperand(2);
2622   SDValue ARMcc;
2623   unsigned Opc = (Op.getOpcode() == ISD::SRA_PARTS) ? ISD::SRA : ISD::SRL;
2624
2625   assert(Op.getOpcode() == ISD::SRA_PARTS || Op.getOpcode() == ISD::SRL_PARTS);
2626
2627   SDValue RevShAmt = DAG.getNode(ISD::SUB, dl, MVT::i32,
2628                                  DAG.getConstant(VTBits, MVT::i32), ShAmt);
2629   SDValue Tmp1 = DAG.getNode(ISD::SRL, dl, VT, ShOpLo, ShAmt);
2630   SDValue ExtraShAmt = DAG.getNode(ISD::SUB, dl, MVT::i32, ShAmt,
2631                                    DAG.getConstant(VTBits, MVT::i32));
2632   SDValue Tmp2 = DAG.getNode(ISD::SHL, dl, VT, ShOpHi, RevShAmt);
2633   SDValue FalseVal = DAG.getNode(ISD::OR, dl, VT, Tmp1, Tmp2);
2634   SDValue TrueVal = DAG.getNode(Opc, dl, VT, ShOpHi, ExtraShAmt);
2635
2636   SDValue CCR = DAG.getRegister(ARM::CPSR, MVT::i32);
2637   SDValue Cmp = getARMCmp(ExtraShAmt, DAG.getConstant(0, MVT::i32), ISD::SETGE,
2638                           ARMcc, DAG, dl);
2639   SDValue Hi = DAG.getNode(Opc, dl, VT, ShOpHi, ShAmt);
2640   SDValue Lo = DAG.getNode(ARMISD::CMOV, dl, VT, FalseVal, TrueVal, ARMcc,
2641                            CCR, Cmp);
2642
2643   SDValue Ops[2] = { Lo, Hi };
2644   return DAG.getMergeValues(Ops, 2, dl);
2645 }
2646
2647 /// LowerShiftLeftParts - Lower SHL_PARTS, which returns two
2648 /// i32 values and take a 2 x i32 value to shift plus a shift amount.
2649 SDValue ARMTargetLowering::LowerShiftLeftParts(SDValue Op,
2650                                                SelectionDAG &DAG) const {
2651   assert(Op.getNumOperands() == 3 && "Not a double-shift!");
2652   EVT VT = Op.getValueType();
2653   unsigned VTBits = VT.getSizeInBits();
2654   DebugLoc dl = Op.getDebugLoc();
2655   SDValue ShOpLo = Op.getOperand(0);
2656   SDValue ShOpHi = Op.getOperand(1);
2657   SDValue ShAmt  = Op.getOperand(2);
2658   SDValue ARMcc;
2659
2660   assert(Op.getOpcode() == ISD::SHL_PARTS);
2661   SDValue RevShAmt = DAG.getNode(ISD::SUB, dl, MVT::i32,
2662                                  DAG.getConstant(VTBits, MVT::i32), ShAmt);
2663   SDValue Tmp1 = DAG.getNode(ISD::SRL, dl, VT, ShOpLo, RevShAmt);
2664   SDValue ExtraShAmt = DAG.getNode(ISD::SUB, dl, MVT::i32, ShAmt,
2665                                    DAG.getConstant(VTBits, MVT::i32));
2666   SDValue Tmp2 = DAG.getNode(ISD::SHL, dl, VT, ShOpHi, ShAmt);
2667   SDValue Tmp3 = DAG.getNode(ISD::SHL, dl, VT, ShOpLo, ExtraShAmt);
2668
2669   SDValue FalseVal = DAG.getNode(ISD::OR, dl, VT, Tmp1, Tmp2);
2670   SDValue CCR = DAG.getRegister(ARM::CPSR, MVT::i32);
2671   SDValue Cmp = getARMCmp(ExtraShAmt, DAG.getConstant(0, MVT::i32), ISD::SETGE,
2672                           ARMcc, DAG, dl);
2673   SDValue Lo = DAG.getNode(ISD::SHL, dl, VT, ShOpLo, ShAmt);
2674   SDValue Hi = DAG.getNode(ARMISD::CMOV, dl, VT, FalseVal, Tmp3, ARMcc,
2675                            CCR, Cmp);
2676
2677   SDValue Ops[2] = { Lo, Hi };
2678   return DAG.getMergeValues(Ops, 2, dl);
2679 }
2680
2681 SDValue ARMTargetLowering::LowerFLT_ROUNDS_(SDValue Op,
2682                                             SelectionDAG &DAG) const {
2683   // The rounding mode is in bits 23:22 of the FPSCR.
2684   // The ARM rounding mode value to FLT_ROUNDS mapping is 0->1, 1->2, 2->3, 3->0
2685   // The formula we use to implement this is (((FPSCR + 1 << 22) >> 22) & 3)
2686   // so that the shift + and get folded into a bitfield extract.
2687   DebugLoc dl = Op.getDebugLoc();
2688   SDValue FPSCR = DAG.getNode(ISD::INTRINSIC_WO_CHAIN, dl, MVT::i32,
2689                               DAG.getConstant(Intrinsic::arm_get_fpscr,
2690                                               MVT::i32));
2691   SDValue FltRounds = DAG.getNode(ISD::ADD, dl, MVT::i32, FPSCR,
2692                                   DAG.getConstant(1U << 22, MVT::i32));
2693   SDValue RMODE = DAG.getNode(ISD::SRL, dl, MVT::i32, FltRounds,
2694                               DAG.getConstant(22, MVT::i32));
2695   return DAG.getNode(ISD::AND, dl, MVT::i32, RMODE,
2696                      DAG.getConstant(3, MVT::i32));
2697 }
2698
2699 static SDValue LowerCTTZ(SDNode *N, SelectionDAG &DAG,
2700                          const ARMSubtarget *ST) {
2701   EVT VT = N->getValueType(0);
2702   DebugLoc dl = N->getDebugLoc();
2703
2704   if (!ST->hasV6T2Ops())
2705     return SDValue();
2706
2707   SDValue rbit = DAG.getNode(ARMISD::RBIT, dl, VT, N->getOperand(0));
2708   return DAG.getNode(ISD::CTLZ, dl, VT, rbit);
2709 }
2710
2711 static SDValue LowerShift(SDNode *N, SelectionDAG &DAG,
2712                           const ARMSubtarget *ST) {
2713   EVT VT = N->getValueType(0);
2714   DebugLoc dl = N->getDebugLoc();
2715
2716   // Lower vector shifts on NEON to use VSHL.
2717   if (VT.isVector()) {
2718     assert(ST->hasNEON() && "unexpected vector shift");
2719
2720     // Left shifts translate directly to the vshiftu intrinsic.
2721     if (N->getOpcode() == ISD::SHL)
2722       return DAG.getNode(ISD::INTRINSIC_WO_CHAIN, dl, VT,
2723                          DAG.getConstant(Intrinsic::arm_neon_vshiftu, MVT::i32),
2724                          N->getOperand(0), N->getOperand(1));
2725
2726     assert((N->getOpcode() == ISD::SRA ||
2727             N->getOpcode() == ISD::SRL) && "unexpected vector shift opcode");
2728
2729     // NEON uses the same intrinsics for both left and right shifts.  For
2730     // right shifts, the shift amounts are negative, so negate the vector of
2731     // shift amounts.
2732     EVT ShiftVT = N->getOperand(1).getValueType();
2733     SDValue NegatedCount = DAG.getNode(ISD::SUB, dl, ShiftVT,
2734                                        getZeroVector(ShiftVT, DAG, dl),
2735                                        N->getOperand(1));
2736     Intrinsic::ID vshiftInt = (N->getOpcode() == ISD::SRA ?
2737                                Intrinsic::arm_neon_vshifts :
2738                                Intrinsic::arm_neon_vshiftu);
2739     return DAG.getNode(ISD::INTRINSIC_WO_CHAIN, dl, VT,
2740                        DAG.getConstant(vshiftInt, MVT::i32),
2741                        N->getOperand(0), NegatedCount);
2742   }
2743
2744   // We can get here for a node like i32 = ISD::SHL i32, i64
2745   if (VT != MVT::i64)
2746     return SDValue();
2747
2748   assert((N->getOpcode() == ISD::SRL || N->getOpcode() == ISD::SRA) &&
2749          "Unknown shift to lower!");
2750
2751   // We only lower SRA, SRL of 1 here, all others use generic lowering.
2752   if (!isa<ConstantSDNode>(N->getOperand(1)) ||
2753       cast<ConstantSDNode>(N->getOperand(1))->getZExtValue() != 1)
2754     return SDValue();
2755
2756   // If we are in thumb mode, we don't have RRX.
2757   if (ST->isThumb1Only()) return SDValue();
2758
2759   // Okay, we have a 64-bit SRA or SRL of 1.  Lower this to an RRX expr.
2760   SDValue Lo = DAG.getNode(ISD::EXTRACT_ELEMENT, dl, MVT::i32, N->getOperand(0),
2761                            DAG.getConstant(0, MVT::i32));
2762   SDValue Hi = DAG.getNode(ISD::EXTRACT_ELEMENT, dl, MVT::i32, N->getOperand(0),
2763                            DAG.getConstant(1, MVT::i32));
2764
2765   // First, build a SRA_FLAG/SRL_FLAG op, which shifts the top part by one and
2766   // captures the result into a carry flag.
2767   unsigned Opc = N->getOpcode() == ISD::SRL ? ARMISD::SRL_FLAG:ARMISD::SRA_FLAG;
2768   Hi = DAG.getNode(Opc, dl, DAG.getVTList(MVT::i32, MVT::Flag), &Hi, 1);
2769
2770   // The low part is an ARMISD::RRX operand, which shifts the carry in.
2771   Lo = DAG.getNode(ARMISD::RRX, dl, MVT::i32, Lo, Hi.getValue(1));
2772
2773   // Merge the pieces into a single i64 value.
2774  return DAG.getNode(ISD::BUILD_PAIR, dl, MVT::i64, Lo, Hi);
2775 }
2776
2777 static SDValue LowerVSETCC(SDValue Op, SelectionDAG &DAG) {
2778   SDValue TmpOp0, TmpOp1;
2779   bool Invert = false;
2780   bool Swap = false;
2781   unsigned Opc = 0;
2782
2783   SDValue Op0 = Op.getOperand(0);
2784   SDValue Op1 = Op.getOperand(1);
2785   SDValue CC = Op.getOperand(2);
2786   EVT VT = Op.getValueType();
2787   ISD::CondCode SetCCOpcode = cast<CondCodeSDNode>(CC)->get();
2788   DebugLoc dl = Op.getDebugLoc();
2789
2790   if (Op.getOperand(1).getValueType().isFloatingPoint()) {
2791     switch (SetCCOpcode) {
2792     default: llvm_unreachable("Illegal FP comparison"); break;
2793     case ISD::SETUNE:
2794     case ISD::SETNE:  Invert = true; // Fallthrough
2795     case ISD::SETOEQ:
2796     case ISD::SETEQ:  Opc = ARMISD::VCEQ; break;
2797     case ISD::SETOLT:
2798     case ISD::SETLT: Swap = true; // Fallthrough
2799     case ISD::SETOGT:
2800     case ISD::SETGT:  Opc = ARMISD::VCGT; break;
2801     case ISD::SETOLE:
2802     case ISD::SETLE:  Swap = true; // Fallthrough
2803     case ISD::SETOGE:
2804     case ISD::SETGE: Opc = ARMISD::VCGE; break;
2805     case ISD::SETUGE: Swap = true; // Fallthrough
2806     case ISD::SETULE: Invert = true; Opc = ARMISD::VCGT; break;
2807     case ISD::SETUGT: Swap = true; // Fallthrough
2808     case ISD::SETULT: Invert = true; Opc = ARMISD::VCGE; break;
2809     case ISD::SETUEQ: Invert = true; // Fallthrough
2810     case ISD::SETONE:
2811       // Expand this to (OLT | OGT).
2812       TmpOp0 = Op0;
2813       TmpOp1 = Op1;
2814       Opc = ISD::OR;
2815       Op0 = DAG.getNode(ARMISD::VCGT, dl, VT, TmpOp1, TmpOp0);
2816       Op1 = DAG.getNode(ARMISD::VCGT, dl, VT, TmpOp0, TmpOp1);
2817       break;
2818     case ISD::SETUO: Invert = true; // Fallthrough
2819     case ISD::SETO:
2820       // Expand this to (OLT | OGE).
2821       TmpOp0 = Op0;
2822       TmpOp1 = Op1;
2823       Opc = ISD::OR;
2824       Op0 = DAG.getNode(ARMISD::VCGT, dl, VT, TmpOp1, TmpOp0);
2825       Op1 = DAG.getNode(ARMISD::VCGE, dl, VT, TmpOp0, TmpOp1);
2826       break;
2827     }
2828   } else {
2829     // Integer comparisons.
2830     switch (SetCCOpcode) {
2831     default: llvm_unreachable("Illegal integer comparison"); break;
2832     case ISD::SETNE:  Invert = true;
2833     case ISD::SETEQ:  Opc = ARMISD::VCEQ; break;
2834     case ISD::SETLT:  Swap = true;
2835     case ISD::SETGT:  Opc = ARMISD::VCGT; break;
2836     case ISD::SETLE:  Swap = true;
2837     case ISD::SETGE:  Opc = ARMISD::VCGE; break;
2838     case ISD::SETULT: Swap = true;
2839     case ISD::SETUGT: Opc = ARMISD::VCGTU; break;
2840     case ISD::SETULE: Swap = true;
2841     case ISD::SETUGE: Opc = ARMISD::VCGEU; break;
2842     }
2843
2844     // Detect VTST (Vector Test Bits) = icmp ne (and (op0, op1), zero).
2845     if (Opc == ARMISD::VCEQ) {
2846
2847       SDValue AndOp;
2848       if (ISD::isBuildVectorAllZeros(Op1.getNode()))
2849         AndOp = Op0;
2850       else if (ISD::isBuildVectorAllZeros(Op0.getNode()))
2851         AndOp = Op1;
2852
2853       // Ignore bitconvert.
2854       if (AndOp.getNode() && AndOp.getOpcode() == ISD::BIT_CONVERT)
2855         AndOp = AndOp.getOperand(0);
2856
2857       if (AndOp.getNode() && AndOp.getOpcode() == ISD::AND) {
2858         Opc = ARMISD::VTST;
2859         Op0 = DAG.getNode(ISD::BIT_CONVERT, dl, VT, AndOp.getOperand(0));
2860         Op1 = DAG.getNode(ISD::BIT_CONVERT, dl, VT, AndOp.getOperand(1));
2861         Invert = !Invert;
2862       }
2863     }
2864   }
2865
2866   if (Swap)
2867     std::swap(Op0, Op1);
2868
2869   SDValue Result = DAG.getNode(Opc, dl, VT, Op0, Op1);
2870
2871   if (Invert)
2872     Result = DAG.getNOT(dl, Result, VT);
2873
2874   return Result;
2875 }
2876
2877 /// isNEONModifiedImm - Check if the specified splat value corresponds to a
2878 /// valid vector constant for a NEON instruction with a "modified immediate"
2879 /// operand (e.g., VMOV).  If so, return the encoded value.
2880 static SDValue isNEONModifiedImm(uint64_t SplatBits, uint64_t SplatUndef,
2881                                  unsigned SplatBitSize, SelectionDAG &DAG,
2882                                  EVT &VT, bool is128Bits, bool isVMOV) {
2883   unsigned OpCmode, Imm;
2884
2885   // SplatBitSize is set to the smallest size that splats the vector, so a
2886   // zero vector will always have SplatBitSize == 8.  However, NEON modified
2887   // immediate instructions others than VMOV do not support the 8-bit encoding
2888   // of a zero vector, and the default encoding of zero is supposed to be the
2889   // 32-bit version.
2890   if (SplatBits == 0)
2891     SplatBitSize = 32;
2892
2893   switch (SplatBitSize) {
2894   case 8:
2895     if (!isVMOV)
2896       return SDValue();
2897     // Any 1-byte value is OK.  Op=0, Cmode=1110.
2898     assert((SplatBits & ~0xff) == 0 && "one byte splat value is too big");
2899     OpCmode = 0xe;
2900     Imm = SplatBits;
2901     VT = is128Bits ? MVT::v16i8 : MVT::v8i8;
2902     break;
2903
2904   case 16:
2905     // NEON's 16-bit VMOV supports splat values where only one byte is nonzero.
2906     VT = is128Bits ? MVT::v8i16 : MVT::v4i16;
2907     if ((SplatBits & ~0xff) == 0) {
2908       // Value = 0x00nn: Op=x, Cmode=100x.
2909       OpCmode = 0x8;
2910       Imm = SplatBits;
2911       break;
2912     }
2913     if ((SplatBits & ~0xff00) == 0) {
2914       // Value = 0xnn00: Op=x, Cmode=101x.
2915       OpCmode = 0xa;
2916       Imm = SplatBits >> 8;
2917       break;
2918     }
2919     return SDValue();
2920
2921   case 32:
2922     // NEON's 32-bit VMOV supports splat values where:
2923     // * only one byte is nonzero, or
2924     // * the least significant byte is 0xff and the second byte is nonzero, or
2925     // * the least significant 2 bytes are 0xff and the third is nonzero.
2926     VT = is128Bits ? MVT::v4i32 : MVT::v2i32;
2927     if ((SplatBits & ~0xff) == 0) {
2928       // Value = 0x000000nn: Op=x, Cmode=000x.
2929       OpCmode = 0;
2930       Imm = SplatBits;
2931       break;
2932     }
2933     if ((SplatBits & ~0xff00) == 0) {
2934       // Value = 0x0000nn00: Op=x, Cmode=001x.
2935       OpCmode = 0x2;
2936       Imm = SplatBits >> 8;
2937       break;
2938     }
2939     if ((SplatBits & ~0xff0000) == 0) {
2940       // Value = 0x00nn0000: Op=x, Cmode=010x.
2941       OpCmode = 0x4;
2942       Imm = SplatBits >> 16;
2943       break;
2944     }
2945     if ((SplatBits & ~0xff000000) == 0) {
2946       // Value = 0xnn000000: Op=x, Cmode=011x.
2947       OpCmode = 0x6;
2948       Imm = SplatBits >> 24;
2949       break;
2950     }
2951
2952     if ((SplatBits & ~0xffff) == 0 &&
2953         ((SplatBits | SplatUndef) & 0xff) == 0xff) {
2954       // Value = 0x0000nnff: Op=x, Cmode=1100.
2955       OpCmode = 0xc;
2956       Imm = SplatBits >> 8;
2957       SplatBits |= 0xff;
2958       break;
2959     }
2960
2961     if ((SplatBits & ~0xffffff) == 0 &&
2962         ((SplatBits | SplatUndef) & 0xffff) == 0xffff) {
2963       // Value = 0x00nnffff: Op=x, Cmode=1101.
2964       OpCmode = 0xd;
2965       Imm = SplatBits >> 16;
2966       SplatBits |= 0xffff;
2967       break;
2968     }
2969
2970     // Note: there are a few 32-bit splat values (specifically: 00ffff00,
2971     // ff000000, ff0000ff, and ffff00ff) that are valid for VMOV.I64 but not
2972     // VMOV.I32.  A (very) minor optimization would be to replicate the value
2973     // and fall through here to test for a valid 64-bit splat.  But, then the
2974     // caller would also need to check and handle the change in size.
2975     return SDValue();
2976
2977   case 64: {
2978     if (!isVMOV)
2979       return SDValue();
2980     // NEON has a 64-bit VMOV splat where each byte is either 0 or 0xff.
2981     uint64_t BitMask = 0xff;
2982     uint64_t Val = 0;
2983     unsigned ImmMask = 1;
2984     Imm = 0;
2985     for (int ByteNum = 0; ByteNum < 8; ++ByteNum) {
2986       if (((SplatBits | SplatUndef) & BitMask) == BitMask) {
2987         Val |= BitMask;
2988         Imm |= ImmMask;
2989       } else if ((SplatBits & BitMask) != 0) {
2990         return SDValue();
2991       }
2992       BitMask <<= 8;
2993       ImmMask <<= 1;
2994     }
2995     // Op=1, Cmode=1110.
2996     OpCmode = 0x1e;
2997     SplatBits = Val;
2998     VT = is128Bits ? MVT::v2i64 : MVT::v1i64;
2999     break;
3000   }
3001
3002   default:
3003     llvm_unreachable("unexpected size for isNEONModifiedImm");
3004     return SDValue();
3005   }
3006
3007   unsigned EncodedVal = ARM_AM::createNEONModImm(OpCmode, Imm);
3008   return DAG.getTargetConstant(EncodedVal, MVT::i32);
3009 }
3010
3011 static bool isVEXTMask(const SmallVectorImpl<int> &M, EVT VT,
3012                        bool &ReverseVEXT, unsigned &Imm) {
3013   unsigned NumElts = VT.getVectorNumElements();
3014   ReverseVEXT = false;
3015
3016   // Assume that the first shuffle index is not UNDEF.  Fail if it is.
3017   if (M[0] < 0)
3018     return false;
3019
3020   Imm = M[0];
3021
3022   // If this is a VEXT shuffle, the immediate value is the index of the first
3023   // element.  The other shuffle indices must be the successive elements after
3024   // the first one.
3025   unsigned ExpectedElt = Imm;
3026   for (unsigned i = 1; i < NumElts; ++i) {
3027     // Increment the expected index.  If it wraps around, it may still be
3028     // a VEXT but the source vectors must be swapped.
3029     ExpectedElt += 1;
3030     if (ExpectedElt == NumElts * 2) {
3031       ExpectedElt = 0;
3032       ReverseVEXT = true;
3033     }
3034
3035     if (M[i] < 0) continue; // ignore UNDEF indices
3036     if (ExpectedElt != static_cast<unsigned>(M[i]))
3037       return false;
3038   }
3039
3040   // Adjust the index value if the source operands will be swapped.
3041   if (ReverseVEXT)
3042     Imm -= NumElts;
3043
3044   return true;
3045 }
3046
3047 /// isVREVMask - Check if a vector shuffle corresponds to a VREV
3048 /// instruction with the specified blocksize.  (The order of the elements
3049 /// within each block of the vector is reversed.)
3050 static bool isVREVMask(const SmallVectorImpl<int> &M, EVT VT,
3051                        unsigned BlockSize) {
3052   assert((BlockSize==16 || BlockSize==32 || BlockSize==64) &&
3053          "Only possible block sizes for VREV are: 16, 32, 64");
3054
3055   unsigned EltSz = VT.getVectorElementType().getSizeInBits();
3056   if (EltSz == 64)
3057     return false;
3058
3059   unsigned NumElts = VT.getVectorNumElements();
3060   unsigned BlockElts = M[0] + 1;
3061   // If the first shuffle index is UNDEF, be optimistic.
3062   if (M[0] < 0)
3063     BlockElts = BlockSize / EltSz;
3064
3065   if (BlockSize <= EltSz || BlockSize != BlockElts * EltSz)
3066     return false;
3067
3068   for (unsigned i = 0; i < NumElts; ++i) {
3069     if (M[i] < 0) continue; // ignore UNDEF indices
3070     if ((unsigned) M[i] != (i - i%BlockElts) + (BlockElts - 1 - i%BlockElts))
3071       return false;
3072   }
3073
3074   return true;
3075 }
3076
3077 static bool isVTRNMask(const SmallVectorImpl<int> &M, EVT VT,
3078                        unsigned &WhichResult) {
3079   unsigned EltSz = VT.getVectorElementType().getSizeInBits();
3080   if (EltSz == 64)
3081     return false;
3082
3083   unsigned NumElts = VT.getVectorNumElements();
3084   WhichResult = (M[0] == 0 ? 0 : 1);
3085   for (unsigned i = 0; i < NumElts; i += 2) {
3086     if ((M[i] >= 0 && (unsigned) M[i] != i + WhichResult) ||
3087         (M[i+1] >= 0 && (unsigned) M[i+1] != i + NumElts + WhichResult))
3088       return false;
3089   }
3090   return true;
3091 }
3092
3093 /// isVTRN_v_undef_Mask - Special case of isVTRNMask for canonical form of
3094 /// "vector_shuffle v, v", i.e., "vector_shuffle v, undef".
3095 /// Mask is e.g., <0, 0, 2, 2> instead of <0, 4, 2, 6>.
3096 static bool isVTRN_v_undef_Mask(const SmallVectorImpl<int> &M, EVT VT,
3097                                 unsigned &WhichResult) {
3098   unsigned EltSz = VT.getVectorElementType().getSizeInBits();
3099   if (EltSz == 64)
3100     return false;
3101
3102   unsigned NumElts = VT.getVectorNumElements();
3103   WhichResult = (M[0] == 0 ? 0 : 1);
3104   for (unsigned i = 0; i < NumElts; i += 2) {
3105     if ((M[i] >= 0 && (unsigned) M[i] != i + WhichResult) ||
3106         (M[i+1] >= 0 && (unsigned) M[i+1] != i + WhichResult))
3107       return false;
3108   }
3109   return true;
3110 }
3111
3112 static bool isVUZPMask(const SmallVectorImpl<int> &M, EVT VT,
3113                        unsigned &WhichResult) {
3114   unsigned EltSz = VT.getVectorElementType().getSizeInBits();
3115   if (EltSz == 64)
3116     return false;
3117
3118   unsigned NumElts = VT.getVectorNumElements();
3119   WhichResult = (M[0] == 0 ? 0 : 1);
3120   for (unsigned i = 0; i != NumElts; ++i) {
3121     if (M[i] < 0) continue; // ignore UNDEF indices
3122     if ((unsigned) M[i] != 2 * i + WhichResult)
3123       return false;
3124   }
3125
3126   // VUZP.32 for 64-bit vectors is a pseudo-instruction alias for VTRN.32.
3127   if (VT.is64BitVector() && EltSz == 32)
3128     return false;
3129
3130   return true;
3131 }
3132
3133 /// isVUZP_v_undef_Mask - Special case of isVUZPMask for canonical form of
3134 /// "vector_shuffle v, v", i.e., "vector_shuffle v, undef".
3135 /// Mask is e.g., <0, 2, 0, 2> instead of <0, 2, 4, 6>,
3136 static bool isVUZP_v_undef_Mask(const SmallVectorImpl<int> &M, EVT VT,
3137                                 unsigned &WhichResult) {
3138   unsigned EltSz = VT.getVectorElementType().getSizeInBits();
3139   if (EltSz == 64)
3140     return false;
3141
3142   unsigned Half = VT.getVectorNumElements() / 2;
3143   WhichResult = (M[0] == 0 ? 0 : 1);
3144   for (unsigned j = 0; j != 2; ++j) {
3145     unsigned Idx = WhichResult;
3146     for (unsigned i = 0; i != Half; ++i) {
3147       int MIdx = M[i + j * Half];
3148       if (MIdx >= 0 && (unsigned) MIdx != Idx)
3149         return false;
3150       Idx += 2;
3151     }
3152   }
3153
3154   // VUZP.32 for 64-bit vectors is a pseudo-instruction alias for VTRN.32.
3155   if (VT.is64BitVector() && EltSz == 32)
3156     return false;
3157
3158   return true;
3159 }
3160
3161 static bool isVZIPMask(const SmallVectorImpl<int> &M, EVT VT,
3162                        unsigned &WhichResult) {
3163   unsigned EltSz = VT.getVectorElementType().getSizeInBits();
3164   if (EltSz == 64)
3165     return false;
3166
3167   unsigned NumElts = VT.getVectorNumElements();
3168   WhichResult = (M[0] == 0 ? 0 : 1);
3169   unsigned Idx = WhichResult * NumElts / 2;
3170   for (unsigned i = 0; i != NumElts; i += 2) {
3171     if ((M[i] >= 0 && (unsigned) M[i] != Idx) ||
3172         (M[i+1] >= 0 && (unsigned) M[i+1] != Idx + NumElts))
3173       return false;
3174     Idx += 1;
3175   }
3176
3177   // VZIP.32 for 64-bit vectors is a pseudo-instruction alias for VTRN.32.
3178   if (VT.is64BitVector() && EltSz == 32)
3179     return false;
3180
3181   return true;
3182 }
3183
3184 /// isVZIP_v_undef_Mask - Special case of isVZIPMask for canonical form of
3185 /// "vector_shuffle v, v", i.e., "vector_shuffle v, undef".
3186 /// Mask is e.g., <0, 0, 1, 1> instead of <0, 4, 1, 5>.
3187 static bool isVZIP_v_undef_Mask(const SmallVectorImpl<int> &M, EVT VT,
3188                                 unsigned &WhichResult) {
3189   unsigned EltSz = VT.getVectorElementType().getSizeInBits();
3190   if (EltSz == 64)
3191     return false;
3192
3193   unsigned NumElts = VT.getVectorNumElements();
3194   WhichResult = (M[0] == 0 ? 0 : 1);
3195   unsigned Idx = WhichResult * NumElts / 2;
3196   for (unsigned i = 0; i != NumElts; i += 2) {
3197     if ((M[i] >= 0 && (unsigned) M[i] != Idx) ||
3198         (M[i+1] >= 0 && (unsigned) M[i+1] != Idx))
3199       return false;
3200     Idx += 1;
3201   }
3202
3203   // VZIP.32 for 64-bit vectors is a pseudo-instruction alias for VTRN.32.
3204   if (VT.is64BitVector() && EltSz == 32)
3205     return false;
3206
3207   return true;
3208 }
3209
3210 // If N is an integer constant that can be moved into a register in one
3211 // instruction, return an SDValue of such a constant (will become a MOV
3212 // instruction).  Otherwise return null.
3213 static SDValue IsSingleInstrConstant(SDValue N, SelectionDAG &DAG,
3214                                      const ARMSubtarget *ST, DebugLoc dl) {
3215   uint64_t Val;
3216   if (!isa<ConstantSDNode>(N))
3217     return SDValue();
3218   Val = cast<ConstantSDNode>(N)->getZExtValue();
3219
3220   if (ST->isThumb1Only()) {
3221     if (Val <= 255 || ~Val <= 255)
3222       return DAG.getConstant(Val, MVT::i32);
3223   } else {
3224     if (ARM_AM::getSOImmVal(Val) != -1 || ARM_AM::getSOImmVal(~Val) != -1)
3225       return DAG.getConstant(Val, MVT::i32);
3226   }
3227   return SDValue();
3228 }
3229
3230 // If this is a case we can't handle, return null and let the default
3231 // expansion code take care of it.
3232 static SDValue LowerBUILD_VECTOR(SDValue Op, SelectionDAG &DAG,
3233                                  const ARMSubtarget *ST) {
3234   BuildVectorSDNode *BVN = cast<BuildVectorSDNode>(Op.getNode());
3235   DebugLoc dl = Op.getDebugLoc();
3236   EVT VT = Op.getValueType();
3237
3238   APInt SplatBits, SplatUndef;
3239   unsigned SplatBitSize;
3240   bool HasAnyUndefs;
3241   if (BVN->isConstantSplat(SplatBits, SplatUndef, SplatBitSize, HasAnyUndefs)) {
3242     if (SplatBitSize <= 64) {
3243       // Check if an immediate VMOV works.
3244       EVT VmovVT;
3245       SDValue Val = isNEONModifiedImm(SplatBits.getZExtValue(),
3246                                       SplatUndef.getZExtValue(), SplatBitSize,
3247                                       DAG, VmovVT, VT.is128BitVector(), true);
3248       if (Val.getNode()) {
3249         SDValue Vmov = DAG.getNode(ARMISD::VMOVIMM, dl, VmovVT, Val);
3250         return DAG.getNode(ISD::BIT_CONVERT, dl, VT, Vmov);
3251       }
3252
3253       // Try an immediate VMVN.
3254       uint64_t NegatedImm = (SplatBits.getZExtValue() ^
3255                              ((1LL << SplatBitSize) - 1));
3256       Val = isNEONModifiedImm(NegatedImm,
3257                                       SplatUndef.getZExtValue(), SplatBitSize,
3258                                       DAG, VmovVT, VT.is128BitVector(), false);
3259       if (Val.getNode()) {
3260         SDValue Vmov = DAG.getNode(ARMISD::VMVNIMM, dl, VmovVT, Val);
3261         return DAG.getNode(ISD::BIT_CONVERT, dl, VT, Vmov);
3262       }
3263     }
3264   }
3265
3266   // Scan through the operands to see if only one value is used.
3267   unsigned NumElts = VT.getVectorNumElements();
3268   bool isOnlyLowElement = true;
3269   bool usesOnlyOneValue = true;
3270   bool isConstant = true;
3271   SDValue Value;
3272   for (unsigned i = 0; i < NumElts; ++i) {
3273     SDValue V = Op.getOperand(i);
3274     if (V.getOpcode() == ISD::UNDEF)
3275       continue;
3276     if (i > 0)
3277       isOnlyLowElement = false;
3278     if (!isa<ConstantFPSDNode>(V) && !isa<ConstantSDNode>(V))
3279       isConstant = false;
3280
3281     if (!Value.getNode())
3282       Value = V;
3283     else if (V != Value)
3284       usesOnlyOneValue = false;
3285   }
3286
3287   if (!Value.getNode())
3288     return DAG.getUNDEF(VT);
3289
3290   if (isOnlyLowElement)
3291     return DAG.getNode(ISD::SCALAR_TO_VECTOR, dl, VT, Value);
3292
3293   unsigned EltSize = VT.getVectorElementType().getSizeInBits();
3294
3295   if (EnableARMVDUPsplat) {
3296     // Use VDUP for non-constant splats.  For f32 constant splats, reduce to
3297     // i32 and try again.
3298     if (usesOnlyOneValue && EltSize <= 32) {
3299       if (!isConstant)
3300         return DAG.getNode(ARMISD::VDUP, dl, VT, Value);
3301       if (VT.getVectorElementType().isFloatingPoint()) {
3302         SmallVector<SDValue, 8> Ops;
3303         for (unsigned i = 0; i < NumElts; ++i)
3304           Ops.push_back(DAG.getNode(ISD::BIT_CONVERT, dl, MVT::i32,
3305                                     Op.getOperand(i)));
3306         SDValue Val = DAG.getNode(ISD::BUILD_VECTOR, dl, MVT::v4i32, &Ops[0],
3307                                   NumElts);
3308         return DAG.getNode(ISD::BIT_CONVERT, dl, VT,
3309                            LowerBUILD_VECTOR(Val, DAG, ST));
3310       }
3311       SDValue Val = IsSingleInstrConstant(Value, DAG, ST, dl);
3312       if (Val.getNode())
3313         return DAG.getNode(ARMISD::VDUP, dl, VT, Val);
3314     }
3315   }
3316
3317   // If all elements are constants and the case above didn't get hit, fall back
3318   // to the default expansion, which will generate a load from the constant
3319   // pool.
3320   if (isConstant)
3321     return SDValue();
3322
3323   if (!EnableARMVDUPsplat) {
3324     // Use VDUP for non-constant splats.
3325     if (usesOnlyOneValue && EltSize <= 32)
3326       return DAG.getNode(ARMISD::VDUP, dl, VT, Value);
3327   }
3328
3329   // Vectors with 32- or 64-bit elements can be built by directly assigning
3330   // the subregisters.  Lower it to an ARMISD::BUILD_VECTOR so the operands
3331   // will be legalized.
3332   if (EltSize >= 32) {
3333     // Do the expansion with floating-point types, since that is what the VFP
3334     // registers are defined to use, and since i64 is not legal.
3335     EVT EltVT = EVT::getFloatingPointVT(EltSize);
3336     EVT VecVT = EVT::getVectorVT(*DAG.getContext(), EltVT, NumElts);
3337     SmallVector<SDValue, 8> Ops;
3338     for (unsigned i = 0; i < NumElts; ++i)
3339       Ops.push_back(DAG.getNode(ISD::BIT_CONVERT, dl, EltVT, Op.getOperand(i)));
3340     SDValue Val = DAG.getNode(ARMISD::BUILD_VECTOR, dl, VecVT, &Ops[0],NumElts);
3341     return DAG.getNode(ISD::BIT_CONVERT, dl, VT, Val);
3342   }
3343
3344   return SDValue();
3345 }
3346
3347 /// isShuffleMaskLegal - Targets can use this to indicate that they only
3348 /// support *some* VECTOR_SHUFFLE operations, those with specific masks.
3349 /// By default, if a target supports the VECTOR_SHUFFLE node, all mask values
3350 /// are assumed to be legal.
3351 bool
3352 ARMTargetLowering::isShuffleMaskLegal(const SmallVectorImpl<int> &M,
3353                                       EVT VT) const {
3354   if (VT.getVectorNumElements() == 4 &&
3355       (VT.is128BitVector() || VT.is64BitVector())) {
3356     unsigned PFIndexes[4];
3357     for (unsigned i = 0; i != 4; ++i) {
3358       if (M[i] < 0)
3359         PFIndexes[i] = 8;
3360       else
3361         PFIndexes[i] = M[i];
3362     }
3363
3364     // Compute the index in the perfect shuffle table.
3365     unsigned PFTableIndex =
3366       PFIndexes[0]*9*9*9+PFIndexes[1]*9*9+PFIndexes[2]*9+PFIndexes[3];
3367     unsigned PFEntry = PerfectShuffleTable[PFTableIndex];
3368     unsigned Cost = (PFEntry >> 30);
3369
3370     if (Cost <= 4)
3371       return true;
3372   }
3373
3374   bool ReverseVEXT;
3375   unsigned Imm, WhichResult;
3376
3377   unsigned EltSize = VT.getVectorElementType().getSizeInBits();
3378   return (EltSize >= 32 ||
3379           ShuffleVectorSDNode::isSplatMask(&M[0], VT) ||
3380           isVREVMask(M, VT, 64) ||
3381           isVREVMask(M, VT, 32) ||
3382           isVREVMask(M, VT, 16) ||
3383           isVEXTMask(M, VT, ReverseVEXT, Imm) ||
3384           isVTRNMask(M, VT, WhichResult) ||
3385           isVUZPMask(M, VT, WhichResult) ||
3386           isVZIPMask(M, VT, WhichResult) ||
3387           isVTRN_v_undef_Mask(M, VT, WhichResult) ||
3388           isVUZP_v_undef_Mask(M, VT, WhichResult) ||
3389           isVZIP_v_undef_Mask(M, VT, WhichResult));
3390 }
3391
3392 /// GeneratePerfectShuffle - Given an entry in the perfect-shuffle table, emit
3393 /// the specified operations to build the shuffle.
3394 static SDValue GeneratePerfectShuffle(unsigned PFEntry, SDValue LHS,
3395                                       SDValue RHS, SelectionDAG &DAG,
3396                                       DebugLoc dl) {
3397   unsigned OpNum = (PFEntry >> 26) & 0x0F;
3398   unsigned LHSID = (PFEntry >> 13) & ((1 << 13)-1);
3399   unsigned RHSID = (PFEntry >>  0) & ((1 << 13)-1);
3400
3401   enum {
3402     OP_COPY = 0, // Copy, used for things like <u,u,u,3> to say it is <0,1,2,3>
3403     OP_VREV,
3404     OP_VDUP0,
3405     OP_VDUP1,
3406     OP_VDUP2,
3407     OP_VDUP3,
3408     OP_VEXT1,
3409     OP_VEXT2,
3410     OP_VEXT3,
3411     OP_VUZPL, // VUZP, left result
3412     OP_VUZPR, // VUZP, right result
3413     OP_VZIPL, // VZIP, left result
3414     OP_VZIPR, // VZIP, right result
3415     OP_VTRNL, // VTRN, left result
3416     OP_VTRNR  // VTRN, right result
3417   };
3418
3419   if (OpNum == OP_COPY) {
3420     if (LHSID == (1*9+2)*9+3) return LHS;
3421     assert(LHSID == ((4*9+5)*9+6)*9+7 && "Illegal OP_COPY!");
3422     return RHS;
3423   }
3424
3425   SDValue OpLHS, OpRHS;
3426   OpLHS = GeneratePerfectShuffle(PerfectShuffleTable[LHSID], LHS, RHS, DAG, dl);
3427   OpRHS = GeneratePerfectShuffle(PerfectShuffleTable[RHSID], LHS, RHS, DAG, dl);
3428   EVT VT = OpLHS.getValueType();
3429
3430   switch (OpNum) {
3431   default: llvm_unreachable("Unknown shuffle opcode!");
3432   case OP_VREV:
3433     return DAG.getNode(ARMISD::VREV64, dl, VT, OpLHS);
3434   case OP_VDUP0:
3435   case OP_VDUP1:
3436   case OP_VDUP2:
3437   case OP_VDUP3:
3438     return DAG.getNode(ARMISD::VDUPLANE, dl, VT,
3439                        OpLHS, DAG.getConstant(OpNum-OP_VDUP0, MVT::i32));
3440   case OP_VEXT1:
3441   case OP_VEXT2:
3442   case OP_VEXT3:
3443     return DAG.getNode(ARMISD::VEXT, dl, VT,
3444                        OpLHS, OpRHS,
3445                        DAG.getConstant(OpNum-OP_VEXT1+1, MVT::i32));
3446   case OP_VUZPL:
3447   case OP_VUZPR:
3448     return DAG.getNode(ARMISD::VUZP, dl, DAG.getVTList(VT, VT),
3449                        OpLHS, OpRHS).getValue(OpNum-OP_VUZPL);
3450   case OP_VZIPL:
3451   case OP_VZIPR:
3452     return DAG.getNode(ARMISD::VZIP, dl, DAG.getVTList(VT, VT),
3453                        OpLHS, OpRHS).getValue(OpNum-OP_VZIPL);
3454   case OP_VTRNL:
3455   case OP_VTRNR:
3456     return DAG.getNode(ARMISD::VTRN, dl, DAG.getVTList(VT, VT),
3457                        OpLHS, OpRHS).getValue(OpNum-OP_VTRNL);
3458   }
3459 }
3460
3461 static SDValue LowerVECTOR_SHUFFLE(SDValue Op, SelectionDAG &DAG) {
3462   SDValue V1 = Op.getOperand(0);
3463   SDValue V2 = Op.getOperand(1);
3464   DebugLoc dl = Op.getDebugLoc();
3465   EVT VT = Op.getValueType();
3466   ShuffleVectorSDNode *SVN = cast<ShuffleVectorSDNode>(Op.getNode());
3467   SmallVector<int, 8> ShuffleMask;
3468
3469   // Convert shuffles that are directly supported on NEON to target-specific
3470   // DAG nodes, instead of keeping them as shuffles and matching them again
3471   // during code selection.  This is more efficient and avoids the possibility
3472   // of inconsistencies between legalization and selection.
3473   // FIXME: floating-point vectors should be canonicalized to integer vectors
3474   // of the same time so that they get CSEd properly.
3475   SVN->getMask(ShuffleMask);
3476
3477   unsigned EltSize = VT.getVectorElementType().getSizeInBits();
3478   if (EltSize <= 32) {
3479     if (ShuffleVectorSDNode::isSplatMask(&ShuffleMask[0], VT)) {
3480       int Lane = SVN->getSplatIndex();
3481       // If this is undef splat, generate it via "just" vdup, if possible.
3482       if (Lane == -1) Lane = 0;
3483
3484       if (Lane == 0 && V1.getOpcode() == ISD::SCALAR_TO_VECTOR) {
3485         return DAG.getNode(ARMISD::VDUP, dl, VT, V1.getOperand(0));
3486       }
3487       return DAG.getNode(ARMISD::VDUPLANE, dl, VT, V1,
3488                          DAG.getConstant(Lane, MVT::i32));
3489     }
3490
3491     bool ReverseVEXT;
3492     unsigned Imm;
3493     if (isVEXTMask(ShuffleMask, VT, ReverseVEXT, Imm)) {
3494       if (ReverseVEXT)
3495         std::swap(V1, V2);
3496       return DAG.getNode(ARMISD::VEXT, dl, VT, V1, V2,
3497                          DAG.getConstant(Imm, MVT::i32));
3498     }
3499
3500     if (isVREVMask(ShuffleMask, VT, 64))
3501       return DAG.getNode(ARMISD::VREV64, dl, VT, V1);
3502     if (isVREVMask(ShuffleMask, VT, 32))
3503       return DAG.getNode(ARMISD::VREV32, dl, VT, V1);
3504     if (isVREVMask(ShuffleMask, VT, 16))
3505       return DAG.getNode(ARMISD::VREV16, dl, VT, V1);
3506
3507     // Check for Neon shuffles that modify both input vectors in place.
3508     // If both results are used, i.e., if there are two shuffles with the same
3509     // source operands and with masks corresponding to both results of one of
3510     // these operations, DAG memoization will ensure that a single node is
3511     // used for both shuffles.
3512     unsigned WhichResult;
3513     if (isVTRNMask(ShuffleMask, VT, WhichResult))
3514       return DAG.getNode(ARMISD::VTRN, dl, DAG.getVTList(VT, VT),
3515                          V1, V2).getValue(WhichResult);
3516     if (isVUZPMask(ShuffleMask, VT, WhichResult))
3517       return DAG.getNode(ARMISD::VUZP, dl, DAG.getVTList(VT, VT),
3518                          V1, V2).getValue(WhichResult);
3519     if (isVZIPMask(ShuffleMask, VT, WhichResult))
3520       return DAG.getNode(ARMISD::VZIP, dl, DAG.getVTList(VT, VT),
3521                          V1, V2).getValue(WhichResult);
3522
3523     if (isVTRN_v_undef_Mask(ShuffleMask, VT, WhichResult))
3524       return DAG.getNode(ARMISD::VTRN, dl, DAG.getVTList(VT, VT),
3525                          V1, V1).getValue(WhichResult);
3526     if (isVUZP_v_undef_Mask(ShuffleMask, VT, WhichResult))
3527       return DAG.getNode(ARMISD::VUZP, dl, DAG.getVTList(VT, VT),
3528                          V1, V1).getValue(WhichResult);
3529     if (isVZIP_v_undef_Mask(ShuffleMask, VT, WhichResult))
3530       return DAG.getNode(ARMISD::VZIP, dl, DAG.getVTList(VT, VT),
3531                          V1, V1).getValue(WhichResult);
3532   }
3533
3534   // If the shuffle is not directly supported and it has 4 elements, use
3535   // the PerfectShuffle-generated table to synthesize it from other shuffles.
3536   unsigned NumElts = VT.getVectorNumElements();
3537   if (NumElts == 4) {
3538     unsigned PFIndexes[4];
3539     for (unsigned i = 0; i != 4; ++i) {
3540       if (ShuffleMask[i] < 0)
3541         PFIndexes[i] = 8;
3542       else
3543         PFIndexes[i] = ShuffleMask[i];
3544     }
3545
3546     // Compute the index in the perfect shuffle table.
3547     unsigned PFTableIndex =
3548       PFIndexes[0]*9*9*9+PFIndexes[1]*9*9+PFIndexes[2]*9+PFIndexes[3];
3549     unsigned PFEntry = PerfectShuffleTable[PFTableIndex];
3550     unsigned Cost = (PFEntry >> 30);
3551
3552     if (Cost <= 4)
3553       return GeneratePerfectShuffle(PFEntry, V1, V2, DAG, dl);
3554   }
3555
3556   // Implement shuffles with 32- or 64-bit elements as ARMISD::BUILD_VECTORs.
3557   if (EltSize >= 32) {
3558     // Do the expansion with floating-point types, since that is what the VFP
3559     // registers are defined to use, and since i64 is not legal.
3560     EVT EltVT = EVT::getFloatingPointVT(EltSize);
3561     EVT VecVT = EVT::getVectorVT(*DAG.getContext(), EltVT, NumElts);
3562     V1 = DAG.getNode(ISD::BIT_CONVERT, dl, VecVT, V1);
3563     V2 = DAG.getNode(ISD::BIT_CONVERT, dl, VecVT, V2);
3564     SmallVector<SDValue, 8> Ops;
3565     for (unsigned i = 0; i < NumElts; ++i) {
3566       if (ShuffleMask[i] < 0)
3567         Ops.push_back(DAG.getUNDEF(EltVT));
3568       else
3569         Ops.push_back(DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, EltVT,
3570                                   ShuffleMask[i] < (int)NumElts ? V1 : V2,
3571                                   DAG.getConstant(ShuffleMask[i] & (NumElts-1),
3572                                                   MVT::i32)));
3573     }
3574     SDValue Val = DAG.getNode(ARMISD::BUILD_VECTOR, dl, VecVT, &Ops[0],NumElts);
3575     return DAG.getNode(ISD::BIT_CONVERT, dl, VT, Val);
3576   }
3577
3578   return SDValue();
3579 }
3580
3581 static SDValue LowerEXTRACT_VECTOR_ELT(SDValue Op, SelectionDAG &DAG) {
3582   EVT VT = Op.getValueType();
3583   DebugLoc dl = Op.getDebugLoc();
3584   SDValue Vec = Op.getOperand(0);
3585   SDValue Lane = Op.getOperand(1);
3586   assert(VT == MVT::i32 &&
3587          Vec.getValueType().getVectorElementType().getSizeInBits() < 32 &&
3588          "unexpected type for custom-lowering vector extract");
3589   return DAG.getNode(ARMISD::VGETLANEu, dl, MVT::i32, Vec, Lane);
3590 }
3591
3592 static SDValue LowerCONCAT_VECTORS(SDValue Op, SelectionDAG &DAG) {
3593   // The only time a CONCAT_VECTORS operation can have legal types is when
3594   // two 64-bit vectors are concatenated to a 128-bit vector.
3595   assert(Op.getValueType().is128BitVector() && Op.getNumOperands() == 2 &&
3596          "unexpected CONCAT_VECTORS");
3597   DebugLoc dl = Op.getDebugLoc();
3598   SDValue Val = DAG.getUNDEF(MVT::v2f64);
3599   SDValue Op0 = Op.getOperand(0);
3600   SDValue Op1 = Op.getOperand(1);
3601   if (Op0.getOpcode() != ISD::UNDEF)
3602     Val = DAG.getNode(ISD::INSERT_VECTOR_ELT, dl, MVT::v2f64, Val,
3603                       DAG.getNode(ISD::BIT_CONVERT, dl, MVT::f64, Op0),
3604                       DAG.getIntPtrConstant(0));
3605   if (Op1.getOpcode() != ISD::UNDEF)
3606     Val = DAG.getNode(ISD::INSERT_VECTOR_ELT, dl, MVT::v2f64, Val,
3607                       DAG.getNode(ISD::BIT_CONVERT, dl, MVT::f64, Op1),
3608                       DAG.getIntPtrConstant(1));
3609   return DAG.getNode(ISD::BIT_CONVERT, dl, Op.getValueType(), Val);
3610 }
3611
3612 /// SkipExtension - For a node that is either a SIGN_EXTEND, ZERO_EXTEND, or
3613 /// an extending load, return the unextended value.
3614 static SDValue SkipExtension(SDNode *N, SelectionDAG &DAG) {
3615   if (N->getOpcode() == ISD::SIGN_EXTEND || N->getOpcode() == ISD::ZERO_EXTEND)
3616     return N->getOperand(0);
3617   LoadSDNode *LD = cast<LoadSDNode>(N);
3618   return DAG.getLoad(LD->getMemoryVT(), N->getDebugLoc(), LD->getChain(),
3619                      LD->getBasePtr(), LD->getPointerInfo(), LD->isVolatile(),
3620                      LD->isNonTemporal(), LD->getAlignment());
3621 }
3622
3623 static SDValue LowerMUL(SDValue Op, SelectionDAG &DAG) {
3624   // Multiplications are only custom-lowered for 128-bit vectors so that
3625   // VMULL can be detected.  Otherwise v2i64 multiplications are not legal.
3626   EVT VT = Op.getValueType();
3627   assert(VT.is128BitVector() && "unexpected type for custom-lowering ISD::MUL");
3628   SDNode *N0 = Op.getOperand(0).getNode();
3629   SDNode *N1 = Op.getOperand(1).getNode();
3630   unsigned NewOpc = 0;
3631   if ((N0->getOpcode() == ISD::SIGN_EXTEND || ISD::isSEXTLoad(N0)) &&
3632       (N1->getOpcode() == ISD::SIGN_EXTEND || ISD::isSEXTLoad(N1))) {
3633     NewOpc = ARMISD::VMULLs;
3634   } else if ((N0->getOpcode() == ISD::ZERO_EXTEND || ISD::isZEXTLoad(N0)) &&
3635              (N1->getOpcode() == ISD::ZERO_EXTEND || ISD::isZEXTLoad(N1))) {
3636     NewOpc = ARMISD::VMULLu;
3637   } else if (VT.getSimpleVT().SimpleTy == MVT::v2i64) {
3638     // Fall through to expand this.  It is not legal.
3639     return SDValue();
3640   } else {
3641     // Other vector multiplications are legal.
3642     return Op;
3643   }
3644
3645   // Legalize to a VMULL instruction.
3646   DebugLoc DL = Op.getDebugLoc();
3647   SDValue Op0 = SkipExtension(N0, DAG);
3648   SDValue Op1 = SkipExtension(N1, DAG);
3649
3650   assert(Op0.getValueType().is64BitVector() &&
3651          Op1.getValueType().is64BitVector() &&
3652          "unexpected types for extended operands to VMULL");
3653   return DAG.getNode(NewOpc, DL, VT, Op0, Op1);
3654 }
3655
3656 SDValue ARMTargetLowering::LowerOperation(SDValue Op, SelectionDAG &DAG) const {
3657   switch (Op.getOpcode()) {
3658   default: llvm_unreachable("Don't know how to custom lower this!");
3659   case ISD::ConstantPool:  return LowerConstantPool(Op, DAG);
3660   case ISD::BlockAddress:  return LowerBlockAddress(Op, DAG);
3661   case ISD::GlobalAddress:
3662     return Subtarget->isTargetDarwin() ? LowerGlobalAddressDarwin(Op, DAG) :
3663       LowerGlobalAddressELF(Op, DAG);
3664   case ISD::GlobalTLSAddress:   return LowerGlobalTLSAddress(Op, DAG);
3665   case ISD::SELECT:        return LowerSELECT(Op, DAG);
3666   case ISD::SELECT_CC:     return LowerSELECT_CC(Op, DAG);
3667   case ISD::BR_CC:         return LowerBR_CC(Op, DAG);
3668   case ISD::BR_JT:         return LowerBR_JT(Op, DAG);
3669   case ISD::VASTART:       return LowerVASTART(Op, DAG);
3670   case ISD::MEMBARRIER:    return LowerMEMBARRIER(Op, DAG, Subtarget);
3671   case ISD::SINT_TO_FP:
3672   case ISD::UINT_TO_FP:    return LowerINT_TO_FP(Op, DAG);
3673   case ISD::FP_TO_SINT:
3674   case ISD::FP_TO_UINT:    return LowerFP_TO_INT(Op, DAG);
3675   case ISD::FCOPYSIGN:     return LowerFCOPYSIGN(Op, DAG);
3676   case ISD::RETURNADDR:    return LowerRETURNADDR(Op, DAG);
3677   case ISD::FRAMEADDR:     return LowerFRAMEADDR(Op, DAG);
3678   case ISD::GLOBAL_OFFSET_TABLE: return LowerGLOBAL_OFFSET_TABLE(Op, DAG);
3679   case ISD::EH_SJLJ_SETJMP: return LowerEH_SJLJ_SETJMP(Op, DAG);
3680   case ISD::EH_SJLJ_LONGJMP: return LowerEH_SJLJ_LONGJMP(Op, DAG);
3681   case ISD::INTRINSIC_WO_CHAIN: return LowerINTRINSIC_WO_CHAIN(Op, DAG,
3682                                                                Subtarget);
3683   case ISD::BIT_CONVERT:   return ExpandBIT_CONVERT(Op.getNode(), DAG);
3684   case ISD::SHL:
3685   case ISD::SRL:
3686   case ISD::SRA:           return LowerShift(Op.getNode(), DAG, Subtarget);
3687   case ISD::SHL_PARTS:     return LowerShiftLeftParts(Op, DAG);
3688   case ISD::SRL_PARTS:
3689   case ISD::SRA_PARTS:     return LowerShiftRightParts(Op, DAG);
3690   case ISD::CTTZ:          return LowerCTTZ(Op.getNode(), DAG, Subtarget);
3691   case ISD::VSETCC:        return LowerVSETCC(Op, DAG);
3692   case ISD::BUILD_VECTOR:  return LowerBUILD_VECTOR(Op, DAG, Subtarget);
3693   case ISD::VECTOR_SHUFFLE: return LowerVECTOR_SHUFFLE(Op, DAG);
3694   case ISD::EXTRACT_VECTOR_ELT: return LowerEXTRACT_VECTOR_ELT(Op, DAG);
3695   case ISD::CONCAT_VECTORS: return LowerCONCAT_VECTORS(Op, DAG);
3696   case ISD::FLT_ROUNDS_:   return LowerFLT_ROUNDS_(Op, DAG);
3697   case ISD::MUL:           return LowerMUL(Op, DAG);
3698   }
3699   return SDValue();
3700 }
3701
3702 /// ReplaceNodeResults - Replace the results of node with an illegal result
3703 /// type with new values built out of custom code.
3704 void ARMTargetLowering::ReplaceNodeResults(SDNode *N,
3705                                            SmallVectorImpl<SDValue>&Results,
3706                                            SelectionDAG &DAG) const {
3707   SDValue Res;
3708   switch (N->getOpcode()) {
3709   default:
3710     llvm_unreachable("Don't know how to custom expand this!");
3711     break;
3712   case ISD::BIT_CONVERT:
3713     Res = ExpandBIT_CONVERT(N, DAG);
3714     break;
3715   case ISD::SRL:
3716   case ISD::SRA:
3717     Res = LowerShift(N, DAG, Subtarget);
3718     break;
3719   }
3720   if (Res.getNode())
3721     Results.push_back(Res);
3722 }
3723
3724 //===----------------------------------------------------------------------===//
3725 //                           ARM Scheduler Hooks
3726 //===----------------------------------------------------------------------===//
3727
3728 MachineBasicBlock *
3729 ARMTargetLowering::EmitAtomicCmpSwap(MachineInstr *MI,
3730                                      MachineBasicBlock *BB,
3731                                      unsigned Size) const {
3732   unsigned dest    = MI->getOperand(0).getReg();
3733   unsigned ptr     = MI->getOperand(1).getReg();
3734   unsigned oldval  = MI->getOperand(2).getReg();
3735   unsigned newval  = MI->getOperand(3).getReg();
3736   unsigned scratch = BB->getParent()->getRegInfo()
3737     .createVirtualRegister(ARM::GPRRegisterClass);
3738   const TargetInstrInfo *TII = getTargetMachine().getInstrInfo();
3739   DebugLoc dl = MI->getDebugLoc();
3740   bool isThumb2 = Subtarget->isThumb2();
3741
3742   unsigned ldrOpc, strOpc;
3743   switch (Size) {
3744   default: llvm_unreachable("unsupported size for AtomicCmpSwap!");
3745   case 1:
3746     ldrOpc = isThumb2 ? ARM::t2LDREXB : ARM::LDREXB;
3747     strOpc = isThumb2 ? ARM::t2LDREXB : ARM::STREXB;
3748     break;
3749   case 2:
3750     ldrOpc = isThumb2 ? ARM::t2LDREXH : ARM::LDREXH;
3751     strOpc = isThumb2 ? ARM::t2STREXH : ARM::STREXH;
3752     break;
3753   case 4:
3754     ldrOpc = isThumb2 ? ARM::t2LDREX : ARM::LDREX;
3755     strOpc = isThumb2 ? ARM::t2STREX : ARM::STREX;
3756     break;
3757   }
3758
3759   MachineFunction *MF = BB->getParent();
3760   const BasicBlock *LLVM_BB = BB->getBasicBlock();
3761   MachineFunction::iterator It = BB;
3762   ++It; // insert the new blocks after the current block
3763
3764   MachineBasicBlock *loop1MBB = MF->CreateMachineBasicBlock(LLVM_BB);
3765   MachineBasicBlock *loop2MBB = MF->CreateMachineBasicBlock(LLVM_BB);
3766   MachineBasicBlock *exitMBB = MF->CreateMachineBasicBlock(LLVM_BB);
3767   MF->insert(It, loop1MBB);
3768   MF->insert(It, loop2MBB);
3769   MF->insert(It, exitMBB);
3770
3771   // Transfer the remainder of BB and its successor edges to exitMBB.
3772   exitMBB->splice(exitMBB->begin(), BB,
3773                   llvm::next(MachineBasicBlock::iterator(MI)),
3774                   BB->end());
3775   exitMBB->transferSuccessorsAndUpdatePHIs(BB);
3776
3777   //  thisMBB:
3778   //   ...
3779   //   fallthrough --> loop1MBB
3780   BB->addSuccessor(loop1MBB);
3781
3782   // loop1MBB:
3783   //   ldrex dest, [ptr]
3784   //   cmp dest, oldval
3785   //   bne exitMBB
3786   BB = loop1MBB;
3787   AddDefaultPred(BuildMI(BB, dl, TII->get(ldrOpc), dest).addReg(ptr));
3788   AddDefaultPred(BuildMI(BB, dl, TII->get(isThumb2 ? ARM::t2CMPrr : ARM::CMPrr))
3789                  .addReg(dest).addReg(oldval));
3790   BuildMI(BB, dl, TII->get(isThumb2 ? ARM::t2Bcc : ARM::Bcc))
3791     .addMBB(exitMBB).addImm(ARMCC::NE).addReg(ARM::CPSR);
3792   BB->addSuccessor(loop2MBB);
3793   BB->addSuccessor(exitMBB);
3794
3795   // loop2MBB:
3796   //   strex scratch, newval, [ptr]
3797   //   cmp scratch, #0
3798   //   bne loop1MBB
3799   BB = loop2MBB;
3800   AddDefaultPred(BuildMI(BB, dl, TII->get(strOpc), scratch).addReg(newval)
3801                  .addReg(ptr));
3802   AddDefaultPred(BuildMI(BB, dl, TII->get(isThumb2 ? ARM::t2CMPri : ARM::CMPri))
3803                  .addReg(scratch).addImm(0));
3804   BuildMI(BB, dl, TII->get(isThumb2 ? ARM::t2Bcc : ARM::Bcc))
3805     .addMBB(loop1MBB).addImm(ARMCC::NE).addReg(ARM::CPSR);
3806   BB->addSuccessor(loop1MBB);
3807   BB->addSuccessor(exitMBB);
3808
3809   //  exitMBB:
3810   //   ...
3811   BB = exitMBB;
3812
3813   MI->eraseFromParent();   // The instruction is gone now.
3814
3815   return BB;
3816 }
3817
3818 MachineBasicBlock *
3819 ARMTargetLowering::EmitAtomicBinary(MachineInstr *MI, MachineBasicBlock *BB,
3820                                     unsigned Size, unsigned BinOpcode) const {
3821   // This also handles ATOMIC_SWAP, indicated by BinOpcode==0.
3822   const TargetInstrInfo *TII = getTargetMachine().getInstrInfo();
3823
3824   const BasicBlock *LLVM_BB = BB->getBasicBlock();
3825   MachineFunction *MF = BB->getParent();
3826   MachineFunction::iterator It = BB;
3827   ++It;
3828
3829   unsigned dest = MI->getOperand(0).getReg();
3830   unsigned ptr = MI->getOperand(1).getReg();
3831   unsigned incr = MI->getOperand(2).getReg();
3832   DebugLoc dl = MI->getDebugLoc();
3833
3834   bool isThumb2 = Subtarget->isThumb2();
3835   unsigned ldrOpc, strOpc;
3836   switch (Size) {
3837   default: llvm_unreachable("unsupported size for AtomicCmpSwap!");
3838   case 1:
3839     ldrOpc = isThumb2 ? ARM::t2LDREXB : ARM::LDREXB;
3840     strOpc = isThumb2 ? ARM::t2STREXB : ARM::STREXB;
3841     break;
3842   case 2:
3843     ldrOpc = isThumb2 ? ARM::t2LDREXH : ARM::LDREXH;
3844     strOpc = isThumb2 ? ARM::t2STREXH : ARM::STREXH;
3845     break;
3846   case 4:
3847     ldrOpc = isThumb2 ? ARM::t2LDREX : ARM::LDREX;
3848     strOpc = isThumb2 ? ARM::t2STREX : ARM::STREX;
3849     break;
3850   }
3851
3852   MachineBasicBlock *loopMBB = MF->CreateMachineBasicBlock(LLVM_BB);
3853   MachineBasicBlock *exitMBB = MF->CreateMachineBasicBlock(LLVM_BB);
3854   MF->insert(It, loopMBB);
3855   MF->insert(It, exitMBB);
3856
3857   // Transfer the remainder of BB and its successor edges to exitMBB.
3858   exitMBB->splice(exitMBB->begin(), BB,
3859                   llvm::next(MachineBasicBlock::iterator(MI)),
3860                   BB->end());
3861   exitMBB->transferSuccessorsAndUpdatePHIs(BB);
3862
3863   MachineRegisterInfo &RegInfo = MF->getRegInfo();
3864   unsigned scratch = RegInfo.createVirtualRegister(ARM::GPRRegisterClass);
3865   unsigned scratch2 = (!BinOpcode) ? incr :
3866     RegInfo.createVirtualRegister(ARM::GPRRegisterClass);
3867
3868   //  thisMBB:
3869   //   ...
3870   //   fallthrough --> loopMBB
3871   BB->addSuccessor(loopMBB);
3872
3873   //  loopMBB:
3874   //   ldrex dest, ptr
3875   //   <binop> scratch2, dest, incr
3876   //   strex scratch, scratch2, ptr
3877   //   cmp scratch, #0
3878   //   bne- loopMBB
3879   //   fallthrough --> exitMBB
3880   BB = loopMBB;
3881   AddDefaultPred(BuildMI(BB, dl, TII->get(ldrOpc), dest).addReg(ptr));
3882   if (BinOpcode) {
3883     // operand order needs to go the other way for NAND
3884     if (BinOpcode == ARM::BICrr || BinOpcode == ARM::t2BICrr)
3885       AddDefaultPred(BuildMI(BB, dl, TII->get(BinOpcode), scratch2).
3886                      addReg(incr).addReg(dest)).addReg(0);
3887     else
3888       AddDefaultPred(BuildMI(BB, dl, TII->get(BinOpcode), scratch2).
3889                      addReg(dest).addReg(incr)).addReg(0);
3890   }
3891
3892   AddDefaultPred(BuildMI(BB, dl, TII->get(strOpc), scratch).addReg(scratch2)
3893                  .addReg(ptr));
3894   AddDefaultPred(BuildMI(BB, dl, TII->get(isThumb2 ? ARM::t2CMPri : ARM::CMPri))
3895                  .addReg(scratch).addImm(0));
3896   BuildMI(BB, dl, TII->get(isThumb2 ? ARM::t2Bcc : ARM::Bcc))
3897     .addMBB(loopMBB).addImm(ARMCC::NE).addReg(ARM::CPSR);
3898
3899   BB->addSuccessor(loopMBB);
3900   BB->addSuccessor(exitMBB);
3901
3902   //  exitMBB:
3903   //   ...
3904   BB = exitMBB;
3905
3906   MI->eraseFromParent();   // The instruction is gone now.
3907
3908   return BB;
3909 }
3910
3911 static
3912 MachineBasicBlock *OtherSucc(MachineBasicBlock *MBB, MachineBasicBlock *Succ) {
3913   for (MachineBasicBlock::succ_iterator I = MBB->succ_begin(),
3914        E = MBB->succ_end(); I != E; ++I)
3915     if (*I != Succ)
3916       return *I;
3917   llvm_unreachable("Expecting a BB with two successors!");
3918 }
3919
3920 MachineBasicBlock *
3921 ARMTargetLowering::EmitInstrWithCustomInserter(MachineInstr *MI,
3922                                                MachineBasicBlock *BB) const {
3923   const TargetInstrInfo *TII = getTargetMachine().getInstrInfo();
3924   DebugLoc dl = MI->getDebugLoc();
3925   bool isThumb2 = Subtarget->isThumb2();
3926   switch (MI->getOpcode()) {
3927   default:
3928     MI->dump();
3929     llvm_unreachable("Unexpected instr type to insert");
3930
3931   case ARM::ATOMIC_LOAD_ADD_I8:
3932      return EmitAtomicBinary(MI, BB, 1, isThumb2 ? ARM::t2ADDrr : ARM::ADDrr);
3933   case ARM::ATOMIC_LOAD_ADD_I16:
3934      return EmitAtomicBinary(MI, BB, 2, isThumb2 ? ARM::t2ADDrr : ARM::ADDrr);
3935   case ARM::ATOMIC_LOAD_ADD_I32:
3936      return EmitAtomicBinary(MI, BB, 4, isThumb2 ? ARM::t2ADDrr : ARM::ADDrr);
3937
3938   case ARM::ATOMIC_LOAD_AND_I8:
3939      return EmitAtomicBinary(MI, BB, 1, isThumb2 ? ARM::t2ANDrr : ARM::ANDrr);
3940   case ARM::ATOMIC_LOAD_AND_I16:
3941      return EmitAtomicBinary(MI, BB, 2, isThumb2 ? ARM::t2ANDrr : ARM::ANDrr);
3942   case ARM::ATOMIC_LOAD_AND_I32:
3943      return EmitAtomicBinary(MI, BB, 4, isThumb2 ? ARM::t2ANDrr : ARM::ANDrr);
3944
3945   case ARM::ATOMIC_LOAD_OR_I8:
3946      return EmitAtomicBinary(MI, BB, 1, isThumb2 ? ARM::t2ORRrr : ARM::ORRrr);
3947   case ARM::ATOMIC_LOAD_OR_I16:
3948      return EmitAtomicBinary(MI, BB, 2, isThumb2 ? ARM::t2ORRrr : ARM::ORRrr);
3949   case ARM::ATOMIC_LOAD_OR_I32:
3950      return EmitAtomicBinary(MI, BB, 4, isThumb2 ? ARM::t2ORRrr : ARM::ORRrr);
3951
3952   case ARM::ATOMIC_LOAD_XOR_I8:
3953      return EmitAtomicBinary(MI, BB, 1, isThumb2 ? ARM::t2EORrr : ARM::EORrr);
3954   case ARM::ATOMIC_LOAD_XOR_I16:
3955      return EmitAtomicBinary(MI, BB, 2, isThumb2 ? ARM::t2EORrr : ARM::EORrr);
3956   case ARM::ATOMIC_LOAD_XOR_I32:
3957      return EmitAtomicBinary(MI, BB, 4, isThumb2 ? ARM::t2EORrr : ARM::EORrr);
3958
3959   case ARM::ATOMIC_LOAD_NAND_I8:
3960      return EmitAtomicBinary(MI, BB, 1, isThumb2 ? ARM::t2BICrr : ARM::BICrr);
3961   case ARM::ATOMIC_LOAD_NAND_I16:
3962      return EmitAtomicBinary(MI, BB, 2, isThumb2 ? ARM::t2BICrr : ARM::BICrr);
3963   case ARM::ATOMIC_LOAD_NAND_I32:
3964      return EmitAtomicBinary(MI, BB, 4, isThumb2 ? ARM::t2BICrr : ARM::BICrr);
3965
3966   case ARM::ATOMIC_LOAD_SUB_I8:
3967      return EmitAtomicBinary(MI, BB, 1, isThumb2 ? ARM::t2SUBrr : ARM::SUBrr);
3968   case ARM::ATOMIC_LOAD_SUB_I16:
3969      return EmitAtomicBinary(MI, BB, 2, isThumb2 ? ARM::t2SUBrr : ARM::SUBrr);
3970   case ARM::ATOMIC_LOAD_SUB_I32:
3971      return EmitAtomicBinary(MI, BB, 4, isThumb2 ? ARM::t2SUBrr : ARM::SUBrr);
3972
3973   case ARM::ATOMIC_SWAP_I8:  return EmitAtomicBinary(MI, BB, 1, 0);
3974   case ARM::ATOMIC_SWAP_I16: return EmitAtomicBinary(MI, BB, 2, 0);
3975   case ARM::ATOMIC_SWAP_I32: return EmitAtomicBinary(MI, BB, 4, 0);
3976
3977   case ARM::ATOMIC_CMP_SWAP_I8:  return EmitAtomicCmpSwap(MI, BB, 1);
3978   case ARM::ATOMIC_CMP_SWAP_I16: return EmitAtomicCmpSwap(MI, BB, 2);
3979   case ARM::ATOMIC_CMP_SWAP_I32: return EmitAtomicCmpSwap(MI, BB, 4);
3980
3981   case ARM::tMOVCCr_pseudo: {
3982     // To "insert" a SELECT_CC instruction, we actually have to insert the
3983     // diamond control-flow pattern.  The incoming instruction knows the
3984     // destination vreg to set, the condition code register to branch on, the
3985     // true/false values to select between, and a branch opcode to use.
3986     const BasicBlock *LLVM_BB = BB->getBasicBlock();
3987     MachineFunction::iterator It = BB;
3988     ++It;
3989
3990     //  thisMBB:
3991     //  ...
3992     //   TrueVal = ...
3993     //   cmpTY ccX, r1, r2
3994     //   bCC copy1MBB
3995     //   fallthrough --> copy0MBB
3996     MachineBasicBlock *thisMBB  = BB;
3997     MachineFunction *F = BB->getParent();
3998     MachineBasicBlock *copy0MBB = F->CreateMachineBasicBlock(LLVM_BB);
3999     MachineBasicBlock *sinkMBB  = F->CreateMachineBasicBlock(LLVM_BB);
4000     F->insert(It, copy0MBB);
4001     F->insert(It, sinkMBB);
4002
4003     // Transfer the remainder of BB and its successor edges to sinkMBB.
4004     sinkMBB->splice(sinkMBB->begin(), BB,
4005                     llvm::next(MachineBasicBlock::iterator(MI)),
4006                     BB->end());
4007     sinkMBB->transferSuccessorsAndUpdatePHIs(BB);
4008
4009     BB->addSuccessor(copy0MBB);
4010     BB->addSuccessor(sinkMBB);
4011
4012     BuildMI(BB, dl, TII->get(ARM::tBcc)).addMBB(sinkMBB)
4013       .addImm(MI->getOperand(3).getImm()).addReg(MI->getOperand(4).getReg());
4014
4015     //  copy0MBB:
4016     //   %FalseValue = ...
4017     //   # fallthrough to sinkMBB
4018     BB = copy0MBB;
4019
4020     // Update machine-CFG edges
4021     BB->addSuccessor(sinkMBB);
4022
4023     //  sinkMBB:
4024     //   %Result = phi [ %FalseValue, copy0MBB ], [ %TrueValue, thisMBB ]
4025     //  ...
4026     BB = sinkMBB;
4027     BuildMI(*BB, BB->begin(), dl,
4028             TII->get(ARM::PHI), MI->getOperand(0).getReg())
4029       .addReg(MI->getOperand(1).getReg()).addMBB(copy0MBB)
4030       .addReg(MI->getOperand(2).getReg()).addMBB(thisMBB);
4031
4032     MI->eraseFromParent();   // The pseudo instruction is gone now.
4033     return BB;
4034   }
4035
4036   case ARM::BCCi64:
4037   case ARM::BCCZi64: {
4038     // Compare both parts that make up the double comparison separately for
4039     // equality.
4040     bool RHSisZero = MI->getOpcode() == ARM::BCCZi64;
4041
4042     unsigned LHS1 = MI->getOperand(1).getReg();
4043     unsigned LHS2 = MI->getOperand(2).getReg();
4044     if (RHSisZero) {
4045       AddDefaultPred(BuildMI(BB, dl,
4046                              TII->get(isThumb2 ? ARM::t2CMPri : ARM::CMPri))
4047                      .addReg(LHS1).addImm(0));
4048       BuildMI(BB, dl, TII->get(isThumb2 ? ARM::t2CMPri : ARM::CMPri))
4049         .addReg(LHS2).addImm(0)
4050         .addImm(ARMCC::EQ).addReg(ARM::CPSR);
4051     } else {
4052       unsigned RHS1 = MI->getOperand(3).getReg();
4053       unsigned RHS2 = MI->getOperand(4).getReg();
4054       AddDefaultPred(BuildMI(BB, dl,
4055                              TII->get(isThumb2 ? ARM::t2CMPrr : ARM::CMPrr))
4056                      .addReg(LHS1).addReg(RHS1));
4057       BuildMI(BB, dl, TII->get(isThumb2 ? ARM::t2CMPrr : ARM::CMPrr))
4058         .addReg(LHS2).addReg(RHS2)
4059         .addImm(ARMCC::EQ).addReg(ARM::CPSR);
4060     }
4061
4062     MachineBasicBlock *destMBB = MI->getOperand(RHSisZero ? 3 : 5).getMBB();
4063     MachineBasicBlock *exitMBB = OtherSucc(BB, destMBB);
4064     if (MI->getOperand(0).getImm() == ARMCC::NE)
4065       std::swap(destMBB, exitMBB);
4066
4067     BuildMI(BB, dl, TII->get(isThumb2 ? ARM::t2Bcc : ARM::Bcc))
4068       .addMBB(destMBB).addImm(ARMCC::EQ).addReg(ARM::CPSR);
4069     BuildMI(BB, dl, TII->get(isThumb2 ? ARM::t2B : ARM::B))
4070       .addMBB(exitMBB);
4071
4072     MI->eraseFromParent();   // The pseudo instruction is gone now.
4073     return BB;
4074   }
4075   }
4076 }
4077
4078 //===----------------------------------------------------------------------===//
4079 //                           ARM Optimization Hooks
4080 //===----------------------------------------------------------------------===//
4081
4082 static
4083 SDValue combineSelectAndUse(SDNode *N, SDValue Slct, SDValue OtherOp,
4084                             TargetLowering::DAGCombinerInfo &DCI) {
4085   SelectionDAG &DAG = DCI.DAG;
4086   const TargetLowering &TLI = DAG.getTargetLoweringInfo();
4087   EVT VT = N->getValueType(0);
4088   unsigned Opc = N->getOpcode();
4089   bool isSlctCC = Slct.getOpcode() == ISD::SELECT_CC;
4090   SDValue LHS = isSlctCC ? Slct.getOperand(2) : Slct.getOperand(1);
4091   SDValue RHS = isSlctCC ? Slct.getOperand(3) : Slct.getOperand(2);
4092   ISD::CondCode CC = ISD::SETCC_INVALID;
4093
4094   if (isSlctCC) {
4095     CC = cast<CondCodeSDNode>(Slct.getOperand(4))->get();
4096   } else {
4097     SDValue CCOp = Slct.getOperand(0);
4098     if (CCOp.getOpcode() == ISD::SETCC)
4099       CC = cast<CondCodeSDNode>(CCOp.getOperand(2))->get();
4100   }
4101
4102   bool DoXform = false;
4103   bool InvCC = false;
4104   assert ((Opc == ISD::ADD || (Opc == ISD::SUB && Slct == N->getOperand(1))) &&
4105           "Bad input!");
4106
4107   if (LHS.getOpcode() == ISD::Constant &&
4108       cast<ConstantSDNode>(LHS)->isNullValue()) {
4109     DoXform = true;
4110   } else if (CC != ISD::SETCC_INVALID &&
4111              RHS.getOpcode() == ISD::Constant &&
4112              cast<ConstantSDNode>(RHS)->isNullValue()) {
4113     std::swap(LHS, RHS);
4114     SDValue Op0 = Slct.getOperand(0);
4115     EVT OpVT = isSlctCC ? Op0.getValueType() :
4116                           Op0.getOperand(0).getValueType();
4117     bool isInt = OpVT.isInteger();
4118     CC = ISD::getSetCCInverse(CC, isInt);
4119
4120     if (!TLI.isCondCodeLegal(CC, OpVT))
4121       return SDValue();         // Inverse operator isn't legal.
4122
4123     DoXform = true;
4124     InvCC = true;
4125   }
4126
4127   if (DoXform) {
4128     SDValue Result = DAG.getNode(Opc, RHS.getDebugLoc(), VT, OtherOp, RHS);
4129     if (isSlctCC)
4130       return DAG.getSelectCC(N->getDebugLoc(), OtherOp, Result,
4131                              Slct.getOperand(0), Slct.getOperand(1), CC);
4132     SDValue CCOp = Slct.getOperand(0);
4133     if (InvCC)
4134       CCOp = DAG.getSetCC(Slct.getDebugLoc(), CCOp.getValueType(),
4135                           CCOp.getOperand(0), CCOp.getOperand(1), CC);
4136     return DAG.getNode(ISD::SELECT, N->getDebugLoc(), VT,
4137                        CCOp, OtherOp, Result);
4138   }
4139   return SDValue();
4140 }
4141
4142 /// PerformADDCombineWithOperands - Try DAG combinations for an ADD with
4143 /// operands N0 and N1.  This is a helper for PerformADDCombine that is
4144 /// called with the default operands, and if that fails, with commuted
4145 /// operands.
4146 static SDValue PerformADDCombineWithOperands(SDNode *N, SDValue N0, SDValue N1,
4147                                          TargetLowering::DAGCombinerInfo &DCI) {
4148   // fold (add (select cc, 0, c), x) -> (select cc, x, (add, x, c))
4149   if (N0.getOpcode() == ISD::SELECT && N0.getNode()->hasOneUse()) {
4150     SDValue Result = combineSelectAndUse(N, N0, N1, DCI);
4151     if (Result.getNode()) return Result;
4152   }
4153   return SDValue();
4154 }
4155
4156 /// PerformADDCombine - Target-specific dag combine xforms for ISD::ADD.
4157 ///
4158 static SDValue PerformADDCombine(SDNode *N,
4159                                  TargetLowering::DAGCombinerInfo &DCI) {
4160   SDValue N0 = N->getOperand(0);
4161   SDValue N1 = N->getOperand(1);
4162
4163   // First try with the default operand order.
4164   SDValue Result = PerformADDCombineWithOperands(N, N0, N1, DCI);
4165   if (Result.getNode())
4166     return Result;
4167
4168   // If that didn't work, try again with the operands commuted.
4169   return PerformADDCombineWithOperands(N, N1, N0, DCI);
4170 }
4171
4172 /// PerformSUBCombine - Target-specific dag combine xforms for ISD::SUB.
4173 ///
4174 static SDValue PerformSUBCombine(SDNode *N,
4175                                  TargetLowering::DAGCombinerInfo &DCI) {
4176   SDValue N0 = N->getOperand(0);
4177   SDValue N1 = N->getOperand(1);
4178
4179   // fold (sub x, (select cc, 0, c)) -> (select cc, x, (sub, x, c))
4180   if (N1.getOpcode() == ISD::SELECT && N1.getNode()->hasOneUse()) {
4181     SDValue Result = combineSelectAndUse(N, N1, N0, DCI);
4182     if (Result.getNode()) return Result;
4183   }
4184
4185   return SDValue();
4186 }
4187
4188 static SDValue PerformMULCombine(SDNode *N,
4189                                  TargetLowering::DAGCombinerInfo &DCI,
4190                                  const ARMSubtarget *Subtarget) {
4191   SelectionDAG &DAG = DCI.DAG;
4192
4193   if (Subtarget->isThumb1Only())
4194     return SDValue();
4195
4196   if (DAG.getMachineFunction().
4197       getFunction()->hasFnAttr(Attribute::OptimizeForSize))
4198     return SDValue();
4199
4200   if (DCI.isBeforeLegalize() || DCI.isCalledByLegalizer())
4201     return SDValue();
4202
4203   EVT VT = N->getValueType(0);
4204   if (VT != MVT::i32)
4205     return SDValue();
4206
4207   ConstantSDNode *C = dyn_cast<ConstantSDNode>(N->getOperand(1));
4208   if (!C)
4209     return SDValue();
4210
4211   uint64_t MulAmt = C->getZExtValue();
4212   unsigned ShiftAmt = CountTrailingZeros_64(MulAmt);
4213   ShiftAmt = ShiftAmt & (32 - 1);
4214   SDValue V = N->getOperand(0);
4215   DebugLoc DL = N->getDebugLoc();
4216
4217   SDValue Res;
4218   MulAmt >>= ShiftAmt;
4219   if (isPowerOf2_32(MulAmt - 1)) {
4220     // (mul x, 2^N + 1) => (add (shl x, N), x)
4221     Res = DAG.getNode(ISD::ADD, DL, VT,
4222                       V, DAG.getNode(ISD::SHL, DL, VT,
4223                                      V, DAG.getConstant(Log2_32(MulAmt-1),
4224                                                         MVT::i32)));
4225   } else if (isPowerOf2_32(MulAmt + 1)) {
4226     // (mul x, 2^N - 1) => (sub (shl x, N), x)
4227     Res = DAG.getNode(ISD::SUB, DL, VT,
4228                       DAG.getNode(ISD::SHL, DL, VT,
4229                                   V, DAG.getConstant(Log2_32(MulAmt+1),
4230                                                      MVT::i32)),
4231                                                      V);
4232   } else
4233     return SDValue();
4234
4235   if (ShiftAmt != 0)
4236     Res = DAG.getNode(ISD::SHL, DL, VT, Res,
4237                       DAG.getConstant(ShiftAmt, MVT::i32));
4238
4239   // Do not add new nodes to DAG combiner worklist.
4240   DCI.CombineTo(N, Res, false);
4241   return SDValue();
4242 }
4243
4244 /// PerformORCombine - Target-specific dag combine xforms for ISD::OR
4245 static SDValue PerformORCombine(SDNode *N,
4246                                 TargetLowering::DAGCombinerInfo &DCI,
4247                                 const ARMSubtarget *Subtarget) {
4248   // Try to use the ARM/Thumb2 BFI (bitfield insert) instruction when
4249   // reasonable.
4250
4251   // BFI is only available on V6T2+
4252   if (Subtarget->isThumb1Only() || !Subtarget->hasV6T2Ops())
4253     return SDValue();
4254
4255   SelectionDAG &DAG = DCI.DAG;
4256   SDValue N0 = N->getOperand(0), N1 = N->getOperand(1);
4257   DebugLoc DL = N->getDebugLoc();
4258   // 1) or (and A, mask), val => ARMbfi A, val, mask
4259   //      iff (val & mask) == val
4260   //
4261   // 2) or (and A, mask), (and B, mask2) => ARMbfi A, (lsr B, amt), mask
4262   //  2a) iff isBitFieldInvertedMask(mask) && isBitFieldInvertedMask(~mask2)
4263   //          && CountPopulation_32(mask) == CountPopulation_32(~mask2)
4264   //  2b) iff isBitFieldInvertedMask(~mask) && isBitFieldInvertedMask(mask2)
4265   //          && CountPopulation_32(mask) == CountPopulation_32(~mask2)
4266   //  (i.e., copy a bitfield value into another bitfield of the same width)
4267   if (N0.getOpcode() != ISD::AND)
4268     return SDValue();
4269
4270   EVT VT = N->getValueType(0);
4271   if (VT != MVT::i32)
4272     return SDValue();
4273
4274
4275   // The value and the mask need to be constants so we can verify this is
4276   // actually a bitfield set. If the mask is 0xffff, we can do better
4277   // via a movt instruction, so don't use BFI in that case.
4278   ConstantSDNode *C = dyn_cast<ConstantSDNode>(N0.getOperand(1));
4279   if (!C)
4280     return SDValue();
4281   unsigned Mask = C->getZExtValue();
4282   if (Mask == 0xffff)
4283     return SDValue();
4284   SDValue Res;
4285   // Case (1): or (and A, mask), val => ARMbfi A, val, mask
4286   if ((C = dyn_cast<ConstantSDNode>(N1))) {
4287     unsigned Val = C->getZExtValue();
4288     if (!ARM::isBitFieldInvertedMask(Mask) || (Val & ~Mask) != Val)
4289       return SDValue();
4290     Val >>= CountTrailingZeros_32(~Mask);
4291
4292     Res = DAG.getNode(ARMISD::BFI, DL, VT, N0.getOperand(0),
4293                       DAG.getConstant(Val, MVT::i32),
4294                       DAG.getConstant(Mask, MVT::i32));
4295
4296     // Do not add new nodes to DAG combiner worklist.
4297     DCI.CombineTo(N, Res, false);
4298   } else if (N1.getOpcode() == ISD::AND) {
4299     // case (2) or (and A, mask), (and B, mask2) => ARMbfi A, (lsr B, amt), mask
4300     C = dyn_cast<ConstantSDNode>(N1.getOperand(1));
4301     if (!C)
4302       return SDValue();
4303     unsigned Mask2 = C->getZExtValue();
4304
4305     if (ARM::isBitFieldInvertedMask(Mask) &&
4306         ARM::isBitFieldInvertedMask(~Mask2) &&
4307         (CountPopulation_32(Mask) == CountPopulation_32(~Mask2))) {
4308       // The pack halfword instruction works better for masks that fit it,
4309       // so use that when it's available.
4310       if (Subtarget->hasT2ExtractPack() &&
4311           (Mask == 0xffff || Mask == 0xffff0000))
4312         return SDValue();
4313       // 2a
4314       unsigned lsb = CountTrailingZeros_32(Mask2);
4315       Res = DAG.getNode(ISD::SRL, DL, VT, N1.getOperand(0),
4316                         DAG.getConstant(lsb, MVT::i32));
4317       Res = DAG.getNode(ARMISD::BFI, DL, VT, N0.getOperand(0), Res,
4318                         DAG.getConstant(Mask, MVT::i32));
4319       // Do not add new nodes to DAG combiner worklist.
4320       DCI.CombineTo(N, Res, false);
4321     } else if (ARM::isBitFieldInvertedMask(~Mask) &&
4322                ARM::isBitFieldInvertedMask(Mask2) &&
4323                (CountPopulation_32(~Mask) == CountPopulation_32(Mask2))) {
4324       // The pack halfword instruction works better for masks that fit it,
4325       // so use that when it's available.
4326       if (Subtarget->hasT2ExtractPack() &&
4327           (Mask2 == 0xffff || Mask2 == 0xffff0000))
4328         return SDValue();
4329       // 2b
4330       unsigned lsb = CountTrailingZeros_32(Mask);
4331       Res = DAG.getNode(ISD::SRL, DL, VT, N0.getOperand(0),
4332                         DAG.getConstant(lsb, MVT::i32));
4333       Res = DAG.getNode(ARMISD::BFI, DL, VT, N1.getOperand(0), Res,
4334                                 DAG.getConstant(Mask2, MVT::i32));
4335       // Do not add new nodes to DAG combiner worklist.
4336       DCI.CombineTo(N, Res, false);
4337     }
4338   }
4339
4340   return SDValue();
4341 }
4342
4343 /// PerformBUILD_VECTORCombine - Target-specific dag combine xforms for
4344 /// ISD::BUILD_VECTOR.
4345 static SDValue PerformBUILD_VECTORCombine(SDNode *N, SelectionDAG &DAG) {
4346   // build_vector(N=ARMISD::VMOVRRD(X), N:1) -> bit_convert(X):
4347   // VMOVRRD is introduced when legalizing i64 types.  It forces the i64 value
4348   // into a pair of GPRs, which is fine when the value is used as a scalar,
4349   // but if the i64 value is converted to a vector, we need to undo the VMOVRRD.
4350   if (N->getNumOperands() == 2) {
4351     SDValue Op0 = N->getOperand(0);
4352     SDValue Op1 = N->getOperand(1);
4353     if (Op0.getOpcode() == ISD::BIT_CONVERT)
4354       Op0 = Op0.getOperand(0);
4355     if (Op1.getOpcode() == ISD::BIT_CONVERT)
4356       Op1 = Op1.getOperand(0);
4357     if (Op0.getOpcode() == ARMISD::VMOVRRD &&
4358         Op0.getNode() == Op1.getNode() &&
4359         Op0.getResNo() == 0 && Op1.getResNo() == 1) {
4360       return DAG.getNode(ISD::BIT_CONVERT, N->getDebugLoc(),
4361                          N->getValueType(0), Op0.getOperand(0));
4362     }
4363   }
4364
4365   return SDValue();
4366 }
4367
4368 /// PerformVMOVRRDCombine - Target-specific dag combine xforms for
4369 /// ARMISD::VMOVRRD.
4370 static SDValue PerformVMOVRRDCombine(SDNode *N,
4371                                    TargetLowering::DAGCombinerInfo &DCI) {
4372   // fmrrd(fmdrr x, y) -> x,y
4373   SDValue InDouble = N->getOperand(0);
4374   if (InDouble.getOpcode() == ARMISD::VMOVDRR)
4375     return DCI.CombineTo(N, InDouble.getOperand(0), InDouble.getOperand(1));
4376   return SDValue();
4377 }
4378
4379 /// PerformVDUPLANECombine - Target-specific dag combine xforms for
4380 /// ARMISD::VDUPLANE.
4381 static SDValue PerformVDUPLANECombine(SDNode *N,
4382                                       TargetLowering::DAGCombinerInfo &DCI) {
4383   // If the source is already a VMOVIMM or VMVNIMM splat, the VDUPLANE is
4384   // redundant.
4385   SDValue Op = N->getOperand(0);
4386   EVT VT = N->getValueType(0);
4387
4388   // Ignore bit_converts.
4389   while (Op.getOpcode() == ISD::BIT_CONVERT)
4390     Op = Op.getOperand(0);
4391   if (Op.getOpcode() != ARMISD::VMOVIMM && Op.getOpcode() != ARMISD::VMVNIMM)
4392     return SDValue();
4393
4394   // Make sure the VMOV element size is not bigger than the VDUPLANE elements.
4395   unsigned EltSize = Op.getValueType().getVectorElementType().getSizeInBits();
4396   // The canonical VMOV for a zero vector uses a 32-bit element size.
4397   unsigned Imm = cast<ConstantSDNode>(Op.getOperand(0))->getZExtValue();
4398   unsigned EltBits;
4399   if (ARM_AM::decodeNEONModImm(Imm, EltBits) == 0)
4400     EltSize = 8;
4401   if (EltSize > VT.getVectorElementType().getSizeInBits())
4402     return SDValue();
4403
4404   SDValue Res = DCI.DAG.getNode(ISD::BIT_CONVERT, N->getDebugLoc(), VT, Op);
4405   return DCI.CombineTo(N, Res, false);
4406 }
4407
4408 /// getVShiftImm - Check if this is a valid build_vector for the immediate
4409 /// operand of a vector shift operation, where all the elements of the
4410 /// build_vector must have the same constant integer value.
4411 static bool getVShiftImm(SDValue Op, unsigned ElementBits, int64_t &Cnt) {
4412   // Ignore bit_converts.
4413   while (Op.getOpcode() == ISD::BIT_CONVERT)
4414     Op = Op.getOperand(0);
4415   BuildVectorSDNode *BVN = dyn_cast<BuildVectorSDNode>(Op.getNode());
4416   APInt SplatBits, SplatUndef;
4417   unsigned SplatBitSize;
4418   bool HasAnyUndefs;
4419   if (! BVN || ! BVN->isConstantSplat(SplatBits, SplatUndef, SplatBitSize,
4420                                       HasAnyUndefs, ElementBits) ||
4421       SplatBitSize > ElementBits)
4422     return false;
4423   Cnt = SplatBits.getSExtValue();
4424   return true;
4425 }
4426
4427 /// isVShiftLImm - Check if this is a valid build_vector for the immediate
4428 /// operand of a vector shift left operation.  That value must be in the range:
4429 ///   0 <= Value < ElementBits for a left shift; or
4430 ///   0 <= Value <= ElementBits for a long left shift.
4431 static bool isVShiftLImm(SDValue Op, EVT VT, bool isLong, int64_t &Cnt) {
4432   assert(VT.isVector() && "vector shift count is not a vector type");
4433   unsigned ElementBits = VT.getVectorElementType().getSizeInBits();
4434   if (! getVShiftImm(Op, ElementBits, Cnt))
4435     return false;
4436   return (Cnt >= 0 && (isLong ? Cnt-1 : Cnt) < ElementBits);
4437 }
4438
4439 /// isVShiftRImm - Check if this is a valid build_vector for the immediate
4440 /// operand of a vector shift right operation.  For a shift opcode, the value
4441 /// is positive, but for an intrinsic the value count must be negative. The
4442 /// absolute value must be in the range:
4443 ///   1 <= |Value| <= ElementBits for a right shift; or
4444 ///   1 <= |Value| <= ElementBits/2 for a narrow right shift.
4445 static bool isVShiftRImm(SDValue Op, EVT VT, bool isNarrow, bool isIntrinsic,
4446                          int64_t &Cnt) {
4447   assert(VT.isVector() && "vector shift count is not a vector type");
4448   unsigned ElementBits = VT.getVectorElementType().getSizeInBits();
4449   if (! getVShiftImm(Op, ElementBits, Cnt))
4450     return false;
4451   if (isIntrinsic)
4452     Cnt = -Cnt;
4453   return (Cnt >= 1 && Cnt <= (isNarrow ? ElementBits/2 : ElementBits));
4454 }
4455
4456 /// PerformIntrinsicCombine - ARM-specific DAG combining for intrinsics.
4457 static SDValue PerformIntrinsicCombine(SDNode *N, SelectionDAG &DAG) {
4458   unsigned IntNo = cast<ConstantSDNode>(N->getOperand(0))->getZExtValue();
4459   switch (IntNo) {
4460   default:
4461     // Don't do anything for most intrinsics.
4462     break;
4463
4464   // Vector shifts: check for immediate versions and lower them.
4465   // Note: This is done during DAG combining instead of DAG legalizing because
4466   // the build_vectors for 64-bit vector element shift counts are generally
4467   // not legal, and it is hard to see their values after they get legalized to
4468   // loads from a constant pool.
4469   case Intrinsic::arm_neon_vshifts:
4470   case Intrinsic::arm_neon_vshiftu:
4471   case Intrinsic::arm_neon_vshiftls:
4472   case Intrinsic::arm_neon_vshiftlu:
4473   case Intrinsic::arm_neon_vshiftn:
4474   case Intrinsic::arm_neon_vrshifts:
4475   case Intrinsic::arm_neon_vrshiftu:
4476   case Intrinsic::arm_neon_vrshiftn:
4477   case Intrinsic::arm_neon_vqshifts:
4478   case Intrinsic::arm_neon_vqshiftu:
4479   case Intrinsic::arm_neon_vqshiftsu:
4480   case Intrinsic::arm_neon_vqshiftns:
4481   case Intrinsic::arm_neon_vqshiftnu:
4482   case Intrinsic::arm_neon_vqshiftnsu:
4483   case Intrinsic::arm_neon_vqrshiftns:
4484   case Intrinsic::arm_neon_vqrshiftnu:
4485   case Intrinsic::arm_neon_vqrshiftnsu: {
4486     EVT VT = N->getOperand(1).getValueType();
4487     int64_t Cnt;
4488     unsigned VShiftOpc = 0;
4489
4490     switch (IntNo) {
4491     case Intrinsic::arm_neon_vshifts:
4492     case Intrinsic::arm_neon_vshiftu:
4493       if (isVShiftLImm(N->getOperand(2), VT, false, Cnt)) {
4494         VShiftOpc = ARMISD::VSHL;
4495         break;
4496       }
4497       if (isVShiftRImm(N->getOperand(2), VT, false, true, Cnt)) {
4498         VShiftOpc = (IntNo == Intrinsic::arm_neon_vshifts ?
4499                      ARMISD::VSHRs : ARMISD::VSHRu);
4500         break;
4501       }
4502       return SDValue();
4503
4504     case Intrinsic::arm_neon_vshiftls:
4505     case Intrinsic::arm_neon_vshiftlu:
4506       if (isVShiftLImm(N->getOperand(2), VT, true, Cnt))
4507         break;
4508       llvm_unreachable("invalid shift count for vshll intrinsic");
4509
4510     case Intrinsic::arm_neon_vrshifts:
4511     case Intrinsic::arm_neon_vrshiftu:
4512       if (isVShiftRImm(N->getOperand(2), VT, false, true, Cnt))
4513         break;
4514       return SDValue();
4515
4516     case Intrinsic::arm_neon_vqshifts:
4517     case Intrinsic::arm_neon_vqshiftu:
4518       if (isVShiftLImm(N->getOperand(2), VT, false, Cnt))
4519         break;
4520       return SDValue();
4521
4522     case Intrinsic::arm_neon_vqshiftsu:
4523       if (isVShiftLImm(N->getOperand(2), VT, false, Cnt))
4524         break;
4525       llvm_unreachable("invalid shift count for vqshlu intrinsic");
4526
4527     case Intrinsic::arm_neon_vshiftn:
4528     case Intrinsic::arm_neon_vrshiftn:
4529     case Intrinsic::arm_neon_vqshiftns:
4530     case Intrinsic::arm_neon_vqshiftnu:
4531     case Intrinsic::arm_neon_vqshiftnsu:
4532     case Intrinsic::arm_neon_vqrshiftns:
4533     case Intrinsic::arm_neon_vqrshiftnu:
4534     case Intrinsic::arm_neon_vqrshiftnsu:
4535       // Narrowing shifts require an immediate right shift.
4536       if (isVShiftRImm(N->getOperand(2), VT, true, true, Cnt))
4537         break;
4538       llvm_unreachable("invalid shift count for narrowing vector shift "
4539                        "intrinsic");
4540
4541     default:
4542       llvm_unreachable("unhandled vector shift");
4543     }
4544
4545     switch (IntNo) {
4546     case Intrinsic::arm_neon_vshifts:
4547     case Intrinsic::arm_neon_vshiftu:
4548       // Opcode already set above.
4549       break;
4550     case Intrinsic::arm_neon_vshiftls:
4551     case Intrinsic::arm_neon_vshiftlu:
4552       if (Cnt == VT.getVectorElementType().getSizeInBits())
4553         VShiftOpc = ARMISD::VSHLLi;
4554       else
4555         VShiftOpc = (IntNo == Intrinsic::arm_neon_vshiftls ?
4556                      ARMISD::VSHLLs : ARMISD::VSHLLu);
4557       break;
4558     case Intrinsic::arm_neon_vshiftn:
4559       VShiftOpc = ARMISD::VSHRN; break;
4560     case Intrinsic::arm_neon_vrshifts:
4561       VShiftOpc = ARMISD::VRSHRs; break;
4562     case Intrinsic::arm_neon_vrshiftu:
4563       VShiftOpc = ARMISD::VRSHRu; break;
4564     case Intrinsic::arm_neon_vrshiftn:
4565       VShiftOpc = ARMISD::VRSHRN; break;
4566     case Intrinsic::arm_neon_vqshifts:
4567       VShiftOpc = ARMISD::VQSHLs; break;
4568     case Intrinsic::arm_neon_vqshiftu:
4569       VShiftOpc = ARMISD::VQSHLu; break;
4570     case Intrinsic::arm_neon_vqshiftsu:
4571       VShiftOpc = ARMISD::VQSHLsu; break;
4572     case Intrinsic::arm_neon_vqshiftns:
4573       VShiftOpc = ARMISD::VQSHRNs; break;
4574     case Intrinsic::arm_neon_vqshiftnu:
4575       VShiftOpc = ARMISD::VQSHRNu; break;
4576     case Intrinsic::arm_neon_vqshiftnsu:
4577       VShiftOpc = ARMISD::VQSHRNsu; break;
4578     case Intrinsic::arm_neon_vqrshiftns:
4579       VShiftOpc = ARMISD::VQRSHRNs; break;
4580     case Intrinsic::arm_neon_vqrshiftnu:
4581       VShiftOpc = ARMISD::VQRSHRNu; break;
4582     case Intrinsic::arm_neon_vqrshiftnsu:
4583       VShiftOpc = ARMISD::VQRSHRNsu; break;
4584     }
4585
4586     return DAG.getNode(VShiftOpc, N->getDebugLoc(), N->getValueType(0),
4587                        N->getOperand(1), DAG.getConstant(Cnt, MVT::i32));
4588   }
4589
4590   case Intrinsic::arm_neon_vshiftins: {
4591     EVT VT = N->getOperand(1).getValueType();
4592     int64_t Cnt;
4593     unsigned VShiftOpc = 0;
4594
4595     if (isVShiftLImm(N->getOperand(3), VT, false, Cnt))
4596       VShiftOpc = ARMISD::VSLI;
4597     else if (isVShiftRImm(N->getOperand(3), VT, false, true, Cnt))
4598       VShiftOpc = ARMISD::VSRI;
4599     else {
4600       llvm_unreachable("invalid shift count for vsli/vsri intrinsic");
4601     }
4602
4603     return DAG.getNode(VShiftOpc, N->getDebugLoc(), N->getValueType(0),
4604                        N->getOperand(1), N->getOperand(2),
4605                        DAG.getConstant(Cnt, MVT::i32));
4606   }
4607
4608   case Intrinsic::arm_neon_vqrshifts:
4609   case Intrinsic::arm_neon_vqrshiftu:
4610     // No immediate versions of these to check for.
4611     break;
4612   }
4613
4614   return SDValue();
4615 }
4616
4617 /// PerformShiftCombine - Checks for immediate versions of vector shifts and
4618 /// lowers them.  As with the vector shift intrinsics, this is done during DAG
4619 /// combining instead of DAG legalizing because the build_vectors for 64-bit
4620 /// vector element shift counts are generally not legal, and it is hard to see
4621 /// their values after they get legalized to loads from a constant pool.
4622 static SDValue PerformShiftCombine(SDNode *N, SelectionDAG &DAG,
4623                                    const ARMSubtarget *ST) {
4624   EVT VT = N->getValueType(0);
4625
4626   // Nothing to be done for scalar shifts.
4627   if (! VT.isVector())
4628     return SDValue();
4629
4630   assert(ST->hasNEON() && "unexpected vector shift");
4631   int64_t Cnt;
4632
4633   switch (N->getOpcode()) {
4634   default: llvm_unreachable("unexpected shift opcode");
4635
4636   case ISD::SHL:
4637     if (isVShiftLImm(N->getOperand(1), VT, false, Cnt))
4638       return DAG.getNode(ARMISD::VSHL, N->getDebugLoc(), VT, N->getOperand(0),
4639                          DAG.getConstant(Cnt, MVT::i32));
4640     break;
4641
4642   case ISD::SRA:
4643   case ISD::SRL:
4644     if (isVShiftRImm(N->getOperand(1), VT, false, false, Cnt)) {
4645       unsigned VShiftOpc = (N->getOpcode() == ISD::SRA ?
4646                             ARMISD::VSHRs : ARMISD::VSHRu);
4647       return DAG.getNode(VShiftOpc, N->getDebugLoc(), VT, N->getOperand(0),
4648                          DAG.getConstant(Cnt, MVT::i32));
4649     }
4650   }
4651   return SDValue();
4652 }
4653
4654 /// PerformExtendCombine - Target-specific DAG combining for ISD::SIGN_EXTEND,
4655 /// ISD::ZERO_EXTEND, and ISD::ANY_EXTEND.
4656 static SDValue PerformExtendCombine(SDNode *N, SelectionDAG &DAG,
4657                                     const ARMSubtarget *ST) {
4658   SDValue N0 = N->getOperand(0);
4659
4660   // Check for sign- and zero-extensions of vector extract operations of 8-
4661   // and 16-bit vector elements.  NEON supports these directly.  They are
4662   // handled during DAG combining because type legalization will promote them
4663   // to 32-bit types and it is messy to recognize the operations after that.
4664   if (ST->hasNEON() && N0.getOpcode() == ISD::EXTRACT_VECTOR_ELT) {
4665     SDValue Vec = N0.getOperand(0);
4666     SDValue Lane = N0.getOperand(1);
4667     EVT VT = N->getValueType(0);
4668     EVT EltVT = N0.getValueType();
4669     const TargetLowering &TLI = DAG.getTargetLoweringInfo();
4670
4671     if (VT == MVT::i32 &&
4672         (EltVT == MVT::i8 || EltVT == MVT::i16) &&
4673         TLI.isTypeLegal(Vec.getValueType())) {
4674
4675       unsigned Opc = 0;
4676       switch (N->getOpcode()) {
4677       default: llvm_unreachable("unexpected opcode");
4678       case ISD::SIGN_EXTEND:
4679         Opc = ARMISD::VGETLANEs;
4680         break;
4681       case ISD::ZERO_EXTEND:
4682       case ISD::ANY_EXTEND:
4683         Opc = ARMISD::VGETLANEu;
4684         break;
4685       }
4686       return DAG.getNode(Opc, N->getDebugLoc(), VT, Vec, Lane);
4687     }
4688   }
4689
4690   return SDValue();
4691 }
4692
4693 /// PerformSELECT_CCCombine - Target-specific DAG combining for ISD::SELECT_CC
4694 /// to match f32 max/min patterns to use NEON vmax/vmin instructions.
4695 static SDValue PerformSELECT_CCCombine(SDNode *N, SelectionDAG &DAG,
4696                                        const ARMSubtarget *ST) {
4697   // If the target supports NEON, try to use vmax/vmin instructions for f32
4698   // selects like "x < y ? x : y".  Unless the NoNaNsFPMath option is set,
4699   // be careful about NaNs:  NEON's vmax/vmin return NaN if either operand is
4700   // a NaN; only do the transformation when it matches that behavior.
4701
4702   // For now only do this when using NEON for FP operations; if using VFP, it
4703   // is not obvious that the benefit outweighs the cost of switching to the
4704   // NEON pipeline.
4705   if (!ST->hasNEON() || !ST->useNEONForSinglePrecisionFP() ||
4706       N->getValueType(0) != MVT::f32)
4707     return SDValue();
4708
4709   SDValue CondLHS = N->getOperand(0);
4710   SDValue CondRHS = N->getOperand(1);
4711   SDValue LHS = N->getOperand(2);
4712   SDValue RHS = N->getOperand(3);
4713   ISD::CondCode CC = cast<CondCodeSDNode>(N->getOperand(4))->get();
4714
4715   unsigned Opcode = 0;
4716   bool IsReversed;
4717   if (DAG.isEqualTo(LHS, CondLHS) && DAG.isEqualTo(RHS, CondRHS)) {
4718     IsReversed = false; // x CC y ? x : y
4719   } else if (DAG.isEqualTo(LHS, CondRHS) && DAG.isEqualTo(RHS, CondLHS)) {
4720     IsReversed = true ; // x CC y ? y : x
4721   } else {
4722     return SDValue();
4723   }
4724
4725   bool IsUnordered;
4726   switch (CC) {
4727   default: break;
4728   case ISD::SETOLT:
4729   case ISD::SETOLE:
4730   case ISD::SETLT:
4731   case ISD::SETLE:
4732   case ISD::SETULT:
4733   case ISD::SETULE:
4734     // If LHS is NaN, an ordered comparison will be false and the result will
4735     // be the RHS, but vmin(NaN, RHS) = NaN.  Avoid this by checking that LHS
4736     // != NaN.  Likewise, for unordered comparisons, check for RHS != NaN.
4737     IsUnordered = (CC == ISD::SETULT || CC == ISD::SETULE);
4738     if (!DAG.isKnownNeverNaN(IsUnordered ? RHS : LHS))
4739       break;
4740     // For less-than-or-equal comparisons, "+0 <= -0" will be true but vmin
4741     // will return -0, so vmin can only be used for unsafe math or if one of
4742     // the operands is known to be nonzero.
4743     if ((CC == ISD::SETLE || CC == ISD::SETOLE || CC == ISD::SETULE) &&
4744         !UnsafeFPMath &&
4745         !(DAG.isKnownNeverZero(LHS) || DAG.isKnownNeverZero(RHS)))
4746       break;
4747     Opcode = IsReversed ? ARMISD::FMAX : ARMISD::FMIN;
4748     break;
4749
4750   case ISD::SETOGT:
4751   case ISD::SETOGE:
4752   case ISD::SETGT:
4753   case ISD::SETGE:
4754   case ISD::SETUGT:
4755   case ISD::SETUGE:
4756     // If LHS is NaN, an ordered comparison will be false and the result will
4757     // be the RHS, but vmax(NaN, RHS) = NaN.  Avoid this by checking that LHS
4758     // != NaN.  Likewise, for unordered comparisons, check for RHS != NaN.
4759     IsUnordered = (CC == ISD::SETUGT || CC == ISD::SETUGE);
4760     if (!DAG.isKnownNeverNaN(IsUnordered ? RHS : LHS))
4761       break;
4762     // For greater-than-or-equal comparisons, "-0 >= +0" will be true but vmax
4763     // will return +0, so vmax can only be used for unsafe math or if one of
4764     // the operands is known to be nonzero.
4765     if ((CC == ISD::SETGE || CC == ISD::SETOGE || CC == ISD::SETUGE) &&
4766         !UnsafeFPMath &&
4767         !(DAG.isKnownNeverZero(LHS) || DAG.isKnownNeverZero(RHS)))
4768       break;
4769     Opcode = IsReversed ? ARMISD::FMIN : ARMISD::FMAX;
4770     break;
4771   }
4772
4773   if (!Opcode)
4774     return SDValue();
4775   return DAG.getNode(Opcode, N->getDebugLoc(), N->getValueType(0), LHS, RHS);
4776 }
4777
4778 SDValue ARMTargetLowering::PerformDAGCombine(SDNode *N,
4779                                              DAGCombinerInfo &DCI) const {
4780   switch (N->getOpcode()) {
4781   default: break;
4782   case ISD::ADD:        return PerformADDCombine(N, DCI);
4783   case ISD::SUB:        return PerformSUBCombine(N, DCI);
4784   case ISD::MUL:        return PerformMULCombine(N, DCI, Subtarget);
4785   case ISD::OR:         return PerformORCombine(N, DCI, Subtarget);
4786   case ISD::BUILD_VECTOR: return PerformBUILD_VECTORCombine(N, DCI.DAG);
4787   case ARMISD::VMOVRRD: return PerformVMOVRRDCombine(N, DCI);
4788   case ARMISD::VDUPLANE: return PerformVDUPLANECombine(N, DCI);
4789   case ISD::INTRINSIC_WO_CHAIN: return PerformIntrinsicCombine(N, DCI.DAG);
4790   case ISD::SHL:
4791   case ISD::SRA:
4792   case ISD::SRL:        return PerformShiftCombine(N, DCI.DAG, Subtarget);
4793   case ISD::SIGN_EXTEND:
4794   case ISD::ZERO_EXTEND:
4795   case ISD::ANY_EXTEND: return PerformExtendCombine(N, DCI.DAG, Subtarget);
4796   case ISD::SELECT_CC:  return PerformSELECT_CCCombine(N, DCI.DAG, Subtarget);
4797   }
4798   return SDValue();
4799 }
4800
4801 bool ARMTargetLowering::allowsUnalignedMemoryAccesses(EVT VT) const {
4802   if (!Subtarget->hasV6Ops())
4803     // Pre-v6 does not support unaligned mem access.
4804     return false;
4805
4806   // v6+ may or may not support unaligned mem access depending on the system
4807   // configuration.
4808   // FIXME: This is pretty conservative. Should we provide cmdline option to
4809   // control the behaviour?
4810   if (!Subtarget->isTargetDarwin())
4811     return false;
4812
4813   switch (VT.getSimpleVT().SimpleTy) {
4814   default:
4815     return false;
4816   case MVT::i8:
4817   case MVT::i16:
4818   case MVT::i32:
4819     return true;
4820   // FIXME: VLD1 etc with standard alignment is legal.
4821   }
4822 }
4823
4824 static bool isLegalT1AddressImmediate(int64_t V, EVT VT) {
4825   if (V < 0)
4826     return false;
4827
4828   unsigned Scale = 1;
4829   switch (VT.getSimpleVT().SimpleTy) {
4830   default: return false;
4831   case MVT::i1:
4832   case MVT::i8:
4833     // Scale == 1;
4834     break;
4835   case MVT::i16:
4836     // Scale == 2;
4837     Scale = 2;
4838     break;
4839   case MVT::i32:
4840     // Scale == 4;
4841     Scale = 4;
4842     break;
4843   }
4844
4845   if ((V & (Scale - 1)) != 0)
4846     return false;
4847   V /= Scale;
4848   return V == (V & ((1LL << 5) - 1));
4849 }
4850
4851 static bool isLegalT2AddressImmediate(int64_t V, EVT VT,
4852                                       const ARMSubtarget *Subtarget) {
4853   bool isNeg = false;
4854   if (V < 0) {
4855     isNeg = true;
4856     V = - V;
4857   }
4858
4859   switch (VT.getSimpleVT().SimpleTy) {
4860   default: return false;
4861   case MVT::i1:
4862   case MVT::i8:
4863   case MVT::i16:
4864   case MVT::i32:
4865     // + imm12 or - imm8
4866     if (isNeg)
4867       return V == (V & ((1LL << 8) - 1));
4868     return V == (V & ((1LL << 12) - 1));
4869   case MVT::f32:
4870   case MVT::f64:
4871     // Same as ARM mode. FIXME: NEON?
4872     if (!Subtarget->hasVFP2())
4873       return false;
4874     if ((V & 3) != 0)
4875       return false;
4876     V >>= 2;
4877     return V == (V & ((1LL << 8) - 1));
4878   }
4879 }
4880
4881 /// isLegalAddressImmediate - Return true if the integer value can be used
4882 /// as the offset of the target addressing mode for load / store of the
4883 /// given type.
4884 static bool isLegalAddressImmediate(int64_t V, EVT VT,
4885                                     const ARMSubtarget *Subtarget) {
4886   if (V == 0)
4887     return true;
4888
4889   if (!VT.isSimple())
4890     return false;
4891
4892   if (Subtarget->isThumb1Only())
4893     return isLegalT1AddressImmediate(V, VT);
4894   else if (Subtarget->isThumb2())
4895     return isLegalT2AddressImmediate(V, VT, Subtarget);
4896
4897   // ARM mode.
4898   if (V < 0)
4899     V = - V;
4900   switch (VT.getSimpleVT().SimpleTy) {
4901   default: return false;
4902   case MVT::i1:
4903   case MVT::i8:
4904   case MVT::i32:
4905     // +- imm12
4906     return V == (V & ((1LL << 12) - 1));
4907   case MVT::i16:
4908     // +- imm8
4909     return V == (V & ((1LL << 8) - 1));
4910   case MVT::f32:
4911   case MVT::f64:
4912     if (!Subtarget->hasVFP2()) // FIXME: NEON?
4913       return false;
4914     if ((V & 3) != 0)
4915       return false;
4916     V >>= 2;
4917     return V == (V & ((1LL << 8) - 1));
4918   }
4919 }
4920
4921 bool ARMTargetLowering::isLegalT2ScaledAddressingMode(const AddrMode &AM,
4922                                                       EVT VT) const {
4923   int Scale = AM.Scale;
4924   if (Scale < 0)
4925     return false;
4926
4927   switch (VT.getSimpleVT().SimpleTy) {
4928   default: return false;
4929   case MVT::i1:
4930   case MVT::i8:
4931   case MVT::i16:
4932   case MVT::i32:
4933     if (Scale == 1)
4934       return true;
4935     // r + r << imm
4936     Scale = Scale & ~1;
4937     return Scale == 2 || Scale == 4 || Scale == 8;
4938   case MVT::i64:
4939     // r + r
4940     if (((unsigned)AM.HasBaseReg + Scale) <= 2)
4941       return true;
4942     return false;
4943   case MVT::isVoid:
4944     // Note, we allow "void" uses (basically, uses that aren't loads or
4945     // stores), because arm allows folding a scale into many arithmetic
4946     // operations.  This should be made more precise and revisited later.
4947
4948     // Allow r << imm, but the imm has to be a multiple of two.
4949     if (Scale & 1) return false;
4950     return isPowerOf2_32(Scale);
4951   }
4952 }
4953
4954 /// isLegalAddressingMode - Return true if the addressing mode represented
4955 /// by AM is legal for this target, for a load/store of the specified type.
4956 bool ARMTargetLowering::isLegalAddressingMode(const AddrMode &AM,
4957                                               const Type *Ty) const {
4958   EVT VT = getValueType(Ty, true);
4959   if (!isLegalAddressImmediate(AM.BaseOffs, VT, Subtarget))
4960     return false;
4961
4962   // Can never fold addr of global into load/store.
4963   if (AM.BaseGV)
4964     return false;
4965
4966   switch (AM.Scale) {
4967   case 0:  // no scale reg, must be "r+i" or "r", or "i".
4968     break;
4969   case 1:
4970     if (Subtarget->isThumb1Only())
4971       return false;
4972     // FALL THROUGH.
4973   default:
4974     // ARM doesn't support any R+R*scale+imm addr modes.
4975     if (AM.BaseOffs)
4976       return false;
4977
4978     if (!VT.isSimple())
4979       return false;
4980
4981     if (Subtarget->isThumb2())
4982       return isLegalT2ScaledAddressingMode(AM, VT);
4983
4984     int Scale = AM.Scale;
4985     switch (VT.getSimpleVT().SimpleTy) {
4986     default: return false;
4987     case MVT::i1:
4988     case MVT::i8:
4989     case MVT::i32:
4990       if (Scale < 0) Scale = -Scale;
4991       if (Scale == 1)
4992         return true;
4993       // r + r << imm
4994       return isPowerOf2_32(Scale & ~1);
4995     case MVT::i16:
4996     case MVT::i64:
4997       // r + r
4998       if (((unsigned)AM.HasBaseReg + Scale) <= 2)
4999         return true;
5000       return false;
5001
5002     case MVT::isVoid:
5003       // Note, we allow "void" uses (basically, uses that aren't loads or
5004       // stores), because arm allows folding a scale into many arithmetic
5005       // operations.  This should be made more precise and revisited later.
5006
5007       // Allow r << imm, but the imm has to be a multiple of two.
5008       if (Scale & 1) return false;
5009       return isPowerOf2_32(Scale);
5010     }
5011     break;
5012   }
5013   return true;
5014 }
5015
5016 /// isLegalICmpImmediate - Return true if the specified immediate is legal
5017 /// icmp immediate, that is the target has icmp instructions which can compare
5018 /// a register against the immediate without having to materialize the
5019 /// immediate into a register.
5020 bool ARMTargetLowering::isLegalICmpImmediate(int64_t Imm) const {
5021   if (!Subtarget->isThumb())
5022     return ARM_AM::getSOImmVal(Imm) != -1;
5023   if (Subtarget->isThumb2())
5024     return ARM_AM::getT2SOImmVal(Imm) != -1;
5025   return Imm >= 0 && Imm <= 255;
5026 }
5027
5028 static bool getARMIndexedAddressParts(SDNode *Ptr, EVT VT,
5029                                       bool isSEXTLoad, SDValue &Base,
5030                                       SDValue &Offset, bool &isInc,
5031                                       SelectionDAG &DAG) {
5032   if (Ptr->getOpcode() != ISD::ADD && Ptr->getOpcode() != ISD::SUB)
5033     return false;
5034
5035   if (VT == MVT::i16 || ((VT == MVT::i8 || VT == MVT::i1) && isSEXTLoad)) {
5036     // AddressingMode 3
5037     Base = Ptr->getOperand(0);
5038     if (ConstantSDNode *RHS = dyn_cast<ConstantSDNode>(Ptr->getOperand(1))) {
5039       int RHSC = (int)RHS->getZExtValue();
5040       if (RHSC < 0 && RHSC > -256) {
5041         assert(Ptr->getOpcode() == ISD::ADD);
5042         isInc = false;
5043         Offset = DAG.getConstant(-RHSC, RHS->getValueType(0));
5044         return true;
5045       }
5046     }
5047     isInc = (Ptr->getOpcode() == ISD::ADD);
5048     Offset = Ptr->getOperand(1);
5049     return true;
5050   } else if (VT == MVT::i32 || VT == MVT::i8 || VT == MVT::i1) {
5051     // AddressingMode 2
5052     if (ConstantSDNode *RHS = dyn_cast<ConstantSDNode>(Ptr->getOperand(1))) {
5053       int RHSC = (int)RHS->getZExtValue();
5054       if (RHSC < 0 && RHSC > -0x1000) {
5055         assert(Ptr->getOpcode() == ISD::ADD);
5056         isInc = false;
5057         Offset = DAG.getConstant(-RHSC, RHS->getValueType(0));
5058         Base = Ptr->getOperand(0);
5059         return true;
5060       }
5061     }
5062
5063     if (Ptr->getOpcode() == ISD::ADD) {
5064       isInc = true;
5065       ARM_AM::ShiftOpc ShOpcVal= ARM_AM::getShiftOpcForNode(Ptr->getOperand(0));
5066       if (ShOpcVal != ARM_AM::no_shift) {
5067         Base = Ptr->getOperand(1);
5068         Offset = Ptr->getOperand(0);
5069       } else {
5070         Base = Ptr->getOperand(0);
5071         Offset = Ptr->getOperand(1);
5072       }
5073       return true;
5074     }
5075
5076     isInc = (Ptr->getOpcode() == ISD::ADD);
5077     Base = Ptr->getOperand(0);
5078     Offset = Ptr->getOperand(1);
5079     return true;
5080   }
5081
5082   // FIXME: Use VLDM / VSTM to emulate indexed FP load / store.
5083   return false;
5084 }
5085
5086 static bool getT2IndexedAddressParts(SDNode *Ptr, EVT VT,
5087                                      bool isSEXTLoad, SDValue &Base,
5088                                      SDValue &Offset, bool &isInc,
5089                                      SelectionDAG &DAG) {
5090   if (Ptr->getOpcode() != ISD::ADD && Ptr->getOpcode() != ISD::SUB)
5091     return false;
5092
5093   Base = Ptr->getOperand(0);
5094   if (ConstantSDNode *RHS = dyn_cast<ConstantSDNode>(Ptr->getOperand(1))) {
5095     int RHSC = (int)RHS->getZExtValue();
5096     if (RHSC < 0 && RHSC > -0x100) { // 8 bits.
5097       assert(Ptr->getOpcode() == ISD::ADD);
5098       isInc = false;
5099       Offset = DAG.getConstant(-RHSC, RHS->getValueType(0));
5100       return true;
5101     } else if (RHSC > 0 && RHSC < 0x100) { // 8 bit, no zero.
5102       isInc = Ptr->getOpcode() == ISD::ADD;
5103       Offset = DAG.getConstant(RHSC, RHS->getValueType(0));
5104       return true;
5105     }
5106   }
5107
5108   return false;
5109 }
5110
5111 /// getPreIndexedAddressParts - returns true by value, base pointer and
5112 /// offset pointer and addressing mode by reference if the node's address
5113 /// can be legally represented as pre-indexed load / store address.
5114 bool
5115 ARMTargetLowering::getPreIndexedAddressParts(SDNode *N, SDValue &Base,
5116                                              SDValue &Offset,
5117                                              ISD::MemIndexedMode &AM,
5118                                              SelectionDAG &DAG) const {
5119   if (Subtarget->isThumb1Only())
5120     return false;
5121
5122   EVT VT;
5123   SDValue Ptr;
5124   bool isSEXTLoad = false;
5125   if (LoadSDNode *LD = dyn_cast<LoadSDNode>(N)) {
5126     Ptr = LD->getBasePtr();
5127     VT  = LD->getMemoryVT();
5128     isSEXTLoad = LD->getExtensionType() == ISD::SEXTLOAD;
5129   } else if (StoreSDNode *ST = dyn_cast<StoreSDNode>(N)) {
5130     Ptr = ST->getBasePtr();
5131     VT  = ST->getMemoryVT();
5132   } else
5133     return false;
5134
5135   bool isInc;
5136   bool isLegal = false;
5137   if (Subtarget->isThumb2())
5138     isLegal = getT2IndexedAddressParts(Ptr.getNode(), VT, isSEXTLoad, Base,
5139                                        Offset, isInc, DAG);
5140   else
5141     isLegal = getARMIndexedAddressParts(Ptr.getNode(), VT, isSEXTLoad, Base,
5142                                         Offset, isInc, DAG);
5143   if (!isLegal)
5144     return false;
5145
5146   AM = isInc ? ISD::PRE_INC : ISD::PRE_DEC;
5147   return true;
5148 }
5149
5150 /// getPostIndexedAddressParts - returns true by value, base pointer and
5151 /// offset pointer and addressing mode by reference if this node can be
5152 /// combined with a load / store to form a post-indexed load / store.
5153 bool ARMTargetLowering::getPostIndexedAddressParts(SDNode *N, SDNode *Op,
5154                                                    SDValue &Base,
5155                                                    SDValue &Offset,
5156                                                    ISD::MemIndexedMode &AM,
5157                                                    SelectionDAG &DAG) const {
5158   if (Subtarget->isThumb1Only())
5159     return false;
5160
5161   EVT VT;
5162   SDValue Ptr;
5163   bool isSEXTLoad = false;
5164   if (LoadSDNode *LD = dyn_cast<LoadSDNode>(N)) {
5165     VT  = LD->getMemoryVT();
5166     Ptr = LD->getBasePtr();
5167     isSEXTLoad = LD->getExtensionType() == ISD::SEXTLOAD;
5168   } else if (StoreSDNode *ST = dyn_cast<StoreSDNode>(N)) {
5169     VT  = ST->getMemoryVT();
5170     Ptr = ST->getBasePtr();
5171   } else
5172     return false;
5173
5174   bool isInc;
5175   bool isLegal = false;
5176   if (Subtarget->isThumb2())
5177     isLegal = getT2IndexedAddressParts(Op, VT, isSEXTLoad, Base, Offset,
5178                                        isInc, DAG);
5179   else
5180     isLegal = getARMIndexedAddressParts(Op, VT, isSEXTLoad, Base, Offset,
5181                                         isInc, DAG);
5182   if (!isLegal)
5183     return false;
5184
5185   if (Ptr != Base) {
5186     // Swap base ptr and offset to catch more post-index load / store when
5187     // it's legal. In Thumb2 mode, offset must be an immediate.
5188     if (Ptr == Offset && Op->getOpcode() == ISD::ADD &&
5189         !Subtarget->isThumb2())
5190       std::swap(Base, Offset);
5191
5192     // Post-indexed load / store update the base pointer.
5193     if (Ptr != Base)
5194       return false;
5195   }
5196
5197   AM = isInc ? ISD::POST_INC : ISD::POST_DEC;
5198   return true;
5199 }
5200
5201 void ARMTargetLowering::computeMaskedBitsForTargetNode(const SDValue Op,
5202                                                        const APInt &Mask,
5203                                                        APInt &KnownZero,
5204                                                        APInt &KnownOne,
5205                                                        const SelectionDAG &DAG,
5206                                                        unsigned Depth) const {
5207   KnownZero = KnownOne = APInt(Mask.getBitWidth(), 0);
5208   switch (Op.getOpcode()) {
5209   default: break;
5210   case ARMISD::CMOV: {
5211     // Bits are known zero/one if known on the LHS and RHS.
5212     DAG.ComputeMaskedBits(Op.getOperand(0), Mask, KnownZero, KnownOne, Depth+1);
5213     if (KnownZero == 0 && KnownOne == 0) return;
5214
5215     APInt KnownZeroRHS, KnownOneRHS;
5216     DAG.ComputeMaskedBits(Op.getOperand(1), Mask,
5217                           KnownZeroRHS, KnownOneRHS, Depth+1);
5218     KnownZero &= KnownZeroRHS;
5219     KnownOne  &= KnownOneRHS;
5220     return;
5221   }
5222   }
5223 }
5224
5225 //===----------------------------------------------------------------------===//
5226 //                           ARM Inline Assembly Support
5227 //===----------------------------------------------------------------------===//
5228
5229 /// getConstraintType - Given a constraint letter, return the type of
5230 /// constraint it is for this target.
5231 ARMTargetLowering::ConstraintType
5232 ARMTargetLowering::getConstraintType(const std::string &Constraint) const {
5233   if (Constraint.size() == 1) {
5234     switch (Constraint[0]) {
5235     default:  break;
5236     case 'l': return C_RegisterClass;
5237     case 'w': return C_RegisterClass;
5238     }
5239   }
5240   return TargetLowering::getConstraintType(Constraint);
5241 }
5242
5243 std::pair<unsigned, const TargetRegisterClass*>
5244 ARMTargetLowering::getRegForInlineAsmConstraint(const std::string &Constraint,
5245                                                 EVT VT) const {
5246   if (Constraint.size() == 1) {
5247     // GCC ARM Constraint Letters
5248     switch (Constraint[0]) {
5249     case 'l':
5250       if (Subtarget->isThumb())
5251         return std::make_pair(0U, ARM::tGPRRegisterClass);
5252       else
5253         return std::make_pair(0U, ARM::GPRRegisterClass);
5254     case 'r':
5255       return std::make_pair(0U, ARM::GPRRegisterClass);
5256     case 'w':
5257       if (VT == MVT::f32)
5258         return std::make_pair(0U, ARM::SPRRegisterClass);
5259       if (VT.getSizeInBits() == 64)
5260         return std::make_pair(0U, ARM::DPRRegisterClass);
5261       if (VT.getSizeInBits() == 128)
5262         return std::make_pair(0U, ARM::QPRRegisterClass);
5263       break;
5264     }
5265   }
5266   if (StringRef("{cc}").equals_lower(Constraint))
5267     return std::make_pair(unsigned(ARM::CPSR), ARM::CCRRegisterClass);
5268
5269   return TargetLowering::getRegForInlineAsmConstraint(Constraint, VT);
5270 }
5271
5272 std::vector<unsigned> ARMTargetLowering::
5273 getRegClassForInlineAsmConstraint(const std::string &Constraint,
5274                                   EVT VT) const {
5275   if (Constraint.size() != 1)
5276     return std::vector<unsigned>();
5277
5278   switch (Constraint[0]) {      // GCC ARM Constraint Letters
5279   default: break;
5280   case 'l':
5281     return make_vector<unsigned>(ARM::R0, ARM::R1, ARM::R2, ARM::R3,
5282                                  ARM::R4, ARM::R5, ARM::R6, ARM::R7,
5283                                  0);
5284   case 'r':
5285     return make_vector<unsigned>(ARM::R0, ARM::R1, ARM::R2, ARM::R3,
5286                                  ARM::R4, ARM::R5, ARM::R6, ARM::R7,
5287                                  ARM::R8, ARM::R9, ARM::R10, ARM::R11,
5288                                  ARM::R12, ARM::LR, 0);
5289   case 'w':
5290     if (VT == MVT::f32)
5291       return make_vector<unsigned>(ARM::S0, ARM::S1, ARM::S2, ARM::S3,
5292                                    ARM::S4, ARM::S5, ARM::S6, ARM::S7,
5293                                    ARM::S8, ARM::S9, ARM::S10, ARM::S11,
5294                                    ARM::S12,ARM::S13,ARM::S14,ARM::S15,
5295                                    ARM::S16,ARM::S17,ARM::S18,ARM::S19,
5296                                    ARM::S20,ARM::S21,ARM::S22,ARM::S23,
5297                                    ARM::S24,ARM::S25,ARM::S26,ARM::S27,
5298                                    ARM::S28,ARM::S29,ARM::S30,ARM::S31, 0);
5299     if (VT.getSizeInBits() == 64)
5300       return make_vector<unsigned>(ARM::D0, ARM::D1, ARM::D2, ARM::D3,
5301                                    ARM::D4, ARM::D5, ARM::D6, ARM::D7,
5302                                    ARM::D8, ARM::D9, ARM::D10,ARM::D11,
5303                                    ARM::D12,ARM::D13,ARM::D14,ARM::D15, 0);
5304     if (VT.getSizeInBits() == 128)
5305       return make_vector<unsigned>(ARM::Q0, ARM::Q1, ARM::Q2, ARM::Q3,
5306                                    ARM::Q4, ARM::Q5, ARM::Q6, ARM::Q7, 0);
5307       break;
5308   }
5309
5310   return std::vector<unsigned>();
5311 }
5312
5313 /// LowerAsmOperandForConstraint - Lower the specified operand into the Ops
5314 /// vector.  If it is invalid, don't add anything to Ops.
5315 void ARMTargetLowering::LowerAsmOperandForConstraint(SDValue Op,
5316                                                      char Constraint,
5317                                                      std::vector<SDValue>&Ops,
5318                                                      SelectionDAG &DAG) const {
5319   SDValue Result(0, 0);
5320
5321   switch (Constraint) {
5322   default: break;
5323   case 'I': case 'J': case 'K': case 'L':
5324   case 'M': case 'N': case 'O':
5325     ConstantSDNode *C = dyn_cast<ConstantSDNode>(Op);
5326     if (!C)
5327       return;
5328
5329     int64_t CVal64 = C->getSExtValue();
5330     int CVal = (int) CVal64;
5331     // None of these constraints allow values larger than 32 bits.  Check
5332     // that the value fits in an int.
5333     if (CVal != CVal64)
5334       return;
5335
5336     switch (Constraint) {
5337       case 'I':
5338         if (Subtarget->isThumb1Only()) {
5339           // This must be a constant between 0 and 255, for ADD
5340           // immediates.
5341           if (CVal >= 0 && CVal <= 255)
5342             break;
5343         } else if (Subtarget->isThumb2()) {
5344           // A constant that can be used as an immediate value in a
5345           // data-processing instruction.
5346           if (ARM_AM::getT2SOImmVal(CVal) != -1)
5347             break;
5348         } else {
5349           // A constant that can be used as an immediate value in a
5350           // data-processing instruction.
5351           if (ARM_AM::getSOImmVal(CVal) != -1)
5352             break;
5353         }
5354         return;
5355
5356       case 'J':
5357         if (Subtarget->isThumb()) {  // FIXME thumb2
5358           // This must be a constant between -255 and -1, for negated ADD
5359           // immediates. This can be used in GCC with an "n" modifier that
5360           // prints the negated value, for use with SUB instructions. It is
5361           // not useful otherwise but is implemented for compatibility.
5362           if (CVal >= -255 && CVal <= -1)
5363             break;
5364         } else {
5365           // This must be a constant between -4095 and 4095. It is not clear
5366           // what this constraint is intended for. Implemented for
5367           // compatibility with GCC.
5368           if (CVal >= -4095 && CVal <= 4095)
5369             break;
5370         }
5371         return;
5372
5373       case 'K':
5374         if (Subtarget->isThumb1Only()) {
5375           // A 32-bit value where only one byte has a nonzero value. Exclude
5376           // zero to match GCC. This constraint is used by GCC internally for
5377           // constants that can be loaded with a move/shift combination.
5378           // It is not useful otherwise but is implemented for compatibility.
5379           if (CVal != 0 && ARM_AM::isThumbImmShiftedVal(CVal))
5380             break;
5381         } else if (Subtarget->isThumb2()) {
5382           // A constant whose bitwise inverse can be used as an immediate
5383           // value in a data-processing instruction. This can be used in GCC
5384           // with a "B" modifier that prints the inverted value, for use with
5385           // BIC and MVN instructions. It is not useful otherwise but is
5386           // implemented for compatibility.
5387           if (ARM_AM::getT2SOImmVal(~CVal) != -1)
5388             break;
5389         } else {
5390           // A constant whose bitwise inverse can be used as an immediate
5391           // value in a data-processing instruction. This can be used in GCC
5392           // with a "B" modifier that prints the inverted value, for use with
5393           // BIC and MVN instructions. It is not useful otherwise but is
5394           // implemented for compatibility.
5395           if (ARM_AM::getSOImmVal(~CVal) != -1)
5396             break;
5397         }
5398         return;
5399
5400       case 'L':
5401         if (Subtarget->isThumb1Only()) {
5402           // This must be a constant between -7 and 7,
5403           // for 3-operand ADD/SUB immediate instructions.
5404           if (CVal >= -7 && CVal < 7)
5405             break;
5406         } else if (Subtarget->isThumb2()) {
5407           // A constant whose negation can be used as an immediate value in a
5408           // data-processing instruction. This can be used in GCC with an "n"
5409           // modifier that prints the negated value, for use with SUB
5410           // instructions. It is not useful otherwise but is implemented for
5411           // compatibility.
5412           if (ARM_AM::getT2SOImmVal(-CVal) != -1)
5413             break;
5414         } else {
5415           // A constant whose negation can be used as an immediate value in a
5416           // data-processing instruction. This can be used in GCC with an "n"
5417           // modifier that prints the negated value, for use with SUB
5418           // instructions. It is not useful otherwise but is implemented for
5419           // compatibility.
5420           if (ARM_AM::getSOImmVal(-CVal) != -1)
5421             break;
5422         }
5423         return;
5424
5425       case 'M':
5426         if (Subtarget->isThumb()) { // FIXME thumb2
5427           // This must be a multiple of 4 between 0 and 1020, for
5428           // ADD sp + immediate.
5429           if ((CVal >= 0 && CVal <= 1020) && ((CVal & 3) == 0))
5430             break;
5431         } else {
5432           // A power of two or a constant between 0 and 32.  This is used in
5433           // GCC for the shift amount on shifted register operands, but it is
5434           // useful in general for any shift amounts.
5435           if ((CVal >= 0 && CVal <= 32) || ((CVal & (CVal - 1)) == 0))
5436             break;
5437         }
5438         return;
5439
5440       case 'N':
5441         if (Subtarget->isThumb()) {  // FIXME thumb2
5442           // This must be a constant between 0 and 31, for shift amounts.
5443           if (CVal >= 0 && CVal <= 31)
5444             break;
5445         }
5446         return;
5447
5448       case 'O':
5449         if (Subtarget->isThumb()) {  // FIXME thumb2
5450           // This must be a multiple of 4 between -508 and 508, for
5451           // ADD/SUB sp = sp + immediate.
5452           if ((CVal >= -508 && CVal <= 508) && ((CVal & 3) == 0))
5453             break;
5454         }
5455         return;
5456     }
5457     Result = DAG.getTargetConstant(CVal, Op.getValueType());
5458     break;
5459   }
5460
5461   if (Result.getNode()) {
5462     Ops.push_back(Result);
5463     return;
5464   }
5465   return TargetLowering::LowerAsmOperandForConstraint(Op, Constraint, Ops, DAG);
5466 }
5467
5468 bool
5469 ARMTargetLowering::isOffsetFoldingLegal(const GlobalAddressSDNode *GA) const {
5470   // The ARM target isn't yet aware of offsets.
5471   return false;
5472 }
5473
5474 int ARM::getVFPf32Imm(const APFloat &FPImm) {
5475   APInt Imm = FPImm.bitcastToAPInt();
5476   uint32_t Sign = Imm.lshr(31).getZExtValue() & 1;
5477   int32_t Exp = (Imm.lshr(23).getSExtValue() & 0xff) - 127;  // -126 to 127
5478   int64_t Mantissa = Imm.getZExtValue() & 0x7fffff;  // 23 bits
5479
5480   // We can handle 4 bits of mantissa.
5481   // mantissa = (16+UInt(e:f:g:h))/16.
5482   if (Mantissa & 0x7ffff)
5483     return -1;
5484   Mantissa >>= 19;
5485   if ((Mantissa & 0xf) != Mantissa)
5486     return -1;
5487
5488   // We can handle 3 bits of exponent: exp == UInt(NOT(b):c:d)-3
5489   if (Exp < -3 || Exp > 4)
5490     return -1;
5491   Exp = ((Exp+3) & 0x7) ^ 4;
5492
5493   return ((int)Sign << 7) | (Exp << 4) | Mantissa;
5494 }
5495
5496 int ARM::getVFPf64Imm(const APFloat &FPImm) {
5497   APInt Imm = FPImm.bitcastToAPInt();
5498   uint64_t Sign = Imm.lshr(63).getZExtValue() & 1;
5499   int64_t Exp = (Imm.lshr(52).getSExtValue() & 0x7ff) - 1023;   // -1022 to 1023
5500   uint64_t Mantissa = Imm.getZExtValue() & 0xfffffffffffffLL;
5501
5502   // We can handle 4 bits of mantissa.
5503   // mantissa = (16+UInt(e:f:g:h))/16.
5504   if (Mantissa & 0xffffffffffffLL)
5505     return -1;
5506   Mantissa >>= 48;
5507   if ((Mantissa & 0xf) != Mantissa)
5508     return -1;
5509
5510   // We can handle 3 bits of exponent: exp == UInt(NOT(b):c:d)-3
5511   if (Exp < -3 || Exp > 4)
5512     return -1;
5513   Exp = ((Exp+3) & 0x7) ^ 4;
5514
5515   return ((int)Sign << 7) | (Exp << 4) | Mantissa;
5516 }
5517
5518 bool ARM::isBitFieldInvertedMask(unsigned v) {
5519   if (v == 0xffffffff)
5520     return 0;
5521   // there can be 1's on either or both "outsides", all the "inside"
5522   // bits must be 0's
5523   unsigned int lsb = 0, msb = 31;
5524   while (v & (1 << msb)) --msb;
5525   while (v & (1 << lsb)) ++lsb;
5526   for (unsigned int i = lsb; i <= msb; ++i) {
5527     if (v & (1 << i))
5528       return 0;
5529   }
5530   return 1;
5531 }
5532
5533 /// isFPImmLegal - Returns true if the target can instruction select the
5534 /// specified FP immediate natively. If false, the legalizer will
5535 /// materialize the FP immediate as a load from a constant pool.
5536 bool ARMTargetLowering::isFPImmLegal(const APFloat &Imm, EVT VT) const {
5537   if (!Subtarget->hasVFP3())
5538     return false;
5539   if (VT == MVT::f32)
5540     return ARM::getVFPf32Imm(Imm) != -1;
5541   if (VT == MVT::f64)
5542     return ARM::getVFPf64Imm(Imm) != -1;
5543   return false;
5544 }