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 #include "X86.h"
  16 #include "X86InstrBuilder.h"
  17 #include "X86ISelLowering.h"
  18 #include "X86MachineFunctionInfo.h"
  19 #include "X86TargetMachine.h"
  20 #include "llvm/CallingConv.h"
  21 #include "llvm/Constants.h"
  22 #include "llvm/DerivedTypes.h"
  23 #include "llvm/GlobalVariable.h"
  24 #include "llvm/Function.h"
  25 #include "llvm/Intrinsics.h"
  26 #include "llvm/ADT/BitVector.h"
  27 #include "llvm/ADT/VectorExtras.h"
  28 #include "llvm/CodeGen/CallingConvLower.h"
  29 #include "llvm/CodeGen/MachineFrameInfo.h"
  30 #include "llvm/CodeGen/MachineFunction.h"
  31 #include "llvm/CodeGen/MachineInstrBuilder.h"
  32 #include "llvm/CodeGen/MachineModuleInfo.h"
  33 #include "llvm/CodeGen/MachineRegisterInfo.h"
  34 #include "llvm/CodeGen/PseudoSourceValue.h"
  35 #include "llvm/CodeGen/SelectionDAG.h"
  36 #include "llvm/Support/MathExtras.h"
  37 #include "llvm/Support/Debug.h"
  38 #include "llvm/Target/TargetOptions.h"
  39 #include "llvm/ADT/SmallSet.h"
  40 #include "llvm/ADT/StringExtras.h"
  41 using namespace llvm;
  42
  43 // Forward declarations.
  44 static SDValue getMOVLMask(unsigned NumElems, SelectionDAG &DAG);
  45
  46 X86TargetLowering::X86TargetLowering(X86TargetMachine &TM)
  47   : TargetLowering(TM) {
  48   Subtarget = &TM.getSubtarget<X86Subtarget>();
  49   X86ScalarSSEf64 = Subtarget->hasSSE2();
  50   X86ScalarSSEf32 = Subtarget->hasSSE1();
  51   X86StackPtr = Subtarget->is64Bit() ? X86::RSP : X86::ESP;
  52
  53   bool Fast = false;
  54
  55   RegInfo = TM.getRegisterInfo();
  56   TD = getTargetData();
  57
  58   // Set up the TargetLowering object.
  59
  60   // X86 is weird, it always uses i8 for shift amounts and setcc results.
  61   setShiftAmountType(MVT::i8);
  62   setSetCCResultContents(ZeroOrOneSetCCResult);
  63   setSchedulingPreference(SchedulingForRegPressure);
  64   setShiftAmountFlavor(Mask);   // shl X, 32 == shl X, 0
  65   setStackPointerRegisterToSaveRestore(X86StackPtr);
  66
  67   if (Subtarget->isTargetDarwin()) {
  68     // Darwin should use _setjmp/_longjmp instead of setjmp/longjmp.
  69     setUseUnderscoreSetJmp(false);
  70     setUseUnderscoreLongJmp(false);
  71   } else if (Subtarget->isTargetMingw()) {
  72     // MS runtime is weird: it exports _setjmp, but longjmp!
  73     setUseUnderscoreSetJmp(true);
  74     setUseUnderscoreLongJmp(false);
  75   } else {
  76     setUseUnderscoreSetJmp(true);
  77     setUseUnderscoreLongJmp(true);
  78   }
  79
  80   // Set up the register classes.
  81   addRegisterClass(MVT::i8, X86::GR8RegisterClass);
  82   addRegisterClass(MVT::i16, X86::GR16RegisterClass);
  83   addRegisterClass(MVT::i32, X86::GR32RegisterClass);
  84   if (Subtarget->is64Bit())
  85     addRegisterClass(MVT::i64, X86::GR64RegisterClass);
  86
  87   setLoadXAction(ISD::SEXTLOAD, MVT::i1, Promote);
  88
  89   // We don't accept any truncstore of integer registers.
  90   setTruncStoreAction(MVT::i64, MVT::i32, Expand);
  91   setTruncStoreAction(MVT::i64, MVT::i16, Expand);
  92   setTruncStoreAction(MVT::i64, MVT::i8 , Expand);
  93   setTruncStoreAction(MVT::i32, MVT::i16, Expand);
  94   setTruncStoreAction(MVT::i32, MVT::i8 , Expand);
  95   setTruncStoreAction(MVT::i16, MVT::i8, Expand);
  96
  97   // Promote all UINT_TO_FP to larger SINT_TO_FP's, as X86 doesn't have this
  98   // operation.
  99   setOperationAction(ISD::UINT_TO_FP       , MVT::i1   , Promote);
 100   setOperationAction(ISD::UINT_TO_FP       , MVT::i8   , Promote);
 101   setOperationAction(ISD::UINT_TO_FP       , MVT::i16  , Promote);
 102
 103   if (Subtarget->is64Bit()) {
 104     setOperationAction(ISD::UINT_TO_FP     , MVT::i64  , Expand);
 105     setOperationAction(ISD::UINT_TO_FP     , MVT::i32  , Promote);
 106   } else {
 107     if (X86ScalarSSEf64)
 108       // If SSE i64 SINT_TO_FP is not available, expand i32 UINT_TO_FP.
 109       setOperationAction(ISD::UINT_TO_FP   , MVT::i32  , Expand);
 110     else
 111       setOperationAction(ISD::UINT_TO_FP   , MVT::i32  , Promote);
 112   }
 113
 114   // Promote i1/i8 SINT_TO_FP to larger SINT_TO_FP's, as X86 doesn't have
 115   // this operation.
 116   setOperationAction(ISD::SINT_TO_FP       , MVT::i1   , Promote);
 117   setOperationAction(ISD::SINT_TO_FP       , MVT::i8   , Promote);
 118   // SSE has no i16 to fp conversion, only i32
 119   if (X86ScalarSSEf32) {
 120     setOperationAction(ISD::SINT_TO_FP     , MVT::i16  , Promote);
 121     // f32 and f64 cases are Legal, f80 case is not
 122     setOperationAction(ISD::SINT_TO_FP     , MVT::i32  , Custom);
 123   } else {
 124     setOperationAction(ISD::SINT_TO_FP     , MVT::i16  , Custom);
 125     setOperationAction(ISD::SINT_TO_FP     , MVT::i32  , Custom);
 126   }
 127
 128   // In 32-bit mode these are custom lowered.  In 64-bit mode F32 and F64
 129   // are Legal, f80 is custom lowered.
 130   setOperationAction(ISD::FP_TO_SINT     , MVT::i64  , Custom);
 131   setOperationAction(ISD::SINT_TO_FP     , MVT::i64  , Custom);
 132
 133   // Promote i1/i8 FP_TO_SINT to larger FP_TO_SINTS's, as X86 doesn't have
 134   // this operation.
 135   setOperationAction(ISD::FP_TO_SINT       , MVT::i1   , Promote);
 136   setOperationAction(ISD::FP_TO_SINT       , MVT::i8   , Promote);
 137
 138   if (X86ScalarSSEf32) {
 139     setOperationAction(ISD::FP_TO_SINT     , MVT::i16  , Promote);
 140     // f32 and f64 cases are Legal, f80 case is not
 141     setOperationAction(ISD::FP_TO_SINT     , MVT::i32  , Custom);
 142   } else {
 143     setOperationAction(ISD::FP_TO_SINT     , MVT::i16  , Custom);
 144     setOperationAction(ISD::FP_TO_SINT     , MVT::i32  , Custom);
 145   }
 146
 147   // Handle FP_TO_UINT by promoting the destination to a larger signed
 148   // conversion.
 149   setOperationAction(ISD::FP_TO_UINT       , MVT::i1   , Promote);
 150   setOperationAction(ISD::FP_TO_UINT       , MVT::i8   , Promote);
 151   setOperationAction(ISD::FP_TO_UINT       , MVT::i16  , Promote);
 152
 153   if (Subtarget->is64Bit()) {
 154     setOperationAction(ISD::FP_TO_UINT     , MVT::i64  , Expand);
 155     setOperationAction(ISD::FP_TO_UINT     , MVT::i32  , Promote);
 156   } else {
 157     if (X86ScalarSSEf32 && !Subtarget->hasSSE3())
 158       // Expand FP_TO_UINT into a select.
 159       // FIXME: We would like to use a Custom expander here eventually to do
 160       // the optimal thing for SSE vs. the default expansion in the legalizer.
 161       setOperationAction(ISD::FP_TO_UINT   , MVT::i32  , Expand);
 162     else
 163       // With SSE3 we can use fisttpll to convert to a signed i64.
 164       setOperationAction(ISD::FP_TO_UINT   , MVT::i32  , Promote);
 165   }
 166
 167   // TODO: when we have SSE, these could be more efficient, by using movd/movq.
 168   if (!X86ScalarSSEf64) {
 169     setOperationAction(ISD::BIT_CONVERT      , MVT::f32  , Expand);
 170     setOperationAction(ISD::BIT_CONVERT      , MVT::i32  , Expand);
 171   }
 172
 173   // Scalar integer divide and remainder are lowered to use operations that
 174   // produce two results, to match the available instructions. This exposes
 175   // the two-result form to trivial CSE, which is able to combine x/y and x%y
 176   // into a single instruction.
 177   //
 178   // Scalar integer multiply-high is also lowered to use two-result
 179   // operations, to match the available instructions. However, plain multiply
 180   // (low) operations are left as Legal, as there are single-result
 181   // instructions for this in x86. Using the two-result multiply instructions
 182   // when both high and low results are needed must be arranged by dagcombine.
 183   setOperationAction(ISD::MULHS           , MVT::i8    , Expand);
 184   setOperationAction(ISD::MULHU           , MVT::i8    , Expand);
 185   setOperationAction(ISD::SDIV            , MVT::i8    , Expand);
 186   setOperationAction(ISD::UDIV            , MVT::i8    , Expand);
 187   setOperationAction(ISD::SREM            , MVT::i8    , Expand);
 188   setOperationAction(ISD::UREM            , MVT::i8    , Expand);
 189   setOperationAction(ISD::MULHS           , MVT::i16   , Expand);
 190   setOperationAction(ISD::MULHU           , MVT::i16   , Expand);
 191   setOperationAction(ISD::SDIV            , MVT::i16   , Expand);
 192   setOperationAction(ISD::UDIV            , MVT::i16   , Expand);
 193   setOperationAction(ISD::SREM            , MVT::i16   , Expand);
 194   setOperationAction(ISD::UREM            , MVT::i16   , Expand);
 195   setOperationAction(ISD::MULHS           , MVT::i32   , Expand);
 196   setOperationAction(ISD::MULHU           , MVT::i32   , Expand);
 197   setOperationAction(ISD::SDIV            , MVT::i32   , Expand);
 198   setOperationAction(ISD::UDIV            , MVT::i32   , Expand);
 199   setOperationAction(ISD::SREM            , MVT::i32   , Expand);
 200   setOperationAction(ISD::UREM            , MVT::i32   , Expand);
 201   setOperationAction(ISD::MULHS           , MVT::i64   , Expand);
 202   setOperationAction(ISD::MULHU           , MVT::i64   , Expand);
 203   setOperationAction(ISD::SDIV            , MVT::i64   , Expand);
 204   setOperationAction(ISD::UDIV            , MVT::i64   , Expand);
 205   setOperationAction(ISD::SREM            , MVT::i64   , Expand);
 206   setOperationAction(ISD::UREM            , MVT::i64   , Expand);
 207
 208   setOperationAction(ISD::BR_JT            , MVT::Other, Expand);
 209   setOperationAction(ISD::BRCOND           , MVT::Other, Custom);
 210   setOperationAction(ISD::BR_CC            , MVT::Other, Expand);
 211   setOperationAction(ISD::SELECT_CC        , MVT::Other, Expand);
 212   if (Subtarget->is64Bit())
 213     setOperationAction(ISD::SIGN_EXTEND_INREG, MVT::i32, Legal);
 214   setOperationAction(ISD::SIGN_EXTEND_INREG, MVT::i16  , Legal);
 215   setOperationAction(ISD::SIGN_EXTEND_INREG, MVT::i8   , Legal);
 216   setOperationAction(ISD::SIGN_EXTEND_INREG, MVT::i1   , Expand);
 217   setOperationAction(ISD::FP_ROUND_INREG   , MVT::f32  , Expand);
 218   setOperationAction(ISD::FREM             , MVT::f32  , Expand);
 219   setOperationAction(ISD::FREM             , MVT::f64  , Expand);
 220   setOperationAction(ISD::FREM             , MVT::f80  , Expand);
 221   setOperationAction(ISD::FLT_ROUNDS_      , MVT::i32  , Custom);
 222
 223   setOperationAction(ISD::CTPOP            , MVT::i8   , Expand);
 224   setOperationAction(ISD::CTTZ             , MVT::i8   , Custom);
 225   setOperationAction(ISD::CTLZ             , MVT::i8   , Custom);
 226   setOperationAction(ISD::CTPOP            , MVT::i16  , Expand);
 227   setOperationAction(ISD::CTTZ             , MVT::i16  , Custom);
 228   setOperationAction(ISD::CTLZ             , MVT::i16  , Custom);
 229   setOperationAction(ISD::CTPOP            , MVT::i32  , Expand);
 230   setOperationAction(ISD::CTTZ             , MVT::i32  , Custom);
 231   setOperationAction(ISD::CTLZ             , MVT::i32  , Custom);
 232   if (Subtarget->is64Bit()) {
 233     setOperationAction(ISD::CTPOP          , MVT::i64  , Expand);
 234     setOperationAction(ISD::CTTZ           , MVT::i64  , Custom);
 235     setOperationAction(ISD::CTLZ           , MVT::i64  , Custom);
 236   }
 237
 238   setOperationAction(ISD::READCYCLECOUNTER , MVT::i64  , Custom);
 239   setOperationAction(ISD::BSWAP            , MVT::i16  , Expand);
 240
 241   // These should be promoted to a larger select which is supported.
 242   setOperationAction(ISD::SELECT           , MVT::i1   , Promote);
 243   setOperationAction(ISD::SELECT           , MVT::i8   , Promote);
 244   // X86 wants to expand cmov itself.
 245   setOperationAction(ISD::SELECT          , MVT::i16  , Custom);
 246   setOperationAction(ISD::SELECT          , MVT::i32  , Custom);
 247   setOperationAction(ISD::SELECT          , MVT::f32  , Custom);
 248   setOperationAction(ISD::SELECT          , MVT::f64  , Custom);
 249   setOperationAction(ISD::SELECT          , MVT::f80  , Custom);
 250   setOperationAction(ISD::SETCC           , MVT::i8   , Custom);
 251   setOperationAction(ISD::SETCC           , MVT::i16  , Custom);
 252   setOperationAction(ISD::SETCC           , MVT::i32  , Custom);
 253   setOperationAction(ISD::SETCC           , MVT::f32  , Custom);
 254   setOperationAction(ISD::SETCC           , MVT::f64  , Custom);
 255   setOperationAction(ISD::SETCC           , MVT::f80  , Custom);
 256   if (Subtarget->is64Bit()) {
 257     setOperationAction(ISD::SELECT        , MVT::i64  , Custom);
 258     setOperationAction(ISD::SETCC         , MVT::i64  , Custom);
 259   }
 260   // X86 ret instruction may pop stack.
 261   setOperationAction(ISD::RET             , MVT::Other, Custom);
 262   setOperationAction(ISD::EH_RETURN       , MVT::Other, Custom);
 263
 264   // Darwin ABI issue.
 265   setOperationAction(ISD::ConstantPool    , MVT::i32  , Custom);
 266   setOperationAction(ISD::JumpTable       , MVT::i32  , Custom);
 267   setOperationAction(ISD::GlobalAddress   , MVT::i32  , Custom);
 268   setOperationAction(ISD::GlobalTLSAddress, MVT::i32  , Custom);
 269   if (Subtarget->is64Bit())
 270     setOperationAction(ISD::GlobalTLSAddress, MVT::i64, Custom);
 271   setOperationAction(ISD::ExternalSymbol  , MVT::i32  , Custom);
 272   if (Subtarget->is64Bit()) {
 273     setOperationAction(ISD::ConstantPool  , MVT::i64  , Custom);
 274     setOperationAction(ISD::JumpTable     , MVT::i64  , Custom);
 275     setOperationAction(ISD::GlobalAddress , MVT::i64  , Custom);
 276     setOperationAction(ISD::ExternalSymbol, MVT::i64  , Custom);
 277   }
 278   // 64-bit addm sub, shl, sra, srl (iff 32-bit x86)
 279   setOperationAction(ISD::SHL_PARTS       , MVT::i32  , Custom);
 280   setOperationAction(ISD::SRA_PARTS       , MVT::i32  , Custom);
 281   setOperationAction(ISD::SRL_PARTS       , MVT::i32  , Custom);
 282   if (Subtarget->is64Bit()) {
 283     setOperationAction(ISD::SHL_PARTS     , MVT::i64  , Custom);
 284     setOperationAction(ISD::SRA_PARTS     , MVT::i64  , Custom);
 285     setOperationAction(ISD::SRL_PARTS     , MVT::i64  , Custom);
 286   }
 287
 288   if (Subtarget->hasSSE1())
 289     setOperationAction(ISD::PREFETCH      , MVT::Other, Legal);
 290
 291   if (!Subtarget->hasSSE2())
 292     setOperationAction(ISD::MEMBARRIER    , MVT::Other, Expand);
 293
 294   // Expand certain atomics
 295   setOperationAction(ISD::ATOMIC_CMP_SWAP_8 , MVT::i8, Custom);
 296   setOperationAction(ISD::ATOMIC_CMP_SWAP_16, MVT::i16, Custom);
 297   setOperationAction(ISD::ATOMIC_CMP_SWAP_32, MVT::i32, Custom);
 298   setOperationAction(ISD::ATOMIC_CMP_SWAP_64, MVT::i64, Custom);
 299
 300   setOperationAction(ISD::ATOMIC_LOAD_SUB_8 , MVT::i8, Custom);
 301   setOperationAction(ISD::ATOMIC_LOAD_SUB_16, MVT::i16, Custom);
 302   setOperationAction(ISD::ATOMIC_LOAD_SUB_32, MVT::i32, Custom);
 303   setOperationAction(ISD::ATOMIC_LOAD_SUB_64, MVT::i64, Custom);
 304
 305   if (!Subtarget->is64Bit()) {
 306     setOperationAction(ISD::ATOMIC_LOAD_ADD_64, MVT::i64, Custom);
 307     setOperationAction(ISD::ATOMIC_LOAD_SUB_64, MVT::i64, Custom);
 308     setOperationAction(ISD::ATOMIC_LOAD_AND_64, MVT::i64, Custom);
 309     setOperationAction(ISD::ATOMIC_LOAD_OR_64, MVT::i64, Custom);
 310     setOperationAction(ISD::ATOMIC_LOAD_XOR_64, MVT::i64, Custom);
 311     setOperationAction(ISD::ATOMIC_LOAD_NAND_64, MVT::i64, Custom);
 312     setOperationAction(ISD::ATOMIC_SWAP_64, MVT::i64, Custom);
 313   }
 314
 315   // Use the default ISD::DBG_STOPPOINT, ISD::DECLARE expansion.
 316   setOperationAction(ISD::DBG_STOPPOINT, MVT::Other, Expand);
 317   // FIXME - use subtarget debug flags
 318   if (!Subtarget->isTargetDarwin() &&
 319       !Subtarget->isTargetELF() &&
 320       !Subtarget->isTargetCygMing()) {
 321     setOperationAction(ISD::DBG_LABEL, MVT::Other, Expand);
 322     setOperationAction(ISD::EH_LABEL, MVT::Other, Expand);
 323   }
 324
 325   setOperationAction(ISD::EXCEPTIONADDR, MVT::i64, Expand);
 326   setOperationAction(ISD::EHSELECTION,   MVT::i64, Expand);
 327   setOperationAction(ISD::EXCEPTIONADDR, MVT::i32, Expand);
 328   setOperationAction(ISD::EHSELECTION,   MVT::i32, Expand);
 329   if (Subtarget->is64Bit()) {
 330     setExceptionPointerRegister(X86::RAX);
 331     setExceptionSelectorRegister(X86::RDX);
 332   } else {
 333     setExceptionPointerRegister(X86::EAX);
 334     setExceptionSelectorRegister(X86::EDX);
 335   }
 336   setOperationAction(ISD::FRAME_TO_ARGS_OFFSET, MVT::i32, Custom);
 337   setOperationAction(ISD::FRAME_TO_ARGS_OFFSET, MVT::i64, Custom);
 338
 339   setOperationAction(ISD::TRAMPOLINE, MVT::Other, Custom);
 340
 341   setOperationAction(ISD::TRAP, MVT::Other, Legal);
 342
 343   // VASTART needs to be custom lowered to use the VarArgsFrameIndex
 344   setOperationAction(ISD::VASTART           , MVT::Other, Custom);
 345   setOperationAction(ISD::VAEND             , MVT::Other, Expand);
 346   if (Subtarget->is64Bit()) {
 347     setOperationAction(ISD::VAARG           , MVT::Other, Custom);
 348     setOperationAction(ISD::VACOPY          , MVT::Other, Custom);
 349   } else {
 350     setOperationAction(ISD::VAARG           , MVT::Other, Expand);
 351     setOperationAction(ISD::VACOPY          , MVT::Other, Expand);
 352   }
 353
 354   setOperationAction(ISD::STACKSAVE,          MVT::Other, Expand);
 355   setOperationAction(ISD::STACKRESTORE,       MVT::Other, Expand);
 356   if (Subtarget->is64Bit())
 357     setOperationAction(ISD::DYNAMIC_STACKALLOC, MVT::i64, Expand);
 358   if (Subtarget->isTargetCygMing())
 359     setOperationAction(ISD::DYNAMIC_STACKALLOC, MVT::i32, Custom);
 360   else
 361     setOperationAction(ISD::DYNAMIC_STACKALLOC, MVT::i32, Expand);
 362
 363   if (X86ScalarSSEf64) {
 364     // f32 and f64 use SSE.
 365     // Set up the FP register classes.
 366     addRegisterClass(MVT::f32, X86::FR32RegisterClass);
 367     addRegisterClass(MVT::f64, X86::FR64RegisterClass);
 368
 369     // Use ANDPD to simulate FABS.
 370     setOperationAction(ISD::FABS , MVT::f64, Custom);
 371     setOperationAction(ISD::FABS , MVT::f32, Custom);
 372
 373     // Use XORP to simulate FNEG.
 374     setOperationAction(ISD::FNEG , MVT::f64, Custom);
 375     setOperationAction(ISD::FNEG , MVT::f32, Custom);
 376
 377     // Use ANDPD and ORPD to simulate FCOPYSIGN.
 378     setOperationAction(ISD::FCOPYSIGN, MVT::f64, Custom);
 379     setOperationAction(ISD::FCOPYSIGN, MVT::f32, Custom);
 380
 381     // We don't support sin/cos/fmod
 382     setOperationAction(ISD::FSIN , MVT::f64, Expand);
 383     setOperationAction(ISD::FCOS , MVT::f64, Expand);
 384     setOperationAction(ISD::FSIN , MVT::f32, Expand);
 385     setOperationAction(ISD::FCOS , MVT::f32, Expand);
 386
 387     // Expand FP immediates into loads from the stack, except for the special
 388     // cases we handle.
 389     addLegalFPImmediate(APFloat(+0.0)); // xorpd
 390     addLegalFPImmediate(APFloat(+0.0f)); // xorps
 391
 392     // Floating truncations from f80 and extensions to f80 go through memory.
 393     // If optimizing, we lie about this though and handle it in
 394     // InstructionSelectPreprocess so that dagcombine2 can hack on these.
 395     if (Fast) {
 396       setConvertAction(MVT::f32, MVT::f80, Expand);
 397       setConvertAction(MVT::f64, MVT::f80, Expand);
 398       setConvertAction(MVT::f80, MVT::f32, Expand);
 399       setConvertAction(MVT::f80, MVT::f64, Expand);
 400     }
 401   } else if (X86ScalarSSEf32) {
 402     // Use SSE for f32, x87 for f64.
 403     // Set up the FP register classes.
 404     addRegisterClass(MVT::f32, X86::FR32RegisterClass);
 405     addRegisterClass(MVT::f64, X86::RFP64RegisterClass);
 406
 407     // Use ANDPS to simulate FABS.
 408     setOperationAction(ISD::FABS , MVT::f32, Custom);
 409
 410     // Use XORP to simulate FNEG.
 411     setOperationAction(ISD::FNEG , MVT::f32, Custom);
 412
 413     setOperationAction(ISD::UNDEF,     MVT::f64, Expand);
 414
 415     // Use ANDPS and ORPS to simulate FCOPYSIGN.
 416     setOperationAction(ISD::FCOPYSIGN, MVT::f64, Expand);
 417     setOperationAction(ISD::FCOPYSIGN, MVT::f32, Custom);
 418
 419     // We don't support sin/cos/fmod
 420     setOperationAction(ISD::FSIN , MVT::f32, Expand);
 421     setOperationAction(ISD::FCOS , MVT::f32, Expand);
 422
 423     // Special cases we handle for FP constants.
 424     addLegalFPImmediate(APFloat(+0.0f)); // xorps
 425     addLegalFPImmediate(APFloat(+0.0)); // FLD0
 426     addLegalFPImmediate(APFloat(+1.0)); // FLD1
 427     addLegalFPImmediate(APFloat(-0.0)); // FLD0/FCHS
 428     addLegalFPImmediate(APFloat(-1.0)); // FLD1/FCHS
 429
 430     // SSE <-> X87 conversions go through memory.  If optimizing, we lie about
 431     // this though and handle it in InstructionSelectPreprocess so that
 432     // dagcombine2 can hack on these.
 433     if (Fast) {
 434       setConvertAction(MVT::f32, MVT::f64, Expand);
 435       setConvertAction(MVT::f32, MVT::f80, Expand);
 436       setConvertAction(MVT::f80, MVT::f32, Expand);
 437       setConvertAction(MVT::f64, MVT::f32, Expand);
 438       // And x87->x87 truncations also.
 439       setConvertAction(MVT::f80, MVT::f64, Expand);
 440     }
 441
 442     if (!UnsafeFPMath) {
 443       setOperationAction(ISD::FSIN           , MVT::f64  , Expand);
 444       setOperationAction(ISD::FCOS           , MVT::f64  , Expand);
 445     }
 446   } else {
 447     // f32 and f64 in x87.
 448     // Set up the FP register classes.
 449     addRegisterClass(MVT::f64, X86::RFP64RegisterClass);
 450     addRegisterClass(MVT::f32, X86::RFP32RegisterClass);
 451
 452     setOperationAction(ISD::UNDEF,     MVT::f64, Expand);
 453     setOperationAction(ISD::UNDEF,     MVT::f32, Expand);
 454     setOperationAction(ISD::FCOPYSIGN, MVT::f64, Expand);
 455     setOperationAction(ISD::FCOPYSIGN, MVT::f32, Expand);
 456
 457     // Floating truncations go through memory.  If optimizing, we lie about
 458     // this though and handle it in InstructionSelectPreprocess so that
 459     // dagcombine2 can hack on these.
 460     if (Fast) {
 461       setConvertAction(MVT::f80, MVT::f32, Expand);
 462       setConvertAction(MVT::f64, MVT::f32, Expand);
 463       setConvertAction(MVT::f80, MVT::f64, Expand);
 464     }
 465
 466     if (!UnsafeFPMath) {
 467       setOperationAction(ISD::FSIN           , MVT::f64  , Expand);
 468       setOperationAction(ISD::FCOS           , MVT::f64  , Expand);
 469     }
 470     addLegalFPImmediate(APFloat(+0.0)); // FLD0
 471     addLegalFPImmediate(APFloat(+1.0)); // FLD1
 472     addLegalFPImmediate(APFloat(-0.0)); // FLD0/FCHS
 473     addLegalFPImmediate(APFloat(-1.0)); // FLD1/FCHS
 474     addLegalFPImmediate(APFloat(+0.0f)); // FLD0
 475     addLegalFPImmediate(APFloat(+1.0f)); // FLD1
 476     addLegalFPImmediate(APFloat(-0.0f)); // FLD0/FCHS
 477     addLegalFPImmediate(APFloat(-1.0f)); // FLD1/FCHS
 478   }
 479
 480   // Long double always uses X87.
 481   addRegisterClass(MVT::f80, X86::RFP80RegisterClass);
 482   setOperationAction(ISD::UNDEF,     MVT::f80, Expand);
 483   setOperationAction(ISD::FCOPYSIGN, MVT::f80, Expand);
 484   {
 485     APFloat TmpFlt(+0.0);
 486     TmpFlt.convert(APFloat::x87DoubleExtended, APFloat::rmNearestTiesToEven);
 487     addLegalFPImmediate(TmpFlt);  // FLD0
 488     TmpFlt.changeSign();
 489     addLegalFPImmediate(TmpFlt);  // FLD0/FCHS
 490     APFloat TmpFlt2(+1.0);
 491     TmpFlt2.convert(APFloat::x87DoubleExtended, APFloat::rmNearestTiesToEven);
 492     addLegalFPImmediate(TmpFlt2);  // FLD1
 493     TmpFlt2.changeSign();
 494     addLegalFPImmediate(TmpFlt2);  // FLD1/FCHS
 495   }
 496
 497   if (!UnsafeFPMath) {
 498     setOperationAction(ISD::FSIN           , MVT::f80  , Expand);
 499     setOperationAction(ISD::FCOS           , MVT::f80  , Expand);
 500   }
 501
 502   // Always use a library call for pow.
 503   setOperationAction(ISD::FPOW             , MVT::f32  , Expand);
 504   setOperationAction(ISD::FPOW             , MVT::f64  , Expand);
 505   setOperationAction(ISD::FPOW             , MVT::f80  , Expand);
 506
 507   setOperationAction(ISD::FLOG, MVT::f80, Expand);
 508   setOperationAction(ISD::FLOG2, MVT::f80, Expand);
 509   setOperationAction(ISD::FLOG10, MVT::f80, Expand);
 510   setOperationAction(ISD::FEXP, MVT::f80, Expand);
 511   setOperationAction(ISD::FEXP2, MVT::f80, Expand);
 512
 513   // First set operation action for all vector types to expand. Then we
 514   // will selectively turn on ones that can be effectively codegen'd.
 515   for (unsigned VT = (unsigned)MVT::FIRST_VECTOR_VALUETYPE;
 516        VT <= (unsigned)MVT::LAST_VECTOR_VALUETYPE; ++VT) {
 517     setOperationAction(ISD::ADD , (MVT::SimpleValueType)VT, Expand);
 518     setOperationAction(ISD::SUB , (MVT::SimpleValueType)VT, Expand);
 519     setOperationAction(ISD::FADD, (MVT::SimpleValueType)VT, Expand);
 520     setOperationAction(ISD::FNEG, (MVT::SimpleValueType)VT, Expand);
 521     setOperationAction(ISD::FSUB, (MVT::SimpleValueType)VT, Expand);
 522     setOperationAction(ISD::MUL , (MVT::SimpleValueType)VT, Expand);
 523     setOperationAction(ISD::FMUL, (MVT::SimpleValueType)VT, Expand);
 524     setOperationAction(ISD::SDIV, (MVT::SimpleValueType)VT, Expand);
 525     setOperationAction(ISD::UDIV, (MVT::SimpleValueType)VT, Expand);
 526     setOperationAction(ISD::FDIV, (MVT::SimpleValueType)VT, Expand);
 527     setOperationAction(ISD::SREM, (MVT::SimpleValueType)VT, Expand);
 528     setOperationAction(ISD::UREM, (MVT::SimpleValueType)VT, Expand);
 529     setOperationAction(ISD::LOAD, (MVT::SimpleValueType)VT, Expand);
 530     setOperationAction(ISD::VECTOR_SHUFFLE, (MVT::SimpleValueType)VT, Expand);
 531     setOperationAction(ISD::EXTRACT_VECTOR_ELT,(MVT::SimpleValueType)VT,Expand);
 532     setOperationAction(ISD::INSERT_VECTOR_ELT,(MVT::SimpleValueType)VT, Expand);
 533     setOperationAction(ISD::FABS, (MVT::SimpleValueType)VT, Expand);
 534     setOperationAction(ISD::FSIN, (MVT::SimpleValueType)VT, Expand);
 535     setOperationAction(ISD::FCOS, (MVT::SimpleValueType)VT, Expand);
 536     setOperationAction(ISD::FREM, (MVT::SimpleValueType)VT, Expand);
 537     setOperationAction(ISD::FPOWI, (MVT::SimpleValueType)VT, Expand);
 538     setOperationAction(ISD::FSQRT, (MVT::SimpleValueType)VT, Expand);
 539     setOperationAction(ISD::FCOPYSIGN, (MVT::SimpleValueType)VT, Expand);
 540     setOperationAction(ISD::SMUL_LOHI, (MVT::SimpleValueType)VT, Expand);
 541     setOperationAction(ISD::UMUL_LOHI, (MVT::SimpleValueType)VT, Expand);
 542     setOperationAction(ISD::SDIVREM, (MVT::SimpleValueType)VT, Expand);
 543     setOperationAction(ISD::UDIVREM, (MVT::SimpleValueType)VT, Expand);
 544     setOperationAction(ISD::FPOW, (MVT::SimpleValueType)VT, Expand);
 545     setOperationAction(ISD::CTPOP, (MVT::SimpleValueType)VT, Expand);
 546     setOperationAction(ISD::CTTZ, (MVT::SimpleValueType)VT, Expand);
 547     setOperationAction(ISD::CTLZ, (MVT::SimpleValueType)VT, Expand);
 548     setOperationAction(ISD::SHL, (MVT::SimpleValueType)VT, Expand);
 549     setOperationAction(ISD::SRA, (MVT::SimpleValueType)VT, Expand);
 550     setOperationAction(ISD::SRL, (MVT::SimpleValueType)VT, Expand);
 551     setOperationAction(ISD::ROTL, (MVT::SimpleValueType)VT, Expand);
 552     setOperationAction(ISD::ROTR, (MVT::SimpleValueType)VT, Expand);
 553     setOperationAction(ISD::BSWAP, (MVT::SimpleValueType)VT, Expand);
 554     setOperationAction(ISD::VSETCC, (MVT::SimpleValueType)VT, Expand);
 555     setOperationAction(ISD::FLOG, (MVT::SimpleValueType)VT, Expand);
 556     setOperationAction(ISD::FLOG2, (MVT::SimpleValueType)VT, Expand);
 557     setOperationAction(ISD::FLOG10, (MVT::SimpleValueType)VT, Expand);
 558     setOperationAction(ISD::FEXP, (MVT::SimpleValueType)VT, Expand);
 559     setOperationAction(ISD::FEXP2, (MVT::SimpleValueType)VT, Expand);
 560   }
 561
 562   if (Subtarget->hasMMX()) {
 563     addRegisterClass(MVT::v8i8,  X86::VR64RegisterClass);
 564     addRegisterClass(MVT::v4i16, X86::VR64RegisterClass);
 565     addRegisterClass(MVT::v2i32, X86::VR64RegisterClass);
 566     addRegisterClass(MVT::v2f32, X86::VR64RegisterClass);
 567     addRegisterClass(MVT::v1i64, X86::VR64RegisterClass);
 568
 569     // FIXME: add MMX packed arithmetics
 570
 571     setOperationAction(ISD::ADD,                MVT::v8i8,  Legal);
 572     setOperationAction(ISD::ADD,                MVT::v4i16, Legal);
 573     setOperationAction(ISD::ADD,                MVT::v2i32, Legal);
 574     setOperationAction(ISD::ADD,                MVT::v1i64, Legal);
 575
 576     setOperationAction(ISD::SUB,                MVT::v8i8,  Legal);
 577     setOperationAction(ISD::SUB,                MVT::v4i16, Legal);
 578     setOperationAction(ISD::SUB,                MVT::v2i32, Legal);
 579     setOperationAction(ISD::SUB,                MVT::v1i64, Legal);
 580
 581     setOperationAction(ISD::MULHS,              MVT::v4i16, Legal);
 582     setOperationAction(ISD::MUL,                MVT::v4i16, Legal);
 583
 584     setOperationAction(ISD::AND,                MVT::v8i8,  Promote);
 585     AddPromotedToType (ISD::AND,                MVT::v8i8,  MVT::v1i64);
 586     setOperationAction(ISD::AND,                MVT::v4i16, Promote);
 587     AddPromotedToType (ISD::AND,                MVT::v4i16, MVT::v1i64);
 588     setOperationAction(ISD::AND,                MVT::v2i32, Promote);
 589     AddPromotedToType (ISD::AND,                MVT::v2i32, MVT::v1i64);
 590     setOperationAction(ISD::AND,                MVT::v1i64, Legal);
 591
 592     setOperationAction(ISD::OR,                 MVT::v8i8,  Promote);
 593     AddPromotedToType (ISD::OR,                 MVT::v8i8,  MVT::v1i64);
 594     setOperationAction(ISD::OR,                 MVT::v4i16, Promote);
 595     AddPromotedToType (ISD::OR,                 MVT::v4i16, MVT::v1i64);
 596     setOperationAction(ISD::OR,                 MVT::v2i32, Promote);
 597     AddPromotedToType (ISD::OR,                 MVT::v2i32, MVT::v1i64);
 598     setOperationAction(ISD::OR,                 MVT::v1i64, Legal);
 599
 600     setOperationAction(ISD::XOR,                MVT::v8i8,  Promote);
 601     AddPromotedToType (ISD::XOR,                MVT::v8i8,  MVT::v1i64);
 602     setOperationAction(ISD::XOR,                MVT::v4i16, Promote);
 603     AddPromotedToType (ISD::XOR,                MVT::v4i16, MVT::v1i64);
 604     setOperationAction(ISD::XOR,                MVT::v2i32, Promote);
 605     AddPromotedToType (ISD::XOR,                MVT::v2i32, MVT::v1i64);
 606     setOperationAction(ISD::XOR,                MVT::v1i64, Legal);
 607
 608     setOperationAction(ISD::LOAD,               MVT::v8i8,  Promote);
 609     AddPromotedToType (ISD::LOAD,               MVT::v8i8,  MVT::v1i64);
 610     setOperationAction(ISD::LOAD,               MVT::v4i16, Promote);
 611     AddPromotedToType (ISD::LOAD,               MVT::v4i16, MVT::v1i64);
 612     setOperationAction(ISD::LOAD,               MVT::v2i32, Promote);
 613     AddPromotedToType (ISD::LOAD,               MVT::v2i32, MVT::v1i64);
 614     setOperationAction(ISD::LOAD,               MVT::v2f32, Promote);
 615     AddPromotedToType (ISD::LOAD,               MVT::v2f32, MVT::v1i64);
 616     setOperationAction(ISD::LOAD,               MVT::v1i64, Legal);
 617
 618     setOperationAction(ISD::BUILD_VECTOR,       MVT::v8i8,  Custom);
 619     setOperationAction(ISD::BUILD_VECTOR,       MVT::v4i16, Custom);
 620     setOperationAction(ISD::BUILD_VECTOR,       MVT::v2i32, Custom);
 621     setOperationAction(ISD::BUILD_VECTOR,       MVT::v2f32, Custom);
 622     setOperationAction(ISD::BUILD_VECTOR,       MVT::v1i64, Custom);
 623
 624     setOperationAction(ISD::VECTOR_SHUFFLE,     MVT::v8i8,  Custom);
 625     setOperationAction(ISD::VECTOR_SHUFFLE,     MVT::v4i16, Custom);
 626     setOperationAction(ISD::VECTOR_SHUFFLE,     MVT::v2i32, Custom);
 627     setOperationAction(ISD::VECTOR_SHUFFLE,     MVT::v1i64, Custom);
 628
 629     setOperationAction(ISD::SCALAR_TO_VECTOR,   MVT::v2f32, Custom);
 630     setOperationAction(ISD::SCALAR_TO_VECTOR,   MVT::v8i8,  Custom);
 631     setOperationAction(ISD::SCALAR_TO_VECTOR,   MVT::v4i16, Custom);
 632     setOperationAction(ISD::SCALAR_TO_VECTOR,   MVT::v1i64, Custom);
 633
 634     setOperationAction(ISD::INSERT_VECTOR_ELT,  MVT::v4i16, Custom);
 635   }
 636
 637   if (Subtarget->hasSSE1()) {
 638     addRegisterClass(MVT::v4f32, X86::VR128RegisterClass);
 639
 640     setOperationAction(ISD::FADD,               MVT::v4f32, Legal);
 641     setOperationAction(ISD::FSUB,               MVT::v4f32, Legal);
 642     setOperationAction(ISD::FMUL,               MVT::v4f32, Legal);
 643     setOperationAction(ISD::FDIV,               MVT::v4f32, Legal);
 644     setOperationAction(ISD::FSQRT,              MVT::v4f32, Legal);
 645     setOperationAction(ISD::FNEG,               MVT::v4f32, Custom);
 646     setOperationAction(ISD::LOAD,               MVT::v4f32, Legal);
 647     setOperationAction(ISD::BUILD_VECTOR,       MVT::v4f32, Custom);
 648     setOperationAction(ISD::VECTOR_SHUFFLE,     MVT::v4f32, Custom);
 649     setOperationAction(ISD::EXTRACT_VECTOR_ELT, MVT::v4f32, Custom);
 650     setOperationAction(ISD::SELECT,             MVT::v4f32, Custom);
 651     setOperationAction(ISD::VSETCC,             MVT::v4f32, Custom);
 652   }
 653
 654   if (Subtarget->hasSSE2()) {
 655     addRegisterClass(MVT::v2f64, X86::VR128RegisterClass);
 656     addRegisterClass(MVT::v16i8, X86::VR128RegisterClass);
 657     addRegisterClass(MVT::v8i16, X86::VR128RegisterClass);
 658     addRegisterClass(MVT::v4i32, X86::VR128RegisterClass);
 659     addRegisterClass(MVT::v2i64, X86::VR128RegisterClass);
 660
 661     setOperationAction(ISD::ADD,                MVT::v16i8, Legal);
 662     setOperationAction(ISD::ADD,                MVT::v8i16, Legal);
 663     setOperationAction(ISD::ADD,                MVT::v4i32, Legal);
 664     setOperationAction(ISD::ADD,                MVT::v2i64, Legal);
 665     setOperationAction(ISD::SUB,                MVT::v16i8, Legal);
 666     setOperationAction(ISD::SUB,                MVT::v8i16, Legal);
 667     setOperationAction(ISD::SUB,                MVT::v4i32, Legal);
 668     setOperationAction(ISD::SUB,                MVT::v2i64, Legal);
 669     setOperationAction(ISD::MUL,                MVT::v8i16, Legal);
 670     setOperationAction(ISD::FADD,               MVT::v2f64, Legal);
 671     setOperationAction(ISD::FSUB,               MVT::v2f64, Legal);
 672     setOperationAction(ISD::FMUL,               MVT::v2f64, Legal);
 673     setOperationAction(ISD::FDIV,               MVT::v2f64, Legal);
 674     setOperationAction(ISD::FSQRT,              MVT::v2f64, Legal);
 675     setOperationAction(ISD::FNEG,               MVT::v2f64, Custom);
 676
 677     setOperationAction(ISD::VSETCC,             MVT::v2f64, Custom);
 678     setOperationAction(ISD::VSETCC,             MVT::v16i8, Custom);
 679     setOperationAction(ISD::VSETCC,             MVT::v8i16, Custom);
 680     setOperationAction(ISD::VSETCC,             MVT::v4i32, Custom);
 681
 682     setOperationAction(ISD::SCALAR_TO_VECTOR,   MVT::v16i8, Custom);
 683     setOperationAction(ISD::SCALAR_TO_VECTOR,   MVT::v8i16, Custom);
 684     setOperationAction(ISD::INSERT_VECTOR_ELT,  MVT::v8i16, Custom);
 685     setOperationAction(ISD::INSERT_VECTOR_ELT,  MVT::v4i32, Custom);
 686     setOperationAction(ISD::INSERT_VECTOR_ELT,  MVT::v4f32, Custom);
 687
 688     // Custom lower build_vector, vector_shuffle, and extract_vector_elt.
 689     for (unsigned i = (unsigned)MVT::v16i8; i != (unsigned)MVT::v2i64; ++i) {
 690       MVT VT = (MVT::SimpleValueType)i;
 691       // Do not attempt to custom lower non-power-of-2 vectors
 692       if (!isPowerOf2_32(VT.getVectorNumElements()))
 693         continue;
 694       setOperationAction(ISD::BUILD_VECTOR,       VT, Custom);
 695       setOperationAction(ISD::VECTOR_SHUFFLE,     VT, Custom);
 696       setOperationAction(ISD::EXTRACT_VECTOR_ELT, VT, Custom);
 697     }
 698     setOperationAction(ISD::BUILD_VECTOR,       MVT::v2f64, Custom);
 699     setOperationAction(ISD::BUILD_VECTOR,       MVT::v2i64, Custom);
 700     setOperationAction(ISD::VECTOR_SHUFFLE,     MVT::v2f64, Custom);
 701     setOperationAction(ISD::VECTOR_SHUFFLE,     MVT::v2i64, Custom);
 702     setOperationAction(ISD::INSERT_VECTOR_ELT,  MVT::v2f64, Custom);
 703     setOperationAction(ISD::EXTRACT_VECTOR_ELT, MVT::v2f64, Custom);
 704     if (Subtarget->is64Bit()) {
 705       setOperationAction(ISD::INSERT_VECTOR_ELT,  MVT::v2i64, Custom);
 706       setOperationAction(ISD::EXTRACT_VECTOR_ELT, MVT::v2i64, Custom);
 707     }
 708
 709     // Promote v16i8, v8i16, v4i32 load, select, and, or, xor to v2i64.
 710     for (unsigned VT = (unsigned)MVT::v16i8; VT != (unsigned)MVT::v2i64; VT++) {
 711       setOperationAction(ISD::AND,    (MVT::SimpleValueType)VT, Promote);
 712       AddPromotedToType (ISD::AND,    (MVT::SimpleValueType)VT, MVT::v2i64);
 713       setOperationAction(ISD::OR,     (MVT::SimpleValueType)VT, Promote);
 714       AddPromotedToType (ISD::OR,     (MVT::SimpleValueType)VT, MVT::v2i64);
 715       setOperationAction(ISD::XOR,    (MVT::SimpleValueType)VT, Promote);
 716       AddPromotedToType (ISD::XOR,    (MVT::SimpleValueType)VT, MVT::v2i64);
 717       setOperationAction(ISD::LOAD,   (MVT::SimpleValueType)VT, Promote);
 718       AddPromotedToType (ISD::LOAD,   (MVT::SimpleValueType)VT, MVT::v2i64);
 719       setOperationAction(ISD::SELECT, (MVT::SimpleValueType)VT, Promote);
 720       AddPromotedToType (ISD::SELECT, (MVT::SimpleValueType)VT, MVT::v2i64);
 721     }
 722
 723     setTruncStoreAction(MVT::f64, MVT::f32, Expand);
 724
 725     // Custom lower v2i64 and v2f64 selects.
 726     setOperationAction(ISD::LOAD,               MVT::v2f64, Legal);
 727     setOperationAction(ISD::LOAD,               MVT::v2i64, Legal);
 728     setOperationAction(ISD::SELECT,             MVT::v2f64, Custom);
 729     setOperationAction(ISD::SELECT,             MVT::v2i64, Custom);
 730
 731   }
 732
 733   if (Subtarget->hasSSE41()) {
 734     // FIXME: Do we need to handle scalar-to-vector here?
 735     setOperationAction(ISD::MUL,                MVT::v4i32, Legal);
 736     setOperationAction(ISD::MUL,                MVT::v2i64, Legal);
 737
 738     // i8 and i16 vectors are custom , because the source register and source
 739     // source memory operand types are not the same width.  f32 vectors are
 740     // custom since the immediate controlling the insert encodes additional
 741     // information.
 742     setOperationAction(ISD::INSERT_VECTOR_ELT,  MVT::v16i8, Custom);
 743     setOperationAction(ISD::INSERT_VECTOR_ELT,  MVT::v8i16, Custom);
 744     setOperationAction(ISD::INSERT_VECTOR_ELT,  MVT::v4i32, Legal);
 745     setOperationAction(ISD::INSERT_VECTOR_ELT,  MVT::v4f32, Custom);
 746
 747     setOperationAction(ISD::EXTRACT_VECTOR_ELT, MVT::v16i8, Custom);
 748     setOperationAction(ISD::EXTRACT_VECTOR_ELT, MVT::v8i16, Custom);
 749     setOperationAction(ISD::EXTRACT_VECTOR_ELT, MVT::v4i32, Legal);
 750     setOperationAction(ISD::EXTRACT_VECTOR_ELT, MVT::v4f32, Custom);
 751
 752     if (Subtarget->is64Bit()) {
 753       setOperationAction(ISD::INSERT_VECTOR_ELT,  MVT::v2i64, Legal);
 754       setOperationAction(ISD::EXTRACT_VECTOR_ELT, MVT::v2i64, Legal);
 755     }
 756   }
 757
 758   if (Subtarget->hasSSE42()) {
 759     setOperationAction(ISD::VSETCC,             MVT::v2i64, Custom);
 760   }
 761
 762   // We want to custom lower some of our intrinsics.
 763   setOperationAction(ISD::INTRINSIC_WO_CHAIN, MVT::Other, Custom);
 764
 765   // We have target-specific dag combine patterns for the following nodes:
 766   setTargetDAGCombine(ISD::VECTOR_SHUFFLE);
 767   setTargetDAGCombine(ISD::BUILD_VECTOR);
 768   setTargetDAGCombine(ISD::SELECT);
 769   setTargetDAGCombine(ISD::STORE);
 770
 771   computeRegisterProperties();
 772
 773   // FIXME: These should be based on subtarget info. Plus, the values should
 774   // be smaller when we are in optimizing for size mode.
 775   maxStoresPerMemset = 16; // For @llvm.memset -> sequence of stores
 776   maxStoresPerMemcpy = 16; // For @llvm.memcpy -> sequence of stores
 777   maxStoresPerMemmove = 3; // For @llvm.memmove -> sequence of stores
 778   allowUnalignedMemoryAccesses = true; // x86 supports it!
 779   setPrefLoopAlignment(16);
 780 }
 781
 782
 783 MVT X86TargetLowering::getSetCCResultType(const SDValue &) const {
 784   return MVT::i8;
 785 }
 786
 787
 788 /// getMaxByValAlign - Helper for getByValTypeAlignment to determine
 789 /// the desired ByVal argument alignment.
 790 static void getMaxByValAlign(const Type *Ty, unsigned &MaxAlign) {
 791   if (MaxAlign == 16)
 792     return;
 793   if (const VectorType *VTy = dyn_cast<VectorType>(Ty)) {
 794     if (VTy->getBitWidth() == 128)
 795       MaxAlign = 16;
 796   } else if (const ArrayType *ATy = dyn_cast<ArrayType>(Ty)) {
 797     unsigned EltAlign = 0;
 798     getMaxByValAlign(ATy->getElementType(), EltAlign);
 799     if (EltAlign > MaxAlign)
 800       MaxAlign = EltAlign;
 801   } else if (const StructType *STy = dyn_cast<StructType>(Ty)) {
 802     for (unsigned i = 0, e = STy->getNumElements(); i != e; ++i) {
 803       unsigned EltAlign = 0;
 804       getMaxByValAlign(STy->getElementType(i), EltAlign);
 805       if (EltAlign > MaxAlign)
 806         MaxAlign = EltAlign;
 807       if (MaxAlign == 16)
 808         break;
 809     }
 810   }
 811   return;
 812 }
 813
 814 /// getByValTypeAlignment - Return the desired alignment for ByVal aggregate
 815 /// function arguments in the caller parameter area. For X86, aggregates
 816 /// that contain SSE vectors are placed at 16-byte boundaries while the rest
 817 /// are at 4-byte boundaries.
 818 unsigned X86TargetLowering::getByValTypeAlignment(const Type *Ty) const {
 819   if (Subtarget->is64Bit()) {
 820     // Max of 8 and alignment of type.
 821     unsigned TyAlign = TD->getABITypeAlignment(Ty);
 822     if (TyAlign > 8)
 823       return TyAlign;
 824     return 8;
 825   }
 826
 827   unsigned Align = 4;
 828   if (Subtarget->hasSSE1())
 829     getMaxByValAlign(Ty, Align);
 830   return Align;
 831 }
 832
 833 /// getOptimalMemOpType - Returns the target specific optimal type for load
 834 /// and store operations as a result of memset, memcpy, and memmove
 835 /// lowering. It returns MVT::iAny if SelectionDAG should be responsible for
 836 /// determining it.
 837 MVT
 838 X86TargetLowering::getOptimalMemOpType(uint64_t Size, unsigned Align,
 839                                        bool isSrcConst, bool isSrcStr) const {
 840   if ((isSrcConst || isSrcStr) && Subtarget->hasSSE2() && Size >= 16)
 841     return MVT::v4i32;
 842   if ((isSrcConst || isSrcStr) && Subtarget->hasSSE1() && Size >= 16)
 843     return MVT::v4f32;
 844   if (Subtarget->is64Bit() && Size >= 8)
 845     return MVT::i64;
 846   return MVT::i32;
 847 }
 848
 849
 850 /// getPICJumpTableRelocaBase - Returns relocation base for the given PIC
 851 /// jumptable.
 852 SDValue X86TargetLowering::getPICJumpTableRelocBase(SDValue Table,
 853                                                       SelectionDAG &DAG) const {
 854   if (usesGlobalOffsetTable())
 855     return DAG.getNode(ISD::GLOBAL_OFFSET_TABLE, getPointerTy());
 856   if (!Subtarget->isPICStyleRIPRel())
 857     return DAG.getNode(X86ISD::GlobalBaseReg, getPointerTy());
 858   return Table;
 859 }
 860
 861 //===----------------------------------------------------------------------===//
 862 //               Return Value Calling Convention Implementation
 863 //===----------------------------------------------------------------------===//
 864
 865 #include "X86GenCallingConv.inc"
 866
 867 /// LowerRET - Lower an ISD::RET node.
 868 SDValue X86TargetLowering::LowerRET(SDValue Op, SelectionDAG &DAG) {
 869   assert((Op.getNumOperands() & 1) == 1 && "ISD::RET should have odd # args");
 870
 871   SmallVector<CCValAssign, 16> RVLocs;
 872   unsigned CC = DAG.getMachineFunction().getFunction()->getCallingConv();
 873   bool isVarArg = DAG.getMachineFunction().getFunction()->isVarArg();
 874   CCState CCInfo(CC, isVarArg, getTargetMachine(), RVLocs);
 875   CCInfo.AnalyzeReturn(Op.getNode(), RetCC_X86);
 876
 877   // If this is the first return lowered for this function, add the regs to the
 878   // liveout set for the function.
 879   if (DAG.getMachineFunction().getRegInfo().liveout_empty()) {
 880     for (unsigned i = 0; i != RVLocs.size(); ++i)
 881       if (RVLocs[i].isRegLoc())
 882         DAG.getMachineFunction().getRegInfo().addLiveOut(RVLocs[i].getLocReg());
 883   }
 884   SDValue Chain = Op.getOperand(0);
 885
 886   // Handle tail call return.
 887   Chain = GetPossiblePreceedingTailCall(Chain, X86ISD::TAILCALL);
 888   if (Chain.getOpcode() == X86ISD::TAILCALL) {
 889     SDValue TailCall = Chain;
 890     SDValue TargetAddress = TailCall.getOperand(1);
 891     SDValue StackAdjustment = TailCall.getOperand(2);
 892     assert(((TargetAddress.getOpcode() == ISD::Register &&
 893                (cast<RegisterSDNode>(TargetAddress)->getReg() == X86::EAX ||
 894                 cast<RegisterSDNode>(TargetAddress)->getReg() == X86::R9)) ||
 895               TargetAddress.getOpcode() == ISD::TargetExternalSymbol ||
 896               TargetAddress.getOpcode() == ISD::TargetGlobalAddress) &&
 897              "Expecting an global address, external symbol, or register");
 898     assert(StackAdjustment.getOpcode() == ISD::Constant &&
 899            "Expecting a const value");
 900
 901     SmallVector<SDValue,8> Operands;
 902     Operands.push_back(Chain.getOperand(0));
 903     Operands.push_back(TargetAddress);
 904     Operands.push_back(StackAdjustment);
 905     // Copy registers used by the call. Last operand is a flag so it is not
 906     // copied.
 907     for (unsigned i=3; i < TailCall.getNumOperands()-1; i++) {
 908       Operands.push_back(Chain.getOperand(i));
 909     }
 910     return DAG.getNode(X86ISD::TC_RETURN, MVT::Other, &Operands[0],
 911                        Operands.size());
 912   }
 913
 914   // Regular return.
 915   SDValue Flag;
 916
 917   SmallVector<SDValue, 6> RetOps;
 918   RetOps.push_back(Chain); // Operand #0 = Chain (updated below)
 919   // Operand #1 = Bytes To Pop
 920   RetOps.push_back(DAG.getConstant(getBytesToPopOnReturn(), MVT::i16));
 921
 922   // Copy the result values into the output registers.
 923   for (unsigned i = 0; i != RVLocs.size(); ++i) {
 924     CCValAssign &VA = RVLocs[i];
 925     assert(VA.isRegLoc() && "Can only return in registers!");
 926     SDValue ValToCopy = Op.getOperand(i*2+1);
 927
 928     // Returns in ST0/ST1 are handled specially: these are pushed as operands to
 929     // the RET instruction and handled by the FP Stackifier.
 930     if (RVLocs[i].getLocReg() == X86::ST0 ||
 931         RVLocs[i].getLocReg() == X86::ST1) {
 932       // If this is a copy from an xmm register to ST(0), use an FPExtend to
 933       // change the value to the FP stack register class.
 934       if (isScalarFPTypeInSSEReg(RVLocs[i].getValVT()))
 935         ValToCopy = DAG.getNode(ISD::FP_EXTEND, MVT::f80, ValToCopy);
 936       RetOps.push_back(ValToCopy);
 937       // Don't emit a copytoreg.
 938       continue;
 939     }
 940
 941     Chain = DAG.getCopyToReg(Chain, VA.getLocReg(), ValToCopy, Flag);
 942     Flag = Chain.getValue(1);
 943   }
 944
 945   // The x86-64 ABI for returning structs by value requires that we copy
 946   // the sret argument into %rax for the return. We saved the argument into
 947   // a virtual register in the entry block, so now we copy the value out
 948   // and into %rax.
 949   if (Subtarget->is64Bit() &&
 950       DAG.getMachineFunction().getFunction()->hasStructRetAttr()) {
 951     MachineFunction &MF = DAG.getMachineFunction();
 952     X86MachineFunctionInfo *FuncInfo = MF.getInfo<X86MachineFunctionInfo>();
 953     unsigned Reg = FuncInfo->getSRetReturnReg();
 954     if (!Reg) {
 955       Reg = MF.getRegInfo().createVirtualRegister(getRegClassFor(MVT::i64));
 956       FuncInfo->setSRetReturnReg(Reg);
 957     }
 958     SDValue Val = DAG.getCopyFromReg(Chain, Reg, getPointerTy());
 959
 960     Chain = DAG.getCopyToReg(Chain, X86::RAX, Val, Flag);
 961     Flag = Chain.getValue(1);
 962   }
 963
 964   RetOps[0] = Chain;  // Update chain.
 965
 966   // Add the flag if we have it.
 967   if (Flag.getNode())
 968     RetOps.push_back(Flag);
 969
 970   return DAG.getNode(X86ISD::RET_FLAG, MVT::Other, &RetOps[0], RetOps.size());
 971 }
 972
 973
 974 /// LowerCallResult - Lower the result values of an ISD::CALL into the
 975 /// appropriate copies out of appropriate physical registers.  This assumes that
 976 /// Chain/InFlag are the input chain/flag to use, and that TheCall is the call
 977 /// being lowered.  The returns a SDNode with the same number of values as the
 978 /// ISD::CALL.
 979 SDNode *X86TargetLowering::
 980 LowerCallResult(SDValue Chain, SDValue InFlag, CallSDNode *TheCall,
 981                 unsigned CallingConv, SelectionDAG &DAG) {
 982
 983   // Assign locations to each value returned by this call.
 984   SmallVector<CCValAssign, 16> RVLocs;
 985   bool isVarArg = TheCall->isVarArg();
 986   CCState CCInfo(CallingConv, isVarArg, getTargetMachine(), RVLocs);
 987   CCInfo.AnalyzeCallResult(TheCall, RetCC_X86);
 988
 989   SmallVector<SDValue, 8> ResultVals;
 990
 991   // Copy all of the result registers out of their specified physreg.
 992   for (unsigned i = 0; i != RVLocs.size(); ++i) {
 993     MVT CopyVT = RVLocs[i].getValVT();
 994
 995     // If this is a call to a function that returns an fp value on the floating
 996     // point stack, but where we prefer to use the value in xmm registers, copy
 997     // it out as F80 and use a truncate to move it from fp stack reg to xmm reg.
 998     if ((RVLocs[i].getLocReg() == X86::ST0 ||
 999          RVLocs[i].getLocReg() == X86::ST1) &&
1000         isScalarFPTypeInSSEReg(RVLocs[i].getValVT())) {
1001       CopyVT = MVT::f80;
1002     }
1003
1004     Chain = DAG.getCopyFromReg(Chain, RVLocs[i].getLocReg(),
1005                                CopyVT, InFlag).getValue(1);
1006     SDValue Val = Chain.getValue(0);
1007     InFlag = Chain.getValue(2);
1008
1009     if (CopyVT != RVLocs[i].getValVT()) {
1010       // Round the F80 the right size, which also moves to the appropriate xmm
1011       // register.
1012       Val = DAG.getNode(ISD::FP_ROUND, RVLocs[i].getValVT(), Val,
1013                         // This truncation won't change the value.
1014                         DAG.getIntPtrConstant(1));
1015     }
1016
1017     ResultVals.push_back(Val);
1018   }
1019
1020   // Merge everything together with a MERGE_VALUES node.
1021   ResultVals.push_back(Chain);
1022   return DAG.getMergeValues(TheCall->getVTList(), &ResultVals[0],
1023                             ResultVals.size()).getNode();
1024 }
1025
1026
1027 //===----------------------------------------------------------------------===//
1028 //                C & StdCall & Fast Calling Convention implementation
1029 //===----------------------------------------------------------------------===//
1030 //  StdCall calling convention seems to be standard for many Windows' API
1031 //  routines and around. It differs from C calling convention just a little:
1032 //  callee should clean up the stack, not caller. Symbols should be also
1033 //  decorated in some fancy way :) It doesn't support any vector arguments.
1034 //  For info on fast calling convention see Fast Calling Convention (tail call)
1035 //  implementation LowerX86_32FastCCCallTo.
1036
1037 /// AddLiveIn - This helper function adds the specified physical register to the
1038 /// MachineFunction as a live in value.  It also creates a corresponding virtual
1039 /// register for it.
1040 static unsigned AddLiveIn(MachineFunction &MF, unsigned PReg,
1041                           const TargetRegisterClass *RC) {
1042   assert(RC->contains(PReg) && "Not the correct regclass!");
1043   unsigned VReg = MF.getRegInfo().createVirtualRegister(RC);
1044   MF.getRegInfo().addLiveIn(PReg, VReg);
1045   return VReg;
1046 }
1047
1048 /// CallIsStructReturn - Determines whether a CALL node uses struct return
1049 /// semantics.
1050 static bool CallIsStructReturn(CallSDNode *TheCall) {
1051   unsigned NumOps = TheCall->getNumArgs();
1052   if (!NumOps)
1053     return false;
1054
1055   return TheCall->getArgFlags(0).isSRet();
1056 }
1057
1058 /// ArgsAreStructReturn - Determines whether a FORMAL_ARGUMENTS node uses struct
1059 /// return semantics.
1060 static bool ArgsAreStructReturn(SDValue Op) {
1061   unsigned NumArgs = Op.getNode()->getNumValues() - 1;
1062   if (!NumArgs)
1063     return false;
1064
1065   return cast<ARG_FLAGSSDNode>(Op.getOperand(3))->getArgFlags().isSRet();
1066 }
1067
1068 /// IsCalleePop - Determines whether a CALL or FORMAL_ARGUMENTS node requires
1069 /// the callee to pop its own arguments. Callee pop is necessary to support tail
1070 /// calls.
1071 bool X86TargetLowering::IsCalleePop(bool IsVarArg, unsigned CallingConv) {
1072   if (IsVarArg)
1073     return false;
1074
1075   switch (CallingConv) {
1076   default:
1077     return false;
1078   case CallingConv::X86_StdCall:
1079     return !Subtarget->is64Bit();
1080   case CallingConv::X86_FastCall:
1081     return !Subtarget->is64Bit();
1082   case CallingConv::Fast:
1083     return PerformTailCallOpt;
1084   }
1085 }
1086
1087 /// CCAssignFnForNode - Selects the correct CCAssignFn for a the
1088 /// given CallingConvention value.
1089 CCAssignFn *X86TargetLowering::CCAssignFnForNode(unsigned CC) const {
1090   if (Subtarget->is64Bit()) {
1091     if (Subtarget->isTargetWin64())
1092       return CC_X86_Win64_C;
1093     else if (CC == CallingConv::Fast && PerformTailCallOpt)
1094       return CC_X86_64_TailCall;
1095     else
1096       return CC_X86_64_C;
1097   }
1098
1099   if (CC == CallingConv::X86_FastCall)
1100     return CC_X86_32_FastCall;
1101   else if (CC == CallingConv::Fast)
1102     return CC_X86_32_FastCC;
1103   else
1104     return CC_X86_32_C;
1105 }
1106
1107 /// NameDecorationForFORMAL_ARGUMENTS - Selects the appropriate decoration to
1108 /// apply to a MachineFunction containing a given FORMAL_ARGUMENTS node.
1109 NameDecorationStyle
1110 X86TargetLowering::NameDecorationForFORMAL_ARGUMENTS(SDValue Op) {
1111   unsigned CC = cast<ConstantSDNode>(Op.getOperand(1))->getZExtValue();
1112   if (CC == CallingConv::X86_FastCall)
1113     return FastCall;
1114   else if (CC == CallingConv::X86_StdCall)
1115     return StdCall;
1116   return None;
1117 }
1118
1119
1120 /// CallRequiresGOTInRegister - Check whether the call requires the GOT pointer
1121 /// in a register before calling.
1122 bool X86TargetLowering::CallRequiresGOTPtrInReg(bool Is64Bit, bool IsTailCall) {
1123   return !IsTailCall && !Is64Bit &&
1124     getTargetMachine().getRelocationModel() == Reloc::PIC_ &&
1125     Subtarget->isPICStyleGOT();
1126 }
1127
1128 /// CallRequiresFnAddressInReg - Check whether the call requires the function
1129 /// address to be loaded in a register.
1130 bool
1131 X86TargetLowering::CallRequiresFnAddressInReg(bool Is64Bit, bool IsTailCall) {
1132   return !Is64Bit && IsTailCall &&
1133     getTargetMachine().getRelocationModel() == Reloc::PIC_ &&
1134     Subtarget->isPICStyleGOT();
1135 }
1136
1137 /// CreateCopyOfByValArgument - Make a copy of an aggregate at address specified
1138 /// by "Src" to address "Dst" with size and alignment information specified by
1139 /// the specific parameter attribute. The copy will be passed as a byval
1140 /// function parameter.
1141 static SDValue
1142 CreateCopyOfByValArgument(SDValue Src, SDValue Dst, SDValue Chain,
1143                           ISD::ArgFlagsTy Flags, SelectionDAG &DAG) {
1144   SDValue SizeNode     = DAG.getConstant(Flags.getByValSize(), MVT::i32);
1145   return DAG.getMemcpy(Chain, Dst, Src, SizeNode, Flags.getByValAlign(),
1146                        /*AlwaysInline=*/true, NULL, 0, NULL, 0);
1147 }
1148
1149 SDValue X86TargetLowering::LowerMemArgument(SDValue Op, SelectionDAG &DAG,
1150                                               const CCValAssign &VA,
1151                                               MachineFrameInfo *MFI,
1152                                               unsigned CC,
1153                                               SDValue Root, unsigned i) {
1154   // Create the nodes corresponding to a load from this parameter slot.
1155   ISD::ArgFlagsTy Flags =
1156     cast<ARG_FLAGSSDNode>(Op.getOperand(3 + i))->getArgFlags();
1157   bool AlwaysUseMutable = (CC==CallingConv::Fast) && PerformTailCallOpt;
1158   bool isImmutable = !AlwaysUseMutable && !Flags.isByVal();
1159
1160   // FIXME: For now, all byval parameter objects are marked mutable. This can be
1161   // changed with more analysis.
1162   // In case of tail call optimization mark all arguments mutable. Since they
1163   // could be overwritten by lowering of arguments in case of a tail call.
1164   int FI = MFI->CreateFixedObject(VA.getValVT().getSizeInBits()/8,
1165                                   VA.getLocMemOffset(), isImmutable);
1166   SDValue FIN = DAG.getFrameIndex(FI, getPointerTy());
1167   if (Flags.isByVal())
1168     return FIN;
1169   return DAG.getLoad(VA.getValVT(), Root, FIN,
1170                      PseudoSourceValue::getFixedStack(FI), 0);
1171 }
1172
1173 SDValue
1174 X86TargetLowering::LowerFORMAL_ARGUMENTS(SDValue Op, SelectionDAG &DAG) {
1175   MachineFunction &MF = DAG.getMachineFunction();
1176   X86MachineFunctionInfo *FuncInfo = MF.getInfo<X86MachineFunctionInfo>();
1177
1178   const Function* Fn = MF.getFunction();
1179   if (Fn->hasExternalLinkage() &&
1180       Subtarget->isTargetCygMing() &&
1181       Fn->getName() == "main")
1182     FuncInfo->setForceFramePointer(true);
1183
1184   // Decorate the function name.
1185   FuncInfo->setDecorationStyle(NameDecorationForFORMAL_ARGUMENTS(Op));
1186
1187   MachineFrameInfo *MFI = MF.getFrameInfo();
1188   SDValue Root = Op.getOperand(0);
1189   bool isVarArg = cast<ConstantSDNode>(Op.getOperand(2))->getZExtValue() != 0;
1190   unsigned CC = MF.getFunction()->getCallingConv();
1191   bool Is64Bit = Subtarget->is64Bit();
1192   bool IsWin64 = Subtarget->isTargetWin64();
1193
1194   assert(!(isVarArg && CC == CallingConv::Fast) &&
1195          "Var args not supported with calling convention fastcc");
1196
1197   // Assign locations to all of the incoming arguments.
1198   SmallVector<CCValAssign, 16> ArgLocs;
1199   CCState CCInfo(CC, isVarArg, getTargetMachine(), ArgLocs);
1200   CCInfo.AnalyzeFormalArguments(Op.getNode(), CCAssignFnForNode(CC));
1201
1202   SmallVector<SDValue, 8> ArgValues;
1203   unsigned LastVal = ~0U;
1204   for (unsigned i = 0, e = ArgLocs.size(); i != e; ++i) {
1205     CCValAssign &VA = ArgLocs[i];
1206     // TODO: If an arg is passed in two places (e.g. reg and stack), skip later
1207     // places.
1208     assert(VA.getValNo() != LastVal &&
1209            "Don't support value assigned to multiple locs yet");
1210     LastVal = VA.getValNo();
1211
1212     if (VA.isRegLoc()) {
1213       MVT RegVT = VA.getLocVT();
1214       TargetRegisterClass *RC;
1215       if (RegVT == MVT::i32)
1216         RC = X86::GR32RegisterClass;
1217       else if (Is64Bit && RegVT == MVT::i64)
1218         RC = X86::GR64RegisterClass;
1219       else if (RegVT == MVT::f32)
1220         RC = X86::FR32RegisterClass;
1221       else if (RegVT == MVT::f64)
1222         RC = X86::FR64RegisterClass;
1223       else if (RegVT.isVector() && RegVT.getSizeInBits() == 128)
1224         RC = X86::VR128RegisterClass;
1225       else if (RegVT.isVector()) {
1226         assert(RegVT.getSizeInBits() == 64);
1227         if (!Is64Bit)
1228           RC = X86::VR64RegisterClass;     // MMX values are passed in MMXs.
1229         else {
1230           // Darwin calling convention passes MMX values in either GPRs or
1231           // XMMs in x86-64. Other targets pass them in memory.
1232           if (RegVT != MVT::v1i64 && Subtarget->hasSSE2()) {
1233             RC = X86::VR128RegisterClass;  // MMX values are passed in XMMs.
1234             RegVT = MVT::v2i64;
1235           } else {
1236             RC = X86::GR64RegisterClass;   // v1i64 values are passed in GPRs.
1237             RegVT = MVT::i64;
1238           }
1239         }
1240       } else {
1241         assert(0 && "Unknown argument type!");
1242       }
1243
1244       unsigned Reg = AddLiveIn(DAG.getMachineFunction(), VA.getLocReg(), RC);
1245       SDValue ArgValue = DAG.getCopyFromReg(Root, Reg, RegVT);
1246
1247       // If this is an 8 or 16-bit value, it is really passed promoted to 32
1248       // bits.  Insert an assert[sz]ext to capture this, then truncate to the
1249       // right size.
1250       if (VA.getLocInfo() == CCValAssign::SExt)
1251         ArgValue = DAG.getNode(ISD::AssertSext, RegVT, ArgValue,
1252                                DAG.getValueType(VA.getValVT()));
1253       else if (VA.getLocInfo() == CCValAssign::ZExt)
1254         ArgValue = DAG.getNode(ISD::AssertZext, RegVT, ArgValue,
1255                                DAG.getValueType(VA.getValVT()));
1256
1257       if (VA.getLocInfo() != CCValAssign::Full)
1258         ArgValue = DAG.getNode(ISD::TRUNCATE, VA.getValVT(), ArgValue);
1259
1260       // Handle MMX values passed in GPRs.
1261       if (Is64Bit && RegVT != VA.getLocVT()) {
1262         if (RegVT.getSizeInBits() == 64 && RC == X86::GR64RegisterClass)
1263           ArgValue = DAG.getNode(ISD::BIT_CONVERT, VA.getLocVT(), ArgValue);
1264         else if (RC == X86::VR128RegisterClass) {
1265           ArgValue = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, MVT::i64, ArgValue,
1266                                  DAG.getConstant(0, MVT::i64));
1267           ArgValue = DAG.getNode(ISD::BIT_CONVERT, VA.getLocVT(), ArgValue);
1268         }
1269       }
1270
1271       ArgValues.push_back(ArgValue);
1272     } else {
1273       assert(VA.isMemLoc());
1274       ArgValues.push_back(LowerMemArgument(Op, DAG, VA, MFI, CC, Root, i));
1275     }
1276   }
1277
1278   // The x86-64 ABI for returning structs by value requires that we copy
1279   // the sret argument into %rax for the return. Save the argument into
1280   // a virtual register so that we can access it from the return points.
1281   if (Is64Bit && DAG.getMachineFunction().getFunction()->hasStructRetAttr()) {
1282     MachineFunction &MF = DAG.getMachineFunction();
1283     X86MachineFunctionInfo *FuncInfo = MF.getInfo<X86MachineFunctionInfo>();
1284     unsigned Reg = FuncInfo->getSRetReturnReg();
1285     if (!Reg) {
1286       Reg = MF.getRegInfo().createVirtualRegister(getRegClassFor(MVT::i64));
1287       FuncInfo->setSRetReturnReg(Reg);
1288     }
1289     SDValue Copy = DAG.getCopyToReg(DAG.getEntryNode(), Reg, ArgValues[0]);
1290     Root = DAG.getNode(ISD::TokenFactor, MVT::Other, Copy, Root);
1291   }
1292
1293   unsigned StackSize = CCInfo.getNextStackOffset();
1294   // align stack specially for tail calls
1295   if (PerformTailCallOpt && CC == CallingConv::Fast)
1296     StackSize = GetAlignedArgumentStackSize(StackSize, DAG);
1297
1298   // If the function takes variable number of arguments, make a frame index for
1299   // the start of the first vararg value... for expansion of llvm.va_start.
1300   if (isVarArg) {
1301     if (Is64Bit || CC != CallingConv::X86_FastCall) {
1302       VarArgsFrameIndex = MFI->CreateFixedObject(1, StackSize);
1303     }
1304     if (Is64Bit) {
1305       unsigned TotalNumIntRegs = 0, TotalNumXMMRegs = 0;
1306
1307       // FIXME: We should really autogenerate these arrays
1308       static const unsigned GPR64ArgRegsWin64[] = {
1309         X86::RCX, X86::RDX, X86::R8,  X86::R9
1310       };
1311       static const unsigned XMMArgRegsWin64[] = {
1312         X86::XMM0, X86::XMM1, X86::XMM2, X86::XMM3
1313       };
1314       static const unsigned GPR64ArgRegs64Bit[] = {
1315         X86::RDI, X86::RSI, X86::RDX, X86::RCX, X86::R8, X86::R9
1316       };
1317       static const unsigned XMMArgRegs64Bit[] = {
1318         X86::XMM0, X86::XMM1, X86::XMM2, X86::XMM3,
1319         X86::XMM4, X86::XMM5, X86::XMM6, X86::XMM7
1320       };
1321       const unsigned *GPR64ArgRegs, *XMMArgRegs;
1322
1323       if (IsWin64) {
1324         TotalNumIntRegs = 4; TotalNumXMMRegs = 4;
1325         GPR64ArgRegs = GPR64ArgRegsWin64;
1326         XMMArgRegs = XMMArgRegsWin64;
1327       } else {
1328         TotalNumIntRegs = 6; TotalNumXMMRegs = 8;
1329         GPR64ArgRegs = GPR64ArgRegs64Bit;
1330         XMMArgRegs = XMMArgRegs64Bit;
1331       }
1332       unsigned NumIntRegs = CCInfo.getFirstUnallocated(GPR64ArgRegs,
1333                                                        TotalNumIntRegs);
1334       unsigned NumXMMRegs = CCInfo.getFirstUnallocated(XMMArgRegs,
1335                                                        TotalNumXMMRegs);
1336
1337       // For X86-64, if there are vararg parameters that are passed via
1338       // registers, then we must store them to their spots on the stack so they
1339       // may be loaded by deferencing the result of va_next.
1340       VarArgsGPOffset = NumIntRegs * 8;
1341       VarArgsFPOffset = TotalNumIntRegs * 8 + NumXMMRegs * 16;
1342       RegSaveFrameIndex = MFI->CreateStackObject(TotalNumIntRegs * 8 +
1343                                                  TotalNumXMMRegs * 16, 16);
1344
1345       // Store the integer parameter registers.
1346       SmallVector<SDValue, 8> MemOps;
1347       SDValue RSFIN = DAG.getFrameIndex(RegSaveFrameIndex, getPointerTy());
1348       SDValue FIN = DAG.getNode(ISD::ADD, getPointerTy(), RSFIN,
1349                                   DAG.getIntPtrConstant(VarArgsGPOffset));
1350       for (; NumIntRegs != TotalNumIntRegs; ++NumIntRegs) {
1351         unsigned VReg = AddLiveIn(MF, GPR64ArgRegs[NumIntRegs],
1352                                   X86::GR64RegisterClass);
1353         SDValue Val = DAG.getCopyFromReg(Root, VReg, MVT::i64);
1354         SDValue Store =
1355           DAG.getStore(Val.getValue(1), Val, FIN,
1356                        PseudoSourceValue::getFixedStack(RegSaveFrameIndex), 0);
1357         MemOps.push_back(Store);
1358         FIN = DAG.getNode(ISD::ADD, getPointerTy(), FIN,
1359                           DAG.getIntPtrConstant(8));
1360       }
1361
1362       // Now store the XMM (fp + vector) parameter registers.
1363       FIN = DAG.getNode(ISD::ADD, getPointerTy(), RSFIN,
1364                         DAG.getIntPtrConstant(VarArgsFPOffset));
1365       for (; NumXMMRegs != TotalNumXMMRegs; ++NumXMMRegs) {
1366         unsigned VReg = AddLiveIn(MF, XMMArgRegs[NumXMMRegs],
1367                                   X86::VR128RegisterClass);
1368         SDValue Val = DAG.getCopyFromReg(Root, VReg, MVT::v4f32);
1369         SDValue Store =
1370           DAG.getStore(Val.getValue(1), Val, FIN,
1371                        PseudoSourceValue::getFixedStack(RegSaveFrameIndex), 0);
1372         MemOps.push_back(Store);
1373         FIN = DAG.getNode(ISD::ADD, getPointerTy(), FIN,
1374                           DAG.getIntPtrConstant(16));
1375       }
1376       if (!MemOps.empty())
1377           Root = DAG.getNode(ISD::TokenFactor, MVT::Other,
1378                              &MemOps[0], MemOps.size());
1379     }
1380   }
1381
1382   ArgValues.push_back(Root);
1383
1384   // Some CCs need callee pop.
1385   if (IsCalleePop(isVarArg, CC)) {
1386     BytesToPopOnReturn  = StackSize; // Callee pops everything.
1387     BytesCallerReserves = 0;
1388   } else {
1389     BytesToPopOnReturn  = 0; // Callee pops nothing.
1390     // If this is an sret function, the return should pop the hidden pointer.
1391     if (!Is64Bit && CC != CallingConv::Fast && ArgsAreStructReturn(Op))
1392       BytesToPopOnReturn = 4;
1393     BytesCallerReserves = StackSize;
1394   }
1395
1396   if (!Is64Bit) {
1397     RegSaveFrameIndex = 0xAAAAAAA;   // RegSaveFrameIndex is X86-64 only.
1398     if (CC == CallingConv::X86_FastCall)
1399       VarArgsFrameIndex = 0xAAAAAAA;   // fastcc functions can't have varargs.
1400   }
1401
1402   FuncInfo->setBytesToPopOnReturn(BytesToPopOnReturn);
1403
1404   // Return the new list of results.
1405   return DAG.getMergeValues(Op.getNode()->getVTList(), &ArgValues[0],
1406                             ArgValues.size()).getValue(Op.getResNo());
1407 }
1408
1409 SDValue
1410 X86TargetLowering::LowerMemOpCallTo(CallSDNode *TheCall, SelectionDAG &DAG,
1411                                     const SDValue &StackPtr,
1412                                     const CCValAssign &VA,
1413                                     SDValue Chain,
1414                                     SDValue Arg, ISD::ArgFlagsTy Flags) {
1415   unsigned LocMemOffset = VA.getLocMemOffset();
1416   SDValue PtrOff = DAG.getIntPtrConstant(LocMemOffset);
1417   PtrOff = DAG.getNode(ISD::ADD, getPointerTy(), StackPtr, PtrOff);
1418   if (Flags.isByVal()) {
1419     return CreateCopyOfByValArgument(Arg, PtrOff, Chain, Flags, DAG);
1420   }
1421   return DAG.getStore(Chain, Arg, PtrOff,
1422                       PseudoSourceValue::getStack(), LocMemOffset);
1423 }
1424
1425 /// EmitTailCallLoadRetAddr - Emit a load of return adress if tail call
1426 /// optimization is performed and it is required.
1427 SDValue
1428 X86TargetLowering::EmitTailCallLoadRetAddr(SelectionDAG &DAG,
1429                                            SDValue &OutRetAddr,
1430                                            SDValue Chain,
1431                                            bool IsTailCall,
1432                                            bool Is64Bit,
1433                                            int FPDiff) {
1434   if (!IsTailCall || FPDiff==0) return Chain;
1435
1436   // Adjust the Return address stack slot.
1437   MVT VT = getPointerTy();
1438   OutRetAddr = getReturnAddressFrameIndex(DAG);
1439   // Load the "old" Return address.
1440   OutRetAddr = DAG.getLoad(VT, Chain,OutRetAddr, NULL, 0);
1441   return SDValue(OutRetAddr.getNode(), 1);
1442 }
1443
1444 /// EmitTailCallStoreRetAddr - Emit a store of the return adress if tail call
1445 /// optimization is performed and it is required (FPDiff!=0).
1446 static SDValue
1447 EmitTailCallStoreRetAddr(SelectionDAG & DAG, MachineFunction &MF,
1448                          SDValue Chain, SDValue RetAddrFrIdx,
1449                          bool Is64Bit, int FPDiff) {
1450   // Store the return address to the appropriate stack slot.
1451   if (!FPDiff) return Chain;
1452   // Calculate the new stack slot for the return address.
1453   int SlotSize = Is64Bit ? 8 : 4;
1454   int NewReturnAddrFI =
1455     MF.getFrameInfo()->CreateFixedObject(SlotSize, FPDiff-SlotSize);
1456   MVT VT = Is64Bit ? MVT::i64 : MVT::i32;
1457   SDValue NewRetAddrFrIdx = DAG.getFrameIndex(NewReturnAddrFI, VT);
1458   Chain = DAG.getStore(Chain, RetAddrFrIdx, NewRetAddrFrIdx,
1459                        PseudoSourceValue::getFixedStack(NewReturnAddrFI), 0);
1460   return Chain;
1461 }
1462
1463 SDValue X86TargetLowering::LowerCALL(SDValue Op, SelectionDAG &DAG) {
1464   MachineFunction &MF = DAG.getMachineFunction();
1465   CallSDNode *TheCall = cast<CallSDNode>(Op.getNode());
1466   SDValue Chain       = TheCall->getChain();
1467   unsigned CC         = TheCall->getCallingConv();
1468   bool isVarArg       = TheCall->isVarArg();
1469   bool IsTailCall     = TheCall->isTailCall() &&
1470                         CC == CallingConv::Fast && PerformTailCallOpt;
1471   SDValue Callee      = TheCall->getCallee();
1472   bool Is64Bit        = Subtarget->is64Bit();
1473   bool IsStructRet    = CallIsStructReturn(TheCall);
1474
1475   assert(!(isVarArg && CC == CallingConv::Fast) &&
1476          "Var args not supported with calling convention fastcc");
1477
1478   // Analyze operands of the call, assigning locations to each operand.
1479   SmallVector<CCValAssign, 16> ArgLocs;
1480   CCState CCInfo(CC, isVarArg, getTargetMachine(), ArgLocs);
1481   CCInfo.AnalyzeCallOperands(TheCall, CCAssignFnForNode(CC));
1482
1483   // Get a count of how many bytes are to be pushed on the stack.
1484   unsigned NumBytes = CCInfo.getNextStackOffset();
1485   if (PerformTailCallOpt && CC == CallingConv::Fast)
1486     NumBytes = GetAlignedArgumentStackSize(NumBytes, DAG);
1487
1488   int FPDiff = 0;
1489   if (IsTailCall) {
1490     // Lower arguments at fp - stackoffset + fpdiff.
1491     unsigned NumBytesCallerPushed =
1492       MF.getInfo<X86MachineFunctionInfo>()->getBytesToPopOnReturn();
1493     FPDiff = NumBytesCallerPushed - NumBytes;
1494
1495     // Set the delta of movement of the returnaddr stackslot.
1496     // But only set if delta is greater than previous delta.
1497     if (FPDiff < (MF.getInfo<X86MachineFunctionInfo>()->getTCReturnAddrDelta()))
1498       MF.getInfo<X86MachineFunctionInfo>()->setTCReturnAddrDelta(FPDiff);
1499   }
1500
1501   Chain = DAG.getCALLSEQ_START(Chain, DAG.getIntPtrConstant(NumBytes));
1502
1503   SDValue RetAddrFrIdx;
1504   // Load return adress for tail calls.
1505   Chain = EmitTailCallLoadRetAddr(DAG, RetAddrFrIdx, Chain, IsTailCall, Is64Bit,
1506                                   FPDiff);
1507
1508   SmallVector<std::pair<unsigned, SDValue>, 8> RegsToPass;
1509   SmallVector<SDValue, 8> MemOpChains;
1510   SDValue StackPtr;
1511
1512   // Walk the register/memloc assignments, inserting copies/loads.  In the case
1513   // of tail call optimization arguments are handle later.
1514   for (unsigned i = 0, e = ArgLocs.size(); i != e; ++i) {
1515     CCValAssign &VA = ArgLocs[i];
1516     SDValue Arg = TheCall->getArg(i);
1517     ISD::ArgFlagsTy Flags = TheCall->getArgFlags(i);
1518     bool isByVal = Flags.isByVal();
1519
1520     // Promote the value if needed.
1521     switch (VA.getLocInfo()) {
1522     default: assert(0 && "Unknown loc info!");
1523     case CCValAssign::Full: break;
1524     case CCValAssign::SExt:
1525       Arg = DAG.getNode(ISD::SIGN_EXTEND, VA.getLocVT(), Arg);
1526       break;
1527     case CCValAssign::ZExt:
1528       Arg = DAG.getNode(ISD::ZERO_EXTEND, VA.getLocVT(), Arg);
1529       break;
1530     case CCValAssign::AExt:
1531       Arg = DAG.getNode(ISD::ANY_EXTEND, VA.getLocVT(), Arg);
1532       break;
1533     }
1534
1535     if (VA.isRegLoc()) {
1536       if (Is64Bit) {
1537         MVT RegVT = VA.getLocVT();
1538         if (RegVT.isVector() && RegVT.getSizeInBits() == 64)
1539           switch (VA.getLocReg()) {
1540           default:
1541             break;
1542           case X86::RDI: case X86::RSI: case X86::RDX: case X86::RCX:
1543           case X86::R8: {
1544             // Special case: passing MMX values in GPR registers.
1545             Arg = DAG.getNode(ISD::BIT_CONVERT, MVT::i64, Arg);
1546             break;
1547           }
1548           case X86::XMM0: case X86::XMM1: case X86::XMM2: case X86::XMM3:
1549           case X86::XMM4: case X86::XMM5: case X86::XMM6: case X86::XMM7: {
1550             // Special case: passing MMX values in XMM registers.
1551             Arg = DAG.getNode(ISD::BIT_CONVERT, MVT::i64, Arg);
1552             Arg = DAG.getNode(ISD::SCALAR_TO_VECTOR, MVT::v2i64, Arg);
1553             Arg = DAG.getNode(ISD::VECTOR_SHUFFLE, MVT::v2i64,
1554                               DAG.getNode(ISD::UNDEF, MVT::v2i64), Arg,
1555                               getMOVLMask(2, DAG));
1556             break;
1557           }
1558           }
1559       }
1560       RegsToPass.push_back(std::make_pair(VA.getLocReg(), Arg));
1561     } else {
1562       if (!IsTailCall || (IsTailCall && isByVal)) {
1563         assert(VA.isMemLoc());
1564         if (StackPtr.getNode() == 0)
1565           StackPtr = DAG.getCopyFromReg(Chain, X86StackPtr, getPointerTy());
1566
1567         MemOpChains.push_back(LowerMemOpCallTo(TheCall, DAG, StackPtr, VA,
1568                                                Chain, Arg, Flags));
1569       }
1570     }
1571   }
1572
1573   if (!MemOpChains.empty())
1574     Chain = DAG.getNode(ISD::TokenFactor, MVT::Other,
1575                         &MemOpChains[0], MemOpChains.size());
1576
1577   // Build a sequence of copy-to-reg nodes chained together with token chain
1578   // and flag operands which copy the outgoing args into registers.
1579   SDValue InFlag;
1580   // Tail call byval lowering might overwrite argument registers so in case of
1581   // tail call optimization the copies to registers are lowered later.
1582   if (!IsTailCall)
1583     for (unsigned i = 0, e = RegsToPass.size(); i != e; ++i) {
1584       Chain = DAG.getCopyToReg(Chain, RegsToPass[i].first, RegsToPass[i].second,
1585                                InFlag);
1586       InFlag = Chain.getValue(1);
1587     }
1588
1589   // ELF / PIC requires GOT in the EBX register before function calls via PLT
1590   // GOT pointer.
1591   if (CallRequiresGOTPtrInReg(Is64Bit, IsTailCall)) {
1592     Chain = DAG.getCopyToReg(Chain, X86::EBX,
1593                              DAG.getNode(X86ISD::GlobalBaseReg, getPointerTy()),
1594                              InFlag);
1595     InFlag = Chain.getValue(1);
1596   }
1597   // If we are tail calling and generating PIC/GOT style code load the address
1598   // of the callee into ecx. The value in ecx is used as target of the tail
1599   // jump. This is done to circumvent the ebx/callee-saved problem for tail
1600   // calls on PIC/GOT architectures. Normally we would just put the address of
1601   // GOT into ebx and then call target@PLT. But for tail callss ebx would be
1602   // restored (since ebx is callee saved) before jumping to the target@PLT.
1603   if (CallRequiresFnAddressInReg(Is64Bit, IsTailCall)) {
1604     // Note: The actual moving to ecx is done further down.
1605     GlobalAddressSDNode *G = dyn_cast<GlobalAddressSDNode>(Callee);
1606     if (G && !G->getGlobal()->hasHiddenVisibility() &&
1607         !G->getGlobal()->hasProtectedVisibility())
1608       Callee =  LowerGlobalAddress(Callee, DAG);
1609     else if (isa<ExternalSymbolSDNode>(Callee))
1610       Callee = LowerExternalSymbol(Callee,DAG);
1611   }
1612
1613   if (Is64Bit && isVarArg) {
1614     // From AMD64 ABI document:
1615     // For calls that may call functions that use varargs or stdargs
1616     // (prototype-less calls or calls to functions containing ellipsis (...) in
1617     // the declaration) %al is used as hidden argument to specify the number
1618     // of SSE registers used. The contents of %al do not need to match exactly
1619     // the number of registers, but must be an ubound on the number of SSE
1620     // registers used and is in the range 0 - 8 inclusive.
1621
1622     // FIXME: Verify this on Win64
1623     // Count the number of XMM registers allocated.
1624     static const unsigned XMMArgRegs[] = {
1625       X86::XMM0, X86::XMM1, X86::XMM2, X86::XMM3,
1626       X86::XMM4, X86::XMM5, X86::XMM6, X86::XMM7
1627     };
1628     unsigned NumXMMRegs = CCInfo.getFirstUnallocated(XMMArgRegs, 8);
1629
1630     Chain = DAG.getCopyToReg(Chain, X86::AL,
1631                              DAG.getConstant(NumXMMRegs, MVT::i8), InFlag);
1632     InFlag = Chain.getValue(1);
1633   }
1634
1635
1636   // For tail calls lower the arguments to the 'real' stack slot.
1637   if (IsTailCall) {
1638     SmallVector<SDValue, 8> MemOpChains2;
1639     SDValue FIN;
1640     int FI = 0;
1641     // Do not flag preceeding copytoreg stuff together with the following stuff.
1642     InFlag = SDValue();
1643     for (unsigned i = 0, e = ArgLocs.size(); i != e; ++i) {
1644       CCValAssign &VA = ArgLocs[i];
1645       if (!VA.isRegLoc()) {
1646         assert(VA.isMemLoc());
1647         SDValue Arg = TheCall->getArg(i);
1648         ISD::ArgFlagsTy Flags = TheCall->getArgFlags(i);
1649         // Create frame index.
1650         int32_t Offset = VA.getLocMemOffset()+FPDiff;
1651         uint32_t OpSize = (VA.getLocVT().getSizeInBits()+7)/8;
1652         FI = MF.getFrameInfo()->CreateFixedObject(OpSize, Offset);
1653         FIN = DAG.getFrameIndex(FI, getPointerTy());
1654
1655         if (Flags.isByVal()) {
1656           // Copy relative to framepointer.
1657           SDValue Source = DAG.getIntPtrConstant(VA.getLocMemOffset());
1658           if (StackPtr.getNode() == 0)
1659             StackPtr = DAG.getCopyFromReg(Chain, X86StackPtr, getPointerTy());
1660           Source = DAG.getNode(ISD::ADD, getPointerTy(), StackPtr, Source);
1661
1662           MemOpChains2.push_back(CreateCopyOfByValArgument(Source, FIN, Chain,
1663                                                            Flags, DAG));
1664         } else {
1665           // Store relative to framepointer.
1666           MemOpChains2.push_back(
1667             DAG.getStore(Chain, Arg, FIN,
1668                          PseudoSourceValue::getFixedStack(FI), 0));
1669         }
1670       }
1671     }
1672
1673     if (!MemOpChains2.empty())
1674       Chain = DAG.getNode(ISD::TokenFactor, MVT::Other,
1675                           &MemOpChains2[0], MemOpChains2.size());
1676
1677     // Copy arguments to their registers.
1678     for (unsigned i = 0, e = RegsToPass.size(); i != e; ++i) {
1679       Chain = DAG.getCopyToReg(Chain, RegsToPass[i].first, RegsToPass[i].second,
1680                                InFlag);
1681       InFlag = Chain.getValue(1);
1682     }
1683     InFlag =SDValue();
1684
1685     // Store the return address to the appropriate stack slot.
1686     Chain = EmitTailCallStoreRetAddr(DAG, MF, Chain, RetAddrFrIdx, Is64Bit,
1687                                      FPDiff);
1688   }
1689
1690   // If the callee is a GlobalAddress node (quite common, every direct call is)
1691   // turn it into a TargetGlobalAddress node so that legalize doesn't hack it.
1692   if (GlobalAddressSDNode *G = dyn_cast<GlobalAddressSDNode>(Callee)) {
1693     // We should use extra load for direct calls to dllimported functions in
1694     // non-JIT mode.
1695     if (!Subtarget->GVRequiresExtraLoad(G->getGlobal(),
1696                                         getTargetMachine(), true))
1697       Callee = DAG.getTargetGlobalAddress(G->getGlobal(), getPointerTy());
1698   } else if (ExternalSymbolSDNode *S = dyn_cast<ExternalSymbolSDNode>(Callee)) {
1699     Callee = DAG.getTargetExternalSymbol(S->getSymbol(), getPointerTy());
1700   } else if (IsTailCall) {
1701     unsigned Opc = Is64Bit ? X86::R9 : X86::EAX;
1702
1703     Chain = DAG.getCopyToReg(Chain,
1704                              DAG.getRegister(Opc, getPointerTy()),
1705                              Callee,InFlag);
1706     Callee = DAG.getRegister(Opc, getPointerTy());
1707     // Add register as live out.
1708     DAG.getMachineFunction().getRegInfo().addLiveOut(Opc);
1709   }
1710
1711   // Returns a chain & a flag for retval copy to use.
1712   SDVTList NodeTys = DAG.getVTList(MVT::Other, MVT::Flag);
1713   SmallVector<SDValue, 8> Ops;
1714
1715   if (IsTailCall) {
1716     Ops.push_back(Chain);
1717     Ops.push_back(DAG.getIntPtrConstant(NumBytes));
1718     Ops.push_back(DAG.getIntPtrConstant(0));
1719     if (InFlag.getNode())
1720       Ops.push_back(InFlag);
1721     Chain = DAG.getNode(ISD::CALLSEQ_END, NodeTys, &Ops[0], Ops.size());
1722     InFlag = Chain.getValue(1);
1723
1724     // Returns a chain & a flag for retval copy to use.
1725     NodeTys = DAG.getVTList(MVT::Other, MVT::Flag);
1726     Ops.clear();
1727   }
1728
1729   Ops.push_back(Chain);
1730   Ops.push_back(Callee);
1731
1732   if (IsTailCall)
1733     Ops.push_back(DAG.getConstant(FPDiff, MVT::i32));
1734
1735   // Add argument registers to the end of the list so that they are known live
1736   // into the call.
1737   for (unsigned i = 0, e = RegsToPass.size(); i != e; ++i)
1738     Ops.push_back(DAG.getRegister(RegsToPass[i].first,
1739                                   RegsToPass[i].second.getValueType()));
1740
1741   // Add an implicit use GOT pointer in EBX.
1742   if (!IsTailCall && !Is64Bit &&
1743       getTargetMachine().getRelocationModel() == Reloc::PIC_ &&
1744       Subtarget->isPICStyleGOT())
1745     Ops.push_back(DAG.getRegister(X86::EBX, getPointerTy()));
1746
1747   // Add an implicit use of AL for x86 vararg functions.
1748   if (Is64Bit && isVarArg)
1749     Ops.push_back(DAG.getRegister(X86::AL, MVT::i8));
1750
1751   if (InFlag.getNode())
1752     Ops.push_back(InFlag);
1753
1754   if (IsTailCall) {
1755     assert(InFlag.getNode() &&
1756            "Flag must be set. Depend on flag being set in LowerRET");
1757     Chain = DAG.getNode(X86ISD::TAILCALL,
1758                         TheCall->getVTList(), &Ops[0], Ops.size());
1759
1760     return SDValue(Chain.getNode(), Op.getResNo());
1761   }
1762
1763   Chain = DAG.getNode(X86ISD::CALL, NodeTys, &Ops[0], Ops.size());
1764   InFlag = Chain.getValue(1);
1765
1766   // Create the CALLSEQ_END node.
1767   unsigned NumBytesForCalleeToPush;
1768   if (IsCalleePop(isVarArg, CC))
1769     NumBytesForCalleeToPush = NumBytes;    // Callee pops everything
1770   else if (!Is64Bit && CC != CallingConv::Fast && IsStructRet)
1771     // If this is is a call to a struct-return function, the callee
1772     // pops the hidden struct pointer, so we have to push it back.
1773     // This is common for Darwin/X86, Linux & Mingw32 targets.
1774     NumBytesForCalleeToPush = 4;
1775   else
1776     NumBytesForCalleeToPush = 0;  // Callee pops nothing.
1777
1778   // Returns a flag for retval copy to use.
1779   Chain = DAG.getCALLSEQ_END(Chain,
1780                              DAG.getIntPtrConstant(NumBytes),
1781                              DAG.getIntPtrConstant(NumBytesForCalleeToPush),
1782                              InFlag);
1783   InFlag = Chain.getValue(1);
1784
1785   // Handle result values, copying them out of physregs into vregs that we
1786   // return.
1787   return SDValue(LowerCallResult(Chain, InFlag, TheCall, CC, DAG),
1788                  Op.getResNo());
1789 }
1790
1791
1792 //===----------------------------------------------------------------------===//
1793 //                Fast Calling Convention (tail call) implementation
1794 //===----------------------------------------------------------------------===//
1795
1796 //  Like std call, callee cleans arguments, convention except that ECX is
1797 //  reserved for storing the tail called function address. Only 2 registers are
1798 //  free for argument passing (inreg). Tail call optimization is performed
1799 //  provided:
1800 //                * tailcallopt is enabled
1801 //                * caller/callee are fastcc
1802 //  On X86_64 architecture with GOT-style position independent code only local
1803 //  (within module) calls are supported at the moment.
1804 //  To keep the stack aligned according to platform abi the function
1805 //  GetAlignedArgumentStackSize ensures that argument delta is always multiples
1806 //  of stack alignment. (Dynamic linkers need this - darwin's dyld for example)
1807 //  If a tail called function callee has more arguments than the caller the
1808 //  caller needs to make sure that there is room to move the RETADDR to. This is
1809 //  achieved by reserving an area the size of the argument delta right after the
1810 //  original REtADDR, but before the saved framepointer or the spilled registers
1811 //  e.g. caller(arg1, arg2) calls callee(arg1, arg2,arg3,arg4)
1812 //  stack layout:
1813 //    arg1
1814 //    arg2
1815 //    RETADDR
1816 //    [ new RETADDR
1817 //      move area ]
1818 //    (possible EBP)
1819 //    ESI
1820 //    EDI
1821 //    local1 ..
1822
1823 /// GetAlignedArgumentStackSize - Make the stack size align e.g 16n + 12 aligned
1824 /// for a 16 byte align requirement.
1825 unsigned X86TargetLowering::GetAlignedArgumentStackSize(unsigned StackSize,
1826                                                         SelectionDAG& DAG) {
1827   MachineFunction &MF = DAG.getMachineFunction();
1828   const TargetMachine &TM = MF.getTarget();
1829   const TargetFrameInfo &TFI = *TM.getFrameInfo();
1830   unsigned StackAlignment = TFI.getStackAlignment();
1831   uint64_t AlignMask = StackAlignment - 1;
1832   int64_t Offset = StackSize;
1833   uint64_t SlotSize = TD->getPointerSize();
1834   if ( (Offset & AlignMask) <= (StackAlignment - SlotSize) ) {
1835     // Number smaller than 12 so just add the difference.
1836     Offset += ((StackAlignment - SlotSize) - (Offset & AlignMask));
1837   } else {
1838     // Mask out lower bits, add stackalignment once plus the 12 bytes.
1839     Offset = ((~AlignMask) & Offset) + StackAlignment +
1840       (StackAlignment-SlotSize);
1841   }
1842   return Offset;
1843 }
1844
1845 /// IsEligibleForTailCallElimination - Check to see whether the next instruction
1846 /// following the call is a return. A function is eligible if caller/callee
1847 /// calling conventions match, currently only fastcc supports tail calls, and
1848 /// the function CALL is immediatly followed by a RET.
1849 bool X86TargetLowering::IsEligibleForTailCallOptimization(CallSDNode *TheCall,
1850                                                       SDValue Ret,
1851                                                       SelectionDAG& DAG) const {
1852   if (!PerformTailCallOpt)
1853     return false;
1854
1855   if (CheckTailCallReturnConstraints(TheCall, Ret)) {
1856     MachineFunction &MF = DAG.getMachineFunction();
1857     unsigned CallerCC = MF.getFunction()->getCallingConv();
1858     unsigned CalleeCC= TheCall->getCallingConv();
1859     if (CalleeCC == CallingConv::Fast && CallerCC == CalleeCC) {
1860       SDValue Callee = TheCall->getCallee();
1861       // On x86/32Bit PIC/GOT  tail calls are supported.
1862       if (getTargetMachine().getRelocationModel() != Reloc::PIC_ ||
1863           !Subtarget->isPICStyleGOT()|| !Subtarget->is64Bit())
1864         return true;
1865
1866       // Can only do local tail calls (in same module, hidden or protected) on
1867       // x86_64 PIC/GOT at the moment.
1868       if (GlobalAddressSDNode *G = dyn_cast<GlobalAddressSDNode>(Callee))
1869         return G->getGlobal()->hasHiddenVisibility()
1870             || G->getGlobal()->hasProtectedVisibility();
1871     }
1872   }
1873
1874   return false;
1875 }
1876
1877 FastISel *
1878 X86TargetLowering::createFastISel(MachineFunction &mf,
1879                                   MachineModuleInfo *mmo,
1880                                   DenseMap<const Value *, unsigned> &vm,
1881                                   DenseMap<const BasicBlock *,
1882                                            MachineBasicBlock *> &bm,
1883                                   DenseMap<const AllocaInst *, int> &am) {
1884
1885   return X86::createFastISel(mf, mmo, vm, bm, am);
1886 }
1887
1888
1889 //===----------------------------------------------------------------------===//
1890 //                           Other Lowering Hooks
1891 //===----------------------------------------------------------------------===//
1892
1893
1894 SDValue X86TargetLowering::getReturnAddressFrameIndex(SelectionDAG &DAG) {
1895   MachineFunction &MF = DAG.getMachineFunction();
1896   X86MachineFunctionInfo *FuncInfo = MF.getInfo<X86MachineFunctionInfo>();
1897   int ReturnAddrIndex = FuncInfo->getRAIndex();
1898   uint64_t SlotSize = TD->getPointerSize();
1899
1900   if (ReturnAddrIndex == 0) {
1901     // Set up a frame object for the return address.
1902     ReturnAddrIndex = MF.getFrameInfo()->CreateFixedObject(SlotSize, -SlotSize);
1903     FuncInfo->setRAIndex(ReturnAddrIndex);
1904   }
1905
1906   return DAG.getFrameIndex(ReturnAddrIndex, getPointerTy());
1907 }
1908
1909
1910 /// translateX86CC - do a one to one translation of a ISD::CondCode to the X86
1911 /// specific condition code. It returns a false if it cannot do a direct
1912 /// translation. X86CC is the translated CondCode.  LHS/RHS are modified as
1913 /// needed.
1914 static bool translateX86CC(ISD::CondCode SetCCOpcode, bool isFP,
1915                            unsigned &X86CC, SDValue &LHS, SDValue &RHS,
1916                            SelectionDAG &DAG) {
1917   X86CC = X86::COND_INVALID;
1918   if (!isFP) {
1919     if (ConstantSDNode *RHSC = dyn_cast<ConstantSDNode>(RHS)) {
1920       if (SetCCOpcode == ISD::SETGT && RHSC->isAllOnesValue()) {
1921         // X > -1   -> X == 0, jump !sign.
1922         RHS = DAG.getConstant(0, RHS.getValueType());
1923         X86CC = X86::COND_NS;
1924         return true;
1925       } else if (SetCCOpcode == ISD::SETLT && RHSC->isNullValue()) {
1926         // X < 0   -> X == 0, jump on sign.
1927         X86CC = X86::COND_S;
1928         return true;
1929       } else if (SetCCOpcode == ISD::SETLT && RHSC->getZExtValue() == 1) {
1930         // X < 1   -> X <= 0
1931         RHS = DAG.getConstant(0, RHS.getValueType());
1932         X86CC = X86::COND_LE;
1933         return true;
1934       }
1935     }
1936
1937     switch (SetCCOpcode) {
1938     default: break;
1939     case ISD::SETEQ:  X86CC = X86::COND_E;  break;
1940     case ISD::SETGT:  X86CC = X86::COND_G;  break;
1941     case ISD::SETGE:  X86CC = X86::COND_GE; break;
1942     case ISD::SETLT:  X86CC = X86::COND_L;  break;
1943     case ISD::SETLE:  X86CC = X86::COND_LE; break;
1944     case ISD::SETNE:  X86CC = X86::COND_NE; break;
1945     case ISD::SETULT: X86CC = X86::COND_B;  break;
1946     case ISD::SETUGT: X86CC = X86::COND_A;  break;
1947     case ISD::SETULE: X86CC = X86::COND_BE; break;
1948     case ISD::SETUGE: X86CC = X86::COND_AE; break;
1949     }
1950   } else {
1951     // First determine if it requires or is profitable to flip the operands.
1952     bool Flip = false;
1953     switch (SetCCOpcode) {
1954     default: break;
1955     case ISD::SETOLT:
1956     case ISD::SETOLE:
1957     case ISD::SETUGT:
1958     case ISD::SETUGE:
1959       Flip = true;
1960       break;
1961     }
1962
1963     // If LHS is a foldable load, but RHS is not, flip the condition.
1964     if (!Flip &&
1965         (ISD::isNON_EXTLoad(LHS.getNode()) && LHS.hasOneUse()) &&
1966         !(ISD::isNON_EXTLoad(RHS.getNode()) && RHS.hasOneUse())) {
1967       SetCCOpcode = getSetCCSwappedOperands(SetCCOpcode);
1968       Flip = true;
1969     }
1970     if (Flip)
1971       std::swap(LHS, RHS);
1972
1973     // On a floating point condition, the flags are set as follows:
1974     // ZF  PF  CF   op
1975     //  0 | 0 | 0 | X > Y
1976     //  0 | 0 | 1 | X < Y
1977     //  1 | 0 | 0 | X == Y
1978     //  1 | 1 | 1 | unordered
1979     switch (SetCCOpcode) {
1980     default: break;
1981     case ISD::SETUEQ:
1982     case ISD::SETEQ:
1983       X86CC = X86::COND_E;
1984       break;
1985     case ISD::SETOLT:              // flipped
1986     case ISD::SETOGT:
1987     case ISD::SETGT:
1988       X86CC = X86::COND_A;
1989       break;
1990     case ISD::SETOLE:              // flipped
1991     case ISD::SETOGE:
1992     case ISD::SETGE:
1993       X86CC = X86::COND_AE;
1994       break;
1995     case ISD::SETUGT:              // flipped
1996     case ISD::SETULT:
1997     case ISD::SETLT:
1998       X86CC = X86::COND_B;
1999       break;
2000     case ISD::SETUGE:              // flipped
2001     case ISD::SETULE:
2002     case ISD::SETLE:
2003       X86CC = X86::COND_BE;
2004       break;
2005     case ISD::SETONE:
2006     case ISD::SETNE:
2007       X86CC = X86::COND_NE;
2008       break;
2009     case ISD::SETUO:
2010       X86CC = X86::COND_P;
2011       break;
2012     case ISD::SETO:
2013       X86CC = X86::COND_NP;
2014       break;
2015     }
2016   }
2017
2018   return X86CC != X86::COND_INVALID;
2019 }
2020
2021 /// hasFPCMov - is there a floating point cmov for the specific X86 condition
2022 /// code. Current x86 isa includes the following FP cmov instructions:
2023 /// fcmovb, fcomvbe, fcomve, fcmovu, fcmovae, fcmova, fcmovne, fcmovnu.
2024 static bool hasFPCMov(unsigned X86CC) {
2025   switch (X86CC) {
2026   default:
2027     return false;
2028   case X86::COND_B:
2029   case X86::COND_BE:
2030   case X86::COND_E:
2031   case X86::COND_P:
2032   case X86::COND_A:
2033   case X86::COND_AE:
2034   case X86::COND_NE:
2035   case X86::COND_NP:
2036     return true;
2037   }
2038 }
2039
2040 /// isUndefOrInRange - Op is either an undef node or a ConstantSDNode.  Return
2041 /// true if Op is undef or if its value falls within the specified range (L, H].
2042 static bool isUndefOrInRange(SDValue Op, unsigned Low, unsigned Hi) {
2043   if (Op.getOpcode() == ISD::UNDEF)
2044     return true;
2045
2046   unsigned Val = cast<ConstantSDNode>(Op)->getZExtValue();
2047   return (Val >= Low && Val < Hi);
2048 }
2049
2050 /// isUndefOrEqual - Op is either an undef node or a ConstantSDNode.  Return
2051 /// true if Op is undef or if its value equal to the specified value.
2052 static bool isUndefOrEqual(SDValue Op, unsigned Val) {
2053   if (Op.getOpcode() == ISD::UNDEF)
2054     return true;
2055   return cast<ConstantSDNode>(Op)->getZExtValue() == Val;
2056 }
2057
2058 /// isPSHUFDMask - Return true if the specified VECTOR_SHUFFLE operand
2059 /// specifies a shuffle of elements that is suitable for input to PSHUFD.
2060 bool X86::isPSHUFDMask(SDNode *N) {
2061   assert(N->getOpcode() == ISD::BUILD_VECTOR);
2062
2063   if (N->getNumOperands() != 2 && N->getNumOperands() != 4)
2064     return false;
2065
2066   // Check if the value doesn't reference the second vector.
2067   for (unsigned i = 0, e = N->getNumOperands(); i != e; ++i) {
2068     SDValue Arg = N->getOperand(i);
2069     if (Arg.getOpcode() == ISD::UNDEF) continue;
2070     assert(isa<ConstantSDNode>(Arg) && "Invalid VECTOR_SHUFFLE mask!");
2071     if (cast<ConstantSDNode>(Arg)->getZExtValue() >= e)
2072       return false;
2073   }
2074
2075   return true;
2076 }
2077
2078 /// isPSHUFHWMask - Return true if the specified VECTOR_SHUFFLE operand
2079 /// specifies a shuffle of elements that is suitable for input to PSHUFHW.
2080 bool X86::isPSHUFHWMask(SDNode *N) {
2081   assert(N->getOpcode() == ISD::BUILD_VECTOR);
2082
2083   if (N->getNumOperands() != 8)
2084     return false;
2085
2086   // Lower quadword copied in order.
2087   for (unsigned i = 0; i != 4; ++i) {
2088     SDValue Arg = N->getOperand(i);
2089     if (Arg.getOpcode() == ISD::UNDEF) continue;
2090     assert(isa<ConstantSDNode>(Arg) && "Invalid VECTOR_SHUFFLE mask!");
2091     if (cast<ConstantSDNode>(Arg)->getZExtValue() != i)
2092       return false;
2093   }
2094
2095   // Upper quadword shuffled.
2096   for (unsigned i = 4; i != 8; ++i) {
2097     SDValue Arg = N->getOperand(i);
2098     if (Arg.getOpcode() == ISD::UNDEF) continue;
2099     assert(isa<ConstantSDNode>(Arg) && "Invalid VECTOR_SHUFFLE mask!");
2100     unsigned Val = cast<ConstantSDNode>(Arg)->getZExtValue();
2101     if (Val < 4 || Val > 7)
2102       return false;
2103   }
2104
2105   return true;
2106 }
2107
2108 /// isPSHUFLWMask - Return true if the specified VECTOR_SHUFFLE operand
2109 /// specifies a shuffle of elements that is suitable for input to PSHUFLW.
2110 bool X86::isPSHUFLWMask(SDNode *N) {
2111   assert(N->getOpcode() == ISD::BUILD_VECTOR);
2112
2113   if (N->getNumOperands() != 8)
2114     return false;
2115
2116   // Upper quadword copied in order.
2117   for (unsigned i = 4; i != 8; ++i)
2118     if (!isUndefOrEqual(N->getOperand(i), i))
2119       return false;
2120
2121   // Lower quadword shuffled.
2122   for (unsigned i = 0; i != 4; ++i)
2123     if (!isUndefOrInRange(N->getOperand(i), 0, 4))
2124       return false;
2125
2126   return true;
2127 }
2128
2129 /// isSHUFPMask - Return true if the specified VECTOR_SHUFFLE operand
2130 /// specifies a shuffle of elements that is suitable for input to SHUFP*.
2131 static bool isSHUFPMask(SDOperandPtr Elems, unsigned NumElems) {
2132   if (NumElems != 2 && NumElems != 4) return false;
2133
2134   unsigned Half = NumElems / 2;
2135   for (unsigned i = 0; i < Half; ++i)
2136     if (!isUndefOrInRange(Elems[i], 0, NumElems))
2137       return false;
2138   for (unsigned i = Half; i < NumElems; ++i)
2139     if (!isUndefOrInRange(Elems[i], NumElems, NumElems*2))
2140       return false;
2141
2142   return true;
2143 }
2144
2145 bool X86::isSHUFPMask(SDNode *N) {
2146   assert(N->getOpcode() == ISD::BUILD_VECTOR);
2147   return ::isSHUFPMask(N->op_begin(), N->getNumOperands());
2148 }
2149
2150 /// isCommutedSHUFP - Returns true if the shuffle mask is exactly
2151 /// the reverse of what x86 shuffles want. x86 shuffles requires the lower
2152 /// half elements to come from vector 1 (which would equal the dest.) and
2153 /// the upper half to come from vector 2.
2154 static bool isCommutedSHUFP(SDOperandPtr Ops, unsigned NumOps) {
2155   if (NumOps != 2 && NumOps != 4) return false;
2156
2157   unsigned Half = NumOps / 2;
2158   for (unsigned i = 0; i < Half; ++i)
2159     if (!isUndefOrInRange(Ops[i], NumOps, NumOps*2))
2160       return false;
2161   for (unsigned i = Half; i < NumOps; ++i)
2162     if (!isUndefOrInRange(Ops[i], 0, NumOps))
2163       return false;
2164   return true;
2165 }
2166
2167 static bool isCommutedSHUFP(SDNode *N) {
2168   assert(N->getOpcode() == ISD::BUILD_VECTOR);
2169   return isCommutedSHUFP(N->op_begin(), N->getNumOperands());
2170 }
2171
2172 /// isMOVHLPSMask - Return true if the specified VECTOR_SHUFFLE operand
2173 /// specifies a shuffle of elements that is suitable for input to MOVHLPS.
2174 bool X86::isMOVHLPSMask(SDNode *N) {
2175   assert(N->getOpcode() == ISD::BUILD_VECTOR);
2176
2177   if (N->getNumOperands() != 4)
2178     return false;
2179
2180   // Expect bit0 == 6, bit1 == 7, bit2 == 2, bit3 == 3
2181   return isUndefOrEqual(N->getOperand(0), 6) &&
2182          isUndefOrEqual(N->getOperand(1), 7) &&
2183          isUndefOrEqual(N->getOperand(2), 2) &&
2184          isUndefOrEqual(N->getOperand(3), 3);
2185 }
2186
2187 /// isMOVHLPS_v_undef_Mask - Special case of isMOVHLPSMask for canonical form
2188 /// of vector_shuffle v, v, <2, 3, 2, 3>, i.e. vector_shuffle v, undef,
2189 /// <2, 3, 2, 3>
2190 bool X86::isMOVHLPS_v_undef_Mask(SDNode *N) {
2191   assert(N->getOpcode() == ISD::BUILD_VECTOR);
2192
2193   if (N->getNumOperands() != 4)
2194     return false;
2195
2196   // Expect bit0 == 2, bit1 == 3, bit2 == 2, bit3 == 3
2197   return isUndefOrEqual(N->getOperand(0), 2) &&
2198          isUndefOrEqual(N->getOperand(1), 3) &&
2199          isUndefOrEqual(N->getOperand(2), 2) &&
2200          isUndefOrEqual(N->getOperand(3), 3);
2201 }
2202
2203 /// isMOVLPMask - Return true if the specified VECTOR_SHUFFLE operand
2204 /// specifies a shuffle of elements that is suitable for input to MOVLP{S|D}.
2205 bool X86::isMOVLPMask(SDNode *N) {
2206   assert(N->getOpcode() == ISD::BUILD_VECTOR);
2207
2208   unsigned NumElems = N->getNumOperands();
2209   if (NumElems != 2 && NumElems != 4)
2210     return false;
2211
2212   for (unsigned i = 0; i < NumElems/2; ++i)
2213     if (!isUndefOrEqual(N->getOperand(i), i + NumElems))
2214       return false;
2215
2216   for (unsigned i = NumElems/2; i < NumElems; ++i)
2217     if (!isUndefOrEqual(N->getOperand(i), i))
2218       return false;
2219
2220   return true;
2221 }
2222
2223 /// isMOVHPMask - Return true if the specified VECTOR_SHUFFLE operand
2224 /// specifies a shuffle of elements that is suitable for input to MOVHP{S|D}
2225 /// and MOVLHPS.
2226 bool X86::isMOVHPMask(SDNode *N) {
2227   assert(N->getOpcode() == ISD::BUILD_VECTOR);
2228
2229   unsigned NumElems = N->getNumOperands();
2230   if (NumElems != 2 && NumElems != 4)
2231     return false;
2232
2233   for (unsigned i = 0; i < NumElems/2; ++i)
2234     if (!isUndefOrEqual(N->getOperand(i), i))
2235       return false;
2236
2237   for (unsigned i = 0; i < NumElems/2; ++i) {
2238     SDValue Arg = N->getOperand(i + NumElems/2);
2239     if (!isUndefOrEqual(Arg, i + NumElems))
2240       return false;
2241   }
2242
2243   return true;
2244 }
2245
2246 /// isUNPCKLMask - Return true if the specified VECTOR_SHUFFLE operand
2247 /// specifies a shuffle of elements that is suitable for input to UNPCKL.
2248 bool static isUNPCKLMask(SDOperandPtr Elts, unsigned NumElts,
2249                          bool V2IsSplat = false) {
2250   if (NumElts != 2 && NumElts != 4 && NumElts != 8 && NumElts != 16)
2251     return false;
2252
2253   for (unsigned i = 0, j = 0; i != NumElts; i += 2, ++j) {
2254     SDValue BitI  = Elts[i];
2255     SDValue BitI1 = Elts[i+1];
2256     if (!isUndefOrEqual(BitI, j))
2257       return false;
2258     if (V2IsSplat) {
2259       if (isUndefOrEqual(BitI1, NumElts))
2260         return false;
2261     } else {
2262       if (!isUndefOrEqual(BitI1, j + NumElts))
2263         return false;
2264     }
2265   }
2266
2267   return true;
2268 }
2269
2270 bool X86::isUNPCKLMask(SDNode *N, bool V2IsSplat) {
2271   assert(N->getOpcode() == ISD::BUILD_VECTOR);
2272   return ::isUNPCKLMask(N->op_begin(), N->getNumOperands(), V2IsSplat);
2273 }
2274
2275 /// isUNPCKHMask - Return true if the specified VECTOR_SHUFFLE operand
2276 /// specifies a shuffle of elements that is suitable for input to UNPCKH.
2277 bool static isUNPCKHMask(SDOperandPtr Elts, unsigned NumElts,
2278                          bool V2IsSplat = false) {
2279   if (NumElts != 2 && NumElts != 4 && NumElts != 8 && NumElts != 16)
2280     return false;
2281
2282   for (unsigned i = 0, j = 0; i != NumElts; i += 2, ++j) {
2283     SDValue BitI  = Elts[i];
2284     SDValue BitI1 = Elts[i+1];
2285     if (!isUndefOrEqual(BitI, j + NumElts/2))
2286       return false;
2287     if (V2IsSplat) {
2288       if (isUndefOrEqual(BitI1, NumElts))
2289         return false;
2290     } else {
2291       if (!isUndefOrEqual(BitI1, j + NumElts/2 + NumElts))
2292         return false;
2293     }
2294   }
2295
2296   return true;
2297 }
2298
2299 bool X86::isUNPCKHMask(SDNode *N, bool V2IsSplat) {
2300   assert(N->getOpcode() == ISD::BUILD_VECTOR);
2301   return ::isUNPCKHMask(N->op_begin(), N->getNumOperands(), V2IsSplat);
2302 }
2303
2304 /// isUNPCKL_v_undef_Mask - Special case of isUNPCKLMask for canonical form
2305 /// of vector_shuffle v, v, <0, 4, 1, 5>, i.e. vector_shuffle v, undef,
2306 /// <0, 0, 1, 1>
2307 bool X86::isUNPCKL_v_undef_Mask(SDNode *N) {
2308   assert(N->getOpcode() == ISD::BUILD_VECTOR);
2309
2310   unsigned NumElems = N->getNumOperands();
2311   if (NumElems != 2 && NumElems != 4 && NumElems != 8 && NumElems != 16)
2312     return false;
2313
2314   for (unsigned i = 0, j = 0; i != NumElems; i += 2, ++j) {
2315     SDValue BitI  = N->getOperand(i);
2316     SDValue BitI1 = N->getOperand(i+1);
2317
2318     if (!isUndefOrEqual(BitI, j))
2319       return false;
2320     if (!isUndefOrEqual(BitI1, j))
2321       return false;
2322   }
2323
2324   return true;
2325 }
2326
2327 /// isUNPCKH_v_undef_Mask - Special case of isUNPCKHMask for canonical form
2328 /// of vector_shuffle v, v, <2, 6, 3, 7>, i.e. vector_shuffle v, undef,
2329 /// <2, 2, 3, 3>
2330 bool X86::isUNPCKH_v_undef_Mask(SDNode *N) {
2331   assert(N->getOpcode() == ISD::BUILD_VECTOR);
2332
2333   unsigned NumElems = N->getNumOperands();
2334   if (NumElems != 2 && NumElems != 4 && NumElems != 8 && NumElems != 16)
2335     return false;
2336
2337   for (unsigned i = 0, j = NumElems / 2; i != NumElems; i += 2, ++j) {
2338     SDValue BitI  = N->getOperand(i);
2339     SDValue BitI1 = N->getOperand(i + 1);
2340
2341     if (!isUndefOrEqual(BitI, j))
2342       return false;
2343     if (!isUndefOrEqual(BitI1, j))
2344       return false;
2345   }
2346
2347   return true;
2348 }
2349
2350 /// isMOVLMask - Return true if the specified VECTOR_SHUFFLE operand
2351 /// specifies a shuffle of elements that is suitable for input to MOVSS,
2352 /// MOVSD, and MOVD, i.e. setting the lowest element.
2353 static bool isMOVLMask(SDOperandPtr Elts, unsigned NumElts) {
2354   if (NumElts != 2 && NumElts != 4)
2355     return false;
2356
2357   if (!isUndefOrEqual(Elts[0], NumElts))
2358     return false;
2359
2360   for (unsigned i = 1; i < NumElts; ++i) {
2361     if (!isUndefOrEqual(Elts[i], i))
2362       return false;
2363   }
2364
2365   return true;
2366 }
2367
2368 bool X86::isMOVLMask(SDNode *N) {
2369   assert(N->getOpcode() == ISD::BUILD_VECTOR);
2370   return ::isMOVLMask(N->op_begin(), N->getNumOperands());
2371 }
2372
2373 /// isCommutedMOVL - Returns true if the shuffle mask is except the reverse
2374 /// of what x86 movss want. X86 movs requires the lowest  element to be lowest
2375 /// element of vector 2 and the other elements to come from vector 1 in order.
2376 static bool isCommutedMOVL(SDOperandPtr Ops, unsigned NumOps,
2377                            bool V2IsSplat = false,
2378                            bool V2IsUndef = false) {
2379   if (NumOps != 2 && NumOps != 4 && NumOps != 8 && NumOps != 16)
2380     return false;
2381
2382   if (!isUndefOrEqual(Ops[0], 0))
2383     return false;
2384
2385   for (unsigned i = 1; i < NumOps; ++i) {
2386     SDValue Arg = Ops[i];
2387     if (!(isUndefOrEqual(Arg, i+NumOps) ||
2388           (V2IsUndef && isUndefOrInRange(Arg, NumOps, NumOps*2)) ||
2389           (V2IsSplat && isUndefOrEqual(Arg, NumOps))))
2390       return false;
2391   }
2392
2393   return true;
2394 }
2395
2396 static bool isCommutedMOVL(SDNode *N, bool V2IsSplat = false,
2397                            bool V2IsUndef = false) {
2398   assert(N->getOpcode() == ISD::BUILD_VECTOR);
2399   return isCommutedMOVL(N->op_begin(), N->getNumOperands(),
2400                         V2IsSplat, V2IsUndef);
2401 }
2402
2403 /// isMOVSHDUPMask - Return true if the specified VECTOR_SHUFFLE operand
2404 /// specifies a shuffle of elements that is suitable for input to MOVSHDUP.
2405 bool X86::isMOVSHDUPMask(SDNode *N) {
2406   assert(N->getOpcode() == ISD::BUILD_VECTOR);
2407
2408   if (N->getNumOperands() != 4)
2409     return false;
2410
2411   // Expect 1, 1, 3, 3
2412   for (unsigned i = 0; i < 2; ++i) {
2413     SDValue Arg = N->getOperand(i);
2414     if (Arg.getOpcode() == ISD::UNDEF) continue;
2415     assert(isa<ConstantSDNode>(Arg) && "Invalid VECTOR_SHUFFLE mask!");
2416     unsigned Val = cast<ConstantSDNode>(Arg)->getZExtValue();
2417     if (Val != 1) return false;
2418   }
2419
2420   bool HasHi = false;
2421   for (unsigned i = 2; i < 4; ++i) {
2422     SDValue Arg = N->getOperand(i);
2423     if (Arg.getOpcode() == ISD::UNDEF) continue;
2424     assert(isa<ConstantSDNode>(Arg) && "Invalid VECTOR_SHUFFLE mask!");
2425     unsigned Val = cast<ConstantSDNode>(Arg)->getZExtValue();
2426     if (Val != 3) return false;
2427     HasHi = true;
2428   }
2429
2430   // Don't use movshdup if it can be done with a shufps.
2431   return HasHi;
2432 }
2433
2434 /// isMOVSLDUPMask - Return true if the specified VECTOR_SHUFFLE operand
2435 /// specifies a shuffle of elements that is suitable for input to MOVSLDUP.
2436 bool X86::isMOVSLDUPMask(SDNode *N) {
2437   assert(N->getOpcode() == ISD::BUILD_VECTOR);
2438
2439   if (N->getNumOperands() != 4)
2440     return false;
2441
2442   // Expect 0, 0, 2, 2
2443   for (unsigned i = 0; i < 2; ++i) {
2444     SDValue Arg = N->getOperand(i);
2445     if (Arg.getOpcode() == ISD::UNDEF) continue;
2446     assert(isa<ConstantSDNode>(Arg) && "Invalid VECTOR_SHUFFLE mask!");
2447     unsigned Val = cast<ConstantSDNode>(Arg)->getZExtValue();
2448     if (Val != 0) return false;
2449   }
2450
2451   bool HasHi = false;
2452   for (unsigned i = 2; i < 4; ++i) {
2453     SDValue Arg = N->getOperand(i);
2454     if (Arg.getOpcode() == ISD::UNDEF) continue;
2455     assert(isa<ConstantSDNode>(Arg) && "Invalid VECTOR_SHUFFLE mask!");
2456     unsigned Val = cast<ConstantSDNode>(Arg)->getZExtValue();
2457     if (Val != 2) return false;
2458     HasHi = true;
2459   }
2460
2461   // Don't use movshdup if it can be done with a shufps.
2462   return HasHi;
2463 }
2464
2465 /// isIdentityMask - Return true if the specified VECTOR_SHUFFLE operand
2466 /// specifies a identity operation on the LHS or RHS.
2467 static bool isIdentityMask(SDNode *N, bool RHS = false) {
2468   unsigned NumElems = N->getNumOperands();
2469   for (unsigned i = 0; i < NumElems; ++i)
2470     if (!isUndefOrEqual(N->getOperand(i), i + (RHS ? NumElems : 0)))
2471       return false;
2472   return true;
2473 }
2474
2475 /// isSplatMask - Return true if the specified VECTOR_SHUFFLE operand specifies
2476 /// a splat of a single element.
2477 static bool isSplatMask(SDNode *N) {
2478   assert(N->getOpcode() == ISD::BUILD_VECTOR);
2479
2480   // This is a splat operation if each element of the permute is the same, and
2481   // if the value doesn't reference the second vector.
2482   unsigned NumElems = N->getNumOperands();
2483   SDValue ElementBase;
2484   unsigned i = 0;
2485   for (; i != NumElems; ++i) {
2486     SDValue Elt = N->getOperand(i);
2487     if (isa<ConstantSDNode>(Elt)) {
2488       ElementBase = Elt;
2489       break;
2490     }
2491   }
2492
2493   if (!ElementBase.getNode())
2494     return false;
2495
2496   for (; i != NumElems; ++i) {
2497     SDValue Arg = N->getOperand(i);
2498     if (Arg.getOpcode() == ISD::UNDEF) continue;
2499     assert(isa<ConstantSDNode>(Arg) && "Invalid VECTOR_SHUFFLE mask!");
2500     if (Arg != ElementBase) return false;
2501   }
2502
2503   // Make sure it is a splat of the first vector operand.
2504   return cast<ConstantSDNode>(ElementBase)->getZExtValue() < NumElems;
2505 }
2506
2507 /// isSplatMask - Return true if the specified VECTOR_SHUFFLE operand specifies
2508 /// a splat of a single element and it's a 2 or 4 element mask.
2509 bool X86::isSplatMask(SDNode *N) {
2510   assert(N->getOpcode() == ISD::BUILD_VECTOR);
2511
2512   // We can only splat 64-bit, and 32-bit quantities with a single instruction.
2513   if (N->getNumOperands() != 4 && N->getNumOperands() != 2)
2514     return false;
2515   return ::isSplatMask(N);
2516 }
2517
2518 /// isSplatLoMask - Return true if the specified VECTOR_SHUFFLE operand
2519 /// specifies a splat of zero element.
2520 bool X86::isSplatLoMask(SDNode *N) {
2521   assert(N->getOpcode() == ISD::BUILD_VECTOR);
2522
2523   for (unsigned i = 0, e = N->getNumOperands(); i < e; ++i)
2524     if (!isUndefOrEqual(N->getOperand(i), 0))
2525       return false;
2526   return true;
2527 }
2528
2529 /// isMOVDDUPMask - Return true if the specified VECTOR_SHUFFLE operand
2530 /// specifies a shuffle of elements that is suitable for input to MOVDDUP.
2531 bool X86::isMOVDDUPMask(SDNode *N) {
2532   assert(N->getOpcode() == ISD::BUILD_VECTOR);
2533
2534   unsigned e = N->getNumOperands() / 2;
2535   for (unsigned i = 0; i < e; ++i)
2536     if (!isUndefOrEqual(N->getOperand(i), i))
2537       return false;
2538   for (unsigned i = 0; i < e; ++i)
2539     if (!isUndefOrEqual(N->getOperand(e+i), i))
2540       return false;
2541   return true;
2542 }
2543
2544 /// getShuffleSHUFImmediate - Return the appropriate immediate to shuffle
2545 /// the specified isShuffleMask VECTOR_SHUFFLE mask with PSHUF* and SHUFP*
2546 /// instructions.
2547 unsigned X86::getShuffleSHUFImmediate(SDNode *N) {
2548   unsigned NumOperands = N->getNumOperands();
2549   unsigned Shift = (NumOperands == 4) ? 2 : 1;
2550   unsigned Mask = 0;
2551   for (unsigned i = 0; i < NumOperands; ++i) {
2552     unsigned Val = 0;
2553     SDValue Arg = N->getOperand(NumOperands-i-1);
2554     if (Arg.getOpcode() != ISD::UNDEF)
2555       Val = cast<ConstantSDNode>(Arg)->getZExtValue();
2556     if (Val >= NumOperands) Val -= NumOperands;
2557     Mask |= Val;
2558     if (i != NumOperands - 1)
2559       Mask <<= Shift;
2560   }
2561
2562   return Mask;
2563 }
2564
2565 /// getShufflePSHUFHWImmediate - Return the appropriate immediate to shuffle
2566 /// the specified isShuffleMask VECTOR_SHUFFLE mask with PSHUFHW
2567 /// instructions.
2568 unsigned X86::getShufflePSHUFHWImmediate(SDNode *N) {
2569   unsigned Mask = 0;
2570   // 8 nodes, but we only care about the last 4.
2571   for (unsigned i = 7; i >= 4; --i) {
2572     unsigned Val = 0;
2573     SDValue Arg = N->getOperand(i);
2574     if (Arg.getOpcode() != ISD::UNDEF)
2575       Val = cast<ConstantSDNode>(Arg)->getZExtValue();
2576     Mask |= (Val - 4);
2577     if (i != 4)
2578       Mask <<= 2;
2579   }
2580
2581   return Mask;
2582 }
2583
2584 /// getShufflePSHUFLWImmediate - Return the appropriate immediate to shuffle
2585 /// the specified isShuffleMask VECTOR_SHUFFLE mask with PSHUFLW
2586 /// instructions.
2587 unsigned X86::getShufflePSHUFLWImmediate(SDNode *N) {
2588   unsigned Mask = 0;
2589   // 8 nodes, but we only care about the first 4.
2590   for (int i = 3; i >= 0; --i) {
2591     unsigned Val = 0;
2592     SDValue Arg = N->getOperand(i);
2593     if (Arg.getOpcode() != ISD::UNDEF)
2594       Val = cast<ConstantSDNode>(Arg)->getZExtValue();
2595     Mask |= Val;
2596     if (i != 0)
2597       Mask <<= 2;
2598   }
2599
2600   return Mask;
2601 }
2602
2603 /// isPSHUFHW_PSHUFLWMask - true if the specified VECTOR_SHUFFLE operand
2604 /// specifies a 8 element shuffle that can be broken into a pair of
2605 /// PSHUFHW and PSHUFLW.
2606 static bool isPSHUFHW_PSHUFLWMask(SDNode *N) {
2607   assert(N->getOpcode() == ISD::BUILD_VECTOR);
2608
2609   if (N->getNumOperands() != 8)
2610     return false;
2611
2612   // Lower quadword shuffled.
2613   for (unsigned i = 0; i != 4; ++i) {
2614     SDValue Arg = N->getOperand(i);
2615     if (Arg.getOpcode() == ISD::UNDEF) continue;
2616     assert(isa<ConstantSDNode>(Arg) && "Invalid VECTOR_SHUFFLE mask!");
2617     unsigned Val = cast<ConstantSDNode>(Arg)->getZExtValue();
2618     if (Val >= 4)
2619       return false;
2620   }
2621
2622   // Upper quadword shuffled.
2623   for (unsigned i = 4; i != 8; ++i) {
2624     SDValue Arg = N->getOperand(i);
2625     if (Arg.getOpcode() == ISD::UNDEF) continue;
2626     assert(isa<ConstantSDNode>(Arg) && "Invalid VECTOR_SHUFFLE mask!");
2627     unsigned Val = cast<ConstantSDNode>(Arg)->getZExtValue();
2628     if (Val < 4 || Val > 7)
2629       return false;
2630   }
2631
2632   return true;
2633 }
2634
2635 /// CommuteVectorShuffle - Swap vector_shuffle operands as well as
2636 /// values in ther permute mask.
2637 static SDValue CommuteVectorShuffle(SDValue Op, SDValue &V1,
2638                                       SDValue &V2, SDValue &Mask,
2639                                       SelectionDAG &DAG) {
2640   MVT VT = Op.getValueType();
2641   MVT MaskVT = Mask.getValueType();
2642   MVT EltVT = MaskVT.getVectorElementType();
2643   unsigned NumElems = Mask.getNumOperands();
2644   SmallVector<SDValue, 8> MaskVec;
2645
2646   for (unsigned i = 0; i != NumElems; ++i) {
2647     SDValue Arg = Mask.getOperand(i);
2648     if (Arg.getOpcode() == ISD::UNDEF) {
2649       MaskVec.push_back(DAG.getNode(ISD::UNDEF, EltVT));
2650       continue;
2651     }
2652     assert(isa<ConstantSDNode>(Arg) && "Invalid VECTOR_SHUFFLE mask!");
2653     unsigned Val = cast<ConstantSDNode>(Arg)->getZExtValue();
2654     if (Val < NumElems)
2655       MaskVec.push_back(DAG.getConstant(Val + NumElems, EltVT));
2656     else
2657       MaskVec.push_back(DAG.getConstant(Val - NumElems, EltVT));
2658   }
2659
2660   std::swap(V1, V2);
2661   Mask = DAG.getNode(ISD::BUILD_VECTOR, MaskVT, &MaskVec[0], NumElems);
2662   return DAG.getNode(ISD::VECTOR_SHUFFLE, VT, V1, V2, Mask);
2663 }
2664
2665 /// CommuteVectorShuffleMask - Change values in a shuffle permute mask assuming
2666 /// the two vector operands have swapped position.
2667 static
2668 SDValue CommuteVectorShuffleMask(SDValue Mask, SelectionDAG &DAG) {
2669   MVT MaskVT = Mask.getValueType();
2670   MVT EltVT = MaskVT.getVectorElementType();
2671   unsigned NumElems = Mask.getNumOperands();
2672   SmallVector<SDValue, 8> MaskVec;
2673   for (unsigned i = 0; i != NumElems; ++i) {
2674     SDValue Arg = Mask.getOperand(i);
2675     if (Arg.getOpcode() == ISD::UNDEF) {
2676       MaskVec.push_back(DAG.getNode(ISD::UNDEF, EltVT));
2677       continue;
2678     }
2679     assert(isa<ConstantSDNode>(Arg) && "Invalid VECTOR_SHUFFLE mask!");
2680     unsigned Val = cast<ConstantSDNode>(Arg)->getZExtValue();
2681     if (Val < NumElems)
2682       MaskVec.push_back(DAG.getConstant(Val + NumElems, EltVT));
2683     else
2684       MaskVec.push_back(DAG.getConstant(Val - NumElems, EltVT));
2685   }
2686   return DAG.getNode(ISD::BUILD_VECTOR, MaskVT, &MaskVec[0], NumElems);
2687 }
2688
2689
2690 /// ShouldXformToMOVHLPS - Return true if the node should be transformed to
2691 /// match movhlps. The lower half elements should come from upper half of
2692 /// V1 (and in order), and the upper half elements should come from the upper
2693 /// half of V2 (and in order).
2694 static bool ShouldXformToMOVHLPS(SDNode *Mask) {
2695   unsigned NumElems = Mask->getNumOperands();
2696   if (NumElems != 4)
2697     return false;
2698   for (unsigned i = 0, e = 2; i != e; ++i)
2699     if (!isUndefOrEqual(Mask->getOperand(i), i+2))
2700       return false;
2701   for (unsigned i = 2; i != 4; ++i)
2702     if (!isUndefOrEqual(Mask->getOperand(i), i+4))
2703       return false;
2704   return true;
2705 }
2706
2707 /// isScalarLoadToVector - Returns true if the node is a scalar load that
2708 /// is promoted to a vector. It also returns the LoadSDNode by reference if
2709 /// required.
2710 static bool isScalarLoadToVector(SDNode *N, LoadSDNode **LD = NULL) {
2711   if (N->getOpcode() != ISD::SCALAR_TO_VECTOR)
2712     return false;
2713   N = N->getOperand(0).getNode();
2714   if (!ISD::isNON_EXTLoad(N))
2715     return false;
2716   if (LD)
2717     *LD = cast<LoadSDNode>(N);
2718   return true;
2719 }
2720
2721 /// ShouldXformToMOVLP{S|D} - Return true if the node should be transformed to
2722 /// match movlp{s|d}. The lower half elements should come from lower half of
2723 /// V1 (and in order), and the upper half elements should come from the upper
2724 /// half of V2 (and in order). And since V1 will become the source of the
2725 /// MOVLP, it must be either a vector load or a scalar load to vector.
2726 static bool ShouldXformToMOVLP(SDNode *V1, SDNode *V2, SDNode *Mask) {
2727   if (!ISD::isNON_EXTLoad(V1) && !isScalarLoadToVector(V1))
2728     return false;
2729   // Is V2 is a vector load, don't do this transformation. We will try to use
2730   // load folding shufps op.
2731   if (ISD::isNON_EXTLoad(V2))
2732     return false;
2733
2734   unsigned NumElems = Mask->getNumOperands();
2735   if (NumElems != 2 && NumElems != 4)
2736     return false;
2737   for (unsigned i = 0, e = NumElems/2; i != e; ++i)
2738     if (!isUndefOrEqual(Mask->getOperand(i), i))
2739       return false;
2740   for (unsigned i = NumElems/2; i != NumElems; ++i)
2741     if (!isUndefOrEqual(Mask->getOperand(i), i+NumElems))
2742       return false;
2743   return true;
2744 }
2745
2746 /// isSplatVector - Returns true if N is a BUILD_VECTOR node whose elements are
2747 /// all the same.
2748 static bool isSplatVector(SDNode *N) {
2749   if (N->getOpcode() != ISD::BUILD_VECTOR)
2750     return false;
2751
2752   SDValue SplatValue = N->getOperand(0);
2753   for (unsigned i = 1, e = N->getNumOperands(); i != e; ++i)
2754     if (N->getOperand(i) != SplatValue)
2755       return false;
2756   return true;
2757 }
2758
2759 /// isUndefShuffle - Returns true if N is a VECTOR_SHUFFLE that can be resolved
2760 /// to an undef.
2761 static bool isUndefShuffle(SDNode *N) {
2762   if (N->getOpcode() != ISD::VECTOR_SHUFFLE)
2763     return false;
2764
2765   SDValue V1 = N->getOperand(0);
2766   SDValue V2 = N->getOperand(1);
2767   SDValue Mask = N->getOperand(2);
2768   unsigned NumElems = Mask.getNumOperands();
2769   for (unsigned i = 0; i != NumElems; ++i) {
2770     SDValue Arg = Mask.getOperand(i);
2771     if (Arg.getOpcode() != ISD::UNDEF) {
2772       unsigned Val = cast<ConstantSDNode>(Arg)->getZExtValue();
2773       if (Val < NumElems && V1.getOpcode() != ISD::UNDEF)
2774         return false;
2775       else if (Val >= NumElems && V2.getOpcode() != ISD::UNDEF)
2776         return false;
2777     }
2778   }
2779   return true;
2780 }
2781
2782 /// isZeroNode - Returns true if Elt is a constant zero or a floating point
2783 /// constant +0.0.
2784 static inline bool isZeroNode(SDValue Elt) {
2785   return ((isa<ConstantSDNode>(Elt) &&
2786            cast<ConstantSDNode>(Elt)->getZExtValue() == 0) ||
2787           (isa<ConstantFPSDNode>(Elt) &&
2788            cast<ConstantFPSDNode>(Elt)->getValueAPF().isPosZero()));
2789 }
2790
2791 /// isZeroShuffle - Returns true if N is a VECTOR_SHUFFLE that can be resolved
2792 /// to an zero vector.
2793 static bool isZeroShuffle(SDNode *N) {
2794   if (N->getOpcode() != ISD::VECTOR_SHUFFLE)
2795     return false;
2796
2797   SDValue V1 = N->getOperand(0);
2798   SDValue V2 = N->getOperand(1);
2799   SDValue Mask = N->getOperand(2);
2800   unsigned NumElems = Mask.getNumOperands();
2801   for (unsigned i = 0; i != NumElems; ++i) {
2802     SDValue Arg = Mask.getOperand(i);
2803     if (Arg.getOpcode() == ISD::UNDEF)
2804       continue;
2805
2806     unsigned Idx = cast<ConstantSDNode>(Arg)->getZExtValue();
2807     if (Idx < NumElems) {
2808       unsigned Opc = V1.getNode()->getOpcode();
2809       if (Opc == ISD::UNDEF || ISD::isBuildVectorAllZeros(V1.getNode()))
2810         continue;
2811       if (Opc != ISD::BUILD_VECTOR ||
2812           !isZeroNode(V1.getNode()->getOperand(Idx)))
2813         return false;
2814     } else if (Idx >= NumElems) {
2815       unsigned Opc = V2.getNode()->getOpcode();
2816       if (Opc == ISD::UNDEF || ISD::isBuildVectorAllZeros(V2.getNode()))
2817         continue;
2818       if (Opc != ISD::BUILD_VECTOR ||
2819           !isZeroNode(V2.getNode()->getOperand(Idx - NumElems)))
2820         return false;
2821     }
2822   }
2823   return true;
2824 }
2825
2826 /// getZeroVector - Returns a vector of specified type with all zero elements.
2827 ///
2828 static SDValue getZeroVector(MVT VT, bool HasSSE2, SelectionDAG &DAG) {
2829   assert(VT.isVector() && "Expected a vector type");
2830
2831   // Always build zero vectors as <4 x i32> or <2 x i32> bitcasted to their dest
2832   // type.  This ensures they get CSE'd.
2833   SDValue Vec;
2834   if (VT.getSizeInBits() == 64) { // MMX
2835     SDValue Cst = DAG.getTargetConstant(0, MVT::i32);
2836     Vec = DAG.getNode(ISD::BUILD_VECTOR, MVT::v2i32, Cst, Cst);
2837   } else if (HasSSE2) {  // SSE2
2838     SDValue Cst = DAG.getTargetConstant(0, MVT::i32);
2839     Vec = DAG.getNode(ISD::BUILD_VECTOR, MVT::v4i32, Cst, Cst, Cst, Cst);
2840   } else { // SSE1
2841     SDValue Cst = DAG.getTargetConstantFP(+0.0, MVT::f32);
2842     Vec = DAG.getNode(ISD::BUILD_VECTOR, MVT::v4f32, Cst, Cst, Cst, Cst);
2843   }
2844   return DAG.getNode(ISD::BIT_CONVERT, VT, Vec);
2845 }
2846
2847 /// getOnesVector - Returns a vector of specified type with all bits set.
2848 ///
2849 static SDValue getOnesVector(MVT VT, SelectionDAG &DAG) {
2850   assert(VT.isVector() && "Expected a vector type");
2851
2852   // Always build ones vectors as <4 x i32> or <2 x i32> bitcasted to their dest
2853   // type.  This ensures they get CSE'd.
2854   SDValue Cst = DAG.getTargetConstant(~0U, MVT::i32);
2855   SDValue Vec;
2856   if (VT.getSizeInBits() == 64)  // MMX
2857     Vec = DAG.getNode(ISD::BUILD_VECTOR, MVT::v2i32, Cst, Cst);
2858   else                                              // SSE
2859     Vec = DAG.getNode(ISD::BUILD_VECTOR, MVT::v4i32, Cst, Cst, Cst, Cst);
2860   return DAG.getNode(ISD::BIT_CONVERT, VT, Vec);
2861 }
2862
2863
2864 /// NormalizeMask - V2 is a splat, modify the mask (if needed) so all elements
2865 /// that point to V2 points to its first element.
2866 static SDValue NormalizeMask(SDValue Mask, SelectionDAG &DAG) {
2867   assert(Mask.getOpcode() == ISD::BUILD_VECTOR);
2868
2869   bool Changed = false;
2870   SmallVector<SDValue, 8> MaskVec;
2871   unsigned NumElems = Mask.getNumOperands();
2872   for (unsigned i = 0; i != NumElems; ++i) {
2873     SDValue Arg = Mask.getOperand(i);
2874     if (Arg.getOpcode() != ISD::UNDEF) {
2875       unsigned Val = cast<ConstantSDNode>(Arg)->getZExtValue();
2876       if (Val > NumElems) {
2877         Arg = DAG.getConstant(NumElems, Arg.getValueType());
2878         Changed = true;
2879       }
2880     }
2881     MaskVec.push_back(Arg);
2882   }
2883
2884   if (Changed)
2885     Mask = DAG.getNode(ISD::BUILD_VECTOR, Mask.getValueType(),
2886                        &MaskVec[0], MaskVec.size());
2887   return Mask;
2888 }
2889
2890 /// getMOVLMask - Returns a vector_shuffle mask for an movs{s|d}, movd
2891 /// operation of specified width.
2892 static SDValue getMOVLMask(unsigned NumElems, SelectionDAG &DAG) {
2893   MVT MaskVT = MVT::getIntVectorWithNumElements(NumElems);
2894   MVT BaseVT = MaskVT.getVectorElementType();
2895
2896   SmallVector<SDValue, 8> MaskVec;
2897   MaskVec.push_back(DAG.getConstant(NumElems, BaseVT));
2898   for (unsigned i = 1; i != NumElems; ++i)
2899     MaskVec.push_back(DAG.getConstant(i, BaseVT));
2900   return DAG.getNode(ISD::BUILD_VECTOR, MaskVT, &MaskVec[0], MaskVec.size());
2901 }
2902
2903 /// getUnpacklMask - Returns a vector_shuffle mask for an unpackl operation
2904 /// of specified width.
2905 static SDValue getUnpacklMask(unsigned NumElems, SelectionDAG &DAG) {
2906   MVT MaskVT = MVT::getIntVectorWithNumElements(NumElems);
2907   MVT BaseVT = MaskVT.getVectorElementType();
2908   SmallVector<SDValue, 8> MaskVec;
2909   for (unsigned i = 0, e = NumElems/2; i != e; ++i) {
2910     MaskVec.push_back(DAG.getConstant(i,            BaseVT));
2911     MaskVec.push_back(DAG.getConstant(i + NumElems, BaseVT));
2912   }
2913   return DAG.getNode(ISD::BUILD_VECTOR, MaskVT, &MaskVec[0], MaskVec.size());
2914 }
2915
2916 /// getUnpackhMask - Returns a vector_shuffle mask for an unpackh operation
2917 /// of specified width.
2918 static SDValue getUnpackhMask(unsigned NumElems, SelectionDAG &DAG) {
2919   MVT MaskVT = MVT::getIntVectorWithNumElements(NumElems);
2920   MVT BaseVT = MaskVT.getVectorElementType();
2921   unsigned Half = NumElems/2;
2922   SmallVector<SDValue, 8> MaskVec;
2923   for (unsigned i = 0; i != Half; ++i) {
2924     MaskVec.push_back(DAG.getConstant(i + Half,            BaseVT));
2925     MaskVec.push_back(DAG.getConstant(i + NumElems + Half, BaseVT));
2926   }
2927   return DAG.getNode(ISD::BUILD_VECTOR, MaskVT, &MaskVec[0], MaskVec.size());
2928 }
2929
2930 /// getSwapEltZeroMask - Returns a vector_shuffle mask for a shuffle that swaps
2931 /// element #0 of a vector with the specified index, leaving the rest of the
2932 /// elements in place.
2933 static SDValue getSwapEltZeroMask(unsigned NumElems, unsigned DestElt,
2934                                    SelectionDAG &DAG) {
2935   MVT MaskVT = MVT::getIntVectorWithNumElements(NumElems);
2936   MVT BaseVT = MaskVT.getVectorElementType();
2937   SmallVector<SDValue, 8> MaskVec;
2938   // Element #0 of the result gets the elt we are replacing.
2939   MaskVec.push_back(DAG.getConstant(DestElt, BaseVT));
2940   for (unsigned i = 1; i != NumElems; ++i)
2941     MaskVec.push_back(DAG.getConstant(i == DestElt ? 0 : i, BaseVT));
2942   return DAG.getNode(ISD::BUILD_VECTOR, MaskVT, &MaskVec[0], MaskVec.size());
2943 }
2944
2945 /// PromoteSplat - Promote a splat of v4f32, v8i16 or v16i8 to v4i32.
2946 static SDValue PromoteSplat(SDValue Op, SelectionDAG &DAG, bool HasSSE2) {
2947   MVT PVT = HasSSE2 ? MVT::v4i32 : MVT::v4f32;
2948   MVT VT = Op.getValueType();
2949   if (PVT == VT)
2950     return Op;
2951   SDValue V1 = Op.getOperand(0);
2952   SDValue Mask = Op.getOperand(2);
2953   unsigned NumElems = Mask.getNumOperands();
2954   // Special handling of v4f32 -> v4i32.
2955   if (VT != MVT::v4f32) {
2956     Mask = getUnpacklMask(NumElems, DAG);
2957     while (NumElems > 4) {
2958       V1 = DAG.getNode(ISD::VECTOR_SHUFFLE, VT, V1, V1, Mask);
2959       NumElems >>= 1;
2960     }
2961     Mask = getZeroVector(MVT::v4i32, true, DAG);
2962   }
2963
2964   V1 = DAG.getNode(ISD::BIT_CONVERT, PVT, V1);
2965   SDValue Shuffle = DAG.getNode(ISD::VECTOR_SHUFFLE, PVT, V1,
2966                                   DAG.getNode(ISD::UNDEF, PVT), Mask);
2967   return DAG.getNode(ISD::BIT_CONVERT, VT, Shuffle);
2968 }
2969
2970 /// isVectorLoad - Returns true if the node is a vector load, a scalar
2971 /// load that's promoted to vector, or a load bitcasted.
2972 static bool isVectorLoad(SDValue Op) {
2973   assert(Op.getValueType().isVector() && "Expected a vector type");
2974   if (Op.getOpcode() == ISD::SCALAR_TO_VECTOR ||
2975       Op.getOpcode() == ISD::BIT_CONVERT) {
2976     return isa<LoadSDNode>(Op.getOperand(0));
2977   }
2978   return isa<LoadSDNode>(Op);
2979 }
2980
2981
2982 /// CanonicalizeMovddup - Cannonicalize movddup shuffle to v2f64.
2983 ///
2984 static SDValue CanonicalizeMovddup(SDValue Op, SDValue V1, SDValue Mask,
2985                                    SelectionDAG &DAG, bool HasSSE3) {
2986   // If we have sse3 and shuffle has more than one use or input is a load, then
2987   // use movddup. Otherwise, use movlhps.
2988   bool UseMovddup = HasSSE3 && (!Op.hasOneUse() || isVectorLoad(V1));
2989   MVT PVT = UseMovddup ? MVT::v2f64 : MVT::v4f32;
2990   MVT VT = Op.getValueType();
2991   if (VT == PVT)
2992     return Op;
2993   unsigned NumElems = PVT.getVectorNumElements();
2994   if (NumElems == 2) {
2995     SDValue Cst = DAG.getTargetConstant(0, MVT::i32);
2996     Mask = DAG.getNode(ISD::BUILD_VECTOR, MVT::v2i32, Cst, Cst);
2997   } else {
2998     assert(NumElems == 4);
2999     SDValue Cst0 = DAG.getTargetConstant(0, MVT::i32);
3000     SDValue Cst1 = DAG.getTargetConstant(1, MVT::i32);
3001     Mask = DAG.getNode(ISD::BUILD_VECTOR, MVT::v4i32, Cst0, Cst1, Cst0, Cst1);
3002   }
3003
3004   V1 = DAG.getNode(ISD::BIT_CONVERT, PVT, V1);
3005   SDValue Shuffle = DAG.getNode(ISD::VECTOR_SHUFFLE, PVT, V1,
3006                                 DAG.getNode(ISD::UNDEF, PVT), Mask);
3007   return DAG.getNode(ISD::BIT_CONVERT, VT, Shuffle);
3008 }
3009
3010 /// getShuffleVectorZeroOrUndef - Return a vector_shuffle of the specified
3011 /// vector of zero or undef vector.  This produces a shuffle where the low
3012 /// element of V2 is swizzled into the zero/undef vector, landing at element
3013 /// Idx.  This produces a shuffle mask like 4,1,2,3 (idx=0) or  0,1,2,4 (idx=3).
3014 static SDValue getShuffleVectorZeroOrUndef(SDValue V2, unsigned Idx,
3015                                              bool isZero, bool HasSSE2,
3016                                              SelectionDAG &DAG) {
3017   MVT VT = V2.getValueType();
3018   SDValue V1 = isZero
3019     ? getZeroVector(VT, HasSSE2, DAG) : DAG.getNode(ISD::UNDEF, VT);
3020   unsigned NumElems = V2.getValueType().getVectorNumElements();
3021   MVT MaskVT = MVT::getIntVectorWithNumElements(NumElems);
3022   MVT EVT = MaskVT.getVectorElementType();
3023   SmallVector<SDValue, 16> MaskVec;
3024   for (unsigned i = 0; i != NumElems; ++i)
3025     if (i == Idx)  // If this is the insertion idx, put the low elt of V2 here.
3026       MaskVec.push_back(DAG.getConstant(NumElems, EVT));
3027     else
3028       MaskVec.push_back(DAG.getConstant(i, EVT));
3029   SDValue Mask = DAG.getNode(ISD::BUILD_VECTOR, MaskVT,
3030                                &MaskVec[0], MaskVec.size());
3031   return DAG.getNode(ISD::VECTOR_SHUFFLE, VT, V1, V2, Mask);
3032 }
3033
3034 /// getNumOfConsecutiveZeros - Return the number of elements in a result of
3035 /// a shuffle that is zero.
3036 static
3037 unsigned getNumOfConsecutiveZeros(SDValue Op, SDValue Mask,
3038                                   unsigned NumElems, bool Low,
3039                                   SelectionDAG &DAG) {
3040   unsigned NumZeros = 0;
3041   for (unsigned i = 0; i < NumElems; ++i) {
3042     unsigned Index = Low ? i : NumElems-i-1;
3043     SDValue Idx = Mask.getOperand(Index);
3044     if (Idx.getOpcode() == ISD::UNDEF) {
3045       ++NumZeros;
3046       continue;
3047     }
3048     SDValue Elt = DAG.getShuffleScalarElt(Op.getNode(), Index);
3049     if (Elt.getNode() && isZeroNode(Elt))
3050       ++NumZeros;
3051     else
3052       break;
3053   }
3054   return NumZeros;
3055 }
3056
3057 /// isVectorShift - Returns true if the shuffle can be implemented as a
3058 /// logical left or right shift of a vector.
3059 static bool isVectorShift(SDValue Op, SDValue Mask, SelectionDAG &DAG,
3060                           bool &isLeft, SDValue &ShVal, unsigned &ShAmt) {
3061   unsigned NumElems = Mask.getNumOperands();
3062
3063   isLeft = true;
3064   unsigned NumZeros= getNumOfConsecutiveZeros(Op, Mask, NumElems, true, DAG);
3065   if (!NumZeros) {
3066     isLeft = false;
3067     NumZeros = getNumOfConsecutiveZeros(Op, Mask, NumElems, false, DAG);
3068     if (!NumZeros)
3069       return false;
3070   }
3071
3072   bool SeenV1 = false;
3073   bool SeenV2 = false;
3074   for (unsigned i = NumZeros; i < NumElems; ++i) {
3075     unsigned Val = isLeft ? (i - NumZeros) : i;
3076     SDValue Idx = Mask.getOperand(isLeft ? i : (i - NumZeros));
3077     if (Idx.getOpcode() == ISD::UNDEF)
3078       continue;
3079     unsigned Index = cast<ConstantSDNode>(Idx)->getZExtValue();
3080     if (Index < NumElems)
3081       SeenV1 = true;
3082     else {
3083       Index -= NumElems;
3084       SeenV2 = true;
3085     }
3086     if (Index != Val)
3087       return false;
3088   }
3089   if (SeenV1 && SeenV2)
3090     return false;
3091
3092   ShVal = SeenV1 ? Op.getOperand(0) : Op.getOperand(1);
3093   ShAmt = NumZeros;
3094   return true;
3095 }
3096
3097
3098 /// LowerBuildVectorv16i8 - Custom lower build_vector of v16i8.
3099 ///
3100 static SDValue LowerBuildVectorv16i8(SDValue Op, unsigned NonZeros,
3101                                        unsigned NumNonZero, unsigned NumZero,
3102                                        SelectionDAG &DAG, TargetLowering &TLI) {
3103   if (NumNonZero > 8)
3104     return SDValue();
3105
3106   SDValue V(0, 0);
3107   bool First = true;
3108   for (unsigned i = 0; i < 16; ++i) {
3109     bool ThisIsNonZero = (NonZeros & (1 << i)) != 0;
3110     if (ThisIsNonZero && First) {
3111       if (NumZero)
3112         V = getZeroVector(MVT::v8i16, true, DAG);
3113       else
3114         V = DAG.getNode(ISD::UNDEF, MVT::v8i16);
3115       First = false;
3116     }
3117
3118     if ((i & 1) != 0) {
3119       SDValue ThisElt(0, 0), LastElt(0, 0);
3120       bool LastIsNonZero = (NonZeros & (1 << (i-1))) != 0;
3121       if (LastIsNonZero) {
3122         LastElt = DAG.getNode(ISD::ZERO_EXTEND, MVT::i16, Op.getOperand(i-1));
3123       }
3124       if (ThisIsNonZero) {
3125         ThisElt = DAG.getNode(ISD::ZERO_EXTEND, MVT::i16, Op.getOperand(i));
3126         ThisElt = DAG.getNode(ISD::SHL, MVT::i16,
3127                               ThisElt, DAG.getConstant(8, MVT::i8));
3128         if (LastIsNonZero)
3129           ThisElt = DAG.getNode(ISD::OR, MVT::i16, ThisElt, LastElt);
3130       } else
3131         ThisElt = LastElt;
3132
3133       if (ThisElt.getNode())
3134         V = DAG.getNode(ISD::INSERT_VECTOR_ELT, MVT::v8i16, V, ThisElt,
3135                         DAG.getIntPtrConstant(i/2));
3136     }
3137   }
3138
3139   return DAG.getNode(ISD::BIT_CONVERT, MVT::v16i8, V);
3140 }
3141
3142 /// LowerBuildVectorv8i16 - Custom lower build_vector of v8i16.
3143 ///
3144 static SDValue LowerBuildVectorv8i16(SDValue Op, unsigned NonZeros,
3145                                        unsigned NumNonZero, unsigned NumZero,
3146                                        SelectionDAG &DAG, TargetLowering &TLI) {
3147   if (NumNonZero > 4)
3148     return SDValue();
3149
3150   SDValue V(0, 0);
3151   bool First = true;
3152   for (unsigned i = 0; i < 8; ++i) {
3153     bool isNonZero = (NonZeros & (1 << i)) != 0;
3154     if (isNonZero) {
3155       if (First) {
3156         if (NumZero)
3157           V = getZeroVector(MVT::v8i16, true, DAG);
3158         else
3159           V = DAG.getNode(ISD::UNDEF, MVT::v8i16);
3160         First = false;
3161       }
3162       V = DAG.getNode(ISD::INSERT_VECTOR_ELT, MVT::v8i16, V, Op.getOperand(i),
3163                       DAG.getIntPtrConstant(i));
3164     }
3165   }
3166
3167   return V;
3168 }
3169
3170 /// getVShift - Return a vector logical shift node.
3171 ///
3172 static SDValue getVShift(bool isLeft, MVT VT, SDValue SrcOp,
3173                            unsigned NumBits, SelectionDAG &DAG,
3174                            const TargetLowering &TLI) {
3175   bool isMMX = VT.getSizeInBits() == 64;
3176   MVT ShVT = isMMX ? MVT::v1i64 : MVT::v2i64;
3177   unsigned Opc = isLeft ? X86ISD::VSHL : X86ISD::VSRL;
3178   SrcOp = DAG.getNode(ISD::BIT_CONVERT, ShVT, SrcOp);
3179   return DAG.getNode(ISD::BIT_CONVERT, VT,
3180                      DAG.getNode(Opc, ShVT, SrcOp,
3181                              DAG.getConstant(NumBits, TLI.getShiftAmountTy())));
3182 }
3183
3184 SDValue
3185 X86TargetLowering::LowerBUILD_VECTOR(SDValue Op, SelectionDAG &DAG) {
3186   // All zero's are handled with pxor, all one's are handled with pcmpeqd.
3187   if (ISD::isBuildVectorAllZeros(Op.getNode())
3188       || ISD::isBuildVectorAllOnes(Op.getNode())) {
3189     // Canonicalize this to either <4 x i32> or <2 x i32> (SSE vs MMX) to
3190     // 1) ensure the zero vectors are CSE'd, and 2) ensure that i64 scalars are
3191     // eliminated on x86-32 hosts.
3192     if (Op.getValueType() == MVT::v4i32 || Op.getValueType() == MVT::v2i32)
3193       return Op;
3194
3195     if (ISD::isBuildVectorAllOnes(Op.getNode()))
3196       return getOnesVector(Op.getValueType(), DAG);
3197     return getZeroVector(Op.getValueType(), Subtarget->hasSSE2(), DAG);
3198   }
3199
3200   MVT VT = Op.getValueType();
3201   MVT EVT = VT.getVectorElementType();
3202   unsigned EVTBits = EVT.getSizeInBits();
3203
3204   unsigned NumElems = Op.getNumOperands();
3205   unsigned NumZero  = 0;
3206   unsigned NumNonZero = 0;
3207   unsigned NonZeros = 0;
3208   bool IsAllConstants = true;
3209   SmallSet<SDValue, 8> Values;
3210   for (unsigned i = 0; i < NumElems; ++i) {
3211     SDValue Elt = Op.getOperand(i);
3212     if (Elt.getOpcode() == ISD::UNDEF)
3213       continue;
3214     Values.insert(Elt);
3215     if (Elt.getOpcode() != ISD::Constant &&
3216         Elt.getOpcode() != ISD::ConstantFP)
3217       IsAllConstants = false;
3218     if (isZeroNode(Elt))
3219       NumZero++;
3220     else {
3221       NonZeros |= (1 << i);
3222       NumNonZero++;
3223     }
3224   }
3225
3226   if (NumNonZero == 0) {
3227     // All undef vector. Return an UNDEF.  All zero vectors were handled above.
3228     return DAG.getNode(ISD::UNDEF, VT);
3229   }
3230
3231   // Special case for single non-zero, non-undef, element.
3232   if (NumNonZero == 1 && NumElems <= 4) {
3233     unsigned Idx = CountTrailingZeros_32(NonZeros);
3234     SDValue Item = Op.getOperand(Idx);
3235
3236     // If this is an insertion of an i64 value on x86-32, and if the top bits of
3237     // the value are obviously zero, truncate the value to i32 and do the
3238     // insertion that way.  Only do this if the value is non-constant or if the
3239     // value is a constant being inserted into element 0.  It is cheaper to do
3240     // a constant pool load than it is to do a movd + shuffle.
3241     if (EVT == MVT::i64 && !Subtarget->is64Bit() &&
3242         (!IsAllConstants || Idx == 0)) {
3243       if (DAG.MaskedValueIsZero(Item, APInt::getBitsSet(64, 32, 64))) {
3244         // Handle MMX and SSE both.
3245         MVT VecVT = VT == MVT::v2i64 ? MVT::v4i32 : MVT::v2i32;
3246         unsigned VecElts = VT == MVT::v2i64 ? 4 : 2;
3247
3248         // Truncate the value (which may itself be a constant) to i32, and
3249         // convert it to a vector with movd (S2V+shuffle to zero extend).
3250         Item = DAG.getNode(ISD::TRUNCATE, MVT::i32, Item);
3251         Item = DAG.getNode(ISD::SCALAR_TO_VECTOR, VecVT, Item);
3252         Item = getShuffleVectorZeroOrUndef(Item, 0, true,
3253                                            Subtarget->hasSSE2(), DAG);
3254
3255         // Now we have our 32-bit value zero extended in the low element of
3256         // a vector.  If Idx != 0, swizzle it into place.
3257         if (Idx != 0) {
3258           SDValue Ops[] = {
3259             Item, DAG.getNode(ISD::UNDEF, Item.getValueType()),
3260             getSwapEltZeroMask(VecElts, Idx, DAG)
3261           };
3262           Item = DAG.getNode(ISD::VECTOR_SHUFFLE, VecVT, Ops, 3);
3263         }
3264         return DAG.getNode(ISD::BIT_CONVERT, Op.getValueType(), Item);
3265       }
3266     }
3267
3268     // If we have a constant or non-constant insertion into the low element of
3269     // a vector, we can do this with SCALAR_TO_VECTOR + shuffle of zero into
3270     // the rest of the elements.  This will be matched as movd/movq/movss/movsd
3271     // depending on what the source datatype is.  Because we can only get here
3272     // when NumElems <= 4, this only needs to handle i32/f32/i64/f64.
3273     if (Idx == 0 &&
3274         // Don't do this for i64 values on x86-32.
3275         (EVT != MVT::i64 || Subtarget->is64Bit())) {
3276       Item = DAG.getNode(ISD::SCALAR_TO_VECTOR, VT, Item);
3277       // Turn it into a MOVL (i.e. movss, movsd, or movd) to a zero vector.
3278       return getShuffleVectorZeroOrUndef(Item, 0, NumZero > 0,
3279                                          Subtarget->hasSSE2(), DAG);
3280     }
3281
3282     // Is it a vector logical left shift?
3283     if (NumElems == 2 && Idx == 1 &&
3284         isZeroNode(Op.getOperand(0)) && !isZeroNode(Op.getOperand(1))) {
3285       unsigned NumBits = VT.getSizeInBits();
3286       return getVShift(true, VT,
3287                        DAG.getNode(ISD::SCALAR_TO_VECTOR, VT, Op.getOperand(1)),
3288                        NumBits/2, DAG, *this);
3289     }
3290
3291     if (IsAllConstants) // Otherwise, it's better to do a constpool load.
3292       return SDValue();
3293
3294     // Otherwise, if this is a vector with i32 or f32 elements, and the element
3295     // is a non-constant being inserted into an element other than the low one,
3296     // we can't use a constant pool load.  Instead, use SCALAR_TO_VECTOR (aka
3297     // movd/movss) to move this into the low element, then shuffle it into
3298     // place.
3299     if (EVTBits == 32) {
3300       Item = DAG.getNode(ISD::SCALAR_TO_VECTOR, VT, Item);
3301
3302       // Turn it into a shuffle of zero and zero-extended scalar to vector.
3303       Item = getShuffleVectorZeroOrUndef(Item, 0, NumZero > 0,
3304                                          Subtarget->hasSSE2(), DAG);
3305       MVT MaskVT  = MVT::getIntVectorWithNumElements(NumElems);
3306       MVT MaskEVT = MaskVT.getVectorElementType();
3307       SmallVector<SDValue, 8> MaskVec;
3308       for (unsigned i = 0; i < NumElems; i++)
3309         MaskVec.push_back(DAG.getConstant((i == Idx) ? 0 : 1, MaskEVT));
3310       SDValue Mask = DAG.getNode(ISD::BUILD_VECTOR, MaskVT,
3311                                    &MaskVec[0], MaskVec.size());
3312       return DAG.getNode(ISD::VECTOR_SHUFFLE, VT, Item,
3313                          DAG.getNode(ISD::UNDEF, VT), Mask);
3314     }
3315   }
3316
3317   // Splat is obviously ok. Let legalizer expand it to a shuffle.
3318   if (Values.size() == 1)
3319     return SDValue();
3320
3321   // A vector full of immediates; various special cases are already
3322   // handled, so this is best done with a single constant-pool load.
3323   if (IsAllConstants)
3324     return SDValue();
3325
3326   // Let legalizer expand 2-wide build_vectors.
3327   if (EVTBits == 64) {
3328     if (NumNonZero == 1) {
3329       // One half is zero or undef.
3330       unsigned Idx = CountTrailingZeros_32(NonZeros);
3331       SDValue V2 = DAG.getNode(ISD::SCALAR_TO_VECTOR, VT,
3332                                  Op.getOperand(Idx));
3333       return getShuffleVectorZeroOrUndef(V2, Idx, true,
3334                                          Subtarget->hasSSE2(), DAG);
3335     }
3336     return SDValue();
3337   }
3338
3339   // If element VT is < 32 bits, convert it to inserts into a zero vector.
3340   if (EVTBits == 8 && NumElems == 16) {
3341     SDValue V = LowerBuildVectorv16i8(Op, NonZeros,NumNonZero,NumZero, DAG,
3342                                         *this);
3343     if (V.getNode()) return V;
3344   }
3345
3346   if (EVTBits == 16 && NumElems == 8) {
3347     SDValue V = LowerBuildVectorv8i16(Op, NonZeros,NumNonZero,NumZero, DAG,
3348                                         *this);
3349     if (V.getNode()) return V;
3350   }
3351
3352   // If element VT is == 32 bits, turn it into a number of shuffles.
3353   SmallVector<SDValue, 8> V;
3354   V.resize(NumElems);
3355   if (NumElems == 4 && NumZero > 0) {
3356     for (unsigned i = 0; i < 4; ++i) {
3357       bool isZero = !(NonZeros & (1 << i));
3358       if (isZero)
3359         V[i] = getZeroVector(VT, Subtarget->hasSSE2(), DAG);
3360       else
3361         V[i] = DAG.getNode(ISD::SCALAR_TO_VECTOR, VT, Op.getOperand(i));
3362     }
3363
3364     for (unsigned i = 0; i < 2; ++i) {
3365       switch ((NonZeros & (0x3 << i*2)) >> (i*2)) {
3366         default: break;
3367         case 0:
3368           V[i] = V[i*2];  // Must be a zero vector.
3369           break;
3370         case 1:
3371           V[i] = DAG.getNode(ISD::VECTOR_SHUFFLE, VT, V[i*2+1], V[i*2],
3372                              getMOVLMask(NumElems, DAG));
3373           break;
3374         case 2:
3375           V[i] = DAG.getNode(ISD::VECTOR_SHUFFLE, VT, V[i*2], V[i*2+1],
3376                              getMOVLMask(NumElems, DAG));
3377           break;
3378         case 3:
3379           V[i] = DAG.getNode(ISD::VECTOR_SHUFFLE, VT, V[i*2], V[i*2+1],
3380                              getUnpacklMask(NumElems, DAG));
3381           break;
3382       }
3383     }
3384
3385     MVT MaskVT = MVT::getIntVectorWithNumElements(NumElems);
3386     MVT EVT = MaskVT.getVectorElementType();
3387     SmallVector<SDValue, 8> MaskVec;
3388     bool Reverse = (NonZeros & 0x3) == 2;
3389     for (unsigned i = 0; i < 2; ++i)
3390       if (Reverse)
3391         MaskVec.push_back(DAG.getConstant(1-i, EVT));
3392       else
3393         MaskVec.push_back(DAG.getConstant(i, EVT));
3394     Reverse = ((NonZeros & (0x3 << 2)) >> 2) == 2;
3395     for (unsigned i = 0; i < 2; ++i)
3396       if (Reverse)
3397         MaskVec.push_back(DAG.getConstant(1-i+NumElems, EVT));
3398       else
3399         MaskVec.push_back(DAG.getConstant(i+NumElems, EVT));
3400     SDValue ShufMask = DAG.getNode(ISD::BUILD_VECTOR, MaskVT,
3401                                      &MaskVec[0], MaskVec.size());
3402     return DAG.getNode(ISD::VECTOR_SHUFFLE, VT, V[0], V[1], ShufMask);
3403   }
3404
3405   if (Values.size() > 2) {
3406     // Expand into a number of unpckl*.
3407     // e.g. for v4f32
3408     //   Step 1: unpcklps 0, 2 ==> X: <?, ?, 2, 0>
3409     //         : unpcklps 1, 3 ==> Y: <?, ?, 3, 1>
3410     //   Step 2: unpcklps X, Y ==>    <3, 2, 1, 0>
3411     SDValue UnpckMask = getUnpacklMask(NumElems, DAG);
3412     for (unsigned i = 0; i < NumElems; ++i)
3413       V[i] = DAG.getNode(ISD::SCALAR_TO_VECTOR, VT, Op.getOperand(i));
3414     NumElems >>= 1;
3415     while (NumElems != 0) {
3416       for (unsigned i = 0; i < NumElems; ++i)
3417         V[i] = DAG.getNode(ISD::VECTOR_SHUFFLE, VT, V[i], V[i + NumElems],
3418                            UnpckMask);
3419       NumElems >>= 1;
3420     }
3421     return V[0];
3422   }
3423
3424   return SDValue();
3425 }
3426
3427 static
3428 SDValue LowerVECTOR_SHUFFLEv8i16(SDValue V1, SDValue V2,
3429                                  SDValue PermMask, SelectionDAG &DAG,
3430                                  TargetLowering &TLI) {
3431   SDValue NewV;
3432   MVT MaskVT = MVT::getIntVectorWithNumElements(8);
3433   MVT MaskEVT = MaskVT.getVectorElementType();
3434   MVT PtrVT = TLI.getPointerTy();
3435   SmallVector<SDValue, 8> MaskElts(PermMask.getNode()->op_begin(),
3436                                    PermMask.getNode()->op_end());
3437
3438   // First record which half of which vector the low elements come from.
3439   SmallVector<unsigned, 4> LowQuad(4);
3440   for (unsigned i = 0; i < 4; ++i) {
3441     SDValue Elt = MaskElts[i];
3442     if (Elt.getOpcode() == ISD::UNDEF)
3443       continue;
3444     unsigned EltIdx = cast<ConstantSDNode>(Elt)->getZExtValue();
3445     int QuadIdx = EltIdx / 4;
3446     ++LowQuad[QuadIdx];
3447   }
3448
3449   int BestLowQuad = -1;
3450   unsigned MaxQuad = 1;
3451   for (unsigned i = 0; i < 4; ++i) {
3452     if (LowQuad[i] > MaxQuad) {
3453       BestLowQuad = i;
3454       MaxQuad = LowQuad[i];
3455     }
3456   }
3457
3458   // Record which half of which vector the high elements come from.
3459   SmallVector<unsigned, 4> HighQuad(4);
3460   for (unsigned i = 4; i < 8; ++i) {
3461     SDValue Elt = MaskElts[i];
3462     if (Elt.getOpcode() == ISD::UNDEF)
3463       continue;
3464     unsigned EltIdx = cast<ConstantSDNode>(Elt)->getZExtValue();
3465     int QuadIdx = EltIdx / 4;
3466     ++HighQuad[QuadIdx];
3467   }
3468
3469   int BestHighQuad = -1;
3470   MaxQuad = 1;
3471   for (unsigned i = 0; i < 4; ++i) {
3472     if (HighQuad[i] > MaxQuad) {
3473       BestHighQuad = i;
3474       MaxQuad = HighQuad[i];
3475     }
3476   }
3477
3478   // If it's possible to sort parts of either half with PSHUF{H|L}W, then do it.
3479   if (BestLowQuad != -1 || BestHighQuad != -1) {
3480     // First sort the 4 chunks in order using shufpd.
3481     SmallVector<SDValue, 8> MaskVec;
3482
3483     if (BestLowQuad != -1)
3484       MaskVec.push_back(DAG.getConstant(BestLowQuad, MVT::i32));
3485     else
3486       MaskVec.push_back(DAG.getConstant(0, MVT::i32));
3487
3488     if (BestHighQuad != -1)
3489       MaskVec.push_back(DAG.getConstant(BestHighQuad, MVT::i32));
3490     else
3491       MaskVec.push_back(DAG.getConstant(1, MVT::i32));
3492
3493     SDValue Mask= DAG.getNode(ISD::BUILD_VECTOR, MVT::v2i32, &MaskVec[0],2);
3494     NewV = DAG.getNode(ISD::VECTOR_SHUFFLE, MVT::v2i64,
3495                        DAG.getNode(ISD::BIT_CONVERT, MVT::v2i64, V1),
3496                        DAG.getNode(ISD::BIT_CONVERT, MVT::v2i64, V2), Mask);
3497     NewV = DAG.getNode(ISD::BIT_CONVERT, MVT::v8i16, NewV);
3498
3499     // Now sort high and low parts separately.
3500     BitVector InOrder(8);
3501     if (BestLowQuad != -1) {
3502       // Sort lower half in order using PSHUFLW.
3503       MaskVec.clear();
3504       bool AnyOutOrder = false;
3505
3506       for (unsigned i = 0; i != 4; ++i) {
3507         SDValue Elt = MaskElts[i];
3508         if (Elt.getOpcode() == ISD::UNDEF) {
3509           MaskVec.push_back(Elt);
3510           InOrder.set(i);
3511         } else {
3512           unsigned EltIdx = cast<ConstantSDNode>(Elt)->getZExtValue();
3513           if (EltIdx != i)
3514             AnyOutOrder = true;
3515
3516           MaskVec.push_back(DAG.getConstant(EltIdx % 4, MaskEVT));
3517
3518           // If this element is in the right place after this shuffle, then
3519           // remember it.
3520           if ((int)(EltIdx / 4) == BestLowQuad)
3521             InOrder.set(i);
3522         }
3523       }
3524       if (AnyOutOrder) {
3525         for (unsigned i = 4; i != 8; ++i)
3526           MaskVec.push_back(DAG.getConstant(i, MaskEVT));
3527         SDValue Mask = DAG.getNode(ISD::BUILD_VECTOR, MaskVT, &MaskVec[0], 8);
3528         NewV = DAG.getNode(ISD::VECTOR_SHUFFLE, MVT::v8i16, NewV, NewV, Mask);
3529       }
3530     }
3531
3532     if (BestHighQuad != -1) {
3533       // Sort high half in order using PSHUFHW if possible.
3534       MaskVec.clear();
3535
3536       for (unsigned i = 0; i != 4; ++i)
3537         MaskVec.push_back(DAG.getConstant(i, MaskEVT));
3538
3539       bool AnyOutOrder = false;
3540       for (unsigned i = 4; i != 8; ++i) {
3541         SDValue Elt = MaskElts[i];
3542         if (Elt.getOpcode() == ISD::UNDEF) {
3543           MaskVec.push_back(Elt);
3544           InOrder.set(i);
3545         } else {
3546           unsigned EltIdx = cast<ConstantSDNode>(Elt)->getZExtValue();
3547           if (EltIdx != i)
3548             AnyOutOrder = true;
3549
3550           MaskVec.push_back(DAG.getConstant((EltIdx % 4) + 4, MaskEVT));
3551
3552           // If this element is in the right place after this shuffle, then
3553           // remember it.
3554           if ((int)(EltIdx / 4) == BestHighQuad)
3555             InOrder.set(i);
3556         }
3557       }
3558
3559       if (AnyOutOrder) {
3560         SDValue Mask = DAG.getNode(ISD::BUILD_VECTOR, MaskVT, &MaskVec[0], 8);
3561         NewV = DAG.getNode(ISD::VECTOR_SHUFFLE, MVT::v8i16, NewV, NewV, Mask);
3562       }
3563     }
3564
3565     // The other elements are put in the right place using pextrw and pinsrw.
3566     for (unsigned i = 0; i != 8; ++i) {
3567       if (InOrder[i])
3568         continue;
3569       SDValue Elt = MaskElts[i];
3570       if (Elt.getOpcode() == ISD::UNDEF)
3571         continue;
3572       unsigned EltIdx = cast<ConstantSDNode>(Elt)->getZExtValue();
3573       SDValue ExtOp = (EltIdx < 8)
3574         ? DAG.getNode(ISD::EXTRACT_VECTOR_ELT, MVT::i16, V1,
3575                       DAG.getConstant(EltIdx, PtrVT))
3576         : DAG.getNode(ISD::EXTRACT_VECTOR_ELT, MVT::i16, V2,
3577                       DAG.getConstant(EltIdx - 8, PtrVT));
3578       NewV = DAG.getNode(ISD::INSERT_VECTOR_ELT, MVT::v8i16, NewV, ExtOp,
3579                          DAG.getConstant(i, PtrVT));
3580     }
3581
3582     return NewV;
3583   }
3584
3585   // PSHUF{H|L}W are not used. Lower into extracts and inserts but try to use as
3586   // few as possible. First, let's find out how many elements are already in the
3587   // right order.
3588   unsigned V1InOrder = 0;
3589   unsigned V1FromV1 = 0;
3590   unsigned V2InOrder = 0;
3591   unsigned V2FromV2 = 0;
3592   SmallVector<SDValue, 8> V1Elts;
3593   SmallVector<SDValue, 8> V2Elts;
3594   for (unsigned i = 0; i < 8; ++i) {
3595     SDValue Elt = MaskElts[i];
3596     if (Elt.getOpcode() == ISD::UNDEF) {
3597       V1Elts.push_back(Elt);
3598       V2Elts.push_back(Elt);
3599       ++V1InOrder;
3600       ++V2InOrder;
3601       continue;
3602     }
3603     unsigned EltIdx = cast<ConstantSDNode>(Elt)->getZExtValue();
3604     if (EltIdx == i) {
3605       V1Elts.push_back(Elt);
3606       V2Elts.push_back(DAG.getConstant(i+8, MaskEVT));
3607       ++V1InOrder;
3608     } else if (EltIdx == i+8) {
3609       V1Elts.push_back(Elt);
3610       V2Elts.push_back(DAG.getConstant(i, MaskEVT));
3611       ++V2InOrder;
3612     } else if (EltIdx < 8) {
3613       V1Elts.push_back(Elt);
3614       ++V1FromV1;
3615     } else {
3616       V2Elts.push_back(DAG.getConstant(EltIdx-8, MaskEVT));
3617       ++V2FromV2;
3618     }
3619   }
3620
3621   if (V2InOrder > V1InOrder) {
3622     PermMask = CommuteVectorShuffleMask(PermMask, DAG);
3623     std::swap(V1, V2);
3624     std::swap(V1Elts, V2Elts);
3625     std::swap(V1FromV1, V2FromV2);
3626   }
3627
3628   if ((V1FromV1 + V1InOrder) != 8) {
3629     // Some elements are from V2.
3630     if (V1FromV1) {
3631       // If there are elements that are from V1 but out of place,
3632       // then first sort them in place
3633       SmallVector<SDValue, 8> MaskVec;
3634       for (unsigned i = 0; i < 8; ++i) {
3635         SDValue Elt = V1Elts[i];
3636         if (Elt.getOpcode() == ISD::UNDEF) {
3637           MaskVec.push_back(DAG.getNode(ISD::UNDEF, MaskEVT));
3638           continue;
3639         }
3640         unsigned EltIdx = cast<ConstantSDNode>(Elt)->getZExtValue();
3641         if (EltIdx >= 8)
3642           MaskVec.push_back(DAG.getNode(ISD::UNDEF, MaskEVT));
3643         else
3644           MaskVec.push_back(DAG.getConstant(EltIdx, MaskEVT));
3645       }
3646       SDValue Mask = DAG.getNode(ISD::BUILD_VECTOR, MaskVT, &MaskVec[0], 8);
3647       V1 = DAG.getNode(ISD::VECTOR_SHUFFLE, MVT::v8i16, V1, V1, Mask);
3648     }
3649
3650     NewV = V1;
3651     for (unsigned i = 0; i < 8; ++i) {
3652       SDValue Elt = V1Elts[i];
3653       if (Elt.getOpcode() == ISD::UNDEF)
3654         continue;
3655       unsigned EltIdx = cast<ConstantSDNode>(Elt)->getZExtValue();
3656       if (EltIdx < 8)
3657         continue;
3658       SDValue ExtOp = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, MVT::i16, V2,
3659                                     DAG.getConstant(EltIdx - 8, PtrVT));
3660       NewV = DAG.getNode(ISD::INSERT_VECTOR_ELT, MVT::v8i16, NewV, ExtOp,
3661                          DAG.getConstant(i, PtrVT));
3662     }
3663     return NewV;
3664   } else {
3665     // All elements are from V1.
3666     NewV = V1;
3667     for (unsigned i = 0; i < 8; ++i) {
3668       SDValue Elt = V1Elts[i];
3669       if (Elt.getOpcode() == ISD::UNDEF)
3670         continue;
3671       unsigned EltIdx = cast<ConstantSDNode>(Elt)->getZExtValue();
3672       SDValue ExtOp = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, MVT::i16, V1,
3673                                     DAG.getConstant(EltIdx, PtrVT));
3674       NewV = DAG.getNode(ISD::INSERT_VECTOR_ELT, MVT::v8i16, NewV, ExtOp,
3675                          DAG.getConstant(i, PtrVT));
3676     }
3677     return NewV;
3678   }
3679 }
3680
3681 /// RewriteAsNarrowerShuffle - Try rewriting v8i16 and v16i8 shuffles as 4 wide
3682 /// ones, or rewriting v4i32 / v2f32 as 2 wide ones if possible. This can be
3683 /// done when every pair / quad of shuffle mask elements point to elements in
3684 /// the right sequence. e.g.
3685 /// vector_shuffle <>, <>, < 3, 4, | 10, 11, | 0, 1, | 14, 15>
3686 static
3687 SDValue RewriteAsNarrowerShuffle(SDValue V1, SDValue V2,
3688                                 MVT VT,
3689                                 SDValue PermMask, SelectionDAG &DAG,
3690                                 TargetLowering &TLI) {
3691   unsigned NumElems = PermMask.getNumOperands();
3692   unsigned NewWidth = (NumElems == 4) ? 2 : 4;
3693   MVT MaskVT = MVT::getIntVectorWithNumElements(NewWidth);
3694   MVT MaskEltVT = MaskVT.getVectorElementType();
3695   MVT NewVT = MaskVT;
3696   switch (VT.getSimpleVT()) {
3697   default: assert(false && "Unexpected!");
3698   case MVT::v4f32: NewVT = MVT::v2f64; break;
3699   case MVT::v4i32: NewVT = MVT::v2i64; break;
3700   case MVT::v8i16: NewVT = MVT::v4i32; break;
3701   case MVT::v16i8: NewVT = MVT::v4i32; break;
3702   }
3703
3704   if (NewWidth == 2) {
3705     if (VT.isInteger())
3706       NewVT = MVT::v2i64;
3707     else
3708       NewVT = MVT::v2f64;
3709   }
3710   unsigned Scale = NumElems / NewWidth;
3711   SmallVector<SDValue, 8> MaskVec;
3712   for (unsigned i = 0; i < NumElems; i += Scale) {
3713     unsigned StartIdx = ~0U;
3714     for (unsigned j = 0; j < Scale; ++j) {
3715       SDValue Elt = PermMask.getOperand(i+j);
3716       if (Elt.getOpcode() == ISD::UNDEF)
3717         continue;
3718       unsigned EltIdx = cast<ConstantSDNode>(Elt)->getZExtValue();
3719       if (StartIdx == ~0U)
3720         StartIdx = EltIdx - (EltIdx % Scale);
3721       if (EltIdx != StartIdx + j)
3722         return SDValue();
3723     }
3724     if (StartIdx == ~0U)
3725       MaskVec.push_back(DAG.getNode(ISD::UNDEF, MaskEltVT));
3726     else
3727       MaskVec.push_back(DAG.getConstant(StartIdx / Scale, MaskEltVT));
3728   }
3729
3730   V1 = DAG.getNode(ISD::BIT_CONVERT, NewVT, V1);
3731   V2 = DAG.getNode(ISD::BIT_CONVERT, NewVT, V2);
3732   return DAG.getNode(ISD::VECTOR_SHUFFLE, NewVT, V1, V2,
3733                      DAG.getNode(ISD::BUILD_VECTOR, MaskVT,
3734                                  &MaskVec[0], MaskVec.size()));
3735 }
3736
3737 /// getVZextMovL - Return a zero-extending vector move low node.
3738 ///
3739 static SDValue getVZextMovL(MVT VT, MVT OpVT,
3740                               SDValue SrcOp, SelectionDAG &DAG,
3741                               const X86Subtarget *Subtarget) {
3742   if (VT == MVT::v2f64 || VT == MVT::v4f32) {
3743     LoadSDNode *LD = NULL;
3744     if (!isScalarLoadToVector(SrcOp.getNode(), &LD))
3745       LD = dyn_cast<LoadSDNode>(SrcOp);
3746     if (!LD) {
3747       // movssrr and movsdrr do not clear top bits. Try to use movd, movq
3748       // instead.
3749       MVT EVT = (OpVT == MVT::v2f64) ? MVT::i64 : MVT::i32;
3750       if ((EVT != MVT::i64 || Subtarget->is64Bit()) &&
3751           SrcOp.getOpcode() == ISD::SCALAR_TO_VECTOR &&
3752           SrcOp.getOperand(0).getOpcode() == ISD::BIT_CONVERT &&
3753           SrcOp.getOperand(0).getOperand(0).getValueType() == EVT) {
3754         // PR2108
3755         OpVT = (OpVT == MVT::v2f64) ? MVT::v2i64 : MVT::v4i32;
3756         return DAG.getNode(ISD::BIT_CONVERT, VT,
3757                            DAG.getNode(X86ISD::VZEXT_MOVL, OpVT,
3758                                        DAG.getNode(ISD::SCALAR_TO_VECTOR, OpVT,
3759                                                    SrcOp.getOperand(0)
3760                                                           .getOperand(0))));
3761       }
3762     }
3763   }
3764
3765   return DAG.getNode(ISD::BIT_CONVERT, VT,
3766                      DAG.getNode(X86ISD::VZEXT_MOVL, OpVT,
3767                                  DAG.getNode(ISD::BIT_CONVERT, OpVT, SrcOp)));
3768 }
3769
3770 /// LowerVECTOR_SHUFFLE_4wide - Handle all 4 wide cases with a number of
3771 /// shuffles.
3772 static SDValue
3773 LowerVECTOR_SHUFFLE_4wide(SDValue V1, SDValue V2,
3774                           SDValue PermMask, MVT VT, SelectionDAG &DAG) {
3775   MVT MaskVT = PermMask.getValueType();
3776   MVT MaskEVT = MaskVT.getVectorElementType();
3777   SmallVector<std::pair<int, int>, 8> Locs;
3778   Locs.resize(4);
3779   SmallVector<SDValue, 8> Mask1(4, DAG.getNode(ISD::UNDEF, MaskEVT));
3780   unsigned NumHi = 0;
3781   unsigned NumLo = 0;
3782   for (unsigned i = 0; i != 4; ++i) {
3783     SDValue Elt = PermMask.getOperand(i);
3784     if (Elt.getOpcode() == ISD::UNDEF) {
3785       Locs[i] = std::make_pair(-1, -1);
3786     } else {
3787       unsigned Val = cast<ConstantSDNode>(Elt)->getZExtValue();
3788       assert(Val < 8 && "Invalid VECTOR_SHUFFLE index!");
3789       if (Val < 4) {
3790         Locs[i] = std::make_pair(0, NumLo);
3791         Mask1[NumLo] = Elt;
3792         NumLo++;
3793       } else {
3794         Locs[i] = std::make_pair(1, NumHi);
3795         if (2+NumHi < 4)
3796           Mask1[2+NumHi] = Elt;
3797         NumHi++;
3798       }
3799     }
3800   }
3801
3802   if (NumLo <= 2 && NumHi <= 2) {
3803     // If no more than two elements come from either vector. This can be
3804     // implemented with two shuffles. First shuffle gather the elements.
3805     // The second shuffle, which takes the first shuffle as both of its
3806     // vector operands, put the elements into the right order.
3807     V1 = DAG.getNode(ISD::VECTOR_SHUFFLE, VT, V1, V2,
3808                      DAG.getNode(ISD::BUILD_VECTOR, MaskVT,
3809                                  &Mask1[0], Mask1.size()));
3810
3811     SmallVector<SDValue, 8> Mask2(4, DAG.getNode(ISD::UNDEF, MaskEVT));
3812     for (unsigned i = 0; i != 4; ++i) {
3813       if (Locs[i].first == -1)
3814         continue;
3815       else {
3816         unsigned Idx = (i < 2) ? 0 : 4;
3817         Idx += Locs[i].first * 2 + Locs[i].second;
3818         Mask2[i] = DAG.getConstant(Idx, MaskEVT);
3819       }
3820     }
3821
3822     return DAG.getNode(ISD::VECTOR_SHUFFLE, VT, V1, V1,
3823                        DAG.getNode(ISD::BUILD_VECTOR, MaskVT,
3824                                    &Mask2[0], Mask2.size()));
3825   } else if (NumLo == 3 || NumHi == 3) {
3826     // Otherwise, we must have three elements from one vector, call it X, and
3827     // one element from the other, call it Y.  First, use a shufps to build an
3828     // intermediate vector with the one element from Y and the element from X
3829     // that will be in the same half in the final destination (the indexes don't
3830     // matter). Then, use a shufps to build the final vector, taking the half
3831     // containing the element from Y from the intermediate, and the other half
3832     // from X.
3833     if (NumHi == 3) {
3834       // Normalize it so the 3 elements come from V1.
3835       PermMask = CommuteVectorShuffleMask(PermMask, DAG);
3836       std::swap(V1, V2);
3837     }
3838
3839     // Find the element from V2.
3840     unsigned HiIndex;
3841     for (HiIndex = 0; HiIndex < 3; ++HiIndex) {
3842       SDValue Elt = PermMask.getOperand(HiIndex);
3843       if (Elt.getOpcode() == ISD::UNDEF)
3844         continue;
3845       unsigned Val = cast<ConstantSDNode>(Elt)->getZExtValue();
3846       if (Val >= 4)
3847         break;
3848     }
3849
3850     Mask1[0] = PermMask.getOperand(HiIndex);
3851     Mask1[1] = DAG.getNode(ISD::UNDEF, MaskEVT);
3852     Mask1[2] = PermMask.getOperand(HiIndex^1);
3853     Mask1[3] = DAG.getNode(ISD::UNDEF, MaskEVT);
3854     V2 = DAG.getNode(ISD::VECTOR_SHUFFLE, VT, V1, V2,
3855                      DAG.getNode(ISD::BUILD_VECTOR, MaskVT, &Mask1[0], 4));
3856
3857     if (HiIndex >= 2) {
3858       Mask1[0] = PermMask.getOperand(0);
3859       Mask1[1] = PermMask.getOperand(1);
3860       Mask1[2] = DAG.getConstant(HiIndex & 1 ? 6 : 4, MaskEVT);
3861       Mask1[3] = DAG.getConstant(HiIndex & 1 ? 4 : 6, MaskEVT);
3862       return DAG.getNode(ISD::VECTOR_SHUFFLE, VT, V1, V2,
3863                          DAG.getNode(ISD::BUILD_VECTOR, MaskVT, &Mask1[0], 4));
3864     } else {
3865       Mask1[0] = DAG.getConstant(HiIndex & 1 ? 2 : 0, MaskEVT);
3866       Mask1[1] = DAG.getConstant(HiIndex & 1 ? 0 : 2, MaskEVT);
3867       Mask1[2] = PermMask.getOperand(2);
3868       Mask1[3] = PermMask.getOperand(3);
3869       if (Mask1[2].getOpcode() != ISD::UNDEF)
3870         Mask1[2] =
3871           DAG.getConstant(cast<ConstantSDNode>(Mask1[2])->getZExtValue()+4,
3872                           MaskEVT);
3873       if (Mask1[3].getOpcode() != ISD::UNDEF)
3874         Mask1[3] =
3875           DAG.getConstant(cast<ConstantSDNode>(Mask1[3])->getZExtValue()+4,
3876                           MaskEVT);
3877       return DAG.getNode(ISD::VECTOR_SHUFFLE, VT, V2, V1,
3878                          DAG.getNode(ISD::BUILD_VECTOR, MaskVT, &Mask1[0], 4));
3879     }
3880   }
3881
3882   // Break it into (shuffle shuffle_hi, shuffle_lo).
3883   Locs.clear();
3884   SmallVector<SDValue,8> LoMask(4, DAG.getNode(ISD::UNDEF, MaskEVT));
3885   SmallVector<SDValue,8> HiMask(4, DAG.getNode(ISD::UNDEF, MaskEVT));
3886   SmallVector<SDValue,8> *MaskPtr = &LoMask;
3887   unsigned MaskIdx = 0;
3888   unsigned LoIdx = 0;
3889   unsigned HiIdx = 2;
3890   for (unsigned i = 0; i != 4; ++i) {
3891     if (i == 2) {
3892       MaskPtr = &HiMask;
3893       MaskIdx = 1;
3894       LoIdx = 0;
3895       HiIdx = 2;
3896     }
3897     SDValue Elt = PermMask.getOperand(i);
3898     if (Elt.getOpcode() == ISD::UNDEF) {
3899       Locs[i] = std::make_pair(-1, -1);
3900     } else if (cast<ConstantSDNode>(Elt)->getZExtValue() < 4) {
3901       Locs[i] = std::make_pair(MaskIdx, LoIdx);
3902       (*MaskPtr)[LoIdx] = Elt;
3903       LoIdx++;
3904     } else {
3905       Locs[i] = std::make_pair(MaskIdx, HiIdx);
3906       (*MaskPtr)[HiIdx] = Elt;
3907       HiIdx++;
3908     }
3909   }
3910
3911   SDValue LoShuffle = DAG.getNode(ISD::VECTOR_SHUFFLE, VT, V1, V2,
3912                                     DAG.getNode(ISD::BUILD_VECTOR, MaskVT,
3913                                                 &LoMask[0], LoMask.size()));
3914   SDValue HiShuffle = DAG.getNode(ISD::VECTOR_SHUFFLE, VT, V1, V2,
3915                                     DAG.getNode(ISD::BUILD_VECTOR, MaskVT,
3916                                                 &HiMask[0], HiMask.size()));
3917   SmallVector<SDValue, 8> MaskOps;
3918   for (unsigned i = 0; i != 4; ++i) {
3919     if (Locs[i].first == -1) {
3920       MaskOps.push_back(DAG.getNode(ISD::UNDEF, MaskEVT));
3921     } else {
3922       unsigned Idx = Locs[i].first * 4 + Locs[i].second;
3923       MaskOps.push_back(DAG.getConstant(Idx, MaskEVT));
3924     }
3925   }
3926   return DAG.getNode(ISD::VECTOR_SHUFFLE, VT, LoShuffle, HiShuffle,
3927                      DAG.getNode(ISD::BUILD_VECTOR, MaskVT,
3928                                  &MaskOps[0], MaskOps.size()));
3929 }
3930
3931 SDValue
3932 X86TargetLowering::LowerVECTOR_SHUFFLE(SDValue Op, SelectionDAG &DAG) {
3933   SDValue V1 = Op.getOperand(0);
3934   SDValue V2 = Op.getOperand(1);
3935   SDValue PermMask = Op.getOperand(2);
3936   MVT VT = Op.getValueType();
3937   unsigned NumElems = PermMask.getNumOperands();
3938   bool isMMX = VT.getSizeInBits() == 64;
3939   bool V1IsUndef = V1.getOpcode() == ISD::UNDEF;
3940   bool V2IsUndef = V2.getOpcode() == ISD::UNDEF;
3941   bool V1IsSplat = false;
3942   bool V2IsSplat = false;
3943
3944   if (isUndefShuffle(Op.getNode()))
3945     return DAG.getNode(ISD::UNDEF, VT);
3946
3947   if (isZeroShuffle(Op.getNode()))
3948     return getZeroVector(VT, Subtarget->hasSSE2(), DAG);
3949
3950   if (isIdentityMask(PermMask.getNode()))
3951     return V1;
3952   else if (isIdentityMask(PermMask.getNode(), true))
3953     return V2;
3954
3955   // Canonicalize movddup shuffles.
3956   if (V2IsUndef && Subtarget->hasSSE2() &&
3957       X86::isMOVDDUPMask(PermMask.getNode()))
3958     return CanonicalizeMovddup(Op, V1, PermMask, DAG, Subtarget->hasSSE3());
3959
3960   if (isSplatMask(PermMask.getNode())) {
3961     if (isMMX || NumElems < 4) return Op;
3962     // Promote it to a v4{if}32 splat.
3963     return PromoteSplat(Op, DAG, Subtarget->hasSSE2());
3964   }
3965
3966   // If the shuffle can be profitably rewritten as a narrower shuffle, then
3967   // do it!
3968   if (VT == MVT::v8i16 || VT == MVT::v16i8) {
3969     SDValue NewOp= RewriteAsNarrowerShuffle(V1, V2, VT, PermMask, DAG, *this);
3970     if (NewOp.getNode())
3971       return DAG.getNode(ISD::BIT_CONVERT, VT, LowerVECTOR_SHUFFLE(NewOp, DAG));
3972   } else if ((VT == MVT::v4i32 || (VT == MVT::v4f32 && Subtarget->hasSSE2()))) {
3973     // FIXME: Figure out a cleaner way to do this.
3974     // Try to make use of movq to zero out the top part.
3975     if (ISD::isBuildVectorAllZeros(V2.getNode())) {
3976       SDValue NewOp = RewriteAsNarrowerShuffle(V1, V2, VT, PermMask,
3977                                                  DAG, *this);
3978       if (NewOp.getNode()) {
3979         SDValue NewV1 = NewOp.getOperand(0);
3980         SDValue NewV2 = NewOp.getOperand(1);
3981         SDValue NewMask = NewOp.getOperand(2);
3982         if (isCommutedMOVL(NewMask.getNode(), true, false)) {
3983           NewOp = CommuteVectorShuffle(NewOp, NewV1, NewV2, NewMask, DAG);
3984           return getVZextMovL(VT, NewOp.getValueType(), NewV2, DAG, Subtarget);
3985         }
3986       }
3987     } else if (ISD::isBuildVectorAllZeros(V1.getNode())) {
3988       SDValue NewOp= RewriteAsNarrowerShuffle(V1, V2, VT, PermMask,
3989                                                 DAG, *this);
3990       if (NewOp.getNode() && X86::isMOVLMask(NewOp.getOperand(2).getNode()))
3991         return getVZextMovL(VT, NewOp.getValueType(), NewOp.getOperand(1),
3992                              DAG, Subtarget);
3993     }
3994   }
3995
3996   // Check if this can be converted into a logical shift.
3997   bool isLeft = false;
3998   unsigned ShAmt = 0;
3999   SDValue ShVal;
4000   bool isShift = isVectorShift(Op, PermMask, DAG, isLeft, ShVal, ShAmt);
4001   if (isShift && ShVal.hasOneUse()) {
4002     // If the shifted value has multiple uses, it may be cheaper to use
4003     // v_set0 + movlhps or movhlps, etc.
4004     MVT EVT = VT.getVectorElementType();
4005     ShAmt *= EVT.getSizeInBits();
4006     return getVShift(isLeft, VT, ShVal, ShAmt, DAG, *this);
4007   }
4008
4009   if (X86::isMOVLMask(PermMask.getNode())) {
4010     if (V1IsUndef)
4011       return V2;
4012     if (ISD::isBuildVectorAllZeros(V1.getNode()))
4013       return getVZextMovL(VT, VT, V2, DAG, Subtarget);
4014     if (!isMMX)
4015       return Op;
4016   }
4017
4018   if (!isMMX && (X86::isMOVSHDUPMask(PermMask.getNode()) ||
4019                  X86::isMOVSLDUPMask(PermMask.getNode()) ||
4020                  X86::isMOVHLPSMask(PermMask.getNode()) ||
4021                  X86::isMOVHPMask(PermMask.getNode()) ||
4022                  X86::isMOVLPMask(PermMask.getNode())))
4023     return Op;
4024
4025   if (ShouldXformToMOVHLPS(PermMask.getNode()) ||
4026       ShouldXformToMOVLP(V1.getNode(), V2.getNode(), PermMask.getNode()))
4027     return CommuteVectorShuffle(Op, V1, V2, PermMask, DAG);
4028
4029   if (isShift) {
4030     // No better options. Use a vshl / vsrl.
4031     MVT EVT = VT.getVectorElementType();
4032     ShAmt *= EVT.getSizeInBits();
4033     return getVShift(isLeft, VT, ShVal, ShAmt, DAG, *this);
4034   }
4035
4036   bool Commuted = false;
4037   // FIXME: This should also accept a bitcast of a splat?  Be careful, not
4038   // 1,1,1,1 -> v8i16 though.
4039   V1IsSplat = isSplatVector(V1.getNode());
4040   V2IsSplat = isSplatVector(V2.getNode());
4041
4042   // Canonicalize the splat or undef, if present, to be on the RHS.
4043   if ((V1IsSplat || V1IsUndef) && !(V2IsSplat || V2IsUndef)) {
4044     Op = CommuteVectorShuffle(Op, V1, V2, PermMask, DAG);
4045     std::swap(V1IsSplat, V2IsSplat);
4046     std::swap(V1IsUndef, V2IsUndef);
4047     Commuted = true;
4048   }
4049
4050   // FIXME: Figure out a cleaner way to do this.
4051   if (isCommutedMOVL(PermMask.getNode(), V2IsSplat, V2IsUndef)) {
4052     if (V2IsUndef) return V1;
4053     Op = CommuteVectorShuffle(Op, V1, V2, PermMask, DAG);
4054     if (V2IsSplat) {
4055       // V2 is a splat, so the mask may be malformed. That is, it may point
4056       // to any V2 element. The instruction selectior won't like this. Get
4057       // a corrected mask and commute to form a proper MOVS{S|D}.
4058       SDValue NewMask = getMOVLMask(NumElems, DAG);
4059       if (NewMask.getNode() != PermMask.getNode())
4060         Op = DAG.getNode(ISD::VECTOR_SHUFFLE, VT, V1, V2, NewMask);
4061     }
4062     return Op;
4063   }
4064
4065   if (X86::isUNPCKL_v_undef_Mask(PermMask.getNode()) ||
4066       X86::isUNPCKH_v_undef_Mask(PermMask.getNode()) ||
4067       X86::isUNPCKLMask(PermMask.getNode()) ||
4068       X86::isUNPCKHMask(PermMask.getNode()))
4069     return Op;
4070
4071   if (V2IsSplat) {
4072     // Normalize mask so all entries that point to V2 points to its first
4073     // element then try to match unpck{h|l} again. If match, return a
4074     // new vector_shuffle with the corrected mask.
4075     SDValue NewMask = NormalizeMask(PermMask, DAG);
4076     if (NewMask.getNode() != PermMask.getNode()) {
4077       if (X86::isUNPCKLMask(PermMask.getNode(), true)) {
4078         SDValue NewMask = getUnpacklMask(NumElems, DAG);
4079         return DAG.getNode(ISD::VECTOR_SHUFFLE, VT, V1, V2, NewMask);
4080       } else if (X86::isUNPCKHMask(PermMask.getNode(), true)) {
4081         SDValue NewMask = getUnpackhMask(NumElems, DAG);
4082         return DAG.getNode(ISD::VECTOR_SHUFFLE, VT, V1, V2, NewMask);
4083       }
4084     }
4085   }
4086
4087   // Normalize the node to match x86 shuffle ops if needed
4088   if (V2.getOpcode() != ISD::UNDEF && isCommutedSHUFP(PermMask.getNode()))
4089       Op = CommuteVectorShuffle(Op, V1, V2, PermMask, DAG);
4090
4091   if (Commuted) {
4092     // Commute is back and try unpck* again.
4093     Op = CommuteVectorShuffle(Op, V1, V2, PermMask, DAG);
4094     if (X86::isUNPCKL_v_undef_Mask(PermMask.getNode()) ||
4095         X86::isUNPCKH_v_undef_Mask(PermMask.getNode()) ||
4096         X86::isUNPCKLMask(PermMask.getNode()) ||
4097         X86::isUNPCKHMask(PermMask.getNode()))
4098       return Op;
4099   }
4100
4101   // Try PSHUF* first, then SHUFP*.
4102   // MMX doesn't have PSHUFD but it does have PSHUFW. While it's theoretically
4103   // possible to shuffle a v2i32 using PSHUFW, that's not yet implemented.
4104   if (isMMX && NumElems == 4 && X86::isPSHUFDMask(PermMask.getNode())) {
4105     if (V2.getOpcode() != ISD::UNDEF)
4106       return DAG.getNode(ISD::VECTOR_SHUFFLE, VT, V1,
4107                          DAG.getNode(ISD::UNDEF, VT), PermMask);
4108     return Op;
4109   }
4110
4111   if (!isMMX) {
4112     if (Subtarget->hasSSE2() &&
4113         (X86::isPSHUFDMask(PermMask.getNode()) ||
4114          X86::isPSHUFHWMask(PermMask.getNode()) ||
4115          X86::isPSHUFLWMask(PermMask.getNode()))) {
4116       MVT RVT = VT;
4117       if (VT == MVT::v4f32) {
4118         RVT = MVT::v4i32;
4119         Op = DAG.getNode(ISD::VECTOR_SHUFFLE, RVT,
4120                          DAG.getNode(ISD::BIT_CONVERT, RVT, V1),
4121                          DAG.getNode(ISD::UNDEF, RVT), PermMask);
4122       } else if (V2.getOpcode() != ISD::UNDEF)
4123         Op = DAG.getNode(ISD::VECTOR_SHUFFLE, RVT, V1,
4124                          DAG.getNode(ISD::UNDEF, RVT), PermMask);
4125       if (RVT != VT)
4126         Op = DAG.getNode(ISD::BIT_CONVERT, VT, Op);
4127       return Op;
4128     }
4129
4130     // Binary or unary shufps.
4131     if (X86::isSHUFPMask(PermMask.getNode()) ||
4132         (V2.getOpcode() == ISD::UNDEF && X86::isPSHUFDMask(PermMask.getNode())))
4133       return Op;
4134   }
4135
4136   // Handle v8i16 specifically since SSE can do byte extraction and insertion.
4137   if (VT == MVT::v8i16) {
4138     SDValue NewOp = LowerVECTOR_SHUFFLEv8i16(V1, V2, PermMask, DAG, *this);
4139     if (NewOp.getNode())
4140       return NewOp;
4141   }
4142
4143   // Handle all 4 wide cases with a number of shuffles except for MMX.
4144   if (NumElems == 4 && !isMMX)
4145     return LowerVECTOR_SHUFFLE_4wide(V1, V2, PermMask, VT, DAG);
4146
4147   return SDValue();
4148 }
4149
4150 SDValue
4151 X86TargetLowering::LowerEXTRACT_VECTOR_ELT_SSE4(SDValue Op,
4152                                                 SelectionDAG &DAG) {
4153   MVT VT = Op.getValueType();
4154   if (VT.getSizeInBits() == 8) {
4155     SDValue Extract = DAG.getNode(X86ISD::PEXTRB, MVT::i32,
4156                                     Op.getOperand(0), Op.getOperand(1));
4157     SDValue Assert  = DAG.getNode(ISD::AssertZext, MVT::i32, Extract,
4158                                     DAG.getValueType(VT));
4159     return DAG.getNode(ISD::TRUNCATE, VT, Assert);
4160   } else if (VT.getSizeInBits() == 16) {
4161     SDValue Extract = DAG.getNode(X86ISD::PEXTRW, MVT::i32,
4162                                     Op.getOperand(0), Op.getOperand(1));
4163     SDValue Assert  = DAG.getNode(ISD::AssertZext, MVT::i32, Extract,
4164                                     DAG.getValueType(VT));
4165     return DAG.getNode(ISD::TRUNCATE, VT, Assert);
4166   } else if (VT == MVT::f32) {
4167     // EXTRACTPS outputs to a GPR32 register which will require a movd to copy
4168     // the result back to FR32 register. It's only worth matching if the
4169     // result has a single use which is a store or a bitcast to i32.
4170     if (!Op.hasOneUse())
4171       return SDValue();
4172     SDNode *User = *Op.getNode()->use_begin();
4173     if (User->getOpcode() != ISD::STORE &&
4174         (User->getOpcode() != ISD::BIT_CONVERT ||
4175          User->getValueType(0) != MVT::i32))
4176       return SDValue();
4177     SDValue Extract = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, MVT::i32,
4178                     DAG.getNode(ISD::BIT_CONVERT, MVT::v4i32, Op.getOperand(0)),
4179                                     Op.getOperand(1));
4180     return DAG.getNode(ISD::BIT_CONVERT, MVT::f32, Extract);
4181   }
4182   return SDValue();
4183 }
4184
4185
4186 SDValue
4187 X86TargetLowering::LowerEXTRACT_VECTOR_ELT(SDValue Op, SelectionDAG &DAG) {
4188   if (!isa<ConstantSDNode>(Op.getOperand(1)))
4189     return SDValue();
4190
4191   if (Subtarget->hasSSE41()) {
4192     SDValue Res = LowerEXTRACT_VECTOR_ELT_SSE4(Op, DAG);
4193     if (Res.getNode())
4194       return Res;
4195   }
4196
4197   MVT VT = Op.getValueType();
4198   // TODO: handle v16i8.
4199   if (VT.getSizeInBits() == 16) {
4200     SDValue Vec = Op.getOperand(0);
4201     unsigned Idx = cast<ConstantSDNode>(Op.getOperand(1))->getZExtValue();
4202     if (Idx == 0)
4203       return DAG.getNode(ISD::TRUNCATE, MVT::i16,
4204                          DAG.getNode(ISD::EXTRACT_VECTOR_ELT, MVT::i32,
4205                                  DAG.getNode(ISD::BIT_CONVERT, MVT::v4i32, Vec),
4206                                      Op.getOperand(1)));
4207     // Transform it so it match pextrw which produces a 32-bit result.
4208     MVT EVT = (MVT::SimpleValueType)(VT.getSimpleVT()+1);
4209     SDValue Extract = DAG.getNode(X86ISD::PEXTRW, EVT,
4210                                     Op.getOperand(0), Op.getOperand(1));
4211     SDValue Assert  = DAG.getNode(ISD::AssertZext, EVT, Extract,
4212                                     DAG.getValueType(VT));
4213     return DAG.getNode(ISD::TRUNCATE, VT, Assert);
4214   } else if (VT.getSizeInBits() == 32) {
4215     unsigned Idx = cast<ConstantSDNode>(Op.getOperand(1))->getZExtValue();
4216     if (Idx == 0)
4217       return Op;
4218     // SHUFPS the element to the lowest double word, then movss.
4219     MVT MaskVT = MVT::getIntVectorWithNumElements(4);
4220     SmallVector<SDValue, 8> IdxVec;
4221     IdxVec.
4222       push_back(DAG.getConstant(Idx, MaskVT.getVectorElementType()));
4223     IdxVec.
4224       push_back(DAG.getNode(ISD::UNDEF, MaskVT.getVectorElementType()));
4225     IdxVec.
4226       push_back(DAG.getNode(ISD::UNDEF, MaskVT.getVectorElementType()));
4227     IdxVec.
4228       push_back(DAG.getNode(ISD::UNDEF, MaskVT.getVectorElementType()));
4229     SDValue Mask = DAG.getNode(ISD::BUILD_VECTOR, MaskVT,
4230                                  &IdxVec[0], IdxVec.size());
4231     SDValue Vec = Op.getOperand(0);
4232     Vec = DAG.getNode(ISD::VECTOR_SHUFFLE, Vec.getValueType(),
4233                       Vec, DAG.getNode(ISD::UNDEF, Vec.getValueType()), Mask);
4234     return DAG.getNode(ISD::EXTRACT_VECTOR_ELT, VT, Vec,
4235                        DAG.getIntPtrConstant(0));
4236   } else if (VT.getSizeInBits() == 64) {
4237     // FIXME: .td only matches this for <2 x f64>, not <2 x i64> on 32b
4238     // FIXME: seems like this should be unnecessary if mov{h,l}pd were taught
4239     //        to match extract_elt for f64.
4240     unsigned Idx = cast<ConstantSDNode>(Op.getOperand(1))->getZExtValue();
4241     if (Idx == 0)
4242       return Op;
4243
4244     // UNPCKHPD the element to the lowest double word, then movsd.
4245     // Note if the lower 64 bits of the result of the UNPCKHPD is then stored
4246     // to a f64mem, the whole operation is folded into a single MOVHPDmr.
4247     MVT MaskVT = MVT::getIntVectorWithNumElements(2);
4248     SmallVector<SDValue, 8> IdxVec;
4249     IdxVec.push_back(DAG.getConstant(1, MaskVT.getVectorElementType()));
4250     IdxVec.
4251       push_back(DAG.getNode(ISD::UNDEF, MaskVT.getVectorElementType()));
4252     SDValue Mask = DAG.getNode(ISD::BUILD_VECTOR, MaskVT,
4253                                  &IdxVec[0], IdxVec.size());
4254     SDValue Vec = Op.getOperand(0);
4255     Vec = DAG.getNode(ISD::VECTOR_SHUFFLE, Vec.getValueType(),
4256                       Vec, DAG.getNode(ISD::UNDEF, Vec.getValueType()), Mask);
4257     return DAG.getNode(ISD::EXTRACT_VECTOR_ELT, VT, Vec,
4258                        DAG.getIntPtrConstant(0));
4259   }
4260
4261   return SDValue();
4262 }
4263
4264 SDValue
4265 X86TargetLowering::LowerINSERT_VECTOR_ELT_SSE4(SDValue Op, SelectionDAG &DAG){
4266   MVT VT = Op.getValueType();
4267   MVT EVT = VT.getVectorElementType();
4268
4269   SDValue N0 = Op.getOperand(0);
4270   SDValue N1 = Op.getOperand(1);
4271   SDValue N2 = Op.getOperand(2);
4272
4273   if ((EVT.getSizeInBits() == 8 || EVT.getSizeInBits() == 16) &&
4274       isa<ConstantSDNode>(N2)) {
4275     unsigned Opc = (EVT.getSizeInBits() == 8) ? X86ISD::PINSRB
4276                                                   : X86ISD::PINSRW;
4277     // Transform it so it match pinsr{b,w} which expects a GR32 as its second
4278     // argument.
4279     if (N1.getValueType() != MVT::i32)
4280       N1 = DAG.getNode(ISD::ANY_EXTEND, MVT::i32, N1);
4281     if (N2.getValueType() != MVT::i32)
4282       N2 = DAG.getIntPtrConstant(cast<ConstantSDNode>(N2)->getZExtValue());
4283     return DAG.getNode(Opc, VT, N0, N1, N2);
4284   } else if (EVT == MVT::f32 && isa<ConstantSDNode>(N2)) {
4285     // Bits [7:6] of the constant are the source select.  This will always be
4286     //  zero here.  The DAG Combiner may combine an extract_elt index into these
4287     //  bits.  For example (insert (extract, 3), 2) could be matched by putting
4288     //  the '3' into bits [7:6] of X86ISD::INSERTPS.
4289     // Bits [5:4] of the constant are the destination select.  This is the
4290     //  value of the incoming immediate.
4291     // Bits [3:0] of the constant are the zero mask.  The DAG Combiner may
4292     //   combine either bitwise AND or insert of float 0.0 to set these bits.
4293     N2 = DAG.getIntPtrConstant(cast<ConstantSDNode>(N2)->getZExtValue() << 4);
4294     return DAG.getNode(X86ISD::INSERTPS, VT, N0, N1, N2);
4295   }
4296   return SDValue();
4297 }
4298
4299 SDValue
4300 X86TargetLowering::LowerINSERT_VECTOR_ELT(SDValue Op, SelectionDAG &DAG) {
4301   MVT VT = Op.getValueType();
4302   MVT EVT = VT.getVectorElementType();
4303
4304   if (Subtarget->hasSSE41())
4305     return LowerINSERT_VECTOR_ELT_SSE4(Op, DAG);
4306
4307   if (EVT == MVT::i8)
4308     return SDValue();
4309
4310   SDValue N0 = Op.getOperand(0);
4311   SDValue N1 = Op.getOperand(1);
4312   SDValue N2 = Op.getOperand(2);
4313
4314   if (EVT.getSizeInBits() == 16) {
4315     // Transform it so it match pinsrw which expects a 16-bit value in a GR32
4316     // as its second argument.
4317     if (N1.getValueType() != MVT::i32)
4318       N1 = DAG.getNode(ISD::ANY_EXTEND, MVT::i32, N1);
4319     if (N2.getValueType() != MVT::i32)
4320       N2 = DAG.getIntPtrConstant(cast<ConstantSDNode>(N2)->getZExtValue());
4321     return DAG.getNode(X86ISD::PINSRW, VT, N0, N1, N2);
4322   }
4323   return SDValue();
4324 }
4325
4326 SDValue
4327 X86TargetLowering::LowerSCALAR_TO_VECTOR(SDValue Op, SelectionDAG &DAG) {
4328   if (Op.getValueType() == MVT::v2f32)
4329     return DAG.getNode(ISD::BIT_CONVERT, MVT::v2f32,
4330                        DAG.getNode(ISD::SCALAR_TO_VECTOR, MVT::v2i32,
4331                                    DAG.getNode(ISD::BIT_CONVERT, MVT::i32,
4332                                                Op.getOperand(0))));
4333
4334   SDValue AnyExt = DAG.getNode(ISD::ANY_EXTEND, MVT::i32, Op.getOperand(0));
4335   MVT VT = MVT::v2i32;
4336   switch (Op.getValueType().getSimpleVT()) {
4337   default: break;
4338   case MVT::v16i8:
4339   case MVT::v8i16:
4340     VT = MVT::v4i32;
4341     break;
4342   }
4343   return DAG.getNode(ISD::BIT_CONVERT, Op.getValueType(),
4344                      DAG.getNode(ISD::SCALAR_TO_VECTOR, VT, AnyExt));
4345 }
4346
4347 // ConstantPool, JumpTable, GlobalAddress, and ExternalSymbol are lowered as
4348 // their target countpart wrapped in the X86ISD::Wrapper node. Suppose N is
4349 // one of the above mentioned nodes. It has to be wrapped because otherwise
4350 // Select(N) returns N. So the raw TargetGlobalAddress nodes, etc. can only
4351 // be used to form addressing mode. These wrapped nodes will be selected
4352 // into MOV32ri.
4353 SDValue
4354 X86TargetLowering::LowerConstantPool(SDValue Op, SelectionDAG &DAG) {
4355   ConstantPoolSDNode *CP = cast<ConstantPoolSDNode>(Op);
4356   SDValue Result = DAG.getTargetConstantPool(CP->getConstVal(),
4357                                                getPointerTy(),
4358                                                CP->getAlignment());
4359   Result = DAG.getNode(X86ISD::Wrapper, getPointerTy(), Result);
4360   // With PIC, the address is actually $g + Offset.
4361   if (getTargetMachine().getRelocationModel() == Reloc::PIC_ &&
4362       !Subtarget->isPICStyleRIPRel()) {
4363     Result = DAG.getNode(ISD::ADD, getPointerTy(),
4364                          DAG.getNode(X86ISD::GlobalBaseReg, getPointerTy()),
4365                          Result);
4366   }
4367
4368   return Result;
4369 }
4370
4371 SDValue
4372 X86TargetLowering::LowerGlobalAddress(const GlobalValue *GV,
4373                                       SelectionDAG &DAG) const {
4374   SDValue Result = DAG.getTargetGlobalAddress(GV, getPointerTy());
4375   Result = DAG.getNode(X86ISD::Wrapper, getPointerTy(), Result);
4376   // With PIC, the address is actually $g + Offset.
4377   if (getTargetMachine().getRelocationModel() == Reloc::PIC_ &&
4378       !Subtarget->isPICStyleRIPRel()) {
4379     Result = DAG.getNode(ISD::ADD, getPointerTy(),
4380                          DAG.getNode(X86ISD::GlobalBaseReg, getPointerTy()),
4381                          Result);
4382   }
4383
4384   // For Darwin & Mingw32, external and weak symbols are indirect, so we want to
4385   // load the value at address GV, not the value of GV itself. This means that
4386   // the GlobalAddress must be in the base or index register of the address, not
4387   // the GV offset field. Platform check is inside GVRequiresExtraLoad() call
4388   // The same applies for external symbols during PIC codegen
4389   if (Subtarget->GVRequiresExtraLoad(GV, getTargetMachine(), false))
4390     Result = DAG.getLoad(getPointerTy(), DAG.getEntryNode(), Result,
4391                          PseudoSourceValue::getGOT(), 0);
4392
4393   return Result;
4394 }
4395
4396 SDValue
4397 X86TargetLowering::LowerGlobalAddress(SDValue Op, SelectionDAG &DAG) {
4398   const GlobalValue *GV = cast<GlobalAddressSDNode>(Op)->getGlobal();
4399   return LowerGlobalAddress(GV, DAG);
4400 }
4401
4402 // Lower ISD::GlobalTLSAddress using the "general dynamic" model, 32 bit
4403 static SDValue
4404 LowerToTLSGeneralDynamicModel32(GlobalAddressSDNode *GA, SelectionDAG &DAG,
4405                                 const MVT PtrVT) {
4406   SDValue InFlag;
4407   SDValue Chain = DAG.getCopyToReg(DAG.getEntryNode(), X86::EBX,
4408                                      DAG.getNode(X86ISD::GlobalBaseReg,
4409                                                  PtrVT), InFlag);
4410   InFlag = Chain.getValue(1);
4411
4412   // emit leal symbol@TLSGD(,%ebx,1), %eax
4413   SDVTList NodeTys = DAG.getVTList(PtrVT, MVT::Other, MVT::Flag);
4414   SDValue TGA = DAG.getTargetGlobalAddress(GA->getGlobal(),
4415                                              GA->getValueType(0),
4416                                              GA->getOffset());
4417   SDValue Ops[] = { Chain,  TGA, InFlag };
4418   SDValue Result = DAG.getNode(X86ISD::TLSADDR, NodeTys, Ops, 3);
4419   InFlag = Result.getValue(2);
4420   Chain = Result.getValue(1);
4421
4422   // call ___tls_get_addr. This function receives its argument in
4423   // the register EAX.
4424   Chain = DAG.getCopyToReg(Chain, X86::EAX, Result, InFlag);
4425   InFlag = Chain.getValue(1);
4426
4427   NodeTys = DAG.getVTList(MVT::Other, MVT::Flag);
4428   SDValue Ops1[] = { Chain,
4429                       DAG.getTargetExternalSymbol("___tls_get_addr",
4430                                                   PtrVT),
4431                       DAG.getRegister(X86::EAX, PtrVT),
4432                       DAG.getRegister(X86::EBX, PtrVT),
4433                       InFlag };
4434   Chain = DAG.getNode(X86ISD::CALL, NodeTys, Ops1, 5);
4435   InFlag = Chain.getValue(1);
4436
4437   return DAG.getCopyFromReg(Chain, X86::EAX, PtrVT, InFlag);
4438 }
4439
4440 // Lower ISD::GlobalTLSAddress using the "general dynamic" model, 64 bit
4441 static SDValue
4442 LowerToTLSGeneralDynamicModel64(GlobalAddressSDNode *GA, SelectionDAG &DAG,
4443                                 const MVT PtrVT) {
4444   SDValue InFlag, Chain;
4445
4446   // emit leaq symbol@TLSGD(%rip), %rdi
4447   SDVTList NodeTys = DAG.getVTList(PtrVT, MVT::Other, MVT::Flag);
4448   SDValue TGA = DAG.getTargetGlobalAddress(GA->getGlobal(),
4449                                              GA->getValueType(0),
4450                                              GA->getOffset());
4451   SDValue Ops[]  = { DAG.getEntryNode(), TGA};
4452   SDValue Result = DAG.getNode(X86ISD::TLSADDR, NodeTys, Ops, 2);
4453   Chain  = Result.getValue(1);
4454   InFlag = Result.getValue(2);
4455
4456   // call __tls_get_addr. This function receives its argument in
4457   // the register RDI.
4458   Chain = DAG.getCopyToReg(Chain, X86::RDI, Result, InFlag);
4459   InFlag = Chain.getValue(1);
4460
4461   NodeTys = DAG.getVTList(MVT::Other, MVT::Flag);
4462   SDValue Ops1[] = { Chain,
4463                       DAG.getTargetExternalSymbol("__tls_get_addr",
4464                                                   PtrVT),
4465                       DAG.getRegister(X86::RDI, PtrVT),
4466                       InFlag };
4467   Chain = DAG.getNode(X86ISD::CALL, NodeTys, Ops1, 4);
4468   InFlag = Chain.getValue(1);
4469
4470   return DAG.getCopyFromReg(Chain, X86::RAX, PtrVT, InFlag);
4471 }
4472
4473 // Lower ISD::GlobalTLSAddress using the "initial exec" (for no-pic) or
4474 // "local exec" model.
4475 static SDValue LowerToTLSExecModel(GlobalAddressSDNode *GA, SelectionDAG &DAG,
4476                                      const MVT PtrVT) {
4477   // Get the Thread Pointer
4478   SDValue ThreadPointer = DAG.getNode(X86ISD::THREAD_POINTER, PtrVT);
4479   // emit "addl x@ntpoff,%eax" (local exec) or "addl x@indntpoff,%eax" (initial
4480   // exec)
4481   SDValue TGA = DAG.getTargetGlobalAddress(GA->getGlobal(),
4482                                              GA->getValueType(0),
4483                                              GA->getOffset());
4484   SDValue Offset = DAG.getNode(X86ISD::Wrapper, PtrVT, TGA);
4485
4486   if (GA->getGlobal()->isDeclaration()) // initial exec TLS model
4487     Offset = DAG.getLoad(PtrVT, DAG.getEntryNode(), Offset,
4488                          PseudoSourceValue::getGOT(), 0);
4489
4490   // The address of the thread local variable is the add of the thread
4491   // pointer with the offset of the variable.
4492   return DAG.getNode(ISD::ADD, PtrVT, ThreadPointer, Offset);
4493 }
4494
4495 SDValue
4496 X86TargetLowering::LowerGlobalTLSAddress(SDValue Op, SelectionDAG &DAG) {
4497   // TODO: implement the "local dynamic" model
4498   // TODO: implement the "initial exec"model for pic executables
4499   assert(Subtarget->isTargetELF() &&
4500          "TLS not implemented for non-ELF targets");
4501   GlobalAddressSDNode *GA = cast<GlobalAddressSDNode>(Op);
4502   // If the relocation model is PIC, use the "General Dynamic" TLS Model,
4503   // otherwise use the "Local Exec"TLS Model
4504   if (Subtarget->is64Bit()) {
4505     return LowerToTLSGeneralDynamicModel64(GA, DAG, getPointerTy());
4506   } else {
4507     if (getTargetMachine().getRelocationModel() == Reloc::PIC_)
4508       return LowerToTLSGeneralDynamicModel32(GA, DAG, getPointerTy());
4509     else
4510       return LowerToTLSExecModel(GA, DAG, getPointerTy());
4511   }
4512 }
4513
4514 SDValue
4515 X86TargetLowering::LowerExternalSymbol(SDValue Op, SelectionDAG &DAG) {
4516   const char *Sym = cast<ExternalSymbolSDNode>(Op)->getSymbol();
4517   SDValue Result = DAG.getTargetExternalSymbol(Sym, getPointerTy());
4518   Result = DAG.getNode(X86ISD::Wrapper, getPointerTy(), Result);
4519   // With PIC, the address is actually $g + Offset.
4520   if (getTargetMachine().getRelocationModel() == Reloc::PIC_ &&
4521       !Subtarget->isPICStyleRIPRel()) {
4522     Result = DAG.getNode(ISD::ADD, getPointerTy(),
4523                          DAG.getNode(X86ISD::GlobalBaseReg, getPointerTy()),
4524                          Result);
4525   }
4526
4527   return Result;
4528 }
4529
4530 SDValue X86TargetLowering::LowerJumpTable(SDValue Op, SelectionDAG &DAG) {
4531   JumpTableSDNode *JT = cast<JumpTableSDNode>(Op);
4532   SDValue Result = DAG.getTargetJumpTable(JT->getIndex(), getPointerTy());
4533   Result = DAG.getNode(X86ISD::Wrapper, getPointerTy(), Result);
4534   // With PIC, the address is actually $g + Offset.
4535   if (getTargetMachine().getRelocationModel() == Reloc::PIC_ &&
4536       !Subtarget->isPICStyleRIPRel()) {
4537     Result = DAG.getNode(ISD::ADD, getPointerTy(),
4538                          DAG.getNode(X86ISD::GlobalBaseReg, getPointerTy()),
4539                          Result);
4540   }
4541
4542   return Result;
4543 }
4544
4545 /// LowerShift - Lower SRA_PARTS and friends, which return two i32 values and
4546 /// take a 2 x i32 value to shift plus a shift amount.
4547 SDValue X86TargetLowering::LowerShift(SDValue Op, SelectionDAG &DAG) {
4548   assert(Op.getNumOperands() == 3 && "Not a double-shift!");
4549   MVT VT = Op.getValueType();
4550   unsigned VTBits = VT.getSizeInBits();
4551   bool isSRA = Op.getOpcode() == ISD::SRA_PARTS;
4552   SDValue ShOpLo = Op.getOperand(0);
4553   SDValue ShOpHi = Op.getOperand(1);
4554   SDValue ShAmt  = Op.getOperand(2);
4555   SDValue Tmp1 = isSRA ?
4556     DAG.getNode(ISD::SRA, VT, ShOpHi, DAG.getConstant(VTBits - 1, MVT::i8)) :
4557     DAG.getConstant(0, VT);
4558
4559   SDValue Tmp2, Tmp3;
4560   if (Op.getOpcode() == ISD::SHL_PARTS) {
4561     Tmp2 = DAG.getNode(X86ISD::SHLD, VT, ShOpHi, ShOpLo, ShAmt);
4562     Tmp3 = DAG.getNode(ISD::SHL, VT, ShOpLo, ShAmt);
4563   } else {
4564     Tmp2 = DAG.getNode(X86ISD::SHRD, VT, ShOpLo, ShOpHi, ShAmt);
4565     Tmp3 = DAG.getNode(isSRA ? ISD::SRA : ISD::SRL, VT, ShOpHi, ShAmt);
4566   }
4567
4568   SDValue AndNode = DAG.getNode(ISD::AND, MVT::i8, ShAmt,
4569                                   DAG.getConstant(VTBits, MVT::i8));
4570   SDValue Cond = DAG.getNode(X86ISD::CMP, VT,
4571                                AndNode, DAG.getConstant(0, MVT::i8));
4572
4573   SDValue Hi, Lo;
4574   SDValue CC = DAG.getConstant(X86::COND_NE, MVT::i8);
4575   SDValue Ops0[4] = { Tmp2, Tmp3, CC, Cond };
4576   SDValue Ops1[4] = { Tmp3, Tmp1, CC, Cond };
4577
4578   if (Op.getOpcode() == ISD::SHL_PARTS) {
4579     Hi = DAG.getNode(X86ISD::CMOV, VT, Ops0, 4);
4580     Lo = DAG.getNode(X86ISD::CMOV, VT, Ops1, 4);
4581   } else {
4582     Lo = DAG.getNode(X86ISD::CMOV, VT, Ops0, 4);
4583     Hi = DAG.getNode(X86ISD::CMOV, VT, Ops1, 4);
4584   }
4585
4586   SDValue Ops[2] = { Lo, Hi };
4587   return DAG.getMergeValues(Ops, 2);
4588 }
4589
4590 SDValue X86TargetLowering::LowerSINT_TO_FP(SDValue Op, SelectionDAG &DAG) {
4591   MVT SrcVT = Op.getOperand(0).getValueType();
4592   assert(SrcVT.getSimpleVT() <= MVT::i64 && SrcVT.getSimpleVT() >= MVT::i16 &&
4593          "Unknown SINT_TO_FP to lower!");
4594
4595   // These are really Legal; caller falls through into that case.
4596   if (SrcVT == MVT::i32 && isScalarFPTypeInSSEReg(Op.getValueType()))
4597     return SDValue();
4598   if (SrcVT == MVT::i64 && Op.getValueType() != MVT::f80 &&
4599       Subtarget->is64Bit())
4600     return SDValue();
4601
4602   unsigned Size = SrcVT.getSizeInBits()/8;
4603   MachineFunction &MF = DAG.getMachineFunction();
4604   int SSFI = MF.getFrameInfo()->CreateStackObject(Size, Size);
4605   SDValue StackSlot = DAG.getFrameIndex(SSFI, getPointerTy());
4606   SDValue Chain = DAG.getStore(DAG.getEntryNode(), Op.getOperand(0),
4607                                  StackSlot,
4608                                  PseudoSourceValue::getFixedStack(SSFI), 0);
4609
4610   // Build the FILD
4611   SDVTList Tys;
4612   bool useSSE = isScalarFPTypeInSSEReg(Op.getValueType());
4613   if (useSSE)
4614     Tys = DAG.getVTList(MVT::f64, MVT::Other, MVT::Flag);
4615   else
4616     Tys = DAG.getVTList(Op.getValueType(), MVT::Other);
4617   SmallVector<SDValue, 8> Ops;
4618   Ops.push_back(Chain);
4619   Ops.push_back(StackSlot);
4620   Ops.push_back(DAG.getValueType(SrcVT));
4621   SDValue Result = DAG.getNode(useSSE ? X86ISD::FILD_FLAG : X86ISD::FILD,
4622                                  Tys, &Ops[0], Ops.size());
4623
4624   if (useSSE) {
4625     Chain = Result.getValue(1);
4626     SDValue InFlag = Result.getValue(2);
4627
4628     // FIXME: Currently the FST is flagged to the FILD_FLAG. This
4629     // shouldn't be necessary except that RFP cannot be live across
4630     // multiple blocks. When stackifier is fixed, they can be uncoupled.
4631     MachineFunction &MF = DAG.getMachineFunction();
4632     int SSFI = MF.getFrameInfo()->CreateStackObject(8, 8);
4633     SDValue StackSlot = DAG.getFrameIndex(SSFI, getPointerTy());
4634     Tys = DAG.getVTList(MVT::Other);
4635     SmallVector<SDValue, 8> Ops;
4636     Ops.push_back(Chain);
4637     Ops.push_back(Result);
4638     Ops.push_back(StackSlot);
4639     Ops.push_back(DAG.getValueType(Op.getValueType()));
4640     Ops.push_back(InFlag);
4641     Chain = DAG.getNode(X86ISD::FST, Tys, &Ops[0], Ops.size());
4642     Result = DAG.getLoad(Op.getValueType(), Chain, StackSlot,
4643                          PseudoSourceValue::getFixedStack(SSFI), 0);
4644   }
4645
4646   return Result;
4647 }
4648
4649 std::pair<SDValue,SDValue> X86TargetLowering::
4650 FP_TO_SINTHelper(SDValue Op, SelectionDAG &DAG) {
4651   assert(Op.getValueType().getSimpleVT() <= MVT::i64 &&
4652          Op.getValueType().getSimpleVT() >= MVT::i16 &&
4653          "Unknown FP_TO_SINT to lower!");
4654
4655   // These are really Legal.
4656   if (Op.getValueType() == MVT::i32 &&
4657       isScalarFPTypeInSSEReg(Op.getOperand(0).getValueType()))
4658     return std::make_pair(SDValue(), SDValue());
4659   if (Subtarget->is64Bit() &&
4660       Op.getValueType() == MVT::i64 &&
4661       Op.getOperand(0).getValueType() != MVT::f80)
4662     return std::make_pair(SDValue(), SDValue());
4663
4664   // We lower FP->sint64 into FISTP64, followed by a load, all to a temporary
4665   // stack slot.
4666   MachineFunction &MF = DAG.getMachineFunction();
4667   unsigned MemSize = Op.getValueType().getSizeInBits()/8;
4668   int SSFI = MF.getFrameInfo()->CreateStackObject(MemSize, MemSize);
4669   SDValue StackSlot = DAG.getFrameIndex(SSFI, getPointerTy());
4670   unsigned Opc;
4671   switch (Op.getValueType().getSimpleVT()) {
4672   default: assert(0 && "Invalid FP_TO_SINT to lower!");
4673   case MVT::i16: Opc = X86ISD::FP_TO_INT16_IN_MEM; break;
4674   case MVT::i32: Opc = X86ISD::FP_TO_INT32_IN_MEM; break;
4675   case MVT::i64: Opc = X86ISD::FP_TO_INT64_IN_MEM; break;
4676   }
4677
4678   SDValue Chain = DAG.getEntryNode();
4679   SDValue Value = Op.getOperand(0);
4680   if (isScalarFPTypeInSSEReg(Op.getOperand(0).getValueType())) {
4681     assert(Op.getValueType() == MVT::i64 && "Invalid FP_TO_SINT to lower!");
4682     Chain = DAG.getStore(Chain, Value, StackSlot,
4683                          PseudoSourceValue::getFixedStack(SSFI), 0);
4684     SDVTList Tys = DAG.getVTList(Op.getOperand(0).getValueType(), MVT::Other);
4685     SDValue Ops[] = {
4686       Chain, StackSlot, DAG.getValueType(Op.getOperand(0).getValueType())
4687     };
4688     Value = DAG.getNode(X86ISD::FLD, Tys, Ops, 3);
4689     Chain = Value.getValue(1);
4690     SSFI = MF.getFrameInfo()->CreateStackObject(MemSize, MemSize);
4691     StackSlot = DAG.getFrameIndex(SSFI, getPointerTy());
4692   }
4693
4694   // Build the FP_TO_INT*_IN_MEM
4695   SDValue Ops[] = { Chain, Value, StackSlot };
4696   SDValue FIST = DAG.getNode(Opc, MVT::Other, Ops, 3);
4697
4698   return std::make_pair(FIST, StackSlot);
4699 }
4700
4701 SDValue X86TargetLowering::LowerFP_TO_SINT(SDValue Op, SelectionDAG &DAG) {
4702   std::pair<SDValue,SDValue> Vals = FP_TO_SINTHelper(Op, DAG);
4703   SDValue FIST = Vals.first, StackSlot = Vals.second;
4704   if (FIST.getNode() == 0) return SDValue();
4705
4706   // Load the result.
4707   return DAG.getLoad(Op.getValueType(), FIST, StackSlot, NULL, 0);
4708 }
4709
4710 SDNode *X86TargetLowering::ExpandFP_TO_SINT(SDNode *N, SelectionDAG &DAG) {
4711   std::pair<SDValue,SDValue> Vals = FP_TO_SINTHelper(SDValue(N, 0), DAG);
4712   SDValue FIST = Vals.first, StackSlot = Vals.second;
4713   if (FIST.getNode() == 0) return 0;
4714
4715   MVT VT = N->getValueType(0);
4716
4717   // Return a load from the stack slot.
4718   SDValue Res = DAG.getLoad(VT, FIST, StackSlot, NULL, 0);
4719
4720   // Use MERGE_VALUES to drop the chain result value and get a node with one
4721   // result.  This requires turning off getMergeValues simplification, since
4722   // otherwise it will give us Res back.
4723   return DAG.getMergeValues(&Res, 1, false).getNode();
4724 }
4725
4726 SDValue X86TargetLowering::LowerFABS(SDValue Op, SelectionDAG &DAG) {
4727   MVT VT = Op.getValueType();
4728   MVT EltVT = VT;
4729   if (VT.isVector())
4730     EltVT = VT.getVectorElementType();
4731   std::vector<Constant*> CV;
4732   if (EltVT == MVT::f64) {
4733     Constant *C = ConstantFP::get(APFloat(APInt(64, ~(1ULL << 63))));
4734     CV.push_back(C);
4735     CV.push_back(C);
4736   } else {
4737     Constant *C = ConstantFP::get(APFloat(APInt(32, ~(1U << 31))));
4738     CV.push_back(C);
4739     CV.push_back(C);
4740     CV.push_back(C);
4741     CV.push_back(C);
4742   }
4743   Constant *C = ConstantVector::get(CV);
4744   SDValue CPIdx = DAG.getConstantPool(C, getPointerTy(), 4);
4745   SDValue Mask = DAG.getLoad(VT, DAG.getEntryNode(), CPIdx,
4746                                PseudoSourceValue::getConstantPool(), 0,
4747                                false, 16);
4748   return DAG.getNode(X86ISD::FAND, VT, Op.getOperand(0), Mask);
4749 }
4750
4751 SDValue X86TargetLowering::LowerFNEG(SDValue Op, SelectionDAG &DAG) {
4752   MVT VT = Op.getValueType();
4753   MVT EltVT = VT;
4754   unsigned EltNum = 1;
4755   if (VT.isVector()) {
4756     EltVT = VT.getVectorElementType();
4757     EltNum = VT.getVectorNumElements();
4758   }
4759   std::vector<Constant*> CV;
4760   if (EltVT == MVT::f64) {
4761     Constant *C = ConstantFP::get(APFloat(APInt(64, 1ULL << 63)));
4762     CV.push_back(C);
4763     CV.push_back(C);
4764   } else {
4765     Constant *C = ConstantFP::get(APFloat(APInt(32, 1U << 31)));
4766     CV.push_back(C);
4767     CV.push_back(C);
4768     CV.push_back(C);
4769     CV.push_back(C);
4770   }
4771   Constant *C = ConstantVector::get(CV);
4772   SDValue CPIdx = DAG.getConstantPool(C, getPointerTy(), 4);
4773   SDValue Mask = DAG.getLoad(VT, DAG.getEntryNode(), CPIdx,
4774                                PseudoSourceValue::getConstantPool(), 0,
4775                                false, 16);
4776   if (VT.isVector()) {
4777     return DAG.getNode(ISD::BIT_CONVERT, VT,
4778                        DAG.getNode(ISD::XOR, MVT::v2i64,
4779                     DAG.getNode(ISD::BIT_CONVERT, MVT::v2i64, Op.getOperand(0)),
4780                     DAG.getNode(ISD::BIT_CONVERT, MVT::v2i64, Mask)));
4781   } else {
4782     return DAG.getNode(X86ISD::FXOR, VT, Op.getOperand(0), Mask);
4783   }
4784 }
4785
4786 SDValue X86TargetLowering::LowerFCOPYSIGN(SDValue Op, SelectionDAG &DAG) {
4787   SDValue Op0 = Op.getOperand(0);
4788   SDValue Op1 = Op.getOperand(1);
4789   MVT VT = Op.getValueType();
4790   MVT SrcVT = Op1.getValueType();
4791
4792   // If second operand is smaller, extend it first.
4793   if (SrcVT.bitsLT(VT)) {
4794     Op1 = DAG.getNode(ISD::FP_EXTEND, VT, Op1);
4795     SrcVT = VT;
4796   }
4797   // And if it is bigger, shrink it first.
4798   if (SrcVT.bitsGT(VT)) {
4799     Op1 = DAG.getNode(ISD::FP_ROUND, VT, Op1, DAG.getIntPtrConstant(1));
4800     SrcVT = VT;
4801   }
4802
4803   // At this point the operands and the result should have the same
4804   // type, and that won't be f80 since that is not custom lowered.
4805
4806   // First get the sign bit of second operand.
4807   std::vector<Constant*> CV;
4808   if (SrcVT == MVT::f64) {
4809     CV.push_back(ConstantFP::get(APFloat(APInt(64, 1ULL << 63))));
4810     CV.push_back(ConstantFP::get(APFloat(APInt(64, 0))));
4811   } else {
4812     CV.push_back(ConstantFP::get(APFloat(APInt(32, 1U << 31))));
4813     CV.push_back(ConstantFP::get(APFloat(APInt(32, 0))));
4814     CV.push_back(ConstantFP::get(APFloat(APInt(32, 0))));
4815     CV.push_back(ConstantFP::get(APFloat(APInt(32, 0))));
4816   }
4817   Constant *C = ConstantVector::get(CV);
4818   SDValue CPIdx = DAG.getConstantPool(C, getPointerTy(), 4);
4819   SDValue Mask1 = DAG.getLoad(SrcVT, DAG.getEntryNode(), CPIdx,
4820                                 PseudoSourceValue::getConstantPool(), 0,
4821                                 false, 16);
4822   SDValue SignBit = DAG.getNode(X86ISD::FAND, SrcVT, Op1, Mask1);
4823
4824   // Shift sign bit right or left if the two operands have different types.
4825   if (SrcVT.bitsGT(VT)) {
4826     // Op0 is MVT::f32, Op1 is MVT::f64.
4827     SignBit = DAG.getNode(ISD::SCALAR_TO_VECTOR, MVT::v2f64, SignBit);
4828     SignBit = DAG.getNode(X86ISD::FSRL, MVT::v2f64, SignBit,
4829                           DAG.getConstant(32, MVT::i32));
4830     SignBit = DAG.getNode(ISD::BIT_CONVERT, MVT::v4f32, SignBit);
4831     SignBit = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, MVT::f32, SignBit,
4832                           DAG.getIntPtrConstant(0));
4833   }
4834
4835   // Clear first operand sign bit.
4836   CV.clear();
4837   if (VT == MVT::f64) {
4838     CV.push_back(ConstantFP::get(APFloat(APInt(64, ~(1ULL << 63)))));
4839     CV.push_back(ConstantFP::get(APFloat(APInt(64, 0))));
4840   } else {
4841     CV.push_back(ConstantFP::get(APFloat(APInt(32, ~(1U << 31)))));
4842     CV.push_back(ConstantFP::get(APFloat(APInt(32, 0))));
4843     CV.push_back(ConstantFP::get(APFloat(APInt(32, 0))));
4844     CV.push_back(ConstantFP::get(APFloat(APInt(32, 0))));
4845   }
4846   C = ConstantVector::get(CV);
4847   CPIdx = DAG.getConstantPool(C, getPointerTy(), 4);
4848   SDValue Mask2 = DAG.getLoad(VT, DAG.getEntryNode(), CPIdx,
4849                                 PseudoSourceValue::getConstantPool(), 0,
4850                                 false, 16);
4851   SDValue Val = DAG.getNode(X86ISD::FAND, VT, Op0, Mask2);
4852
4853   // Or the value with the sign bit.
4854   return DAG.getNode(X86ISD::FOR, VT, Val, SignBit);
4855 }
4856
4857 SDValue X86TargetLowering::LowerSETCC(SDValue Op, SelectionDAG &DAG) {
4858   assert(Op.getValueType() == MVT::i8 && "SetCC type must be 8-bit integer");
4859   SDValue Cond;
4860   SDValue Op0 = Op.getOperand(0);
4861   SDValue Op1 = Op.getOperand(1);
4862   SDValue CC = Op.getOperand(2);
4863   ISD::CondCode SetCCOpcode = cast<CondCodeSDNode>(CC)->get();
4864   bool isFP = Op.getOperand(1).getValueType().isFloatingPoint();
4865   unsigned X86CC;
4866
4867   if (translateX86CC(cast<CondCodeSDNode>(CC)->get(), isFP, X86CC,
4868                      Op0, Op1, DAG)) {
4869     Cond = DAG.getNode(X86ISD::CMP, MVT::i32, Op0, Op1);
4870     return DAG.getNode(X86ISD::SETCC, MVT::i8,
4871                        DAG.getConstant(X86CC, MVT::i8), Cond);
4872   }
4873
4874   assert(isFP && "Illegal integer SetCC!");
4875
4876   Cond = DAG.getNode(X86ISD::CMP, MVT::i32, Op0, Op1);
4877   switch (SetCCOpcode) {
4878   default: assert(false && "Illegal floating point SetCC!");
4879   case ISD::SETOEQ: {  // !PF & ZF
4880     SDValue Tmp1 = DAG.getNode(X86ISD::SETCC, MVT::i8,
4881                                  DAG.getConstant(X86::COND_NP, MVT::i8), Cond);
4882     SDValue Tmp2 = DAG.getNode(X86ISD::SETCC, MVT::i8,
4883                                  DAG.getConstant(X86::COND_E, MVT::i8), Cond);
4884     return DAG.getNode(ISD::AND, MVT::i8, Tmp1, Tmp2);
4885   }
4886   case ISD::SETUNE: {  // PF | !ZF
4887     SDValue Tmp1 = DAG.getNode(X86ISD::SETCC, MVT::i8,
4888                                  DAG.getConstant(X86::COND_P, MVT::i8), Cond);
4889     SDValue Tmp2 = DAG.getNode(X86ISD::SETCC, MVT::i8,
4890                                  DAG.getConstant(X86::COND_NE, MVT::i8), Cond);
4891     return DAG.getNode(ISD::OR, MVT::i8, Tmp1, Tmp2);
4892   }
4893   }
4894 }
4895
4896 SDValue X86TargetLowering::LowerVSETCC(SDValue Op, SelectionDAG &DAG) {
4897   SDValue Cond;
4898   SDValue Op0 = Op.getOperand(0);
4899   SDValue Op1 = Op.getOperand(1);
4900   SDValue CC = Op.getOperand(2);
4901   MVT VT = Op.getValueType();
4902   ISD::CondCode SetCCOpcode = cast<CondCodeSDNode>(CC)->get();
4903   bool isFP = Op.getOperand(1).getValueType().isFloatingPoint();
4904
4905   if (isFP) {
4906     unsigned SSECC = 8;
4907     MVT VT0 = Op0.getValueType();
4908     assert(VT0 == MVT::v4f32 || VT0 == MVT::v2f64);
4909     unsigned Opc = VT0 == MVT::v4f32 ? X86ISD::CMPPS : X86ISD::CMPPD;
4910     bool Swap = false;
4911
4912     switch (SetCCOpcode) {
4913     default: break;
4914     case ISD::SETOEQ:
4915     case ISD::SETEQ:  SSECC = 0; break;
4916     case ISD::SETOGT:
4917     case ISD::SETGT: Swap = true; // Fallthrough
4918     case ISD::SETLT:
4919     case ISD::SETOLT: SSECC = 1; break;
4920     case ISD::SETOGE:
4921     case ISD::SETGE: Swap = true; // Fallthrough
4922     case ISD::SETLE:
4923     case ISD::SETOLE: SSECC = 2; break;
4924     case ISD::SETUO:  SSECC = 3; break;
4925     case ISD::SETUNE:
4926     case ISD::SETNE:  SSECC = 4; break;
4927     case ISD::SETULE: Swap = true;
4928     case ISD::SETUGE: SSECC = 5; break;
4929     case ISD::SETULT: Swap = true;
4930     case ISD::SETUGT: SSECC = 6; break;
4931     case ISD::SETO:   SSECC = 7; break;
4932     }
4933     if (Swap)
4934       std::swap(Op0, Op1);
4935
4936     // In the two special cases we can't handle, emit two comparisons.
4937     if (SSECC == 8) {
4938       if (SetCCOpcode == ISD::SETUEQ) {
4939         SDValue UNORD, EQ;
4940         UNORD = DAG.getNode(Opc, VT, Op0, Op1, DAG.getConstant(3, MVT::i8));
4941         EQ = DAG.getNode(Opc, VT, Op0, Op1, DAG.getConstant(0, MVT::i8));
4942         return DAG.getNode(ISD::OR, VT, UNORD, EQ);
4943       }
4944       else if (SetCCOpcode == ISD::SETONE) {
4945         SDValue ORD, NEQ;
4946         ORD = DAG.getNode(Opc, VT, Op0, Op1, DAG.getConstant(7, MVT::i8));
4947         NEQ = DAG.getNode(Opc, VT, Op0, Op1, DAG.getConstant(4, MVT::i8));
4948         return DAG.getNode(ISD::AND, VT, ORD, NEQ);
4949       }
4950       assert(0 && "Illegal FP comparison");
4951     }
4952     // Handle all other FP comparisons here.
4953     return DAG.getNode(Opc, VT, Op0, Op1, DAG.getConstant(SSECC, MVT::i8));
4954   }
4955
4956   // We are handling one of the integer comparisons here.  Since SSE only has
4957   // GT and EQ comparisons for integer, swapping operands and multiple
4958   // operations may be required for some comparisons.
4959   unsigned Opc = 0, EQOpc = 0, GTOpc = 0;
4960   bool Swap = false, Invert = false, FlipSigns = false;
4961
4962   switch (VT.getSimpleVT()) {
4963   default: break;
4964   case MVT::v16i8: EQOpc = X86ISD::PCMPEQB; GTOpc = X86ISD::PCMPGTB; break;
4965   case MVT::v8i16: EQOpc = X86ISD::PCMPEQW; GTOpc = X86ISD::PCMPGTW; break;
4966   case MVT::v4i32: EQOpc = X86ISD::PCMPEQD; GTOpc = X86ISD::PCMPGTD; break;
4967   case MVT::v2i64: EQOpc = X86ISD::PCMPEQQ; GTOpc = X86ISD::PCMPGTQ; break;
4968   }
4969
4970   switch (SetCCOpcode) {
4971   default: break;
4972   case ISD::SETNE:  Invert = true;
4973   case ISD::SETEQ:  Opc = EQOpc; break;
4974   case ISD::SETLT:  Swap = true;
4975   case ISD::SETGT:  Opc = GTOpc; break;
4976   case ISD::SETGE:  Swap = true;
4977   case ISD::SETLE:  Opc = GTOpc; Invert = true; break;
4978   case ISD::SETULT: Swap = true;
4979   case ISD::SETUGT: Opc = GTOpc; FlipSigns = true; break;
4980   case ISD::SETUGE: Swap = true;
4981   case ISD::SETULE: Opc = GTOpc; FlipSigns = true; Invert = true; break;
4982   }
4983   if (Swap)
4984     std::swap(Op0, Op1);
4985
4986   // Since SSE has no unsigned integer comparisons, we need to flip  the sign
4987   // bits of the inputs before performing those operations.
4988   if (FlipSigns) {
4989     MVT EltVT = VT.getVectorElementType();
4990     SDValue SignBit = DAG.getConstant(EltVT.getIntegerVTSignBit(), EltVT);
4991     std::vector<SDValue> SignBits(VT.getVectorNumElements(), SignBit);
4992     SDValue SignVec = DAG.getNode(ISD::BUILD_VECTOR, VT, &SignBits[0],
4993                                     SignBits.size());
4994     Op0 = DAG.getNode(ISD::XOR, VT, Op0, SignVec);
4995     Op1 = DAG.getNode(ISD::XOR, VT, Op1, SignVec);
4996   }
4997
4998   SDValue Result = DAG.getNode(Opc, VT, Op0, Op1);
4999
5000   // If the logical-not of the result is required, perform that now.
5001   if (Invert) {
5002     MVT EltVT = VT.getVectorElementType();
5003     SDValue NegOne = DAG.getConstant(EltVT.getIntegerVTBitMask(), EltVT);
5004     std::vector<SDValue> NegOnes(VT.getVectorNumElements(), NegOne);
5005     SDValue NegOneV = DAG.getNode(ISD::BUILD_VECTOR, VT, &NegOnes[0],
5006                                     NegOnes.size());
5007     Result = DAG.getNode(ISD::XOR, VT, Result, NegOneV);
5008   }
5009   return Result;
5010 }
5011
5012 SDValue X86TargetLowering::LowerSELECT(SDValue Op, SelectionDAG &DAG) {
5013   bool addTest = true;
5014   SDValue Cond  = Op.getOperand(0);
5015   SDValue CC;
5016
5017   if (Cond.getOpcode() == ISD::SETCC)
5018     Cond = LowerSETCC(Cond, DAG);
5019
5020   // If condition flag is set by a X86ISD::CMP, then use it as the condition
5021   // setting operand in place of the X86ISD::SETCC.
5022   if (Cond.getOpcode() == X86ISD::SETCC) {
5023     CC = Cond.getOperand(0);
5024
5025     SDValue Cmp = Cond.getOperand(1);
5026     unsigned Opc = Cmp.getOpcode();
5027     MVT VT = Op.getValueType();
5028
5029     bool IllegalFPCMov = false;
5030     if (VT.isFloatingPoint() && !VT.isVector() &&
5031         !isScalarFPTypeInSSEReg(VT))  // FPStack?
5032       IllegalFPCMov = !hasFPCMov(cast<ConstantSDNode>(CC)->getSExtValue());
5033
5034     if ((Opc == X86ISD::CMP ||
5035          Opc == X86ISD::COMI ||
5036          Opc == X86ISD::UCOMI) && !IllegalFPCMov) {
5037       Cond = Cmp;
5038       addTest = false;
5039     }
5040   }
5041
5042   if (addTest) {
5043     CC = DAG.getConstant(X86::COND_NE, MVT::i8);
5044     Cond= DAG.getNode(X86ISD::CMP, MVT::i32, Cond, DAG.getConstant(0, MVT::i8));
5045   }
5046
5047   const MVT *VTs = DAG.getNodeValueTypes(Op.getValueType(),
5048                                                     MVT::Flag);
5049   SmallVector<SDValue, 4> Ops;
5050   // X86ISD::CMOV means set the result (which is operand 1) to the RHS if
5051   // condition is true.
5052   Ops.push_back(Op.getOperand(2));
5053   Ops.push_back(Op.getOperand(1));
5054   Ops.push_back(CC);
5055   Ops.push_back(Cond);
5056   return DAG.getNode(X86ISD::CMOV, VTs, 2, &Ops[0], Ops.size());
5057 }
5058
5059 SDValue X86TargetLowering::LowerBRCOND(SDValue Op, SelectionDAG &DAG) {
5060   bool addTest = true;
5061   SDValue Chain = Op.getOperand(0);
5062   SDValue Cond  = Op.getOperand(1);
5063   SDValue Dest  = Op.getOperand(2);
5064   SDValue CC;
5065
5066   if (Cond.getOpcode() == ISD::SETCC)
5067     Cond = LowerSETCC(Cond, DAG);
5068
5069   // If condition flag is set by a X86ISD::CMP, then use it as the condition
5070   // setting operand in place of the X86ISD::SETCC.
5071   if (Cond.getOpcode() == X86ISD::SETCC) {
5072     CC = Cond.getOperand(0);
5073
5074     SDValue Cmp = Cond.getOperand(1);
5075     unsigned Opc = Cmp.getOpcode();
5076     if (Opc == X86ISD::CMP ||
5077         Opc == X86ISD::COMI ||
5078         Opc == X86ISD::UCOMI) {
5079       Cond = Cmp;
5080       addTest = false;
5081     }
5082   }
5083
5084   if (addTest) {
5085     CC = DAG.getConstant(X86::COND_NE, MVT::i8);
5086     Cond= DAG.getNode(X86ISD::CMP, MVT::i32, Cond, DAG.getConstant(0, MVT::i8));
5087   }
5088   return DAG.getNode(X86ISD::BRCOND, Op.getValueType(),
5089                      Chain, Op.getOperand(2), CC, Cond);
5090 }
5091
5092
5093 // Lower dynamic stack allocation to _alloca call for Cygwin/Mingw targets.
5094 // Calls to _alloca is needed to probe the stack when allocating more than 4k
5095 // bytes in one go. Touching the stack at 4K increments is necessary to ensure
5096 // that the guard pages used by the OS virtual memory manager are allocated in
5097 // correct sequence.
5098 SDValue
5099 X86TargetLowering::LowerDYNAMIC_STACKALLOC(SDValue Op,
5100                                            SelectionDAG &DAG) {
5101   assert(Subtarget->isTargetCygMing() &&
5102          "This should be used only on Cygwin/Mingw targets");
5103
5104   // Get the inputs.
5105   SDValue Chain = Op.getOperand(0);
5106   SDValue Size  = Op.getOperand(1);
5107   // FIXME: Ensure alignment here
5108
5109   SDValue Flag;
5110
5111   MVT IntPtr = getPointerTy();
5112   MVT SPTy = Subtarget->is64Bit() ? MVT::i64 : MVT::i32;
5113
5114   Chain = DAG.getCALLSEQ_START(Chain, DAG.getIntPtrConstant(0));
5115
5116   Chain = DAG.getCopyToReg(Chain, X86::EAX, Size, Flag);
5117   Flag = Chain.getValue(1);
5118
5119   SDVTList  NodeTys = DAG.getVTList(MVT::Other, MVT::Flag);
5120   SDValue Ops[] = { Chain,
5121                       DAG.getTargetExternalSymbol("_alloca", IntPtr),
5122                       DAG.getRegister(X86::EAX, IntPtr),
5123                       DAG.getRegister(X86StackPtr, SPTy),
5124                       Flag };
5125   Chain = DAG.getNode(X86ISD::CALL, NodeTys, Ops, 5);
5126   Flag = Chain.getValue(1);
5127
5128   Chain = DAG.getCALLSEQ_END(Chain,
5129                              DAG.getIntPtrConstant(0),
5130                              DAG.getIntPtrConstant(0),
5131                              Flag);
5132
5133   Chain = DAG.getCopyFromReg(Chain, X86StackPtr, SPTy).getValue(1);
5134
5135   SDValue Ops1[2] = { Chain.getValue(0), Chain };
5136   return DAG.getMergeValues(Ops1, 2);
5137 }
5138
5139 SDValue
5140 X86TargetLowering::EmitTargetCodeForMemset(SelectionDAG &DAG,
5141                                            SDValue Chain,
5142                                            SDValue Dst, SDValue Src,
5143                                            SDValue Size, unsigned Align,
5144                                            const Value *DstSV,
5145                                            uint64_t DstSVOff) {
5146   ConstantSDNode *ConstantSize = dyn_cast<ConstantSDNode>(Size);
5147
5148   // If not DWORD aligned or size is more than the threshold, call the library.
5149   // The libc version is likely to be faster for these cases. It can use the
5150   // address value and run time information about the CPU.
5151   if ((Align & 3) != 0 ||
5152       !ConstantSize ||
5153       ConstantSize->getZExtValue() >
5154         getSubtarget()->getMaxInlineSizeThreshold()) {
5155     SDValue InFlag(0, 0);
5156
5157     // Check to see if there is a specialized entry-point for memory zeroing.
5158     ConstantSDNode *V = dyn_cast<ConstantSDNode>(Src);
5159
5160     if (const char *bzeroEntry =  V &&
5161         V->isNullValue() ? Subtarget->getBZeroEntry() : 0) {
5162       MVT IntPtr = getPointerTy();
5163       const Type *IntPtrTy = TD->getIntPtrType();
5164       TargetLowering::ArgListTy Args;
5165       TargetLowering::ArgListEntry Entry;
5166       Entry.Node = Dst;
5167       Entry.Ty = IntPtrTy;
5168       Args.push_back(Entry);
5169       Entry.Node = Size;
5170       Args.push_back(Entry);
5171       std::pair<SDValue,SDValue> CallResult =
5172         LowerCallTo(Chain, Type::VoidTy, false, false, false, false,
5173                     CallingConv::C, false,
5174                     DAG.getExternalSymbol(bzeroEntry, IntPtr), Args, DAG);
5175       return CallResult.second;
5176     }
5177
5178     // Otherwise have the target-independent code call memset.
5179     return SDValue();
5180   }
5181
5182   uint64_t SizeVal = ConstantSize->getZExtValue();
5183   SDValue InFlag(0, 0);
5184   MVT AVT;
5185   SDValue Count;
5186   ConstantSDNode *ValC = dyn_cast<ConstantSDNode>(Src);
5187   unsigned BytesLeft = 0;
5188   bool TwoRepStos = false;
5189   if (ValC) {
5190     unsigned ValReg;
5191     uint64_t Val = ValC->getZExtValue() & 255;
5192
5193     // If the value is a constant, then we can potentially use larger sets.
5194     switch (Align & 3) {
5195     case 2:   // WORD aligned
5196       AVT = MVT::i16;
5197       ValReg = X86::AX;
5198       Val = (Val << 8) | Val;
5199       break;
5200     case 0:  // DWORD aligned
5201       AVT = MVT::i32;
5202       ValReg = X86::EAX;
5203       Val = (Val << 8)  | Val;
5204       Val = (Val << 16) | Val;
5205       if (Subtarget->is64Bit() && ((Align & 0x7) == 0)) {  // QWORD aligned
5206         AVT = MVT::i64;
5207         ValReg = X86::RAX;
5208         Val = (Val << 32) | Val;
5209       }
5210       break;
5211     default:  // Byte aligned
5212       AVT = MVT::i8;
5213       ValReg = X86::AL;
5214       Count = DAG.getIntPtrConstant(SizeVal);
5215       break;
5216     }
5217
5218     if (AVT.bitsGT(MVT::i8)) {
5219       unsigned UBytes = AVT.getSizeInBits() / 8;
5220       Count = DAG.getIntPtrConstant(SizeVal / UBytes);
5221       BytesLeft = SizeVal % UBytes;
5222     }
5223
5224     Chain  = DAG.getCopyToReg(Chain, ValReg, DAG.getConstant(Val, AVT),
5225                               InFlag);
5226     InFlag = Chain.getValue(1);
5227   } else {
5228     AVT = MVT::i8;
5229     Count  = DAG.getIntPtrConstant(SizeVal);
5230     Chain  = DAG.getCopyToReg(Chain, X86::AL, Src, InFlag);
5231     InFlag = Chain.getValue(1);
5232   }
5233
5234   Chain  = DAG.getCopyToReg(Chain, Subtarget->is64Bit() ? X86::RCX : X86::ECX,
5235                             Count, InFlag);
5236   InFlag = Chain.getValue(1);
5237   Chain  = DAG.getCopyToReg(Chain, Subtarget->is64Bit() ? X86::RDI : X86::EDI,
5238                             Dst, InFlag);
5239   InFlag = Chain.getValue(1);
5240
5241   SDVTList Tys = DAG.getVTList(MVT::Other, MVT::Flag);
5242   SmallVector<SDValue, 8> Ops;
5243   Ops.push_back(Chain);
5244   Ops.push_back(DAG.getValueType(AVT));
5245   Ops.push_back(InFlag);
5246   Chain  = DAG.getNode(X86ISD::REP_STOS, Tys, &Ops[0], Ops.size());
5247
5248   if (TwoRepStos) {
5249     InFlag = Chain.getValue(1);
5250     Count  = Size;
5251     MVT CVT = Count.getValueType();
5252     SDValue Left = DAG.getNode(ISD::AND, CVT, Count,
5253                                DAG.getConstant((AVT == MVT::i64) ? 7 : 3, CVT));
5254     Chain  = DAG.getCopyToReg(Chain, (CVT == MVT::i64) ? X86::RCX : X86::ECX,
5255                               Left, InFlag);
5256     InFlag = Chain.getValue(1);
5257     Tys = DAG.getVTList(MVT::Other, MVT::Flag);
5258     Ops.clear();
5259     Ops.push_back(Chain);
5260     Ops.push_back(DAG.getValueType(MVT::i8));
5261     Ops.push_back(InFlag);
5262     Chain  = DAG.getNode(X86ISD::REP_STOS, Tys, &Ops[0], Ops.size());
5263   } else if (BytesLeft) {
5264     // Handle the last 1 - 7 bytes.
5265     unsigned Offset = SizeVal - BytesLeft;
5266     MVT AddrVT = Dst.getValueType();
5267     MVT SizeVT = Size.getValueType();
5268
5269     Chain = DAG.getMemset(Chain,
5270                           DAG.getNode(ISD::ADD, AddrVT, Dst,
5271                                       DAG.getConstant(Offset, AddrVT)),
5272                           Src,
5273                           DAG.getConstant(BytesLeft, SizeVT),
5274                           Align, DstSV, DstSVOff + Offset);
5275   }
5276
5277   // TODO: Use a Tokenfactor, as in memcpy, instead of a single chain.
5278   return Chain;
5279 }
5280
5281 SDValue
5282 X86TargetLowering::EmitTargetCodeForMemcpy(SelectionDAG &DAG,
5283                                       SDValue Chain, SDValue Dst, SDValue Src,
5284                                       SDValue Size, unsigned Align,
5285                                       bool AlwaysInline,
5286                                       const Value *DstSV, uint64_t DstSVOff,
5287                                       const Value *SrcSV, uint64_t SrcSVOff) {
5288   // This requires the copy size to be a constant, preferrably
5289   // within a subtarget-specific limit.
5290   ConstantSDNode *ConstantSize = dyn_cast<ConstantSDNode>(Size);
5291   if (!ConstantSize)
5292     return SDValue();
5293   uint64_t SizeVal = ConstantSize->getZExtValue();
5294   if (!AlwaysInline && SizeVal > getSubtarget()->getMaxInlineSizeThreshold())
5295     return SDValue();
5296
5297   /// If not DWORD aligned, call the library.
5298   if ((Align & 3) != 0)
5299     return SDValue();
5300
5301   // DWORD aligned
5302   MVT AVT = MVT::i32;
5303   if (Subtarget->is64Bit() && ((Align & 0x7) == 0))  // QWORD aligned
5304     AVT = MVT::i64;
5305
5306   unsigned UBytes = AVT.getSizeInBits() / 8;
5307   unsigned CountVal = SizeVal / UBytes;
5308   SDValue Count = DAG.getIntPtrConstant(CountVal);
5309   unsigned BytesLeft = SizeVal % UBytes;
5310
5311   SDValue InFlag(0, 0);
5312   Chain  = DAG.getCopyToReg(Chain, Subtarget->is64Bit() ? X86::RCX : X86::ECX,
5313                             Count, InFlag);
5314   InFlag = Chain.getValue(1);
5315   Chain  = DAG.getCopyToReg(Chain, Subtarget->is64Bit() ? X86::RDI : X86::EDI,
5316                             Dst, InFlag);
5317   InFlag = Chain.getValue(1);
5318   Chain  = DAG.getCopyToReg(Chain, Subtarget->is64Bit() ? X86::RSI : X86::ESI,
5319                             Src, InFlag);
5320   InFlag = Chain.getValue(1);
5321
5322   SDVTList Tys = DAG.getVTList(MVT::Other, MVT::Flag);
5323   SmallVector<SDValue, 8> Ops;
5324   Ops.push_back(Chain);
5325   Ops.push_back(DAG.getValueType(AVT));
5326   Ops.push_back(InFlag);
5327   SDValue RepMovs = DAG.getNode(X86ISD::REP_MOVS, Tys, &Ops[0], Ops.size());
5328
5329   SmallVector<SDValue, 4> Results;
5330   Results.push_back(RepMovs);
5331   if (BytesLeft) {
5332     // Handle the last 1 - 7 bytes.
5333     unsigned Offset = SizeVal - BytesLeft;
5334     MVT DstVT = Dst.getValueType();
5335     MVT SrcVT = Src.getValueType();
5336     MVT SizeVT = Size.getValueType();
5337     Results.push_back(DAG.getMemcpy(Chain,
5338                                     DAG.getNode(ISD::ADD, DstVT, Dst,
5339                                                 DAG.getConstant(Offset, DstVT)),
5340                                     DAG.getNode(ISD::ADD, SrcVT, Src,
5341                                                 DAG.getConstant(Offset, SrcVT)),
5342                                     DAG.getConstant(BytesLeft, SizeVT),
5343                                     Align, AlwaysInline,
5344                                     DstSV, DstSVOff + Offset,
5345                                     SrcSV, SrcSVOff + Offset));
5346   }
5347
5348   return DAG.getNode(ISD::TokenFactor, MVT::Other, &Results[0], Results.size());
5349 }
5350
5351 /// Expand the result of: i64,outchain = READCYCLECOUNTER inchain
5352 SDNode *X86TargetLowering::ExpandREADCYCLECOUNTER(SDNode *N, SelectionDAG &DAG){
5353   SDVTList Tys = DAG.getVTList(MVT::Other, MVT::Flag);
5354   SDValue TheChain = N->getOperand(0);
5355   SDValue rd = DAG.getNode(X86ISD::RDTSC_DAG, Tys, &TheChain, 1);
5356   if (Subtarget->is64Bit()) {
5357     SDValue rax = DAG.getCopyFromReg(rd, X86::RAX, MVT::i64, rd.getValue(1));
5358     SDValue rdx = DAG.getCopyFromReg(rax.getValue(1), X86::RDX,
5359                                        MVT::i64, rax.getValue(2));
5360     SDValue Tmp = DAG.getNode(ISD::SHL, MVT::i64, rdx,
5361                                 DAG.getConstant(32, MVT::i8));
5362     SDValue Ops[] = {
5363       DAG.getNode(ISD::OR, MVT::i64, rax, Tmp), rdx.getValue(1)
5364     };
5365
5366     return DAG.getMergeValues(Ops, 2).getNode();
5367   }
5368
5369   SDValue eax = DAG.getCopyFromReg(rd, X86::EAX, MVT::i32, rd.getValue(1));
5370   SDValue edx = DAG.getCopyFromReg(eax.getValue(1), X86::EDX,
5371                                        MVT::i32, eax.getValue(2));
5372   // Use a buildpair to merge the two 32-bit values into a 64-bit one.
5373   SDValue Ops[] = { eax, edx };
5374   Ops[0] = DAG.getNode(ISD::BUILD_PAIR, MVT::i64, Ops, 2);
5375
5376   // Use a MERGE_VALUES to return the value and chain.
5377   Ops[1] = edx.getValue(1);
5378   return DAG.getMergeValues(Ops, 2).getNode();
5379 }
5380
5381 SDValue X86TargetLowering::LowerVASTART(SDValue Op, SelectionDAG &DAG) {
5382   const Value *SV = cast<SrcValueSDNode>(Op.getOperand(2))->getValue();
5383
5384   if (!Subtarget->is64Bit()) {
5385     // vastart just stores the address of the VarArgsFrameIndex slot into the
5386     // memory location argument.
5387     SDValue FR = DAG.getFrameIndex(VarArgsFrameIndex, getPointerTy());
5388     return DAG.getStore(Op.getOperand(0), FR,Op.getOperand(1), SV, 0);
5389   }
5390
5391   // __va_list_tag:
5392   //   gp_offset         (0 - 6 * 8)
5393   //   fp_offset         (48 - 48 + 8 * 16)
5394   //   overflow_arg_area (point to parameters coming in memory).
5395   //   reg_save_area
5396   SmallVector<SDValue, 8> MemOps;
5397   SDValue FIN = Op.getOperand(1);
5398   // Store gp_offset
5399   SDValue Store = DAG.getStore(Op.getOperand(0),
5400                                  DAG.getConstant(VarArgsGPOffset, MVT::i32),
5401                                  FIN, SV, 0);
5402   MemOps.push_back(Store);
5403
5404   // Store fp_offset
5405   FIN = DAG.getNode(ISD::ADD, getPointerTy(), FIN, DAG.getIntPtrConstant(4));
5406   Store = DAG.getStore(Op.getOperand(0),
5407                        DAG.getConstant(VarArgsFPOffset, MVT::i32),
5408                        FIN, SV, 0);
5409   MemOps.push_back(Store);
5410
5411   // Store ptr to overflow_arg_area
5412   FIN = DAG.getNode(ISD::ADD, getPointerTy(), FIN, DAG.getIntPtrConstant(4));
5413   SDValue OVFIN = DAG.getFrameIndex(VarArgsFrameIndex, getPointerTy());
5414   Store = DAG.getStore(Op.getOperand(0), OVFIN, FIN, SV, 0);
5415   MemOps.push_back(Store);
5416
5417   // Store ptr to reg_save_area.
5418   FIN = DAG.getNode(ISD::ADD, getPointerTy(), FIN, DAG.getIntPtrConstant(8));
5419   SDValue RSFIN = DAG.getFrameIndex(RegSaveFrameIndex, getPointerTy());
5420   Store = DAG.getStore(Op.getOperand(0), RSFIN, FIN, SV, 0);
5421   MemOps.push_back(Store);
5422   return DAG.getNode(ISD::TokenFactor, MVT::Other, &MemOps[0], MemOps.size());
5423 }
5424
5425 SDValue X86TargetLowering::LowerVAARG(SDValue Op, SelectionDAG &DAG) {
5426   // X86-64 va_list is a struct { i32, i32, i8*, i8* }.
5427   assert(Subtarget->is64Bit() && "This code only handles 64-bit va_arg!");
5428   SDValue Chain = Op.getOperand(0);
5429   SDValue SrcPtr = Op.getOperand(1);
5430   SDValue SrcSV = Op.getOperand(2);
5431
5432   assert(0 && "VAArgInst is not yet implemented for x86-64!");
5433   abort();
5434   return SDValue();
5435 }
5436
5437 SDValue X86TargetLowering::LowerVACOPY(SDValue Op, SelectionDAG &DAG) {
5438   // X86-64 va_list is a struct { i32, i32, i8*, i8* }.
5439   assert(Subtarget->is64Bit() && "This code only handles 64-bit va_copy!");
5440   SDValue Chain = Op.getOperand(0);
5441   SDValue DstPtr = Op.getOperand(1);
5442   SDValue SrcPtr = Op.getOperand(2);
5443   const Value *DstSV = cast<SrcValueSDNode>(Op.getOperand(3))->getValue();
5444   const Value *SrcSV = cast<SrcValueSDNode>(Op.getOperand(4))->getValue();
5445
5446   return DAG.getMemcpy(Chain, DstPtr, SrcPtr,
5447                        DAG.getIntPtrConstant(24), 8, false,
5448                        DstSV, 0, SrcSV, 0);
5449 }
5450
5451 SDValue
5452 X86TargetLowering::LowerINTRINSIC_WO_CHAIN(SDValue Op, SelectionDAG &DAG) {
5453   unsigned IntNo = cast<ConstantSDNode>(Op.getOperand(0))->getZExtValue();
5454   switch (IntNo) {
5455   default: return SDValue();    // Don't custom lower most intrinsics.
5456   // Comparison intrinsics.
5457   case Intrinsic::x86_sse_comieq_ss:
5458   case Intrinsic::x86_sse_comilt_ss:
5459   case Intrinsic::x86_sse_comile_ss:
5460   case Intrinsic::x86_sse_comigt_ss:
5461   case Intrinsic::x86_sse_comige_ss:
5462   case Intrinsic::x86_sse_comineq_ss:
5463   case Intrinsic::x86_sse_ucomieq_ss:
5464   case Intrinsic::x86_sse_ucomilt_ss:
5465   case Intrinsic::x86_sse_ucomile_ss:
5466   case Intrinsic::x86_sse_ucomigt_ss:
5467   case Intrinsic::x86_sse_ucomige_ss:
5468   case Intrinsic::x86_sse_ucomineq_ss:
5469   case Intrinsic::x86_sse2_comieq_sd:
5470   case Intrinsic::x86_sse2_comilt_sd:
5471   case Intrinsic::x86_sse2_comile_sd:
5472   case Intrinsic::x86_sse2_comigt_sd:
5473   case Intrinsic::x86_sse2_comige_sd:
5474   case Intrinsic::x86_sse2_comineq_sd:
5475   case Intrinsic::x86_sse2_ucomieq_sd:
5476   case Intrinsic::x86_sse2_ucomilt_sd:
5477   case Intrinsic::x86_sse2_ucomile_sd:
5478   case Intrinsic::x86_sse2_ucomigt_sd:
5479   case Intrinsic::x86_sse2_ucomige_sd:
5480   case Intrinsic::x86_sse2_ucomineq_sd: {
5481     unsigned Opc = 0;
5482     ISD::CondCode CC = ISD::SETCC_INVALID;
5483     switch (IntNo) {
5484     default: break;
5485     case Intrinsic::x86_sse_comieq_ss:
5486     case Intrinsic::x86_sse2_comieq_sd:
5487       Opc = X86ISD::COMI;
5488       CC = ISD::SETEQ;
5489       break;
5490     case Intrinsic::x86_sse_comilt_ss:
5491     case Intrinsic::x86_sse2_comilt_sd:
5492       Opc = X86ISD::COMI;
5493       CC = ISD::SETLT;
5494       break;
5495     case Intrinsic::x86_sse_comile_ss:
5496     case Intrinsic::x86_sse2_comile_sd:
5497       Opc = X86ISD::COMI;
5498       CC = ISD::SETLE;
5499       break;
5500     case Intrinsic::x86_sse_comigt_ss:
5501     case Intrinsic::x86_sse2_comigt_sd:
5502       Opc = X86ISD::COMI;
5503       CC = ISD::SETGT;
5504       break;
5505     case Intrinsic::x86_sse_comige_ss:
5506     case Intrinsic::x86_sse2_comige_sd:
5507       Opc = X86ISD::COMI;
5508       CC = ISD::SETGE;
5509       break;
5510     case Intrinsic::x86_sse_comineq_ss:
5511     case Intrinsic::x86_sse2_comineq_sd:
5512       Opc = X86ISD::COMI;
5513       CC = ISD::SETNE;
5514       break;
5515     case Intrinsic::x86_sse_ucomieq_ss:
5516     case Intrinsic::x86_sse2_ucomieq_sd:
5517       Opc = X86ISD::UCOMI;
5518       CC = ISD::SETEQ;
5519       break;
5520     case Intrinsic::x86_sse_ucomilt_ss:
5521     case Intrinsic::x86_sse2_ucomilt_sd:
5522       Opc = X86ISD::UCOMI;
5523       CC = ISD::SETLT;
5524       break;
5525     case Intrinsic::x86_sse_ucomile_ss:
5526     case Intrinsic::x86_sse2_ucomile_sd:
5527       Opc = X86ISD::UCOMI;
5528       CC = ISD::SETLE;
5529       break;
5530     case Intrinsic::x86_sse_ucomigt_ss:
5531     case Intrinsic::x86_sse2_ucomigt_sd:
5532       Opc = X86ISD::UCOMI;
5533       CC = ISD::SETGT;
5534       break;
5535     case Intrinsic::x86_sse_ucomige_ss:
5536     case Intrinsic::x86_sse2_ucomige_sd:
5537       Opc = X86ISD::UCOMI;
5538       CC = ISD::SETGE;
5539       break;
5540     case Intrinsic::x86_sse_ucomineq_ss:
5541     case Intrinsic::x86_sse2_ucomineq_sd:
5542       Opc = X86ISD::UCOMI;
5543       CC = ISD::SETNE;
5544       break;
5545     }
5546
5547     unsigned X86CC;
5548     SDValue LHS = Op.getOperand(1);
5549     SDValue RHS = Op.getOperand(2);
5550     translateX86CC(CC, true, X86CC, LHS, RHS, DAG);
5551
5552     SDValue Cond = DAG.getNode(Opc, MVT::i32, LHS, RHS);
5553     SDValue SetCC = DAG.getNode(X86ISD::SETCC, MVT::i8,
5554                                 DAG.getConstant(X86CC, MVT::i8), Cond);
5555     return DAG.getNode(ISD::ZERO_EXTEND, MVT::i32, SetCC);
5556   }
5557
5558   // Fix vector shift instructions where the last operand is a non-immediate
5559   // i32 value.
5560   case Intrinsic::x86_sse2_pslli_w:
5561   case Intrinsic::x86_sse2_pslli_d:
5562   case Intrinsic::x86_sse2_pslli_q:
5563   case Intrinsic::x86_sse2_psrli_w:
5564   case Intrinsic::x86_sse2_psrli_d:
5565   case Intrinsic::x86_sse2_psrli_q:
5566   case Intrinsic::x86_sse2_psrai_w:
5567   case Intrinsic::x86_sse2_psrai_d:
5568   case Intrinsic::x86_mmx_pslli_w:
5569   case Intrinsic::x86_mmx_pslli_d:
5570   case Intrinsic::x86_mmx_pslli_q:
5571   case Intrinsic::x86_mmx_psrli_w:
5572   case Intrinsic::x86_mmx_psrli_d:
5573   case Intrinsic::x86_mmx_psrli_q:
5574   case Intrinsic::x86_mmx_psrai_w:
5575   case Intrinsic::x86_mmx_psrai_d: {
5576     SDValue ShAmt = Op.getOperand(2);
5577     if (isa<ConstantSDNode>(ShAmt))
5578       return SDValue();
5579
5580     unsigned NewIntNo = 0;
5581     MVT ShAmtVT = MVT::v4i32;
5582     switch (IntNo) {
5583     case Intrinsic::x86_sse2_pslli_w:
5584       NewIntNo = Intrinsic::x86_sse2_psll_w;
5585       break;
5586     case Intrinsic::x86_sse2_pslli_d:
5587       NewIntNo = Intrinsic::x86_sse2_psll_d;
5588       break;
5589     case Intrinsic::x86_sse2_pslli_q:
5590       NewIntNo = Intrinsic::x86_sse2_psll_q;
5591       break;
5592     case Intrinsic::x86_sse2_psrli_w:
5593       NewIntNo = Intrinsic::x86_sse2_psrl_w;
5594       break;
5595     case Intrinsic::x86_sse2_psrli_d:
5596       NewIntNo = Intrinsic::x86_sse2_psrl_d;
5597       break;
5598     case Intrinsic::x86_sse2_psrli_q:
5599       NewIntNo = Intrinsic::x86_sse2_psrl_q;
5600       break;
5601     case Intrinsic::x86_sse2_psrai_w:
5602       NewIntNo = Intrinsic::x86_sse2_psra_w;
5603       break;
5604     case Intrinsic::x86_sse2_psrai_d:
5605       NewIntNo = Intrinsic::x86_sse2_psra_d;
5606       break;
5607     default: {
5608       ShAmtVT = MVT::v2i32;
5609       switch (IntNo) {
5610       case Intrinsic::x86_mmx_pslli_w:
5611         NewIntNo = Intrinsic::x86_mmx_psll_w;
5612         break;
5613       case Intrinsic::x86_mmx_pslli_d:
5614         NewIntNo = Intrinsic::x86_mmx_psll_d;
5615         break;
5616       case Intrinsic::x86_mmx_pslli_q:
5617         NewIntNo = Intrinsic::x86_mmx_psll_q;
5618         break;
5619       case Intrinsic::x86_mmx_psrli_w:
5620         NewIntNo = Intrinsic::x86_mmx_psrl_w;
5621         break;
5622       case Intrinsic::x86_mmx_psrli_d:
5623         NewIntNo = Intrinsic::x86_mmx_psrl_d;
5624         break;
5625       case Intrinsic::x86_mmx_psrli_q:
5626         NewIntNo = Intrinsic::x86_mmx_psrl_q;
5627         break;
5628       case Intrinsic::x86_mmx_psrai_w:
5629         NewIntNo = Intrinsic::x86_mmx_psra_w;
5630         break;
5631       case Intrinsic::x86_mmx_psrai_d:
5632         NewIntNo = Intrinsic::x86_mmx_psra_d;
5633         break;
5634       default: abort();  // Can't reach here.
5635       }
5636       break;
5637     }
5638     }
5639     MVT VT = Op.getValueType();
5640     ShAmt = DAG.getNode(ISD::BIT_CONVERT, VT,
5641                         DAG.getNode(ISD::SCALAR_TO_VECTOR, ShAmtVT, ShAmt));
5642     return DAG.getNode(ISD::INTRINSIC_WO_CHAIN, VT,
5643                        DAG.getConstant(NewIntNo, MVT::i32),
5644                        Op.getOperand(1), ShAmt);
5645   }
5646   }
5647 }
5648
5649 SDValue X86TargetLowering::LowerRETURNADDR(SDValue Op, SelectionDAG &DAG) {
5650   // Depths > 0 not supported yet!
5651   if (cast<ConstantSDNode>(Op.getOperand(0))->getZExtValue() > 0)
5652     return SDValue();
5653
5654   // Just load the return address
5655   SDValue RetAddrFI = getReturnAddressFrameIndex(DAG);
5656   return DAG.getLoad(getPointerTy(), DAG.getEntryNode(), RetAddrFI, NULL, 0);
5657 }
5658
5659 SDValue X86TargetLowering::LowerFRAMEADDR(SDValue Op, SelectionDAG &DAG) {
5660   MachineFrameInfo *MFI = DAG.getMachineFunction().getFrameInfo();
5661   MFI->setFrameAddressIsTaken(true);
5662   MVT VT = Op.getValueType();
5663   unsigned Depth = cast<ConstantSDNode>(Op.getOperand(0))->getZExtValue();
5664   unsigned FrameReg = Subtarget->is64Bit() ? X86::RBP : X86::EBP;
5665   SDValue FrameAddr = DAG.getCopyFromReg(DAG.getEntryNode(), FrameReg, VT);
5666   while (Depth--)
5667     FrameAddr = DAG.getLoad(VT, DAG.getEntryNode(), FrameAddr, NULL, 0);
5668   return FrameAddr;
5669 }
5670
5671 SDValue X86TargetLowering::LowerFRAME_TO_ARGS_OFFSET(SDValue Op,
5672                                                      SelectionDAG &DAG) {
5673   return DAG.getIntPtrConstant(2*TD->getPointerSize());
5674 }
5675
5676 SDValue X86TargetLowering::LowerEH_RETURN(SDValue Op, SelectionDAG &DAG)
5677 {
5678   MachineFunction &MF = DAG.getMachineFunction();
5679   SDValue Chain     = Op.getOperand(0);
5680   SDValue Offset    = Op.getOperand(1);
5681   SDValue Handler   = Op.getOperand(2);
5682
5683   SDValue Frame = DAG.getRegister(Subtarget->is64Bit() ? X86::RBP : X86::EBP,
5684                                   getPointerTy());
5685   unsigned StoreAddrReg = (Subtarget->is64Bit() ? X86::RCX : X86::ECX);
5686
5687   SDValue StoreAddr = DAG.getNode(ISD::SUB, getPointerTy(), Frame,
5688                                   DAG.getIntPtrConstant(-TD->getPointerSize()));
5689   StoreAddr = DAG.getNode(ISD::ADD, getPointerTy(), StoreAddr, Offset);
5690   Chain = DAG.getStore(Chain, Handler, StoreAddr, NULL, 0);
5691   Chain = DAG.getCopyToReg(Chain, StoreAddrReg, StoreAddr);
5692   MF.getRegInfo().addLiveOut(StoreAddrReg);
5693
5694   return DAG.getNode(X86ISD::EH_RETURN,
5695                      MVT::Other,
5696                      Chain, DAG.getRegister(StoreAddrReg, getPointerTy()));
5697 }
5698
5699 SDValue X86TargetLowering::LowerTRAMPOLINE(SDValue Op,
5700                                              SelectionDAG &DAG) {
5701   SDValue Root = Op.getOperand(0);
5702   SDValue Trmp = Op.getOperand(1); // trampoline
5703   SDValue FPtr = Op.getOperand(2); // nested function
5704   SDValue Nest = Op.getOperand(3); // 'nest' parameter value
5705
5706   const Value *TrmpAddr = cast<SrcValueSDNode>(Op.getOperand(4))->getValue();
5707
5708   const X86InstrInfo *TII =
5709     ((X86TargetMachine&)getTargetMachine()).getInstrInfo();
5710
5711   if (Subtarget->is64Bit()) {
5712     SDValue OutChains[6];
5713
5714     // Large code-model.
5715
5716     const unsigned char JMP64r  = TII->getBaseOpcodeFor(X86::JMP64r);
5717     const unsigned char MOV64ri = TII->getBaseOpcodeFor(X86::MOV64ri);
5718
5719     const unsigned char N86R10 = RegInfo->getX86RegNum(X86::R10);
5720     const unsigned char N86R11 = RegInfo->getX86RegNum(X86::R11);
5721
5722     const unsigned char REX_WB = 0x40 | 0x08 | 0x01; // REX prefix
5723
5724     // Load the pointer to the nested function into R11.
5725     unsigned OpCode = ((MOV64ri | N86R11) << 8) | REX_WB; // movabsq r11
5726     SDValue Addr = Trmp;
5727     OutChains[0] = DAG.getStore(Root, DAG.getConstant(OpCode, MVT::i16), Addr,
5728                                 TrmpAddr, 0);
5729
5730     Addr = DAG.getNode(ISD::ADD, MVT::i64, Trmp, DAG.getConstant(2, MVT::i64));
5731     OutChains[1] = DAG.getStore(Root, FPtr, Addr, TrmpAddr, 2, false, 2);
5732
5733     // Load the 'nest' parameter value into R10.
5734     // R10 is specified in X86CallingConv.td
5735     OpCode = ((MOV64ri | N86R10) << 8) | REX_WB; // movabsq r10
5736     Addr = DAG.getNode(ISD::ADD, MVT::i64, Trmp, DAG.getConstant(10, MVT::i64));
5737     OutChains[2] = DAG.getStore(Root, DAG.getConstant(OpCode, MVT::i16), Addr,
5738                                 TrmpAddr, 10);
5739
5740     Addr = DAG.getNode(ISD::ADD, MVT::i64, Trmp, DAG.getConstant(12, MVT::i64));
5741     OutChains[3] = DAG.getStore(Root, Nest, Addr, TrmpAddr, 12, false, 2);
5742
5743     // Jump to the nested function.
5744     OpCode = (JMP64r << 8) | REX_WB; // jmpq *...
5745     Addr = DAG.getNode(ISD::ADD, MVT::i64, Trmp, DAG.getConstant(20, MVT::i64));
5746     OutChains[4] = DAG.getStore(Root, DAG.getConstant(OpCode, MVT::i16), Addr,
5747                                 TrmpAddr, 20);
5748
5749     unsigned char ModRM = N86R11 | (4 << 3) | (3 << 6); // ...r11
5750     Addr = DAG.getNode(ISD::ADD, MVT::i64, Trmp, DAG.getConstant(22, MVT::i64));
5751     OutChains[5] = DAG.getStore(Root, DAG.getConstant(ModRM, MVT::i8), Addr,
5752                                 TrmpAddr, 22);
5753
5754     SDValue Ops[] =
5755       { Trmp, DAG.getNode(ISD::TokenFactor, MVT::Other, OutChains, 6) };
5756     return DAG.getMergeValues(Ops, 2);
5757   } else {
5758     const Function *Func =
5759       cast<Function>(cast<SrcValueSDNode>(Op.getOperand(5))->getValue());
5760     unsigned CC = Func->getCallingConv();
5761     unsigned NestReg;
5762
5763     switch (CC) {
5764     default:
5765       assert(0 && "Unsupported calling convention");
5766     case CallingConv::C:
5767     case CallingConv::X86_StdCall: {
5768       // Pass 'nest' parameter in ECX.
5769       // Must be kept in sync with X86CallingConv.td
5770       NestReg = X86::ECX;
5771
5772       // Check that ECX wasn't needed by an 'inreg' parameter.
5773       const FunctionType *FTy = Func->getFunctionType();
5774       const AttrListPtr &Attrs = Func->getAttributes();
5775
5776       if (!Attrs.isEmpty() && !Func->isVarArg()) {
5777         unsigned InRegCount = 0;
5778         unsigned Idx = 1;
5779
5780         for (FunctionType::param_iterator I = FTy->param_begin(),
5781              E = FTy->param_end(); I != E; ++I, ++Idx)
5782           if (Attrs.paramHasAttr(Idx, Attribute::InReg))
5783             // FIXME: should only count parameters that are lowered to integers.
5784             InRegCount += (TD->getTypeSizeInBits(*I) + 31) / 32;
5785
5786         if (InRegCount > 2) {
5787           cerr << "Nest register in use - reduce number of inreg parameters!\n";
5788           abort();
5789         }
5790       }
5791       break;
5792     }
5793     case CallingConv::X86_FastCall:
5794     case CallingConv::Fast:
5795       // Pass 'nest' parameter in EAX.
5796       // Must be kept in sync with X86CallingConv.td
5797       NestReg = X86::EAX;
5798       break;
5799     }
5800
5801     SDValue OutChains[4];
5802     SDValue Addr, Disp;
5803
5804     Addr = DAG.getNode(ISD::ADD, MVT::i32, Trmp, DAG.getConstant(10, MVT::i32));
5805     Disp = DAG.getNode(ISD::SUB, MVT::i32, FPtr, Addr);
5806
5807     const unsigned char MOV32ri = TII->getBaseOpcodeFor(X86::MOV32ri);
5808     const unsigned char N86Reg = RegInfo->getX86RegNum(NestReg);
5809     OutChains[0] = DAG.getStore(Root, DAG.getConstant(MOV32ri|N86Reg, MVT::i8),
5810                                 Trmp, TrmpAddr, 0);
5811
5812     Addr = DAG.getNode(ISD::ADD, MVT::i32, Trmp, DAG.getConstant(1, MVT::i32));
5813     OutChains[1] = DAG.getStore(Root, Nest, Addr, TrmpAddr, 1, false, 1);
5814
5815     const unsigned char JMP = TII->getBaseOpcodeFor(X86::JMP);
5816     Addr = DAG.getNode(ISD::ADD, MVT::i32, Trmp, DAG.getConstant(5, MVT::i32));
5817     OutChains[2] = DAG.getStore(Root, DAG.getConstant(JMP, MVT::i8), Addr,
5818                                 TrmpAddr, 5, false, 1);
5819
5820     Addr = DAG.getNode(ISD::ADD, MVT::i32, Trmp, DAG.getConstant(6, MVT::i32));
5821     OutChains[3] = DAG.getStore(Root, Disp, Addr, TrmpAddr, 6, false, 1);
5822
5823     SDValue Ops[] =
5824       { Trmp, DAG.getNode(ISD::TokenFactor, MVT::Other, OutChains, 4) };
5825     return DAG.getMergeValues(Ops, 2);
5826   }
5827 }
5828
5829 SDValue X86TargetLowering::LowerFLT_ROUNDS_(SDValue Op, SelectionDAG &DAG) {
5830   /*
5831    The rounding mode is in bits 11:10 of FPSR, and has the following
5832    settings:
5833      00 Round to nearest
5834      01 Round to -inf
5835      10 Round to +inf
5836      11 Round to 0
5837
5838   FLT_ROUNDS, on the other hand, expects the following:
5839     -1 Undefined
5840      0 Round to 0
5841      1 Round to nearest
5842      2 Round to +inf
5843      3 Round to -inf
5844
5845   To perform the conversion, we do:
5846     (((((FPSR & 0x800) >> 11) | ((FPSR & 0x400) >> 9)) + 1) & 3)
5847   */
5848
5849   MachineFunction &MF = DAG.getMachineFunction();
5850   const TargetMachine &TM = MF.getTarget();
5851   const TargetFrameInfo &TFI = *TM.getFrameInfo();
5852   unsigned StackAlignment = TFI.getStackAlignment();
5853   MVT VT = Op.getValueType();
5854
5855   // Save FP Control Word to stack slot
5856   int SSFI = MF.getFrameInfo()->CreateStackObject(2, StackAlignment);
5857   SDValue StackSlot = DAG.getFrameIndex(SSFI, getPointerTy());
5858
5859   SDValue Chain = DAG.getNode(X86ISD::FNSTCW16m, MVT::Other,
5860                               DAG.getEntryNode(), StackSlot);
5861
5862   // Load FP Control Word from stack slot
5863   SDValue CWD = DAG.getLoad(MVT::i16, Chain, StackSlot, NULL, 0);
5864
5865   // Transform as necessary
5866   SDValue CWD1 =
5867     DAG.getNode(ISD::SRL, MVT::i16,
5868                 DAG.getNode(ISD::AND, MVT::i16,
5869                             CWD, DAG.getConstant(0x800, MVT::i16)),
5870                 DAG.getConstant(11, MVT::i8));
5871   SDValue CWD2 =
5872     DAG.getNode(ISD::SRL, MVT::i16,
5873                 DAG.getNode(ISD::AND, MVT::i16,
5874                             CWD, DAG.getConstant(0x400, MVT::i16)),
5875                 DAG.getConstant(9, MVT::i8));
5876
5877   SDValue RetVal =
5878     DAG.getNode(ISD::AND, MVT::i16,
5879                 DAG.getNode(ISD::ADD, MVT::i16,
5880                             DAG.getNode(ISD::OR, MVT::i16, CWD1, CWD2),
5881                             DAG.getConstant(1, MVT::i16)),
5882                 DAG.getConstant(3, MVT::i16));
5883
5884
5885   return DAG.getNode((VT.getSizeInBits() < 16 ?
5886                       ISD::TRUNCATE : ISD::ZERO_EXTEND), VT, RetVal);
5887 }
5888
5889 SDValue X86TargetLowering::LowerCTLZ(SDValue Op, SelectionDAG &DAG) {
5890   MVT VT = Op.getValueType();
5891   MVT OpVT = VT;
5892   unsigned NumBits = VT.getSizeInBits();
5893
5894   Op = Op.getOperand(0);
5895   if (VT == MVT::i8) {
5896     // Zero extend to i32 since there is not an i8 bsr.
5897     OpVT = MVT::i32;
5898     Op = DAG.getNode(ISD::ZERO_EXTEND, OpVT, Op);
5899   }
5900
5901   // Issue a bsr (scan bits in reverse) which also sets EFLAGS.
5902   SDVTList VTs = DAG.getVTList(OpVT, MVT::i32);
5903   Op = DAG.getNode(X86ISD::BSR, VTs, Op);
5904
5905   // If src is zero (i.e. bsr sets ZF), returns NumBits.
5906   SmallVector<SDValue, 4> Ops;
5907   Ops.push_back(Op);
5908   Ops.push_back(DAG.getConstant(NumBits+NumBits-1, OpVT));
5909   Ops.push_back(DAG.getConstant(X86::COND_E, MVT::i8));
5910   Ops.push_back(Op.getValue(1));
5911   Op = DAG.getNode(X86ISD::CMOV, OpVT, &Ops[0], 4);
5912
5913   // Finally xor with NumBits-1.
5914   Op = DAG.getNode(ISD::XOR, OpVT, Op, DAG.getConstant(NumBits-1, OpVT));
5915
5916   if (VT == MVT::i8)
5917     Op = DAG.getNode(ISD::TRUNCATE, MVT::i8, Op);
5918   return Op;
5919 }
5920
5921 SDValue X86TargetLowering::LowerCTTZ(SDValue Op, SelectionDAG &DAG) {
5922   MVT VT = Op.getValueType();
5923   MVT OpVT = VT;
5924   unsigned NumBits = VT.getSizeInBits();
5925
5926   Op = Op.getOperand(0);
5927   if (VT == MVT::i8) {
5928     OpVT = MVT::i32;
5929     Op = DAG.getNode(ISD::ZERO_EXTEND, OpVT, Op);
5930   }
5931
5932   // Issue a bsf (scan bits forward) which also sets EFLAGS.
5933   SDVTList VTs = DAG.getVTList(OpVT, MVT::i32);
5934   Op = DAG.getNode(X86ISD::BSF, VTs, Op);
5935
5936   // If src is zero (i.e. bsf sets ZF), returns NumBits.
5937   SmallVector<SDValue, 4> Ops;
5938   Ops.push_back(Op);
5939   Ops.push_back(DAG.getConstant(NumBits, OpVT));
5940   Ops.push_back(DAG.getConstant(X86::COND_E, MVT::i8));
5941   Ops.push_back(Op.getValue(1));
5942   Op = DAG.getNode(X86ISD::CMOV, OpVT, &Ops[0], 4);
5943
5944   if (VT == MVT::i8)
5945     Op = DAG.getNode(ISD::TRUNCATE, MVT::i8, Op);
5946   return Op;
5947 }
5948
5949 SDValue X86TargetLowering::LowerCMP_SWAP(SDValue Op, SelectionDAG &DAG) {
5950   MVT T = Op.getValueType();
5951   unsigned Reg = 0;
5952   unsigned size = 0;
5953   switch(T.getSimpleVT()) {
5954   default:
5955     assert(false && "Invalid value type!");
5956   case MVT::i8:  Reg = X86::AL;  size = 1; break;
5957   case MVT::i16: Reg = X86::AX;  size = 2; break;
5958   case MVT::i32: Reg = X86::EAX; size = 4; break;
5959   case MVT::i64:
5960     if (Subtarget->is64Bit()) {
5961       Reg = X86::RAX; size = 8;
5962     } else //Should go away when LowerType stuff lands
5963       return SDValue(ExpandATOMIC_CMP_SWAP(Op.getNode(), DAG), 0);
5964     break;
5965   };
5966   SDValue cpIn = DAG.getCopyToReg(Op.getOperand(0), Reg,
5967                                     Op.getOperand(2), SDValue());
5968   SDValue Ops[] = { cpIn.getValue(0),
5969                     Op.getOperand(1),
5970                     Op.getOperand(3),
5971                     DAG.getTargetConstant(size, MVT::i8),
5972                     cpIn.getValue(1) };
5973   SDVTList Tys = DAG.getVTList(MVT::Other, MVT::Flag);
5974   SDValue Result = DAG.getNode(X86ISD::LCMPXCHG_DAG, Tys, Ops, 5);
5975   SDValue cpOut =
5976     DAG.getCopyFromReg(Result.getValue(0), Reg, T, Result.getValue(1));
5977   return cpOut;
5978 }
5979
5980 SDNode* X86TargetLowering::ExpandATOMIC_CMP_SWAP(SDNode* Op,
5981                                                  SelectionDAG &DAG) {
5982   MVT T = Op->getValueType(0);
5983   assert (T == MVT::i64 && "Only know how to expand i64 Cmp and Swap");
5984   SDValue cpInL, cpInH;
5985   cpInL = DAG.getNode(ISD::EXTRACT_ELEMENT, MVT::i32, Op->getOperand(2),
5986                       DAG.getConstant(0, MVT::i32));
5987   cpInH = DAG.getNode(ISD::EXTRACT_ELEMENT, MVT::i32, Op->getOperand(2),
5988                       DAG.getConstant(1, MVT::i32));
5989   cpInL = DAG.getCopyToReg(Op->getOperand(0), X86::EAX,
5990                            cpInL, SDValue());
5991   cpInH = DAG.getCopyToReg(cpInL.getValue(0), X86::EDX,
5992                            cpInH, cpInL.getValue(1));
5993   SDValue swapInL, swapInH;
5994   swapInL = DAG.getNode(ISD::EXTRACT_ELEMENT, MVT::i32, Op->getOperand(3),
5995                         DAG.getConstant(0, MVT::i32));
5996   swapInH = DAG.getNode(ISD::EXTRACT_ELEMENT, MVT::i32, Op->getOperand(3),
5997                         DAG.getConstant(1, MVT::i32));
5998   swapInL = DAG.getCopyToReg(cpInH.getValue(0), X86::EBX,
5999                              swapInL, cpInH.getValue(1));
6000   swapInH = DAG.getCopyToReg(swapInL.getValue(0), X86::ECX,
6001                              swapInH, swapInL.getValue(1));
6002   SDValue Ops[] = { swapInH.getValue(0),
6003                     Op->getOperand(1),
6004                     swapInH.getValue(1) };
6005   SDVTList Tys = DAG.getVTList(MVT::Other, MVT::Flag);
6006   SDValue Result = DAG.getNode(X86ISD::LCMPXCHG8_DAG, Tys, Ops, 3);
6007   SDValue cpOutL = DAG.getCopyFromReg(Result.getValue(0), X86::EAX, MVT::i32,
6008                                         Result.getValue(1));
6009   SDValue cpOutH = DAG.getCopyFromReg(cpOutL.getValue(1), X86::EDX, MVT::i32,
6010                                         cpOutL.getValue(2));
6011   SDValue OpsF[] = { cpOutL.getValue(0), cpOutH.getValue(0)};
6012   SDValue ResultVal = DAG.getNode(ISD::BUILD_PAIR, MVT::i64, OpsF, 2);
6013   SDValue Vals[2] = { ResultVal, cpOutH.getValue(1) };
6014   return DAG.getMergeValues(Vals, 2).getNode();
6015 }
6016
6017 SDValue X86TargetLowering::LowerATOMIC_BINARY_64(SDValue Op,
6018                                                  SelectionDAG &DAG,
6019                                                  unsigned NewOp) {
6020   SDNode *Node = Op.getNode();
6021   MVT T = Node->getValueType(0);
6022   assert (T == MVT::i64 && "Only know how to expand i64 atomics");
6023
6024   SDValue Chain = Node->getOperand(0);
6025   SDValue In1 = Node->getOperand(1);
6026   assert(Node->getOperand(2).getNode()->getOpcode()==ISD::BUILD_PAIR);
6027   SDValue In2L = Node->getOperand(2).getNode()->getOperand(0);
6028   SDValue In2H = Node->getOperand(2).getNode()->getOperand(1);
6029   // This is a generalized SDNode, not an AtomicSDNode, so it doesn't
6030   // have a MemOperand.  Pass the info through as a normal operand.
6031   SDValue LSI = DAG.getMemOperand(cast<MemSDNode>(Node)->getMemOperand());
6032   SDValue Ops[] = { Chain, In1, In2L, In2H, LSI };
6033   SDVTList Tys = DAG.getVTList(MVT::i32, MVT::i32, MVT::Other);
6034   SDValue Result = DAG.getNode(NewOp, Tys, Ops, 5);
6035   SDValue OpsF[] = { Result.getValue(0), Result.getValue(1)};
6036   SDValue ResultVal = DAG.getNode(ISD::BUILD_PAIR, MVT::i64, OpsF, 2);
6037   SDValue Vals[2] = { ResultVal, Result.getValue(2) };
6038   return SDValue(DAG.getMergeValues(Vals, 2).getNode(), 0);
6039 }
6040
6041 SDValue X86TargetLowering::LowerLOAD_SUB(SDValue Op, SelectionDAG &DAG) {
6042   SDNode *Node = Op.getNode();
6043   MVT T = Node->getValueType(0);
6044   SDValue negOp = DAG.getNode(ISD::SUB, T,
6045                                 DAG.getConstant(0, T), Node->getOperand(2));
6046   return DAG.getAtomic((Op.getOpcode()==ISD::ATOMIC_LOAD_SUB_8 ?
6047                                         ISD::ATOMIC_LOAD_ADD_8 :
6048                         Op.getOpcode()==ISD::ATOMIC_LOAD_SUB_16 ?
6049                                         ISD::ATOMIC_LOAD_ADD_16 :
6050                         Op.getOpcode()==ISD::ATOMIC_LOAD_SUB_32 ?
6051                                         ISD::ATOMIC_LOAD_ADD_32 :
6052                                         ISD::ATOMIC_LOAD_ADD_64),
6053                        Node->getOperand(0),
6054                        Node->getOperand(1), negOp,
6055                        cast<AtomicSDNode>(Node)->getSrcValue(),
6056                        cast<AtomicSDNode>(Node)->getAlignment());
6057 }
6058
6059 /// LowerOperation - Provide custom lowering hooks for some operations.
6060 ///
6061 SDValue X86TargetLowering::LowerOperation(SDValue Op, SelectionDAG &DAG) {
6062   switch (Op.getOpcode()) {
6063   default: assert(0 && "Should not custom lower this!");
6064   case ISD::ATOMIC_CMP_SWAP_8:
6065   case ISD::ATOMIC_CMP_SWAP_16:
6066   case ISD::ATOMIC_CMP_SWAP_32:
6067   case ISD::ATOMIC_CMP_SWAP_64: return LowerCMP_SWAP(Op,DAG);
6068   case ISD::ATOMIC_LOAD_SUB_8:
6069   case ISD::ATOMIC_LOAD_SUB_16:
6070   case ISD::ATOMIC_LOAD_SUB_32: return LowerLOAD_SUB(Op,DAG);
6071   case ISD::ATOMIC_LOAD_SUB_64: return (Subtarget->is64Bit()) ?
6072                                         LowerLOAD_SUB(Op,DAG) :
6073                                         LowerATOMIC_BINARY_64(Op,DAG,
6074                                         X86ISD::ATOMSUB64_DAG);
6075   case ISD::ATOMIC_LOAD_AND_64: return LowerATOMIC_BINARY_64(Op,DAG,
6076                                         X86ISD::ATOMAND64_DAG);
6077   case ISD::ATOMIC_LOAD_OR_64:  return LowerATOMIC_BINARY_64(Op, DAG,
6078                                         X86ISD::ATOMOR64_DAG);
6079   case ISD::ATOMIC_LOAD_XOR_64: return LowerATOMIC_BINARY_64(Op,DAG,
6080                                         X86ISD::ATOMXOR64_DAG);
6081   case ISD::ATOMIC_LOAD_NAND_64:return LowerATOMIC_BINARY_64(Op,DAG,
6082                                         X86ISD::ATOMNAND64_DAG);
6083   case ISD::ATOMIC_LOAD_ADD_64: return LowerATOMIC_BINARY_64(Op,DAG,
6084                                         X86ISD::ATOMADD64_DAG);
6085   case ISD::ATOMIC_SWAP_64:     return LowerATOMIC_BINARY_64(Op,DAG,
6086                                         X86ISD::ATOMSWAP64_DAG);
6087   case ISD::BUILD_VECTOR:       return LowerBUILD_VECTOR(Op, DAG);
6088   case ISD::VECTOR_SHUFFLE:     return LowerVECTOR_SHUFFLE(Op, DAG);
6089   case ISD::EXTRACT_VECTOR_ELT: return LowerEXTRACT_VECTOR_ELT(Op, DAG);
6090   case ISD::INSERT_VECTOR_ELT:  return LowerINSERT_VECTOR_ELT(Op, DAG);
6091   case ISD::SCALAR_TO_VECTOR:   return LowerSCALAR_TO_VECTOR(Op, DAG);
6092   case ISD::ConstantPool:       return LowerConstantPool(Op, DAG);
6093   case ISD::GlobalAddress:      return LowerGlobalAddress(Op, DAG);
6094   case ISD::GlobalTLSAddress:   return LowerGlobalTLSAddress(Op, DAG);
6095   case ISD::ExternalSymbol:     return LowerExternalSymbol(Op, DAG);
6096   case ISD::SHL_PARTS:
6097   case ISD::SRA_PARTS:
6098   case ISD::SRL_PARTS:          return LowerShift(Op, DAG);
6099   case ISD::SINT_TO_FP:         return LowerSINT_TO_FP(Op, DAG);
6100   case ISD::FP_TO_SINT:         return LowerFP_TO_SINT(Op, DAG);
6101   case ISD::FABS:               return LowerFABS(Op, DAG);
6102   case ISD::FNEG:               return LowerFNEG(Op, DAG);
6103   case ISD::FCOPYSIGN:          return LowerFCOPYSIGN(Op, DAG);
6104   case ISD::SETCC:              return LowerSETCC(Op, DAG);
6105   case ISD::VSETCC:             return LowerVSETCC(Op, DAG);
6106   case ISD::SELECT:             return LowerSELECT(Op, DAG);
6107   case ISD::BRCOND:             return LowerBRCOND(Op, DAG);
6108   case ISD::JumpTable:          return LowerJumpTable(Op, DAG);
6109   case ISD::CALL:               return LowerCALL(Op, DAG);
6110   case ISD::RET:                return LowerRET(Op, DAG);
6111   case ISD::FORMAL_ARGUMENTS:   return LowerFORMAL_ARGUMENTS(Op, DAG);
6112   case ISD::VASTART:            return LowerVASTART(Op, DAG);
6113   case ISD::VAARG:              return LowerVAARG(Op, DAG);
6114   case ISD::VACOPY:             return LowerVACOPY(Op, DAG);
6115   case ISD::INTRINSIC_WO_CHAIN: return LowerINTRINSIC_WO_CHAIN(Op, DAG);
6116   case ISD::RETURNADDR:         return LowerRETURNADDR(Op, DAG);
6117   case ISD::FRAMEADDR:          return LowerFRAMEADDR(Op, DAG);
6118   case ISD::FRAME_TO_ARGS_OFFSET:
6119                                 return LowerFRAME_TO_ARGS_OFFSET(Op, DAG);
6120   case ISD::DYNAMIC_STACKALLOC: return LowerDYNAMIC_STACKALLOC(Op, DAG);
6121   case ISD::EH_RETURN:          return LowerEH_RETURN(Op, DAG);
6122   case ISD::TRAMPOLINE:         return LowerTRAMPOLINE(Op, DAG);
6123   case ISD::FLT_ROUNDS_:        return LowerFLT_ROUNDS_(Op, DAG);
6124   case ISD::CTLZ:               return LowerCTLZ(Op, DAG);
6125   case ISD::CTTZ:               return LowerCTTZ(Op, DAG);
6126
6127   // FIXME: REMOVE THIS WHEN LegalizeDAGTypes lands.
6128   case ISD::READCYCLECOUNTER:
6129     return SDValue(ExpandREADCYCLECOUNTER(Op.getNode(), DAG), 0);
6130   }
6131 }
6132
6133 /// ReplaceNodeResults - Replace a node with an illegal result type
6134 /// with a new node built out of custom code.
6135 SDNode *X86TargetLowering::ReplaceNodeResults(SDNode *N, SelectionDAG &DAG) {
6136   switch (N->getOpcode()) {
6137   default: assert(0 && "Should not custom lower this!");
6138   case ISD::FP_TO_SINT:         return ExpandFP_TO_SINT(N, DAG);
6139   case ISD::READCYCLECOUNTER:   return ExpandREADCYCLECOUNTER(N, DAG);
6140   case ISD::ATOMIC_CMP_SWAP_64: return ExpandATOMIC_CMP_SWAP(N, DAG);
6141   }
6142 }
6143
6144 const char *X86TargetLowering::getTargetNodeName(unsigned Opcode) const {
6145   switch (Opcode) {
6146   default: return NULL;
6147   case X86ISD::BSF:                return "X86ISD::BSF";
6148   case X86ISD::BSR:                return "X86ISD::BSR";
6149   case X86ISD::SHLD:               return "X86ISD::SHLD";
6150   case X86ISD::SHRD:               return "X86ISD::SHRD";
6151   case X86ISD::FAND:               return "X86ISD::FAND";
6152   case X86ISD::FOR:                return "X86ISD::FOR";
6153   case X86ISD::FXOR:               return "X86ISD::FXOR";
6154   case X86ISD::FSRL:               return "X86ISD::FSRL";
6155   case X86ISD::FILD:               return "X86ISD::FILD";
6156   case X86ISD::FILD_FLAG:          return "X86ISD::FILD_FLAG";
6157   case X86ISD::FP_TO_INT16_IN_MEM: return "X86ISD::FP_TO_INT16_IN_MEM";
6158   case X86ISD::FP_TO_INT32_IN_MEM: return "X86ISD::FP_TO_INT32_IN_MEM";
6159   case X86ISD::FP_TO_INT64_IN_MEM: return "X86ISD::FP_TO_INT64_IN_MEM";
6160   case X86ISD::FLD:                return "X86ISD::FLD";
6161   case X86ISD::FST:                return "X86ISD::FST";
6162   case X86ISD::CALL:               return "X86ISD::CALL";
6163   case X86ISD::TAILCALL:           return "X86ISD::TAILCALL";
6164   case X86ISD::RDTSC_DAG:          return "X86ISD::RDTSC_DAG";
6165   case X86ISD::CMP:                return "X86ISD::CMP";
6166   case X86ISD::COMI:               return "X86ISD::COMI";
6167   case X86ISD::UCOMI:              return "X86ISD::UCOMI";
6168   case X86ISD::SETCC:              return "X86ISD::SETCC";
6169   case X86ISD::CMOV:               return "X86ISD::CMOV";
6170   case X86ISD::BRCOND:             return "X86ISD::BRCOND";
6171   case X86ISD::RET_FLAG:           return "X86ISD::RET_FLAG";
6172   case X86ISD::REP_STOS:           return "X86ISD::REP_STOS";
6173   case X86ISD::REP_MOVS:           return "X86ISD::REP_MOVS";
6174   case X86ISD::GlobalBaseReg:      return "X86ISD::GlobalBaseReg";
6175   case X86ISD::Wrapper:            return "X86ISD::Wrapper";
6176   case X86ISD::PEXTRB:             return "X86ISD::PEXTRB";
6177   case X86ISD::PEXTRW:             return "X86ISD::PEXTRW";
6178   case X86ISD::INSERTPS:           return "X86ISD::INSERTPS";
6179   case X86ISD::PINSRB:             return "X86ISD::PINSRB";
6180   case X86ISD::PINSRW:             return "X86ISD::PINSRW";
6181   case X86ISD::FMAX:               return "X86ISD::FMAX";
6182   case X86ISD::FMIN:               return "X86ISD::FMIN";
6183   case X86ISD::FRSQRT:             return "X86ISD::FRSQRT";
6184   case X86ISD::FRCP:               return "X86ISD::FRCP";
6185   case X86ISD::TLSADDR:            return "X86ISD::TLSADDR";
6186   case X86ISD::THREAD_POINTER:     return "X86ISD::THREAD_POINTER";
6187   case X86ISD::EH_RETURN:          return "X86ISD::EH_RETURN";
6188   case X86ISD::TC_RETURN:          return "X86ISD::TC_RETURN";
6189   case X86ISD::FNSTCW16m:          return "X86ISD::FNSTCW16m";
6190   case X86ISD::LCMPXCHG_DAG:       return "X86ISD::LCMPXCHG_DAG";
6191   case X86ISD::LCMPXCHG8_DAG:      return "X86ISD::LCMPXCHG8_DAG";
6192   case X86ISD::ATOMADD64_DAG:      return "X86ISD::ATOMADD64_DAG";
6193   case X86ISD::ATOMSUB64_DAG:      return "X86ISD::ATOMSUB64_DAG";
6194   case X86ISD::ATOMOR64_DAG:       return "X86ISD::ATOMOR64_DAG";
6195   case X86ISD::ATOMXOR64_DAG:      return "X86ISD::ATOMXOR64_DAG";
6196   case X86ISD::ATOMAND64_DAG:      return "X86ISD::ATOMAND64_DAG";
6197   case X86ISD::ATOMNAND64_DAG:     return "X86ISD::ATOMNAND64_DAG";
6198   case X86ISD::VZEXT_MOVL:         return "X86ISD::VZEXT_MOVL";
6199   case X86ISD::VZEXT_LOAD:         return "X86ISD::VZEXT_LOAD";
6200   case X86ISD::VSHL:               return "X86ISD::VSHL";
6201   case X86ISD::VSRL:               return "X86ISD::VSRL";
6202   case X86ISD::CMPPD:              return "X86ISD::CMPPD";
6203   case X86ISD::CMPPS:              return "X86ISD::CMPPS";
6204   case X86ISD::PCMPEQB:            return "X86ISD::PCMPEQB";
6205   case X86ISD::PCMPEQW:            return "X86ISD::PCMPEQW";
6206   case X86ISD::PCMPEQD:            return "X86ISD::PCMPEQD";
6207   case X86ISD::PCMPEQQ:            return "X86ISD::PCMPEQQ";
6208   case X86ISD::PCMPGTB:            return "X86ISD::PCMPGTB";
6209   case X86ISD::PCMPGTW:            return "X86ISD::PCMPGTW";
6210   case X86ISD::PCMPGTD:            return "X86ISD::PCMPGTD";
6211   case X86ISD::PCMPGTQ:            return "X86ISD::PCMPGTQ";
6212   }
6213 }
6214
6215 // isLegalAddressingMode - Return true if the addressing mode represented
6216 // by AM is legal for this target, for a load/store of the specified type.
6217 bool X86TargetLowering::isLegalAddressingMode(const AddrMode &AM,
6218                                               const Type *Ty) const {
6219   // X86 supports extremely general addressing modes.
6220
6221   // X86 allows a sign-extended 32-bit immediate field as a displacement.
6222   if (AM.BaseOffs <= -(1LL << 32) || AM.BaseOffs >= (1LL << 32)-1)
6223     return false;
6224
6225   if (AM.BaseGV) {
6226     // We can only fold this if we don't need an extra load.
6227     if (Subtarget->GVRequiresExtraLoad(AM.BaseGV, getTargetMachine(), false))
6228       return false;
6229
6230     // X86-64 only supports addr of globals in small code model.
6231     if (Subtarget->is64Bit()) {
6232       if (getTargetMachine().getCodeModel() != CodeModel::Small)
6233         return false;
6234       // If lower 4G is not available, then we must use rip-relative addressing.
6235       if (AM.BaseOffs || AM.Scale > 1)
6236         return false;
6237     }
6238   }
6239
6240   switch (AM.Scale) {
6241   case 0:
6242   case 1:
6243   case 2:
6244   case 4:
6245   case 8:
6246     // These scales always work.
6247     break;
6248   case 3:
6249   case 5:
6250   case 9:
6251     // These scales are formed with basereg+scalereg.  Only accept if there is
6252     // no basereg yet.
6253     if (AM.HasBaseReg)
6254       return false;
6255     break;
6256   default:  // Other stuff never works.
6257     return false;
6258   }
6259
6260   return true;
6261 }
6262
6263
6264 bool X86TargetLowering::isTruncateFree(const Type *Ty1, const Type *Ty2) const {
6265   if (!Ty1->isInteger() || !Ty2->isInteger())
6266     return false;
6267   unsigned NumBits1 = Ty1->getPrimitiveSizeInBits();
6268   unsigned NumBits2 = Ty2->getPrimitiveSizeInBits();
6269   if (NumBits1 <= NumBits2)
6270     return false;
6271   return Subtarget->is64Bit() || NumBits1 < 64;
6272 }
6273
6274 bool X86TargetLowering::isTruncateFree(MVT VT1, MVT VT2) const {
6275   if (!VT1.isInteger() || !VT2.isInteger())
6276     return false;
6277   unsigned NumBits1 = VT1.getSizeInBits();
6278   unsigned NumBits2 = VT2.getSizeInBits();
6279   if (NumBits1 <= NumBits2)
6280     return false;
6281   return Subtarget->is64Bit() || NumBits1 < 64;
6282 }
6283
6284 /// isShuffleMaskLegal - Targets can use this to indicate that they only
6285 /// support *some* VECTOR_SHUFFLE operations, those with specific masks.
6286 /// By default, if a target supports the VECTOR_SHUFFLE node, all mask values
6287 /// are assumed to be legal.
6288 bool
6289 X86TargetLowering::isShuffleMaskLegal(SDValue Mask, MVT VT) const {
6290   // Only do shuffles on 128-bit vector types for now.
6291   if (VT.getSizeInBits() == 64) return false;
6292   return (Mask.getNode()->getNumOperands() <= 4 ||
6293           isIdentityMask(Mask.getNode()) ||
6294           isIdentityMask(Mask.getNode(), true) ||
6295           isSplatMask(Mask.getNode())  ||
6296           isPSHUFHW_PSHUFLWMask(Mask.getNode()) ||
6297           X86::isUNPCKLMask(Mask.getNode()) ||
6298           X86::isUNPCKHMask(Mask.getNode()) ||
6299           X86::isUNPCKL_v_undef_Mask(Mask.getNode()) ||
6300           X86::isUNPCKH_v_undef_Mask(Mask.getNode()));
6301 }
6302
6303 bool
6304 X86TargetLowering::isVectorClearMaskLegal(const std::vector<SDValue> &BVOps,
6305                                           MVT EVT, SelectionDAG &DAG) const {
6306   unsigned NumElts = BVOps.size();
6307   // Only do shuffles on 128-bit vector types for now.
6308   if (EVT.getSizeInBits() * NumElts == 64) return false;
6309   if (NumElts == 2) return true;
6310   if (NumElts == 4) {
6311     return (isMOVLMask(&BVOps[0], 4)  ||
6312             isCommutedMOVL(&BVOps[0], 4, true) ||
6313             isSHUFPMask(&BVOps[0], 4) ||
6314             isCommutedSHUFP(&BVOps[0], 4));
6315   }
6316   return false;
6317 }
6318
6319 //===----------------------------------------------------------------------===//
6320 //                           X86 Scheduler Hooks
6321 //===----------------------------------------------------------------------===//
6322
6323 // private utility function
6324 MachineBasicBlock *
6325 X86TargetLowering::EmitAtomicBitwiseWithCustomInserter(MachineInstr *bInstr,
6326                                                        MachineBasicBlock *MBB,
6327                                                        unsigned regOpc,
6328                                                        unsigned immOpc,
6329                                                        unsigned LoadOpc,
6330                                                        unsigned CXchgOpc,
6331                                                        unsigned copyOpc,
6332                                                        unsigned notOpc,
6333                                                        unsigned EAXreg,
6334                                                        TargetRegisterClass *RC,
6335                                                        bool invSrc) {
6336   // For the atomic bitwise operator, we generate
6337   //   thisMBB:
6338   //   newMBB:
6339   //     ld  t1 = [bitinstr.addr]
6340   //     op  t2 = t1, [bitinstr.val]
6341   //     mov EAX = t1
6342   //     lcs dest = [bitinstr.addr], t2  [EAX is implicit]
6343   //     bz  newMBB
6344   //     fallthrough -->nextMBB
6345   const TargetInstrInfo *TII = getTargetMachine().getInstrInfo();
6346   const BasicBlock *LLVM_BB = MBB->getBasicBlock();
6347   MachineFunction::iterator MBBIter = MBB;
6348   ++MBBIter;
6349
6350   /// First build the CFG
6351   MachineFunction *F = MBB->getParent();
6352   MachineBasicBlock *thisMBB = MBB;
6353   MachineBasicBlock *newMBB = F->CreateMachineBasicBlock(LLVM_BB);
6354   MachineBasicBlock *nextMBB = F->CreateMachineBasicBlock(LLVM_BB);
6355   F->insert(MBBIter, newMBB);
6356   F->insert(MBBIter, nextMBB);
6357
6358   // Move all successors to thisMBB to nextMBB
6359   nextMBB->transferSuccessors(thisMBB);
6360
6361   // Update thisMBB to fall through to newMBB
6362   thisMBB->addSuccessor(newMBB);
6363
6364   // newMBB jumps to itself and fall through to nextMBB
6365   newMBB->addSuccessor(nextMBB);
6366   newMBB->addSuccessor(newMBB);
6367
6368   // Insert instructions into newMBB based on incoming instruction
6369   assert(bInstr->getNumOperands() < 8 && "unexpected number of operands");
6370   MachineOperand& destOper = bInstr->getOperand(0);
6371   MachineOperand* argOpers[6];
6372   int numArgs = bInstr->getNumOperands() - 1;
6373   for (int i=0; i < numArgs; ++i)
6374     argOpers[i] = &bInstr->getOperand(i+1);
6375
6376   // x86 address has 4 operands: base, index, scale, and displacement
6377   int lastAddrIndx = 3; // [0,3]
6378   int valArgIndx = 4;
6379
6380   unsigned t1 = F->getRegInfo().createVirtualRegister(RC);
6381   MachineInstrBuilder MIB = BuildMI(newMBB, TII->get(LoadOpc), t1);
6382   for (int i=0; i <= lastAddrIndx; ++i)
6383     (*MIB).addOperand(*argOpers[i]);
6384
6385   unsigned tt = F->getRegInfo().createVirtualRegister(RC);
6386   if (invSrc) {
6387     MIB = BuildMI(newMBB, TII->get(notOpc), tt).addReg(t1);
6388   }
6389   else
6390     tt = t1;
6391
6392   unsigned t2 = F->getRegInfo().createVirtualRegister(RC);
6393   assert((argOpers[valArgIndx]->isReg() ||
6394           argOpers[valArgIndx]->isImm()) &&
6395          "invalid operand");
6396   if (argOpers[valArgIndx]->isReg())
6397     MIB = BuildMI(newMBB, TII->get(regOpc), t2);
6398   else
6399     MIB = BuildMI(newMBB, TII->get(immOpc), t2);
6400   MIB.addReg(tt);
6401   (*MIB).addOperand(*argOpers[valArgIndx]);
6402
6403   MIB = BuildMI(newMBB, TII->get(copyOpc), EAXreg);
6404   MIB.addReg(t1);
6405
6406   MIB = BuildMI(newMBB, TII->get(CXchgOpc));
6407   for (int i=0; i <= lastAddrIndx; ++i)
6408     (*MIB).addOperand(*argOpers[i]);
6409   MIB.addReg(t2);
6410   assert(bInstr->hasOneMemOperand() && "Unexpected number of memoperand");
6411   (*MIB).addMemOperand(*F, *bInstr->memoperands_begin());
6412
6413   MIB = BuildMI(newMBB, TII->get(copyOpc), destOper.getReg());
6414   MIB.addReg(EAXreg);
6415
6416   // insert branch
6417   BuildMI(newMBB, TII->get(X86::JNE)).addMBB(newMBB);
6418
6419   F->DeleteMachineInstr(bInstr);   // The pseudo instruction is gone now.
6420   return nextMBB;
6421 }
6422
6423 // private utility function:  64 bit atomics on 32 bit host.
6424 MachineBasicBlock *
6425 X86TargetLowering::EmitAtomicBit6432WithCustomInserter(MachineInstr *bInstr,
6426                                                        MachineBasicBlock *MBB,
6427                                                        unsigned regOpcL,
6428                                                        unsigned regOpcH,
6429                                                        unsigned immOpcL,
6430                                                        unsigned immOpcH,
6431                                                        bool invSrc) {
6432   // For the atomic bitwise operator, we generate
6433   //   thisMBB (instructions are in pairs, except cmpxchg8b)
6434   //     ld t1,t2 = [bitinstr.addr]
6435   //   newMBB:
6436   //     out1, out2 = phi (thisMBB, t1/t2) (newMBB, t3/t4)
6437   //     op  t5, t6 <- out1, out2, [bitinstr.val]
6438   //      (for SWAP, substitute:  mov t5, t6 <- [bitinstr.val])
6439   //     mov ECX, EBX <- t5, t6
6440   //     mov EAX, EDX <- t1, t2
6441   //     cmpxchg8b [bitinstr.addr]  [EAX, EDX, EBX, ECX implicit]
6442   //     mov t3, t4 <- EAX, EDX
6443   //     bz  newMBB
6444   //     result in out1, out2
6445   //     fallthrough -->nextMBB
6446
6447   const TargetRegisterClass *RC = X86::GR32RegisterClass;
6448   const unsigned LoadOpc = X86::MOV32rm;
6449   const unsigned copyOpc = X86::MOV32rr;
6450   const unsigned NotOpc = X86::NOT32r;
6451   const TargetInstrInfo *TII = getTargetMachine().getInstrInfo();
6452   const BasicBlock *LLVM_BB = MBB->getBasicBlock();
6453   MachineFunction::iterator MBBIter = MBB;
6454   ++MBBIter;
6455
6456   /// First build the CFG
6457   MachineFunction *F = MBB->getParent();
6458   MachineBasicBlock *thisMBB = MBB;
6459   MachineBasicBlock *newMBB = F->CreateMachineBasicBlock(LLVM_BB);
6460   MachineBasicBlock *nextMBB = F->CreateMachineBasicBlock(LLVM_BB);
6461   F->insert(MBBIter, newMBB);
6462   F->insert(MBBIter, nextMBB);
6463
6464   // Move all successors to thisMBB to nextMBB
6465   nextMBB->transferSuccessors(thisMBB);
6466
6467   // Update thisMBB to fall through to newMBB
6468   thisMBB->addSuccessor(newMBB);
6469
6470   // newMBB jumps to itself and fall through to nextMBB
6471   newMBB->addSuccessor(nextMBB);
6472   newMBB->addSuccessor(newMBB);
6473
6474   // Insert instructions into newMBB based on incoming instruction
6475   // There are 8 "real" operands plus 9 implicit def/uses, ignored here.
6476   assert(bInstr->getNumOperands() < 18 && "unexpected number of operands");
6477   MachineOperand& dest1Oper = bInstr->getOperand(0);
6478   MachineOperand& dest2Oper = bInstr->getOperand(1);
6479   MachineOperand* argOpers[6];
6480   for (int i=0; i < 6; ++i)
6481     argOpers[i] = &bInstr->getOperand(i+2);
6482
6483   // x86 address has 4 operands: base, index, scale, and displacement
6484   int lastAddrIndx = 3; // [0,3]
6485
6486   unsigned t1 = F->getRegInfo().createVirtualRegister(RC);
6487   MachineInstrBuilder MIB = BuildMI(thisMBB, TII->get(LoadOpc), t1);
6488   for (int i=0; i <= lastAddrIndx; ++i)
6489     (*MIB).addOperand(*argOpers[i]);
6490   unsigned t2 = F->getRegInfo().createVirtualRegister(RC);
6491   MIB = BuildMI(thisMBB, TII->get(LoadOpc), t2);
6492   // add 4 to displacement.
6493   for (int i=0; i <= lastAddrIndx-1; ++i)
6494     (*MIB).addOperand(*argOpers[i]);
6495   MachineOperand newOp3 = *(argOpers[3]);
6496   if (newOp3.isImm())
6497     newOp3.setImm(newOp3.getImm()+4);
6498   else
6499     newOp3.setOffset(newOp3.getOffset()+4);
6500   (*MIB).addOperand(newOp3);
6501
6502   // t3/4 are defined later, at the bottom of the loop
6503   unsigned t3 = F->getRegInfo().createVirtualRegister(RC);
6504   unsigned t4 = F->getRegInfo().createVirtualRegister(RC);
6505   BuildMI(newMBB, TII->get(X86::PHI), dest1Oper.getReg())
6506     .addReg(t1).addMBB(thisMBB).addReg(t3).addMBB(newMBB);
6507   BuildMI(newMBB, TII->get(X86::PHI), dest2Oper.getReg())
6508     .addReg(t2).addMBB(thisMBB).addReg(t4).addMBB(newMBB);
6509
6510   unsigned tt1 = F->getRegInfo().createVirtualRegister(RC);
6511   unsigned tt2 = F->getRegInfo().createVirtualRegister(RC);
6512   if (invSrc) {
6513     MIB = BuildMI(newMBB, TII->get(NotOpc), tt1).addReg(t1);
6514     MIB = BuildMI(newMBB, TII->get(NotOpc), tt2).addReg(t2);
6515   } else {
6516     tt1 = t1;
6517     tt2 = t2;
6518   }
6519
6520   assert((argOpers[4]->isReg() || argOpers[4]->isImm()) &&
6521          "invalid operand");
6522   unsigned t5 = F->getRegInfo().createVirtualRegister(RC);
6523   unsigned t6 = F->getRegInfo().createVirtualRegister(RC);
6524   if (argOpers[4]->isReg())
6525     MIB = BuildMI(newMBB, TII->get(regOpcL), t5);
6526   else
6527     MIB = BuildMI(newMBB, TII->get(immOpcL), t5);
6528   if (regOpcL != X86::MOV32rr)
6529     MIB.addReg(tt1);
6530   (*MIB).addOperand(*argOpers[4]);
6531   assert(argOpers[5]->isReg() == argOpers[4]->isReg());
6532   assert(argOpers[5]->isImm() == argOpers[4]->isImm());
6533   if (argOpers[5]->isReg())
6534     MIB = BuildMI(newMBB, TII->get(regOpcH), t6);
6535   else
6536     MIB = BuildMI(newMBB, TII->get(immOpcH), t6);
6537   if (regOpcH != X86::MOV32rr)
6538     MIB.addReg(tt2);
6539   (*MIB).addOperand(*argOpers[5]);
6540
6541   MIB = BuildMI(newMBB, TII->get(copyOpc), X86::EAX);
6542   MIB.addReg(t1);
6543   MIB = BuildMI(newMBB, TII->get(copyOpc), X86::EDX);
6544   MIB.addReg(t2);
6545
6546   MIB = BuildMI(newMBB, TII->get(copyOpc), X86::EBX);
6547   MIB.addReg(t5);
6548   MIB = BuildMI(newMBB, TII->get(copyOpc), X86::ECX);
6549   MIB.addReg(t6);
6550
6551   MIB = BuildMI(newMBB, TII->get(X86::LCMPXCHG8B));
6552   for (int i=0; i <= lastAddrIndx; ++i)
6553     (*MIB).addOperand(*argOpers[i]);
6554
6555   assert(bInstr->hasOneMemOperand() && "Unexpected number of memoperand");
6556   (*MIB).addMemOperand(*F, *bInstr->memoperands_begin());
6557
6558   MIB = BuildMI(newMBB, TII->get(copyOpc), t3);
6559   MIB.addReg(X86::EAX);
6560   MIB = BuildMI(newMBB, TII->get(copyOpc), t4);
6561   MIB.addReg(X86::EDX);
6562
6563   // insert branch
6564   BuildMI(newMBB, TII->get(X86::JNE)).addMBB(newMBB);
6565
6566   F->DeleteMachineInstr(bInstr);   // The pseudo instruction is gone now.
6567   return nextMBB;
6568 }
6569
6570 // private utility function
6571 MachineBasicBlock *
6572 X86TargetLowering::EmitAtomicMinMaxWithCustomInserter(MachineInstr *mInstr,
6573                                                       MachineBasicBlock *MBB,
6574                                                       unsigned cmovOpc) {
6575   // For the atomic min/max operator, we generate
6576   //   thisMBB:
6577   //   newMBB:
6578   //     ld t1 = [min/max.addr]
6579   //     mov t2 = [min/max.val]
6580   //     cmp  t1, t2
6581   //     cmov[cond] t2 = t1
6582   //     mov EAX = t1
6583   //     lcs dest = [bitinstr.addr], t2  [EAX is implicit]
6584   //     bz   newMBB
6585   //     fallthrough -->nextMBB
6586   //
6587   const TargetInstrInfo *TII = getTargetMachine().getInstrInfo();
6588   const BasicBlock *LLVM_BB = MBB->getBasicBlock();
6589   MachineFunction::iterator MBBIter = MBB;
6590   ++MBBIter;
6591
6592   /// First build the CFG
6593   MachineFunction *F = MBB->getParent();
6594   MachineBasicBlock *thisMBB = MBB;
6595   MachineBasicBlock *newMBB = F->CreateMachineBasicBlock(LLVM_BB);
6596   MachineBasicBlock *nextMBB = F->CreateMachineBasicBlock(LLVM_BB);
6597   F->insert(MBBIter, newMBB);
6598   F->insert(MBBIter, nextMBB);
6599
6600   // Move all successors to thisMBB to nextMBB
6601   nextMBB->transferSuccessors(thisMBB);
6602
6603   // Update thisMBB to fall through to newMBB
6604   thisMBB->addSuccessor(newMBB);
6605
6606   // newMBB jumps to newMBB and fall through to nextMBB
6607   newMBB->addSuccessor(nextMBB);
6608   newMBB->addSuccessor(newMBB);
6609
6610   // Insert instructions into newMBB based on incoming instruction
6611   assert(mInstr->getNumOperands() < 8 && "unexpected number of operands");
6612   MachineOperand& destOper = mInstr->getOperand(0);
6613   MachineOperand* argOpers[6];
6614   int numArgs = mInstr->getNumOperands() - 1;
6615   for (int i=0; i < numArgs; ++i)
6616     argOpers[i] = &mInstr->getOperand(i+1);
6617
6618   // x86 address has 4 operands: base, index, scale, and displacement
6619   int lastAddrIndx = 3; // [0,3]
6620   int valArgIndx = 4;
6621
6622   unsigned t1 = F->getRegInfo().createVirtualRegister(X86::GR32RegisterClass);
6623   MachineInstrBuilder MIB = BuildMI(newMBB, TII->get(X86::MOV32rm), t1);
6624   for (int i=0; i <= lastAddrIndx; ++i)
6625     (*MIB).addOperand(*argOpers[i]);
6626
6627   // We only support register and immediate values
6628   assert((argOpers[valArgIndx]->isReg() ||
6629           argOpers[valArgIndx]->isImm()) &&
6630          "invalid operand");
6631
6632   unsigned t2 = F->getRegInfo().createVirtualRegister(X86::GR32RegisterClass);
6633   if (argOpers[valArgIndx]->isReg())
6634     MIB = BuildMI(newMBB, TII->get(X86::MOV32rr), t2);
6635   else
6636     MIB = BuildMI(newMBB, TII->get(X86::MOV32rr), t2);
6637   (*MIB).addOperand(*argOpers[valArgIndx]);
6638
6639   MIB = BuildMI(newMBB, TII->get(X86::MOV32rr), X86::EAX);
6640   MIB.addReg(t1);
6641
6642   MIB = BuildMI(newMBB, TII->get(X86::CMP32rr));
6643   MIB.addReg(t1);
6644   MIB.addReg(t2);
6645
6646   // Generate movc
6647   unsigned t3 = F->getRegInfo().createVirtualRegister(X86::GR32RegisterClass);
6648   MIB = BuildMI(newMBB, TII->get(cmovOpc),t3);
6649   MIB.addReg(t2);
6650   MIB.addReg(t1);
6651
6652   // Cmp and exchange if none has modified the memory location
6653   MIB = BuildMI(newMBB, TII->get(X86::LCMPXCHG32));
6654   for (int i=0; i <= lastAddrIndx; ++i)
6655     (*MIB).addOperand(*argOpers[i]);
6656   MIB.addReg(t3);
6657   assert(mInstr->hasOneMemOperand() && "Unexpected number of memoperand");
6658   (*MIB).addMemOperand(*F, *mInstr->memoperands_begin());
6659
6660   MIB = BuildMI(newMBB, TII->get(X86::MOV32rr), destOper.getReg());
6661   MIB.addReg(X86::EAX);
6662
6663   // insert branch
6664   BuildMI(newMBB, TII->get(X86::JNE)).addMBB(newMBB);
6665
6666   F->DeleteMachineInstr(mInstr);   // The pseudo instruction is gone now.
6667   return nextMBB;
6668 }
6669
6670
6671 MachineBasicBlock *
6672 X86TargetLowering::EmitInstrWithCustomInserter(MachineInstr *MI,
6673                                                MachineBasicBlock *BB) {
6674   const TargetInstrInfo *TII = getTargetMachine().getInstrInfo();
6675   switch (MI->getOpcode()) {
6676   default: assert(false && "Unexpected instr type to insert");
6677   case X86::CMOV_FR32:
6678   case X86::CMOV_FR64:
6679   case X86::CMOV_V4F32:
6680   case X86::CMOV_V2F64:
6681   case X86::CMOV_V2I64: {
6682     // To "insert" a SELECT_CC instruction, we actually have to insert the
6683     // diamond control-flow pattern.  The incoming instruction knows the
6684     // destination vreg to set, the condition code register to branch on, the
6685     // true/false values to select between, and a branch opcode to use.
6686     const BasicBlock *LLVM_BB = BB->getBasicBlock();
6687     MachineFunction::iterator It = BB;
6688     ++It;
6689
6690     //  thisMBB:
6691     //  ...
6692     //   TrueVal = ...
6693     //   cmpTY ccX, r1, r2
6694     //   bCC copy1MBB
6695     //   fallthrough --> copy0MBB
6696     MachineBasicBlock *thisMBB = BB;
6697     MachineFunction *F = BB->getParent();
6698     MachineBasicBlock *copy0MBB = F->CreateMachineBasicBlock(LLVM_BB);
6699     MachineBasicBlock *sinkMBB = F->CreateMachineBasicBlock(LLVM_BB);
6700     unsigned Opc =
6701       X86::GetCondBranchFromCond((X86::CondCode)MI->getOperand(3).getImm());
6702     BuildMI(BB, TII->get(Opc)).addMBB(sinkMBB);
6703     F->insert(It, copy0MBB);
6704     F->insert(It, sinkMBB);
6705     // Update machine-CFG edges by transferring all successors of the current
6706     // block to the new block which will contain the Phi node for the select.
6707     sinkMBB->transferSuccessors(BB);
6708
6709     // Add the true and fallthrough blocks as its successors.
6710     BB->addSuccessor(copy0MBB);
6711     BB->addSuccessor(sinkMBB);
6712
6713     //  copy0MBB:
6714     //   %FalseValue = ...
6715     //   # fallthrough to sinkMBB
6716     BB = copy0MBB;
6717
6718     // Update machine-CFG edges
6719     BB->addSuccessor(sinkMBB);
6720
6721     //  sinkMBB:
6722     //   %Result = phi [ %FalseValue, copy0MBB ], [ %TrueValue, thisMBB ]
6723     //  ...
6724     BB = sinkMBB;
6725     BuildMI(BB, TII->get(X86::PHI), MI->getOperand(0).getReg())
6726       .addReg(MI->getOperand(1).getReg()).addMBB(copy0MBB)
6727       .addReg(MI->getOperand(2).getReg()).addMBB(thisMBB);
6728
6729     F->DeleteMachineInstr(MI);   // The pseudo instruction is gone now.
6730     return BB;
6731   }
6732
6733   case X86::FP32_TO_INT16_IN_MEM:
6734   case X86::FP32_TO_INT32_IN_MEM:
6735   case X86::FP32_TO_INT64_IN_MEM:
6736   case X86::FP64_TO_INT16_IN_MEM:
6737   case X86::FP64_TO_INT32_IN_MEM:
6738   case X86::FP64_TO_INT64_IN_MEM:
6739   case X86::FP80_TO_INT16_IN_MEM:
6740   case X86::FP80_TO_INT32_IN_MEM:
6741   case X86::FP80_TO_INT64_IN_MEM: {
6742     // Change the floating point control register to use "round towards zero"
6743     // mode when truncating to an integer value.
6744     MachineFunction *F = BB->getParent();
6745     int CWFrameIdx = F->getFrameInfo()->CreateStackObject(2, 2);
6746     addFrameReference(BuildMI(BB, TII->get(X86::FNSTCW16m)), CWFrameIdx);
6747
6748     // Load the old value of the high byte of the control word...
6749     unsigned OldCW =
6750       F->getRegInfo().createVirtualRegister(X86::GR16RegisterClass);
6751     addFrameReference(BuildMI(BB, TII->get(X86::MOV16rm), OldCW), CWFrameIdx);
6752
6753     // Set the high part to be round to zero...
6754     addFrameReference(BuildMI(BB, TII->get(X86::MOV16mi)), CWFrameIdx)
6755       .addImm(0xC7F);
6756
6757     // Reload the modified control word now...
6758     addFrameReference(BuildMI(BB, TII->get(X86::FLDCW16m)), CWFrameIdx);
6759
6760     // Restore the memory image of control word to original value
6761     addFrameReference(BuildMI(BB, TII->get(X86::MOV16mr)), CWFrameIdx)
6762       .addReg(OldCW);
6763
6764     // Get the X86 opcode to use.
6765     unsigned Opc;
6766     switch (MI->getOpcode()) {
6767     default: assert(0 && "illegal opcode!");
6768     case X86::FP32_TO_INT16_IN_MEM: Opc = X86::IST_Fp16m32; break;
6769     case X86::FP32_TO_INT32_IN_MEM: Opc = X86::IST_Fp32m32; break;
6770     case X86::FP32_TO_INT64_IN_MEM: Opc = X86::IST_Fp64m32; break;
6771     case X86::FP64_TO_INT16_IN_MEM: Opc = X86::IST_Fp16m64; break;
6772     case X86::FP64_TO_INT32_IN_MEM: Opc = X86::IST_Fp32m64; break;
6773     case X86::FP64_TO_INT64_IN_MEM: Opc = X86::IST_Fp64m64; break;
6774     case X86::FP80_TO_INT16_IN_MEM: Opc = X86::IST_Fp16m80; break;
6775     case X86::FP80_TO_INT32_IN_MEM: Opc = X86::IST_Fp32m80; break;
6776     case X86::FP80_TO_INT64_IN_MEM: Opc = X86::IST_Fp64m80; break;
6777     }
6778
6779     X86AddressMode AM;
6780     MachineOperand &Op = MI->getOperand(0);
6781     if (Op.isReg()) {
6782       AM.BaseType = X86AddressMode::RegBase;
6783       AM.Base.Reg = Op.getReg();
6784     } else {
6785       AM.BaseType = X86AddressMode::FrameIndexBase;
6786       AM.Base.FrameIndex = Op.getIndex();
6787     }
6788     Op = MI->getOperand(1);
6789     if (Op.isImm())
6790       AM.Scale = Op.getImm();
6791     Op = MI->getOperand(2);
6792     if (Op.isImm())
6793       AM.IndexReg = Op.getImm();
6794     Op = MI->getOperand(3);
6795     if (Op.isGlobal()) {
6796       AM.GV = Op.getGlobal();
6797     } else {
6798       AM.Disp = Op.getImm();
6799     }
6800     addFullAddress(BuildMI(BB, TII->get(Opc)), AM)
6801                       .addReg(MI->getOperand(4).getReg());
6802
6803     // Reload the original control word now.
6804     addFrameReference(BuildMI(BB, TII->get(X86::FLDCW16m)), CWFrameIdx);
6805
6806     F->DeleteMachineInstr(MI);   // The pseudo instruction is gone now.
6807     return BB;
6808   }
6809   case X86::ATOMAND32:
6810     return EmitAtomicBitwiseWithCustomInserter(MI, BB, X86::AND32rr,
6811                                                X86::AND32ri, X86::MOV32rm,
6812                                                X86::LCMPXCHG32, X86::MOV32rr,
6813                                                X86::NOT32r, X86::EAX,
6814                                                X86::GR32RegisterClass);
6815   case X86::ATOMOR32:
6816     return EmitAtomicBitwiseWithCustomInserter(MI, BB, X86::OR32rr,
6817                                                X86::OR32ri, X86::MOV32rm,
6818                                                X86::LCMPXCHG32, X86::MOV32rr,
6819                                                X86::NOT32r, X86::EAX,
6820                                                X86::GR32RegisterClass);
6821   case X86::ATOMXOR32:
6822     return EmitAtomicBitwiseWithCustomInserter(MI, BB, X86::XOR32rr,
6823                                                X86::XOR32ri, X86::MOV32rm,
6824                                                X86::LCMPXCHG32, X86::MOV32rr,
6825                                                X86::NOT32r, X86::EAX,
6826                                                X86::GR32RegisterClass);
6827   case X86::ATOMNAND32:
6828     return EmitAtomicBitwiseWithCustomInserter(MI, BB, X86::AND32rr,
6829                                                X86::AND32ri, X86::MOV32rm,
6830                                                X86::LCMPXCHG32, X86::MOV32rr,
6831                                                X86::NOT32r, X86::EAX,
6832                                                X86::GR32RegisterClass, true);
6833   case X86::ATOMMIN32:
6834     return EmitAtomicMinMaxWithCustomInserter(MI, BB, X86::CMOVL32rr);
6835   case X86::ATOMMAX32:
6836     return EmitAtomicMinMaxWithCustomInserter(MI, BB, X86::CMOVG32rr);
6837   case X86::ATOMUMIN32:
6838     return EmitAtomicMinMaxWithCustomInserter(MI, BB, X86::CMOVB32rr);
6839   case X86::ATOMUMAX32:
6840     return EmitAtomicMinMaxWithCustomInserter(MI, BB, X86::CMOVA32rr);
6841
6842   case X86::ATOMAND16:
6843     return EmitAtomicBitwiseWithCustomInserter(MI, BB, X86::AND16rr,
6844                                                X86::AND16ri, X86::MOV16rm,
6845                                                X86::LCMPXCHG16, X86::MOV16rr,
6846                                                X86::NOT16r, X86::AX,
6847                                                X86::GR16RegisterClass);
6848   case X86::ATOMOR16:
6849     return EmitAtomicBitwiseWithCustomInserter(MI, BB, X86::OR16rr,
6850                                                X86::OR16ri, X86::MOV16rm,
6851                                                X86::LCMPXCHG16, X86::MOV16rr,
6852                                                X86::NOT16r, X86::AX,
6853                                                X86::GR16RegisterClass);
6854   case X86::ATOMXOR16:
6855     return EmitAtomicBitwiseWithCustomInserter(MI, BB, X86::XOR16rr,
6856                                                X86::XOR16ri, X86::MOV16rm,
6857                                                X86::LCMPXCHG16, X86::MOV16rr,
6858                                                X86::NOT16r, X86::AX,
6859                                                X86::GR16RegisterClass);
6860   case X86::ATOMNAND16:
6861     return EmitAtomicBitwiseWithCustomInserter(MI, BB, X86::AND16rr,
6862                                                X86::AND16ri, X86::MOV16rm,
6863                                                X86::LCMPXCHG16, X86::MOV16rr,
6864                                                X86::NOT16r, X86::AX,
6865                                                X86::GR16RegisterClass, true);
6866   case X86::ATOMMIN16:
6867     return EmitAtomicMinMaxWithCustomInserter(MI, BB, X86::CMOVL16rr);
6868   case X86::ATOMMAX16:
6869     return EmitAtomicMinMaxWithCustomInserter(MI, BB, X86::CMOVG16rr);
6870   case X86::ATOMUMIN16:
6871     return EmitAtomicMinMaxWithCustomInserter(MI, BB, X86::CMOVB16rr);
6872   case X86::ATOMUMAX16:
6873     return EmitAtomicMinMaxWithCustomInserter(MI, BB, X86::CMOVA16rr);
6874
6875   case X86::ATOMAND8:
6876     return EmitAtomicBitwiseWithCustomInserter(MI, BB, X86::AND8rr,
6877                                                X86::AND8ri, X86::MOV8rm,
6878                                                X86::LCMPXCHG8, X86::MOV8rr,
6879                                                X86::NOT8r, X86::AL,
6880                                                X86::GR8RegisterClass);
6881   case X86::ATOMOR8:
6882     return EmitAtomicBitwiseWithCustomInserter(MI, BB, X86::OR8rr,
6883                                                X86::OR8ri, X86::MOV8rm,
6884                                                X86::LCMPXCHG8, X86::MOV8rr,
6885                                                X86::NOT8r, X86::AL,
6886                                                X86::GR8RegisterClass);
6887   case X86::ATOMXOR8:
6888     return EmitAtomicBitwiseWithCustomInserter(MI, BB, X86::XOR8rr,
6889                                                X86::XOR8ri, X86::MOV8rm,
6890                                                X86::LCMPXCHG8, X86::MOV8rr,
6891                                                X86::NOT8r, X86::AL,
6892                                                X86::GR8RegisterClass);
6893   case X86::ATOMNAND8:
6894     return EmitAtomicBitwiseWithCustomInserter(MI, BB, X86::AND8rr,
6895                                                X86::AND8ri, X86::MOV8rm,
6896                                                X86::LCMPXCHG8, X86::MOV8rr,
6897                                                X86::NOT8r, X86::AL,
6898                                                X86::GR8RegisterClass, true);
6899   // FIXME: There are no CMOV8 instructions; MIN/MAX need some other way.
6900   // This group is for 64-bit host.
6901   case X86::ATOMAND64:
6902     return EmitAtomicBitwiseWithCustomInserter(MI, BB, X86::AND64rr,
6903                                                X86::AND64ri32, X86::MOV64rm,
6904                                                X86::LCMPXCHG64, X86::MOV64rr,
6905                                                X86::NOT64r, X86::RAX,
6906                                                X86::GR64RegisterClass);
6907   case X86::ATOMOR64:
6908     return EmitAtomicBitwiseWithCustomInserter(MI, BB, X86::OR64rr,
6909                                                X86::OR64ri32, X86::MOV64rm,
6910                                                X86::LCMPXCHG64, X86::MOV64rr,
6911                                                X86::NOT64r, X86::RAX,
6912                                                X86::GR64RegisterClass);
6913   case X86::ATOMXOR64:
6914     return EmitAtomicBitwiseWithCustomInserter(MI, BB, X86::XOR64rr,
6915                                                X86::XOR64ri32, X86::MOV64rm,
6916                                                X86::LCMPXCHG64, X86::MOV64rr,
6917                                                X86::NOT64r, X86::RAX,
6918                                                X86::GR64RegisterClass);
6919   case X86::ATOMNAND64:
6920     return EmitAtomicBitwiseWithCustomInserter(MI, BB, X86::AND64rr,
6921                                                X86::AND64ri32, X86::MOV64rm,
6922                                                X86::LCMPXCHG64, X86::MOV64rr,
6923                                                X86::NOT64r, X86::RAX,
6924                                                X86::GR64RegisterClass, true);
6925   case X86::ATOMMIN64:
6926     return EmitAtomicMinMaxWithCustomInserter(MI, BB, X86::CMOVL64rr);
6927   case X86::ATOMMAX64:
6928     return EmitAtomicMinMaxWithCustomInserter(MI, BB, X86::CMOVG64rr);
6929   case X86::ATOMUMIN64:
6930     return EmitAtomicMinMaxWithCustomInserter(MI, BB, X86::CMOVB64rr);
6931   case X86::ATOMUMAX64:
6932     return EmitAtomicMinMaxWithCustomInserter(MI, BB, X86::CMOVA64rr);
6933
6934   // This group does 64-bit operations on a 32-bit host.
6935   case X86::ATOMAND6432:
6936     return EmitAtomicBit6432WithCustomInserter(MI, BB,
6937                                                X86::AND32rr, X86::AND32rr,
6938                                                X86::AND32ri, X86::AND32ri,
6939                                                false);
6940   case X86::ATOMOR6432:
6941     return EmitAtomicBit6432WithCustomInserter(MI, BB,
6942                                                X86::OR32rr, X86::OR32rr,
6943                                                X86::OR32ri, X86::OR32ri,
6944                                                false);
6945   case X86::ATOMXOR6432:
6946     return EmitAtomicBit6432WithCustomInserter(MI, BB,
6947                                                X86::XOR32rr, X86::XOR32rr,
6948                                                X86::XOR32ri, X86::XOR32ri,
6949                                                false);
6950   case X86::ATOMNAND6432:
6951     return EmitAtomicBit6432WithCustomInserter(MI, BB,
6952                                                X86::AND32rr, X86::AND32rr,
6953                                                X86::AND32ri, X86::AND32ri,
6954                                                true);
6955   case X86::ATOMADD6432:
6956     return EmitAtomicBit6432WithCustomInserter(MI, BB,
6957                                                X86::ADD32rr, X86::ADC32rr,
6958                                                X86::ADD32ri, X86::ADC32ri,
6959                                                false);
6960   case X86::ATOMSUB6432:
6961     return EmitAtomicBit6432WithCustomInserter(MI, BB,
6962                                                X86::SUB32rr, X86::SBB32rr,
6963                                                X86::SUB32ri, X86::SBB32ri,
6964                                                false);
6965   case X86::ATOMSWAP6432:
6966     return EmitAtomicBit6432WithCustomInserter(MI, BB,
6967                                                X86::MOV32rr, X86::MOV32rr,
6968                                                X86::MOV32ri, X86::MOV32ri,
6969                                                false);
6970   }
6971 }
6972
6973 //===----------------------------------------------------------------------===//
6974 //                           X86 Optimization Hooks
6975 //===----------------------------------------------------------------------===//
6976
6977 void X86TargetLowering::computeMaskedBitsForTargetNode(const SDValue Op,
6978                                                        const APInt &Mask,
6979                                                        APInt &KnownZero,
6980                                                        APInt &KnownOne,
6981                                                        const SelectionDAG &DAG,
6982                                                        unsigned Depth) const {
6983   unsigned Opc = Op.getOpcode();
6984   assert((Opc >= ISD::BUILTIN_OP_END ||
6985           Opc == ISD::INTRINSIC_WO_CHAIN ||
6986           Opc == ISD::INTRINSIC_W_CHAIN ||
6987           Opc == ISD::INTRINSIC_VOID) &&
6988          "Should use MaskedValueIsZero if you don't know whether Op"
6989          " is a target node!");
6990
6991   KnownZero = KnownOne = APInt(Mask.getBitWidth(), 0);   // Don't know anything.
6992   switch (Opc) {
6993   default: break;
6994   case X86ISD::SETCC:
6995     KnownZero |= APInt::getHighBitsSet(Mask.getBitWidth(),
6996                                        Mask.getBitWidth() - 1);
6997     break;
6998   }
6999 }
7000
7001 /// isGAPlusOffset - Returns true (and the GlobalValue and the offset) if the
7002 /// node is a GlobalAddress + offset.
7003 bool X86TargetLowering::isGAPlusOffset(SDNode *N,
7004                                        GlobalValue* &GA, int64_t &Offset) const{
7005   if (N->getOpcode() == X86ISD::Wrapper) {
7006     if (isa<GlobalAddressSDNode>(N->getOperand(0))) {
7007       GA = cast<GlobalAddressSDNode>(N->getOperand(0))->getGlobal();
7008       return true;
7009     }
7010   }
7011   return TargetLowering::isGAPlusOffset(N, GA, Offset);
7012 }
7013
7014 static bool isBaseAlignmentOfN(unsigned N, SDNode *Base,
7015                                const TargetLowering &TLI) {
7016   GlobalValue *GV;
7017   int64_t Offset = 0;
7018   if (TLI.isGAPlusOffset(Base, GV, Offset))
7019     return (GV->getAlignment() >= N && (Offset % N) == 0);
7020   // DAG combine handles the stack object case.
7021   return false;
7022 }
7023
7024 static bool EltsFromConsecutiveLoads(SDNode *N, SDValue PermMask,
7025                                      unsigned NumElems, MVT EVT,
7026                                      SDNode *&Base,
7027                                      SelectionDAG &DAG, MachineFrameInfo *MFI,
7028                                      const TargetLowering &TLI) {
7029   Base = NULL;
7030   for (unsigned i = 0; i < NumElems; ++i) {
7031     SDValue Idx = PermMask.getOperand(i);
7032     if (Idx.getOpcode() == ISD::UNDEF) {
7033       if (!Base)
7034         return false;
7035       continue;
7036     }
7037
7038     SDValue Elt = DAG.getShuffleScalarElt(N, i);
7039     if (!Elt.getNode() ||
7040         (Elt.getOpcode() != ISD::UNDEF && !ISD::isNON_EXTLoad(Elt.getNode())))
7041       return false;
7042     if (!Base) {
7043       Base = Elt.getNode();
7044       if (Base->getOpcode() == ISD::UNDEF)
7045         return false;
7046       continue;
7047     }
7048     if (Elt.getOpcode() == ISD::UNDEF)
7049       continue;
7050
7051     if (!TLI.isConsecutiveLoad(Elt.getNode(), Base,
7052                                EVT.getSizeInBits()/8, i, MFI))
7053       return false;
7054   }
7055   return true;
7056 }
7057
7058 /// PerformShuffleCombine - Combine a vector_shuffle that is equal to
7059 /// build_vector load1, load2, load3, load4, <0, 1, 2, 3> into a 128-bit load
7060 /// if the load addresses are consecutive, non-overlapping, and in the right
7061 /// order.
7062 static SDValue PerformShuffleCombine(SDNode *N, SelectionDAG &DAG,
7063                                        const TargetLowering &TLI) {
7064   MachineFrameInfo *MFI = DAG.getMachineFunction().getFrameInfo();
7065   MVT VT = N->getValueType(0);
7066   MVT EVT = VT.getVectorElementType();
7067   SDValue PermMask = N->getOperand(2);
7068   unsigned NumElems = PermMask.getNumOperands();
7069   SDNode *Base = NULL;
7070   if (!EltsFromConsecutiveLoads(N, PermMask, NumElems, EVT, Base,
7071                                 DAG, MFI, TLI))
7072     return SDValue();
7073
7074   LoadSDNode *LD = cast<LoadSDNode>(Base);
7075   if (isBaseAlignmentOfN(16, Base->getOperand(1).getNode(), TLI))
7076     return DAG.getLoad(VT, LD->getChain(), LD->getBasePtr(), LD->getSrcValue(),
7077                        LD->getSrcValueOffset(), LD->isVolatile());
7078   return DAG.getLoad(VT, LD->getChain(), LD->getBasePtr(), LD->getSrcValue(),
7079                      LD->getSrcValueOffset(), LD->isVolatile(),
7080                      LD->getAlignment());
7081 }
7082
7083 /// PerformBuildVectorCombine - build_vector 0,(load i64 / f64) -> movq / movsd.
7084 static SDValue PerformBuildVectorCombine(SDNode *N, SelectionDAG &DAG,
7085                                          const X86Subtarget *Subtarget,
7086                                          const TargetLowering &TLI) {
7087   unsigned NumOps = N->getNumOperands();
7088
7089   // Ignore single operand BUILD_VECTOR.
7090   if (NumOps == 1)
7091     return SDValue();
7092
7093   MVT VT = N->getValueType(0);
7094   MVT EVT = VT.getVectorElementType();
7095   if ((EVT != MVT::i64 && EVT != MVT::f64) || Subtarget->is64Bit())
7096     // We are looking for load i64 and zero extend. We want to transform
7097     // it before legalizer has a chance to expand it. Also look for i64
7098     // BUILD_PAIR bit casted to f64.
7099     return SDValue();
7100   // This must be an insertion into a zero vector.
7101   SDValue HighElt = N->getOperand(1);
7102   if (!isZeroNode(HighElt))
7103     return SDValue();
7104
7105   // Value must be a load.
7106   SDNode *Base = N->getOperand(0).getNode();
7107   if (!isa<LoadSDNode>(Base)) {
7108     if (Base->getOpcode() != ISD::BIT_CONVERT)
7109       return SDValue();
7110     Base = Base->getOperand(0).getNode();
7111     if (!isa<LoadSDNode>(Base))
7112       return SDValue();
7113   }
7114
7115   // Transform it into VZEXT_LOAD addr.
7116   LoadSDNode *LD = cast<LoadSDNode>(Base);
7117
7118   // Load must not be an extload.
7119   if (LD->getExtensionType() != ISD::NON_EXTLOAD)
7120     return SDValue();
7121
7122   SDVTList Tys = DAG.getVTList(VT, MVT::Other);
7123   SDValue Ops[] = { LD->getChain(), LD->getBasePtr() };
7124   SDValue ResNode = DAG.getNode(X86ISD::VZEXT_LOAD, Tys, Ops, 2);
7125   DAG.ReplaceAllUsesOfValueWith(SDValue(Base, 1), ResNode.getValue(1));
7126   return ResNode;
7127 }
7128
7129 /// PerformSELECTCombine - Do target-specific dag combines on SELECT nodes.
7130 static SDValue PerformSELECTCombine(SDNode *N, SelectionDAG &DAG,
7131                                       const X86Subtarget *Subtarget) {
7132   SDValue Cond = N->getOperand(0);
7133
7134   // If we have SSE[12] support, try to form min/max nodes.
7135   if (Subtarget->hasSSE2() &&
7136       (N->getValueType(0) == MVT::f32 || N->getValueType(0) == MVT::f64)) {
7137     if (Cond.getOpcode() == ISD::SETCC) {
7138       // Get the LHS/RHS of the select.
7139       SDValue LHS = N->getOperand(1);
7140       SDValue RHS = N->getOperand(2);
7141       ISD::CondCode CC = cast<CondCodeSDNode>(Cond.getOperand(2))->get();
7142
7143       unsigned Opcode = 0;
7144       if (LHS == Cond.getOperand(0) && RHS == Cond.getOperand(1)) {
7145         switch (CC) {
7146         default: break;
7147         case ISD::SETOLE: // (X <= Y) ? X : Y -> min
7148         case ISD::SETULE:
7149         case ISD::SETLE:
7150           if (!UnsafeFPMath) break;
7151           // FALL THROUGH.
7152         case ISD::SETOLT:  // (X olt/lt Y) ? X : Y -> min
7153         case ISD::SETLT:
7154           Opcode = X86ISD::FMIN;
7155           break;
7156
7157         case ISD::SETOGT: // (X > Y) ? X : Y -> max
7158         case ISD::SETUGT:
7159         case ISD::SETGT:
7160           if (!UnsafeFPMath) break;
7161           // FALL THROUGH.
7162         case ISD::SETUGE:  // (X uge/ge Y) ? X : Y -> max
7163         case ISD::SETGE:
7164           Opcode = X86ISD::FMAX;
7165           break;
7166         }
7167       } else if (LHS == Cond.getOperand(1) && RHS == Cond.getOperand(0)) {
7168         switch (CC) {
7169         default: break;
7170         case ISD::SETOGT: // (X > Y) ? Y : X -> min
7171         case ISD::SETUGT:
7172         case ISD::SETGT:
7173           if (!UnsafeFPMath) break;
7174           // FALL THROUGH.
7175         case ISD::SETUGE:  // (X uge/ge Y) ? Y : X -> min
7176         case ISD::SETGE:
7177           Opcode = X86ISD::FMIN;
7178           break;
7179
7180         case ISD::SETOLE:   // (X <= Y) ? Y : X -> max
7181         case ISD::SETULE:
7182         case ISD::SETLE:
7183           if (!UnsafeFPMath) break;
7184           // FALL THROUGH.
7185         case ISD::SETOLT:   // (X olt/lt Y) ? Y : X -> max
7186         case ISD::SETLT:
7187           Opcode = X86ISD::FMAX;
7188           break;
7189         }
7190       }
7191
7192       if (Opcode)
7193         return DAG.getNode(Opcode, N->getValueType(0), LHS, RHS);
7194     }
7195
7196   }
7197
7198   return SDValue();
7199 }
7200
7201 /// PerformSTORECombine - Do target-specific dag combines on STORE nodes.
7202 static SDValue PerformSTORECombine(SDNode *N, SelectionDAG &DAG,
7203                                      const X86Subtarget *Subtarget) {
7204   // Turn load->store of MMX types into GPR load/stores.  This avoids clobbering
7205   // the FP state in cases where an emms may be missing.
7206   // A preferable solution to the general problem is to figure out the right
7207   // places to insert EMMS.  This qualifies as a quick hack.
7208   StoreSDNode *St = cast<StoreSDNode>(N);
7209   if (St->getValue().getValueType().isVector() &&
7210       St->getValue().getValueType().getSizeInBits() == 64 &&
7211       isa<LoadSDNode>(St->getValue()) &&
7212       !cast<LoadSDNode>(St->getValue())->isVolatile() &&
7213       St->getChain().hasOneUse() && !St->isVolatile()) {
7214     SDNode* LdVal = St->getValue().getNode();
7215     LoadSDNode *Ld = 0;
7216     int TokenFactorIndex = -1;
7217     SmallVector<SDValue, 8> Ops;
7218     SDNode* ChainVal = St->getChain().getNode();
7219     // Must be a store of a load.  We currently handle two cases:  the load
7220     // is a direct child, and it's under an intervening TokenFactor.  It is
7221     // possible to dig deeper under nested TokenFactors.
7222     if (ChainVal == LdVal)
7223       Ld = cast<LoadSDNode>(St->getChain());
7224     else if (St->getValue().hasOneUse() &&
7225              ChainVal->getOpcode() == ISD::TokenFactor) {
7226       for (unsigned i=0, e = ChainVal->getNumOperands(); i != e; ++i) {
7227         if (ChainVal->getOperand(i).getNode() == LdVal) {
7228           TokenFactorIndex = i;
7229           Ld = cast<LoadSDNode>(St->getValue());
7230         } else
7231           Ops.push_back(ChainVal->getOperand(i));
7232       }
7233     }
7234     if (Ld) {
7235       // If we are a 64-bit capable x86, lower to a single movq load/store pair.
7236       if (Subtarget->is64Bit()) {
7237         SDValue NewLd = DAG.getLoad(MVT::i64, Ld->getChain(),
7238                                       Ld->getBasePtr(), Ld->getSrcValue(),
7239                                       Ld->getSrcValueOffset(), Ld->isVolatile(),
7240                                       Ld->getAlignment());
7241         SDValue NewChain = NewLd.getValue(1);
7242         if (TokenFactorIndex != -1) {
7243           Ops.push_back(NewChain);
7244           NewChain = DAG.getNode(ISD::TokenFactor, MVT::Other, &Ops[0],
7245                                  Ops.size());
7246         }
7247         return DAG.getStore(NewChain, NewLd, St->getBasePtr(),
7248                             St->getSrcValue(), St->getSrcValueOffset(),
7249                             St->isVolatile(), St->getAlignment());
7250       }
7251
7252       // Otherwise, lower to two 32-bit copies.
7253       SDValue LoAddr = Ld->getBasePtr();
7254       SDValue HiAddr = DAG.getNode(ISD::ADD, MVT::i32, LoAddr,
7255                                      DAG.getConstant(4, MVT::i32));
7256
7257       SDValue LoLd = DAG.getLoad(MVT::i32, Ld->getChain(), LoAddr,
7258                                    Ld->getSrcValue(), Ld->getSrcValueOffset(),
7259                                    Ld->isVolatile(), Ld->getAlignment());
7260       SDValue HiLd = DAG.getLoad(MVT::i32, Ld->getChain(), HiAddr,
7261                                    Ld->getSrcValue(), Ld->getSrcValueOffset()+4,
7262                                    Ld->isVolatile(),
7263                                    MinAlign(Ld->getAlignment(), 4));
7264
7265       SDValue NewChain = LoLd.getValue(1);
7266       if (TokenFactorIndex != -1) {
7267         Ops.push_back(LoLd);
7268         Ops.push_back(HiLd);
7269         NewChain = DAG.getNode(ISD::TokenFactor, MVT::Other, &Ops[0],
7270                                Ops.size());
7271       }
7272
7273       LoAddr = St->getBasePtr();
7274       HiAddr = DAG.getNode(ISD::ADD, MVT::i32, LoAddr,
7275                            DAG.getConstant(4, MVT::i32));
7276
7277       SDValue LoSt = DAG.getStore(NewChain, LoLd, LoAddr,
7278                           St->getSrcValue(), St->getSrcValueOffset(),
7279                           St->isVolatile(), St->getAlignment());
7280       SDValue HiSt = DAG.getStore(NewChain, HiLd, HiAddr,
7281                                     St->getSrcValue(),
7282                                     St->getSrcValueOffset() + 4,
7283                                     St->isVolatile(),
7284                                     MinAlign(St->getAlignment(), 4));
7285       return DAG.getNode(ISD::TokenFactor, MVT::Other, LoSt, HiSt);
7286     }
7287   }
7288   return SDValue();
7289 }
7290
7291 /// PerformFORCombine - Do target-specific dag combines on X86ISD::FOR and
7292 /// X86ISD::FXOR nodes.
7293 static SDValue PerformFORCombine(SDNode *N, SelectionDAG &DAG) {
7294   assert(N->getOpcode() == X86ISD::FOR || N->getOpcode() == X86ISD::FXOR);
7295   // F[X]OR(0.0, x) -> x
7296   // F[X]OR(x, 0.0) -> x
7297   if (ConstantFPSDNode *C = dyn_cast<ConstantFPSDNode>(N->getOperand(0)))
7298     if (C->getValueAPF().isPosZero())
7299       return N->getOperand(1);
7300   if (ConstantFPSDNode *C = dyn_cast<ConstantFPSDNode>(N->getOperand(1)))
7301     if (C->getValueAPF().isPosZero())
7302       return N->getOperand(0);
7303   return SDValue();
7304 }
7305
7306 /// PerformFANDCombine - Do target-specific dag combines on X86ISD::FAND nodes.
7307 static SDValue PerformFANDCombine(SDNode *N, SelectionDAG &DAG) {
7308   // FAND(0.0, x) -> 0.0
7309   // FAND(x, 0.0) -> 0.0
7310   if (ConstantFPSDNode *C = dyn_cast<ConstantFPSDNode>(N->getOperand(0)))
7311     if (C->getValueAPF().isPosZero())
7312       return N->getOperand(0);
7313   if (ConstantFPSDNode *C = dyn_cast<ConstantFPSDNode>(N->getOperand(1)))
7314     if (C->getValueAPF().isPosZero())
7315       return N->getOperand(1);
7316   return SDValue();
7317 }
7318
7319
7320 SDValue X86TargetLowering::PerformDAGCombine(SDNode *N,
7321                                                DAGCombinerInfo &DCI) const {
7322   SelectionDAG &DAG = DCI.DAG;
7323   switch (N->getOpcode()) {
7324   default: break;
7325   case ISD::VECTOR_SHUFFLE: return PerformShuffleCombine(N, DAG, *this);
7326   case ISD::BUILD_VECTOR:
7327     return PerformBuildVectorCombine(N, DAG, Subtarget, *this);
7328   case ISD::SELECT:         return PerformSELECTCombine(N, DAG, Subtarget);
7329   case ISD::STORE:          return PerformSTORECombine(N, DAG, Subtarget);
7330   case X86ISD::FXOR:
7331   case X86ISD::FOR:         return PerformFORCombine(N, DAG);
7332   case X86ISD::FAND:        return PerformFANDCombine(N, DAG);
7333   }
7334
7335   return SDValue();
7336 }
7337
7338 //===----------------------------------------------------------------------===//
7339 //                           X86 Inline Assembly Support
7340 //===----------------------------------------------------------------------===//
7341
7342 /// getConstraintType - Given a constraint letter, return the type of
7343 /// constraint it is for this target.
7344 X86TargetLowering::ConstraintType
7345 X86TargetLowering::getConstraintType(const std::string &Constraint) const {
7346   if (Constraint.size() == 1) {
7347     switch (Constraint[0]) {
7348     case 'A':
7349     case 'f':
7350     case 'r':
7351     case 'R':
7352     case 'l':
7353     case 'q':
7354     case 'Q':
7355     case 'x':
7356     case 'y':
7357     case 'Y':
7358       return C_RegisterClass;
7359     default:
7360       break;
7361     }
7362   }
7363   return TargetLowering::getConstraintType(Constraint);
7364 }
7365
7366 /// LowerXConstraint - try to replace an X constraint, which matches anything,
7367 /// with another that has more specific requirements based on the type of the
7368 /// corresponding operand.
7369 const char *X86TargetLowering::
7370 LowerXConstraint(MVT ConstraintVT) const {
7371   // FP X constraints get lowered to SSE1/2 registers if available, otherwise
7372   // 'f' like normal targets.
7373   if (ConstraintVT.isFloatingPoint()) {
7374     if (Subtarget->hasSSE2())
7375       return "Y";
7376     if (Subtarget->hasSSE1())
7377       return "x";
7378   }
7379
7380   return TargetLowering::LowerXConstraint(ConstraintVT);
7381 }
7382
7383 /// LowerAsmOperandForConstraint - Lower the specified operand into the Ops
7384 /// vector.  If it is invalid, don't add anything to Ops.
7385 void X86TargetLowering::LowerAsmOperandForConstraint(SDValue Op,
7386                                                      char Constraint,
7387                                                      bool hasMemory,
7388                                                      std::vector<SDValue>&Ops,
7389                                                      SelectionDAG &DAG) const {
7390   SDValue Result(0, 0);
7391
7392   switch (Constraint) {
7393   default: break;
7394   case 'I':
7395     if (ConstantSDNode *C = dyn_cast<ConstantSDNode>(Op)) {
7396       if (C->getZExtValue() <= 31) {
7397         Result = DAG.getTargetConstant(C->getZExtValue(), Op.getValueType());
7398         break;
7399       }
7400     }
7401     return;
7402   case 'J':
7403     if (ConstantSDNode *C = dyn_cast<ConstantSDNode>(Op)) {
7404       if (C->getZExtValue() <= 63) {
7405         Result = DAG.getTargetConstant(C->getZExtValue(), Op.getValueType());
7406         break;
7407       }
7408     }
7409     return;
7410   case 'N':
7411     if (ConstantSDNode *C = dyn_cast<ConstantSDNode>(Op)) {
7412       if (C->getZExtValue() <= 255) {
7413         Result = DAG.getTargetConstant(C->getZExtValue(), Op.getValueType());
7414         break;
7415       }
7416     }
7417     return;
7418   case 'i': {
7419     // Literal immediates are always ok.
7420     if (ConstantSDNode *CST = dyn_cast<ConstantSDNode>(Op)) {
7421       Result = DAG.getTargetConstant(CST->getZExtValue(), Op.getValueType());
7422       break;
7423     }
7424
7425     // If we are in non-pic codegen mode, we allow the address of a global (with
7426     // an optional displacement) to be used with 'i'.
7427     GlobalAddressSDNode *GA = dyn_cast<GlobalAddressSDNode>(Op);
7428     int64_t Offset = 0;
7429
7430     // Match either (GA) or (GA+C)
7431     if (GA) {
7432       Offset = GA->getOffset();
7433     } else if (Op.getOpcode() == ISD::ADD) {
7434       ConstantSDNode *C = dyn_cast<ConstantSDNode>(Op.getOperand(1));
7435       GA = dyn_cast<GlobalAddressSDNode>(Op.getOperand(0));
7436       if (C && GA) {
7437         Offset = GA->getOffset()+C->getZExtValue();
7438       } else {
7439         C = dyn_cast<ConstantSDNode>(Op.getOperand(1));
7440         GA = dyn_cast<GlobalAddressSDNode>(Op.getOperand(0));
7441         if (C && GA)
7442           Offset = GA->getOffset()+C->getZExtValue();
7443         else
7444           C = 0, GA = 0;
7445       }
7446     }
7447
7448     if (GA) {
7449       if (hasMemory)
7450         Op = LowerGlobalAddress(GA->getGlobal(), DAG);
7451       else
7452         Op = DAG.getTargetGlobalAddress(GA->getGlobal(), GA->getValueType(0),
7453                                         Offset);
7454       Result = Op;
7455       break;
7456     }
7457
7458     // Otherwise, not valid for this mode.
7459     return;
7460   }
7461   }
7462
7463   if (Result.getNode()) {
7464     Ops.push_back(Result);
7465     return;
7466   }
7467   return TargetLowering::LowerAsmOperandForConstraint(Op, Constraint, hasMemory,
7468                                                       Ops, DAG);
7469 }
7470
7471 std::vector<unsigned> X86TargetLowering::
7472 getRegClassForInlineAsmConstraint(const std::string &Constraint,
7473                                   MVT VT) const {
7474   if (Constraint.size() == 1) {
7475     // FIXME: not handling fp-stack yet!
7476     switch (Constraint[0]) {      // GCC X86 Constraint Letters
7477     default: break;  // Unknown constraint letter
7478     case 'A':   // EAX/EDX
7479       if (VT == MVT::i32 || VT == MVT::i64)
7480         return make_vector<unsigned>(X86::EAX, X86::EDX, 0);
7481       break;
7482     case 'q':   // Q_REGS (GENERAL_REGS in 64-bit mode)
7483     case 'Q':   // Q_REGS
7484       if (VT == MVT::i32)
7485         return make_vector<unsigned>(X86::EAX, X86::EDX, X86::ECX, X86::EBX, 0);
7486       else if (VT == MVT::i16)
7487         return make_vector<unsigned>(X86::AX, X86::DX, X86::CX, X86::BX, 0);
7488       else if (VT == MVT::i8)
7489         return make_vector<unsigned>(X86::AL, X86::DL, X86::CL, X86::BL, 0);
7490       else if (VT == MVT::i64)
7491         return make_vector<unsigned>(X86::RAX, X86::RDX, X86::RCX, X86::RBX, 0);
7492       break;
7493     }
7494   }
7495
7496   return std::vector<unsigned>();
7497 }
7498
7499 std::pair<unsigned, const TargetRegisterClass*>
7500 X86TargetLowering::getRegForInlineAsmConstraint(const std::string &Constraint,
7501                                                 MVT VT) const {
7502   // First, see if this is a constraint that directly corresponds to an LLVM
7503   // register class.
7504   if (Constraint.size() == 1) {
7505     // GCC Constraint Letters
7506     switch (Constraint[0]) {
7507     default: break;
7508     case 'r':   // GENERAL_REGS
7509     case 'R':   // LEGACY_REGS
7510     case 'l':   // INDEX_REGS
7511       if (VT == MVT::i64 && Subtarget->is64Bit())
7512         return std::make_pair(0U, X86::GR64RegisterClass);
7513       if (VT == MVT::i32)
7514         return std::make_pair(0U, X86::GR32RegisterClass);
7515       else if (VT == MVT::i16)
7516         return std::make_pair(0U, X86::GR16RegisterClass);
7517       else if (VT == MVT::i8)
7518         return std::make_pair(0U, X86::GR8RegisterClass);
7519       break;
7520     case 'f':  // FP Stack registers.
7521       // If SSE is enabled for this VT, use f80 to ensure the isel moves the
7522       // value to the correct fpstack register class.
7523       if (VT == MVT::f32 && !isScalarFPTypeInSSEReg(VT))
7524         return std::make_pair(0U, X86::RFP32RegisterClass);
7525       if (VT == MVT::f64 && !isScalarFPTypeInSSEReg(VT))
7526         return std::make_pair(0U, X86::RFP64RegisterClass);
7527       return std::make_pair(0U, X86::RFP80RegisterClass);
7528     case 'y':   // MMX_REGS if MMX allowed.
7529       if (!Subtarget->hasMMX()) break;
7530       return std::make_pair(0U, X86::VR64RegisterClass);
7531       break;
7532     case 'Y':   // SSE_REGS if SSE2 allowed
7533       if (!Subtarget->hasSSE2()) break;
7534       // FALL THROUGH.
7535     case 'x':   // SSE_REGS if SSE1 allowed
7536       if (!Subtarget->hasSSE1()) break;
7537
7538       switch (VT.getSimpleVT()) {
7539       default: break;
7540       // Scalar SSE types.
7541       case MVT::f32:
7542       case MVT::i32:
7543         return std::make_pair(0U, X86::FR32RegisterClass);
7544       case MVT::f64:
7545       case MVT::i64:
7546         return std::make_pair(0U, X86::FR64RegisterClass);
7547       // Vector types.
7548       case MVT::v16i8:
7549       case MVT::v8i16:
7550       case MVT::v4i32:
7551       case MVT::v2i64:
7552       case MVT::v4f32:
7553       case MVT::v2f64:
7554         return std::make_pair(0U, X86::VR128RegisterClass);
7555       }
7556       break;
7557     }
7558   }
7559
7560   // Use the default implementation in TargetLowering to convert the register
7561   // constraint into a member of a register class.
7562   std::pair<unsigned, const TargetRegisterClass*> Res;
7563   Res = TargetLowering::getRegForInlineAsmConstraint(Constraint, VT);
7564
7565   // Not found as a standard register?
7566   if (Res.second == 0) {
7567     // GCC calls "st(0)" just plain "st".
7568     if (StringsEqualNoCase("{st}", Constraint)) {
7569       Res.first = X86::ST0;
7570       Res.second = X86::RFP80RegisterClass;
7571     }
7572
7573     return Res;
7574   }
7575
7576   // Otherwise, check to see if this is a register class of the wrong value
7577   // type.  For example, we want to map "{ax},i32" -> {eax}, we don't want it to
7578   // turn into {ax},{dx}.
7579   if (Res.second->hasType(VT))
7580     return Res;   // Correct type already, nothing to do.
7581
7582   // All of the single-register GCC register classes map their values onto
7583   // 16-bit register pieces "ax","dx","cx","bx","si","di","bp","sp".  If we
7584   // really want an 8-bit or 32-bit register, map to the appropriate register
7585   // class and return the appropriate register.
7586   if (Res.second == X86::GR16RegisterClass) {
7587     if (VT == MVT::i8) {
7588       unsigned DestReg = 0;
7589       switch (Res.first) {
7590       default: break;
7591       case X86::AX: DestReg = X86::AL; break;
7592       case X86::DX: DestReg = X86::DL; break;
7593       case X86::CX: DestReg = X86::CL; break;
7594       case X86::BX: DestReg = X86::BL; break;
7595       }
7596       if (DestReg) {
7597         Res.first = DestReg;
7598         Res.second = Res.second = X86::GR8RegisterClass;
7599       }
7600     } else if (VT == MVT::i32) {
7601       unsigned DestReg = 0;
7602       switch (Res.first) {
7603       default: break;
7604       case X86::AX: DestReg = X86::EAX; break;
7605       case X86::DX: DestReg = X86::EDX; break;
7606       case X86::CX: DestReg = X86::ECX; break;
7607       case X86::BX: DestReg = X86::EBX; break;
7608       case X86::SI: DestReg = X86::ESI; break;
7609       case X86::DI: DestReg = X86::EDI; break;
7610       case X86::BP: DestReg = X86::EBP; break;
7611       case X86::SP: DestReg = X86::ESP; break;
7612       }
7613       if (DestReg) {
7614         Res.first = DestReg;
7615         Res.second = Res.second = X86::GR32RegisterClass;
7616       }
7617     } else if (VT == MVT::i64) {
7618       unsigned DestReg = 0;
7619       switch (Res.first) {
7620       default: break;
7621       case X86::AX: DestReg = X86::RAX; break;
7622       case X86::DX: DestReg = X86::RDX; break;
7623       case X86::CX: DestReg = X86::RCX; break;
7624       case X86::BX: DestReg = X86::RBX; break;
7625       case X86::SI: DestReg = X86::RSI; break;
7626       case X86::DI: DestReg = X86::RDI; break;
7627       case X86::BP: DestReg = X86::RBP; break;
7628       case X86::SP: DestReg = X86::RSP; break;
7629       }
7630       if (DestReg) {
7631         Res.first = DestReg;
7632         Res.second = Res.second = X86::GR64RegisterClass;
7633       }
7634     }
7635   } else if (Res.second == X86::FR32RegisterClass ||
7636              Res.second == X86::FR64RegisterClass ||
7637              Res.second == X86::VR128RegisterClass) {
7638     // Handle references to XMM physical registers that got mapped into the
7639     // wrong class.  This can happen with constraints like {xmm0} where the
7640     // target independent register mapper will just pick the first match it can
7641     // find, ignoring the required type.
7642     if (VT == MVT::f32)
7643       Res.second = X86::FR32RegisterClass;
7644     else if (VT == MVT::f64)
7645       Res.second = X86::FR64RegisterClass;
7646     else if (X86::VR128RegisterClass->hasType(VT))
7647       Res.second = X86::VR128RegisterClass;
7648   }
7649
7650   return Res;
7651 }