lib/Target/X86/X86ISelLowering.cpp

   1 //===-- X86ISelLowering.cpp - X86 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 X86 uses to lower LLVM code into a
  11 // selection DAG.
  12 //
  13 //===----------------------------------------------------------------------===//
  14
  15 #define DEBUG_TYPE "x86-isel"
  16 #include "X86.h"
  17 #include "X86InstrBuilder.h"
  18 #include "X86ISelLowering.h"
  19 #include "X86TargetMachine.h"
  20 #include "X86TargetObjectFile.h"
  21 #include "Utils/X86ShuffleDecode.h"
  22 #include "llvm/CallingConv.h"
  23 #include "llvm/Constants.h"
  24 #include "llvm/DerivedTypes.h"
  25 #include "llvm/GlobalAlias.h"
  26 #include "llvm/GlobalVariable.h"
  27 #include "llvm/Function.h"
  28 #include "llvm/Instructions.h"
  29 #include "llvm/Intrinsics.h"
  30 #include "llvm/LLVMContext.h"
  31 #include "llvm/CodeGen/IntrinsicLowering.h"
  32 #include "llvm/CodeGen/MachineFrameInfo.h"
  33 #include "llvm/CodeGen/MachineFunction.h"
  34 #include "llvm/CodeGen/MachineInstrBuilder.h"
  35 #include "llvm/CodeGen/MachineJumpTableInfo.h"
  36 #include "llvm/CodeGen/MachineModuleInfo.h"
  37 #include "llvm/CodeGen/MachineRegisterInfo.h"
  38 #include "llvm/CodeGen/PseudoSourceValue.h"
  39 #include "llvm/MC/MCAsmInfo.h"
  40 #include "llvm/MC/MCContext.h"
  41 #include "llvm/MC/MCExpr.h"
  42 #include "llvm/MC/MCSymbol.h"
  43 #include "llvm/ADT/BitVector.h"
  44 #include "llvm/ADT/SmallSet.h"
  45 #include "llvm/ADT/Statistic.h"
  46 #include "llvm/ADT/StringExtras.h"
  47 #include "llvm/ADT/VectorExtras.h"
  48 #include "llvm/Support/CallSite.h"
  49 #include "llvm/Support/Debug.h"
  50 #include "llvm/Support/Dwarf.h"
  51 #include "llvm/Support/ErrorHandling.h"
  52 #include "llvm/Support/MathExtras.h"
  53 #include "llvm/Support/raw_ostream.h"
  54 using namespace llvm;
  55 using namespace dwarf;
  56
  57 STATISTIC(NumTailCalls, "Number of tail calls");
  58
  59 // Forward declarations.
  60 static SDValue getMOVL(SelectionDAG &DAG, DebugLoc dl, EVT VT, SDValue V1,
  61                        SDValue V2);
  62
  63 static SDValue Insert128BitVector(SDValue Result,
  64                                   SDValue Vec,
  65                                   SDValue Idx,
  66                                   SelectionDAG &DAG,
  67                                   DebugLoc dl);
  68
  69 static SDValue Extract128BitVector(SDValue Vec,
  70                                    SDValue Idx,
  71                                    SelectionDAG &DAG,
  72                                    DebugLoc dl);
  73
  74 /// Generate a DAG to grab 128-bits from a vector > 128 bits.  This
  75 /// sets things up to match to an AVX VEXTRACTF128 instruction or a
  76 /// simple subregister reference.  Idx is an index in the 128 bits we
  77 /// want.  It need not be aligned to a 128-bit bounday.  That makes
  78 /// lowering EXTRACT_VECTOR_ELT operations easier.
  79 static SDValue Extract128BitVector(SDValue Vec,
  80                                    SDValue Idx,
  81                                    SelectionDAG &DAG,
  82                                    DebugLoc dl) {
  83   EVT VT = Vec.getValueType();
  84   assert(VT.getSizeInBits() == 256 && "Unexpected vector size!");
  85   EVT ElVT = VT.getVectorElementType();
  86   int Factor = VT.getSizeInBits()/128;
  87   EVT ResultVT = EVT::getVectorVT(*DAG.getContext(), ElVT,
  88                                   VT.getVectorNumElements()/Factor);
  89
  90   // Extract from UNDEF is UNDEF.
  91   if (Vec.getOpcode() == ISD::UNDEF)
  92     return DAG.getNode(ISD::UNDEF, dl, ResultVT);
  93
  94   if (isa<ConstantSDNode>(Idx)) {
  95     unsigned IdxVal = cast<ConstantSDNode>(Idx)->getZExtValue();
  96
  97     // Extract the relevant 128 bits.  Generate an EXTRACT_SUBVECTOR
  98     // we can match to VEXTRACTF128.
  99     unsigned ElemsPerChunk = 128 / ElVT.getSizeInBits();
 100
 101     // This is the index of the first element of the 128-bit chunk
 102     // we want.
 103     unsigned NormalizedIdxVal = (((IdxVal * ElVT.getSizeInBits()) / 128)
 104                                  * ElemsPerChunk);
 105
 106     SDValue VecIdx = DAG.getConstant(NormalizedIdxVal, MVT::i32);
 107     SDValue Result = DAG.getNode(ISD::EXTRACT_SUBVECTOR, dl, ResultVT, Vec,
 108                                  VecIdx);
 109
 110     return Result;
 111   }
 112
 113   return SDValue();
 114 }
 115
 116 /// Generate a DAG to put 128-bits into a vector > 128 bits.  This
 117 /// sets things up to match to an AVX VINSERTF128 instruction or a
 118 /// simple superregister reference.  Idx is an index in the 128 bits
 119 /// we want.  It need not be aligned to a 128-bit bounday.  That makes
 120 /// lowering INSERT_VECTOR_ELT operations easier.
 121 static SDValue Insert128BitVector(SDValue Result,
 122                                   SDValue Vec,
 123                                   SDValue Idx,
 124                                   SelectionDAG &DAG,
 125                                   DebugLoc dl) {
 126   if (isa<ConstantSDNode>(Idx)) {
 127     EVT VT = Vec.getValueType();
 128     assert(VT.getSizeInBits() == 128 && "Unexpected vector size!");
 129
 130     EVT ElVT = VT.getVectorElementType();
 131     unsigned IdxVal = cast<ConstantSDNode>(Idx)->getZExtValue();
 132     EVT ResultVT = Result.getValueType();
 133
 134     // Insert the relevant 128 bits.
 135     unsigned ElemsPerChunk = 128/ElVT.getSizeInBits();
 136
 137     // This is the index of the first element of the 128-bit chunk
 138     // we want.
 139     unsigned NormalizedIdxVal = (((IdxVal * ElVT.getSizeInBits())/128)
 140                                  * ElemsPerChunk);
 141
 142     SDValue VecIdx = DAG.getConstant(NormalizedIdxVal, MVT::i32);
 143     Result = DAG.getNode(ISD::INSERT_SUBVECTOR, dl, ResultVT, Result, Vec,
 144                          VecIdx);
 145     return Result;
 146   }
 147
 148   return SDValue();
 149 }
 150
 151 static TargetLoweringObjectFile *createTLOF(X86TargetMachine &TM) {
 152   const X86Subtarget *Subtarget = &TM.getSubtarget<X86Subtarget>();
 153   bool is64Bit = Subtarget->is64Bit();
 154
 155   if (Subtarget->isTargetEnvMacho()) {
 156     if (is64Bit)
 157       return new X8664_MachoTargetObjectFile();
 158     return new TargetLoweringObjectFileMachO();
 159   }
 160
 161   if (Subtarget->isTargetELF())
 162     return new TargetLoweringObjectFileELF();
 163   if (Subtarget->isTargetCOFF() && !Subtarget->isTargetEnvMacho())
 164     return new TargetLoweringObjectFileCOFF();
 165   llvm_unreachable("unknown subtarget type");
 166 }
 167
 168 X86TargetLowering::X86TargetLowering(X86TargetMachine &TM)
 169   : TargetLowering(TM, createTLOF(TM)) {
 170   Subtarget = &TM.getSubtarget<X86Subtarget>();
 171   X86ScalarSSEf64 = Subtarget->hasXMMInt() || Subtarget->hasAVX();
 172   X86ScalarSSEf32 = Subtarget->hasXMM() || Subtarget->hasAVX();
 173   X86StackPtr = Subtarget->is64Bit() ? X86::RSP : X86::ESP;
 174
 175   RegInfo = TM.getRegisterInfo();
 176   TD = getTargetData();
 177
 178   // Set up the TargetLowering object.
 179   static MVT IntVTs[] = { MVT::i8, MVT::i16, MVT::i32, MVT::i64 };
 180
 181   // X86 is weird, it always uses i8 for shift amounts and setcc results.
 182   setBooleanContents(ZeroOrOneBooleanContent);
 183
 184   // For 64-bit since we have so many registers use the ILP scheduler, for
 185   // 32-bit code use the register pressure specific scheduling.
 186   if (Subtarget->is64Bit())
 187     setSchedulingPreference(Sched::ILP);
 188   else
 189     setSchedulingPreference(Sched::RegPressure);
 190   setStackPointerRegisterToSaveRestore(X86StackPtr);
 191
 192   if (Subtarget->isTargetWindows() && !Subtarget->isTargetCygMing()) {
 193     // Setup Windows compiler runtime calls.
 194     setLibcallName(RTLIB::SDIV_I64, "_alldiv");
 195     setLibcallName(RTLIB::UDIV_I64, "_aulldiv");
 196     setLibcallName(RTLIB::SREM_I64, "_allrem");
 197     setLibcallName(RTLIB::UREM_I64, "_aullrem");
 198     setLibcallName(RTLIB::MUL_I64, "_allmul");
 199     setLibcallName(RTLIB::FPTOUINT_F64_I64, "_ftol2");
 200     setLibcallName(RTLIB::FPTOUINT_F32_I64, "_ftol2");
 201     setLibcallCallingConv(RTLIB::SDIV_I64, CallingConv::X86_StdCall);
 202     setLibcallCallingConv(RTLIB::UDIV_I64, CallingConv::X86_StdCall);
 203     setLibcallCallingConv(RTLIB::SREM_I64, CallingConv::X86_StdCall);
 204     setLibcallCallingConv(RTLIB::UREM_I64, CallingConv::X86_StdCall);
 205     setLibcallCallingConv(RTLIB::MUL_I64, CallingConv::X86_StdCall);
 206     setLibcallCallingConv(RTLIB::FPTOUINT_F64_I64, CallingConv::C);
 207     setLibcallCallingConv(RTLIB::FPTOUINT_F32_I64, CallingConv::C);
 208   }
 209
 210   if (Subtarget->isTargetDarwin()) {
 211     // Darwin should use _setjmp/_longjmp instead of setjmp/longjmp.
 212     setUseUnderscoreSetJmp(false);
 213     setUseUnderscoreLongJmp(false);
 214   } else if (Subtarget->isTargetMingw()) {
 215     // MS runtime is weird: it exports _setjmp, but longjmp!
 216     setUseUnderscoreSetJmp(true);
 217     setUseUnderscoreLongJmp(false);
 218   } else {
 219     setUseUnderscoreSetJmp(true);
 220     setUseUnderscoreLongJmp(true);
 221   }
 222
 223   // Set up the register classes.
 224   addRegisterClass(MVT::i8, X86::GR8RegisterClass);
 225   addRegisterClass(MVT::i16, X86::GR16RegisterClass);
 226   addRegisterClass(MVT::i32, X86::GR32RegisterClass);
 227   if (Subtarget->is64Bit())
 228     addRegisterClass(MVT::i64, X86::GR64RegisterClass);
 229
 230   setLoadExtAction(ISD::SEXTLOAD, MVT::i1, Promote);
 231
 232   // We don't accept any truncstore of integer registers.
 233   setTruncStoreAction(MVT::i64, MVT::i32, Expand);
 234   setTruncStoreAction(MVT::i64, MVT::i16, Expand);
 235   setTruncStoreAction(MVT::i64, MVT::i8 , Expand);
 236   setTruncStoreAction(MVT::i32, MVT::i16, Expand);
 237   setTruncStoreAction(MVT::i32, MVT::i8 , Expand);
 238   setTruncStoreAction(MVT::i16, MVT::i8,  Expand);
 239
 240   // SETOEQ and SETUNE require checking two conditions.
 241   setCondCodeAction(ISD::SETOEQ, MVT::f32, Expand);
 242   setCondCodeAction(ISD::SETOEQ, MVT::f64, Expand);
 243   setCondCodeAction(ISD::SETOEQ, MVT::f80, Expand);
 244   setCondCodeAction(ISD::SETUNE, MVT::f32, Expand);
 245   setCondCodeAction(ISD::SETUNE, MVT::f64, Expand);
 246   setCondCodeAction(ISD::SETUNE, MVT::f80, Expand);
 247
 248   // Promote all UINT_TO_FP to larger SINT_TO_FP's, as X86 doesn't have this
 249   // operation.
 250   setOperationAction(ISD::UINT_TO_FP       , MVT::i1   , Promote);
 251   setOperationAction(ISD::UINT_TO_FP       , MVT::i8   , Promote);
 252   setOperationAction(ISD::UINT_TO_FP       , MVT::i16  , Promote);
 253
 254   if (Subtarget->is64Bit()) {
 255     setOperationAction(ISD::UINT_TO_FP     , MVT::i32  , Promote);
 256     setOperationAction(ISD::UINT_TO_FP     , MVT::i64  , Expand);
 257   } else if (!UseSoftFloat) {
 258     // We have an algorithm for SSE2->double, and we turn this into a
 259     // 64-bit FILD followed by conditional FADD for other targets.
 260     setOperationAction(ISD::UINT_TO_FP     , MVT::i64  , Custom);
 261     // We have an algorithm for SSE2, and we turn this into a 64-bit
 262     // FILD for other targets.
 263     setOperationAction(ISD::UINT_TO_FP     , MVT::i32  , Custom);
 264   }
 265
 266   // Promote i1/i8 SINT_TO_FP to larger SINT_TO_FP's, as X86 doesn't have
 267   // this operation.
 268   setOperationAction(ISD::SINT_TO_FP       , MVT::i1   , Promote);
 269   setOperationAction(ISD::SINT_TO_FP       , MVT::i8   , Promote);
 270
 271   if (!UseSoftFloat) {
 272     // SSE has no i16 to fp conversion, only i32
 273     if (X86ScalarSSEf32) {
 274       setOperationAction(ISD::SINT_TO_FP     , MVT::i16  , Promote);
 275       // f32 and f64 cases are Legal, f80 case is not
 276       setOperationAction(ISD::SINT_TO_FP     , MVT::i32  , Custom);
 277     } else {
 278       setOperationAction(ISD::SINT_TO_FP     , MVT::i16  , Custom);
 279       setOperationAction(ISD::SINT_TO_FP     , MVT::i32  , Custom);
 280     }
 281   } else {
 282     setOperationAction(ISD::SINT_TO_FP     , MVT::i16  , Promote);
 283     setOperationAction(ISD::SINT_TO_FP     , MVT::i32  , Promote);
 284   }
 285
 286   // In 32-bit mode these are custom lowered.  In 64-bit mode F32 and F64
 287   // are Legal, f80 is custom lowered.
 288   setOperationAction(ISD::FP_TO_SINT     , MVT::i64  , Custom);
 289   setOperationAction(ISD::SINT_TO_FP     , MVT::i64  , Custom);
 290
 291   // Promote i1/i8 FP_TO_SINT to larger FP_TO_SINTS's, as X86 doesn't have
 292   // this operation.
 293   setOperationAction(ISD::FP_TO_SINT       , MVT::i1   , Promote);
 294   setOperationAction(ISD::FP_TO_SINT       , MVT::i8   , Promote);
 295
 296   if (X86ScalarSSEf32) {
 297     setOperationAction(ISD::FP_TO_SINT     , MVT::i16  , Promote);
 298     // f32 and f64 cases are Legal, f80 case is not
 299     setOperationAction(ISD::FP_TO_SINT     , MVT::i32  , Custom);
 300   } else {
 301     setOperationAction(ISD::FP_TO_SINT     , MVT::i16  , Custom);
 302     setOperationAction(ISD::FP_TO_SINT     , MVT::i32  , Custom);
 303   }
 304
 305   // Handle FP_TO_UINT by promoting the destination to a larger signed
 306   // conversion.
 307   setOperationAction(ISD::FP_TO_UINT       , MVT::i1   , Promote);
 308   setOperationAction(ISD::FP_TO_UINT       , MVT::i8   , Promote);
 309   setOperationAction(ISD::FP_TO_UINT       , MVT::i16  , Promote);
 310
 311   if (Subtarget->is64Bit()) {
 312     setOperationAction(ISD::FP_TO_UINT     , MVT::i64  , Expand);
 313     setOperationAction(ISD::FP_TO_UINT     , MVT::i32  , Promote);
 314   } else if (!UseSoftFloat) {
 315     if (X86ScalarSSEf32 && !Subtarget->hasSSE3())
 316       // Expand FP_TO_UINT into a select.
 317       // FIXME: We would like to use a Custom expander here eventually to do
 318       // the optimal thing for SSE vs. the default expansion in the legalizer.
 319       setOperationAction(ISD::FP_TO_UINT   , MVT::i32  , Expand);
 320     else
 321       // With SSE3 we can use fisttpll to convert to a signed i64; without
 322       // SSE, we're stuck with a fistpll.
 323       setOperationAction(ISD::FP_TO_UINT   , MVT::i32  , Custom);
 324   }
 325
 326   // TODO: when we have SSE, these could be more efficient, by using movd/movq.
 327   if (!X86ScalarSSEf64) {
 328     setOperationAction(ISD::BITCAST        , MVT::f32  , Expand);
 329     setOperationAction(ISD::BITCAST        , MVT::i32  , Expand);
 330     if (Subtarget->is64Bit()) {
 331       setOperationAction(ISD::BITCAST      , MVT::f64  , Expand);
 332       // Without SSE, i64->f64 goes through memory.
 333       setOperationAction(ISD::BITCAST      , MVT::i64  , Expand);
 334     }
 335   }
 336
 337   // Scalar integer divide and remainder are lowered to use operations that
 338   // produce two results, to match the available instructions. This exposes
 339   // the two-result form to trivial CSE, which is able to combine x/y and x%y
 340   // into a single instruction.
 341   //
 342   // Scalar integer multiply-high is also lowered to use two-result
 343   // operations, to match the available instructions. However, plain multiply
 344   // (low) operations are left as Legal, as there are single-result
 345   // instructions for this in x86. Using the two-result multiply instructions
 346   // when both high and low results are needed must be arranged by dagcombine.
 347   for (unsigned i = 0, e = 4; i != e; ++i) {
 348     MVT VT = IntVTs[i];
 349     setOperationAction(ISD::MULHS, VT, Expand);
 350     setOperationAction(ISD::MULHU, VT, Expand);
 351     setOperationAction(ISD::SDIV, VT, Expand);
 352     setOperationAction(ISD::UDIV, VT, Expand);
 353     setOperationAction(ISD::SREM, VT, Expand);
 354     setOperationAction(ISD::UREM, VT, Expand);
 355
 356     // Add/Sub overflow ops with MVT::Glues are lowered to EFLAGS dependences.
 357     setOperationAction(ISD::ADDC, VT, Custom);
 358     setOperationAction(ISD::ADDE, VT, Custom);
 359     setOperationAction(ISD::SUBC, VT, Custom);
 360     setOperationAction(ISD::SUBE, VT, Custom);
 361   }
 362
 363   setOperationAction(ISD::BR_JT            , MVT::Other, Expand);
 364   setOperationAction(ISD::BRCOND           , MVT::Other, Custom);
 365   setOperationAction(ISD::BR_CC            , MVT::Other, Expand);
 366   setOperationAction(ISD::SELECT_CC        , MVT::Other, Expand);
 367   if (Subtarget->is64Bit())
 368     setOperationAction(ISD::SIGN_EXTEND_INREG, MVT::i32, Legal);
 369   setOperationAction(ISD::SIGN_EXTEND_INREG, MVT::i16  , Legal);
 370   setOperationAction(ISD::SIGN_EXTEND_INREG, MVT::i8   , Legal);
 371   setOperationAction(ISD::SIGN_EXTEND_INREG, MVT::i1   , Expand);
 372   setOperationAction(ISD::FP_ROUND_INREG   , MVT::f32  , Expand);
 373   setOperationAction(ISD::FREM             , MVT::f32  , Expand);
 374   setOperationAction(ISD::FREM             , MVT::f64  , Expand);
 375   setOperationAction(ISD::FREM             , MVT::f80  , Expand);
 376   setOperationAction(ISD::FLT_ROUNDS_      , MVT::i32  , Custom);
 377
 378   setOperationAction(ISD::CTTZ             , MVT::i8   , Custom);
 379   setOperationAction(ISD::CTLZ             , MVT::i8   , Custom);
 380   setOperationAction(ISD::CTTZ             , MVT::i16  , Custom);
 381   setOperationAction(ISD::CTLZ             , MVT::i16  , Custom);
 382   setOperationAction(ISD::CTTZ             , MVT::i32  , Custom);
 383   setOperationAction(ISD::CTLZ             , MVT::i32  , Custom);
 384   if (Subtarget->is64Bit()) {
 385     setOperationAction(ISD::CTTZ           , MVT::i64  , Custom);
 386     setOperationAction(ISD::CTLZ           , MVT::i64  , Custom);
 387   }
 388
 389   if (Subtarget->hasPOPCNT()) {
 390     setOperationAction(ISD::CTPOP          , MVT::i8   , Promote);
 391   } else {
 392     setOperationAction(ISD::CTPOP          , MVT::i8   , Expand);
 393     setOperationAction(ISD::CTPOP          , MVT::i16  , Expand);
 394     setOperationAction(ISD::CTPOP          , MVT::i32  , Expand);
 395     if (Subtarget->is64Bit())
 396       setOperationAction(ISD::CTPOP        , MVT::i64  , Expand);
 397   }
 398
 399   setOperationAction(ISD::READCYCLECOUNTER , MVT::i64  , Custom);
 400   setOperationAction(ISD::BSWAP            , MVT::i16  , Expand);
 401
 402   // These should be promoted to a larger select which is supported.
 403   setOperationAction(ISD::SELECT          , MVT::i1   , Promote);
 404   // X86 wants to expand cmov itself.
 405   setOperationAction(ISD::SELECT          , MVT::i8   , Custom);
 406   setOperationAction(ISD::SELECT          , MVT::i16  , Custom);
 407   setOperationAction(ISD::SELECT          , MVT::i32  , Custom);
 408   setOperationAction(ISD::SELECT          , MVT::f32  , Custom);
 409   setOperationAction(ISD::SELECT          , MVT::f64  , Custom);
 410   setOperationAction(ISD::SELECT          , MVT::f80  , Custom);
 411   setOperationAction(ISD::SETCC           , MVT::i8   , Custom);
 412   setOperationAction(ISD::SETCC           , MVT::i16  , Custom);
 413   setOperationAction(ISD::SETCC           , MVT::i32  , Custom);
 414   setOperationAction(ISD::SETCC           , MVT::f32  , Custom);
 415   setOperationAction(ISD::SETCC           , MVT::f64  , Custom);
 416   setOperationAction(ISD::SETCC           , MVT::f80  , Custom);
 417   if (Subtarget->is64Bit()) {
 418     setOperationAction(ISD::SELECT        , MVT::i64  , Custom);
 419     setOperationAction(ISD::SETCC         , MVT::i64  , Custom);
 420   }
 421   setOperationAction(ISD::EH_RETURN       , MVT::Other, Custom);
 422
 423   // Darwin ABI issue.
 424   setOperationAction(ISD::ConstantPool    , MVT::i32  , Custom);
 425   setOperationAction(ISD::JumpTable       , MVT::i32  , Custom);
 426   setOperationAction(ISD::GlobalAddress   , MVT::i32  , Custom);
 427   setOperationAction(ISD::GlobalTLSAddress, MVT::i32  , Custom);
 428   if (Subtarget->is64Bit())
 429     setOperationAction(ISD::GlobalTLSAddress, MVT::i64, Custom);
 430   setOperationAction(ISD::ExternalSymbol  , MVT::i32  , Custom);
 431   setOperationAction(ISD::BlockAddress    , MVT::i32  , Custom);
 432   if (Subtarget->is64Bit()) {
 433     setOperationAction(ISD::ConstantPool  , MVT::i64  , Custom);
 434     setOperationAction(ISD::JumpTable     , MVT::i64  , Custom);
 435     setOperationAction(ISD::GlobalAddress , MVT::i64  , Custom);
 436     setOperationAction(ISD::ExternalSymbol, MVT::i64  , Custom);
 437     setOperationAction(ISD::BlockAddress  , MVT::i64  , Custom);
 438   }
 439   // 64-bit addm sub, shl, sra, srl (iff 32-bit x86)
 440   setOperationAction(ISD::SHL_PARTS       , MVT::i32  , Custom);
 441   setOperationAction(ISD::SRA_PARTS       , MVT::i32  , Custom);
 442   setOperationAction(ISD::SRL_PARTS       , MVT::i32  , Custom);
 443   if (Subtarget->is64Bit()) {
 444     setOperationAction(ISD::SHL_PARTS     , MVT::i64  , Custom);
 445     setOperationAction(ISD::SRA_PARTS     , MVT::i64  , Custom);
 446     setOperationAction(ISD::SRL_PARTS     , MVT::i64  , Custom);
 447   }
 448
 449   if (Subtarget->hasXMM())
 450     setOperationAction(ISD::PREFETCH      , MVT::Other, Legal);
 451
 452   setOperationAction(ISD::MEMBARRIER    , MVT::Other, Custom);
 453   setOperationAction(ISD::ATOMIC_FENCE  , MVT::Other, Custom);
 454
 455   // On X86 and X86-64, atomic operations are lowered to locked instructions.
 456   // Locked instructions, in turn, have implicit fence semantics (all memory
 457   // operations are flushed before issuing the locked instruction, and they
 458   // are not buffered), so we can fold away the common pattern of
 459   // fence-atomic-fence.
 460   setShouldFoldAtomicFences(true);
 461
 462   // Expand certain atomics
 463   for (unsigned i = 0, e = 4; i != e; ++i) {
 464     MVT VT = IntVTs[i];
 465     setOperationAction(ISD::ATOMIC_CMP_SWAP, VT, Custom);
 466     setOperationAction(ISD::ATOMIC_LOAD_SUB, VT, Custom);
 467     setOperationAction(ISD::ATOMIC_STORE, VT, Custom);
 468   }
 469
 470   if (!Subtarget->is64Bit()) {
 471     setOperationAction(ISD::ATOMIC_LOAD, MVT::i64, Custom);
 472     setOperationAction(ISD::ATOMIC_LOAD_ADD, MVT::i64, Custom);
 473     setOperationAction(ISD::ATOMIC_LOAD_SUB, MVT::i64, Custom);
 474     setOperationAction(ISD::ATOMIC_LOAD_AND, MVT::i64, Custom);
 475     setOperationAction(ISD::ATOMIC_LOAD_OR, MVT::i64, Custom);
 476     setOperationAction(ISD::ATOMIC_LOAD_XOR, MVT::i64, Custom);
 477     setOperationAction(ISD::ATOMIC_LOAD_NAND, MVT::i64, Custom);
 478     setOperationAction(ISD::ATOMIC_SWAP, MVT::i64, Custom);
 479   }
 480
 481   if (Subtarget->hasCmpxchg16b()) {
 482     setOperationAction(ISD::ATOMIC_CMP_SWAP, MVT::i128, Custom);
 483   }
 484
 485   // FIXME - use subtarget debug flags
 486   if (!Subtarget->isTargetDarwin() &&
 487       !Subtarget->isTargetELF() &&
 488       !Subtarget->isTargetCygMing()) {
 489     setOperationAction(ISD::EH_LABEL, MVT::Other, Expand);
 490   }
 491
 492   setOperationAction(ISD::EXCEPTIONADDR, MVT::i64, Expand);
 493   setOperationAction(ISD::EHSELECTION,   MVT::i64, Expand);
 494   setOperationAction(ISD::EXCEPTIONADDR, MVT::i32, Expand);
 495   setOperationAction(ISD::EHSELECTION,   MVT::i32, Expand);
 496   if (Subtarget->is64Bit()) {
 497     setExceptionPointerRegister(X86::RAX);
 498     setExceptionSelectorRegister(X86::RDX);
 499   } else {
 500     setExceptionPointerRegister(X86::EAX);
 501     setExceptionSelectorRegister(X86::EDX);
 502   }
 503   setOperationAction(ISD::FRAME_TO_ARGS_OFFSET, MVT::i32, Custom);
 504   setOperationAction(ISD::FRAME_TO_ARGS_OFFSET, MVT::i64, Custom);
 505
 506   setOperationAction(ISD::TRAMPOLINE, MVT::Other, Custom);
 507
 508   setOperationAction(ISD::TRAP, MVT::Other, Legal);
 509
 510   // VASTART needs to be custom lowered to use the VarArgsFrameIndex
 511   setOperationAction(ISD::VASTART           , MVT::Other, Custom);
 512   setOperationAction(ISD::VAEND             , MVT::Other, Expand);
 513   if (Subtarget->is64Bit()) {
 514     setOperationAction(ISD::VAARG           , MVT::Other, Custom);
 515     setOperationAction(ISD::VACOPY          , MVT::Other, Custom);
 516   } else {
 517     setOperationAction(ISD::VAARG           , MVT::Other, Expand);
 518     setOperationAction(ISD::VACOPY          , MVT::Other, Expand);
 519   }
 520
 521   setOperationAction(ISD::STACKSAVE,          MVT::Other, Expand);
 522   setOperationAction(ISD::STACKRESTORE,       MVT::Other, Expand);
 523   setOperationAction(ISD::DYNAMIC_STACKALLOC,
 524                      (Subtarget->is64Bit() ? MVT::i64 : MVT::i32),
 525                      (Subtarget->isTargetCOFF()
 526                       && !Subtarget->isTargetEnvMacho()
 527                       ? Custom : Expand));
 528
 529   if (!UseSoftFloat && X86ScalarSSEf64) {
 530     // f32 and f64 use SSE.
 531     // Set up the FP register classes.
 532     addRegisterClass(MVT::f32, X86::FR32RegisterClass);
 533     addRegisterClass(MVT::f64, X86::FR64RegisterClass);
 534
 535     // Use ANDPD to simulate FABS.
 536     setOperationAction(ISD::FABS , MVT::f64, Custom);
 537     setOperationAction(ISD::FABS , MVT::f32, Custom);
 538
 539     // Use XORP to simulate FNEG.
 540     setOperationAction(ISD::FNEG , MVT::f64, Custom);
 541     setOperationAction(ISD::FNEG , MVT::f32, Custom);
 542
 543     // Use ANDPD and ORPD to simulate FCOPYSIGN.
 544     setOperationAction(ISD::FCOPYSIGN, MVT::f64, Custom);
 545     setOperationAction(ISD::FCOPYSIGN, MVT::f32, Custom);
 546
 547     // Lower this to FGETSIGNx86 plus an AND.
 548     setOperationAction(ISD::FGETSIGN, MVT::i64, Custom);
 549     setOperationAction(ISD::FGETSIGN, MVT::i32, Custom);
 550
 551     // We don't support sin/cos/fmod
 552     setOperationAction(ISD::FSIN , MVT::f64, Expand);
 553     setOperationAction(ISD::FCOS , MVT::f64, Expand);
 554     setOperationAction(ISD::FSIN , MVT::f32, Expand);
 555     setOperationAction(ISD::FCOS , MVT::f32, Expand);
 556
 557     // Expand FP immediates into loads from the stack, except for the special
 558     // cases we handle.
 559     addLegalFPImmediate(APFloat(+0.0)); // xorpd
 560     addLegalFPImmediate(APFloat(+0.0f)); // xorps
 561   } else if (!UseSoftFloat && X86ScalarSSEf32) {
 562     // Use SSE for f32, x87 for f64.
 563     // Set up the FP register classes.
 564     addRegisterClass(MVT::f32, X86::FR32RegisterClass);
 565     addRegisterClass(MVT::f64, X86::RFP64RegisterClass);
 566
 567     // Use ANDPS to simulate FABS.
 568     setOperationAction(ISD::FABS , MVT::f32, Custom);
 569
 570     // Use XORP to simulate FNEG.
 571     setOperationAction(ISD::FNEG , MVT::f32, Custom);
 572
 573     setOperationAction(ISD::UNDEF,     MVT::f64, Expand);
 574
 575     // Use ANDPS and ORPS to simulate FCOPYSIGN.
 576     setOperationAction(ISD::FCOPYSIGN, MVT::f64, Expand);
 577     setOperationAction(ISD::FCOPYSIGN, MVT::f32, Custom);
 578
 579     // We don't support sin/cos/fmod
 580     setOperationAction(ISD::FSIN , MVT::f32, Expand);
 581     setOperationAction(ISD::FCOS , MVT::f32, Expand);
 582
 583     // Special cases we handle for FP constants.
 584     addLegalFPImmediate(APFloat(+0.0f)); // xorps
 585     addLegalFPImmediate(APFloat(+0.0)); // FLD0
 586     addLegalFPImmediate(APFloat(+1.0)); // FLD1
 587     addLegalFPImmediate(APFloat(-0.0)); // FLD0/FCHS
 588     addLegalFPImmediate(APFloat(-1.0)); // FLD1/FCHS
 589
 590     if (!UnsafeFPMath) {
 591       setOperationAction(ISD::FSIN           , MVT::f64  , Expand);
 592       setOperationAction(ISD::FCOS           , MVT::f64  , Expand);
 593     }
 594   } else if (!UseSoftFloat) {
 595     // f32 and f64 in x87.
 596     // Set up the FP register classes.
 597     addRegisterClass(MVT::f64, X86::RFP64RegisterClass);
 598     addRegisterClass(MVT::f32, X86::RFP32RegisterClass);
 599
 600     setOperationAction(ISD::UNDEF,     MVT::f64, Expand);
 601     setOperationAction(ISD::UNDEF,     MVT::f32, Expand);
 602     setOperationAction(ISD::FCOPYSIGN, MVT::f64, Expand);
 603     setOperationAction(ISD::FCOPYSIGN, MVT::f32, Expand);
 604
 605     if (!UnsafeFPMath) {
 606       setOperationAction(ISD::FSIN           , MVT::f64  , Expand);
 607       setOperationAction(ISD::FCOS           , MVT::f64  , Expand);
 608     }
 609     addLegalFPImmediate(APFloat(+0.0)); // FLD0
 610     addLegalFPImmediate(APFloat(+1.0)); // FLD1
 611     addLegalFPImmediate(APFloat(-0.0)); // FLD0/FCHS
 612     addLegalFPImmediate(APFloat(-1.0)); // FLD1/FCHS
 613     addLegalFPImmediate(APFloat(+0.0f)); // FLD0
 614     addLegalFPImmediate(APFloat(+1.0f)); // FLD1
 615     addLegalFPImmediate(APFloat(-0.0f)); // FLD0/FCHS
 616     addLegalFPImmediate(APFloat(-1.0f)); // FLD1/FCHS
 617   }
 618
 619   // We don't support FMA.
 620   setOperationAction(ISD::FMA, MVT::f64, Expand);
 621   setOperationAction(ISD::FMA, MVT::f32, Expand);
 622
 623   // Long double always uses X87.
 624   if (!UseSoftFloat) {
 625     addRegisterClass(MVT::f80, X86::RFP80RegisterClass);
 626     setOperationAction(ISD::UNDEF,     MVT::f80, Expand);
 627     setOperationAction(ISD::FCOPYSIGN, MVT::f80, Expand);
 628     {
 629       APFloat TmpFlt = APFloat::getZero(APFloat::x87DoubleExtended);
 630       addLegalFPImmediate(TmpFlt);  // FLD0
 631       TmpFlt.changeSign();
 632       addLegalFPImmediate(TmpFlt);  // FLD0/FCHS
 633
 634       bool ignored;
 635       APFloat TmpFlt2(+1.0);
 636       TmpFlt2.convert(APFloat::x87DoubleExtended, APFloat::rmNearestTiesToEven,
 637                       &ignored);
 638       addLegalFPImmediate(TmpFlt2);  // FLD1
 639       TmpFlt2.changeSign();
 640       addLegalFPImmediate(TmpFlt2);  // FLD1/FCHS
 641     }
 642
 643     if (!UnsafeFPMath) {
 644       setOperationAction(ISD::FSIN           , MVT::f80  , Expand);
 645       setOperationAction(ISD::FCOS           , MVT::f80  , Expand);
 646     }
 647
 648     setOperationAction(ISD::FMA, MVT::f80, Expand);
 649   }
 650
 651   // Always use a library call for pow.
 652   setOperationAction(ISD::FPOW             , MVT::f32  , Expand);
 653   setOperationAction(ISD::FPOW             , MVT::f64  , Expand);
 654   setOperationAction(ISD::FPOW             , MVT::f80  , Expand);
 655
 656   setOperationAction(ISD::FLOG, MVT::f80, Expand);
 657   setOperationAction(ISD::FLOG2, MVT::f80, Expand);
 658   setOperationAction(ISD::FLOG10, MVT::f80, Expand);
 659   setOperationAction(ISD::FEXP, MVT::f80, Expand);
 660   setOperationAction(ISD::FEXP2, MVT::f80, Expand);
 661
 662   // First set operation action for all vector types to either promote
 663   // (for widening) or expand (for scalarization). Then we will selectively
 664   // turn on ones that can be effectively codegen'd.
 665   for (unsigned VT = (unsigned)MVT::FIRST_VECTOR_VALUETYPE;
 666        VT <= (unsigned)MVT::LAST_VECTOR_VALUETYPE; ++VT) {
 667     setOperationAction(ISD::ADD , (MVT::SimpleValueType)VT, Expand);
 668     setOperationAction(ISD::SUB , (MVT::SimpleValueType)VT, Expand);
 669     setOperationAction(ISD::FADD, (MVT::SimpleValueType)VT, Expand);
 670     setOperationAction(ISD::FNEG, (MVT::SimpleValueType)VT, Expand);
 671     setOperationAction(ISD::FSUB, (MVT::SimpleValueType)VT, Expand);
 672     setOperationAction(ISD::MUL , (MVT::SimpleValueType)VT, Expand);
 673     setOperationAction(ISD::FMUL, (MVT::SimpleValueType)VT, Expand);
 674     setOperationAction(ISD::SDIV, (MVT::SimpleValueType)VT, Expand);
 675     setOperationAction(ISD::UDIV, (MVT::SimpleValueType)VT, Expand);
 676     setOperationAction(ISD::FDIV, (MVT::SimpleValueType)VT, Expand);
 677     setOperationAction(ISD::SREM, (MVT::SimpleValueType)VT, Expand);
 678     setOperationAction(ISD::UREM, (MVT::SimpleValueType)VT, Expand);
 679     setOperationAction(ISD::LOAD, (MVT::SimpleValueType)VT, Expand);
 680     setOperationAction(ISD::VECTOR_SHUFFLE, (MVT::SimpleValueType)VT, Expand);
 681     setOperationAction(ISD::EXTRACT_VECTOR_ELT,(MVT::SimpleValueType)VT,Expand);
 682     setOperationAction(ISD::INSERT_VECTOR_ELT,(MVT::SimpleValueType)VT, Expand);
 683     setOperationAction(ISD::EXTRACT_SUBVECTOR,(MVT::SimpleValueType)VT,Expand);
 684     setOperationAction(ISD::INSERT_SUBVECTOR,(MVT::SimpleValueType)VT,Expand);
 685     setOperationAction(ISD::FABS, (MVT::SimpleValueType)VT, Expand);
 686     setOperationAction(ISD::FSIN, (MVT::SimpleValueType)VT, Expand);
 687     setOperationAction(ISD::FCOS, (MVT::SimpleValueType)VT, Expand);
 688     setOperationAction(ISD::FREM, (MVT::SimpleValueType)VT, Expand);
 689     setOperationAction(ISD::FPOWI, (MVT::SimpleValueType)VT, Expand);
 690     setOperationAction(ISD::FSQRT, (MVT::SimpleValueType)VT, Expand);
 691     setOperationAction(ISD::FCOPYSIGN, (MVT::SimpleValueType)VT, Expand);
 692     setOperationAction(ISD::SMUL_LOHI, (MVT::SimpleValueType)VT, Expand);
 693     setOperationAction(ISD::UMUL_LOHI, (MVT::SimpleValueType)VT, Expand);
 694     setOperationAction(ISD::SDIVREM, (MVT::SimpleValueType)VT, Expand);
 695     setOperationAction(ISD::UDIVREM, (MVT::SimpleValueType)VT, Expand);
 696     setOperationAction(ISD::FPOW, (MVT::SimpleValueType)VT, Expand);
 697     setOperationAction(ISD::CTPOP, (MVT::SimpleValueType)VT, Expand);
 698     setOperationAction(ISD::CTTZ, (MVT::SimpleValueType)VT, Expand);
 699     setOperationAction(ISD::CTLZ, (MVT::SimpleValueType)VT, Expand);
 700     setOperationAction(ISD::SHL, (MVT::SimpleValueType)VT, Expand);
 701     setOperationAction(ISD::SRA, (MVT::SimpleValueType)VT, Expand);
 702     setOperationAction(ISD::SRL, (MVT::SimpleValueType)VT, Expand);
 703     setOperationAction(ISD::ROTL, (MVT::SimpleValueType)VT, Expand);
 704     setOperationAction(ISD::ROTR, (MVT::SimpleValueType)VT, Expand);
 705     setOperationAction(ISD::BSWAP, (MVT::SimpleValueType)VT, Expand);
 706     setOperationAction(ISD::VSETCC, (MVT::SimpleValueType)VT, Expand);
 707     setOperationAction(ISD::FLOG, (MVT::SimpleValueType)VT, Expand);
 708     setOperationAction(ISD::FLOG2, (MVT::SimpleValueType)VT, Expand);
 709     setOperationAction(ISD::FLOG10, (MVT::SimpleValueType)VT, Expand);
 710     setOperationAction(ISD::FEXP, (MVT::SimpleValueType)VT, Expand);
 711     setOperationAction(ISD::FEXP2, (MVT::SimpleValueType)VT, Expand);
 712     setOperationAction(ISD::FP_TO_UINT, (MVT::SimpleValueType)VT, Expand);
 713     setOperationAction(ISD::FP_TO_SINT, (MVT::SimpleValueType)VT, Expand);
 714     setOperationAction(ISD::UINT_TO_FP, (MVT::SimpleValueType)VT, Expand);
 715     setOperationAction(ISD::SINT_TO_FP, (MVT::SimpleValueType)VT, Expand);
 716     setOperationAction(ISD::SIGN_EXTEND_INREG, (MVT::SimpleValueType)VT,Expand);
 717     setOperationAction(ISD::TRUNCATE,  (MVT::SimpleValueType)VT, Expand);
 718     setOperationAction(ISD::SIGN_EXTEND,  (MVT::SimpleValueType)VT, Expand);
 719     setOperationAction(ISD::ZERO_EXTEND,  (MVT::SimpleValueType)VT, Expand);
 720     setOperationAction(ISD::ANY_EXTEND,  (MVT::SimpleValueType)VT, Expand);
 721     for (unsigned InnerVT = (unsigned)MVT::FIRST_VECTOR_VALUETYPE;
 722          InnerVT <= (unsigned)MVT::LAST_VECTOR_VALUETYPE; ++InnerVT)
 723       setTruncStoreAction((MVT::SimpleValueType)VT,
 724                           (MVT::SimpleValueType)InnerVT, Expand);
 725     setLoadExtAction(ISD::SEXTLOAD, (MVT::SimpleValueType)VT, Expand);
 726     setLoadExtAction(ISD::ZEXTLOAD, (MVT::SimpleValueType)VT, Expand);
 727     setLoadExtAction(ISD::EXTLOAD, (MVT::SimpleValueType)VT, Expand);
 728   }
 729
 730   // FIXME: In order to prevent SSE instructions being expanded to MMX ones
 731   // with -msoft-float, disable use of MMX as well.
 732   if (!UseSoftFloat && Subtarget->hasMMX()) {
 733     addRegisterClass(MVT::x86mmx, X86::VR64RegisterClass);
 734     // No operations on x86mmx supported, everything uses intrinsics.
 735   }
 736
 737   // MMX-sized vectors (other than x86mmx) are expected to be expanded
 738   // into smaller operations.
 739   setOperationAction(ISD::MULHS,              MVT::v8i8,  Expand);
 740   setOperationAction(ISD::MULHS,              MVT::v4i16, Expand);
 741   setOperationAction(ISD::MULHS,              MVT::v2i32, Expand);
 742   setOperationAction(ISD::MULHS,              MVT::v1i64, Expand);
 743   setOperationAction(ISD::AND,                MVT::v8i8,  Expand);
 744   setOperationAction(ISD::AND,                MVT::v4i16, Expand);
 745   setOperationAction(ISD::AND,                MVT::v2i32, Expand);
 746   setOperationAction(ISD::AND,                MVT::v1i64, Expand);
 747   setOperationAction(ISD::OR,                 MVT::v8i8,  Expand);
 748   setOperationAction(ISD::OR,                 MVT::v4i16, Expand);
 749   setOperationAction(ISD::OR,                 MVT::v2i32, Expand);
 750   setOperationAction(ISD::OR,                 MVT::v1i64, Expand);
 751   setOperationAction(ISD::XOR,                MVT::v8i8,  Expand);
 752   setOperationAction(ISD::XOR,                MVT::v4i16, Expand);
 753   setOperationAction(ISD::XOR,                MVT::v2i32, Expand);
 754   setOperationAction(ISD::XOR,                MVT::v1i64, Expand);
 755   setOperationAction(ISD::SCALAR_TO_VECTOR,   MVT::v8i8,  Expand);
 756   setOperationAction(ISD::SCALAR_TO_VECTOR,   MVT::v4i16, Expand);
 757   setOperationAction(ISD::SCALAR_TO_VECTOR,   MVT::v2i32, Expand);
 758   setOperationAction(ISD::SCALAR_TO_VECTOR,   MVT::v1i64, Expand);
 759   setOperationAction(ISD::INSERT_VECTOR_ELT,  MVT::v1i64, Expand);
 760   setOperationAction(ISD::SELECT,             MVT::v8i8,  Expand);
 761   setOperationAction(ISD::SELECT,             MVT::v4i16, Expand);
 762   setOperationAction(ISD::SELECT,             MVT::v2i32, Expand);
 763   setOperationAction(ISD::SELECT,             MVT::v1i64, Expand);
 764   setOperationAction(ISD::BITCAST,            MVT::v8i8,  Expand);
 765   setOperationAction(ISD::BITCAST,            MVT::v4i16, Expand);
 766   setOperationAction(ISD::BITCAST,            MVT::v2i32, Expand);
 767   setOperationAction(ISD::BITCAST,            MVT::v1i64, Expand);
 768
 769   if (!UseSoftFloat && Subtarget->hasXMM()) {
 770     addRegisterClass(MVT::v4f32, X86::VR128RegisterClass);
 771
 772     setOperationAction(ISD::FADD,               MVT::v4f32, Legal);
 773     setOperationAction(ISD::FSUB,               MVT::v4f32, Legal);
 774     setOperationAction(ISD::FMUL,               MVT::v4f32, Legal);
 775     setOperationAction(ISD::FDIV,               MVT::v4f32, Legal);
 776     setOperationAction(ISD::FSQRT,              MVT::v4f32, Legal);
 777     setOperationAction(ISD::FNEG,               MVT::v4f32, Custom);
 778     setOperationAction(ISD::LOAD,               MVT::v4f32, Legal);
 779     setOperationAction(ISD::BUILD_VECTOR,       MVT::v4f32, Custom);
 780     setOperationAction(ISD::VECTOR_SHUFFLE,     MVT::v4f32, Custom);
 781     setOperationAction(ISD::EXTRACT_VECTOR_ELT, MVT::v4f32, Custom);
 782     setOperationAction(ISD::SELECT,             MVT::v4f32, Custom);
 783     setOperationAction(ISD::VSETCC,             MVT::v4f32, Custom);
 784   }
 785
 786   if (!UseSoftFloat && Subtarget->hasXMMInt()) {
 787     addRegisterClass(MVT::v2f64, X86::VR128RegisterClass);
 788
 789     // FIXME: Unfortunately -soft-float and -no-implicit-float means XMM
 790     // registers cannot be used even for integer operations.
 791     addRegisterClass(MVT::v16i8, X86::VR128RegisterClass);
 792     addRegisterClass(MVT::v8i16, X86::VR128RegisterClass);
 793     addRegisterClass(MVT::v4i32, X86::VR128RegisterClass);
 794     addRegisterClass(MVT::v2i64, X86::VR128RegisterClass);
 795
 796     setOperationAction(ISD::ADD,                MVT::v16i8, Legal);
 797     setOperationAction(ISD::ADD,                MVT::v8i16, Legal);
 798     setOperationAction(ISD::ADD,                MVT::v4i32, Legal);
 799     setOperationAction(ISD::ADD,                MVT::v2i64, Legal);
 800     setOperationAction(ISD::MUL,                MVT::v2i64, Custom);
 801     setOperationAction(ISD::SUB,                MVT::v16i8, Legal);
 802     setOperationAction(ISD::SUB,                MVT::v8i16, Legal);
 803     setOperationAction(ISD::SUB,                MVT::v4i32, Legal);
 804     setOperationAction(ISD::SUB,                MVT::v2i64, Legal);
 805     setOperationAction(ISD::MUL,                MVT::v8i16, Legal);
 806     setOperationAction(ISD::FADD,               MVT::v2f64, Legal);
 807     setOperationAction(ISD::FSUB,               MVT::v2f64, Legal);
 808     setOperationAction(ISD::FMUL,               MVT::v2f64, Legal);
 809     setOperationAction(ISD::FDIV,               MVT::v2f64, Legal);
 810     setOperationAction(ISD::FSQRT,              MVT::v2f64, Legal);
 811     setOperationAction(ISD::FNEG,               MVT::v2f64, Custom);
 812
 813     setOperationAction(ISD::VSETCC,             MVT::v2f64, Custom);
 814     setOperationAction(ISD::VSETCC,             MVT::v16i8, Custom);
 815     setOperationAction(ISD::VSETCC,             MVT::v8i16, Custom);
 816     setOperationAction(ISD::VSETCC,             MVT::v4i32, Custom);
 817
 818     setOperationAction(ISD::SCALAR_TO_VECTOR,   MVT::v16i8, Custom);
 819     setOperationAction(ISD::SCALAR_TO_VECTOR,   MVT::v8i16, Custom);
 820     setOperationAction(ISD::INSERT_VECTOR_ELT,  MVT::v8i16, Custom);
 821     setOperationAction(ISD::INSERT_VECTOR_ELT,  MVT::v4i32, Custom);
 822     setOperationAction(ISD::INSERT_VECTOR_ELT,  MVT::v4f32, Custom);
 823
 824     setOperationAction(ISD::CONCAT_VECTORS,     MVT::v2f64, Custom);
 825     setOperationAction(ISD::CONCAT_VECTORS,     MVT::v2i64, Custom);
 826     setOperationAction(ISD::CONCAT_VECTORS,     MVT::v16i8, Custom);
 827     setOperationAction(ISD::CONCAT_VECTORS,     MVT::v8i16, Custom);
 828     setOperationAction(ISD::CONCAT_VECTORS,     MVT::v4i32, Custom);
 829
 830     // Custom lower build_vector, vector_shuffle, and extract_vector_elt.
 831     for (unsigned i = (unsigned)MVT::v16i8; i != (unsigned)MVT::v2i64; ++i) {
 832       EVT VT = (MVT::SimpleValueType)i;
 833       // Do not attempt to custom lower non-power-of-2 vectors
 834       if (!isPowerOf2_32(VT.getVectorNumElements()))
 835         continue;
 836       // Do not attempt to custom lower non-128-bit vectors
 837       if (!VT.is128BitVector())
 838         continue;
 839       setOperationAction(ISD::BUILD_VECTOR,
 840                          VT.getSimpleVT().SimpleTy, Custom);
 841       setOperationAction(ISD::VECTOR_SHUFFLE,
 842                          VT.getSimpleVT().SimpleTy, Custom);
 843       setOperationAction(ISD::EXTRACT_VECTOR_ELT,
 844                          VT.getSimpleVT().SimpleTy, Custom);
 845     }
 846
 847     setOperationAction(ISD::BUILD_VECTOR,       MVT::v2f64, Custom);
 848     setOperationAction(ISD::BUILD_VECTOR,       MVT::v2i64, Custom);
 849     setOperationAction(ISD::VECTOR_SHUFFLE,     MVT::v2f64, Custom);
 850     setOperationAction(ISD::VECTOR_SHUFFLE,     MVT::v2i64, Custom);
 851     setOperationAction(ISD::INSERT_VECTOR_ELT,  MVT::v2f64, Custom);
 852     setOperationAction(ISD::EXTRACT_VECTOR_ELT, MVT::v2f64, Custom);
 853
 854     if (Subtarget->is64Bit()) {
 855       setOperationAction(ISD::INSERT_VECTOR_ELT,  MVT::v2i64, Custom);
 856       setOperationAction(ISD::EXTRACT_VECTOR_ELT, MVT::v2i64, Custom);
 857     }
 858
 859     // Promote v16i8, v8i16, v4i32 load, select, and, or, xor to v2i64.
 860     for (unsigned i = (unsigned)MVT::v16i8; i != (unsigned)MVT::v2i64; i++) {
 861       MVT::SimpleValueType SVT = (MVT::SimpleValueType)i;
 862       EVT VT = SVT;
 863
 864       // Do not attempt to promote non-128-bit vectors
 865       if (!VT.is128BitVector())
 866         continue;
 867
 868       setOperationAction(ISD::AND,    SVT, Promote);
 869       AddPromotedToType (ISD::AND,    SVT, MVT::v2i64);
 870       setOperationAction(ISD::OR,     SVT, Promote);
 871       AddPromotedToType (ISD::OR,     SVT, MVT::v2i64);
 872       setOperationAction(ISD::XOR,    SVT, Promote);
 873       AddPromotedToType (ISD::XOR,    SVT, MVT::v2i64);
 874       setOperationAction(ISD::LOAD,   SVT, Promote);
 875       AddPromotedToType (ISD::LOAD,   SVT, MVT::v2i64);
 876       setOperationAction(ISD::SELECT, SVT, Promote);
 877       AddPromotedToType (ISD::SELECT, SVT, MVT::v2i64);
 878     }
 879
 880     setTruncStoreAction(MVT::f64, MVT::f32, Expand);
 881
 882     // Custom lower v2i64 and v2f64 selects.
 883     setOperationAction(ISD::LOAD,               MVT::v2f64, Legal);
 884     setOperationAction(ISD::LOAD,               MVT::v2i64, Legal);
 885     setOperationAction(ISD::SELECT,             MVT::v2f64, Custom);
 886     setOperationAction(ISD::SELECT,             MVT::v2i64, Custom);
 887
 888     setOperationAction(ISD::FP_TO_SINT,         MVT::v4i32, Legal);
 889     setOperationAction(ISD::SINT_TO_FP,         MVT::v4i32, Legal);
 890   }
 891
 892   if (Subtarget->hasSSE41() || Subtarget->hasAVX()) {
 893     setOperationAction(ISD::FFLOOR,             MVT::f32,   Legal);
 894     setOperationAction(ISD::FCEIL,              MVT::f32,   Legal);
 895     setOperationAction(ISD::FTRUNC,             MVT::f32,   Legal);
 896     setOperationAction(ISD::FRINT,              MVT::f32,   Legal);
 897     setOperationAction(ISD::FNEARBYINT,         MVT::f32,   Legal);
 898     setOperationAction(ISD::FFLOOR,             MVT::f64,   Legal);
 899     setOperationAction(ISD::FCEIL,              MVT::f64,   Legal);
 900     setOperationAction(ISD::FTRUNC,             MVT::f64,   Legal);
 901     setOperationAction(ISD::FRINT,              MVT::f64,   Legal);
 902     setOperationAction(ISD::FNEARBYINT,         MVT::f64,   Legal);
 903
 904     // FIXME: Do we need to handle scalar-to-vector here?
 905     setOperationAction(ISD::MUL,                MVT::v4i32, Legal);
 906
 907     // Can turn SHL into an integer multiply.
 908     setOperationAction(ISD::SHL,                MVT::v4i32, Custom);
 909     setOperationAction(ISD::SHL,                MVT::v16i8, Custom);
 910
 911     // i8 and i16 vectors are custom , because the source register and source
 912     // source memory operand types are not the same width.  f32 vectors are
 913     // custom since the immediate controlling the insert encodes additional
 914     // information.
 915     setOperationAction(ISD::INSERT_VECTOR_ELT,  MVT::v16i8, Custom);
 916     setOperationAction(ISD::INSERT_VECTOR_ELT,  MVT::v8i16, Custom);
 917     setOperationAction(ISD::INSERT_VECTOR_ELT,  MVT::v4i32, Custom);
 918     setOperationAction(ISD::INSERT_VECTOR_ELT,  MVT::v4f32, Custom);
 919
 920     setOperationAction(ISD::EXTRACT_VECTOR_ELT, MVT::v16i8, Custom);
 921     setOperationAction(ISD::EXTRACT_VECTOR_ELT, MVT::v8i16, Custom);
 922     setOperationAction(ISD::EXTRACT_VECTOR_ELT, MVT::v4i32, Custom);
 923     setOperationAction(ISD::EXTRACT_VECTOR_ELT, MVT::v4f32, Custom);
 924
 925     if (Subtarget->is64Bit()) {
 926       setOperationAction(ISD::INSERT_VECTOR_ELT,  MVT::v2i64, Legal);
 927       setOperationAction(ISD::EXTRACT_VECTOR_ELT, MVT::v2i64, Legal);
 928     }
 929   }
 930
 931   if (Subtarget->hasSSE2() || Subtarget->hasAVX()) {
 932     setOperationAction(ISD::SRL,               MVT::v2i64, Custom);
 933     setOperationAction(ISD::SRL,               MVT::v4i32, Custom);
 934     setOperationAction(ISD::SRL,               MVT::v16i8, Custom);
 935     setOperationAction(ISD::SRL,               MVT::v8i16, Custom);
 936
 937     setOperationAction(ISD::SHL,               MVT::v2i64, Custom);
 938     setOperationAction(ISD::SHL,               MVT::v4i32, Custom);
 939     setOperationAction(ISD::SHL,               MVT::v8i16, Custom);
 940
 941     setOperationAction(ISD::SRA,               MVT::v4i32, Custom);
 942     setOperationAction(ISD::SRA,               MVT::v8i16, Custom);
 943   }
 944
 945   if (Subtarget->hasSSE42() || Subtarget->hasAVX())
 946     setOperationAction(ISD::VSETCC,             MVT::v2i64, Custom);
 947
 948   if (!UseSoftFloat && Subtarget->hasAVX()) {
 949     addRegisterClass(MVT::v32i8,  X86::VR256RegisterClass);
 950     addRegisterClass(MVT::v16i16, X86::VR256RegisterClass);
 951     addRegisterClass(MVT::v8i32,  X86::VR256RegisterClass);
 952     addRegisterClass(MVT::v8f32,  X86::VR256RegisterClass);
 953     addRegisterClass(MVT::v4i64,  X86::VR256RegisterClass);
 954     addRegisterClass(MVT::v4f64,  X86::VR256RegisterClass);
 955
 956     setOperationAction(ISD::LOAD,               MVT::v8f32, Legal);
 957     setOperationAction(ISD::LOAD,               MVT::v4f64, Legal);
 958     setOperationAction(ISD::LOAD,               MVT::v4i64, Legal);
 959
 960     setOperationAction(ISD::FADD,               MVT::v8f32, Legal);
 961     setOperationAction(ISD::FSUB,               MVT::v8f32, Legal);
 962     setOperationAction(ISD::FMUL,               MVT::v8f32, Legal);
 963     setOperationAction(ISD::FDIV,               MVT::v8f32, Legal);
 964     setOperationAction(ISD::FSQRT,              MVT::v8f32, Legal);
 965     setOperationAction(ISD::FNEG,               MVT::v8f32, Custom);
 966
 967     setOperationAction(ISD::FADD,               MVT::v4f64, Legal);
 968     setOperationAction(ISD::FSUB,               MVT::v4f64, Legal);
 969     setOperationAction(ISD::FMUL,               MVT::v4f64, Legal);
 970     setOperationAction(ISD::FDIV,               MVT::v4f64, Legal);
 971     setOperationAction(ISD::FSQRT,              MVT::v4f64, Legal);
 972     setOperationAction(ISD::FNEG,               MVT::v4f64, Custom);
 973
 974     setOperationAction(ISD::FP_TO_SINT,         MVT::v8i32, Legal);
 975     setOperationAction(ISD::SINT_TO_FP,         MVT::v8i32, Legal);
 976     setOperationAction(ISD::FP_ROUND,           MVT::v4f32, Legal);
 977
 978     setOperationAction(ISD::CONCAT_VECTORS,     MVT::v4f64,  Custom);
 979     setOperationAction(ISD::CONCAT_VECTORS,     MVT::v4i64,  Custom);
 980     setOperationAction(ISD::CONCAT_VECTORS,     MVT::v8f32,  Custom);
 981     setOperationAction(ISD::CONCAT_VECTORS,     MVT::v8i32,  Custom);
 982     setOperationAction(ISD::CONCAT_VECTORS,     MVT::v32i8,  Custom);
 983     setOperationAction(ISD::CONCAT_VECTORS,     MVT::v16i16, Custom);
 984
 985     setOperationAction(ISD::SRL,               MVT::v4i64, Custom);
 986     setOperationAction(ISD::SRL,               MVT::v8i32, Custom);
 987     setOperationAction(ISD::SRL,               MVT::v16i16, Custom);
 988     setOperationAction(ISD::SRL,               MVT::v32i8, Custom);
 989
 990     setOperationAction(ISD::SHL,               MVT::v4i64, Custom);
 991     setOperationAction(ISD::SHL,               MVT::v8i32, Custom);
 992     setOperationAction(ISD::SHL,               MVT::v16i16, Custom);
 993     setOperationAction(ISD::SHL,               MVT::v32i8, Custom);
 994
 995     setOperationAction(ISD::SRA,               MVT::v8i32, Custom);
 996     setOperationAction(ISD::SRA,               MVT::v16i16, Custom);
 997
 998     setOperationAction(ISD::VSETCC,            MVT::v32i8, Custom);
 999     setOperationAction(ISD::VSETCC,            MVT::v16i16, Custom);
1000     setOperationAction(ISD::VSETCC,            MVT::v8i32, Custom);
1001     setOperationAction(ISD::VSETCC,            MVT::v4i64, Custom);
1002
1003     setOperationAction(ISD::SELECT,            MVT::v4f64, Custom);
1004     setOperationAction(ISD::SELECT,            MVT::v4i64, Custom);
1005     setOperationAction(ISD::SELECT,            MVT::v8f32, Custom);
1006
1007     setOperationAction(ISD::ADD,               MVT::v4i64, Custom);
1008     setOperationAction(ISD::ADD,               MVT::v8i32, Custom);
1009     setOperationAction(ISD::ADD,               MVT::v16i16, Custom);
1010     setOperationAction(ISD::ADD,               MVT::v32i8, Custom);
1011
1012     setOperationAction(ISD::SUB,               MVT::v4i64, Custom);
1013     setOperationAction(ISD::SUB,               MVT::v8i32, Custom);
1014     setOperationAction(ISD::SUB,               MVT::v16i16, Custom);
1015     setOperationAction(ISD::SUB,               MVT::v32i8, Custom);
1016
1017     setOperationAction(ISD::MUL,               MVT::v4i64, Custom);
1018     setOperationAction(ISD::MUL,               MVT::v8i32, Custom);
1019     setOperationAction(ISD::MUL,               MVT::v16i16, Custom);
1020     // Don't lower v32i8 because there is no 128-bit byte mul
1021
1022     // Custom lower several nodes for 256-bit types.
1023     for (unsigned i = (unsigned)MVT::FIRST_VECTOR_VALUETYPE;
1024                   i <= (unsigned)MVT::LAST_VECTOR_VALUETYPE; ++i) {
1025       MVT::SimpleValueType SVT = (MVT::SimpleValueType)i;
1026       EVT VT = SVT;
1027
1028       // Extract subvector is special because the value type
1029       // (result) is 128-bit but the source is 256-bit wide.
1030       if (VT.is128BitVector())
1031         setOperationAction(ISD::EXTRACT_SUBVECTOR, SVT, Custom);
1032
1033       // Do not attempt to custom lower other non-256-bit vectors
1034       if (!VT.is256BitVector())
1035         continue;
1036
1037       setOperationAction(ISD::BUILD_VECTOR,       SVT, Custom);
1038       setOperationAction(ISD::VECTOR_SHUFFLE,     SVT, Custom);
1039       setOperationAction(ISD::INSERT_VECTOR_ELT,  SVT, Custom);
1040       setOperationAction(ISD::EXTRACT_VECTOR_ELT, SVT, Custom);
1041       setOperationAction(ISD::SCALAR_TO_VECTOR,   SVT, Custom);
1042       setOperationAction(ISD::INSERT_SUBVECTOR,   SVT, Custom);
1043     }
1044
1045     // Promote v32i8, v16i16, v8i32 select, and, or, xor to v4i64.
1046     for (unsigned i = (unsigned)MVT::v32i8; i != (unsigned)MVT::v4i64; ++i) {
1047       MVT::SimpleValueType SVT = (MVT::SimpleValueType)i;
1048       EVT VT = SVT;
1049
1050       // Do not attempt to promote non-256-bit vectors
1051       if (!VT.is256BitVector())
1052         continue;
1053
1054       setOperationAction(ISD::AND,    SVT, Promote);
1055       AddPromotedToType (ISD::AND,    SVT, MVT::v4i64);
1056       setOperationAction(ISD::OR,     SVT, Promote);
1057       AddPromotedToType (ISD::OR,     SVT, MVT::v4i64);
1058       setOperationAction(ISD::XOR,    SVT, Promote);
1059       AddPromotedToType (ISD::XOR,    SVT, MVT::v4i64);
1060       setOperationAction(ISD::LOAD,   SVT, Promote);
1061       AddPromotedToType (ISD::LOAD,   SVT, MVT::v4i64);
1062       setOperationAction(ISD::SELECT, SVT, Promote);
1063       AddPromotedToType (ISD::SELECT, SVT, MVT::v4i64);
1064     }
1065   }
1066
1067   // SIGN_EXTEND_INREGs are evaluated by the extend type. Handle the expansion
1068   // of this type with custom code.
1069   for (unsigned VT = (unsigned)MVT::FIRST_VECTOR_VALUETYPE;
1070          VT != (unsigned)MVT::LAST_VECTOR_VALUETYPE; VT++) {
1071     setOperationAction(ISD::SIGN_EXTEND_INREG, (MVT::SimpleValueType)VT, Custom);
1072   }
1073
1074   // We want to custom lower some of our intrinsics.
1075   setOperationAction(ISD::INTRINSIC_WO_CHAIN, MVT::Other, Custom);
1076
1077
1078   // Only custom-lower 64-bit SADDO and friends on 64-bit because we don't
1079   // handle type legalization for these operations here.
1080   //
1081   // FIXME: We really should do custom legalization for addition and
1082   // subtraction on x86-32 once PR3203 is fixed.  We really can't do much better
1083   // than generic legalization for 64-bit multiplication-with-overflow, though.
1084   for (unsigned i = 0, e = 3+Subtarget->is64Bit(); i != e; ++i) {
1085     // Add/Sub/Mul with overflow operations are custom lowered.
1086     MVT VT = IntVTs[i];
1087     setOperationAction(ISD::SADDO, VT, Custom);
1088     setOperationAction(ISD::UADDO, VT, Custom);
1089     setOperationAction(ISD::SSUBO, VT, Custom);
1090     setOperationAction(ISD::USUBO, VT, Custom);
1091     setOperationAction(ISD::SMULO, VT, Custom);
1092     setOperationAction(ISD::UMULO, VT, Custom);
1093   }
1094
1095   // There are no 8-bit 3-address imul/mul instructions
1096   setOperationAction(ISD::SMULO, MVT::i8, Expand);
1097   setOperationAction(ISD::UMULO, MVT::i8, Expand);
1098
1099   if (!Subtarget->is64Bit()) {
1100     // These libcalls are not available in 32-bit.
1101     setLibcallName(RTLIB::SHL_I128, 0);
1102     setLibcallName(RTLIB::SRL_I128, 0);
1103     setLibcallName(RTLIB::SRA_I128, 0);
1104   }
1105
1106   // We have target-specific dag combine patterns for the following nodes:
1107   setTargetDAGCombine(ISD::VECTOR_SHUFFLE);
1108   setTargetDAGCombine(ISD::EXTRACT_VECTOR_ELT);
1109   setTargetDAGCombine(ISD::BUILD_VECTOR);
1110   setTargetDAGCombine(ISD::SELECT);
1111   setTargetDAGCombine(ISD::SHL);
1112   setTargetDAGCombine(ISD::SRA);
1113   setTargetDAGCombine(ISD::SRL);
1114   setTargetDAGCombine(ISD::OR);
1115   setTargetDAGCombine(ISD::AND);
1116   setTargetDAGCombine(ISD::ADD);
1117   setTargetDAGCombine(ISD::SUB);
1118   setTargetDAGCombine(ISD::STORE);
1119   setTargetDAGCombine(ISD::ZERO_EXTEND);
1120   setTargetDAGCombine(ISD::SINT_TO_FP);
1121   if (Subtarget->is64Bit())
1122     setTargetDAGCombine(ISD::MUL);
1123
1124   computeRegisterProperties();
1125
1126   // On Darwin, -Os means optimize for size without hurting performance,
1127   // do not reduce the limit.
1128   maxStoresPerMemset = 16; // For @llvm.memset -> sequence of stores
1129   maxStoresPerMemsetOptSize = Subtarget->isTargetDarwin() ? 16 : 8;
1130   maxStoresPerMemcpy = 8; // For @llvm.memcpy -> sequence of stores
1131   maxStoresPerMemcpyOptSize = Subtarget->isTargetDarwin() ? 8 : 4;
1132   maxStoresPerMemmove = 8; // For @llvm.memmove -> sequence of stores
1133   maxStoresPerMemmoveOptSize = Subtarget->isTargetDarwin() ? 8 : 4;
1134   setPrefLoopAlignment(16);
1135   benefitFromCodePlacementOpt = true;
1136
1137   setPrefFunctionAlignment(4);
1138 }
1139
1140
1141 MVT::SimpleValueType X86TargetLowering::getSetCCResultType(EVT VT) const {
1142   return MVT::i8;
1143 }
1144
1145
1146 /// getMaxByValAlign - Helper for getByValTypeAlignment to determine
1147 /// the desired ByVal argument alignment.
1148 static void getMaxByValAlign(Type *Ty, unsigned &MaxAlign) {
1149   if (MaxAlign == 16)
1150     return;
1151   if (VectorType *VTy = dyn_cast<VectorType>(Ty)) {
1152     if (VTy->getBitWidth() == 128)
1153       MaxAlign = 16;
1154   } else if (ArrayType *ATy = dyn_cast<ArrayType>(Ty)) {
1155     unsigned EltAlign = 0;
1156     getMaxByValAlign(ATy->getElementType(), EltAlign);
1157     if (EltAlign > MaxAlign)
1158       MaxAlign = EltAlign;
1159   } else if (StructType *STy = dyn_cast<StructType>(Ty)) {
1160     for (unsigned i = 0, e = STy->getNumElements(); i != e; ++i) {
1161       unsigned EltAlign = 0;
1162       getMaxByValAlign(STy->getElementType(i), EltAlign);
1163       if (EltAlign > MaxAlign)
1164         MaxAlign = EltAlign;
1165       if (MaxAlign == 16)
1166         break;
1167     }
1168   }
1169   return;
1170 }
1171
1172 /// getByValTypeAlignment - Return the desired alignment for ByVal aggregate
1173 /// function arguments in the caller parameter area. For X86, aggregates
1174 /// that contain SSE vectors are placed at 16-byte boundaries while the rest
1175 /// are at 4-byte boundaries.
1176 unsigned X86TargetLowering::getByValTypeAlignment(Type *Ty) const {
1177   if (Subtarget->is64Bit()) {
1178     // Max of 8 and alignment of type.
1179     unsigned TyAlign = TD->getABITypeAlignment(Ty);
1180     if (TyAlign > 8)
1181       return TyAlign;
1182     return 8;
1183   }
1184
1185   unsigned Align = 4;
1186   if (Subtarget->hasXMM())
1187     getMaxByValAlign(Ty, Align);
1188   return Align;
1189 }
1190
1191 /// getOptimalMemOpType - Returns the target specific optimal type for load
1192 /// and store operations as a result of memset, memcpy, and memmove
1193 /// lowering. If DstAlign is zero that means it's safe to destination
1194 /// alignment can satisfy any constraint. Similarly if SrcAlign is zero it
1195 /// means there isn't a need to check it against alignment requirement,
1196 /// probably because the source does not need to be loaded. If
1197 /// 'NonScalarIntSafe' is true, that means it's safe to return a
1198 /// non-scalar-integer type, e.g. empty string source, constant, or loaded
1199 /// from memory. 'MemcpyStrSrc' indicates whether the memcpy source is
1200 /// constant so it does not need to be loaded.
1201 /// It returns EVT::Other if the type should be determined using generic
1202 /// target-independent logic.
1203 EVT
1204 X86TargetLowering::getOptimalMemOpType(uint64_t Size,
1205                                        unsigned DstAlign, unsigned SrcAlign,
1206                                        bool NonScalarIntSafe,
1207                                        bool MemcpyStrSrc,
1208                                        MachineFunction &MF) const {
1209   // FIXME: This turns off use of xmm stores for memset/memcpy on targets like
1210   // linux.  This is because the stack realignment code can't handle certain
1211   // cases like PR2962.  This should be removed when PR2962 is fixed.
1212   const Function *F = MF.getFunction();
1213   if (NonScalarIntSafe &&
1214       !F->hasFnAttr(Attribute::NoImplicitFloat)) {
1215     if (Size >= 16 &&
1216         (Subtarget->isUnalignedMemAccessFast() ||
1217          ((DstAlign == 0 || DstAlign >= 16) &&
1218           (SrcAlign == 0 || SrcAlign >= 16))) &&
1219         Subtarget->getStackAlignment() >= 16) {
1220       if (Subtarget->hasSSE2())
1221         return MVT::v4i32;
1222       if (Subtarget->hasSSE1())
1223         return MVT::v4f32;
1224     } else if (!MemcpyStrSrc && Size >= 8 &&
1225                !Subtarget->is64Bit() &&
1226                Subtarget->getStackAlignment() >= 8 &&
1227                Subtarget->hasXMMInt()) {
1228       // Do not use f64 to lower memcpy if source is string constant. It's
1229       // better to use i32 to avoid the loads.
1230       return MVT::f64;
1231     }
1232   }
1233   if (Subtarget->is64Bit() && Size >= 8)
1234     return MVT::i64;
1235   return MVT::i32;
1236 }
1237
1238 /// getJumpTableEncoding - Return the entry encoding for a jump table in the
1239 /// current function.  The returned value is a member of the
1240 /// MachineJumpTableInfo::JTEntryKind enum.
1241 unsigned X86TargetLowering::getJumpTableEncoding() const {
1242   // In GOT pic mode, each entry in the jump table is emitted as a @GOTOFF
1243   // symbol.
1244   if (getTargetMachine().getRelocationModel() == Reloc::PIC_ &&
1245       Subtarget->isPICStyleGOT())
1246     return MachineJumpTableInfo::EK_Custom32;
1247
1248   // Otherwise, use the normal jump table encoding heuristics.
1249   return TargetLowering::getJumpTableEncoding();
1250 }
1251
1252 const MCExpr *
1253 X86TargetLowering::LowerCustomJumpTableEntry(const MachineJumpTableInfo *MJTI,
1254                                              const MachineBasicBlock *MBB,
1255                                              unsigned uid,MCContext &Ctx) const{
1256   assert(getTargetMachine().getRelocationModel() == Reloc::PIC_ &&
1257          Subtarget->isPICStyleGOT());
1258   // In 32-bit ELF systems, our jump table entries are formed with @GOTOFF
1259   // entries.
1260   return MCSymbolRefExpr::Create(MBB->getSymbol(),
1261                                  MCSymbolRefExpr::VK_GOTOFF, Ctx);
1262 }
1263
1264 /// getPICJumpTableRelocaBase - Returns relocation base for the given PIC
1265 /// jumptable.
1266 SDValue X86TargetLowering::getPICJumpTableRelocBase(SDValue Table,
1267                                                     SelectionDAG &DAG) const {
1268   if (!Subtarget->is64Bit())
1269     // This doesn't have DebugLoc associated with it, but is not really the
1270     // same as a Register.
1271     return DAG.getNode(X86ISD::GlobalBaseReg, DebugLoc(), getPointerTy());
1272   return Table;
1273 }
1274
1275 /// getPICJumpTableRelocBaseExpr - This returns the relocation base for the
1276 /// given PIC jumptable, the same as getPICJumpTableRelocBase, but as an
1277 /// MCExpr.
1278 const MCExpr *X86TargetLowering::
1279 getPICJumpTableRelocBaseExpr(const MachineFunction *MF, unsigned JTI,
1280                              MCContext &Ctx) const {
1281   // X86-64 uses RIP relative addressing based on the jump table label.
1282   if (Subtarget->isPICStyleRIPRel())
1283     return TargetLowering::getPICJumpTableRelocBaseExpr(MF, JTI, Ctx);
1284
1285   // Otherwise, the reference is relative to the PIC base.
1286   return MCSymbolRefExpr::Create(MF->getPICBaseSymbol(), Ctx);
1287 }
1288
1289 // FIXME: Why this routine is here? Move to RegInfo!
1290 std::pair<const TargetRegisterClass*, uint8_t>
1291 X86TargetLowering::findRepresentativeClass(EVT VT) const{
1292   const TargetRegisterClass *RRC = 0;
1293   uint8_t Cost = 1;
1294   switch (VT.getSimpleVT().SimpleTy) {
1295   default:
1296     return TargetLowering::findRepresentativeClass(VT);
1297   case MVT::i8: case MVT::i16: case MVT::i32: case MVT::i64:
1298     RRC = (Subtarget->is64Bit()
1299            ? X86::GR64RegisterClass : X86::GR32RegisterClass);
1300     break;
1301   case MVT::x86mmx:
1302     RRC = X86::VR64RegisterClass;
1303     break;
1304   case MVT::f32: case MVT::f64:
1305   case MVT::v16i8: case MVT::v8i16: case MVT::v4i32: case MVT::v2i64:
1306   case MVT::v4f32: case MVT::v2f64:
1307   case MVT::v32i8: case MVT::v8i32: case MVT::v4i64: case MVT::v8f32:
1308   case MVT::v4f64:
1309     RRC = X86::VR128RegisterClass;
1310     break;
1311   }
1312   return std::make_pair(RRC, Cost);
1313 }
1314
1315 bool X86TargetLowering::getStackCookieLocation(unsigned &AddressSpace,
1316                                                unsigned &Offset) const {
1317   if (!Subtarget->isTargetLinux())
1318     return false;
1319
1320   if (Subtarget->is64Bit()) {
1321     // %fs:0x28, unless we're using a Kernel code model, in which case it's %gs:
1322     Offset = 0x28;
1323     if (getTargetMachine().getCodeModel() == CodeModel::Kernel)
1324       AddressSpace = 256;
1325     else
1326       AddressSpace = 257;
1327   } else {
1328     // %gs:0x14 on i386
1329     Offset = 0x14;
1330     AddressSpace = 256;
1331   }
1332   return true;
1333 }
1334
1335
1336 //===----------------------------------------------------------------------===//
1337 //               Return Value Calling Convention Implementation
1338 //===----------------------------------------------------------------------===//
1339
1340 #include "X86GenCallingConv.inc"
1341
1342 bool
1343 X86TargetLowering::CanLowerReturn(CallingConv::ID CallConv,
1344                                   MachineFunction &MF, bool isVarArg,
1345                         const SmallVectorImpl<ISD::OutputArg> &Outs,
1346                         LLVMContext &Context) const {
1347   SmallVector<CCValAssign, 16> RVLocs;
1348   CCState CCInfo(CallConv, isVarArg, MF, getTargetMachine(),
1349                  RVLocs, Context);
1350   return CCInfo.CheckReturn(Outs, RetCC_X86);
1351 }
1352
1353 SDValue
1354 X86TargetLowering::LowerReturn(SDValue Chain,
1355                                CallingConv::ID CallConv, bool isVarArg,
1356                                const SmallVectorImpl<ISD::OutputArg> &Outs,
1357                                const SmallVectorImpl<SDValue> &OutVals,
1358                                DebugLoc dl, SelectionDAG &DAG) const {
1359   MachineFunction &MF = DAG.getMachineFunction();
1360   X86MachineFunctionInfo *FuncInfo = MF.getInfo<X86MachineFunctionInfo>();
1361
1362   SmallVector<CCValAssign, 16> RVLocs;
1363   CCState CCInfo(CallConv, isVarArg, MF, getTargetMachine(),
1364                  RVLocs, *DAG.getContext());
1365   CCInfo.AnalyzeReturn(Outs, RetCC_X86);
1366
1367   // Add the regs to the liveout set for the function.
1368   MachineRegisterInfo &MRI = DAG.getMachineFunction().getRegInfo();
1369   for (unsigned i = 0; i != RVLocs.size(); ++i)
1370     if (RVLocs[i].isRegLoc() && !MRI.isLiveOut(RVLocs[i].getLocReg()))
1371       MRI.addLiveOut(RVLocs[i].getLocReg());
1372
1373   SDValue Flag;
1374
1375   SmallVector<SDValue, 6> RetOps;
1376   RetOps.push_back(Chain); // Operand #0 = Chain (updated below)
1377   // Operand #1 = Bytes To Pop
1378   RetOps.push_back(DAG.getTargetConstant(FuncInfo->getBytesToPopOnReturn(),
1379                    MVT::i16));
1380
1381   // Copy the result values into the output registers.
1382   for (unsigned i = 0; i != RVLocs.size(); ++i) {
1383     CCValAssign &VA = RVLocs[i];
1384     assert(VA.isRegLoc() && "Can only return in registers!");
1385     SDValue ValToCopy = OutVals[i];
1386     EVT ValVT = ValToCopy.getValueType();
1387
1388     // If this is x86-64, and we disabled SSE, we can't return FP values,
1389     // or SSE or MMX vectors.
1390     if ((ValVT == MVT::f32 || ValVT == MVT::f64 ||
1391          VA.getLocReg() == X86::XMM0 || VA.getLocReg() == X86::XMM1) &&
1392           (Subtarget->is64Bit() && !Subtarget->hasXMM())) {
1393       report_fatal_error("SSE register return with SSE disabled");
1394     }
1395     // Likewise we can't return F64 values with SSE1 only.  gcc does so, but
1396     // llvm-gcc has never done it right and no one has noticed, so this
1397     // should be OK for now.
1398     if (ValVT == MVT::f64 &&
1399         (Subtarget->is64Bit() && !Subtarget->hasXMMInt()))
1400       report_fatal_error("SSE2 register return with SSE2 disabled");
1401
1402     // Returns in ST0/ST1 are handled specially: these are pushed as operands to
1403     // the RET instruction and handled by the FP Stackifier.
1404     if (VA.getLocReg() == X86::ST0 ||
1405         VA.getLocReg() == X86::ST1) {
1406       // If this is a copy from an xmm register to ST(0), use an FPExtend to
1407       // change the value to the FP stack register class.
1408       if (isScalarFPTypeInSSEReg(VA.getValVT()))
1409         ValToCopy = DAG.getNode(ISD::FP_EXTEND, dl, MVT::f80, ValToCopy);
1410       RetOps.push_back(ValToCopy);
1411       // Don't emit a copytoreg.
1412       continue;
1413     }
1414
1415     // 64-bit vector (MMX) values are returned in XMM0 / XMM1 except for v1i64
1416     // which is returned in RAX / RDX.
1417     if (Subtarget->is64Bit()) {
1418       if (ValVT == MVT::x86mmx) {
1419         if (VA.getLocReg() == X86::XMM0 || VA.getLocReg() == X86::XMM1) {
1420           ValToCopy = DAG.getNode(ISD::BITCAST, dl, MVT::i64, ValToCopy);
1421           ValToCopy = DAG.getNode(ISD::SCALAR_TO_VECTOR, dl, MVT::v2i64,
1422                                   ValToCopy);
1423           // If we don't have SSE2 available, convert to v4f32 so the generated
1424           // register is legal.
1425           if (!Subtarget->hasSSE2())
1426             ValToCopy = DAG.getNode(ISD::BITCAST, dl, MVT::v4f32,ValToCopy);
1427         }
1428       }
1429     }
1430
1431     Chain = DAG.getCopyToReg(Chain, dl, VA.getLocReg(), ValToCopy, Flag);
1432     Flag = Chain.getValue(1);
1433   }
1434
1435   // The x86-64 ABI for returning structs by value requires that we copy
1436   // the sret argument into %rax for the return. We saved the argument into
1437   // a virtual register in the entry block, so now we copy the value out
1438   // and into %rax.
1439   if (Subtarget->is64Bit() &&
1440       DAG.getMachineFunction().getFunction()->hasStructRetAttr()) {
1441     MachineFunction &MF = DAG.getMachineFunction();
1442     X86MachineFunctionInfo *FuncInfo = MF.getInfo<X86MachineFunctionInfo>();
1443     unsigned Reg = FuncInfo->getSRetReturnReg();
1444     assert(Reg &&
1445            "SRetReturnReg should have been set in LowerFormalArguments().");
1446     SDValue Val = DAG.getCopyFromReg(Chain, dl, Reg, getPointerTy());
1447
1448     Chain = DAG.getCopyToReg(Chain, dl, X86::RAX, Val, Flag);
1449     Flag = Chain.getValue(1);
1450
1451     // RAX now acts like a return value.
1452     MRI.addLiveOut(X86::RAX);
1453   }
1454
1455   RetOps[0] = Chain;  // Update chain.
1456
1457   // Add the flag if we have it.
1458   if (Flag.getNode())
1459     RetOps.push_back(Flag);
1460
1461   return DAG.getNode(X86ISD::RET_FLAG, dl,
1462                      MVT::Other, &RetOps[0], RetOps.size());
1463 }
1464
1465 bool X86TargetLowering::isUsedByReturnOnly(SDNode *N) const {
1466   if (N->getNumValues() != 1)
1467     return false;
1468   if (!N->hasNUsesOfValue(1, 0))
1469     return false;
1470
1471   SDNode *Copy = *N->use_begin();
1472   if (Copy->getOpcode() != ISD::CopyToReg &&
1473       Copy->getOpcode() != ISD::FP_EXTEND)
1474     return false;
1475
1476   bool HasRet = false;
1477   for (SDNode::use_iterator UI = Copy->use_begin(), UE = Copy->use_end();
1478        UI != UE; ++UI) {
1479     if (UI->getOpcode() != X86ISD::RET_FLAG)
1480       return false;
1481     HasRet = true;
1482   }
1483
1484   return HasRet;
1485 }
1486
1487 EVT
1488 X86TargetLowering::getTypeForExtArgOrReturn(LLVMContext &Context, EVT VT,
1489                                             ISD::NodeType ExtendKind) const {
1490   MVT ReturnMVT;
1491   // TODO: Is this also valid on 32-bit?
1492   if (Subtarget->is64Bit() && VT == MVT::i1 && ExtendKind == ISD::ZERO_EXTEND)
1493     ReturnMVT = MVT::i8;
1494   else
1495     ReturnMVT = MVT::i32;
1496
1497   EVT MinVT = getRegisterType(Context, ReturnMVT);
1498   return VT.bitsLT(MinVT) ? MinVT : VT;
1499 }
1500
1501 /// LowerCallResult - Lower the result values of a call into the
1502 /// appropriate copies out of appropriate physical registers.
1503 ///
1504 SDValue
1505 X86TargetLowering::LowerCallResult(SDValue Chain, SDValue InFlag,
1506                                    CallingConv::ID CallConv, bool isVarArg,
1507                                    const SmallVectorImpl<ISD::InputArg> &Ins,
1508                                    DebugLoc dl, SelectionDAG &DAG,
1509                                    SmallVectorImpl<SDValue> &InVals) const {
1510
1511   // Assign locations to each value returned by this call.
1512   SmallVector<CCValAssign, 16> RVLocs;
1513   bool Is64Bit = Subtarget->is64Bit();
1514   CCState CCInfo(CallConv, isVarArg, DAG.getMachineFunction(),
1515                  getTargetMachine(), RVLocs, *DAG.getContext());
1516   CCInfo.AnalyzeCallResult(Ins, RetCC_X86);
1517
1518   // Copy all of the result registers out of their specified physreg.
1519   for (unsigned i = 0; i != RVLocs.size(); ++i) {
1520     CCValAssign &VA = RVLocs[i];
1521     EVT CopyVT = VA.getValVT();
1522
1523     // If this is x86-64, and we disabled SSE, we can't return FP values
1524     if ((CopyVT == MVT::f32 || CopyVT == MVT::f64) &&
1525         ((Is64Bit || Ins[i].Flags.isInReg()) && !Subtarget->hasXMM())) {
1526       report_fatal_error("SSE register return with SSE disabled");
1527     }
1528
1529     SDValue Val;
1530
1531     // If this is a call to a function that returns an fp value on the floating
1532     // point stack, we must guarantee the the value is popped from the stack, so
1533     // a CopyFromReg is not good enough - the copy instruction may be eliminated
1534     // if the return value is not used. We use the FpPOP_RETVAL instruction
1535     // instead.
1536     if (VA.getLocReg() == X86::ST0 || VA.getLocReg() == X86::ST1) {
1537       // If we prefer to use the value in xmm registers, copy it out as f80 and
1538       // use a truncate to move it from fp stack reg to xmm reg.
1539       if (isScalarFPTypeInSSEReg(VA.getValVT())) CopyVT = MVT::f80;
1540       SDValue Ops[] = { Chain, InFlag };
1541       Chain = SDValue(DAG.getMachineNode(X86::FpPOP_RETVAL, dl, CopyVT,
1542                                          MVT::Other, MVT::Glue, Ops, 2), 1);
1543       Val = Chain.getValue(0);
1544
1545       // Round the f80 to the right size, which also moves it to the appropriate
1546       // xmm register.
1547       if (CopyVT != VA.getValVT())
1548         Val = DAG.getNode(ISD::FP_ROUND, dl, VA.getValVT(), Val,
1549                           // This truncation won't change the value.
1550                           DAG.getIntPtrConstant(1));
1551     } else {
1552       Chain = DAG.getCopyFromReg(Chain, dl, VA.getLocReg(),
1553                                  CopyVT, InFlag).getValue(1);
1554       Val = Chain.getValue(0);
1555     }
1556     InFlag = Chain.getValue(2);
1557     InVals.push_back(Val);
1558   }
1559
1560   return Chain;
1561 }
1562
1563
1564 //===----------------------------------------------------------------------===//
1565 //                C & StdCall & Fast Calling Convention implementation
1566 //===----------------------------------------------------------------------===//
1567 //  StdCall calling convention seems to be standard for many Windows' API
1568 //  routines and around. It differs from C calling convention just a little:
1569 //  callee should clean up the stack, not caller. Symbols should be also
1570 //  decorated in some fancy way :) It doesn't support any vector arguments.
1571 //  For info on fast calling convention see Fast Calling Convention (tail call)
1572 //  implementation LowerX86_32FastCCCallTo.
1573
1574 /// CallIsStructReturn - Determines whether a call uses struct return
1575 /// semantics.
1576 static bool CallIsStructReturn(const SmallVectorImpl<ISD::OutputArg> &Outs) {
1577   if (Outs.empty())
1578     return false;
1579
1580   return Outs[0].Flags.isSRet();
1581 }
1582
1583 /// ArgsAreStructReturn - Determines whether a function uses struct
1584 /// return semantics.
1585 static bool
1586 ArgsAreStructReturn(const SmallVectorImpl<ISD::InputArg> &Ins) {
1587   if (Ins.empty())
1588     return false;
1589
1590   return Ins[0].Flags.isSRet();
1591 }
1592
1593 /// CreateCopyOfByValArgument - Make a copy of an aggregate at address specified
1594 /// by "Src" to address "Dst" with size and alignment information specified by
1595 /// the specific parameter attribute. The copy will be passed as a byval
1596 /// function parameter.
1597 static SDValue
1598 CreateCopyOfByValArgument(SDValue Src, SDValue Dst, SDValue Chain,
1599                           ISD::ArgFlagsTy Flags, SelectionDAG &DAG,
1600                           DebugLoc dl) {
1601   SDValue SizeNode = DAG.getConstant(Flags.getByValSize(), MVT::i32);
1602
1603   return DAG.getMemcpy(Chain, dl, Dst, Src, SizeNode, Flags.getByValAlign(),
1604                        /*isVolatile*/false, /*AlwaysInline=*/true,
1605                        MachinePointerInfo(), MachinePointerInfo());
1606 }
1607
1608 /// IsTailCallConvention - Return true if the calling convention is one that
1609 /// supports tail call optimization.
1610 static bool IsTailCallConvention(CallingConv::ID CC) {
1611   return (CC == CallingConv::Fast || CC == CallingConv::GHC);
1612 }
1613
1614 bool X86TargetLowering::mayBeEmittedAsTailCall(CallInst *CI) const {
1615   if (!CI->isTailCall())
1616     return false;
1617
1618   CallSite CS(CI);
1619   CallingConv::ID CalleeCC = CS.getCallingConv();
1620   if (!IsTailCallConvention(CalleeCC) && CalleeCC != CallingConv::C)
1621     return false;
1622
1623   return true;
1624 }
1625
1626 /// FuncIsMadeTailCallSafe - Return true if the function is being made into
1627 /// a tailcall target by changing its ABI.
1628 static bool FuncIsMadeTailCallSafe(CallingConv::ID CC) {
1629   return GuaranteedTailCallOpt && IsTailCallConvention(CC);
1630 }
1631
1632 SDValue
1633 X86TargetLowering::LowerMemArgument(SDValue Chain,
1634                                     CallingConv::ID CallConv,
1635                                     const SmallVectorImpl<ISD::InputArg> &Ins,
1636                                     DebugLoc dl, SelectionDAG &DAG,
1637                                     const CCValAssign &VA,
1638                                     MachineFrameInfo *MFI,
1639                                     unsigned i) const {
1640   // Create the nodes corresponding to a load from this parameter slot.
1641   ISD::ArgFlagsTy Flags = Ins[i].Flags;
1642   bool AlwaysUseMutable = FuncIsMadeTailCallSafe(CallConv);
1643   bool isImmutable = !AlwaysUseMutable && !Flags.isByVal();
1644   EVT ValVT;
1645
1646   // If value is passed by pointer we have address passed instead of the value
1647   // itself.
1648   if (VA.getLocInfo() == CCValAssign::Indirect)
1649     ValVT = VA.getLocVT();
1650   else
1651     ValVT = VA.getValVT();
1652
1653   // FIXME: For now, all byval parameter objects are marked mutable. This can be
1654   // changed with more analysis.
1655   // In case of tail call optimization mark all arguments mutable. Since they
1656   // could be overwritten by lowering of arguments in case of a tail call.
1657   if (Flags.isByVal()) {
1658     unsigned Bytes = Flags.getByValSize();
1659     if (Bytes == 0) Bytes = 1; // Don't create zero-sized stack objects.
1660     int FI = MFI->CreateFixedObject(Bytes, VA.getLocMemOffset(), isImmutable);
1661     return DAG.getFrameIndex(FI, getPointerTy());
1662   } else {
1663     int FI = MFI->CreateFixedObject(ValVT.getSizeInBits()/8,
1664                                     VA.getLocMemOffset(), isImmutable);
1665     SDValue FIN = DAG.getFrameIndex(FI, getPointerTy());
1666     return DAG.getLoad(ValVT, dl, Chain, FIN,
1667                        MachinePointerInfo::getFixedStack(FI),
1668                        false, false, 0);
1669   }
1670 }
1671
1672 SDValue
1673 X86TargetLowering::LowerFormalArguments(SDValue Chain,
1674                                         CallingConv::ID CallConv,
1675                                         bool isVarArg,
1676                                       const SmallVectorImpl<ISD::InputArg> &Ins,
1677                                         DebugLoc dl,
1678                                         SelectionDAG &DAG,
1679                                         SmallVectorImpl<SDValue> &InVals)
1680                                           const {
1681   MachineFunction &MF = DAG.getMachineFunction();
1682   X86MachineFunctionInfo *FuncInfo = MF.getInfo<X86MachineFunctionInfo>();
1683
1684   const Function* Fn = MF.getFunction();
1685   if (Fn->hasExternalLinkage() &&
1686       Subtarget->isTargetCygMing() &&
1687       Fn->getName() == "main")
1688     FuncInfo->setForceFramePointer(true);
1689
1690   MachineFrameInfo *MFI = MF.getFrameInfo();
1691   bool Is64Bit = Subtarget->is64Bit();
1692   bool IsWin64 = Subtarget->isTargetWin64();
1693
1694   assert(!(isVarArg && IsTailCallConvention(CallConv)) &&
1695          "Var args not supported with calling convention fastcc or ghc");
1696
1697   // Assign locations to all of the incoming arguments.
1698   SmallVector<CCValAssign, 16> ArgLocs;
1699   CCState CCInfo(CallConv, isVarArg, MF, getTargetMachine(),
1700                  ArgLocs, *DAG.getContext());
1701
1702   // Allocate shadow area for Win64
1703   if (IsWin64) {
1704     CCInfo.AllocateStack(32, 8);
1705   }
1706
1707   CCInfo.AnalyzeFormalArguments(Ins, CC_X86);
1708
1709   unsigned LastVal = ~0U;
1710   SDValue ArgValue;
1711   for (unsigned i = 0, e = ArgLocs.size(); i != e; ++i) {
1712     CCValAssign &VA = ArgLocs[i];
1713     // TODO: If an arg is passed in two places (e.g. reg and stack), skip later
1714     // places.
1715     assert(VA.getValNo() != LastVal &&
1716            "Don't support value assigned to multiple locs yet");
1717     LastVal = VA.getValNo();
1718
1719     if (VA.isRegLoc()) {
1720       EVT RegVT = VA.getLocVT();
1721       TargetRegisterClass *RC = NULL;
1722       if (RegVT == MVT::i32)
1723         RC = X86::GR32RegisterClass;
1724       else if (Is64Bit && RegVT == MVT::i64)
1725         RC = X86::GR64RegisterClass;
1726       else if (RegVT == MVT::f32)
1727         RC = X86::FR32RegisterClass;
1728       else if (RegVT == MVT::f64)
1729         RC = X86::FR64RegisterClass;
1730       else if (RegVT.isVector() && RegVT.getSizeInBits() == 256)
1731         RC = X86::VR256RegisterClass;
1732       else if (RegVT.isVector() && RegVT.getSizeInBits() == 128)
1733         RC = X86::VR128RegisterClass;
1734       else if (RegVT == MVT::x86mmx)
1735         RC = X86::VR64RegisterClass;
1736       else
1737         llvm_unreachable("Unknown argument type!");
1738
1739       unsigned Reg = MF.addLiveIn(VA.getLocReg(), RC);
1740       ArgValue = DAG.getCopyFromReg(Chain, dl, Reg, RegVT);
1741
1742       // If this is an 8 or 16-bit value, it is really passed promoted to 32
1743       // bits.  Insert an assert[sz]ext to capture this, then truncate to the
1744       // right size.
1745       if (VA.getLocInfo() == CCValAssign::SExt)
1746         ArgValue = DAG.getNode(ISD::AssertSext, dl, RegVT, ArgValue,
1747                                DAG.getValueType(VA.getValVT()));
1748       else if (VA.getLocInfo() == CCValAssign::ZExt)
1749         ArgValue = DAG.getNode(ISD::AssertZext, dl, RegVT, ArgValue,
1750                                DAG.getValueType(VA.getValVT()));
1751       else if (VA.getLocInfo() == CCValAssign::BCvt)
1752         ArgValue = DAG.getNode(ISD::BITCAST, dl, VA.getValVT(), ArgValue);
1753
1754       if (VA.isExtInLoc()) {
1755         // Handle MMX values passed in XMM regs.
1756         if (RegVT.isVector()) {
1757           ArgValue = DAG.getNode(X86ISD::MOVDQ2Q, dl, VA.getValVT(),
1758                                  ArgValue);
1759         } else
1760           ArgValue = DAG.getNode(ISD::TRUNCATE, dl, VA.getValVT(), ArgValue);
1761       }
1762     } else {
1763       assert(VA.isMemLoc());
1764       ArgValue = LowerMemArgument(Chain, CallConv, Ins, dl, DAG, VA, MFI, i);
1765     }
1766
1767     // If value is passed via pointer - do a load.
1768     if (VA.getLocInfo() == CCValAssign::Indirect)
1769       ArgValue = DAG.getLoad(VA.getValVT(), dl, Chain, ArgValue,
1770                              MachinePointerInfo(), false, false, 0);
1771
1772     InVals.push_back(ArgValue);
1773   }
1774
1775   // The x86-64 ABI for returning structs by value requires that we copy
1776   // the sret argument into %rax for the return. Save the argument into
1777   // a virtual register so that we can access it from the return points.
1778   if (Is64Bit && MF.getFunction()->hasStructRetAttr()) {
1779     X86MachineFunctionInfo *FuncInfo = MF.getInfo<X86MachineFunctionInfo>();
1780     unsigned Reg = FuncInfo->getSRetReturnReg();
1781     if (!Reg) {
1782       Reg = MF.getRegInfo().createVirtualRegister(getRegClassFor(MVT::i64));
1783       FuncInfo->setSRetReturnReg(Reg);
1784     }
1785     SDValue Copy = DAG.getCopyToReg(DAG.getEntryNode(), dl, Reg, InVals[0]);
1786     Chain = DAG.getNode(ISD::TokenFactor, dl, MVT::Other, Copy, Chain);
1787   }
1788
1789   unsigned StackSize = CCInfo.getNextStackOffset();
1790   // Align stack specially for tail calls.
1791   if (FuncIsMadeTailCallSafe(CallConv))
1792     StackSize = GetAlignedArgumentStackSize(StackSize, DAG);
1793
1794   // If the function takes variable number of arguments, make a frame index for
1795   // the start of the first vararg value... for expansion of llvm.va_start.
1796   if (isVarArg) {
1797     if (Is64Bit || (CallConv != CallingConv::X86_FastCall &&
1798                     CallConv != CallingConv::X86_ThisCall)) {
1799       FuncInfo->setVarArgsFrameIndex(MFI->CreateFixedObject(1, StackSize,true));
1800     }
1801     if (Is64Bit) {
1802       unsigned TotalNumIntRegs = 0, TotalNumXMMRegs = 0;
1803
1804       // FIXME: We should really autogenerate these arrays
1805       static const unsigned GPR64ArgRegsWin64[] = {
1806         X86::RCX, X86::RDX, X86::R8,  X86::R9
1807       };
1808       static const unsigned GPR64ArgRegs64Bit[] = {
1809         X86::RDI, X86::RSI, X86::RDX, X86::RCX, X86::R8, X86::R9
1810       };
1811       static const unsigned XMMArgRegs64Bit[] = {
1812         X86::XMM0, X86::XMM1, X86::XMM2, X86::XMM3,
1813         X86::XMM4, X86::XMM5, X86::XMM6, X86::XMM7
1814       };
1815       const unsigned *GPR64ArgRegs;
1816       unsigned NumXMMRegs = 0;
1817
1818       if (IsWin64) {
1819         // The XMM registers which might contain var arg parameters are shadowed
1820         // in their paired GPR.  So we only need to save the GPR to their home
1821         // slots.
1822         TotalNumIntRegs = 4;
1823         GPR64ArgRegs = GPR64ArgRegsWin64;
1824       } else {
1825         TotalNumIntRegs = 6; TotalNumXMMRegs = 8;
1826         GPR64ArgRegs = GPR64ArgRegs64Bit;
1827
1828         NumXMMRegs = CCInfo.getFirstUnallocated(XMMArgRegs64Bit, TotalNumXMMRegs);
1829       }
1830       unsigned NumIntRegs = CCInfo.getFirstUnallocated(GPR64ArgRegs,
1831                                                        TotalNumIntRegs);
1832
1833       bool NoImplicitFloatOps = Fn->hasFnAttr(Attribute::NoImplicitFloat);
1834       assert(!(NumXMMRegs && !Subtarget->hasXMM()) &&
1835              "SSE register cannot be used when SSE is disabled!");
1836       assert(!(NumXMMRegs && UseSoftFloat && NoImplicitFloatOps) &&
1837              "SSE register cannot be used when SSE is disabled!");
1838       if (UseSoftFloat || NoImplicitFloatOps || !Subtarget->hasXMM())
1839         // Kernel mode asks for SSE to be disabled, so don't push them
1840         // on the stack.
1841         TotalNumXMMRegs = 0;
1842
1843       if (IsWin64) {
1844         const TargetFrameLowering &TFI = *getTargetMachine().getFrameLowering();
1845         // Get to the caller-allocated home save location.  Add 8 to account
1846         // for the return address.
1847         int HomeOffset = TFI.getOffsetOfLocalArea() + 8;
1848         FuncInfo->setRegSaveFrameIndex(
1849           MFI->CreateFixedObject(1, NumIntRegs * 8 + HomeOffset, false));
1850         // Fixup to set vararg frame on shadow area (4 x i64).
1851         if (NumIntRegs < 4)
1852           FuncInfo->setVarArgsFrameIndex(FuncInfo->getRegSaveFrameIndex());
1853       } else {
1854         // For X86-64, if there are vararg parameters that are passed via
1855         // registers, then we must store them to their spots on the stack so they
1856         // may be loaded by deferencing the result of va_next.
1857         FuncInfo->setVarArgsGPOffset(NumIntRegs * 8);
1858         FuncInfo->setVarArgsFPOffset(TotalNumIntRegs * 8 + NumXMMRegs * 16);
1859         FuncInfo->setRegSaveFrameIndex(
1860           MFI->CreateStackObject(TotalNumIntRegs * 8 + TotalNumXMMRegs * 16, 16,
1861                                false));
1862       }
1863
1864       // Store the integer parameter registers.
1865       SmallVector<SDValue, 8> MemOps;
1866       SDValue RSFIN = DAG.getFrameIndex(FuncInfo->getRegSaveFrameIndex(),
1867                                         getPointerTy());
1868       unsigned Offset = FuncInfo->getVarArgsGPOffset();
1869       for (; NumIntRegs != TotalNumIntRegs; ++NumIntRegs) {
1870         SDValue FIN = DAG.getNode(ISD::ADD, dl, getPointerTy(), RSFIN,
1871                                   DAG.getIntPtrConstant(Offset));
1872         unsigned VReg = MF.addLiveIn(GPR64ArgRegs[NumIntRegs],
1873                                      X86::GR64RegisterClass);
1874         SDValue Val = DAG.getCopyFromReg(Chain, dl, VReg, MVT::i64);
1875         SDValue Store =
1876           DAG.getStore(Val.getValue(1), dl, Val, FIN,
1877                        MachinePointerInfo::getFixedStack(
1878                          FuncInfo->getRegSaveFrameIndex(), Offset),
1879                        false, false, 0);
1880         MemOps.push_back(Store);
1881         Offset += 8;
1882       }
1883
1884       if (TotalNumXMMRegs != 0 && NumXMMRegs != TotalNumXMMRegs) {
1885         // Now store the XMM (fp + vector) parameter registers.
1886         SmallVector<SDValue, 11> SaveXMMOps;
1887         SaveXMMOps.push_back(Chain);
1888
1889         unsigned AL = MF.addLiveIn(X86::AL, X86::GR8RegisterClass);
1890         SDValue ALVal = DAG.getCopyFromReg(DAG.getEntryNode(), dl, AL, MVT::i8);
1891         SaveXMMOps.push_back(ALVal);
1892
1893         SaveXMMOps.push_back(DAG.getIntPtrConstant(
1894                                FuncInfo->getRegSaveFrameIndex()));
1895         SaveXMMOps.push_back(DAG.getIntPtrConstant(
1896                                FuncInfo->getVarArgsFPOffset()));
1897
1898         for (; NumXMMRegs != TotalNumXMMRegs; ++NumXMMRegs) {
1899           unsigned VReg = MF.addLiveIn(XMMArgRegs64Bit[NumXMMRegs],
1900                                        X86::VR128RegisterClass);
1901           SDValue Val = DAG.getCopyFromReg(Chain, dl, VReg, MVT::v4f32);
1902           SaveXMMOps.push_back(Val);
1903         }
1904         MemOps.push_back(DAG.getNode(X86ISD::VASTART_SAVE_XMM_REGS, dl,
1905                                      MVT::Other,
1906                                      &SaveXMMOps[0], SaveXMMOps.size()));
1907       }
1908
1909       if (!MemOps.empty())
1910         Chain = DAG.getNode(ISD::TokenFactor, dl, MVT::Other,
1911                             &MemOps[0], MemOps.size());
1912     }
1913   }
1914
1915   // Some CCs need callee pop.
1916   if (X86::isCalleePop(CallConv, Is64Bit, isVarArg, GuaranteedTailCallOpt)) {
1917     FuncInfo->setBytesToPopOnReturn(StackSize); // Callee pops everything.
1918   } else {
1919     FuncInfo->setBytesToPopOnReturn(0); // Callee pops nothing.
1920     // If this is an sret function, the return should pop the hidden pointer.
1921     if (!Is64Bit && !IsTailCallConvention(CallConv) && ArgsAreStructReturn(Ins))
1922       FuncInfo->setBytesToPopOnReturn(4);
1923   }
1924
1925   if (!Is64Bit) {
1926     // RegSaveFrameIndex is X86-64 only.
1927     FuncInfo->setRegSaveFrameIndex(0xAAAAAAA);
1928     if (CallConv == CallingConv::X86_FastCall ||
1929         CallConv == CallingConv::X86_ThisCall)
1930       // fastcc functions can't have varargs.
1931       FuncInfo->setVarArgsFrameIndex(0xAAAAAAA);
1932   }
1933
1934   FuncInfo->setArgumentStackSize(StackSize);
1935
1936   return Chain;
1937 }
1938
1939 SDValue
1940 X86TargetLowering::LowerMemOpCallTo(SDValue Chain,
1941                                     SDValue StackPtr, SDValue Arg,
1942                                     DebugLoc dl, SelectionDAG &DAG,
1943                                     const CCValAssign &VA,
1944                                     ISD::ArgFlagsTy Flags) const {
1945   unsigned LocMemOffset = VA.getLocMemOffset();
1946   SDValue PtrOff = DAG.getIntPtrConstant(LocMemOffset);
1947   PtrOff = DAG.getNode(ISD::ADD, dl, getPointerTy(), StackPtr, PtrOff);
1948   if (Flags.isByVal())
1949     return CreateCopyOfByValArgument(Arg, PtrOff, Chain, Flags, DAG, dl);
1950
1951   return DAG.getStore(Chain, dl, Arg, PtrOff,
1952                       MachinePointerInfo::getStack(LocMemOffset),
1953                       false, false, 0);
1954 }
1955
1956 /// EmitTailCallLoadRetAddr - Emit a load of return address if tail call
1957 /// optimization is performed and it is required.
1958 SDValue
1959 X86TargetLowering::EmitTailCallLoadRetAddr(SelectionDAG &DAG,
1960                                            SDValue &OutRetAddr, SDValue Chain,
1961                                            bool IsTailCall, bool Is64Bit,
1962                                            int FPDiff, DebugLoc dl) const {
1963   // Adjust the Return address stack slot.
1964   EVT VT = getPointerTy();
1965   OutRetAddr = getReturnAddressFrameIndex(DAG);
1966
1967   // Load the "old" Return address.
1968   OutRetAddr = DAG.getLoad(VT, dl, Chain, OutRetAddr, MachinePointerInfo(),
1969                            false, false, 0);
1970   return SDValue(OutRetAddr.getNode(), 1);
1971 }
1972
1973 /// EmitTailCallStoreRetAddr - Emit a store of the return address if tail call
1974 /// optimization is performed and it is required (FPDiff!=0).
1975 static SDValue
1976 EmitTailCallStoreRetAddr(SelectionDAG & DAG, MachineFunction &MF,
1977                          SDValue Chain, SDValue RetAddrFrIdx,
1978                          bool Is64Bit, int FPDiff, DebugLoc dl) {
1979   // Store the return address to the appropriate stack slot.
1980   if (!FPDiff) return Chain;
1981   // Calculate the new stack slot for the return address.
1982   int SlotSize = Is64Bit ? 8 : 4;
1983   int NewReturnAddrFI =
1984     MF.getFrameInfo()->CreateFixedObject(SlotSize, FPDiff-SlotSize, false);
1985   EVT VT = Is64Bit ? MVT::i64 : MVT::i32;
1986   SDValue NewRetAddrFrIdx = DAG.getFrameIndex(NewReturnAddrFI, VT);
1987   Chain = DAG.getStore(Chain, dl, RetAddrFrIdx, NewRetAddrFrIdx,
1988                        MachinePointerInfo::getFixedStack(NewReturnAddrFI),
1989                        false, false, 0);
1990   return Chain;
1991 }
1992
1993 SDValue
1994 X86TargetLowering::LowerCall(SDValue Chain, SDValue Callee,
1995                              CallingConv::ID CallConv, bool isVarArg,
1996                              bool &isTailCall,
1997                              const SmallVectorImpl<ISD::OutputArg> &Outs,
1998                              const SmallVectorImpl<SDValue> &OutVals,
1999                              const SmallVectorImpl<ISD::InputArg> &Ins,
2000                              DebugLoc dl, SelectionDAG &DAG,
2001                              SmallVectorImpl<SDValue> &InVals) const {
2002   MachineFunction &MF = DAG.getMachineFunction();
2003   bool Is64Bit        = Subtarget->is64Bit();
2004   bool IsWin64        = Subtarget->isTargetWin64();
2005   bool IsStructRet    = CallIsStructReturn(Outs);
2006   bool IsSibcall      = false;
2007
2008   if (isTailCall) {
2009     // Check if it's really possible to do a tail call.
2010     isTailCall = IsEligibleForTailCallOptimization(Callee, CallConv,
2011                     isVarArg, IsStructRet, MF.getFunction()->hasStructRetAttr(),
2012                                                    Outs, OutVals, Ins, DAG);
2013
2014     // Sibcalls are automatically detected tailcalls which do not require
2015     // ABI changes.
2016     if (!GuaranteedTailCallOpt && isTailCall)
2017       IsSibcall = true;
2018
2019     if (isTailCall)
2020       ++NumTailCalls;
2021   }
2022
2023   assert(!(isVarArg && IsTailCallConvention(CallConv)) &&
2024          "Var args not supported with calling convention fastcc or ghc");
2025
2026   // Analyze operands of the call, assigning locations to each operand.
2027   SmallVector<CCValAssign, 16> ArgLocs;
2028   CCState CCInfo(CallConv, isVarArg, MF, getTargetMachine(),
2029                  ArgLocs, *DAG.getContext());
2030
2031   // Allocate shadow area for Win64
2032   if (IsWin64) {
2033     CCInfo.AllocateStack(32, 8);
2034   }
2035
2036   CCInfo.AnalyzeCallOperands(Outs, CC_X86);
2037
2038   // Get a count of how many bytes are to be pushed on the stack.
2039   unsigned NumBytes = CCInfo.getNextStackOffset();
2040   if (IsSibcall)
2041     // This is a sibcall. The memory operands are available in caller's
2042     // own caller's stack.
2043     NumBytes = 0;
2044   else if (GuaranteedTailCallOpt && IsTailCallConvention(CallConv))
2045     NumBytes = GetAlignedArgumentStackSize(NumBytes, DAG);
2046
2047   int FPDiff = 0;
2048   if (isTailCall && !IsSibcall) {
2049     // Lower arguments at fp - stackoffset + fpdiff.
2050     unsigned NumBytesCallerPushed =
2051       MF.getInfo<X86MachineFunctionInfo>()->getBytesToPopOnReturn();
2052     FPDiff = NumBytesCallerPushed - NumBytes;
2053
2054     // Set the delta of movement of the returnaddr stackslot.
2055     // But only set if delta is greater than previous delta.
2056     if (FPDiff < (MF.getInfo<X86MachineFunctionInfo>()->getTCReturnAddrDelta()))
2057       MF.getInfo<X86MachineFunctionInfo>()->setTCReturnAddrDelta(FPDiff);
2058   }
2059
2060   if (!IsSibcall)
2061     Chain = DAG.getCALLSEQ_START(Chain, DAG.getIntPtrConstant(NumBytes, true));
2062
2063   SDValue RetAddrFrIdx;
2064   // Load return address for tail calls.
2065   if (isTailCall && FPDiff)
2066     Chain = EmitTailCallLoadRetAddr(DAG, RetAddrFrIdx, Chain, isTailCall,
2067                                     Is64Bit, FPDiff, dl);
2068
2069   SmallVector<std::pair<unsigned, SDValue>, 8> RegsToPass;
2070   SmallVector<SDValue, 8> MemOpChains;
2071   SDValue StackPtr;
2072
2073   // Walk the register/memloc assignments, inserting copies/loads.  In the case
2074   // of tail call optimization arguments are handle later.
2075   for (unsigned i = 0, e = ArgLocs.size(); i != e; ++i) {
2076     CCValAssign &VA = ArgLocs[i];
2077     EVT RegVT = VA.getLocVT();
2078     SDValue Arg = OutVals[i];
2079     ISD::ArgFlagsTy Flags = Outs[i].Flags;
2080     bool isByVal = Flags.isByVal();
2081
2082     // Promote the value if needed.
2083     switch (VA.getLocInfo()) {
2084     default: llvm_unreachable("Unknown loc info!");
2085     case CCValAssign::Full: break;
2086     case CCValAssign::SExt:
2087       Arg = DAG.getNode(ISD::SIGN_EXTEND, dl, RegVT, Arg);
2088       break;
2089     case CCValAssign::ZExt:
2090       Arg = DAG.getNode(ISD::ZERO_EXTEND, dl, RegVT, Arg);
2091       break;
2092     case CCValAssign::AExt:
2093       if (RegVT.isVector() && RegVT.getSizeInBits() == 128) {
2094         // Special case: passing MMX values in XMM registers.
2095         Arg = DAG.getNode(ISD::BITCAST, dl, MVT::i64, Arg);
2096         Arg = DAG.getNode(ISD::SCALAR_TO_VECTOR, dl, MVT::v2i64, Arg);
2097         Arg = getMOVL(DAG, dl, MVT::v2i64, DAG.getUNDEF(MVT::v2i64), Arg);
2098       } else
2099         Arg = DAG.getNode(ISD::ANY_EXTEND, dl, RegVT, Arg);
2100       break;
2101     case CCValAssign::BCvt:
2102       Arg = DAG.getNode(ISD::BITCAST, dl, RegVT, Arg);
2103       break;
2104     case CCValAssign::Indirect: {
2105       // Store the argument.
2106       SDValue SpillSlot = DAG.CreateStackTemporary(VA.getValVT());
2107       int FI = cast<FrameIndexSDNode>(SpillSlot)->getIndex();
2108       Chain = DAG.getStore(Chain, dl, Arg, SpillSlot,
2109                            MachinePointerInfo::getFixedStack(FI),
2110                            false, false, 0);
2111       Arg = SpillSlot;
2112       break;
2113     }
2114     }
2115
2116     if (VA.isRegLoc()) {
2117       RegsToPass.push_back(std::make_pair(VA.getLocReg(), Arg));
2118       if (isVarArg && IsWin64) {
2119         // Win64 ABI requires argument XMM reg to be copied to the corresponding
2120         // shadow reg if callee is a varargs function.
2121         unsigned ShadowReg = 0;
2122         switch (VA.getLocReg()) {
2123         case X86::XMM0: ShadowReg = X86::RCX; break;
2124         case X86::XMM1: ShadowReg = X86::RDX; break;
2125         case X86::XMM2: ShadowReg = X86::R8; break;
2126         case X86::XMM3: ShadowReg = X86::R9; break;
2127         }
2128         if (ShadowReg)
2129           RegsToPass.push_back(std::make_pair(ShadowReg, Arg));
2130       }
2131     } else if (!IsSibcall && (!isTailCall || isByVal)) {
2132       assert(VA.isMemLoc());
2133       if (StackPtr.getNode() == 0)
2134         StackPtr = DAG.getCopyFromReg(Chain, dl, X86StackPtr, getPointerTy());
2135       MemOpChains.push_back(LowerMemOpCallTo(Chain, StackPtr, Arg,
2136                                              dl, DAG, VA, Flags));
2137     }
2138   }
2139
2140   if (!MemOpChains.empty())
2141     Chain = DAG.getNode(ISD::TokenFactor, dl, MVT::Other,
2142                         &MemOpChains[0], MemOpChains.size());
2143
2144   // Build a sequence of copy-to-reg nodes chained together with token chain
2145   // and flag operands which copy the outgoing args into registers.
2146   SDValue InFlag;
2147   // Tail call byval lowering might overwrite argument registers so in case of
2148   // tail call optimization the copies to registers are lowered later.
2149   if (!isTailCall)
2150     for (unsigned i = 0, e = RegsToPass.size(); i != e; ++i) {
2151       Chain = DAG.getCopyToReg(Chain, dl, RegsToPass[i].first,
2152                                RegsToPass[i].second, InFlag);
2153       InFlag = Chain.getValue(1);
2154     }
2155
2156   if (Subtarget->isPICStyleGOT()) {
2157     // ELF / PIC requires GOT in the EBX register before function calls via PLT
2158     // GOT pointer.
2159     if (!isTailCall) {
2160       Chain = DAG.getCopyToReg(Chain, dl, X86::EBX,
2161                                DAG.getNode(X86ISD::GlobalBaseReg,
2162                                            DebugLoc(), getPointerTy()),
2163                                InFlag);
2164       InFlag = Chain.getValue(1);
2165     } else {
2166       // If we are tail calling and generating PIC/GOT style code load the
2167       // address of the callee into ECX. The value in ecx is used as target of
2168       // the tail jump. This is done to circumvent the ebx/callee-saved problem
2169       // for tail calls on PIC/GOT architectures. Normally we would just put the
2170       // address of GOT into ebx and then call target@PLT. But for tail calls
2171       // ebx would be restored (since ebx is callee saved) before jumping to the
2172       // target@PLT.
2173
2174       // Note: The actual moving to ECX is done further down.
2175       GlobalAddressSDNode *G = dyn_cast<GlobalAddressSDNode>(Callee);
2176       if (G && !G->getGlobal()->hasHiddenVisibility() &&
2177           !G->getGlobal()->hasProtectedVisibility())
2178         Callee = LowerGlobalAddress(Callee, DAG);
2179       else if (isa<ExternalSymbolSDNode>(Callee))
2180         Callee = LowerExternalSymbol(Callee, DAG);
2181     }
2182   }
2183
2184   if (Is64Bit && isVarArg && !IsWin64) {
2185     // From AMD64 ABI document:
2186     // For calls that may call functions that use varargs or stdargs
2187     // (prototype-less calls or calls to functions containing ellipsis (...) in
2188     // the declaration) %al is used as hidden argument to specify the number
2189     // of SSE registers used. The contents of %al do not need to match exactly
2190     // the number of registers, but must be an ubound on the number of SSE
2191     // registers used and is in the range 0 - 8 inclusive.
2192
2193     // Count the number of XMM registers allocated.
2194     static const unsigned XMMArgRegs[] = {
2195       X86::XMM0, X86::XMM1, X86::XMM2, X86::XMM3,
2196       X86::XMM4, X86::XMM5, X86::XMM6, X86::XMM7
2197     };
2198     unsigned NumXMMRegs = CCInfo.getFirstUnallocated(XMMArgRegs, 8);
2199     assert((Subtarget->hasXMM() || !NumXMMRegs)
2200            && "SSE registers cannot be used when SSE is disabled");
2201
2202     Chain = DAG.getCopyToReg(Chain, dl, X86::AL,
2203                              DAG.getConstant(NumXMMRegs, MVT::i8), InFlag);
2204     InFlag = Chain.getValue(1);
2205   }
2206
2207
2208   // For tail calls lower the arguments to the 'real' stack slot.
2209   if (isTailCall) {
2210     // Force all the incoming stack arguments to be loaded from the stack
2211     // before any new outgoing arguments are stored to the stack, because the
2212     // outgoing stack slots may alias the incoming argument stack slots, and
2213     // the alias isn't otherwise explicit. This is slightly more conservative
2214     // than necessary, because it means that each store effectively depends
2215     // on every argument instead of just those arguments it would clobber.
2216     SDValue ArgChain = DAG.getStackArgumentTokenFactor(Chain);
2217
2218     SmallVector<SDValue, 8> MemOpChains2;
2219     SDValue FIN;
2220     int FI = 0;
2221     // Do not flag preceding copytoreg stuff together with the following stuff.
2222     InFlag = SDValue();
2223     if (GuaranteedTailCallOpt) {
2224       for (unsigned i = 0, e = ArgLocs.size(); i != e; ++i) {
2225         CCValAssign &VA = ArgLocs[i];
2226         if (VA.isRegLoc())
2227           continue;
2228         assert(VA.isMemLoc());
2229         SDValue Arg = OutVals[i];
2230         ISD::ArgFlagsTy Flags = Outs[i].Flags;
2231         // Create frame index.
2232         int32_t Offset = VA.getLocMemOffset()+FPDiff;
2233         uint32_t OpSize = (VA.getLocVT().getSizeInBits()+7)/8;
2234         FI = MF.getFrameInfo()->CreateFixedObject(OpSize, Offset, true);
2235         FIN = DAG.getFrameIndex(FI, getPointerTy());
2236
2237         if (Flags.isByVal()) {
2238           // Copy relative to framepointer.
2239           SDValue Source = DAG.getIntPtrConstant(VA.getLocMemOffset());
2240           if (StackPtr.getNode() == 0)
2241             StackPtr = DAG.getCopyFromReg(Chain, dl, X86StackPtr,
2242                                           getPointerTy());
2243           Source = DAG.getNode(ISD::ADD, dl, getPointerTy(), StackPtr, Source);
2244
2245           MemOpChains2.push_back(CreateCopyOfByValArgument(Source, FIN,
2246                                                            ArgChain,
2247                                                            Flags, DAG, dl));
2248         } else {
2249           // Store relative to framepointer.
2250           MemOpChains2.push_back(
2251             DAG.getStore(ArgChain, dl, Arg, FIN,
2252                          MachinePointerInfo::getFixedStack(FI),
2253                          false, false, 0));
2254         }
2255       }
2256     }
2257
2258     if (!MemOpChains2.empty())
2259       Chain = DAG.getNode(ISD::TokenFactor, dl, MVT::Other,
2260                           &MemOpChains2[0], MemOpChains2.size());
2261
2262     // Copy arguments to their registers.
2263     for (unsigned i = 0, e = RegsToPass.size(); i != e; ++i) {
2264       Chain = DAG.getCopyToReg(Chain, dl, RegsToPass[i].first,
2265                                RegsToPass[i].second, InFlag);
2266       InFlag = Chain.getValue(1);
2267     }
2268     InFlag =SDValue();
2269
2270     // Store the return address to the appropriate stack slot.
2271     Chain = EmitTailCallStoreRetAddr(DAG, MF, Chain, RetAddrFrIdx, Is64Bit,
2272                                      FPDiff, dl);
2273   }
2274
2275   if (getTargetMachine().getCodeModel() == CodeModel::Large) {
2276     assert(Is64Bit && "Large code model is only legal in 64-bit mode.");
2277     // In the 64-bit large code model, we have to make all calls
2278     // through a register, since the call instruction's 32-bit
2279     // pc-relative offset may not be large enough to hold the whole
2280     // address.
2281   } else if (GlobalAddressSDNode *G = dyn_cast<GlobalAddressSDNode>(Callee)) {
2282     // If the callee is a GlobalAddress node (quite common, every direct call
2283     // is) turn it into a TargetGlobalAddress node so that legalize doesn't hack
2284     // it.
2285
2286     // We should use extra load for direct calls to dllimported functions in
2287     // non-JIT mode.
2288     const GlobalValue *GV = G->getGlobal();
2289     if (!GV->hasDLLImportLinkage()) {
2290       unsigned char OpFlags = 0;
2291       bool ExtraLoad = false;
2292       unsigned WrapperKind = ISD::DELETED_NODE;
2293
2294       // On ELF targets, in both X86-64 and X86-32 mode, direct calls to
2295       // external symbols most go through the PLT in PIC mode.  If the symbol
2296       // has hidden or protected visibility, or if it is static or local, then
2297       // we don't need to use the PLT - we can directly call it.
2298       if (Subtarget->isTargetELF() &&
2299           getTargetMachine().getRelocationModel() == Reloc::PIC_ &&
2300           GV->hasDefaultVisibility() && !GV->hasLocalLinkage()) {
2301         OpFlags = X86II::MO_PLT;
2302       } else if (Subtarget->isPICStyleStubAny() &&
2303                  (GV->isDeclaration() || GV->isWeakForLinker()) &&
2304                  (!Subtarget->getTargetTriple().isMacOSX() ||
2305                   Subtarget->getTargetTriple().isMacOSXVersionLT(10, 5))) {
2306         // PC-relative references to external symbols should go through $stub,
2307         // unless we're building with the leopard linker or later, which
2308         // automatically synthesizes these stubs.
2309         OpFlags = X86II::MO_DARWIN_STUB;
2310       } else if (Subtarget->isPICStyleRIPRel() &&
2311                  isa<Function>(GV) &&
2312                  cast<Function>(GV)->hasFnAttr(Attribute::NonLazyBind)) {
2313         // If the function is marked as non-lazy, generate an indirect call
2314         // which loads from the GOT directly. This avoids runtime overhead
2315         // at the cost of eager binding (and one extra byte of encoding).
2316         OpFlags = X86II::MO_GOTPCREL;
2317         WrapperKind = X86ISD::WrapperRIP;
2318         ExtraLoad = true;
2319       }
2320
2321       Callee = DAG.getTargetGlobalAddress(GV, dl, getPointerTy(),
2322                                           G->getOffset(), OpFlags);
2323
2324       // Add a wrapper if needed.
2325       if (WrapperKind != ISD::DELETED_NODE)
2326         Callee = DAG.getNode(X86ISD::WrapperRIP, dl, getPointerTy(), Callee);
2327       // Add extra indirection if needed.
2328       if (ExtraLoad)
2329         Callee = DAG.getLoad(getPointerTy(), dl, DAG.getEntryNode(), Callee,
2330                              MachinePointerInfo::getGOT(),
2331                              false, false, 0);
2332     }
2333   } else if (ExternalSymbolSDNode *S = dyn_cast<ExternalSymbolSDNode>(Callee)) {
2334     unsigned char OpFlags = 0;
2335
2336     // On ELF targets, in either X86-64 or X86-32 mode, direct calls to
2337     // external symbols should go through the PLT.
2338     if (Subtarget->isTargetELF() &&
2339         getTargetMachine().getRelocationModel() == Reloc::PIC_) {
2340       OpFlags = X86II::MO_PLT;
2341     } else if (Subtarget->isPICStyleStubAny() &&
2342                (!Subtarget->getTargetTriple().isMacOSX() ||
2343                 Subtarget->getTargetTriple().isMacOSXVersionLT(10, 5))) {
2344       // PC-relative references to external symbols should go through $stub,
2345       // unless we're building with the leopard linker or later, which
2346       // automatically synthesizes these stubs.
2347       OpFlags = X86II::MO_DARWIN_STUB;
2348     }
2349
2350     Callee = DAG.getTargetExternalSymbol(S->getSymbol(), getPointerTy(),
2351                                          OpFlags);
2352   }
2353
2354   // Returns a chain & a flag for retval copy to use.
2355   SDVTList NodeTys = DAG.getVTList(MVT::Other, MVT::Glue);
2356   SmallVector<SDValue, 8> Ops;
2357
2358   if (!IsSibcall && isTailCall) {
2359     Chain = DAG.getCALLSEQ_END(Chain, DAG.getIntPtrConstant(NumBytes, true),
2360                            DAG.getIntPtrConstant(0, true), InFlag);
2361     InFlag = Chain.getValue(1);
2362   }
2363
2364   Ops.push_back(Chain);
2365   Ops.push_back(Callee);
2366
2367   if (isTailCall)
2368     Ops.push_back(DAG.getConstant(FPDiff, MVT::i32));
2369
2370   // Add argument registers to the end of the list so that they are known live
2371   // into the call.
2372   for (unsigned i = 0, e = RegsToPass.size(); i != e; ++i)
2373     Ops.push_back(DAG.getRegister(RegsToPass[i].first,
2374                                   RegsToPass[i].second.getValueType()));
2375
2376   // Add an implicit use GOT pointer in EBX.
2377   if (!isTailCall && Subtarget->isPICStyleGOT())
2378     Ops.push_back(DAG.getRegister(X86::EBX, getPointerTy()));
2379
2380   // Add an implicit use of AL for non-Windows x86 64-bit vararg functions.
2381   if (Is64Bit && isVarArg && !IsWin64)
2382     Ops.push_back(DAG.getRegister(X86::AL, MVT::i8));
2383
2384   if (InFlag.getNode())
2385     Ops.push_back(InFlag);
2386
2387   if (isTailCall) {
2388     // We used to do:
2389     //// If this is the first return lowered for this function, add the regs
2390     //// to the liveout set for the function.
2391     // This isn't right, although it's probably harmless on x86; liveouts
2392     // should be computed from returns not tail calls.  Consider a void
2393     // function making a tail call to a function returning int.
2394     return DAG.getNode(X86ISD::TC_RETURN, dl,
2395                        NodeTys, &Ops[0], Ops.size());
2396   }
2397
2398   Chain = DAG.getNode(X86ISD::CALL, dl, NodeTys, &Ops[0], Ops.size());
2399   InFlag = Chain.getValue(1);
2400
2401   // Create the CALLSEQ_END node.
2402   unsigned NumBytesForCalleeToPush;
2403   if (X86::isCalleePop(CallConv, Is64Bit, isVarArg, GuaranteedTailCallOpt))
2404     NumBytesForCalleeToPush = NumBytes;    // Callee pops everything
2405   else if (!Is64Bit && !IsTailCallConvention(CallConv) && IsStructRet)
2406     // If this is a call to a struct-return function, the callee
2407     // pops the hidden struct pointer, so we have to push it back.
2408     // This is common for Darwin/X86, Linux & Mingw32 targets.
2409     NumBytesForCalleeToPush = 4;
2410   else
2411     NumBytesForCalleeToPush = 0;  // Callee pops nothing.
2412
2413   // Returns a flag for retval copy to use.
2414   if (!IsSibcall) {
2415     Chain = DAG.getCALLSEQ_END(Chain,
2416                                DAG.getIntPtrConstant(NumBytes, true),
2417                                DAG.getIntPtrConstant(NumBytesForCalleeToPush,
2418                                                      true),
2419                                InFlag);
2420     InFlag = Chain.getValue(1);
2421   }
2422
2423   // Handle result values, copying them out of physregs into vregs that we
2424   // return.
2425   return LowerCallResult(Chain, InFlag, CallConv, isVarArg,
2426                          Ins, dl, DAG, InVals);
2427 }
2428
2429
2430 //===----------------------------------------------------------------------===//
2431 //                Fast Calling Convention (tail call) implementation
2432 //===----------------------------------------------------------------------===//
2433
2434 //  Like std call, callee cleans arguments, convention except that ECX is
2435 //  reserved for storing the tail called function address. Only 2 registers are
2436 //  free for argument passing (inreg). Tail call optimization is performed
2437 //  provided:
2438 //                * tailcallopt is enabled
2439 //                * caller/callee are fastcc
2440 //  On X86_64 architecture with GOT-style position independent code only local
2441 //  (within module) calls are supported at the moment.
2442 //  To keep the stack aligned according to platform abi the function
2443 //  GetAlignedArgumentStackSize ensures that argument delta is always multiples
2444 //  of stack alignment. (Dynamic linkers need this - darwin's dyld for example)
2445 //  If a tail called function callee has more arguments than the caller the
2446 //  caller needs to make sure that there is room to move the RETADDR to. This is
2447 //  achieved by reserving an area the size of the argument delta right after the
2448 //  original REtADDR, but before the saved framepointer or the spilled registers
2449 //  e.g. caller(arg1, arg2) calls callee(arg1, arg2,arg3,arg4)
2450 //  stack layout:
2451 //    arg1
2452 //    arg2
2453 //    RETADDR
2454 //    [ new RETADDR
2455 //      move area ]
2456 //    (possible EBP)
2457 //    ESI
2458 //    EDI
2459 //    local1 ..
2460
2461 /// GetAlignedArgumentStackSize - Make the stack size align e.g 16n + 12 aligned
2462 /// for a 16 byte align requirement.
2463 unsigned
2464 X86TargetLowering::GetAlignedArgumentStackSize(unsigned StackSize,
2465                                                SelectionDAG& DAG) const {
2466   MachineFunction &MF = DAG.getMachineFunction();
2467   const TargetMachine &TM = MF.getTarget();
2468   const TargetFrameLowering &TFI = *TM.getFrameLowering();
2469   unsigned StackAlignment = TFI.getStackAlignment();
2470   uint64_t AlignMask = StackAlignment - 1;
2471   int64_t Offset = StackSize;
2472   uint64_t SlotSize = TD->getPointerSize();
2473   if ( (Offset & AlignMask) <= (StackAlignment - SlotSize) ) {
2474     // Number smaller than 12 so just add the difference.
2475     Offset += ((StackAlignment - SlotSize) - (Offset & AlignMask));
2476   } else {
2477     // Mask out lower bits, add stackalignment once plus the 12 bytes.
2478     Offset = ((~AlignMask) & Offset) + StackAlignment +
2479       (StackAlignment-SlotSize);
2480   }
2481   return Offset;
2482 }
2483
2484 /// MatchingStackOffset - Return true if the given stack call argument is
2485 /// already available in the same position (relatively) of the caller's
2486 /// incoming argument stack.
2487 static
2488 bool MatchingStackOffset(SDValue Arg, unsigned Offset, ISD::ArgFlagsTy Flags,
2489                          MachineFrameInfo *MFI, const MachineRegisterInfo *MRI,
2490                          const X86InstrInfo *TII) {
2491   unsigned Bytes = Arg.getValueType().getSizeInBits() / 8;
2492   int FI = INT_MAX;
2493   if (Arg.getOpcode() == ISD::CopyFromReg) {
2494     unsigned VR = cast<RegisterSDNode>(Arg.getOperand(1))->getReg();
2495     if (!TargetRegisterInfo::isVirtualRegister(VR))
2496       return false;
2497     MachineInstr *Def = MRI->getVRegDef(VR);
2498     if (!Def)
2499       return false;
2500     if (!Flags.isByVal()) {
2501       if (!TII->isLoadFromStackSlot(Def, FI))
2502         return false;
2503     } else {
2504       unsigned Opcode = Def->getOpcode();
2505       if ((Opcode == X86::LEA32r || Opcode == X86::LEA64r) &&
2506           Def->getOperand(1).isFI()) {
2507         FI = Def->getOperand(1).getIndex();
2508         Bytes = Flags.getByValSize();
2509       } else
2510         return false;
2511     }
2512   } else if (LoadSDNode *Ld = dyn_cast<LoadSDNode>(Arg)) {
2513     if (Flags.isByVal())
2514       // ByVal argument is passed in as a pointer but it's now being
2515       // dereferenced. e.g.
2516       // define @foo(%struct.X* %A) {
2517       //   tail call @bar(%struct.X* byval %A)
2518       // }
2519       return false;
2520     SDValue Ptr = Ld->getBasePtr();
2521     FrameIndexSDNode *FINode = dyn_cast<FrameIndexSDNode>(Ptr);
2522     if (!FINode)
2523       return false;
2524     FI = FINode->getIndex();
2525   } else if (Arg.getOpcode() == ISD::FrameIndex && Flags.isByVal()) {
2526     FrameIndexSDNode *FINode = cast<FrameIndexSDNode>(Arg);
2527     FI = FINode->getIndex();
2528     Bytes = Flags.getByValSize();
2529   } else
2530     return false;
2531
2532   assert(FI != INT_MAX);
2533   if (!MFI->isFixedObjectIndex(FI))
2534     return false;
2535   return Offset == MFI->getObjectOffset(FI) && Bytes == MFI->getObjectSize(FI);
2536 }
2537
2538 /// IsEligibleForTailCallOptimization - Check whether the call is eligible
2539 /// for tail call optimization. Targets which want to do tail call
2540 /// optimization should implement this function.
2541 bool
2542 X86TargetLowering::IsEligibleForTailCallOptimization(SDValue Callee,
2543                                                      CallingConv::ID CalleeCC,
2544                                                      bool isVarArg,
2545                                                      bool isCalleeStructRet,
2546                                                      bool isCallerStructRet,
2547                                     const SmallVectorImpl<ISD::OutputArg> &Outs,
2548                                     const SmallVectorImpl<SDValue> &OutVals,
2549                                     const SmallVectorImpl<ISD::InputArg> &Ins,
2550                                                      SelectionDAG& DAG) const {
2551   if (!IsTailCallConvention(CalleeCC) &&
2552       CalleeCC != CallingConv::C)
2553     return false;
2554
2555   // If -tailcallopt is specified, make fastcc functions tail-callable.
2556   const MachineFunction &MF = DAG.getMachineFunction();
2557   const Function *CallerF = DAG.getMachineFunction().getFunction();
2558   CallingConv::ID CallerCC = CallerF->getCallingConv();
2559   bool CCMatch = CallerCC == CalleeCC;
2560
2561   if (GuaranteedTailCallOpt) {
2562     if (IsTailCallConvention(CalleeCC) && CCMatch)
2563       return true;
2564     return false;
2565   }
2566
2567   // Look for obvious safe cases to perform tail call optimization that do not
2568   // require ABI changes. This is what gcc calls sibcall.
2569
2570   // Can't do sibcall if stack needs to be dynamically re-aligned. PEI needs to
2571   // emit a special epilogue.
2572   if (RegInfo->needsStackRealignment(MF))
2573     return false;
2574
2575   // Also avoid sibcall optimization if either caller or callee uses struct
2576   // return semantics.
2577   if (isCalleeStructRet || isCallerStructRet)
2578     return false;
2579
2580   // An stdcall caller is expected to clean up its arguments; the callee
2581   // isn't going to do that.
2582   if (!CCMatch && CallerCC==CallingConv::X86_StdCall)
2583     return false;
2584
2585   // Do not sibcall optimize vararg calls unless all arguments are passed via
2586   // registers.
2587   if (isVarArg && !Outs.empty()) {
2588
2589     // Optimizing for varargs on Win64 is unlikely to be safe without
2590     // additional testing.
2591     if (Subtarget->isTargetWin64())
2592       return false;
2593
2594     SmallVector<CCValAssign, 16> ArgLocs;
2595     CCState CCInfo(CalleeCC, isVarArg, DAG.getMachineFunction(),
2596                    getTargetMachine(), ArgLocs, *DAG.getContext());
2597
2598     CCInfo.AnalyzeCallOperands(Outs, CC_X86);
2599     for (unsigned i = 0, e = ArgLocs.size(); i != e; ++i)
2600       if (!ArgLocs[i].isRegLoc())
2601         return false;
2602   }
2603
2604   // If the call result is in ST0 / ST1, it needs to be popped off the x87 stack.
2605   // Therefore if it's not used by the call it is not safe to optimize this into
2606   // a sibcall.
2607   bool Unused = false;
2608   for (unsigned i = 0, e = Ins.size(); i != e; ++i) {
2609     if (!Ins[i].Used) {
2610       Unused = true;
2611       break;
2612     }
2613   }
2614   if (Unused) {
2615     SmallVector<CCValAssign, 16> RVLocs;
2616     CCState CCInfo(CalleeCC, false, DAG.getMachineFunction(),
2617                    getTargetMachine(), RVLocs, *DAG.getContext());
2618     CCInfo.AnalyzeCallResult(Ins, RetCC_X86);
2619     for (unsigned i = 0, e = RVLocs.size(); i != e; ++i) {
2620       CCValAssign &VA = RVLocs[i];
2621       if (VA.getLocReg() == X86::ST0 || VA.getLocReg() == X86::ST1)
2622         return false;
2623     }
2624   }
2625
2626   // If the calling conventions do not match, then we'd better make sure the
2627   // results are returned in the same way as what the caller expects.
2628   if (!CCMatch) {
2629     SmallVector<CCValAssign, 16> RVLocs1;
2630     CCState CCInfo1(CalleeCC, false, DAG.getMachineFunction(),
2631                     getTargetMachine(), RVLocs1, *DAG.getContext());
2632     CCInfo1.AnalyzeCallResult(Ins, RetCC_X86);
2633
2634     SmallVector<CCValAssign, 16> RVLocs2;
2635     CCState CCInfo2(CallerCC, false, DAG.getMachineFunction(),
2636                     getTargetMachine(), RVLocs2, *DAG.getContext());
2637     CCInfo2.AnalyzeCallResult(Ins, RetCC_X86);
2638
2639     if (RVLocs1.size() != RVLocs2.size())
2640       return false;
2641     for (unsigned i = 0, e = RVLocs1.size(); i != e; ++i) {
2642       if (RVLocs1[i].isRegLoc() != RVLocs2[i].isRegLoc())
2643         return false;
2644       if (RVLocs1[i].getLocInfo() != RVLocs2[i].getLocInfo())
2645         return false;
2646       if (RVLocs1[i].isRegLoc()) {
2647         if (RVLocs1[i].getLocReg() != RVLocs2[i].getLocReg())
2648           return false;
2649       } else {
2650         if (RVLocs1[i].getLocMemOffset() != RVLocs2[i].getLocMemOffset())
2651           return false;
2652       }
2653     }
2654   }
2655
2656   // If the callee takes no arguments then go on to check the results of the
2657   // call.
2658   if (!Outs.empty()) {
2659     // Check if stack adjustment is needed. For now, do not do this if any
2660     // argument is passed on the stack.
2661     SmallVector<CCValAssign, 16> ArgLocs;
2662     CCState CCInfo(CalleeCC, isVarArg, DAG.getMachineFunction(),
2663                    getTargetMachine(), ArgLocs, *DAG.getContext());
2664
2665     // Allocate shadow area for Win64
2666     if (Subtarget->isTargetWin64()) {
2667       CCInfo.AllocateStack(32, 8);
2668     }
2669
2670     CCInfo.AnalyzeCallOperands(Outs, CC_X86);
2671     if (CCInfo.getNextStackOffset()) {
2672       MachineFunction &MF = DAG.getMachineFunction();
2673       if (MF.getInfo<X86MachineFunctionInfo>()->getBytesToPopOnReturn())
2674         return false;
2675
2676       // Check if the arguments are already laid out in the right way as
2677       // the caller's fixed stack objects.
2678       MachineFrameInfo *MFI = MF.getFrameInfo();
2679       const MachineRegisterInfo *MRI = &MF.getRegInfo();
2680       const X86InstrInfo *TII =
2681         ((X86TargetMachine&)getTargetMachine()).getInstrInfo();
2682       for (unsigned i = 0, e = ArgLocs.size(); i != e; ++i) {
2683         CCValAssign &VA = ArgLocs[i];
2684         SDValue Arg = OutVals[i];
2685         ISD::ArgFlagsTy Flags = Outs[i].Flags;
2686         if (VA.getLocInfo() == CCValAssign::Indirect)
2687           return false;
2688         if (!VA.isRegLoc()) {
2689           if (!MatchingStackOffset(Arg, VA.getLocMemOffset(), Flags,
2690                                    MFI, MRI, TII))
2691             return false;
2692         }
2693       }
2694     }
2695
2696     // If the tailcall address may be in a register, then make sure it's
2697     // possible to register allocate for it. In 32-bit, the call address can
2698     // only target EAX, EDX, or ECX since the tail call must be scheduled after
2699     // callee-saved registers are restored. These happen to be the same
2700     // registers used to pass 'inreg' arguments so watch out for those.
2701     if (!Subtarget->is64Bit() &&
2702         !isa<GlobalAddressSDNode>(Callee) &&
2703         !isa<ExternalSymbolSDNode>(Callee)) {
2704       unsigned NumInRegs = 0;
2705       for (unsigned i = 0, e = ArgLocs.size(); i != e; ++i) {
2706         CCValAssign &VA = ArgLocs[i];
2707         if (!VA.isRegLoc())
2708           continue;
2709         unsigned Reg = VA.getLocReg();
2710         switch (Reg) {
2711         default: break;
2712         case X86::EAX: case X86::EDX: case X86::ECX:
2713           if (++NumInRegs == 3)
2714             return false;
2715           break;
2716         }
2717       }
2718     }
2719   }
2720
2721   return true;
2722 }
2723
2724 FastISel *
2725 X86TargetLowering::createFastISel(FunctionLoweringInfo &funcInfo) const {
2726   return X86::createFastISel(funcInfo);
2727 }
2728
2729
2730 //===----------------------------------------------------------------------===//
2731 //                           Other Lowering Hooks
2732 //===----------------------------------------------------------------------===//
2733
2734 static bool MayFoldLoad(SDValue Op) {
2735   return Op.hasOneUse() && ISD::isNormalLoad(Op.getNode());
2736 }
2737
2738 static bool MayFoldIntoStore(SDValue Op) {
2739   return Op.hasOneUse() && ISD::isNormalStore(*Op.getNode()->use_begin());
2740 }
2741
2742 static bool isTargetShuffle(unsigned Opcode) {
2743   switch(Opcode) {
2744   default: return false;
2745   case X86ISD::PSHUFD:
2746   case X86ISD::PSHUFHW:
2747   case X86ISD::PSHUFLW:
2748   case X86ISD::SHUFPD:
2749   case X86ISD::PALIGN:
2750   case X86ISD::SHUFPS:
2751   case X86ISD::MOVLHPS:
2752   case X86ISD::MOVLHPD:
2753   case X86ISD::MOVHLPS:
2754   case X86ISD::MOVLPS:
2755   case X86ISD::MOVLPD:
2756   case X86ISD::MOVSHDUP:
2757   case X86ISD::MOVSLDUP:
2758   case X86ISD::MOVDDUP:
2759   case X86ISD::MOVSS:
2760   case X86ISD::MOVSD:
2761   case X86ISD::UNPCKLPS:
2762   case X86ISD::UNPCKLPD:
2763   case X86ISD::VUNPCKLPSY:
2764   case X86ISD::VUNPCKLPDY:
2765   case X86ISD::PUNPCKLWD:
2766   case X86ISD::PUNPCKLBW:
2767   case X86ISD::PUNPCKLDQ:
2768   case X86ISD::PUNPCKLQDQ:
2769   case X86ISD::UNPCKHPS:
2770   case X86ISD::UNPCKHPD:
2771   case X86ISD::VUNPCKHPSY:
2772   case X86ISD::VUNPCKHPDY:
2773   case X86ISD::PUNPCKHWD:
2774   case X86ISD::PUNPCKHBW:
2775   case X86ISD::PUNPCKHDQ:
2776   case X86ISD::PUNPCKHQDQ:
2777   case X86ISD::VPERMILPS:
2778   case X86ISD::VPERMILPSY:
2779   case X86ISD::VPERMILPD:
2780   case X86ISD::VPERMILPDY:
2781   case X86ISD::VPERM2F128:
2782     return true;
2783   }
2784   return false;
2785 }
2786
2787 static SDValue getTargetShuffleNode(unsigned Opc, DebugLoc dl, EVT VT,
2788                                                SDValue V1, SelectionDAG &DAG) {
2789   switch(Opc) {
2790   default: llvm_unreachable("Unknown x86 shuffle node");
2791   case X86ISD::MOVSHDUP:
2792   case X86ISD::MOVSLDUP:
2793   case X86ISD::MOVDDUP:
2794     return DAG.getNode(Opc, dl, VT, V1);
2795   }
2796
2797   return SDValue();
2798 }
2799
2800 static SDValue getTargetShuffleNode(unsigned Opc, DebugLoc dl, EVT VT,
2801                           SDValue V1, unsigned TargetMask, SelectionDAG &DAG) {
2802   switch(Opc) {
2803   default: llvm_unreachable("Unknown x86 shuffle node");
2804   case X86ISD::PSHUFD:
2805   case X86ISD::PSHUFHW:
2806   case X86ISD::PSHUFLW:
2807   case X86ISD::VPERMILPS:
2808   case X86ISD::VPERMILPSY:
2809   case X86ISD::VPERMILPD:
2810   case X86ISD::VPERMILPDY:
2811     return DAG.getNode(Opc, dl, VT, V1, DAG.getConstant(TargetMask, MVT::i8));
2812   }
2813
2814   return SDValue();
2815 }
2816
2817 static SDValue getTargetShuffleNode(unsigned Opc, DebugLoc dl, EVT VT,
2818                SDValue V1, SDValue V2, unsigned TargetMask, SelectionDAG &DAG) {
2819   switch(Opc) {
2820   default: llvm_unreachable("Unknown x86 shuffle node");
2821   case X86ISD::PALIGN:
2822   case X86ISD::SHUFPD:
2823   case X86ISD::SHUFPS:
2824   case X86ISD::VPERM2F128:
2825     return DAG.getNode(Opc, dl, VT, V1, V2,
2826                        DAG.getConstant(TargetMask, MVT::i8));
2827   }
2828   return SDValue();
2829 }
2830
2831 static SDValue getTargetShuffleNode(unsigned Opc, DebugLoc dl, EVT VT,
2832                                     SDValue V1, SDValue V2, SelectionDAG &DAG) {
2833   switch(Opc) {
2834   default: llvm_unreachable("Unknown x86 shuffle node");
2835   case X86ISD::MOVLHPS:
2836   case X86ISD::MOVLHPD:
2837   case X86ISD::MOVHLPS:
2838   case X86ISD::MOVLPS:
2839   case X86ISD::MOVLPD:
2840   case X86ISD::MOVSS:
2841   case X86ISD::MOVSD:
2842   case X86ISD::UNPCKLPS:
2843   case X86ISD::UNPCKLPD:
2844   case X86ISD::VUNPCKLPSY:
2845   case X86ISD::VUNPCKLPDY:
2846   case X86ISD::PUNPCKLWD:
2847   case X86ISD::PUNPCKLBW:
2848   case X86ISD::PUNPCKLDQ:
2849   case X86ISD::PUNPCKLQDQ:
2850   case X86ISD::UNPCKHPS:
2851   case X86ISD::UNPCKHPD:
2852   case X86ISD::VUNPCKHPSY:
2853   case X86ISD::VUNPCKHPDY:
2854   case X86ISD::PUNPCKHWD:
2855   case X86ISD::PUNPCKHBW:
2856   case X86ISD::PUNPCKHDQ:
2857   case X86ISD::PUNPCKHQDQ:
2858     return DAG.getNode(Opc, dl, VT, V1, V2);
2859   }
2860   return SDValue();
2861 }
2862
2863 SDValue X86TargetLowering::getReturnAddressFrameIndex(SelectionDAG &DAG) const {
2864   MachineFunction &MF = DAG.getMachineFunction();
2865   X86MachineFunctionInfo *FuncInfo = MF.getInfo<X86MachineFunctionInfo>();
2866   int ReturnAddrIndex = FuncInfo->getRAIndex();
2867
2868   if (ReturnAddrIndex == 0) {
2869     // Set up a frame object for the return address.
2870     uint64_t SlotSize = TD->getPointerSize();
2871     ReturnAddrIndex = MF.getFrameInfo()->CreateFixedObject(SlotSize, -SlotSize,
2872                                                            false);
2873     FuncInfo->setRAIndex(ReturnAddrIndex);
2874   }
2875
2876   return DAG.getFrameIndex(ReturnAddrIndex, getPointerTy());
2877 }
2878
2879
2880 bool X86::isOffsetSuitableForCodeModel(int64_t Offset, CodeModel::Model M,
2881                                        bool hasSymbolicDisplacement) {
2882   // Offset should fit into 32 bit immediate field.
2883   if (!isInt<32>(Offset))
2884     return false;
2885
2886   // If we don't have a symbolic displacement - we don't have any extra
2887   // restrictions.
2888   if (!hasSymbolicDisplacement)
2889     return true;
2890
2891   // FIXME: Some tweaks might be needed for medium code model.
2892   if (M != CodeModel::Small && M != CodeModel::Kernel)
2893     return false;
2894
2895   // For small code model we assume that latest object is 16MB before end of 31
2896   // bits boundary. We may also accept pretty large negative constants knowing
2897   // that all objects are in the positive half of address space.
2898   if (M == CodeModel::Small && Offset < 16*1024*1024)
2899     return true;
2900
2901   // For kernel code model we know that all object resist in the negative half
2902   // of 32bits address space. We may not accept negative offsets, since they may
2903   // be just off and we may accept pretty large positive ones.
2904   if (M == CodeModel::Kernel && Offset > 0)
2905     return true;
2906
2907   return false;
2908 }
2909
2910 /// isCalleePop - Determines whether the callee is required to pop its
2911 /// own arguments. Callee pop is necessary to support tail calls.
2912 bool X86::isCalleePop(CallingConv::ID CallingConv,
2913                       bool is64Bit, bool IsVarArg, bool TailCallOpt) {
2914   if (IsVarArg)
2915     return false;
2916
2917   switch (CallingConv) {
2918   default:
2919     return false;
2920   case CallingConv::X86_StdCall:
2921     return !is64Bit;
2922   case CallingConv::X86_FastCall:
2923     return !is64Bit;
2924   case CallingConv::X86_ThisCall:
2925     return !is64Bit;
2926   case CallingConv::Fast:
2927     return TailCallOpt;
2928   case CallingConv::GHC:
2929     return TailCallOpt;
2930   }
2931 }
2932
2933 /// TranslateX86CC - do a one to one translation of a ISD::CondCode to the X86
2934 /// specific condition code, returning the condition code and the LHS/RHS of the
2935 /// comparison to make.
2936 static unsigned TranslateX86CC(ISD::CondCode SetCCOpcode, bool isFP,
2937                                SDValue &LHS, SDValue &RHS, SelectionDAG &DAG) {
2938   if (!isFP) {
2939     if (ConstantSDNode *RHSC = dyn_cast<ConstantSDNode>(RHS)) {
2940       if (SetCCOpcode == ISD::SETGT && RHSC->isAllOnesValue()) {
2941         // X > -1   -> X == 0, jump !sign.
2942         RHS = DAG.getConstant(0, RHS.getValueType());
2943         return X86::COND_NS;
2944       } else if (SetCCOpcode == ISD::SETLT && RHSC->isNullValue()) {
2945         // X < 0   -> X == 0, jump on sign.
2946         return X86::COND_S;
2947       } else if (SetCCOpcode == ISD::SETLT && RHSC->getZExtValue() == 1) {
2948         // X < 1   -> X <= 0
2949         RHS = DAG.getConstant(0, RHS.getValueType());
2950         return X86::COND_LE;
2951       }
2952     }
2953
2954     switch (SetCCOpcode) {
2955     default: llvm_unreachable("Invalid integer condition!");
2956     case ISD::SETEQ:  return X86::COND_E;
2957     case ISD::SETGT:  return X86::COND_G;
2958     case ISD::SETGE:  return X86::COND_GE;
2959     case ISD::SETLT:  return X86::COND_L;
2960     case ISD::SETLE:  return X86::COND_LE;
2961     case ISD::SETNE:  return X86::COND_NE;
2962     case ISD::SETULT: return X86::COND_B;
2963     case ISD::SETUGT: return X86::COND_A;
2964     case ISD::SETULE: return X86::COND_BE;
2965     case ISD::SETUGE: return X86::COND_AE;
2966     }
2967   }
2968
2969   // First determine if it is required or is profitable to flip the operands.
2970
2971   // If LHS is a foldable load, but RHS is not, flip the condition.
2972   if (ISD::isNON_EXTLoad(LHS.getNode()) &&
2973       !ISD::isNON_EXTLoad(RHS.getNode())) {
2974     SetCCOpcode = getSetCCSwappedOperands(SetCCOpcode);
2975     std::swap(LHS, RHS);
2976   }
2977
2978   switch (SetCCOpcode) {
2979   default: break;
2980   case ISD::SETOLT:
2981   case ISD::SETOLE:
2982   case ISD::SETUGT:
2983   case ISD::SETUGE:
2984     std::swap(LHS, RHS);
2985     break;
2986   }
2987
2988   // On a floating point condition, the flags are set as follows:
2989   // ZF  PF  CF   op
2990   //  0 | 0 | 0 | X > Y
2991   //  0 | 0 | 1 | X < Y
2992   //  1 | 0 | 0 | X == Y
2993   //  1 | 1 | 1 | unordered
2994   switch (SetCCOpcode) {
2995   default: llvm_unreachable("Condcode should be pre-legalized away");
2996   case ISD::SETUEQ:
2997   case ISD::SETEQ:   return X86::COND_E;
2998   case ISD::SETOLT:              // flipped
2999   case ISD::SETOGT:
3000   case ISD::SETGT:   return X86::COND_A;
3001   case ISD::SETOLE:              // flipped
3002   case ISD::SETOGE:
3003   case ISD::SETGE:   return X86::COND_AE;
3004   case ISD::SETUGT:              // flipped
3005   case ISD::SETULT:
3006   case ISD::SETLT:   return X86::COND_B;
3007   case ISD::SETUGE:              // flipped
3008   case ISD::SETULE:
3009   case ISD::SETLE:   return X86::COND_BE;
3010   case ISD::SETONE:
3011   case ISD::SETNE:   return X86::COND_NE;
3012   case ISD::SETUO:   return X86::COND_P;
3013   case ISD::SETO:    return X86::COND_NP;
3014   case ISD::SETOEQ:
3015   case ISD::SETUNE:  return X86::COND_INVALID;
3016   }
3017 }
3018
3019 /// hasFPCMov - is there a floating point cmov for the specific X86 condition
3020 /// code. Current x86 isa includes the following FP cmov instructions:
3021 /// fcmovb, fcomvbe, fcomve, fcmovu, fcmovae, fcmova, fcmovne, fcmovnu.
3022 static bool hasFPCMov(unsigned X86CC) {
3023   switch (X86CC) {
3024   default:
3025     return false;
3026   case X86::COND_B:
3027   case X86::COND_BE:
3028   case X86::COND_E:
3029   case X86::COND_P:
3030   case X86::COND_A:
3031   case X86::COND_AE:
3032   case X86::COND_NE:
3033   case X86::COND_NP:
3034     return true;
3035   }
3036 }
3037
3038 /// isFPImmLegal - Returns true if the target can instruction select the
3039 /// specified FP immediate natively. If false, the legalizer will
3040 /// materialize the FP immediate as a load from a constant pool.
3041 bool X86TargetLowering::isFPImmLegal(const APFloat &Imm, EVT VT) const {
3042   for (unsigned i = 0, e = LegalFPImmediates.size(); i != e; ++i) {
3043     if (Imm.bitwiseIsEqual(LegalFPImmediates[i]))
3044       return true;
3045   }
3046   return false;
3047 }
3048
3049 /// isUndefOrInRange - Return true if Val is undef or if its value falls within
3050 /// the specified range (L, H].
3051 static bool isUndefOrInRange(int Val, int Low, int Hi) {
3052   return (Val < 0) || (Val >= Low && Val < Hi);
3053 }
3054
3055 /// isUndefOrInRange - Return true if every element in Mask, begining
3056 /// from position Pos and ending in Pos+Size, falls within the specified
3057 /// range (L, L+Pos]. or is undef.
3058 static bool isUndefOrInRange(const SmallVectorImpl<int> &Mask,
3059                              int Pos, int Size, int Low, int Hi) {
3060   for (int i = Pos, e = Pos+Size; i != e; ++i)
3061     if (!isUndefOrInRange(Mask[i], Low, Hi))
3062       return false;
3063   return true;
3064 }
3065
3066 /// isUndefOrEqual - Val is either less than zero (undef) or equal to the
3067 /// specified value.
3068 static bool isUndefOrEqual(int Val, int CmpVal) {
3069   if (Val < 0 || Val == CmpVal)
3070     return true;
3071   return false;
3072 }
3073
3074 /// isSequentialOrUndefInRange - Return true if every element in Mask, begining
3075 /// from position Pos and ending in Pos+Size, falls within the specified
3076 /// sequential range (L, L+Pos]. or is undef.
3077 static bool isSequentialOrUndefInRange(const SmallVectorImpl<int> &Mask,
3078                                        int Pos, int Size, int Low) {
3079   for (int i = Pos, e = Pos+Size; i != e; ++i, ++Low)
3080     if (!isUndefOrEqual(Mask[i], Low))
3081       return false;
3082   return true;
3083 }
3084
3085 /// isPSHUFDMask - Return true if the node specifies a shuffle of elements that
3086 /// is suitable for input to PSHUFD or PSHUFW.  That is, it doesn't reference
3087 /// the second operand.
3088 static bool isPSHUFDMask(const SmallVectorImpl<int> &Mask, EVT VT) {
3089   if (VT == MVT::v4f32 || VT == MVT::v4i32 )
3090     return (Mask[0] < 4 && Mask[1] < 4 && Mask[2] < 4 && Mask[3] < 4);
3091   if (VT == MVT::v2f64 || VT == MVT::v2i64)
3092     return (Mask[0] < 2 && Mask[1] < 2);
3093   return false;
3094 }
3095
3096 bool X86::isPSHUFDMask(ShuffleVectorSDNode *N) {
3097   SmallVector<int, 8> M;
3098   N->getMask(M);
3099   return ::isPSHUFDMask(M, N->getValueType(0));
3100 }
3101
3102 /// isPSHUFHWMask - Return true if the node specifies a shuffle of elements that
3103 /// is suitable for input to PSHUFHW.
3104 static bool isPSHUFHWMask(const SmallVectorImpl<int> &Mask, EVT VT) {
3105   if (VT != MVT::v8i16)
3106     return false;
3107
3108   // Lower quadword copied in order or undef.
3109   for (int i = 0; i != 4; ++i)
3110     if (Mask[i] >= 0 && Mask[i] != i)
3111       return false;
3112
3113   // Upper quadword shuffled.
3114   for (int i = 4; i != 8; ++i)
3115     if (Mask[i] >= 0 && (Mask[i] < 4 || Mask[i] > 7))
3116       return false;
3117
3118   return true;
3119 }
3120
3121 bool X86::isPSHUFHWMask(ShuffleVectorSDNode *N) {
3122   SmallVector<int, 8> M;
3123   N->getMask(M);
3124   return ::isPSHUFHWMask(M, N->getValueType(0));
3125 }
3126
3127 /// isPSHUFLWMask - Return true if the node specifies a shuffle of elements that
3128 /// is suitable for input to PSHUFLW.
3129 static bool isPSHUFLWMask(const SmallVectorImpl<int> &Mask, EVT VT) {
3130   if (VT != MVT::v8i16)
3131     return false;
3132
3133   // Upper quadword copied in order.
3134   for (int i = 4; i != 8; ++i)
3135     if (Mask[i] >= 0 && Mask[i] != i)
3136       return false;
3137
3138   // Lower quadword shuffled.
3139   for (int i = 0; i != 4; ++i)
3140     if (Mask[i] >= 4)
3141       return false;
3142
3143   return true;
3144 }
3145
3146 bool X86::isPSHUFLWMask(ShuffleVectorSDNode *N) {
3147   SmallVector<int, 8> M;
3148   N->getMask(M);
3149   return ::isPSHUFLWMask(M, N->getValueType(0));
3150 }
3151
3152 /// isPALIGNRMask - Return true if the node specifies a shuffle of elements that
3153 /// is suitable for input to PALIGNR.
3154 static bool isPALIGNRMask(const SmallVectorImpl<int> &Mask, EVT VT,
3155                           bool hasSSSE3) {
3156   int i, e = VT.getVectorNumElements();
3157   if (VT.getSizeInBits() != 128 && VT.getSizeInBits() != 64)
3158     return false;
3159
3160   // Do not handle v2i64 / v2f64 shuffles with palignr.
3161   if (e < 4 || !hasSSSE3)
3162     return false;
3163
3164   for (i = 0; i != e; ++i)
3165     if (Mask[i] >= 0)
3166       break;
3167
3168   // All undef, not a palignr.
3169   if (i == e)
3170     return false;
3171
3172   // Make sure we're shifting in the right direction.
3173   if (Mask[i] <= i)
3174     return false;
3175
3176   int s = Mask[i] - i;
3177
3178   // Check the rest of the elements to see if they are consecutive.
3179   for (++i; i != e; ++i) {
3180     int m = Mask[i];
3181     if (m >= 0 && m != s+i)
3182       return false;
3183   }
3184   return true;
3185 }
3186
3187 /// isVSHUFPSYMask - Return true if the specified VECTOR_SHUFFLE operand
3188 /// specifies a shuffle of elements that is suitable for input to 256-bit
3189 /// VSHUFPSY.
3190 static bool isVSHUFPSYMask(const SmallVectorImpl<int> &Mask, EVT VT,
3191                           const X86Subtarget *Subtarget) {
3192   int NumElems = VT.getVectorNumElements();
3193
3194   if (!Subtarget->hasAVX() || VT.getSizeInBits() != 256)
3195     return false;
3196
3197   if (NumElems != 8)
3198     return false;
3199
3200   // VSHUFPSY divides the resulting vector into 4 chunks.
3201   // The sources are also splitted into 4 chunks, and each destination
3202   // chunk must come from a different source chunk.
3203   //
3204   //  SRC1 =>   X7    X6    X5    X4    X3    X2    X1    X0
3205   //  SRC2 =>   Y7    Y6    Y5    Y4    Y3    Y2    Y1    Y9
3206   //
3207   //  DST  =>  Y7..Y4,   Y7..Y4,   X7..X4,   X7..X4,
3208   //           Y3..Y0,   Y3..Y0,   X3..X0,   X3..X0
3209   //
3210   int QuarterSize = NumElems/4;
3211   int HalfSize = QuarterSize*2;
3212   for (int i = 0; i < QuarterSize; ++i)
3213     if (!isUndefOrInRange(Mask[i], 0, HalfSize))
3214       return false;
3215   for (int i = QuarterSize; i < QuarterSize*2; ++i)
3216     if (!isUndefOrInRange(Mask[i], NumElems, NumElems+HalfSize))
3217       return false;
3218
3219   // The mask of the second half must be the same as the first but with
3220   // the appropriate offsets. This works in the same way as VPERMILPS
3221   // works with masks.
3222   for (int i = QuarterSize*2; i < QuarterSize*3; ++i) {
3223     if (!isUndefOrInRange(Mask[i], HalfSize, NumElems))
3224       return false;
3225     int FstHalfIdx = i-HalfSize;
3226     if (Mask[FstHalfIdx] < 0)
3227       continue;
3228     if (!isUndefOrEqual(Mask[i], Mask[FstHalfIdx]+HalfSize))
3229       return false;
3230   }
3231   for (int i = QuarterSize*3; i < NumElems; ++i) {
3232     if (!isUndefOrInRange(Mask[i], NumElems+HalfSize, NumElems*2))
3233       return false;
3234     int FstHalfIdx = i-HalfSize;
3235     if (Mask[FstHalfIdx] < 0)
3236       continue;
3237     if (!isUndefOrEqual(Mask[i], Mask[FstHalfIdx]+HalfSize))
3238       return false;
3239
3240   }
3241
3242   return true;
3243 }
3244
3245 /// getShuffleVSHUFPSYImmediate - Return the appropriate immediate to shuffle
3246 /// the specified VECTOR_MASK mask with VSHUFPSY instruction.
3247 static unsigned getShuffleVSHUFPSYImmediate(SDNode *N) {
3248   ShuffleVectorSDNode *SVOp = cast<ShuffleVectorSDNode>(N);
3249   EVT VT = SVOp->getValueType(0);
3250   int NumElems = VT.getVectorNumElements();
3251
3252   assert(NumElems == 8 && VT.getSizeInBits() == 256 &&
3253          "Only supports v8i32 and v8f32 types");
3254
3255   int HalfSize = NumElems/2;
3256   unsigned Mask = 0;
3257   for (int i = 0; i != NumElems ; ++i) {
3258     if (SVOp->getMaskElt(i) < 0)
3259       continue;
3260     // The mask of the first half must be equal to the second one.
3261     unsigned Shamt = (i%HalfSize)*2;
3262     unsigned Elt = SVOp->getMaskElt(i) % HalfSize;
3263     Mask |= Elt << Shamt;
3264   }
3265
3266   return Mask;
3267 }
3268
3269 /// isVSHUFPDYMask - Return true if the specified VECTOR_SHUFFLE operand
3270 /// specifies a shuffle of elements that is suitable for input to 256-bit
3271 /// VSHUFPDY. This shuffle doesn't have the same restriction as the PS
3272 /// version and the mask of the second half isn't binded with the first
3273 /// one.
3274 static bool isVSHUFPDYMask(const SmallVectorImpl<int> &Mask, EVT VT,
3275                            const X86Subtarget *Subtarget) {
3276   int NumElems = VT.getVectorNumElements();
3277
3278   if (!Subtarget->hasAVX() || VT.getSizeInBits() != 256)
3279     return false;
3280
3281   if (NumElems != 4)
3282     return false;
3283
3284   // VSHUFPSY divides the resulting vector into 4 chunks.
3285   // The sources are also splitted into 4 chunks, and each destination
3286   // chunk must come from a different source chunk.
3287   //
3288   //  SRC1 =>      X3       X2       X1       X0
3289   //  SRC2 =>      Y3       Y2       Y1       Y0
3290   //
3291   //  DST  =>  Y2..Y3,  X2..X3,  Y1..Y0,  X1..X0
3292   //
3293   int QuarterSize = NumElems/4;
3294   int HalfSize = QuarterSize*2;
3295   for (int i = 0; i < QuarterSize; ++i)
3296     if (!isUndefOrInRange(Mask[i], 0, HalfSize))
3297       return false;
3298   for (int i = QuarterSize; i < QuarterSize*2; ++i)
3299     if (!isUndefOrInRange(Mask[i], NumElems, NumElems+HalfSize))
3300       return false;
3301   for (int i = QuarterSize*2; i < QuarterSize*3; ++i)
3302     if (!isUndefOrInRange(Mask[i], HalfSize, NumElems))
3303       return false;
3304   for (int i = QuarterSize*3; i < NumElems; ++i)
3305     if (!isUndefOrInRange(Mask[i], NumElems+HalfSize, NumElems*2))
3306       return false;
3307
3308   return true;
3309 }
3310
3311 /// getShuffleVSHUFPDYImmediate - Return the appropriate immediate to shuffle
3312 /// the specified VECTOR_MASK mask with VSHUFPDY instruction.
3313 static unsigned getShuffleVSHUFPDYImmediate(SDNode *N) {
3314   ShuffleVectorSDNode *SVOp = cast<ShuffleVectorSDNode>(N);
3315   EVT VT = SVOp->getValueType(0);
3316   int NumElems = VT.getVectorNumElements();
3317
3318   assert(NumElems == 4 && VT.getSizeInBits() == 256 &&
3319          "Only supports v4i64 and v4f64 types");
3320
3321   int HalfSize = NumElems/2;
3322   unsigned Mask = 0;
3323   for (int i = 0; i != NumElems ; ++i) {
3324     if (SVOp->getMaskElt(i) < 0)
3325       continue;
3326     int Elt = SVOp->getMaskElt(i) % HalfSize;
3327     Mask |= Elt << i;
3328   }
3329
3330   return Mask;
3331 }
3332
3333 /// isSHUFPMask - Return true if the specified VECTOR_SHUFFLE operand
3334 /// specifies a shuffle of elements that is suitable for input to 128-bit
3335 /// SHUFPS and SHUFPD.
3336 static bool isSHUFPMask(const SmallVectorImpl<int> &Mask, EVT VT) {
3337   int NumElems = VT.getVectorNumElements();
3338
3339   if (VT.getSizeInBits() != 128)
3340     return false;
3341
3342   if (NumElems != 2 && NumElems != 4)
3343     return false;
3344
3345   int Half = NumElems / 2;
3346   for (int i = 0; i < Half; ++i)
3347     if (!isUndefOrInRange(Mask[i], 0, NumElems))
3348       return false;
3349   for (int i = Half; i < NumElems; ++i)
3350     if (!isUndefOrInRange(Mask[i], NumElems, NumElems*2))
3351       return false;
3352
3353   return true;
3354 }
3355
3356 bool X86::isSHUFPMask(ShuffleVectorSDNode *N) {
3357   SmallVector<int, 8> M;
3358   N->getMask(M);
3359   return ::isSHUFPMask(M, N->getValueType(0));
3360 }
3361
3362 /// isCommutedSHUFP - Returns true if the shuffle mask is exactly
3363 /// the reverse of what x86 shuffles want. x86 shuffles requires the lower
3364 /// half elements to come from vector 1 (which would equal the dest.) and
3365 /// the upper half to come from vector 2.
3366 static bool isCommutedSHUFPMask(const SmallVectorImpl<int> &Mask, EVT VT) {
3367   int NumElems = VT.getVectorNumElements();
3368
3369   if (NumElems != 2 && NumElems != 4)
3370     return false;
3371
3372   int Half = NumElems / 2;
3373   for (int i = 0; i < Half; ++i)
3374     if (!isUndefOrInRange(Mask[i], NumElems, NumElems*2))
3375       return false;
3376   for (int i = Half; i < NumElems; ++i)
3377     if (!isUndefOrInRange(Mask[i], 0, NumElems))
3378       return false;
3379   return true;
3380 }
3381
3382 static bool isCommutedSHUFP(ShuffleVectorSDNode *N) {
3383   SmallVector<int, 8> M;
3384   N->getMask(M);
3385   return isCommutedSHUFPMask(M, N->getValueType(0));
3386 }
3387
3388 /// isMOVHLPSMask - Return true if the specified VECTOR_SHUFFLE operand
3389 /// specifies a shuffle of elements that is suitable for input to MOVHLPS.
3390 bool X86::isMOVHLPSMask(ShuffleVectorSDNode *N) {
3391   EVT VT = N->getValueType(0);
3392   unsigned NumElems = VT.getVectorNumElements();
3393
3394   if (VT.getSizeInBits() != 128)
3395     return false;
3396
3397   if (NumElems != 4)
3398     return false;
3399
3400   // Expect bit0 == 6, bit1 == 7, bit2 == 2, bit3 == 3
3401   return isUndefOrEqual(N->getMaskElt(0), 6) &&
3402          isUndefOrEqual(N->getMaskElt(1), 7) &&
3403          isUndefOrEqual(N->getMaskElt(2), 2) &&
3404          isUndefOrEqual(N->getMaskElt(3), 3);
3405 }
3406
3407 /// isMOVHLPS_v_undef_Mask - Special case of isMOVHLPSMask for canonical form
3408 /// of vector_shuffle v, v, <2, 3, 2, 3>, i.e. vector_shuffle v, undef,
3409 /// <2, 3, 2, 3>
3410 bool X86::isMOVHLPS_v_undef_Mask(ShuffleVectorSDNode *N) {
3411   EVT VT = N->getValueType(0);
3412   unsigned NumElems = VT.getVectorNumElements();
3413
3414   if (VT.getSizeInBits() != 128)
3415     return false;
3416
3417   if (NumElems != 4)
3418     return false;
3419
3420   return isUndefOrEqual(N->getMaskElt(0), 2) &&
3421          isUndefOrEqual(N->getMaskElt(1), 3) &&
3422          isUndefOrEqual(N->getMaskElt(2), 2) &&
3423          isUndefOrEqual(N->getMaskElt(3), 3);
3424 }
3425
3426 /// isMOVLPMask - Return true if the specified VECTOR_SHUFFLE operand
3427 /// specifies a shuffle of elements that is suitable for input to MOVLP{S|D}.
3428 bool X86::isMOVLPMask(ShuffleVectorSDNode *N) {
3429   unsigned NumElems = N->getValueType(0).getVectorNumElements();
3430
3431   if (NumElems != 2 && NumElems != 4)
3432     return false;
3433
3434   for (unsigned i = 0; i < NumElems/2; ++i)
3435     if (!isUndefOrEqual(N->getMaskElt(i), i + NumElems))
3436       return false;
3437
3438   for (unsigned i = NumElems/2; i < NumElems; ++i)
3439     if (!isUndefOrEqual(N->getMaskElt(i), i))
3440       return false;
3441
3442   return true;
3443 }
3444
3445 /// isMOVLHPSMask - Return true if the specified VECTOR_SHUFFLE operand
3446 /// specifies a shuffle of elements that is suitable for input to MOVLHPS.
3447 bool X86::isMOVLHPSMask(ShuffleVectorSDNode *N) {
3448   unsigned NumElems = N->getValueType(0).getVectorNumElements();
3449
3450   if ((NumElems != 2 && NumElems != 4)
3451       || N->getValueType(0).getSizeInBits() > 128)
3452     return false;
3453
3454   for (unsigned i = 0; i < NumElems/2; ++i)
3455     if (!isUndefOrEqual(N->getMaskElt(i), i))
3456       return false;
3457
3458   for (unsigned i = 0; i < NumElems/2; ++i)
3459     if (!isUndefOrEqual(N->getMaskElt(i + NumElems/2), i + NumElems))
3460       return false;
3461
3462   return true;
3463 }
3464
3465 /// isUNPCKLMask - Return true if the specified VECTOR_SHUFFLE operand
3466 /// specifies a shuffle of elements that is suitable for input to UNPCKL.
3467 static bool isUNPCKLMask(const SmallVectorImpl<int> &Mask, EVT VT,
3468                          bool V2IsSplat = false) {
3469   int NumElts = VT.getVectorNumElements();
3470
3471   assert((VT.is128BitVector() || VT.is256BitVector()) &&
3472          "Unsupported vector type for unpckh");
3473
3474   if (VT.getSizeInBits() == 256 && NumElts != 4 && NumElts != 8)
3475     return false;
3476
3477   // Handle 128 and 256-bit vector lengths. AVX defines UNPCK* to operate
3478   // independently on 128-bit lanes.
3479   unsigned NumLanes = VT.getSizeInBits()/128;
3480   unsigned NumLaneElts = NumElts/NumLanes;
3481
3482   unsigned Start = 0;
3483   unsigned End = NumLaneElts;
3484   for (unsigned s = 0; s < NumLanes; ++s) {
3485     for (unsigned i = Start, j = s * NumLaneElts;
3486          i != End;
3487          i += 2, ++j) {
3488       int BitI  = Mask[i];
3489       int BitI1 = Mask[i+1];
3490       if (!isUndefOrEqual(BitI, j))
3491         return false;
3492       if (V2IsSplat) {
3493         if (!isUndefOrEqual(BitI1, NumElts))
3494           return false;
3495       } else {
3496         if (!isUndefOrEqual(BitI1, j + NumElts))
3497           return false;
3498       }
3499     }
3500     // Process the next 128 bits.
3501     Start += NumLaneElts;
3502     End += NumLaneElts;
3503   }
3504
3505   return true;
3506 }
3507
3508 bool X86::isUNPCKLMask(ShuffleVectorSDNode *N, bool V2IsSplat) {
3509   SmallVector<int, 8> M;
3510   N->getMask(M);
3511   return ::isUNPCKLMask(M, N->getValueType(0), V2IsSplat);
3512 }
3513
3514 /// isUNPCKHMask - Return true if the specified VECTOR_SHUFFLE operand
3515 /// specifies a shuffle of elements that is suitable for input to UNPCKH.
3516 static bool isUNPCKHMask(const SmallVectorImpl<int> &Mask, EVT VT,
3517                          bool V2IsSplat = false) {
3518   int NumElts = VT.getVectorNumElements();
3519
3520   assert((VT.is128BitVector() || VT.is256BitVector()) &&
3521          "Unsupported vector type for unpckh");
3522
3523   if (VT.getSizeInBits() == 256 && NumElts != 4 && NumElts != 8)
3524     return false;
3525
3526   // Handle 128 and 256-bit vector lengths. AVX defines UNPCK* to operate
3527   // independently on 128-bit lanes.
3528   unsigned NumLanes = VT.getSizeInBits()/128;
3529   unsigned NumLaneElts = NumElts/NumLanes;
3530
3531   unsigned Start = 0;
3532   unsigned End = NumLaneElts;
3533   for (unsigned l = 0; l != NumLanes; ++l) {
3534     for (unsigned i = Start, j = (l*NumLaneElts)+NumLaneElts/2;
3535                              i != End; i += 2, ++j) {
3536       int BitI  = Mask[i];
3537       int BitI1 = Mask[i+1];
3538       if (!isUndefOrEqual(BitI, j))
3539         return false;
3540       if (V2IsSplat) {
3541         if (isUndefOrEqual(BitI1, NumElts))
3542           return false;
3543       } else {
3544         if (!isUndefOrEqual(BitI1, j+NumElts))
3545           return false;
3546       }
3547     }
3548     // Process the next 128 bits.
3549     Start += NumLaneElts;
3550     End += NumLaneElts;
3551   }
3552   return true;
3553 }
3554
3555 bool X86::isUNPCKHMask(ShuffleVectorSDNode *N, bool V2IsSplat) {
3556   SmallVector<int, 8> M;
3557   N->getMask(M);
3558   return ::isUNPCKHMask(M, N->getValueType(0), V2IsSplat);
3559 }
3560
3561 /// isUNPCKL_v_undef_Mask - Special case of isUNPCKLMask for canonical form
3562 /// of vector_shuffle v, v, <0, 4, 1, 5>, i.e. vector_shuffle v, undef,
3563 /// <0, 0, 1, 1>
3564 static bool isUNPCKL_v_undef_Mask(const SmallVectorImpl<int> &Mask, EVT VT) {
3565   int NumElems = VT.getVectorNumElements();
3566   if (NumElems != 2 && NumElems != 4 && NumElems != 8 && NumElems != 16)
3567     return false;
3568
3569   // For 256-bit i64/f64, use MOVDDUPY instead, so reject the matching pattern
3570   // FIXME: Need a better way to get rid of this, there's no latency difference
3571   // between UNPCKLPD and MOVDDUP, the later should always be checked first and
3572   // the former later. We should also remove the "_undef" special mask.
3573   if (NumElems == 4 && VT.getSizeInBits() == 256)
3574     return false;
3575
3576   // Handle 128 and 256-bit vector lengths. AVX defines UNPCK* to operate
3577   // independently on 128-bit lanes.
3578   unsigned NumLanes = VT.getSizeInBits() / 128;
3579   unsigned NumLaneElts = NumElems / NumLanes;
3580
3581   for (unsigned s = 0; s < NumLanes; ++s) {
3582     for (unsigned i = s * NumLaneElts, j = s * NumLaneElts;
3583          i != NumLaneElts * (s + 1);
3584          i += 2, ++j) {
3585       int BitI  = Mask[i];
3586       int BitI1 = Mask[i+1];
3587
3588       if (!isUndefOrEqual(BitI, j))
3589         return false;
3590       if (!isUndefOrEqual(BitI1, j))
3591         return false;
3592     }
3593   }
3594
3595   return true;
3596 }
3597
3598 bool X86::isUNPCKL_v_undef_Mask(ShuffleVectorSDNode *N) {
3599   SmallVector<int, 8> M;
3600   N->getMask(M);
3601   return ::isUNPCKL_v_undef_Mask(M, N->getValueType(0));
3602 }
3603
3604 /// isUNPCKH_v_undef_Mask - Special case of isUNPCKHMask for canonical form
3605 /// of vector_shuffle v, v, <2, 6, 3, 7>, i.e. vector_shuffle v, undef,
3606 /// <2, 2, 3, 3>
3607 static bool isUNPCKH_v_undef_Mask(const SmallVectorImpl<int> &Mask, EVT VT) {
3608   int NumElems = VT.getVectorNumElements();
3609   if (NumElems != 2 && NumElems != 4 && NumElems != 8 && NumElems != 16)
3610     return false;
3611
3612   for (int i = 0, j = NumElems / 2; i != NumElems; i += 2, ++j) {
3613     int BitI  = Mask[i];
3614     int BitI1 = Mask[i+1];
3615     if (!isUndefOrEqual(BitI, j))
3616       return false;
3617     if (!isUndefOrEqual(BitI1, j))
3618       return false;
3619   }
3620   return true;
3621 }
3622
3623 bool X86::isUNPCKH_v_undef_Mask(ShuffleVectorSDNode *N) {
3624   SmallVector<int, 8> M;
3625   N->getMask(M);
3626   return ::isUNPCKH_v_undef_Mask(M, N->getValueType(0));
3627 }
3628
3629 /// isMOVLMask - Return true if the specified VECTOR_SHUFFLE operand
3630 /// specifies a shuffle of elements that is suitable for input to MOVSS,
3631 /// MOVSD, and MOVD, i.e. setting the lowest element.
3632 static bool isMOVLMask(const SmallVectorImpl<int> &Mask, EVT VT) {
3633   if (VT.getVectorElementType().getSizeInBits() < 32)
3634     return false;
3635
3636   int NumElts = VT.getVectorNumElements();
3637
3638   if (!isUndefOrEqual(Mask[0], NumElts))
3639     return false;
3640
3641   for (int i = 1; i < NumElts; ++i)
3642     if (!isUndefOrEqual(Mask[i], i))
3643       return false;
3644
3645   return true;
3646 }
3647
3648 bool X86::isMOVLMask(ShuffleVectorSDNode *N) {
3649   SmallVector<int, 8> M;
3650   N->getMask(M);
3651   return ::isMOVLMask(M, N->getValueType(0));
3652 }
3653
3654 /// isVPERM2F128Mask - Match 256-bit shuffles where the elements are considered
3655 /// as permutations between 128-bit chunks or halves. As an example: this
3656 /// shuffle bellow:
3657 ///   vector_shuffle <4, 5, 6, 7, 12, 13, 14, 15>
3658 /// The first half comes from the second half of V1 and the second half from the
3659 /// the second half of V2.
3660 static bool isVPERM2F128Mask(const SmallVectorImpl<int> &Mask, EVT VT,
3661                              const X86Subtarget *Subtarget) {
3662   if (!Subtarget->hasAVX() || VT.getSizeInBits() != 256)
3663     return false;
3664
3665   // The shuffle result is divided into half A and half B. In total the two
3666   // sources have 4 halves, namely: C, D, E, F. The final values of A and
3667   // B must come from C, D, E or F.
3668   int HalfSize = VT.getVectorNumElements()/2;
3669   bool MatchA = false, MatchB = false;
3670
3671   // Check if A comes from one of C, D, E, F.
3672   for (int Half = 0; Half < 4; ++Half) {
3673     if (isSequentialOrUndefInRange(Mask, 0, HalfSize, Half*HalfSize)) {
3674       MatchA = true;
3675       break;
3676     }
3677   }
3678
3679   // Check if B comes from one of C, D, E, F.
3680   for (int Half = 0; Half < 4; ++Half) {
3681     if (isSequentialOrUndefInRange(Mask, HalfSize, HalfSize, Half*HalfSize)) {
3682       MatchB = true;
3683       break;
3684     }
3685   }
3686
3687   return MatchA && MatchB;
3688 }
3689
3690 /// getShuffleVPERM2F128Immediate - Return the appropriate immediate to shuffle
3691 /// the specified VECTOR_MASK mask with VPERM2F128 instructions.
3692 static unsigned getShuffleVPERM2F128Immediate(SDNode *N) {
3693   ShuffleVectorSDNode *SVOp = cast<ShuffleVectorSDNode>(N);
3694   EVT VT = SVOp->getValueType(0);
3695
3696   int HalfSize = VT.getVectorNumElements()/2;
3697
3698   int FstHalf = 0, SndHalf = 0;
3699   for (int i = 0; i < HalfSize; ++i) {
3700     if (SVOp->getMaskElt(i) > 0) {
3701       FstHalf = SVOp->getMaskElt(i)/HalfSize;
3702       break;
3703     }
3704   }
3705   for (int i = HalfSize; i < HalfSize*2; ++i) {
3706     if (SVOp->getMaskElt(i) > 0) {
3707       SndHalf = SVOp->getMaskElt(i)/HalfSize;
3708       break;
3709     }
3710   }
3711
3712   return (FstHalf | (SndHalf << 4));
3713 }
3714
3715 /// isVPERMILPDMask - Return true if the specified VECTOR_SHUFFLE operand
3716 /// specifies a shuffle of elements that is suitable for input to VPERMILPD*.
3717 /// Note that VPERMIL mask matching is different depending whether theunderlying
3718 /// type is 32 or 64. In the VPERMILPS the high half of the mask should point
3719 /// to the same elements of the low, but to the higher half of the source.
3720 /// In VPERMILPD the two lanes could be shuffled independently of each other
3721 /// with the same restriction that lanes can't be crossed.
3722 static bool isVPERMILPDMask(const SmallVectorImpl<int> &Mask, EVT VT,
3723                             const X86Subtarget *Subtarget) {
3724   int NumElts = VT.getVectorNumElements();
3725   int NumLanes = VT.getSizeInBits()/128;
3726
3727   if (!Subtarget->hasAVX())
3728     return false;
3729
3730   // Match any permutation of 128-bit vector with 64-bit types
3731   if (NumLanes == 1 && NumElts != 2)
3732     return false;
3733
3734   // Only match 256-bit with 32 types
3735   if (VT.getSizeInBits() == 256 && NumElts != 4)
3736     return false;
3737
3738   // The mask on the high lane is independent of the low. Both can match
3739   // any element in inside its own lane, but can't cross.
3740   int LaneSize = NumElts/NumLanes;
3741   for (int l = 0; l < NumLanes; ++l)
3742     for (int i = l*LaneSize; i < LaneSize*(l+1); ++i) {
3743       int LaneStart = l*LaneSize;
3744       if (!isUndefOrInRange(Mask[i], LaneStart, LaneStart+LaneSize))
3745         return false;
3746     }
3747
3748   return true;
3749 }
3750
3751 /// isVPERMILPSMask - Return true if the specified VECTOR_SHUFFLE operand
3752 /// specifies a shuffle of elements that is suitable for input to VPERMILPS*.
3753 /// Note that VPERMIL mask matching is different depending whether theunderlying
3754 /// type is 32 or 64. In the VPERMILPS the high half of the mask should point
3755 /// to the same elements of the low, but to the higher half of the source.
3756 /// In VPERMILPD the two lanes could be shuffled independently of each other
3757 /// with the same restriction that lanes can't be crossed.
3758 static bool isVPERMILPSMask(const SmallVectorImpl<int> &Mask, EVT VT,
3759                             const X86Subtarget *Subtarget) {
3760   unsigned NumElts = VT.getVectorNumElements();
3761   unsigned NumLanes = VT.getSizeInBits()/128;
3762
3763   if (!Subtarget->hasAVX())
3764     return false;
3765
3766   // Match any permutation of 128-bit vector with 32-bit types
3767   if (NumLanes == 1 && NumElts != 4)
3768     return false;
3769
3770   // Only match 256-bit with 32 types
3771   if (VT.getSizeInBits() == 256 && NumElts != 8)
3772     return false;
3773
3774   // The mask on the high lane should be the same as the low. Actually,
3775   // they can differ if any of the corresponding index in a lane is undef
3776   // and the other stays in range.
3777   int LaneSize = NumElts/NumLanes;
3778   for (int i = 0; i < LaneSize; ++i) {
3779     int HighElt = i+LaneSize;
3780     bool HighValid = isUndefOrInRange(Mask[HighElt], LaneSize, NumElts);
3781     bool LowValid = isUndefOrInRange(Mask[i], 0, LaneSize);
3782
3783     if (!HighValid || !LowValid)
3784       return false;
3785     if (Mask[i] < 0 || Mask[HighElt] < 0)
3786       continue;
3787     if (Mask[HighElt]-Mask[i] != LaneSize)
3788       return false;
3789   }
3790
3791   return true;
3792 }
3793
3794 /// getShuffleVPERMILPSImmediate - Return the appropriate immediate to shuffle
3795 /// the specified VECTOR_MASK mask with VPERMILPS* instructions.
3796 static unsigned getShuffleVPERMILPSImmediate(SDNode *N) {
3797   ShuffleVectorSDNode *SVOp = cast<ShuffleVectorSDNode>(N);
3798   EVT VT = SVOp->getValueType(0);
3799
3800   int NumElts = VT.getVectorNumElements();
3801   int NumLanes = VT.getSizeInBits()/128;
3802   int LaneSize = NumElts/NumLanes;
3803
3804   // Although the mask is equal for both lanes do it twice to get the cases
3805   // where a mask will match because the same mask element is undef on the
3806   // first half but valid on the second. This would get pathological cases
3807   // such as: shuffle <u, 0, 1, 2, 4, 4, 5, 6>, which is completely valid.
3808   unsigned Mask = 0;
3809   for (int l = 0; l < NumLanes; ++l) {
3810     for (int i = 0; i < LaneSize; ++i) {
3811       int MaskElt = SVOp->getMaskElt(i+(l*LaneSize));
3812       if (MaskElt < 0)
3813         continue;
3814       if (MaskElt >= LaneSize)
3815         MaskElt -= LaneSize;
3816       Mask |= MaskElt << (i*2);
3817     }
3818   }
3819
3820   return Mask;
3821 }
3822
3823 /// getShuffleVPERMILPDImmediate - Return the appropriate immediate to shuffle
3824 /// the specified VECTOR_MASK mask with VPERMILPD* instructions.
3825 static unsigned getShuffleVPERMILPDImmediate(SDNode *N) {
3826   ShuffleVectorSDNode *SVOp = cast<ShuffleVectorSDNode>(N);
3827   EVT VT = SVOp->getValueType(0);
3828
3829   int NumElts = VT.getVectorNumElements();
3830   int NumLanes = VT.getSizeInBits()/128;
3831
3832   unsigned Mask = 0;
3833   int LaneSize = NumElts/NumLanes;
3834   for (int l = 0; l < NumLanes; ++l)
3835     for (int i = l*LaneSize; i < LaneSize*(l+1); ++i) {
3836       int MaskElt = SVOp->getMaskElt(i);
3837       if (MaskElt < 0)
3838         continue;
3839       Mask |= (MaskElt-l*LaneSize) << i;
3840     }
3841
3842   return Mask;
3843 }
3844
3845 /// isCommutedMOVL - Returns true if the shuffle mask is except the reverse
3846 /// of what x86 movss want. X86 movs requires the lowest  element to be lowest
3847 /// element of vector 2 and the other elements to come from vector 1 in order.
3848 static bool isCommutedMOVLMask(const SmallVectorImpl<int> &Mask, EVT VT,
3849                                bool V2IsSplat = false, bool V2IsUndef = false) {
3850   int NumOps = VT.getVectorNumElements();
3851   if (NumOps != 2 && NumOps != 4 && NumOps != 8 && NumOps != 16)
3852     return false;
3853
3854   if (!isUndefOrEqual(Mask[0], 0))
3855     return false;
3856
3857   for (int i = 1; i < NumOps; ++i)
3858     if (!(isUndefOrEqual(Mask[i], i+NumOps) ||
3859           (V2IsUndef && isUndefOrInRange(Mask[i], NumOps, NumOps*2)) ||
3860           (V2IsSplat && isUndefOrEqual(Mask[i], NumOps))))
3861       return false;
3862
3863   return true;
3864 }
3865
3866 static bool isCommutedMOVL(ShuffleVectorSDNode *N, bool V2IsSplat = false,
3867                            bool V2IsUndef = false) {
3868   SmallVector<int, 8> M;
3869   N->getMask(M);
3870   return isCommutedMOVLMask(M, N->getValueType(0), V2IsSplat, V2IsUndef);
3871 }
3872
3873 /// isMOVSHDUPMask - Return true if the specified VECTOR_SHUFFLE operand
3874 /// specifies a shuffle of elements that is suitable for input to MOVSHDUP.
3875 /// Masks to match: <1, 1, 3, 3> or <1, 1, 3, 3, 5, 5, 7, 7>
3876 bool X86::isMOVSHDUPMask(ShuffleVectorSDNode *N,
3877                          const X86Subtarget *Subtarget) {
3878   if (!Subtarget->hasSSE3() && !Subtarget->hasAVX())
3879     return false;
3880
3881   // The second vector must be undef
3882   if (N->getOperand(1).getOpcode() != ISD::UNDEF)
3883     return false;
3884
3885   EVT VT = N->getValueType(0);
3886   unsigned NumElems = VT.getVectorNumElements();
3887
3888   if ((VT.getSizeInBits() == 128 && NumElems != 4) ||
3889       (VT.getSizeInBits() == 256 && NumElems != 8))
3890     return false;
3891
3892   // "i+1" is the value the indexed mask element must have
3893   for (unsigned i = 0; i < NumElems; i += 2)
3894     if (!isUndefOrEqual(N->getMaskElt(i), i+1) ||
3895         !isUndefOrEqual(N->getMaskElt(i+1), i+1))
3896       return false;
3897
3898   return true;
3899 }
3900
3901 /// isMOVSLDUPMask - Return true if the specified VECTOR_SHUFFLE operand
3902 /// specifies a shuffle of elements that is suitable for input to MOVSLDUP.
3903 /// Masks to match: <0, 0, 2, 2> or <0, 0, 2, 2, 4, 4, 6, 6>
3904 bool X86::isMOVSLDUPMask(ShuffleVectorSDNode *N,
3905                          const X86Subtarget *Subtarget) {
3906   if (!Subtarget->hasSSE3() && !Subtarget->hasAVX())
3907     return false;
3908
3909   // The second vector must be undef
3910   if (N->getOperand(1).getOpcode() != ISD::UNDEF)
3911     return false;
3912
3913   EVT VT = N->getValueType(0);
3914   unsigned NumElems = VT.getVectorNumElements();
3915
3916   if ((VT.getSizeInBits() == 128 && NumElems != 4) ||
3917       (VT.getSizeInBits() == 256 && NumElems != 8))
3918     return false;
3919
3920   // "i" is the value the indexed mask element must have
3921   for (unsigned i = 0; i < NumElems; i += 2)
3922     if (!isUndefOrEqual(N->getMaskElt(i), i) ||
3923         !isUndefOrEqual(N->getMaskElt(i+1), i))
3924       return false;
3925
3926   return true;
3927 }
3928
3929 /// isMOVDDUPYMask - Return true if the specified VECTOR_SHUFFLE operand
3930 /// specifies a shuffle of elements that is suitable for input to 256-bit
3931 /// version of MOVDDUP.
3932 static bool isMOVDDUPYMask(ShuffleVectorSDNode *N,
3933                            const X86Subtarget *Subtarget) {
3934   EVT VT = N->getValueType(0);
3935   int NumElts = VT.getVectorNumElements();
3936   bool V2IsUndef = N->getOperand(1).getOpcode() == ISD::UNDEF;
3937
3938   if (!Subtarget->hasAVX() || VT.getSizeInBits() != 256 ||
3939       !V2IsUndef || NumElts != 4)
3940     return false;
3941
3942   for (int i = 0; i != NumElts/2; ++i)
3943     if (!isUndefOrEqual(N->getMaskElt(i), 0))
3944       return false;
3945   for (int i = NumElts/2; i != NumElts; ++i)
3946     if (!isUndefOrEqual(N->getMaskElt(i), NumElts/2))
3947       return false;
3948   return true;
3949 }
3950
3951 /// isMOVDDUPMask - Return true if the specified VECTOR_SHUFFLE operand
3952 /// specifies a shuffle of elements that is suitable for input to 128-bit
3953 /// version of MOVDDUP.
3954 bool X86::isMOVDDUPMask(ShuffleVectorSDNode *N) {
3955   EVT VT = N->getValueType(0);
3956
3957   if (VT.getSizeInBits() != 128)
3958     return false;
3959
3960   int e = VT.getVectorNumElements() / 2;
3961   for (int i = 0; i < e; ++i)
3962     if (!isUndefOrEqual(N->getMaskElt(i), i))
3963       return false;
3964   for (int i = 0; i < e; ++i)
3965     if (!isUndefOrEqual(N->getMaskElt(e+i), i))
3966       return false;
3967   return true;
3968 }
3969
3970 /// isVEXTRACTF128Index - Return true if the specified
3971 /// EXTRACT_SUBVECTOR operand specifies a vector extract that is
3972 /// suitable for input to VEXTRACTF128.
3973 bool X86::isVEXTRACTF128Index(SDNode *N) {
3974   if (!isa<ConstantSDNode>(N->getOperand(1).getNode()))
3975     return false;
3976
3977   // The index should be aligned on a 128-bit boundary.
3978   uint64_t Index =
3979     cast<ConstantSDNode>(N->getOperand(1).getNode())->getZExtValue();
3980
3981   unsigned VL = N->getValueType(0).getVectorNumElements();
3982   unsigned VBits = N->getValueType(0).getSizeInBits();
3983   unsigned ElSize = VBits / VL;
3984   bool Result = (Index * ElSize) % 128 == 0;
3985
3986   return Result;
3987 }
3988
3989 /// isVINSERTF128Index - Return true if the specified INSERT_SUBVECTOR
3990 /// operand specifies a subvector insert that is suitable for input to
3991 /// VINSERTF128.
3992 bool X86::isVINSERTF128Index(SDNode *N) {
3993   if (!isa<ConstantSDNode>(N->getOperand(2).getNode()))
3994     return false;
3995
3996   // The index should be aligned on a 128-bit boundary.
3997   uint64_t Index =
3998     cast<ConstantSDNode>(N->getOperand(2).getNode())->getZExtValue();
3999
4000   unsigned VL = N->getValueType(0).getVectorNumElements();
4001   unsigned VBits = N->getValueType(0).getSizeInBits();
4002   unsigned ElSize = VBits / VL;
4003   bool Result = (Index * ElSize) % 128 == 0;
4004
4005   return Result;
4006 }
4007
4008 /// getShuffleSHUFImmediate - Return the appropriate immediate to shuffle
4009 /// the specified VECTOR_SHUFFLE mask with PSHUF* and SHUFP* instructions.
4010 unsigned X86::getShuffleSHUFImmediate(SDNode *N) {
4011   ShuffleVectorSDNode *SVOp = cast<ShuffleVectorSDNode>(N);
4012   int NumOperands = SVOp->getValueType(0).getVectorNumElements();
4013
4014   unsigned Shift = (NumOperands == 4) ? 2 : 1;
4015   unsigned Mask = 0;
4016   for (int i = 0; i < NumOperands; ++i) {
4017     int Val = SVOp->getMaskElt(NumOperands-i-1);
4018     if (Val < 0) Val = 0;
4019     if (Val >= NumOperands) Val -= NumOperands;
4020     Mask |= Val;
4021     if (i != NumOperands - 1)
4022       Mask <<= Shift;
4023   }
4024   return Mask;
4025 }
4026
4027 /// getShufflePSHUFHWImmediate - Return the appropriate immediate to shuffle
4028 /// the specified VECTOR_SHUFFLE mask with the PSHUFHW instruction.
4029 unsigned X86::getShufflePSHUFHWImmediate(SDNode *N) {
4030   ShuffleVectorSDNode *SVOp = cast<ShuffleVectorSDNode>(N);
4031   unsigned Mask = 0;
4032   // 8 nodes, but we only care about the last 4.
4033   for (unsigned i = 7; i >= 4; --i) {
4034     int Val = SVOp->getMaskElt(i);
4035     if (Val >= 0)
4036       Mask |= (Val - 4);
4037     if (i != 4)
4038       Mask <<= 2;
4039   }
4040   return Mask;
4041 }
4042
4043 /// getShufflePSHUFLWImmediate - Return the appropriate immediate to shuffle
4044 /// the specified VECTOR_SHUFFLE mask with the PSHUFLW instruction.
4045 unsigned X86::getShufflePSHUFLWImmediate(SDNode *N) {
4046   ShuffleVectorSDNode *SVOp = cast<ShuffleVectorSDNode>(N);
4047   unsigned Mask = 0;
4048   // 8 nodes, but we only care about the first 4.
4049   for (int i = 3; i >= 0; --i) {
4050     int Val = SVOp->getMaskElt(i);
4051     if (Val >= 0)
4052       Mask |= Val;
4053     if (i != 0)
4054       Mask <<= 2;
4055   }
4056   return Mask;
4057 }
4058
4059 /// getShufflePALIGNRImmediate - Return the appropriate immediate to shuffle
4060 /// the specified VECTOR_SHUFFLE mask with the PALIGNR instruction.
4061 unsigned X86::getShufflePALIGNRImmediate(SDNode *N) {
4062   ShuffleVectorSDNode *SVOp = cast<ShuffleVectorSDNode>(N);
4063   EVT VVT = N->getValueType(0);
4064   unsigned EltSize = VVT.getVectorElementType().getSizeInBits() >> 3;
4065   int Val = 0;
4066
4067   unsigned i, e;
4068   for (i = 0, e = VVT.getVectorNumElements(); i != e; ++i) {
4069     Val = SVOp->getMaskElt(i);
4070     if (Val >= 0)
4071       break;
4072   }
4073   assert(Val - i > 0 && "PALIGNR imm should be positive");
4074   return (Val - i) * EltSize;
4075 }
4076
4077 /// getExtractVEXTRACTF128Immediate - Return the appropriate immediate
4078 /// to extract the specified EXTRACT_SUBVECTOR index with VEXTRACTF128
4079 /// instructions.
4080 unsigned X86::getExtractVEXTRACTF128Immediate(SDNode *N) {
4081   if (!isa<ConstantSDNode>(N->getOperand(1).getNode()))
4082     llvm_unreachable("Illegal extract subvector for VEXTRACTF128");
4083
4084   uint64_t Index =
4085     cast<ConstantSDNode>(N->getOperand(1).getNode())->getZExtValue();
4086
4087   EVT VecVT = N->getOperand(0).getValueType();
4088   EVT ElVT = VecVT.getVectorElementType();
4089
4090   unsigned NumElemsPerChunk = 128 / ElVT.getSizeInBits();
4091   return Index / NumElemsPerChunk;
4092 }
4093
4094 /// getInsertVINSERTF128Immediate - Return the appropriate immediate
4095 /// to insert at the specified INSERT_SUBVECTOR index with VINSERTF128
4096 /// instructions.
4097 unsigned X86::getInsertVINSERTF128Immediate(SDNode *N) {
4098   if (!isa<ConstantSDNode>(N->getOperand(2).getNode()))
4099     llvm_unreachable("Illegal insert subvector for VINSERTF128");
4100
4101   uint64_t Index =
4102     cast<ConstantSDNode>(N->getOperand(2).getNode())->getZExtValue();
4103
4104   EVT VecVT = N->getValueType(0);
4105   EVT ElVT = VecVT.getVectorElementType();
4106
4107   unsigned NumElemsPerChunk = 128 / ElVT.getSizeInBits();
4108   return Index / NumElemsPerChunk;
4109 }
4110
4111 /// isZeroNode - Returns true if Elt is a constant zero or a floating point
4112 /// constant +0.0.
4113 bool X86::isZeroNode(SDValue Elt) {
4114   return ((isa<ConstantSDNode>(Elt) &&
4115            cast<ConstantSDNode>(Elt)->isNullValue()) ||
4116           (isa<ConstantFPSDNode>(Elt) &&
4117            cast<ConstantFPSDNode>(Elt)->getValueAPF().isPosZero()));
4118 }
4119
4120 /// CommuteVectorShuffle - Swap vector_shuffle operands as well as values in
4121 /// their permute mask.
4122 static SDValue CommuteVectorShuffle(ShuffleVectorSDNode *SVOp,
4123                                     SelectionDAG &DAG) {
4124   EVT VT = SVOp->getValueType(0);
4125   unsigned NumElems = VT.getVectorNumElements();
4126   SmallVector<int, 8> MaskVec;
4127
4128   for (unsigned i = 0; i != NumElems; ++i) {
4129     int idx = SVOp->getMaskElt(i);
4130     if (idx < 0)
4131       MaskVec.push_back(idx);
4132     else if (idx < (int)NumElems)
4133       MaskVec.push_back(idx + NumElems);
4134     else
4135       MaskVec.push_back(idx - NumElems);
4136   }
4137   return DAG.getVectorShuffle(VT, SVOp->getDebugLoc(), SVOp->getOperand(1),
4138                               SVOp->getOperand(0), &MaskVec[0]);
4139 }
4140
4141 /// CommuteVectorShuffleMask - Change values in a shuffle permute mask assuming
4142 /// the two vector operands have swapped position.
4143 static void CommuteVectorShuffleMask(SmallVectorImpl<int> &Mask, EVT VT) {
4144   unsigned NumElems = VT.getVectorNumElements();
4145   for (unsigned i = 0; i != NumElems; ++i) {
4146     int idx = Mask[i];
4147     if (idx < 0)
4148       continue;
4149     else if (idx < (int)NumElems)
4150       Mask[i] = idx + NumElems;
4151     else
4152       Mask[i] = idx - NumElems;
4153   }
4154 }
4155
4156 /// ShouldXformToMOVHLPS - Return true if the node should be transformed to
4157 /// match movhlps. The lower half elements should come from upper half of
4158 /// V1 (and in order), and the upper half elements should come from the upper
4159 /// half of V2 (and in order).
4160 static bool ShouldXformToMOVHLPS(ShuffleVectorSDNode *Op) {
4161   EVT VT = Op->getValueType(0);
4162   if (VT.getSizeInBits() != 128)
4163     return false;
4164   if (VT.getVectorNumElements() != 4)
4165     return false;
4166   for (unsigned i = 0, e = 2; i != e; ++i)
4167     if (!isUndefOrEqual(Op->getMaskElt(i), i+2))
4168       return false;
4169   for (unsigned i = 2; i != 4; ++i)
4170     if (!isUndefOrEqual(Op->getMaskElt(i), i+4))
4171       return false;
4172   return true;
4173 }
4174
4175 /// isScalarLoadToVector - Returns true if the node is a scalar load that
4176 /// is promoted to a vector. It also returns the LoadSDNode by reference if
4177 /// required.
4178 static bool isScalarLoadToVector(SDNode *N, LoadSDNode **LD = NULL) {
4179   if (N->getOpcode() != ISD::SCALAR_TO_VECTOR)
4180     return false;
4181   N = N->getOperand(0).getNode();
4182   if (!ISD::isNON_EXTLoad(N))
4183     return false;
4184   if (LD)
4185     *LD = cast<LoadSDNode>(N);
4186   return true;
4187 }
4188
4189 /// ShouldXformToMOVLP{S|D} - Return true if the node should be transformed to
4190 /// match movlp{s|d}. The lower half elements should come from lower half of
4191 /// V1 (and in order), and the upper half elements should come from the upper
4192 /// half of V2 (and in order). And since V1 will become the source of the
4193 /// MOVLP, it must be either a vector load or a scalar load to vector.
4194 static bool ShouldXformToMOVLP(SDNode *V1, SDNode *V2,
4195                                ShuffleVectorSDNode *Op) {
4196   EVT VT = Op->getValueType(0);
4197   if (VT.getSizeInBits() != 128)
4198     return false;
4199
4200   if (!ISD::isNON_EXTLoad(V1) && !isScalarLoadToVector(V1))
4201     return false;
4202   // Is V2 is a vector load, don't do this transformation. We will try to use
4203   // load folding shufps op.
4204   if (ISD::isNON_EXTLoad(V2))
4205     return false;
4206
4207   unsigned NumElems = VT.getVectorNumElements();
4208
4209   if (NumElems != 2 && NumElems != 4)
4210     return false;
4211   for (unsigned i = 0, e = NumElems/2; i != e; ++i)
4212     if (!isUndefOrEqual(Op->getMaskElt(i), i))
4213       return false;
4214   for (unsigned i = NumElems/2; i != NumElems; ++i)
4215     if (!isUndefOrEqual(Op->getMaskElt(i), i+NumElems))
4216       return false;
4217   return true;
4218 }
4219
4220 /// isSplatVector - Returns true if N is a BUILD_VECTOR node whose elements are
4221 /// all the same.
4222 static bool isSplatVector(SDNode *N) {
4223   if (N->getOpcode() != ISD::BUILD_VECTOR)
4224     return false;
4225
4226   SDValue SplatValue = N->getOperand(0);
4227   for (unsigned i = 1, e = N->getNumOperands(); i != e; ++i)
4228     if (N->getOperand(i) != SplatValue)
4229       return false;
4230   return true;
4231 }
4232
4233 /// isZeroShuffle - Returns true if N is a VECTOR_SHUFFLE that can be resolved
4234 /// to an zero vector.
4235 /// FIXME: move to dag combiner / method on ShuffleVectorSDNode
4236 static bool isZeroShuffle(ShuffleVectorSDNode *N) {
4237   SDValue V1 = N->getOperand(0);
4238   SDValue V2 = N->getOperand(1);
4239   unsigned NumElems = N->getValueType(0).getVectorNumElements();
4240   for (unsigned i = 0; i != NumElems; ++i) {
4241     int Idx = N->getMaskElt(i);
4242     if (Idx >= (int)NumElems) {
4243       unsigned Opc = V2.getOpcode();
4244       if (Opc == ISD::UNDEF || ISD::isBuildVectorAllZeros(V2.getNode()))
4245         continue;
4246       if (Opc != ISD::BUILD_VECTOR ||
4247           !X86::isZeroNode(V2.getOperand(Idx-NumElems)))
4248         return false;
4249     } else if (Idx >= 0) {
4250       unsigned Opc = V1.getOpcode();
4251       if (Opc == ISD::UNDEF || ISD::isBuildVectorAllZeros(V1.getNode()))
4252         continue;
4253       if (Opc != ISD::BUILD_VECTOR ||
4254           !X86::isZeroNode(V1.getOperand(Idx)))
4255         return false;
4256     }
4257   }
4258   return true;
4259 }
4260
4261 /// getZeroVector - Returns a vector of specified type with all zero elements.
4262 ///
4263 static SDValue getZeroVector(EVT VT, bool HasSSE2, SelectionDAG &DAG,
4264                              DebugLoc dl) {
4265   assert(VT.isVector() && "Expected a vector type");
4266
4267   // Always build SSE zero vectors as <4 x i32> bitcasted
4268   // to their dest type. This ensures they get CSE'd.
4269   SDValue Vec;
4270   if (VT.getSizeInBits() == 128) {  // SSE
4271     if (HasSSE2) {  // SSE2
4272       SDValue Cst = DAG.getTargetConstant(0, MVT::i32);
4273       Vec = DAG.getNode(ISD::BUILD_VECTOR, dl, MVT::v4i32, Cst, Cst, Cst, Cst);
4274     } else { // SSE1
4275       SDValue Cst = DAG.getTargetConstantFP(+0.0, MVT::f32);
4276       Vec = DAG.getNode(ISD::BUILD_VECTOR, dl, MVT::v4f32, Cst, Cst, Cst, Cst);
4277     }
4278   } else if (VT.getSizeInBits() == 256) { // AVX
4279     // 256-bit logic and arithmetic instructions in AVX are
4280     // all floating-point, no support for integer ops. Default
4281     // to emitting fp zeroed vectors then.
4282     SDValue Cst = DAG.getTargetConstantFP(+0.0, MVT::f32);
4283     SDValue Ops[] = { Cst, Cst, Cst, Cst, Cst, Cst, Cst, Cst };
4284     Vec = DAG.getNode(ISD::BUILD_VECTOR, dl, MVT::v8f32, Ops, 8);
4285   }
4286   return DAG.getNode(ISD::BITCAST, dl, VT, Vec);
4287 }
4288
4289 /// getOnesVector - Returns a vector of specified type with all bits set.
4290 /// Always build ones vectors as <4 x i32>. For 256-bit types, use two
4291 /// <4 x i32> inserted in a <8 x i32> appropriately. Then bitcast to their
4292 /// original type, ensuring they get CSE'd.
4293 static SDValue getOnesVector(EVT VT, SelectionDAG &DAG, DebugLoc dl) {
4294   assert(VT.isVector() && "Expected a vector type");
4295   assert((VT.is128BitVector() || VT.is256BitVector())
4296          && "Expected a 128-bit or 256-bit vector type");
4297
4298   SDValue Cst = DAG.getTargetConstant(~0U, MVT::i32);
4299   SDValue Vec = DAG.getNode(ISD::BUILD_VECTOR, dl, MVT::v4i32,
4300                             Cst, Cst, Cst, Cst);
4301
4302   if (VT.is256BitVector()) {
4303     SDValue InsV = Insert128BitVector(DAG.getNode(ISD::UNDEF, dl, MVT::v8i32),
4304                               Vec, DAG.getConstant(0, MVT::i32), DAG, dl);
4305     Vec = Insert128BitVector(InsV, Vec,
4306                   DAG.getConstant(4 /* NumElems/2 */, MVT::i32), DAG, dl);
4307   }
4308
4309   return DAG.getNode(ISD::BITCAST, dl, VT, Vec);
4310 }
4311
4312 /// NormalizeMask - V2 is a splat, modify the mask (if needed) so all elements
4313 /// that point to V2 points to its first element.
4314 static SDValue NormalizeMask(ShuffleVectorSDNode *SVOp, SelectionDAG &DAG) {
4315   EVT VT = SVOp->getValueType(0);
4316   unsigned NumElems = VT.getVectorNumElements();
4317
4318   bool Changed = false;
4319   SmallVector<int, 8> MaskVec;
4320   SVOp->getMask(MaskVec);
4321
4322   for (unsigned i = 0; i != NumElems; ++i) {
4323     if (MaskVec[i] > (int)NumElems) {
4324       MaskVec[i] = NumElems;
4325       Changed = true;
4326     }
4327   }
4328   if (Changed)
4329     return DAG.getVectorShuffle(VT, SVOp->getDebugLoc(), SVOp->getOperand(0),
4330                                 SVOp->getOperand(1), &MaskVec[0]);
4331   return SDValue(SVOp, 0);
4332 }
4333
4334 /// getMOVLMask - Returns a vector_shuffle mask for an movs{s|d}, movd
4335 /// operation of specified width.
4336 static SDValue getMOVL(SelectionDAG &DAG, DebugLoc dl, EVT VT, SDValue V1,
4337                        SDValue V2) {
4338   unsigned NumElems = VT.getVectorNumElements();
4339   SmallVector<int, 8> Mask;
4340   Mask.push_back(NumElems);
4341   for (unsigned i = 1; i != NumElems; ++i)
4342     Mask.push_back(i);
4343   return DAG.getVectorShuffle(VT, dl, V1, V2, &Mask[0]);
4344 }
4345
4346 /// getUnpackl - Returns a vector_shuffle node for an unpackl operation.
4347 static SDValue getUnpackl(SelectionDAG &DAG, DebugLoc dl, EVT VT, SDValue V1,
4348                           SDValue V2) {
4349   unsigned NumElems = VT.getVectorNumElements();
4350   SmallVector<int, 8> Mask;
4351   for (unsigned i = 0, e = NumElems/2; i != e; ++i) {
4352     Mask.push_back(i);
4353     Mask.push_back(i + NumElems);
4354   }
4355   return DAG.getVectorShuffle(VT, dl, V1, V2, &Mask[0]);
4356 }
4357
4358 /// getUnpackh - Returns a vector_shuffle node for an unpackh operation.
4359 static SDValue getUnpackh(SelectionDAG &DAG, DebugLoc dl, EVT VT, SDValue V1,
4360                           SDValue V2) {
4361   unsigned NumElems = VT.getVectorNumElements();
4362   unsigned Half = NumElems/2;
4363   SmallVector<int, 8> Mask;
4364   for (unsigned i = 0; i != Half; ++i) {
4365     Mask.push_back(i + Half);
4366     Mask.push_back(i + NumElems + Half);
4367   }
4368   return DAG.getVectorShuffle(VT, dl, V1, V2, &Mask[0]);
4369 }
4370
4371 // PromoteSplati8i16 - All i16 and i8 vector types can't be used directly by
4372 // a generic shuffle instruction because the target has no such instructions.
4373 // Generate shuffles which repeat i16 and i8 several times until they can be
4374 // represented by v4f32 and then be manipulated by target suported shuffles.
4375 static SDValue PromoteSplati8i16(SDValue V, SelectionDAG &DAG, int &EltNo) {
4376   EVT VT = V.getValueType();
4377   int NumElems = VT.getVectorNumElements();
4378   DebugLoc dl = V.getDebugLoc();
4379
4380   while (NumElems > 4) {
4381     if (EltNo < NumElems/2) {
4382       V = getUnpackl(DAG, dl, VT, V, V);
4383     } else {
4384       V = getUnpackh(DAG, dl, VT, V, V);
4385       EltNo -= NumElems/2;
4386     }
4387     NumElems >>= 1;
4388   }
4389   return V;
4390 }
4391
4392 /// getLegalSplat - Generate a legal splat with supported x86 shuffles
4393 static SDValue getLegalSplat(SelectionDAG &DAG, SDValue V, int EltNo) {
4394   EVT VT = V.getValueType();
4395   DebugLoc dl = V.getDebugLoc();
4396   assert((VT.getSizeInBits() == 128 || VT.getSizeInBits() == 256)
4397          && "Vector size not supported");
4398
4399   if (VT.getSizeInBits() == 128) {
4400     V = DAG.getNode(ISD::BITCAST, dl, MVT::v4f32, V);
4401     int SplatMask[4] = { EltNo, EltNo, EltNo, EltNo };
4402     V = DAG.getVectorShuffle(MVT::v4f32, dl, V, DAG.getUNDEF(MVT::v4f32),
4403                              &SplatMask[0]);
4404   } else {
4405     // To use VPERMILPS to splat scalars, the second half of indicies must
4406     // refer to the higher part, which is a duplication of the lower one,
4407     // because VPERMILPS can only handle in-lane permutations.
4408     int SplatMask[8] = { EltNo, EltNo, EltNo, EltNo,
4409                          EltNo+4, EltNo+4, EltNo+4, EltNo+4 };
4410
4411     V = DAG.getNode(ISD::BITCAST, dl, MVT::v8f32, V);
4412     V = DAG.getVectorShuffle(MVT::v8f32, dl, V, DAG.getUNDEF(MVT::v8f32),
4413                              &SplatMask[0]);
4414   }
4415
4416   return DAG.getNode(ISD::BITCAST, dl, VT, V);
4417 }
4418
4419 /// PromoteSplat - Splat is promoted to target supported vector shuffles.
4420 static SDValue PromoteSplat(ShuffleVectorSDNode *SV, SelectionDAG &DAG) {
4421   EVT SrcVT = SV->getValueType(0);
4422   SDValue V1 = SV->getOperand(0);
4423   DebugLoc dl = SV->getDebugLoc();
4424
4425   int EltNo = SV->getSplatIndex();
4426   int NumElems = SrcVT.getVectorNumElements();
4427   unsigned Size = SrcVT.getSizeInBits();
4428
4429   assert(((Size == 128 && NumElems > 4) || Size == 256) &&
4430           "Unknown how to promote splat for type");
4431
4432   // Extract the 128-bit part containing the splat element and update
4433   // the splat element index when it refers to the higher register.
4434   if (Size == 256) {
4435     unsigned Idx = (EltNo > NumElems/2) ? NumElems/2 : 0;
4436     V1 = Extract128BitVector(V1, DAG.getConstant(Idx, MVT::i32), DAG, dl);
4437     if (Idx > 0)
4438       EltNo -= NumElems/2;
4439   }
4440
4441   // All i16 and i8 vector types can't be used directly by a generic shuffle
4442   // instruction because the target has no such instruction. Generate shuffles
4443   // which repeat i16 and i8 several times until they fit in i32, and then can
4444   // be manipulated by target suported shuffles.
4445   EVT EltVT = SrcVT.getVectorElementType();
4446   if (EltVT == MVT::i8 || EltVT == MVT::i16)
4447     V1 = PromoteSplati8i16(V1, DAG, EltNo);
4448
4449   // Recreate the 256-bit vector and place the same 128-bit vector
4450   // into the low and high part. This is necessary because we want
4451   // to use VPERM* to shuffle the vectors
4452   if (Size == 256) {
4453     SDValue InsV = Insert128BitVector(DAG.getUNDEF(SrcVT), V1,
4454                          DAG.getConstant(0, MVT::i32), DAG, dl);
4455     V1 = Insert128BitVector(InsV, V1,
4456                DAG.getConstant(NumElems/2, MVT::i32), DAG, dl);
4457   }
4458
4459   return getLegalSplat(DAG, V1, EltNo);
4460 }
4461
4462 /// getShuffleVectorZeroOrUndef - Return a vector_shuffle of the specified
4463 /// vector of zero or undef vector.  This produces a shuffle where the low
4464 /// element of V2 is swizzled into the zero/undef vector, landing at element
4465 /// Idx.  This produces a shuffle mask like 4,1,2,3 (idx=0) or  0,1,2,4 (idx=3).
4466 static SDValue getShuffleVectorZeroOrUndef(SDValue V2, unsigned Idx,
4467                                              bool isZero, bool HasSSE2,
4468                                              SelectionDAG &DAG) {
4469   EVT VT = V2.getValueType();
4470   SDValue V1 = isZero
4471     ? getZeroVector(VT, HasSSE2, DAG, V2.getDebugLoc()) : DAG.getUNDEF(VT);
4472   unsigned NumElems = VT.getVectorNumElements();
4473   SmallVector<int, 16> MaskVec;
4474   for (unsigned i = 0; i != NumElems; ++i)
4475     // If this is the insertion idx, put the low elt of V2 here.
4476     MaskVec.push_back(i == Idx ? NumElems : i);
4477   return DAG.getVectorShuffle(VT, V2.getDebugLoc(), V1, V2, &MaskVec[0]);
4478 }
4479
4480 /// getShuffleScalarElt - Returns the scalar element that will make up the ith
4481 /// element of the result of the vector shuffle.
4482 static SDValue getShuffleScalarElt(SDNode *N, int Index, SelectionDAG &DAG,
4483                                    unsigned Depth) {
4484   if (Depth == 6)
4485     return SDValue();  // Limit search depth.
4486
4487   SDValue V = SDValue(N, 0);
4488   EVT VT = V.getValueType();
4489   unsigned Opcode = V.getOpcode();
4490
4491   // Recurse into ISD::VECTOR_SHUFFLE node to find scalars.
4492   if (const ShuffleVectorSDNode *SV = dyn_cast<ShuffleVectorSDNode>(N)) {
4493     Index = SV->getMaskElt(Index);
4494
4495     if (Index < 0)
4496       return DAG.getUNDEF(VT.getVectorElementType());
4497
4498     int NumElems = VT.getVectorNumElements();
4499     SDValue NewV = (Index < NumElems) ? SV->getOperand(0) : SV->getOperand(1);
4500     return getShuffleScalarElt(NewV.getNode(), Index % NumElems, DAG, Depth+1);
4501   }
4502
4503   // Recurse into target specific vector shuffles to find scalars.
4504   if (isTargetShuffle(Opcode)) {
4505     int NumElems = VT.getVectorNumElements();
4506     SmallVector<unsigned, 16> ShuffleMask;
4507     SDValue ImmN;
4508
4509     switch(Opcode) {
4510     case X86ISD::SHUFPS:
4511     case X86ISD::SHUFPD:
4512       ImmN = N->getOperand(N->getNumOperands()-1);
4513       DecodeSHUFPSMask(NumElems,
4514                        cast<ConstantSDNode>(ImmN)->getZExtValue(),
4515                        ShuffleMask);
4516       break;
4517     case X86ISD::PUNPCKHBW:
4518     case X86ISD::PUNPCKHWD:
4519     case X86ISD::PUNPCKHDQ:
4520     case X86ISD::PUNPCKHQDQ:
4521       DecodePUNPCKHMask(NumElems, ShuffleMask);
4522       break;
4523     case X86ISD::UNPCKHPS:
4524     case X86ISD::UNPCKHPD:
4525     case X86ISD::VUNPCKHPSY:
4526     case X86ISD::VUNPCKHPDY:
4527       DecodeUNPCKHPMask(NumElems, ShuffleMask);
4528       break;
4529     case X86ISD::PUNPCKLBW:
4530     case X86ISD::PUNPCKLWD:
4531     case X86ISD::PUNPCKLDQ:
4532     case X86ISD::PUNPCKLQDQ:
4533       DecodePUNPCKLMask(VT, ShuffleMask);
4534       break;
4535     case X86ISD::UNPCKLPS:
4536     case X86ISD::UNPCKLPD:
4537     case X86ISD::VUNPCKLPSY:
4538     case X86ISD::VUNPCKLPDY:
4539       DecodeUNPCKLPMask(VT, ShuffleMask);
4540       break;
4541     case X86ISD::MOVHLPS:
4542       DecodeMOVHLPSMask(NumElems, ShuffleMask);
4543       break;
4544     case X86ISD::MOVLHPS:
4545       DecodeMOVLHPSMask(NumElems, ShuffleMask);
4546       break;
4547     case X86ISD::PSHUFD:
4548       ImmN = N->getOperand(N->getNumOperands()-1);
4549       DecodePSHUFMask(NumElems,
4550                       cast<ConstantSDNode>(ImmN)->getZExtValue(),
4551                       ShuffleMask);
4552       break;
4553     case X86ISD::PSHUFHW:
4554       ImmN = N->getOperand(N->getNumOperands()-1);
4555       DecodePSHUFHWMask(cast<ConstantSDNode>(ImmN)->getZExtValue(),
4556                         ShuffleMask);
4557       break;
4558     case X86ISD::PSHUFLW:
4559       ImmN = N->getOperand(N->getNumOperands()-1);
4560       DecodePSHUFLWMask(cast<ConstantSDNode>(ImmN)->getZExtValue(),
4561                         ShuffleMask);
4562       break;
4563     case X86ISD::MOVSS:
4564     case X86ISD::MOVSD: {
4565       // The index 0 always comes from the first element of the second source,
4566       // this is why MOVSS and MOVSD are used in the first place. The other
4567       // elements come from the other positions of the first source vector.
4568       unsigned OpNum = (Index == 0) ? 1 : 0;
4569       return getShuffleScalarElt(V.getOperand(OpNum).getNode(), Index, DAG,
4570                                  Depth+1);
4571     }
4572     case X86ISD::VPERMILPS:
4573       ImmN = N->getOperand(N->getNumOperands()-1);
4574       DecodeVPERMILPSMask(4, cast<ConstantSDNode>(ImmN)->getZExtValue(),
4575                         ShuffleMask);
4576       break;
4577     case X86ISD::VPERMILPSY:
4578       ImmN = N->getOperand(N->getNumOperands()-1);
4579       DecodeVPERMILPSMask(8, cast<ConstantSDNode>(ImmN)->getZExtValue(),
4580                         ShuffleMask);
4581       break;
4582     case X86ISD::VPERMILPD:
4583       ImmN = N->getOperand(N->getNumOperands()-1);
4584       DecodeVPERMILPDMask(2, cast<ConstantSDNode>(ImmN)->getZExtValue(),
4585                         ShuffleMask);
4586       break;
4587     case X86ISD::VPERMILPDY:
4588       ImmN = N->getOperand(N->getNumOperands()-1);
4589       DecodeVPERMILPDMask(4, cast<ConstantSDNode>(ImmN)->getZExtValue(),
4590                         ShuffleMask);
4591       break;
4592     case X86ISD::VPERM2F128:
4593       ImmN = N->getOperand(N->getNumOperands()-1);
4594       DecodeVPERM2F128Mask(VT, cast<ConstantSDNode>(ImmN)->getZExtValue(),
4595                            ShuffleMask);
4596       break;
4597     default:
4598       assert("not implemented for target shuffle node");
4599       return SDValue();
4600     }
4601
4602     Index = ShuffleMask[Index];
4603     if (Index < 0)
4604       return DAG.getUNDEF(VT.getVectorElementType());
4605
4606     SDValue NewV = (Index < NumElems) ? N->getOperand(0) : N->getOperand(1);
4607     return getShuffleScalarElt(NewV.getNode(), Index % NumElems, DAG,
4608                                Depth+1);
4609   }
4610
4611   // Actual nodes that may contain scalar elements
4612   if (Opcode == ISD::BITCAST) {
4613     V = V.getOperand(0);
4614     EVT SrcVT = V.getValueType();
4615     unsigned NumElems = VT.getVectorNumElements();
4616
4617     if (!SrcVT.isVector() || SrcVT.getVectorNumElements() != NumElems)
4618       return SDValue();
4619   }
4620
4621   if (V.getOpcode() == ISD::SCALAR_TO_VECTOR)
4622     return (Index == 0) ? V.getOperand(0)
4623                           : DAG.getUNDEF(VT.getVectorElementType());
4624
4625   if (V.getOpcode() == ISD::BUILD_VECTOR)
4626     return V.getOperand(Index);
4627
4628   return SDValue();
4629 }
4630
4631 /// getNumOfConsecutiveZeros - Return the number of elements of a vector
4632 /// shuffle operation which come from a consecutively from a zero. The
4633 /// search can start in two different directions, from left or right.
4634 static
4635 unsigned getNumOfConsecutiveZeros(SDNode *N, int NumElems,
4636                                   bool ZerosFromLeft, SelectionDAG &DAG) {
4637   int i = 0;
4638
4639   while (i < NumElems) {
4640     unsigned Index = ZerosFromLeft ? i : NumElems-i-1;
4641     SDValue Elt = getShuffleScalarElt(N, Index, DAG, 0);
4642     if (!(Elt.getNode() &&
4643          (Elt.getOpcode() == ISD::UNDEF || X86::isZeroNode(Elt))))
4644       break;
4645     ++i;
4646   }
4647
4648   return i;
4649 }
4650
4651 /// isShuffleMaskConsecutive - Check if the shuffle mask indicies from MaskI to
4652 /// MaskE correspond consecutively to elements from one of the vector operands,
4653 /// starting from its index OpIdx. Also tell OpNum which source vector operand.
4654 static
4655 bool isShuffleMaskConsecutive(ShuffleVectorSDNode *SVOp, int MaskI, int MaskE,
4656                               int OpIdx, int NumElems, unsigned &OpNum) {
4657   bool SeenV1 = false;
4658   bool SeenV2 = false;
4659
4660   for (int i = MaskI; i <= MaskE; ++i, ++OpIdx) {
4661     int Idx = SVOp->getMaskElt(i);
4662     // Ignore undef indicies
4663     if (Idx < 0)
4664       continue;
4665
4666     if (Idx < NumElems)
4667       SeenV1 = true;
4668     else
4669       SeenV2 = true;
4670
4671     // Only accept consecutive elements from the same vector
4672     if ((Idx % NumElems != OpIdx) || (SeenV1 && SeenV2))
4673       return false;
4674   }
4675
4676   OpNum = SeenV1 ? 0 : 1;
4677   return true;
4678 }
4679
4680 /// isVectorShiftRight - Returns true if the shuffle can be implemented as a
4681 /// logical left shift of a vector.
4682 static bool isVectorShiftRight(ShuffleVectorSDNode *SVOp, SelectionDAG &DAG,
4683                                bool &isLeft, SDValue &ShVal, unsigned &ShAmt) {
4684   unsigned NumElems = SVOp->getValueType(0).getVectorNumElements();
4685   unsigned NumZeros = getNumOfConsecutiveZeros(SVOp, NumElems,
4686               false /* check zeros from right */, DAG);
4687   unsigned OpSrc;
4688
4689   if (!NumZeros)
4690     return false;
4691
4692   // Considering the elements in the mask that are not consecutive zeros,
4693   // check if they consecutively come from only one of the source vectors.
4694   //
4695   //               V1 = {X, A, B, C}     0
4696   //                         \  \  \    /
4697   //   vector_shuffle V1, V2 <1, 2, 3, X>
4698   //
4699   if (!isShuffleMaskConsecutive(SVOp,
4700             0,                   // Mask Start Index
4701             NumElems-NumZeros-1, // Mask End Index
4702             NumZeros,            // Where to start looking in the src vector
4703             NumElems,            // Number of elements in vector
4704             OpSrc))              // Which source operand ?
4705     return false;
4706
4707   isLeft = false;
4708   ShAmt = NumZeros;
4709   ShVal = SVOp->getOperand(OpSrc);
4710   return true;
4711 }
4712
4713 /// isVectorShiftLeft - Returns true if the shuffle can be implemented as a
4714 /// logical left shift of a vector.
4715 static bool isVectorShiftLeft(ShuffleVectorSDNode *SVOp, SelectionDAG &DAG,
4716                               bool &isLeft, SDValue &ShVal, unsigned &ShAmt) {
4717   unsigned NumElems = SVOp->getValueType(0).getVectorNumElements();
4718   unsigned NumZeros = getNumOfConsecutiveZeros(SVOp, NumElems,
4719               true /* check zeros from left */, DAG);
4720   unsigned OpSrc;
4721
4722   if (!NumZeros)
4723     return false;
4724
4725   // Considering the elements in the mask that are not consecutive zeros,
4726   // check if they consecutively come from only one of the source vectors.
4727   //
4728   //                           0    { A, B, X, X } = V2
4729   //                          / \    /  /
4730   //   vector_shuffle V1, V2 <X, X, 4, 5>
4731   //
4732   if (!isShuffleMaskConsecutive(SVOp,
4733             NumZeros,     // Mask Start Index
4734             NumElems-1,   // Mask End Index
4735             0,            // Where to start looking in the src vector
4736             NumElems,     // Number of elements in vector
4737             OpSrc))       // Which source operand ?
4738     return false;
4739
4740   isLeft = true;
4741   ShAmt = NumZeros;
4742   ShVal = SVOp->getOperand(OpSrc);
4743   return true;
4744 }
4745
4746 /// isVectorShift - Returns true if the shuffle can be implemented as a
4747 /// logical left or right shift of a vector.
4748 static bool isVectorShift(ShuffleVectorSDNode *SVOp, SelectionDAG &DAG,
4749                           bool &isLeft, SDValue &ShVal, unsigned &ShAmt) {
4750   if (isVectorShiftLeft(SVOp, DAG, isLeft, ShVal, ShAmt) ||
4751       isVectorShiftRight(SVOp, DAG, isLeft, ShVal, ShAmt))
4752     return true;
4753
4754   return false;
4755 }
4756
4757 /// LowerBuildVectorv16i8 - Custom lower build_vector of v16i8.
4758 ///
4759 static SDValue LowerBuildVectorv16i8(SDValue Op, unsigned NonZeros,
4760                                        unsigned NumNonZero, unsigned NumZero,
4761                                        SelectionDAG &DAG,
4762                                        const TargetLowering &TLI) {
4763   if (NumNonZero > 8)
4764     return SDValue();
4765
4766   DebugLoc dl = Op.getDebugLoc();
4767   SDValue V(0, 0);
4768   bool First = true;
4769   for (unsigned i = 0; i < 16; ++i) {
4770     bool ThisIsNonZero = (NonZeros & (1 << i)) != 0;
4771     if (ThisIsNonZero && First) {
4772       if (NumZero)
4773         V = getZeroVector(MVT::v8i16, true, DAG, dl);
4774       else
4775         V = DAG.getUNDEF(MVT::v8i16);
4776       First = false;
4777     }
4778
4779     if ((i & 1) != 0) {
4780       SDValue ThisElt(0, 0), LastElt(0, 0);
4781       bool LastIsNonZero = (NonZeros & (1 << (i-1))) != 0;
4782       if (LastIsNonZero) {
4783         LastElt = DAG.getNode(ISD::ZERO_EXTEND, dl,
4784                               MVT::i16, Op.getOperand(i-1));
4785       }
4786       if (ThisIsNonZero) {
4787         ThisElt = DAG.getNode(ISD::ZERO_EXTEND, dl, MVT::i16, Op.getOperand(i));
4788         ThisElt = DAG.getNode(ISD::SHL, dl, MVT::i16,
4789                               ThisElt, DAG.getConstant(8, MVT::i8));
4790         if (LastIsNonZero)
4791           ThisElt = DAG.getNode(ISD::OR, dl, MVT::i16, ThisElt, LastElt);
4792       } else
4793         ThisElt = LastElt;
4794
4795       if (ThisElt.getNode())
4796         V = DAG.getNode(ISD::INSERT_VECTOR_ELT, dl, MVT::v8i16, V, ThisElt,
4797                         DAG.getIntPtrConstant(i/2));
4798     }
4799   }
4800
4801   return DAG.getNode(ISD::BITCAST, dl, MVT::v16i8, V);
4802 }
4803
4804 /// LowerBuildVectorv8i16 - Custom lower build_vector of v8i16.
4805 ///
4806 static SDValue LowerBuildVectorv8i16(SDValue Op, unsigned NonZeros,
4807                                      unsigned NumNonZero, unsigned NumZero,
4808                                      SelectionDAG &DAG,
4809                                      const TargetLowering &TLI) {
4810   if (NumNonZero > 4)
4811     return SDValue();
4812
4813   DebugLoc dl = Op.getDebugLoc();
4814   SDValue V(0, 0);
4815   bool First = true;
4816   for (unsigned i = 0; i < 8; ++i) {
4817     bool isNonZero = (NonZeros & (1 << i)) != 0;
4818     if (isNonZero) {
4819       if (First) {
4820         if (NumZero)
4821           V = getZeroVector(MVT::v8i16, true, DAG, dl);
4822         else
4823           V = DAG.getUNDEF(MVT::v8i16);
4824         First = false;
4825       }
4826       V = DAG.getNode(ISD::INSERT_VECTOR_ELT, dl,
4827                       MVT::v8i16, V, Op.getOperand(i),
4828                       DAG.getIntPtrConstant(i));
4829     }
4830   }
4831
4832   return V;
4833 }
4834
4835 /// getVShift - Return a vector logical shift node.
4836 ///
4837 static SDValue getVShift(bool isLeft, EVT VT, SDValue SrcOp,
4838                          unsigned NumBits, SelectionDAG &DAG,
4839                          const TargetLowering &TLI, DebugLoc dl) {
4840   EVT ShVT = MVT::v2i64;
4841   unsigned Opc = isLeft ? X86ISD::VSHL : X86ISD::VSRL;
4842   SrcOp = DAG.getNode(ISD::BITCAST, dl, ShVT, SrcOp);
4843   return DAG.getNode(ISD::BITCAST, dl, VT,
4844                      DAG.getNode(Opc, dl, ShVT, SrcOp,
4845                              DAG.getConstant(NumBits,
4846                                   TLI.getShiftAmountTy(SrcOp.getValueType()))));
4847 }
4848
4849 SDValue
4850 X86TargetLowering::LowerAsSplatVectorLoad(SDValue SrcOp, EVT VT, DebugLoc dl,
4851                                           SelectionDAG &DAG) const {
4852
4853   // Check if the scalar load can be widened into a vector load. And if
4854   // the address is "base + cst" see if the cst can be "absorbed" into
4855   // the shuffle mask.
4856   if (LoadSDNode *LD = dyn_cast<LoadSDNode>(SrcOp)) {
4857     SDValue Ptr = LD->getBasePtr();
4858     if (!ISD::isNormalLoad(LD) || LD->isVolatile())
4859       return SDValue();
4860     EVT PVT = LD->getValueType(0);
4861     if (PVT != MVT::i32 && PVT != MVT::f32)
4862       return SDValue();
4863
4864     int FI = -1;
4865     int64_t Offset = 0;
4866     if (FrameIndexSDNode *FINode = dyn_cast<FrameIndexSDNode>(Ptr)) {
4867       FI = FINode->getIndex();
4868       Offset = 0;
4869     } else if (DAG.isBaseWithConstantOffset(Ptr) &&
4870                isa<FrameIndexSDNode>(Ptr.getOperand(0))) {
4871       FI = cast<FrameIndexSDNode>(Ptr.getOperand(0))->getIndex();
4872       Offset = Ptr.getConstantOperandVal(1);
4873       Ptr = Ptr.getOperand(0);
4874     } else {
4875       return SDValue();
4876     }
4877
4878     // FIXME: 256-bit vector instructions don't require a strict alignment,
4879     // improve this code to support it better.
4880     unsigned RequiredAlign = VT.getSizeInBits()/8;
4881     SDValue Chain = LD->getChain();
4882     // Make sure the stack object alignment is at least 16 or 32.
4883     MachineFrameInfo *MFI = DAG.getMachineFunction().getFrameInfo();
4884     if (DAG.InferPtrAlignment(Ptr) < RequiredAlign) {
4885       if (MFI->isFixedObjectIndex(FI)) {
4886         // Can't change the alignment. FIXME: It's possible to compute
4887         // the exact stack offset and reference FI + adjust offset instead.
4888         // If someone *really* cares about this. That's the way to implement it.
4889         return SDValue();
4890       } else {
4891         MFI->setObjectAlignment(FI, RequiredAlign);
4892       }
4893     }
4894
4895     // (Offset % 16 or 32) must be multiple of 4. Then address is then
4896     // Ptr + (Offset & ~15).
4897     if (Offset < 0)
4898       return SDValue();
4899     if ((Offset % RequiredAlign) & 3)
4900       return SDValue();
4901     int64_t StartOffset = Offset & ~(RequiredAlign-1);
4902     if (StartOffset)
4903       Ptr = DAG.getNode(ISD::ADD, Ptr.getDebugLoc(), Ptr.getValueType(),
4904                         Ptr,DAG.getConstant(StartOffset, Ptr.getValueType()));
4905
4906     int EltNo = (Offset - StartOffset) >> 2;
4907     int NumElems = VT.getVectorNumElements();
4908
4909     EVT CanonVT = VT.getSizeInBits() == 128 ? MVT::v4i32 : MVT::v8i32;
4910     EVT NVT = EVT::getVectorVT(*DAG.getContext(), PVT, NumElems);
4911     SDValue V1 = DAG.getLoad(NVT, dl, Chain, Ptr,
4912                              LD->getPointerInfo().getWithOffset(StartOffset),
4913                              false, false, 0);
4914
4915     // Canonicalize it to a v4i32 or v8i32 shuffle.
4916     SmallVector<int, 8> Mask;
4917     for (int i = 0; i < NumElems; ++i)
4918       Mask.push_back(EltNo);
4919
4920     V1 = DAG.getNode(ISD::BITCAST, dl, CanonVT, V1);
4921     return DAG.getNode(ISD::BITCAST, dl, NVT,
4922                        DAG.getVectorShuffle(CanonVT, dl, V1,
4923                                             DAG.getUNDEF(CanonVT),&Mask[0]));
4924   }
4925
4926   return SDValue();
4927 }
4928
4929 /// EltsFromConsecutiveLoads - Given the initializing elements 'Elts' of a
4930 /// vector of type 'VT', see if the elements can be replaced by a single large
4931 /// load which has the same value as a build_vector whose operands are 'elts'.
4932 ///
4933 /// Example: <load i32 *a, load i32 *a+4, undef, undef> -> zextload a
4934 ///
4935 /// FIXME: we'd also like to handle the case where the last elements are zero
4936 /// rather than undef via VZEXT_LOAD, but we do not detect that case today.
4937 /// There's even a handy isZeroNode for that purpose.
4938 static SDValue EltsFromConsecutiveLoads(EVT VT, SmallVectorImpl<SDValue> &Elts,
4939                                         DebugLoc &DL, SelectionDAG &DAG) {
4940   EVT EltVT = VT.getVectorElementType();
4941   unsigned NumElems = Elts.size();
4942
4943   LoadSDNode *LDBase = NULL;
4944   unsigned LastLoadedElt = -1U;
4945
4946   // For each element in the initializer, see if we've found a load or an undef.
4947   // If we don't find an initial load element, or later load elements are
4948   // non-consecutive, bail out.
4949   for (unsigned i = 0; i < NumElems; ++i) {
4950     SDValue Elt = Elts[i];
4951
4952     if (!Elt.getNode() ||
4953         (Elt.getOpcode() != ISD::UNDEF && !ISD::isNON_EXTLoad(Elt.getNode())))
4954       return SDValue();
4955     if (!LDBase) {
4956       if (Elt.getNode()->getOpcode() == ISD::UNDEF)
4957         return SDValue();
4958       LDBase = cast<LoadSDNode>(Elt.getNode());
4959       LastLoadedElt = i;
4960       continue;
4961     }
4962     if (Elt.getOpcode() == ISD::UNDEF)
4963       continue;
4964
4965     LoadSDNode *LD = cast<LoadSDNode>(Elt);
4966     if (!DAG.isConsecutiveLoad(LD, LDBase, EltVT.getSizeInBits()/8, i))
4967       return SDValue();
4968     LastLoadedElt = i;
4969   }
4970
4971   // If we have found an entire vector of loads and undefs, then return a large
4972   // load of the entire vector width starting at the base pointer.  If we found
4973   // consecutive loads for the low half, generate a vzext_load node.
4974   if (LastLoadedElt == NumElems - 1) {
4975     if (DAG.InferPtrAlignment(LDBase->getBasePtr()) >= 16)
4976       return DAG.getLoad(VT, DL, LDBase->getChain(), LDBase->getBasePtr(),
4977                          LDBase->getPointerInfo(),
4978                          LDBase->isVolatile(), LDBase->isNonTemporal(), 0);
4979     return DAG.getLoad(VT, DL, LDBase->getChain(), LDBase->getBasePtr(),
4980                        LDBase->getPointerInfo(),
4981                        LDBase->isVolatile(), LDBase->isNonTemporal(),
4982                        LDBase->getAlignment());
4983   } else if (NumElems == 4 && LastLoadedElt == 1 &&
4984              DAG.getTargetLoweringInfo().isTypeLegal(MVT::v2i64)) {
4985     SDVTList Tys = DAG.getVTList(MVT::v2i64, MVT::Other);
4986     SDValue Ops[] = { LDBase->getChain(), LDBase->getBasePtr() };
4987     SDValue ResNode = DAG.getMemIntrinsicNode(X86ISD::VZEXT_LOAD, DL, Tys,
4988                                               Ops, 2, MVT::i32,
4989                                               LDBase->getMemOperand());
4990     return DAG.getNode(ISD::BITCAST, DL, VT, ResNode);
4991   }
4992   return SDValue();
4993 }
4994
4995 SDValue
4996 X86TargetLowering::LowerBUILD_VECTOR(SDValue Op, SelectionDAG &DAG) const {
4997   DebugLoc dl = Op.getDebugLoc();
4998
4999   EVT VT = Op.getValueType();
5000   EVT ExtVT = VT.getVectorElementType();
5001   unsigned NumElems = Op.getNumOperands();
5002
5003   // Vectors containing all zeros can be matched by pxor and xorps later
5004   if (ISD::isBuildVectorAllZeros(Op.getNode())) {
5005     // Canonicalize this to <4 x i32> to 1) ensure the zero vectors are CSE'd
5006     // and 2) ensure that i64 scalars are eliminated on x86-32 hosts.
5007     if (Op.getValueType() == MVT::v4i32 ||
5008         Op.getValueType() == MVT::v8i32)
5009       return Op;
5010
5011     return getZeroVector(Op.getValueType(), Subtarget->hasSSE2(), DAG, dl);
5012   }
5013
5014   // Vectors containing all ones can be matched by pcmpeqd on 128-bit width
5015   // vectors or broken into v4i32 operations on 256-bit vectors.
5016   if (ISD::isBuildVectorAllOnes(Op.getNode())) {
5017     if (Op.getValueType() == MVT::v4i32)
5018       return Op;
5019
5020     return getOnesVector(Op.getValueType(), DAG, dl);
5021   }
5022
5023   unsigned EVTBits = ExtVT.getSizeInBits();
5024
5025   unsigned NumZero  = 0;
5026   unsigned NumNonZero = 0;
5027   unsigned NonZeros = 0;
5028   bool IsAllConstants = true;
5029   SmallSet<SDValue, 8> Values;
5030   for (unsigned i = 0; i < NumElems; ++i) {
5031     SDValue Elt = Op.getOperand(i);
5032     if (Elt.getOpcode() == ISD::UNDEF)
5033       continue;
5034     Values.insert(Elt);
5035     if (Elt.getOpcode() != ISD::Constant &&
5036         Elt.getOpcode() != ISD::ConstantFP)
5037       IsAllConstants = false;
5038     if (X86::isZeroNode(Elt))
5039       NumZero++;
5040     else {
5041       NonZeros |= (1 << i);
5042       NumNonZero++;
5043     }
5044   }
5045
5046   // All undef vector. Return an UNDEF.  All zero vectors were handled above.
5047   if (NumNonZero == 0)
5048     return DAG.getUNDEF(VT);
5049
5050   // Special case for single non-zero, non-undef, element.
5051   if (NumNonZero == 1) {
5052     unsigned Idx = CountTrailingZeros_32(NonZeros);
5053     SDValue Item = Op.getOperand(Idx);
5054
5055     // If this is an insertion of an i64 value on x86-32, and if the top bits of
5056     // the value are obviously zero, truncate the value to i32 and do the
5057     // insertion that way.  Only do this if the value is non-constant or if the
5058     // value is a constant being inserted into element 0.  It is cheaper to do
5059     // a constant pool load than it is to do a movd + shuffle.
5060     if (ExtVT == MVT::i64 && !Subtarget->is64Bit() &&
5061         (!IsAllConstants || Idx == 0)) {
5062       if (DAG.MaskedValueIsZero(Item, APInt::getBitsSet(64, 32, 64))) {
5063         // Handle SSE only.
5064         assert(VT == MVT::v2i64 && "Expected an SSE value type!");
5065         EVT VecVT = MVT::v4i32;
5066         unsigned VecElts = 4;
5067
5068         // Truncate the value (which may itself be a constant) to i32, and
5069         // convert it to a vector with movd (S2V+shuffle to zero extend).
5070         Item = DAG.getNode(ISD::TRUNCATE, dl, MVT::i32, Item);
5071         Item = DAG.getNode(ISD::SCALAR_TO_VECTOR, dl, VecVT, Item);
5072         Item = getShuffleVectorZeroOrUndef(Item, 0, true,
5073                                            Subtarget->hasSSE2(), DAG);
5074
5075         // Now we have our 32-bit value zero extended in the low element of
5076         // a vector.  If Idx != 0, swizzle it into place.
5077         if (Idx != 0) {
5078           SmallVector<int, 4> Mask;
5079           Mask.push_back(Idx);
5080           for (unsigned i = 1; i != VecElts; ++i)
5081             Mask.push_back(i);
5082           Item = DAG.getVectorShuffle(VecVT, dl, Item,
5083                                       DAG.getUNDEF(Item.getValueType()),
5084                                       &Mask[0]);
5085         }
5086         return DAG.getNode(ISD::BITCAST, dl, Op.getValueType(), Item);
5087       }
5088     }
5089
5090     // If we have a constant or non-constant insertion into the low element of
5091     // a vector, we can do this with SCALAR_TO_VECTOR + shuffle of zero into
5092     // the rest of the elements.  This will be matched as movd/movq/movss/movsd
5093     // depending on what the source datatype is.
5094     if (Idx == 0) {
5095       if (NumZero == 0) {
5096         return DAG.getNode(ISD::SCALAR_TO_VECTOR, dl, VT, Item);
5097       } else if (ExtVT == MVT::i32 || ExtVT == MVT::f32 || ExtVT == MVT::f64 ||
5098           (ExtVT == MVT::i64 && Subtarget->is64Bit())) {
5099         Item = DAG.getNode(ISD::SCALAR_TO_VECTOR, dl, VT, Item);
5100         // Turn it into a MOVL (i.e. movss, movsd, or movd) to a zero vector.
5101         return getShuffleVectorZeroOrUndef(Item, 0, true, Subtarget->hasSSE2(),
5102                                            DAG);
5103       } else if (ExtVT == MVT::i16 || ExtVT == MVT::i8) {
5104         Item = DAG.getNode(ISD::ZERO_EXTEND, dl, MVT::i32, Item);
5105         assert(VT.getSizeInBits() == 128 && "Expected an SSE value type!");
5106         EVT MiddleVT = MVT::v4i32;
5107         Item = DAG.getNode(ISD::SCALAR_TO_VECTOR, dl, MiddleVT, Item);
5108         Item = getShuffleVectorZeroOrUndef(Item, 0, true,
5109                                            Subtarget->hasSSE2(), DAG);
5110         return DAG.getNode(ISD::BITCAST, dl, VT, Item);
5111       }
5112     }
5113
5114     // Is it a vector logical left shift?
5115     if (NumElems == 2 && Idx == 1 &&
5116         X86::isZeroNode(Op.getOperand(0)) &&
5117         !X86::isZeroNode(Op.getOperand(1))) {
5118       unsigned NumBits = VT.getSizeInBits();
5119       return getVShift(true, VT,
5120                        DAG.getNode(ISD::SCALAR_TO_VECTOR, dl,
5121                                    VT, Op.getOperand(1)),
5122                        NumBits/2, DAG, *this, dl);
5123     }
5124
5125     if (IsAllConstants) // Otherwise, it's better to do a constpool load.
5126       return SDValue();
5127
5128     // Otherwise, if this is a vector with i32 or f32 elements, and the element
5129     // is a non-constant being inserted into an element other than the low one,
5130     // we can't use a constant pool load.  Instead, use SCALAR_TO_VECTOR (aka
5131     // movd/movss) to move this into the low element, then shuffle it into
5132     // place.
5133     if (EVTBits == 32) {
5134       Item = DAG.getNode(ISD::SCALAR_TO_VECTOR, dl, VT, Item);
5135
5136       // Turn it into a shuffle of zero and zero-extended scalar to vector.
5137       Item = getShuffleVectorZeroOrUndef(Item, 0, NumZero > 0,
5138                                          Subtarget->hasSSE2(), DAG);
5139       SmallVector<int, 8> MaskVec;
5140       for (unsigned i = 0; i < NumElems; i++)
5141         MaskVec.push_back(i == Idx ? 0 : 1);
5142       return DAG.getVectorShuffle(VT, dl, Item, DAG.getUNDEF(VT), &MaskVec[0]);
5143     }
5144   }
5145
5146   // Splat is obviously ok. Let legalizer expand it to a shuffle.
5147   if (Values.size() == 1) {
5148     if (EVTBits == 32) {
5149       // Instead of a shuffle like this:
5150       // shuffle (scalar_to_vector (load (ptr + 4))), undef, <0, 0, 0, 0>
5151       // Check if it's possible to issue this instead.
5152       // shuffle (vload ptr)), undef, <1, 1, 1, 1>
5153       unsigned Idx = CountTrailingZeros_32(NonZeros);
5154       SDValue Item = Op.getOperand(Idx);
5155       if (Op.getNode()->isOnlyUserOf(Item.getNode()))
5156         return LowerAsSplatVectorLoad(Item, VT, dl, DAG);
5157     }
5158     return SDValue();
5159   }
5160
5161   // A vector full of immediates; various special cases are already
5162   // handled, so this is best done with a single constant-pool load.
5163   if (IsAllConstants)
5164     return SDValue();
5165
5166   // For AVX-length vectors, build the individual 128-bit pieces and use
5167   // shuffles to put them in place.
5168   if (VT.getSizeInBits() == 256 && !ISD::isBuildVectorAllZeros(Op.getNode())) {
5169     SmallVector<SDValue, 32> V;
5170     for (unsigned i = 0; i < NumElems; ++i)
5171       V.push_back(Op.getOperand(i));
5172
5173     EVT HVT = EVT::getVectorVT(*DAG.getContext(), ExtVT, NumElems/2);
5174
5175     // Build both the lower and upper subvector.
5176     SDValue Lower = DAG.getNode(ISD::BUILD_VECTOR, dl, HVT, &V[0], NumElems/2);
5177     SDValue Upper = DAG.getNode(ISD::BUILD_VECTOR, dl, HVT, &V[NumElems / 2],
5178                                 NumElems/2);
5179
5180     // Recreate the wider vector with the lower and upper part.
5181     SDValue Vec = Insert128BitVector(DAG.getNode(ISD::UNDEF, dl, VT), Lower,
5182                                 DAG.getConstant(0, MVT::i32), DAG, dl);
5183     return Insert128BitVector(Vec, Upper, DAG.getConstant(NumElems/2, MVT::i32),
5184                               DAG, dl);
5185   }
5186
5187   // Let legalizer expand 2-wide build_vectors.
5188   if (EVTBits == 64) {
5189     if (NumNonZero == 1) {
5190       // One half is zero or undef.
5191       unsigned Idx = CountTrailingZeros_32(NonZeros);
5192       SDValue V2 = DAG.getNode(ISD::SCALAR_TO_VECTOR, dl, VT,
5193                                  Op.getOperand(Idx));
5194       return getShuffleVectorZeroOrUndef(V2, Idx, true,
5195                                          Subtarget->hasSSE2(), DAG);
5196     }
5197     return SDValue();
5198   }
5199
5200   // If element VT is < 32 bits, convert it to inserts into a zero vector.
5201   if (EVTBits == 8 && NumElems == 16) {
5202     SDValue V = LowerBuildVectorv16i8(Op, NonZeros,NumNonZero,NumZero, DAG,
5203                                         *this);
5204     if (V.getNode()) return V;
5205   }
5206
5207   if (EVTBits == 16 && NumElems == 8) {
5208     SDValue V = LowerBuildVectorv8i16(Op, NonZeros,NumNonZero,NumZero, DAG,
5209                                       *this);
5210     if (V.getNode()) return V;
5211   }
5212
5213   // If element VT is == 32 bits, turn it into a number of shuffles.
5214   SmallVector<SDValue, 8> V;
5215   V.resize(NumElems);
5216   if (NumElems == 4 && NumZero > 0) {
5217     for (unsigned i = 0; i < 4; ++i) {
5218       bool isZero = !(NonZeros & (1 << i));
5219       if (isZero)
5220         V[i] = getZeroVector(VT, Subtarget->hasSSE2(), DAG, dl);
5221       else
5222         V[i] = DAG.getNode(ISD::SCALAR_TO_VECTOR, dl, VT, Op.getOperand(i));
5223     }
5224
5225     for (unsigned i = 0; i < 2; ++i) {
5226       switch ((NonZeros & (0x3 << i*2)) >> (i*2)) {
5227         default: break;
5228         case 0:
5229           V[i] = V[i*2];  // Must be a zero vector.
5230           break;
5231         case 1:
5232           V[i] = getMOVL(DAG, dl, VT, V[i*2+1], V[i*2]);
5233           break;
5234         case 2:
5235           V[i] = getMOVL(DAG, dl, VT, V[i*2], V[i*2+1]);
5236           break;
5237         case 3:
5238           V[i] = getUnpackl(DAG, dl, VT, V[i*2], V[i*2+1]);
5239           break;
5240       }
5241     }
5242
5243     SmallVector<int, 8> MaskVec;
5244     bool Reverse = (NonZeros & 0x3) == 2;
5245     for (unsigned i = 0; i < 2; ++i)
5246       MaskVec.push_back(Reverse ? 1-i : i);
5247     Reverse = ((NonZeros & (0x3 << 2)) >> 2) == 2;
5248     for (unsigned i = 0; i < 2; ++i)
5249       MaskVec.push_back(Reverse ? 1-i+NumElems : i+NumElems);
5250     return DAG.getVectorShuffle(VT, dl, V[0], V[1], &MaskVec[0]);
5251   }
5252
5253   if (Values.size() > 1 && VT.getSizeInBits() == 128) {
5254     // Check for a build vector of consecutive loads.
5255     for (unsigned i = 0; i < NumElems; ++i)
5256       V[i] = Op.getOperand(i);
5257
5258     // Check for elements which are consecutive loads.
5259     SDValue LD = EltsFromConsecutiveLoads(VT, V, dl, DAG);
5260     if (LD.getNode())
5261       return LD;
5262
5263     // For SSE 4.1, use insertps to put the high elements into the low element.
5264     if (getSubtarget()->hasSSE41()) {
5265       SDValue Result;
5266       if (Op.getOperand(0).getOpcode() != ISD::UNDEF)
5267         Result = DAG.getNode(ISD::SCALAR_TO_VECTOR, dl, VT, Op.getOperand(0));
5268       else
5269         Result = DAG.getUNDEF(VT);
5270
5271       for (unsigned i = 1; i < NumElems; ++i) {
5272         if (Op.getOperand(i).getOpcode() == ISD::UNDEF) continue;
5273         Result = DAG.getNode(ISD::INSERT_VECTOR_ELT, dl, VT, Result,
5274                              Op.getOperand(i), DAG.getIntPtrConstant(i));
5275       }
5276       return Result;
5277     }
5278
5279     // Otherwise, expand into a number of unpckl*, start by extending each of
5280     // our (non-undef) elements to the full vector width with the element in the
5281     // bottom slot of the vector (which generates no code for SSE).
5282     for (unsigned i = 0; i < NumElems; ++i) {
5283       if (Op.getOperand(i).getOpcode() != ISD::UNDEF)
5284         V[i] = DAG.getNode(ISD::SCALAR_TO_VECTOR, dl, VT, Op.getOperand(i));
5285       else
5286         V[i] = DAG.getUNDEF(VT);
5287     }
5288
5289     // Next, we iteratively mix elements, e.g. for v4f32:
5290     //   Step 1: unpcklps 0, 2 ==> X: <?, ?, 2, 0>
5291     //         : unpcklps 1, 3 ==> Y: <?, ?, 3, 1>
5292     //   Step 2: unpcklps X, Y ==>    <3, 2, 1, 0>
5293     unsigned EltStride = NumElems >> 1;
5294     while (EltStride != 0) {
5295       for (unsigned i = 0; i < EltStride; ++i) {
5296         // If V[i+EltStride] is undef and this is the first round of mixing,
5297         // then it is safe to just drop this shuffle: V[i] is already in the
5298         // right place, the one element (since it's the first round) being
5299         // inserted as undef can be dropped.  This isn't safe for successive
5300         // rounds because they will permute elements within both vectors.
5301         if (V[i+EltStride].getOpcode() == ISD::UNDEF &&
5302             EltStride == NumElems/2)
5303           continue;
5304
5305         V[i] = getUnpackl(DAG, dl, VT, V[i], V[i + EltStride]);
5306       }
5307       EltStride >>= 1;
5308     }
5309     return V[0];
5310   }
5311   return SDValue();
5312 }
5313
5314 // LowerMMXCONCAT_VECTORS - We support concatenate two MMX registers and place
5315 // them in a MMX register.  This is better than doing a stack convert.
5316 static SDValue LowerMMXCONCAT_VECTORS(SDValue Op, SelectionDAG &DAG) {
5317   DebugLoc dl = Op.getDebugLoc();
5318   EVT ResVT = Op.getValueType();
5319
5320   assert(ResVT == MVT::v2i64 || ResVT == MVT::v4i32 ||
5321          ResVT == MVT::v8i16 || ResVT == MVT::v16i8);
5322   int Mask[2];
5323   SDValue InVec = DAG.getNode(ISD::BITCAST,dl, MVT::v1i64, Op.getOperand(0));
5324   SDValue VecOp = DAG.getNode(X86ISD::MOVQ2DQ, dl, MVT::v2i64, InVec);
5325   InVec = Op.getOperand(1);
5326   if (InVec.getOpcode() == ISD::SCALAR_TO_VECTOR) {
5327     unsigned NumElts = ResVT.getVectorNumElements();
5328     VecOp = DAG.getNode(ISD::BITCAST, dl, ResVT, VecOp);
5329     VecOp = DAG.getNode(ISD::INSERT_VECTOR_ELT, dl, ResVT, VecOp,
5330                        InVec.getOperand(0), DAG.getIntPtrConstant(NumElts/2+1));
5331   } else {
5332     InVec = DAG.getNode(ISD::BITCAST, dl, MVT::v1i64, InVec);
5333     SDValue VecOp2 = DAG.getNode(X86ISD::MOVQ2DQ, dl, MVT::v2i64, InVec);
5334     Mask[0] = 0; Mask[1] = 2;
5335     VecOp = DAG.getVectorShuffle(MVT::v2i64, dl, VecOp, VecOp2, Mask);
5336   }
5337   return DAG.getNode(ISD::BITCAST, dl, ResVT, VecOp);
5338 }
5339
5340 // LowerAVXCONCAT_VECTORS - 256-bit AVX can use the vinsertf128 instruction
5341 // to create 256-bit vectors from two other 128-bit ones.
5342 static SDValue LowerAVXCONCAT_VECTORS(SDValue Op, SelectionDAG &DAG) {
5343   DebugLoc dl = Op.getDebugLoc();
5344   EVT ResVT = Op.getValueType();
5345
5346   assert(ResVT.getSizeInBits() == 256 && "Value type must be 256-bit wide");
5347
5348   SDValue V1 = Op.getOperand(0);
5349   SDValue V2 = Op.getOperand(1);
5350   unsigned NumElems = ResVT.getVectorNumElements();
5351
5352   SDValue V = Insert128BitVector(DAG.getNode(ISD::UNDEF, dl, ResVT), V1,
5353                                  DAG.getConstant(0, MVT::i32), DAG, dl);
5354   return Insert128BitVector(V, V2, DAG.getConstant(NumElems/2, MVT::i32),
5355                             DAG, dl);
5356 }
5357
5358 SDValue
5359 X86TargetLowering::LowerCONCAT_VECTORS(SDValue Op, SelectionDAG &DAG) const {
5360   EVT ResVT = Op.getValueType();
5361
5362   assert(Op.getNumOperands() == 2);
5363   assert((ResVT.getSizeInBits() == 128 || ResVT.getSizeInBits() == 256) &&
5364          "Unsupported CONCAT_VECTORS for value type");
5365
5366   // We support concatenate two MMX registers and place them in a MMX register.
5367   // This is better than doing a stack convert.
5368   if (ResVT.is128BitVector())
5369     return LowerMMXCONCAT_VECTORS(Op, DAG);
5370
5371   // 256-bit AVX can use the vinsertf128 instruction to create 256-bit vectors
5372   // from two other 128-bit ones.
5373   return LowerAVXCONCAT_VECTORS(Op, DAG);
5374 }
5375
5376 // v8i16 shuffles - Prefer shuffles in the following order:
5377 // 1. [all]   pshuflw, pshufhw, optional move
5378 // 2. [ssse3] 1 x pshufb
5379 // 3. [ssse3] 2 x pshufb + 1 x por
5380 // 4. [all]   mov + pshuflw + pshufhw + N x (pextrw + pinsrw)
5381 SDValue
5382 X86TargetLowering::LowerVECTOR_SHUFFLEv8i16(SDValue Op,
5383                                             SelectionDAG &DAG) const {
5384   ShuffleVectorSDNode *SVOp = cast<ShuffleVectorSDNode>(Op);
5385   SDValue V1 = SVOp->getOperand(0);
5386   SDValue V2 = SVOp->getOperand(1);
5387   DebugLoc dl = SVOp->getDebugLoc();
5388   SmallVector<int, 8> MaskVals;
5389
5390   // Determine if more than 1 of the words in each of the low and high quadwords
5391   // of the result come from the same quadword of one of the two inputs.  Undef
5392   // mask values count as coming from any quadword, for better codegen.
5393   SmallVector<unsigned, 4> LoQuad(4);
5394   SmallVector<unsigned, 4> HiQuad(4);
5395   BitVector InputQuads(4);
5396   for (unsigned i = 0; i < 8; ++i) {
5397     SmallVectorImpl<unsigned> &Quad = i < 4 ? LoQuad : HiQuad;
5398     int EltIdx = SVOp->getMaskElt(i);
5399     MaskVals.push_back(EltIdx);
5400     if (EltIdx < 0) {
5401       ++Quad[0];
5402       ++Quad[1];
5403       ++Quad[2];
5404       ++Quad[3];
5405       continue;
5406     }
5407     ++Quad[EltIdx / 4];
5408     InputQuads.set(EltIdx / 4);
5409   }
5410
5411   int BestLoQuad = -1;
5412   unsigned MaxQuad = 1;
5413   for (unsigned i = 0; i < 4; ++i) {
5414     if (LoQuad[i] > MaxQuad) {
5415       BestLoQuad = i;
5416       MaxQuad = LoQuad[i];
5417     }
5418   }
5419
5420   int BestHiQuad = -1;
5421   MaxQuad = 1;
5422   for (unsigned i = 0; i < 4; ++i) {
5423     if (HiQuad[i] > MaxQuad) {
5424       BestHiQuad = i;
5425       MaxQuad = HiQuad[i];
5426     }
5427   }
5428
5429   // For SSSE3, If all 8 words of the result come from only 1 quadword of each
5430   // of the two input vectors, shuffle them into one input vector so only a
5431   // single pshufb instruction is necessary. If There are more than 2 input
5432   // quads, disable the next transformation since it does not help SSSE3.
5433   bool V1Used = InputQuads[0] || InputQuads[1];
5434   bool V2Used = InputQuads[2] || InputQuads[3];
5435   if (Subtarget->hasSSSE3()) {
5436     if (InputQuads.count() == 2 && V1Used && V2Used) {
5437       BestLoQuad = InputQuads.find_first();
5438       BestHiQuad = InputQuads.find_next(BestLoQuad);
5439     }
5440     if (InputQuads.count() > 2) {
5441       BestLoQuad = -1;
5442       BestHiQuad = -1;
5443     }
5444   }
5445
5446   // If BestLoQuad or BestHiQuad are set, shuffle the quads together and update
5447   // the shuffle mask.  If a quad is scored as -1, that means that it contains
5448   // words from all 4 input quadwords.
5449   SDValue NewV;
5450   if (BestLoQuad >= 0 || BestHiQuad >= 0) {
5451     SmallVector<int, 8> MaskV;
5452     MaskV.push_back(BestLoQuad < 0 ? 0 : BestLoQuad);
5453     MaskV.push_back(BestHiQuad < 0 ? 1 : BestHiQuad);
5454     NewV = DAG.getVectorShuffle(MVT::v2i64, dl,
5455                   DAG.getNode(ISD::BITCAST, dl, MVT::v2i64, V1),
5456                   DAG.getNode(ISD::BITCAST, dl, MVT::v2i64, V2), &MaskV[0]);
5457     NewV = DAG.getNode(ISD::BITCAST, dl, MVT::v8i16, NewV);
5458
5459     // Rewrite the MaskVals and assign NewV to V1 if NewV now contains all the
5460     // source words for the shuffle, to aid later transformations.
5461     bool AllWordsInNewV = true;
5462     bool InOrder[2] = { true, true };
5463     for (unsigned i = 0; i != 8; ++i) {
5464       int idx = MaskVals[i];
5465       if (idx != (int)i)
5466         InOrder[i/4] = false;
5467       if (idx < 0 || (idx/4) == BestLoQuad || (idx/4) == BestHiQuad)
5468         continue;
5469       AllWordsInNewV = false;
5470       break;
5471     }
5472
5473     bool pshuflw = AllWordsInNewV, pshufhw = AllWordsInNewV;
5474     if (AllWordsInNewV) {
5475       for (int i = 0; i != 8; ++i) {
5476         int idx = MaskVals[i];
5477         if (idx < 0)
5478           continue;
5479         idx = MaskVals[i] = (idx / 4) == BestLoQuad ? (idx & 3) : (idx & 3) + 4;
5480         if ((idx != i) && idx < 4)
5481           pshufhw = false;
5482         if ((idx != i) && idx > 3)
5483           pshuflw = false;
5484       }
5485       V1 = NewV;
5486       V2Used = false;
5487       BestLoQuad = 0;
5488       BestHiQuad = 1;
5489     }
5490
5491     // If we've eliminated the use of V2, and the new mask is a pshuflw or
5492     // pshufhw, that's as cheap as it gets.  Return the new shuffle.
5493     if ((pshufhw && InOrder[0]) || (pshuflw && InOrder[1])) {
5494       unsigned Opc = pshufhw ? X86ISD::PSHUFHW : X86ISD::PSHUFLW;
5495       unsigned TargetMask = 0;
5496       NewV = DAG.getVectorShuffle(MVT::v8i16, dl, NewV,
5497                                   DAG.getUNDEF(MVT::v8i16), &MaskVals[0]);
5498       TargetMask = pshufhw ? X86::getShufflePSHUFHWImmediate(NewV.getNode()):
5499                              X86::getShufflePSHUFLWImmediate(NewV.getNode());
5500       V1 = NewV.getOperand(0);
5501       return getTargetShuffleNode(Opc, dl, MVT::v8i16, V1, TargetMask, DAG);
5502     }
5503   }
5504
5505   // If we have SSSE3, and all words of the result are from 1 input vector,
5506   // case 2 is generated, otherwise case 3 is generated.  If no SSSE3
5507   // is present, fall back to case 4.
5508   if (Subtarget->hasSSSE3()) {
5509     SmallVector<SDValue,16> pshufbMask;
5510
5511     // If we have elements from both input vectors, set the high bit of the
5512     // shuffle mask element to zero out elements that come from V2 in the V1
5513     // mask, and elements that come from V1 in the V2 mask, so that the two
5514     // results can be OR'd together.
5515     bool TwoInputs = V1Used && V2Used;
5516     for (unsigned i = 0; i != 8; ++i) {
5517       int EltIdx = MaskVals[i] * 2;
5518       if (TwoInputs && (EltIdx >= 16)) {
5519         pshufbMask.push_back(DAG.getConstant(0x80, MVT::i8));
5520         pshufbMask.push_back(DAG.getConstant(0x80, MVT::i8));
5521         continue;
5522       }
5523       pshufbMask.push_back(DAG.getConstant(EltIdx,   MVT::i8));
5524       pshufbMask.push_back(DAG.getConstant(EltIdx+1, MVT::i8));
5525     }
5526     V1 = DAG.getNode(ISD::BITCAST, dl, MVT::v16i8, V1);
5527     V1 = DAG.getNode(X86ISD::PSHUFB, dl, MVT::v16i8, V1,
5528                      DAG.getNode(ISD::BUILD_VECTOR, dl,
5529                                  MVT::v16i8, &pshufbMask[0], 16));
5530     if (!TwoInputs)
5531       return DAG.getNode(ISD::BITCAST, dl, MVT::v8i16, V1);
5532
5533     // Calculate the shuffle mask for the second input, shuffle it, and
5534     // OR it with the first shuffled input.
5535     pshufbMask.clear();
5536     for (unsigned i = 0; i != 8; ++i) {
5537       int EltIdx = MaskVals[i] * 2;
5538       if (EltIdx < 16) {
5539         pshufbMask.push_back(DAG.getConstant(0x80, MVT::i8));
5540         pshufbMask.push_back(DAG.getConstant(0x80, MVT::i8));
5541         continue;
5542       }
5543       pshufbMask.push_back(DAG.getConstant(EltIdx - 16, MVT::i8));
5544       pshufbMask.push_back(DAG.getConstant(EltIdx - 15, MVT::i8));
5545     }
5546     V2 = DAG.getNode(ISD::BITCAST, dl, MVT::v16i8, V2);
5547     V2 = DAG.getNode(X86ISD::PSHUFB, dl, MVT::v16i8, V2,
5548                      DAG.getNode(ISD::BUILD_VECTOR, dl,
5549                                  MVT::v16i8, &pshufbMask[0], 16));
5550     V1 = DAG.getNode(ISD::OR, dl, MVT::v16i8, V1, V2);
5551     return DAG.getNode(ISD::BITCAST, dl, MVT::v8i16, V1);
5552   }
5553
5554   // If BestLoQuad >= 0, generate a pshuflw to put the low elements in order,
5555   // and update MaskVals with new element order.
5556   BitVector InOrder(8);
5557   if (BestLoQuad >= 0) {
5558     SmallVector<int, 8> MaskV;
5559     for (int i = 0; i != 4; ++i) {
5560       int idx = MaskVals[i];
5561       if (idx < 0) {
5562         MaskV.push_back(-1);
5563         InOrder.set(i);
5564       } else if ((idx / 4) == BestLoQuad) {
5565         MaskV.push_back(idx & 3);
5566         InOrder.set(i);
5567       } else {
5568         MaskV.push_back(-1);
5569       }
5570     }
5571     for (unsigned i = 4; i != 8; ++i)
5572       MaskV.push_back(i);
5573     NewV = DAG.getVectorShuffle(MVT::v8i16, dl, NewV, DAG.getUNDEF(MVT::v8i16),
5574                                 &MaskV[0]);
5575
5576     if (NewV.getOpcode() == ISD::VECTOR_SHUFFLE && Subtarget->hasSSSE3())
5577       NewV = getTargetShuffleNode(X86ISD::PSHUFLW, dl, MVT::v8i16,
5578                                NewV.getOperand(0),
5579                                X86::getShufflePSHUFLWImmediate(NewV.getNode()),
5580                                DAG);
5581   }
5582
5583   // If BestHi >= 0, generate a pshufhw to put the high elements in order,
5584   // and update MaskVals with the new element order.
5585   if (BestHiQuad >= 0) {
5586     SmallVector<int, 8> MaskV;
5587     for (unsigned i = 0; i != 4; ++i)
5588       MaskV.push_back(i);
5589     for (unsigned i = 4; i != 8; ++i) {
5590       int idx = MaskVals[i];
5591       if (idx < 0) {
5592         MaskV.push_back(-1);
5593         InOrder.set(i);
5594       } else if ((idx / 4) == BestHiQuad) {
5595         MaskV.push_back((idx & 3) + 4);
5596         InOrder.set(i);
5597       } else {
5598         MaskV.push_back(-1);
5599       }
5600     }
5601     NewV = DAG.getVectorShuffle(MVT::v8i16, dl, NewV, DAG.getUNDEF(MVT::v8i16),
5602                                 &MaskV[0]);
5603
5604     if (NewV.getOpcode() == ISD::VECTOR_SHUFFLE && Subtarget->hasSSSE3())
5605       NewV = getTargetShuffleNode(X86ISD::PSHUFHW, dl, MVT::v8i16,
5606                               NewV.getOperand(0),
5607                               X86::getShufflePSHUFHWImmediate(NewV.getNode()),
5608                               DAG);
5609   }
5610
5611   // In case BestHi & BestLo were both -1, which means each quadword has a word
5612   // from each of the four input quadwords, calculate the InOrder bitvector now
5613   // before falling through to the insert/extract cleanup.
5614   if (BestLoQuad == -1 && BestHiQuad == -1) {
5615     NewV = V1;
5616     for (int i = 0; i != 8; ++i)
5617       if (MaskVals[i] < 0 || MaskVals[i] == i)
5618         InOrder.set(i);
5619   }
5620
5621   // The other elements are put in the right place using pextrw and pinsrw.
5622   for (unsigned i = 0; i != 8; ++i) {
5623     if (InOrder[i])
5624       continue;
5625     int EltIdx = MaskVals[i];
5626     if (EltIdx < 0)
5627       continue;
5628     SDValue ExtOp = (EltIdx < 8)
5629     ? DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, MVT::i16, V1,
5630                   DAG.getIntPtrConstant(EltIdx))
5631     : DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, MVT::i16, V2,
5632                   DAG.getIntPtrConstant(EltIdx - 8));
5633     NewV = DAG.getNode(ISD::INSERT_VECTOR_ELT, dl, MVT::v8i16, NewV, ExtOp,
5634                        DAG.getIntPtrConstant(i));
5635   }
5636   return NewV;
5637 }
5638
5639 // v16i8 shuffles - Prefer shuffles in the following order:
5640 // 1. [ssse3] 1 x pshufb
5641 // 2. [ssse3] 2 x pshufb + 1 x por
5642 // 3. [all]   v8i16 shuffle + N x pextrw + rotate + pinsrw
5643 static
5644 SDValue LowerVECTOR_SHUFFLEv16i8(ShuffleVectorSDNode *SVOp,
5645                                  SelectionDAG &DAG,
5646                                  const X86TargetLowering &TLI) {
5647   SDValue V1 = SVOp->getOperand(0);
5648   SDValue V2 = SVOp->getOperand(1);
5649   DebugLoc dl = SVOp->getDebugLoc();
5650   SmallVector<int, 16> MaskVals;
5651   SVOp->getMask(MaskVals);
5652
5653   // If we have SSSE3, case 1 is generated when all result bytes come from
5654   // one of  the inputs.  Otherwise, case 2 is generated.  If no SSSE3 is
5655   // present, fall back to case 3.
5656   // FIXME: kill V2Only once shuffles are canonizalized by getNode.
5657   bool V1Only = true;
5658   bool V2Only = true;
5659   for (unsigned i = 0; i < 16; ++i) {
5660     int EltIdx = MaskVals[i];
5661     if (EltIdx < 0)
5662       continue;
5663     if (EltIdx < 16)
5664       V2Only = false;
5665     else
5666       V1Only = false;
5667   }
5668
5669   // If SSSE3, use 1 pshufb instruction per vector with elements in the result.
5670   if (TLI.getSubtarget()->hasSSSE3()) {
5671     SmallVector<SDValue,16> pshufbMask;
5672
5673     // If all result elements are from one input vector, then only translate
5674     // undef mask values to 0x80 (zero out result) in the pshufb mask.
5675     //
5676     // Otherwise, we have elements from both input vectors, and must zero out
5677     // elements that come from V2 in the first mask, and V1 in the second mask
5678     // so that we can OR them together.
5679     bool TwoInputs = !(V1Only || V2Only);
5680     for (unsigned i = 0; i != 16; ++i) {
5681       int EltIdx = MaskVals[i];
5682       if (EltIdx < 0 || (TwoInputs && EltIdx >= 16)) {
5683         pshufbMask.push_back(DAG.getConstant(0x80, MVT::i8));
5684         continue;
5685       }
5686       pshufbMask.push_back(DAG.getConstant(EltIdx, MVT::i8));
5687     }
5688     // If all the elements are from V2, assign it to V1 and return after
5689     // building the first pshufb.
5690     if (V2Only)
5691       V1 = V2;
5692     V1 = DAG.getNode(X86ISD::PSHUFB, dl, MVT::v16i8, V1,
5693                      DAG.getNode(ISD::BUILD_VECTOR, dl,
5694                                  MVT::v16i8, &pshufbMask[0], 16));
5695     if (!TwoInputs)
5696       return V1;
5697
5698     // Calculate the shuffle mask for the second input, shuffle it, and
5699     // OR it with the first shuffled input.
5700     pshufbMask.clear();
5701     for (unsigned i = 0; i != 16; ++i) {
5702       int EltIdx = MaskVals[i];
5703       if (EltIdx < 16) {
5704         pshufbMask.push_back(DAG.getConstant(0x80, MVT::i8));
5705         continue;
5706       }
5707       pshufbMask.push_back(DAG.getConstant(EltIdx - 16, MVT::i8));
5708     }
5709     V2 = DAG.getNode(X86ISD::PSHUFB, dl, MVT::v16i8, V2,
5710                      DAG.getNode(ISD::BUILD_VECTOR, dl,
5711                                  MVT::v16i8, &pshufbMask[0], 16));
5712     return DAG.getNode(ISD::OR, dl, MVT::v16i8, V1, V2);
5713   }
5714
5715   // No SSSE3 - Calculate in place words and then fix all out of place words
5716   // With 0-16 extracts & inserts.  Worst case is 16 bytes out of order from
5717   // the 16 different words that comprise the two doublequadword input vectors.
5718   V1 = DAG.getNode(ISD::BITCAST, dl, MVT::v8i16, V1);
5719   V2 = DAG.getNode(ISD::BITCAST, dl, MVT::v8i16, V2);
5720   SDValue NewV = V2Only ? V2 : V1;
5721   for (int i = 0; i != 8; ++i) {
5722     int Elt0 = MaskVals[i*2];
5723     int Elt1 = MaskVals[i*2+1];
5724
5725     // This word of the result is all undef, skip it.
5726     if (Elt0 < 0 && Elt1 < 0)
5727       continue;
5728
5729     // This word of the result is already in the correct place, skip it.
5730     if (V1Only && (Elt0 == i*2) && (Elt1 == i*2+1))
5731       continue;
5732     if (V2Only && (Elt0 == i*2+16) && (Elt1 == i*2+17))
5733       continue;
5734
5735     SDValue Elt0Src = Elt0 < 16 ? V1 : V2;
5736     SDValue Elt1Src = Elt1 < 16 ? V1 : V2;
5737     SDValue InsElt;
5738
5739     // If Elt0 and Elt1 are defined, are consecutive, and can be load
5740     // using a single extract together, load it and store it.
5741     if ((Elt0 >= 0) && ((Elt0 + 1) == Elt1) && ((Elt0 & 1) == 0)) {
5742       InsElt = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, MVT::i16, Elt1Src,
5743                            DAG.getIntPtrConstant(Elt1 / 2));
5744       NewV = DAG.getNode(ISD::INSERT_VECTOR_ELT, dl, MVT::v8i16, NewV, InsElt,
5745                         DAG.getIntPtrConstant(i));
5746       continue;
5747     }
5748
5749     // If Elt1 is defined, extract it from the appropriate source.  If the
5750     // source byte is not also odd, shift the extracted word left 8 bits
5751     // otherwise clear the bottom 8 bits if we need to do an or.
5752     if (Elt1 >= 0) {
5753       InsElt = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, MVT::i16, Elt1Src,
5754                            DAG.getIntPtrConstant(Elt1 / 2));
5755       if ((Elt1 & 1) == 0)
5756         InsElt = DAG.getNode(ISD::SHL, dl, MVT::i16, InsElt,
5757                              DAG.getConstant(8,
5758                                   TLI.getShiftAmountTy(InsElt.getValueType())));
5759       else if (Elt0 >= 0)
5760         InsElt = DAG.getNode(ISD::AND, dl, MVT::i16, InsElt,
5761                              DAG.getConstant(0xFF00, MVT::i16));
5762     }
5763     // If Elt0 is defined, extract it from the appropriate source.  If the
5764     // source byte is not also even, shift the extracted word right 8 bits. If
5765     // Elt1 was also defined, OR the extracted values together before
5766     // inserting them in the result.
5767     if (Elt0 >= 0) {
5768       SDValue InsElt0 = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, MVT::i16,
5769                                     Elt0Src, DAG.getIntPtrConstant(Elt0 / 2));
5770       if ((Elt0 & 1) != 0)
5771         InsElt0 = DAG.getNode(ISD::SRL, dl, MVT::i16, InsElt0,
5772                               DAG.getConstant(8,
5773                                  TLI.getShiftAmountTy(InsElt0.getValueType())));
5774       else if (Elt1 >= 0)
5775         InsElt0 = DAG.getNode(ISD::AND, dl, MVT::i16, InsElt0,
5776                              DAG.getConstant(0x00FF, MVT::i16));
5777       InsElt = Elt1 >= 0 ? DAG.getNode(ISD::OR, dl, MVT::i16, InsElt, InsElt0)
5778                          : InsElt0;
5779     }
5780     NewV = DAG.getNode(ISD::INSERT_VECTOR_ELT, dl, MVT::v8i16, NewV, InsElt,
5781                        DAG.getIntPtrConstant(i));
5782   }
5783   return DAG.getNode(ISD::BITCAST, dl, MVT::v16i8, NewV);
5784 }
5785
5786 /// RewriteAsNarrowerShuffle - Try rewriting v8i16 and v16i8 shuffles as 4 wide
5787 /// ones, or rewriting v4i32 / v4f32 as 2 wide ones if possible. This can be
5788 /// done when every pair / quad of shuffle mask elements point to elements in
5789 /// the right sequence. e.g.
5790 /// vector_shuffle X, Y, <2, 3, | 10, 11, | 0, 1, | 14, 15>
5791 static
5792 SDValue RewriteAsNarrowerShuffle(ShuffleVectorSDNode *SVOp,
5793                                  SelectionDAG &DAG, DebugLoc dl) {
5794   EVT VT = SVOp->getValueType(0);
5795   SDValue V1 = SVOp->getOperand(0);
5796   SDValue V2 = SVOp->getOperand(1);
5797   unsigned NumElems = VT.getVectorNumElements();
5798   unsigned NewWidth = (NumElems == 4) ? 2 : 4;
5799   EVT NewVT;
5800   switch (VT.getSimpleVT().SimpleTy) {
5801   default: assert(false && "Unexpected!");
5802   case MVT::v4f32: NewVT = MVT::v2f64; break;
5803   case MVT::v4i32: NewVT = MVT::v2i64; break;
5804   case MVT::v8i16: NewVT = MVT::v4i32; break;
5805   case MVT::v16i8: NewVT = MVT::v4i32; break;
5806   }
5807
5808   int Scale = NumElems / NewWidth;
5809   SmallVector<int, 8> MaskVec;
5810   for (unsigned i = 0; i < NumElems; i += Scale) {
5811     int StartIdx = -1;
5812     for (int j = 0; j < Scale; ++j) {
5813       int EltIdx = SVOp->getMaskElt(i+j);
5814       if (EltIdx < 0)
5815         continue;
5816       if (StartIdx == -1)
5817         StartIdx = EltIdx - (EltIdx % Scale);
5818       if (EltIdx != StartIdx + j)
5819         return SDValue();
5820     }
5821     if (StartIdx == -1)
5822       MaskVec.push_back(-1);
5823     else
5824       MaskVec.push_back(StartIdx / Scale);
5825   }
5826
5827   V1 = DAG.getNode(ISD::BITCAST, dl, NewVT, V1);
5828   V2 = DAG.getNode(ISD::BITCAST, dl, NewVT, V2);
5829   return DAG.getVectorShuffle(NewVT, dl, V1, V2, &MaskVec[0]);
5830 }
5831
5832 /// getVZextMovL - Return a zero-extending vector move low node.
5833 ///
5834 static SDValue getVZextMovL(EVT VT, EVT OpVT,
5835                             SDValue SrcOp, SelectionDAG &DAG,
5836                             const X86Subtarget *Subtarget, DebugLoc dl) {
5837   if (VT == MVT::v2f64 || VT == MVT::v4f32) {
5838     LoadSDNode *LD = NULL;
5839     if (!isScalarLoadToVector(SrcOp.getNode(), &LD))
5840       LD = dyn_cast<LoadSDNode>(SrcOp);
5841     if (!LD) {
5842       // movssrr and movsdrr do not clear top bits. Try to use movd, movq
5843       // instead.
5844       MVT ExtVT = (OpVT == MVT::v2f64) ? MVT::i64 : MVT::i32;
5845       if ((ExtVT != MVT::i64 || Subtarget->is64Bit()) &&
5846           SrcOp.getOpcode() == ISD::SCALAR_TO_VECTOR &&
5847           SrcOp.getOperand(0).getOpcode() == ISD::BITCAST &&
5848           SrcOp.getOperand(0).getOperand(0).getValueType() == ExtVT) {
5849         // PR2108
5850         OpVT = (OpVT == MVT::v2f64) ? MVT::v2i64 : MVT::v4i32;
5851         return DAG.getNode(ISD::BITCAST, dl, VT,
5852                            DAG.getNode(X86ISD::VZEXT_MOVL, dl, OpVT,
5853                                        DAG.getNode(ISD::SCALAR_TO_VECTOR, dl,
5854                                                    OpVT,
5855                                                    SrcOp.getOperand(0)
5856                                                           .getOperand(0))));
5857       }
5858     }
5859   }
5860
5861   return DAG.getNode(ISD::BITCAST, dl, VT,
5862                      DAG.getNode(X86ISD::VZEXT_MOVL, dl, OpVT,
5863                                  DAG.getNode(ISD::BITCAST, dl,
5864                                              OpVT, SrcOp)));
5865 }
5866
5867 /// areShuffleHalvesWithinDisjointLanes - Check whether each half of a vector
5868 /// shuffle node referes to only one lane in the sources.
5869 static bool areShuffleHalvesWithinDisjointLanes(ShuffleVectorSDNode *SVOp) {
5870   EVT VT = SVOp->getValueType(0);
5871   int NumElems = VT.getVectorNumElements();
5872   int HalfSize = NumElems/2;
5873   SmallVector<int, 16> M;
5874   SVOp->getMask(M);
5875   bool MatchA = false, MatchB = false;
5876
5877   for (int l = 0; l < NumElems*2; l += HalfSize) {
5878     if (isUndefOrInRange(M, 0, HalfSize, l, l+HalfSize)) {
5879       MatchA = true;
5880       break;
5881     }
5882   }
5883
5884   for (int l = 0; l < NumElems*2; l += HalfSize) {
5885     if (isUndefOrInRange(M, HalfSize, HalfSize, l, l+HalfSize)) {
5886       MatchB = true;
5887       break;
5888     }
5889   }
5890
5891   return MatchA && MatchB;
5892 }
5893
5894 /// LowerVECTOR_SHUFFLE_256 - Handle all 256-bit wide vectors shuffles
5895 /// which could not be matched by any known target speficic shuffle
5896 static SDValue
5897 LowerVECTOR_SHUFFLE_256(ShuffleVectorSDNode *SVOp, SelectionDAG &DAG) {
5898   if (areShuffleHalvesWithinDisjointLanes(SVOp)) {
5899     // If each half of a vector shuffle node referes to only one lane in the
5900     // source vectors, extract each used 128-bit lane and shuffle them using
5901     // 128-bit shuffles. Then, concatenate the results. Otherwise leave
5902     // the work to the legalizer.
5903     DebugLoc dl = SVOp->getDebugLoc();
5904     EVT VT = SVOp->getValueType(0);
5905     int NumElems = VT.getVectorNumElements();
5906     int HalfSize = NumElems/2;
5907
5908     // Extract the reference for each half
5909     int FstVecExtractIdx = 0, SndVecExtractIdx = 0;
5910     int FstVecOpNum = 0, SndVecOpNum = 0;
5911     for (int i = 0; i < HalfSize; ++i) {
5912       int Elt = SVOp->getMaskElt(i);
5913       if (SVOp->getMaskElt(i) < 0)
5914         continue;
5915       FstVecOpNum = Elt/NumElems;
5916       FstVecExtractIdx = Elt % NumElems < HalfSize ? 0 : HalfSize;
5917       break;
5918     }
5919     for (int i = HalfSize; i < NumElems; ++i) {
5920       int Elt = SVOp->getMaskElt(i);
5921       if (SVOp->getMaskElt(i) < 0)
5922         continue;
5923       SndVecOpNum = Elt/NumElems;
5924       SndVecExtractIdx = Elt % NumElems < HalfSize ? 0 : HalfSize;
5925       break;
5926     }
5927
5928     // Extract the subvectors
5929     SDValue V1 = Extract128BitVector(SVOp->getOperand(FstVecOpNum),
5930                       DAG.getConstant(FstVecExtractIdx, MVT::i32), DAG, dl);
5931     SDValue V2 = Extract128BitVector(SVOp->getOperand(SndVecOpNum),
5932                       DAG.getConstant(SndVecExtractIdx, MVT::i32), DAG, dl);
5933
5934     // Generate 128-bit shuffles
5935     SmallVector<int, 16> MaskV1, MaskV2;
5936     for (int i = 0; i < HalfSize; ++i) {
5937       int Elt = SVOp->getMaskElt(i);
5938       MaskV1.push_back(Elt < 0 ? Elt : Elt % HalfSize);
5939     }
5940     for (int i = HalfSize; i < NumElems; ++i) {
5941       int Elt = SVOp->getMaskElt(i);
5942       MaskV2.push_back(Elt < 0 ? Elt : Elt % HalfSize);
5943     }
5944
5945     EVT NVT = V1.getValueType();
5946     V1 = DAG.getVectorShuffle(NVT, dl, V1, DAG.getUNDEF(NVT), &MaskV1[0]);
5947     V2 = DAG.getVectorShuffle(NVT, dl, V2, DAG.getUNDEF(NVT), &MaskV2[0]);
5948
5949     // Concatenate the result back
5950     SDValue V = Insert128BitVector(DAG.getNode(ISD::UNDEF, dl, VT), V1,
5951                                    DAG.getConstant(0, MVT::i32), DAG, dl);
5952     return Insert128BitVector(V, V2, DAG.getConstant(NumElems/2, MVT::i32),
5953                               DAG, dl);
5954   }
5955
5956   return SDValue();
5957 }
5958
5959 /// LowerVECTOR_SHUFFLE_128v4 - Handle all 128-bit wide vectors with
5960 /// 4 elements, and match them with several different shuffle types.
5961 static SDValue
5962 LowerVECTOR_SHUFFLE_128v4(ShuffleVectorSDNode *SVOp, SelectionDAG &DAG) {
5963   SDValue V1 = SVOp->getOperand(0);
5964   SDValue V2 = SVOp->getOperand(1);
5965   DebugLoc dl = SVOp->getDebugLoc();
5966   EVT VT = SVOp->getValueType(0);
5967
5968   assert(VT.getSizeInBits() == 128 && "Unsupported vector size");
5969
5970   SmallVector<std::pair<int, int>, 8> Locs;
5971   Locs.resize(4);
5972   SmallVector<int, 8> Mask1(4U, -1);
5973   SmallVector<int, 8> PermMask;
5974   SVOp->getMask(PermMask);
5975
5976   unsigned NumHi = 0;
5977   unsigned NumLo = 0;
5978   for (unsigned i = 0; i != 4; ++i) {
5979     int Idx = PermMask[i];
5980     if (Idx < 0) {
5981       Locs[i] = std::make_pair(-1, -1);
5982     } else {
5983       assert(Idx < 8 && "Invalid VECTOR_SHUFFLE index!");
5984       if (Idx < 4) {
5985         Locs[i] = std::make_pair(0, NumLo);
5986         Mask1[NumLo] = Idx;
5987         NumLo++;
5988       } else {
5989         Locs[i] = std::make_pair(1, NumHi);
5990         if (2+NumHi < 4)
5991           Mask1[2+NumHi] = Idx;
5992         NumHi++;
5993       }
5994     }
5995   }
5996
5997   if (NumLo <= 2 && NumHi <= 2) {
5998     // If no more than two elements come from either vector. This can be
5999     // implemented with two shuffles. First shuffle gather the elements.
6000     // The second shuffle, which takes the first shuffle as both of its
6001     // vector operands, put the elements into the right order.
6002     V1 = DAG.getVectorShuffle(VT, dl, V1, V2, &Mask1[0]);
6003
6004     SmallVector<int, 8> Mask2(4U, -1);
6005
6006     for (unsigned i = 0; i != 4; ++i) {
6007       if (Locs[i].first == -1)
6008         continue;
6009       else {
6010         unsigned Idx = (i < 2) ? 0 : 4;
6011         Idx += Locs[i].first * 2 + Locs[i].second;
6012         Mask2[i] = Idx;
6013       }
6014     }
6015
6016     return DAG.getVectorShuffle(VT, dl, V1, V1, &Mask2[0]);
6017   } else if (NumLo == 3 || NumHi == 3) {
6018     // Otherwise, we must have three elements from one vector, call it X, and
6019     // one element from the other, call it Y.  First, use a shufps to build an
6020     // intermediate vector with the one element from Y and the element from X
6021     // that will be in the same half in the final destination (the indexes don't
6022     // matter). Then, use a shufps to build the final vector, taking the half
6023     // containing the element from Y from the intermediate, and the other half
6024     // from X.
6025     if (NumHi == 3) {
6026       // Normalize it so the 3 elements come from V1.
6027       CommuteVectorShuffleMask(PermMask, VT);
6028       std::swap(V1, V2);
6029     }
6030
6031     // Find the element from V2.
6032     unsigned HiIndex;
6033     for (HiIndex = 0; HiIndex < 3; ++HiIndex) {
6034       int Val = PermMask[HiIndex];
6035       if (Val < 0)
6036         continue;
6037       if (Val >= 4)
6038         break;
6039     }
6040
6041     Mask1[0] = PermMask[HiIndex];
6042     Mask1[1] = -1;
6043     Mask1[2] = PermMask[HiIndex^1];
6044     Mask1[3] = -1;
6045     V2 = DAG.getVectorShuffle(VT, dl, V1, V2, &Mask1[0]);
6046
6047     if (HiIndex >= 2) {
6048       Mask1[0] = PermMask[0];
6049       Mask1[1] = PermMask[1];
6050       Mask1[2] = HiIndex & 1 ? 6 : 4;
6051       Mask1[3] = HiIndex & 1 ? 4 : 6;
6052       return DAG.getVectorShuffle(VT, dl, V1, V2, &Mask1[0]);
6053     } else {
6054       Mask1[0] = HiIndex & 1 ? 2 : 0;
6055       Mask1[1] = HiIndex & 1 ? 0 : 2;
6056       Mask1[2] = PermMask[2];
6057       Mask1[3] = PermMask[3];
6058       if (Mask1[2] >= 0)
6059         Mask1[2] += 4;
6060       if (Mask1[3] >= 0)
6061         Mask1[3] += 4;
6062       return DAG.getVectorShuffle(VT, dl, V2, V1, &Mask1[0]);
6063     }
6064   }
6065
6066   // Break it into (shuffle shuffle_hi, shuffle_lo).
6067   Locs.clear();
6068   Locs.resize(4);
6069   SmallVector<int,8> LoMask(4U, -1);
6070   SmallVector<int,8> HiMask(4U, -1);
6071
6072   SmallVector<int,8> *MaskPtr = &LoMask;
6073   unsigned MaskIdx = 0;
6074   unsigned LoIdx = 0;
6075   unsigned HiIdx = 2;
6076   for (unsigned i = 0; i != 4; ++i) {
6077     if (i == 2) {
6078       MaskPtr = &HiMask;
6079       MaskIdx = 1;
6080       LoIdx = 0;
6081       HiIdx = 2;
6082     }
6083     int Idx = PermMask[i];
6084     if (Idx < 0) {
6085       Locs[i] = std::make_pair(-1, -1);
6086     } else if (Idx < 4) {
6087       Locs[i] = std::make_pair(MaskIdx, LoIdx);
6088       (*MaskPtr)[LoIdx] = Idx;
6089       LoIdx++;
6090     } else {
6091       Locs[i] = std::make_pair(MaskIdx, HiIdx);
6092       (*MaskPtr)[HiIdx] = Idx;
6093       HiIdx++;
6094     }
6095   }
6096
6097   SDValue LoShuffle = DAG.getVectorShuffle(VT, dl, V1, V2, &LoMask[0]);
6098   SDValue HiShuffle = DAG.getVectorShuffle(VT, dl, V1, V2, &HiMask[0]);
6099   SmallVector<int, 8> MaskOps;
6100   for (unsigned i = 0; i != 4; ++i) {
6101     if (Locs[i].first == -1) {
6102       MaskOps.push_back(-1);
6103     } else {
6104       unsigned Idx = Locs[i].first * 4 + Locs[i].second;
6105       MaskOps.push_back(Idx);
6106     }
6107   }
6108   return DAG.getVectorShuffle(VT, dl, LoShuffle, HiShuffle, &MaskOps[0]);
6109 }
6110
6111 static bool MayFoldVectorLoad(SDValue V) {
6112   if (V.hasOneUse() && V.getOpcode() == ISD::BITCAST)
6113     V = V.getOperand(0);
6114   if (V.hasOneUse() && V.getOpcode() == ISD::SCALAR_TO_VECTOR)
6115     V = V.getOperand(0);
6116   if (MayFoldLoad(V))
6117     return true;
6118   return false;
6119 }
6120
6121 // FIXME: the version above should always be used. Since there's
6122 // a bug where several vector shuffles can't be folded because the
6123 // DAG is not updated during lowering and a node claims to have two
6124 // uses while it only has one, use this version, and let isel match
6125 // another instruction if the load really happens to have more than
6126 // one use. Remove this version after this bug get fixed.
6127 // rdar://8434668, PR8156
6128 static bool RelaxedMayFoldVectorLoad(SDValue V) {
6129   if (V.hasOneUse() && V.getOpcode() == ISD::BITCAST)
6130     V = V.getOperand(0);
6131   if (V.hasOneUse() && V.getOpcode() == ISD::SCALAR_TO_VECTOR)
6132     V = V.getOperand(0);
6133   if (ISD::isNormalLoad(V.getNode()))
6134     return true;
6135   return false;
6136 }
6137
6138 /// CanFoldShuffleIntoVExtract - Check if the current shuffle is used by
6139 /// a vector extract, and if both can be later optimized into a single load.
6140 /// This is done in visitEXTRACT_VECTOR_ELT and the conditions are checked
6141 /// here because otherwise a target specific shuffle node is going to be
6142 /// emitted for this shuffle, and the optimization not done.
6143 /// FIXME: This is probably not the best approach, but fix the problem
6144 /// until the right path is decided.
6145 static
6146 bool CanXFormVExtractWithShuffleIntoLoad(SDValue V, SelectionDAG &DAG,
6147                                          const TargetLowering &TLI) {
6148   EVT VT = V.getValueType();
6149   ShuffleVectorSDNode *SVOp = dyn_cast<ShuffleVectorSDNode>(V);
6150
6151   // Be sure that the vector shuffle is present in a pattern like this:
6152   // (vextract (v4f32 shuffle (load $addr), <1,u,u,u>), c) -> (f32 load $addr)
6153   if (!V.hasOneUse())
6154     return false;
6155
6156   SDNode *N = *V.getNode()->use_begin();
6157   if (N->getOpcode() != ISD::EXTRACT_VECTOR_ELT)
6158     return false;
6159
6160   SDValue EltNo = N->getOperand(1);
6161   if (!isa<ConstantSDNode>(EltNo))
6162     return false;
6163
6164   // If the bit convert changed the number of elements, it is unsafe
6165   // to examine the mask.
6166   bool HasShuffleIntoBitcast = false;
6167   if (V.getOpcode() == ISD::BITCAST) {
6168     EVT SrcVT = V.getOperand(0).getValueType();
6169     if (SrcVT.getVectorNumElements() != VT.getVectorNumElements())
6170       return false;
6171     V = V.getOperand(0);
6172     HasShuffleIntoBitcast = true;
6173   }
6174
6175   // Select the input vector, guarding against out of range extract vector.
6176   unsigned NumElems = VT.getVectorNumElements();
6177   unsigned Elt = cast<ConstantSDNode>(EltNo)->getZExtValue();
6178   int Idx = (Elt > NumElems) ? -1 : SVOp->getMaskElt(Elt);
6179   V = (Idx < (int)NumElems) ? V.getOperand(0) : V.getOperand(1);
6180
6181   // Skip one more bit_convert if necessary
6182   if (V.getOpcode() == ISD::BITCAST)
6183     V = V.getOperand(0);
6184
6185   if (ISD::isNormalLoad(V.getNode())) {
6186     // Is the original load suitable?
6187     LoadSDNode *LN0 = cast<LoadSDNode>(V);
6188
6189     // FIXME: avoid the multi-use bug that is preventing lots of
6190     // of foldings to be detected, this is still wrong of course, but
6191     // give the temporary desired behavior, and if it happens that
6192     // the load has real more uses, during isel it will not fold, and
6193     // will generate poor code.
6194     if (!LN0 || LN0->isVolatile()) // || !LN0->hasOneUse()
6195       return false;
6196
6197     if (!HasShuffleIntoBitcast)
6198       return true;
6199
6200     // If there's a bitcast before the shuffle, check if the load type and
6201     // alignment is valid.
6202     unsigned Align = LN0->getAlignment();
6203     unsigned NewAlign =
6204       TLI.getTargetData()->getABITypeAlignment(
6205                                     VT.getTypeForEVT(*DAG.getContext()));
6206
6207     if (NewAlign > Align || !TLI.isOperationLegalOrCustom(ISD::LOAD, VT))
6208       return false;
6209   }
6210
6211   return true;
6212 }
6213
6214 static
6215 SDValue getMOVDDup(SDValue &Op, DebugLoc &dl, SDValue V1, SelectionDAG &DAG) {
6216   EVT VT = Op.getValueType();
6217
6218   // Canonizalize to v2f64.
6219   V1 = DAG.getNode(ISD::BITCAST, dl, MVT::v2f64, V1);
6220   return DAG.getNode(ISD::BITCAST, dl, VT,
6221                      getTargetShuffleNode(X86ISD::MOVDDUP, dl, MVT::v2f64,
6222                                           V1, DAG));
6223 }
6224
6225 static
6226 SDValue getMOVLowToHigh(SDValue &Op, DebugLoc &dl, SelectionDAG &DAG,
6227                         bool HasSSE2) {
6228   SDValue V1 = Op.getOperand(0);
6229   SDValue V2 = Op.getOperand(1);
6230   EVT VT = Op.getValueType();
6231
6232   assert(VT != MVT::v2i64 && "unsupported shuffle type");
6233
6234   if (HasSSE2 && VT == MVT::v2f64)
6235     return getTargetShuffleNode(X86ISD::MOVLHPD, dl, VT, V1, V2, DAG);
6236
6237   // v4f32 or v4i32
6238   return getTargetShuffleNode(X86ISD::MOVLHPS, dl, VT, V1, V2, DAG);
6239 }
6240
6241 static
6242 SDValue getMOVHighToLow(SDValue &Op, DebugLoc &dl, SelectionDAG &DAG) {
6243   SDValue V1 = Op.getOperand(0);
6244   SDValue V2 = Op.getOperand(1);
6245   EVT VT = Op.getValueType();
6246
6247   assert((VT == MVT::v4i32 || VT == MVT::v4f32) &&
6248          "unsupported shuffle type");
6249
6250   if (V2.getOpcode() == ISD::UNDEF)
6251     V2 = V1;
6252
6253   // v4i32 or v4f32
6254   return getTargetShuffleNode(X86ISD::MOVHLPS, dl, VT, V1, V2, DAG);
6255 }
6256
6257 static inline unsigned getSHUFPOpcode(EVT VT) {
6258   switch(VT.getSimpleVT().SimpleTy) {
6259   case MVT::v8i32: // Use fp unit for int unpack.
6260   case MVT::v8f32:
6261   case MVT::v4i32: // Use fp unit for int unpack.
6262   case MVT::v4f32: return X86ISD::SHUFPS;
6263   case MVT::v4i64: // Use fp unit for int unpack.
6264   case MVT::v4f64:
6265   case MVT::v2i64: // Use fp unit for int unpack.
6266   case MVT::v2f64: return X86ISD::SHUFPD;
6267   default:
6268     llvm_unreachable("Unknown type for shufp*");
6269   }
6270   return 0;
6271 }
6272
6273 static
6274 SDValue getMOVLP(SDValue &Op, DebugLoc &dl, SelectionDAG &DAG, bool HasSSE2) {
6275   SDValue V1 = Op.getOperand(0);
6276   SDValue V2 = Op.getOperand(1);
6277   EVT VT = Op.getValueType();
6278   unsigned NumElems = VT.getVectorNumElements();
6279
6280   // Use MOVLPS and MOVLPD in case V1 or V2 are loads. During isel, the second
6281   // operand of these instructions is only memory, so check if there's a
6282   // potencial load folding here, otherwise use SHUFPS or MOVSD to match the
6283   // same masks.
6284   bool CanFoldLoad = false;
6285
6286   // Trivial case, when V2 comes from a load.
6287   if (MayFoldVectorLoad(V2))
6288     CanFoldLoad = true;
6289
6290   // When V1 is a load, it can be folded later into a store in isel, example:
6291   //  (store (v4f32 (X86Movlps (load addr:$src1), VR128:$src2)), addr:$src1)
6292   //    turns into:
6293   //  (MOVLPSmr addr:$src1, VR128:$src2)
6294   // So, recognize this potential and also use MOVLPS or MOVLPD
6295   if (MayFoldVectorLoad(V1) && MayFoldIntoStore(Op))
6296     CanFoldLoad = true;
6297
6298   // Both of them can't be memory operations though.
6299   if (MayFoldVectorLoad(V1) && MayFoldVectorLoad(V2))
6300     CanFoldLoad = false;
6301
6302   if (CanFoldLoad) {
6303     if (HasSSE2 && NumElems == 2)
6304       return getTargetShuffleNode(X86ISD::MOVLPD, dl, VT, V1, V2, DAG);
6305
6306     if (NumElems == 4)
6307       return getTargetShuffleNode(X86ISD::MOVLPS, dl, VT, V1, V2, DAG);
6308   }
6309
6310   ShuffleVectorSDNode *SVOp = cast<ShuffleVectorSDNode>(Op);
6311   // movl and movlp will both match v2i64, but v2i64 is never matched by
6312   // movl earlier because we make it strict to avoid messing with the movlp load
6313   // folding logic (see the code above getMOVLP call). Match it here then,
6314   // this is horrible, but will stay like this until we move all shuffle
6315   // matching to x86 specific nodes. Note that for the 1st condition all
6316   // types are matched with movsd.
6317   if ((HasSSE2 && NumElems == 2) || !X86::isMOVLMask(SVOp))
6318     return getTargetShuffleNode(X86ISD::MOVSD, dl, VT, V1, V2, DAG);
6319   else if (HasSSE2)
6320     return getTargetShuffleNode(X86ISD::MOVSS, dl, VT, V1, V2, DAG);
6321
6322
6323   assert(VT != MVT::v4i32 && "unsupported shuffle type");
6324
6325   // Invert the operand order and use SHUFPS to match it.
6326   return getTargetShuffleNode(getSHUFPOpcode(VT), dl, VT, V2, V1,
6327                               X86::getShuffleSHUFImmediate(SVOp), DAG);
6328 }
6329
6330 static inline unsigned getUNPCKLOpcode(EVT VT) {
6331   switch(VT.getSimpleVT().SimpleTy) {
6332   case MVT::v4i32: return X86ISD::PUNPCKLDQ;
6333   case MVT::v2i64: return X86ISD::PUNPCKLQDQ;
6334   case MVT::v4f32: return X86ISD::UNPCKLPS;
6335   case MVT::v2f64: return X86ISD::UNPCKLPD;
6336   case MVT::v8i32: // Use fp unit for int unpack.
6337   case MVT::v8f32: return X86ISD::VUNPCKLPSY;
6338   case MVT::v4i64: // Use fp unit for int unpack.
6339   case MVT::v4f64: return X86ISD::VUNPCKLPDY;
6340   case MVT::v16i8: return X86ISD::PUNPCKLBW;
6341   case MVT::v8i16: return X86ISD::PUNPCKLWD;
6342   default:
6343     llvm_unreachable("Unknown type for unpckl");
6344   }
6345   return 0;
6346 }
6347
6348 static inline unsigned getUNPCKHOpcode(EVT VT) {
6349   switch(VT.getSimpleVT().SimpleTy) {
6350   case MVT::v4i32: return X86ISD::PUNPCKHDQ;
6351   case MVT::v2i64: return X86ISD::PUNPCKHQDQ;
6352   case MVT::v4f32: return X86ISD::UNPCKHPS;
6353   case MVT::v2f64: return X86ISD::UNPCKHPD;
6354   case MVT::v8i32: // Use fp unit for int unpack.
6355   case MVT::v8f32: return X86ISD::VUNPCKHPSY;
6356   case MVT::v4i64: // Use fp unit for int unpack.
6357   case MVT::v4f64: return X86ISD::VUNPCKHPDY;
6358   case MVT::v16i8: return X86ISD::PUNPCKHBW;
6359   case MVT::v8i16: return X86ISD::PUNPCKHWD;
6360   default:
6361     llvm_unreachable("Unknown type for unpckh");
6362   }
6363   return 0;
6364 }
6365
6366 static inline unsigned getVPERMILOpcode(EVT VT) {
6367   switch(VT.getSimpleVT().SimpleTy) {
6368   case MVT::v4i32:
6369   case MVT::v4f32: return X86ISD::VPERMILPS;
6370   case MVT::v2i64:
6371   case MVT::v2f64: return X86ISD::VPERMILPD;
6372   case MVT::v8i32:
6373   case MVT::v8f32: return X86ISD::VPERMILPSY;
6374   case MVT::v4i64:
6375   case MVT::v4f64: return X86ISD::VPERMILPDY;
6376   default:
6377     llvm_unreachable("Unknown type for vpermil");
6378   }
6379   return 0;
6380 }
6381
6382 /// isVectorBroadcast - Check if the node chain is suitable to be xformed to
6383 /// a vbroadcast node. The nodes are suitable whenever we can fold a load coming
6384 /// from a 32 or 64 bit scalar. Update Op to the desired load to be folded.
6385 static bool isVectorBroadcast(SDValue &Op) {
6386   EVT VT = Op.getValueType();
6387   bool Is256 = VT.getSizeInBits() == 256;
6388
6389   assert((VT.getSizeInBits() == 128 || Is256) &&
6390          "Unsupported type for vbroadcast node");
6391
6392   SDValue V = Op;
6393   if (V.hasOneUse() && V.getOpcode() == ISD::BITCAST)
6394     V = V.getOperand(0);
6395
6396   if (Is256 && !(V.hasOneUse() &&
6397                  V.getOpcode() == ISD::INSERT_SUBVECTOR &&
6398                  V.getOperand(0).getOpcode() == ISD::UNDEF))
6399     return false;
6400
6401   if (Is256)
6402     V = V.getOperand(1);
6403   if (V.hasOneUse() && V.getOpcode() != ISD::SCALAR_TO_VECTOR)
6404     return false;
6405
6406   // Check the source scalar_to_vector type. 256-bit broadcasts are
6407   // supported for 32/64-bit sizes, while 128-bit ones are only supported
6408   // for 32-bit scalars.
6409   unsigned ScalarSize = V.getOperand(0).getValueType().getSizeInBits();
6410   if (ScalarSize != 32 && ScalarSize != 64)
6411     return false;
6412   if (!Is256 && ScalarSize == 64)
6413     return false;
6414
6415   V = V.getOperand(0);
6416   if (!MayFoldLoad(V))
6417     return false;
6418
6419   // Return the load node
6420   Op = V;
6421   return true;
6422 }
6423
6424 static
6425 SDValue NormalizeVectorShuffle(SDValue Op, SelectionDAG &DAG,
6426                                const TargetLowering &TLI,
6427                                const X86Subtarget *Subtarget) {
6428   ShuffleVectorSDNode *SVOp = cast<ShuffleVectorSDNode>(Op);
6429   EVT VT = Op.getValueType();
6430   DebugLoc dl = Op.getDebugLoc();
6431   SDValue V1 = Op.getOperand(0);
6432   SDValue V2 = Op.getOperand(1);
6433
6434   if (isZeroShuffle(SVOp))
6435     return getZeroVector(VT, Subtarget->hasSSE2(), DAG, dl);
6436
6437   // Handle splat operations
6438   if (SVOp->isSplat()) {
6439     unsigned NumElem = VT.getVectorNumElements();
6440     int Size = VT.getSizeInBits();
6441     // Special case, this is the only place now where it's allowed to return
6442     // a vector_shuffle operation without using a target specific node, because
6443     // *hopefully* it will be optimized away by the dag combiner. FIXME: should
6444     // this be moved to DAGCombine instead?
6445     if (NumElem <= 4 && CanXFormVExtractWithShuffleIntoLoad(Op, DAG, TLI))
6446       return Op;
6447
6448     // Use vbroadcast whenever the splat comes from a foldable load
6449     if (Subtarget->hasAVX() && isVectorBroadcast(V1))
6450       return DAG.getNode(X86ISD::VBROADCAST, dl, VT, V1);
6451
6452     // Handle splats by matching through known shuffle masks
6453     if ((Size == 128 && NumElem <= 4) ||
6454         (Size == 256 && NumElem < 8))
6455       return SDValue();
6456
6457     // All remaning splats are promoted to target supported vector shuffles.
6458     return PromoteSplat(SVOp, DAG);
6459   }
6460
6461   // If the shuffle can be profitably rewritten as a narrower shuffle, then
6462   // do it!
6463   if (VT == MVT::v8i16 || VT == MVT::v16i8) {
6464     SDValue NewOp = RewriteAsNarrowerShuffle(SVOp, DAG, dl);
6465     if (NewOp.getNode())
6466       return DAG.getNode(ISD::BITCAST, dl, VT, NewOp);
6467   } else if ((VT == MVT::v4i32 || (VT == MVT::v4f32 && Subtarget->hasSSE2()))) {
6468     // FIXME: Figure out a cleaner way to do this.
6469     // Try to make use of movq to zero out the top part.
6470     if (ISD::isBuildVectorAllZeros(V2.getNode())) {
6471       SDValue NewOp = RewriteAsNarrowerShuffle(SVOp, DAG, dl);
6472       if (NewOp.getNode()) {
6473         if (isCommutedMOVL(cast<ShuffleVectorSDNode>(NewOp), true, false))
6474           return getVZextMovL(VT, NewOp.getValueType(), NewOp.getOperand(0),
6475                               DAG, Subtarget, dl);
6476       }
6477     } else if (ISD::isBuildVectorAllZeros(V1.getNode())) {
6478       SDValue NewOp = RewriteAsNarrowerShuffle(SVOp, DAG, dl);
6479       if (NewOp.getNode() && X86::isMOVLMask(cast<ShuffleVectorSDNode>(NewOp)))
6480         return getVZextMovL(VT, NewOp.getValueType(), NewOp.getOperand(1),
6481                             DAG, Subtarget, dl);
6482     }
6483   }
6484   return SDValue();
6485 }
6486
6487 SDValue
6488 X86TargetLowering::LowerVECTOR_SHUFFLE(SDValue Op, SelectionDAG &DAG) const {
6489   ShuffleVectorSDNode *SVOp = cast<ShuffleVectorSDNode>(Op);
6490   SDValue V1 = Op.getOperand(0);
6491   SDValue V2 = Op.getOperand(1);
6492   EVT VT = Op.getValueType();
6493   DebugLoc dl = Op.getDebugLoc();
6494   unsigned NumElems = VT.getVectorNumElements();
6495   bool isMMX = VT.getSizeInBits() == 64;
6496   bool V1IsUndef = V1.getOpcode() == ISD::UNDEF;
6497   bool V2IsUndef = V2.getOpcode() == ISD::UNDEF;
6498   bool V1IsSplat = false;
6499   bool V2IsSplat = false;
6500   bool HasSSE2 = Subtarget->hasSSE2() || Subtarget->hasAVX();
6501   bool HasSSE3 = Subtarget->hasSSE3() || Subtarget->hasAVX();
6502   bool HasSSSE3 = Subtarget->hasSSSE3() || Subtarget->hasAVX();
6503   MachineFunction &MF = DAG.getMachineFunction();
6504   bool OptForSize = MF.getFunction()->hasFnAttr(Attribute::OptimizeForSize);
6505
6506   // Shuffle operations on MMX not supported.
6507   if (isMMX)
6508     return Op;
6509
6510   // Vector shuffle lowering takes 3 steps:
6511   //
6512   // 1) Normalize the input vectors. Here splats, zeroed vectors, profitable
6513   //    narrowing and commutation of operands should be handled.
6514   // 2) Matching of shuffles with known shuffle masks to x86 target specific
6515   //    shuffle nodes.
6516   // 3) Rewriting of unmatched masks into new generic shuffle operations,
6517   //    so the shuffle can be broken into other shuffles and the legalizer can
6518   //    try the lowering again.
6519   //
6520   // The general ideia is that no vector_shuffle operation should be left to
6521   // be matched during isel, all of them must be converted to a target specific
6522   // node here.
6523
6524   // Normalize the input vectors. Here splats, zeroed vectors, profitable
6525   // narrowing and commutation of operands should be handled. The actual code
6526   // doesn't include all of those, work in progress...
6527   SDValue NewOp = NormalizeVectorShuffle(Op, DAG, *this, Subtarget);
6528   if (NewOp.getNode())
6529     return NewOp;
6530
6531   // NOTE: isPSHUFDMask can also match both masks below (unpckl_undef and
6532   // unpckh_undef). Only use pshufd if speed is more important than size.
6533   if (OptForSize && X86::isUNPCKL_v_undef_Mask(SVOp))
6534     return getTargetShuffleNode(getUNPCKLOpcode(VT), dl, VT, V1, V1, DAG);
6535   if (OptForSize && X86::isUNPCKH_v_undef_Mask(SVOp))
6536     return getTargetShuffleNode(getUNPCKHOpcode(VT), dl, VT, V1, V1, DAG);
6537
6538   if (X86::isMOVDDUPMask(SVOp) && HasSSE3 && V2IsUndef &&
6539       RelaxedMayFoldVectorLoad(V1))
6540     return getMOVDDup(Op, dl, V1, DAG);
6541
6542   if (X86::isMOVHLPS_v_undef_Mask(SVOp))
6543     return getMOVHighToLow(Op, dl, DAG);
6544
6545   // Use to match splats
6546   if (HasSSE2 && X86::isUNPCKHMask(SVOp) && V2IsUndef &&
6547       (VT == MVT::v2f64 || VT == MVT::v2i64))
6548     return getTargetShuffleNode(getUNPCKHOpcode(VT), dl, VT, V1, V1, DAG);
6549
6550   if (X86::isPSHUFDMask(SVOp)) {
6551     // The actual implementation will match the mask in the if above and then
6552     // during isel it can match several different instructions, not only pshufd
6553     // as its name says, sad but true, emulate the behavior for now...
6554     if (X86::isMOVDDUPMask(SVOp) && ((VT == MVT::v4f32 || VT == MVT::v2i64)))
6555         return getTargetShuffleNode(X86ISD::MOVLHPS, dl, VT, V1, V1, DAG);
6556
6557     unsigned TargetMask = X86::getShuffleSHUFImmediate(SVOp);
6558
6559     if (HasSSE2 && (VT == MVT::v4f32 || VT == MVT::v4i32))
6560       return getTargetShuffleNode(X86ISD::PSHUFD, dl, VT, V1, TargetMask, DAG);
6561
6562     return getTargetShuffleNode(getSHUFPOpcode(VT), dl, VT, V1, V1,
6563                                 TargetMask, DAG);
6564   }
6565
6566   // Check if this can be converted into a logical shift.
6567   bool isLeft = false;
6568   unsigned ShAmt = 0;
6569   SDValue ShVal;
6570   bool isShift = getSubtarget()->hasSSE2() &&
6571     isVectorShift(SVOp, DAG, isLeft, ShVal, ShAmt);
6572   if (isShift && ShVal.hasOneUse()) {
6573     // If the shifted value has multiple uses, it may be cheaper to use
6574     // v_set0 + movlhps or movhlps, etc.
6575     EVT EltVT = VT.getVectorElementType();
6576     ShAmt *= EltVT.getSizeInBits();
6577     return getVShift(isLeft, VT, ShVal, ShAmt, DAG, *this, dl);
6578   }
6579
6580   if (X86::isMOVLMask(SVOp)) {
6581     if (V1IsUndef)
6582       return V2;
6583     if (ISD::isBuildVectorAllZeros(V1.getNode()))
6584       return getVZextMovL(VT, VT, V2, DAG, Subtarget, dl);
6585     if (!X86::isMOVLPMask(SVOp)) {
6586       if (HasSSE2 && (VT == MVT::v2i64 || VT == MVT::v2f64))
6587         return getTargetShuffleNode(X86ISD::MOVSD, dl, VT, V1, V2, DAG);
6588
6589       if (VT == MVT::v4i32 || VT == MVT::v4f32)
6590         return getTargetShuffleNode(X86ISD::MOVSS, dl, VT, V1, V2, DAG);
6591     }
6592   }
6593
6594   // FIXME: fold these into legal mask.
6595   if (X86::isMOVLHPSMask(SVOp) && !X86::isUNPCKLMask(SVOp))
6596     return getMOVLowToHigh(Op, dl, DAG, HasSSE2);
6597
6598   if (X86::isMOVHLPSMask(SVOp))
6599     return getMOVHighToLow(Op, dl, DAG);
6600
6601   if (X86::isMOVSHDUPMask(SVOp, Subtarget))
6602     return getTargetShuffleNode(X86ISD::MOVSHDUP, dl, VT, V1, DAG);
6603
6604   if (X86::isMOVSLDUPMask(SVOp, Subtarget))
6605     return getTargetShuffleNode(X86ISD::MOVSLDUP, dl, VT, V1, DAG);
6606
6607   if (X86::isMOVLPMask(SVOp))
6608     return getMOVLP(Op, dl, DAG, HasSSE2);
6609
6610   if (ShouldXformToMOVHLPS(SVOp) ||
6611       ShouldXformToMOVLP(V1.getNode(), V2.getNode(), SVOp))
6612     return CommuteVectorShuffle(SVOp, DAG);
6613
6614   if (isShift) {
6615     // No better options. Use a vshl / vsrl.
6616     EVT EltVT = VT.getVectorElementType();
6617     ShAmt *= EltVT.getSizeInBits();
6618     return getVShift(isLeft, VT, ShVal, ShAmt, DAG, *this, dl);
6619   }
6620
6621   bool Commuted = false;
6622   // FIXME: This should also accept a bitcast of a splat?  Be careful, not
6623   // 1,1,1,1 -> v8i16 though.
6624   V1IsSplat = isSplatVector(V1.getNode());
6625   V2IsSplat = isSplatVector(V2.getNode());
6626
6627   // Canonicalize the splat or undef, if present, to be on the RHS.
6628   if ((V1IsSplat || V1IsUndef) && !(V2IsSplat || V2IsUndef)) {
6629     Op = CommuteVectorShuffle(SVOp, DAG);
6630     SVOp = cast<ShuffleVectorSDNode>(Op);
6631     V1 = SVOp->getOperand(0);
6632     V2 = SVOp->getOperand(1);
6633     std::swap(V1IsSplat, V2IsSplat);
6634     std::swap(V1IsUndef, V2IsUndef);
6635     Commuted = true;
6636   }
6637
6638   if (isCommutedMOVL(SVOp, V2IsSplat, V2IsUndef)) {
6639     // Shuffling low element of v1 into undef, just return v1.
6640     if (V2IsUndef)
6641       return V1;
6642     // If V2 is a splat, the mask may be malformed such as <4,3,3,3>, which
6643     // the instruction selector will not match, so get a canonical MOVL with
6644     // swapped operands to undo the commute.
6645     return getMOVL(DAG, dl, VT, V2, V1);
6646   }
6647
6648   if (X86::isUNPCKLMask(SVOp))
6649     return getTargetShuffleNode(getUNPCKLOpcode(VT), dl, VT, V1, V2, DAG);
6650
6651   if (X86::isUNPCKHMask(SVOp))
6652     return getTargetShuffleNode(getUNPCKHOpcode(VT), dl, VT, V1, V2, DAG);
6653
6654   if (V2IsSplat) {
6655     // Normalize mask so all entries that point to V2 points to its first
6656     // element then try to match unpck{h|l} again. If match, return a
6657     // new vector_shuffle with the corrected mask.
6658     SDValue NewMask = NormalizeMask(SVOp, DAG);
6659     ShuffleVectorSDNode *NSVOp = cast<ShuffleVectorSDNode>(NewMask);
6660     if (NSVOp != SVOp) {
6661       if (X86::isUNPCKLMask(NSVOp, true)) {
6662         return NewMask;
6663       } else if (X86::isUNPCKHMask(NSVOp, true)) {
6664         return NewMask;
6665       }
6666     }
6667   }
6668
6669   if (Commuted) {
6670     // Commute is back and try unpck* again.
6671     // FIXME: this seems wrong.
6672     SDValue NewOp = CommuteVectorShuffle(SVOp, DAG);
6673     ShuffleVectorSDNode *NewSVOp = cast<ShuffleVectorSDNode>(NewOp);
6674
6675     if (X86::isUNPCKLMask(NewSVOp))
6676       return getTargetShuffleNode(getUNPCKLOpcode(VT), dl, VT, V2, V1, DAG);
6677
6678     if (X86::isUNPCKHMask(NewSVOp))
6679       return getTargetShuffleNode(getUNPCKHOpcode(VT), dl, VT, V2, V1, DAG);
6680   }
6681
6682   // Normalize the node to match x86 shuffle ops if needed
6683   if (V2.getOpcode() != ISD::UNDEF && isCommutedSHUFP(SVOp))
6684     return CommuteVectorShuffle(SVOp, DAG);
6685
6686   // The checks below are all present in isShuffleMaskLegal, but they are
6687   // inlined here right now to enable us to directly emit target specific
6688   // nodes, and remove one by one until they don't return Op anymore.
6689   SmallVector<int, 16> M;
6690   SVOp->getMask(M);
6691
6692   if (isPALIGNRMask(M, VT, HasSSSE3))
6693     return getTargetShuffleNode(X86ISD::PALIGN, dl, VT, V1, V2,
6694                                 X86::getShufflePALIGNRImmediate(SVOp),
6695                                 DAG);
6696
6697   if (ShuffleVectorSDNode::isSplatMask(&M[0], VT) &&
6698       SVOp->getSplatIndex() == 0 && V2IsUndef) {
6699     if (VT == MVT::v2f64)
6700       return getTargetShuffleNode(X86ISD::UNPCKLPD, dl, VT, V1, V1, DAG);
6701     if (VT == MVT::v2i64)
6702       return getTargetShuffleNode(X86ISD::PUNPCKLQDQ, dl, VT, V1, V1, DAG);
6703   }
6704
6705   if (isPSHUFHWMask(M, VT))
6706     return getTargetShuffleNode(X86ISD::PSHUFHW, dl, VT, V1,
6707                                 X86::getShufflePSHUFHWImmediate(SVOp),
6708                                 DAG);
6709
6710   if (isPSHUFLWMask(M, VT))
6711     return getTargetShuffleNode(X86ISD::PSHUFLW, dl, VT, V1,
6712                                 X86::getShufflePSHUFLWImmediate(SVOp),
6713                                 DAG);
6714
6715   if (isSHUFPMask(M, VT))
6716     return getTargetShuffleNode(getSHUFPOpcode(VT), dl, VT, V1, V2,
6717                                 X86::getShuffleSHUFImmediate(SVOp), DAG);
6718
6719   if (X86::isUNPCKL_v_undef_Mask(SVOp))
6720     return getTargetShuffleNode(getUNPCKLOpcode(VT), dl, VT, V1, V1, DAG);
6721   if (X86::isUNPCKH_v_undef_Mask(SVOp))
6722     return getTargetShuffleNode(getUNPCKHOpcode(VT), dl, VT, V1, V1, DAG);
6723
6724   //===--------------------------------------------------------------------===//
6725   // Generate target specific nodes for 128 or 256-bit shuffles only
6726   // supported in the AVX instruction set.
6727   //
6728
6729   // Handle VMOVDDUPY permutations
6730   if (isMOVDDUPYMask(SVOp, Subtarget))
6731     return getTargetShuffleNode(X86ISD::MOVDDUP, dl, VT, V1, DAG);
6732
6733   // Handle VPERMILPS* permutations
6734   if (isVPERMILPSMask(M, VT, Subtarget))
6735     return getTargetShuffleNode(getVPERMILOpcode(VT), dl, VT, V1,
6736                                 getShuffleVPERMILPSImmediate(SVOp), DAG);
6737
6738   // Handle VPERMILPD* permutations
6739   if (isVPERMILPDMask(M, VT, Subtarget))
6740     return getTargetShuffleNode(getVPERMILOpcode(VT), dl, VT, V1,
6741                                 getShuffleVPERMILPDImmediate(SVOp), DAG);
6742
6743   // Handle VPERM2F128 permutations
6744   if (isVPERM2F128Mask(M, VT, Subtarget))
6745     return getTargetShuffleNode(X86ISD::VPERM2F128, dl, VT, V1, V2,
6746                                 getShuffleVPERM2F128Immediate(SVOp), DAG);
6747
6748   // Handle VSHUFPSY permutations
6749   if (isVSHUFPSYMask(M, VT, Subtarget))
6750     return getTargetShuffleNode(getSHUFPOpcode(VT), dl, VT, V1, V2,
6751                                 getShuffleVSHUFPSYImmediate(SVOp), DAG);
6752
6753   // Handle VSHUFPDY permutations
6754   if (isVSHUFPDYMask(M, VT, Subtarget))
6755     return getTargetShuffleNode(getSHUFPOpcode(VT), dl, VT, V1, V2,
6756                                 getShuffleVSHUFPDYImmediate(SVOp), DAG);
6757
6758   //===--------------------------------------------------------------------===//
6759   // Since no target specific shuffle was selected for this generic one,
6760   // lower it into other known shuffles. FIXME: this isn't true yet, but
6761   // this is the plan.
6762   //
6763
6764   // Handle v8i16 specifically since SSE can do byte extraction and insertion.
6765   if (VT == MVT::v8i16) {
6766     SDValue NewOp = LowerVECTOR_SHUFFLEv8i16(Op, DAG);
6767     if (NewOp.getNode())
6768       return NewOp;
6769   }
6770
6771   if (VT == MVT::v16i8) {
6772     SDValue NewOp = LowerVECTOR_SHUFFLEv16i8(SVOp, DAG, *this);
6773     if (NewOp.getNode())
6774       return NewOp;
6775   }
6776
6777   // Handle all 128-bit wide vectors with 4 elements, and match them with
6778   // several different shuffle types.
6779   if (NumElems == 4 && VT.getSizeInBits() == 128)
6780     return LowerVECTOR_SHUFFLE_128v4(SVOp, DAG);
6781
6782   // Handle general 256-bit shuffles
6783   if (VT.is256BitVector())
6784     return LowerVECTOR_SHUFFLE_256(SVOp, DAG);
6785
6786   return SDValue();
6787 }
6788
6789 SDValue
6790 X86TargetLowering::LowerEXTRACT_VECTOR_ELT_SSE4(SDValue Op,
6791                                                 SelectionDAG &DAG) const {
6792   EVT VT = Op.getValueType();
6793   DebugLoc dl = Op.getDebugLoc();
6794
6795   if (Op.getOperand(0).getValueType().getSizeInBits() != 128)
6796     return SDValue();
6797
6798   if (VT.getSizeInBits() == 8) {
6799     SDValue Extract = DAG.getNode(X86ISD::PEXTRB, dl, MVT::i32,
6800                                     Op.getOperand(0), Op.getOperand(1));
6801     SDValue Assert  = DAG.getNode(ISD::AssertZext, dl, MVT::i32, Extract,
6802                                     DAG.getValueType(VT));
6803     return DAG.getNode(ISD::TRUNCATE, dl, VT, Assert);
6804   } else if (VT.getSizeInBits() == 16) {
6805     unsigned Idx = cast<ConstantSDNode>(Op.getOperand(1))->getZExtValue();
6806     // If Idx is 0, it's cheaper to do a move instead of a pextrw.
6807     if (Idx == 0)
6808       return DAG.getNode(ISD::TRUNCATE, dl, MVT::i16,
6809                          DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, MVT::i32,
6810                                      DAG.getNode(ISD::BITCAST, dl,
6811                                                  MVT::v4i32,
6812                                                  Op.getOperand(0)),
6813                                      Op.getOperand(1)));
6814     SDValue Extract = DAG.getNode(X86ISD::PEXTRW, dl, MVT::i32,
6815                                     Op.getOperand(0), Op.getOperand(1));
6816     SDValue Assert  = DAG.getNode(ISD::AssertZext, dl, MVT::i32, Extract,
6817                                     DAG.getValueType(VT));
6818     return DAG.getNode(ISD::TRUNCATE, dl, VT, Assert);
6819   } else if (VT == MVT::f32) {
6820     // EXTRACTPS outputs to a GPR32 register which will require a movd to copy
6821     // the result back to FR32 register. It's only worth matching if the
6822     // result has a single use which is a store or a bitcast to i32.  And in
6823     // the case of a store, it's not worth it if the index is a constant 0,
6824     // because a MOVSSmr can be used instead, which is smaller and faster.
6825     if (!Op.hasOneUse())
6826       return SDValue();
6827     SDNode *User = *Op.getNode()->use_begin();
6828     if ((User->getOpcode() != ISD::STORE ||
6829          (isa<ConstantSDNode>(Op.getOperand(1)) &&
6830           cast<ConstantSDNode>(Op.getOperand(1))->isNullValue())) &&
6831         (User->getOpcode() != ISD::BITCAST ||
6832          User->getValueType(0) != MVT::i32))
6833       return SDValue();
6834     SDValue Extract = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, MVT::i32,
6835                                   DAG.getNode(ISD::BITCAST, dl, MVT::v4i32,
6836                                               Op.getOperand(0)),
6837                                               Op.getOperand(1));
6838     return DAG.getNode(ISD::BITCAST, dl, MVT::f32, Extract);
6839   } else if (VT == MVT::i32) {
6840     // ExtractPS works with constant index.
6841     if (isa<ConstantSDNode>(Op.getOperand(1)))
6842       return Op;
6843   }
6844   return SDValue();
6845 }
6846
6847
6848 SDValue
6849 X86TargetLowering::LowerEXTRACT_VECTOR_ELT(SDValue Op,
6850                                            SelectionDAG &DAG) const {
6851   if (!isa<ConstantSDNode>(Op.getOperand(1)))
6852     return SDValue();
6853
6854   SDValue Vec = Op.getOperand(0);
6855   EVT VecVT = Vec.getValueType();
6856
6857   // If this is a 256-bit vector result, first extract the 128-bit vector and
6858   // then extract the element from the 128-bit vector.
6859   if (VecVT.getSizeInBits() == 256) {
6860     DebugLoc dl = Op.getNode()->getDebugLoc();
6861     unsigned NumElems = VecVT.getVectorNumElements();
6862     SDValue Idx = Op.getOperand(1);
6863     unsigned IdxVal = cast<ConstantSDNode>(Idx)->getZExtValue();
6864
6865     // Get the 128-bit vector.
6866     bool Upper = IdxVal >= NumElems/2;
6867     Vec = Extract128BitVector(Vec,
6868                     DAG.getConstant(Upper ? NumElems/2 : 0, MVT::i32), DAG, dl);
6869
6870     return DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, Op.getValueType(), Vec,
6871                     Upper ? DAG.getConstant(IdxVal-NumElems/2, MVT::i32) : Idx);
6872   }
6873
6874   assert(Vec.getValueSizeInBits() <= 128 && "Unexpected vector length");
6875
6876   if (Subtarget->hasSSE41() || Subtarget->hasAVX()) {
6877     SDValue Res = LowerEXTRACT_VECTOR_ELT_SSE4(Op, DAG);
6878     if (Res.getNode())
6879       return Res;
6880   }
6881
6882   EVT VT = Op.getValueType();
6883   DebugLoc dl = Op.getDebugLoc();
6884   // TODO: handle v16i8.
6885   if (VT.getSizeInBits() == 16) {
6886     SDValue Vec = Op.getOperand(0);
6887     unsigned Idx = cast<ConstantSDNode>(Op.getOperand(1))->getZExtValue();
6888     if (Idx == 0)
6889       return DAG.getNode(ISD::TRUNCATE, dl, MVT::i16,
6890                          DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, MVT::i32,
6891                                      DAG.getNode(ISD::BITCAST, dl,
6892                                                  MVT::v4i32, Vec),
6893                                      Op.getOperand(1)));
6894     // Transform it so it match pextrw which produces a 32-bit result.
6895     EVT EltVT = MVT::i32;
6896     SDValue Extract = DAG.getNode(X86ISD::PEXTRW, dl, EltVT,
6897                                     Op.getOperand(0), Op.getOperand(1));
6898     SDValue Assert  = DAG.getNode(ISD::AssertZext, dl, EltVT, Extract,
6899                                     DAG.getValueType(VT));
6900     return DAG.getNode(ISD::TRUNCATE, dl, VT, Assert);
6901   } else if (VT.getSizeInBits() == 32) {
6902     unsigned Idx = cast<ConstantSDNode>(Op.getOperand(1))->getZExtValue();
6903     if (Idx == 0)
6904       return Op;
6905
6906     // SHUFPS the element to the lowest double word, then movss.
6907     int Mask[4] = { static_cast<int>(Idx), -1, -1, -1 };
6908     EVT VVT = Op.getOperand(0).getValueType();
6909     SDValue Vec = DAG.getVectorShuffle(VVT, dl, Op.getOperand(0),
6910                                        DAG.getUNDEF(VVT), Mask);
6911     return DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, VT, Vec,
6912                        DAG.getIntPtrConstant(0));
6913   } else if (VT.getSizeInBits() == 64) {
6914     // FIXME: .td only matches this for <2 x f64>, not <2 x i64> on 32b
6915     // FIXME: seems like this should be unnecessary if mov{h,l}pd were taught
6916     //        to match extract_elt for f64.
6917     unsigned Idx = cast<ConstantSDNode>(Op.getOperand(1))->getZExtValue();
6918     if (Idx == 0)
6919       return Op;
6920
6921     // UNPCKHPD the element to the lowest double word, then movsd.
6922     // Note if the lower 64 bits of the result of the UNPCKHPD is then stored
6923     // to a f64mem, the whole operation is folded into a single MOVHPDmr.
6924     int Mask[2] = { 1, -1 };
6925     EVT VVT = Op.getOperand(0).getValueType();
6926     SDValue Vec = DAG.getVectorShuffle(VVT, dl, Op.getOperand(0),
6927                                        DAG.getUNDEF(VVT), Mask);
6928     return DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, VT, Vec,
6929                        DAG.getIntPtrConstant(0));
6930   }
6931
6932   return SDValue();
6933 }
6934
6935 SDValue
6936 X86TargetLowering::LowerINSERT_VECTOR_ELT_SSE4(SDValue Op,
6937                                                SelectionDAG &DAG) const {
6938   EVT VT = Op.getValueType();
6939   EVT EltVT = VT.getVectorElementType();
6940   DebugLoc dl = Op.getDebugLoc();
6941
6942   SDValue N0 = Op.getOperand(0);
6943   SDValue N1 = Op.getOperand(1);
6944   SDValue N2 = Op.getOperand(2);
6945
6946   if (VT.getSizeInBits() == 256)
6947     return SDValue();
6948
6949   if ((EltVT.getSizeInBits() == 8 || EltVT.getSizeInBits() == 16) &&
6950       isa<ConstantSDNode>(N2)) {
6951     unsigned Opc;
6952     if (VT == MVT::v8i16)
6953       Opc = X86ISD::PINSRW;
6954     else if (VT == MVT::v16i8)
6955       Opc = X86ISD::PINSRB;
6956     else
6957       Opc = X86ISD::PINSRB;
6958
6959     // Transform it so it match pinsr{b,w} which expects a GR32 as its second
6960     // argument.
6961     if (N1.getValueType() != MVT::i32)
6962       N1 = DAG.getNode(ISD::ANY_EXTEND, dl, MVT::i32, N1);
6963     if (N2.getValueType() != MVT::i32)
6964       N2 = DAG.getIntPtrConstant(cast<ConstantSDNode>(N2)->getZExtValue());
6965     return DAG.getNode(Opc, dl, VT, N0, N1, N2);
6966   } else if (EltVT == MVT::f32 && isa<ConstantSDNode>(N2)) {
6967     // Bits [7:6] of the constant are the source select.  This will always be
6968     //  zero here.  The DAG Combiner may combine an extract_elt index into these
6969     //  bits.  For example (insert (extract, 3), 2) could be matched by putting
6970     //  the '3' into bits [7:6] of X86ISD::INSERTPS.
6971     // Bits [5:4] of the constant are the destination select.  This is the
6972     //  value of the incoming immediate.
6973     // Bits [3:0] of the constant are the zero mask.  The DAG Combiner may
6974     //   combine either bitwise AND or insert of float 0.0 to set these bits.
6975     N2 = DAG.getIntPtrConstant(cast<ConstantSDNode>(N2)->getZExtValue() << 4);
6976     // Create this as a scalar to vector..
6977     N1 = DAG.getNode(ISD::SCALAR_TO_VECTOR, dl, MVT::v4f32, N1);
6978     return DAG.getNode(X86ISD::INSERTPS, dl, VT, N0, N1, N2);
6979   } else if (EltVT == MVT::i32 && isa<ConstantSDNode>(N2)) {
6980     // PINSR* works with constant index.
6981     return Op;
6982   }
6983   return SDValue();
6984 }
6985
6986 SDValue
6987 X86TargetLowering::LowerINSERT_VECTOR_ELT(SDValue Op, SelectionDAG &DAG) const {
6988   EVT VT = Op.getValueType();
6989   EVT EltVT = VT.getVectorElementType();
6990
6991   DebugLoc dl = Op.getDebugLoc();
6992   SDValue N0 = Op.getOperand(0);
6993   SDValue N1 = Op.getOperand(1);
6994   SDValue N2 = Op.getOperand(2);
6995
6996   // If this is a 256-bit vector result, first extract the 128-bit vector,
6997   // insert the element into the extracted half and then place it back.
6998   if (VT.getSizeInBits() == 256) {
6999     if (!isa<ConstantSDNode>(N2))
7000       return SDValue();
7001
7002     // Get the desired 128-bit vector half.
7003     unsigned NumElems = VT.getVectorNumElements();
7004     unsigned IdxVal = cast<ConstantSDNode>(N2)->getZExtValue();
7005     bool Upper = IdxVal >= NumElems/2;
7006     SDValue Ins128Idx = DAG.getConstant(Upper ? NumElems/2 : 0, MVT::i32);
7007     SDValue V = Extract128BitVector(N0, Ins128Idx, DAG, dl);
7008
7009     // Insert the element into the desired half.
7010     V = DAG.getNode(ISD::INSERT_VECTOR_ELT, dl, V.getValueType(), V,
7011                  N1, Upper ? DAG.getConstant(IdxVal-NumElems/2, MVT::i32) : N2);
7012
7013     // Insert the changed part back to the 256-bit vector
7014     return Insert128BitVector(N0, V, Ins128Idx, DAG, dl);
7015   }
7016
7017   if (Subtarget->hasSSE41() || Subtarget->hasAVX())
7018     return LowerINSERT_VECTOR_ELT_SSE4(Op, DAG);
7019
7020   if (EltVT == MVT::i8)
7021     return SDValue();
7022
7023   if (EltVT.getSizeInBits() == 16 && isa<ConstantSDNode>(N2)) {
7024     // Transform it so it match pinsrw which expects a 16-bit value in a GR32
7025     // as its second argument.
7026     if (N1.getValueType() != MVT::i32)
7027       N1 = DAG.getNode(ISD::ANY_EXTEND, dl, MVT::i32, N1);
7028     if (N2.getValueType() != MVT::i32)
7029       N2 = DAG.getIntPtrConstant(cast<ConstantSDNode>(N2)->getZExtValue());
7030     return DAG.getNode(X86ISD::PINSRW, dl, VT, N0, N1, N2);
7031   }
7032   return SDValue();
7033 }
7034
7035 SDValue
7036 X86TargetLowering::LowerSCALAR_TO_VECTOR(SDValue Op, SelectionDAG &DAG) const {
7037   LLVMContext *Context = DAG.getContext();
7038   DebugLoc dl = Op.getDebugLoc();
7039   EVT OpVT = Op.getValueType();
7040
7041   // If this is a 256-bit vector result, first insert into a 128-bit
7042   // vector and then insert into the 256-bit vector.
7043   if (OpVT.getSizeInBits() > 128) {
7044     // Insert into a 128-bit vector.
7045     EVT VT128 = EVT::getVectorVT(*Context,
7046                                  OpVT.getVectorElementType(),
7047                                  OpVT.getVectorNumElements() / 2);
7048
7049     Op = DAG.getNode(ISD::SCALAR_TO_VECTOR, dl, VT128, Op.getOperand(0));
7050
7051     // Insert the 128-bit vector.
7052     return Insert128BitVector(DAG.getNode(ISD::UNDEF, dl, OpVT), Op,
7053                               DAG.getConstant(0, MVT::i32),
7054                               DAG, dl);
7055   }
7056
7057   if (Op.getValueType() == MVT::v1i64 &&
7058       Op.getOperand(0).getValueType() == MVT::i64)
7059     return DAG.getNode(ISD::SCALAR_TO_VECTOR, dl, MVT::v1i64, Op.getOperand(0));
7060
7061   SDValue AnyExt = DAG.getNode(ISD::ANY_EXTEND, dl, MVT::i32, Op.getOperand(0));
7062   assert(Op.getValueType().getSimpleVT().getSizeInBits() == 128 &&
7063          "Expected an SSE type!");
7064   return DAG.getNode(ISD::BITCAST, dl, Op.getValueType(),
7065                      DAG.getNode(ISD::SCALAR_TO_VECTOR, dl, MVT::v4i32,AnyExt));
7066 }
7067
7068 // Lower a node with an EXTRACT_SUBVECTOR opcode.  This may result in
7069 // a simple subregister reference or explicit instructions to grab
7070 // upper bits of a vector.
7071 SDValue
7072 X86TargetLowering::LowerEXTRACT_SUBVECTOR(SDValue Op, SelectionDAG &DAG) const {
7073   if (Subtarget->hasAVX()) {
7074     DebugLoc dl = Op.getNode()->getDebugLoc();
7075     SDValue Vec = Op.getNode()->getOperand(0);
7076     SDValue Idx = Op.getNode()->getOperand(1);
7077
7078     if (Op.getNode()->getValueType(0).getSizeInBits() == 128
7079         && Vec.getNode()->getValueType(0).getSizeInBits() == 256) {
7080         return Extract128BitVector(Vec, Idx, DAG, dl);
7081     }
7082   }
7083   return SDValue();
7084 }
7085
7086 // Lower a node with an INSERT_SUBVECTOR opcode.  This may result in a
7087 // simple superregister reference or explicit instructions to insert
7088 // the upper bits of a vector.
7089 SDValue
7090 X86TargetLowering::LowerINSERT_SUBVECTOR(SDValue Op, SelectionDAG &DAG) const {
7091   if (Subtarget->hasAVX()) {
7092     DebugLoc dl = Op.getNode()->getDebugLoc();
7093     SDValue Vec = Op.getNode()->getOperand(0);
7094     SDValue SubVec = Op.getNode()->getOperand(1);
7095     SDValue Idx = Op.getNode()->getOperand(2);
7096
7097     if (Op.getNode()->getValueType(0).getSizeInBits() == 256
7098         && SubVec.getNode()->getValueType(0).getSizeInBits() == 128) {
7099       return Insert128BitVector(Vec, SubVec, Idx, DAG, dl);
7100     }
7101   }
7102   return SDValue();
7103 }
7104
7105 // ConstantPool, JumpTable, GlobalAddress, and ExternalSymbol are lowered as
7106 // their target countpart wrapped in the X86ISD::Wrapper node. Suppose N is
7107 // one of the above mentioned nodes. It has to be wrapped because otherwise
7108 // Select(N) returns N. So the raw TargetGlobalAddress nodes, etc. can only
7109 // be used to form addressing mode. These wrapped nodes will be selected
7110 // into MOV32ri.
7111 SDValue
7112 X86TargetLowering::LowerConstantPool(SDValue Op, SelectionDAG &DAG) const {
7113   ConstantPoolSDNode *CP = cast<ConstantPoolSDNode>(Op);
7114
7115   // In PIC mode (unless we're in RIPRel PIC mode) we add an offset to the
7116   // global base reg.
7117   unsigned char OpFlag = 0;
7118   unsigned WrapperKind = X86ISD::Wrapper;
7119   CodeModel::Model M = getTargetMachine().getCodeModel();
7120
7121   if (Subtarget->isPICStyleRIPRel() &&
7122       (M == CodeModel::Small || M == CodeModel::Kernel))
7123     WrapperKind = X86ISD::WrapperRIP;
7124   else if (Subtarget->isPICStyleGOT())
7125     OpFlag = X86II::MO_GOTOFF;
7126   else if (Subtarget->isPICStyleStubPIC())
7127     OpFlag = X86II::MO_PIC_BASE_OFFSET;
7128
7129   SDValue Result = DAG.getTargetConstantPool(CP->getConstVal(), getPointerTy(),
7130                                              CP->getAlignment(),
7131                                              CP->getOffset(), OpFlag);
7132   DebugLoc DL = CP->getDebugLoc();
7133   Result = DAG.getNode(WrapperKind, DL, getPointerTy(), Result);
7134   // With PIC, the address is actually $g + Offset.
7135   if (OpFlag) {
7136     Result = DAG.getNode(ISD::ADD, DL, getPointerTy(),
7137                          DAG.getNode(X86ISD::GlobalBaseReg,
7138                                      DebugLoc(), getPointerTy()),
7139                          Result);
7140   }
7141
7142   return Result;
7143 }
7144
7145 SDValue X86TargetLowering::LowerJumpTable(SDValue Op, SelectionDAG &DAG) const {
7146   JumpTableSDNode *JT = cast<JumpTableSDNode>(Op);
7147
7148   // In PIC mode (unless we're in RIPRel PIC mode) we add an offset to the
7149   // global base reg.
7150   unsigned char OpFlag = 0;
7151   unsigned WrapperKind = X86ISD::Wrapper;
7152   CodeModel::Model M = getTargetMachine().getCodeModel();
7153
7154   if (Subtarget->isPICStyleRIPRel() &&
7155       (M == CodeModel::Small || M == CodeModel::Kernel))
7156     WrapperKind = X86ISD::WrapperRIP;
7157   else if (Subtarget->isPICStyleGOT())
7158     OpFlag = X86II::MO_GOTOFF;
7159   else if (Subtarget->isPICStyleStubPIC())
7160     OpFlag = X86II::MO_PIC_BASE_OFFSET;
7161
7162   SDValue Result = DAG.getTargetJumpTable(JT->getIndex(), getPointerTy(),
7163                                           OpFlag);
7164   DebugLoc DL = JT->getDebugLoc();
7165   Result = DAG.getNode(WrapperKind, DL, getPointerTy(), Result);
7166
7167   // With PIC, the address is actually $g + Offset.
7168   if (OpFlag)
7169     Result = DAG.getNode(ISD::ADD, DL, getPointerTy(),
7170                          DAG.getNode(X86ISD::GlobalBaseReg,
7171                                      DebugLoc(), getPointerTy()),
7172                          Result);
7173
7174   return Result;
7175 }
7176
7177 SDValue
7178 X86TargetLowering::LowerExternalSymbol(SDValue Op, SelectionDAG &DAG) const {
7179   const char *Sym = cast<ExternalSymbolSDNode>(Op)->getSymbol();
7180
7181   // In PIC mode (unless we're in RIPRel PIC mode) we add an offset to the
7182   // global base reg.
7183   unsigned char OpFlag = 0;
7184   unsigned WrapperKind = X86ISD::Wrapper;
7185   CodeModel::Model M = getTargetMachine().getCodeModel();
7186
7187   if (Subtarget->isPICStyleRIPRel() &&
7188       (M == CodeModel::Small || M == CodeModel::Kernel)) {
7189     if (Subtarget->isTargetDarwin() || Subtarget->isTargetELF())
7190       OpFlag = X86II::MO_GOTPCREL;
7191     WrapperKind = X86ISD::WrapperRIP;
7192   } else if (Subtarget->isPICStyleGOT()) {
7193     OpFlag = X86II::MO_GOT;
7194   } else if (Subtarget->isPICStyleStubPIC()) {
7195     OpFlag = X86II::MO_DARWIN_NONLAZY_PIC_BASE;
7196   } else if (Subtarget->isPICStyleStubNoDynamic()) {
7197     OpFlag = X86II::MO_DARWIN_NONLAZY;
7198   }
7199
7200   SDValue Result = DAG.getTargetExternalSymbol(Sym, getPointerTy(), OpFlag);
7201
7202   DebugLoc DL = Op.getDebugLoc();
7203   Result = DAG.getNode(WrapperKind, DL, getPointerTy(), Result);
7204
7205
7206   // With PIC, the address is actually $g + Offset.
7207   if (getTargetMachine().getRelocationModel() == Reloc::PIC_ &&
7208       !Subtarget->is64Bit()) {
7209     Result = DAG.getNode(ISD::ADD, DL, getPointerTy(),
7210                          DAG.getNode(X86ISD::GlobalBaseReg,
7211                                      DebugLoc(), getPointerTy()),
7212                          Result);
7213   }
7214
7215   // For symbols that require a load from a stub to get the address, emit the
7216   // load.
7217   if (isGlobalStubReference(OpFlag))
7218     Result = DAG.getLoad(getPointerTy(), DL, DAG.getEntryNode(), Result,
7219                          MachinePointerInfo::getGOT(), false, false, 0);
7220
7221   return Result;
7222 }
7223
7224 SDValue
7225 X86TargetLowering::LowerBlockAddress(SDValue Op, SelectionDAG &DAG) const {
7226   // Create the TargetBlockAddressAddress node.
7227   unsigned char OpFlags =
7228     Subtarget->ClassifyBlockAddressReference();
7229   CodeModel::Model M = getTargetMachine().getCodeModel();
7230   const BlockAddress *BA = cast<BlockAddressSDNode>(Op)->getBlockAddress();
7231   DebugLoc dl = Op.getDebugLoc();
7232   SDValue Result = DAG.getBlockAddress(BA, getPointerTy(),
7233                                        /*isTarget=*/true, OpFlags);
7234
7235   if (Subtarget->isPICStyleRIPRel() &&
7236       (M == CodeModel::Small || M == CodeModel::Kernel))
7237     Result = DAG.getNode(X86ISD::WrapperRIP, dl, getPointerTy(), Result);
7238   else
7239     Result = DAG.getNode(X86ISD::Wrapper, dl, getPointerTy(), Result);
7240
7241   // With PIC, the address is actually $g + Offset.
7242   if (isGlobalRelativeToPICBase(OpFlags)) {
7243     Result = DAG.getNode(ISD::ADD, dl, getPointerTy(),
7244                          DAG.getNode(X86ISD::GlobalBaseReg, dl, getPointerTy()),
7245                          Result);
7246   }
7247
7248   return Result;
7249 }
7250
7251 SDValue
7252 X86TargetLowering::LowerGlobalAddress(const GlobalValue *GV, DebugLoc dl,
7253                                       int64_t Offset,
7254                                       SelectionDAG &DAG) const {
7255   // Create the TargetGlobalAddress node, folding in the constant
7256   // offset if it is legal.
7257   unsigned char OpFlags =
7258     Subtarget->ClassifyGlobalReference(GV, getTargetMachine());
7259   CodeModel::Model M = getTargetMachine().getCodeModel();
7260   SDValue Result;
7261   if (OpFlags == X86II::MO_NO_FLAG &&
7262       X86::isOffsetSuitableForCodeModel(Offset, M)) {
7263     // A direct static reference to a global.
7264     Result = DAG.getTargetGlobalAddress(GV, dl, getPointerTy(), Offset);
7265     Offset = 0;
7266   } else {
7267     Result = DAG.getTargetGlobalAddress(GV, dl, getPointerTy(), 0, OpFlags);
7268   }
7269
7270   if (Subtarget->isPICStyleRIPRel() &&
7271       (M == CodeModel::Small || M == CodeModel::Kernel))
7272     Result = DAG.getNode(X86ISD::WrapperRIP, dl, getPointerTy(), Result);
7273   else
7274     Result = DAG.getNode(X86ISD::Wrapper, dl, getPointerTy(), Result);
7275
7276   // With PIC, the address is actually $g + Offset.
7277   if (isGlobalRelativeToPICBase(OpFlags)) {
7278     Result = DAG.getNode(ISD::ADD, dl, getPointerTy(),
7279                          DAG.getNode(X86ISD::GlobalBaseReg, dl, getPointerTy()),
7280                          Result);
7281   }
7282
7283   // For globals that require a load from a stub to get the address, emit the
7284   // load.
7285   if (isGlobalStubReference(OpFlags))
7286     Result = DAG.getLoad(getPointerTy(), dl, DAG.getEntryNode(), Result,
7287                          MachinePointerInfo::getGOT(), false, false, 0);
7288
7289   // If there was a non-zero offset that we didn't fold, create an explicit
7290   // addition for it.
7291   if (Offset != 0)
7292     Result = DAG.getNode(ISD::ADD, dl, getPointerTy(), Result,
7293                          DAG.getConstant(Offset, getPointerTy()));
7294
7295   return Result;
7296 }
7297
7298 SDValue
7299 X86TargetLowering::LowerGlobalAddress(SDValue Op, SelectionDAG &DAG) const {
7300   const GlobalValue *GV = cast<GlobalAddressSDNode>(Op)->getGlobal();
7301   int64_t Offset = cast<GlobalAddressSDNode>(Op)->getOffset();
7302   return LowerGlobalAddress(GV, Op.getDebugLoc(), Offset, DAG);
7303 }
7304
7305 static SDValue
7306 GetTLSADDR(SelectionDAG &DAG, SDValue Chain, GlobalAddressSDNode *GA,
7307            SDValue *InFlag, const EVT PtrVT, unsigned ReturnReg,
7308            unsigned char OperandFlags) {
7309   MachineFrameInfo *MFI = DAG.getMachineFunction().getFrameInfo();
7310   SDVTList NodeTys = DAG.getVTList(MVT::Other, MVT::Glue);
7311   DebugLoc dl = GA->getDebugLoc();
7312   SDValue TGA = DAG.getTargetGlobalAddress(GA->getGlobal(), dl,
7313                                            GA->getValueType(0),
7314                                            GA->getOffset(),
7315                                            OperandFlags);
7316   if (InFlag) {
7317     SDValue Ops[] = { Chain,  TGA, *InFlag };
7318     Chain = DAG.getNode(X86ISD::TLSADDR, dl, NodeTys, Ops, 3);
7319   } else {
7320     SDValue Ops[]  = { Chain, TGA };
7321     Chain = DAG.getNode(X86ISD::TLSADDR, dl, NodeTys, Ops, 2);
7322   }
7323
7324   // TLSADDR will be codegen'ed as call. Inform MFI that function has calls.
7325   MFI->setAdjustsStack(true);
7326
7327   SDValue Flag = Chain.getValue(1);
7328   return DAG.getCopyFromReg(Chain, dl, ReturnReg, PtrVT, Flag);
7329 }
7330
7331 // Lower ISD::GlobalTLSAddress using the "general dynamic" model, 32 bit
7332 static SDValue
7333 LowerToTLSGeneralDynamicModel32(GlobalAddressSDNode *GA, SelectionDAG &DAG,
7334                                 const EVT PtrVT) {
7335   SDValue InFlag;
7336   DebugLoc dl = GA->getDebugLoc();  // ? function entry point might be better
7337   SDValue Chain = DAG.getCopyToReg(DAG.getEntryNode(), dl, X86::EBX,
7338                                      DAG.getNode(X86ISD::GlobalBaseReg,
7339                                                  DebugLoc(), PtrVT), InFlag);
7340   InFlag = Chain.getValue(1);
7341
7342   return GetTLSADDR(DAG, Chain, GA, &InFlag, PtrVT, X86::EAX, X86II::MO_TLSGD);
7343 }
7344
7345 // Lower ISD::GlobalTLSAddress using the "general dynamic" model, 64 bit
7346 static SDValue
7347 LowerToTLSGeneralDynamicModel64(GlobalAddressSDNode *GA, SelectionDAG &DAG,
7348                                 const EVT PtrVT) {
7349   return GetTLSADDR(DAG, DAG.getEntryNode(), GA, NULL, PtrVT,
7350                     X86::RAX, X86II::MO_TLSGD);
7351 }
7352
7353 // Lower ISD::GlobalTLSAddress using the "initial exec" (for no-pic) or
7354 // "local exec" model.
7355 static SDValue LowerToTLSExecModel(GlobalAddressSDNode *GA, SelectionDAG &DAG,
7356                                    const EVT PtrVT, TLSModel::Model model,
7357                                    bool is64Bit) {
7358   DebugLoc dl = GA->getDebugLoc();
7359
7360   // Get the Thread Pointer, which is %gs:0 (32-bit) or %fs:0 (64-bit).
7361   Value *Ptr = Constant::getNullValue(Type::getInt8PtrTy(*DAG.getContext(),
7362                                                          is64Bit ? 257 : 256));
7363
7364   SDValue ThreadPointer = DAG.getLoad(PtrVT, dl, DAG.getEntryNode(),
7365                                       DAG.getIntPtrConstant(0),
7366                                       MachinePointerInfo(Ptr), false, false, 0);
7367
7368   unsigned char OperandFlags = 0;
7369   // Most TLS accesses are not RIP relative, even on x86-64.  One exception is
7370   // initialexec.
7371   unsigned WrapperKind = X86ISD::Wrapper;
7372   if (model == TLSModel::LocalExec) {
7373     OperandFlags = is64Bit ? X86II::MO_TPOFF : X86II::MO_NTPOFF;
7374   } else if (is64Bit) {
7375     assert(model == TLSModel::InitialExec);
7376     OperandFlags = X86II::MO_GOTTPOFF;
7377     WrapperKind = X86ISD::WrapperRIP;
7378   } else {
7379     assert(model == TLSModel::InitialExec);
7380     OperandFlags = X86II::MO_INDNTPOFF;
7381   }
7382
7383   // emit "addl x@ntpoff,%eax" (local exec) or "addl x@indntpoff,%eax" (initial
7384   // exec)
7385   SDValue TGA = DAG.getTargetGlobalAddress(GA->getGlobal(), dl,
7386                                            GA->getValueType(0),
7387                                            GA->getOffset(), OperandFlags);
7388   SDValue Offset = DAG.getNode(WrapperKind, dl, PtrVT, TGA);
7389
7390   if (model == TLSModel::InitialExec)
7391     Offset = DAG.getLoad(PtrVT, dl, DAG.getEntryNode(), Offset,
7392                          MachinePointerInfo::getGOT(), false, false, 0);
7393
7394   // The address of the thread local variable is the add of the thread
7395   // pointer with the offset of the variable.
7396   return DAG.getNode(ISD::ADD, dl, PtrVT, ThreadPointer, Offset);
7397 }
7398
7399 SDValue
7400 X86TargetLowering::LowerGlobalTLSAddress(SDValue Op, SelectionDAG &DAG) const {
7401
7402   GlobalAddressSDNode *GA = cast<GlobalAddressSDNode>(Op);
7403   const GlobalValue *GV = GA->getGlobal();
7404
7405   if (Subtarget->isTargetELF()) {
7406     // TODO: implement the "local dynamic" model
7407     // TODO: implement the "initial exec"model for pic executables
7408
7409     // If GV is an alias then use the aliasee for determining
7410     // thread-localness.
7411     if (const GlobalAlias *GA = dyn_cast<GlobalAlias>(GV))
7412       GV = GA->resolveAliasedGlobal(false);
7413
7414     TLSModel::Model model
7415       = getTLSModel(GV, getTargetMachine().getRelocationModel());
7416
7417     switch (model) {
7418       case TLSModel::GeneralDynamic:
7419       case TLSModel::LocalDynamic: // not implemented
7420         if (Subtarget->is64Bit())
7421           return LowerToTLSGeneralDynamicModel64(GA, DAG, getPointerTy());
7422         return LowerToTLSGeneralDynamicModel32(GA, DAG, getPointerTy());
7423
7424       case TLSModel::InitialExec:
7425       case TLSModel::LocalExec:
7426         return LowerToTLSExecModel(GA, DAG, getPointerTy(), model,
7427                                    Subtarget->is64Bit());
7428     }
7429   } else if (Subtarget->isTargetDarwin()) {
7430     // Darwin only has one model of TLS.  Lower to that.
7431     unsigned char OpFlag = 0;
7432     unsigned WrapperKind = Subtarget->isPICStyleRIPRel() ?
7433                            X86ISD::WrapperRIP : X86ISD::Wrapper;
7434
7435     // In PIC mode (unless we're in RIPRel PIC mode) we add an offset to the
7436     // global base reg.
7437     bool PIC32 = (getTargetMachine().getRelocationModel() == Reloc::PIC_) &&
7438                   !Subtarget->is64Bit();
7439     if (PIC32)
7440       OpFlag = X86II::MO_TLVP_PIC_BASE;
7441     else
7442       OpFlag = X86II::MO_TLVP;
7443     DebugLoc DL = Op.getDebugLoc();
7444     SDValue Result = DAG.getTargetGlobalAddress(GA->getGlobal(), DL,
7445                                                 GA->getValueType(0),
7446                                                 GA->getOffset(), OpFlag);
7447     SDValue Offset = DAG.getNode(WrapperKind, DL, getPointerTy(), Result);
7448
7449     // With PIC32, the address is actually $g + Offset.
7450     if (PIC32)
7451       Offset = DAG.getNode(ISD::ADD, DL, getPointerTy(),
7452                            DAG.getNode(X86ISD::GlobalBaseReg,
7453                                        DebugLoc(), getPointerTy()),
7454                            Offset);
7455
7456     // Lowering the machine isd will make sure everything is in the right
7457     // location.
7458     SDValue Chain = DAG.getEntryNode();
7459     SDVTList NodeTys = DAG.getVTList(MVT::Other, MVT::Glue);
7460     SDValue Args[] = { Chain, Offset };
7461     Chain = DAG.getNode(X86ISD::TLSCALL, DL, NodeTys, Args, 2);
7462
7463     // TLSCALL will be codegen'ed as call. Inform MFI that function has calls.
7464     MachineFrameInfo *MFI = DAG.getMachineFunction().getFrameInfo();
7465     MFI->setAdjustsStack(true);
7466
7467     // And our return value (tls address) is in the standard call return value
7468     // location.
7469     unsigned Reg = Subtarget->is64Bit() ? X86::RAX : X86::EAX;
7470     return DAG.getCopyFromReg(Chain, DL, Reg, getPointerTy());
7471   }
7472
7473   assert(false &&
7474          "TLS not implemented for this target.");
7475
7476   llvm_unreachable("Unreachable");
7477   return SDValue();
7478 }
7479
7480
7481 /// LowerShiftParts - Lower SRA_PARTS and friends, which return two i32 values and
7482 /// take a 2 x i32 value to shift plus a shift amount.
7483 SDValue X86TargetLowering::LowerShiftParts(SDValue Op, SelectionDAG &DAG) const {
7484   assert(Op.getNumOperands() == 3 && "Not a double-shift!");
7485   EVT VT = Op.getValueType();
7486   unsigned VTBits = VT.getSizeInBits();
7487   DebugLoc dl = Op.getDebugLoc();
7488   bool isSRA = Op.getOpcode() == ISD::SRA_PARTS;
7489   SDValue ShOpLo = Op.getOperand(0);
7490   SDValue ShOpHi = Op.getOperand(1);
7491   SDValue ShAmt  = Op.getOperand(2);
7492   SDValue Tmp1 = isSRA ? DAG.getNode(ISD::SRA, dl, VT, ShOpHi,
7493                                      DAG.getConstant(VTBits - 1, MVT::i8))
7494                        : DAG.getConstant(0, VT);
7495
7496   SDValue Tmp2, Tmp3;
7497   if (Op.getOpcode() == ISD::SHL_PARTS) {
7498     Tmp2 = DAG.getNode(X86ISD::SHLD, dl, VT, ShOpHi, ShOpLo, ShAmt);
7499     Tmp3 = DAG.getNode(ISD::SHL, dl, VT, ShOpLo, ShAmt);
7500   } else {
7501     Tmp2 = DAG.getNode(X86ISD::SHRD, dl, VT, ShOpLo, ShOpHi, ShAmt);
7502     Tmp3 = DAG.getNode(isSRA ? ISD::SRA : ISD::SRL, dl, VT, ShOpHi, ShAmt);
7503   }
7504
7505   SDValue AndNode = DAG.getNode(ISD::AND, dl, MVT::i8, ShAmt,
7506                                 DAG.getConstant(VTBits, MVT::i8));
7507   SDValue Cond = DAG.getNode(X86ISD::CMP, dl, MVT::i32,
7508                              AndNode, DAG.getConstant(0, MVT::i8));
7509
7510   SDValue Hi, Lo;
7511   SDValue CC = DAG.getConstant(X86::COND_NE, MVT::i8);
7512   SDValue Ops0[4] = { Tmp2, Tmp3, CC, Cond };
7513   SDValue Ops1[4] = { Tmp3, Tmp1, CC, Cond };
7514
7515   if (Op.getOpcode() == ISD::SHL_PARTS) {
7516     Hi = DAG.getNode(X86ISD::CMOV, dl, VT, Ops0, 4);
7517     Lo = DAG.getNode(X86ISD::CMOV, dl, VT, Ops1, 4);
7518   } else {
7519     Lo = DAG.getNode(X86ISD::CMOV, dl, VT, Ops0, 4);
7520     Hi = DAG.getNode(X86ISD::CMOV, dl, VT, Ops1, 4);
7521   }
7522
7523   SDValue Ops[2] = { Lo, Hi };
7524   return DAG.getMergeValues(Ops, 2, dl);
7525 }
7526
7527 SDValue X86TargetLowering::LowerSINT_TO_FP(SDValue Op,
7528                                            SelectionDAG &DAG) const {
7529   EVT SrcVT = Op.getOperand(0).getValueType();
7530
7531   if (SrcVT.isVector())
7532     return SDValue();
7533
7534   assert(SrcVT.getSimpleVT() <= MVT::i64 && SrcVT.getSimpleVT() >= MVT::i16 &&
7535          "Unknown SINT_TO_FP to lower!");
7536
7537   // These are really Legal; return the operand so the caller accepts it as
7538   // Legal.
7539   if (SrcVT == MVT::i32 && isScalarFPTypeInSSEReg(Op.getValueType()))
7540     return Op;
7541   if (SrcVT == MVT::i64 && isScalarFPTypeInSSEReg(Op.getValueType()) &&
7542       Subtarget->is64Bit()) {
7543     return Op;
7544   }
7545
7546   DebugLoc dl = Op.getDebugLoc();
7547   unsigned Size = SrcVT.getSizeInBits()/8;
7548   MachineFunction &MF = DAG.getMachineFunction();
7549   int SSFI = MF.getFrameInfo()->CreateStackObject(Size, Size, false);
7550   SDValue StackSlot = DAG.getFrameIndex(SSFI, getPointerTy());
7551   SDValue Chain = DAG.getStore(DAG.getEntryNode(), dl, Op.getOperand(0),
7552                                StackSlot,
7553                                MachinePointerInfo::getFixedStack(SSFI),
7554                                false, false, 0);
7555   return BuildFILD(Op, SrcVT, Chain, StackSlot, DAG);
7556 }
7557
7558 SDValue X86TargetLowering::BuildFILD(SDValue Op, EVT SrcVT, SDValue Chain,
7559                                      SDValue StackSlot,
7560                                      SelectionDAG &DAG) const {
7561   // Build the FILD
7562   DebugLoc DL = Op.getDebugLoc();
7563   SDVTList Tys;
7564   bool useSSE = isScalarFPTypeInSSEReg(Op.getValueType());
7565   if (useSSE)
7566     Tys = DAG.getVTList(MVT::f64, MVT::Other, MVT::Glue);
7567   else
7568     Tys = DAG.getVTList(Op.getValueType(), MVT::Other);
7569
7570   unsigned ByteSize = SrcVT.getSizeInBits()/8;
7571
7572   FrameIndexSDNode *FI = dyn_cast<FrameIndexSDNode>(StackSlot);
7573   MachineMemOperand *MMO;
7574   if (FI) {
7575     int SSFI = FI->getIndex();
7576     MMO =
7577       DAG.getMachineFunction()
7578       .getMachineMemOperand(MachinePointerInfo::getFixedStack(SSFI),
7579                             MachineMemOperand::MOLoad, ByteSize, ByteSize);
7580   } else {
7581     MMO = cast<LoadSDNode>(StackSlot)->getMemOperand();
7582     StackSlot = StackSlot.getOperand(1);
7583   }
7584   SDValue Ops[] = { Chain, StackSlot, DAG.getValueType(SrcVT) };
7585   SDValue Result = DAG.getMemIntrinsicNode(useSSE ? X86ISD::FILD_FLAG :
7586                                            X86ISD::FILD, DL,
7587                                            Tys, Ops, array_lengthof(Ops),
7588                                            SrcVT, MMO);
7589
7590   if (useSSE) {
7591     Chain = Result.getValue(1);
7592     SDValue InFlag = Result.getValue(2);
7593
7594     // FIXME: Currently the FST is flagged to the FILD_FLAG. This
7595     // shouldn't be necessary except that RFP cannot be live across
7596     // multiple blocks. When stackifier is fixed, they can be uncoupled.
7597     MachineFunction &MF = DAG.getMachineFunction();
7598     unsigned SSFISize = Op.getValueType().getSizeInBits()/8;
7599     int SSFI = MF.getFrameInfo()->CreateStackObject(SSFISize, SSFISize, false);
7600     SDValue StackSlot = DAG.getFrameIndex(SSFI, getPointerTy());
7601     Tys = DAG.getVTList(MVT::Other);
7602     SDValue Ops[] = {
7603       Chain, Result, StackSlot, DAG.getValueType(Op.getValueType()), InFlag
7604     };
7605     MachineMemOperand *MMO =
7606       DAG.getMachineFunction()
7607       .getMachineMemOperand(MachinePointerInfo::getFixedStack(SSFI),
7608                             MachineMemOperand::MOStore, SSFISize, SSFISize);
7609
7610     Chain = DAG.getMemIntrinsicNode(X86ISD::FST, DL, Tys,
7611                                     Ops, array_lengthof(Ops),
7612                                     Op.getValueType(), MMO);
7613     Result = DAG.getLoad(Op.getValueType(), DL, Chain, StackSlot,
7614                          MachinePointerInfo::getFixedStack(SSFI),
7615                          false, false, 0);
7616   }
7617
7618   return Result;
7619 }
7620
7621 // LowerUINT_TO_FP_i64 - 64-bit unsigned integer to double expansion.
7622 SDValue X86TargetLowering::LowerUINT_TO_FP_i64(SDValue Op,
7623                                                SelectionDAG &DAG) const {
7624   // This algorithm is not obvious. Here it is in C code, more or less:
7625   /*
7626     double uint64_to_double( uint32_t hi, uint32_t lo ) {
7627       static const __m128i exp = { 0x4330000045300000ULL, 0 };
7628       static const __m128d bias = { 0x1.0p84, 0x1.0p52 };
7629
7630       // Copy ints to xmm registers.
7631       __m128i xh = _mm_cvtsi32_si128( hi );
7632       __m128i xl = _mm_cvtsi32_si128( lo );
7633
7634       // Combine into low half of a single xmm register.
7635       __m128i x = _mm_unpacklo_epi32( xh, xl );
7636       __m128d d;
7637       double sd;
7638
7639       // Merge in appropriate exponents to give the integer bits the right
7640       // magnitude.
7641       x = _mm_unpacklo_epi32( x, exp );
7642
7643       // Subtract away the biases to deal with the IEEE-754 double precision
7644       // implicit 1.
7645       d = _mm_sub_pd( (__m128d) x, bias );
7646
7647       // All conversions up to here are exact. The correctly rounded result is
7648       // calculated using the current rounding mode using the following
7649       // horizontal add.
7650       d = _mm_add_sd( d, _mm_unpackhi_pd( d, d ) );
7651       _mm_store_sd( &sd, d );   // Because we are returning doubles in XMM, this
7652                                 // store doesn't really need to be here (except
7653                                 // maybe to zero the other double)
7654       return sd;
7655     }
7656   */
7657
7658   DebugLoc dl = Op.getDebugLoc();
7659   LLVMContext *Context = DAG.getContext();
7660
7661   // Build some magic constants.
7662   std::vector<Constant*> CV0;
7663   CV0.push_back(ConstantInt::get(*Context, APInt(32, 0x45300000)));
7664   CV0.push_back(ConstantInt::get(*Context, APInt(32, 0x43300000)));
7665   CV0.push_back(ConstantInt::get(*Context, APInt(32, 0)));
7666   CV0.push_back(ConstantInt::get(*Context, APInt(32, 0)));
7667   Constant *C0 = ConstantVector::get(CV0);
7668   SDValue CPIdx0 = DAG.getConstantPool(C0, getPointerTy(), 16);
7669
7670   std::vector<Constant*> CV1;
7671   CV1.push_back(
7672     ConstantFP::get(*Context, APFloat(APInt(64, 0x4530000000000000ULL))));
7673   CV1.push_back(
7674     ConstantFP::get(*Context, APFloat(APInt(64, 0x4330000000000000ULL))));
7675   Constant *C1 = ConstantVector::get(CV1);
7676   SDValue CPIdx1 = DAG.getConstantPool(C1, getPointerTy(), 16);
7677
7678   SDValue XR1 = DAG.getNode(ISD::SCALAR_TO_VECTOR, dl, MVT::v4i32,
7679                             DAG.getNode(ISD::EXTRACT_ELEMENT, dl, MVT::i32,
7680                                         Op.getOperand(0),
7681                                         DAG.getIntPtrConstant(1)));
7682   SDValue XR2 = DAG.getNode(ISD::SCALAR_TO_VECTOR, dl, MVT::v4i32,
7683                             DAG.getNode(ISD::EXTRACT_ELEMENT, dl, MVT::i32,
7684                                         Op.getOperand(0),
7685                                         DAG.getIntPtrConstant(0)));
7686   SDValue Unpck1 = getUnpackl(DAG, dl, MVT::v4i32, XR1, XR2);
7687   SDValue CLod0 = DAG.getLoad(MVT::v4i32, dl, DAG.getEntryNode(), CPIdx0,
7688                               MachinePointerInfo::getConstantPool(),
7689                               false, false, 16);
7690   SDValue Unpck2 = getUnpackl(DAG, dl, MVT::v4i32, Unpck1, CLod0);
7691   SDValue XR2F = DAG.getNode(ISD::BITCAST, dl, MVT::v2f64, Unpck2);
7692   SDValue CLod1 = DAG.getLoad(MVT::v2f64, dl, CLod0.getValue(1), CPIdx1,
7693                               MachinePointerInfo::getConstantPool(),
7694                               false, false, 16);
7695   SDValue Sub = DAG.getNode(ISD::FSUB, dl, MVT::v2f64, XR2F, CLod1);
7696
7697   // Add the halves; easiest way is to swap them into another reg first.
7698   int ShufMask[2] = { 1, -1 };
7699   SDValue Shuf = DAG.getVectorShuffle(MVT::v2f64, dl, Sub,
7700                                       DAG.getUNDEF(MVT::v2f64), ShufMask);
7701   SDValue Add = DAG.getNode(ISD::FADD, dl, MVT::v2f64, Shuf, Sub);
7702   return DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, MVT::f64, Add,
7703                      DAG.getIntPtrConstant(0));
7704 }
7705
7706 // LowerUINT_TO_FP_i32 - 32-bit unsigned integer to float expansion.
7707 SDValue X86TargetLowering::LowerUINT_TO_FP_i32(SDValue Op,
7708                                                SelectionDAG &DAG) const {
7709   DebugLoc dl = Op.getDebugLoc();
7710   // FP constant to bias correct the final result.
7711   SDValue Bias = DAG.getConstantFP(BitsToDouble(0x4330000000000000ULL),
7712                                    MVT::f64);
7713
7714   // Load the 32-bit value into an XMM register.
7715   SDValue Load = DAG.getNode(ISD::SCALAR_TO_VECTOR, dl, MVT::v4i32,
7716                              Op.getOperand(0));
7717
7718   // Zero out the upper parts of the register.
7719   Load = getShuffleVectorZeroOrUndef(Load, 0, true, Subtarget->hasSSE2(), DAG);
7720
7721   Load = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, MVT::f64,
7722                      DAG.getNode(ISD::BITCAST, dl, MVT::v2f64, Load),
7723                      DAG.getIntPtrConstant(0));
7724
7725   // Or the load with the bias.
7726   SDValue Or = DAG.getNode(ISD::OR, dl, MVT::v2i64,
7727                            DAG.getNode(ISD::BITCAST, dl, MVT::v2i64,
7728                                        DAG.getNode(ISD::SCALAR_TO_VECTOR, dl,
7729                                                    MVT::v2f64, Load)),
7730                            DAG.getNode(ISD::BITCAST, dl, MVT::v2i64,
7731                                        DAG.getNode(ISD::SCALAR_TO_VECTOR, dl,
7732                                                    MVT::v2f64, Bias)));
7733   Or = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, MVT::f64,
7734                    DAG.getNode(ISD::BITCAST, dl, MVT::v2f64, Or),
7735                    DAG.getIntPtrConstant(0));
7736
7737   // Subtract the bias.
7738   SDValue Sub = DAG.getNode(ISD::FSUB, dl, MVT::f64, Or, Bias);
7739
7740   // Handle final rounding.
7741   EVT DestVT = Op.getValueType();
7742
7743   if (DestVT.bitsLT(MVT::f64)) {
7744     return DAG.getNode(ISD::FP_ROUND, dl, DestVT, Sub,
7745                        DAG.getIntPtrConstant(0));
7746   } else if (DestVT.bitsGT(MVT::f64)) {
7747     return DAG.getNode(ISD::FP_EXTEND, dl, DestVT, Sub);
7748   }
7749
7750   // Handle final rounding.
7751   return Sub;
7752 }
7753
7754 SDValue X86TargetLowering::LowerUINT_TO_FP(SDValue Op,
7755                                            SelectionDAG &DAG) const {
7756   SDValue N0 = Op.getOperand(0);
7757   DebugLoc dl = Op.getDebugLoc();
7758
7759   // Since UINT_TO_FP is legal (it's marked custom), dag combiner won't
7760   // optimize it to a SINT_TO_FP when the sign bit is known zero. Perform
7761   // the optimization here.
7762   if (DAG.SignBitIsZero(N0))
7763     return DAG.getNode(ISD::SINT_TO_FP, dl, Op.getValueType(), N0);
7764
7765   EVT SrcVT = N0.getValueType();
7766   EVT DstVT = Op.getValueType();
7767   if (SrcVT == MVT::i64 && DstVT == MVT::f64 && X86ScalarSSEf64)
7768     return LowerUINT_TO_FP_i64(Op, DAG);
7769   else if (SrcVT == MVT::i32 && X86ScalarSSEf64)
7770     return LowerUINT_TO_FP_i32(Op, DAG);
7771
7772   // Make a 64-bit buffer, and use it to build an FILD.
7773   SDValue StackSlot = DAG.CreateStackTemporary(MVT::i64);
7774   if (SrcVT == MVT::i32) {
7775     SDValue WordOff = DAG.getConstant(4, getPointerTy());
7776     SDValue OffsetSlot = DAG.getNode(ISD::ADD, dl,
7777                                      getPointerTy(), StackSlot, WordOff);
7778     SDValue Store1 = DAG.getStore(DAG.getEntryNode(), dl, Op.getOperand(0),
7779                                   StackSlot, MachinePointerInfo(),
7780                                   false, false, 0);
7781     SDValue Store2 = DAG.getStore(Store1, dl, DAG.getConstant(0, MVT::i32),
7782                                   OffsetSlot, MachinePointerInfo(),
7783                                   false, false, 0);
7784     SDValue Fild = BuildFILD(Op, MVT::i64, Store2, StackSlot, DAG);
7785     return Fild;
7786   }
7787
7788   assert(SrcVT == MVT::i64 && "Unexpected type in UINT_TO_FP");
7789   SDValue Store = DAG.getStore(DAG.getEntryNode(), dl, Op.getOperand(0),
7790                                 StackSlot, MachinePointerInfo(),
7791                                false, false, 0);
7792   // For i64 source, we need to add the appropriate power of 2 if the input
7793   // was negative.  This is the same as the optimization in
7794   // DAGTypeLegalizer::ExpandIntOp_UNIT_TO_FP, and for it to be safe here,
7795   // we must be careful to do the computation in x87 extended precision, not
7796   // in SSE. (The generic code can't know it's OK to do this, or how to.)
7797   int SSFI = cast<FrameIndexSDNode>(StackSlot)->getIndex();
7798   MachineMemOperand *MMO =
7799     DAG.getMachineFunction()
7800     .getMachineMemOperand(MachinePointerInfo::getFixedStack(SSFI),
7801                           MachineMemOperand::MOLoad, 8, 8);
7802
7803   SDVTList Tys = DAG.getVTList(MVT::f80, MVT::Other);
7804   SDValue Ops[] = { Store, StackSlot, DAG.getValueType(MVT::i64) };
7805   SDValue Fild = DAG.getMemIntrinsicNode(X86ISD::FILD, dl, Tys, Ops, 3,
7806                                          MVT::i64, MMO);
7807
7808   APInt FF(32, 0x5F800000ULL);
7809
7810   // Check whether the sign bit is set.
7811   SDValue SignSet = DAG.getSetCC(dl, getSetCCResultType(MVT::i64),
7812                                  Op.getOperand(0), DAG.getConstant(0, MVT::i64),
7813                                  ISD::SETLT);
7814
7815   // Build a 64 bit pair (0, FF) in the constant pool, with FF in the lo bits.
7816   SDValue FudgePtr = DAG.getConstantPool(
7817                              ConstantInt::get(*DAG.getContext(), FF.zext(64)),
7818                                          getPointerTy());
7819
7820   // Get a pointer to FF if the sign bit was set, or to 0 otherwise.
7821   SDValue Zero = DAG.getIntPtrConstant(0);
7822   SDValue Four = DAG.getIntPtrConstant(4);
7823   SDValue Offset = DAG.getNode(ISD::SELECT, dl, Zero.getValueType(), SignSet,
7824                                Zero, Four);
7825   FudgePtr = DAG.getNode(ISD::ADD, dl, getPointerTy(), FudgePtr, Offset);
7826
7827   // Load the value out, extending it from f32 to f80.
7828   // FIXME: Avoid the extend by constructing the right constant pool?
7829   SDValue Fudge = DAG.getExtLoad(ISD::EXTLOAD, dl, MVT::f80, DAG.getEntryNode(),
7830                                  FudgePtr, MachinePointerInfo::getConstantPool(),
7831                                  MVT::f32, false, false, 4);
7832   // Extend everything to 80 bits to force it to be done on x87.
7833   SDValue Add = DAG.getNode(ISD::FADD, dl, MVT::f80, Fild, Fudge);
7834   return DAG.getNode(ISD::FP_ROUND, dl, DstVT, Add, DAG.getIntPtrConstant(0));
7835 }
7836
7837 std::pair<SDValue,SDValue> X86TargetLowering::
7838 FP_TO_INTHelper(SDValue Op, SelectionDAG &DAG, bool IsSigned) const {
7839   DebugLoc DL = Op.getDebugLoc();
7840
7841   EVT DstTy = Op.getValueType();
7842
7843   if (!IsSigned) {
7844     assert(DstTy == MVT::i32 && "Unexpected FP_TO_UINT");
7845     DstTy = MVT::i64;
7846   }
7847
7848   assert(DstTy.getSimpleVT() <= MVT::i64 &&
7849          DstTy.getSimpleVT() >= MVT::i16 &&
7850          "Unknown FP_TO_SINT to lower!");
7851
7852   // These are really Legal.
7853   if (DstTy == MVT::i32 &&
7854       isScalarFPTypeInSSEReg(Op.getOperand(0).getValueType()))
7855     return std::make_pair(SDValue(), SDValue());
7856   if (Subtarget->is64Bit() &&
7857       DstTy == MVT::i64 &&
7858       isScalarFPTypeInSSEReg(Op.getOperand(0).getValueType()))
7859     return std::make_pair(SDValue(), SDValue());
7860
7861   // We lower FP->sint64 into FISTP64, followed by a load, all to a temporary
7862   // stack slot.
7863   MachineFunction &MF = DAG.getMachineFunction();
7864   unsigned MemSize = DstTy.getSizeInBits()/8;
7865   int SSFI = MF.getFrameInfo()->CreateStackObject(MemSize, MemSize, false);
7866   SDValue StackSlot = DAG.getFrameIndex(SSFI, getPointerTy());
7867
7868
7869
7870   unsigned Opc;
7871   switch (DstTy.getSimpleVT().SimpleTy) {
7872   default: llvm_unreachable("Invalid FP_TO_SINT to lower!");
7873   case MVT::i16: Opc = X86ISD::FP_TO_INT16_IN_MEM; break;
7874   case MVT::i32: Opc = X86ISD::FP_TO_INT32_IN_MEM; break;
7875   case MVT::i64: Opc = X86ISD::FP_TO_INT64_IN_MEM; break;
7876   }
7877
7878   SDValue Chain = DAG.getEntryNode();
7879   SDValue Value = Op.getOperand(0);
7880   EVT TheVT = Op.getOperand(0).getValueType();
7881   if (isScalarFPTypeInSSEReg(TheVT)) {
7882     assert(DstTy == MVT::i64 && "Invalid FP_TO_SINT to lower!");
7883     Chain = DAG.getStore(Chain, DL, Value, StackSlot,
7884                          MachinePointerInfo::getFixedStack(SSFI),
7885                          false, false, 0);
7886     SDVTList Tys = DAG.getVTList(Op.getOperand(0).getValueType(), MVT::Other);
7887     SDValue Ops[] = {
7888       Chain, StackSlot, DAG.getValueType(TheVT)
7889     };
7890
7891     MachineMemOperand *MMO =
7892       MF.getMachineMemOperand(MachinePointerInfo::getFixedStack(SSFI),
7893                               MachineMemOperand::MOLoad, MemSize, MemSize);
7894     Value = DAG.getMemIntrinsicNode(X86ISD::FLD, DL, Tys, Ops, 3,
7895                                     DstTy, MMO);
7896     Chain = Value.getValue(1);
7897     SSFI = MF.getFrameInfo()->CreateStackObject(MemSize, MemSize, false);
7898     StackSlot = DAG.getFrameIndex(SSFI, getPointerTy());
7899   }
7900
7901   MachineMemOperand *MMO =
7902     MF.getMachineMemOperand(MachinePointerInfo::getFixedStack(SSFI),
7903                             MachineMemOperand::MOStore, MemSize, MemSize);
7904
7905   // Build the FP_TO_INT*_IN_MEM
7906   SDValue Ops[] = { Chain, Value, StackSlot };
7907   SDValue FIST = DAG.getMemIntrinsicNode(Opc, DL, DAG.getVTList(MVT::Other),
7908                                          Ops, 3, DstTy, MMO);
7909
7910   return std::make_pair(FIST, StackSlot);
7911 }
7912
7913 SDValue X86TargetLowering::LowerFP_TO_SINT(SDValue Op,
7914                                            SelectionDAG &DAG) const {
7915   if (Op.getValueType().isVector())
7916     return SDValue();
7917
7918   std::pair<SDValue,SDValue> Vals = FP_TO_INTHelper(Op, DAG, true);
7919   SDValue FIST = Vals.first, StackSlot = Vals.second;
7920   // If FP_TO_INTHelper failed, the node is actually supposed to be Legal.
7921   if (FIST.getNode() == 0) return Op;
7922
7923   // Load the result.
7924   return DAG.getLoad(Op.getValueType(), Op.getDebugLoc(),
7925                      FIST, StackSlot, MachinePointerInfo(), false, false, 0);
7926 }
7927
7928 SDValue X86TargetLowering::LowerFP_TO_UINT(SDValue Op,
7929                                            SelectionDAG &DAG) const {
7930   std::pair<SDValue,SDValue> Vals = FP_TO_INTHelper(Op, DAG, false);
7931   SDValue FIST = Vals.first, StackSlot = Vals.second;
7932   assert(FIST.getNode() && "Unexpected failure");
7933
7934   // Load the result.
7935   return DAG.getLoad(Op.getValueType(), Op.getDebugLoc(),
7936                      FIST, StackSlot, MachinePointerInfo(), false, false, 0);
7937 }
7938
7939 SDValue X86TargetLowering::LowerFABS(SDValue Op,
7940                                      SelectionDAG &DAG) const {
7941   LLVMContext *Context = DAG.getContext();
7942   DebugLoc dl = Op.getDebugLoc();
7943   EVT VT = Op.getValueType();
7944   EVT EltVT = VT;
7945   if (VT.isVector())
7946     EltVT = VT.getVectorElementType();
7947   std::vector<Constant*> CV;
7948   if (EltVT == MVT::f64) {
7949     Constant *C = ConstantFP::get(*Context, APFloat(APInt(64, ~(1ULL << 63))));
7950     CV.push_back(C);
7951     CV.push_back(C);
7952   } else {
7953     Constant *C = ConstantFP::get(*Context, APFloat(APInt(32, ~(1U << 31))));
7954     CV.push_back(C);
7955     CV.push_back(C);
7956     CV.push_back(C);
7957     CV.push_back(C);
7958   }
7959   Constant *C = ConstantVector::get(CV);
7960   SDValue CPIdx = DAG.getConstantPool(C, getPointerTy(), 16);
7961   SDValue Mask = DAG.getLoad(VT, dl, DAG.getEntryNode(), CPIdx,
7962                              MachinePointerInfo::getConstantPool(),
7963                              false, false, 16);
7964   return DAG.getNode(X86ISD::FAND, dl, VT, Op.getOperand(0), Mask);
7965 }
7966
7967 SDValue X86TargetLowering::LowerFNEG(SDValue Op, SelectionDAG &DAG) const {
7968   LLVMContext *Context = DAG.getContext();
7969   DebugLoc dl = Op.getDebugLoc();
7970   EVT VT = Op.getValueType();
7971   EVT EltVT = VT;
7972   if (VT.isVector())
7973     EltVT = VT.getVectorElementType();
7974   std::vector<Constant*> CV;
7975   if (EltVT == MVT::f64) {
7976     Constant *C = ConstantFP::get(*Context, APFloat(APInt(64, 1ULL << 63)));
7977     CV.push_back(C);
7978     CV.push_back(C);
7979   } else {
7980     Constant *C = ConstantFP::get(*Context, APFloat(APInt(32, 1U << 31)));
7981     CV.push_back(C);
7982     CV.push_back(C);
7983     CV.push_back(C);
7984     CV.push_back(C);
7985   }
7986   Constant *C = ConstantVector::get(CV);
7987   SDValue CPIdx = DAG.getConstantPool(C, getPointerTy(), 16);
7988   SDValue Mask = DAG.getLoad(VT, dl, DAG.getEntryNode(), CPIdx,
7989                              MachinePointerInfo::getConstantPool(),
7990                              false, false, 16);
7991   if (VT.isVector()) {
7992     return DAG.getNode(ISD::BITCAST, dl, VT,
7993                        DAG.getNode(ISD::XOR, dl, MVT::v2i64,
7994                     DAG.getNode(ISD::BITCAST, dl, MVT::v2i64,
7995                                 Op.getOperand(0)),
7996                     DAG.getNode(ISD::BITCAST, dl, MVT::v2i64, Mask)));
7997   } else {
7998     return DAG.getNode(X86ISD::FXOR, dl, VT, Op.getOperand(0), Mask);
7999   }
8000 }
8001
8002 SDValue X86TargetLowering::LowerFCOPYSIGN(SDValue Op, SelectionDAG &DAG) const {
8003   LLVMContext *Context = DAG.getContext();
8004   SDValue Op0 = Op.getOperand(0);
8005   SDValue Op1 = Op.getOperand(1);
8006   DebugLoc dl = Op.getDebugLoc();
8007   EVT VT = Op.getValueType();
8008   EVT SrcVT = Op1.getValueType();
8009
8010   // If second operand is smaller, extend it first.
8011   if (SrcVT.bitsLT(VT)) {
8012     Op1 = DAG.getNode(ISD::FP_EXTEND, dl, VT, Op1);
8013     SrcVT = VT;
8014   }
8015   // And if it is bigger, shrink it first.
8016   if (SrcVT.bitsGT(VT)) {
8017     Op1 = DAG.getNode(ISD::FP_ROUND, dl, VT, Op1, DAG.getIntPtrConstant(1));
8018     SrcVT = VT;
8019   }
8020
8021   // At this point the operands and the result should have the same
8022   // type, and that won't be f80 since that is not custom lowered.
8023
8024   // First get the sign bit of second operand.
8025   std::vector<Constant*> CV;
8026   if (SrcVT == MVT::f64) {
8027     CV.push_back(ConstantFP::get(*Context, APFloat(APInt(64, 1ULL << 63))));
8028     CV.push_back(ConstantFP::get(*Context, APFloat(APInt(64, 0))));
8029   } else {
8030     CV.push_back(ConstantFP::get(*Context, APFloat(APInt(32, 1U << 31))));
8031     CV.push_back(ConstantFP::get(*Context, APFloat(APInt(32, 0))));
8032     CV.push_back(ConstantFP::get(*Context, APFloat(APInt(32, 0))));
8033     CV.push_back(ConstantFP::get(*Context, APFloat(APInt(32, 0))));
8034   }
8035   Constant *C = ConstantVector::get(CV);
8036   SDValue CPIdx = DAG.getConstantPool(C, getPointerTy(), 16);
8037   SDValue Mask1 = DAG.getLoad(SrcVT, dl, DAG.getEntryNode(), CPIdx,
8038                               MachinePointerInfo::getConstantPool(),
8039                               false, false, 16);
8040   SDValue SignBit = DAG.getNode(X86ISD::FAND, dl, SrcVT, Op1, Mask1);
8041
8042   // Shift sign bit right or left if the two operands have different types.
8043   if (SrcVT.bitsGT(VT)) {
8044     // Op0 is MVT::f32, Op1 is MVT::f64.
8045     SignBit = DAG.getNode(ISD::SCALAR_TO_VECTOR, dl, MVT::v2f64, SignBit);
8046     SignBit = DAG.getNode(X86ISD::FSRL, dl, MVT::v2f64, SignBit,
8047                           DAG.getConstant(32, MVT::i32));
8048     SignBit = DAG.getNode(ISD::BITCAST, dl, MVT::v4f32, SignBit);
8049     SignBit = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, MVT::f32, SignBit,
8050                           DAG.getIntPtrConstant(0));
8051   }
8052
8053   // Clear first operand sign bit.
8054   CV.clear();
8055   if (VT == MVT::f64) {
8056     CV.push_back(ConstantFP::get(*Context, APFloat(APInt(64, ~(1ULL << 63)))));
8057     CV.push_back(ConstantFP::get(*Context, APFloat(APInt(64, 0))));
8058   } else {
8059     CV.push_back(ConstantFP::get(*Context, APFloat(APInt(32, ~(1U << 31)))));
8060     CV.push_back(ConstantFP::get(*Context, APFloat(APInt(32, 0))));
8061     CV.push_back(ConstantFP::get(*Context, APFloat(APInt(32, 0))));
8062     CV.push_back(ConstantFP::get(*Context, APFloat(APInt(32, 0))));
8063   }
8064   C = ConstantVector::get(CV);
8065   CPIdx = DAG.getConstantPool(C, getPointerTy(), 16);
8066   SDValue Mask2 = DAG.getLoad(VT, dl, DAG.getEntryNode(), CPIdx,
8067                               MachinePointerInfo::getConstantPool(),
8068                               false, false, 16);
8069   SDValue Val = DAG.getNode(X86ISD::FAND, dl, VT, Op0, Mask2);
8070
8071   // Or the value with the sign bit.
8072   return DAG.getNode(X86ISD::FOR, dl, VT, Val, SignBit);
8073 }
8074
8075 SDValue X86TargetLowering::LowerFGETSIGN(SDValue Op, SelectionDAG &DAG) const {
8076   SDValue N0 = Op.getOperand(0);
8077   DebugLoc dl = Op.getDebugLoc();
8078   EVT VT = Op.getValueType();
8079
8080   // Lower ISD::FGETSIGN to (AND (X86ISD::FGETSIGNx86 ...) 1).
8081   SDValue xFGETSIGN = DAG.getNode(X86ISD::FGETSIGNx86, dl, VT, N0,
8082                                   DAG.getConstant(1, VT));
8083   return DAG.getNode(ISD::AND, dl, VT, xFGETSIGN, DAG.getConstant(1, VT));
8084 }
8085
8086 /// Emit nodes that will be selected as "test Op0,Op0", or something
8087 /// equivalent.
8088 SDValue X86TargetLowering::EmitTest(SDValue Op, unsigned X86CC,
8089                                     SelectionDAG &DAG) const {
8090   DebugLoc dl = Op.getDebugLoc();
8091
8092   // CF and OF aren't always set the way we want. Determine which
8093   // of these we need.
8094   bool NeedCF = false;
8095   bool NeedOF = false;
8096   switch (X86CC) {
8097   default: break;
8098   case X86::COND_A: case X86::COND_AE:
8099   case X86::COND_B: case X86::COND_BE:
8100     NeedCF = true;
8101     break;
8102   case X86::COND_G: case X86::COND_GE:
8103   case X86::COND_L: case X86::COND_LE:
8104   case X86::COND_O: case X86::COND_NO:
8105     NeedOF = true;
8106     break;
8107   }
8108
8109   // See if we can use the EFLAGS value from the operand instead of
8110   // doing a separate TEST. TEST always sets OF and CF to 0, so unless
8111   // we prove that the arithmetic won't overflow, we can't use OF or CF.
8112   if (Op.getResNo() != 0 || NeedOF || NeedCF)
8113     // Emit a CMP with 0, which is the TEST pattern.
8114     return DAG.getNode(X86ISD::CMP, dl, MVT::i32, Op,
8115                        DAG.getConstant(0, Op.getValueType()));
8116
8117   unsigned Opcode = 0;
8118   unsigned NumOperands = 0;
8119   switch (Op.getNode()->getOpcode()) {
8120   case ISD::ADD:
8121     // Due to an isel shortcoming, be conservative if this add is likely to be
8122     // selected as part of a load-modify-store instruction. When the root node
8123     // in a match is a store, isel doesn't know how to remap non-chain non-flag
8124     // uses of other nodes in the match, such as the ADD in this case. This
8125     // leads to the ADD being left around and reselected, with the result being
8126     // two adds in the output.  Alas, even if none our users are stores, that
8127     // doesn't prove we're O.K.  Ergo, if we have any parents that aren't
8128     // CopyToReg or SETCC, eschew INC/DEC.  A better fix seems to require
8129     // climbing the DAG back to the root, and it doesn't seem to be worth the
8130     // effort.
8131     for (SDNode::use_iterator UI = Op.getNode()->use_begin(),
8132            UE = Op.getNode()->use_end(); UI != UE; ++UI)
8133       if (UI->getOpcode() != ISD::CopyToReg && UI->getOpcode() != ISD::SETCC)
8134         goto default_case;
8135
8136     if (ConstantSDNode *C =
8137         dyn_cast<ConstantSDNode>(Op.getNode()->getOperand(1))) {
8138       // An add of one will be selected as an INC.
8139       if (C->getAPIntValue() == 1) {
8140         Opcode = X86ISD::INC;
8141         NumOperands = 1;
8142         break;
8143       }
8144
8145       // An add of negative one (subtract of one) will be selected as a DEC.
8146       if (C->getAPIntValue().isAllOnesValue()) {
8147         Opcode = X86ISD::DEC;
8148         NumOperands = 1;
8149         break;
8150       }
8151     }
8152
8153     // Otherwise use a regular EFLAGS-setting add.
8154     Opcode = X86ISD::ADD;
8155     NumOperands = 2;
8156     break;
8157   case ISD::AND: {
8158     // If the primary and result isn't used, don't bother using X86ISD::AND,
8159     // because a TEST instruction will be better.
8160     bool NonFlagUse = false;
8161     for (SDNode::use_iterator UI = Op.getNode()->use_begin(),
8162            UE = Op.getNode()->use_end(); UI != UE; ++UI) {
8163       SDNode *User = *UI;
8164       unsigned UOpNo = UI.getOperandNo();
8165       if (User->getOpcode() == ISD::TRUNCATE && User->hasOneUse()) {
8166         // Look pass truncate.
8167         UOpNo = User->use_begin().getOperandNo();
8168         User = *User->use_begin();
8169       }
8170
8171       if (User->getOpcode() != ISD::BRCOND &&
8172           User->getOpcode() != ISD::SETCC &&
8173           (User->getOpcode() != ISD::SELECT || UOpNo != 0)) {
8174         NonFlagUse = true;
8175         break;
8176       }
8177     }
8178
8179     if (!NonFlagUse)
8180       break;
8181   }
8182     // FALL THROUGH
8183   case ISD::SUB:
8184   case ISD::OR:
8185   case ISD::XOR:
8186     // Due to the ISEL shortcoming noted above, be conservative if this op is
8187     // likely to be selected as part of a load-modify-store instruction.
8188     for (SDNode::use_iterator UI = Op.getNode()->use_begin(),
8189            UE = Op.getNode()->use_end(); UI != UE; ++UI)
8190       if (UI->getOpcode() == ISD::STORE)
8191         goto default_case;
8192
8193     // Otherwise use a regular EFLAGS-setting instruction.
8194     switch (Op.getNode()->getOpcode()) {
8195     default: llvm_unreachable("unexpected operator!");
8196     case ISD::SUB: Opcode = X86ISD::SUB; break;
8197     case ISD::OR:  Opcode = X86ISD::OR;  break;
8198     case ISD::XOR: Opcode = X86ISD::XOR; break;
8199     case ISD::AND: Opcode = X86ISD::AND; break;
8200     }
8201
8202     NumOperands = 2;
8203     break;
8204   case X86ISD::ADD:
8205   case X86ISD::SUB:
8206   case X86ISD::INC:
8207   case X86ISD::DEC:
8208   case X86ISD::OR:
8209   case X86ISD::XOR:
8210   case X86ISD::AND:
8211     return SDValue(Op.getNode(), 1);
8212   default:
8213   default_case:
8214     break;
8215   }
8216
8217   if (Opcode == 0)
8218     // Emit a CMP with 0, which is the TEST pattern.
8219     return DAG.getNode(X86ISD::CMP, dl, MVT::i32, Op,
8220                        DAG.getConstant(0, Op.getValueType()));
8221
8222   SDVTList VTs = DAG.getVTList(Op.getValueType(), MVT::i32);
8223   SmallVector<SDValue, 4> Ops;
8224   for (unsigned i = 0; i != NumOperands; ++i)
8225     Ops.push_back(Op.getOperand(i));
8226
8227   SDValue New = DAG.getNode(Opcode, dl, VTs, &Ops[0], NumOperands);
8228   DAG.ReplaceAllUsesWith(Op, New);
8229   return SDValue(New.getNode(), 1);
8230 }
8231
8232 /// Emit nodes that will be selected as "cmp Op0,Op1", or something
8233 /// equivalent.
8234 SDValue X86TargetLowering::EmitCmp(SDValue Op0, SDValue Op1, unsigned X86CC,
8235                                    SelectionDAG &DAG) const {
8236   if (ConstantSDNode *C = dyn_cast<ConstantSDNode>(Op1))
8237     if (C->getAPIntValue() == 0)
8238       return EmitTest(Op0, X86CC, DAG);
8239
8240   DebugLoc dl = Op0.getDebugLoc();
8241   return DAG.getNode(X86ISD::CMP, dl, MVT::i32, Op0, Op1);
8242 }
8243
8244 /// LowerToBT - Result of 'and' is compared against zero. Turn it into a BT node
8245 /// if it's possible.
8246 SDValue X86TargetLowering::LowerToBT(SDValue And, ISD::CondCode CC,
8247                                      DebugLoc dl, SelectionDAG &DAG) const {
8248   SDValue Op0 = And.getOperand(0);
8249   SDValue Op1 = And.getOperand(1);
8250   if (Op0.getOpcode() == ISD::TRUNCATE)
8251     Op0 = Op0.getOperand(0);
8252   if (Op1.getOpcode() == ISD::TRUNCATE)
8253     Op1 = Op1.getOperand(0);
8254
8255   SDValue LHS, RHS;
8256   if (Op1.getOpcode() == ISD::SHL)
8257     std::swap(Op0, Op1);
8258   if (Op0.getOpcode() == ISD::SHL) {
8259     if (ConstantSDNode *And00C = dyn_cast<ConstantSDNode>(Op0.getOperand(0)))
8260       if (And00C->getZExtValue() == 1) {
8261         // If we looked past a truncate, check that it's only truncating away
8262         // known zeros.
8263         unsigned BitWidth = Op0.getValueSizeInBits();
8264         unsigned AndBitWidth = And.getValueSizeInBits();
8265         if (BitWidth > AndBitWidth) {
8266           APInt Mask = APInt::getAllOnesValue(BitWidth), Zeros, Ones;
8267           DAG.ComputeMaskedBits(Op0, Mask, Zeros, Ones);
8268           if (Zeros.countLeadingOnes() < BitWidth - AndBitWidth)
8269             return SDValue();
8270         }
8271         LHS = Op1;
8272         RHS = Op0.getOperand(1);
8273       }
8274   } else if (Op1.getOpcode() == ISD::Constant) {
8275     ConstantSDNode *AndRHS = cast<ConstantSDNode>(Op1);
8276     SDValue AndLHS = Op0;
8277     if (AndRHS->getZExtValue() == 1 && AndLHS.getOpcode() == ISD::SRL) {
8278       LHS = AndLHS.getOperand(0);
8279       RHS = AndLHS.getOperand(1);
8280     }
8281   }
8282
8283   if (LHS.getNode()) {
8284     // If LHS is i8, promote it to i32 with any_extend.  There is no i8 BT
8285     // instruction.  Since the shift amount is in-range-or-undefined, we know
8286     // that doing a bittest on the i32 value is ok.  We extend to i32 because
8287     // the encoding for the i16 version is larger than the i32 version.
8288     // Also promote i16 to i32 for performance / code size reason.
8289     if (LHS.getValueType() == MVT::i8 ||
8290         LHS.getValueType() == MVT::i16)
8291       LHS = DAG.getNode(ISD::ANY_EXTEND, dl, MVT::i32, LHS);
8292
8293     // If the operand types disagree, extend the shift amount to match.  Since
8294     // BT ignores high bits (like shifts) we can use anyextend.
8295     if (LHS.getValueType() != RHS.getValueType())
8296       RHS = DAG.getNode(ISD::ANY_EXTEND, dl, LHS.getValueType(), RHS);
8297
8298     SDValue BT = DAG.getNode(X86ISD::BT, dl, MVT::i32, LHS, RHS);
8299     unsigned Cond = CC == ISD::SETEQ ? X86::COND_AE : X86::COND_B;
8300     return DAG.getNode(X86ISD::SETCC, dl, MVT::i8,
8301                        DAG.getConstant(Cond, MVT::i8), BT);
8302   }
8303
8304   return SDValue();
8305 }
8306
8307 SDValue X86TargetLowering::LowerSETCC(SDValue Op, SelectionDAG &DAG) const {
8308   assert(Op.getValueType() == MVT::i8 && "SetCC type must be 8-bit integer");
8309   SDValue Op0 = Op.getOperand(0);
8310   SDValue Op1 = Op.getOperand(1);
8311   DebugLoc dl = Op.getDebugLoc();
8312   ISD::CondCode CC = cast<CondCodeSDNode>(Op.getOperand(2))->get();
8313
8314   // Optimize to BT if possible.
8315   // Lower (X & (1 << N)) == 0 to BT(X, N).
8316   // Lower ((X >>u N) & 1) != 0 to BT(X, N).
8317   // Lower ((X >>s N) & 1) != 0 to BT(X, N).
8318   if (Op0.getOpcode() == ISD::AND && Op0.hasOneUse() &&
8319       Op1.getOpcode() == ISD::Constant &&
8320       cast<ConstantSDNode>(Op1)->isNullValue() &&
8321       (CC == ISD::SETEQ || CC == ISD::SETNE)) {
8322     SDValue NewSetCC = LowerToBT(Op0, CC, dl, DAG);
8323     if (NewSetCC.getNode())
8324       return NewSetCC;
8325   }
8326
8327   // Look for X == 0, X == 1, X != 0, or X != 1.  We can simplify some forms of
8328   // these.
8329   if (Op1.getOpcode() == ISD::Constant &&
8330       (cast<ConstantSDNode>(Op1)->getZExtValue() == 1 ||
8331        cast<ConstantSDNode>(Op1)->isNullValue()) &&
8332       (CC == ISD::SETEQ || CC == ISD::SETNE)) {
8333
8334     // If the input is a setcc, then reuse the input setcc or use a new one with
8335     // the inverted condition.
8336     if (Op0.getOpcode() == X86ISD::SETCC) {
8337       X86::CondCode CCode = (X86::CondCode)Op0.getConstantOperandVal(0);
8338       bool Invert = (CC == ISD::SETNE) ^
8339         cast<ConstantSDNode>(Op1)->isNullValue();
8340       if (!Invert) return Op0;
8341
8342       CCode = X86::GetOppositeBranchCondition(CCode);
8343       return DAG.getNode(X86ISD::SETCC, dl, MVT::i8,
8344                          DAG.getConstant(CCode, MVT::i8), Op0.getOperand(1));
8345     }
8346   }
8347
8348   bool isFP = Op1.getValueType().isFloatingPoint();
8349   unsigned X86CC = TranslateX86CC(CC, isFP, Op0, Op1, DAG);
8350   if (X86CC == X86::COND_INVALID)
8351     return SDValue();
8352
8353   SDValue EFLAGS = EmitCmp(Op0, Op1, X86CC, DAG);
8354   return DAG.getNode(X86ISD::SETCC, dl, MVT::i8,
8355                      DAG.getConstant(X86CC, MVT::i8), EFLAGS);
8356 }
8357
8358 // Lower256IntVETCC - Break a VSETCC 256-bit integer VSETCC into two new 128
8359 // ones, and then concatenate the result back.
8360 static SDValue Lower256IntVETCC(SDValue Op, SelectionDAG &DAG) {
8361   EVT VT = Op.getValueType();
8362
8363   assert(VT.getSizeInBits() == 256 && Op.getOpcode() == ISD::VSETCC &&
8364          "Unsupported value type for operation");
8365
8366   int NumElems = VT.getVectorNumElements();
8367   DebugLoc dl = Op.getDebugLoc();
8368   SDValue CC = Op.getOperand(2);
8369   SDValue Idx0 = DAG.getConstant(0, MVT::i32);
8370   SDValue Idx1 = DAG.getConstant(NumElems/2, MVT::i32);
8371
8372   // Extract the LHS vectors
8373   SDValue LHS = Op.getOperand(0);
8374   SDValue LHS1 = Extract128BitVector(LHS, Idx0, DAG, dl);
8375   SDValue LHS2 = Extract128BitVector(LHS, Idx1, DAG, dl);
8376
8377   // Extract the RHS vectors
8378   SDValue RHS = Op.getOperand(1);
8379   SDValue RHS1 = Extract128BitVector(RHS, Idx0, DAG, dl);
8380   SDValue RHS2 = Extract128BitVector(RHS, Idx1, DAG, dl);
8381
8382   // Issue the operation on the smaller types and concatenate the result back
8383   MVT EltVT = VT.getVectorElementType().getSimpleVT();
8384   EVT NewVT = MVT::getVectorVT(EltVT, NumElems/2);
8385   return DAG.getNode(ISD::CONCAT_VECTORS, dl, VT,
8386                      DAG.getNode(Op.getOpcode(), dl, NewVT, LHS1, RHS1, CC),
8387                      DAG.getNode(Op.getOpcode(), dl, NewVT, LHS2, RHS2, CC));
8388 }
8389
8390
8391 SDValue X86TargetLowering::LowerVSETCC(SDValue Op, SelectionDAG &DAG) const {
8392   SDValue Cond;
8393   SDValue Op0 = Op.getOperand(0);
8394   SDValue Op1 = Op.getOperand(1);
8395   SDValue CC = Op.getOperand(2);
8396   EVT VT = Op.getValueType();
8397   ISD::CondCode SetCCOpcode = cast<CondCodeSDNode>(CC)->get();
8398   bool isFP = Op.getOperand(1).getValueType().isFloatingPoint();
8399   DebugLoc dl = Op.getDebugLoc();
8400
8401   if (isFP) {
8402     unsigned SSECC = 8;
8403     EVT EltVT = Op0.getValueType().getVectorElementType();
8404     assert(EltVT == MVT::f32 || EltVT == MVT::f64);
8405
8406     unsigned Opc = EltVT == MVT::f32 ? X86ISD::CMPPS : X86ISD::CMPPD;
8407     bool Swap = false;
8408
8409     switch (SetCCOpcode) {
8410     default: break;
8411     case ISD::SETOEQ:
8412     case ISD::SETEQ:  SSECC = 0; break;
8413     case ISD::SETOGT:
8414     case ISD::SETGT: Swap = true; // Fallthrough
8415     case ISD::SETLT:
8416     case ISD::SETOLT: SSECC = 1; break;
8417     case ISD::SETOGE:
8418     case ISD::SETGE: Swap = true; // Fallthrough
8419     case ISD::SETLE:
8420     case ISD::SETOLE: SSECC = 2; break;
8421     case ISD::SETUO:  SSECC = 3; break;
8422     case ISD::SETUNE:
8423     case ISD::SETNE:  SSECC = 4; break;
8424     case ISD::SETULE: Swap = true;
8425     case ISD::SETUGE: SSECC = 5; break;
8426     case ISD::SETULT: Swap = true;
8427     case ISD::SETUGT: SSECC = 6; break;
8428     case ISD::SETO:   SSECC = 7; break;
8429     }
8430     if (Swap)
8431       std::swap(Op0, Op1);
8432
8433     // In the two special cases we can't handle, emit two comparisons.
8434     if (SSECC == 8) {
8435       if (SetCCOpcode == ISD::SETUEQ) {
8436         SDValue UNORD, EQ;
8437         UNORD = DAG.getNode(Opc, dl, VT, Op0, Op1, DAG.getConstant(3, MVT::i8));
8438         EQ = DAG.getNode(Opc, dl, VT, Op0, Op1, DAG.getConstant(0, MVT::i8));
8439         return DAG.getNode(ISD::OR, dl, VT, UNORD, EQ);
8440       }
8441       else if (SetCCOpcode == ISD::SETONE) {
8442         SDValue ORD, NEQ;
8443         ORD = DAG.getNode(Opc, dl, VT, Op0, Op1, DAG.getConstant(7, MVT::i8));
8444         NEQ = DAG.getNode(Opc, dl, VT, Op0, Op1, DAG.getConstant(4, MVT::i8));
8445         return DAG.getNode(ISD::AND, dl, VT, ORD, NEQ);
8446       }
8447       llvm_unreachable("Illegal FP comparison");
8448     }
8449     // Handle all other FP comparisons here.
8450     return DAG.getNode(Opc, dl, VT, Op0, Op1, DAG.getConstant(SSECC, MVT::i8));
8451   }
8452
8453   // Break 256-bit integer vector compare into smaller ones.
8454   if (!isFP && VT.getSizeInBits() == 256)
8455     return Lower256IntVETCC(Op, DAG);
8456
8457   // We are handling one of the integer comparisons here.  Since SSE only has
8458   // GT and EQ comparisons for integer, swapping operands and multiple
8459   // operations may be required for some comparisons.
8460   unsigned Opc = 0, EQOpc = 0, GTOpc = 0;
8461   bool Swap = false, Invert = false, FlipSigns = false;
8462
8463   switch (VT.getSimpleVT().SimpleTy) {
8464   default: break;
8465   case MVT::v16i8: EQOpc = X86ISD::PCMPEQB; GTOpc = X86ISD::PCMPGTB; break;
8466   case MVT::v8i16: EQOpc = X86ISD::PCMPEQW; GTOpc = X86ISD::PCMPGTW; break;
8467   case MVT::v4i32: EQOpc = X86ISD::PCMPEQD; GTOpc = X86ISD::PCMPGTD; break;
8468   case MVT::v2i64: EQOpc = X86ISD::PCMPEQQ; GTOpc = X86ISD::PCMPGTQ; break;
8469   }
8470
8471   switch (SetCCOpcode) {
8472   default: break;
8473   case ISD::SETNE:  Invert = true;
8474   case ISD::SETEQ:  Opc = EQOpc; break;
8475   case ISD::SETLT:  Swap = true;
8476   case ISD::SETGT:  Opc = GTOpc; break;
8477   case ISD::SETGE:  Swap = true;
8478   case ISD::SETLE:  Opc = GTOpc; Invert = true; break;
8479   case ISD::SETULT: Swap = true;
8480   case ISD::SETUGT: Opc = GTOpc; FlipSigns = true; break;
8481   case ISD::SETUGE: Swap = true;
8482   case ISD::SETULE: Opc = GTOpc; FlipSigns = true; Invert = true; break;
8483   }
8484   if (Swap)
8485     std::swap(Op0, Op1);
8486
8487   // Since SSE has no unsigned integer comparisons, we need to flip  the sign
8488   // bits of the inputs before performing those operations.
8489   if (FlipSigns) {
8490     EVT EltVT = VT.getVectorElementType();
8491     SDValue SignBit = DAG.getConstant(APInt::getSignBit(EltVT.getSizeInBits()),
8492                                       EltVT);
8493     std::vector<SDValue> SignBits(VT.getVectorNumElements(), SignBit);
8494     SDValue SignVec = DAG.getNode(ISD::BUILD_VECTOR, dl, VT, &SignBits[0],
8495                                     SignBits.size());
8496     Op0 = DAG.getNode(ISD::XOR, dl, VT, Op0, SignVec);
8497     Op1 = DAG.getNode(ISD::XOR, dl, VT, Op1, SignVec);
8498   }
8499
8500   SDValue Result = DAG.getNode(Opc, dl, VT, Op0, Op1);
8501
8502   // If the logical-not of the result is required, perform that now.
8503   if (Invert)
8504     Result = DAG.getNOT(dl, Result, VT);
8505
8506   return Result;
8507 }
8508
8509 // isX86LogicalCmp - Return true if opcode is a X86 logical comparison.
8510 static bool isX86LogicalCmp(SDValue Op) {
8511   unsigned Opc = Op.getNode()->getOpcode();
8512   if (Opc == X86ISD::CMP || Opc == X86ISD::COMI || Opc == X86ISD::UCOMI)
8513     return true;
8514   if (Op.getResNo() == 1 &&
8515       (Opc == X86ISD::ADD ||
8516        Opc == X86ISD::SUB ||
8517        Opc == X86ISD::ADC ||
8518        Opc == X86ISD::SBB ||
8519        Opc == X86ISD::SMUL ||
8520        Opc == X86ISD::UMUL ||
8521        Opc == X86ISD::INC ||
8522        Opc == X86ISD::DEC ||
8523        Opc == X86ISD::OR ||
8524        Opc == X86ISD::XOR ||
8525        Opc == X86ISD::AND))
8526     return true;
8527
8528   if (Op.getResNo() == 2 && Opc == X86ISD::UMUL)
8529     return true;
8530
8531   return false;
8532 }
8533
8534 static bool isZero(SDValue V) {
8535   ConstantSDNode *C = dyn_cast<ConstantSDNode>(V);
8536   return C && C->isNullValue();
8537 }
8538
8539 static bool isAllOnes(SDValue V) {
8540   ConstantSDNode *C = dyn_cast<ConstantSDNode>(V);
8541   return C && C->isAllOnesValue();
8542 }
8543
8544 SDValue X86TargetLowering::LowerSELECT(SDValue Op, SelectionDAG &DAG) const {
8545   bool addTest = true;
8546   SDValue Cond  = Op.getOperand(0);
8547   SDValue Op1 = Op.getOperand(1);
8548   SDValue Op2 = Op.getOperand(2);
8549   DebugLoc DL = Op.getDebugLoc();
8550   SDValue CC;
8551
8552   if (Cond.getOpcode() == ISD::SETCC) {
8553     SDValue NewCond = LowerSETCC(Cond, DAG);
8554     if (NewCond.getNode())
8555       Cond = NewCond;
8556   }
8557
8558   // (select (x == 0), -1, y) -> (sign_bit (x - 1)) | y
8559   // (select (x == 0), y, -1) -> ~(sign_bit (x - 1)) | y
8560   // (select (x != 0), y, -1) -> (sign_bit (x - 1)) | y
8561   // (select (x != 0), -1, y) -> ~(sign_bit (x - 1)) | y
8562   if (Cond.getOpcode() == X86ISD::SETCC &&
8563       Cond.getOperand(1).getOpcode() == X86ISD::CMP &&
8564       isZero(Cond.getOperand(1).getOperand(1))) {
8565     SDValue Cmp = Cond.getOperand(1);
8566
8567     unsigned CondCode =cast<ConstantSDNode>(Cond.getOperand(0))->getZExtValue();
8568
8569     if ((isAllOnes(Op1) || isAllOnes(Op2)) &&
8570         (CondCode == X86::COND_E || CondCode == X86::COND_NE)) {
8571       SDValue Y = isAllOnes(Op2) ? Op1 : Op2;
8572
8573       SDValue CmpOp0 = Cmp.getOperand(0);
8574       Cmp = DAG.getNode(X86ISD::CMP, DL, MVT::i32,
8575                         CmpOp0, DAG.getConstant(1, CmpOp0.getValueType()));
8576
8577       SDValue Res =   // Res = 0 or -1.
8578         DAG.getNode(X86ISD::SETCC_CARRY, DL, Op.getValueType(),
8579                     DAG.getConstant(X86::COND_B, MVT::i8), Cmp);
8580
8581       if (isAllOnes(Op1) != (CondCode == X86::COND_E))
8582         Res = DAG.getNOT(DL, Res, Res.getValueType());
8583
8584       ConstantSDNode *N2C = dyn_cast<ConstantSDNode>(Op2);
8585       if (N2C == 0 || !N2C->isNullValue())
8586         Res = DAG.getNode(ISD::OR, DL, Res.getValueType(), Res, Y);
8587       return Res;
8588     }
8589   }
8590
8591   // Look past (and (setcc_carry (cmp ...)), 1).
8592   if (Cond.getOpcode() == ISD::AND &&
8593       Cond.getOperand(0).getOpcode() == X86ISD::SETCC_CARRY) {
8594     ConstantSDNode *C = dyn_cast<ConstantSDNode>(Cond.getOperand(1));
8595     if (C && C->getAPIntValue() == 1)
8596       Cond = Cond.getOperand(0);
8597   }
8598
8599   // If condition flag is set by a X86ISD::CMP, then use it as the condition
8600   // setting operand in place of the X86ISD::SETCC.
8601   if (Cond.getOpcode() == X86ISD::SETCC ||
8602       Cond.getOpcode() == X86ISD::SETCC_CARRY) {
8603     CC = Cond.getOperand(0);
8604
8605     SDValue Cmp = Cond.getOperand(1);
8606     unsigned Opc = Cmp.getOpcode();
8607     EVT VT = Op.getValueType();
8608
8609     bool IllegalFPCMov = false;
8610     if (VT.isFloatingPoint() && !VT.isVector() &&
8611         !isScalarFPTypeInSSEReg(VT))  // FPStack?
8612       IllegalFPCMov = !hasFPCMov(cast<ConstantSDNode>(CC)->getSExtValue());
8613
8614     if ((isX86LogicalCmp(Cmp) && !IllegalFPCMov) ||
8615         Opc == X86ISD::BT) { // FIXME
8616       Cond = Cmp;
8617       addTest = false;
8618     }
8619   }
8620
8621   if (addTest) {
8622     // Look pass the truncate.
8623     if (Cond.getOpcode() == ISD::TRUNCATE)
8624       Cond = Cond.getOperand(0);
8625
8626     // We know the result of AND is compared against zero. Try to match
8627     // it to BT.
8628     if (Cond.getOpcode() == ISD::AND && Cond.hasOneUse()) {
8629       SDValue NewSetCC = LowerToBT(Cond, ISD::SETNE, DL, DAG);
8630       if (NewSetCC.getNode()) {
8631         CC = NewSetCC.getOperand(0);
8632         Cond = NewSetCC.getOperand(1);
8633         addTest = false;
8634       }
8635     }
8636   }
8637
8638   if (addTest) {
8639     CC = DAG.getConstant(X86::COND_NE, MVT::i8);
8640     Cond = EmitTest(Cond, X86::COND_NE, DAG);
8641   }
8642
8643   // a <  b ? -1 :  0 -> RES = ~setcc_carry
8644   // a <  b ?  0 : -1 -> RES = setcc_carry
8645   // a >= b ? -1 :  0 -> RES = setcc_carry
8646   // a >= b ?  0 : -1 -> RES = ~setcc_carry
8647   if (Cond.getOpcode() == X86ISD::CMP) {
8648     unsigned CondCode = cast<ConstantSDNode>(CC)->getZExtValue();
8649
8650     if ((CondCode == X86::COND_AE || CondCode == X86::COND_B) &&
8651         (isAllOnes(Op1) || isAllOnes(Op2)) && (isZero(Op1) || isZero(Op2))) {
8652       SDValue Res = DAG.getNode(X86ISD::SETCC_CARRY, DL, Op.getValueType(),
8653                                 DAG.getConstant(X86::COND_B, MVT::i8), Cond);
8654       if (isAllOnes(Op1) != (CondCode == X86::COND_B))
8655         return DAG.getNOT(DL, Res, Res.getValueType());
8656       return Res;
8657     }
8658   }
8659
8660   // X86ISD::CMOV means set the result (which is operand 1) to the RHS if
8661   // condition is true.
8662   SDVTList VTs = DAG.getVTList(Op.getValueType(), MVT::Glue);
8663   SDValue Ops[] = { Op2, Op1, CC, Cond };
8664   return DAG.getNode(X86ISD::CMOV, DL, VTs, Ops, array_lengthof(Ops));
8665 }
8666
8667 // isAndOrOfSingleUseSetCCs - Return true if node is an ISD::AND or
8668 // ISD::OR of two X86ISD::SETCC nodes each of which has no other use apart
8669 // from the AND / OR.
8670 static bool isAndOrOfSetCCs(SDValue Op, unsigned &Opc) {
8671   Opc = Op.getOpcode();
8672   if (Opc != ISD::OR && Opc != ISD::AND)
8673     return false;
8674   return (Op.getOperand(0).getOpcode() == X86ISD::SETCC &&
8675           Op.getOperand(0).hasOneUse() &&
8676           Op.getOperand(1).getOpcode() == X86ISD::SETCC &&
8677           Op.getOperand(1).hasOneUse());
8678 }
8679
8680 // isXor1OfSetCC - Return true if node is an ISD::XOR of a X86ISD::SETCC and
8681 // 1 and that the SETCC node has a single use.
8682 static bool isXor1OfSetCC(SDValue Op) {
8683   if (Op.getOpcode() != ISD::XOR)
8684     return false;
8685   ConstantSDNode *N1C = dyn_cast<ConstantSDNode>(Op.getOperand(1));
8686   if (N1C && N1C->getAPIntValue() == 1) {
8687     return Op.getOperand(0).getOpcode() == X86ISD::SETCC &&
8688       Op.getOperand(0).hasOneUse();
8689   }
8690   return false;
8691 }
8692
8693 SDValue X86TargetLowering::LowerBRCOND(SDValue Op, SelectionDAG &DAG) const {
8694   bool addTest = true;
8695   SDValue Chain = Op.getOperand(0);
8696   SDValue Cond  = Op.getOperand(1);
8697   SDValue Dest  = Op.getOperand(2);
8698   DebugLoc dl = Op.getDebugLoc();
8699   SDValue CC;
8700
8701   if (Cond.getOpcode() == ISD::SETCC) {
8702     SDValue NewCond = LowerSETCC(Cond, DAG);
8703     if (NewCond.getNode())
8704       Cond = NewCond;
8705   }
8706 #if 0
8707   // FIXME: LowerXALUO doesn't handle these!!
8708   else if (Cond.getOpcode() == X86ISD::ADD  ||
8709            Cond.getOpcode() == X86ISD::SUB  ||
8710            Cond.getOpcode() == X86ISD::SMUL ||
8711            Cond.getOpcode() == X86ISD::UMUL)
8712     Cond = LowerXALUO(Cond, DAG);
8713 #endif
8714
8715   // Look pass (and (setcc_carry (cmp ...)), 1).
8716   if (Cond.getOpcode() == ISD::AND &&
8717       Cond.getOperand(0).getOpcode() == X86ISD::SETCC_CARRY) {
8718     ConstantSDNode *C = dyn_cast<ConstantSDNode>(Cond.getOperand(1));
8719     if (C && C->getAPIntValue() == 1)
8720       Cond = Cond.getOperand(0);
8721   }
8722
8723   // If condition flag is set by a X86ISD::CMP, then use it as the condition
8724   // setting operand in place of the X86ISD::SETCC.
8725   if (Cond.getOpcode() == X86ISD::SETCC ||
8726       Cond.getOpcode() == X86ISD::SETCC_CARRY) {
8727     CC = Cond.getOperand(0);
8728
8729     SDValue Cmp = Cond.getOperand(1);
8730     unsigned Opc = Cmp.getOpcode();
8731     // FIXME: WHY THE SPECIAL CASING OF LogicalCmp??
8732     if (isX86LogicalCmp(Cmp) || Opc == X86ISD::BT) {
8733       Cond = Cmp;
8734       addTest = false;
8735     } else {
8736       switch (cast<ConstantSDNode>(CC)->getZExtValue()) {
8737       default: break;
8738       case X86::COND_O:
8739       case X86::COND_B:
8740         // These can only come from an arithmetic instruction with overflow,
8741         // e.g. SADDO, UADDO.
8742         Cond = Cond.getNode()->getOperand(1);
8743         addTest = false;
8744         break;
8745       }
8746     }
8747   } else {
8748     unsigned CondOpc;
8749     if (Cond.hasOneUse() && isAndOrOfSetCCs(Cond, CondOpc)) {
8750       SDValue Cmp = Cond.getOperand(0).getOperand(1);
8751       if (CondOpc == ISD::OR) {
8752         // Also, recognize the pattern generated by an FCMP_UNE. We can emit
8753         // two branches instead of an explicit OR instruction with a
8754         // separate test.
8755         if (Cmp == Cond.getOperand(1).getOperand(1) &&
8756             isX86LogicalCmp(Cmp)) {
8757           CC = Cond.getOperand(0).getOperand(0);
8758           Chain = DAG.getNode(X86ISD::BRCOND, dl, Op.getValueType(),
8759                               Chain, Dest, CC, Cmp);
8760           CC = Cond.getOperand(1).getOperand(0);
8761           Cond = Cmp;
8762           addTest = false;
8763         }
8764       } else { // ISD::AND
8765         // Also, recognize the pattern generated by an FCMP_OEQ. We can emit
8766         // two branches instead of an explicit AND instruction with a
8767         // separate test. However, we only do this if this block doesn't
8768         // have a fall-through edge, because this requires an explicit
8769         // jmp when the condition is false.
8770         if (Cmp == Cond.getOperand(1).getOperand(1) &&
8771             isX86LogicalCmp(Cmp) &&
8772             Op.getNode()->hasOneUse()) {
8773           X86::CondCode CCode =
8774             (X86::CondCode)Cond.getOperand(0).getConstantOperandVal(0);
8775           CCode = X86::GetOppositeBranchCondition(CCode);
8776           CC = DAG.getConstant(CCode, MVT::i8);
8777           SDNode *User = *Op.getNode()->use_begin();
8778           // Look for an unconditional branch following this conditional branch.
8779           // We need this because we need to reverse the successors in order
8780           // to implement FCMP_OEQ.
8781           if (User->getOpcode() == ISD::BR) {
8782             SDValue FalseBB = User->getOperand(1);
8783             SDNode *NewBR =
8784               DAG.UpdateNodeOperands(User, User->getOperand(0), Dest);
8785             assert(NewBR == User);
8786             (void)NewBR;
8787             Dest = FalseBB;
8788
8789             Chain = DAG.getNode(X86ISD::BRCOND, dl, Op.getValueType(),
8790                                 Chain, Dest, CC, Cmp);
8791             X86::CondCode CCode =
8792               (X86::CondCode)Cond.getOperand(1).getConstantOperandVal(0);
8793             CCode = X86::GetOppositeBranchCondition(CCode);
8794             CC = DAG.getConstant(CCode, MVT::i8);
8795             Cond = Cmp;
8796             addTest = false;
8797           }
8798         }
8799       }
8800     } else if (Cond.hasOneUse() && isXor1OfSetCC(Cond)) {
8801       // Recognize for xorb (setcc), 1 patterns. The xor inverts the condition.
8802       // It should be transformed during dag combiner except when the condition
8803       // is set by a arithmetics with overflow node.
8804       X86::CondCode CCode =
8805         (X86::CondCode)Cond.getOperand(0).getConstantOperandVal(0);
8806       CCode = X86::GetOppositeBranchCondition(CCode);
8807       CC = DAG.getConstant(CCode, MVT::i8);
8808       Cond = Cond.getOperand(0).getOperand(1);
8809       addTest = false;
8810     }
8811   }
8812
8813   if (addTest) {
8814     // Look pass the truncate.
8815     if (Cond.getOpcode() == ISD::TRUNCATE)
8816       Cond = Cond.getOperand(0);
8817
8818     // We know the result of AND is compared against zero. Try to match
8819     // it to BT.
8820     if (Cond.getOpcode() == ISD::AND && Cond.hasOneUse()) {
8821       SDValue NewSetCC = LowerToBT(Cond, ISD::SETNE, dl, DAG);
8822       if (NewSetCC.getNode()) {
8823         CC = NewSetCC.getOperand(0);
8824         Cond = NewSetCC.getOperand(1);
8825         addTest = false;
8826       }
8827     }
8828   }
8829
8830   if (addTest) {
8831     CC = DAG.getConstant(X86::COND_NE, MVT::i8);
8832     Cond = EmitTest(Cond, X86::COND_NE, DAG);
8833   }
8834   return DAG.getNode(X86ISD::BRCOND, dl, Op.getValueType(),
8835                      Chain, Dest, CC, Cond);
8836 }
8837
8838
8839 // Lower dynamic stack allocation to _alloca call for Cygwin/Mingw targets.
8840 // Calls to _alloca is needed to probe the stack when allocating more than 4k
8841 // bytes in one go. Touching the stack at 4K increments is necessary to ensure
8842 // that the guard pages used by the OS virtual memory manager are allocated in
8843 // correct sequence.
8844 SDValue
8845 X86TargetLowering::LowerDYNAMIC_STACKALLOC(SDValue Op,
8846                                            SelectionDAG &DAG) const {
8847   assert((Subtarget->isTargetCygMing() || Subtarget->isTargetWindows()) &&
8848          "This should be used only on Windows targets");
8849   assert(!Subtarget->isTargetEnvMacho());
8850   DebugLoc dl = Op.getDebugLoc();
8851
8852   // Get the inputs.
8853   SDValue Chain = Op.getOperand(0);
8854   SDValue Size  = Op.getOperand(1);
8855   // FIXME: Ensure alignment here
8856
8857   SDValue Flag;
8858
8859   EVT SPTy = Subtarget->is64Bit() ? MVT::i64 : MVT::i32;
8860   unsigned Reg = (Subtarget->is64Bit() ? X86::RAX : X86::EAX);
8861
8862   Chain = DAG.getCopyToReg(Chain, dl, Reg, Size, Flag);
8863   Flag = Chain.getValue(1);
8864
8865   SDVTList NodeTys = DAG.getVTList(MVT::Other, MVT::Glue);
8866
8867   Chain = DAG.getNode(X86ISD::WIN_ALLOCA, dl, NodeTys, Chain, Flag);
8868   Flag = Chain.getValue(1);
8869
8870   Chain = DAG.getCopyFromReg(Chain, dl, X86StackPtr, SPTy).getValue(1);
8871
8872   SDValue Ops1[2] = { Chain.getValue(0), Chain };
8873   return DAG.getMergeValues(Ops1, 2, dl);
8874 }
8875
8876 SDValue X86TargetLowering::LowerVASTART(SDValue Op, SelectionDAG &DAG) const {
8877   MachineFunction &MF = DAG.getMachineFunction();
8878   X86MachineFunctionInfo *FuncInfo = MF.getInfo<X86MachineFunctionInfo>();
8879
8880   const Value *SV = cast<SrcValueSDNode>(Op.getOperand(2))->getValue();
8881   DebugLoc DL = Op.getDebugLoc();
8882
8883   if (!Subtarget->is64Bit() || Subtarget->isTargetWin64()) {
8884     // vastart just stores the address of the VarArgsFrameIndex slot into the
8885     // memory location argument.
8886     SDValue FR = DAG.getFrameIndex(FuncInfo->getVarArgsFrameIndex(),
8887                                    getPointerTy());
8888     return DAG.getStore(Op.getOperand(0), DL, FR, Op.getOperand(1),
8889                         MachinePointerInfo(SV), false, false, 0);
8890   }
8891
8892   // __va_list_tag:
8893   //   gp_offset         (0 - 6 * 8)
8894   //   fp_offset         (48 - 48 + 8 * 16)
8895   //   overflow_arg_area (point to parameters coming in memory).
8896   //   reg_save_area
8897   SmallVector<SDValue, 8> MemOps;
8898   SDValue FIN = Op.getOperand(1);
8899   // Store gp_offset
8900   SDValue Store = DAG.getStore(Op.getOperand(0), DL,
8901                                DAG.getConstant(FuncInfo->getVarArgsGPOffset(),
8902                                                MVT::i32),
8903                                FIN, MachinePointerInfo(SV), false, false, 0);
8904   MemOps.push_back(Store);
8905
8906   // Store fp_offset
8907   FIN = DAG.getNode(ISD::ADD, DL, getPointerTy(),
8908                     FIN, DAG.getIntPtrConstant(4));
8909   Store = DAG.getStore(Op.getOperand(0), DL,
8910                        DAG.getConstant(FuncInfo->getVarArgsFPOffset(),
8911                                        MVT::i32),
8912                        FIN, MachinePointerInfo(SV, 4), false, false, 0);
8913   MemOps.push_back(Store);
8914
8915   // Store ptr to overflow_arg_area
8916   FIN = DAG.getNode(ISD::ADD, DL, getPointerTy(),
8917                     FIN, DAG.getIntPtrConstant(4));
8918   SDValue OVFIN = DAG.getFrameIndex(FuncInfo->getVarArgsFrameIndex(),
8919                                     getPointerTy());
8920   Store = DAG.getStore(Op.getOperand(0), DL, OVFIN, FIN,
8921                        MachinePointerInfo(SV, 8),
8922                        false, false, 0);
8923   MemOps.push_back(Store);
8924
8925   // Store ptr to reg_save_area.
8926   FIN = DAG.getNode(ISD::ADD, DL, getPointerTy(),
8927                     FIN, DAG.getIntPtrConstant(8));
8928   SDValue RSFIN = DAG.getFrameIndex(FuncInfo->getRegSaveFrameIndex(),
8929                                     getPointerTy());
8930   Store = DAG.getStore(Op.getOperand(0), DL, RSFIN, FIN,
8931                        MachinePointerInfo(SV, 16), false, false, 0);
8932   MemOps.push_back(Store);
8933   return DAG.getNode(ISD::TokenFactor, DL, MVT::Other,
8934                      &MemOps[0], MemOps.size());
8935 }
8936
8937 SDValue X86TargetLowering::LowerVAARG(SDValue Op, SelectionDAG &DAG) const {
8938   assert(Subtarget->is64Bit() &&
8939          "LowerVAARG only handles 64-bit va_arg!");
8940   assert((Subtarget->isTargetLinux() ||
8941           Subtarget->isTargetDarwin()) &&
8942           "Unhandled target in LowerVAARG");
8943   assert(Op.getNode()->getNumOperands() == 4);
8944   SDValue Chain = Op.getOperand(0);
8945   SDValue SrcPtr = Op.getOperand(1);
8946   const Value *SV = cast<SrcValueSDNode>(Op.getOperand(2))->getValue();
8947   unsigned Align = Op.getConstantOperandVal(3);
8948   DebugLoc dl = Op.getDebugLoc();
8949
8950   EVT ArgVT = Op.getNode()->getValueType(0);
8951   Type *ArgTy = ArgVT.getTypeForEVT(*DAG.getContext());
8952   uint32_t ArgSize = getTargetData()->getTypeAllocSize(ArgTy);
8953   uint8_t ArgMode;
8954
8955   // Decide which area this value should be read from.
8956   // TODO: Implement the AMD64 ABI in its entirety. This simple
8957   // selection mechanism works only for the basic types.
8958   if (ArgVT == MVT::f80) {
8959     llvm_unreachable("va_arg for f80 not yet implemented");
8960   } else if (ArgVT.isFloatingPoint() && ArgSize <= 16 /*bytes*/) {
8961     ArgMode = 2;  // Argument passed in XMM register. Use fp_offset.
8962   } else if (ArgVT.isInteger() && ArgSize <= 32 /*bytes*/) {
8963     ArgMode = 1;  // Argument passed in GPR64 register(s). Use gp_offset.
8964   } else {
8965     llvm_unreachable("Unhandled argument type in LowerVAARG");
8966   }
8967
8968   if (ArgMode == 2) {
8969     // Sanity Check: Make sure using fp_offset makes sense.
8970     assert(!UseSoftFloat &&
8971            !(DAG.getMachineFunction()
8972                 .getFunction()->hasFnAttr(Attribute::NoImplicitFloat)) &&
8973            Subtarget->hasXMM());
8974   }
8975
8976   // Insert VAARG_64 node into the DAG
8977   // VAARG_64 returns two values: Variable Argument Address, Chain
8978   SmallVector<SDValue, 11> InstOps;
8979   InstOps.push_back(Chain);
8980   InstOps.push_back(SrcPtr);
8981   InstOps.push_back(DAG.getConstant(ArgSize, MVT::i32));
8982   InstOps.push_back(DAG.getConstant(ArgMode, MVT::i8));
8983   InstOps.push_back(DAG.getConstant(Align, MVT::i32));
8984   SDVTList VTs = DAG.getVTList(getPointerTy(), MVT::Other);
8985   SDValue VAARG = DAG.getMemIntrinsicNode(X86ISD::VAARG_64, dl,
8986                                           VTs, &InstOps[0], InstOps.size(),
8987                                           MVT::i64,
8988                                           MachinePointerInfo(SV),
8989                                           /*Align=*/0,
8990                                           /*Volatile=*/false,
8991                                           /*ReadMem=*/true,
8992                                           /*WriteMem=*/true);
8993   Chain = VAARG.getValue(1);
8994
8995   // Load the next argument and return it
8996   return DAG.getLoad(ArgVT, dl,
8997                      Chain,
8998                      VAARG,
8999                      MachinePointerInfo(),
9000                      false, false, 0);
9001 }
9002
9003 SDValue X86TargetLowering::LowerVACOPY(SDValue Op, SelectionDAG &DAG) const {
9004   // X86-64 va_list is a struct { i32, i32, i8*, i8* }.
9005   assert(Subtarget->is64Bit() && "This code only handles 64-bit va_copy!");
9006   SDValue Chain = Op.getOperand(0);
9007   SDValue DstPtr = Op.getOperand(1);
9008   SDValue SrcPtr = Op.getOperand(2);
9009   const Value *DstSV = cast<SrcValueSDNode>(Op.getOperand(3))->getValue();
9010   const Value *SrcSV = cast<SrcValueSDNode>(Op.getOperand(4))->getValue();
9011   DebugLoc DL = Op.getDebugLoc();
9012
9013   return DAG.getMemcpy(Chain, DL, DstPtr, SrcPtr,
9014                        DAG.getIntPtrConstant(24), 8, /*isVolatile*/false,
9015                        false,
9016                        MachinePointerInfo(DstSV), MachinePointerInfo(SrcSV));
9017 }
9018
9019 SDValue
9020 X86TargetLowering::LowerINTRINSIC_WO_CHAIN(SDValue Op, SelectionDAG &DAG) const {
9021   DebugLoc dl = Op.getDebugLoc();
9022   unsigned IntNo = cast<ConstantSDNode>(Op.getOperand(0))->getZExtValue();
9023   switch (IntNo) {
9024   default: return SDValue();    // Don't custom lower most intrinsics.
9025   // Comparison intrinsics.
9026   case Intrinsic::x86_sse_comieq_ss:
9027   case Intrinsic::x86_sse_comilt_ss:
9028   case Intrinsic::x86_sse_comile_ss:
9029   case Intrinsic::x86_sse_comigt_ss:
9030   case Intrinsic::x86_sse_comige_ss:
9031   case Intrinsic::x86_sse_comineq_ss:
9032   case Intrinsic::x86_sse_ucomieq_ss:
9033   case Intrinsic::x86_sse_ucomilt_ss:
9034   case Intrinsic::x86_sse_ucomile_ss:
9035   case Intrinsic::x86_sse_ucomigt_ss:
9036   case Intrinsic::x86_sse_ucomige_ss:
9037   case Intrinsic::x86_sse_ucomineq_ss:
9038   case Intrinsic::x86_sse2_comieq_sd:
9039   case Intrinsic::x86_sse2_comilt_sd:
9040   case Intrinsic::x86_sse2_comile_sd:
9041   case Intrinsic::x86_sse2_comigt_sd:
9042   case Intrinsic::x86_sse2_comige_sd:
9043   case Intrinsic::x86_sse2_comineq_sd:
9044   case Intrinsic::x86_sse2_ucomieq_sd:
9045   case Intrinsic::x86_sse2_ucomilt_sd:
9046   case Intrinsic::x86_sse2_ucomile_sd:
9047   case Intrinsic::x86_sse2_ucomigt_sd:
9048   case Intrinsic::x86_sse2_ucomige_sd:
9049   case Intrinsic::x86_sse2_ucomineq_sd: {
9050     unsigned Opc = 0;
9051     ISD::CondCode CC = ISD::SETCC_INVALID;
9052     switch (IntNo) {
9053     default: break;
9054     case Intrinsic::x86_sse_comieq_ss:
9055     case Intrinsic::x86_sse2_comieq_sd:
9056       Opc = X86ISD::COMI;
9057       CC = ISD::SETEQ;
9058       break;
9059     case Intrinsic::x86_sse_comilt_ss:
9060     case Intrinsic::x86_sse2_comilt_sd:
9061       Opc = X86ISD::COMI;
9062       CC = ISD::SETLT;
9063       break;
9064     case Intrinsic::x86_sse_comile_ss:
9065     case Intrinsic::x86_sse2_comile_sd:
9066       Opc = X86ISD::COMI;
9067       CC = ISD::SETLE;
9068       break;
9069     case Intrinsic::x86_sse_comigt_ss:
9070     case Intrinsic::x86_sse2_comigt_sd:
9071       Opc = X86ISD::COMI;
9072       CC = ISD::SETGT;
9073       break;
9074     case Intrinsic::x86_sse_comige_ss:
9075     case Intrinsic::x86_sse2_comige_sd:
9076       Opc = X86ISD::COMI;
9077       CC = ISD::SETGE;
9078       break;
9079     case Intrinsic::x86_sse_comineq_ss:
9080     case Intrinsic::x86_sse2_comineq_sd:
9081       Opc = X86ISD::COMI;
9082       CC = ISD::SETNE;
9083       break;
9084     case Intrinsic::x86_sse_ucomieq_ss:
9085     case Intrinsic::x86_sse2_ucomieq_sd:
9086       Opc = X86ISD::UCOMI;
9087       CC = ISD::SETEQ;
9088       break;
9089     case Intrinsic::x86_sse_ucomilt_ss:
9090     case Intrinsic::x86_sse2_ucomilt_sd:
9091       Opc = X86ISD::UCOMI;
9092       CC = ISD::SETLT;
9093       break;
9094     case Intrinsic::x86_sse_ucomile_ss:
9095     case Intrinsic::x86_sse2_ucomile_sd:
9096       Opc = X86ISD::UCOMI;
9097       CC = ISD::SETLE;
9098       break;
9099     case Intrinsic::x86_sse_ucomigt_ss:
9100     case Intrinsic::x86_sse2_ucomigt_sd:
9101       Opc = X86ISD::UCOMI;
9102       CC = ISD::SETGT;
9103       break;
9104     case Intrinsic::x86_sse_ucomige_ss:
9105     case Intrinsic::x86_sse2_ucomige_sd:
9106       Opc = X86ISD::UCOMI;
9107       CC = ISD::SETGE;
9108       break;
9109     case Intrinsic::x86_sse_ucomineq_ss:
9110     case Intrinsic::x86_sse2_ucomineq_sd:
9111       Opc = X86ISD::UCOMI;
9112       CC = ISD::SETNE;
9113       break;
9114     }
9115
9116     SDValue LHS = Op.getOperand(1);
9117     SDValue RHS = Op.getOperand(2);
9118     unsigned X86CC = TranslateX86CC(CC, true, LHS, RHS, DAG);
9119     assert(X86CC != X86::COND_INVALID && "Unexpected illegal condition!");
9120     SDValue Cond = DAG.getNode(Opc, dl, MVT::i32, LHS, RHS);
9121     SDValue SetCC = DAG.getNode(X86ISD::SETCC, dl, MVT::i8,
9122                                 DAG.getConstant(X86CC, MVT::i8), Cond);
9123     return DAG.getNode(ISD::ZERO_EXTEND, dl, MVT::i32, SetCC);
9124   }
9125   // ptest and testp intrinsics. The intrinsic these come from are designed to
9126   // return an integer value, not just an instruction so lower it to the ptest
9127   // or testp pattern and a setcc for the result.
9128   case Intrinsic::x86_sse41_ptestz:
9129   case Intrinsic::x86_sse41_ptestc:
9130   case Intrinsic::x86_sse41_ptestnzc:
9131   case Intrinsic::x86_avx_ptestz_256:
9132   case Intrinsic::x86_avx_ptestc_256:
9133   case Intrinsic::x86_avx_ptestnzc_256:
9134   case Intrinsic::x86_avx_vtestz_ps:
9135   case Intrinsic::x86_avx_vtestc_ps:
9136   case Intrinsic::x86_avx_vtestnzc_ps:
9137   case Intrinsic::x86_avx_vtestz_pd:
9138   case Intrinsic::x86_avx_vtestc_pd:
9139   case Intrinsic::x86_avx_vtestnzc_pd:
9140   case Intrinsic::x86_avx_vtestz_ps_256:
9141   case Intrinsic::x86_avx_vtestc_ps_256:
9142   case Intrinsic::x86_avx_vtestnzc_ps_256:
9143   case Intrinsic::x86_avx_vtestz_pd_256:
9144   case Intrinsic::x86_avx_vtestc_pd_256:
9145   case Intrinsic::x86_avx_vtestnzc_pd_256: {
9146     bool IsTestPacked = false;
9147     unsigned X86CC = 0;
9148     switch (IntNo) {
9149     default: llvm_unreachable("Bad fallthrough in Intrinsic lowering.");
9150     case Intrinsic::x86_avx_vtestz_ps:
9151     case Intrinsic::x86_avx_vtestz_pd:
9152     case Intrinsic::x86_avx_vtestz_ps_256:
9153     case Intrinsic::x86_avx_vtestz_pd_256:
9154       IsTestPacked = true; // Fallthrough
9155     case Intrinsic::x86_sse41_ptestz:
9156     case Intrinsic::x86_avx_ptestz_256:
9157       // ZF = 1
9158       X86CC = X86::COND_E;
9159       break;
9160     case Intrinsic::x86_avx_vtestc_ps:
9161     case Intrinsic::x86_avx_vtestc_pd:
9162     case Intrinsic::x86_avx_vtestc_ps_256:
9163     case Intrinsic::x86_avx_vtestc_pd_256:
9164       IsTestPacked = true; // Fallthrough
9165     case Intrinsic::x86_sse41_ptestc:
9166     case Intrinsic::x86_avx_ptestc_256:
9167       // CF = 1
9168       X86CC = X86::COND_B;
9169       break;
9170     case Intrinsic::x86_avx_vtestnzc_ps:
9171     case Intrinsic::x86_avx_vtestnzc_pd:
9172     case Intrinsic::x86_avx_vtestnzc_ps_256:
9173     case Intrinsic::x86_avx_vtestnzc_pd_256:
9174       IsTestPacked = true; // Fallthrough
9175     case Intrinsic::x86_sse41_ptestnzc:
9176     case Intrinsic::x86_avx_ptestnzc_256:
9177       // ZF and CF = 0
9178       X86CC = X86::COND_A;
9179       break;
9180     }
9181
9182     SDValue LHS = Op.getOperand(1);
9183     SDValue RHS = Op.getOperand(2);
9184     unsigned TestOpc = IsTestPacked ? X86ISD::TESTP : X86ISD::PTEST;
9185     SDValue Test = DAG.getNode(TestOpc, dl, MVT::i32, LHS, RHS);
9186     SDValue CC = DAG.getConstant(X86CC, MVT::i8);
9187     SDValue SetCC = DAG.getNode(X86ISD::SETCC, dl, MVT::i8, CC, Test);
9188     return DAG.getNode(ISD::ZERO_EXTEND, dl, MVT::i32, SetCC);
9189   }
9190
9191   // Fix vector shift instructions where the last operand is a non-immediate
9192   // i32 value.
9193   case Intrinsic::x86_sse2_pslli_w:
9194   case Intrinsic::x86_sse2_pslli_d:
9195   case Intrinsic::x86_sse2_pslli_q:
9196   case Intrinsic::x86_sse2_psrli_w:
9197   case Intrinsic::x86_sse2_psrli_d:
9198   case Intrinsic::x86_sse2_psrli_q:
9199   case Intrinsic::x86_sse2_psrai_w:
9200   case Intrinsic::x86_sse2_psrai_d:
9201   case Intrinsic::x86_mmx_pslli_w:
9202   case Intrinsic::x86_mmx_pslli_d:
9203   case Intrinsic::x86_mmx_pslli_q:
9204   case Intrinsic::x86_mmx_psrli_w:
9205   case Intrinsic::x86_mmx_psrli_d:
9206   case Intrinsic::x86_mmx_psrli_q:
9207   case Intrinsic::x86_mmx_psrai_w:
9208   case Intrinsic::x86_mmx_psrai_d: {
9209     SDValue ShAmt = Op.getOperand(2);
9210     if (isa<ConstantSDNode>(ShAmt))
9211       return SDValue();
9212
9213     unsigned NewIntNo = 0;
9214     EVT ShAmtVT = MVT::v4i32;
9215     switch (IntNo) {
9216     case Intrinsic::x86_sse2_pslli_w:
9217       NewIntNo = Intrinsic::x86_sse2_psll_w;
9218       break;
9219     case Intrinsic::x86_sse2_pslli_d:
9220       NewIntNo = Intrinsic::x86_sse2_psll_d;
9221       break;
9222     case Intrinsic::x86_sse2_pslli_q:
9223       NewIntNo = Intrinsic::x86_sse2_psll_q;
9224       break;
9225     case Intrinsic::x86_sse2_psrli_w:
9226       NewIntNo = Intrinsic::x86_sse2_psrl_w;
9227       break;
9228     case Intrinsic::x86_sse2_psrli_d:
9229       NewIntNo = Intrinsic::x86_sse2_psrl_d;
9230       break;
9231     case Intrinsic::x86_sse2_psrli_q:
9232       NewIntNo = Intrinsic::x86_sse2_psrl_q;
9233       break;
9234     case Intrinsic::x86_sse2_psrai_w:
9235       NewIntNo = Intrinsic::x86_sse2_psra_w;
9236       break;
9237     case Intrinsic::x86_sse2_psrai_d:
9238       NewIntNo = Intrinsic::x86_sse2_psra_d;
9239       break;
9240     default: {
9241       ShAmtVT = MVT::v2i32;
9242       switch (IntNo) {
9243       case Intrinsic::x86_mmx_pslli_w:
9244         NewIntNo = Intrinsic::x86_mmx_psll_w;
9245         break;
9246       case Intrinsic::x86_mmx_pslli_d:
9247         NewIntNo = Intrinsic::x86_mmx_psll_d;
9248         break;
9249       case Intrinsic::x86_mmx_pslli_q:
9250         NewIntNo = Intrinsic::x86_mmx_psll_q;
9251         break;
9252       case Intrinsic::x86_mmx_psrli_w:
9253         NewIntNo = Intrinsic::x86_mmx_psrl_w;
9254         break;
9255       case Intrinsic::x86_mmx_psrli_d:
9256         NewIntNo = Intrinsic::x86_mmx_psrl_d;
9257         break;
9258       case Intrinsic::x86_mmx_psrli_q:
9259         NewIntNo = Intrinsic::x86_mmx_psrl_q;
9260         break;
9261       case Intrinsic::x86_mmx_psrai_w:
9262         NewIntNo = Intrinsic::x86_mmx_psra_w;
9263         break;
9264       case Intrinsic::x86_mmx_psrai_d:
9265         NewIntNo = Intrinsic::x86_mmx_psra_d;
9266         break;
9267       default: llvm_unreachable("Impossible intrinsic");  // Can't reach here.
9268       }
9269       break;
9270     }
9271     }
9272
9273     // The vector shift intrinsics with scalars uses 32b shift amounts but
9274     // the sse2/mmx shift instructions reads 64 bits. Set the upper 32 bits
9275     // to be zero.
9276     SDValue ShOps[4];
9277     ShOps[0] = ShAmt;
9278     ShOps[1] = DAG.getConstant(0, MVT::i32);
9279     if (ShAmtVT == MVT::v4i32) {
9280       ShOps[2] = DAG.getUNDEF(MVT::i32);
9281       ShOps[3] = DAG.getUNDEF(MVT::i32);
9282       ShAmt =  DAG.getNode(ISD::BUILD_VECTOR, dl, ShAmtVT, &ShOps[0], 4);
9283     } else {
9284       ShAmt =  DAG.getNode(ISD::BUILD_VECTOR, dl, ShAmtVT, &ShOps[0], 2);
9285 // FIXME this must be lowered to get rid of the invalid type.
9286     }
9287
9288     EVT VT = Op.getValueType();
9289     ShAmt = DAG.getNode(ISD::BITCAST, dl, VT, ShAmt);
9290     return DAG.getNode(ISD::INTRINSIC_WO_CHAIN, dl, VT,
9291                        DAG.getConstant(NewIntNo, MVT::i32),
9292                        Op.getOperand(1), ShAmt);
9293   }
9294   }
9295 }
9296
9297 SDValue X86TargetLowering::LowerRETURNADDR(SDValue Op,
9298                                            SelectionDAG &DAG) const {
9299   MachineFrameInfo *MFI = DAG.getMachineFunction().getFrameInfo();
9300   MFI->setReturnAddressIsTaken(true);
9301
9302   unsigned Depth = cast<ConstantSDNode>(Op.getOperand(0))->getZExtValue();
9303   DebugLoc dl = Op.getDebugLoc();
9304
9305   if (Depth > 0) {
9306     SDValue FrameAddr = LowerFRAMEADDR(Op, DAG);
9307     SDValue Offset =
9308       DAG.getConstant(TD->getPointerSize(),
9309                       Subtarget->is64Bit() ? MVT::i64 : MVT::i32);
9310     return DAG.getLoad(getPointerTy(), dl, DAG.getEntryNode(),
9311                        DAG.getNode(ISD::ADD, dl, getPointerTy(),
9312                                    FrameAddr, Offset),
9313                        MachinePointerInfo(), false, false, 0);
9314   }
9315
9316   // Just load the return address.
9317   SDValue RetAddrFI = getReturnAddressFrameIndex(DAG);
9318   return DAG.getLoad(getPointerTy(), dl, DAG.getEntryNode(),
9319                      RetAddrFI, MachinePointerInfo(), false, false, 0);
9320 }
9321
9322 SDValue X86TargetLowering::LowerFRAMEADDR(SDValue Op, SelectionDAG &DAG) const {
9323   MachineFrameInfo *MFI = DAG.getMachineFunction().getFrameInfo();
9324   MFI->setFrameAddressIsTaken(true);
9325
9326   EVT VT = Op.getValueType();
9327   DebugLoc dl = Op.getDebugLoc();  // FIXME probably not meaningful
9328   unsigned Depth = cast<ConstantSDNode>(Op.getOperand(0))->getZExtValue();
9329   unsigned FrameReg = Subtarget->is64Bit() ? X86::RBP : X86::EBP;
9330   SDValue FrameAddr = DAG.getCopyFromReg(DAG.getEntryNode(), dl, FrameReg, VT);
9331   while (Depth--)
9332     FrameAddr = DAG.getLoad(VT, dl, DAG.getEntryNode(), FrameAddr,
9333                             MachinePointerInfo(),
9334                             false, false, 0);
9335   return FrameAddr;
9336 }
9337
9338 SDValue X86TargetLowering::LowerFRAME_TO_ARGS_OFFSET(SDValue Op,
9339                                                      SelectionDAG &DAG) const {
9340   return DAG.getIntPtrConstant(2*TD->getPointerSize());
9341 }
9342
9343 SDValue X86TargetLowering::LowerEH_RETURN(SDValue Op, SelectionDAG &DAG) const {
9344   MachineFunction &MF = DAG.getMachineFunction();
9345   SDValue Chain     = Op.getOperand(0);
9346   SDValue Offset    = Op.getOperand(1);
9347   SDValue Handler   = Op.getOperand(2);
9348   DebugLoc dl       = Op.getDebugLoc();
9349
9350   SDValue Frame = DAG.getCopyFromReg(DAG.getEntryNode(), dl,
9351                                      Subtarget->is64Bit() ? X86::RBP : X86::EBP,
9352                                      getPointerTy());
9353   unsigned StoreAddrReg = (Subtarget->is64Bit() ? X86::RCX : X86::ECX);
9354
9355   SDValue StoreAddr = DAG.getNode(ISD::ADD, dl, getPointerTy(), Frame,
9356                                   DAG.getIntPtrConstant(TD->getPointerSize()));
9357   StoreAddr = DAG.getNode(ISD::ADD, dl, getPointerTy(), StoreAddr, Offset);
9358   Chain = DAG.getStore(Chain, dl, Handler, StoreAddr, MachinePointerInfo(),
9359                        false, false, 0);
9360   Chain = DAG.getCopyToReg(Chain, dl, StoreAddrReg, StoreAddr);
9361   MF.getRegInfo().addLiveOut(StoreAddrReg);
9362
9363   return DAG.getNode(X86ISD::EH_RETURN, dl,
9364                      MVT::Other,
9365                      Chain, DAG.getRegister(StoreAddrReg, getPointerTy()));
9366 }
9367
9368 SDValue X86TargetLowering::LowerTRAMPOLINE(SDValue Op,
9369                                              SelectionDAG &DAG) const {
9370   SDValue Root = Op.getOperand(0);
9371   SDValue Trmp = Op.getOperand(1); // trampoline
9372   SDValue FPtr = Op.getOperand(2); // nested function
9373   SDValue Nest = Op.getOperand(3); // 'nest' parameter value
9374   DebugLoc dl  = Op.getDebugLoc();
9375
9376   const Value *TrmpAddr = cast<SrcValueSDNode>(Op.getOperand(4))->getValue();
9377
9378   if (Subtarget->is64Bit()) {
9379     SDValue OutChains[6];
9380
9381     // Large code-model.
9382     const unsigned char JMP64r  = 0xFF; // 64-bit jmp through register opcode.
9383     const unsigned char MOV64ri = 0xB8; // X86::MOV64ri opcode.
9384
9385     const unsigned char N86R10 = X86_MC::getX86RegNum(X86::R10);
9386     const unsigned char N86R11 = X86_MC::getX86RegNum(X86::R11);
9387
9388     const unsigned char REX_WB = 0x40 | 0x08 | 0x01; // REX prefix
9389
9390     // Load the pointer to the nested function into R11.
9391     unsigned OpCode = ((MOV64ri | N86R11) << 8) | REX_WB; // movabsq r11
9392     SDValue Addr = Trmp;
9393     OutChains[0] = DAG.getStore(Root, dl, DAG.getConstant(OpCode, MVT::i16),
9394                                 Addr, MachinePointerInfo(TrmpAddr),
9395                                 false, false, 0);
9396
9397     Addr = DAG.getNode(ISD::ADD, dl, MVT::i64, Trmp,
9398                        DAG.getConstant(2, MVT::i64));
9399     OutChains[1] = DAG.getStore(Root, dl, FPtr, Addr,
9400                                 MachinePointerInfo(TrmpAddr, 2),
9401                                 false, false, 2);
9402
9403     // Load the 'nest' parameter value into R10.
9404     // R10 is specified in X86CallingConv.td
9405     OpCode = ((MOV64ri | N86R10) << 8) | REX_WB; // movabsq r10
9406     Addr = DAG.getNode(ISD::ADD, dl, MVT::i64, Trmp,
9407                        DAG.getConstant(10, MVT::i64));
9408     OutChains[2] = DAG.getStore(Root, dl, DAG.getConstant(OpCode, MVT::i16),
9409                                 Addr, MachinePointerInfo(TrmpAddr, 10),
9410                                 false, false, 0);
9411
9412     Addr = DAG.getNode(ISD::ADD, dl, MVT::i64, Trmp,
9413                        DAG.getConstant(12, MVT::i64));
9414     OutChains[3] = DAG.getStore(Root, dl, Nest, Addr,
9415                                 MachinePointerInfo(TrmpAddr, 12),
9416                                 false, false, 2);
9417
9418     // Jump to the nested function.
9419     OpCode = (JMP64r << 8) | REX_WB; // jmpq *...
9420     Addr = DAG.getNode(ISD::ADD, dl, MVT::i64, Trmp,
9421                        DAG.getConstant(20, MVT::i64));
9422     OutChains[4] = DAG.getStore(Root, dl, DAG.getConstant(OpCode, MVT::i16),
9423                                 Addr, MachinePointerInfo(TrmpAddr, 20),
9424                                 false, false, 0);
9425
9426     unsigned char ModRM = N86R11 | (4 << 3) | (3 << 6); // ...r11
9427     Addr = DAG.getNode(ISD::ADD, dl, MVT::i64, Trmp,
9428                        DAG.getConstant(22, MVT::i64));
9429     OutChains[5] = DAG.getStore(Root, dl, DAG.getConstant(ModRM, MVT::i8), Addr,
9430                                 MachinePointerInfo(TrmpAddr, 22),
9431                                 false, false, 0);
9432
9433     SDValue Ops[] =
9434       { Trmp, DAG.getNode(ISD::TokenFactor, dl, MVT::Other, OutChains, 6) };
9435     return DAG.getMergeValues(Ops, 2, dl);
9436   } else {
9437     const Function *Func =
9438       cast<Function>(cast<SrcValueSDNode>(Op.getOperand(5))->getValue());
9439     CallingConv::ID CC = Func->getCallingConv();
9440     unsigned NestReg;
9441
9442     switch (CC) {
9443     default:
9444       llvm_unreachable("Unsupported calling convention");
9445     case CallingConv::C:
9446     case CallingConv::X86_StdCall: {
9447       // Pass 'nest' parameter in ECX.
9448       // Must be kept in sync with X86CallingConv.td
9449       NestReg = X86::ECX;
9450
9451       // Check that ECX wasn't needed by an 'inreg' parameter.
9452       FunctionType *FTy = Func->getFunctionType();
9453       const AttrListPtr &Attrs = Func->getAttributes();
9454
9455       if (!Attrs.isEmpty() && !Func->isVarArg()) {
9456         unsigned InRegCount = 0;
9457         unsigned Idx = 1;
9458
9459         for (FunctionType::param_iterator I = FTy->param_begin(),
9460              E = FTy->param_end(); I != E; ++I, ++Idx)
9461           if (Attrs.paramHasAttr(Idx, Attribute::InReg))
9462             // FIXME: should only count parameters that are lowered to integers.
9463             InRegCount += (TD->getTypeSizeInBits(*I) + 31) / 32;
9464
9465         if (InRegCount > 2) {
9466           report_fatal_error("Nest register in use - reduce number of inreg"
9467                              " parameters!");
9468         }
9469       }
9470       break;
9471     }
9472     case CallingConv::X86_FastCall:
9473     case CallingConv::X86_ThisCall:
9474     case CallingConv::Fast:
9475       // Pass 'nest' parameter in EAX.
9476       // Must be kept in sync with X86CallingConv.td
9477       NestReg = X86::EAX;
9478       break;
9479     }
9480
9481     SDValue OutChains[4];
9482     SDValue Addr, Disp;
9483
9484     Addr = DAG.getNode(ISD::ADD, dl, MVT::i32, Trmp,
9485                        DAG.getConstant(10, MVT::i32));
9486     Disp = DAG.getNode(ISD::SUB, dl, MVT::i32, FPtr, Addr);
9487
9488     // This is storing the opcode for MOV32ri.
9489     const unsigned char MOV32ri = 0xB8; // X86::MOV32ri's opcode byte.
9490     const unsigned char N86Reg = X86_MC::getX86RegNum(NestReg);
9491     OutChains[0] = DAG.getStore(Root, dl,
9492                                 DAG.getConstant(MOV32ri|N86Reg, MVT::i8),
9493                                 Trmp, MachinePointerInfo(TrmpAddr),
9494                                 false, false, 0);
9495
9496     Addr = DAG.getNode(ISD::ADD, dl, MVT::i32, Trmp,
9497                        DAG.getConstant(1, MVT::i32));
9498     OutChains[1] = DAG.getStore(Root, dl, Nest, Addr,
9499                                 MachinePointerInfo(TrmpAddr, 1),
9500                                 false, false, 1);
9501
9502     const unsigned char JMP = 0xE9; // jmp <32bit dst> opcode.
9503     Addr = DAG.getNode(ISD::ADD, dl, MVT::i32, Trmp,
9504                        DAG.getConstant(5, MVT::i32));
9505     OutChains[2] = DAG.getStore(Root, dl, DAG.getConstant(JMP, MVT::i8), Addr,
9506                                 MachinePointerInfo(TrmpAddr, 5),
9507                                 false, false, 1);
9508
9509     Addr = DAG.getNode(ISD::ADD, dl, MVT::i32, Trmp,
9510                        DAG.getConstant(6, MVT::i32));
9511     OutChains[3] = DAG.getStore(Root, dl, Disp, Addr,
9512                                 MachinePointerInfo(TrmpAddr, 6),
9513                                 false, false, 1);
9514
9515     SDValue Ops[] =
9516       { Trmp, DAG.getNode(ISD::TokenFactor, dl, MVT::Other, OutChains, 4) };
9517     return DAG.getMergeValues(Ops, 2, dl);
9518   }
9519 }
9520
9521 SDValue X86TargetLowering::LowerFLT_ROUNDS_(SDValue Op,
9522                                             SelectionDAG &DAG) const {
9523   /*
9524    The rounding mode is in bits 11:10 of FPSR, and has the following
9525    settings:
9526      00 Round to nearest
9527      01 Round to -inf
9528      10 Round to +inf
9529      11 Round to 0
9530
9531   FLT_ROUNDS, on the other hand, expects the following:
9532     -1 Undefined
9533      0 Round to 0
9534      1 Round to nearest
9535      2 Round to +inf
9536      3 Round to -inf
9537
9538   To perform the conversion, we do:
9539     (((((FPSR & 0x800) >> 11) | ((FPSR & 0x400) >> 9)) + 1) & 3)
9540   */
9541
9542   MachineFunction &MF = DAG.getMachineFunction();
9543   const TargetMachine &TM = MF.getTarget();
9544   const TargetFrameLowering &TFI = *TM.getFrameLowering();
9545   unsigned StackAlignment = TFI.getStackAlignment();
9546   EVT VT = Op.getValueType();
9547   DebugLoc DL = Op.getDebugLoc();
9548
9549   // Save FP Control Word to stack slot
9550   int SSFI = MF.getFrameInfo()->CreateStackObject(2, StackAlignment, false);
9551   SDValue StackSlot = DAG.getFrameIndex(SSFI, getPointerTy());
9552
9553
9554   MachineMemOperand *MMO =
9555    MF.getMachineMemOperand(MachinePointerInfo::getFixedStack(SSFI),
9556                            MachineMemOperand::MOStore, 2, 2);
9557
9558   SDValue Ops[] = { DAG.getEntryNode(), StackSlot };
9559   SDValue Chain = DAG.getMemIntrinsicNode(X86ISD::FNSTCW16m, DL,
9560                                           DAG.getVTList(MVT::Other),
9561                                           Ops, 2, MVT::i16, MMO);
9562
9563   // Load FP Control Word from stack slot
9564   SDValue CWD = DAG.getLoad(MVT::i16, DL, Chain, StackSlot,
9565                             MachinePointerInfo(), false, false, 0);
9566
9567   // Transform as necessary
9568   SDValue CWD1 =
9569     DAG.getNode(ISD::SRL, DL, MVT::i16,
9570                 DAG.getNode(ISD::AND, DL, MVT::i16,
9571                             CWD, DAG.getConstant(0x800, MVT::i16)),
9572                 DAG.getConstant(11, MVT::i8));
9573   SDValue CWD2 =
9574     DAG.getNode(ISD::SRL, DL, MVT::i16,
9575                 DAG.getNode(ISD::AND, DL, MVT::i16,
9576                             CWD, DAG.getConstant(0x400, MVT::i16)),
9577                 DAG.getConstant(9, MVT::i8));
9578
9579   SDValue RetVal =
9580     DAG.getNode(ISD::AND, DL, MVT::i16,
9581                 DAG.getNode(ISD::ADD, DL, MVT::i16,
9582                             DAG.getNode(ISD::OR, DL, MVT::i16, CWD1, CWD2),
9583                             DAG.getConstant(1, MVT::i16)),
9584                 DAG.getConstant(3, MVT::i16));
9585
9586
9587   return DAG.getNode((VT.getSizeInBits() < 16 ?
9588                       ISD::TRUNCATE : ISD::ZERO_EXTEND), DL, VT, RetVal);
9589 }
9590
9591 SDValue X86TargetLowering::LowerCTLZ(SDValue Op, SelectionDAG &DAG) const {
9592   EVT VT = Op.getValueType();
9593   EVT OpVT = VT;
9594   unsigned NumBits = VT.getSizeInBits();
9595   DebugLoc dl = Op.getDebugLoc();
9596
9597   Op = Op.getOperand(0);
9598   if (VT == MVT::i8) {
9599     // Zero extend to i32 since there is not an i8 bsr.
9600     OpVT = MVT::i32;
9601     Op = DAG.getNode(ISD::ZERO_EXTEND, dl, OpVT, Op);
9602   }
9603
9604   // Issue a bsr (scan bits in reverse) which also sets EFLAGS.
9605   SDVTList VTs = DAG.getVTList(OpVT, MVT::i32);
9606   Op = DAG.getNode(X86ISD::BSR, dl, VTs, Op);
9607
9608   // If src is zero (i.e. bsr sets ZF), returns NumBits.
9609   SDValue Ops[] = {
9610     Op,
9611     DAG.getConstant(NumBits+NumBits-1, OpVT),
9612     DAG.getConstant(X86::COND_E, MVT::i8),
9613     Op.getValue(1)
9614   };
9615   Op = DAG.getNode(X86ISD::CMOV, dl, OpVT, Ops, array_lengthof(Ops));
9616
9617   // Finally xor with NumBits-1.
9618   Op = DAG.getNode(ISD::XOR, dl, OpVT, Op, DAG.getConstant(NumBits-1, OpVT));
9619
9620   if (VT == MVT::i8)
9621     Op = DAG.getNode(ISD::TRUNCATE, dl, MVT::i8, Op);
9622   return Op;
9623 }
9624
9625 SDValue X86TargetLowering::LowerCTTZ(SDValue Op, SelectionDAG &DAG) const {
9626   EVT VT = Op.getValueType();
9627   EVT OpVT = VT;
9628   unsigned NumBits = VT.getSizeInBits();
9629   DebugLoc dl = Op.getDebugLoc();
9630
9631   Op = Op.getOperand(0);
9632   if (VT == MVT::i8) {
9633     OpVT = MVT::i32;
9634     Op = DAG.getNode(ISD::ZERO_EXTEND, dl, OpVT, Op);
9635   }
9636
9637   // Issue a bsf (scan bits forward) which also sets EFLAGS.
9638   SDVTList VTs = DAG.getVTList(OpVT, MVT::i32);
9639   Op = DAG.getNode(X86ISD::BSF, dl, VTs, Op);
9640
9641   // If src is zero (i.e. bsf sets ZF), returns NumBits.
9642   SDValue Ops[] = {
9643     Op,
9644     DAG.getConstant(NumBits, OpVT),
9645     DAG.getConstant(X86::COND_E, MVT::i8),
9646     Op.getValue(1)
9647   };
9648   Op = DAG.getNode(X86ISD::CMOV, dl, OpVT, Ops, array_lengthof(Ops));
9649
9650   if (VT == MVT::i8)
9651     Op = DAG.getNode(ISD::TRUNCATE, dl, MVT::i8, Op);
9652   return Op;
9653 }
9654
9655 // Lower256IntArith - Break a 256-bit integer operation into two new 128-bit
9656 // ones, and then concatenate the result back.
9657 static SDValue Lower256IntArith(SDValue Op, SelectionDAG &DAG) {
9658   EVT VT = Op.getValueType();
9659
9660   assert(VT.getSizeInBits() == 256 && VT.isInteger() &&
9661          "Unsupported value type for operation");
9662
9663   int NumElems = VT.getVectorNumElements();
9664   DebugLoc dl = Op.getDebugLoc();
9665   SDValue Idx0 = DAG.getConstant(0, MVT::i32);
9666   SDValue Idx1 = DAG.getConstant(NumElems/2, MVT::i32);
9667
9668   // Extract the LHS vectors
9669   SDValue LHS = Op.getOperand(0);
9670   SDValue LHS1 = Extract128BitVector(LHS, Idx0, DAG, dl);
9671   SDValue LHS2 = Extract128BitVector(LHS, Idx1, DAG, dl);
9672
9673   // Extract the RHS vectors
9674   SDValue RHS = Op.getOperand(1);
9675   SDValue RHS1 = Extract128BitVector(RHS, Idx0, DAG, dl);
9676   SDValue RHS2 = Extract128BitVector(RHS, Idx1, DAG, dl);
9677
9678   MVT EltVT = VT.getVectorElementType().getSimpleVT();
9679   EVT NewVT = MVT::getVectorVT(EltVT, NumElems/2);
9680
9681   return DAG.getNode(ISD::CONCAT_VECTORS, dl, VT,
9682                      DAG.getNode(Op.getOpcode(), dl, NewVT, LHS1, RHS1),
9683                      DAG.getNode(Op.getOpcode(), dl, NewVT, LHS2, RHS2));
9684 }
9685
9686 SDValue X86TargetLowering::LowerADD(SDValue Op, SelectionDAG &DAG) const {
9687   assert(Op.getValueType().getSizeInBits() == 256 &&
9688          Op.getValueType().isInteger() &&
9689          "Only handle AVX 256-bit vector integer operation");
9690   return Lower256IntArith(Op, DAG);
9691 }
9692
9693 SDValue X86TargetLowering::LowerSUB(SDValue Op, SelectionDAG &DAG) const {
9694   assert(Op.getValueType().getSizeInBits() == 256 &&
9695          Op.getValueType().isInteger() &&
9696          "Only handle AVX 256-bit vector integer operation");
9697   return Lower256IntArith(Op, DAG);
9698 }
9699
9700 SDValue X86TargetLowering::LowerMUL(SDValue Op, SelectionDAG &DAG) const {
9701   EVT VT = Op.getValueType();
9702
9703   // Decompose 256-bit ops into smaller 128-bit ops.
9704   if (VT.getSizeInBits() == 256)
9705     return Lower256IntArith(Op, DAG);
9706
9707   assert(VT == MVT::v2i64 && "Only know how to lower V2I64 multiply");
9708   DebugLoc dl = Op.getDebugLoc();
9709
9710   //  ulong2 Ahi = __builtin_ia32_psrlqi128( a, 32);
9711   //  ulong2 Bhi = __builtin_ia32_psrlqi128( b, 32);
9712   //  ulong2 AloBlo = __builtin_ia32_pmuludq128( a, b );
9713   //  ulong2 AloBhi = __builtin_ia32_pmuludq128( a, Bhi );
9714   //  ulong2 AhiBlo = __builtin_ia32_pmuludq128( Ahi, b );
9715   //
9716   //  AloBhi = __builtin_ia32_psllqi128( AloBhi, 32 );
9717   //  AhiBlo = __builtin_ia32_psllqi128( AhiBlo, 32 );
9718   //  return AloBlo + AloBhi + AhiBlo;
9719
9720   SDValue A = Op.getOperand(0);
9721   SDValue B = Op.getOperand(1);
9722
9723   SDValue Ahi = DAG.getNode(ISD::INTRINSIC_WO_CHAIN, dl, VT,
9724                        DAG.getConstant(Intrinsic::x86_sse2_psrli_q, MVT::i32),
9725                        A, DAG.getConstant(32, MVT::i32));
9726   SDValue Bhi = DAG.getNode(ISD::INTRINSIC_WO_CHAIN, dl, VT,
9727                        DAG.getConstant(Intrinsic::x86_sse2_psrli_q, MVT::i32),
9728                        B, DAG.getConstant(32, MVT::i32));
9729   SDValue AloBlo = DAG.getNode(ISD::INTRINSIC_WO_CHAIN, dl, VT,
9730                        DAG.getConstant(Intrinsic::x86_sse2_pmulu_dq, MVT::i32),
9731                        A, B);
9732   SDValue AloBhi = DAG.getNode(ISD::INTRINSIC_WO_CHAIN, dl, VT,
9733                        DAG.getConstant(Intrinsic::x86_sse2_pmulu_dq, MVT::i32),
9734                        A, Bhi);
9735   SDValue AhiBlo = DAG.getNode(ISD::INTRINSIC_WO_CHAIN, dl, VT,
9736                        DAG.getConstant(Intrinsic::x86_sse2_pmulu_dq, MVT::i32),
9737                        Ahi, B);
9738   AloBhi = DAG.getNode(ISD::INTRINSIC_WO_CHAIN, dl, VT,
9739                        DAG.getConstant(Intrinsic::x86_sse2_pslli_q, MVT::i32),
9740                        AloBhi, DAG.getConstant(32, MVT::i32));
9741   AhiBlo = DAG.getNode(ISD::INTRINSIC_WO_CHAIN, dl, VT,
9742                        DAG.getConstant(Intrinsic::x86_sse2_pslli_q, MVT::i32),
9743                        AhiBlo, DAG.getConstant(32, MVT::i32));
9744   SDValue Res = DAG.getNode(ISD::ADD, dl, VT, AloBlo, AloBhi);
9745   Res = DAG.getNode(ISD::ADD, dl, VT, Res, AhiBlo);
9746   return Res;
9747 }
9748
9749 SDValue X86TargetLowering::LowerShift(SDValue Op, SelectionDAG &DAG) const {
9750
9751   EVT VT = Op.getValueType();
9752   DebugLoc dl = Op.getDebugLoc();
9753   SDValue R = Op.getOperand(0);
9754   SDValue Amt = Op.getOperand(1);
9755   LLVMContext *Context = DAG.getContext();
9756
9757   if (!(Subtarget->hasSSE2() || Subtarget->hasAVX()))
9758     return SDValue();
9759
9760   // Decompose 256-bit shifts into smaller 128-bit shifts.
9761   if (VT.getSizeInBits() == 256) {
9762     int NumElems = VT.getVectorNumElements();
9763     MVT EltVT = VT.getVectorElementType().getSimpleVT();
9764     EVT NewVT = MVT::getVectorVT(EltVT, NumElems/2);
9765
9766     // Extract the two vectors
9767     SDValue V1 = Extract128BitVector(R, DAG.getConstant(0, MVT::i32), DAG, dl);
9768     SDValue V2 = Extract128BitVector(R, DAG.getConstant(NumElems/2, MVT::i32),
9769                                      DAG, dl);
9770
9771     // Recreate the shift amount vectors
9772     SDValue Amt1, Amt2;
9773     if (Amt.getOpcode() == ISD::BUILD_VECTOR) {
9774       // Constant shift amount
9775       SmallVector<SDValue, 4> Amt1Csts;
9776       SmallVector<SDValue, 4> Amt2Csts;
9777       for (int i = 0; i < NumElems/2; ++i)
9778         Amt1Csts.push_back(Amt->getOperand(i));
9779       for (int i = NumElems/2; i < NumElems; ++i)
9780         Amt2Csts.push_back(Amt->getOperand(i));
9781
9782       Amt1 = DAG.getNode(ISD::BUILD_VECTOR, dl, NewVT,
9783                                  &Amt1Csts[0], NumElems/2);
9784       Amt2 = DAG.getNode(ISD::BUILD_VECTOR, dl, NewVT,
9785                                  &Amt2Csts[0], NumElems/2);
9786     } else {
9787       // Variable shift amount
9788       Amt1 = Extract128BitVector(Amt, DAG.getConstant(0, MVT::i32), DAG, dl);
9789       Amt2 = Extract128BitVector(Amt, DAG.getConstant(NumElems/2, MVT::i32),
9790                                  DAG, dl);
9791     }
9792
9793     // Issue new vector shifts for the smaller types
9794     V1 = DAG.getNode(Op.getOpcode(), dl, NewVT, V1, Amt1);
9795     V2 = DAG.getNode(Op.getOpcode(), dl, NewVT, V2, Amt2);
9796
9797     // Concatenate the result back
9798     return DAG.getNode(ISD::CONCAT_VECTORS, dl, VT, V1, V2);
9799   }
9800
9801   // Optimize shl/srl/sra with constant shift amount.
9802   if (isSplatVector(Amt.getNode())) {
9803     SDValue SclrAmt = Amt->getOperand(0);
9804     if (ConstantSDNode *C = dyn_cast<ConstantSDNode>(SclrAmt)) {
9805       uint64_t ShiftAmt = C->getZExtValue();
9806
9807       if (VT == MVT::v2i64 && Op.getOpcode() == ISD::SHL)
9808        return DAG.getNode(ISD::INTRINSIC_WO_CHAIN, dl, VT,
9809                      DAG.getConstant(Intrinsic::x86_sse2_pslli_q, MVT::i32),
9810                      R, DAG.getConstant(ShiftAmt, MVT::i32));
9811
9812       if (VT == MVT::v4i32 && Op.getOpcode() == ISD::SHL)
9813        return DAG.getNode(ISD::INTRINSIC_WO_CHAIN, dl, VT,
9814                      DAG.getConstant(Intrinsic::x86_sse2_pslli_d, MVT::i32),
9815                      R, DAG.getConstant(ShiftAmt, MVT::i32));
9816
9817       if (VT == MVT::v8i16 && Op.getOpcode() == ISD::SHL)
9818        return DAG.getNode(ISD::INTRINSIC_WO_CHAIN, dl, VT,
9819                      DAG.getConstant(Intrinsic::x86_sse2_pslli_w, MVT::i32),
9820                      R, DAG.getConstant(ShiftAmt, MVT::i32));
9821
9822       if (VT == MVT::v2i64 && Op.getOpcode() == ISD::SRL)
9823        return DAG.getNode(ISD::INTRINSIC_WO_CHAIN, dl, VT,
9824                      DAG.getConstant(Intrinsic::x86_sse2_psrli_q, MVT::i32),
9825                      R, DAG.getConstant(ShiftAmt, MVT::i32));
9826
9827       if (VT == MVT::v4i32 && Op.getOpcode() == ISD::SRL)
9828        return DAG.getNode(ISD::INTRINSIC_WO_CHAIN, dl, VT,
9829                      DAG.getConstant(Intrinsic::x86_sse2_psrli_d, MVT::i32),
9830                      R, DAG.getConstant(ShiftAmt, MVT::i32));
9831
9832       if (VT == MVT::v8i16 && Op.getOpcode() == ISD::SRL)
9833        return DAG.getNode(ISD::INTRINSIC_WO_CHAIN, dl, VT,
9834                      DAG.getConstant(Intrinsic::x86_sse2_psrli_w, MVT::i32),
9835                      R, DAG.getConstant(ShiftAmt, MVT::i32));
9836
9837       if (VT == MVT::v4i32 && Op.getOpcode() == ISD::SRA)
9838        return DAG.getNode(ISD::INTRINSIC_WO_CHAIN, dl, VT,
9839                      DAG.getConstant(Intrinsic::x86_sse2_psrai_d, MVT::i32),
9840                      R, DAG.getConstant(ShiftAmt, MVT::i32));
9841
9842       if (VT == MVT::v8i16 && Op.getOpcode() == ISD::SRA)
9843        return DAG.getNode(ISD::INTRINSIC_WO_CHAIN, dl, VT,
9844                      DAG.getConstant(Intrinsic::x86_sse2_psrai_w, MVT::i32),
9845                      R, DAG.getConstant(ShiftAmt, MVT::i32));
9846     }
9847   }
9848
9849   // Lower SHL with variable shift amount.
9850   if (VT == MVT::v4i32 && Op->getOpcode() == ISD::SHL) {
9851     Op = DAG.getNode(ISD::INTRINSIC_WO_CHAIN, dl, VT,
9852                      DAG.getConstant(Intrinsic::x86_sse2_pslli_d, MVT::i32),
9853                      Op.getOperand(1), DAG.getConstant(23, MVT::i32));
9854
9855     ConstantInt *CI = ConstantInt::get(*Context, APInt(32, 0x3f800000U));
9856
9857     std::vector<Constant*> CV(4, CI);
9858     Constant *C = ConstantVector::get(CV);
9859     SDValue CPIdx = DAG.getConstantPool(C, getPointerTy(), 16);
9860     SDValue Addend = DAG.getLoad(VT, dl, DAG.getEntryNode(), CPIdx,
9861                                  MachinePointerInfo::getConstantPool(),
9862                                  false, false, 16);
9863
9864     Op = DAG.getNode(ISD::ADD, dl, VT, Op, Addend);
9865     Op = DAG.getNode(ISD::BITCAST, dl, MVT::v4f32, Op);
9866     Op = DAG.getNode(ISD::FP_TO_SINT, dl, VT, Op);
9867     return DAG.getNode(ISD::MUL, dl, VT, Op, R);
9868   }
9869   if (VT == MVT::v16i8 && Op->getOpcode() == ISD::SHL) {
9870     // a = a << 5;
9871     Op = DAG.getNode(ISD::INTRINSIC_WO_CHAIN, dl, VT,
9872                      DAG.getConstant(Intrinsic::x86_sse2_pslli_w, MVT::i32),
9873                      Op.getOperand(1), DAG.getConstant(5, MVT::i32));
9874
9875     ConstantInt *CM1 = ConstantInt::get(*Context, APInt(8, 15));
9876     ConstantInt *CM2 = ConstantInt::get(*Context, APInt(8, 63));
9877
9878     std::vector<Constant*> CVM1(16, CM1);
9879     std::vector<Constant*> CVM2(16, CM2);
9880     Constant *C = ConstantVector::get(CVM1);
9881     SDValue CPIdx = DAG.getConstantPool(C, getPointerTy(), 16);
9882     SDValue M = DAG.getLoad(VT, dl, DAG.getEntryNode(), CPIdx,
9883                             MachinePointerInfo::getConstantPool(),
9884                             false, false, 16);
9885
9886     // r = pblendv(r, psllw(r & (char16)15, 4), a);
9887     M = DAG.getNode(ISD::AND, dl, VT, R, M);
9888     M = DAG.getNode(ISD::INTRINSIC_WO_CHAIN, dl, VT,
9889                     DAG.getConstant(Intrinsic::x86_sse2_pslli_w, MVT::i32), M,
9890                     DAG.getConstant(4, MVT::i32));
9891     R = DAG.getNode(X86ISD::PBLENDVB, dl, VT, R, M, Op);
9892     // a += a
9893     Op = DAG.getNode(ISD::ADD, dl, VT, Op, Op);
9894
9895     C = ConstantVector::get(CVM2);
9896     CPIdx = DAG.getConstantPool(C, getPointerTy(), 16);
9897     M = DAG.getLoad(VT, dl, DAG.getEntryNode(), CPIdx,
9898                     MachinePointerInfo::getConstantPool(),
9899                     false, false, 16);
9900
9901     // r = pblendv(r, psllw(r & (char16)63, 2), a);
9902     M = DAG.getNode(ISD::AND, dl, VT, R, M);
9903     M = DAG.getNode(ISD::INTRINSIC_WO_CHAIN, dl, VT,
9904                     DAG.getConstant(Intrinsic::x86_sse2_pslli_w, MVT::i32), M,
9905                     DAG.getConstant(2, MVT::i32));
9906     R = DAG.getNode(X86ISD::PBLENDVB, dl, VT, R, M, Op);
9907     // a += a
9908     Op = DAG.getNode(ISD::ADD, dl, VT, Op, Op);
9909
9910     // return pblendv(r, r+r, a);
9911     R = DAG.getNode(X86ISD::PBLENDVB, dl, VT,
9912                     R, DAG.getNode(ISD::ADD, dl, VT, R, R), Op);
9913     return R;
9914   }
9915   return SDValue();
9916 }
9917
9918 SDValue X86TargetLowering::LowerXALUO(SDValue Op, SelectionDAG &DAG) const {
9919   // Lower the "add/sub/mul with overflow" instruction into a regular ins plus
9920   // a "setcc" instruction that checks the overflow flag. The "brcond" lowering
9921   // looks for this combo and may remove the "setcc" instruction if the "setcc"
9922   // has only one use.
9923   SDNode *N = Op.getNode();
9924   SDValue LHS = N->getOperand(0);
9925   SDValue RHS = N->getOperand(1);
9926   unsigned BaseOp = 0;
9927   unsigned Cond = 0;
9928   DebugLoc DL = Op.getDebugLoc();
9929   switch (Op.getOpcode()) {
9930   default: llvm_unreachable("Unknown ovf instruction!");
9931   case ISD::SADDO:
9932     // A subtract of one will be selected as a INC. Note that INC doesn't
9933     // set CF, so we can't do this for UADDO.
9934     if (ConstantSDNode *C = dyn_cast<ConstantSDNode>(RHS))
9935       if (C->isOne()) {
9936         BaseOp = X86ISD::INC;
9937         Cond = X86::COND_O;
9938         break;
9939       }
9940     BaseOp = X86ISD::ADD;
9941     Cond = X86::COND_O;
9942     break;
9943   case ISD::UADDO:
9944     BaseOp = X86ISD::ADD;
9945     Cond = X86::COND_B;
9946     break;
9947   case ISD::SSUBO:
9948     // A subtract of one will be selected as a DEC. Note that DEC doesn't
9949     // set CF, so we can't do this for USUBO.
9950     if (ConstantSDNode *C = dyn_cast<ConstantSDNode>(RHS))
9951       if (C->isOne()) {
9952         BaseOp = X86ISD::DEC;
9953         Cond = X86::COND_O;
9954         break;
9955       }
9956     BaseOp = X86ISD::SUB;
9957     Cond = X86::COND_O;
9958     break;
9959   case ISD::USUBO:
9960     BaseOp = X86ISD::SUB;
9961     Cond = X86::COND_B;
9962     break;
9963   case ISD::SMULO:
9964     BaseOp = X86ISD::SMUL;
9965     Cond = X86::COND_O;
9966     break;
9967   case ISD::UMULO: { // i64, i8 = umulo lhs, rhs --> i64, i64, i32 umul lhs,rhs
9968     SDVTList VTs = DAG.getVTList(N->getValueType(0), N->getValueType(0),
9969                                  MVT::i32);
9970     SDValue Sum = DAG.getNode(X86ISD::UMUL, DL, VTs, LHS, RHS);
9971
9972     SDValue SetCC =
9973       DAG.getNode(X86ISD::SETCC, DL, MVT::i8,
9974                   DAG.getConstant(X86::COND_O, MVT::i32),
9975                   SDValue(Sum.getNode(), 2));
9976
9977     return DAG.getNode(ISD::MERGE_VALUES, DL, N->getVTList(), Sum, SetCC);
9978   }
9979   }
9980
9981   // Also sets EFLAGS.
9982   SDVTList VTs = DAG.getVTList(N->getValueType(0), MVT::i32);
9983   SDValue Sum = DAG.getNode(BaseOp, DL, VTs, LHS, RHS);
9984
9985   SDValue SetCC =
9986     DAG.getNode(X86ISD::SETCC, DL, N->getValueType(1),
9987                 DAG.getConstant(Cond, MVT::i32),
9988                 SDValue(Sum.getNode(), 1));
9989
9990   return DAG.getNode(ISD::MERGE_VALUES, DL, N->getVTList(), Sum, SetCC);
9991 }
9992
9993 SDValue X86TargetLowering::LowerSIGN_EXTEND_INREG(SDValue Op, SelectionDAG &DAG) const{
9994   DebugLoc dl = Op.getDebugLoc();
9995   SDNode* Node = Op.getNode();
9996   EVT ExtraVT = cast<VTSDNode>(Node->getOperand(1))->getVT();
9997   EVT VT = Node->getValueType(0);
9998
9999   if (Subtarget->hasSSE2() && VT.isVector()) {
10000     unsigned BitsDiff = VT.getScalarType().getSizeInBits() -
10001                         ExtraVT.getScalarType().getSizeInBits();
10002     SDValue ShAmt = DAG.getConstant(BitsDiff, MVT::i32);
10003
10004     unsigned SHLIntrinsicsID = 0;
10005     unsigned SRAIntrinsicsID = 0;
10006     switch (VT.getSimpleVT().SimpleTy) {
10007       default:
10008         return SDValue();
10009       case MVT::v2i64: {
10010         SHLIntrinsicsID = Intrinsic::x86_sse2_pslli_q;
10011         SRAIntrinsicsID = 0;
10012         break;
10013       }
10014       case MVT::v4i32: {
10015         SHLIntrinsicsID = Intrinsic::x86_sse2_pslli_d;
10016         SRAIntrinsicsID = Intrinsic::x86_sse2_psrai_d;
10017         break;
10018       }
10019       case MVT::v8i16: {
10020         SHLIntrinsicsID = Intrinsic::x86_sse2_pslli_w;
10021         SRAIntrinsicsID = Intrinsic::x86_sse2_psrai_w;
10022         break;
10023       }
10024     }
10025
10026     SDValue Tmp1 = DAG.getNode(ISD::INTRINSIC_WO_CHAIN, dl, VT,
10027                          DAG.getConstant(SHLIntrinsicsID, MVT::i32),
10028                          Node->getOperand(0), ShAmt);
10029
10030     // In case of 1 bit sext, no need to shr
10031     if (ExtraVT.getScalarType().getSizeInBits() == 1) return Tmp1;
10032
10033     if (SRAIntrinsicsID) {
10034       Tmp1 = DAG.getNode(ISD::INTRINSIC_WO_CHAIN, dl, VT,
10035                          DAG.getConstant(SRAIntrinsicsID, MVT::i32),
10036                          Tmp1, ShAmt);
10037     }
10038     return Tmp1;
10039   }
10040
10041   return SDValue();
10042 }
10043
10044
10045 SDValue X86TargetLowering::LowerMEMBARRIER(SDValue Op, SelectionDAG &DAG) const{
10046   DebugLoc dl = Op.getDebugLoc();
10047
10048   // Go ahead and emit the fence on x86-64 even if we asked for no-sse2.
10049   // There isn't any reason to disable it if the target processor supports it.
10050   if (!Subtarget->hasSSE2() && !Subtarget->is64Bit()) {
10051     SDValue Chain = Op.getOperand(0);
10052     SDValue Zero = DAG.getConstant(0, MVT::i32);
10053     SDValue Ops[] = {
10054       DAG.getRegister(X86::ESP, MVT::i32), // Base
10055       DAG.getTargetConstant(1, MVT::i8),   // Scale
10056       DAG.getRegister(0, MVT::i32),        // Index
10057       DAG.getTargetConstant(0, MVT::i32),  // Disp
10058       DAG.getRegister(0, MVT::i32),        // Segment.
10059       Zero,
10060       Chain
10061     };
10062     SDNode *Res =
10063       DAG.getMachineNode(X86::OR32mrLocked, dl, MVT::Other, Ops,
10064                           array_lengthof(Ops));
10065     return SDValue(Res, 0);
10066   }
10067
10068   unsigned isDev = cast<ConstantSDNode>(Op.getOperand(5))->getZExtValue();
10069   if (!isDev)
10070     return DAG.getNode(X86ISD::MEMBARRIER, dl, MVT::Other, Op.getOperand(0));
10071
10072   unsigned Op1 = cast<ConstantSDNode>(Op.getOperand(1))->getZExtValue();
10073   unsigned Op2 = cast<ConstantSDNode>(Op.getOperand(2))->getZExtValue();
10074   unsigned Op3 = cast<ConstantSDNode>(Op.getOperand(3))->getZExtValue();
10075   unsigned Op4 = cast<ConstantSDNode>(Op.getOperand(4))->getZExtValue();
10076
10077   // def : Pat<(membarrier (i8 0), (i8 0), (i8 0), (i8 1), (i8 1)), (SFENCE)>;
10078   if (!Op1 && !Op2 && !Op3 && Op4)
10079     return DAG.getNode(X86ISD::SFENCE, dl, MVT::Other, Op.getOperand(0));
10080
10081   // def : Pat<(membarrier (i8 1), (i8 0), (i8 0), (i8 0), (i8 1)), (LFENCE)>;
10082   if (Op1 && !Op2 && !Op3 && !Op4)
10083     return DAG.getNode(X86ISD::LFENCE, dl, MVT::Other, Op.getOperand(0));
10084
10085   // def : Pat<(membarrier (i8 imm), (i8 imm), (i8 imm), (i8 imm), (i8 1)),
10086   //           (MFENCE)>;
10087   return DAG.getNode(X86ISD::MFENCE, dl, MVT::Other, Op.getOperand(0));
10088 }
10089
10090 SDValue X86TargetLowering::LowerATOMIC_FENCE(SDValue Op,
10091                                              SelectionDAG &DAG) const {
10092   DebugLoc dl = Op.getDebugLoc();
10093   AtomicOrdering FenceOrdering = static_cast<AtomicOrdering>(
10094     cast<ConstantSDNode>(Op.getOperand(1))->getZExtValue());
10095   SynchronizationScope FenceScope = static_cast<SynchronizationScope>(
10096     cast<ConstantSDNode>(Op.getOperand(2))->getZExtValue());
10097
10098   // The only fence that needs an instruction is a sequentially-consistent
10099   // cross-thread fence.
10100   if (FenceOrdering == SequentiallyConsistent && FenceScope == CrossThread) {
10101     // Use mfence if we have SSE2 or we're on x86-64 (even if we asked for
10102     // no-sse2). There isn't any reason to disable it if the target processor
10103     // supports it.
10104     if (Subtarget->hasSSE2() || Subtarget->is64Bit())
10105       return DAG.getNode(X86ISD::MFENCE, dl, MVT::Other, Op.getOperand(0));
10106
10107     SDValue Chain = Op.getOperand(0);
10108     SDValue Zero = DAG.getConstant(0, MVT::i32);
10109     SDValue Ops[] = {
10110       DAG.getRegister(X86::ESP, MVT::i32), // Base
10111       DAG.getTargetConstant(1, MVT::i8),   // Scale
10112       DAG.getRegister(0, MVT::i32),        // Index
10113       DAG.getTargetConstant(0, MVT::i32),  // Disp
10114       DAG.getRegister(0, MVT::i32),        // Segment.
10115       Zero,
10116       Chain
10117     };
10118     SDNode *Res =
10119       DAG.getMachineNode(X86::OR32mrLocked, dl, MVT::Other, Ops,
10120                          array_lengthof(Ops));
10121     return SDValue(Res, 0);
10122   }
10123
10124   // MEMBARRIER is a compiler barrier; it codegens to a no-op.
10125   return DAG.getNode(X86ISD::MEMBARRIER, dl, MVT::Other, Op.getOperand(0));
10126 }
10127
10128
10129 SDValue X86TargetLowering::LowerCMP_SWAP(SDValue Op, SelectionDAG &DAG) const {
10130   EVT T = Op.getValueType();
10131   DebugLoc DL = Op.getDebugLoc();
10132   unsigned Reg = 0;
10133   unsigned size = 0;
10134   switch(T.getSimpleVT().SimpleTy) {
10135   default:
10136     assert(false && "Invalid value type!");
10137   case MVT::i8:  Reg = X86::AL;  size = 1; break;
10138   case MVT::i16: Reg = X86::AX;  size = 2; break;
10139   case MVT::i32: Reg = X86::EAX; size = 4; break;
10140   case MVT::i64:
10141     assert(Subtarget->is64Bit() && "Node not type legal!");
10142     Reg = X86::RAX; size = 8;
10143     break;
10144   }
10145   SDValue cpIn = DAG.getCopyToReg(Op.getOperand(0), DL, Reg,
10146                                     Op.getOperand(2), SDValue());
10147   SDValue Ops[] = { cpIn.getValue(0),
10148                     Op.getOperand(1),
10149                     Op.getOperand(3),
10150                     DAG.getTargetConstant(size, MVT::i8),
10151                     cpIn.getValue(1) };
10152   SDVTList Tys = DAG.getVTList(MVT::Other, MVT::Glue);
10153   MachineMemOperand *MMO = cast<AtomicSDNode>(Op)->getMemOperand();
10154   SDValue Result = DAG.getMemIntrinsicNode(X86ISD::LCMPXCHG_DAG, DL, Tys,
10155                                            Ops, 5, T, MMO);
10156   SDValue cpOut =
10157     DAG.getCopyFromReg(Result.getValue(0), DL, Reg, T, Result.getValue(1));
10158   return cpOut;
10159 }
10160
10161 SDValue X86TargetLowering::LowerREADCYCLECOUNTER(SDValue Op,
10162                                                  SelectionDAG &DAG) const {
10163   assert(Subtarget->is64Bit() && "Result not type legalized?");
10164   SDVTList Tys = DAG.getVTList(MVT::Other, MVT::Glue);
10165   SDValue TheChain = Op.getOperand(0);
10166   DebugLoc dl = Op.getDebugLoc();
10167   SDValue rd = DAG.getNode(X86ISD::RDTSC_DAG, dl, Tys, &TheChain, 1);
10168   SDValue rax = DAG.getCopyFromReg(rd, dl, X86::RAX, MVT::i64, rd.getValue(1));
10169   SDValue rdx = DAG.getCopyFromReg(rax.getValue(1), dl, X86::RDX, MVT::i64,
10170                                    rax.getValue(2));
10171   SDValue Tmp = DAG.getNode(ISD::SHL, dl, MVT::i64, rdx,
10172                             DAG.getConstant(32, MVT::i8));
10173   SDValue Ops[] = {
10174     DAG.getNode(ISD::OR, dl, MVT::i64, rax, Tmp),
10175     rdx.getValue(1)
10176   };
10177   return DAG.getMergeValues(Ops, 2, dl);
10178 }
10179
10180 SDValue X86TargetLowering::LowerBITCAST(SDValue Op,
10181                                             SelectionDAG &DAG) const {
10182   EVT SrcVT = Op.getOperand(0).getValueType();
10183   EVT DstVT = Op.getValueType();
10184   assert(Subtarget->is64Bit() && !Subtarget->hasSSE2() &&
10185          Subtarget->hasMMX() && "Unexpected custom BITCAST");
10186   assert((DstVT == MVT::i64 ||
10187           (DstVT.isVector() && DstVT.getSizeInBits()==64)) &&
10188          "Unexpected custom BITCAST");
10189   // i64 <=> MMX conversions are Legal.
10190   if (SrcVT==MVT::i64 && DstVT.isVector())
10191     return Op;
10192   if (DstVT==MVT::i64 && SrcVT.isVector())
10193     return Op;
10194   // MMX <=> MMX conversions are Legal.
10195   if (SrcVT.isVector() && DstVT.isVector())
10196     return Op;
10197   // All other conversions need to be expanded.
10198   return SDValue();
10199 }
10200
10201 SDValue X86TargetLowering::LowerLOAD_SUB(SDValue Op, SelectionDAG &DAG) const {
10202   SDNode *Node = Op.getNode();
10203   DebugLoc dl = Node->getDebugLoc();
10204   EVT T = Node->getValueType(0);
10205   SDValue negOp = DAG.getNode(ISD::SUB, dl, T,
10206                               DAG.getConstant(0, T), Node->getOperand(2));
10207   return DAG.getAtomic(ISD::ATOMIC_LOAD_ADD, dl,
10208                        cast<AtomicSDNode>(Node)->getMemoryVT(),
10209                        Node->getOperand(0),
10210                        Node->getOperand(1), negOp,
10211                        cast<AtomicSDNode>(Node)->getSrcValue(),
10212                        cast<AtomicSDNode>(Node)->getAlignment(),
10213                        cast<AtomicSDNode>(Node)->getOrdering(),
10214                        cast<AtomicSDNode>(Node)->getSynchScope());
10215 }
10216
10217 static SDValue LowerATOMIC_STORE(SDValue Op, SelectionDAG &DAG) {
10218   SDNode *Node = Op.getNode();
10219   DebugLoc dl = Node->getDebugLoc();
10220   EVT VT = cast<AtomicSDNode>(Node)->getMemoryVT();
10221
10222   // Convert seq_cst store -> xchg
10223   // Convert wide store -> swap (-> cmpxchg8b/cmpxchg16b)
10224   // FIXME: On 32-bit, store -> fist or movq would be more efficient
10225   //        (The only way to get a 16-byte store is cmpxchg16b)
10226   // FIXME: 16-byte ATOMIC_SWAP isn't actually hooked up at the moment.
10227   if (cast<AtomicSDNode>(Node)->getOrdering() == SequentiallyConsistent ||
10228       !DAG.getTargetLoweringInfo().isTypeLegal(VT)) {
10229     SDValue Swap = DAG.getAtomic(ISD::ATOMIC_SWAP, dl,
10230                                  cast<AtomicSDNode>(Node)->getMemoryVT(),
10231                                  Node->getOperand(0),
10232                                  Node->getOperand(1), Node->getOperand(2),
10233                                  cast<AtomicSDNode>(Node)->getMemOperand(),
10234                                  cast<AtomicSDNode>(Node)->getOrdering(),
10235                                  cast<AtomicSDNode>(Node)->getSynchScope());
10236     return Swap.getValue(1);
10237   }
10238   // Other atomic stores have a simple pattern.
10239   return Op;
10240 }
10241
10242 static SDValue LowerADDC_ADDE_SUBC_SUBE(SDValue Op, SelectionDAG &DAG) {
10243   EVT VT = Op.getNode()->getValueType(0);
10244
10245   // Let legalize expand this if it isn't a legal type yet.
10246   if (!DAG.getTargetLoweringInfo().isTypeLegal(VT))
10247     return SDValue();
10248
10249   SDVTList VTs = DAG.getVTList(VT, MVT::i32);
10250
10251   unsigned Opc;
10252   bool ExtraOp = false;
10253   switch (Op.getOpcode()) {
10254   default: assert(0 && "Invalid code");
10255   case ISD::ADDC: Opc = X86ISD::ADD; break;
10256   case ISD::ADDE: Opc = X86ISD::ADC; ExtraOp = true; break;
10257   case ISD::SUBC: Opc = X86ISD::SUB; break;
10258   case ISD::SUBE: Opc = X86ISD::SBB; ExtraOp = true; break;
10259   }
10260
10261   if (!ExtraOp)
10262     return DAG.getNode(Opc, Op->getDebugLoc(), VTs, Op.getOperand(0),
10263                        Op.getOperand(1));
10264   return DAG.getNode(Opc, Op->getDebugLoc(), VTs, Op.getOperand(0),
10265                      Op.getOperand(1), Op.getOperand(2));
10266 }
10267
10268 /// LowerOperation - Provide custom lowering hooks for some operations.
10269 ///
10270 SDValue X86TargetLowering::LowerOperation(SDValue Op, SelectionDAG &DAG) const {
10271   switch (Op.getOpcode()) {
10272   default: llvm_unreachable("Should not custom lower this!");
10273   case ISD::SIGN_EXTEND_INREG:  return LowerSIGN_EXTEND_INREG(Op,DAG);
10274   case ISD::MEMBARRIER:         return LowerMEMBARRIER(Op,DAG);
10275   case ISD::ATOMIC_FENCE:       return LowerATOMIC_FENCE(Op,DAG);
10276   case ISD::ATOMIC_CMP_SWAP:    return LowerCMP_SWAP(Op,DAG);
10277   case ISD::ATOMIC_LOAD_SUB:    return LowerLOAD_SUB(Op,DAG);
10278   case ISD::ATOMIC_STORE:       return LowerATOMIC_STORE(Op,DAG);
10279   case ISD::BUILD_VECTOR:       return LowerBUILD_VECTOR(Op, DAG);
10280   case ISD::CONCAT_VECTORS:     return LowerCONCAT_VECTORS(Op, DAG);
10281   case ISD::VECTOR_SHUFFLE:     return LowerVECTOR_SHUFFLE(Op, DAG);
10282   case ISD::EXTRACT_VECTOR_ELT: return LowerEXTRACT_VECTOR_ELT(Op, DAG);
10283   case ISD::INSERT_VECTOR_ELT:  return LowerINSERT_VECTOR_ELT(Op, DAG);
10284   case ISD::EXTRACT_SUBVECTOR:  return LowerEXTRACT_SUBVECTOR(Op, DAG);
10285   case ISD::INSERT_SUBVECTOR:   return LowerINSERT_SUBVECTOR(Op, DAG);
10286   case ISD::SCALAR_TO_VECTOR:   return LowerSCALAR_TO_VECTOR(Op, DAG);
10287   case ISD::ConstantPool:       return LowerConstantPool(Op, DAG);
10288   case ISD::GlobalAddress:      return LowerGlobalAddress(Op, DAG);
10289   case ISD::GlobalTLSAddress:   return LowerGlobalTLSAddress(Op, DAG);
10290   case ISD::ExternalSymbol:     return LowerExternalSymbol(Op, DAG);
10291   case ISD::BlockAddress:       return LowerBlockAddress(Op, DAG);
10292   case ISD::SHL_PARTS:
10293   case ISD::SRA_PARTS:
10294   case ISD::SRL_PARTS:          return LowerShiftParts(Op, DAG);
10295   case ISD::SINT_TO_FP:         return LowerSINT_TO_FP(Op, DAG);
10296   case ISD::UINT_TO_FP:         return LowerUINT_TO_FP(Op, DAG);
10297   case ISD::FP_TO_SINT:         return LowerFP_TO_SINT(Op, DAG);
10298   case ISD::FP_TO_UINT:         return LowerFP_TO_UINT(Op, DAG);
10299   case ISD::FABS:               return LowerFABS(Op, DAG);
10300   case ISD::FNEG:               return LowerFNEG(Op, DAG);
10301   case ISD::FCOPYSIGN:          return LowerFCOPYSIGN(Op, DAG);
10302   case ISD::FGETSIGN:           return LowerFGETSIGN(Op, DAG);
10303   case ISD::SETCC:              return LowerSETCC(Op, DAG);
10304   case ISD::VSETCC:             return LowerVSETCC(Op, DAG);
10305   case ISD::SELECT:             return LowerSELECT(Op, DAG);
10306   case ISD::BRCOND:             return LowerBRCOND(Op, DAG);
10307   case ISD::JumpTable:          return LowerJumpTable(Op, DAG);
10308   case ISD::VASTART:            return LowerVASTART(Op, DAG);
10309   case ISD::VAARG:              return LowerVAARG(Op, DAG);
10310   case ISD::VACOPY:             return LowerVACOPY(Op, DAG);
10311   case ISD::INTRINSIC_WO_CHAIN: return LowerINTRINSIC_WO_CHAIN(Op, DAG);
10312   case ISD::RETURNADDR:         return LowerRETURNADDR(Op, DAG);
10313   case ISD::FRAMEADDR:          return LowerFRAMEADDR(Op, DAG);
10314   case ISD::FRAME_TO_ARGS_OFFSET:
10315                                 return LowerFRAME_TO_ARGS_OFFSET(Op, DAG);
10316   case ISD::DYNAMIC_STACKALLOC: return LowerDYNAMIC_STACKALLOC(Op, DAG);
10317   case ISD::EH_RETURN:          return LowerEH_RETURN(Op, DAG);
10318   case ISD::TRAMPOLINE:         return LowerTRAMPOLINE(Op, DAG);
10319   case ISD::FLT_ROUNDS_:        return LowerFLT_ROUNDS_(Op, DAG);
10320   case ISD::CTLZ:               return LowerCTLZ(Op, DAG);
10321   case ISD::CTTZ:               return LowerCTTZ(Op, DAG);
10322   case ISD::MUL:                return LowerMUL(Op, DAG);
10323   case ISD::SRA:
10324   case ISD::SRL:
10325   case ISD::SHL:                return LowerShift(Op, DAG);
10326   case ISD::SADDO:
10327   case ISD::UADDO:
10328   case ISD::SSUBO:
10329   case ISD::USUBO:
10330   case ISD::SMULO:
10331   case ISD::UMULO:              return LowerXALUO(Op, DAG);
10332   case ISD::READCYCLECOUNTER:   return LowerREADCYCLECOUNTER(Op, DAG);
10333   case ISD::BITCAST:            return LowerBITCAST(Op, DAG);
10334   case ISD::ADDC:
10335   case ISD::ADDE:
10336   case ISD::SUBC:
10337   case ISD::SUBE:               return LowerADDC_ADDE_SUBC_SUBE(Op, DAG);
10338   case ISD::ADD:                return LowerADD(Op, DAG);
10339   case ISD::SUB:                return LowerSUB(Op, DAG);
10340   }
10341 }
10342
10343 static void ReplaceATOMIC_LOAD(SDNode *Node,
10344                                   SmallVectorImpl<SDValue> &Results,
10345                                   SelectionDAG &DAG) {
10346   DebugLoc dl = Node->getDebugLoc();
10347   EVT VT = cast<AtomicSDNode>(Node)->getMemoryVT();
10348
10349   // Convert wide load -> cmpxchg8b/cmpxchg16b
10350   // FIXME: On 32-bit, load -> fild or movq would be more efficient
10351   //        (The only way to get a 16-byte load is cmpxchg16b)
10352   // FIXME: 16-byte ATOMIC_CMP_SWAP isn't actually hooked up at the moment.
10353   SDValue Zero = DAG.getConstant(0, VT);
10354   SDValue Swap = DAG.getAtomic(ISD::ATOMIC_CMP_SWAP, dl, VT,
10355                                Node->getOperand(0),
10356                                Node->getOperand(1), Zero, Zero,
10357                                cast<AtomicSDNode>(Node)->getMemOperand(),
10358                                cast<AtomicSDNode>(Node)->getOrdering(),
10359                                cast<AtomicSDNode>(Node)->getSynchScope());
10360   Results.push_back(Swap.getValue(0));
10361   Results.push_back(Swap.getValue(1));
10362 }
10363
10364 void X86TargetLowering::
10365 ReplaceATOMIC_BINARY_64(SDNode *Node, SmallVectorImpl<SDValue>&Results,
10366                         SelectionDAG &DAG, unsigned NewOp) const {
10367   EVT T = Node->getValueType(0);
10368   DebugLoc dl = Node->getDebugLoc();
10369   assert (T == MVT::i64 && "Only know how to expand i64 atomics");
10370
10371   SDValue Chain = Node->getOperand(0);
10372   SDValue In1 = Node->getOperand(1);
10373   SDValue In2L = DAG.getNode(ISD::EXTRACT_ELEMENT, dl, MVT::i32,
10374                              Node->getOperand(2), DAG.getIntPtrConstant(0));
10375   SDValue In2H = DAG.getNode(ISD::EXTRACT_ELEMENT, dl, MVT::i32,
10376                              Node->getOperand(2), DAG.getIntPtrConstant(1));
10377   SDValue Ops[] = { Chain, In1, In2L, In2H };
10378   SDVTList Tys = DAG.getVTList(MVT::i32, MVT::i32, MVT::Other);
10379   SDValue Result =
10380     DAG.getMemIntrinsicNode(NewOp, dl, Tys, Ops, 4, MVT::i64,
10381                             cast<MemSDNode>(Node)->getMemOperand());
10382   SDValue OpsF[] = { Result.getValue(0), Result.getValue(1)};
10383   Results.push_back(DAG.getNode(ISD::BUILD_PAIR, dl, MVT::i64, OpsF, 2));
10384   Results.push_back(Result.getValue(2));
10385 }
10386
10387 /// ReplaceNodeResults - Replace a node with an illegal result type
10388 /// with a new node built out of custom code.
10389 void X86TargetLowering::ReplaceNodeResults(SDNode *N,
10390                                            SmallVectorImpl<SDValue>&Results,
10391                                            SelectionDAG &DAG) const {
10392   DebugLoc dl = N->getDebugLoc();
10393   switch (N->getOpcode()) {
10394   default:
10395     assert(false && "Do not know how to custom type legalize this operation!");
10396     return;
10397   case ISD::SIGN_EXTEND_INREG:
10398   case ISD::ADDC:
10399   case ISD::ADDE:
10400   case ISD::SUBC:
10401   case ISD::SUBE:
10402     // We don't want to expand or promote these.
10403     return;
10404   case ISD::FP_TO_SINT: {
10405     std::pair<SDValue,SDValue> Vals =
10406         FP_TO_INTHelper(SDValue(N, 0), DAG, true);
10407     SDValue FIST = Vals.first, StackSlot = Vals.second;
10408     if (FIST.getNode() != 0) {
10409       EVT VT = N->getValueType(0);
10410       // Return a load from the stack slot.
10411       Results.push_back(DAG.getLoad(VT, dl, FIST, StackSlot,
10412                                     MachinePointerInfo(), false, false, 0));
10413     }
10414     return;
10415   }
10416   case ISD::READCYCLECOUNTER: {
10417     SDVTList Tys = DAG.getVTList(MVT::Other, MVT::Glue);
10418     SDValue TheChain = N->getOperand(0);
10419     SDValue rd = DAG.getNode(X86ISD::RDTSC_DAG, dl, Tys, &TheChain, 1);
10420     SDValue eax = DAG.getCopyFromReg(rd, dl, X86::EAX, MVT::i32,
10421                                      rd.getValue(1));
10422     SDValue edx = DAG.getCopyFromReg(eax.getValue(1), dl, X86::EDX, MVT::i32,
10423                                      eax.getValue(2));
10424     // Use a buildpair to merge the two 32-bit values into a 64-bit one.
10425     SDValue Ops[] = { eax, edx };
10426     Results.push_back(DAG.getNode(ISD::BUILD_PAIR, dl, MVT::i64, Ops, 2));
10427     Results.push_back(edx.getValue(1));
10428     return;
10429   }
10430   case ISD::ATOMIC_CMP_SWAP: {
10431     EVT T = N->getValueType(0);
10432     assert((T == MVT::i64 || T == MVT::i128) && "can only expand cmpxchg pair");
10433     bool Regs64bit = T == MVT::i128;
10434     EVT HalfT = Regs64bit ? MVT::i64 : MVT::i32;
10435     SDValue cpInL, cpInH;
10436     cpInL = DAG.getNode(ISD::EXTRACT_ELEMENT, dl, HalfT, N->getOperand(2),
10437                         DAG.getConstant(0, HalfT));
10438     cpInH = DAG.getNode(ISD::EXTRACT_ELEMENT, dl, HalfT, N->getOperand(2),
10439                         DAG.getConstant(1, HalfT));
10440     cpInL = DAG.getCopyToReg(N->getOperand(0), dl,
10441                              Regs64bit ? X86::RAX : X86::EAX,
10442                              cpInL, SDValue());
10443     cpInH = DAG.getCopyToReg(cpInL.getValue(0), dl,
10444                              Regs64bit ? X86::RDX : X86::EDX,
10445                              cpInH, cpInL.getValue(1));
10446     SDValue swapInL, swapInH;
10447     swapInL = DAG.getNode(ISD::EXTRACT_ELEMENT, dl, HalfT, N->getOperand(3),
10448                           DAG.getConstant(0, HalfT));
10449     swapInH = DAG.getNode(ISD::EXTRACT_ELEMENT, dl, HalfT, N->getOperand(3),
10450                           DAG.getConstant(1, HalfT));
10451     swapInL = DAG.getCopyToReg(cpInH.getValue(0), dl,
10452                                Regs64bit ? X86::RBX : X86::EBX,
10453                                swapInL, cpInH.getValue(1));
10454     swapInH = DAG.getCopyToReg(swapInL.getValue(0), dl,
10455                                Regs64bit ? X86::RCX : X86::ECX,
10456                                swapInH, swapInL.getValue(1));
10457     SDValue Ops[] = { swapInH.getValue(0),
10458                       N->getOperand(1),
10459                       swapInH.getValue(1) };
10460     SDVTList Tys = DAG.getVTList(MVT::Other, MVT::Glue);
10461     MachineMemOperand *MMO = cast<AtomicSDNode>(N)->getMemOperand();
10462     unsigned Opcode = Regs64bit ? X86ISD::LCMPXCHG16_DAG :
10463                                   X86ISD::LCMPXCHG8_DAG;
10464     SDValue Result = DAG.getMemIntrinsicNode(Opcode, dl, Tys,
10465                                              Ops, 3, T, MMO);
10466     SDValue cpOutL = DAG.getCopyFromReg(Result.getValue(0), dl,
10467                                         Regs64bit ? X86::RAX : X86::EAX,
10468                                         HalfT, Result.getValue(1));
10469     SDValue cpOutH = DAG.getCopyFromReg(cpOutL.getValue(1), dl,
10470                                         Regs64bit ? X86::RDX : X86::EDX,
10471                                         HalfT, cpOutL.getValue(2));
10472     SDValue OpsF[] = { cpOutL.getValue(0), cpOutH.getValue(0)};
10473     Results.push_back(DAG.getNode(ISD::BUILD_PAIR, dl, T, OpsF, 2));
10474     Results.push_back(cpOutH.getValue(1));
10475     return;
10476   }
10477   case ISD::ATOMIC_LOAD_ADD:
10478     ReplaceATOMIC_BINARY_64(N, Results, DAG, X86ISD::ATOMADD64_DAG);
10479     return;
10480   case ISD::ATOMIC_LOAD_AND:
10481     ReplaceATOMIC_BINARY_64(N, Results, DAG, X86ISD::ATOMAND64_DAG);
10482     return;
10483   case ISD::ATOMIC_LOAD_NAND:
10484     ReplaceATOMIC_BINARY_64(N, Results, DAG, X86ISD::ATOMNAND64_DAG);
10485     return;
10486   case ISD::ATOMIC_LOAD_OR:
10487     ReplaceATOMIC_BINARY_64(N, Results, DAG, X86ISD::ATOMOR64_DAG);
10488     return;
10489   case ISD::ATOMIC_LOAD_SUB:
10490     ReplaceATOMIC_BINARY_64(N, Results, DAG, X86ISD::ATOMSUB64_DAG);
10491     return;
10492   case ISD::ATOMIC_LOAD_XOR:
10493     ReplaceATOMIC_BINARY_64(N, Results, DAG, X86ISD::ATOMXOR64_DAG);
10494     return;
10495   case ISD::ATOMIC_SWAP:
10496     ReplaceATOMIC_BINARY_64(N, Results, DAG, X86ISD::ATOMSWAP64_DAG);
10497     return;
10498   case ISD::ATOMIC_LOAD:
10499     ReplaceATOMIC_LOAD(N, Results, DAG);
10500   }
10501 }
10502
10503 const char *X86TargetLowering::getTargetNodeName(unsigned Opcode) const {
10504   switch (Opcode) {
10505   default: return NULL;
10506   case X86ISD::BSF:                return "X86ISD::BSF";
10507   case X86ISD::BSR:                return "X86ISD::BSR";
10508   case X86ISD::SHLD:               return "X86ISD::SHLD";
10509   case X86ISD::SHRD:               return "X86ISD::SHRD";
10510   case X86ISD::FAND:               return "X86ISD::FAND";
10511   case X86ISD::FOR:                return "X86ISD::FOR";
10512   case X86ISD::FXOR:               return "X86ISD::FXOR";
10513   case X86ISD::FSRL:               return "X86ISD::FSRL";
10514   case X86ISD::FILD:               return "X86ISD::FILD";
10515   case X86ISD::FILD_FLAG:          return "X86ISD::FILD_FLAG";
10516   case X86ISD::FP_TO_INT16_IN_MEM: return "X86ISD::FP_TO_INT16_IN_MEM";
10517   case X86ISD::FP_TO_INT32_IN_MEM: return "X86ISD::FP_TO_INT32_IN_MEM";
10518   case X86ISD::FP_TO_INT64_IN_MEM: return "X86ISD::FP_TO_INT64_IN_MEM";
10519   case X86ISD::FLD:                return "X86ISD::FLD";
10520   case X86ISD::FST:                return "X86ISD::FST";
10521   case X86ISD::CALL:               return "X86ISD::CALL";
10522   case X86ISD::RDTSC_DAG:          return "X86ISD::RDTSC_DAG";
10523   case X86ISD::BT:                 return "X86ISD::BT";
10524   case X86ISD::CMP:                return "X86ISD::CMP";
10525   case X86ISD::COMI:               return "X86ISD::COMI";
10526   case X86ISD::UCOMI:              return "X86ISD::UCOMI";
10527   case X86ISD::SETCC:              return "X86ISD::SETCC";
10528   case X86ISD::SETCC_CARRY:        return "X86ISD::SETCC_CARRY";
10529   case X86ISD::FSETCCsd:           return "X86ISD::FSETCCsd";
10530   case X86ISD::FSETCCss:           return "X86ISD::FSETCCss";
10531   case X86ISD::CMOV:               return "X86ISD::CMOV";
10532   case X86ISD::BRCOND:             return "X86ISD::BRCOND";
10533   case X86ISD::RET_FLAG:           return "X86ISD::RET_FLAG";
10534   case X86ISD::REP_STOS:           return "X86ISD::REP_STOS";
10535   case X86ISD::REP_MOVS:           return "X86ISD::REP_MOVS";
10536   case X86ISD::GlobalBaseReg:      return "X86ISD::GlobalBaseReg";
10537   case X86ISD::Wrapper:            return "X86ISD::Wrapper";
10538   case X86ISD::WrapperRIP:         return "X86ISD::WrapperRIP";
10539   case X86ISD::PEXTRB:             return "X86ISD::PEXTRB";
10540   case X86ISD::PEXTRW:             return "X86ISD::PEXTRW";
10541   case X86ISD::INSERTPS:           return "X86ISD::INSERTPS";
10542   case X86ISD::PINSRB:             return "X86ISD::PINSRB";
10543   case X86ISD::PINSRW:             return "X86ISD::PINSRW";
10544   case X86ISD::PSHUFB:             return "X86ISD::PSHUFB";
10545   case X86ISD::ANDNP:              return "X86ISD::ANDNP";
10546   case X86ISD::PSIGNB:             return "X86ISD::PSIGNB";
10547   case X86ISD::PSIGNW:             return "X86ISD::PSIGNW";
10548   case X86ISD::PSIGND:             return "X86ISD::PSIGND";
10549   case X86ISD::PBLENDVB:           return "X86ISD::PBLENDVB";
10550   case X86ISD::FMAX:               return "X86ISD::FMAX";
10551   case X86ISD::FMIN:               return "X86ISD::FMIN";
10552   case X86ISD::FRSQRT:             return "X86ISD::FRSQRT";
10553   case X86ISD::FRCP:               return "X86ISD::FRCP";
10554   case X86ISD::TLSADDR:            return "X86ISD::TLSADDR";
10555   case X86ISD::TLSCALL:            return "X86ISD::TLSCALL";
10556   case X86ISD::EH_RETURN:          return "X86ISD::EH_RETURN";
10557   case X86ISD::TC_RETURN:          return "X86ISD::TC_RETURN";
10558   case X86ISD::FNSTCW16m:          return "X86ISD::FNSTCW16m";
10559   case X86ISD::LCMPXCHG_DAG:       return "X86ISD::LCMPXCHG_DAG";
10560   case X86ISD::LCMPXCHG8_DAG:      return "X86ISD::LCMPXCHG8_DAG";
10561   case X86ISD::ATOMADD64_DAG:      return "X86ISD::ATOMADD64_DAG";
10562   case X86ISD::ATOMSUB64_DAG:      return "X86ISD::ATOMSUB64_DAG";
10563   case X86ISD::ATOMOR64_DAG:       return "X86ISD::ATOMOR64_DAG";
10564   case X86ISD::ATOMXOR64_DAG:      return "X86ISD::ATOMXOR64_DAG";
10565   case X86ISD::ATOMAND64_DAG:      return "X86ISD::ATOMAND64_DAG";
10566   case X86ISD::ATOMNAND64_DAG:     return "X86ISD::ATOMNAND64_DAG";
10567   case X86ISD::VZEXT_MOVL:         return "X86ISD::VZEXT_MOVL";
10568   case X86ISD::VZEXT_LOAD:         return "X86ISD::VZEXT_LOAD";
10569   case X86ISD::VSHL:               return "X86ISD::VSHL";
10570   case X86ISD::VSRL:               return "X86ISD::VSRL";
10571   case X86ISD::CMPPD:              return "X86ISD::CMPPD";
10572   case X86ISD::CMPPS:              return "X86ISD::CMPPS";
10573   case X86ISD::PCMPEQB:            return "X86ISD::PCMPEQB";
10574   case X86ISD::PCMPEQW:            return "X86ISD::PCMPEQW";
10575   case X86ISD::PCMPEQD:            return "X86ISD::PCMPEQD";
10576   case X86ISD::PCMPEQQ:            return "X86ISD::PCMPEQQ";
10577   case X86ISD::PCMPGTB:            return "X86ISD::PCMPGTB";
10578   case X86ISD::PCMPGTW:            return "X86ISD::PCMPGTW";
10579   case X86ISD::PCMPGTD:            return "X86ISD::PCMPGTD";
10580   case X86ISD::PCMPGTQ:            return "X86ISD::PCMPGTQ";
10581   case X86ISD::ADD:                return "X86ISD::ADD";
10582   case X86ISD::SUB:                return "X86ISD::SUB";
10583   case X86ISD::ADC:                return "X86ISD::ADC";
10584   case X86ISD::SBB:                return "X86ISD::SBB";
10585   case X86ISD::SMUL:               return "X86ISD::SMUL";
10586   case X86ISD::UMUL:               return "X86ISD::UMUL";
10587   case X86ISD::INC:                return "X86ISD::INC";
10588   case X86ISD::DEC:                return "X86ISD::DEC";
10589   case X86ISD::OR:                 return "X86ISD::OR";
10590   case X86ISD::XOR:                return "X86ISD::XOR";
10591   case X86ISD::AND:                return "X86ISD::AND";
10592   case X86ISD::MUL_IMM:            return "X86ISD::MUL_IMM";
10593   case X86ISD::PTEST:              return "X86ISD::PTEST";
10594   case X86ISD::TESTP:              return "X86ISD::TESTP";
10595   case X86ISD::PALIGN:             return "X86ISD::PALIGN";
10596   case X86ISD::PSHUFD:             return "X86ISD::PSHUFD";
10597   case X86ISD::PSHUFHW:            return "X86ISD::PSHUFHW";
10598   case X86ISD::PSHUFHW_LD:         return "X86ISD::PSHUFHW_LD";
10599   case X86ISD::PSHUFLW:            return "X86ISD::PSHUFLW";
10600   case X86ISD::PSHUFLW_LD:         return "X86ISD::PSHUFLW_LD";
10601   case X86ISD::SHUFPS:             return "X86ISD::SHUFPS";
10602   case X86ISD::SHUFPD:             return "X86ISD::SHUFPD";
10603   case X86ISD::MOVLHPS:            return "X86ISD::MOVLHPS";
10604   case X86ISD::MOVLHPD:            return "X86ISD::MOVLHPD";
10605   case X86ISD::MOVHLPS:            return "X86ISD::MOVHLPS";
10606   case X86ISD::MOVHLPD:            return "X86ISD::MOVHLPD";
10607   case X86ISD::MOVLPS:             return "X86ISD::MOVLPS";
10608   case X86ISD::MOVLPD:             return "X86ISD::MOVLPD";
10609   case X86ISD::MOVDDUP:            return "X86ISD::MOVDDUP";
10610   case X86ISD::MOVSHDUP:           return "X86ISD::MOVSHDUP";
10611   case X86ISD::MOVSLDUP:           return "X86ISD::MOVSLDUP";
10612   case X86ISD::MOVSHDUP_LD:        return "X86ISD::MOVSHDUP_LD";
10613   case X86ISD::MOVSLDUP_LD:        return "X86ISD::MOVSLDUP_LD";
10614   case X86ISD::MOVSD:              return "X86ISD::MOVSD";
10615   case X86ISD::MOVSS:              return "X86ISD::MOVSS";
10616   case X86ISD::UNPCKLPS:           return "X86ISD::UNPCKLPS";
10617   case X86ISD::UNPCKLPD:           return "X86ISD::UNPCKLPD";
10618   case X86ISD::VUNPCKLPDY:         return "X86ISD::VUNPCKLPDY";
10619   case X86ISD::UNPCKHPS:           return "X86ISD::UNPCKHPS";
10620   case X86ISD::UNPCKHPD:           return "X86ISD::UNPCKHPD";
10621   case X86ISD::PUNPCKLBW:          return "X86ISD::PUNPCKLBW";
10622   case X86ISD::PUNPCKLWD:          return "X86ISD::PUNPCKLWD";
10623   case X86ISD::PUNPCKLDQ:          return "X86ISD::PUNPCKLDQ";
10624   case X86ISD::PUNPCKLQDQ:         return "X86ISD::PUNPCKLQDQ";
10625   case X86ISD::PUNPCKHBW:          return "X86ISD::PUNPCKHBW";
10626   case X86ISD::PUNPCKHWD:          return "X86ISD::PUNPCKHWD";
10627   case X86ISD::PUNPCKHDQ:          return "X86ISD::PUNPCKHDQ";
10628   case X86ISD::PUNPCKHQDQ:         return "X86ISD::PUNPCKHQDQ";
10629   case X86ISD::VBROADCAST:         return "X86ISD::VBROADCAST";
10630   case X86ISD::VPERMILPS:          return "X86ISD::VPERMILPS";
10631   case X86ISD::VPERMILPSY:         return "X86ISD::VPERMILPSY";
10632   case X86ISD::VPERMILPD:          return "X86ISD::VPERMILPD";
10633   case X86ISD::VPERMILPDY:         return "X86ISD::VPERMILPDY";
10634   case X86ISD::VPERM2F128:         return "X86ISD::VPERM2F128";
10635   case X86ISD::VASTART_SAVE_XMM_REGS: return "X86ISD::VASTART_SAVE_XMM_REGS";
10636   case X86ISD::VAARG_64:           return "X86ISD::VAARG_64";
10637   case X86ISD::WIN_ALLOCA:         return "X86ISD::WIN_ALLOCA";
10638   case X86ISD::MEMBARRIER:         return "X86ISD::MEMBARRIER";
10639   }
10640 }
10641
10642 // isLegalAddressingMode - Return true if the addressing mode represented
10643 // by AM is legal for this target, for a load/store of the specified type.
10644 bool X86TargetLowering::isLegalAddressingMode(const AddrMode &AM,
10645                                               Type *Ty) const {
10646   // X86 supports extremely general addressing modes.
10647   CodeModel::Model M = getTargetMachine().getCodeModel();
10648   Reloc::Model R = getTargetMachine().getRelocationModel();
10649
10650   // X86 allows a sign-extended 32-bit immediate field as a displacement.
10651   if (!X86::isOffsetSuitableForCodeModel(AM.BaseOffs, M, AM.BaseGV != NULL))
10652     return false;
10653
10654   if (AM.BaseGV) {
10655     unsigned GVFlags =
10656       Subtarget->ClassifyGlobalReference(AM.BaseGV, getTargetMachine());
10657
10658     // If a reference to this global requires an extra load, we can't fold it.
10659     if (isGlobalStubReference(GVFlags))
10660       return false;
10661
10662     // If BaseGV requires a register for the PIC base, we cannot also have a
10663     // BaseReg specified.
10664     if (AM.HasBaseReg && isGlobalRelativeToPICBase(GVFlags))
10665       return false;
10666
10667     // If lower 4G is not available, then we must use rip-relative addressing.
10668     if ((M != CodeModel::Small || R != Reloc::Static) &&
10669         Subtarget->is64Bit() && (AM.BaseOffs || AM.Scale > 1))
10670       return false;
10671   }
10672
10673   switch (AM.Scale) {
10674   case 0:
10675   case 1:
10676   case 2:
10677   case 4:
10678   case 8:
10679     // These scales always work.
10680     break;
10681   case 3:
10682   case 5:
10683   case 9:
10684     // These scales are formed with basereg+scalereg.  Only accept if there is
10685     // no basereg yet.
10686     if (AM.HasBaseReg)
10687       return false;
10688     break;
10689   default:  // Other stuff never works.
10690     return false;
10691   }
10692
10693   return true;
10694 }
10695
10696
10697 bool X86TargetLowering::isTruncateFree(Type *Ty1, Type *Ty2) const {
10698   if (!Ty1->isIntegerTy() || !Ty2->isIntegerTy())
10699     return false;
10700   unsigned NumBits1 = Ty1->getPrimitiveSizeInBits();
10701   unsigned NumBits2 = Ty2->getPrimitiveSizeInBits();
10702   if (NumBits1 <= NumBits2)
10703     return false;
10704   return true;
10705 }
10706
10707 bool X86TargetLowering::isTruncateFree(EVT VT1, EVT VT2) const {
10708   if (!VT1.isInteger() || !VT2.isInteger())
10709     return false;
10710   unsigned NumBits1 = VT1.getSizeInBits();
10711   unsigned NumBits2 = VT2.getSizeInBits();
10712   if (NumBits1 <= NumBits2)
10713     return false;
10714   return true;
10715 }
10716
10717 bool X86TargetLowering::isZExtFree(Type *Ty1, Type *Ty2) const {
10718   // x86-64 implicitly zero-extends 32-bit results in 64-bit registers.
10719   return Ty1->isIntegerTy(32) && Ty2->isIntegerTy(64) && Subtarget->is64Bit();
10720 }
10721
10722 bool X86TargetLowering::isZExtFree(EVT VT1, EVT VT2) const {
10723   // x86-64 implicitly zero-extends 32-bit results in 64-bit registers.
10724   return VT1 == MVT::i32 && VT2 == MVT::i64 && Subtarget->is64Bit();
10725 }
10726
10727 bool X86TargetLowering::isNarrowingProfitable(EVT VT1, EVT VT2) const {
10728   // i16 instructions are longer (0x66 prefix) and potentially slower.
10729   return !(VT1 == MVT::i32 && VT2 == MVT::i16);
10730 }
10731
10732 /// isShuffleMaskLegal - Targets can use this to indicate that they only
10733 /// support *some* VECTOR_SHUFFLE operations, those with specific masks.
10734 /// By default, if a target supports the VECTOR_SHUFFLE node, all mask values
10735 /// are assumed to be legal.
10736 bool
10737 X86TargetLowering::isShuffleMaskLegal(const SmallVectorImpl<int> &M,
10738                                       EVT VT) const {
10739   // Very little shuffling can be done for 64-bit vectors right now.
10740   if (VT.getSizeInBits() == 64)
10741     return isPALIGNRMask(M, VT, Subtarget->hasSSSE3());
10742
10743   // FIXME: pshufb, blends, shifts.
10744   return (VT.getVectorNumElements() == 2 ||
10745           ShuffleVectorSDNode::isSplatMask(&M[0], VT) ||
10746           isMOVLMask(M, VT) ||
10747           isSHUFPMask(M, VT) ||
10748           isPSHUFDMask(M, VT) ||
10749           isPSHUFHWMask(M, VT) ||
10750           isPSHUFLWMask(M, VT) ||
10751           isPALIGNRMask(M, VT, Subtarget->hasSSSE3()) ||
10752           isUNPCKLMask(M, VT) ||
10753           isUNPCKHMask(M, VT) ||
10754           isUNPCKL_v_undef_Mask(M, VT) ||
10755           isUNPCKH_v_undef_Mask(M, VT));
10756 }
10757
10758 bool
10759 X86TargetLowering::isVectorClearMaskLegal(const SmallVectorImpl<int> &Mask,
10760                                           EVT VT) const {
10761   unsigned NumElts = VT.getVectorNumElements();
10762   // FIXME: This collection of masks seems suspect.
10763   if (NumElts == 2)
10764     return true;
10765   if (NumElts == 4 && VT.getSizeInBits() == 128) {
10766     return (isMOVLMask(Mask, VT)  ||
10767             isCommutedMOVLMask(Mask, VT, true) ||
10768             isSHUFPMask(Mask, VT) ||
10769             isCommutedSHUFPMask(Mask, VT));
10770   }
10771   return false;
10772 }
10773
10774 //===----------------------------------------------------------------------===//
10775 //                           X86 Scheduler Hooks
10776 //===----------------------------------------------------------------------===//
10777
10778 // private utility function
10779 MachineBasicBlock *
10780 X86TargetLowering::EmitAtomicBitwiseWithCustomInserter(MachineInstr *bInstr,
10781                                                        MachineBasicBlock *MBB,
10782                                                        unsigned regOpc,
10783                                                        unsigned immOpc,
10784                                                        unsigned LoadOpc,
10785                                                        unsigned CXchgOpc,
10786                                                        unsigned notOpc,
10787                                                        unsigned EAXreg,
10788                                                        TargetRegisterClass *RC,
10789                                                        bool invSrc) const {
10790   // For the atomic bitwise operator, we generate
10791   //   thisMBB:
10792   //   newMBB:
10793   //     ld  t1 = [bitinstr.addr]
10794   //     op  t2 = t1, [bitinstr.val]
10795   //     mov EAX = t1
10796   //     lcs dest = [bitinstr.addr], t2  [EAX is implicit]
10797   //     bz  newMBB
10798   //     fallthrough -->nextMBB
10799   const TargetInstrInfo *TII = getTargetMachine().getInstrInfo();
10800   const BasicBlock *LLVM_BB = MBB->getBasicBlock();
10801   MachineFunction::iterator MBBIter = MBB;
10802   ++MBBIter;
10803
10804   /// First build the CFG
10805   MachineFunction *F = MBB->getParent();
10806   MachineBasicBlock *thisMBB = MBB;
10807   MachineBasicBlock *newMBB = F->CreateMachineBasicBlock(LLVM_BB);
10808   MachineBasicBlock *nextMBB = F->CreateMachineBasicBlock(LLVM_BB);
10809   F->insert(MBBIter, newMBB);
10810   F->insert(MBBIter, nextMBB);
10811
10812   // Transfer the remainder of thisMBB and its successor edges to nextMBB.
10813   nextMBB->splice(nextMBB->begin(), thisMBB,
10814                   llvm::next(MachineBasicBlock::iterator(bInstr)),
10815                   thisMBB->end());
10816   nextMBB->transferSuccessorsAndUpdatePHIs(thisMBB);
10817
10818   // Update thisMBB to fall through to newMBB
10819   thisMBB->addSuccessor(newMBB);
10820
10821   // newMBB jumps to itself and fall through to nextMBB
10822   newMBB->addSuccessor(nextMBB);
10823   newMBB->addSuccessor(newMBB);
10824
10825   // Insert instructions into newMBB based on incoming instruction
10826   assert(bInstr->getNumOperands() < X86::AddrNumOperands + 4 &&
10827          "unexpected number of operands");
10828   DebugLoc dl = bInstr->getDebugLoc();
10829   MachineOperand& destOper = bInstr->getOperand(0);
10830   MachineOperand* argOpers[2 + X86::AddrNumOperands];
10831   int numArgs = bInstr->getNumOperands() - 1;
10832   for (int i=0; i < numArgs; ++i)
10833     argOpers[i] = &bInstr->getOperand(i+1);
10834
10835   // x86 address has 4 operands: base, index, scale, and displacement
10836   int lastAddrIndx = X86::AddrNumOperands - 1; // [0,3]
10837   int valArgIndx = lastAddrIndx + 1;
10838
10839   unsigned t1 = F->getRegInfo().createVirtualRegister(RC);
10840   MachineInstrBuilder MIB = BuildMI(newMBB, dl, TII->get(LoadOpc), t1);
10841   for (int i=0; i <= lastAddrIndx; ++i)
10842     (*MIB).addOperand(*argOpers[i]);
10843
10844   unsigned tt = F->getRegInfo().createVirtualRegister(RC);
10845   if (invSrc) {
10846     MIB = BuildMI(newMBB, dl, TII->get(notOpc), tt).addReg(t1);
10847   }
10848   else
10849     tt = t1;
10850
10851   unsigned t2 = F->getRegInfo().createVirtualRegister(RC);
10852   assert((argOpers[valArgIndx]->isReg() ||
10853           argOpers[valArgIndx]->isImm()) &&
10854          "invalid operand");
10855   if (argOpers[valArgIndx]->isReg())
10856     MIB = BuildMI(newMBB, dl, TII->get(regOpc), t2);
10857   else
10858     MIB = BuildMI(newMBB, dl, TII->get(immOpc), t2);
10859   MIB.addReg(tt);
10860   (*MIB).addOperand(*argOpers[valArgIndx]);
10861
10862   MIB = BuildMI(newMBB, dl, TII->get(TargetOpcode::COPY), EAXreg);
10863   MIB.addReg(t1);
10864
10865   MIB = BuildMI(newMBB, dl, TII->get(CXchgOpc));
10866   for (int i=0; i <= lastAddrIndx; ++i)
10867     (*MIB).addOperand(*argOpers[i]);
10868   MIB.addReg(t2);
10869   assert(bInstr->hasOneMemOperand() && "Unexpected number of memoperand");
10870   (*MIB).setMemRefs(bInstr->memoperands_begin(),
10871                     bInstr->memoperands_end());
10872
10873   MIB = BuildMI(newMBB, dl, TII->get(TargetOpcode::COPY), destOper.getReg());
10874   MIB.addReg(EAXreg);
10875
10876   // insert branch
10877   BuildMI(newMBB, dl, TII->get(X86::JNE_4)).addMBB(newMBB);
10878
10879   bInstr->eraseFromParent();   // The pseudo instruction is gone now.
10880   return nextMBB;
10881 }
10882
10883 // private utility function:  64 bit atomics on 32 bit host.
10884 MachineBasicBlock *
10885 X86TargetLowering::EmitAtomicBit6432WithCustomInserter(MachineInstr *bInstr,
10886                                                        MachineBasicBlock *MBB,
10887                                                        unsigned regOpcL,
10888                                                        unsigned regOpcH,
10889                                                        unsigned immOpcL,
10890                                                        unsigned immOpcH,
10891                                                        bool invSrc) const {
10892   // For the atomic bitwise operator, we generate
10893   //   thisMBB (instructions are in pairs, except cmpxchg8b)
10894   //     ld t1,t2 = [bitinstr.addr]
10895   //   newMBB:
10896   //     out1, out2 = phi (thisMBB, t1/t2) (newMBB, t3/t4)
10897   //     op  t5, t6 <- out1, out2, [bitinstr.val]
10898   //      (for SWAP, substitute:  mov t5, t6 <- [bitinstr.val])
10899   //     mov ECX, EBX <- t5, t6
10900   //     mov EAX, EDX <- t1, t2
10901   //     cmpxchg8b [bitinstr.addr]  [EAX, EDX, EBX, ECX implicit]
10902   //     mov t3, t4 <- EAX, EDX
10903   //     bz  newMBB
10904   //     result in out1, out2
10905   //     fallthrough -->nextMBB
10906
10907   const TargetRegisterClass *RC = X86::GR32RegisterClass;
10908   const unsigned LoadOpc = X86::MOV32rm;
10909   const unsigned NotOpc = X86::NOT32r;
10910   const TargetInstrInfo *TII = getTargetMachine().getInstrInfo();
10911   const BasicBlock *LLVM_BB = MBB->getBasicBlock();
10912   MachineFunction::iterator MBBIter = MBB;
10913   ++MBBIter;
10914
10915   /// First build the CFG
10916   MachineFunction *F = MBB->getParent();
10917   MachineBasicBlock *thisMBB = MBB;
10918   MachineBasicBlock *newMBB = F->CreateMachineBasicBlock(LLVM_BB);
10919   MachineBasicBlock *nextMBB = F->CreateMachineBasicBlock(LLVM_BB);
10920   F->insert(MBBIter, newMBB);
10921   F->insert(MBBIter, nextMBB);
10922
10923   // Transfer the remainder of thisMBB and its successor edges to nextMBB.
10924   nextMBB->splice(nextMBB->begin(), thisMBB,
10925                   llvm::next(MachineBasicBlock::iterator(bInstr)),
10926                   thisMBB->end());
10927   nextMBB->transferSuccessorsAndUpdatePHIs(thisMBB);
10928
10929   // Update thisMBB to fall through to newMBB
10930   thisMBB->addSuccessor(newMBB);
10931
10932   // newMBB jumps to itself and fall through to nextMBB
10933   newMBB->addSuccessor(nextMBB);
10934   newMBB->addSuccessor(newMBB);
10935
10936   DebugLoc dl = bInstr->getDebugLoc();
10937   // Insert instructions into newMBB based on incoming instruction
10938   // There are 8 "real" operands plus 9 implicit def/uses, ignored here.
10939   assert(bInstr->getNumOperands() < X86::AddrNumOperands + 14 &&
10940          "unexpected number of operands");
10941   MachineOperand& dest1Oper = bInstr->getOperand(0);
10942   MachineOperand& dest2Oper = bInstr->getOperand(1);
10943   MachineOperand* argOpers[2 + X86::AddrNumOperands];
10944   for (int i=0; i < 2 + X86::AddrNumOperands; ++i) {
10945     argOpers[i] = &bInstr->getOperand(i+2);
10946
10947     // We use some of the operands multiple times, so conservatively just
10948     // clear any kill flags that might be present.
10949     if (argOpers[i]->isReg() && argOpers[i]->isUse())
10950       argOpers[i]->setIsKill(false);
10951   }
10952
10953   // x86 address has 5 operands: base, index, scale, displacement, and segment.
10954   int lastAddrIndx = X86::AddrNumOperands - 1; // [0,3]
10955
10956   unsigned t1 = F->getRegInfo().createVirtualRegister(RC);
10957   MachineInstrBuilder MIB = BuildMI(thisMBB, dl, TII->get(LoadOpc), t1);
10958   for (int i=0; i <= lastAddrIndx; ++i)
10959     (*MIB).addOperand(*argOpers[i]);
10960   unsigned t2 = F->getRegInfo().createVirtualRegister(RC);
10961   MIB = BuildMI(thisMBB, dl, TII->get(LoadOpc), t2);
10962   // add 4 to displacement.
10963   for (int i=0; i <= lastAddrIndx-2; ++i)
10964     (*MIB).addOperand(*argOpers[i]);
10965   MachineOperand newOp3 = *(argOpers[3]);
10966   if (newOp3.isImm())
10967     newOp3.setImm(newOp3.getImm()+4);
10968   else
10969     newOp3.setOffset(newOp3.getOffset()+4);
10970   (*MIB).addOperand(newOp3);
10971   (*MIB).addOperand(*argOpers[lastAddrIndx]);
10972
10973   // t3/4 are defined later, at the bottom of the loop
10974   unsigned t3 = F->getRegInfo().createVirtualRegister(RC);
10975   unsigned t4 = F->getRegInfo().createVirtualRegister(RC);
10976   BuildMI(newMBB, dl, TII->get(X86::PHI), dest1Oper.getReg())
10977     .addReg(t1).addMBB(thisMBB).addReg(t3).addMBB(newMBB);
10978   BuildMI(newMBB, dl, TII->get(X86::PHI), dest2Oper.getReg())
10979     .addReg(t2).addMBB(thisMBB).addReg(t4).addMBB(newMBB);
10980
10981   // The subsequent operations should be using the destination registers of
10982   //the PHI instructions.
10983   if (invSrc) {
10984     t1 = F->getRegInfo().createVirtualRegister(RC);
10985     t2 = F->getRegInfo().createVirtualRegister(RC);
10986     MIB = BuildMI(newMBB, dl, TII->get(NotOpc), t1).addReg(dest1Oper.getReg());
10987     MIB = BuildMI(newMBB, dl, TII->get(NotOpc), t2).addReg(dest2Oper.getReg());
10988   } else {
10989     t1 = dest1Oper.getReg();
10990     t2 = dest2Oper.getReg();
10991   }
10992
10993   int valArgIndx = lastAddrIndx + 1;
10994   assert((argOpers[valArgIndx]->isReg() ||
10995           argOpers[valArgIndx]->isImm()) &&
10996          "invalid operand");
10997   unsigned t5 = F->getRegInfo().createVirtualRegister(RC);
10998   unsigned t6 = F->getRegInfo().createVirtualRegister(RC);
10999   if (argOpers[valArgIndx]->isReg())
11000     MIB = BuildMI(newMBB, dl, TII->get(regOpcL), t5);
11001   else
11002     MIB = BuildMI(newMBB, dl, TII->get(immOpcL), t5);
11003   if (regOpcL != X86::MOV32rr)
11004     MIB.addReg(t1);
11005   (*MIB).addOperand(*argOpers[valArgIndx]);
11006   assert(argOpers[valArgIndx + 1]->isReg() ==
11007          argOpers[valArgIndx]->isReg());
11008   assert(argOpers[valArgIndx + 1]->isImm() ==
11009          argOpers[valArgIndx]->isImm());
11010   if (argOpers[valArgIndx + 1]->isReg())
11011     MIB = BuildMI(newMBB, dl, TII->get(regOpcH), t6);
11012   else
11013     MIB = BuildMI(newMBB, dl, TII->get(immOpcH), t6);
11014   if (regOpcH != X86::MOV32rr)
11015     MIB.addReg(t2);
11016   (*MIB).addOperand(*argOpers[valArgIndx + 1]);
11017
11018   MIB = BuildMI(newMBB, dl, TII->get(TargetOpcode::COPY), X86::EAX);
11019   MIB.addReg(t1);
11020   MIB = BuildMI(newMBB, dl, TII->get(TargetOpcode::COPY), X86::EDX);
11021   MIB.addReg(t2);
11022
11023   MIB = BuildMI(newMBB, dl, TII->get(TargetOpcode::COPY), X86::EBX);
11024   MIB.addReg(t5);
11025   MIB = BuildMI(newMBB, dl, TII->get(TargetOpcode::COPY), X86::ECX);
11026   MIB.addReg(t6);
11027
11028   MIB = BuildMI(newMBB, dl, TII->get(X86::LCMPXCHG8B));
11029   for (int i=0; i <= lastAddrIndx; ++i)
11030     (*MIB).addOperand(*argOpers[i]);
11031
11032   assert(bInstr->hasOneMemOperand() && "Unexpected number of memoperand");
11033   (*MIB).setMemRefs(bInstr->memoperands_begin(),
11034                     bInstr->memoperands_end());
11035
11036   MIB = BuildMI(newMBB, dl, TII->get(TargetOpcode::COPY), t3);
11037   MIB.addReg(X86::EAX);
11038   MIB = BuildMI(newMBB, dl, TII->get(TargetOpcode::COPY), t4);
11039   MIB.addReg(X86::EDX);
11040
11041   // insert branch
11042   BuildMI(newMBB, dl, TII->get(X86::JNE_4)).addMBB(newMBB);
11043
11044   bInstr->eraseFromParent();   // The pseudo instruction is gone now.
11045   return nextMBB;
11046 }
11047
11048 // private utility function
11049 MachineBasicBlock *
11050 X86TargetLowering::EmitAtomicMinMaxWithCustomInserter(MachineInstr *mInstr,
11051                                                       MachineBasicBlock *MBB,
11052                                                       unsigned cmovOpc) const {
11053   // For the atomic min/max operator, we generate
11054   //   thisMBB:
11055   //   newMBB:
11056   //     ld t1 = [min/max.addr]
11057   //     mov t2 = [min/max.val]
11058   //     cmp  t1, t2
11059   //     cmov[cond] t2 = t1
11060   //     mov EAX = t1
11061   //     lcs dest = [bitinstr.addr], t2  [EAX is implicit]
11062   //     bz   newMBB
11063   //     fallthrough -->nextMBB
11064   //
11065   const TargetInstrInfo *TII = getTargetMachine().getInstrInfo();
11066   const BasicBlock *LLVM_BB = MBB->getBasicBlock();
11067   MachineFunction::iterator MBBIter = MBB;
11068   ++MBBIter;
11069
11070   /// First build the CFG
11071   MachineFunction *F = MBB->getParent();
11072   MachineBasicBlock *thisMBB = MBB;
11073   MachineBasicBlock *newMBB = F->CreateMachineBasicBlock(LLVM_BB);
11074   MachineBasicBlock *nextMBB = F->CreateMachineBasicBlock(LLVM_BB);
11075   F->insert(MBBIter, newMBB);
11076   F->insert(MBBIter, nextMBB);
11077
11078   // Transfer the remainder of thisMBB and its successor edges to nextMBB.
11079   nextMBB->splice(nextMBB->begin(), thisMBB,
11080                   llvm::next(MachineBasicBlock::iterator(mInstr)),
11081                   thisMBB->end());
11082   nextMBB->transferSuccessorsAndUpdatePHIs(thisMBB);
11083
11084   // Update thisMBB to fall through to newMBB
11085   thisMBB->addSuccessor(newMBB);
11086
11087   // newMBB jumps to newMBB and fall through to nextMBB
11088   newMBB->addSuccessor(nextMBB);
11089   newMBB->addSuccessor(newMBB);
11090
11091   DebugLoc dl = mInstr->getDebugLoc();
11092   // Insert instructions into newMBB based on incoming instruction
11093   assert(mInstr->getNumOperands() < X86::AddrNumOperands + 4 &&
11094          "unexpected number of operands");
11095   MachineOperand& destOper = mInstr->getOperand(0);
11096   MachineOperand* argOpers[2 + X86::AddrNumOperands];
11097   int numArgs = mInstr->getNumOperands() - 1;
11098   for (int i=0; i < numArgs; ++i)
11099     argOpers[i] = &mInstr->getOperand(i+1);
11100
11101   // x86 address has 4 operands: base, index, scale, and displacement
11102   int lastAddrIndx = X86::AddrNumOperands - 1; // [0,3]
11103   int valArgIndx = lastAddrIndx + 1;
11104
11105   unsigned t1 = F->getRegInfo().createVirtualRegister(X86::GR32RegisterClass);
11106   MachineInstrBuilder MIB = BuildMI(newMBB, dl, TII->get(X86::MOV32rm), t1);
11107   for (int i=0; i <= lastAddrIndx; ++i)
11108     (*MIB).addOperand(*argOpers[i]);
11109
11110   // We only support register and immediate values
11111   assert((argOpers[valArgIndx]->isReg() ||
11112           argOpers[valArgIndx]->isImm()) &&
11113          "invalid operand");
11114
11115   unsigned t2 = F->getRegInfo().createVirtualRegister(X86::GR32RegisterClass);
11116   if (argOpers[valArgIndx]->isReg())
11117     MIB = BuildMI(newMBB, dl, TII->get(TargetOpcode::COPY), t2);
11118   else
11119     MIB = BuildMI(newMBB, dl, TII->get(X86::MOV32rr), t2);
11120   (*MIB).addOperand(*argOpers[valArgIndx]);
11121
11122   MIB = BuildMI(newMBB, dl, TII->get(TargetOpcode::COPY), X86::EAX);
11123   MIB.addReg(t1);
11124
11125   MIB = BuildMI(newMBB, dl, TII->get(X86::CMP32rr));
11126   MIB.addReg(t1);
11127   MIB.addReg(t2);
11128
11129   // Generate movc
11130   unsigned t3 = F->getRegInfo().createVirtualRegister(X86::GR32RegisterClass);
11131   MIB = BuildMI(newMBB, dl, TII->get(cmovOpc),t3);
11132   MIB.addReg(t2);
11133   MIB.addReg(t1);
11134
11135   // Cmp and exchange if none has modified the memory location
11136   MIB = BuildMI(newMBB, dl, TII->get(X86::LCMPXCHG32));
11137   for (int i=0; i <= lastAddrIndx; ++i)
11138     (*MIB).addOperand(*argOpers[i]);
11139   MIB.addReg(t3);
11140   assert(mInstr->hasOneMemOperand() && "Unexpected number of memoperand");
11141   (*MIB).setMemRefs(mInstr->memoperands_begin(),
11142                     mInstr->memoperands_end());
11143
11144   MIB = BuildMI(newMBB, dl, TII->get(TargetOpcode::COPY), destOper.getReg());
11145   MIB.addReg(X86::EAX);
11146
11147   // insert branch
11148   BuildMI(newMBB, dl, TII->get(X86::JNE_4)).addMBB(newMBB);
11149
11150   mInstr->eraseFromParent();   // The pseudo instruction is gone now.
11151   return nextMBB;
11152 }
11153
11154 // FIXME: When we get size specific XMM0 registers, i.e. XMM0_V16I8
11155 // or XMM0_V32I8 in AVX all of this code can be replaced with that
11156 // in the .td file.
11157 MachineBasicBlock *
11158 X86TargetLowering::EmitPCMP(MachineInstr *MI, MachineBasicBlock *BB,
11159                             unsigned numArgs, bool memArg) const {
11160   assert((Subtarget->hasSSE42() || Subtarget->hasAVX()) &&
11161          "Target must have SSE4.2 or AVX features enabled");
11162
11163   DebugLoc dl = MI->getDebugLoc();
11164   const TargetInstrInfo *TII = getTargetMachine().getInstrInfo();
11165   unsigned Opc;
11166   if (!Subtarget->hasAVX()) {
11167     if (memArg)
11168       Opc = numArgs == 3 ? X86::PCMPISTRM128rm : X86::PCMPESTRM128rm;
11169     else
11170       Opc = numArgs == 3 ? X86::PCMPISTRM128rr : X86::PCMPESTRM128rr;
11171   } else {
11172     if (memArg)
11173       Opc = numArgs == 3 ? X86::VPCMPISTRM128rm : X86::VPCMPESTRM128rm;
11174     else
11175       Opc = numArgs == 3 ? X86::VPCMPISTRM128rr : X86::VPCMPESTRM128rr;
11176   }
11177
11178   MachineInstrBuilder MIB = BuildMI(*BB, MI, dl, TII->get(Opc));
11179   for (unsigned i = 0; i < numArgs; ++i) {
11180     MachineOperand &Op = MI->getOperand(i+1);
11181     if (!(Op.isReg() && Op.isImplicit()))
11182       MIB.addOperand(Op);
11183   }
11184   BuildMI(*BB, MI, dl, TII->get(X86::MOVAPSrr), MI->getOperand(0).getReg())
11185     .addReg(X86::XMM0);
11186
11187   MI->eraseFromParent();
11188   return BB;
11189 }
11190
11191 MachineBasicBlock *
11192 X86TargetLowering::EmitMonitor(MachineInstr *MI, MachineBasicBlock *BB) const {
11193   DebugLoc dl = MI->getDebugLoc();
11194   const TargetInstrInfo *TII = getTargetMachine().getInstrInfo();
11195
11196   // Address into RAX/EAX, other two args into ECX, EDX.
11197   unsigned MemOpc = Subtarget->is64Bit() ? X86::LEA64r : X86::LEA32r;
11198   unsigned MemReg = Subtarget->is64Bit() ? X86::RAX : X86::EAX;
11199   MachineInstrBuilder MIB = BuildMI(*BB, MI, dl, TII->get(MemOpc), MemReg);
11200   for (int i = 0; i < X86::AddrNumOperands; ++i)
11201     MIB.addOperand(MI->getOperand(i));
11202
11203   unsigned ValOps = X86::AddrNumOperands;
11204   BuildMI(*BB, MI, dl, TII->get(TargetOpcode::COPY), X86::ECX)
11205     .addReg(MI->getOperand(ValOps).getReg());
11206   BuildMI(*BB, MI, dl, TII->get(TargetOpcode::COPY), X86::EDX)
11207     .addReg(MI->getOperand(ValOps+1).getReg());
11208
11209   // The instruction doesn't actually take any operands though.
11210   BuildMI(*BB, MI, dl, TII->get(X86::MONITORrrr));
11211
11212   MI->eraseFromParent(); // The pseudo is gone now.
11213   return BB;
11214 }
11215
11216 MachineBasicBlock *
11217 X86TargetLowering::EmitMwait(MachineInstr *MI, MachineBasicBlock *BB) const {
11218   DebugLoc dl = MI->getDebugLoc();
11219   const TargetInstrInfo *TII = getTargetMachine().getInstrInfo();
11220
11221   // First arg in ECX, the second in EAX.
11222   BuildMI(*BB, MI, dl, TII->get(TargetOpcode::COPY), X86::ECX)
11223     .addReg(MI->getOperand(0).getReg());
11224   BuildMI(*BB, MI, dl, TII->get(TargetOpcode::COPY), X86::EAX)
11225     .addReg(MI->getOperand(1).getReg());
11226
11227   // The instruction doesn't actually take any operands though.
11228   BuildMI(*BB, MI, dl, TII->get(X86::MWAITrr));
11229
11230   MI->eraseFromParent(); // The pseudo is gone now.
11231   return BB;
11232 }
11233
11234 MachineBasicBlock *
11235 X86TargetLowering::EmitVAARG64WithCustomInserter(
11236                    MachineInstr *MI,
11237                    MachineBasicBlock *MBB) const {
11238   // Emit va_arg instruction on X86-64.
11239
11240   // Operands to this pseudo-instruction:
11241   // 0  ) Output        : destination address (reg)
11242   // 1-5) Input         : va_list address (addr, i64mem)
11243   // 6  ) ArgSize       : Size (in bytes) of vararg type
11244   // 7  ) ArgMode       : 0=overflow only, 1=use gp_offset, 2=use fp_offset
11245   // 8  ) Align         : Alignment of type
11246   // 9  ) EFLAGS (implicit-def)
11247
11248   assert(MI->getNumOperands() == 10 && "VAARG_64 should have 10 operands!");
11249   assert(X86::AddrNumOperands == 5 && "VAARG_64 assumes 5 address operands");
11250
11251   unsigned DestReg = MI->getOperand(0).getReg();
11252   MachineOperand &Base = MI->getOperand(1);
11253   MachineOperand &Scale = MI->getOperand(2);
11254   MachineOperand &Index = MI->getOperand(3);
11255   MachineOperand &Disp = MI->getOperand(4);
11256   MachineOperand &Segment = MI->getOperand(5);
11257   unsigned ArgSize = MI->getOperand(6).getImm();
11258   unsigned ArgMode = MI->getOperand(7).getImm();
11259   unsigned Align = MI->getOperand(8).getImm();
11260
11261   // Memory Reference
11262   assert(MI->hasOneMemOperand() && "Expected VAARG_64 to have one memoperand");
11263   MachineInstr::mmo_iterator MMOBegin = MI->memoperands_begin();
11264   MachineInstr::mmo_iterator MMOEnd = MI->memoperands_end();
11265
11266   // Machine Information
11267   const TargetInstrInfo *TII = getTargetMachine().getInstrInfo();
11268   MachineRegisterInfo &MRI = MBB->getParent()->getRegInfo();
11269   const TargetRegisterClass *AddrRegClass = getRegClassFor(MVT::i64);
11270   const TargetRegisterClass *OffsetRegClass = getRegClassFor(MVT::i32);
11271   DebugLoc DL = MI->getDebugLoc();
11272
11273   // struct va_list {
11274   //   i32   gp_offset
11275   //   i32   fp_offset
11276   //   i64   overflow_area (address)
11277   //   i64   reg_save_area (address)
11278   // }
11279   // sizeof(va_list) = 24
11280   // alignment(va_list) = 8
11281
11282   unsigned TotalNumIntRegs = 6;
11283   unsigned TotalNumXMMRegs = 8;
11284   bool UseGPOffset = (ArgMode == 1);
11285   bool UseFPOffset = (ArgMode == 2);
11286   unsigned MaxOffset = TotalNumIntRegs * 8 +
11287                        (UseFPOffset ? TotalNumXMMRegs * 16 : 0);
11288
11289   /* Align ArgSize to a multiple of 8 */
11290   unsigned ArgSizeA8 = (ArgSize + 7) & ~7;
11291   bool NeedsAlign = (Align > 8);
11292
11293   MachineBasicBlock *thisMBB = MBB;
11294   MachineBasicBlock *overflowMBB;
11295   MachineBasicBlock *offsetMBB;
11296   MachineBasicBlock *endMBB;
11297
11298   unsigned OffsetDestReg = 0;    // Argument address computed by offsetMBB
11299   unsigned OverflowDestReg = 0;  // Argument address computed by overflowMBB
11300   unsigned OffsetReg = 0;
11301
11302   if (!UseGPOffset && !UseFPOffset) {
11303     // If we only pull from the overflow region, we don't create a branch.
11304     // We don't need to alter control flow.
11305     OffsetDestReg = 0; // unused
11306     OverflowDestReg = DestReg;
11307
11308     offsetMBB = NULL;
11309     overflowMBB = thisMBB;
11310     endMBB = thisMBB;
11311   } else {
11312     // First emit code to check if gp_offset (or fp_offset) is below the bound.
11313     // If so, pull the argument from reg_save_area. (branch to offsetMBB)
11314     // If not, pull from overflow_area. (branch to overflowMBB)
11315     //
11316     //       thisMBB
11317     //         |     .
11318     //         |        .
11319     //     offsetMBB   overflowMBB
11320     //         |        .
11321     //         |     .
11322     //        endMBB
11323
11324     // Registers for the PHI in endMBB
11325     OffsetDestReg = MRI.createVirtualRegister(AddrRegClass);
11326     OverflowDestReg = MRI.createVirtualRegister(AddrRegClass);
11327
11328     const BasicBlock *LLVM_BB = MBB->getBasicBlock();
11329     MachineFunction *MF = MBB->getParent();
11330     overflowMBB = MF->CreateMachineBasicBlock(LLVM_BB);
11331     offsetMBB = MF->CreateMachineBasicBlock(LLVM_BB);
11332     endMBB = MF->CreateMachineBasicBlock(LLVM_BB);
11333
11334     MachineFunction::iterator MBBIter = MBB;
11335     ++MBBIter;
11336
11337     // Insert the new basic blocks
11338     MF->insert(MBBIter, offsetMBB);
11339     MF->insert(MBBIter, overflowMBB);
11340     MF->insert(MBBIter, endMBB);
11341
11342     // Transfer the remainder of MBB and its successor edges to endMBB.
11343     endMBB->splice(endMBB->begin(), thisMBB,
11344                     llvm::next(MachineBasicBlock::iterator(MI)),
11345                     thisMBB->end());
11346     endMBB->transferSuccessorsAndUpdatePHIs(thisMBB);
11347
11348     // Make offsetMBB and overflowMBB successors of thisMBB
11349     thisMBB->addSuccessor(offsetMBB);
11350     thisMBB->addSuccessor(overflowMBB);
11351
11352     // endMBB is a successor of both offsetMBB and overflowMBB
11353     offsetMBB->addSuccessor(endMBB);
11354     overflowMBB->addSuccessor(endMBB);
11355
11356     // Load the offset value into a register
11357     OffsetReg = MRI.createVirtualRegister(OffsetRegClass);
11358     BuildMI(thisMBB, DL, TII->get(X86::MOV32rm), OffsetReg)
11359       .addOperand(Base)
11360       .addOperand(Scale)
11361       .addOperand(Index)
11362       .addDisp(Disp, UseFPOffset ? 4 : 0)
11363       .addOperand(Segment)
11364       .setMemRefs(MMOBegin, MMOEnd);
11365
11366     // Check if there is enough room left to pull this argument.
11367     BuildMI(thisMBB, DL, TII->get(X86::CMP32ri))
11368       .addReg(OffsetReg)
11369       .addImm(MaxOffset + 8 - ArgSizeA8);
11370
11371     // Branch to "overflowMBB" if offset >= max
11372     // Fall through to "offsetMBB" otherwise
11373     BuildMI(thisMBB, DL, TII->get(X86::GetCondBranchFromCond(X86::COND_AE)))
11374       .addMBB(overflowMBB);
11375   }
11376
11377   // In offsetMBB, emit code to use the reg_save_area.
11378   if (offsetMBB) {
11379     assert(OffsetReg != 0);
11380
11381     // Read the reg_save_area address.
11382     unsigned RegSaveReg = MRI.createVirtualRegister(AddrRegClass);
11383     BuildMI(offsetMBB, DL, TII->get(X86::MOV64rm), RegSaveReg)
11384       .addOperand(Base)
11385       .addOperand(Scale)
11386       .addOperand(Index)
11387       .addDisp(Disp, 16)
11388       .addOperand(Segment)
11389       .setMemRefs(MMOBegin, MMOEnd);
11390
11391     // Zero-extend the offset
11392     unsigned OffsetReg64 = MRI.createVirtualRegister(AddrRegClass);
11393       BuildMI(offsetMBB, DL, TII->get(X86::SUBREG_TO_REG), OffsetReg64)
11394         .addImm(0)
11395         .addReg(OffsetReg)
11396         .addImm(X86::sub_32bit);
11397
11398     // Add the offset to the reg_save_area to get the final address.
11399     BuildMI(offsetMBB, DL, TII->get(X86::ADD64rr), OffsetDestReg)
11400       .addReg(OffsetReg64)
11401       .addReg(RegSaveReg);
11402
11403     // Compute the offset for the next argument
11404     unsigned NextOffsetReg = MRI.createVirtualRegister(OffsetRegClass);
11405     BuildMI(offsetMBB, DL, TII->get(X86::ADD32ri), NextOffsetReg)
11406       .addReg(OffsetReg)
11407       .addImm(UseFPOffset ? 16 : 8);
11408
11409     // Store it back into the va_list.
11410     BuildMI(offsetMBB, DL, TII->get(X86::MOV32mr))
11411       .addOperand(Base)
11412       .addOperand(Scale)
11413       .addOperand(Index)
11414       .addDisp(Disp, UseFPOffset ? 4 : 0)
11415       .addOperand(Segment)
11416       .addReg(NextOffsetReg)
11417       .setMemRefs(MMOBegin, MMOEnd);
11418
11419     // Jump to endMBB
11420     BuildMI(offsetMBB, DL, TII->get(X86::JMP_4))
11421       .addMBB(endMBB);
11422   }
11423
11424   //
11425   // Emit code to use overflow area
11426   //
11427
11428   // Load the overflow_area address into a register.
11429   unsigned OverflowAddrReg = MRI.createVirtualRegister(AddrRegClass);
11430   BuildMI(overflowMBB, DL, TII->get(X86::MOV64rm), OverflowAddrReg)
11431     .addOperand(Base)
11432     .addOperand(Scale)
11433     .addOperand(Index)
11434     .addDisp(Disp, 8)
11435     .addOperand(Segment)
11436     .setMemRefs(MMOBegin, MMOEnd);
11437
11438   // If we need to align it, do so. Otherwise, just copy the address
11439   // to OverflowDestReg.
11440   if (NeedsAlign) {
11441     // Align the overflow address
11442     assert((Align & (Align-1)) == 0 && "Alignment must be a power of 2");
11443     unsigned TmpReg = MRI.createVirtualRegister(AddrRegClass);
11444
11445     // aligned_addr = (addr + (align-1)) & ~(align-1)
11446     BuildMI(overflowMBB, DL, TII->get(X86::ADD64ri32), TmpReg)
11447       .addReg(OverflowAddrReg)
11448       .addImm(Align-1);
11449
11450     BuildMI(overflowMBB, DL, TII->get(X86::AND64ri32), OverflowDestReg)
11451       .addReg(TmpReg)
11452       .addImm(~(uint64_t)(Align-1));
11453   } else {
11454     BuildMI(overflowMBB, DL, TII->get(TargetOpcode::COPY), OverflowDestReg)
11455       .addReg(OverflowAddrReg);
11456   }
11457
11458   // Compute the next overflow address after this argument.
11459   // (the overflow address should be kept 8-byte aligned)
11460   unsigned NextAddrReg = MRI.createVirtualRegister(AddrRegClass);
11461   BuildMI(overflowMBB, DL, TII->get(X86::ADD64ri32), NextAddrReg)
11462     .addReg(OverflowDestReg)
11463     .addImm(ArgSizeA8);
11464
11465   // Store the new overflow address.
11466   BuildMI(overflowMBB, DL, TII->get(X86::MOV64mr))
11467     .addOperand(Base)
11468     .addOperand(Scale)
11469     .addOperand(Index)
11470     .addDisp(Disp, 8)
11471     .addOperand(Segment)
11472     .addReg(NextAddrReg)
11473     .setMemRefs(MMOBegin, MMOEnd);
11474
11475   // If we branched, emit the PHI to the front of endMBB.
11476   if (offsetMBB) {
11477     BuildMI(*endMBB, endMBB->begin(), DL,
11478             TII->get(X86::PHI), DestReg)
11479       .addReg(OffsetDestReg).addMBB(offsetMBB)
11480       .addReg(OverflowDestReg).addMBB(overflowMBB);
11481   }
11482
11483   // Erase the pseudo instruction
11484   MI->eraseFromParent();
11485
11486   return endMBB;
11487 }
11488
11489 MachineBasicBlock *
11490 X86TargetLowering::EmitVAStartSaveXMMRegsWithCustomInserter(
11491                                                  MachineInstr *MI,
11492                                                  MachineBasicBlock *MBB) const {
11493   // Emit code to save XMM registers to the stack. The ABI says that the
11494   // number of registers to save is given in %al, so it's theoretically
11495   // possible to do an indirect jump trick to avoid saving all of them,
11496   // however this code takes a simpler approach and just executes all
11497   // of the stores if %al is non-zero. It's less code, and it's probably
11498   // easier on the hardware branch predictor, and stores aren't all that
11499   // expensive anyway.
11500
11501   // Create the new basic blocks. One block contains all the XMM stores,
11502   // and one block is the final destination regardless of whether any
11503   // stores were performed.
11504   const BasicBlock *LLVM_BB = MBB->getBasicBlock();
11505   MachineFunction *F = MBB->getParent();
11506   MachineFunction::iterator MBBIter = MBB;
11507   ++MBBIter;
11508   MachineBasicBlock *XMMSaveMBB = F->CreateMachineBasicBlock(LLVM_BB);
11509   MachineBasicBlock *EndMBB = F->CreateMachineBasicBlock(LLVM_BB);
11510   F->insert(MBBIter, XMMSaveMBB);
11511   F->insert(MBBIter, EndMBB);
11512
11513   // Transfer the remainder of MBB and its successor edges to EndMBB.
11514   EndMBB->splice(EndMBB->begin(), MBB,
11515                  llvm::next(MachineBasicBlock::iterator(MI)),
11516                  MBB->end());
11517   EndMBB->transferSuccessorsAndUpdatePHIs(MBB);
11518
11519   // The original block will now fall through to the XMM save block.
11520   MBB->addSuccessor(XMMSaveMBB);
11521   // The XMMSaveMBB will fall through to the end block.
11522   XMMSaveMBB->addSuccessor(EndMBB);
11523
11524   // Now add the instructions.
11525   const TargetInstrInfo *TII = getTargetMachine().getInstrInfo();
11526   DebugLoc DL = MI->getDebugLoc();
11527
11528   unsigned CountReg = MI->getOperand(0).getReg();
11529   int64_t RegSaveFrameIndex = MI->getOperand(1).getImm();
11530   int64_t VarArgsFPOffset = MI->getOperand(2).getImm();
11531
11532   if (!Subtarget->isTargetWin64()) {
11533     // If %al is 0, branch around the XMM save block.
11534     BuildMI(MBB, DL, TII->get(X86::TEST8rr)).addReg(CountReg).addReg(CountReg);
11535     BuildMI(MBB, DL, TII->get(X86::JE_4)).addMBB(EndMBB);
11536     MBB->addSuccessor(EndMBB);
11537   }
11538
11539   // In the XMM save block, save all the XMM argument registers.
11540   for (int i = 3, e = MI->getNumOperands(); i != e; ++i) {
11541     int64_t Offset = (i - 3) * 16 + VarArgsFPOffset;
11542     MachineMemOperand *MMO =
11543       F->getMachineMemOperand(
11544           MachinePointerInfo::getFixedStack(RegSaveFrameIndex, Offset),
11545         MachineMemOperand::MOStore,
11546         /*Size=*/16, /*Align=*/16);
11547     BuildMI(XMMSaveMBB, DL, TII->get(X86::MOVAPSmr))
11548       .addFrameIndex(RegSaveFrameIndex)
11549       .addImm(/*Scale=*/1)
11550       .addReg(/*IndexReg=*/0)
11551       .addImm(/*Disp=*/Offset)
11552       .addReg(/*Segment=*/0)
11553       .addReg(MI->getOperand(i).getReg())
11554       .addMemOperand(MMO);
11555   }
11556
11557   MI->eraseFromParent();   // The pseudo instruction is gone now.
11558
11559   return EndMBB;
11560 }
11561
11562 MachineBasicBlock *
11563 X86TargetLowering::EmitLoweredSelect(MachineInstr *MI,
11564                                      MachineBasicBlock *BB) const {
11565   const TargetInstrInfo *TII = getTargetMachine().getInstrInfo();
11566   DebugLoc DL = MI->getDebugLoc();
11567
11568   // To "insert" a SELECT_CC instruction, we actually have to insert the
11569   // diamond control-flow pattern.  The incoming instruction knows the
11570   // destination vreg to set, the condition code register to branch on, the
11571   // true/false values to select between, and a branch opcode to use.
11572   const BasicBlock *LLVM_BB = BB->getBasicBlock();
11573   MachineFunction::iterator It = BB;
11574   ++It;
11575
11576   //  thisMBB:
11577   //  ...
11578   //   TrueVal = ...
11579   //   cmpTY ccX, r1, r2
11580   //   bCC copy1MBB
11581   //   fallthrough --> copy0MBB
11582   MachineBasicBlock *thisMBB = BB;
11583   MachineFunction *F = BB->getParent();
11584   MachineBasicBlock *copy0MBB = F->CreateMachineBasicBlock(LLVM_BB);
11585   MachineBasicBlock *sinkMBB = F->CreateMachineBasicBlock(LLVM_BB);
11586   F->insert(It, copy0MBB);
11587   F->insert(It, sinkMBB);
11588
11589   // If the EFLAGS register isn't dead in the terminator, then claim that it's
11590   // live into the sink and copy blocks.
11591   const MachineFunction *MF = BB->getParent();
11592   const TargetRegisterInfo *TRI = MF->getTarget().getRegisterInfo();
11593   BitVector ReservedRegs = TRI->getReservedRegs(*MF);
11594
11595   for (unsigned I = 0, E = MI->getNumOperands(); I != E; ++I) {
11596     const MachineOperand &MO = MI->getOperand(I);
11597     if (!MO.isReg() || !MO.isUse() || MO.isKill()) continue;
11598     unsigned Reg = MO.getReg();
11599     if (Reg != X86::EFLAGS) continue;
11600     copy0MBB->addLiveIn(Reg);
11601     sinkMBB->addLiveIn(Reg);
11602   }
11603
11604   // Transfer the remainder of BB and its successor edges to sinkMBB.
11605   sinkMBB->splice(sinkMBB->begin(), BB,
11606                   llvm::next(MachineBasicBlock::iterator(MI)),
11607                   BB->end());
11608   sinkMBB->transferSuccessorsAndUpdatePHIs(BB);
11609
11610   // Add the true and fallthrough blocks as its successors.
11611   BB->addSuccessor(copy0MBB);
11612   BB->addSuccessor(sinkMBB);
11613
11614   // Create the conditional branch instruction.
11615   unsigned Opc =
11616     X86::GetCondBranchFromCond((X86::CondCode)MI->getOperand(3).getImm());
11617   BuildMI(BB, DL, TII->get(Opc)).addMBB(sinkMBB);
11618
11619   //  copy0MBB:
11620   //   %FalseValue = ...
11621   //   # fallthrough to sinkMBB
11622   copy0MBB->addSuccessor(sinkMBB);
11623
11624   //  sinkMBB:
11625   //   %Result = phi [ %FalseValue, copy0MBB ], [ %TrueValue, thisMBB ]
11626   //  ...
11627   BuildMI(*sinkMBB, sinkMBB->begin(), DL,
11628           TII->get(X86::PHI), MI->getOperand(0).getReg())
11629     .addReg(MI->getOperand(1).getReg()).addMBB(copy0MBB)
11630     .addReg(MI->getOperand(2).getReg()).addMBB(thisMBB);
11631
11632   MI->eraseFromParent();   // The pseudo instruction is gone now.
11633   return sinkMBB;
11634 }
11635
11636 MachineBasicBlock *
11637 X86TargetLowering::EmitLoweredWinAlloca(MachineInstr *MI,
11638                                           MachineBasicBlock *BB) const {
11639   const TargetInstrInfo *TII = getTargetMachine().getInstrInfo();
11640   DebugLoc DL = MI->getDebugLoc();
11641
11642   assert(!Subtarget->isTargetEnvMacho());
11643
11644   // The lowering is pretty easy: we're just emitting the call to _alloca.  The
11645   // non-trivial part is impdef of ESP.
11646
11647   if (Subtarget->isTargetWin64()) {
11648     if (Subtarget->isTargetCygMing()) {
11649       // ___chkstk(Mingw64):
11650       // Clobbers R10, R11, RAX and EFLAGS.
11651       // Updates RSP.
11652       BuildMI(*BB, MI, DL, TII->get(X86::W64ALLOCA))
11653         .addExternalSymbol("___chkstk")
11654         .addReg(X86::RAX, RegState::Implicit)
11655         .addReg(X86::RSP, RegState::Implicit)
11656         .addReg(X86::RAX, RegState::Define | RegState::Implicit)
11657         .addReg(X86::RSP, RegState::Define | RegState::Implicit)
11658         .addReg(X86::EFLAGS, RegState::Define | RegState::Implicit);
11659     } else {
11660       // __chkstk(MSVCRT): does not update stack pointer.
11661       // Clobbers R10, R11 and EFLAGS.
11662       // FIXME: RAX(allocated size) might be reused and not killed.
11663       BuildMI(*BB, MI, DL, TII->get(X86::W64ALLOCA))
11664         .addExternalSymbol("__chkstk")
11665         .addReg(X86::RAX, RegState::Implicit)
11666         .addReg(X86::EFLAGS, RegState::Define | RegState::Implicit);
11667       // RAX has the offset to subtracted from RSP.
11668       BuildMI(*BB, MI, DL, TII->get(X86::SUB64rr), X86::RSP)
11669         .addReg(X86::RSP)
11670         .addReg(X86::RAX);
11671     }
11672   } else {
11673     const char *StackProbeSymbol =
11674       Subtarget->isTargetWindows() ? "_chkstk" : "_alloca";
11675
11676     BuildMI(*BB, MI, DL, TII->get(X86::CALLpcrel32))
11677       .addExternalSymbol(StackProbeSymbol)
11678       .addReg(X86::EAX, RegState::Implicit)
11679       .addReg(X86::ESP, RegState::Implicit)
11680       .addReg(X86::EAX, RegState::Define | RegState::Implicit)
11681       .addReg(X86::ESP, RegState::Define | RegState::Implicit)
11682       .addReg(X86::EFLAGS, RegState::Define | RegState::Implicit);
11683   }
11684
11685   MI->eraseFromParent();   // The pseudo instruction is gone now.
11686   return BB;
11687 }
11688
11689 MachineBasicBlock *
11690 X86TargetLowering::EmitLoweredTLSCall(MachineInstr *MI,
11691                                       MachineBasicBlock *BB) const {
11692   // This is pretty easy.  We're taking the value that we received from
11693   // our load from the relocation, sticking it in either RDI (x86-64)
11694   // or EAX and doing an indirect call.  The return value will then
11695   // be in the normal return register.
11696   const X86InstrInfo *TII
11697     = static_cast<const X86InstrInfo*>(getTargetMachine().getInstrInfo());
11698   DebugLoc DL = MI->getDebugLoc();
11699   MachineFunction *F = BB->getParent();
11700
11701   assert(Subtarget->isTargetDarwin() && "Darwin only instr emitted?");
11702   assert(MI->getOperand(3).isGlobal() && "This should be a global");
11703
11704   if (Subtarget->is64Bit()) {
11705     MachineInstrBuilder MIB = BuildMI(*BB, MI, DL,
11706                                       TII->get(X86::MOV64rm), X86::RDI)
11707     .addReg(X86::RIP)
11708     .addImm(0).addReg(0)
11709     .addGlobalAddress(MI->getOperand(3).getGlobal(), 0,
11710                       MI->getOperand(3).getTargetFlags())
11711     .addReg(0);
11712     MIB = BuildMI(*BB, MI, DL, TII->get(X86::CALL64m));
11713     addDirectMem(MIB, X86::RDI);
11714   } else if (getTargetMachine().getRelocationModel() != Reloc::PIC_) {
11715     MachineInstrBuilder MIB = BuildMI(*BB, MI, DL,
11716                                       TII->get(X86::MOV32rm), X86::EAX)
11717     .addReg(0)
11718     .addImm(0).addReg(0)
11719     .addGlobalAddress(MI->getOperand(3).getGlobal(), 0,
11720                       MI->getOperand(3).getTargetFlags())
11721     .addReg(0);
11722     MIB = BuildMI(*BB, MI, DL, TII->get(X86::CALL32m));
11723     addDirectMem(MIB, X86::EAX);
11724   } else {
11725     MachineInstrBuilder MIB = BuildMI(*BB, MI, DL,
11726                                       TII->get(X86::MOV32rm), X86::EAX)
11727     .addReg(TII->getGlobalBaseReg(F))
11728     .addImm(0).addReg(0)
11729     .addGlobalAddress(MI->getOperand(3).getGlobal(), 0,
11730                       MI->getOperand(3).getTargetFlags())
11731     .addReg(0);
11732     MIB = BuildMI(*BB, MI, DL, TII->get(X86::CALL32m));
11733     addDirectMem(MIB, X86::EAX);
11734   }
11735
11736   MI->eraseFromParent(); // The pseudo instruction is gone now.
11737   return BB;
11738 }
11739
11740 MachineBasicBlock *
11741 X86TargetLowering::EmitInstrWithCustomInserter(MachineInstr *MI,
11742                                                MachineBasicBlock *BB) const {
11743   switch (MI->getOpcode()) {
11744   default: assert(false && "Unexpected instr type to insert");
11745   case X86::TAILJMPd64:
11746   case X86::TAILJMPr64:
11747   case X86::TAILJMPm64:
11748     assert(!"TAILJMP64 would not be touched here.");
11749   case X86::TCRETURNdi64:
11750   case X86::TCRETURNri64:
11751   case X86::TCRETURNmi64:
11752     // Defs of TCRETURNxx64 has Win64's callee-saved registers, as subset.
11753     // On AMD64, additional defs should be added before register allocation.
11754     if (!Subtarget->isTargetWin64()) {
11755       MI->addRegisterDefined(X86::RSI);
11756       MI->addRegisterDefined(X86::RDI);
11757       MI->addRegisterDefined(X86::XMM6);
11758       MI->addRegisterDefined(X86::XMM7);
11759       MI->addRegisterDefined(X86::XMM8);
11760       MI->addRegisterDefined(X86::XMM9);
11761       MI->addRegisterDefined(X86::XMM10);
11762       MI->addRegisterDefined(X86::XMM11);
11763       MI->addRegisterDefined(X86::XMM12);
11764       MI->addRegisterDefined(X86::XMM13);
11765       MI->addRegisterDefined(X86::XMM14);
11766       MI->addRegisterDefined(X86::XMM15);
11767     }
11768     return BB;
11769   case X86::WIN_ALLOCA:
11770     return EmitLoweredWinAlloca(MI, BB);
11771   case X86::TLSCall_32:
11772   case X86::TLSCall_64:
11773     return EmitLoweredTLSCall(MI, BB);
11774   case X86::CMOV_GR8:
11775   case X86::CMOV_FR32:
11776   case X86::CMOV_FR64:
11777   case X86::CMOV_V4F32:
11778   case X86::CMOV_V2F64:
11779   case X86::CMOV_V2I64:
11780   case X86::CMOV_V8F32:
11781   case X86::CMOV_V4F64:
11782   case X86::CMOV_V4I64:
11783   case X86::CMOV_GR16:
11784   case X86::CMOV_GR32:
11785   case X86::CMOV_RFP32:
11786   case X86::CMOV_RFP64:
11787   case X86::CMOV_RFP80:
11788     return EmitLoweredSelect(MI, BB);
11789
11790   case X86::FP32_TO_INT16_IN_MEM:
11791   case X86::FP32_TO_INT32_IN_MEM:
11792   case X86::FP32_TO_INT64_IN_MEM:
11793   case X86::FP64_TO_INT16_IN_MEM:
11794   case X86::FP64_TO_INT32_IN_MEM:
11795   case X86::FP64_TO_INT64_IN_MEM:
11796   case X86::FP80_TO_INT16_IN_MEM:
11797   case X86::FP80_TO_INT32_IN_MEM:
11798   case X86::FP80_TO_INT64_IN_MEM: {
11799     const TargetInstrInfo *TII = getTargetMachine().getInstrInfo();
11800     DebugLoc DL = MI->getDebugLoc();
11801
11802     // Change the floating point control register to use "round towards zero"
11803     // mode when truncating to an integer value.
11804     MachineFunction *F = BB->getParent();
11805     int CWFrameIdx = F->getFrameInfo()->CreateStackObject(2, 2, false);
11806     addFrameReference(BuildMI(*BB, MI, DL,
11807                               TII->get(X86::FNSTCW16m)), CWFrameIdx);
11808
11809     // Load the old value of the high byte of the control word...
11810     unsigned OldCW =
11811       F->getRegInfo().createVirtualRegister(X86::GR16RegisterClass);
11812     addFrameReference(BuildMI(*BB, MI, DL, TII->get(X86::MOV16rm), OldCW),
11813                       CWFrameIdx);
11814
11815     // Set the high part to be round to zero...
11816     addFrameReference(BuildMI(*BB, MI, DL, TII->get(X86::MOV16mi)), CWFrameIdx)
11817       .addImm(0xC7F);
11818
11819     // Reload the modified control word now...
11820     addFrameReference(BuildMI(*BB, MI, DL,
11821                               TII->get(X86::FLDCW16m)), CWFrameIdx);
11822
11823     // Restore the memory image of control word to original value
11824     addFrameReference(BuildMI(*BB, MI, DL, TII->get(X86::MOV16mr)), CWFrameIdx)
11825       .addReg(OldCW);
11826
11827     // Get the X86 opcode to use.
11828     unsigned Opc;
11829     switch (MI->getOpcode()) {
11830     default: llvm_unreachable("illegal opcode!");
11831     case X86::FP32_TO_INT16_IN_MEM: Opc = X86::IST_Fp16m32; break;
11832     case X86::FP32_TO_INT32_IN_MEM: Opc = X86::IST_Fp32m32; break;
11833     case X86::FP32_TO_INT64_IN_MEM: Opc = X86::IST_Fp64m32; break;
11834     case X86::FP64_TO_INT16_IN_MEM: Opc = X86::IST_Fp16m64; break;
11835     case X86::FP64_TO_INT32_IN_MEM: Opc = X86::IST_Fp32m64; break;
11836     case X86::FP64_TO_INT64_IN_MEM: Opc = X86::IST_Fp64m64; break;
11837     case X86::FP80_TO_INT16_IN_MEM: Opc = X86::IST_Fp16m80; break;
11838     case X86::FP80_TO_INT32_IN_MEM: Opc = X86::IST_Fp32m80; break;
11839     case X86::FP80_TO_INT64_IN_MEM: Opc = X86::IST_Fp64m80; break;
11840     }
11841
11842     X86AddressMode AM;
11843     MachineOperand &Op = MI->getOperand(0);
11844     if (Op.isReg()) {
11845       AM.BaseType = X86AddressMode::RegBase;
11846       AM.Base.Reg = Op.getReg();
11847     } else {
11848       AM.BaseType = X86AddressMode::FrameIndexBase;
11849       AM.Base.FrameIndex = Op.getIndex();
11850     }
11851     Op = MI->getOperand(1);
11852     if (Op.isImm())
11853       AM.Scale = Op.getImm();
11854     Op = MI->getOperand(2);
11855     if (Op.isImm())
11856       AM.IndexReg = Op.getImm();
11857     Op = MI->getOperand(3);
11858     if (Op.isGlobal()) {
11859       AM.GV = Op.getGlobal();
11860     } else {
11861       AM.Disp = Op.getImm();
11862     }
11863     addFullAddress(BuildMI(*BB, MI, DL, TII->get(Opc)), AM)
11864                       .addReg(MI->getOperand(X86::AddrNumOperands).getReg());
11865
11866     // Reload the original control word now.
11867     addFrameReference(BuildMI(*BB, MI, DL,
11868                               TII->get(X86::FLDCW16m)), CWFrameIdx);
11869
11870     MI->eraseFromParent();   // The pseudo instruction is gone now.
11871     return BB;
11872   }
11873     // String/text processing lowering.
11874   case X86::PCMPISTRM128REG:
11875   case X86::VPCMPISTRM128REG:
11876     return EmitPCMP(MI, BB, 3, false /* in-mem */);
11877   case X86::PCMPISTRM128MEM:
11878   case X86::VPCMPISTRM128MEM:
11879     return EmitPCMP(MI, BB, 3, true /* in-mem */);
11880   case X86::PCMPESTRM128REG:
11881   case X86::VPCMPESTRM128REG:
11882     return EmitPCMP(MI, BB, 5, false /* in mem */);
11883   case X86::PCMPESTRM128MEM:
11884   case X86::VPCMPESTRM128MEM:
11885     return EmitPCMP(MI, BB, 5, true /* in mem */);
11886
11887     // Thread synchronization.
11888   case X86::MONITOR:
11889     return EmitMonitor(MI, BB);
11890   case X86::MWAIT:
11891     return EmitMwait(MI, BB);
11892
11893     // Atomic Lowering.
11894   case X86::ATOMAND32:
11895     return EmitAtomicBitwiseWithCustomInserter(MI, BB, X86::AND32rr,
11896                                                X86::AND32ri, X86::MOV32rm,
11897                                                X86::LCMPXCHG32,
11898                                                X86::NOT32r, X86::EAX,
11899                                                X86::GR32RegisterClass);
11900   case X86::ATOMOR32:
11901     return EmitAtomicBitwiseWithCustomInserter(MI, BB, X86::OR32rr,
11902                                                X86::OR32ri, X86::MOV32rm,
11903                                                X86::LCMPXCHG32,
11904                                                X86::NOT32r, X86::EAX,
11905                                                X86::GR32RegisterClass);
11906   case X86::ATOMXOR32:
11907     return EmitAtomicBitwiseWithCustomInserter(MI, BB, X86::XOR32rr,
11908                                                X86::XOR32ri, X86::MOV32rm,
11909                                                X86::LCMPXCHG32,
11910                                                X86::NOT32r, X86::EAX,
11911                                                X86::GR32RegisterClass);
11912   case X86::ATOMNAND32:
11913     return EmitAtomicBitwiseWithCustomInserter(MI, BB, X86::AND32rr,
11914                                                X86::AND32ri, X86::MOV32rm,
11915                                                X86::LCMPXCHG32,
11916                                                X86::NOT32r, X86::EAX,
11917                                                X86::GR32RegisterClass, true);
11918   case X86::ATOMMIN32:
11919     return EmitAtomicMinMaxWithCustomInserter(MI, BB, X86::CMOVL32rr);
11920   case X86::ATOMMAX32:
11921     return EmitAtomicMinMaxWithCustomInserter(MI, BB, X86::CMOVG32rr);
11922   case X86::ATOMUMIN32:
11923     return EmitAtomicMinMaxWithCustomInserter(MI, BB, X86::CMOVB32rr);
11924   case X86::ATOMUMAX32:
11925     return EmitAtomicMinMaxWithCustomInserter(MI, BB, X86::CMOVA32rr);
11926
11927   case X86::ATOMAND16:
11928     return EmitAtomicBitwiseWithCustomInserter(MI, BB, X86::AND16rr,
11929                                                X86::AND16ri, X86::MOV16rm,
11930                                                X86::LCMPXCHG16,
11931                                                X86::NOT16r, X86::AX,
11932                                                X86::GR16RegisterClass);
11933   case X86::ATOMOR16:
11934     return EmitAtomicBitwiseWithCustomInserter(MI, BB, X86::OR16rr,
11935                                                X86::OR16ri, X86::MOV16rm,
11936                                                X86::LCMPXCHG16,
11937                                                X86::NOT16r, X86::AX,
11938                                                X86::GR16RegisterClass);
11939   case X86::ATOMXOR16:
11940     return EmitAtomicBitwiseWithCustomInserter(MI, BB, X86::XOR16rr,
11941                                                X86::XOR16ri, X86::MOV16rm,
11942                                                X86::LCMPXCHG16,
11943                                                X86::NOT16r, X86::AX,
11944                                                X86::GR16RegisterClass);
11945   case X86::ATOMNAND16:
11946     return EmitAtomicBitwiseWithCustomInserter(MI, BB, X86::AND16rr,
11947                                                X86::AND16ri, X86::MOV16rm,
11948                                                X86::LCMPXCHG16,
11949                                                X86::NOT16r, X86::AX,
11950                                                X86::GR16RegisterClass, true);
11951   case X86::ATOMMIN16:
11952     return EmitAtomicMinMaxWithCustomInserter(MI, BB, X86::CMOVL16rr);
11953   case X86::ATOMMAX16:
11954     return EmitAtomicMinMaxWithCustomInserter(MI, BB, X86::CMOVG16rr);
11955   case X86::ATOMUMIN16:
11956     return EmitAtomicMinMaxWithCustomInserter(MI, BB, X86::CMOVB16rr);
11957   case X86::ATOMUMAX16:
11958     return EmitAtomicMinMaxWithCustomInserter(MI, BB, X86::CMOVA16rr);
11959
11960   case X86::ATOMAND8:
11961     return EmitAtomicBitwiseWithCustomInserter(MI, BB, X86::AND8rr,
11962                                                X86::AND8ri, X86::MOV8rm,
11963                                                X86::LCMPXCHG8,
11964                                                X86::NOT8r, X86::AL,
11965                                                X86::GR8RegisterClass);
11966   case X86::ATOMOR8:
11967     return EmitAtomicBitwiseWithCustomInserter(MI, BB, X86::OR8rr,
11968                                                X86::OR8ri, X86::MOV8rm,
11969                                                X86::LCMPXCHG8,
11970                                                X86::NOT8r, X86::AL,
11971                                                X86::GR8RegisterClass);
11972   case X86::ATOMXOR8:
11973     return EmitAtomicBitwiseWithCustomInserter(MI, BB, X86::XOR8rr,
11974                                                X86::XOR8ri, X86::MOV8rm,
11975                                                X86::LCMPXCHG8,
11976                                                X86::NOT8r, X86::AL,
11977                                                X86::GR8RegisterClass);
11978   case X86::ATOMNAND8:
11979     return EmitAtomicBitwiseWithCustomInserter(MI, BB, X86::AND8rr,
11980                                                X86::AND8ri, X86::MOV8rm,
11981                                                X86::LCMPXCHG8,
11982                                                X86::NOT8r, X86::AL,
11983                                                X86::GR8RegisterClass, true);
11984   // FIXME: There are no CMOV8 instructions; MIN/MAX need some other way.
11985   // This group is for 64-bit host.
11986   case X86::ATOMAND64:
11987     return EmitAtomicBitwiseWithCustomInserter(MI, BB, X86::AND64rr,
11988                                                X86::AND64ri32, X86::MOV64rm,
11989                                                X86::LCMPXCHG64,
11990                                                X86::NOT64r, X86::RAX,
11991                                                X86::GR64RegisterClass);
11992   case X86::ATOMOR64:
11993     return EmitAtomicBitwiseWithCustomInserter(MI, BB, X86::OR64rr,
11994                                                X86::OR64ri32, X86::MOV64rm,
11995                                                X86::LCMPXCHG64,
11996                                                X86::NOT64r, X86::RAX,
11997                                                X86::GR64RegisterClass);
11998   case X86::ATOMXOR64:
11999     return EmitAtomicBitwiseWithCustomInserter(MI, BB, X86::XOR64rr,
12000                                                X86::XOR64ri32, X86::MOV64rm,
12001                                                X86::LCMPXCHG64,
12002                                                X86::NOT64r, X86::RAX,
12003                                                X86::GR64RegisterClass);
12004   case X86::ATOMNAND64:
12005     return EmitAtomicBitwiseWithCustomInserter(MI, BB, X86::AND64rr,
12006                                                X86::AND64ri32, X86::MOV64rm,
12007                                                X86::LCMPXCHG64,
12008                                                X86::NOT64r, X86::RAX,
12009                                                X86::GR64RegisterClass, true);
12010   case X86::ATOMMIN64:
12011     return EmitAtomicMinMaxWithCustomInserter(MI, BB, X86::CMOVL64rr);
12012   case X86::ATOMMAX64:
12013     return EmitAtomicMinMaxWithCustomInserter(MI, BB, X86::CMOVG64rr);
12014   case X86::ATOMUMIN64:
12015     return EmitAtomicMinMaxWithCustomInserter(MI, BB, X86::CMOVB64rr);
12016   case X86::ATOMUMAX64:
12017     return EmitAtomicMinMaxWithCustomInserter(MI, BB, X86::CMOVA64rr);
12018
12019   // This group does 64-bit operations on a 32-bit host.
12020   case X86::ATOMAND6432:
12021     return EmitAtomicBit6432WithCustomInserter(MI, BB,
12022                                                X86::AND32rr, X86::AND32rr,
12023                                                X86::AND32ri, X86::AND32ri,
12024                                                false);
12025   case X86::ATOMOR6432:
12026     return EmitAtomicBit6432WithCustomInserter(MI, BB,
12027                                                X86::OR32rr, X86::OR32rr,
12028                                                X86::OR32ri, X86::OR32ri,
12029                                                false);
12030   case X86::ATOMXOR6432:
12031     return EmitAtomicBit6432WithCustomInserter(MI, BB,
12032                                                X86::XOR32rr, X86::XOR32rr,
12033                                                X86::XOR32ri, X86::XOR32ri,
12034                                                false);
12035   case X86::ATOMNAND6432:
12036     return EmitAtomicBit6432WithCustomInserter(MI, BB,
12037                                                X86::AND32rr, X86::AND32rr,
12038                                                X86::AND32ri, X86::AND32ri,
12039                                                true);
12040   case X86::ATOMADD6432:
12041     return EmitAtomicBit6432WithCustomInserter(MI, BB,
12042                                                X86::ADD32rr, X86::ADC32rr,
12043                                                X86::ADD32ri, X86::ADC32ri,
12044                                                false);
12045   case X86::ATOMSUB6432:
12046     return EmitAtomicBit6432WithCustomInserter(MI, BB,
12047                                                X86::SUB32rr, X86::SBB32rr,
12048                                                X86::SUB32ri, X86::SBB32ri,
12049                                                false);
12050   case X86::ATOMSWAP6432:
12051     return EmitAtomicBit6432WithCustomInserter(MI, BB,
12052                                                X86::MOV32rr, X86::MOV32rr,
12053                                                X86::MOV32ri, X86::MOV32ri,
12054                                                false);
12055   case X86::VASTART_SAVE_XMM_REGS:
12056     return EmitVAStartSaveXMMRegsWithCustomInserter(MI, BB);
12057
12058   case X86::VAARG_64:
12059     return EmitVAARG64WithCustomInserter(MI, BB);
12060   }
12061 }
12062
12063 //===----------------------------------------------------------------------===//
12064 //                           X86 Optimization Hooks
12065 //===----------------------------------------------------------------------===//
12066
12067 void X86TargetLowering::computeMaskedBitsForTargetNode(const SDValue Op,
12068                                                        const APInt &Mask,
12069                                                        APInt &KnownZero,
12070                                                        APInt &KnownOne,
12071                                                        const SelectionDAG &DAG,
12072                                                        unsigned Depth) const {
12073   unsigned Opc = Op.getOpcode();
12074   assert((Opc >= ISD::BUILTIN_OP_END ||
12075           Opc == ISD::INTRINSIC_WO_CHAIN ||
12076           Opc == ISD::INTRINSIC_W_CHAIN ||
12077           Opc == ISD::INTRINSIC_VOID) &&
12078          "Should use MaskedValueIsZero if you don't know whether Op"
12079          " is a target node!");
12080
12081   KnownZero = KnownOne = APInt(Mask.getBitWidth(), 0);   // Don't know anything.
12082   switch (Opc) {
12083   default: break;
12084   case X86ISD::ADD:
12085   case X86ISD::SUB:
12086   case X86ISD::ADC:
12087   case X86ISD::SBB:
12088   case X86ISD::SMUL:
12089   case X86ISD::UMUL:
12090   case X86ISD::INC:
12091   case X86ISD::DEC:
12092   case X86ISD::OR:
12093   case X86ISD::XOR:
12094   case X86ISD::AND:
12095     // These nodes' second result is a boolean.
12096     if (Op.getResNo() == 0)
12097       break;
12098     // Fallthrough
12099   case X86ISD::SETCC:
12100     KnownZero |= APInt::getHighBitsSet(Mask.getBitWidth(),
12101                                        Mask.getBitWidth() - 1);
12102     break;
12103   }
12104 }
12105
12106 unsigned X86TargetLowering::ComputeNumSignBitsForTargetNode(SDValue Op,
12107                                                          unsigned Depth) const {
12108   // SETCC_CARRY sets the dest to ~0 for true or 0 for false.
12109   if (Op.getOpcode() == X86ISD::SETCC_CARRY)
12110     return Op.getValueType().getScalarType().getSizeInBits();
12111
12112   // Fallback case.
12113   return 1;
12114 }
12115
12116 /// isGAPlusOffset - Returns true (and the GlobalValue and the offset) if the
12117 /// node is a GlobalAddress + offset.
12118 bool X86TargetLowering::isGAPlusOffset(SDNode *N,
12119                                        const GlobalValue* &GA,
12120                                        int64_t &Offset) const {
12121   if (N->getOpcode() == X86ISD::Wrapper) {
12122     if (isa<GlobalAddressSDNode>(N->getOperand(0))) {
12123       GA = cast<GlobalAddressSDNode>(N->getOperand(0))->getGlobal();
12124       Offset = cast<GlobalAddressSDNode>(N->getOperand(0))->getOffset();
12125       return true;
12126     }
12127   }
12128   return TargetLowering::isGAPlusOffset(N, GA, Offset);
12129 }
12130
12131 /// isShuffleHigh128VectorInsertLow - Checks whether the shuffle node is the
12132 /// same as extracting the high 128-bit part of 256-bit vector and then
12133 /// inserting the result into the low part of a new 256-bit vector
12134 static bool isShuffleHigh128VectorInsertLow(ShuffleVectorSDNode *SVOp) {
12135   EVT VT = SVOp->getValueType(0);
12136   int NumElems = VT.getVectorNumElements();
12137
12138   // vector_shuffle <4, 5, 6, 7, u, u, u, u> or <2, 3, u, u>
12139   for (int i = 0, j = NumElems/2; i < NumElems/2; ++i, ++j)
12140     if (!isUndefOrEqual(SVOp->getMaskElt(i), j) ||
12141         SVOp->getMaskElt(j) >= 0)
12142       return false;
12143
12144   return true;
12145 }
12146
12147 /// isShuffleLow128VectorInsertHigh - Checks whether the shuffle node is the
12148 /// same as extracting the low 128-bit part of 256-bit vector and then
12149 /// inserting the result into the high part of a new 256-bit vector
12150 static bool isShuffleLow128VectorInsertHigh(ShuffleVectorSDNode *SVOp) {
12151   EVT VT = SVOp->getValueType(0);
12152   int NumElems = VT.getVectorNumElements();
12153
12154   // vector_shuffle <u, u, u, u, 0, 1, 2, 3> or <u, u, 0, 1>
12155   for (int i = NumElems/2, j = 0; i < NumElems; ++i, ++j)
12156     if (!isUndefOrEqual(SVOp->getMaskElt(i), j) ||
12157         SVOp->getMaskElt(j) >= 0)
12158       return false;
12159
12160   return true;
12161 }
12162
12163 /// PerformShuffleCombine256 - Performs shuffle combines for 256-bit vectors.
12164 static SDValue PerformShuffleCombine256(SDNode *N, SelectionDAG &DAG,
12165                                         TargetLowering::DAGCombinerInfo &DCI) {
12166   DebugLoc dl = N->getDebugLoc();
12167   ShuffleVectorSDNode *SVOp = cast<ShuffleVectorSDNode>(N);
12168   SDValue V1 = SVOp->getOperand(0);
12169   SDValue V2 = SVOp->getOperand(1);
12170   EVT VT = SVOp->getValueType(0);
12171   int NumElems = VT.getVectorNumElements();
12172
12173   if (V1.getOpcode() == ISD::CONCAT_VECTORS &&
12174       V2.getOpcode() == ISD::CONCAT_VECTORS) {
12175     //
12176     //                   0,0,0,...
12177     //                      |
12178     //    V      UNDEF    BUILD_VECTOR    UNDEF
12179     //     \      /           \           /
12180     //  CONCAT_VECTOR         CONCAT_VECTOR
12181     //         \                  /
12182     //          \                /
12183     //          RESULT: V + zero extended
12184     //
12185     if (V2.getOperand(0).getOpcode() != ISD::BUILD_VECTOR ||
12186         V2.getOperand(1).getOpcode() != ISD::UNDEF ||
12187         V1.getOperand(1).getOpcode() != ISD::UNDEF)
12188       return SDValue();
12189
12190     if (!ISD::isBuildVectorAllZeros(V2.getOperand(0).getNode()))
12191       return SDValue();
12192
12193     // To match the shuffle mask, the first half of the mask should
12194     // be exactly the first vector, and all the rest a splat with the
12195     // first element of the second one.
12196     for (int i = 0; i < NumElems/2; ++i)
12197       if (!isUndefOrEqual(SVOp->getMaskElt(i), i) ||
12198           !isUndefOrEqual(SVOp->getMaskElt(i+NumElems/2), NumElems))
12199         return SDValue();
12200
12201     // Emit a zeroed vector and insert the desired subvector on its
12202     // first half.
12203     SDValue Zeros = getZeroVector(VT, true /* HasSSE2 */, DAG, dl);
12204     SDValue InsV = Insert128BitVector(Zeros, V1.getOperand(0),
12205                          DAG.getConstant(0, MVT::i32), DAG, dl);
12206     return DCI.CombineTo(N, InsV);
12207   }
12208
12209   //===--------------------------------------------------------------------===//
12210   // Combine some shuffles into subvector extracts and inserts:
12211   //
12212
12213   // vector_shuffle <4, 5, 6, 7, u, u, u, u> or <2, 3, u, u>
12214   if (isShuffleHigh128VectorInsertLow(SVOp)) {
12215     SDValue V = Extract128BitVector(V1, DAG.getConstant(NumElems/2, MVT::i32),
12216                                     DAG, dl);
12217     SDValue InsV = Insert128BitVector(DAG.getNode(ISD::UNDEF, dl, VT),
12218                                       V, DAG.getConstant(0, MVT::i32), DAG, dl);
12219     return DCI.CombineTo(N, InsV);
12220   }
12221
12222   // vector_shuffle <u, u, u, u, 0, 1, 2, 3> or <u, u, 0, 1>
12223   if (isShuffleLow128VectorInsertHigh(SVOp)) {
12224     SDValue V = Extract128BitVector(V1, DAG.getConstant(0, MVT::i32), DAG, dl);
12225     SDValue InsV = Insert128BitVector(DAG.getNode(ISD::UNDEF, dl, VT),
12226                              V, DAG.getConstant(NumElems/2, MVT::i32), DAG, dl);
12227     return DCI.CombineTo(N, InsV);
12228   }
12229
12230   return SDValue();
12231 }
12232
12233 /// PerformShuffleCombine - Performs several different shuffle combines.
12234 static SDValue PerformShuffleCombine(SDNode *N, SelectionDAG &DAG,
12235                                      TargetLowering::DAGCombinerInfo &DCI,
12236                                      const X86Subtarget *Subtarget) {
12237   DebugLoc dl = N->getDebugLoc();
12238   EVT VT = N->getValueType(0);
12239
12240   // Don't create instructions with illegal types after legalize types has run.
12241   const TargetLowering &TLI = DAG.getTargetLoweringInfo();
12242   if (!DCI.isBeforeLegalize() && !TLI.isTypeLegal(VT.getVectorElementType()))
12243     return SDValue();
12244
12245   // Combine 256-bit vector shuffles. This is only profitable when in AVX mode
12246   if (Subtarget->hasAVX() && VT.getSizeInBits() == 256 &&
12247       N->getOpcode() == ISD::VECTOR_SHUFFLE)
12248     return PerformShuffleCombine256(N, DAG, DCI);
12249
12250   // Only handle 128 wide vector from here on.
12251   if (VT.getSizeInBits() != 128)
12252     return SDValue();
12253
12254   // Combine a vector_shuffle that is equal to build_vector load1, load2, load3,
12255   // load4, <0, 1, 2, 3> into a 128-bit load if the load addresses are
12256   // consecutive, non-overlapping, and in the right order.
12257   SmallVector<SDValue, 16> Elts;
12258   for (unsigned i = 0, e = VT.getVectorNumElements(); i != e; ++i)
12259     Elts.push_back(getShuffleScalarElt(N, i, DAG, 0));
12260
12261   return EltsFromConsecutiveLoads(VT, Elts, dl, DAG);
12262 }
12263
12264 /// PerformEXTRACT_VECTOR_ELTCombine - Detect vector gather/scatter index
12265 /// generation and convert it from being a bunch of shuffles and extracts
12266 /// to a simple store and scalar loads to extract the elements.
12267 static SDValue PerformEXTRACT_VECTOR_ELTCombine(SDNode *N, SelectionDAG &DAG,
12268                                                 const TargetLowering &TLI) {
12269   SDValue InputVector = N->getOperand(0);
12270
12271   // Only operate on vectors of 4 elements, where the alternative shuffling
12272   // gets to be more expensive.
12273   if (InputVector.getValueType() != MVT::v4i32)
12274     return SDValue();
12275
12276   // Check whether every use of InputVector is an EXTRACT_VECTOR_ELT with a
12277   // single use which is a sign-extend or zero-extend, and all elements are
12278   // used.
12279   SmallVector<SDNode *, 4> Uses;
12280   unsigned ExtractedElements = 0;
12281   for (SDNode::use_iterator UI = InputVector.getNode()->use_begin(),
12282        UE = InputVector.getNode()->use_end(); UI != UE; ++UI) {
12283     if (UI.getUse().getResNo() != InputVector.getResNo())
12284       return SDValue();
12285
12286     SDNode *Extract = *UI;
12287     if (Extract->getOpcode() != ISD::EXTRACT_VECTOR_ELT)
12288       return SDValue();
12289
12290     if (Extract->getValueType(0) != MVT::i32)
12291       return SDValue();
12292     if (!Extract->hasOneUse())
12293       return SDValue();
12294     if (Extract->use_begin()->getOpcode() != ISD::SIGN_EXTEND &&
12295         Extract->use_begin()->getOpcode() != ISD::ZERO_EXTEND)
12296       return SDValue();
12297     if (!isa<ConstantSDNode>(Extract->getOperand(1)))
12298       return SDValue();
12299
12300     // Record which element was extracted.
12301     ExtractedElements |=
12302       1 << cast<ConstantSDNode>(Extract->getOperand(1))->getZExtValue();
12303
12304     Uses.push_back(Extract);
12305   }
12306
12307   // If not all the elements were used, this may not be worthwhile.
12308   if (ExtractedElements != 15)
12309     return SDValue();
12310
12311   // Ok, we've now decided to do the transformation.
12312   DebugLoc dl = InputVector.getDebugLoc();
12313
12314   // Store the value to a temporary stack slot.
12315   SDValue StackPtr = DAG.CreateStackTemporary(InputVector.getValueType());
12316   SDValue Ch = DAG.getStore(DAG.getEntryNode(), dl, InputVector, StackPtr,
12317                             MachinePointerInfo(), false, false, 0);
12318
12319   // Replace each use (extract) with a load of the appropriate element.
12320   for (SmallVectorImpl<SDNode *>::iterator UI = Uses.begin(),
12321        UE = Uses.end(); UI != UE; ++UI) {
12322     SDNode *Extract = *UI;
12323
12324     // cOMpute the element's address.
12325     SDValue Idx = Extract->getOperand(1);
12326     unsigned EltSize =
12327         InputVector.getValueType().getVectorElementType().getSizeInBits()/8;
12328     uint64_t Offset = EltSize * cast<ConstantSDNode>(Idx)->getZExtValue();
12329     SDValue OffsetVal = DAG.getConstant(Offset, TLI.getPointerTy());
12330
12331     SDValue ScalarAddr = DAG.getNode(ISD::ADD, dl, TLI.getPointerTy(),
12332                                      StackPtr, OffsetVal);
12333
12334     // Load the scalar.
12335     SDValue LoadScalar = DAG.getLoad(Extract->getValueType(0), dl, Ch,
12336                                      ScalarAddr, MachinePointerInfo(),
12337                                      false, false, 0);
12338
12339     // Replace the exact with the load.
12340     DAG.ReplaceAllUsesOfValueWith(SDValue(Extract, 0), LoadScalar);
12341   }
12342
12343   // The replacement was made in place; don't return anything.
12344   return SDValue();
12345 }
12346
12347 /// PerformSELECTCombine - Do target-specific dag combines on SELECT nodes.
12348 static SDValue PerformSELECTCombine(SDNode *N, SelectionDAG &DAG,
12349                                     const X86Subtarget *Subtarget) {
12350   DebugLoc DL = N->getDebugLoc();
12351   SDValue Cond = N->getOperand(0);
12352   // Get the LHS/RHS of the select.
12353   SDValue LHS = N->getOperand(1);
12354   SDValue RHS = N->getOperand(2);
12355
12356   // If we have SSE[12] support, try to form min/max nodes. SSE min/max
12357   // instructions match the semantics of the common C idiom x<y?x:y but not
12358   // x<=y?x:y, because of how they handle negative zero (which can be
12359   // ignored in unsafe-math mode).
12360   if (Subtarget->hasSSE2() &&
12361       (LHS.getValueType() == MVT::f32 || LHS.getValueType() == MVT::f64) &&
12362       Cond.getOpcode() == ISD::SETCC) {
12363     ISD::CondCode CC = cast<CondCodeSDNode>(Cond.getOperand(2))->get();
12364
12365     unsigned Opcode = 0;
12366     // Check for x CC y ? x : y.
12367     if (DAG.isEqualTo(LHS, Cond.getOperand(0)) &&
12368         DAG.isEqualTo(RHS, Cond.getOperand(1))) {
12369       switch (CC) {
12370       default: break;
12371       case ISD::SETULT:
12372         // Converting this to a min would handle NaNs incorrectly, and swapping
12373         // the operands would cause it to handle comparisons between positive
12374         // and negative zero incorrectly.
12375         if (!DAG.isKnownNeverNaN(LHS) || !DAG.isKnownNeverNaN(RHS)) {
12376           if (!UnsafeFPMath &&
12377               !(DAG.isKnownNeverZero(LHS) || DAG.isKnownNeverZero(RHS)))
12378             break;
12379           std::swap(LHS, RHS);
12380         }
12381         Opcode = X86ISD::FMIN;
12382         break;
12383       case ISD::SETOLE:
12384         // Converting this to a min would handle comparisons between positive
12385         // and negative zero incorrectly.
12386         if (!UnsafeFPMath &&
12387             !DAG.isKnownNeverZero(LHS) && !DAG.isKnownNeverZero(RHS))
12388           break;
12389         Opcode = X86ISD::FMIN;
12390         break;
12391       case ISD::SETULE:
12392         // Converting this to a min would handle both negative zeros and NaNs
12393         // incorrectly, but we can swap the operands to fix both.
12394         std::swap(LHS, RHS);
12395       case ISD::SETOLT:
12396       case ISD::SETLT:
12397       case ISD::SETLE:
12398         Opcode = X86ISD::FMIN;
12399         break;
12400
12401       case ISD::SETOGE:
12402         // Converting this to a max would handle comparisons between positive
12403         // and negative zero incorrectly.
12404         if (!UnsafeFPMath &&
12405             !DAG.isKnownNeverZero(LHS) && !DAG.isKnownNeverZero(RHS))
12406           break;
12407         Opcode = X86ISD::FMAX;
12408         break;
12409       case ISD::SETUGT:
12410         // Converting this to a max would handle NaNs incorrectly, and swapping
12411         // the operands would cause it to handle comparisons between positive
12412         // and negative zero incorrectly.
12413         if (!DAG.isKnownNeverNaN(LHS) || !DAG.isKnownNeverNaN(RHS)) {
12414           if (!UnsafeFPMath &&
12415               !(DAG.isKnownNeverZero(LHS) || DAG.isKnownNeverZero(RHS)))
12416             break;
12417           std::swap(LHS, RHS);
12418         }
12419         Opcode = X86ISD::FMAX;
12420         break;
12421       case ISD::SETUGE:
12422         // Converting this to a max would handle both negative zeros and NaNs
12423         // incorrectly, but we can swap the operands to fix both.
12424         std::swap(LHS, RHS);
12425       case ISD::SETOGT:
12426       case ISD::SETGT:
12427       case ISD::SETGE:
12428         Opcode = X86ISD::FMAX;
12429         break;
12430       }
12431     // Check for x CC y ? y : x -- a min/max with reversed arms.
12432     } else if (DAG.isEqualTo(LHS, Cond.getOperand(1)) &&
12433                DAG.isEqualTo(RHS, Cond.getOperand(0))) {
12434       switch (CC) {
12435       default: break;
12436       case ISD::SETOGE:
12437         // Converting this to a min would handle comparisons between positive
12438         // and negative zero incorrectly, and swapping the operands would
12439         // cause it to handle NaNs incorrectly.
12440         if (!UnsafeFPMath &&
12441             !(DAG.isKnownNeverZero(LHS) || DAG.isKnownNeverZero(RHS))) {
12442           if (!DAG.isKnownNeverNaN(LHS) || !DAG.isKnownNeverNaN(RHS))
12443             break;
12444           std::swap(LHS, RHS);
12445         }
12446         Opcode = X86ISD::FMIN;
12447         break;
12448       case ISD::SETUGT:
12449         // Converting this to a min would handle NaNs incorrectly.
12450         if (!UnsafeFPMath &&
12451             (!DAG.isKnownNeverNaN(LHS) || !DAG.isKnownNeverNaN(RHS)))
12452           break;
12453         Opcode = X86ISD::FMIN;
12454         break;
12455       case ISD::SETUGE:
12456         // Converting this to a min would handle both negative zeros and NaNs
12457         // incorrectly, but we can swap the operands to fix both.
12458         std::swap(LHS, RHS);
12459       case ISD::SETOGT:
12460       case ISD::SETGT:
12461       case ISD::SETGE:
12462         Opcode = X86ISD::FMIN;
12463         break;
12464
12465       case ISD::SETULT:
12466         // Converting this to a max would handle NaNs incorrectly.
12467         if (!DAG.isKnownNeverNaN(LHS) || !DAG.isKnownNeverNaN(RHS))
12468           break;
12469         Opcode = X86ISD::FMAX;
12470         break;
12471       case ISD::SETOLE:
12472         // Converting this to a max would handle comparisons between positive
12473         // and negative zero incorrectly, and swapping the operands would
12474         // cause it to handle NaNs incorrectly.
12475         if (!UnsafeFPMath &&
12476             !DAG.isKnownNeverZero(LHS) && !DAG.isKnownNeverZero(RHS)) {
12477           if (!DAG.isKnownNeverNaN(LHS) || !DAG.isKnownNeverNaN(RHS))
12478             break;
12479           std::swap(LHS, RHS);
12480         }
12481         Opcode = X86ISD::FMAX;
12482         break;
12483       case ISD::SETULE:
12484         // Converting this to a max would handle both negative zeros and NaNs
12485         // incorrectly, but we can swap the operands to fix both.
12486         std::swap(LHS, RHS);
12487       case ISD::SETOLT:
12488       case ISD::SETLT:
12489       case ISD::SETLE:
12490         Opcode = X86ISD::FMAX;
12491         break;
12492       }
12493     }
12494
12495     if (Opcode)
12496       return DAG.getNode(Opcode, DL, N->getValueType(0), LHS, RHS);
12497   }
12498
12499   // If this is a select between two integer constants, try to do some
12500   // optimizations.
12501   if (ConstantSDNode *TrueC = dyn_cast<ConstantSDNode>(LHS)) {
12502     if (ConstantSDNode *FalseC = dyn_cast<ConstantSDNode>(RHS))
12503       // Don't do this for crazy integer types.
12504       if (DAG.getTargetLoweringInfo().isTypeLegal(LHS.getValueType())) {
12505         // If this is efficiently invertible, canonicalize the LHSC/RHSC values
12506         // so that TrueC (the true value) is larger than FalseC.
12507         bool NeedsCondInvert = false;
12508
12509         if (TrueC->getAPIntValue().ult(FalseC->getAPIntValue()) &&
12510             // Efficiently invertible.
12511             (Cond.getOpcode() == ISD::SETCC ||  // setcc -> invertible.
12512              (Cond.getOpcode() == ISD::XOR &&   // xor(X, C) -> invertible.
12513               isa<ConstantSDNode>(Cond.getOperand(1))))) {
12514           NeedsCondInvert = true;
12515           std::swap(TrueC, FalseC);
12516         }
12517
12518         // Optimize C ? 8 : 0 -> zext(C) << 3.  Likewise for any pow2/0.
12519         if (FalseC->getAPIntValue() == 0 &&
12520             TrueC->getAPIntValue().isPowerOf2()) {
12521           if (NeedsCondInvert) // Invert the condition if needed.
12522             Cond = DAG.getNode(ISD::XOR, DL, Cond.getValueType(), Cond,
12523                                DAG.getConstant(1, Cond.getValueType()));
12524
12525           // Zero extend the condition if needed.
12526           Cond = DAG.getNode(ISD::ZERO_EXTEND, DL, LHS.getValueType(), Cond);
12527
12528           unsigned ShAmt = TrueC->getAPIntValue().logBase2();
12529           return DAG.getNode(ISD::SHL, DL, LHS.getValueType(), Cond,
12530                              DAG.getConstant(ShAmt, MVT::i8));
12531         }
12532
12533         // Optimize Cond ? cst+1 : cst -> zext(setcc(C)+cst.
12534         if (FalseC->getAPIntValue()+1 == TrueC->getAPIntValue()) {
12535           if (NeedsCondInvert) // Invert the condition if needed.
12536             Cond = DAG.getNode(ISD::XOR, DL, Cond.getValueType(), Cond,
12537                                DAG.getConstant(1, Cond.getValueType()));
12538
12539           // Zero extend the condition if needed.
12540           Cond = DAG.getNode(ISD::ZERO_EXTEND, DL,
12541                              FalseC->getValueType(0), Cond);
12542           return DAG.getNode(ISD::ADD, DL, Cond.getValueType(), Cond,
12543                              SDValue(FalseC, 0));
12544         }
12545
12546         // Optimize cases that will turn into an LEA instruction.  This requires
12547         // an i32 or i64 and an efficient multiplier (1, 2, 3, 4, 5, 8, 9).
12548         if (N->getValueType(0) == MVT::i32 || N->getValueType(0) == MVT::i64) {
12549           uint64_t Diff = TrueC->getZExtValue()-FalseC->getZExtValue();
12550           if (N->getValueType(0) == MVT::i32) Diff = (unsigned)Diff;
12551
12552           bool isFastMultiplier = false;
12553           if (Diff < 10) {
12554             switch ((unsigned char)Diff) {
12555               default: break;
12556               case 1:  // result = add base, cond
12557               case 2:  // result = lea base(    , cond*2)
12558               case 3:  // result = lea base(cond, cond*2)
12559               case 4:  // result = lea base(    , cond*4)
12560               case 5:  // result = lea base(cond, cond*4)
12561               case 8:  // result = lea base(    , cond*8)
12562               case 9:  // result = lea base(cond, cond*8)
12563                 isFastMultiplier = true;
12564                 break;
12565             }
12566           }
12567
12568           if (isFastMultiplier) {
12569             APInt Diff = TrueC->getAPIntValue()-FalseC->getAPIntValue();
12570             if (NeedsCondInvert) // Invert the condition if needed.
12571               Cond = DAG.getNode(ISD::XOR, DL, Cond.getValueType(), Cond,
12572                                  DAG.getConstant(1, Cond.getValueType()));
12573
12574             // Zero extend the condition if needed.
12575             Cond = DAG.getNode(ISD::ZERO_EXTEND, DL, FalseC->getValueType(0),
12576                                Cond);
12577             // Scale the condition by the difference.
12578             if (Diff != 1)
12579               Cond = DAG.getNode(ISD::MUL, DL, Cond.getValueType(), Cond,
12580                                  DAG.getConstant(Diff, Cond.getValueType()));
12581
12582             // Add the base if non-zero.
12583             if (FalseC->getAPIntValue() != 0)
12584               Cond = DAG.getNode(ISD::ADD, DL, Cond.getValueType(), Cond,
12585                                  SDValue(FalseC, 0));
12586             return Cond;
12587           }
12588         }
12589       }
12590   }
12591
12592   return SDValue();
12593 }
12594
12595 /// Optimize X86ISD::CMOV [LHS, RHS, CONDCODE (e.g. X86::COND_NE), CONDVAL]
12596 static SDValue PerformCMOVCombine(SDNode *N, SelectionDAG &DAG,
12597                                   TargetLowering::DAGCombinerInfo &DCI) {
12598   DebugLoc DL = N->getDebugLoc();
12599
12600   // If the flag operand isn't dead, don't touch this CMOV.
12601   if (N->getNumValues() == 2 && !SDValue(N, 1).use_empty())
12602     return SDValue();
12603
12604   SDValue FalseOp = N->getOperand(0);
12605   SDValue TrueOp = N->getOperand(1);
12606   X86::CondCode CC = (X86::CondCode)N->getConstantOperandVal(2);
12607   SDValue Cond = N->getOperand(3);
12608   if (CC == X86::COND_E || CC == X86::COND_NE) {
12609     switch (Cond.getOpcode()) {
12610     default: break;
12611     case X86ISD::BSR:
12612     case X86ISD::BSF:
12613       // If operand of BSR / BSF are proven never zero, then ZF cannot be set.
12614       if (DAG.isKnownNeverZero(Cond.getOperand(0)))
12615         return (CC == X86::COND_E) ? FalseOp : TrueOp;
12616     }
12617   }
12618
12619   // If this is a select between two integer constants, try to do some
12620   // optimizations.  Note that the operands are ordered the opposite of SELECT
12621   // operands.
12622   if (ConstantSDNode *TrueC = dyn_cast<ConstantSDNode>(TrueOp)) {
12623     if (ConstantSDNode *FalseC = dyn_cast<ConstantSDNode>(FalseOp)) {
12624       // Canonicalize the TrueC/FalseC values so that TrueC (the true value) is
12625       // larger than FalseC (the false value).
12626       if (TrueC->getAPIntValue().ult(FalseC->getAPIntValue())) {
12627         CC = X86::GetOppositeBranchCondition(CC);
12628         std::swap(TrueC, FalseC);
12629       }
12630
12631       // Optimize C ? 8 : 0 -> zext(setcc(C)) << 3.  Likewise for any pow2/0.
12632       // This is efficient for any integer data type (including i8/i16) and
12633       // shift amount.
12634       if (FalseC->getAPIntValue() == 0 && TrueC->getAPIntValue().isPowerOf2()) {
12635         Cond = DAG.getNode(X86ISD::SETCC, DL, MVT::i8,
12636                            DAG.getConstant(CC, MVT::i8), Cond);
12637
12638         // Zero extend the condition if needed.
12639         Cond = DAG.getNode(ISD::ZERO_EXTEND, DL, TrueC->getValueType(0), Cond);
12640
12641         unsigned ShAmt = TrueC->getAPIntValue().logBase2();
12642         Cond = DAG.getNode(ISD::SHL, DL, Cond.getValueType(), Cond,
12643                            DAG.getConstant(ShAmt, MVT::i8));
12644         if (N->getNumValues() == 2)  // Dead flag value?
12645           return DCI.CombineTo(N, Cond, SDValue());
12646         return Cond;
12647       }
12648
12649       // Optimize Cond ? cst+1 : cst -> zext(setcc(C)+cst.  This is efficient
12650       // for any integer data type, including i8/i16.
12651       if (FalseC->getAPIntValue()+1 == TrueC->getAPIntValue()) {
12652         Cond = DAG.getNode(X86ISD::SETCC, DL, MVT::i8,
12653                            DAG.getConstant(CC, MVT::i8), Cond);
12654
12655         // Zero extend the condition if needed.
12656         Cond = DAG.getNode(ISD::ZERO_EXTEND, DL,
12657                            FalseC->getValueType(0), Cond);
12658         Cond = DAG.getNode(ISD::ADD, DL, Cond.getValueType(), Cond,
12659                            SDValue(FalseC, 0));
12660
12661         if (N->getNumValues() == 2)  // Dead flag value?
12662           return DCI.CombineTo(N, Cond, SDValue());
12663         return Cond;
12664       }
12665
12666       // Optimize cases that will turn into an LEA instruction.  This requires
12667       // an i32 or i64 and an efficient multiplier (1, 2, 3, 4, 5, 8, 9).
12668       if (N->getValueType(0) == MVT::i32 || N->getValueType(0) == MVT::i64) {
12669         uint64_t Diff = TrueC->getZExtValue()-FalseC->getZExtValue();
12670         if (N->getValueType(0) == MVT::i32) Diff = (unsigned)Diff;
12671
12672         bool isFastMultiplier = false;
12673         if (Diff < 10) {
12674           switch ((unsigned char)Diff) {
12675           default: break;
12676           case 1:  // result = add base, cond
12677           case 2:  // result = lea base(    , cond*2)
12678           case 3:  // result = lea base(cond, cond*2)
12679           case 4:  // result = lea base(    , cond*4)
12680           case 5:  // result = lea base(cond, cond*4)
12681           case 8:  // result = lea base(    , cond*8)
12682           case 9:  // result = lea base(cond, cond*8)
12683             isFastMultiplier = true;
12684             break;
12685           }
12686         }
12687
12688         if (isFastMultiplier) {
12689           APInt Diff = TrueC->getAPIntValue()-FalseC->getAPIntValue();
12690           Cond = DAG.getNode(X86ISD::SETCC, DL, MVT::i8,
12691                              DAG.getConstant(CC, MVT::i8), Cond);
12692           // Zero extend the condition if needed.
12693           Cond = DAG.getNode(ISD::ZERO_EXTEND, DL, FalseC->getValueType(0),
12694                              Cond);
12695           // Scale the condition by the difference.
12696           if (Diff != 1)
12697             Cond = DAG.getNode(ISD::MUL, DL, Cond.getValueType(), Cond,
12698                                DAG.getConstant(Diff, Cond.getValueType()));
12699
12700           // Add the base if non-zero.
12701           if (FalseC->getAPIntValue() != 0)
12702             Cond = DAG.getNode(ISD::ADD, DL, Cond.getValueType(), Cond,
12703                                SDValue(FalseC, 0));
12704           if (N->getNumValues() == 2)  // Dead flag value?
12705             return DCI.CombineTo(N, Cond, SDValue());
12706           return Cond;
12707         }
12708       }
12709     }
12710   }
12711   return SDValue();
12712 }
12713
12714
12715 /// PerformMulCombine - Optimize a single multiply with constant into two
12716 /// in order to implement it with two cheaper instructions, e.g.
12717 /// LEA + SHL, LEA + LEA.
12718 static SDValue PerformMulCombine(SDNode *N, SelectionDAG &DAG,
12719                                  TargetLowering::DAGCombinerInfo &DCI) {
12720   if (DCI.isBeforeLegalize() || DCI.isCalledByLegalizer())
12721     return SDValue();
12722
12723   EVT VT = N->getValueType(0);
12724   if (VT != MVT::i64)
12725     return SDValue();
12726
12727   ConstantSDNode *C = dyn_cast<ConstantSDNode>(N->getOperand(1));
12728   if (!C)
12729     return SDValue();
12730   uint64_t MulAmt = C->getZExtValue();
12731   if (isPowerOf2_64(MulAmt) || MulAmt == 3 || MulAmt == 5 || MulAmt == 9)
12732     return SDValue();
12733
12734   uint64_t MulAmt1 = 0;
12735   uint64_t MulAmt2 = 0;
12736   if ((MulAmt % 9) == 0) {
12737     MulAmt1 = 9;
12738     MulAmt2 = MulAmt / 9;
12739   } else if ((MulAmt % 5) == 0) {
12740     MulAmt1 = 5;
12741     MulAmt2 = MulAmt / 5;
12742   } else if ((MulAmt % 3) == 0) {
12743     MulAmt1 = 3;
12744     MulAmt2 = MulAmt / 3;
12745   }
12746   if (MulAmt2 &&
12747       (isPowerOf2_64(MulAmt2) || MulAmt2 == 3 || MulAmt2 == 5 || MulAmt2 == 9)){
12748     DebugLoc DL = N->getDebugLoc();
12749
12750     if (isPowerOf2_64(MulAmt2) &&
12751         !(N->hasOneUse() && N->use_begin()->getOpcode() == ISD::ADD))
12752       // If second multiplifer is pow2, issue it first. We want the multiply by
12753       // 3, 5, or 9 to be folded into the addressing mode unless the lone use
12754       // is an add.
12755       std::swap(MulAmt1, MulAmt2);
12756
12757     SDValue NewMul;
12758     if (isPowerOf2_64(MulAmt1))
12759       NewMul = DAG.getNode(ISD::SHL, DL, VT, N->getOperand(0),
12760                            DAG.getConstant(Log2_64(MulAmt1), MVT::i8));
12761     else
12762       NewMul = DAG.getNode(X86ISD::MUL_IMM, DL, VT, N->getOperand(0),
12763                            DAG.getConstant(MulAmt1, VT));
12764
12765     if (isPowerOf2_64(MulAmt2))
12766       NewMul = DAG.getNode(ISD::SHL, DL, VT, NewMul,
12767                            DAG.getConstant(Log2_64(MulAmt2), MVT::i8));
12768     else
12769       NewMul = DAG.getNode(X86ISD::MUL_IMM, DL, VT, NewMul,
12770                            DAG.getConstant(MulAmt2, VT));
12771
12772     // Do not add new nodes to DAG combiner worklist.
12773     DCI.CombineTo(N, NewMul, false);
12774   }
12775   return SDValue();
12776 }
12777
12778 static SDValue PerformSHLCombine(SDNode *N, SelectionDAG &DAG) {
12779   SDValue N0 = N->getOperand(0);
12780   SDValue N1 = N->getOperand(1);
12781   ConstantSDNode *N1C = dyn_cast<ConstantSDNode>(N1);
12782   EVT VT = N0.getValueType();
12783
12784   // fold (shl (and (setcc_c), c1), c2) -> (and setcc_c, (c1 << c2))
12785   // since the result of setcc_c is all zero's or all ones.
12786   if (N1C && N0.getOpcode() == ISD::AND &&
12787       N0.getOperand(1).getOpcode() == ISD::Constant) {
12788     SDValue N00 = N0.getOperand(0);
12789     if (N00.getOpcode() == X86ISD::SETCC_CARRY ||
12790         ((N00.getOpcode() == ISD::ANY_EXTEND ||
12791           N00.getOpcode() == ISD::ZERO_EXTEND) &&
12792          N00.getOperand(0).getOpcode() == X86ISD::SETCC_CARRY)) {
12793       APInt Mask = cast<ConstantSDNode>(N0.getOperand(1))->getAPIntValue();
12794       APInt ShAmt = N1C->getAPIntValue();
12795       Mask = Mask.shl(ShAmt);
12796       if (Mask != 0)
12797         return DAG.getNode(ISD::AND, N->getDebugLoc(), VT,
12798                            N00, DAG.getConstant(Mask, VT));
12799     }
12800   }
12801
12802   return SDValue();
12803 }
12804
12805 /// PerformShiftCombine - Transforms vector shift nodes to use vector shifts
12806 ///                       when possible.
12807 static SDValue PerformShiftCombine(SDNode* N, SelectionDAG &DAG,
12808                                    const X86Subtarget *Subtarget) {
12809   EVT VT = N->getValueType(0);
12810   if (!VT.isVector() && VT.isInteger() &&
12811       N->getOpcode() == ISD::SHL)
12812     return PerformSHLCombine(N, DAG);
12813
12814   // On X86 with SSE2 support, we can transform this to a vector shift if
12815   // all elements are shifted by the same amount.  We can't do this in legalize
12816   // because the a constant vector is typically transformed to a constant pool
12817   // so we have no knowledge of the shift amount.
12818   if (!(Subtarget->hasSSE2() || Subtarget->hasAVX()))
12819     return SDValue();
12820
12821   if (VT != MVT::v2i64 && VT != MVT::v4i32 && VT != MVT::v8i16)
12822     return SDValue();
12823
12824   SDValue ShAmtOp = N->getOperand(1);
12825   EVT EltVT = VT.getVectorElementType();
12826   DebugLoc DL = N->getDebugLoc();
12827   SDValue BaseShAmt = SDValue();
12828   if (ShAmtOp.getOpcode() == ISD::BUILD_VECTOR) {
12829     unsigned NumElts = VT.getVectorNumElements();
12830     unsigned i = 0;
12831     for (; i != NumElts; ++i) {
12832       SDValue Arg = ShAmtOp.getOperand(i);
12833       if (Arg.getOpcode() == ISD::UNDEF) continue;
12834       BaseShAmt = Arg;
12835       break;
12836     }
12837     for (; i != NumElts; ++i) {
12838       SDValue Arg = ShAmtOp.getOperand(i);
12839       if (Arg.getOpcode() == ISD::UNDEF) continue;
12840       if (Arg != BaseShAmt) {
12841         return SDValue();
12842       }
12843     }
12844   } else if (ShAmtOp.getOpcode() == ISD::VECTOR_SHUFFLE &&
12845              cast<ShuffleVectorSDNode>(ShAmtOp)->isSplat()) {
12846     SDValue InVec = ShAmtOp.getOperand(0);
12847     if (InVec.getOpcode() == ISD::BUILD_VECTOR) {
12848       unsigned NumElts = InVec.getValueType().getVectorNumElements();
12849       unsigned i = 0;
12850       for (; i != NumElts; ++i) {
12851         SDValue Arg = InVec.getOperand(i);
12852         if (Arg.getOpcode() == ISD::UNDEF) continue;
12853         BaseShAmt = Arg;
12854         break;
12855       }
12856     } else if (InVec.getOpcode() == ISD::INSERT_VECTOR_ELT) {
12857        if (ConstantSDNode *C = dyn_cast<ConstantSDNode>(InVec.getOperand(2))) {
12858          unsigned SplatIdx= cast<ShuffleVectorSDNode>(ShAmtOp)->getSplatIndex();
12859          if (C->getZExtValue() == SplatIdx)
12860            BaseShAmt = InVec.getOperand(1);
12861        }
12862     }
12863     if (BaseShAmt.getNode() == 0)
12864       BaseShAmt = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, DL, EltVT, ShAmtOp,
12865                               DAG.getIntPtrConstant(0));
12866   } else
12867     return SDValue();
12868
12869   // The shift amount is an i32.
12870   if (EltVT.bitsGT(MVT::i32))
12871     BaseShAmt = DAG.getNode(ISD::TRUNCATE, DL, MVT::i32, BaseShAmt);
12872   else if (EltVT.bitsLT(MVT::i32))
12873     BaseShAmt = DAG.getNode(ISD::ZERO_EXTEND, DL, MVT::i32, BaseShAmt);
12874
12875   // The shift amount is identical so we can do a vector shift.
12876   SDValue  ValOp = N->getOperand(0);
12877   switch (N->getOpcode()) {
12878   default:
12879     llvm_unreachable("Unknown shift opcode!");
12880     break;
12881   case ISD::SHL:
12882     if (VT == MVT::v2i64)
12883       return DAG.getNode(ISD::INTRINSIC_WO_CHAIN, DL, VT,
12884                          DAG.getConstant(Intrinsic::x86_sse2_pslli_q, MVT::i32),
12885                          ValOp, BaseShAmt);
12886     if (VT == MVT::v4i32)
12887       return DAG.getNode(ISD::INTRINSIC_WO_CHAIN, DL, VT,
12888                          DAG.getConstant(Intrinsic::x86_sse2_pslli_d, MVT::i32),
12889                          ValOp, BaseShAmt);
12890     if (VT == MVT::v8i16)
12891       return DAG.getNode(ISD::INTRINSIC_WO_CHAIN, DL, VT,
12892                          DAG.getConstant(Intrinsic::x86_sse2_pslli_w, MVT::i32),
12893                          ValOp, BaseShAmt);
12894     break;
12895   case ISD::SRA:
12896     if (VT == MVT::v4i32)
12897       return DAG.getNode(ISD::INTRINSIC_WO_CHAIN, DL, VT,
12898                          DAG.getConstant(Intrinsic::x86_sse2_psrai_d, MVT::i32),
12899                          ValOp, BaseShAmt);
12900     if (VT == MVT::v8i16)
12901       return DAG.getNode(ISD::INTRINSIC_WO_CHAIN, DL, VT,
12902                          DAG.getConstant(Intrinsic::x86_sse2_psrai_w, MVT::i32),
12903                          ValOp, BaseShAmt);
12904     break;
12905   case ISD::SRL:
12906     if (VT == MVT::v2i64)
12907       return DAG.getNode(ISD::INTRINSIC_WO_CHAIN, DL, VT,
12908                          DAG.getConstant(Intrinsic::x86_sse2_psrli_q, MVT::i32),
12909                          ValOp, BaseShAmt);
12910     if (VT == MVT::v4i32)
12911       return DAG.getNode(ISD::INTRINSIC_WO_CHAIN, DL, VT,
12912                          DAG.getConstant(Intrinsic::x86_sse2_psrli_d, MVT::i32),
12913                          ValOp, BaseShAmt);
12914     if (VT ==  MVT::v8i16)
12915       return DAG.getNode(ISD::INTRINSIC_WO_CHAIN, DL, VT,
12916                          DAG.getConstant(Intrinsic::x86_sse2_psrli_w, MVT::i32),
12917                          ValOp, BaseShAmt);
12918     break;
12919   }
12920   return SDValue();
12921 }
12922
12923
12924 // CMPEQCombine - Recognize the distinctive  (AND (setcc ...) (setcc ..))
12925 // where both setccs reference the same FP CMP, and rewrite for CMPEQSS
12926 // and friends.  Likewise for OR -> CMPNEQSS.
12927 static SDValue CMPEQCombine(SDNode *N, SelectionDAG &DAG,
12928                             TargetLowering::DAGCombinerInfo &DCI,
12929                             const X86Subtarget *Subtarget) {
12930   unsigned opcode;
12931
12932   // SSE1 supports CMP{eq|ne}SS, and SSE2 added CMP{eq|ne}SD, but
12933   // we're requiring SSE2 for both.
12934   if (Subtarget->hasSSE2() && isAndOrOfSetCCs(SDValue(N, 0U), opcode)) {
12935     SDValue N0 = N->getOperand(0);
12936     SDValue N1 = N->getOperand(1);
12937     SDValue CMP0 = N0->getOperand(1);
12938     SDValue CMP1 = N1->getOperand(1);
12939     DebugLoc DL = N->getDebugLoc();
12940
12941     // The SETCCs should both refer to the same CMP.
12942     if (CMP0.getOpcode() != X86ISD::CMP || CMP0 != CMP1)
12943       return SDValue();
12944
12945     SDValue CMP00 = CMP0->getOperand(0);
12946     SDValue CMP01 = CMP0->getOperand(1);
12947     EVT     VT    = CMP00.getValueType();
12948
12949     if (VT == MVT::f32 || VT == MVT::f64) {
12950       bool ExpectingFlags = false;
12951       // Check for any users that want flags:
12952       for (SDNode::use_iterator UI = N->use_begin(),
12953              UE = N->use_end();
12954            !ExpectingFlags && UI != UE; ++UI)
12955         switch (UI->getOpcode()) {
12956         default:
12957         case ISD::BR_CC:
12958         case ISD::BRCOND:
12959         case ISD::SELECT:
12960           ExpectingFlags = true;
12961           break;
12962         case ISD::CopyToReg:
12963         case ISD::SIGN_EXTEND:
12964         case ISD::ZERO_EXTEND:
12965         case ISD::ANY_EXTEND:
12966           break;
12967         }
12968
12969       if (!ExpectingFlags) {
12970         enum X86::CondCode cc0 = (enum X86::CondCode)N0.getConstantOperandVal(0);
12971         enum X86::CondCode cc1 = (enum X86::CondCode)N1.getConstantOperandVal(0);
12972
12973         if (cc1 == X86::COND_E || cc1 == X86::COND_NE) {
12974           X86::CondCode tmp = cc0;
12975           cc0 = cc1;
12976           cc1 = tmp;
12977         }
12978
12979         if ((cc0 == X86::COND_E  && cc1 == X86::COND_NP) ||
12980             (cc0 == X86::COND_NE && cc1 == X86::COND_P)) {
12981           bool is64BitFP = (CMP00.getValueType() == MVT::f64);
12982           X86ISD::NodeType NTOperator = is64BitFP ?
12983             X86ISD::FSETCCsd : X86ISD::FSETCCss;
12984           // FIXME: need symbolic constants for these magic numbers.
12985           // See X86ATTInstPrinter.cpp:printSSECC().
12986           unsigned x86cc = (cc0 == X86::COND_E) ? 0 : 4;
12987           SDValue OnesOrZeroesF = DAG.getNode(NTOperator, DL, MVT::f32, CMP00, CMP01,
12988                                               DAG.getConstant(x86cc, MVT::i8));
12989           SDValue OnesOrZeroesI = DAG.getNode(ISD::BITCAST, DL, MVT::i32,
12990                                               OnesOrZeroesF);
12991           SDValue ANDed = DAG.getNode(ISD::AND, DL, MVT::i32, OnesOrZeroesI,
12992                                       DAG.getConstant(1, MVT::i32));
12993           SDValue OneBitOfTruth = DAG.getNode(ISD::TRUNCATE, DL, MVT::i8, ANDed);
12994           return OneBitOfTruth;
12995         }
12996       }
12997     }
12998   }
12999   return SDValue();
13000 }
13001
13002 /// CanFoldXORWithAllOnes - Test whether the XOR operand is a AllOnes vector
13003 /// so it can be folded inside ANDNP.
13004 static bool CanFoldXORWithAllOnes(const SDNode *N) {
13005   EVT VT = N->getValueType(0);
13006
13007   // Match direct AllOnes for 128 and 256-bit vectors
13008   if (ISD::isBuildVectorAllOnes(N))
13009     return true;
13010
13011   // Look through a bit convert.
13012   if (N->getOpcode() == ISD::BITCAST)
13013     N = N->getOperand(0).getNode();
13014
13015   // Sometimes the operand may come from a insert_subvector building a 256-bit
13016   // allones vector
13017   if (VT.getSizeInBits() == 256 &&
13018       N->getOpcode() == ISD::INSERT_SUBVECTOR) {
13019     SDValue V1 = N->getOperand(0);
13020     SDValue V2 = N->getOperand(1);
13021
13022     if (V1.getOpcode() == ISD::INSERT_SUBVECTOR &&
13023         V1.getOperand(0).getOpcode() == ISD::UNDEF &&
13024         ISD::isBuildVectorAllOnes(V1.getOperand(1).getNode()) &&
13025         ISD::isBuildVectorAllOnes(V2.getNode()))
13026       return true;
13027   }
13028
13029   return false;
13030 }
13031
13032 static SDValue PerformAndCombine(SDNode *N, SelectionDAG &DAG,
13033                                  TargetLowering::DAGCombinerInfo &DCI,
13034                                  const X86Subtarget *Subtarget) {
13035   if (DCI.isBeforeLegalizeOps())
13036     return SDValue();
13037
13038   SDValue R = CMPEQCombine(N, DAG, DCI, Subtarget);
13039   if (R.getNode())
13040     return R;
13041
13042   // Want to form ANDNP nodes:
13043   // 1) In the hopes of then easily combining them with OR and AND nodes
13044   //    to form PBLEND/PSIGN.
13045   // 2) To match ANDN packed intrinsics
13046   EVT VT = N->getValueType(0);
13047   if (VT != MVT::v2i64 && VT != MVT::v4i64)
13048     return SDValue();
13049
13050   SDValue N0 = N->getOperand(0);
13051   SDValue N1 = N->getOperand(1);
13052   DebugLoc DL = N->getDebugLoc();
13053
13054   // Check LHS for vnot
13055   if (N0.getOpcode() == ISD::XOR &&
13056       //ISD::isBuildVectorAllOnes(N0.getOperand(1).getNode()))
13057       CanFoldXORWithAllOnes(N0.getOperand(1).getNode()))
13058     return DAG.getNode(X86ISD::ANDNP, DL, VT, N0.getOperand(0), N1);
13059
13060   // Check RHS for vnot
13061   if (N1.getOpcode() == ISD::XOR &&
13062       //ISD::isBuildVectorAllOnes(N1.getOperand(1).getNode()))
13063       CanFoldXORWithAllOnes(N1.getOperand(1).getNode()))
13064     return DAG.getNode(X86ISD::ANDNP, DL, VT, N1.getOperand(0), N0);
13065
13066   return SDValue();
13067 }
13068
13069 static SDValue PerformOrCombine(SDNode *N, SelectionDAG &DAG,
13070                                 TargetLowering::DAGCombinerInfo &DCI,
13071                                 const X86Subtarget *Subtarget) {
13072   if (DCI.isBeforeLegalizeOps())
13073     return SDValue();
13074
13075   SDValue R = CMPEQCombine(N, DAG, DCI, Subtarget);
13076   if (R.getNode())
13077     return R;
13078
13079   EVT VT = N->getValueType(0);
13080   if (VT != MVT::i16 && VT != MVT::i32 && VT != MVT::i64 && VT != MVT::v2i64)
13081     return SDValue();
13082
13083   SDValue N0 = N->getOperand(0);
13084   SDValue N1 = N->getOperand(1);
13085
13086   // look for psign/blend
13087   if (Subtarget->hasSSSE3()) {
13088     if (VT == MVT::v2i64) {
13089       // Canonicalize pandn to RHS
13090       if (N0.getOpcode() == X86ISD::ANDNP)
13091         std::swap(N0, N1);
13092       // or (and (m, x), (pandn m, y))
13093       if (N0.getOpcode() == ISD::AND && N1.getOpcode() == X86ISD::ANDNP) {
13094         SDValue Mask = N1.getOperand(0);
13095         SDValue X    = N1.getOperand(1);
13096         SDValue Y;
13097         if (N0.getOperand(0) == Mask)
13098           Y = N0.getOperand(1);
13099         if (N0.getOperand(1) == Mask)
13100           Y = N0.getOperand(0);
13101
13102         // Check to see if the mask appeared in both the AND and ANDNP and
13103         if (!Y.getNode())
13104           return SDValue();
13105
13106         // Validate that X, Y, and Mask are BIT_CONVERTS, and see through them.
13107         if (Mask.getOpcode() != ISD::BITCAST ||
13108             X.getOpcode() != ISD::BITCAST ||
13109             Y.getOpcode() != ISD::BITCAST)
13110           return SDValue();
13111
13112         // Look through mask bitcast.
13113         Mask = Mask.getOperand(0);
13114         EVT MaskVT = Mask.getValueType();
13115
13116         // Validate that the Mask operand is a vector sra node.  The sra node
13117         // will be an intrinsic.
13118         if (Mask.getOpcode() != ISD::INTRINSIC_WO_CHAIN)
13119           return SDValue();
13120
13121         // FIXME: what to do for bytes, since there is a psignb/pblendvb, but
13122         // there is no psrai.b
13123         switch (cast<ConstantSDNode>(Mask.getOperand(0))->getZExtValue()) {
13124         case Intrinsic::x86_sse2_psrai_w:
13125         case Intrinsic::x86_sse2_psrai_d:
13126           break;
13127         default: return SDValue();
13128         }
13129
13130         // Check that the SRA is all signbits.
13131         SDValue SraC = Mask.getOperand(2);
13132         unsigned SraAmt  = cast<ConstantSDNode>(SraC)->getZExtValue();
13133         unsigned EltBits = MaskVT.getVectorElementType().getSizeInBits();
13134         if ((SraAmt + 1) != EltBits)
13135           return SDValue();
13136
13137         DebugLoc DL = N->getDebugLoc();
13138
13139         // Now we know we at least have a plendvb with the mask val.  See if
13140         // we can form a psignb/w/d.
13141         // psign = x.type == y.type == mask.type && y = sub(0, x);
13142         X = X.getOperand(0);
13143         Y = Y.getOperand(0);
13144         if (Y.getOpcode() == ISD::SUB && Y.getOperand(1) == X &&
13145             ISD::isBuildVectorAllZeros(Y.getOperand(0).getNode()) &&
13146             X.getValueType() == MaskVT && X.getValueType() == Y.getValueType()){
13147           unsigned Opc = 0;
13148           switch (EltBits) {
13149           case 8: Opc = X86ISD::PSIGNB; break;
13150           case 16: Opc = X86ISD::PSIGNW; break;
13151           case 32: Opc = X86ISD::PSIGND; break;
13152           default: break;
13153           }
13154           if (Opc) {
13155             SDValue Sign = DAG.getNode(Opc, DL, MaskVT, X, Mask.getOperand(1));
13156             return DAG.getNode(ISD::BITCAST, DL, MVT::v2i64, Sign);
13157           }
13158         }
13159         // PBLENDVB only available on SSE 4.1
13160         if (!Subtarget->hasSSE41())
13161           return SDValue();
13162
13163         X = DAG.getNode(ISD::BITCAST, DL, MVT::v16i8, X);
13164         Y = DAG.getNode(ISD::BITCAST, DL, MVT::v16i8, Y);
13165         Mask = DAG.getNode(ISD::BITCAST, DL, MVT::v16i8, Mask);
13166         Mask = DAG.getNode(X86ISD::PBLENDVB, DL, MVT::v16i8, X, Y, Mask);
13167         return DAG.getNode(ISD::BITCAST, DL, MVT::v2i64, Mask);
13168       }
13169     }
13170   }
13171
13172   // fold (or (x << c) | (y >> (64 - c))) ==> (shld64 x, y, c)
13173   if (N0.getOpcode() == ISD::SRL && N1.getOpcode() == ISD::SHL)
13174     std::swap(N0, N1);
13175   if (N0.getOpcode() != ISD::SHL || N1.getOpcode() != ISD::SRL)
13176     return SDValue();
13177   if (!N0.hasOneUse() || !N1.hasOneUse())
13178     return SDValue();
13179
13180   SDValue ShAmt0 = N0.getOperand(1);
13181   if (ShAmt0.getValueType() != MVT::i8)
13182     return SDValue();
13183   SDValue ShAmt1 = N1.getOperand(1);
13184   if (ShAmt1.getValueType() != MVT::i8)
13185     return SDValue();
13186   if (ShAmt0.getOpcode() == ISD::TRUNCATE)
13187     ShAmt0 = ShAmt0.getOperand(0);
13188   if (ShAmt1.getOpcode() == ISD::TRUNCATE)
13189     ShAmt1 = ShAmt1.getOperand(0);
13190
13191   DebugLoc DL = N->getDebugLoc();
13192   unsigned Opc = X86ISD::SHLD;
13193   SDValue Op0 = N0.getOperand(0);
13194   SDValue Op1 = N1.getOperand(0);
13195   if (ShAmt0.getOpcode() == ISD::SUB) {
13196     Opc = X86ISD::SHRD;
13197     std::swap(Op0, Op1);
13198     std::swap(ShAmt0, ShAmt1);
13199   }
13200
13201   unsigned Bits = VT.getSizeInBits();
13202   if (ShAmt1.getOpcode() == ISD::SUB) {
13203     SDValue Sum = ShAmt1.getOperand(0);
13204     if (ConstantSDNode *SumC = dyn_cast<ConstantSDNode>(Sum)) {
13205       SDValue ShAmt1Op1 = ShAmt1.getOperand(1);
13206       if (ShAmt1Op1.getNode()->getOpcode() == ISD::TRUNCATE)
13207         ShAmt1Op1 = ShAmt1Op1.getOperand(0);
13208       if (SumC->getSExtValue() == Bits && ShAmt1Op1 == ShAmt0)
13209         return DAG.getNode(Opc, DL, VT,
13210                            Op0, Op1,
13211                            DAG.getNode(ISD::TRUNCATE, DL,
13212                                        MVT::i8, ShAmt0));
13213     }
13214   } else if (ConstantSDNode *ShAmt1C = dyn_cast<ConstantSDNode>(ShAmt1)) {
13215     ConstantSDNode *ShAmt0C = dyn_cast<ConstantSDNode>(ShAmt0);
13216     if (ShAmt0C &&
13217         ShAmt0C->getSExtValue() + ShAmt1C->getSExtValue() == Bits)
13218       return DAG.getNode(Opc, DL, VT,
13219                          N0.getOperand(0), N1.getOperand(0),
13220                          DAG.getNode(ISD::TRUNCATE, DL,
13221                                        MVT::i8, ShAmt0));
13222   }
13223
13224   return SDValue();
13225 }
13226
13227 /// PerformSTORECombine - Do target-specific dag combines on STORE nodes.
13228 static SDValue PerformSTORECombine(SDNode *N, SelectionDAG &DAG,
13229                                    const X86Subtarget *Subtarget) {
13230   StoreSDNode *St = cast<StoreSDNode>(N);
13231   EVT VT = St->getValue().getValueType();
13232   EVT StVT = St->getMemoryVT();
13233   DebugLoc dl = St->getDebugLoc();
13234   SDValue StoredVal = St->getOperand(1);
13235   const TargetLowering &TLI = DAG.getTargetLoweringInfo();
13236
13237   // If we are saving a concatination of two XMM registers, perform two stores.
13238   // This is better in Sandy Bridge cause one 256-bit mem op is done via two
13239   // 128-bit ones. If in the future the cost becomes only one memory access the
13240   // first version would be better.
13241   if (VT.getSizeInBits() == 256 &&
13242     StoredVal.getNode()->getOpcode() == ISD::CONCAT_VECTORS &&
13243     StoredVal.getNumOperands() == 2) {
13244
13245     SDValue Value0 = StoredVal.getOperand(0);
13246     SDValue Value1 = StoredVal.getOperand(1);
13247
13248     SDValue Stride = DAG.getConstant(16, TLI.getPointerTy());
13249     SDValue Ptr0 = St->getBasePtr();
13250     SDValue Ptr1 = DAG.getNode(ISD::ADD, dl, Ptr0.getValueType(), Ptr0, Stride);
13251
13252     SDValue Ch0 = DAG.getStore(St->getChain(), dl, Value0, Ptr0,
13253                                 St->getPointerInfo(), St->isVolatile(),
13254                                 St->isNonTemporal(), St->getAlignment());
13255     SDValue Ch1 = DAG.getStore(St->getChain(), dl, Value1, Ptr1,
13256                                 St->getPointerInfo(), St->isVolatile(),
13257                                 St->isNonTemporal(), St->getAlignment());
13258     return DAG.getNode(ISD::TokenFactor, dl, MVT::Other, Ch0, Ch1);
13259   }
13260
13261   // Optimize trunc store (of multiple scalars) to shuffle and store.
13262   // First, pack all of the elements in one place. Next, store to memory
13263   // in fewer chunks.
13264   if (St->isTruncatingStore() && VT.isVector()) {
13265     const TargetLowering &TLI = DAG.getTargetLoweringInfo();
13266     unsigned NumElems = VT.getVectorNumElements();
13267     assert(StVT != VT && "Cannot truncate to the same type");
13268     unsigned FromSz = VT.getVectorElementType().getSizeInBits();
13269     unsigned ToSz = StVT.getVectorElementType().getSizeInBits();
13270
13271     // From, To sizes and ElemCount must be pow of two
13272     if (!isPowerOf2_32(NumElems * FromSz * ToSz)) return SDValue();
13273     // We are going to use the original vector elt for storing.
13274     // accumulated smaller vector elements must be a multiple of bigger size.
13275     if (0 != (NumElems * ToSz) % FromSz) return SDValue();
13276     unsigned SizeRatio  = FromSz / ToSz;
13277
13278     assert(SizeRatio * NumElems * ToSz == VT.getSizeInBits());
13279
13280     // Create a type on which we perform the shuffle
13281     EVT WideVecVT = EVT::getVectorVT(*DAG.getContext(),
13282             StVT.getScalarType(), NumElems*SizeRatio);
13283
13284     assert(WideVecVT.getSizeInBits() == VT.getSizeInBits());
13285
13286     SDValue WideVec = DAG.getNode(ISD::BITCAST, dl, WideVecVT, St->getValue());
13287     SmallVector<int, 8> ShuffleVec(NumElems * SizeRatio, -1);
13288     for (unsigned i = 0; i < NumElems; i++ ) ShuffleVec[i] = i * SizeRatio;
13289
13290     // Can't shuffle using an illegal type
13291     if (!TLI.isTypeLegal(WideVecVT)) return SDValue();
13292
13293     SDValue Shuff = DAG.getVectorShuffle(WideVecVT, dl, WideVec,
13294                                 DAG.getUNDEF(WideVec.getValueType()),
13295                                 ShuffleVec.data());
13296     // At this point all of the data is stored at the bottom of the
13297     // register. We now need to save it to mem.
13298
13299     // Find the largest store unit
13300     MVT StoreType = MVT::i8;
13301     for (unsigned tp = MVT::FIRST_INTEGER_VALUETYPE;
13302          tp < MVT::LAST_INTEGER_VALUETYPE; ++tp) {
13303       MVT Tp = (MVT::SimpleValueType)tp;
13304       if (TLI.isTypeLegal(Tp) && StoreType.getSizeInBits() < NumElems * ToSz)
13305         StoreType = Tp;
13306     }
13307
13308     // Bitcast the original vector into a vector of store-size units
13309     EVT StoreVecVT = EVT::getVectorVT(*DAG.getContext(),
13310             StoreType, VT.getSizeInBits()/EVT(StoreType).getSizeInBits());
13311     assert(StoreVecVT.getSizeInBits() == VT.getSizeInBits());
13312     SDValue ShuffWide = DAG.getNode(ISD::BITCAST, dl, StoreVecVT, Shuff);
13313     SmallVector<SDValue, 8> Chains;
13314     SDValue Increment = DAG.getConstant(StoreType.getSizeInBits()/8,
13315                                         TLI.getPointerTy());
13316     SDValue Ptr = St->getBasePtr();
13317
13318     // Perform one or more big stores into memory.
13319     for (unsigned i = 0; i < (ToSz*NumElems)/StoreType.getSizeInBits() ; i++) {
13320       SDValue SubVec = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl,
13321                                    StoreType, ShuffWide,
13322                                    DAG.getIntPtrConstant(i));
13323       SDValue Ch = DAG.getStore(St->getChain(), dl, SubVec, Ptr,
13324                                 St->getPointerInfo(), St->isVolatile(),
13325                                 St->isNonTemporal(), St->getAlignment());
13326       Ptr = DAG.getNode(ISD::ADD, dl, Ptr.getValueType(), Ptr, Increment);
13327       Chains.push_back(Ch);
13328     }
13329
13330     return DAG.getNode(ISD::TokenFactor, dl, MVT::Other, &Chains[0],
13331                                Chains.size());
13332   }
13333
13334
13335   // Turn load->store of MMX types into GPR load/stores.  This avoids clobbering
13336   // the FP state in cases where an emms may be missing.
13337   // A preferable solution to the general problem is to figure out the right
13338   // places to insert EMMS.  This qualifies as a quick hack.
13339
13340   // Similarly, turn load->store of i64 into double load/stores in 32-bit mode.
13341   if (VT.getSizeInBits() != 64)
13342     return SDValue();
13343
13344   const Function *F = DAG.getMachineFunction().getFunction();
13345   bool NoImplicitFloatOps = F->hasFnAttr(Attribute::NoImplicitFloat);
13346   bool F64IsLegal = !UseSoftFloat && !NoImplicitFloatOps
13347     && Subtarget->hasSSE2();
13348   if ((VT.isVector() ||
13349        (VT == MVT::i64 && F64IsLegal && !Subtarget->is64Bit())) &&
13350       isa<LoadSDNode>(St->getValue()) &&
13351       !cast<LoadSDNode>(St->getValue())->isVolatile() &&
13352       St->getChain().hasOneUse() && !St->isVolatile()) {
13353     SDNode* LdVal = St->getValue().getNode();
13354     LoadSDNode *Ld = 0;
13355     int TokenFactorIndex = -1;
13356     SmallVector<SDValue, 8> Ops;
13357     SDNode* ChainVal = St->getChain().getNode();
13358     // Must be a store of a load.  We currently handle two cases:  the load
13359     // is a direct child, and it's under an intervening TokenFactor.  It is
13360     // possible to dig deeper under nested TokenFactors.
13361     if (ChainVal == LdVal)
13362       Ld = cast<LoadSDNode>(St->getChain());
13363     else if (St->getValue().hasOneUse() &&
13364              ChainVal->getOpcode() == ISD::TokenFactor) {
13365       for (unsigned i=0, e = ChainVal->getNumOperands(); i != e; ++i) {
13366         if (ChainVal->getOperand(i).getNode() == LdVal) {
13367           TokenFactorIndex = i;
13368           Ld = cast<LoadSDNode>(St->getValue());
13369         } else
13370           Ops.push_back(ChainVal->getOperand(i));
13371       }
13372     }
13373
13374     if (!Ld || !ISD::isNormalLoad(Ld))
13375       return SDValue();
13376
13377     // If this is not the MMX case, i.e. we are just turning i64 load/store
13378     // into f64 load/store, avoid the transformation if there are multiple
13379     // uses of the loaded value.
13380     if (!VT.isVector() && !Ld->hasNUsesOfValue(1, 0))
13381       return SDValue();
13382
13383     DebugLoc LdDL = Ld->getDebugLoc();
13384     DebugLoc StDL = N->getDebugLoc();
13385     // If we are a 64-bit capable x86, lower to a single movq load/store pair.
13386     // Otherwise, if it's legal to use f64 SSE instructions, use f64 load/store
13387     // pair instead.
13388     if (Subtarget->is64Bit() || F64IsLegal) {
13389       EVT LdVT = Subtarget->is64Bit() ? MVT::i64 : MVT::f64;
13390       SDValue NewLd = DAG.getLoad(LdVT, LdDL, Ld->getChain(), Ld->getBasePtr(),
13391                                   Ld->getPointerInfo(), Ld->isVolatile(),
13392                                   Ld->isNonTemporal(), Ld->getAlignment());
13393       SDValue NewChain = NewLd.getValue(1);
13394       if (TokenFactorIndex != -1) {
13395         Ops.push_back(NewChain);
13396         NewChain = DAG.getNode(ISD::TokenFactor, LdDL, MVT::Other, &Ops[0],
13397                                Ops.size());
13398       }
13399       return DAG.getStore(NewChain, StDL, NewLd, St->getBasePtr(),
13400                           St->getPointerInfo(),
13401                           St->isVolatile(), St->isNonTemporal(),
13402                           St->getAlignment());
13403     }
13404
13405     // Otherwise, lower to two pairs of 32-bit loads / stores.
13406     SDValue LoAddr = Ld->getBasePtr();
13407     SDValue HiAddr = DAG.getNode(ISD::ADD, LdDL, MVT::i32, LoAddr,
13408                                  DAG.getConstant(4, MVT::i32));
13409
13410     SDValue LoLd = DAG.getLoad(MVT::i32, LdDL, Ld->getChain(), LoAddr,
13411                                Ld->getPointerInfo(),
13412                                Ld->isVolatile(), Ld->isNonTemporal(),
13413                                Ld->getAlignment());
13414     SDValue HiLd = DAG.getLoad(MVT::i32, LdDL, Ld->getChain(), HiAddr,
13415                                Ld->getPointerInfo().getWithOffset(4),
13416                                Ld->isVolatile(), Ld->isNonTemporal(),
13417                                MinAlign(Ld->getAlignment(), 4));
13418
13419     SDValue NewChain = LoLd.getValue(1);
13420     if (TokenFactorIndex != -1) {
13421       Ops.push_back(LoLd);
13422       Ops.push_back(HiLd);
13423       NewChain = DAG.getNode(ISD::TokenFactor, LdDL, MVT::Other, &Ops[0],
13424                              Ops.size());
13425     }
13426
13427     LoAddr = St->getBasePtr();
13428     HiAddr = DAG.getNode(ISD::ADD, StDL, MVT::i32, LoAddr,
13429                          DAG.getConstant(4, MVT::i32));
13430
13431     SDValue LoSt = DAG.getStore(NewChain, StDL, LoLd, LoAddr,
13432                                 St->getPointerInfo(),
13433                                 St->isVolatile(), St->isNonTemporal(),
13434                                 St->getAlignment());
13435     SDValue HiSt = DAG.getStore(NewChain, StDL, HiLd, HiAddr,
13436                                 St->getPointerInfo().getWithOffset(4),
13437                                 St->isVolatile(),
13438                                 St->isNonTemporal(),
13439                                 MinAlign(St->getAlignment(), 4));
13440     return DAG.getNode(ISD::TokenFactor, StDL, MVT::Other, LoSt, HiSt);
13441   }
13442   return SDValue();
13443 }
13444
13445 /// PerformFORCombine - Do target-specific dag combines on X86ISD::FOR and
13446 /// X86ISD::FXOR nodes.
13447 static SDValue PerformFORCombine(SDNode *N, SelectionDAG &DAG) {
13448   assert(N->getOpcode() == X86ISD::FOR || N->getOpcode() == X86ISD::FXOR);
13449   // F[X]OR(0.0, x) -> x
13450   // F[X]OR(x, 0.0) -> x
13451   if (ConstantFPSDNode *C = dyn_cast<ConstantFPSDNode>(N->getOperand(0)))
13452     if (C->getValueAPF().isPosZero())
13453       return N->getOperand(1);
13454   if (ConstantFPSDNode *C = dyn_cast<ConstantFPSDNode>(N->getOperand(1)))
13455     if (C->getValueAPF().isPosZero())
13456       return N->getOperand(0);
13457   return SDValue();
13458 }
13459
13460 /// PerformFANDCombine - Do target-specific dag combines on X86ISD::FAND nodes.
13461 static SDValue PerformFANDCombine(SDNode *N, SelectionDAG &DAG) {
13462   // FAND(0.0, x) -> 0.0
13463   // FAND(x, 0.0) -> 0.0
13464   if (ConstantFPSDNode *C = dyn_cast<ConstantFPSDNode>(N->getOperand(0)))
13465     if (C->getValueAPF().isPosZero())
13466       return N->getOperand(0);
13467   if (ConstantFPSDNode *C = dyn_cast<ConstantFPSDNode>(N->getOperand(1)))
13468     if (C->getValueAPF().isPosZero())
13469       return N->getOperand(1);
13470   return SDValue();
13471 }
13472
13473 static SDValue PerformBTCombine(SDNode *N,
13474                                 SelectionDAG &DAG,
13475                                 TargetLowering::DAGCombinerInfo &DCI) {
13476   // BT ignores high bits in the bit index operand.
13477   SDValue Op1 = N->getOperand(1);
13478   if (Op1.hasOneUse()) {
13479     unsigned BitWidth = Op1.getValueSizeInBits();
13480     APInt DemandedMask = APInt::getLowBitsSet(BitWidth, Log2_32(BitWidth));
13481     APInt KnownZero, KnownOne;
13482     TargetLowering::TargetLoweringOpt TLO(DAG, !DCI.isBeforeLegalize(),
13483                                           !DCI.isBeforeLegalizeOps());
13484     const TargetLowering &TLI = DAG.getTargetLoweringInfo();
13485     if (TLO.ShrinkDemandedConstant(Op1, DemandedMask) ||
13486         TLI.SimplifyDemandedBits(Op1, DemandedMask, KnownZero, KnownOne, TLO))
13487       DCI.CommitTargetLoweringOpt(TLO);
13488   }
13489   return SDValue();
13490 }
13491
13492 static SDValue PerformVZEXT_MOVLCombine(SDNode *N, SelectionDAG &DAG) {
13493   SDValue Op = N->getOperand(0);
13494   if (Op.getOpcode() == ISD::BITCAST)
13495     Op = Op.getOperand(0);
13496   EVT VT = N->getValueType(0), OpVT = Op.getValueType();
13497   if (Op.getOpcode() == X86ISD::VZEXT_LOAD &&
13498       VT.getVectorElementType().getSizeInBits() ==
13499       OpVT.getVectorElementType().getSizeInBits()) {
13500     return DAG.getNode(ISD::BITCAST, N->getDebugLoc(), VT, Op);
13501   }
13502   return SDValue();
13503 }
13504
13505 static SDValue PerformZExtCombine(SDNode *N, SelectionDAG &DAG) {
13506   // (i32 zext (and (i8  x86isd::setcc_carry), 1)) ->
13507   //           (and (i32 x86isd::setcc_carry), 1)
13508   // This eliminates the zext. This transformation is necessary because
13509   // ISD::SETCC is always legalized to i8.
13510   DebugLoc dl = N->getDebugLoc();
13511   SDValue N0 = N->getOperand(0);
13512   EVT VT = N->getValueType(0);
13513   if (N0.getOpcode() == ISD::AND &&
13514       N0.hasOneUse() &&
13515       N0.getOperand(0).hasOneUse()) {
13516     SDValue N00 = N0.getOperand(0);
13517     if (N00.getOpcode() != X86ISD::SETCC_CARRY)
13518       return SDValue();
13519     ConstantSDNode *C = dyn_cast<ConstantSDNode>(N0.getOperand(1));
13520     if (!C || C->getZExtValue() != 1)
13521       return SDValue();
13522     return DAG.getNode(ISD::AND, dl, VT,
13523                        DAG.getNode(X86ISD::SETCC_CARRY, dl, VT,
13524                                    N00.getOperand(0), N00.getOperand(1)),
13525                        DAG.getConstant(1, VT));
13526   }
13527
13528   return SDValue();
13529 }
13530
13531 // Optimize  RES = X86ISD::SETCC CONDCODE, EFLAG_INPUT
13532 static SDValue PerformSETCCCombine(SDNode *N, SelectionDAG &DAG) {
13533   unsigned X86CC = N->getConstantOperandVal(0);
13534   SDValue EFLAG = N->getOperand(1);
13535   DebugLoc DL = N->getDebugLoc();
13536
13537   // Materialize "setb reg" as "sbb reg,reg", since it can be extended without
13538   // a zext and produces an all-ones bit which is more useful than 0/1 in some
13539   // cases.
13540   if (X86CC == X86::COND_B)
13541     return DAG.getNode(ISD::AND, DL, MVT::i8,
13542                        DAG.getNode(X86ISD::SETCC_CARRY, DL, MVT::i8,
13543                                    DAG.getConstant(X86CC, MVT::i8), EFLAG),
13544                        DAG.getConstant(1, MVT::i8));
13545
13546   return SDValue();
13547 }
13548
13549 static SDValue PerformSINT_TO_FPCombine(SDNode *N, SelectionDAG &DAG,
13550                                         const X86TargetLowering *XTLI) {
13551   SDValue Op0 = N->getOperand(0);
13552   // Transform (SINT_TO_FP (i64 ...)) into an x87 operation if we have
13553   // a 32-bit target where SSE doesn't support i64->FP operations.
13554   if (Op0.getOpcode() == ISD::LOAD) {
13555     LoadSDNode *Ld = cast<LoadSDNode>(Op0.getNode());
13556     EVT VT = Ld->getValueType(0);
13557     if (!Ld->isVolatile() && !N->getValueType(0).isVector() &&
13558         ISD::isNON_EXTLoad(Op0.getNode()) && Op0.hasOneUse() &&
13559         !XTLI->getSubtarget()->is64Bit() &&
13560         !DAG.getTargetLoweringInfo().isTypeLegal(VT)) {
13561       SDValue FILDChain = XTLI->BuildFILD(SDValue(N, 0), Ld->getValueType(0),
13562                                           Ld->getChain(), Op0, DAG);
13563       DAG.ReplaceAllUsesOfValueWith(Op0.getValue(1), FILDChain.getValue(1));
13564       return FILDChain;
13565     }
13566   }
13567   return SDValue();
13568 }
13569
13570 // Optimize RES, EFLAGS = X86ISD::ADC LHS, RHS, EFLAGS
13571 static SDValue PerformADCCombine(SDNode *N, SelectionDAG &DAG,
13572                                  X86TargetLowering::DAGCombinerInfo &DCI) {
13573   // If the LHS and RHS of the ADC node are zero, then it can't overflow and
13574   // the result is either zero or one (depending on the input carry bit).
13575   // Strength reduce this down to a "set on carry" aka SETCC_CARRY&1.
13576   if (X86::isZeroNode(N->getOperand(0)) &&
13577       X86::isZeroNode(N->getOperand(1)) &&
13578       // We don't have a good way to replace an EFLAGS use, so only do this when
13579       // dead right now.
13580       SDValue(N, 1).use_empty()) {
13581     DebugLoc DL = N->getDebugLoc();
13582     EVT VT = N->getValueType(0);
13583     SDValue CarryOut = DAG.getConstant(0, N->getValueType(1));
13584     SDValue Res1 = DAG.getNode(ISD::AND, DL, VT,
13585                                DAG.getNode(X86ISD::SETCC_CARRY, DL, VT,
13586                                            DAG.getConstant(X86::COND_B,MVT::i8),
13587                                            N->getOperand(2)),
13588                                DAG.getConstant(1, VT));
13589     return DCI.CombineTo(N, Res1, CarryOut);
13590   }
13591
13592   return SDValue();
13593 }
13594
13595 // fold (add Y, (sete  X, 0)) -> adc  0, Y
13596 //      (add Y, (setne X, 0)) -> sbb -1, Y
13597 //      (sub (sete  X, 0), Y) -> sbb  0, Y
13598 //      (sub (setne X, 0), Y) -> adc -1, Y
13599 static SDValue OptimizeConditionalInDecrement(SDNode *N, SelectionDAG &DAG) {
13600   DebugLoc DL = N->getDebugLoc();
13601
13602   // Look through ZExts.
13603   SDValue Ext = N->getOperand(N->getOpcode() == ISD::SUB ? 1 : 0);
13604   if (Ext.getOpcode() != ISD::ZERO_EXTEND || !Ext.hasOneUse())
13605     return SDValue();
13606
13607   SDValue SetCC = Ext.getOperand(0);
13608   if (SetCC.getOpcode() != X86ISD::SETCC || !SetCC.hasOneUse())
13609     return SDValue();
13610
13611   X86::CondCode CC = (X86::CondCode)SetCC.getConstantOperandVal(0);
13612   if (CC != X86::COND_E && CC != X86::COND_NE)
13613     return SDValue();
13614
13615   SDValue Cmp = SetCC.getOperand(1);
13616   if (Cmp.getOpcode() != X86ISD::CMP || !Cmp.hasOneUse() ||
13617       !X86::isZeroNode(Cmp.getOperand(1)) ||
13618       !Cmp.getOperand(0).getValueType().isInteger())
13619     return SDValue();
13620
13621   SDValue CmpOp0 = Cmp.getOperand(0);
13622   SDValue NewCmp = DAG.getNode(X86ISD::CMP, DL, MVT::i32, CmpOp0,
13623                                DAG.getConstant(1, CmpOp0.getValueType()));
13624
13625   SDValue OtherVal = N->getOperand(N->getOpcode() == ISD::SUB ? 0 : 1);
13626   if (CC == X86::COND_NE)
13627     return DAG.getNode(N->getOpcode() == ISD::SUB ? X86ISD::ADC : X86ISD::SBB,
13628                        DL, OtherVal.getValueType(), OtherVal,
13629                        DAG.getConstant(-1ULL, OtherVal.getValueType()), NewCmp);
13630   return DAG.getNode(N->getOpcode() == ISD::SUB ? X86ISD::SBB : X86ISD::ADC,
13631                      DL, OtherVal.getValueType(), OtherVal,
13632                      DAG.getConstant(0, OtherVal.getValueType()), NewCmp);
13633 }
13634
13635 static SDValue PerformSubCombine(SDNode *N, SelectionDAG &DAG) {
13636   SDValue Op0 = N->getOperand(0);
13637   SDValue Op1 = N->getOperand(1);
13638
13639   // X86 can't encode an immediate LHS of a sub. See if we can push the
13640   // negation into a preceding instruction.
13641   if (ConstantSDNode *C = dyn_cast<ConstantSDNode>(Op0)) {
13642     // If the RHS of the sub is a XOR with one use and a constant, invert the
13643     // immediate. Then add one to the LHS of the sub so we can turn
13644     // X-Y -> X+~Y+1, saving one register.
13645     if (Op1->hasOneUse() && Op1.getOpcode() == ISD::XOR &&
13646         isa<ConstantSDNode>(Op1.getOperand(1))) {
13647       APInt XorC = cast<ConstantSDNode>(Op1.getOperand(1))->getAPIntValue();
13648       EVT VT = Op0.getValueType();
13649       SDValue NewXor = DAG.getNode(ISD::XOR, Op1.getDebugLoc(), VT,
13650                                    Op1.getOperand(0),
13651                                    DAG.getConstant(~XorC, VT));
13652       return DAG.getNode(ISD::ADD, N->getDebugLoc(), VT, NewXor,
13653                          DAG.getConstant(C->getAPIntValue()+1, VT));
13654     }
13655   }
13656
13657   return OptimizeConditionalInDecrement(N, DAG);
13658 }
13659
13660 SDValue X86TargetLowering::PerformDAGCombine(SDNode *N,
13661                                              DAGCombinerInfo &DCI) const {
13662   SelectionDAG &DAG = DCI.DAG;
13663   switch (N->getOpcode()) {
13664   default: break;
13665   case ISD::EXTRACT_VECTOR_ELT:
13666     return PerformEXTRACT_VECTOR_ELTCombine(N, DAG, *this);
13667   case ISD::SELECT:         return PerformSELECTCombine(N, DAG, Subtarget);
13668   case X86ISD::CMOV:        return PerformCMOVCombine(N, DAG, DCI);
13669   case ISD::ADD:            return OptimizeConditionalInDecrement(N, DAG);
13670   case ISD::SUB:            return PerformSubCombine(N, DAG);
13671   case X86ISD::ADC:         return PerformADCCombine(N, DAG, DCI);
13672   case ISD::MUL:            return PerformMulCombine(N, DAG, DCI);
13673   case ISD::SHL:
13674   case ISD::SRA:
13675   case ISD::SRL:            return PerformShiftCombine(N, DAG, Subtarget);
13676   case ISD::AND:            return PerformAndCombine(N, DAG, DCI, Subtarget);
13677   case ISD::OR:             return PerformOrCombine(N, DAG, DCI, Subtarget);
13678   case ISD::STORE:          return PerformSTORECombine(N, DAG, Subtarget);
13679   case ISD::SINT_TO_FP:     return PerformSINT_TO_FPCombine(N, DAG, this);
13680   case X86ISD::FXOR:
13681   case X86ISD::FOR:         return PerformFORCombine(N, DAG);
13682   case X86ISD::FAND:        return PerformFANDCombine(N, DAG);
13683   case X86ISD::BT:          return PerformBTCombine(N, DAG, DCI);
13684   case X86ISD::VZEXT_MOVL:  return PerformVZEXT_MOVLCombine(N, DAG);
13685   case ISD::ZERO_EXTEND:    return PerformZExtCombine(N, DAG);
13686   case X86ISD::SETCC:       return PerformSETCCCombine(N, DAG);
13687   case X86ISD::SHUFPS:      // Handle all target specific shuffles
13688   case X86ISD::SHUFPD:
13689   case X86ISD::PALIGN:
13690   case X86ISD::PUNPCKHBW:
13691   case X86ISD::PUNPCKHWD:
13692   case X86ISD::PUNPCKHDQ:
13693   case X86ISD::PUNPCKHQDQ:
13694   case X86ISD::UNPCKHPS:
13695   case X86ISD::UNPCKHPD:
13696   case X86ISD::VUNPCKHPSY:
13697   case X86ISD::VUNPCKHPDY:
13698   case X86ISD::PUNPCKLBW:
13699   case X86ISD::PUNPCKLWD:
13700   case X86ISD::PUNPCKLDQ:
13701   case X86ISD::PUNPCKLQDQ:
13702   case X86ISD::UNPCKLPS:
13703   case X86ISD::UNPCKLPD:
13704   case X86ISD::VUNPCKLPSY:
13705   case X86ISD::VUNPCKLPDY:
13706   case X86ISD::MOVHLPS:
13707   case X86ISD::MOVLHPS:
13708   case X86ISD::PSHUFD:
13709   case X86ISD::PSHUFHW:
13710   case X86ISD::PSHUFLW:
13711   case X86ISD::MOVSS:
13712   case X86ISD::MOVSD:
13713   case X86ISD::VPERMILPS:
13714   case X86ISD::VPERMILPSY:
13715   case X86ISD::VPERMILPD:
13716   case X86ISD::VPERMILPDY:
13717   case X86ISD::VPERM2F128:
13718   case ISD::VECTOR_SHUFFLE: return PerformShuffleCombine(N, DAG, DCI,Subtarget);
13719   }
13720
13721   return SDValue();
13722 }
13723
13724 /// isTypeDesirableForOp - Return true if the target has native support for
13725 /// the specified value type and it is 'desirable' to use the type for the
13726 /// given node type. e.g. On x86 i16 is legal, but undesirable since i16
13727 /// instruction encodings are longer and some i16 instructions are slow.
13728 bool X86TargetLowering::isTypeDesirableForOp(unsigned Opc, EVT VT) const {
13729   if (!isTypeLegal(VT))
13730     return false;
13731   if (VT != MVT::i16)
13732     return true;
13733
13734   switch (Opc) {
13735   default:
13736     return true;
13737   case ISD::LOAD:
13738   case ISD::SIGN_EXTEND:
13739   case ISD::ZERO_EXTEND:
13740   case ISD::ANY_EXTEND:
13741   case ISD::SHL:
13742   case ISD::SRL:
13743   case ISD::SUB:
13744   case ISD::ADD:
13745   case ISD::MUL:
13746   case ISD::AND:
13747   case ISD::OR:
13748   case ISD::XOR:
13749     return false;
13750   }
13751 }
13752
13753 /// IsDesirableToPromoteOp - This method query the target whether it is
13754 /// beneficial for dag combiner to promote the specified node. If true, it
13755 /// should return the desired promotion type by reference.
13756 bool X86TargetLowering::IsDesirableToPromoteOp(SDValue Op, EVT &PVT) const {
13757   EVT VT = Op.getValueType();
13758   if (VT != MVT::i16)
13759     return false;
13760
13761   bool Promote = false;
13762   bool Commute = false;
13763   switch (Op.getOpcode()) {
13764   default: break;
13765   case ISD::LOAD: {
13766     LoadSDNode *LD = cast<LoadSDNode>(Op);
13767     // If the non-extending load has a single use and it's not live out, then it
13768     // might be folded.
13769     if (LD->getExtensionType() == ISD::NON_EXTLOAD /*&&
13770                                                      Op.hasOneUse()*/) {
13771       for (SDNode::use_iterator UI = Op.getNode()->use_begin(),
13772              UE = Op.getNode()->use_end(); UI != UE; ++UI) {
13773         // The only case where we'd want to promote LOAD (rather then it being
13774         // promoted as an operand is when it's only use is liveout.
13775         if (UI->getOpcode() != ISD::CopyToReg)
13776           return false;
13777       }
13778     }
13779     Promote = true;
13780     break;
13781   }
13782   case ISD::SIGN_EXTEND:
13783   case ISD::ZERO_EXTEND:
13784   case ISD::ANY_EXTEND:
13785     Promote = true;
13786     break;
13787   case ISD::SHL:
13788   case ISD::SRL: {
13789     SDValue N0 = Op.getOperand(0);
13790     // Look out for (store (shl (load), x)).
13791     if (MayFoldLoad(N0) && MayFoldIntoStore(Op))
13792       return false;
13793     Promote = true;
13794     break;
13795   }
13796   case ISD::ADD:
13797   case ISD::MUL:
13798   case ISD::AND:
13799   case ISD::OR:
13800   case ISD::XOR:
13801     Commute = true;
13802     // fallthrough
13803   case ISD::SUB: {
13804     SDValue N0 = Op.getOperand(0);
13805     SDValue N1 = Op.getOperand(1);
13806     if (!Commute && MayFoldLoad(N1))
13807       return false;
13808     // Avoid disabling potential load folding opportunities.
13809     if (MayFoldLoad(N0) && (!isa<ConstantSDNode>(N1) || MayFoldIntoStore(Op)))
13810       return false;
13811     if (MayFoldLoad(N1) && (!isa<ConstantSDNode>(N0) || MayFoldIntoStore(Op)))
13812       return false;
13813     Promote = true;
13814   }
13815   }
13816
13817   PVT = MVT::i32;
13818   return Promote;
13819 }
13820
13821 //===----------------------------------------------------------------------===//
13822 //                           X86 Inline Assembly Support
13823 //===----------------------------------------------------------------------===//
13824
13825 bool X86TargetLowering::ExpandInlineAsm(CallInst *CI) const {
13826   InlineAsm *IA = cast<InlineAsm>(CI->getCalledValue());
13827
13828   std::string AsmStr = IA->getAsmString();
13829
13830   // TODO: should remove alternatives from the asmstring: "foo {a|b}" -> "foo a"
13831   SmallVector<StringRef, 4> AsmPieces;
13832   SplitString(AsmStr, AsmPieces, ";\n");
13833
13834   switch (AsmPieces.size()) {
13835   default: return false;
13836   case 1:
13837     AsmStr = AsmPieces[0];
13838     AsmPieces.clear();
13839     SplitString(AsmStr, AsmPieces, " \t");  // Split with whitespace.
13840
13841     // FIXME: this should verify that we are targeting a 486 or better.  If not,
13842     // we will turn this bswap into something that will be lowered to logical ops
13843     // instead of emitting the bswap asm.  For now, we don't support 486 or lower
13844     // so don't worry about this.
13845     // bswap $0
13846     if (AsmPieces.size() == 2 &&
13847         (AsmPieces[0] == "bswap" ||
13848          AsmPieces[0] == "bswapq" ||
13849          AsmPieces[0] == "bswapl") &&
13850         (AsmPieces[1] == "$0" ||
13851          AsmPieces[1] == "${0:q}")) {
13852       // No need to check constraints, nothing other than the equivalent of
13853       // "=r,0" would be valid here.
13854       IntegerType *Ty = dyn_cast<IntegerType>(CI->getType());
13855       if (!Ty || Ty->getBitWidth() % 16 != 0)
13856         return false;
13857       return IntrinsicLowering::LowerToByteSwap(CI);
13858     }
13859     // rorw $$8, ${0:w}  -->  llvm.bswap.i16
13860     if (CI->getType()->isIntegerTy(16) &&
13861         AsmPieces.size() == 3 &&
13862         (AsmPieces[0] == "rorw" || AsmPieces[0] == "rolw") &&
13863         AsmPieces[1] == "$$8," &&
13864         AsmPieces[2] == "${0:w}" &&
13865         IA->getConstraintString().compare(0, 5, "=r,0,") == 0) {
13866       AsmPieces.clear();
13867       const std::string &ConstraintsStr = IA->getConstraintString();
13868       SplitString(StringRef(ConstraintsStr).substr(5), AsmPieces, ",");
13869       std::sort(AsmPieces.begin(), AsmPieces.end());
13870       if (AsmPieces.size() == 4 &&
13871           AsmPieces[0] == "~{cc}" &&
13872           AsmPieces[1] == "~{dirflag}" &&
13873           AsmPieces[2] == "~{flags}" &&
13874           AsmPieces[3] == "~{fpsr}") {
13875         IntegerType *Ty = dyn_cast<IntegerType>(CI->getType());
13876         if (!Ty || Ty->getBitWidth() % 16 != 0)
13877           return false;
13878         return IntrinsicLowering::LowerToByteSwap(CI);
13879       }
13880     }
13881     break;
13882   case 3:
13883     if (CI->getType()->isIntegerTy(32) &&
13884         IA->getConstraintString().compare(0, 5, "=r,0,") == 0) {
13885       SmallVector<StringRef, 4> Words;
13886       SplitString(AsmPieces[0], Words, " \t,");
13887       if (Words.size() == 3 && Words[0] == "rorw" && Words[1] == "$$8" &&
13888           Words[2] == "${0:w}") {
13889         Words.clear();
13890         SplitString(AsmPieces[1], Words, " \t,");
13891         if (Words.size() == 3 && Words[0] == "rorl" && Words[1] == "$$16" &&
13892             Words[2] == "$0") {
13893           Words.clear();
13894           SplitString(AsmPieces[2], Words, " \t,");
13895           if (Words.size() == 3 && Words[0] == "rorw" && Words[1] == "$$8" &&
13896               Words[2] == "${0:w}") {
13897             AsmPieces.clear();
13898             const std::string &ConstraintsStr = IA->getConstraintString();
13899             SplitString(StringRef(ConstraintsStr).substr(5), AsmPieces, ",");
13900             std::sort(AsmPieces.begin(), AsmPieces.end());
13901             if (AsmPieces.size() == 4 &&
13902                 AsmPieces[0] == "~{cc}" &&
13903                 AsmPieces[1] == "~{dirflag}" &&
13904                 AsmPieces[2] == "~{flags}" &&
13905                 AsmPieces[3] == "~{fpsr}") {
13906               IntegerType *Ty = dyn_cast<IntegerType>(CI->getType());
13907               if (!Ty || Ty->getBitWidth() % 16 != 0)
13908                 return false;
13909               return IntrinsicLowering::LowerToByteSwap(CI);
13910             }
13911           }
13912         }
13913       }
13914     }
13915
13916     if (CI->getType()->isIntegerTy(64)) {
13917       InlineAsm::ConstraintInfoVector Constraints = IA->ParseConstraints();
13918       if (Constraints.size() >= 2 &&
13919           Constraints[0].Codes.size() == 1 && Constraints[0].Codes[0] == "A" &&
13920           Constraints[1].Codes.size() == 1 && Constraints[1].Codes[0] == "0") {
13921         // bswap %eax / bswap %edx / xchgl %eax, %edx  -> llvm.bswap.i64
13922         SmallVector<StringRef, 4> Words;
13923         SplitString(AsmPieces[0], Words, " \t");
13924         if (Words.size() == 2 && Words[0] == "bswap" && Words[1] == "%eax") {
13925           Words.clear();
13926           SplitString(AsmPieces[1], Words, " \t");
13927           if (Words.size() == 2 && Words[0] == "bswap" && Words[1] == "%edx") {
13928             Words.clear();
13929             SplitString(AsmPieces[2], Words, " \t,");
13930             if (Words.size() == 3 && Words[0] == "xchgl" && Words[1] == "%eax" &&
13931                 Words[2] == "%edx") {
13932               IntegerType *Ty = dyn_cast<IntegerType>(CI->getType());
13933               if (!Ty || Ty->getBitWidth() % 16 != 0)
13934                 return false;
13935               return IntrinsicLowering::LowerToByteSwap(CI);
13936             }
13937           }
13938         }
13939       }
13940     }
13941     break;
13942   }
13943   return false;
13944 }
13945
13946
13947
13948 /// getConstraintType - Given a constraint letter, return the type of
13949 /// constraint it is for this target.
13950 X86TargetLowering::ConstraintType
13951 X86TargetLowering::getConstraintType(const std::string &Constraint) const {
13952   if (Constraint.size() == 1) {
13953     switch (Constraint[0]) {
13954     case 'R':
13955     case 'q':
13956     case 'Q':
13957     case 'f':
13958     case 't':
13959     case 'u':
13960     case 'y':
13961     case 'x':
13962     case 'Y':
13963     case 'l':
13964       return C_RegisterClass;
13965     case 'a':
13966     case 'b':
13967     case 'c':
13968     case 'd':
13969     case 'S':
13970     case 'D':
13971     case 'A':
13972       return C_Register;
13973     case 'I':
13974     case 'J':
13975     case 'K':
13976     case 'L':
13977     case 'M':
13978     case 'N':
13979     case 'G':
13980     case 'C':
13981     case 'e':
13982     case 'Z':
13983       return C_Other;
13984     default:
13985       break;
13986     }
13987   }
13988   return TargetLowering::getConstraintType(Constraint);
13989 }
13990
13991 /// Examine constraint type and operand type and determine a weight value.
13992 /// This object must already have been set up with the operand type
13993 /// and the current alternative constraint selected.
13994 TargetLowering::ConstraintWeight
13995   X86TargetLowering::getSingleConstraintMatchWeight(
13996     AsmOperandInfo &info, const char *constraint) const {
13997   ConstraintWeight weight = CW_Invalid;
13998   Value *CallOperandVal = info.CallOperandVal;
13999     // If we don't have a value, we can't do a match,
14000     // but allow it at the lowest weight.
14001   if (CallOperandVal == NULL)
14002     return CW_Default;
14003   Type *type = CallOperandVal->getType();
14004   // Look at the constraint type.
14005   switch (*constraint) {
14006   default:
14007     weight = TargetLowering::getSingleConstraintMatchWeight(info, constraint);
14008   case 'R':
14009   case 'q':
14010   case 'Q':
14011   case 'a':
14012   case 'b':
14013   case 'c':
14014   case 'd':
14015   case 'S':
14016   case 'D':
14017   case 'A':
14018     if (CallOperandVal->getType()->isIntegerTy())
14019       weight = CW_SpecificReg;
14020     break;
14021   case 'f':
14022   case 't':
14023   case 'u':
14024       if (type->isFloatingPointTy())
14025         weight = CW_SpecificReg;
14026       break;
14027   case 'y':
14028       if (type->isX86_MMXTy() && Subtarget->hasMMX())
14029         weight = CW_SpecificReg;
14030       break;
14031   case 'x':
14032   case 'Y':
14033     if ((type->getPrimitiveSizeInBits() == 128) && Subtarget->hasXMM())
14034       weight = CW_Register;
14035     break;
14036   case 'I':
14037     if (ConstantInt *C = dyn_cast<ConstantInt>(info.CallOperandVal)) {
14038       if (C->getZExtValue() <= 31)
14039         weight = CW_Constant;
14040     }
14041     break;
14042   case 'J':
14043     if (ConstantInt *C = dyn_cast<ConstantInt>(CallOperandVal)) {
14044       if (C->getZExtValue() <= 63)
14045         weight = CW_Constant;
14046     }
14047     break;
14048   case 'K':
14049     if (ConstantInt *C = dyn_cast<ConstantInt>(CallOperandVal)) {
14050       if ((C->getSExtValue() >= -0x80) && (C->getSExtValue() <= 0x7f))
14051         weight = CW_Constant;
14052     }
14053     break;
14054   case 'L':
14055     if (ConstantInt *C = dyn_cast<ConstantInt>(CallOperandVal)) {
14056       if ((C->getZExtValue() == 0xff) || (C->getZExtValue() == 0xffff))
14057         weight = CW_Constant;
14058     }
14059     break;
14060   case 'M':
14061     if (ConstantInt *C = dyn_cast<ConstantInt>(CallOperandVal)) {
14062       if (C->getZExtValue() <= 3)
14063         weight = CW_Constant;
14064     }
14065     break;
14066   case 'N':
14067     if (ConstantInt *C = dyn_cast<ConstantInt>(CallOperandVal)) {
14068       if (C->getZExtValue() <= 0xff)
14069         weight = CW_Constant;
14070     }
14071     break;
14072   case 'G':
14073   case 'C':
14074     if (dyn_cast<ConstantFP>(CallOperandVal)) {
14075       weight = CW_Constant;
14076     }
14077     break;
14078   case 'e':
14079     if (ConstantInt *C = dyn_cast<ConstantInt>(CallOperandVal)) {
14080       if ((C->getSExtValue() >= -0x80000000LL) &&
14081           (C->getSExtValue() <= 0x7fffffffLL))
14082         weight = CW_Constant;
14083     }
14084     break;
14085   case 'Z':
14086     if (ConstantInt *C = dyn_cast<ConstantInt>(CallOperandVal)) {
14087       if (C->getZExtValue() <= 0xffffffff)
14088         weight = CW_Constant;
14089     }
14090     break;
14091   }
14092   return weight;
14093 }
14094
14095 /// LowerXConstraint - try to replace an X constraint, which matches anything,
14096 /// with another that has more specific requirements based on the type of the
14097 /// corresponding operand.
14098 const char *X86TargetLowering::
14099 LowerXConstraint(EVT ConstraintVT) const {
14100   // FP X constraints get lowered to SSE1/2 registers if available, otherwise
14101   // 'f' like normal targets.
14102   if (ConstraintVT.isFloatingPoint()) {
14103     if (Subtarget->hasXMMInt())
14104       return "Y";
14105     if (Subtarget->hasXMM())
14106       return "x";
14107   }
14108
14109   return TargetLowering::LowerXConstraint(ConstraintVT);
14110 }
14111
14112 /// LowerAsmOperandForConstraint - Lower the specified operand into the Ops
14113 /// vector.  If it is invalid, don't add anything to Ops.
14114 void X86TargetLowering::LowerAsmOperandForConstraint(SDValue Op,
14115                                                      std::string &Constraint,
14116                                                      std::vector<SDValue>&Ops,
14117                                                      SelectionDAG &DAG) const {
14118   SDValue Result(0, 0);
14119
14120   // Only support length 1 constraints for now.
14121   if (Constraint.length() > 1) return;
14122
14123   char ConstraintLetter = Constraint[0];
14124   switch (ConstraintLetter) {
14125   default: break;
14126   case 'I':
14127     if (ConstantSDNode *C = dyn_cast<ConstantSDNode>(Op)) {
14128       if (C->getZExtValue() <= 31) {
14129         Result = DAG.getTargetConstant(C->getZExtValue(), Op.getValueType());
14130         break;
14131       }
14132     }
14133     return;
14134   case 'J':
14135     if (ConstantSDNode *C = dyn_cast<ConstantSDNode>(Op)) {
14136       if (C->getZExtValue() <= 63) {
14137         Result = DAG.getTargetConstant(C->getZExtValue(), Op.getValueType());
14138         break;
14139       }
14140     }
14141     return;
14142   case 'K':
14143     if (ConstantSDNode *C = dyn_cast<ConstantSDNode>(Op)) {
14144       if ((int8_t)C->getSExtValue() == C->getSExtValue()) {
14145         Result = DAG.getTargetConstant(C->getZExtValue(), Op.getValueType());
14146         break;
14147       }
14148     }
14149     return;
14150   case 'N':
14151     if (ConstantSDNode *C = dyn_cast<ConstantSDNode>(Op)) {
14152       if (C->getZExtValue() <= 255) {
14153         Result = DAG.getTargetConstant(C->getZExtValue(), Op.getValueType());
14154         break;
14155       }
14156     }
14157     return;
14158   case 'e': {
14159     // 32-bit signed value
14160     if (ConstantSDNode *C = dyn_cast<ConstantSDNode>(Op)) {
14161       if (ConstantInt::isValueValidForType(Type::getInt32Ty(*DAG.getContext()),
14162                                            C->getSExtValue())) {
14163         // Widen to 64 bits here to get it sign extended.
14164         Result = DAG.getTargetConstant(C->getSExtValue(), MVT::i64);
14165         break;
14166       }
14167     // FIXME gcc accepts some relocatable values here too, but only in certain
14168     // memory models; it's complicated.
14169     }
14170     return;
14171   }
14172   case 'Z': {
14173     // 32-bit unsigned value
14174     if (ConstantSDNode *C = dyn_cast<ConstantSDNode>(Op)) {
14175       if (ConstantInt::isValueValidForType(Type::getInt32Ty(*DAG.getContext()),
14176                                            C->getZExtValue())) {
14177         Result = DAG.getTargetConstant(C->getZExtValue(), Op.getValueType());
14178         break;
14179       }
14180     }
14181     // FIXME gcc accepts some relocatable values here too, but only in certain
14182     // memory models; it's complicated.
14183     return;
14184   }
14185   case 'i': {
14186     // Literal immediates are always ok.
14187     if (ConstantSDNode *CST = dyn_cast<ConstantSDNode>(Op)) {
14188       // Widen to 64 bits here to get it sign extended.
14189       Result = DAG.getTargetConstant(CST->getSExtValue(), MVT::i64);
14190       break;
14191     }
14192
14193     // In any sort of PIC mode addresses need to be computed at runtime by
14194     // adding in a register or some sort of table lookup.  These can't
14195     // be used as immediates.
14196     if (Subtarget->isPICStyleGOT() || Subtarget->isPICStyleStubPIC())
14197       return;
14198
14199     // If we are in non-pic codegen mode, we allow the address of a global (with
14200     // an optional displacement) to be used with 'i'.
14201     GlobalAddressSDNode *GA = 0;
14202     int64_t Offset = 0;
14203
14204     // Match either (GA), (GA+C), (GA+C1+C2), etc.
14205     while (1) {
14206       if ((GA = dyn_cast<GlobalAddressSDNode>(Op))) {
14207         Offset += GA->getOffset();
14208         break;
14209       } else if (Op.getOpcode() == ISD::ADD) {
14210         if (ConstantSDNode *C = dyn_cast<ConstantSDNode>(Op.getOperand(1))) {
14211           Offset += C->getZExtValue();
14212           Op = Op.getOperand(0);
14213           continue;
14214         }
14215       } else if (Op.getOpcode() == ISD::SUB) {
14216         if (ConstantSDNode *C = dyn_cast<ConstantSDNode>(Op.getOperand(1))) {
14217           Offset += -C->getZExtValue();
14218           Op = Op.getOperand(0);
14219           continue;
14220         }
14221       }
14222
14223       // Otherwise, this isn't something we can handle, reject it.
14224       return;
14225     }
14226
14227     const GlobalValue *GV = GA->getGlobal();
14228     // If we require an extra load to get this address, as in PIC mode, we
14229     // can't accept it.
14230     if (isGlobalStubReference(Subtarget->ClassifyGlobalReference(GV,
14231                                                         getTargetMachine())))
14232       return;
14233
14234     Result = DAG.getTargetGlobalAddress(GV, Op.getDebugLoc(),
14235                                         GA->getValueType(0), Offset);
14236     break;
14237   }
14238   }
14239
14240   if (Result.getNode()) {
14241     Ops.push_back(Result);
14242     return;
14243   }
14244   return TargetLowering::LowerAsmOperandForConstraint(Op, Constraint, Ops, DAG);
14245 }
14246
14247 std::pair<unsigned, const TargetRegisterClass*>
14248 X86TargetLowering::getRegForInlineAsmConstraint(const std::string &Constraint,
14249                                                 EVT VT) const {
14250   // First, see if this is a constraint that directly corresponds to an LLVM
14251   // register class.
14252   if (Constraint.size() == 1) {
14253     // GCC Constraint Letters
14254     switch (Constraint[0]) {
14255     default: break;
14256       // TODO: Slight differences here in allocation order and leaving
14257       // RIP in the class. Do they matter any more here than they do
14258       // in the normal allocation?
14259     case 'q':   // GENERAL_REGS in 64-bit mode, Q_REGS in 32-bit mode.
14260       if (Subtarget->is64Bit()) {
14261         if (VT == MVT::i32 || VT == MVT::f32)
14262           return std::make_pair(0U, X86::GR32RegisterClass);
14263         else if (VT == MVT::i16)
14264           return std::make_pair(0U, X86::GR16RegisterClass);
14265         else if (VT == MVT::i8 || VT == MVT::i1)
14266           return std::make_pair(0U, X86::GR8RegisterClass);
14267         else if (VT == MVT::i64 || VT == MVT::f64)
14268           return std::make_pair(0U, X86::GR64RegisterClass);
14269         break;
14270       }
14271       // 32-bit fallthrough
14272     case 'Q':   // Q_REGS
14273       if (VT == MVT::i32 || VT == MVT::f32)
14274         return std::make_pair(0U, X86::GR32_ABCDRegisterClass);
14275       else if (VT == MVT::i16)
14276         return std::make_pair(0U, X86::GR16_ABCDRegisterClass);
14277       else if (VT == MVT::i8 || VT == MVT::i1)
14278         return std::make_pair(0U, X86::GR8_ABCD_LRegisterClass);
14279       else if (VT == MVT::i64)
14280         return std::make_pair(0U, X86::GR64_ABCDRegisterClass);
14281       break;
14282     case 'r':   // GENERAL_REGS
14283     case 'l':   // INDEX_REGS
14284       if (VT == MVT::i8 || VT == MVT::i1)
14285         return std::make_pair(0U, X86::GR8RegisterClass);
14286       if (VT == MVT::i16)
14287         return std::make_pair(0U, X86::GR16RegisterClass);
14288       if (VT == MVT::i32 || VT == MVT::f32 || !Subtarget->is64Bit())
14289         return std::make_pair(0U, X86::GR32RegisterClass);
14290       return std::make_pair(0U, X86::GR64RegisterClass);
14291     case 'R':   // LEGACY_REGS
14292       if (VT == MVT::i8 || VT == MVT::i1)
14293         return std::make_pair(0U, X86::GR8_NOREXRegisterClass);
14294       if (VT == MVT::i16)
14295         return std::make_pair(0U, X86::GR16_NOREXRegisterClass);
14296       if (VT == MVT::i32 || !Subtarget->is64Bit())
14297         return std::make_pair(0U, X86::GR32_NOREXRegisterClass);
14298       return std::make_pair(0U, X86::GR64_NOREXRegisterClass);
14299     case 'f':  // FP Stack registers.
14300       // If SSE is enabled for this VT, use f80 to ensure the isel moves the
14301       // value to the correct fpstack register class.
14302       if (VT == MVT::f32 && !isScalarFPTypeInSSEReg(VT))
14303         return std::make_pair(0U, X86::RFP32RegisterClass);
14304       if (VT == MVT::f64 && !isScalarFPTypeInSSEReg(VT))
14305         return std::make_pair(0U, X86::RFP64RegisterClass);
14306       return std::make_pair(0U, X86::RFP80RegisterClass);
14307     case 'y':   // MMX_REGS if MMX allowed.
14308       if (!Subtarget->hasMMX()) break;
14309       return std::make_pair(0U, X86::VR64RegisterClass);
14310     case 'Y':   // SSE_REGS if SSE2 allowed
14311       if (!Subtarget->hasXMMInt()) break;
14312       // FALL THROUGH.
14313     case 'x':   // SSE_REGS if SSE1 allowed
14314       if (!Subtarget->hasXMM()) break;
14315
14316       switch (VT.getSimpleVT().SimpleTy) {
14317       default: break;
14318       // Scalar SSE types.
14319       case MVT::f32:
14320       case MVT::i32:
14321         return std::make_pair(0U, X86::FR32RegisterClass);
14322       case MVT::f64:
14323       case MVT::i64:
14324         return std::make_pair(0U, X86::FR64RegisterClass);
14325       // Vector types.
14326       case MVT::v16i8:
14327       case MVT::v8i16:
14328       case MVT::v4i32:
14329       case MVT::v2i64:
14330       case MVT::v4f32:
14331       case MVT::v2f64:
14332         return std::make_pair(0U, X86::VR128RegisterClass);
14333       }
14334       break;
14335     }
14336   }
14337
14338   // Use the default implementation in TargetLowering to convert the register
14339   // constraint into a member of a register class.
14340   std::pair<unsigned, const TargetRegisterClass*> Res;
14341   Res = TargetLowering::getRegForInlineAsmConstraint(Constraint, VT);
14342
14343   // Not found as a standard register?
14344   if (Res.second == 0) {
14345     // Map st(0) -> st(7) -> ST0
14346     if (Constraint.size() == 7 && Constraint[0] == '{' &&
14347         tolower(Constraint[1]) == 's' &&
14348         tolower(Constraint[2]) == 't' &&
14349         Constraint[3] == '(' &&
14350         (Constraint[4] >= '0' && Constraint[4] <= '7') &&
14351         Constraint[5] == ')' &&
14352         Constraint[6] == '}') {
14353
14354       Res.first = X86::ST0+Constraint[4]-'0';
14355       Res.second = X86::RFP80RegisterClass;
14356       return Res;
14357     }
14358
14359     // GCC allows "st(0)" to be called just plain "st".
14360     if (StringRef("{st}").equals_lower(Constraint)) {
14361       Res.first = X86::ST0;
14362       Res.second = X86::RFP80RegisterClass;
14363       return Res;
14364     }
14365
14366     // flags -> EFLAGS
14367     if (StringRef("{flags}").equals_lower(Constraint)) {
14368       Res.first = X86::EFLAGS;
14369       Res.second = X86::CCRRegisterClass;
14370       return Res;
14371     }
14372
14373     // 'A' means EAX + EDX.
14374     if (Constraint == "A") {
14375       Res.first = X86::EAX;
14376       Res.second = X86::GR32_ADRegisterClass;
14377       return Res;
14378     }
14379     return Res;
14380   }
14381
14382   // Otherwise, check to see if this is a register class of the wrong value
14383   // type.  For example, we want to map "{ax},i32" -> {eax}, we don't want it to
14384   // turn into {ax},{dx}.
14385   if (Res.second->hasType(VT))
14386     return Res;   // Correct type already, nothing to do.
14387
14388   // All of the single-register GCC register classes map their values onto
14389   // 16-bit register pieces "ax","dx","cx","bx","si","di","bp","sp".  If we
14390   // really want an 8-bit or 32-bit register, map to the appropriate register
14391   // class and return the appropriate register.
14392   if (Res.second == X86::GR16RegisterClass) {
14393     if (VT == MVT::i8) {
14394       unsigned DestReg = 0;
14395       switch (Res.first) {
14396       default: break;
14397       case X86::AX: DestReg = X86::AL; break;
14398       case X86::DX: DestReg = X86::DL; break;
14399       case X86::CX: DestReg = X86::CL; break;
14400       case X86::BX: DestReg = X86::BL; break;
14401       }
14402       if (DestReg) {
14403         Res.first = DestReg;
14404         Res.second = X86::GR8RegisterClass;
14405       }
14406     } else if (VT == MVT::i32) {
14407       unsigned DestReg = 0;
14408       switch (Res.first) {
14409       default: break;
14410       case X86::AX: DestReg = X86::EAX; break;
14411       case X86::DX: DestReg = X86::EDX; break;
14412       case X86::CX: DestReg = X86::ECX; break;
14413       case X86::BX: DestReg = X86::EBX; break;
14414       case X86::SI: DestReg = X86::ESI; break;
14415       case X86::DI: DestReg = X86::EDI; break;
14416       case X86::BP: DestReg = X86::EBP; break;
14417       case X86::SP: DestReg = X86::ESP; break;
14418       }
14419       if (DestReg) {
14420         Res.first = DestReg;
14421         Res.second = X86::GR32RegisterClass;
14422       }
14423     } else if (VT == MVT::i64) {
14424       unsigned DestReg = 0;
14425       switch (Res.first) {
14426       default: break;
14427       case X86::AX: DestReg = X86::RAX; break;
14428       case X86::DX: DestReg = X86::RDX; break;
14429       case X86::CX: DestReg = X86::RCX; break;
14430       case X86::BX: DestReg = X86::RBX; break;
14431       case X86::SI: DestReg = X86::RSI; break;
14432       case X86::DI: DestReg = X86::RDI; break;
14433       case X86::BP: DestReg = X86::RBP; break;
14434       case X86::SP: DestReg = X86::RSP; break;
14435       }
14436       if (DestReg) {
14437         Res.first = DestReg;
14438         Res.second = X86::GR64RegisterClass;
14439       }
14440     }
14441   } else if (Res.second == X86::FR32RegisterClass ||
14442              Res.second == X86::FR64RegisterClass ||
14443              Res.second == X86::VR128RegisterClass) {
14444     // Handle references to XMM physical registers that got mapped into the
14445     // wrong class.  This can happen with constraints like {xmm0} where the
14446     // target independent register mapper will just pick the first match it can
14447     // find, ignoring the required type.
14448     if (VT == MVT::f32)
14449       Res.second = X86::FR32RegisterClass;
14450     else if (VT == MVT::f64)
14451       Res.second = X86::FR64RegisterClass;
14452     else if (X86::VR128RegisterClass->hasType(VT))
14453       Res.second = X86::VR128RegisterClass;
14454   }
14455
14456   return Res;
14457 }