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