X86: enable CSE between CMP and SUB
[oota-llvm.git] / lib / Target / X86 / X86ISelLowering.cpp
1 //===-- X86ISelLowering.cpp - X86 DAG Lowering Implementation -------------===//
2 //
3 //                     The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 //
10 // This file defines the interfaces that X86 uses to lower LLVM code into a
11 // selection DAG.
12 //
13 //===----------------------------------------------------------------------===//
14
15 #define DEBUG_TYPE "x86-isel"
16 #include "X86ISelLowering.h"
17 #include "X86.h"
18 #include "X86InstrBuilder.h"
19 #include "X86TargetMachine.h"
20 #include "X86TargetObjectFile.h"
21 #include "Utils/X86ShuffleDecode.h"
22 #include "llvm/CallingConv.h"
23 #include "llvm/Constants.h"
24 #include "llvm/DerivedTypes.h"
25 #include "llvm/GlobalAlias.h"
26 #include "llvm/GlobalVariable.h"
27 #include "llvm/Function.h"
28 #include "llvm/Instructions.h"
29 #include "llvm/Intrinsics.h"
30 #include "llvm/LLVMContext.h"
31 #include "llvm/CodeGen/IntrinsicLowering.h"
32 #include "llvm/CodeGen/MachineFrameInfo.h"
33 #include "llvm/CodeGen/MachineFunction.h"
34 #include "llvm/CodeGen/MachineInstrBuilder.h"
35 #include "llvm/CodeGen/MachineJumpTableInfo.h"
36 #include "llvm/CodeGen/MachineModuleInfo.h"
37 #include "llvm/CodeGen/MachineRegisterInfo.h"
38 #include "llvm/MC/MCAsmInfo.h"
39 #include "llvm/MC/MCContext.h"
40 #include "llvm/MC/MCExpr.h"
41 #include "llvm/MC/MCSymbol.h"
42 #include "llvm/ADT/SmallSet.h"
43 #include "llvm/ADT/Statistic.h"
44 #include "llvm/ADT/StringExtras.h"
45 #include "llvm/ADT/VariadicFunction.h"
46 #include "llvm/Support/CallSite.h"
47 #include "llvm/Support/Debug.h"
48 #include "llvm/Support/ErrorHandling.h"
49 #include "llvm/Support/MathExtras.h"
50 #include "llvm/Target/TargetOptions.h"
51 #include <bitset>
52 using namespace llvm;
53
54 STATISTIC(NumTailCalls, "Number of tail calls");
55
56 // Forward declarations.
57 static SDValue getMOVL(SelectionDAG &DAG, DebugLoc dl, EVT VT, SDValue V1,
58                        SDValue V2);
59
60 /// Generate a DAG to grab 128-bits from a vector > 128 bits.  This
61 /// sets things up to match to an AVX VEXTRACTF128 instruction or a
62 /// simple subregister reference.  Idx is an index in the 128 bits we
63 /// want.  It need not be aligned to a 128-bit bounday.  That makes
64 /// lowering EXTRACT_VECTOR_ELT operations easier.
65 static SDValue Extract128BitVector(SDValue Vec, unsigned IdxVal,
66                                    SelectionDAG &DAG, DebugLoc dl) {
67   EVT VT = Vec.getValueType();
68   assert(VT.getSizeInBits() == 256 && "Unexpected vector size!");
69   EVT ElVT = VT.getVectorElementType();
70   unsigned Factor = VT.getSizeInBits()/128;
71   EVT ResultVT = EVT::getVectorVT(*DAG.getContext(), ElVT,
72                                   VT.getVectorNumElements()/Factor);
73
74   // Extract from UNDEF is UNDEF.
75   if (Vec.getOpcode() == ISD::UNDEF)
76     return DAG.getUNDEF(ResultVT);
77
78   // Extract the relevant 128 bits.  Generate an EXTRACT_SUBVECTOR
79   // we can match to VEXTRACTF128.
80   unsigned ElemsPerChunk = 128 / ElVT.getSizeInBits();
81
82   // This is the index of the first element of the 128-bit chunk
83   // we want.
84   unsigned NormalizedIdxVal = (((IdxVal * ElVT.getSizeInBits()) / 128)
85                                * ElemsPerChunk);
86
87   SDValue VecIdx = DAG.getConstant(NormalizedIdxVal, MVT::i32);
88   SDValue Result = DAG.getNode(ISD::EXTRACT_SUBVECTOR, dl, ResultVT, Vec,
89                                VecIdx);
90
91   return Result;
92 }
93
94 /// Generate a DAG to put 128-bits into a vector > 128 bits.  This
95 /// sets things up to match to an AVX VINSERTF128 instruction or a
96 /// simple superregister reference.  Idx is an index in the 128 bits
97 /// we want.  It need not be aligned to a 128-bit bounday.  That makes
98 /// lowering INSERT_VECTOR_ELT operations easier.
99 static SDValue Insert128BitVector(SDValue Result, SDValue Vec,
100                                   unsigned IdxVal, SelectionDAG &DAG,
101                                   DebugLoc dl) {
102   // Inserting UNDEF is Result
103   if (Vec.getOpcode() == ISD::UNDEF)
104     return Result;
105
106   EVT VT = Vec.getValueType();
107   assert(VT.getSizeInBits() == 128 && "Unexpected vector size!");
108
109   EVT ElVT = VT.getVectorElementType();
110   EVT ResultVT = Result.getValueType();
111
112   // Insert the relevant 128 bits.
113   unsigned ElemsPerChunk = 128/ElVT.getSizeInBits();
114
115   // This is the index of the first element of the 128-bit chunk
116   // we want.
117   unsigned NormalizedIdxVal = (((IdxVal * ElVT.getSizeInBits())/128)
118                                * ElemsPerChunk);
119
120   SDValue VecIdx = DAG.getConstant(NormalizedIdxVal, MVT::i32);
121   return DAG.getNode(ISD::INSERT_SUBVECTOR, dl, ResultVT, Result, Vec,
122                      VecIdx);
123 }
124
125 /// Concat two 128-bit vectors into a 256 bit vector using VINSERTF128
126 /// instructions. This is used because creating CONCAT_VECTOR nodes of
127 /// BUILD_VECTORS returns a larger BUILD_VECTOR while we're trying to lower
128 /// large BUILD_VECTORS.
129 static SDValue Concat128BitVectors(SDValue V1, SDValue V2, EVT VT,
130                                    unsigned NumElems, SelectionDAG &DAG,
131                                    DebugLoc dl) {
132   SDValue V = Insert128BitVector(DAG.getUNDEF(VT), V1, 0, DAG, dl);
133   return Insert128BitVector(V, V2, NumElems/2, DAG, dl);
134 }
135
136 static TargetLoweringObjectFile *createTLOF(X86TargetMachine &TM) {
137   const X86Subtarget *Subtarget = &TM.getSubtarget<X86Subtarget>();
138   bool is64Bit = Subtarget->is64Bit();
139
140   if (Subtarget->isTargetEnvMacho()) {
141     if (is64Bit)
142       return new X86_64MachoTargetObjectFile();
143     return new TargetLoweringObjectFileMachO();
144   }
145
146   if (Subtarget->isTargetLinux())
147     return new X86LinuxTargetObjectFile();
148   if (Subtarget->isTargetELF())
149     return new TargetLoweringObjectFileELF();
150   if (Subtarget->isTargetCOFF() && !Subtarget->isTargetEnvMacho())
151     return new TargetLoweringObjectFileCOFF();
152   llvm_unreachable("unknown subtarget type");
153 }
154
155 X86TargetLowering::X86TargetLowering(X86TargetMachine &TM)
156   : TargetLowering(TM, createTLOF(TM)) {
157   Subtarget = &TM.getSubtarget<X86Subtarget>();
158   X86ScalarSSEf64 = Subtarget->hasSSE2();
159   X86ScalarSSEf32 = Subtarget->hasSSE1();
160   X86StackPtr = Subtarget->is64Bit() ? X86::RSP : X86::ESP;
161
162   RegInfo = TM.getRegisterInfo();
163   TD = getTargetData();
164
165   // Set up the TargetLowering object.
166   static const MVT IntVTs[] = { MVT::i8, MVT::i16, MVT::i32, MVT::i64 };
167
168   // X86 is weird, it always uses i8 for shift amounts and setcc results.
169   setBooleanContents(ZeroOrOneBooleanContent);
170   // X86-SSE is even stranger. It uses -1 or 0 for vector masks.
171   setBooleanVectorContents(ZeroOrNegativeOneBooleanContent);
172
173   // For 64-bit since we have so many registers use the ILP scheduler, for
174   // 32-bit code use the register pressure specific scheduling.
175   // For Atom, always use ILP scheduling.
176   if (Subtarget->isAtom())
177     setSchedulingPreference(Sched::ILP);
178   else if (Subtarget->is64Bit())
179     setSchedulingPreference(Sched::ILP);
180   else
181     setSchedulingPreference(Sched::RegPressure);
182   setStackPointerRegisterToSaveRestore(X86StackPtr);
183
184   if (Subtarget->isTargetWindows() && !Subtarget->isTargetCygMing()) {
185     // Setup Windows compiler runtime calls.
186     setLibcallName(RTLIB::SDIV_I64, "_alldiv");
187     setLibcallName(RTLIB::UDIV_I64, "_aulldiv");
188     setLibcallName(RTLIB::SREM_I64, "_allrem");
189     setLibcallName(RTLIB::UREM_I64, "_aullrem");
190     setLibcallName(RTLIB::MUL_I64, "_allmul");
191     setLibcallCallingConv(RTLIB::SDIV_I64, CallingConv::X86_StdCall);
192     setLibcallCallingConv(RTLIB::UDIV_I64, CallingConv::X86_StdCall);
193     setLibcallCallingConv(RTLIB::SREM_I64, CallingConv::X86_StdCall);
194     setLibcallCallingConv(RTLIB::UREM_I64, CallingConv::X86_StdCall);
195     setLibcallCallingConv(RTLIB::MUL_I64, CallingConv::X86_StdCall);
196
197     // The _ftol2 runtime function has an unusual calling conv, which
198     // is modeled by a special pseudo-instruction.
199     setLibcallName(RTLIB::FPTOUINT_F64_I64, 0);
200     setLibcallName(RTLIB::FPTOUINT_F32_I64, 0);
201     setLibcallName(RTLIB::FPTOUINT_F64_I32, 0);
202     setLibcallName(RTLIB::FPTOUINT_F32_I32, 0);
203   }
204
205   if (Subtarget->isTargetDarwin()) {
206     // Darwin should use _setjmp/_longjmp instead of setjmp/longjmp.
207     setUseUnderscoreSetJmp(false);
208     setUseUnderscoreLongJmp(false);
209   } else if (Subtarget->isTargetMingw()) {
210     // MS runtime is weird: it exports _setjmp, but longjmp!
211     setUseUnderscoreSetJmp(true);
212     setUseUnderscoreLongJmp(false);
213   } else {
214     setUseUnderscoreSetJmp(true);
215     setUseUnderscoreLongJmp(true);
216   }
217
218   // Set up the register classes.
219   addRegisterClass(MVT::i8, &X86::GR8RegClass);
220   addRegisterClass(MVT::i16, &X86::GR16RegClass);
221   addRegisterClass(MVT::i32, &X86::GR32RegClass);
222   if (Subtarget->is64Bit())
223     addRegisterClass(MVT::i64, &X86::GR64RegClass);
224
225   setLoadExtAction(ISD::SEXTLOAD, MVT::i1, Promote);
226
227   // We don't accept any truncstore of integer registers.
228   setTruncStoreAction(MVT::i64, MVT::i32, Expand);
229   setTruncStoreAction(MVT::i64, MVT::i16, Expand);
230   setTruncStoreAction(MVT::i64, MVT::i8 , Expand);
231   setTruncStoreAction(MVT::i32, MVT::i16, Expand);
232   setTruncStoreAction(MVT::i32, MVT::i8 , Expand);
233   setTruncStoreAction(MVT::i16, MVT::i8,  Expand);
234
235   // SETOEQ and SETUNE require checking two conditions.
236   setCondCodeAction(ISD::SETOEQ, MVT::f32, Expand);
237   setCondCodeAction(ISD::SETOEQ, MVT::f64, Expand);
238   setCondCodeAction(ISD::SETOEQ, MVT::f80, Expand);
239   setCondCodeAction(ISD::SETUNE, MVT::f32, Expand);
240   setCondCodeAction(ISD::SETUNE, MVT::f64, Expand);
241   setCondCodeAction(ISD::SETUNE, MVT::f80, Expand);
242
243   // Promote all UINT_TO_FP to larger SINT_TO_FP's, as X86 doesn't have this
244   // operation.
245   setOperationAction(ISD::UINT_TO_FP       , MVT::i1   , Promote);
246   setOperationAction(ISD::UINT_TO_FP       , MVT::i8   , Promote);
247   setOperationAction(ISD::UINT_TO_FP       , MVT::i16  , Promote);
248
249   if (Subtarget->is64Bit()) {
250     setOperationAction(ISD::UINT_TO_FP     , MVT::i32  , Promote);
251     setOperationAction(ISD::UINT_TO_FP     , MVT::i64  , Custom);
252   } else if (!TM.Options.UseSoftFloat) {
253     // We have an algorithm for SSE2->double, and we turn this into a
254     // 64-bit FILD followed by conditional FADD for other targets.
255     setOperationAction(ISD::UINT_TO_FP     , MVT::i64  , Custom);
256     // We have an algorithm for SSE2, and we turn this into a 64-bit
257     // FILD for other targets.
258     setOperationAction(ISD::UINT_TO_FP     , MVT::i32  , Custom);
259   }
260
261   // Promote i1/i8 SINT_TO_FP to larger SINT_TO_FP's, as X86 doesn't have
262   // this operation.
263   setOperationAction(ISD::SINT_TO_FP       , MVT::i1   , Promote);
264   setOperationAction(ISD::SINT_TO_FP       , MVT::i8   , Promote);
265
266   if (!TM.Options.UseSoftFloat) {
267     // SSE has no i16 to fp conversion, only i32
268     if (X86ScalarSSEf32) {
269       setOperationAction(ISD::SINT_TO_FP     , MVT::i16  , Promote);
270       // f32 and f64 cases are Legal, f80 case is not
271       setOperationAction(ISD::SINT_TO_FP     , MVT::i32  , Custom);
272     } else {
273       setOperationAction(ISD::SINT_TO_FP     , MVT::i16  , Custom);
274       setOperationAction(ISD::SINT_TO_FP     , MVT::i32  , Custom);
275     }
276   } else {
277     setOperationAction(ISD::SINT_TO_FP     , MVT::i16  , Promote);
278     setOperationAction(ISD::SINT_TO_FP     , MVT::i32  , Promote);
279   }
280
281   // In 32-bit mode these are custom lowered.  In 64-bit mode F32 and F64
282   // are Legal, f80 is custom lowered.
283   setOperationAction(ISD::FP_TO_SINT     , MVT::i64  , Custom);
284   setOperationAction(ISD::SINT_TO_FP     , MVT::i64  , Custom);
285
286   // Promote i1/i8 FP_TO_SINT to larger FP_TO_SINTS's, as X86 doesn't have
287   // this operation.
288   setOperationAction(ISD::FP_TO_SINT       , MVT::i1   , Promote);
289   setOperationAction(ISD::FP_TO_SINT       , MVT::i8   , Promote);
290
291   if (X86ScalarSSEf32) {
292     setOperationAction(ISD::FP_TO_SINT     , MVT::i16  , Promote);
293     // f32 and f64 cases are Legal, f80 case is not
294     setOperationAction(ISD::FP_TO_SINT     , MVT::i32  , Custom);
295   } else {
296     setOperationAction(ISD::FP_TO_SINT     , MVT::i16  , Custom);
297     setOperationAction(ISD::FP_TO_SINT     , MVT::i32  , Custom);
298   }
299
300   // Handle FP_TO_UINT by promoting the destination to a larger signed
301   // conversion.
302   setOperationAction(ISD::FP_TO_UINT       , MVT::i1   , Promote);
303   setOperationAction(ISD::FP_TO_UINT       , MVT::i8   , Promote);
304   setOperationAction(ISD::FP_TO_UINT       , MVT::i16  , Promote);
305
306   if (Subtarget->is64Bit()) {
307     setOperationAction(ISD::FP_TO_UINT     , MVT::i64  , Expand);
308     setOperationAction(ISD::FP_TO_UINT     , MVT::i32  , Promote);
309   } else if (!TM.Options.UseSoftFloat) {
310     // Since AVX is a superset of SSE3, only check for SSE here.
311     if (Subtarget->hasSSE1() && !Subtarget->hasSSE3())
312       // Expand FP_TO_UINT into a select.
313       // FIXME: We would like to use a Custom expander here eventually to do
314       // the optimal thing for SSE vs. the default expansion in the legalizer.
315       setOperationAction(ISD::FP_TO_UINT   , MVT::i32  , Expand);
316     else
317       // With SSE3 we can use fisttpll to convert to a signed i64; without
318       // SSE, we're stuck with a fistpll.
319       setOperationAction(ISD::FP_TO_UINT   , MVT::i32  , Custom);
320   }
321
322   if (isTargetFTOL()) {
323     // Use the _ftol2 runtime function, which has a pseudo-instruction
324     // to handle its weird calling convention.
325     setOperationAction(ISD::FP_TO_UINT     , MVT::i64  , Custom);
326   }
327
328   // TODO: when we have SSE, these could be more efficient, by using movd/movq.
329   if (!X86ScalarSSEf64) {
330     setOperationAction(ISD::BITCAST        , MVT::f32  , Expand);
331     setOperationAction(ISD::BITCAST        , MVT::i32  , Expand);
332     if (Subtarget->is64Bit()) {
333       setOperationAction(ISD::BITCAST      , MVT::f64  , Expand);
334       // Without SSE, i64->f64 goes through memory.
335       setOperationAction(ISD::BITCAST      , MVT::i64  , Expand);
336     }
337   }
338
339   // Scalar integer divide and remainder are lowered to use operations that
340   // produce two results, to match the available instructions. This exposes
341   // the two-result form to trivial CSE, which is able to combine x/y and x%y
342   // into a single instruction.
343   //
344   // Scalar integer multiply-high is also lowered to use two-result
345   // operations, to match the available instructions. However, plain multiply
346   // (low) operations are left as Legal, as there are single-result
347   // instructions for this in x86. Using the two-result multiply instructions
348   // when both high and low results are needed must be arranged by dagcombine.
349   for (unsigned i = 0; i != array_lengthof(IntVTs); ++i) {
350     MVT VT = IntVTs[i];
351     setOperationAction(ISD::MULHS, VT, Expand);
352     setOperationAction(ISD::MULHU, VT, Expand);
353     setOperationAction(ISD::SDIV, VT, Expand);
354     setOperationAction(ISD::UDIV, VT, Expand);
355     setOperationAction(ISD::SREM, VT, Expand);
356     setOperationAction(ISD::UREM, VT, Expand);
357
358     // Add/Sub overflow ops with MVT::Glues are lowered to EFLAGS dependences.
359     setOperationAction(ISD::ADDC, VT, Custom);
360     setOperationAction(ISD::ADDE, VT, Custom);
361     setOperationAction(ISD::SUBC, VT, Custom);
362     setOperationAction(ISD::SUBE, VT, Custom);
363   }
364
365   setOperationAction(ISD::BR_JT            , MVT::Other, Expand);
366   setOperationAction(ISD::BRCOND           , MVT::Other, Custom);
367   setOperationAction(ISD::BR_CC            , MVT::Other, Expand);
368   setOperationAction(ISD::SELECT_CC        , MVT::Other, Expand);
369   if (Subtarget->is64Bit())
370     setOperationAction(ISD::SIGN_EXTEND_INREG, MVT::i32, Legal);
371   setOperationAction(ISD::SIGN_EXTEND_INREG, MVT::i16  , Legal);
372   setOperationAction(ISD::SIGN_EXTEND_INREG, MVT::i8   , Legal);
373   setOperationAction(ISD::SIGN_EXTEND_INREG, MVT::i1   , Expand);
374   setOperationAction(ISD::FP_ROUND_INREG   , MVT::f32  , Expand);
375   setOperationAction(ISD::FREM             , MVT::f32  , Expand);
376   setOperationAction(ISD::FREM             , MVT::f64  , Expand);
377   setOperationAction(ISD::FREM             , MVT::f80  , Expand);
378   setOperationAction(ISD::FLT_ROUNDS_      , MVT::i32  , Custom);
379
380   // Promote the i8 variants and force them on up to i32 which has a shorter
381   // encoding.
382   setOperationAction(ISD::CTTZ             , MVT::i8   , Promote);
383   AddPromotedToType (ISD::CTTZ             , MVT::i8   , MVT::i32);
384   setOperationAction(ISD::CTTZ_ZERO_UNDEF  , MVT::i8   , Promote);
385   AddPromotedToType (ISD::CTTZ_ZERO_UNDEF  , MVT::i8   , MVT::i32);
386   if (Subtarget->hasBMI()) {
387     setOperationAction(ISD::CTTZ_ZERO_UNDEF, MVT::i16  , Expand);
388     setOperationAction(ISD::CTTZ_ZERO_UNDEF, MVT::i32  , Expand);
389     if (Subtarget->is64Bit())
390       setOperationAction(ISD::CTTZ_ZERO_UNDEF, MVT::i64, Expand);
391   } else {
392     setOperationAction(ISD::CTTZ           , MVT::i16  , Custom);
393     setOperationAction(ISD::CTTZ           , MVT::i32  , Custom);
394     if (Subtarget->is64Bit())
395       setOperationAction(ISD::CTTZ         , MVT::i64  , Custom);
396   }
397
398   if (Subtarget->hasLZCNT()) {
399     // When promoting the i8 variants, force them to i32 for a shorter
400     // encoding.
401     setOperationAction(ISD::CTLZ           , MVT::i8   , Promote);
402     AddPromotedToType (ISD::CTLZ           , MVT::i8   , MVT::i32);
403     setOperationAction(ISD::CTLZ_ZERO_UNDEF, MVT::i8   , Promote);
404     AddPromotedToType (ISD::CTLZ_ZERO_UNDEF, MVT::i8   , MVT::i32);
405     setOperationAction(ISD::CTLZ_ZERO_UNDEF, MVT::i16  , Expand);
406     setOperationAction(ISD::CTLZ_ZERO_UNDEF, MVT::i32  , Expand);
407     if (Subtarget->is64Bit())
408       setOperationAction(ISD::CTLZ_ZERO_UNDEF, MVT::i64, Expand);
409   } else {
410     setOperationAction(ISD::CTLZ           , MVT::i8   , Custom);
411     setOperationAction(ISD::CTLZ           , MVT::i16  , Custom);
412     setOperationAction(ISD::CTLZ           , MVT::i32  , Custom);
413     setOperationAction(ISD::CTLZ_ZERO_UNDEF, MVT::i8   , Custom);
414     setOperationAction(ISD::CTLZ_ZERO_UNDEF, MVT::i16  , Custom);
415     setOperationAction(ISD::CTLZ_ZERO_UNDEF, MVT::i32  , Custom);
416     if (Subtarget->is64Bit()) {
417       setOperationAction(ISD::CTLZ         , MVT::i64  , Custom);
418       setOperationAction(ISD::CTLZ_ZERO_UNDEF, MVT::i64, Custom);
419     }
420   }
421
422   if (Subtarget->hasPOPCNT()) {
423     setOperationAction(ISD::CTPOP          , MVT::i8   , Promote);
424   } else {
425     setOperationAction(ISD::CTPOP          , MVT::i8   , Expand);
426     setOperationAction(ISD::CTPOP          , MVT::i16  , Expand);
427     setOperationAction(ISD::CTPOP          , MVT::i32  , Expand);
428     if (Subtarget->is64Bit())
429       setOperationAction(ISD::CTPOP        , MVT::i64  , Expand);
430   }
431
432   setOperationAction(ISD::READCYCLECOUNTER , MVT::i64  , Custom);
433   setOperationAction(ISD::BSWAP            , MVT::i16  , Expand);
434
435   // These should be promoted to a larger select which is supported.
436   setOperationAction(ISD::SELECT          , MVT::i1   , Promote);
437   // X86 wants to expand cmov itself.
438   setOperationAction(ISD::SELECT          , MVT::i8   , Custom);
439   setOperationAction(ISD::SELECT          , MVT::i16  , Custom);
440   setOperationAction(ISD::SELECT          , MVT::i32  , Custom);
441   setOperationAction(ISD::SELECT          , MVT::f32  , Custom);
442   setOperationAction(ISD::SELECT          , MVT::f64  , Custom);
443   setOperationAction(ISD::SELECT          , MVT::f80  , Custom);
444   setOperationAction(ISD::SETCC           , MVT::i8   , Custom);
445   setOperationAction(ISD::SETCC           , MVT::i16  , Custom);
446   setOperationAction(ISD::SETCC           , MVT::i32  , Custom);
447   setOperationAction(ISD::SETCC           , MVT::f32  , Custom);
448   setOperationAction(ISD::SETCC           , MVT::f64  , Custom);
449   setOperationAction(ISD::SETCC           , MVT::f80  , Custom);
450   if (Subtarget->is64Bit()) {
451     setOperationAction(ISD::SELECT        , MVT::i64  , Custom);
452     setOperationAction(ISD::SETCC         , MVT::i64  , Custom);
453   }
454   setOperationAction(ISD::EH_RETURN       , MVT::Other, Custom);
455
456   // Darwin ABI issue.
457   setOperationAction(ISD::ConstantPool    , MVT::i32  , Custom);
458   setOperationAction(ISD::JumpTable       , MVT::i32  , Custom);
459   setOperationAction(ISD::GlobalAddress   , MVT::i32  , Custom);
460   setOperationAction(ISD::GlobalTLSAddress, MVT::i32  , Custom);
461   if (Subtarget->is64Bit())
462     setOperationAction(ISD::GlobalTLSAddress, MVT::i64, Custom);
463   setOperationAction(ISD::ExternalSymbol  , MVT::i32  , Custom);
464   setOperationAction(ISD::BlockAddress    , MVT::i32  , Custom);
465   if (Subtarget->is64Bit()) {
466     setOperationAction(ISD::ConstantPool  , MVT::i64  , Custom);
467     setOperationAction(ISD::JumpTable     , MVT::i64  , Custom);
468     setOperationAction(ISD::GlobalAddress , MVT::i64  , Custom);
469     setOperationAction(ISD::ExternalSymbol, MVT::i64  , Custom);
470     setOperationAction(ISD::BlockAddress  , MVT::i64  , Custom);
471   }
472   // 64-bit addm sub, shl, sra, srl (iff 32-bit x86)
473   setOperationAction(ISD::SHL_PARTS       , MVT::i32  , Custom);
474   setOperationAction(ISD::SRA_PARTS       , MVT::i32  , Custom);
475   setOperationAction(ISD::SRL_PARTS       , MVT::i32  , Custom);
476   if (Subtarget->is64Bit()) {
477     setOperationAction(ISD::SHL_PARTS     , MVT::i64  , Custom);
478     setOperationAction(ISD::SRA_PARTS     , MVT::i64  , Custom);
479     setOperationAction(ISD::SRL_PARTS     , MVT::i64  , Custom);
480   }
481
482   if (Subtarget->hasSSE1())
483     setOperationAction(ISD::PREFETCH      , MVT::Other, Legal);
484
485   setOperationAction(ISD::MEMBARRIER    , MVT::Other, Custom);
486   setOperationAction(ISD::ATOMIC_FENCE  , MVT::Other, Custom);
487
488   // On X86 and X86-64, atomic operations are lowered to locked instructions.
489   // Locked instructions, in turn, have implicit fence semantics (all memory
490   // operations are flushed before issuing the locked instruction, and they
491   // are not buffered), so we can fold away the common pattern of
492   // fence-atomic-fence.
493   setShouldFoldAtomicFences(true);
494
495   // Expand certain atomics
496   for (unsigned i = 0; i != array_lengthof(IntVTs); ++i) {
497     MVT VT = IntVTs[i];
498     setOperationAction(ISD::ATOMIC_CMP_SWAP, VT, Custom);
499     setOperationAction(ISD::ATOMIC_LOAD_SUB, VT, Custom);
500     setOperationAction(ISD::ATOMIC_STORE, VT, Custom);
501   }
502
503   if (!Subtarget->is64Bit()) {
504     setOperationAction(ISD::ATOMIC_LOAD, MVT::i64, Custom);
505     setOperationAction(ISD::ATOMIC_LOAD_ADD, MVT::i64, Custom);
506     setOperationAction(ISD::ATOMIC_LOAD_SUB, MVT::i64, Custom);
507     setOperationAction(ISD::ATOMIC_LOAD_AND, MVT::i64, Custom);
508     setOperationAction(ISD::ATOMIC_LOAD_OR, MVT::i64, Custom);
509     setOperationAction(ISD::ATOMIC_LOAD_XOR, MVT::i64, Custom);
510     setOperationAction(ISD::ATOMIC_LOAD_NAND, MVT::i64, Custom);
511     setOperationAction(ISD::ATOMIC_SWAP, MVT::i64, Custom);
512   }
513
514   if (Subtarget->hasCmpxchg16b()) {
515     setOperationAction(ISD::ATOMIC_CMP_SWAP, MVT::i128, Custom);
516   }
517
518   // FIXME - use subtarget debug flags
519   if (!Subtarget->isTargetDarwin() &&
520       !Subtarget->isTargetELF() &&
521       !Subtarget->isTargetCygMing()) {
522     setOperationAction(ISD::EH_LABEL, MVT::Other, Expand);
523   }
524
525   setOperationAction(ISD::EXCEPTIONADDR, MVT::i64, Expand);
526   setOperationAction(ISD::EHSELECTION,   MVT::i64, Expand);
527   setOperationAction(ISD::EXCEPTIONADDR, MVT::i32, Expand);
528   setOperationAction(ISD::EHSELECTION,   MVT::i32, Expand);
529   if (Subtarget->is64Bit()) {
530     setExceptionPointerRegister(X86::RAX);
531     setExceptionSelectorRegister(X86::RDX);
532   } else {
533     setExceptionPointerRegister(X86::EAX);
534     setExceptionSelectorRegister(X86::EDX);
535   }
536   setOperationAction(ISD::FRAME_TO_ARGS_OFFSET, MVT::i32, Custom);
537   setOperationAction(ISD::FRAME_TO_ARGS_OFFSET, MVT::i64, Custom);
538
539   setOperationAction(ISD::INIT_TRAMPOLINE, MVT::Other, Custom);
540   setOperationAction(ISD::ADJUST_TRAMPOLINE, MVT::Other, Custom);
541
542   setOperationAction(ISD::TRAP, MVT::Other, Legal);
543
544   // VASTART needs to be custom lowered to use the VarArgsFrameIndex
545   setOperationAction(ISD::VASTART           , MVT::Other, Custom);
546   setOperationAction(ISD::VAEND             , MVT::Other, Expand);
547   if (Subtarget->is64Bit()) {
548     setOperationAction(ISD::VAARG           , MVT::Other, Custom);
549     setOperationAction(ISD::VACOPY          , MVT::Other, Custom);
550   } else {
551     setOperationAction(ISD::VAARG           , MVT::Other, Expand);
552     setOperationAction(ISD::VACOPY          , MVT::Other, Expand);
553   }
554
555   setOperationAction(ISD::STACKSAVE,          MVT::Other, Expand);
556   setOperationAction(ISD::STACKRESTORE,       MVT::Other, Expand);
557
558   if (Subtarget->isTargetCOFF() && !Subtarget->isTargetEnvMacho())
559     setOperationAction(ISD::DYNAMIC_STACKALLOC, Subtarget->is64Bit() ?
560                        MVT::i64 : MVT::i32, Custom);
561   else if (TM.Options.EnableSegmentedStacks)
562     setOperationAction(ISD::DYNAMIC_STACKALLOC, Subtarget->is64Bit() ?
563                        MVT::i64 : MVT::i32, Custom);
564   else
565     setOperationAction(ISD::DYNAMIC_STACKALLOC, Subtarget->is64Bit() ?
566                        MVT::i64 : MVT::i32, Expand);
567
568   if (!TM.Options.UseSoftFloat && X86ScalarSSEf64) {
569     // f32 and f64 use SSE.
570     // Set up the FP register classes.
571     addRegisterClass(MVT::f32, &X86::FR32RegClass);
572     addRegisterClass(MVT::f64, &X86::FR64RegClass);
573
574     // Use ANDPD to simulate FABS.
575     setOperationAction(ISD::FABS , MVT::f64, Custom);
576     setOperationAction(ISD::FABS , MVT::f32, Custom);
577
578     // Use XORP to simulate FNEG.
579     setOperationAction(ISD::FNEG , MVT::f64, Custom);
580     setOperationAction(ISD::FNEG , MVT::f32, Custom);
581
582     // Use ANDPD and ORPD to simulate FCOPYSIGN.
583     setOperationAction(ISD::FCOPYSIGN, MVT::f64, Custom);
584     setOperationAction(ISD::FCOPYSIGN, MVT::f32, Custom);
585
586     // Lower this to FGETSIGNx86 plus an AND.
587     setOperationAction(ISD::FGETSIGN, MVT::i64, Custom);
588     setOperationAction(ISD::FGETSIGN, MVT::i32, Custom);
589
590     // We don't support sin/cos/fmod
591     setOperationAction(ISD::FSIN , MVT::f64, Expand);
592     setOperationAction(ISD::FCOS , MVT::f64, Expand);
593     setOperationAction(ISD::FSIN , MVT::f32, Expand);
594     setOperationAction(ISD::FCOS , MVT::f32, Expand);
595
596     // Expand FP immediates into loads from the stack, except for the special
597     // cases we handle.
598     addLegalFPImmediate(APFloat(+0.0)); // xorpd
599     addLegalFPImmediate(APFloat(+0.0f)); // xorps
600   } else if (!TM.Options.UseSoftFloat && X86ScalarSSEf32) {
601     // Use SSE for f32, x87 for f64.
602     // Set up the FP register classes.
603     addRegisterClass(MVT::f32, &X86::FR32RegClass);
604     addRegisterClass(MVT::f64, &X86::RFP64RegClass);
605
606     // Use ANDPS to simulate FABS.
607     setOperationAction(ISD::FABS , MVT::f32, Custom);
608
609     // Use XORP to simulate FNEG.
610     setOperationAction(ISD::FNEG , MVT::f32, Custom);
611
612     setOperationAction(ISD::UNDEF,     MVT::f64, Expand);
613
614     // Use ANDPS and ORPS to simulate FCOPYSIGN.
615     setOperationAction(ISD::FCOPYSIGN, MVT::f64, Expand);
616     setOperationAction(ISD::FCOPYSIGN, MVT::f32, Custom);
617
618     // We don't support sin/cos/fmod
619     setOperationAction(ISD::FSIN , MVT::f32, Expand);
620     setOperationAction(ISD::FCOS , MVT::f32, Expand);
621
622     // Special cases we handle for FP constants.
623     addLegalFPImmediate(APFloat(+0.0f)); // xorps
624     addLegalFPImmediate(APFloat(+0.0)); // FLD0
625     addLegalFPImmediate(APFloat(+1.0)); // FLD1
626     addLegalFPImmediate(APFloat(-0.0)); // FLD0/FCHS
627     addLegalFPImmediate(APFloat(-1.0)); // FLD1/FCHS
628
629     if (!TM.Options.UnsafeFPMath) {
630       setOperationAction(ISD::FSIN           , MVT::f64  , Expand);
631       setOperationAction(ISD::FCOS           , MVT::f64  , Expand);
632     }
633   } else if (!TM.Options.UseSoftFloat) {
634     // f32 and f64 in x87.
635     // Set up the FP register classes.
636     addRegisterClass(MVT::f64, &X86::RFP64RegClass);
637     addRegisterClass(MVT::f32, &X86::RFP32RegClass);
638
639     setOperationAction(ISD::UNDEF,     MVT::f64, Expand);
640     setOperationAction(ISD::UNDEF,     MVT::f32, Expand);
641     setOperationAction(ISD::FCOPYSIGN, MVT::f64, Expand);
642     setOperationAction(ISD::FCOPYSIGN, MVT::f32, Expand);
643
644     if (!TM.Options.UnsafeFPMath) {
645       setOperationAction(ISD::FSIN           , MVT::f64  , Expand);
646       setOperationAction(ISD::FCOS           , MVT::f64  , Expand);
647     }
648     addLegalFPImmediate(APFloat(+0.0)); // FLD0
649     addLegalFPImmediate(APFloat(+1.0)); // FLD1
650     addLegalFPImmediate(APFloat(-0.0)); // FLD0/FCHS
651     addLegalFPImmediate(APFloat(-1.0)); // FLD1/FCHS
652     addLegalFPImmediate(APFloat(+0.0f)); // FLD0
653     addLegalFPImmediate(APFloat(+1.0f)); // FLD1
654     addLegalFPImmediate(APFloat(-0.0f)); // FLD0/FCHS
655     addLegalFPImmediate(APFloat(-1.0f)); // FLD1/FCHS
656   }
657
658   // We don't support FMA.
659   setOperationAction(ISD::FMA, MVT::f64, Expand);
660   setOperationAction(ISD::FMA, MVT::f32, Expand);
661
662   // Long double always uses X87.
663   if (!TM.Options.UseSoftFloat) {
664     addRegisterClass(MVT::f80, &X86::RFP80RegClass);
665     setOperationAction(ISD::UNDEF,     MVT::f80, Expand);
666     setOperationAction(ISD::FCOPYSIGN, MVT::f80, Expand);
667     {
668       APFloat TmpFlt = APFloat::getZero(APFloat::x87DoubleExtended);
669       addLegalFPImmediate(TmpFlt);  // FLD0
670       TmpFlt.changeSign();
671       addLegalFPImmediate(TmpFlt);  // FLD0/FCHS
672
673       bool ignored;
674       APFloat TmpFlt2(+1.0);
675       TmpFlt2.convert(APFloat::x87DoubleExtended, APFloat::rmNearestTiesToEven,
676                       &ignored);
677       addLegalFPImmediate(TmpFlt2);  // FLD1
678       TmpFlt2.changeSign();
679       addLegalFPImmediate(TmpFlt2);  // FLD1/FCHS
680     }
681
682     if (!TM.Options.UnsafeFPMath) {
683       setOperationAction(ISD::FSIN           , MVT::f80  , Expand);
684       setOperationAction(ISD::FCOS           , MVT::f80  , Expand);
685     }
686
687     setOperationAction(ISD::FFLOOR, MVT::f80, Expand);
688     setOperationAction(ISD::FCEIL,  MVT::f80, Expand);
689     setOperationAction(ISD::FTRUNC, MVT::f80, Expand);
690     setOperationAction(ISD::FRINT,  MVT::f80, Expand);
691     setOperationAction(ISD::FNEARBYINT, MVT::f80, Expand);
692     setOperationAction(ISD::FMA, MVT::f80, Expand);
693   }
694
695   // Always use a library call for pow.
696   setOperationAction(ISD::FPOW             , MVT::f32  , Expand);
697   setOperationAction(ISD::FPOW             , MVT::f64  , Expand);
698   setOperationAction(ISD::FPOW             , MVT::f80  , Expand);
699
700   setOperationAction(ISD::FLOG, MVT::f80, Expand);
701   setOperationAction(ISD::FLOG2, MVT::f80, Expand);
702   setOperationAction(ISD::FLOG10, MVT::f80, Expand);
703   setOperationAction(ISD::FEXP, MVT::f80, Expand);
704   setOperationAction(ISD::FEXP2, MVT::f80, Expand);
705
706   // First set operation action for all vector types to either promote
707   // (for widening) or expand (for scalarization). Then we will selectively
708   // turn on ones that can be effectively codegen'd.
709   for (int VT = MVT::FIRST_VECTOR_VALUETYPE;
710            VT <= MVT::LAST_VECTOR_VALUETYPE; ++VT) {
711     setOperationAction(ISD::ADD , (MVT::SimpleValueType)VT, Expand);
712     setOperationAction(ISD::SUB , (MVT::SimpleValueType)VT, Expand);
713     setOperationAction(ISD::FADD, (MVT::SimpleValueType)VT, Expand);
714     setOperationAction(ISD::FNEG, (MVT::SimpleValueType)VT, Expand);
715     setOperationAction(ISD::FSUB, (MVT::SimpleValueType)VT, Expand);
716     setOperationAction(ISD::MUL , (MVT::SimpleValueType)VT, Expand);
717     setOperationAction(ISD::FMUL, (MVT::SimpleValueType)VT, Expand);
718     setOperationAction(ISD::SDIV, (MVT::SimpleValueType)VT, Expand);
719     setOperationAction(ISD::UDIV, (MVT::SimpleValueType)VT, Expand);
720     setOperationAction(ISD::FDIV, (MVT::SimpleValueType)VT, Expand);
721     setOperationAction(ISD::SREM, (MVT::SimpleValueType)VT, Expand);
722     setOperationAction(ISD::UREM, (MVT::SimpleValueType)VT, Expand);
723     setOperationAction(ISD::LOAD, (MVT::SimpleValueType)VT, Expand);
724     setOperationAction(ISD::VECTOR_SHUFFLE, (MVT::SimpleValueType)VT, Expand);
725     setOperationAction(ISD::EXTRACT_VECTOR_ELT,(MVT::SimpleValueType)VT,Expand);
726     setOperationAction(ISD::INSERT_VECTOR_ELT,(MVT::SimpleValueType)VT, Expand);
727     setOperationAction(ISD::EXTRACT_SUBVECTOR,(MVT::SimpleValueType)VT,Expand);
728     setOperationAction(ISD::INSERT_SUBVECTOR,(MVT::SimpleValueType)VT,Expand);
729     setOperationAction(ISD::FABS, (MVT::SimpleValueType)VT, Expand);
730     setOperationAction(ISD::FSIN, (MVT::SimpleValueType)VT, Expand);
731     setOperationAction(ISD::FCOS, (MVT::SimpleValueType)VT, Expand);
732     setOperationAction(ISD::FREM, (MVT::SimpleValueType)VT, Expand);
733     setOperationAction(ISD::FMA,  (MVT::SimpleValueType)VT, Expand);
734     setOperationAction(ISD::FPOWI, (MVT::SimpleValueType)VT, Expand);
735     setOperationAction(ISD::FSQRT, (MVT::SimpleValueType)VT, Expand);
736     setOperationAction(ISD::FCOPYSIGN, (MVT::SimpleValueType)VT, Expand);
737     setOperationAction(ISD::SMUL_LOHI, (MVT::SimpleValueType)VT, Expand);
738     setOperationAction(ISD::UMUL_LOHI, (MVT::SimpleValueType)VT, Expand);
739     setOperationAction(ISD::SDIVREM, (MVT::SimpleValueType)VT, Expand);
740     setOperationAction(ISD::UDIVREM, (MVT::SimpleValueType)VT, Expand);
741     setOperationAction(ISD::FPOW, (MVT::SimpleValueType)VT, Expand);
742     setOperationAction(ISD::CTPOP, (MVT::SimpleValueType)VT, Expand);
743     setOperationAction(ISD::CTTZ, (MVT::SimpleValueType)VT, Expand);
744     setOperationAction(ISD::CTTZ_ZERO_UNDEF, (MVT::SimpleValueType)VT, Expand);
745     setOperationAction(ISD::CTLZ, (MVT::SimpleValueType)VT, Expand);
746     setOperationAction(ISD::CTLZ_ZERO_UNDEF, (MVT::SimpleValueType)VT, Expand);
747     setOperationAction(ISD::SHL, (MVT::SimpleValueType)VT, Expand);
748     setOperationAction(ISD::SRA, (MVT::SimpleValueType)VT, Expand);
749     setOperationAction(ISD::SRL, (MVT::SimpleValueType)VT, Expand);
750     setOperationAction(ISD::ROTL, (MVT::SimpleValueType)VT, Expand);
751     setOperationAction(ISD::ROTR, (MVT::SimpleValueType)VT, Expand);
752     setOperationAction(ISD::BSWAP, (MVT::SimpleValueType)VT, Expand);
753     setOperationAction(ISD::SETCC, (MVT::SimpleValueType)VT, Expand);
754     setOperationAction(ISD::FLOG, (MVT::SimpleValueType)VT, Expand);
755     setOperationAction(ISD::FLOG2, (MVT::SimpleValueType)VT, Expand);
756     setOperationAction(ISD::FLOG10, (MVT::SimpleValueType)VT, Expand);
757     setOperationAction(ISD::FEXP, (MVT::SimpleValueType)VT, Expand);
758     setOperationAction(ISD::FEXP2, (MVT::SimpleValueType)VT, Expand);
759     setOperationAction(ISD::FP_TO_UINT, (MVT::SimpleValueType)VT, Expand);
760     setOperationAction(ISD::FP_TO_SINT, (MVT::SimpleValueType)VT, Expand);
761     setOperationAction(ISD::UINT_TO_FP, (MVT::SimpleValueType)VT, Expand);
762     setOperationAction(ISD::SINT_TO_FP, (MVT::SimpleValueType)VT, Expand);
763     setOperationAction(ISD::SIGN_EXTEND_INREG, (MVT::SimpleValueType)VT,Expand);
764     setOperationAction(ISD::TRUNCATE,  (MVT::SimpleValueType)VT, Expand);
765     setOperationAction(ISD::SIGN_EXTEND,  (MVT::SimpleValueType)VT, Expand);
766     setOperationAction(ISD::ZERO_EXTEND,  (MVT::SimpleValueType)VT, Expand);
767     setOperationAction(ISD::ANY_EXTEND,  (MVT::SimpleValueType)VT, Expand);
768     setOperationAction(ISD::VSELECT,  (MVT::SimpleValueType)VT, Expand);
769     for (int InnerVT = MVT::FIRST_VECTOR_VALUETYPE;
770              InnerVT <= MVT::LAST_VECTOR_VALUETYPE; ++InnerVT)
771       setTruncStoreAction((MVT::SimpleValueType)VT,
772                           (MVT::SimpleValueType)InnerVT, Expand);
773     setLoadExtAction(ISD::SEXTLOAD, (MVT::SimpleValueType)VT, Expand);
774     setLoadExtAction(ISD::ZEXTLOAD, (MVT::SimpleValueType)VT, Expand);
775     setLoadExtAction(ISD::EXTLOAD, (MVT::SimpleValueType)VT, Expand);
776   }
777
778   // FIXME: In order to prevent SSE instructions being expanded to MMX ones
779   // with -msoft-float, disable use of MMX as well.
780   if (!TM.Options.UseSoftFloat && Subtarget->hasMMX()) {
781     addRegisterClass(MVT::x86mmx, &X86::VR64RegClass);
782     // No operations on x86mmx supported, everything uses intrinsics.
783   }
784
785   // MMX-sized vectors (other than x86mmx) are expected to be expanded
786   // into smaller operations.
787   setOperationAction(ISD::MULHS,              MVT::v8i8,  Expand);
788   setOperationAction(ISD::MULHS,              MVT::v4i16, Expand);
789   setOperationAction(ISD::MULHS,              MVT::v2i32, Expand);
790   setOperationAction(ISD::MULHS,              MVT::v1i64, Expand);
791   setOperationAction(ISD::AND,                MVT::v8i8,  Expand);
792   setOperationAction(ISD::AND,                MVT::v4i16, Expand);
793   setOperationAction(ISD::AND,                MVT::v2i32, Expand);
794   setOperationAction(ISD::AND,                MVT::v1i64, Expand);
795   setOperationAction(ISD::OR,                 MVT::v8i8,  Expand);
796   setOperationAction(ISD::OR,                 MVT::v4i16, Expand);
797   setOperationAction(ISD::OR,                 MVT::v2i32, Expand);
798   setOperationAction(ISD::OR,                 MVT::v1i64, Expand);
799   setOperationAction(ISD::XOR,                MVT::v8i8,  Expand);
800   setOperationAction(ISD::XOR,                MVT::v4i16, Expand);
801   setOperationAction(ISD::XOR,                MVT::v2i32, Expand);
802   setOperationAction(ISD::XOR,                MVT::v1i64, Expand);
803   setOperationAction(ISD::SCALAR_TO_VECTOR,   MVT::v8i8,  Expand);
804   setOperationAction(ISD::SCALAR_TO_VECTOR,   MVT::v4i16, Expand);
805   setOperationAction(ISD::SCALAR_TO_VECTOR,   MVT::v2i32, Expand);
806   setOperationAction(ISD::SCALAR_TO_VECTOR,   MVT::v1i64, Expand);
807   setOperationAction(ISD::INSERT_VECTOR_ELT,  MVT::v1i64, Expand);
808   setOperationAction(ISD::SELECT,             MVT::v8i8,  Expand);
809   setOperationAction(ISD::SELECT,             MVT::v4i16, Expand);
810   setOperationAction(ISD::SELECT,             MVT::v2i32, Expand);
811   setOperationAction(ISD::SELECT,             MVT::v1i64, Expand);
812   setOperationAction(ISD::BITCAST,            MVT::v8i8,  Expand);
813   setOperationAction(ISD::BITCAST,            MVT::v4i16, Expand);
814   setOperationAction(ISD::BITCAST,            MVT::v2i32, Expand);
815   setOperationAction(ISD::BITCAST,            MVT::v1i64, Expand);
816
817   if (!TM.Options.UseSoftFloat && Subtarget->hasSSE1()) {
818     addRegisterClass(MVT::v4f32, &X86::VR128RegClass);
819
820     setOperationAction(ISD::FADD,               MVT::v4f32, Legal);
821     setOperationAction(ISD::FSUB,               MVT::v4f32, Legal);
822     setOperationAction(ISD::FMUL,               MVT::v4f32, Legal);
823     setOperationAction(ISD::FDIV,               MVT::v4f32, Legal);
824     setOperationAction(ISD::FSQRT,              MVT::v4f32, Legal);
825     setOperationAction(ISD::FNEG,               MVT::v4f32, Custom);
826     setOperationAction(ISD::LOAD,               MVT::v4f32, Legal);
827     setOperationAction(ISD::BUILD_VECTOR,       MVT::v4f32, Custom);
828     setOperationAction(ISD::VECTOR_SHUFFLE,     MVT::v4f32, Custom);
829     setOperationAction(ISD::EXTRACT_VECTOR_ELT, MVT::v4f32, Custom);
830     setOperationAction(ISD::SELECT,             MVT::v4f32, Custom);
831     setOperationAction(ISD::SETCC,              MVT::v4f32, Custom);
832   }
833
834   if (!TM.Options.UseSoftFloat && Subtarget->hasSSE2()) {
835     addRegisterClass(MVT::v2f64, &X86::VR128RegClass);
836
837     // FIXME: Unfortunately -soft-float and -no-implicit-float means XMM
838     // registers cannot be used even for integer operations.
839     addRegisterClass(MVT::v16i8, &X86::VR128RegClass);
840     addRegisterClass(MVT::v8i16, &X86::VR128RegClass);
841     addRegisterClass(MVT::v4i32, &X86::VR128RegClass);
842     addRegisterClass(MVT::v2i64, &X86::VR128RegClass);
843
844     setOperationAction(ISD::ADD,                MVT::v16i8, Legal);
845     setOperationAction(ISD::ADD,                MVT::v8i16, Legal);
846     setOperationAction(ISD::ADD,                MVT::v4i32, Legal);
847     setOperationAction(ISD::ADD,                MVT::v2i64, Legal);
848     setOperationAction(ISD::MUL,                MVT::v2i64, Custom);
849     setOperationAction(ISD::SUB,                MVT::v16i8, Legal);
850     setOperationAction(ISD::SUB,                MVT::v8i16, Legal);
851     setOperationAction(ISD::SUB,                MVT::v4i32, Legal);
852     setOperationAction(ISD::SUB,                MVT::v2i64, Legal);
853     setOperationAction(ISD::MUL,                MVT::v8i16, Legal);
854     setOperationAction(ISD::FADD,               MVT::v2f64, Legal);
855     setOperationAction(ISD::FSUB,               MVT::v2f64, Legal);
856     setOperationAction(ISD::FMUL,               MVT::v2f64, Legal);
857     setOperationAction(ISD::FDIV,               MVT::v2f64, Legal);
858     setOperationAction(ISD::FSQRT,              MVT::v2f64, Legal);
859     setOperationAction(ISD::FNEG,               MVT::v2f64, Custom);
860
861     setOperationAction(ISD::SETCC,              MVT::v2i64, Custom);
862     setOperationAction(ISD::SETCC,              MVT::v16i8, Custom);
863     setOperationAction(ISD::SETCC,              MVT::v8i16, Custom);
864     setOperationAction(ISD::SETCC,              MVT::v4i32, Custom);
865
866     setOperationAction(ISD::SCALAR_TO_VECTOR,   MVT::v16i8, Custom);
867     setOperationAction(ISD::SCALAR_TO_VECTOR,   MVT::v8i16, Custom);
868     setOperationAction(ISD::INSERT_VECTOR_ELT,  MVT::v8i16, Custom);
869     setOperationAction(ISD::INSERT_VECTOR_ELT,  MVT::v4i32, Custom);
870     setOperationAction(ISD::INSERT_VECTOR_ELT,  MVT::v4f32, Custom);
871
872     setOperationAction(ISD::CONCAT_VECTORS,     MVT::v2f64, Custom);
873     setOperationAction(ISD::CONCAT_VECTORS,     MVT::v2i64, Custom);
874     setOperationAction(ISD::CONCAT_VECTORS,     MVT::v16i8, Custom);
875     setOperationAction(ISD::CONCAT_VECTORS,     MVT::v8i16, Custom);
876     setOperationAction(ISD::CONCAT_VECTORS,     MVT::v4i32, Custom);
877
878     // Custom lower build_vector, vector_shuffle, and extract_vector_elt.
879     for (int i = MVT::v16i8; i != MVT::v2i64; ++i) {
880       EVT VT = (MVT::SimpleValueType)i;
881       // Do not attempt to custom lower non-power-of-2 vectors
882       if (!isPowerOf2_32(VT.getVectorNumElements()))
883         continue;
884       // Do not attempt to custom lower non-128-bit vectors
885       if (!VT.is128BitVector())
886         continue;
887       setOperationAction(ISD::BUILD_VECTOR,
888                          VT.getSimpleVT().SimpleTy, Custom);
889       setOperationAction(ISD::VECTOR_SHUFFLE,
890                          VT.getSimpleVT().SimpleTy, Custom);
891       setOperationAction(ISD::EXTRACT_VECTOR_ELT,
892                          VT.getSimpleVT().SimpleTy, Custom);
893     }
894
895     setOperationAction(ISD::BUILD_VECTOR,       MVT::v2f64, Custom);
896     setOperationAction(ISD::BUILD_VECTOR,       MVT::v2i64, Custom);
897     setOperationAction(ISD::VECTOR_SHUFFLE,     MVT::v2f64, Custom);
898     setOperationAction(ISD::VECTOR_SHUFFLE,     MVT::v2i64, Custom);
899     setOperationAction(ISD::INSERT_VECTOR_ELT,  MVT::v2f64, Custom);
900     setOperationAction(ISD::EXTRACT_VECTOR_ELT, MVT::v2f64, Custom);
901
902     if (Subtarget->is64Bit()) {
903       setOperationAction(ISD::INSERT_VECTOR_ELT,  MVT::v2i64, Custom);
904       setOperationAction(ISD::EXTRACT_VECTOR_ELT, MVT::v2i64, Custom);
905     }
906
907     // Promote v16i8, v8i16, v4i32 load, select, and, or, xor to v2i64.
908     for (int i = MVT::v16i8; i != MVT::v2i64; ++i) {
909       MVT::SimpleValueType SVT = (MVT::SimpleValueType)i;
910       EVT VT = SVT;
911
912       // Do not attempt to promote non-128-bit vectors
913       if (!VT.is128BitVector())
914         continue;
915
916       setOperationAction(ISD::AND,    SVT, Promote);
917       AddPromotedToType (ISD::AND,    SVT, MVT::v2i64);
918       setOperationAction(ISD::OR,     SVT, Promote);
919       AddPromotedToType (ISD::OR,     SVT, MVT::v2i64);
920       setOperationAction(ISD::XOR,    SVT, Promote);
921       AddPromotedToType (ISD::XOR,    SVT, MVT::v2i64);
922       setOperationAction(ISD::LOAD,   SVT, Promote);
923       AddPromotedToType (ISD::LOAD,   SVT, MVT::v2i64);
924       setOperationAction(ISD::SELECT, SVT, Promote);
925       AddPromotedToType (ISD::SELECT, SVT, MVT::v2i64);
926     }
927
928     setTruncStoreAction(MVT::f64, MVT::f32, Expand);
929
930     // Custom lower v2i64 and v2f64 selects.
931     setOperationAction(ISD::LOAD,               MVT::v2f64, Legal);
932     setOperationAction(ISD::LOAD,               MVT::v2i64, Legal);
933     setOperationAction(ISD::SELECT,             MVT::v2f64, Custom);
934     setOperationAction(ISD::SELECT,             MVT::v2i64, Custom);
935
936     setOperationAction(ISD::FP_TO_SINT,         MVT::v4i32, Legal);
937     setOperationAction(ISD::SINT_TO_FP,         MVT::v4i32, Legal);
938   }
939
940   if (Subtarget->hasSSE41()) {
941     setOperationAction(ISD::FFLOOR,             MVT::f32,   Legal);
942     setOperationAction(ISD::FCEIL,              MVT::f32,   Legal);
943     setOperationAction(ISD::FTRUNC,             MVT::f32,   Legal);
944     setOperationAction(ISD::FRINT,              MVT::f32,   Legal);
945     setOperationAction(ISD::FNEARBYINT,         MVT::f32,   Legal);
946     setOperationAction(ISD::FFLOOR,             MVT::f64,   Legal);
947     setOperationAction(ISD::FCEIL,              MVT::f64,   Legal);
948     setOperationAction(ISD::FTRUNC,             MVT::f64,   Legal);
949     setOperationAction(ISD::FRINT,              MVT::f64,   Legal);
950     setOperationAction(ISD::FNEARBYINT,         MVT::f64,   Legal);
951
952     // FIXME: Do we need to handle scalar-to-vector here?
953     setOperationAction(ISD::MUL,                MVT::v4i32, Legal);
954
955     setOperationAction(ISD::VSELECT,            MVT::v2f64, Legal);
956     setOperationAction(ISD::VSELECT,            MVT::v2i64, Legal);
957     setOperationAction(ISD::VSELECT,            MVT::v16i8, Legal);
958     setOperationAction(ISD::VSELECT,            MVT::v4i32, Legal);
959     setOperationAction(ISD::VSELECT,            MVT::v4f32, Legal);
960
961     // i8 and i16 vectors are custom , because the source register and source
962     // source memory operand types are not the same width.  f32 vectors are
963     // custom since the immediate controlling the insert encodes additional
964     // information.
965     setOperationAction(ISD::INSERT_VECTOR_ELT,  MVT::v16i8, Custom);
966     setOperationAction(ISD::INSERT_VECTOR_ELT,  MVT::v8i16, Custom);
967     setOperationAction(ISD::INSERT_VECTOR_ELT,  MVT::v4i32, Custom);
968     setOperationAction(ISD::INSERT_VECTOR_ELT,  MVT::v4f32, Custom);
969
970     setOperationAction(ISD::EXTRACT_VECTOR_ELT, MVT::v16i8, Custom);
971     setOperationAction(ISD::EXTRACT_VECTOR_ELT, MVT::v8i16, Custom);
972     setOperationAction(ISD::EXTRACT_VECTOR_ELT, MVT::v4i32, Custom);
973     setOperationAction(ISD::EXTRACT_VECTOR_ELT, MVT::v4f32, Custom);
974
975     // FIXME: these should be Legal but thats only for the case where
976     // the index is constant.  For now custom expand to deal with that.
977     if (Subtarget->is64Bit()) {
978       setOperationAction(ISD::INSERT_VECTOR_ELT,  MVT::v2i64, Custom);
979       setOperationAction(ISD::EXTRACT_VECTOR_ELT, MVT::v2i64, Custom);
980     }
981   }
982
983   if (Subtarget->hasSSE2()) {
984     setOperationAction(ISD::SRL,               MVT::v8i16, Custom);
985     setOperationAction(ISD::SRL,               MVT::v16i8, Custom);
986
987     setOperationAction(ISD::SHL,               MVT::v8i16, Custom);
988     setOperationAction(ISD::SHL,               MVT::v16i8, Custom);
989
990     setOperationAction(ISD::SRA,               MVT::v8i16, Custom);
991     setOperationAction(ISD::SRA,               MVT::v16i8, Custom);
992
993     if (Subtarget->hasAVX2()) {
994       setOperationAction(ISD::SRL,             MVT::v2i64, Legal);
995       setOperationAction(ISD::SRL,             MVT::v4i32, Legal);
996
997       setOperationAction(ISD::SHL,             MVT::v2i64, Legal);
998       setOperationAction(ISD::SHL,             MVT::v4i32, Legal);
999
1000       setOperationAction(ISD::SRA,             MVT::v4i32, Legal);
1001     } else {
1002       setOperationAction(ISD::SRL,             MVT::v2i64, Custom);
1003       setOperationAction(ISD::SRL,             MVT::v4i32, Custom);
1004
1005       setOperationAction(ISD::SHL,             MVT::v2i64, Custom);
1006       setOperationAction(ISD::SHL,             MVT::v4i32, Custom);
1007
1008       setOperationAction(ISD::SRA,             MVT::v4i32, Custom);
1009     }
1010   }
1011
1012   if (Subtarget->hasSSE42())
1013     setOperationAction(ISD::SETCC,             MVT::v2i64, Custom);
1014
1015   if (!TM.Options.UseSoftFloat && Subtarget->hasAVX()) {
1016     addRegisterClass(MVT::v32i8,  &X86::VR256RegClass);
1017     addRegisterClass(MVT::v16i16, &X86::VR256RegClass);
1018     addRegisterClass(MVT::v8i32,  &X86::VR256RegClass);
1019     addRegisterClass(MVT::v8f32,  &X86::VR256RegClass);
1020     addRegisterClass(MVT::v4i64,  &X86::VR256RegClass);
1021     addRegisterClass(MVT::v4f64,  &X86::VR256RegClass);
1022
1023     setOperationAction(ISD::LOAD,               MVT::v8f32, Legal);
1024     setOperationAction(ISD::LOAD,               MVT::v4f64, Legal);
1025     setOperationAction(ISD::LOAD,               MVT::v4i64, Legal);
1026
1027     setOperationAction(ISD::FADD,               MVT::v8f32, Legal);
1028     setOperationAction(ISD::FSUB,               MVT::v8f32, Legal);
1029     setOperationAction(ISD::FMUL,               MVT::v8f32, Legal);
1030     setOperationAction(ISD::FDIV,               MVT::v8f32, Legal);
1031     setOperationAction(ISD::FSQRT,              MVT::v8f32, Legal);
1032     setOperationAction(ISD::FNEG,               MVT::v8f32, Custom);
1033
1034     setOperationAction(ISD::FADD,               MVT::v4f64, Legal);
1035     setOperationAction(ISD::FSUB,               MVT::v4f64, Legal);
1036     setOperationAction(ISD::FMUL,               MVT::v4f64, Legal);
1037     setOperationAction(ISD::FDIV,               MVT::v4f64, Legal);
1038     setOperationAction(ISD::FSQRT,              MVT::v4f64, Legal);
1039     setOperationAction(ISD::FNEG,               MVT::v4f64, Custom);
1040
1041     setOperationAction(ISD::FP_TO_SINT,         MVT::v8i32, Legal);
1042     setOperationAction(ISD::SINT_TO_FP,         MVT::v8i32, Legal);
1043     setOperationAction(ISD::FP_ROUND,           MVT::v4f32, Legal);
1044
1045     setOperationAction(ISD::CONCAT_VECTORS,     MVT::v4f64,  Custom);
1046     setOperationAction(ISD::CONCAT_VECTORS,     MVT::v4i64,  Custom);
1047     setOperationAction(ISD::CONCAT_VECTORS,     MVT::v8f32,  Custom);
1048     setOperationAction(ISD::CONCAT_VECTORS,     MVT::v8i32,  Custom);
1049     setOperationAction(ISD::CONCAT_VECTORS,     MVT::v32i8,  Custom);
1050     setOperationAction(ISD::CONCAT_VECTORS,     MVT::v16i16, Custom);
1051
1052     setOperationAction(ISD::SRL,               MVT::v16i16, Custom);
1053     setOperationAction(ISD::SRL,               MVT::v32i8, Custom);
1054
1055     setOperationAction(ISD::SHL,               MVT::v16i16, Custom);
1056     setOperationAction(ISD::SHL,               MVT::v32i8, Custom);
1057
1058     setOperationAction(ISD::SRA,               MVT::v16i16, Custom);
1059     setOperationAction(ISD::SRA,               MVT::v32i8, Custom);
1060
1061     setOperationAction(ISD::SETCC,             MVT::v32i8, Custom);
1062     setOperationAction(ISD::SETCC,             MVT::v16i16, Custom);
1063     setOperationAction(ISD::SETCC,             MVT::v8i32, Custom);
1064     setOperationAction(ISD::SETCC,             MVT::v4i64, Custom);
1065
1066     setOperationAction(ISD::SELECT,            MVT::v4f64, Custom);
1067     setOperationAction(ISD::SELECT,            MVT::v4i64, Custom);
1068     setOperationAction(ISD::SELECT,            MVT::v8f32, Custom);
1069
1070     setOperationAction(ISD::VSELECT,           MVT::v4f64, Legal);
1071     setOperationAction(ISD::VSELECT,           MVT::v4i64, Legal);
1072     setOperationAction(ISD::VSELECT,           MVT::v8i32, Legal);
1073     setOperationAction(ISD::VSELECT,           MVT::v8f32, Legal);
1074
1075     if (Subtarget->hasFMA()) {
1076       setOperationAction(ISD::FMA,             MVT::v8f32, Custom);
1077       setOperationAction(ISD::FMA,             MVT::v4f64, Custom);
1078       setOperationAction(ISD::FMA,             MVT::v4f32, Custom);
1079       setOperationAction(ISD::FMA,             MVT::v2f64, Custom);
1080       setOperationAction(ISD::FMA,             MVT::f32, Custom);
1081       setOperationAction(ISD::FMA,             MVT::f64, Custom);
1082     }
1083     if (Subtarget->hasAVX2()) {
1084       setOperationAction(ISD::ADD,             MVT::v4i64, Legal);
1085       setOperationAction(ISD::ADD,             MVT::v8i32, Legal);
1086       setOperationAction(ISD::ADD,             MVT::v16i16, Legal);
1087       setOperationAction(ISD::ADD,             MVT::v32i8, Legal);
1088
1089       setOperationAction(ISD::SUB,             MVT::v4i64, Legal);
1090       setOperationAction(ISD::SUB,             MVT::v8i32, Legal);
1091       setOperationAction(ISD::SUB,             MVT::v16i16, Legal);
1092       setOperationAction(ISD::SUB,             MVT::v32i8, Legal);
1093
1094       setOperationAction(ISD::MUL,             MVT::v4i64, Custom);
1095       setOperationAction(ISD::MUL,             MVT::v8i32, Legal);
1096       setOperationAction(ISD::MUL,             MVT::v16i16, Legal);
1097       // Don't lower v32i8 because there is no 128-bit byte mul
1098
1099       setOperationAction(ISD::VSELECT,         MVT::v32i8, Legal);
1100
1101       setOperationAction(ISD::SRL,             MVT::v4i64, Legal);
1102       setOperationAction(ISD::SRL,             MVT::v8i32, Legal);
1103
1104       setOperationAction(ISD::SHL,             MVT::v4i64, Legal);
1105       setOperationAction(ISD::SHL,             MVT::v8i32, Legal);
1106
1107       setOperationAction(ISD::SRA,             MVT::v8i32, Legal);
1108     } else {
1109       setOperationAction(ISD::ADD,             MVT::v4i64, Custom);
1110       setOperationAction(ISD::ADD,             MVT::v8i32, Custom);
1111       setOperationAction(ISD::ADD,             MVT::v16i16, Custom);
1112       setOperationAction(ISD::ADD,             MVT::v32i8, Custom);
1113
1114       setOperationAction(ISD::SUB,             MVT::v4i64, Custom);
1115       setOperationAction(ISD::SUB,             MVT::v8i32, Custom);
1116       setOperationAction(ISD::SUB,             MVT::v16i16, Custom);
1117       setOperationAction(ISD::SUB,             MVT::v32i8, Custom);
1118
1119       setOperationAction(ISD::MUL,             MVT::v4i64, Custom);
1120       setOperationAction(ISD::MUL,             MVT::v8i32, Custom);
1121       setOperationAction(ISD::MUL,             MVT::v16i16, Custom);
1122       // Don't lower v32i8 because there is no 128-bit byte mul
1123
1124       setOperationAction(ISD::SRL,             MVT::v4i64, Custom);
1125       setOperationAction(ISD::SRL,             MVT::v8i32, Custom);
1126
1127       setOperationAction(ISD::SHL,             MVT::v4i64, Custom);
1128       setOperationAction(ISD::SHL,             MVT::v8i32, Custom);
1129
1130       setOperationAction(ISD::SRA,             MVT::v8i32, Custom);
1131     }
1132
1133     // Custom lower several nodes for 256-bit types.
1134     for (int i = MVT::FIRST_VECTOR_VALUETYPE;
1135              i <= MVT::LAST_VECTOR_VALUETYPE; ++i) {
1136       MVT::SimpleValueType SVT = (MVT::SimpleValueType)i;
1137       EVT VT = SVT;
1138
1139       // Extract subvector is special because the value type
1140       // (result) is 128-bit but the source is 256-bit wide.
1141       if (VT.is128BitVector())
1142         setOperationAction(ISD::EXTRACT_SUBVECTOR, SVT, Custom);
1143
1144       // Do not attempt to custom lower other non-256-bit vectors
1145       if (!VT.is256BitVector())
1146         continue;
1147
1148       setOperationAction(ISD::BUILD_VECTOR,       SVT, Custom);
1149       setOperationAction(ISD::VECTOR_SHUFFLE,     SVT, Custom);
1150       setOperationAction(ISD::INSERT_VECTOR_ELT,  SVT, Custom);
1151       setOperationAction(ISD::EXTRACT_VECTOR_ELT, SVT, Custom);
1152       setOperationAction(ISD::SCALAR_TO_VECTOR,   SVT, Custom);
1153       setOperationAction(ISD::INSERT_SUBVECTOR,   SVT, Custom);
1154     }
1155
1156     // Promote v32i8, v16i16, v8i32 select, and, or, xor to v4i64.
1157     for (int i = MVT::v32i8; i != MVT::v4i64; ++i) {
1158       MVT::SimpleValueType SVT = (MVT::SimpleValueType)i;
1159       EVT VT = SVT;
1160
1161       // Do not attempt to promote non-256-bit vectors
1162       if (!VT.is256BitVector())
1163         continue;
1164
1165       setOperationAction(ISD::AND,    SVT, Promote);
1166       AddPromotedToType (ISD::AND,    SVT, MVT::v4i64);
1167       setOperationAction(ISD::OR,     SVT, Promote);
1168       AddPromotedToType (ISD::OR,     SVT, MVT::v4i64);
1169       setOperationAction(ISD::XOR,    SVT, Promote);
1170       AddPromotedToType (ISD::XOR,    SVT, MVT::v4i64);
1171       setOperationAction(ISD::LOAD,   SVT, Promote);
1172       AddPromotedToType (ISD::LOAD,   SVT, MVT::v4i64);
1173       setOperationAction(ISD::SELECT, SVT, Promote);
1174       AddPromotedToType (ISD::SELECT, SVT, MVT::v4i64);
1175     }
1176   }
1177
1178   // SIGN_EXTEND_INREGs are evaluated by the extend type. Handle the expansion
1179   // of this type with custom code.
1180   for (int VT = MVT::FIRST_VECTOR_VALUETYPE;
1181            VT != MVT::LAST_VECTOR_VALUETYPE; VT++) {
1182     setOperationAction(ISD::SIGN_EXTEND_INREG, (MVT::SimpleValueType)VT,
1183                        Custom);
1184   }
1185
1186   // We want to custom lower some of our intrinsics.
1187   setOperationAction(ISD::INTRINSIC_WO_CHAIN, MVT::Other, Custom);
1188   setOperationAction(ISD::INTRINSIC_W_CHAIN, MVT::Other, Custom);
1189
1190
1191   // Only custom-lower 64-bit SADDO and friends on 64-bit because we don't
1192   // handle type legalization for these operations here.
1193   //
1194   // FIXME: We really should do custom legalization for addition and
1195   // subtraction on x86-32 once PR3203 is fixed.  We really can't do much better
1196   // than generic legalization for 64-bit multiplication-with-overflow, though.
1197   for (unsigned i = 0, e = 3+Subtarget->is64Bit(); i != e; ++i) {
1198     // Add/Sub/Mul with overflow operations are custom lowered.
1199     MVT VT = IntVTs[i];
1200     setOperationAction(ISD::SADDO, VT, Custom);
1201     setOperationAction(ISD::UADDO, VT, Custom);
1202     setOperationAction(ISD::SSUBO, VT, Custom);
1203     setOperationAction(ISD::USUBO, VT, Custom);
1204     setOperationAction(ISD::SMULO, VT, Custom);
1205     setOperationAction(ISD::UMULO, VT, Custom);
1206   }
1207
1208   // There are no 8-bit 3-address imul/mul instructions
1209   setOperationAction(ISD::SMULO, MVT::i8, Expand);
1210   setOperationAction(ISD::UMULO, MVT::i8, Expand);
1211
1212   if (!Subtarget->is64Bit()) {
1213     // These libcalls are not available in 32-bit.
1214     setLibcallName(RTLIB::SHL_I128, 0);
1215     setLibcallName(RTLIB::SRL_I128, 0);
1216     setLibcallName(RTLIB::SRA_I128, 0);
1217   }
1218
1219   // We have target-specific dag combine patterns for the following nodes:
1220   setTargetDAGCombine(ISD::VECTOR_SHUFFLE);
1221   setTargetDAGCombine(ISD::EXTRACT_VECTOR_ELT);
1222   setTargetDAGCombine(ISD::VSELECT);
1223   setTargetDAGCombine(ISD::SELECT);
1224   setTargetDAGCombine(ISD::SHL);
1225   setTargetDAGCombine(ISD::SRA);
1226   setTargetDAGCombine(ISD::SRL);
1227   setTargetDAGCombine(ISD::OR);
1228   setTargetDAGCombine(ISD::AND);
1229   setTargetDAGCombine(ISD::ADD);
1230   setTargetDAGCombine(ISD::FADD);
1231   setTargetDAGCombine(ISD::FSUB);
1232   setTargetDAGCombine(ISD::FMA);
1233   setTargetDAGCombine(ISD::SUB);
1234   setTargetDAGCombine(ISD::LOAD);
1235   setTargetDAGCombine(ISD::STORE);
1236   setTargetDAGCombine(ISD::ZERO_EXTEND);
1237   setTargetDAGCombine(ISD::ANY_EXTEND);
1238   setTargetDAGCombine(ISD::SIGN_EXTEND);
1239   setTargetDAGCombine(ISD::TRUNCATE);
1240   setTargetDAGCombine(ISD::UINT_TO_FP);
1241   setTargetDAGCombine(ISD::SINT_TO_FP);
1242   setTargetDAGCombine(ISD::SETCC);
1243   setTargetDAGCombine(ISD::FP_TO_SINT);
1244   if (Subtarget->is64Bit())
1245     setTargetDAGCombine(ISD::MUL);
1246   setTargetDAGCombine(ISD::XOR);
1247
1248   computeRegisterProperties();
1249
1250   // On Darwin, -Os means optimize for size without hurting performance,
1251   // do not reduce the limit.
1252   maxStoresPerMemset = 16; // For @llvm.memset -> sequence of stores
1253   maxStoresPerMemsetOptSize = Subtarget->isTargetDarwin() ? 16 : 8;
1254   maxStoresPerMemcpy = 8; // For @llvm.memcpy -> sequence of stores
1255   maxStoresPerMemcpyOptSize = Subtarget->isTargetDarwin() ? 8 : 4;
1256   maxStoresPerMemmove = 8; // For @llvm.memmove -> sequence of stores
1257   maxStoresPerMemmoveOptSize = Subtarget->isTargetDarwin() ? 8 : 4;
1258   setPrefLoopAlignment(4); // 2^4 bytes.
1259   benefitFromCodePlacementOpt = true;
1260
1261   // Predictable cmov don't hurt on atom because it's in-order.
1262   predictableSelectIsExpensive = !Subtarget->isAtom();
1263
1264   setPrefFunctionAlignment(4); // 2^4 bytes.
1265 }
1266
1267
1268 EVT X86TargetLowering::getSetCCResultType(EVT VT) const {
1269   if (!VT.isVector()) return MVT::i8;
1270   return VT.changeVectorElementTypeToInteger();
1271 }
1272
1273
1274 /// getMaxByValAlign - Helper for getByValTypeAlignment to determine
1275 /// the desired ByVal argument alignment.
1276 static void getMaxByValAlign(Type *Ty, unsigned &MaxAlign) {
1277   if (MaxAlign == 16)
1278     return;
1279   if (VectorType *VTy = dyn_cast<VectorType>(Ty)) {
1280     if (VTy->getBitWidth() == 128)
1281       MaxAlign = 16;
1282   } else if (ArrayType *ATy = dyn_cast<ArrayType>(Ty)) {
1283     unsigned EltAlign = 0;
1284     getMaxByValAlign(ATy->getElementType(), EltAlign);
1285     if (EltAlign > MaxAlign)
1286       MaxAlign = EltAlign;
1287   } else if (StructType *STy = dyn_cast<StructType>(Ty)) {
1288     for (unsigned i = 0, e = STy->getNumElements(); i != e; ++i) {
1289       unsigned EltAlign = 0;
1290       getMaxByValAlign(STy->getElementType(i), EltAlign);
1291       if (EltAlign > MaxAlign)
1292         MaxAlign = EltAlign;
1293       if (MaxAlign == 16)
1294         break;
1295     }
1296   }
1297 }
1298
1299 /// getByValTypeAlignment - Return the desired alignment for ByVal aggregate
1300 /// function arguments in the caller parameter area. For X86, aggregates
1301 /// that contain SSE vectors are placed at 16-byte boundaries while the rest
1302 /// are at 4-byte boundaries.
1303 unsigned X86TargetLowering::getByValTypeAlignment(Type *Ty) const {
1304   if (Subtarget->is64Bit()) {
1305     // Max of 8 and alignment of type.
1306     unsigned TyAlign = TD->getABITypeAlignment(Ty);
1307     if (TyAlign > 8)
1308       return TyAlign;
1309     return 8;
1310   }
1311
1312   unsigned Align = 4;
1313   if (Subtarget->hasSSE1())
1314     getMaxByValAlign(Ty, Align);
1315   return Align;
1316 }
1317
1318 /// getOptimalMemOpType - Returns the target specific optimal type for load
1319 /// and store operations as a result of memset, memcpy, and memmove
1320 /// lowering. If DstAlign is zero that means it's safe to destination
1321 /// alignment can satisfy any constraint. Similarly if SrcAlign is zero it
1322 /// means there isn't a need to check it against alignment requirement,
1323 /// probably because the source does not need to be loaded. If
1324 /// 'IsZeroVal' is true, that means it's safe to return a
1325 /// non-scalar-integer type, e.g. empty string source, constant, or loaded
1326 /// from memory. 'MemcpyStrSrc' indicates whether the memcpy source is
1327 /// constant so it does not need to be loaded.
1328 /// It returns EVT::Other if the type should be determined using generic
1329 /// target-independent logic.
1330 EVT
1331 X86TargetLowering::getOptimalMemOpType(uint64_t Size,
1332                                        unsigned DstAlign, unsigned SrcAlign,
1333                                        bool IsZeroVal,
1334                                        bool MemcpyStrSrc,
1335                                        MachineFunction &MF) const {
1336   // FIXME: This turns off use of xmm stores for memset/memcpy on targets like
1337   // linux.  This is because the stack realignment code can't handle certain
1338   // cases like PR2962.  This should be removed when PR2962 is fixed.
1339   const Function *F = MF.getFunction();
1340   if (IsZeroVal &&
1341       !F->hasFnAttr(Attribute::NoImplicitFloat)) {
1342     if (Size >= 16 &&
1343         (Subtarget->isUnalignedMemAccessFast() ||
1344          ((DstAlign == 0 || DstAlign >= 16) &&
1345           (SrcAlign == 0 || SrcAlign >= 16))) &&
1346         Subtarget->getStackAlignment() >= 16) {
1347       if (Subtarget->getStackAlignment() >= 32) {
1348         if (Subtarget->hasAVX2())
1349           return MVT::v8i32;
1350         if (Subtarget->hasAVX())
1351           return MVT::v8f32;
1352       }
1353       if (Subtarget->hasSSE2())
1354         return MVT::v4i32;
1355       if (Subtarget->hasSSE1())
1356         return MVT::v4f32;
1357     } else if (!MemcpyStrSrc && Size >= 8 &&
1358                !Subtarget->is64Bit() &&
1359                Subtarget->getStackAlignment() >= 8 &&
1360                Subtarget->hasSSE2()) {
1361       // Do not use f64 to lower memcpy if source is string constant. It's
1362       // better to use i32 to avoid the loads.
1363       return MVT::f64;
1364     }
1365   }
1366   if (Subtarget->is64Bit() && Size >= 8)
1367     return MVT::i64;
1368   return MVT::i32;
1369 }
1370
1371 /// getJumpTableEncoding - Return the entry encoding for a jump table in the
1372 /// current function.  The returned value is a member of the
1373 /// MachineJumpTableInfo::JTEntryKind enum.
1374 unsigned X86TargetLowering::getJumpTableEncoding() const {
1375   // In GOT pic mode, each entry in the jump table is emitted as a @GOTOFF
1376   // symbol.
1377   if (getTargetMachine().getRelocationModel() == Reloc::PIC_ &&
1378       Subtarget->isPICStyleGOT())
1379     return MachineJumpTableInfo::EK_Custom32;
1380
1381   // Otherwise, use the normal jump table encoding heuristics.
1382   return TargetLowering::getJumpTableEncoding();
1383 }
1384
1385 const MCExpr *
1386 X86TargetLowering::LowerCustomJumpTableEntry(const MachineJumpTableInfo *MJTI,
1387                                              const MachineBasicBlock *MBB,
1388                                              unsigned uid,MCContext &Ctx) const{
1389   assert(getTargetMachine().getRelocationModel() == Reloc::PIC_ &&
1390          Subtarget->isPICStyleGOT());
1391   // In 32-bit ELF systems, our jump table entries are formed with @GOTOFF
1392   // entries.
1393   return MCSymbolRefExpr::Create(MBB->getSymbol(),
1394                                  MCSymbolRefExpr::VK_GOTOFF, Ctx);
1395 }
1396
1397 /// getPICJumpTableRelocaBase - Returns relocation base for the given PIC
1398 /// jumptable.
1399 SDValue X86TargetLowering::getPICJumpTableRelocBase(SDValue Table,
1400                                                     SelectionDAG &DAG) const {
1401   if (!Subtarget->is64Bit())
1402     // This doesn't have DebugLoc associated with it, but is not really the
1403     // same as a Register.
1404     return DAG.getNode(X86ISD::GlobalBaseReg, DebugLoc(), getPointerTy());
1405   return Table;
1406 }
1407
1408 /// getPICJumpTableRelocBaseExpr - This returns the relocation base for the
1409 /// given PIC jumptable, the same as getPICJumpTableRelocBase, but as an
1410 /// MCExpr.
1411 const MCExpr *X86TargetLowering::
1412 getPICJumpTableRelocBaseExpr(const MachineFunction *MF, unsigned JTI,
1413                              MCContext &Ctx) const {
1414   // X86-64 uses RIP relative addressing based on the jump table label.
1415   if (Subtarget->isPICStyleRIPRel())
1416     return TargetLowering::getPICJumpTableRelocBaseExpr(MF, JTI, Ctx);
1417
1418   // Otherwise, the reference is relative to the PIC base.
1419   return MCSymbolRefExpr::Create(MF->getPICBaseSymbol(), Ctx);
1420 }
1421
1422 // FIXME: Why this routine is here? Move to RegInfo!
1423 std::pair<const TargetRegisterClass*, uint8_t>
1424 X86TargetLowering::findRepresentativeClass(EVT VT) const{
1425   const TargetRegisterClass *RRC = 0;
1426   uint8_t Cost = 1;
1427   switch (VT.getSimpleVT().SimpleTy) {
1428   default:
1429     return TargetLowering::findRepresentativeClass(VT);
1430   case MVT::i8: case MVT::i16: case MVT::i32: case MVT::i64:
1431     RRC = Subtarget->is64Bit() ?
1432       (const TargetRegisterClass*)&X86::GR64RegClass :
1433       (const TargetRegisterClass*)&X86::GR32RegClass;
1434     break;
1435   case MVT::x86mmx:
1436     RRC = &X86::VR64RegClass;
1437     break;
1438   case MVT::f32: case MVT::f64:
1439   case MVT::v16i8: case MVT::v8i16: case MVT::v4i32: case MVT::v2i64:
1440   case MVT::v4f32: case MVT::v2f64:
1441   case MVT::v32i8: case MVT::v8i32: case MVT::v4i64: case MVT::v8f32:
1442   case MVT::v4f64:
1443     RRC = &X86::VR128RegClass;
1444     break;
1445   }
1446   return std::make_pair(RRC, Cost);
1447 }
1448
1449 bool X86TargetLowering::getStackCookieLocation(unsigned &AddressSpace,
1450                                                unsigned &Offset) const {
1451   if (!Subtarget->isTargetLinux())
1452     return false;
1453
1454   if (Subtarget->is64Bit()) {
1455     // %fs:0x28, unless we're using a Kernel code model, in which case it's %gs:
1456     Offset = 0x28;
1457     if (getTargetMachine().getCodeModel() == CodeModel::Kernel)
1458       AddressSpace = 256;
1459     else
1460       AddressSpace = 257;
1461   } else {
1462     // %gs:0x14 on i386
1463     Offset = 0x14;
1464     AddressSpace = 256;
1465   }
1466   return true;
1467 }
1468
1469
1470 //===----------------------------------------------------------------------===//
1471 //               Return Value Calling Convention Implementation
1472 //===----------------------------------------------------------------------===//
1473
1474 #include "X86GenCallingConv.inc"
1475
1476 bool
1477 X86TargetLowering::CanLowerReturn(CallingConv::ID CallConv,
1478                                   MachineFunction &MF, bool isVarArg,
1479                         const SmallVectorImpl<ISD::OutputArg> &Outs,
1480                         LLVMContext &Context) const {
1481   SmallVector<CCValAssign, 16> RVLocs;
1482   CCState CCInfo(CallConv, isVarArg, MF, getTargetMachine(),
1483                  RVLocs, Context);
1484   return CCInfo.CheckReturn(Outs, RetCC_X86);
1485 }
1486
1487 SDValue
1488 X86TargetLowering::LowerReturn(SDValue Chain,
1489                                CallingConv::ID CallConv, bool isVarArg,
1490                                const SmallVectorImpl<ISD::OutputArg> &Outs,
1491                                const SmallVectorImpl<SDValue> &OutVals,
1492                                DebugLoc dl, SelectionDAG &DAG) const {
1493   MachineFunction &MF = DAG.getMachineFunction();
1494   X86MachineFunctionInfo *FuncInfo = MF.getInfo<X86MachineFunctionInfo>();
1495
1496   SmallVector<CCValAssign, 16> RVLocs;
1497   CCState CCInfo(CallConv, isVarArg, MF, getTargetMachine(),
1498                  RVLocs, *DAG.getContext());
1499   CCInfo.AnalyzeReturn(Outs, RetCC_X86);
1500
1501   // Add the regs to the liveout set for the function.
1502   MachineRegisterInfo &MRI = DAG.getMachineFunction().getRegInfo();
1503   for (unsigned i = 0; i != RVLocs.size(); ++i)
1504     if (RVLocs[i].isRegLoc() && !MRI.isLiveOut(RVLocs[i].getLocReg()))
1505       MRI.addLiveOut(RVLocs[i].getLocReg());
1506
1507   SDValue Flag;
1508
1509   SmallVector<SDValue, 6> RetOps;
1510   RetOps.push_back(Chain); // Operand #0 = Chain (updated below)
1511   // Operand #1 = Bytes To Pop
1512   RetOps.push_back(DAG.getTargetConstant(FuncInfo->getBytesToPopOnReturn(),
1513                    MVT::i16));
1514
1515   // Copy the result values into the output registers.
1516   for (unsigned i = 0; i != RVLocs.size(); ++i) {
1517     CCValAssign &VA = RVLocs[i];
1518     assert(VA.isRegLoc() && "Can only return in registers!");
1519     SDValue ValToCopy = OutVals[i];
1520     EVT ValVT = ValToCopy.getValueType();
1521
1522     // Promote values to the appropriate types
1523     if (VA.getLocInfo() == CCValAssign::SExt)
1524       ValToCopy = DAG.getNode(ISD::SIGN_EXTEND, dl, VA.getLocVT(), ValToCopy);
1525     else if (VA.getLocInfo() == CCValAssign::ZExt)
1526       ValToCopy = DAG.getNode(ISD::ZERO_EXTEND, dl, VA.getLocVT(), ValToCopy);
1527     else if (VA.getLocInfo() == CCValAssign::AExt)
1528       ValToCopy = DAG.getNode(ISD::ANY_EXTEND, dl, VA.getLocVT(), ValToCopy);
1529     else if (VA.getLocInfo() == CCValAssign::BCvt)
1530       ValToCopy = DAG.getNode(ISD::BITCAST, dl, VA.getLocVT(), ValToCopy);
1531
1532     // If this is x86-64, and we disabled SSE, we can't return FP values,
1533     // or SSE or MMX vectors.
1534     if ((ValVT == MVT::f32 || ValVT == MVT::f64 ||
1535          VA.getLocReg() == X86::XMM0 || VA.getLocReg() == X86::XMM1) &&
1536           (Subtarget->is64Bit() && !Subtarget->hasSSE1())) {
1537       report_fatal_error("SSE register return with SSE disabled");
1538     }
1539     // Likewise we can't return F64 values with SSE1 only.  gcc does so, but
1540     // llvm-gcc has never done it right and no one has noticed, so this
1541     // should be OK for now.
1542     if (ValVT == MVT::f64 &&
1543         (Subtarget->is64Bit() && !Subtarget->hasSSE2()))
1544       report_fatal_error("SSE2 register return with SSE2 disabled");
1545
1546     // Returns in ST0/ST1 are handled specially: these are pushed as operands to
1547     // the RET instruction and handled by the FP Stackifier.
1548     if (VA.getLocReg() == X86::ST0 ||
1549         VA.getLocReg() == X86::ST1) {
1550       // If this is a copy from an xmm register to ST(0), use an FPExtend to
1551       // change the value to the FP stack register class.
1552       if (isScalarFPTypeInSSEReg(VA.getValVT()))
1553         ValToCopy = DAG.getNode(ISD::FP_EXTEND, dl, MVT::f80, ValToCopy);
1554       RetOps.push_back(ValToCopy);
1555       // Don't emit a copytoreg.
1556       continue;
1557     }
1558
1559     // 64-bit vector (MMX) values are returned in XMM0 / XMM1 except for v1i64
1560     // which is returned in RAX / RDX.
1561     if (Subtarget->is64Bit()) {
1562       if (ValVT == MVT::x86mmx) {
1563         if (VA.getLocReg() == X86::XMM0 || VA.getLocReg() == X86::XMM1) {
1564           ValToCopy = DAG.getNode(ISD::BITCAST, dl, MVT::i64, ValToCopy);
1565           ValToCopy = DAG.getNode(ISD::SCALAR_TO_VECTOR, dl, MVT::v2i64,
1566                                   ValToCopy);
1567           // If we don't have SSE2 available, convert to v4f32 so the generated
1568           // register is legal.
1569           if (!Subtarget->hasSSE2())
1570             ValToCopy = DAG.getNode(ISD::BITCAST, dl, MVT::v4f32,ValToCopy);
1571         }
1572       }
1573     }
1574
1575     Chain = DAG.getCopyToReg(Chain, dl, VA.getLocReg(), ValToCopy, Flag);
1576     Flag = Chain.getValue(1);
1577   }
1578
1579   // The x86-64 ABI for returning structs by value requires that we copy
1580   // the sret argument into %rax for the return. We saved the argument into
1581   // a virtual register in the entry block, so now we copy the value out
1582   // and into %rax.
1583   if (Subtarget->is64Bit() &&
1584       DAG.getMachineFunction().getFunction()->hasStructRetAttr()) {
1585     MachineFunction &MF = DAG.getMachineFunction();
1586     X86MachineFunctionInfo *FuncInfo = MF.getInfo<X86MachineFunctionInfo>();
1587     unsigned Reg = FuncInfo->getSRetReturnReg();
1588     assert(Reg &&
1589            "SRetReturnReg should have been set in LowerFormalArguments().");
1590     SDValue Val = DAG.getCopyFromReg(Chain, dl, Reg, getPointerTy());
1591
1592     Chain = DAG.getCopyToReg(Chain, dl, X86::RAX, Val, Flag);
1593     Flag = Chain.getValue(1);
1594
1595     // RAX now acts like a return value.
1596     MRI.addLiveOut(X86::RAX);
1597   }
1598
1599   RetOps[0] = Chain;  // Update chain.
1600
1601   // Add the flag if we have it.
1602   if (Flag.getNode())
1603     RetOps.push_back(Flag);
1604
1605   return DAG.getNode(X86ISD::RET_FLAG, dl,
1606                      MVT::Other, &RetOps[0], RetOps.size());
1607 }
1608
1609 bool X86TargetLowering::isUsedByReturnOnly(SDNode *N, SDValue &Chain) const {
1610   if (N->getNumValues() != 1)
1611     return false;
1612   if (!N->hasNUsesOfValue(1, 0))
1613     return false;
1614
1615   SDValue TCChain = Chain;
1616   SDNode *Copy = *N->use_begin();
1617   if (Copy->getOpcode() == ISD::CopyToReg) {
1618     // If the copy has a glue operand, we conservatively assume it isn't safe to
1619     // perform a tail call.
1620     if (Copy->getOperand(Copy->getNumOperands()-1).getValueType() == MVT::Glue)
1621       return false;
1622     TCChain = Copy->getOperand(0);
1623   } else if (Copy->getOpcode() != ISD::FP_EXTEND)
1624     return false;
1625
1626   bool HasRet = false;
1627   for (SDNode::use_iterator UI = Copy->use_begin(), UE = Copy->use_end();
1628        UI != UE; ++UI) {
1629     if (UI->getOpcode() != X86ISD::RET_FLAG)
1630       return false;
1631     HasRet = true;
1632   }
1633
1634   if (!HasRet)
1635     return false;
1636
1637   Chain = TCChain;
1638   return true;
1639 }
1640
1641 EVT
1642 X86TargetLowering::getTypeForExtArgOrReturn(LLVMContext &Context, EVT VT,
1643                                             ISD::NodeType ExtendKind) const {
1644   MVT ReturnMVT;
1645   // TODO: Is this also valid on 32-bit?
1646   if (Subtarget->is64Bit() && VT == MVT::i1 && ExtendKind == ISD::ZERO_EXTEND)
1647     ReturnMVT = MVT::i8;
1648   else
1649     ReturnMVT = MVT::i32;
1650
1651   EVT MinVT = getRegisterType(Context, ReturnMVT);
1652   return VT.bitsLT(MinVT) ? MinVT : VT;
1653 }
1654
1655 /// LowerCallResult - Lower the result values of a call into the
1656 /// appropriate copies out of appropriate physical registers.
1657 ///
1658 SDValue
1659 X86TargetLowering::LowerCallResult(SDValue Chain, SDValue InFlag,
1660                                    CallingConv::ID CallConv, bool isVarArg,
1661                                    const SmallVectorImpl<ISD::InputArg> &Ins,
1662                                    DebugLoc dl, SelectionDAG &DAG,
1663                                    SmallVectorImpl<SDValue> &InVals) const {
1664
1665   // Assign locations to each value returned by this call.
1666   SmallVector<CCValAssign, 16> RVLocs;
1667   bool Is64Bit = Subtarget->is64Bit();
1668   CCState CCInfo(CallConv, isVarArg, DAG.getMachineFunction(),
1669                  getTargetMachine(), RVLocs, *DAG.getContext());
1670   CCInfo.AnalyzeCallResult(Ins, RetCC_X86);
1671
1672   // Copy all of the result registers out of their specified physreg.
1673   for (unsigned i = 0; i != RVLocs.size(); ++i) {
1674     CCValAssign &VA = RVLocs[i];
1675     EVT CopyVT = VA.getValVT();
1676
1677     // If this is x86-64, and we disabled SSE, we can't return FP values
1678     if ((CopyVT == MVT::f32 || CopyVT == MVT::f64) &&
1679         ((Is64Bit || Ins[i].Flags.isInReg()) && !Subtarget->hasSSE1())) {
1680       report_fatal_error("SSE register return with SSE disabled");
1681     }
1682
1683     SDValue Val;
1684
1685     // If this is a call to a function that returns an fp value on the floating
1686     // point stack, we must guarantee the value is popped from the stack, so
1687     // a CopyFromReg is not good enough - the copy instruction may be eliminated
1688     // if the return value is not used. We use the FpPOP_RETVAL instruction
1689     // instead.
1690     if (VA.getLocReg() == X86::ST0 || VA.getLocReg() == X86::ST1) {
1691       // If we prefer to use the value in xmm registers, copy it out as f80 and
1692       // use a truncate to move it from fp stack reg to xmm reg.
1693       if (isScalarFPTypeInSSEReg(VA.getValVT())) CopyVT = MVT::f80;
1694       SDValue Ops[] = { Chain, InFlag };
1695       Chain = SDValue(DAG.getMachineNode(X86::FpPOP_RETVAL, dl, CopyVT,
1696                                          MVT::Other, MVT::Glue, Ops, 2), 1);
1697       Val = Chain.getValue(0);
1698
1699       // Round the f80 to the right size, which also moves it to the appropriate
1700       // xmm register.
1701       if (CopyVT != VA.getValVT())
1702         Val = DAG.getNode(ISD::FP_ROUND, dl, VA.getValVT(), Val,
1703                           // This truncation won't change the value.
1704                           DAG.getIntPtrConstant(1));
1705     } else {
1706       Chain = DAG.getCopyFromReg(Chain, dl, VA.getLocReg(),
1707                                  CopyVT, InFlag).getValue(1);
1708       Val = Chain.getValue(0);
1709     }
1710     InFlag = Chain.getValue(2);
1711     InVals.push_back(Val);
1712   }
1713
1714   return Chain;
1715 }
1716
1717
1718 //===----------------------------------------------------------------------===//
1719 //                C & StdCall & Fast Calling Convention implementation
1720 //===----------------------------------------------------------------------===//
1721 //  StdCall calling convention seems to be standard for many Windows' API
1722 //  routines and around. It differs from C calling convention just a little:
1723 //  callee should clean up the stack, not caller. Symbols should be also
1724 //  decorated in some fancy way :) It doesn't support any vector arguments.
1725 //  For info on fast calling convention see Fast Calling Convention (tail call)
1726 //  implementation LowerX86_32FastCCCallTo.
1727
1728 /// CallIsStructReturn - Determines whether a call uses struct return
1729 /// semantics.
1730 enum StructReturnType {
1731   NotStructReturn,
1732   RegStructReturn,
1733   StackStructReturn
1734 };
1735 static StructReturnType
1736 callIsStructReturn(const SmallVectorImpl<ISD::OutputArg> &Outs) {
1737   if (Outs.empty())
1738     return NotStructReturn;
1739
1740   const ISD::ArgFlagsTy &Flags = Outs[0].Flags;
1741   if (!Flags.isSRet())
1742     return NotStructReturn;
1743   if (Flags.isInReg())
1744     return RegStructReturn;
1745   return StackStructReturn;
1746 }
1747
1748 /// ArgsAreStructReturn - Determines whether a function uses struct
1749 /// return semantics.
1750 static StructReturnType
1751 argsAreStructReturn(const SmallVectorImpl<ISD::InputArg> &Ins) {
1752   if (Ins.empty())
1753     return NotStructReturn;
1754
1755   const ISD::ArgFlagsTy &Flags = Ins[0].Flags;
1756   if (!Flags.isSRet())
1757     return NotStructReturn;
1758   if (Flags.isInReg())
1759     return RegStructReturn;
1760   return StackStructReturn;
1761 }
1762
1763 /// CreateCopyOfByValArgument - Make a copy of an aggregate at address specified
1764 /// by "Src" to address "Dst" with size and alignment information specified by
1765 /// the specific parameter attribute. The copy will be passed as a byval
1766 /// function parameter.
1767 static SDValue
1768 CreateCopyOfByValArgument(SDValue Src, SDValue Dst, SDValue Chain,
1769                           ISD::ArgFlagsTy Flags, SelectionDAG &DAG,
1770                           DebugLoc dl) {
1771   SDValue SizeNode = DAG.getConstant(Flags.getByValSize(), MVT::i32);
1772
1773   return DAG.getMemcpy(Chain, dl, Dst, Src, SizeNode, Flags.getByValAlign(),
1774                        /*isVolatile*/false, /*AlwaysInline=*/true,
1775                        MachinePointerInfo(), MachinePointerInfo());
1776 }
1777
1778 /// IsTailCallConvention - Return true if the calling convention is one that
1779 /// supports tail call optimization.
1780 static bool IsTailCallConvention(CallingConv::ID CC) {
1781   return (CC == CallingConv::Fast || CC == CallingConv::GHC);
1782 }
1783
1784 bool X86TargetLowering::mayBeEmittedAsTailCall(CallInst *CI) const {
1785   if (!CI->isTailCall() || getTargetMachine().Options.DisableTailCalls)
1786     return false;
1787
1788   CallSite CS(CI);
1789   CallingConv::ID CalleeCC = CS.getCallingConv();
1790   if (!IsTailCallConvention(CalleeCC) && CalleeCC != CallingConv::C)
1791     return false;
1792
1793   return true;
1794 }
1795
1796 /// FuncIsMadeTailCallSafe - Return true if the function is being made into
1797 /// a tailcall target by changing its ABI.
1798 static bool FuncIsMadeTailCallSafe(CallingConv::ID CC,
1799                                    bool GuaranteedTailCallOpt) {
1800   return GuaranteedTailCallOpt && IsTailCallConvention(CC);
1801 }
1802
1803 SDValue
1804 X86TargetLowering::LowerMemArgument(SDValue Chain,
1805                                     CallingConv::ID CallConv,
1806                                     const SmallVectorImpl<ISD::InputArg> &Ins,
1807                                     DebugLoc dl, SelectionDAG &DAG,
1808                                     const CCValAssign &VA,
1809                                     MachineFrameInfo *MFI,
1810                                     unsigned i) const {
1811   // Create the nodes corresponding to a load from this parameter slot.
1812   ISD::ArgFlagsTy Flags = Ins[i].Flags;
1813   bool AlwaysUseMutable = FuncIsMadeTailCallSafe(CallConv,
1814                               getTargetMachine().Options.GuaranteedTailCallOpt);
1815   bool isImmutable = !AlwaysUseMutable && !Flags.isByVal();
1816   EVT ValVT;
1817
1818   // If value is passed by pointer we have address passed instead of the value
1819   // itself.
1820   if (VA.getLocInfo() == CCValAssign::Indirect)
1821     ValVT = VA.getLocVT();
1822   else
1823     ValVT = VA.getValVT();
1824
1825   // FIXME: For now, all byval parameter objects are marked mutable. This can be
1826   // changed with more analysis.
1827   // In case of tail call optimization mark all arguments mutable. Since they
1828   // could be overwritten by lowering of arguments in case of a tail call.
1829   if (Flags.isByVal()) {
1830     unsigned Bytes = Flags.getByValSize();
1831     if (Bytes == 0) Bytes = 1; // Don't create zero-sized stack objects.
1832     int FI = MFI->CreateFixedObject(Bytes, VA.getLocMemOffset(), isImmutable);
1833     return DAG.getFrameIndex(FI, getPointerTy());
1834   } else {
1835     int FI = MFI->CreateFixedObject(ValVT.getSizeInBits()/8,
1836                                     VA.getLocMemOffset(), isImmutable);
1837     SDValue FIN = DAG.getFrameIndex(FI, getPointerTy());
1838     return DAG.getLoad(ValVT, dl, Chain, FIN,
1839                        MachinePointerInfo::getFixedStack(FI),
1840                        false, false, false, 0);
1841   }
1842 }
1843
1844 SDValue
1845 X86TargetLowering::LowerFormalArguments(SDValue Chain,
1846                                         CallingConv::ID CallConv,
1847                                         bool isVarArg,
1848                                       const SmallVectorImpl<ISD::InputArg> &Ins,
1849                                         DebugLoc dl,
1850                                         SelectionDAG &DAG,
1851                                         SmallVectorImpl<SDValue> &InVals)
1852                                           const {
1853   MachineFunction &MF = DAG.getMachineFunction();
1854   X86MachineFunctionInfo *FuncInfo = MF.getInfo<X86MachineFunctionInfo>();
1855
1856   const Function* Fn = MF.getFunction();
1857   if (Fn->hasExternalLinkage() &&
1858       Subtarget->isTargetCygMing() &&
1859       Fn->getName() == "main")
1860     FuncInfo->setForceFramePointer(true);
1861
1862   MachineFrameInfo *MFI = MF.getFrameInfo();
1863   bool Is64Bit = Subtarget->is64Bit();
1864   bool IsWindows = Subtarget->isTargetWindows();
1865   bool IsWin64 = Subtarget->isTargetWin64();
1866
1867   assert(!(isVarArg && IsTailCallConvention(CallConv)) &&
1868          "Var args not supported with calling convention fastcc or ghc");
1869
1870   // Assign locations to all of the incoming arguments.
1871   SmallVector<CCValAssign, 16> ArgLocs;
1872   CCState CCInfo(CallConv, isVarArg, MF, getTargetMachine(),
1873                  ArgLocs, *DAG.getContext());
1874
1875   // Allocate shadow area for Win64
1876   if (IsWin64) {
1877     CCInfo.AllocateStack(32, 8);
1878   }
1879
1880   CCInfo.AnalyzeFormalArguments(Ins, CC_X86);
1881
1882   unsigned LastVal = ~0U;
1883   SDValue ArgValue;
1884   for (unsigned i = 0, e = ArgLocs.size(); i != e; ++i) {
1885     CCValAssign &VA = ArgLocs[i];
1886     // TODO: If an arg is passed in two places (e.g. reg and stack), skip later
1887     // places.
1888     assert(VA.getValNo() != LastVal &&
1889            "Don't support value assigned to multiple locs yet");
1890     (void)LastVal;
1891     LastVal = VA.getValNo();
1892
1893     if (VA.isRegLoc()) {
1894       EVT RegVT = VA.getLocVT();
1895       const TargetRegisterClass *RC;
1896       if (RegVT == MVT::i32)
1897         RC = &X86::GR32RegClass;
1898       else if (Is64Bit && RegVT == MVT::i64)
1899         RC = &X86::GR64RegClass;
1900       else if (RegVT == MVT::f32)
1901         RC = &X86::FR32RegClass;
1902       else if (RegVT == MVT::f64)
1903         RC = &X86::FR64RegClass;
1904       else if (RegVT.isVector() && RegVT.getSizeInBits() == 256)
1905         RC = &X86::VR256RegClass;
1906       else if (RegVT.isVector() && RegVT.getSizeInBits() == 128)
1907         RC = &X86::VR128RegClass;
1908       else if (RegVT == MVT::x86mmx)
1909         RC = &X86::VR64RegClass;
1910       else
1911         llvm_unreachable("Unknown argument type!");
1912
1913       unsigned Reg = MF.addLiveIn(VA.getLocReg(), RC);
1914       ArgValue = DAG.getCopyFromReg(Chain, dl, Reg, RegVT);
1915
1916       // If this is an 8 or 16-bit value, it is really passed promoted to 32
1917       // bits.  Insert an assert[sz]ext to capture this, then truncate to the
1918       // right size.
1919       if (VA.getLocInfo() == CCValAssign::SExt)
1920         ArgValue = DAG.getNode(ISD::AssertSext, dl, RegVT, ArgValue,
1921                                DAG.getValueType(VA.getValVT()));
1922       else if (VA.getLocInfo() == CCValAssign::ZExt)
1923         ArgValue = DAG.getNode(ISD::AssertZext, dl, RegVT, ArgValue,
1924                                DAG.getValueType(VA.getValVT()));
1925       else if (VA.getLocInfo() == CCValAssign::BCvt)
1926         ArgValue = DAG.getNode(ISD::BITCAST, dl, VA.getValVT(), ArgValue);
1927
1928       if (VA.isExtInLoc()) {
1929         // Handle MMX values passed in XMM regs.
1930         if (RegVT.isVector()) {
1931           ArgValue = DAG.getNode(X86ISD::MOVDQ2Q, dl, VA.getValVT(),
1932                                  ArgValue);
1933         } else
1934           ArgValue = DAG.getNode(ISD::TRUNCATE, dl, VA.getValVT(), ArgValue);
1935       }
1936     } else {
1937       assert(VA.isMemLoc());
1938       ArgValue = LowerMemArgument(Chain, CallConv, Ins, dl, DAG, VA, MFI, i);
1939     }
1940
1941     // If value is passed via pointer - do a load.
1942     if (VA.getLocInfo() == CCValAssign::Indirect)
1943       ArgValue = DAG.getLoad(VA.getValVT(), dl, Chain, ArgValue,
1944                              MachinePointerInfo(), false, false, false, 0);
1945
1946     InVals.push_back(ArgValue);
1947   }
1948
1949   // The x86-64 ABI for returning structs by value requires that we copy
1950   // the sret argument into %rax for the return. Save the argument into
1951   // a virtual register so that we can access it from the return points.
1952   if (Is64Bit && MF.getFunction()->hasStructRetAttr()) {
1953     X86MachineFunctionInfo *FuncInfo = MF.getInfo<X86MachineFunctionInfo>();
1954     unsigned Reg = FuncInfo->getSRetReturnReg();
1955     if (!Reg) {
1956       Reg = MF.getRegInfo().createVirtualRegister(getRegClassFor(MVT::i64));
1957       FuncInfo->setSRetReturnReg(Reg);
1958     }
1959     SDValue Copy = DAG.getCopyToReg(DAG.getEntryNode(), dl, Reg, InVals[0]);
1960     Chain = DAG.getNode(ISD::TokenFactor, dl, MVT::Other, Copy, Chain);
1961   }
1962
1963   unsigned StackSize = CCInfo.getNextStackOffset();
1964   // Align stack specially for tail calls.
1965   if (FuncIsMadeTailCallSafe(CallConv,
1966                              MF.getTarget().Options.GuaranteedTailCallOpt))
1967     StackSize = GetAlignedArgumentStackSize(StackSize, DAG);
1968
1969   // If the function takes variable number of arguments, make a frame index for
1970   // the start of the first vararg value... for expansion of llvm.va_start.
1971   if (isVarArg) {
1972     if (Is64Bit || (CallConv != CallingConv::X86_FastCall &&
1973                     CallConv != CallingConv::X86_ThisCall)) {
1974       FuncInfo->setVarArgsFrameIndex(MFI->CreateFixedObject(1, StackSize,true));
1975     }
1976     if (Is64Bit) {
1977       unsigned TotalNumIntRegs = 0, TotalNumXMMRegs = 0;
1978
1979       // FIXME: We should really autogenerate these arrays
1980       static const uint16_t GPR64ArgRegsWin64[] = {
1981         X86::RCX, X86::RDX, X86::R8,  X86::R9
1982       };
1983       static const uint16_t GPR64ArgRegs64Bit[] = {
1984         X86::RDI, X86::RSI, X86::RDX, X86::RCX, X86::R8, X86::R9
1985       };
1986       static const uint16_t XMMArgRegs64Bit[] = {
1987         X86::XMM0, X86::XMM1, X86::XMM2, X86::XMM3,
1988         X86::XMM4, X86::XMM5, X86::XMM6, X86::XMM7
1989       };
1990       const uint16_t *GPR64ArgRegs;
1991       unsigned NumXMMRegs = 0;
1992
1993       if (IsWin64) {
1994         // The XMM registers which might contain var arg parameters are shadowed
1995         // in their paired GPR.  So we only need to save the GPR to their home
1996         // slots.
1997         TotalNumIntRegs = 4;
1998         GPR64ArgRegs = GPR64ArgRegsWin64;
1999       } else {
2000         TotalNumIntRegs = 6; TotalNumXMMRegs = 8;
2001         GPR64ArgRegs = GPR64ArgRegs64Bit;
2002
2003         NumXMMRegs = CCInfo.getFirstUnallocated(XMMArgRegs64Bit,
2004                                                 TotalNumXMMRegs);
2005       }
2006       unsigned NumIntRegs = CCInfo.getFirstUnallocated(GPR64ArgRegs,
2007                                                        TotalNumIntRegs);
2008
2009       bool NoImplicitFloatOps = Fn->hasFnAttr(Attribute::NoImplicitFloat);
2010       assert(!(NumXMMRegs && !Subtarget->hasSSE1()) &&
2011              "SSE register cannot be used when SSE is disabled!");
2012       assert(!(NumXMMRegs && MF.getTarget().Options.UseSoftFloat &&
2013                NoImplicitFloatOps) &&
2014              "SSE register cannot be used when SSE is disabled!");
2015       if (MF.getTarget().Options.UseSoftFloat || NoImplicitFloatOps ||
2016           !Subtarget->hasSSE1())
2017         // Kernel mode asks for SSE to be disabled, so don't push them
2018         // on the stack.
2019         TotalNumXMMRegs = 0;
2020
2021       if (IsWin64) {
2022         const TargetFrameLowering &TFI = *getTargetMachine().getFrameLowering();
2023         // Get to the caller-allocated home save location.  Add 8 to account
2024         // for the return address.
2025         int HomeOffset = TFI.getOffsetOfLocalArea() + 8;
2026         FuncInfo->setRegSaveFrameIndex(
2027           MFI->CreateFixedObject(1, NumIntRegs * 8 + HomeOffset, false));
2028         // Fixup to set vararg frame on shadow area (4 x i64).
2029         if (NumIntRegs < 4)
2030           FuncInfo->setVarArgsFrameIndex(FuncInfo->getRegSaveFrameIndex());
2031       } else {
2032         // For X86-64, if there are vararg parameters that are passed via
2033         // registers, then we must store them to their spots on the stack so
2034         // they may be loaded by deferencing the result of va_next.
2035         FuncInfo->setVarArgsGPOffset(NumIntRegs * 8);
2036         FuncInfo->setVarArgsFPOffset(TotalNumIntRegs * 8 + NumXMMRegs * 16);
2037         FuncInfo->setRegSaveFrameIndex(
2038           MFI->CreateStackObject(TotalNumIntRegs * 8 + TotalNumXMMRegs * 16, 16,
2039                                false));
2040       }
2041
2042       // Store the integer parameter registers.
2043       SmallVector<SDValue, 8> MemOps;
2044       SDValue RSFIN = DAG.getFrameIndex(FuncInfo->getRegSaveFrameIndex(),
2045                                         getPointerTy());
2046       unsigned Offset = FuncInfo->getVarArgsGPOffset();
2047       for (; NumIntRegs != TotalNumIntRegs; ++NumIntRegs) {
2048         SDValue FIN = DAG.getNode(ISD::ADD, dl, getPointerTy(), RSFIN,
2049                                   DAG.getIntPtrConstant(Offset));
2050         unsigned VReg = MF.addLiveIn(GPR64ArgRegs[NumIntRegs],
2051                                      &X86::GR64RegClass);
2052         SDValue Val = DAG.getCopyFromReg(Chain, dl, VReg, MVT::i64);
2053         SDValue Store =
2054           DAG.getStore(Val.getValue(1), dl, Val, FIN,
2055                        MachinePointerInfo::getFixedStack(
2056                          FuncInfo->getRegSaveFrameIndex(), Offset),
2057                        false, false, 0);
2058         MemOps.push_back(Store);
2059         Offset += 8;
2060       }
2061
2062       if (TotalNumXMMRegs != 0 && NumXMMRegs != TotalNumXMMRegs) {
2063         // Now store the XMM (fp + vector) parameter registers.
2064         SmallVector<SDValue, 11> SaveXMMOps;
2065         SaveXMMOps.push_back(Chain);
2066
2067         unsigned AL = MF.addLiveIn(X86::AL, &X86::GR8RegClass);
2068         SDValue ALVal = DAG.getCopyFromReg(DAG.getEntryNode(), dl, AL, MVT::i8);
2069         SaveXMMOps.push_back(ALVal);
2070
2071         SaveXMMOps.push_back(DAG.getIntPtrConstant(
2072                                FuncInfo->getRegSaveFrameIndex()));
2073         SaveXMMOps.push_back(DAG.getIntPtrConstant(
2074                                FuncInfo->getVarArgsFPOffset()));
2075
2076         for (; NumXMMRegs != TotalNumXMMRegs; ++NumXMMRegs) {
2077           unsigned VReg = MF.addLiveIn(XMMArgRegs64Bit[NumXMMRegs],
2078                                        &X86::VR128RegClass);
2079           SDValue Val = DAG.getCopyFromReg(Chain, dl, VReg, MVT::v4f32);
2080           SaveXMMOps.push_back(Val);
2081         }
2082         MemOps.push_back(DAG.getNode(X86ISD::VASTART_SAVE_XMM_REGS, dl,
2083                                      MVT::Other,
2084                                      &SaveXMMOps[0], SaveXMMOps.size()));
2085       }
2086
2087       if (!MemOps.empty())
2088         Chain = DAG.getNode(ISD::TokenFactor, dl, MVT::Other,
2089                             &MemOps[0], MemOps.size());
2090     }
2091   }
2092
2093   // Some CCs need callee pop.
2094   if (X86::isCalleePop(CallConv, Is64Bit, isVarArg,
2095                        MF.getTarget().Options.GuaranteedTailCallOpt)) {
2096     FuncInfo->setBytesToPopOnReturn(StackSize); // Callee pops everything.
2097   } else {
2098     FuncInfo->setBytesToPopOnReturn(0); // Callee pops nothing.
2099     // If this is an sret function, the return should pop the hidden pointer.
2100     if (!Is64Bit && !IsTailCallConvention(CallConv) && !IsWindows &&
2101         argsAreStructReturn(Ins) == StackStructReturn)
2102       FuncInfo->setBytesToPopOnReturn(4);
2103   }
2104
2105   if (!Is64Bit) {
2106     // RegSaveFrameIndex is X86-64 only.
2107     FuncInfo->setRegSaveFrameIndex(0xAAAAAAA);
2108     if (CallConv == CallingConv::X86_FastCall ||
2109         CallConv == CallingConv::X86_ThisCall)
2110       // fastcc functions can't have varargs.
2111       FuncInfo->setVarArgsFrameIndex(0xAAAAAAA);
2112   }
2113
2114   FuncInfo->setArgumentStackSize(StackSize);
2115
2116   return Chain;
2117 }
2118
2119 SDValue
2120 X86TargetLowering::LowerMemOpCallTo(SDValue Chain,
2121                                     SDValue StackPtr, SDValue Arg,
2122                                     DebugLoc dl, SelectionDAG &DAG,
2123                                     const CCValAssign &VA,
2124                                     ISD::ArgFlagsTy Flags) const {
2125   unsigned LocMemOffset = VA.getLocMemOffset();
2126   SDValue PtrOff = DAG.getIntPtrConstant(LocMemOffset);
2127   PtrOff = DAG.getNode(ISD::ADD, dl, getPointerTy(), StackPtr, PtrOff);
2128   if (Flags.isByVal())
2129     return CreateCopyOfByValArgument(Arg, PtrOff, Chain, Flags, DAG, dl);
2130
2131   return DAG.getStore(Chain, dl, Arg, PtrOff,
2132                       MachinePointerInfo::getStack(LocMemOffset),
2133                       false, false, 0);
2134 }
2135
2136 /// EmitTailCallLoadRetAddr - Emit a load of return address if tail call
2137 /// optimization is performed and it is required.
2138 SDValue
2139 X86TargetLowering::EmitTailCallLoadRetAddr(SelectionDAG &DAG,
2140                                            SDValue &OutRetAddr, SDValue Chain,
2141                                            bool IsTailCall, bool Is64Bit,
2142                                            int FPDiff, DebugLoc dl) const {
2143   // Adjust the Return address stack slot.
2144   EVT VT = getPointerTy();
2145   OutRetAddr = getReturnAddressFrameIndex(DAG);
2146
2147   // Load the "old" Return address.
2148   OutRetAddr = DAG.getLoad(VT, dl, Chain, OutRetAddr, MachinePointerInfo(),
2149                            false, false, false, 0);
2150   return SDValue(OutRetAddr.getNode(), 1);
2151 }
2152
2153 /// EmitTailCallStoreRetAddr - Emit a store of the return address if tail call
2154 /// optimization is performed and it is required (FPDiff!=0).
2155 static SDValue
2156 EmitTailCallStoreRetAddr(SelectionDAG & DAG, MachineFunction &MF,
2157                          SDValue Chain, SDValue RetAddrFrIdx,
2158                          bool Is64Bit, int FPDiff, DebugLoc dl) {
2159   // Store the return address to the appropriate stack slot.
2160   if (!FPDiff) return Chain;
2161   // Calculate the new stack slot for the return address.
2162   int SlotSize = Is64Bit ? 8 : 4;
2163   int NewReturnAddrFI =
2164     MF.getFrameInfo()->CreateFixedObject(SlotSize, FPDiff-SlotSize, false);
2165   EVT VT = Is64Bit ? MVT::i64 : MVT::i32;
2166   SDValue NewRetAddrFrIdx = DAG.getFrameIndex(NewReturnAddrFI, VT);
2167   Chain = DAG.getStore(Chain, dl, RetAddrFrIdx, NewRetAddrFrIdx,
2168                        MachinePointerInfo::getFixedStack(NewReturnAddrFI),
2169                        false, false, 0);
2170   return Chain;
2171 }
2172
2173 SDValue
2174 X86TargetLowering::LowerCall(TargetLowering::CallLoweringInfo &CLI,
2175                              SmallVectorImpl<SDValue> &InVals) const {
2176   SelectionDAG &DAG                     = CLI.DAG;
2177   DebugLoc &dl                          = CLI.DL;
2178   SmallVector<ISD::OutputArg, 32> &Outs = CLI.Outs;
2179   SmallVector<SDValue, 32> &OutVals     = CLI.OutVals;
2180   SmallVector<ISD::InputArg, 32> &Ins   = CLI.Ins;
2181   SDValue Chain                         = CLI.Chain;
2182   SDValue Callee                        = CLI.Callee;
2183   CallingConv::ID CallConv              = CLI.CallConv;
2184   bool &isTailCall                      = CLI.IsTailCall;
2185   bool isVarArg                         = CLI.IsVarArg;
2186
2187   MachineFunction &MF = DAG.getMachineFunction();
2188   bool Is64Bit        = Subtarget->is64Bit();
2189   bool IsWin64        = Subtarget->isTargetWin64();
2190   bool IsWindows      = Subtarget->isTargetWindows();
2191   StructReturnType SR = callIsStructReturn(Outs);
2192   bool IsSibcall      = false;
2193
2194   if (MF.getTarget().Options.DisableTailCalls)
2195     isTailCall = false;
2196
2197   if (isTailCall) {
2198     // Check if it's really possible to do a tail call.
2199     isTailCall = IsEligibleForTailCallOptimization(Callee, CallConv,
2200                     isVarArg, SR != NotStructReturn,
2201                     MF.getFunction()->hasStructRetAttr(),
2202                     Outs, OutVals, Ins, DAG);
2203
2204     // Sibcalls are automatically detected tailcalls which do not require
2205     // ABI changes.
2206     if (!MF.getTarget().Options.GuaranteedTailCallOpt && isTailCall)
2207       IsSibcall = true;
2208
2209     if (isTailCall)
2210       ++NumTailCalls;
2211   }
2212
2213   assert(!(isVarArg && IsTailCallConvention(CallConv)) &&
2214          "Var args not supported with calling convention fastcc or ghc");
2215
2216   // Analyze operands of the call, assigning locations to each operand.
2217   SmallVector<CCValAssign, 16> ArgLocs;
2218   CCState CCInfo(CallConv, isVarArg, MF, getTargetMachine(),
2219                  ArgLocs, *DAG.getContext());
2220
2221   // Allocate shadow area for Win64
2222   if (IsWin64) {
2223     CCInfo.AllocateStack(32, 8);
2224   }
2225
2226   CCInfo.AnalyzeCallOperands(Outs, CC_X86);
2227
2228   // Get a count of how many bytes are to be pushed on the stack.
2229   unsigned NumBytes = CCInfo.getNextStackOffset();
2230   if (IsSibcall)
2231     // This is a sibcall. The memory operands are available in caller's
2232     // own caller's stack.
2233     NumBytes = 0;
2234   else if (getTargetMachine().Options.GuaranteedTailCallOpt &&
2235            IsTailCallConvention(CallConv))
2236     NumBytes = GetAlignedArgumentStackSize(NumBytes, DAG);
2237
2238   int FPDiff = 0;
2239   if (isTailCall && !IsSibcall) {
2240     // Lower arguments at fp - stackoffset + fpdiff.
2241     unsigned NumBytesCallerPushed =
2242       MF.getInfo<X86MachineFunctionInfo>()->getBytesToPopOnReturn();
2243     FPDiff = NumBytesCallerPushed - NumBytes;
2244
2245     // Set the delta of movement of the returnaddr stackslot.
2246     // But only set if delta is greater than previous delta.
2247     if (FPDiff < (MF.getInfo<X86MachineFunctionInfo>()->getTCReturnAddrDelta()))
2248       MF.getInfo<X86MachineFunctionInfo>()->setTCReturnAddrDelta(FPDiff);
2249   }
2250
2251   if (!IsSibcall)
2252     Chain = DAG.getCALLSEQ_START(Chain, DAG.getIntPtrConstant(NumBytes, true));
2253
2254   SDValue RetAddrFrIdx;
2255   // Load return address for tail calls.
2256   if (isTailCall && FPDiff)
2257     Chain = EmitTailCallLoadRetAddr(DAG, RetAddrFrIdx, Chain, isTailCall,
2258                                     Is64Bit, FPDiff, dl);
2259
2260   SmallVector<std::pair<unsigned, SDValue>, 8> RegsToPass;
2261   SmallVector<SDValue, 8> MemOpChains;
2262   SDValue StackPtr;
2263
2264   // Walk the register/memloc assignments, inserting copies/loads.  In the case
2265   // of tail call optimization arguments are handle later.
2266   for (unsigned i = 0, e = ArgLocs.size(); i != e; ++i) {
2267     CCValAssign &VA = ArgLocs[i];
2268     EVT RegVT = VA.getLocVT();
2269     SDValue Arg = OutVals[i];
2270     ISD::ArgFlagsTy Flags = Outs[i].Flags;
2271     bool isByVal = Flags.isByVal();
2272
2273     // Promote the value if needed.
2274     switch (VA.getLocInfo()) {
2275     default: llvm_unreachable("Unknown loc info!");
2276     case CCValAssign::Full: break;
2277     case CCValAssign::SExt:
2278       Arg = DAG.getNode(ISD::SIGN_EXTEND, dl, RegVT, Arg);
2279       break;
2280     case CCValAssign::ZExt:
2281       Arg = DAG.getNode(ISD::ZERO_EXTEND, dl, RegVT, Arg);
2282       break;
2283     case CCValAssign::AExt:
2284       if (RegVT.isVector() && RegVT.getSizeInBits() == 128) {
2285         // Special case: passing MMX values in XMM registers.
2286         Arg = DAG.getNode(ISD::BITCAST, dl, MVT::i64, Arg);
2287         Arg = DAG.getNode(ISD::SCALAR_TO_VECTOR, dl, MVT::v2i64, Arg);
2288         Arg = getMOVL(DAG, dl, MVT::v2i64, DAG.getUNDEF(MVT::v2i64), Arg);
2289       } else
2290         Arg = DAG.getNode(ISD::ANY_EXTEND, dl, RegVT, Arg);
2291       break;
2292     case CCValAssign::BCvt:
2293       Arg = DAG.getNode(ISD::BITCAST, dl, RegVT, Arg);
2294       break;
2295     case CCValAssign::Indirect: {
2296       // Store the argument.
2297       SDValue SpillSlot = DAG.CreateStackTemporary(VA.getValVT());
2298       int FI = cast<FrameIndexSDNode>(SpillSlot)->getIndex();
2299       Chain = DAG.getStore(Chain, dl, Arg, SpillSlot,
2300                            MachinePointerInfo::getFixedStack(FI),
2301                            false, false, 0);
2302       Arg = SpillSlot;
2303       break;
2304     }
2305     }
2306
2307     if (VA.isRegLoc()) {
2308       RegsToPass.push_back(std::make_pair(VA.getLocReg(), Arg));
2309       if (isVarArg && IsWin64) {
2310         // Win64 ABI requires argument XMM reg to be copied to the corresponding
2311         // shadow reg if callee is a varargs function.
2312         unsigned ShadowReg = 0;
2313         switch (VA.getLocReg()) {
2314         case X86::XMM0: ShadowReg = X86::RCX; break;
2315         case X86::XMM1: ShadowReg = X86::RDX; break;
2316         case X86::XMM2: ShadowReg = X86::R8; break;
2317         case X86::XMM3: ShadowReg = X86::R9; break;
2318         }
2319         if (ShadowReg)
2320           RegsToPass.push_back(std::make_pair(ShadowReg, Arg));
2321       }
2322     } else if (!IsSibcall && (!isTailCall || isByVal)) {
2323       assert(VA.isMemLoc());
2324       if (StackPtr.getNode() == 0)
2325         StackPtr = DAG.getCopyFromReg(Chain, dl, X86StackPtr, getPointerTy());
2326       MemOpChains.push_back(LowerMemOpCallTo(Chain, StackPtr, Arg,
2327                                              dl, DAG, VA, Flags));
2328     }
2329   }
2330
2331   if (!MemOpChains.empty())
2332     Chain = DAG.getNode(ISD::TokenFactor, dl, MVT::Other,
2333                         &MemOpChains[0], MemOpChains.size());
2334
2335   if (Subtarget->isPICStyleGOT()) {
2336     // ELF / PIC requires GOT in the EBX register before function calls via PLT
2337     // GOT pointer.
2338     if (!isTailCall) {
2339       RegsToPass.push_back(std::make_pair(unsigned(X86::EBX),
2340                DAG.getNode(X86ISD::GlobalBaseReg, DebugLoc(), getPointerTy())));
2341     } else {
2342       // If we are tail calling and generating PIC/GOT style code load the
2343       // address of the callee into ECX. The value in ecx is used as target of
2344       // the tail jump. This is done to circumvent the ebx/callee-saved problem
2345       // for tail calls on PIC/GOT architectures. Normally we would just put the
2346       // address of GOT into ebx and then call target@PLT. But for tail calls
2347       // ebx would be restored (since ebx is callee saved) before jumping to the
2348       // target@PLT.
2349
2350       // Note: The actual moving to ECX is done further down.
2351       GlobalAddressSDNode *G = dyn_cast<GlobalAddressSDNode>(Callee);
2352       if (G && !G->getGlobal()->hasHiddenVisibility() &&
2353           !G->getGlobal()->hasProtectedVisibility())
2354         Callee = LowerGlobalAddress(Callee, DAG);
2355       else if (isa<ExternalSymbolSDNode>(Callee))
2356         Callee = LowerExternalSymbol(Callee, DAG);
2357     }
2358   }
2359
2360   if (Is64Bit && isVarArg && !IsWin64) {
2361     // From AMD64 ABI document:
2362     // For calls that may call functions that use varargs or stdargs
2363     // (prototype-less calls or calls to functions containing ellipsis (...) in
2364     // the declaration) %al is used as hidden argument to specify the number
2365     // of SSE registers used. The contents of %al do not need to match exactly
2366     // the number of registers, but must be an ubound on the number of SSE
2367     // registers used and is in the range 0 - 8 inclusive.
2368
2369     // Count the number of XMM registers allocated.
2370     static const uint16_t XMMArgRegs[] = {
2371       X86::XMM0, X86::XMM1, X86::XMM2, X86::XMM3,
2372       X86::XMM4, X86::XMM5, X86::XMM6, X86::XMM7
2373     };
2374     unsigned NumXMMRegs = CCInfo.getFirstUnallocated(XMMArgRegs, 8);
2375     assert((Subtarget->hasSSE1() || !NumXMMRegs)
2376            && "SSE registers cannot be used when SSE is disabled");
2377
2378     RegsToPass.push_back(std::make_pair(unsigned(X86::AL),
2379                                         DAG.getConstant(NumXMMRegs, MVT::i8)));
2380   }
2381
2382   // For tail calls lower the arguments to the 'real' stack slot.
2383   if (isTailCall) {
2384     // Force all the incoming stack arguments to be loaded from the stack
2385     // before any new outgoing arguments are stored to the stack, because the
2386     // outgoing stack slots may alias the incoming argument stack slots, and
2387     // the alias isn't otherwise explicit. This is slightly more conservative
2388     // than necessary, because it means that each store effectively depends
2389     // on every argument instead of just those arguments it would clobber.
2390     SDValue ArgChain = DAG.getStackArgumentTokenFactor(Chain);
2391
2392     SmallVector<SDValue, 8> MemOpChains2;
2393     SDValue FIN;
2394     int FI = 0;
2395     if (getTargetMachine().Options.GuaranteedTailCallOpt) {
2396       for (unsigned i = 0, e = ArgLocs.size(); i != e; ++i) {
2397         CCValAssign &VA = ArgLocs[i];
2398         if (VA.isRegLoc())
2399           continue;
2400         assert(VA.isMemLoc());
2401         SDValue Arg = OutVals[i];
2402         ISD::ArgFlagsTy Flags = Outs[i].Flags;
2403         // Create frame index.
2404         int32_t Offset = VA.getLocMemOffset()+FPDiff;
2405         uint32_t OpSize = (VA.getLocVT().getSizeInBits()+7)/8;
2406         FI = MF.getFrameInfo()->CreateFixedObject(OpSize, Offset, true);
2407         FIN = DAG.getFrameIndex(FI, getPointerTy());
2408
2409         if (Flags.isByVal()) {
2410           // Copy relative to framepointer.
2411           SDValue Source = DAG.getIntPtrConstant(VA.getLocMemOffset());
2412           if (StackPtr.getNode() == 0)
2413             StackPtr = DAG.getCopyFromReg(Chain, dl, X86StackPtr,
2414                                           getPointerTy());
2415           Source = DAG.getNode(ISD::ADD, dl, getPointerTy(), StackPtr, Source);
2416
2417           MemOpChains2.push_back(CreateCopyOfByValArgument(Source, FIN,
2418                                                            ArgChain,
2419                                                            Flags, DAG, dl));
2420         } else {
2421           // Store relative to framepointer.
2422           MemOpChains2.push_back(
2423             DAG.getStore(ArgChain, dl, Arg, FIN,
2424                          MachinePointerInfo::getFixedStack(FI),
2425                          false, false, 0));
2426         }
2427       }
2428     }
2429
2430     if (!MemOpChains2.empty())
2431       Chain = DAG.getNode(ISD::TokenFactor, dl, MVT::Other,
2432                           &MemOpChains2[0], MemOpChains2.size());
2433
2434     // Store the return address to the appropriate stack slot.
2435     Chain = EmitTailCallStoreRetAddr(DAG, MF, Chain, RetAddrFrIdx, Is64Bit,
2436                                      FPDiff, dl);
2437   }
2438
2439   // Build a sequence of copy-to-reg nodes chained together with token chain
2440   // and flag operands which copy the outgoing args into registers.
2441   SDValue InFlag;
2442   for (unsigned i = 0, e = RegsToPass.size(); i != e; ++i) {
2443     Chain = DAG.getCopyToReg(Chain, dl, RegsToPass[i].first,
2444                              RegsToPass[i].second, InFlag);
2445     InFlag = Chain.getValue(1);
2446   }
2447
2448   if (getTargetMachine().getCodeModel() == CodeModel::Large) {
2449     assert(Is64Bit && "Large code model is only legal in 64-bit mode.");
2450     // In the 64-bit large code model, we have to make all calls
2451     // through a register, since the call instruction's 32-bit
2452     // pc-relative offset may not be large enough to hold the whole
2453     // address.
2454   } else if (GlobalAddressSDNode *G = dyn_cast<GlobalAddressSDNode>(Callee)) {
2455     // If the callee is a GlobalAddress node (quite common, every direct call
2456     // is) turn it into a TargetGlobalAddress node so that legalize doesn't hack
2457     // it.
2458
2459     // We should use extra load for direct calls to dllimported functions in
2460     // non-JIT mode.
2461     const GlobalValue *GV = G->getGlobal();
2462     if (!GV->hasDLLImportLinkage()) {
2463       unsigned char OpFlags = 0;
2464       bool ExtraLoad = false;
2465       unsigned WrapperKind = ISD::DELETED_NODE;
2466
2467       // On ELF targets, in both X86-64 and X86-32 mode, direct calls to
2468       // external symbols most go through the PLT in PIC mode.  If the symbol
2469       // has hidden or protected visibility, or if it is static or local, then
2470       // we don't need to use the PLT - we can directly call it.
2471       if (Subtarget->isTargetELF() &&
2472           getTargetMachine().getRelocationModel() == Reloc::PIC_ &&
2473           GV->hasDefaultVisibility() && !GV->hasLocalLinkage()) {
2474         OpFlags = X86II::MO_PLT;
2475       } else if (Subtarget->isPICStyleStubAny() &&
2476                  (GV->isDeclaration() || GV->isWeakForLinker()) &&
2477                  (!Subtarget->getTargetTriple().isMacOSX() ||
2478                   Subtarget->getTargetTriple().isMacOSXVersionLT(10, 5))) {
2479         // PC-relative references to external symbols should go through $stub,
2480         // unless we're building with the leopard linker or later, which
2481         // automatically synthesizes these stubs.
2482         OpFlags = X86II::MO_DARWIN_STUB;
2483       } else if (Subtarget->isPICStyleRIPRel() &&
2484                  isa<Function>(GV) &&
2485                  cast<Function>(GV)->hasFnAttr(Attribute::NonLazyBind)) {
2486         // If the function is marked as non-lazy, generate an indirect call
2487         // which loads from the GOT directly. This avoids runtime overhead
2488         // at the cost of eager binding (and one extra byte of encoding).
2489         OpFlags = X86II::MO_GOTPCREL;
2490         WrapperKind = X86ISD::WrapperRIP;
2491         ExtraLoad = true;
2492       }
2493
2494       Callee = DAG.getTargetGlobalAddress(GV, dl, getPointerTy(),
2495                                           G->getOffset(), OpFlags);
2496
2497       // Add a wrapper if needed.
2498       if (WrapperKind != ISD::DELETED_NODE)
2499         Callee = DAG.getNode(X86ISD::WrapperRIP, dl, getPointerTy(), Callee);
2500       // Add extra indirection if needed.
2501       if (ExtraLoad)
2502         Callee = DAG.getLoad(getPointerTy(), dl, DAG.getEntryNode(), Callee,
2503                              MachinePointerInfo::getGOT(),
2504                              false, false, false, 0);
2505     }
2506   } else if (ExternalSymbolSDNode *S = dyn_cast<ExternalSymbolSDNode>(Callee)) {
2507     unsigned char OpFlags = 0;
2508
2509     // On ELF targets, in either X86-64 or X86-32 mode, direct calls to
2510     // external symbols should go through the PLT.
2511     if (Subtarget->isTargetELF() &&
2512         getTargetMachine().getRelocationModel() == Reloc::PIC_) {
2513       OpFlags = X86II::MO_PLT;
2514     } else if (Subtarget->isPICStyleStubAny() &&
2515                (!Subtarget->getTargetTriple().isMacOSX() ||
2516                 Subtarget->getTargetTriple().isMacOSXVersionLT(10, 5))) {
2517       // PC-relative references to external symbols should go through $stub,
2518       // unless we're building with the leopard linker or later, which
2519       // automatically synthesizes these stubs.
2520       OpFlags = X86II::MO_DARWIN_STUB;
2521     }
2522
2523     Callee = DAG.getTargetExternalSymbol(S->getSymbol(), getPointerTy(),
2524                                          OpFlags);
2525   }
2526
2527   // Returns a chain & a flag for retval copy to use.
2528   SDVTList NodeTys = DAG.getVTList(MVT::Other, MVT::Glue);
2529   SmallVector<SDValue, 8> Ops;
2530
2531   if (!IsSibcall && isTailCall) {
2532     Chain = DAG.getCALLSEQ_END(Chain, DAG.getIntPtrConstant(NumBytes, true),
2533                            DAG.getIntPtrConstant(0, true), InFlag);
2534     InFlag = Chain.getValue(1);
2535   }
2536
2537   Ops.push_back(Chain);
2538   Ops.push_back(Callee);
2539
2540   if (isTailCall)
2541     Ops.push_back(DAG.getConstant(FPDiff, MVT::i32));
2542
2543   // Add argument registers to the end of the list so that they are known live
2544   // into the call.
2545   for (unsigned i = 0, e = RegsToPass.size(); i != e; ++i)
2546     Ops.push_back(DAG.getRegister(RegsToPass[i].first,
2547                                   RegsToPass[i].second.getValueType()));
2548
2549   // Add a register mask operand representing the call-preserved registers.
2550   const TargetRegisterInfo *TRI = getTargetMachine().getRegisterInfo();
2551   const uint32_t *Mask = TRI->getCallPreservedMask(CallConv);
2552   assert(Mask && "Missing call preserved mask for calling convention");
2553   Ops.push_back(DAG.getRegisterMask(Mask));
2554
2555   if (InFlag.getNode())
2556     Ops.push_back(InFlag);
2557
2558   if (isTailCall) {
2559     // We used to do:
2560     //// If this is the first return lowered for this function, add the regs
2561     //// to the liveout set for the function.
2562     // This isn't right, although it's probably harmless on x86; liveouts
2563     // should be computed from returns not tail calls.  Consider a void
2564     // function making a tail call to a function returning int.
2565     return DAG.getNode(X86ISD::TC_RETURN, dl,
2566                        NodeTys, &Ops[0], Ops.size());
2567   }
2568
2569   Chain = DAG.getNode(X86ISD::CALL, dl, NodeTys, &Ops[0], Ops.size());
2570   InFlag = Chain.getValue(1);
2571
2572   // Create the CALLSEQ_END node.
2573   unsigned NumBytesForCalleeToPush;
2574   if (X86::isCalleePop(CallConv, Is64Bit, isVarArg,
2575                        getTargetMachine().Options.GuaranteedTailCallOpt))
2576     NumBytesForCalleeToPush = NumBytes;    // Callee pops everything
2577   else if (!Is64Bit && !IsTailCallConvention(CallConv) && !IsWindows &&
2578            SR == StackStructReturn)
2579     // If this is a call to a struct-return function, the callee
2580     // pops the hidden struct pointer, so we have to push it back.
2581     // This is common for Darwin/X86, Linux & Mingw32 targets.
2582     // For MSVC Win32 targets, the caller pops the hidden struct pointer.
2583     NumBytesForCalleeToPush = 4;
2584   else
2585     NumBytesForCalleeToPush = 0;  // Callee pops nothing.
2586
2587   // Returns a flag for retval copy to use.
2588   if (!IsSibcall) {
2589     Chain = DAG.getCALLSEQ_END(Chain,
2590                                DAG.getIntPtrConstant(NumBytes, true),
2591                                DAG.getIntPtrConstant(NumBytesForCalleeToPush,
2592                                                      true),
2593                                InFlag);
2594     InFlag = Chain.getValue(1);
2595   }
2596
2597   // Handle result values, copying them out of physregs into vregs that we
2598   // return.
2599   return LowerCallResult(Chain, InFlag, CallConv, isVarArg,
2600                          Ins, dl, DAG, InVals);
2601 }
2602
2603
2604 //===----------------------------------------------------------------------===//
2605 //                Fast Calling Convention (tail call) implementation
2606 //===----------------------------------------------------------------------===//
2607
2608 //  Like std call, callee cleans arguments, convention except that ECX is
2609 //  reserved for storing the tail called function address. Only 2 registers are
2610 //  free for argument passing (inreg). Tail call optimization is performed
2611 //  provided:
2612 //                * tailcallopt is enabled
2613 //                * caller/callee are fastcc
2614 //  On X86_64 architecture with GOT-style position independent code only local
2615 //  (within module) calls are supported at the moment.
2616 //  To keep the stack aligned according to platform abi the function
2617 //  GetAlignedArgumentStackSize ensures that argument delta is always multiples
2618 //  of stack alignment. (Dynamic linkers need this - darwin's dyld for example)
2619 //  If a tail called function callee has more arguments than the caller the
2620 //  caller needs to make sure that there is room to move the RETADDR to. This is
2621 //  achieved by reserving an area the size of the argument delta right after the
2622 //  original REtADDR, but before the saved framepointer or the spilled registers
2623 //  e.g. caller(arg1, arg2) calls callee(arg1, arg2,arg3,arg4)
2624 //  stack layout:
2625 //    arg1
2626 //    arg2
2627 //    RETADDR
2628 //    [ new RETADDR
2629 //      move area ]
2630 //    (possible EBP)
2631 //    ESI
2632 //    EDI
2633 //    local1 ..
2634
2635 /// GetAlignedArgumentStackSize - Make the stack size align e.g 16n + 12 aligned
2636 /// for a 16 byte align requirement.
2637 unsigned
2638 X86TargetLowering::GetAlignedArgumentStackSize(unsigned StackSize,
2639                                                SelectionDAG& DAG) const {
2640   MachineFunction &MF = DAG.getMachineFunction();
2641   const TargetMachine &TM = MF.getTarget();
2642   const TargetFrameLowering &TFI = *TM.getFrameLowering();
2643   unsigned StackAlignment = TFI.getStackAlignment();
2644   uint64_t AlignMask = StackAlignment - 1;
2645   int64_t Offset = StackSize;
2646   uint64_t SlotSize = TD->getPointerSize();
2647   if ( (Offset & AlignMask) <= (StackAlignment - SlotSize) ) {
2648     // Number smaller than 12 so just add the difference.
2649     Offset += ((StackAlignment - SlotSize) - (Offset & AlignMask));
2650   } else {
2651     // Mask out lower bits, add stackalignment once plus the 12 bytes.
2652     Offset = ((~AlignMask) & Offset) + StackAlignment +
2653       (StackAlignment-SlotSize);
2654   }
2655   return Offset;
2656 }
2657
2658 /// MatchingStackOffset - Return true if the given stack call argument is
2659 /// already available in the same position (relatively) of the caller's
2660 /// incoming argument stack.
2661 static
2662 bool MatchingStackOffset(SDValue Arg, unsigned Offset, ISD::ArgFlagsTy Flags,
2663                          MachineFrameInfo *MFI, const MachineRegisterInfo *MRI,
2664                          const X86InstrInfo *TII) {
2665   unsigned Bytes = Arg.getValueType().getSizeInBits() / 8;
2666   int FI = INT_MAX;
2667   if (Arg.getOpcode() == ISD::CopyFromReg) {
2668     unsigned VR = cast<RegisterSDNode>(Arg.getOperand(1))->getReg();
2669     if (!TargetRegisterInfo::isVirtualRegister(VR))
2670       return false;
2671     MachineInstr *Def = MRI->getVRegDef(VR);
2672     if (!Def)
2673       return false;
2674     if (!Flags.isByVal()) {
2675       if (!TII->isLoadFromStackSlot(Def, FI))
2676         return false;
2677     } else {
2678       unsigned Opcode = Def->getOpcode();
2679       if ((Opcode == X86::LEA32r || Opcode == X86::LEA64r) &&
2680           Def->getOperand(1).isFI()) {
2681         FI = Def->getOperand(1).getIndex();
2682         Bytes = Flags.getByValSize();
2683       } else
2684         return false;
2685     }
2686   } else if (LoadSDNode *Ld = dyn_cast<LoadSDNode>(Arg)) {
2687     if (Flags.isByVal())
2688       // ByVal argument is passed in as a pointer but it's now being
2689       // dereferenced. e.g.
2690       // define @foo(%struct.X* %A) {
2691       //   tail call @bar(%struct.X* byval %A)
2692       // }
2693       return false;
2694     SDValue Ptr = Ld->getBasePtr();
2695     FrameIndexSDNode *FINode = dyn_cast<FrameIndexSDNode>(Ptr);
2696     if (!FINode)
2697       return false;
2698     FI = FINode->getIndex();
2699   } else if (Arg.getOpcode() == ISD::FrameIndex && Flags.isByVal()) {
2700     FrameIndexSDNode *FINode = cast<FrameIndexSDNode>(Arg);
2701     FI = FINode->getIndex();
2702     Bytes = Flags.getByValSize();
2703   } else
2704     return false;
2705
2706   assert(FI != INT_MAX);
2707   if (!MFI->isFixedObjectIndex(FI))
2708     return false;
2709   return Offset == MFI->getObjectOffset(FI) && Bytes == MFI->getObjectSize(FI);
2710 }
2711
2712 /// IsEligibleForTailCallOptimization - Check whether the call is eligible
2713 /// for tail call optimization. Targets which want to do tail call
2714 /// optimization should implement this function.
2715 bool
2716 X86TargetLowering::IsEligibleForTailCallOptimization(SDValue Callee,
2717                                                      CallingConv::ID CalleeCC,
2718                                                      bool isVarArg,
2719                                                      bool isCalleeStructRet,
2720                                                      bool isCallerStructRet,
2721                                     const SmallVectorImpl<ISD::OutputArg> &Outs,
2722                                     const SmallVectorImpl<SDValue> &OutVals,
2723                                     const SmallVectorImpl<ISD::InputArg> &Ins,
2724                                                      SelectionDAG& DAG) const {
2725   if (!IsTailCallConvention(CalleeCC) &&
2726       CalleeCC != CallingConv::C)
2727     return false;
2728
2729   // If -tailcallopt is specified, make fastcc functions tail-callable.
2730   const MachineFunction &MF = DAG.getMachineFunction();
2731   const Function *CallerF = DAG.getMachineFunction().getFunction();
2732   CallingConv::ID CallerCC = CallerF->getCallingConv();
2733   bool CCMatch = CallerCC == CalleeCC;
2734
2735   if (getTargetMachine().Options.GuaranteedTailCallOpt) {
2736     if (IsTailCallConvention(CalleeCC) && CCMatch)
2737       return true;
2738     return false;
2739   }
2740
2741   // Look for obvious safe cases to perform tail call optimization that do not
2742   // require ABI changes. This is what gcc calls sibcall.
2743
2744   // Can't do sibcall if stack needs to be dynamically re-aligned. PEI needs to
2745   // emit a special epilogue.
2746   if (RegInfo->needsStackRealignment(MF))
2747     return false;
2748
2749   // Also avoid sibcall optimization if either caller or callee uses struct
2750   // return semantics.
2751   if (isCalleeStructRet || isCallerStructRet)
2752     return false;
2753
2754   // An stdcall caller is expected to clean up its arguments; the callee
2755   // isn't going to do that.
2756   if (!CCMatch && CallerCC==CallingConv::X86_StdCall)
2757     return false;
2758
2759   // Do not sibcall optimize vararg calls unless all arguments are passed via
2760   // registers.
2761   if (isVarArg && !Outs.empty()) {
2762
2763     // Optimizing for varargs on Win64 is unlikely to be safe without
2764     // additional testing.
2765     if (Subtarget->isTargetWin64())
2766       return false;
2767
2768     SmallVector<CCValAssign, 16> ArgLocs;
2769     CCState CCInfo(CalleeCC, isVarArg, DAG.getMachineFunction(),
2770                    getTargetMachine(), ArgLocs, *DAG.getContext());
2771
2772     CCInfo.AnalyzeCallOperands(Outs, CC_X86);
2773     for (unsigned i = 0, e = ArgLocs.size(); i != e; ++i)
2774       if (!ArgLocs[i].isRegLoc())
2775         return false;
2776   }
2777
2778   // If the call result is in ST0 / ST1, it needs to be popped off the x87
2779   // stack.  Therefore, if it's not used by the call it is not safe to optimize
2780   // this into a sibcall.
2781   bool Unused = false;
2782   for (unsigned i = 0, e = Ins.size(); i != e; ++i) {
2783     if (!Ins[i].Used) {
2784       Unused = true;
2785       break;
2786     }
2787   }
2788   if (Unused) {
2789     SmallVector<CCValAssign, 16> RVLocs;
2790     CCState CCInfo(CalleeCC, false, DAG.getMachineFunction(),
2791                    getTargetMachine(), RVLocs, *DAG.getContext());
2792     CCInfo.AnalyzeCallResult(Ins, RetCC_X86);
2793     for (unsigned i = 0, e = RVLocs.size(); i != e; ++i) {
2794       CCValAssign &VA = RVLocs[i];
2795       if (VA.getLocReg() == X86::ST0 || VA.getLocReg() == X86::ST1)
2796         return false;
2797     }
2798   }
2799
2800   // If the calling conventions do not match, then we'd better make sure the
2801   // results are returned in the same way as what the caller expects.
2802   if (!CCMatch) {
2803     SmallVector<CCValAssign, 16> RVLocs1;
2804     CCState CCInfo1(CalleeCC, false, DAG.getMachineFunction(),
2805                     getTargetMachine(), RVLocs1, *DAG.getContext());
2806     CCInfo1.AnalyzeCallResult(Ins, RetCC_X86);
2807
2808     SmallVector<CCValAssign, 16> RVLocs2;
2809     CCState CCInfo2(CallerCC, false, DAG.getMachineFunction(),
2810                     getTargetMachine(), RVLocs2, *DAG.getContext());
2811     CCInfo2.AnalyzeCallResult(Ins, RetCC_X86);
2812
2813     if (RVLocs1.size() != RVLocs2.size())
2814       return false;
2815     for (unsigned i = 0, e = RVLocs1.size(); i != e; ++i) {
2816       if (RVLocs1[i].isRegLoc() != RVLocs2[i].isRegLoc())
2817         return false;
2818       if (RVLocs1[i].getLocInfo() != RVLocs2[i].getLocInfo())
2819         return false;
2820       if (RVLocs1[i].isRegLoc()) {
2821         if (RVLocs1[i].getLocReg() != RVLocs2[i].getLocReg())
2822           return false;
2823       } else {
2824         if (RVLocs1[i].getLocMemOffset() != RVLocs2[i].getLocMemOffset())
2825           return false;
2826       }
2827     }
2828   }
2829
2830   // If the callee takes no arguments then go on to check the results of the
2831   // call.
2832   if (!Outs.empty()) {
2833     // Check if stack adjustment is needed. For now, do not do this if any
2834     // argument is passed on the stack.
2835     SmallVector<CCValAssign, 16> ArgLocs;
2836     CCState CCInfo(CalleeCC, isVarArg, DAG.getMachineFunction(),
2837                    getTargetMachine(), ArgLocs, *DAG.getContext());
2838
2839     // Allocate shadow area for Win64
2840     if (Subtarget->isTargetWin64()) {
2841       CCInfo.AllocateStack(32, 8);
2842     }
2843
2844     CCInfo.AnalyzeCallOperands(Outs, CC_X86);
2845     if (CCInfo.getNextStackOffset()) {
2846       MachineFunction &MF = DAG.getMachineFunction();
2847       if (MF.getInfo<X86MachineFunctionInfo>()->getBytesToPopOnReturn())
2848         return false;
2849
2850       // Check if the arguments are already laid out in the right way as
2851       // the caller's fixed stack objects.
2852       MachineFrameInfo *MFI = MF.getFrameInfo();
2853       const MachineRegisterInfo *MRI = &MF.getRegInfo();
2854       const X86InstrInfo *TII =
2855         ((X86TargetMachine&)getTargetMachine()).getInstrInfo();
2856       for (unsigned i = 0, e = ArgLocs.size(); i != e; ++i) {
2857         CCValAssign &VA = ArgLocs[i];
2858         SDValue Arg = OutVals[i];
2859         ISD::ArgFlagsTy Flags = Outs[i].Flags;
2860         if (VA.getLocInfo() == CCValAssign::Indirect)
2861           return false;
2862         if (!VA.isRegLoc()) {
2863           if (!MatchingStackOffset(Arg, VA.getLocMemOffset(), Flags,
2864                                    MFI, MRI, TII))
2865             return false;
2866         }
2867       }
2868     }
2869
2870     // If the tailcall address may be in a register, then make sure it's
2871     // possible to register allocate for it. In 32-bit, the call address can
2872     // only target EAX, EDX, or ECX since the tail call must be scheduled after
2873     // callee-saved registers are restored. These happen to be the same
2874     // registers used to pass 'inreg' arguments so watch out for those.
2875     if (!Subtarget->is64Bit() &&
2876         !isa<GlobalAddressSDNode>(Callee) &&
2877         !isa<ExternalSymbolSDNode>(Callee)) {
2878       unsigned NumInRegs = 0;
2879       for (unsigned i = 0, e = ArgLocs.size(); i != e; ++i) {
2880         CCValAssign &VA = ArgLocs[i];
2881         if (!VA.isRegLoc())
2882           continue;
2883         unsigned Reg = VA.getLocReg();
2884         switch (Reg) {
2885         default: break;
2886         case X86::EAX: case X86::EDX: case X86::ECX:
2887           if (++NumInRegs == 3)
2888             return false;
2889           break;
2890         }
2891       }
2892     }
2893   }
2894
2895   return true;
2896 }
2897
2898 FastISel *
2899 X86TargetLowering::createFastISel(FunctionLoweringInfo &funcInfo,
2900                                   const TargetLibraryInfo *libInfo) const {
2901   return X86::createFastISel(funcInfo, libInfo);
2902 }
2903
2904
2905 //===----------------------------------------------------------------------===//
2906 //                           Other Lowering Hooks
2907 //===----------------------------------------------------------------------===//
2908
2909 static bool MayFoldLoad(SDValue Op) {
2910   return Op.hasOneUse() && ISD::isNormalLoad(Op.getNode());
2911 }
2912
2913 static bool MayFoldIntoStore(SDValue Op) {
2914   return Op.hasOneUse() && ISD::isNormalStore(*Op.getNode()->use_begin());
2915 }
2916
2917 static bool isTargetShuffle(unsigned Opcode) {
2918   switch(Opcode) {
2919   default: return false;
2920   case X86ISD::PSHUFD:
2921   case X86ISD::PSHUFHW:
2922   case X86ISD::PSHUFLW:
2923   case X86ISD::SHUFP:
2924   case X86ISD::PALIGN:
2925   case X86ISD::MOVLHPS:
2926   case X86ISD::MOVLHPD:
2927   case X86ISD::MOVHLPS:
2928   case X86ISD::MOVLPS:
2929   case X86ISD::MOVLPD:
2930   case X86ISD::MOVSHDUP:
2931   case X86ISD::MOVSLDUP:
2932   case X86ISD::MOVDDUP:
2933   case X86ISD::MOVSS:
2934   case X86ISD::MOVSD:
2935   case X86ISD::UNPCKL:
2936   case X86ISD::UNPCKH:
2937   case X86ISD::VPERMILP:
2938   case X86ISD::VPERM2X128:
2939   case X86ISD::VPERMI:
2940     return true;
2941   }
2942 }
2943
2944 static SDValue getTargetShuffleNode(unsigned Opc, DebugLoc dl, EVT VT,
2945                                     SDValue V1, SelectionDAG &DAG) {
2946   switch(Opc) {
2947   default: llvm_unreachable("Unknown x86 shuffle node");
2948   case X86ISD::MOVSHDUP:
2949   case X86ISD::MOVSLDUP:
2950   case X86ISD::MOVDDUP:
2951     return DAG.getNode(Opc, dl, VT, V1);
2952   }
2953 }
2954
2955 static SDValue getTargetShuffleNode(unsigned Opc, DebugLoc dl, EVT VT,
2956                                     SDValue V1, unsigned TargetMask,
2957                                     SelectionDAG &DAG) {
2958   switch(Opc) {
2959   default: llvm_unreachable("Unknown x86 shuffle node");
2960   case X86ISD::PSHUFD:
2961   case X86ISD::PSHUFHW:
2962   case X86ISD::PSHUFLW:
2963   case X86ISD::VPERMILP:
2964   case X86ISD::VPERMI:
2965     return DAG.getNode(Opc, dl, VT, V1, DAG.getConstant(TargetMask, MVT::i8));
2966   }
2967 }
2968
2969 static SDValue getTargetShuffleNode(unsigned Opc, DebugLoc dl, EVT VT,
2970                                     SDValue V1, SDValue V2, unsigned TargetMask,
2971                                     SelectionDAG &DAG) {
2972   switch(Opc) {
2973   default: llvm_unreachable("Unknown x86 shuffle node");
2974   case X86ISD::PALIGN:
2975   case X86ISD::SHUFP:
2976   case X86ISD::VPERM2X128:
2977     return DAG.getNode(Opc, dl, VT, V1, V2,
2978                        DAG.getConstant(TargetMask, MVT::i8));
2979   }
2980 }
2981
2982 static SDValue getTargetShuffleNode(unsigned Opc, DebugLoc dl, EVT VT,
2983                                     SDValue V1, SDValue V2, SelectionDAG &DAG) {
2984   switch(Opc) {
2985   default: llvm_unreachable("Unknown x86 shuffle node");
2986   case X86ISD::MOVLHPS:
2987   case X86ISD::MOVLHPD:
2988   case X86ISD::MOVHLPS:
2989   case X86ISD::MOVLPS:
2990   case X86ISD::MOVLPD:
2991   case X86ISD::MOVSS:
2992   case X86ISD::MOVSD:
2993   case X86ISD::UNPCKL:
2994   case X86ISD::UNPCKH:
2995     return DAG.getNode(Opc, dl, VT, V1, V2);
2996   }
2997 }
2998
2999 SDValue X86TargetLowering::getReturnAddressFrameIndex(SelectionDAG &DAG) const {
3000   MachineFunction &MF = DAG.getMachineFunction();
3001   X86MachineFunctionInfo *FuncInfo = MF.getInfo<X86MachineFunctionInfo>();
3002   int ReturnAddrIndex = FuncInfo->getRAIndex();
3003
3004   if (ReturnAddrIndex == 0) {
3005     // Set up a frame object for the return address.
3006     uint64_t SlotSize = TD->getPointerSize();
3007     ReturnAddrIndex = MF.getFrameInfo()->CreateFixedObject(SlotSize, -SlotSize,
3008                                                            false);
3009     FuncInfo->setRAIndex(ReturnAddrIndex);
3010   }
3011
3012   return DAG.getFrameIndex(ReturnAddrIndex, getPointerTy());
3013 }
3014
3015
3016 bool X86::isOffsetSuitableForCodeModel(int64_t Offset, CodeModel::Model M,
3017                                        bool hasSymbolicDisplacement) {
3018   // Offset should fit into 32 bit immediate field.
3019   if (!isInt<32>(Offset))
3020     return false;
3021
3022   // If we don't have a symbolic displacement - we don't have any extra
3023   // restrictions.
3024   if (!hasSymbolicDisplacement)
3025     return true;
3026
3027   // FIXME: Some tweaks might be needed for medium code model.
3028   if (M != CodeModel::Small && M != CodeModel::Kernel)
3029     return false;
3030
3031   // For small code model we assume that latest object is 16MB before end of 31
3032   // bits boundary. We may also accept pretty large negative constants knowing
3033   // that all objects are in the positive half of address space.
3034   if (M == CodeModel::Small && Offset < 16*1024*1024)
3035     return true;
3036
3037   // For kernel code model we know that all object resist in the negative half
3038   // of 32bits address space. We may not accept negative offsets, since they may
3039   // be just off and we may accept pretty large positive ones.
3040   if (M == CodeModel::Kernel && Offset > 0)
3041     return true;
3042
3043   return false;
3044 }
3045
3046 /// isCalleePop - Determines whether the callee is required to pop its
3047 /// own arguments. Callee pop is necessary to support tail calls.
3048 bool X86::isCalleePop(CallingConv::ID CallingConv,
3049                       bool is64Bit, bool IsVarArg, bool TailCallOpt) {
3050   if (IsVarArg)
3051     return false;
3052
3053   switch (CallingConv) {
3054   default:
3055     return false;
3056   case CallingConv::X86_StdCall:
3057     return !is64Bit;
3058   case CallingConv::X86_FastCall:
3059     return !is64Bit;
3060   case CallingConv::X86_ThisCall:
3061     return !is64Bit;
3062   case CallingConv::Fast:
3063     return TailCallOpt;
3064   case CallingConv::GHC:
3065     return TailCallOpt;
3066   }
3067 }
3068
3069 /// TranslateX86CC - do a one to one translation of a ISD::CondCode to the X86
3070 /// specific condition code, returning the condition code and the LHS/RHS of the
3071 /// comparison to make.
3072 static unsigned TranslateX86CC(ISD::CondCode SetCCOpcode, bool isFP,
3073                                SDValue &LHS, SDValue &RHS, SelectionDAG &DAG) {
3074   if (!isFP) {
3075     if (ConstantSDNode *RHSC = dyn_cast<ConstantSDNode>(RHS)) {
3076       if (SetCCOpcode == ISD::SETGT && RHSC->isAllOnesValue()) {
3077         // X > -1   -> X == 0, jump !sign.
3078         RHS = DAG.getConstant(0, RHS.getValueType());
3079         return X86::COND_NS;
3080       }
3081       if (SetCCOpcode == ISD::SETLT && RHSC->isNullValue()) {
3082         // X < 0   -> X == 0, jump on sign.
3083         return X86::COND_S;
3084       }
3085       if (SetCCOpcode == ISD::SETLT && RHSC->getZExtValue() == 1) {
3086         // X < 1   -> X <= 0
3087         RHS = DAG.getConstant(0, RHS.getValueType());
3088         return X86::COND_LE;
3089       }
3090     }
3091
3092     switch (SetCCOpcode) {
3093     default: llvm_unreachable("Invalid integer condition!");
3094     case ISD::SETEQ:  return X86::COND_E;
3095     case ISD::SETGT:  return X86::COND_G;
3096     case ISD::SETGE:  return X86::COND_GE;
3097     case ISD::SETLT:  return X86::COND_L;
3098     case ISD::SETLE:  return X86::COND_LE;
3099     case ISD::SETNE:  return X86::COND_NE;
3100     case ISD::SETULT: return X86::COND_B;
3101     case ISD::SETUGT: return X86::COND_A;
3102     case ISD::SETULE: return X86::COND_BE;
3103     case ISD::SETUGE: return X86::COND_AE;
3104     }
3105   }
3106
3107   // First determine if it is required or is profitable to flip the operands.
3108
3109   // If LHS is a foldable load, but RHS is not, flip the condition.
3110   if (ISD::isNON_EXTLoad(LHS.getNode()) &&
3111       !ISD::isNON_EXTLoad(RHS.getNode())) {
3112     SetCCOpcode = getSetCCSwappedOperands(SetCCOpcode);
3113     std::swap(LHS, RHS);
3114   }
3115
3116   switch (SetCCOpcode) {
3117   default: break;
3118   case ISD::SETOLT:
3119   case ISD::SETOLE:
3120   case ISD::SETUGT:
3121   case ISD::SETUGE:
3122     std::swap(LHS, RHS);
3123     break;
3124   }
3125
3126   // On a floating point condition, the flags are set as follows:
3127   // ZF  PF  CF   op
3128   //  0 | 0 | 0 | X > Y
3129   //  0 | 0 | 1 | X < Y
3130   //  1 | 0 | 0 | X == Y
3131   //  1 | 1 | 1 | unordered
3132   switch (SetCCOpcode) {
3133   default: llvm_unreachable("Condcode should be pre-legalized away");
3134   case ISD::SETUEQ:
3135   case ISD::SETEQ:   return X86::COND_E;
3136   case ISD::SETOLT:              // flipped
3137   case ISD::SETOGT:
3138   case ISD::SETGT:   return X86::COND_A;
3139   case ISD::SETOLE:              // flipped
3140   case ISD::SETOGE:
3141   case ISD::SETGE:   return X86::COND_AE;
3142   case ISD::SETUGT:              // flipped
3143   case ISD::SETULT:
3144   case ISD::SETLT:   return X86::COND_B;
3145   case ISD::SETUGE:              // flipped
3146   case ISD::SETULE:
3147   case ISD::SETLE:   return X86::COND_BE;
3148   case ISD::SETONE:
3149   case ISD::SETNE:   return X86::COND_NE;
3150   case ISD::SETUO:   return X86::COND_P;
3151   case ISD::SETO:    return X86::COND_NP;
3152   case ISD::SETOEQ:
3153   case ISD::SETUNE:  return X86::COND_INVALID;
3154   }
3155 }
3156
3157 /// hasFPCMov - is there a floating point cmov for the specific X86 condition
3158 /// code. Current x86 isa includes the following FP cmov instructions:
3159 /// fcmovb, fcomvbe, fcomve, fcmovu, fcmovae, fcmova, fcmovne, fcmovnu.
3160 static bool hasFPCMov(unsigned X86CC) {
3161   switch (X86CC) {
3162   default:
3163     return false;
3164   case X86::COND_B:
3165   case X86::COND_BE:
3166   case X86::COND_E:
3167   case X86::COND_P:
3168   case X86::COND_A:
3169   case X86::COND_AE:
3170   case X86::COND_NE:
3171   case X86::COND_NP:
3172     return true;
3173   }
3174 }
3175
3176 /// isFPImmLegal - Returns true if the target can instruction select the
3177 /// specified FP immediate natively. If false, the legalizer will
3178 /// materialize the FP immediate as a load from a constant pool.
3179 bool X86TargetLowering::isFPImmLegal(const APFloat &Imm, EVT VT) const {
3180   for (unsigned i = 0, e = LegalFPImmediates.size(); i != e; ++i) {
3181     if (Imm.bitwiseIsEqual(LegalFPImmediates[i]))
3182       return true;
3183   }
3184   return false;
3185 }
3186
3187 /// isUndefOrInRange - Return true if Val is undef or if its value falls within
3188 /// the specified range (L, H].
3189 static bool isUndefOrInRange(int Val, int Low, int Hi) {
3190   return (Val < 0) || (Val >= Low && Val < Hi);
3191 }
3192
3193 /// isUndefOrEqual - Val is either less than zero (undef) or equal to the
3194 /// specified value.
3195 static bool isUndefOrEqual(int Val, int CmpVal) {
3196   if (Val < 0 || Val == CmpVal)
3197     return true;
3198   return false;
3199 }
3200
3201 /// isSequentialOrUndefInRange - Return true if every element in Mask, beginning
3202 /// from position Pos and ending in Pos+Size, falls within the specified
3203 /// sequential range (L, L+Pos]. or is undef.
3204 static bool isSequentialOrUndefInRange(ArrayRef<int> Mask,
3205                                        unsigned Pos, unsigned Size, int Low) {
3206   for (unsigned i = Pos, e = Pos+Size; i != e; ++i, ++Low)
3207     if (!isUndefOrEqual(Mask[i], Low))
3208       return false;
3209   return true;
3210 }
3211
3212 /// isPSHUFDMask - Return true if the node specifies a shuffle of elements that
3213 /// is suitable for input to PSHUFD or PSHUFW.  That is, it doesn't reference
3214 /// the second operand.
3215 static bool isPSHUFDMask(ArrayRef<int> Mask, EVT VT) {
3216   if (VT == MVT::v4f32 || VT == MVT::v4i32 )
3217     return (Mask[0] < 4 && Mask[1] < 4 && Mask[2] < 4 && Mask[3] < 4);
3218   if (VT == MVT::v2f64 || VT == MVT::v2i64)
3219     return (Mask[0] < 2 && Mask[1] < 2);
3220   return false;
3221 }
3222
3223 /// isPSHUFHWMask - Return true if the node specifies a shuffle of elements that
3224 /// is suitable for input to PSHUFHW.
3225 static bool isPSHUFHWMask(ArrayRef<int> Mask, EVT VT, bool HasAVX2) {
3226   if (VT != MVT::v8i16 && (!HasAVX2 || VT != MVT::v16i16))
3227     return false;
3228
3229   // Lower quadword copied in order or undef.
3230   if (!isSequentialOrUndefInRange(Mask, 0, 4, 0))
3231     return false;
3232
3233   // Upper quadword shuffled.
3234   for (unsigned i = 4; i != 8; ++i)
3235     if (!isUndefOrInRange(Mask[i], 4, 8))
3236       return false;
3237
3238   if (VT == MVT::v16i16) {
3239     // Lower quadword copied in order or undef.
3240     if (!isSequentialOrUndefInRange(Mask, 8, 4, 8))
3241       return false;
3242
3243     // Upper quadword shuffled.
3244     for (unsigned i = 12; i != 16; ++i)
3245       if (!isUndefOrInRange(Mask[i], 12, 16))
3246         return false;
3247   }
3248
3249   return true;
3250 }
3251
3252 /// isPSHUFLWMask - Return true if the node specifies a shuffle of elements that
3253 /// is suitable for input to PSHUFLW.
3254 static bool isPSHUFLWMask(ArrayRef<int> Mask, EVT VT, bool HasAVX2) {
3255   if (VT != MVT::v8i16 && (!HasAVX2 || VT != MVT::v16i16))
3256     return false;
3257
3258   // Upper quadword copied in order.
3259   if (!isSequentialOrUndefInRange(Mask, 4, 4, 4))
3260     return false;
3261
3262   // Lower quadword shuffled.
3263   for (unsigned i = 0; i != 4; ++i)
3264     if (!isUndefOrInRange(Mask[i], 0, 4))
3265       return false;
3266
3267   if (VT == MVT::v16i16) {
3268     // Upper quadword copied in order.
3269     if (!isSequentialOrUndefInRange(Mask, 12, 4, 12))
3270       return false;
3271
3272     // Lower quadword shuffled.
3273     for (unsigned i = 8; i != 12; ++i)
3274       if (!isUndefOrInRange(Mask[i], 8, 12))
3275         return false;
3276   }
3277
3278   return true;
3279 }
3280
3281 /// isPALIGNRMask - Return true if the node specifies a shuffle of elements that
3282 /// is suitable for input to PALIGNR.
3283 static bool isPALIGNRMask(ArrayRef<int> Mask, EVT VT,
3284                           const X86Subtarget *Subtarget) {
3285   if ((VT.getSizeInBits() == 128 && !Subtarget->hasSSSE3()) ||
3286       (VT.getSizeInBits() == 256 && !Subtarget->hasAVX2()))
3287     return false;
3288
3289   unsigned NumElts = VT.getVectorNumElements();
3290   unsigned NumLanes = VT.getSizeInBits()/128;
3291   unsigned NumLaneElts = NumElts/NumLanes;
3292
3293   // Do not handle 64-bit element shuffles with palignr.
3294   if (NumLaneElts == 2)
3295     return false;
3296
3297   for (unsigned l = 0; l != NumElts; l+=NumLaneElts) {
3298     unsigned i;
3299     for (i = 0; i != NumLaneElts; ++i) {
3300       if (Mask[i+l] >= 0)
3301         break;
3302     }
3303
3304     // Lane is all undef, go to next lane
3305     if (i == NumLaneElts)
3306       continue;
3307
3308     int Start = Mask[i+l];
3309
3310     // Make sure its in this lane in one of the sources
3311     if (!isUndefOrInRange(Start, l, l+NumLaneElts) &&
3312         !isUndefOrInRange(Start, l+NumElts, l+NumElts+NumLaneElts))
3313       return false;
3314
3315     // If not lane 0, then we must match lane 0
3316     if (l != 0 && Mask[i] >= 0 && !isUndefOrEqual(Start, Mask[i]+l))
3317       return false;
3318
3319     // Correct second source to be contiguous with first source
3320     if (Start >= (int)NumElts)
3321       Start -= NumElts - NumLaneElts;
3322
3323     // Make sure we're shifting in the right direction.
3324     if (Start <= (int)(i+l))
3325       return false;
3326
3327     Start -= i;
3328
3329     // Check the rest of the elements to see if they are consecutive.
3330     for (++i; i != NumLaneElts; ++i) {
3331       int Idx = Mask[i+l];
3332
3333       // Make sure its in this lane
3334       if (!isUndefOrInRange(Idx, l, l+NumLaneElts) &&
3335           !isUndefOrInRange(Idx, l+NumElts, l+NumElts+NumLaneElts))
3336         return false;
3337
3338       // If not lane 0, then we must match lane 0
3339       if (l != 0 && Mask[i] >= 0 && !isUndefOrEqual(Idx, Mask[i]+l))
3340         return false;
3341
3342       if (Idx >= (int)NumElts)
3343         Idx -= NumElts - NumLaneElts;
3344
3345       if (!isUndefOrEqual(Idx, Start+i))
3346         return false;
3347
3348     }
3349   }
3350
3351   return true;
3352 }
3353
3354 /// CommuteVectorShuffleMask - Change values in a shuffle permute mask assuming
3355 /// the two vector operands have swapped position.
3356 static void CommuteVectorShuffleMask(SmallVectorImpl<int> &Mask,
3357                                      unsigned NumElems) {
3358   for (unsigned i = 0; i != NumElems; ++i) {
3359     int idx = Mask[i];
3360     if (idx < 0)
3361       continue;
3362     else if (idx < (int)NumElems)
3363       Mask[i] = idx + NumElems;
3364     else
3365       Mask[i] = idx - NumElems;
3366   }
3367 }
3368
3369 /// isSHUFPMask - Return true if the specified VECTOR_SHUFFLE operand
3370 /// specifies a shuffle of elements that is suitable for input to 128/256-bit
3371 /// SHUFPS and SHUFPD. If Commuted is true, then it checks for sources to be
3372 /// reverse of what x86 shuffles want.
3373 static bool isSHUFPMask(ArrayRef<int> Mask, EVT VT, bool HasAVX,
3374                         bool Commuted = false) {
3375   if (!HasAVX && VT.getSizeInBits() == 256)
3376     return false;
3377
3378   unsigned NumElems = VT.getVectorNumElements();
3379   unsigned NumLanes = VT.getSizeInBits()/128;
3380   unsigned NumLaneElems = NumElems/NumLanes;
3381
3382   if (NumLaneElems != 2 && NumLaneElems != 4)
3383     return false;
3384
3385   // VSHUFPSY divides the resulting vector into 4 chunks.
3386   // The sources are also splitted into 4 chunks, and each destination
3387   // chunk must come from a different source chunk.
3388   //
3389   //  SRC1 =>   X7    X6    X5    X4    X3    X2    X1    X0
3390   //  SRC2 =>   Y7    Y6    Y5    Y4    Y3    Y2    Y1    Y9
3391   //
3392   //  DST  =>  Y7..Y4,   Y7..Y4,   X7..X4,   X7..X4,
3393   //           Y3..Y0,   Y3..Y0,   X3..X0,   X3..X0
3394   //
3395   // VSHUFPDY divides the resulting vector into 4 chunks.
3396   // The sources are also splitted into 4 chunks, and each destination
3397   // chunk must come from a different source chunk.
3398   //
3399   //  SRC1 =>      X3       X2       X1       X0
3400   //  SRC2 =>      Y3       Y2       Y1       Y0
3401   //
3402   //  DST  =>  Y3..Y2,  X3..X2,  Y1..Y0,  X1..X0
3403   //
3404   unsigned HalfLaneElems = NumLaneElems/2;
3405   for (unsigned l = 0; l != NumElems; l += NumLaneElems) {
3406     for (unsigned i = 0; i != NumLaneElems; ++i) {
3407       int Idx = Mask[i+l];
3408       unsigned RngStart = l + ((Commuted == (i<HalfLaneElems)) ? NumElems : 0);
3409       if (!isUndefOrInRange(Idx, RngStart, RngStart+NumLaneElems))
3410         return false;
3411       // For VSHUFPSY, the mask of the second half must be the same as the
3412       // first but with the appropriate offsets. This works in the same way as
3413       // VPERMILPS works with masks.
3414       if (NumElems != 8 || l == 0 || Mask[i] < 0)
3415         continue;
3416       if (!isUndefOrEqual(Idx, Mask[i]+l))
3417         return false;
3418     }
3419   }
3420
3421   return true;
3422 }
3423
3424 /// isMOVHLPSMask - Return true if the specified VECTOR_SHUFFLE operand
3425 /// specifies a shuffle of elements that is suitable for input to MOVHLPS.
3426 static bool isMOVHLPSMask(ArrayRef<int> Mask, EVT VT) {
3427   unsigned NumElems = VT.getVectorNumElements();
3428
3429   if (VT.getSizeInBits() != 128)
3430     return false;
3431
3432   if (NumElems != 4)
3433     return false;
3434
3435   // Expect bit0 == 6, bit1 == 7, bit2 == 2, bit3 == 3
3436   return isUndefOrEqual(Mask[0], 6) &&
3437          isUndefOrEqual(Mask[1], 7) &&
3438          isUndefOrEqual(Mask[2], 2) &&
3439          isUndefOrEqual(Mask[3], 3);
3440 }
3441
3442 /// isMOVHLPS_v_undef_Mask - Special case of isMOVHLPSMask for canonical form
3443 /// of vector_shuffle v, v, <2, 3, 2, 3>, i.e. vector_shuffle v, undef,
3444 /// <2, 3, 2, 3>
3445 static bool isMOVHLPS_v_undef_Mask(ArrayRef<int> Mask, EVT VT) {
3446   unsigned NumElems = VT.getVectorNumElements();
3447
3448   if (VT.getSizeInBits() != 128)
3449     return false;
3450
3451   if (NumElems != 4)
3452     return false;
3453
3454   return isUndefOrEqual(Mask[0], 2) &&
3455          isUndefOrEqual(Mask[1], 3) &&
3456          isUndefOrEqual(Mask[2], 2) &&
3457          isUndefOrEqual(Mask[3], 3);
3458 }
3459
3460 /// isMOVLPMask - Return true if the specified VECTOR_SHUFFLE operand
3461 /// specifies a shuffle of elements that is suitable for input to MOVLP{S|D}.
3462 static bool isMOVLPMask(ArrayRef<int> Mask, EVT VT) {
3463   if (VT.getSizeInBits() != 128)
3464     return false;
3465
3466   unsigned NumElems = VT.getVectorNumElements();
3467
3468   if (NumElems != 2 && NumElems != 4)
3469     return false;
3470
3471   for (unsigned i = 0, e = NumElems/2; i != e; ++i)
3472     if (!isUndefOrEqual(Mask[i], i + NumElems))
3473       return false;
3474
3475   for (unsigned i = NumElems/2, e = NumElems; i != e; ++i)
3476     if (!isUndefOrEqual(Mask[i], i))
3477       return false;
3478
3479   return true;
3480 }
3481
3482 /// isMOVLHPSMask - Return true if the specified VECTOR_SHUFFLE operand
3483 /// specifies a shuffle of elements that is suitable for input to MOVLHPS.
3484 static bool isMOVLHPSMask(ArrayRef<int> Mask, EVT VT) {
3485   unsigned NumElems = VT.getVectorNumElements();
3486
3487   if ((NumElems != 2 && NumElems != 4)
3488       || VT.getSizeInBits() > 128)
3489     return false;
3490
3491   for (unsigned i = 0, e = NumElems/2; i != e; ++i)
3492     if (!isUndefOrEqual(Mask[i], i))
3493       return false;
3494
3495   for (unsigned i = 0, e = NumElems/2; i != e; ++i)
3496     if (!isUndefOrEqual(Mask[i + e], i + NumElems))
3497       return false;
3498
3499   return true;
3500 }
3501
3502 //
3503 // Some special combinations that can be optimized.
3504 //
3505 static
3506 SDValue Compact8x32ShuffleNode(ShuffleVectorSDNode *SVOp,
3507                                SelectionDAG &DAG) {
3508   EVT VT = SVOp->getValueType(0);
3509   DebugLoc dl = SVOp->getDebugLoc();
3510
3511   if (VT != MVT::v8i32 && VT != MVT::v8f32)
3512     return SDValue();
3513
3514   ArrayRef<int> Mask = SVOp->getMask();
3515
3516   // These are the special masks that may be optimized.
3517   static const int MaskToOptimizeEven[] = {0, 8, 2, 10, 4, 12, 6, 14};
3518   static const int MaskToOptimizeOdd[]  = {1, 9, 3, 11, 5, 13, 7, 15};
3519   bool MatchEvenMask = true;
3520   bool MatchOddMask  = true;
3521   for (int i=0; i<8; ++i) {
3522     if (!isUndefOrEqual(Mask[i], MaskToOptimizeEven[i]))
3523       MatchEvenMask = false;
3524     if (!isUndefOrEqual(Mask[i], MaskToOptimizeOdd[i]))
3525       MatchOddMask = false;
3526   }
3527   static const int CompactionMaskEven[] = {0, 2, -1, -1, 4, 6, -1, -1};
3528   static const int CompactionMaskOdd [] = {1, 3, -1, -1, 5, 7, -1, -1};
3529
3530   const int *CompactionMask;
3531   if (MatchEvenMask)
3532     CompactionMask = CompactionMaskEven;
3533   else if (MatchOddMask)
3534     CompactionMask = CompactionMaskOdd;
3535   else
3536     return SDValue();
3537
3538   SDValue UndefNode = DAG.getNode(ISD::UNDEF, dl, VT);
3539
3540   SDValue Op0 = DAG.getVectorShuffle(VT, dl, SVOp->getOperand(0),
3541                                      UndefNode, CompactionMask);
3542   SDValue Op1 = DAG.getVectorShuffle(VT, dl, SVOp->getOperand(1),
3543                                      UndefNode, CompactionMask);
3544   static const int UnpackMask[] = {0, 8, 1, 9, 4, 12, 5, 13};
3545   return DAG.getVectorShuffle(VT, dl, Op0, Op1, UnpackMask);
3546 }
3547
3548 /// isUNPCKLMask - Return true if the specified VECTOR_SHUFFLE operand
3549 /// specifies a shuffle of elements that is suitable for input to UNPCKL.
3550 static bool isUNPCKLMask(ArrayRef<int> Mask, EVT VT,
3551                          bool HasAVX2, bool V2IsSplat = false) {
3552   unsigned NumElts = VT.getVectorNumElements();
3553
3554   assert((VT.is128BitVector() || VT.is256BitVector()) &&
3555          "Unsupported vector type for unpckh");
3556
3557   if (VT.getSizeInBits() == 256 && NumElts != 4 && NumElts != 8 &&
3558       (!HasAVX2 || (NumElts != 16 && NumElts != 32)))
3559     return false;
3560
3561   // Handle 128 and 256-bit vector lengths. AVX defines UNPCK* to operate
3562   // independently on 128-bit lanes.
3563   unsigned NumLanes = VT.getSizeInBits()/128;
3564   unsigned NumLaneElts = NumElts/NumLanes;
3565
3566   for (unsigned l = 0; l != NumLanes; ++l) {
3567     for (unsigned i = l*NumLaneElts, j = l*NumLaneElts;
3568          i != (l+1)*NumLaneElts;
3569          i += 2, ++j) {
3570       int BitI  = Mask[i];
3571       int BitI1 = Mask[i+1];
3572       if (!isUndefOrEqual(BitI, j))
3573         return false;
3574       if (V2IsSplat) {
3575         if (!isUndefOrEqual(BitI1, NumElts))
3576           return false;
3577       } else {
3578         if (!isUndefOrEqual(BitI1, j + NumElts))
3579           return false;
3580       }
3581     }
3582   }
3583
3584   return true;
3585 }
3586
3587 /// isUNPCKHMask - Return true if the specified VECTOR_SHUFFLE operand
3588 /// specifies a shuffle of elements that is suitable for input to UNPCKH.
3589 static bool isUNPCKHMask(ArrayRef<int> Mask, EVT VT,
3590                          bool HasAVX2, bool V2IsSplat = false) {
3591   unsigned NumElts = VT.getVectorNumElements();
3592
3593   assert((VT.is128BitVector() || VT.is256BitVector()) &&
3594          "Unsupported vector type for unpckh");
3595
3596   if (VT.getSizeInBits() == 256 && NumElts != 4 && NumElts != 8 &&
3597       (!HasAVX2 || (NumElts != 16 && NumElts != 32)))
3598     return false;
3599
3600   // Handle 128 and 256-bit vector lengths. AVX defines UNPCK* to operate
3601   // independently on 128-bit lanes.
3602   unsigned NumLanes = VT.getSizeInBits()/128;
3603   unsigned NumLaneElts = NumElts/NumLanes;
3604
3605   for (unsigned l = 0; l != NumLanes; ++l) {
3606     for (unsigned i = l*NumLaneElts, j = (l*NumLaneElts)+NumLaneElts/2;
3607          i != (l+1)*NumLaneElts; i += 2, ++j) {
3608       int BitI  = Mask[i];
3609       int BitI1 = Mask[i+1];
3610       if (!isUndefOrEqual(BitI, j))
3611         return false;
3612       if (V2IsSplat) {
3613         if (isUndefOrEqual(BitI1, NumElts))
3614           return false;
3615       } else {
3616         if (!isUndefOrEqual(BitI1, j+NumElts))
3617           return false;
3618       }
3619     }
3620   }
3621   return true;
3622 }
3623
3624 /// isUNPCKL_v_undef_Mask - Special case of isUNPCKLMask for canonical form
3625 /// of vector_shuffle v, v, <0, 4, 1, 5>, i.e. vector_shuffle v, undef,
3626 /// <0, 0, 1, 1>
3627 static bool isUNPCKL_v_undef_Mask(ArrayRef<int> Mask, EVT VT,
3628                                   bool HasAVX2) {
3629   unsigned NumElts = VT.getVectorNumElements();
3630
3631   assert((VT.is128BitVector() || VT.is256BitVector()) &&
3632          "Unsupported vector type for unpckh");
3633
3634   if (VT.getSizeInBits() == 256 && NumElts != 4 && NumElts != 8 &&
3635       (!HasAVX2 || (NumElts != 16 && NumElts != 32)))
3636     return false;
3637
3638   // For 256-bit i64/f64, use MOVDDUPY instead, so reject the matching pattern
3639   // FIXME: Need a better way to get rid of this, there's no latency difference
3640   // between UNPCKLPD and MOVDDUP, the later should always be checked first and
3641   // the former later. We should also remove the "_undef" special mask.
3642   if (NumElts == 4 && VT.getSizeInBits() == 256)
3643     return false;
3644
3645   // Handle 128 and 256-bit vector lengths. AVX defines UNPCK* to operate
3646   // independently on 128-bit lanes.
3647   unsigned NumLanes = VT.getSizeInBits()/128;
3648   unsigned NumLaneElts = NumElts/NumLanes;
3649
3650   for (unsigned l = 0; l != NumLanes; ++l) {
3651     for (unsigned i = l*NumLaneElts, j = l*NumLaneElts;
3652          i != (l+1)*NumLaneElts;
3653          i += 2, ++j) {
3654       int BitI  = Mask[i];
3655       int BitI1 = Mask[i+1];
3656
3657       if (!isUndefOrEqual(BitI, j))
3658         return false;
3659       if (!isUndefOrEqual(BitI1, j))
3660         return false;
3661     }
3662   }
3663
3664   return true;
3665 }
3666
3667 /// isUNPCKH_v_undef_Mask - Special case of isUNPCKHMask for canonical form
3668 /// of vector_shuffle v, v, <2, 6, 3, 7>, i.e. vector_shuffle v, undef,
3669 /// <2, 2, 3, 3>
3670 static bool isUNPCKH_v_undef_Mask(ArrayRef<int> Mask, EVT VT, bool HasAVX2) {
3671   unsigned NumElts = VT.getVectorNumElements();
3672
3673   assert((VT.is128BitVector() || VT.is256BitVector()) &&
3674          "Unsupported vector type for unpckh");
3675
3676   if (VT.getSizeInBits() == 256 && NumElts != 4 && NumElts != 8 &&
3677       (!HasAVX2 || (NumElts != 16 && NumElts != 32)))
3678     return false;
3679
3680   // Handle 128 and 256-bit vector lengths. AVX defines UNPCK* to operate
3681   // independently on 128-bit lanes.
3682   unsigned NumLanes = VT.getSizeInBits()/128;
3683   unsigned NumLaneElts = NumElts/NumLanes;
3684
3685   for (unsigned l = 0; l != NumLanes; ++l) {
3686     for (unsigned i = l*NumLaneElts, j = (l*NumLaneElts)+NumLaneElts/2;
3687          i != (l+1)*NumLaneElts; i += 2, ++j) {
3688       int BitI  = Mask[i];
3689       int BitI1 = Mask[i+1];
3690       if (!isUndefOrEqual(BitI, j))
3691         return false;
3692       if (!isUndefOrEqual(BitI1, j))
3693         return false;
3694     }
3695   }
3696   return true;
3697 }
3698
3699 /// isMOVLMask - Return true if the specified VECTOR_SHUFFLE operand
3700 /// specifies a shuffle of elements that is suitable for input to MOVSS,
3701 /// MOVSD, and MOVD, i.e. setting the lowest element.
3702 static bool isMOVLMask(ArrayRef<int> Mask, EVT VT) {
3703   if (VT.getVectorElementType().getSizeInBits() < 32)
3704     return false;
3705   if (VT.getSizeInBits() == 256)
3706     return false;
3707
3708   unsigned NumElts = VT.getVectorNumElements();
3709
3710   if (!isUndefOrEqual(Mask[0], NumElts))
3711     return false;
3712
3713   for (unsigned i = 1; i != NumElts; ++i)
3714     if (!isUndefOrEqual(Mask[i], i))
3715       return false;
3716
3717   return true;
3718 }
3719
3720 /// isVPERM2X128Mask - Match 256-bit shuffles where the elements are considered
3721 /// as permutations between 128-bit chunks or halves. As an example: this
3722 /// shuffle bellow:
3723 ///   vector_shuffle <4, 5, 6, 7, 12, 13, 14, 15>
3724 /// The first half comes from the second half of V1 and the second half from the
3725 /// the second half of V2.
3726 static bool isVPERM2X128Mask(ArrayRef<int> Mask, EVT VT, bool HasAVX) {
3727   if (!HasAVX || VT.getSizeInBits() != 256)
3728     return false;
3729
3730   // The shuffle result is divided into half A and half B. In total the two
3731   // sources have 4 halves, namely: C, D, E, F. The final values of A and
3732   // B must come from C, D, E or F.
3733   unsigned HalfSize = VT.getVectorNumElements()/2;
3734   bool MatchA = false, MatchB = false;
3735
3736   // Check if A comes from one of C, D, E, F.
3737   for (unsigned Half = 0; Half != 4; ++Half) {
3738     if (isSequentialOrUndefInRange(Mask, 0, HalfSize, Half*HalfSize)) {
3739       MatchA = true;
3740       break;
3741     }
3742   }
3743
3744   // Check if B comes from one of C, D, E, F.
3745   for (unsigned Half = 0; Half != 4; ++Half) {
3746     if (isSequentialOrUndefInRange(Mask, HalfSize, HalfSize, Half*HalfSize)) {
3747       MatchB = true;
3748       break;
3749     }
3750   }
3751
3752   return MatchA && MatchB;
3753 }
3754
3755 /// getShuffleVPERM2X128Immediate - Return the appropriate immediate to shuffle
3756 /// the specified VECTOR_MASK mask with VPERM2F128/VPERM2I128 instructions.
3757 static unsigned getShuffleVPERM2X128Immediate(ShuffleVectorSDNode *SVOp) {
3758   EVT VT = SVOp->getValueType(0);
3759
3760   unsigned HalfSize = VT.getVectorNumElements()/2;
3761
3762   unsigned FstHalf = 0, SndHalf = 0;
3763   for (unsigned i = 0; i < HalfSize; ++i) {
3764     if (SVOp->getMaskElt(i) > 0) {
3765       FstHalf = SVOp->getMaskElt(i)/HalfSize;
3766       break;
3767     }
3768   }
3769   for (unsigned i = HalfSize; i < HalfSize*2; ++i) {
3770     if (SVOp->getMaskElt(i) > 0) {
3771       SndHalf = SVOp->getMaskElt(i)/HalfSize;
3772       break;
3773     }
3774   }
3775
3776   return (FstHalf | (SndHalf << 4));
3777 }
3778
3779 /// isVPERMILPMask - Return true if the specified VECTOR_SHUFFLE operand
3780 /// specifies a shuffle of elements that is suitable for input to VPERMILPD*.
3781 /// Note that VPERMIL mask matching is different depending whether theunderlying
3782 /// type is 32 or 64. In the VPERMILPS the high half of the mask should point
3783 /// to the same elements of the low, but to the higher half of the source.
3784 /// In VPERMILPD the two lanes could be shuffled independently of each other
3785 /// with the same restriction that lanes can't be crossed. Also handles PSHUFDY.
3786 static bool isVPERMILPMask(ArrayRef<int> Mask, EVT VT, bool HasAVX) {
3787   if (!HasAVX)
3788     return false;
3789
3790   unsigned NumElts = VT.getVectorNumElements();
3791   // Only match 256-bit with 32/64-bit types
3792   if (VT.getSizeInBits() != 256 || (NumElts != 4 && NumElts != 8))
3793     return false;
3794
3795   unsigned NumLanes = VT.getSizeInBits()/128;
3796   unsigned LaneSize = NumElts/NumLanes;
3797   for (unsigned l = 0; l != NumElts; l += LaneSize) {
3798     for (unsigned i = 0; i != LaneSize; ++i) {
3799       if (!isUndefOrInRange(Mask[i+l], l, l+LaneSize))
3800         return false;
3801       if (NumElts != 8 || l == 0)
3802         continue;
3803       // VPERMILPS handling
3804       if (Mask[i] < 0)
3805         continue;
3806       if (!isUndefOrEqual(Mask[i+l], Mask[i]+l))
3807         return false;
3808     }
3809   }
3810
3811   return true;
3812 }
3813
3814 /// isCommutedMOVLMask - Returns true if the shuffle mask is except the reverse
3815 /// of what x86 movss want. X86 movs requires the lowest  element to be lowest
3816 /// element of vector 2 and the other elements to come from vector 1 in order.
3817 static bool isCommutedMOVLMask(ArrayRef<int> Mask, EVT VT,
3818                                bool V2IsSplat = false, bool V2IsUndef = false) {
3819   unsigned NumOps = VT.getVectorNumElements();
3820   if (VT.getSizeInBits() == 256)
3821     return false;
3822   if (NumOps != 2 && NumOps != 4 && NumOps != 8 && NumOps != 16)
3823     return false;
3824
3825   if (!isUndefOrEqual(Mask[0], 0))
3826     return false;
3827
3828   for (unsigned i = 1; i != NumOps; ++i)
3829     if (!(isUndefOrEqual(Mask[i], i+NumOps) ||
3830           (V2IsUndef && isUndefOrInRange(Mask[i], NumOps, NumOps*2)) ||
3831           (V2IsSplat && isUndefOrEqual(Mask[i], NumOps))))
3832       return false;
3833
3834   return true;
3835 }
3836
3837 /// isMOVSHDUPMask - Return true if the specified VECTOR_SHUFFLE operand
3838 /// specifies a shuffle of elements that is suitable for input to MOVSHDUP.
3839 /// Masks to match: <1, 1, 3, 3> or <1, 1, 3, 3, 5, 5, 7, 7>
3840 static bool isMOVSHDUPMask(ArrayRef<int> Mask, EVT VT,
3841                            const X86Subtarget *Subtarget) {
3842   if (!Subtarget->hasSSE3())
3843     return false;
3844
3845   unsigned NumElems = VT.getVectorNumElements();
3846
3847   if ((VT.getSizeInBits() == 128 && NumElems != 4) ||
3848       (VT.getSizeInBits() == 256 && NumElems != 8))
3849     return false;
3850
3851   // "i+1" is the value the indexed mask element must have
3852   for (unsigned i = 0; i != NumElems; i += 2)
3853     if (!isUndefOrEqual(Mask[i], i+1) ||
3854         !isUndefOrEqual(Mask[i+1], i+1))
3855       return false;
3856
3857   return true;
3858 }
3859
3860 /// isMOVSLDUPMask - Return true if the specified VECTOR_SHUFFLE operand
3861 /// specifies a shuffle of elements that is suitable for input to MOVSLDUP.
3862 /// Masks to match: <0, 0, 2, 2> or <0, 0, 2, 2, 4, 4, 6, 6>
3863 static bool isMOVSLDUPMask(ArrayRef<int> Mask, EVT VT,
3864                            const X86Subtarget *Subtarget) {
3865   if (!Subtarget->hasSSE3())
3866     return false;
3867
3868   unsigned NumElems = VT.getVectorNumElements();
3869
3870   if ((VT.getSizeInBits() == 128 && NumElems != 4) ||
3871       (VT.getSizeInBits() == 256 && NumElems != 8))
3872     return false;
3873
3874   // "i" is the value the indexed mask element must have
3875   for (unsigned i = 0; i != NumElems; i += 2)
3876     if (!isUndefOrEqual(Mask[i], i) ||
3877         !isUndefOrEqual(Mask[i+1], i))
3878       return false;
3879
3880   return true;
3881 }
3882
3883 /// isMOVDDUPYMask - Return true if the specified VECTOR_SHUFFLE operand
3884 /// specifies a shuffle of elements that is suitable for input to 256-bit
3885 /// version of MOVDDUP.
3886 static bool isMOVDDUPYMask(ArrayRef<int> Mask, EVT VT, bool HasAVX) {
3887   unsigned NumElts = VT.getVectorNumElements();
3888
3889   if (!HasAVX || VT.getSizeInBits() != 256 || NumElts != 4)
3890     return false;
3891
3892   for (unsigned i = 0; i != NumElts/2; ++i)
3893     if (!isUndefOrEqual(Mask[i], 0))
3894       return false;
3895   for (unsigned i = NumElts/2; i != NumElts; ++i)
3896     if (!isUndefOrEqual(Mask[i], NumElts/2))
3897       return false;
3898   return true;
3899 }
3900
3901 /// isMOVDDUPMask - Return true if the specified VECTOR_SHUFFLE operand
3902 /// specifies a shuffle of elements that is suitable for input to 128-bit
3903 /// version of MOVDDUP.
3904 static bool isMOVDDUPMask(ArrayRef<int> Mask, EVT VT) {
3905   if (VT.getSizeInBits() != 128)
3906     return false;
3907
3908   unsigned e = VT.getVectorNumElements() / 2;
3909   for (unsigned i = 0; i != e; ++i)
3910     if (!isUndefOrEqual(Mask[i], i))
3911       return false;
3912   for (unsigned i = 0; i != e; ++i)
3913     if (!isUndefOrEqual(Mask[e+i], i))
3914       return false;
3915   return true;
3916 }
3917
3918 /// isVEXTRACTF128Index - Return true if the specified
3919 /// EXTRACT_SUBVECTOR operand specifies a vector extract that is
3920 /// suitable for input to VEXTRACTF128.
3921 bool X86::isVEXTRACTF128Index(SDNode *N) {
3922   if (!isa<ConstantSDNode>(N->getOperand(1).getNode()))
3923     return false;
3924
3925   // The index should be aligned on a 128-bit boundary.
3926   uint64_t Index =
3927     cast<ConstantSDNode>(N->getOperand(1).getNode())->getZExtValue();
3928
3929   unsigned VL = N->getValueType(0).getVectorNumElements();
3930   unsigned VBits = N->getValueType(0).getSizeInBits();
3931   unsigned ElSize = VBits / VL;
3932   bool Result = (Index * ElSize) % 128 == 0;
3933
3934   return Result;
3935 }
3936
3937 /// isVINSERTF128Index - Return true if the specified INSERT_SUBVECTOR
3938 /// operand specifies a subvector insert that is suitable for input to
3939 /// VINSERTF128.
3940 bool X86::isVINSERTF128Index(SDNode *N) {
3941   if (!isa<ConstantSDNode>(N->getOperand(2).getNode()))
3942     return false;
3943
3944   // The index should be aligned on a 128-bit boundary.
3945   uint64_t Index =
3946     cast<ConstantSDNode>(N->getOperand(2).getNode())->getZExtValue();
3947
3948   unsigned VL = N->getValueType(0).getVectorNumElements();
3949   unsigned VBits = N->getValueType(0).getSizeInBits();
3950   unsigned ElSize = VBits / VL;
3951   bool Result = (Index * ElSize) % 128 == 0;
3952
3953   return Result;
3954 }
3955
3956 /// getShuffleSHUFImmediate - Return the appropriate immediate to shuffle
3957 /// the specified VECTOR_SHUFFLE mask with PSHUF* and SHUFP* instructions.
3958 /// Handles 128-bit and 256-bit.
3959 static unsigned getShuffleSHUFImmediate(ShuffleVectorSDNode *N) {
3960   EVT VT = N->getValueType(0);
3961
3962   assert((VT.is128BitVector() || VT.is256BitVector()) &&
3963          "Unsupported vector type for PSHUF/SHUFP");
3964
3965   // Handle 128 and 256-bit vector lengths. AVX defines PSHUF/SHUFP to operate
3966   // independently on 128-bit lanes.
3967   unsigned NumElts = VT.getVectorNumElements();
3968   unsigned NumLanes = VT.getSizeInBits()/128;
3969   unsigned NumLaneElts = NumElts/NumLanes;
3970
3971   assert((NumLaneElts == 2 || NumLaneElts == 4) &&
3972          "Only supports 2 or 4 elements per lane");
3973
3974   unsigned Shift = (NumLaneElts == 4) ? 1 : 0;
3975   unsigned Mask = 0;
3976   for (unsigned i = 0; i != NumElts; ++i) {
3977     int Elt = N->getMaskElt(i);
3978     if (Elt < 0) continue;
3979     Elt &= NumLaneElts - 1;
3980     unsigned ShAmt = (i << Shift) % 8;
3981     Mask |= Elt << ShAmt;
3982   }
3983
3984   return Mask;
3985 }
3986
3987 /// getShufflePSHUFHWImmediate - Return the appropriate immediate to shuffle
3988 /// the specified VECTOR_SHUFFLE mask with the PSHUFHW instruction.
3989 static unsigned getShufflePSHUFHWImmediate(ShuffleVectorSDNode *N) {
3990   EVT VT = N->getValueType(0);
3991
3992   assert((VT == MVT::v8i16 || VT == MVT::v16i16) &&
3993          "Unsupported vector type for PSHUFHW");
3994
3995   unsigned NumElts = VT.getVectorNumElements();
3996
3997   unsigned Mask = 0;
3998   for (unsigned l = 0; l != NumElts; l += 8) {
3999     // 8 nodes per lane, but we only care about the last 4.
4000     for (unsigned i = 0; i < 4; ++i) {
4001       int Elt = N->getMaskElt(l+i+4);
4002       if (Elt < 0) continue;
4003       Elt &= 0x3; // only 2-bits.
4004       Mask |= Elt << (i * 2);
4005     }
4006   }
4007
4008   return Mask;
4009 }
4010
4011 /// getShufflePSHUFLWImmediate - Return the appropriate immediate to shuffle
4012 /// the specified VECTOR_SHUFFLE mask with the PSHUFLW instruction.
4013 static unsigned getShufflePSHUFLWImmediate(ShuffleVectorSDNode *N) {
4014   EVT VT = N->getValueType(0);
4015
4016   assert((VT == MVT::v8i16 || VT == MVT::v16i16) &&
4017          "Unsupported vector type for PSHUFHW");
4018
4019   unsigned NumElts = VT.getVectorNumElements();
4020
4021   unsigned Mask = 0;
4022   for (unsigned l = 0; l != NumElts; l += 8) {
4023     // 8 nodes per lane, but we only care about the first 4.
4024     for (unsigned i = 0; i < 4; ++i) {
4025       int Elt = N->getMaskElt(l+i);
4026       if (Elt < 0) continue;
4027       Elt &= 0x3; // only 2-bits
4028       Mask |= Elt << (i * 2);
4029     }
4030   }
4031
4032   return Mask;
4033 }
4034
4035 /// getShufflePALIGNRImmediate - Return the appropriate immediate to shuffle
4036 /// the specified VECTOR_SHUFFLE mask with the PALIGNR instruction.
4037 static unsigned getShufflePALIGNRImmediate(ShuffleVectorSDNode *SVOp) {
4038   EVT VT = SVOp->getValueType(0);
4039   unsigned EltSize = VT.getVectorElementType().getSizeInBits() >> 3;
4040
4041   unsigned NumElts = VT.getVectorNumElements();
4042   unsigned NumLanes = VT.getSizeInBits()/128;
4043   unsigned NumLaneElts = NumElts/NumLanes;
4044
4045   int Val = 0;
4046   unsigned i;
4047   for (i = 0; i != NumElts; ++i) {
4048     Val = SVOp->getMaskElt(i);
4049     if (Val >= 0)
4050       break;
4051   }
4052   if (Val >= (int)NumElts)
4053     Val -= NumElts - NumLaneElts;
4054
4055   assert(Val - i > 0 && "PALIGNR imm should be positive");
4056   return (Val - i) * EltSize;
4057 }
4058
4059 /// getExtractVEXTRACTF128Immediate - Return the appropriate immediate
4060 /// to extract the specified EXTRACT_SUBVECTOR index with VEXTRACTF128
4061 /// instructions.
4062 unsigned X86::getExtractVEXTRACTF128Immediate(SDNode *N) {
4063   if (!isa<ConstantSDNode>(N->getOperand(1).getNode()))
4064     llvm_unreachable("Illegal extract subvector for VEXTRACTF128");
4065
4066   uint64_t Index =
4067     cast<ConstantSDNode>(N->getOperand(1).getNode())->getZExtValue();
4068
4069   EVT VecVT = N->getOperand(0).getValueType();
4070   EVT ElVT = VecVT.getVectorElementType();
4071
4072   unsigned NumElemsPerChunk = 128 / ElVT.getSizeInBits();
4073   return Index / NumElemsPerChunk;
4074 }
4075
4076 /// getInsertVINSERTF128Immediate - Return the appropriate immediate
4077 /// to insert at the specified INSERT_SUBVECTOR index with VINSERTF128
4078 /// instructions.
4079 unsigned X86::getInsertVINSERTF128Immediate(SDNode *N) {
4080   if (!isa<ConstantSDNode>(N->getOperand(2).getNode()))
4081     llvm_unreachable("Illegal insert subvector for VINSERTF128");
4082
4083   uint64_t Index =
4084     cast<ConstantSDNode>(N->getOperand(2).getNode())->getZExtValue();
4085
4086   EVT VecVT = N->getValueType(0);
4087   EVT ElVT = VecVT.getVectorElementType();
4088
4089   unsigned NumElemsPerChunk = 128 / ElVT.getSizeInBits();
4090   return Index / NumElemsPerChunk;
4091 }
4092
4093 /// getShuffleCLImmediate - Return the appropriate immediate to shuffle
4094 /// the specified VECTOR_SHUFFLE mask with VPERMQ and VPERMPD instructions.
4095 /// Handles 256-bit.
4096 static unsigned getShuffleCLImmediate(ShuffleVectorSDNode *N) {
4097   EVT VT = N->getValueType(0);
4098
4099   unsigned NumElts = VT.getVectorNumElements();
4100
4101   assert((VT.is256BitVector() && NumElts == 4) &&
4102          "Unsupported vector type for VPERMQ/VPERMPD");
4103
4104   unsigned Mask = 0;
4105   for (unsigned i = 0; i != NumElts; ++i) {
4106     int Elt = N->getMaskElt(i);
4107     if (Elt < 0)
4108       continue;
4109     Mask |= Elt << (i*2);
4110   }
4111
4112   return Mask;
4113 }
4114 /// isZeroNode - Returns true if Elt is a constant zero or a floating point
4115 /// constant +0.0.
4116 bool X86::isZeroNode(SDValue Elt) {
4117   return ((isa<ConstantSDNode>(Elt) &&
4118            cast<ConstantSDNode>(Elt)->isNullValue()) ||
4119           (isa<ConstantFPSDNode>(Elt) &&
4120            cast<ConstantFPSDNode>(Elt)->getValueAPF().isPosZero()));
4121 }
4122
4123 /// CommuteVectorShuffle - Swap vector_shuffle operands as well as values in
4124 /// their permute mask.
4125 static SDValue CommuteVectorShuffle(ShuffleVectorSDNode *SVOp,
4126                                     SelectionDAG &DAG) {
4127   EVT VT = SVOp->getValueType(0);
4128   unsigned NumElems = VT.getVectorNumElements();
4129   SmallVector<int, 8> MaskVec;
4130
4131   for (unsigned i = 0; i != NumElems; ++i) {
4132     int Idx = SVOp->getMaskElt(i);
4133     if (Idx >= 0) {
4134       if (Idx < (int)NumElems)
4135         Idx += NumElems;
4136       else
4137         Idx -= NumElems;
4138     }
4139     MaskVec.push_back(Idx);
4140   }
4141   return DAG.getVectorShuffle(VT, SVOp->getDebugLoc(), SVOp->getOperand(1),
4142                               SVOp->getOperand(0), &MaskVec[0]);
4143 }
4144
4145 /// ShouldXformToMOVHLPS - Return true if the node should be transformed to
4146 /// match movhlps. The lower half elements should come from upper half of
4147 /// V1 (and in order), and the upper half elements should come from the upper
4148 /// half of V2 (and in order).
4149 static bool ShouldXformToMOVHLPS(ArrayRef<int> Mask, EVT VT) {
4150   if (VT.getSizeInBits() != 128)
4151     return false;
4152   if (VT.getVectorNumElements() != 4)
4153     return false;
4154   for (unsigned i = 0, e = 2; i != e; ++i)
4155     if (!isUndefOrEqual(Mask[i], i+2))
4156       return false;
4157   for (unsigned i = 2; i != 4; ++i)
4158     if (!isUndefOrEqual(Mask[i], i+4))
4159       return false;
4160   return true;
4161 }
4162
4163 /// isScalarLoadToVector - Returns true if the node is a scalar load that
4164 /// is promoted to a vector. It also returns the LoadSDNode by reference if
4165 /// required.
4166 static bool isScalarLoadToVector(SDNode *N, LoadSDNode **LD = NULL) {
4167   if (N->getOpcode() != ISD::SCALAR_TO_VECTOR)
4168     return false;
4169   N = N->getOperand(0).getNode();
4170   if (!ISD::isNON_EXTLoad(N))
4171     return false;
4172   if (LD)
4173     *LD = cast<LoadSDNode>(N);
4174   return true;
4175 }
4176
4177 // Test whether the given value is a vector value which will be legalized
4178 // into a load.
4179 static bool WillBeConstantPoolLoad(SDNode *N) {
4180   if (N->getOpcode() != ISD::BUILD_VECTOR)
4181     return false;
4182
4183   // Check for any non-constant elements.
4184   for (unsigned i = 0, e = N->getNumOperands(); i != e; ++i)
4185     switch (N->getOperand(i).getNode()->getOpcode()) {
4186     case ISD::UNDEF:
4187     case ISD::ConstantFP:
4188     case ISD::Constant:
4189       break;
4190     default:
4191       return false;
4192     }
4193
4194   // Vectors of all-zeros and all-ones are materialized with special
4195   // instructions rather than being loaded.
4196   return !ISD::isBuildVectorAllZeros(N) &&
4197          !ISD::isBuildVectorAllOnes(N);
4198 }
4199
4200 /// ShouldXformToMOVLP{S|D} - Return true if the node should be transformed to
4201 /// match movlp{s|d}. The lower half elements should come from lower half of
4202 /// V1 (and in order), and the upper half elements should come from the upper
4203 /// half of V2 (and in order). And since V1 will become the source of the
4204 /// MOVLP, it must be either a vector load or a scalar load to vector.
4205 static bool ShouldXformToMOVLP(SDNode *V1, SDNode *V2,
4206                                ArrayRef<int> Mask, EVT VT) {
4207   if (VT.getSizeInBits() != 128)
4208     return false;
4209
4210   if (!ISD::isNON_EXTLoad(V1) && !isScalarLoadToVector(V1))
4211     return false;
4212   // Is V2 is a vector load, don't do this transformation. We will try to use
4213   // load folding shufps op.
4214   if (ISD::isNON_EXTLoad(V2) || WillBeConstantPoolLoad(V2))
4215     return false;
4216
4217   unsigned NumElems = VT.getVectorNumElements();
4218
4219   if (NumElems != 2 && NumElems != 4)
4220     return false;
4221   for (unsigned i = 0, e = NumElems/2; i != e; ++i)
4222     if (!isUndefOrEqual(Mask[i], i))
4223       return false;
4224   for (unsigned i = NumElems/2, e = NumElems; i != e; ++i)
4225     if (!isUndefOrEqual(Mask[i], i+NumElems))
4226       return false;
4227   return true;
4228 }
4229
4230 /// isSplatVector - Returns true if N is a BUILD_VECTOR node whose elements are
4231 /// all the same.
4232 static bool isSplatVector(SDNode *N) {
4233   if (N->getOpcode() != ISD::BUILD_VECTOR)
4234     return false;
4235
4236   SDValue SplatValue = N->getOperand(0);
4237   for (unsigned i = 1, e = N->getNumOperands(); i != e; ++i)
4238     if (N->getOperand(i) != SplatValue)
4239       return false;
4240   return true;
4241 }
4242
4243 /// isZeroShuffle - Returns true if N is a VECTOR_SHUFFLE that can be resolved
4244 /// to an zero vector.
4245 /// FIXME: move to dag combiner / method on ShuffleVectorSDNode
4246 static bool isZeroShuffle(ShuffleVectorSDNode *N) {
4247   SDValue V1 = N->getOperand(0);
4248   SDValue V2 = N->getOperand(1);
4249   unsigned NumElems = N->getValueType(0).getVectorNumElements();
4250   for (unsigned i = 0; i != NumElems; ++i) {
4251     int Idx = N->getMaskElt(i);
4252     if (Idx >= (int)NumElems) {
4253       unsigned Opc = V2.getOpcode();
4254       if (Opc == ISD::UNDEF || ISD::isBuildVectorAllZeros(V2.getNode()))
4255         continue;
4256       if (Opc != ISD::BUILD_VECTOR ||
4257           !X86::isZeroNode(V2.getOperand(Idx-NumElems)))
4258         return false;
4259     } else if (Idx >= 0) {
4260       unsigned Opc = V1.getOpcode();
4261       if (Opc == ISD::UNDEF || ISD::isBuildVectorAllZeros(V1.getNode()))
4262         continue;
4263       if (Opc != ISD::BUILD_VECTOR ||
4264           !X86::isZeroNode(V1.getOperand(Idx)))
4265         return false;
4266     }
4267   }
4268   return true;
4269 }
4270
4271 /// getZeroVector - Returns a vector of specified type with all zero elements.
4272 ///
4273 static SDValue getZeroVector(EVT VT, const X86Subtarget *Subtarget,
4274                              SelectionDAG &DAG, DebugLoc dl) {
4275   assert(VT.isVector() && "Expected a vector type");
4276   unsigned Size = VT.getSizeInBits();
4277
4278   // Always build SSE zero vectors as <4 x i32> bitcasted
4279   // to their dest type. This ensures they get CSE'd.
4280   SDValue Vec;
4281   if (Size == 128) {  // SSE
4282     if (Subtarget->hasSSE2()) {  // SSE2
4283       SDValue Cst = DAG.getTargetConstant(0, MVT::i32);
4284       Vec = DAG.getNode(ISD::BUILD_VECTOR, dl, MVT::v4i32, Cst, Cst, Cst, Cst);
4285     } else { // SSE1
4286       SDValue Cst = DAG.getTargetConstantFP(+0.0, MVT::f32);
4287       Vec = DAG.getNode(ISD::BUILD_VECTOR, dl, MVT::v4f32, Cst, Cst, Cst, Cst);
4288     }
4289   } else if (Size == 256) { // AVX
4290     if (Subtarget->hasAVX2()) { // AVX2
4291       SDValue Cst = DAG.getTargetConstant(0, MVT::i32);
4292       SDValue Ops[] = { Cst, Cst, Cst, Cst, Cst, Cst, Cst, Cst };
4293       Vec = DAG.getNode(ISD::BUILD_VECTOR, dl, MVT::v8i32, Ops, 8);
4294     } else {
4295       // 256-bit logic and arithmetic instructions in AVX are all
4296       // floating-point, no support for integer ops. Emit fp zeroed vectors.
4297       SDValue Cst = DAG.getTargetConstantFP(+0.0, MVT::f32);
4298       SDValue Ops[] = { Cst, Cst, Cst, Cst, Cst, Cst, Cst, Cst };
4299       Vec = DAG.getNode(ISD::BUILD_VECTOR, dl, MVT::v8f32, Ops, 8);
4300     }
4301   } else
4302     llvm_unreachable("Unexpected vector type");
4303
4304   return DAG.getNode(ISD::BITCAST, dl, VT, Vec);
4305 }
4306
4307 /// getOnesVector - Returns a vector of specified type with all bits set.
4308 /// Always build ones vectors as <4 x i32> or <8 x i32>. For 256-bit types with
4309 /// no AVX2 supprt, use two <4 x i32> inserted in a <8 x i32> appropriately.
4310 /// Then bitcast to their original type, ensuring they get CSE'd.
4311 static SDValue getOnesVector(EVT VT, bool HasAVX2, SelectionDAG &DAG,
4312                              DebugLoc dl) {
4313   assert(VT.isVector() && "Expected a vector type");
4314   unsigned Size = VT.getSizeInBits();
4315
4316   SDValue Cst = DAG.getTargetConstant(~0U, MVT::i32);
4317   SDValue Vec;
4318   if (Size == 256) {
4319     if (HasAVX2) { // AVX2
4320       SDValue Ops[] = { Cst, Cst, Cst, Cst, Cst, Cst, Cst, Cst };
4321       Vec = DAG.getNode(ISD::BUILD_VECTOR, dl, MVT::v8i32, Ops, 8);
4322     } else { // AVX
4323       Vec = DAG.getNode(ISD::BUILD_VECTOR, dl, MVT::v4i32, Cst, Cst, Cst, Cst);
4324       Vec = Concat128BitVectors(Vec, Vec, MVT::v8i32, 8, DAG, dl);
4325     }
4326   } else if (Size == 128) {
4327     Vec = DAG.getNode(ISD::BUILD_VECTOR, dl, MVT::v4i32, Cst, Cst, Cst, Cst);
4328   } else
4329     llvm_unreachable("Unexpected vector type");
4330
4331   return DAG.getNode(ISD::BITCAST, dl, VT, Vec);
4332 }
4333
4334 /// NormalizeMask - V2 is a splat, modify the mask (if needed) so all elements
4335 /// that point to V2 points to its first element.
4336 static void NormalizeMask(SmallVectorImpl<int> &Mask, unsigned NumElems) {
4337   for (unsigned i = 0; i != NumElems; ++i) {
4338     if (Mask[i] > (int)NumElems) {
4339       Mask[i] = NumElems;
4340     }
4341   }
4342 }
4343
4344 /// getMOVLMask - Returns a vector_shuffle mask for an movs{s|d}, movd
4345 /// operation of specified width.
4346 static SDValue getMOVL(SelectionDAG &DAG, DebugLoc dl, EVT VT, SDValue V1,
4347                        SDValue V2) {
4348   unsigned NumElems = VT.getVectorNumElements();
4349   SmallVector<int, 8> Mask;
4350   Mask.push_back(NumElems);
4351   for (unsigned i = 1; i != NumElems; ++i)
4352     Mask.push_back(i);
4353   return DAG.getVectorShuffle(VT, dl, V1, V2, &Mask[0]);
4354 }
4355
4356 /// getUnpackl - Returns a vector_shuffle node for an unpackl operation.
4357 static SDValue getUnpackl(SelectionDAG &DAG, DebugLoc dl, EVT VT, SDValue V1,
4358                           SDValue V2) {
4359   unsigned NumElems = VT.getVectorNumElements();
4360   SmallVector<int, 8> Mask;
4361   for (unsigned i = 0, e = NumElems/2; i != e; ++i) {
4362     Mask.push_back(i);
4363     Mask.push_back(i + NumElems);
4364   }
4365   return DAG.getVectorShuffle(VT, dl, V1, V2, &Mask[0]);
4366 }
4367
4368 /// getUnpackh - Returns a vector_shuffle node for an unpackh operation.
4369 static SDValue getUnpackh(SelectionDAG &DAG, DebugLoc dl, EVT VT, SDValue V1,
4370                           SDValue V2) {
4371   unsigned NumElems = VT.getVectorNumElements();
4372   SmallVector<int, 8> Mask;
4373   for (unsigned i = 0, Half = NumElems/2; i != Half; ++i) {
4374     Mask.push_back(i + Half);
4375     Mask.push_back(i + NumElems + Half);
4376   }
4377   return DAG.getVectorShuffle(VT, dl, V1, V2, &Mask[0]);
4378 }
4379
4380 // PromoteSplati8i16 - All i16 and i8 vector types can't be used directly by
4381 // a generic shuffle instruction because the target has no such instructions.
4382 // Generate shuffles which repeat i16 and i8 several times until they can be
4383 // represented by v4f32 and then be manipulated by target suported shuffles.
4384 static SDValue PromoteSplati8i16(SDValue V, SelectionDAG &DAG, int &EltNo) {
4385   EVT VT = V.getValueType();
4386   int NumElems = VT.getVectorNumElements();
4387   DebugLoc dl = V.getDebugLoc();
4388
4389   while (NumElems > 4) {
4390     if (EltNo < NumElems/2) {
4391       V = getUnpackl(DAG, dl, VT, V, V);
4392     } else {
4393       V = getUnpackh(DAG, dl, VT, V, V);
4394       EltNo -= NumElems/2;
4395     }
4396     NumElems >>= 1;
4397   }
4398   return V;
4399 }
4400
4401 /// getLegalSplat - Generate a legal splat with supported x86 shuffles
4402 static SDValue getLegalSplat(SelectionDAG &DAG, SDValue V, int EltNo) {
4403   EVT VT = V.getValueType();
4404   DebugLoc dl = V.getDebugLoc();
4405   unsigned Size = VT.getSizeInBits();
4406
4407   if (Size == 128) {
4408     V = DAG.getNode(ISD::BITCAST, dl, MVT::v4f32, V);
4409     int SplatMask[4] = { EltNo, EltNo, EltNo, EltNo };
4410     V = DAG.getVectorShuffle(MVT::v4f32, dl, V, DAG.getUNDEF(MVT::v4f32),
4411                              &SplatMask[0]);
4412   } else if (Size == 256) {
4413     // To use VPERMILPS to splat scalars, the second half of indicies must
4414     // refer to the higher part, which is a duplication of the lower one,
4415     // because VPERMILPS can only handle in-lane permutations.
4416     int SplatMask[8] = { EltNo, EltNo, EltNo, EltNo,
4417                          EltNo+4, EltNo+4, EltNo+4, EltNo+4 };
4418
4419     V = DAG.getNode(ISD::BITCAST, dl, MVT::v8f32, V);
4420     V = DAG.getVectorShuffle(MVT::v8f32, dl, V, DAG.getUNDEF(MVT::v8f32),
4421                              &SplatMask[0]);
4422   } else
4423     llvm_unreachable("Vector size not supported");
4424
4425   return DAG.getNode(ISD::BITCAST, dl, VT, V);
4426 }
4427
4428 /// PromoteSplat - Splat is promoted to target supported vector shuffles.
4429 static SDValue PromoteSplat(ShuffleVectorSDNode *SV, SelectionDAG &DAG) {
4430   EVT SrcVT = SV->getValueType(0);
4431   SDValue V1 = SV->getOperand(0);
4432   DebugLoc dl = SV->getDebugLoc();
4433
4434   int EltNo = SV->getSplatIndex();
4435   int NumElems = SrcVT.getVectorNumElements();
4436   unsigned Size = SrcVT.getSizeInBits();
4437
4438   assert(((Size == 128 && NumElems > 4) || Size == 256) &&
4439           "Unknown how to promote splat for type");
4440
4441   // Extract the 128-bit part containing the splat element and update
4442   // the splat element index when it refers to the higher register.
4443   if (Size == 256) {
4444     V1 = Extract128BitVector(V1, EltNo, DAG, dl);
4445     if (EltNo >= NumElems/2)
4446       EltNo -= NumElems/2;
4447   }
4448
4449   // All i16 and i8 vector types can't be used directly by a generic shuffle
4450   // instruction because the target has no such instruction. Generate shuffles
4451   // which repeat i16 and i8 several times until they fit in i32, and then can
4452   // be manipulated by target suported shuffles.
4453   EVT EltVT = SrcVT.getVectorElementType();
4454   if (EltVT == MVT::i8 || EltVT == MVT::i16)
4455     V1 = PromoteSplati8i16(V1, DAG, EltNo);
4456
4457   // Recreate the 256-bit vector and place the same 128-bit vector
4458   // into the low and high part. This is necessary because we want
4459   // to use VPERM* to shuffle the vectors
4460   if (Size == 256) {
4461     V1 = DAG.getNode(ISD::CONCAT_VECTORS, dl, SrcVT, V1, V1);
4462   }
4463
4464   return getLegalSplat(DAG, V1, EltNo);
4465 }
4466
4467 /// getShuffleVectorZeroOrUndef - Return a vector_shuffle of the specified
4468 /// vector of zero or undef vector.  This produces a shuffle where the low
4469 /// element of V2 is swizzled into the zero/undef vector, landing at element
4470 /// Idx.  This produces a shuffle mask like 4,1,2,3 (idx=0) or  0,1,2,4 (idx=3).
4471 static SDValue getShuffleVectorZeroOrUndef(SDValue V2, unsigned Idx,
4472                                            bool IsZero,
4473                                            const X86Subtarget *Subtarget,
4474                                            SelectionDAG &DAG) {
4475   EVT VT = V2.getValueType();
4476   SDValue V1 = IsZero
4477     ? getZeroVector(VT, Subtarget, DAG, V2.getDebugLoc()) : DAG.getUNDEF(VT);
4478   unsigned NumElems = VT.getVectorNumElements();
4479   SmallVector<int, 16> MaskVec;
4480   for (unsigned i = 0; i != NumElems; ++i)
4481     // If this is the insertion idx, put the low elt of V2 here.
4482     MaskVec.push_back(i == Idx ? NumElems : i);
4483   return DAG.getVectorShuffle(VT, V2.getDebugLoc(), V1, V2, &MaskVec[0]);
4484 }
4485
4486 /// getTargetShuffleMask - Calculates the shuffle mask corresponding to the
4487 /// target specific opcode. Returns true if the Mask could be calculated.
4488 /// Sets IsUnary to true if only uses one source.
4489 static bool getTargetShuffleMask(SDNode *N, MVT VT,
4490                                  SmallVectorImpl<int> &Mask, bool &IsUnary) {
4491   unsigned NumElems = VT.getVectorNumElements();
4492   SDValue ImmN;
4493
4494   IsUnary = false;
4495   switch(N->getOpcode()) {
4496   case X86ISD::SHUFP:
4497     ImmN = N->getOperand(N->getNumOperands()-1);
4498     DecodeSHUFPMask(VT, cast<ConstantSDNode>(ImmN)->getZExtValue(), Mask);
4499     break;
4500   case X86ISD::UNPCKH:
4501     DecodeUNPCKHMask(VT, Mask);
4502     break;
4503   case X86ISD::UNPCKL:
4504     DecodeUNPCKLMask(VT, Mask);
4505     break;
4506   case X86ISD::MOVHLPS:
4507     DecodeMOVHLPSMask(NumElems, Mask);
4508     break;
4509   case X86ISD::MOVLHPS:
4510     DecodeMOVLHPSMask(NumElems, Mask);
4511     break;
4512   case X86ISD::PSHUFD:
4513   case X86ISD::VPERMILP:
4514     ImmN = N->getOperand(N->getNumOperands()-1);
4515     DecodePSHUFMask(VT, cast<ConstantSDNode>(ImmN)->getZExtValue(), Mask);
4516     IsUnary = true;
4517     break;
4518   case X86ISD::PSHUFHW:
4519     ImmN = N->getOperand(N->getNumOperands()-1);
4520     DecodePSHUFHWMask(VT, cast<ConstantSDNode>(ImmN)->getZExtValue(), Mask);
4521     IsUnary = true;
4522     break;
4523   case X86ISD::PSHUFLW:
4524     ImmN = N->getOperand(N->getNumOperands()-1);
4525     DecodePSHUFLWMask(VT, cast<ConstantSDNode>(ImmN)->getZExtValue(), Mask);
4526     IsUnary = true;
4527     break;
4528   case X86ISD::VPERMI:
4529     ImmN = N->getOperand(N->getNumOperands()-1);
4530     DecodeVPERMMask(cast<ConstantSDNode>(ImmN)->getZExtValue(), Mask);
4531     IsUnary = true;
4532     break;
4533   case X86ISD::MOVSS:
4534   case X86ISD::MOVSD: {
4535     // The index 0 always comes from the first element of the second source,
4536     // this is why MOVSS and MOVSD are used in the first place. The other
4537     // elements come from the other positions of the first source vector
4538     Mask.push_back(NumElems);
4539     for (unsigned i = 1; i != NumElems; ++i) {
4540       Mask.push_back(i);
4541     }
4542     break;
4543   }
4544   case X86ISD::VPERM2X128:
4545     ImmN = N->getOperand(N->getNumOperands()-1);
4546     DecodeVPERM2X128Mask(VT, cast<ConstantSDNode>(ImmN)->getZExtValue(), Mask);
4547     if (Mask.empty()) return false;
4548     break;
4549   case X86ISD::MOVDDUP:
4550   case X86ISD::MOVLHPD:
4551   case X86ISD::MOVLPD:
4552   case X86ISD::MOVLPS:
4553   case X86ISD::MOVSHDUP:
4554   case X86ISD::MOVSLDUP:
4555   case X86ISD::PALIGN:
4556     // Not yet implemented
4557     return false;
4558   default: llvm_unreachable("unknown target shuffle node");
4559   }
4560
4561   return true;
4562 }
4563
4564 /// getShuffleScalarElt - Returns the scalar element that will make up the ith
4565 /// element of the result of the vector shuffle.
4566 static SDValue getShuffleScalarElt(SDNode *N, unsigned Index, SelectionDAG &DAG,
4567                                    unsigned Depth) {
4568   if (Depth == 6)
4569     return SDValue();  // Limit search depth.
4570
4571   SDValue V = SDValue(N, 0);
4572   EVT VT = V.getValueType();
4573   unsigned Opcode = V.getOpcode();
4574
4575   // Recurse into ISD::VECTOR_SHUFFLE node to find scalars.
4576   if (const ShuffleVectorSDNode *SV = dyn_cast<ShuffleVectorSDNode>(N)) {
4577     int Elt = SV->getMaskElt(Index);
4578
4579     if (Elt < 0)
4580       return DAG.getUNDEF(VT.getVectorElementType());
4581
4582     unsigned NumElems = VT.getVectorNumElements();
4583     SDValue NewV = (Elt < (int)NumElems) ? SV->getOperand(0)
4584                                          : SV->getOperand(1);
4585     return getShuffleScalarElt(NewV.getNode(), Elt % NumElems, DAG, Depth+1);
4586   }
4587
4588   // Recurse into target specific vector shuffles to find scalars.
4589   if (isTargetShuffle(Opcode)) {
4590     MVT ShufVT = V.getValueType().getSimpleVT();
4591     unsigned NumElems = ShufVT.getVectorNumElements();
4592     SmallVector<int, 16> ShuffleMask;
4593     SDValue ImmN;
4594     bool IsUnary;
4595
4596     if (!getTargetShuffleMask(N, ShufVT, ShuffleMask, IsUnary))
4597       return SDValue();
4598
4599     int Elt = ShuffleMask[Index];
4600     if (Elt < 0)
4601       return DAG.getUNDEF(ShufVT.getVectorElementType());
4602
4603     SDValue NewV = (Elt < (int)NumElems) ? N->getOperand(0)
4604                                          : N->getOperand(1);
4605     return getShuffleScalarElt(NewV.getNode(), Elt % NumElems, DAG,
4606                                Depth+1);
4607   }
4608
4609   // Actual nodes that may contain scalar elements
4610   if (Opcode == ISD::BITCAST) {
4611     V = V.getOperand(0);
4612     EVT SrcVT = V.getValueType();
4613     unsigned NumElems = VT.getVectorNumElements();
4614
4615     if (!SrcVT.isVector() || SrcVT.getVectorNumElements() != NumElems)
4616       return SDValue();
4617   }
4618
4619   if (V.getOpcode() == ISD::SCALAR_TO_VECTOR)
4620     return (Index == 0) ? V.getOperand(0)
4621                         : DAG.getUNDEF(VT.getVectorElementType());
4622
4623   if (V.getOpcode() == ISD::BUILD_VECTOR)
4624     return V.getOperand(Index);
4625
4626   return SDValue();
4627 }
4628
4629 /// getNumOfConsecutiveZeros - Return the number of elements of a vector
4630 /// shuffle operation which come from a consecutively from a zero. The
4631 /// search can start in two different directions, from left or right.
4632 static
4633 unsigned getNumOfConsecutiveZeros(ShuffleVectorSDNode *SVOp, unsigned NumElems,
4634                                   bool ZerosFromLeft, SelectionDAG &DAG) {
4635   unsigned i;
4636   for (i = 0; i != NumElems; ++i) {
4637     unsigned Index = ZerosFromLeft ? i : NumElems-i-1;
4638     SDValue Elt = getShuffleScalarElt(SVOp, Index, DAG, 0);
4639     if (!(Elt.getNode() &&
4640          (Elt.getOpcode() == ISD::UNDEF || X86::isZeroNode(Elt))))
4641       break;
4642   }
4643
4644   return i;
4645 }
4646
4647 /// isShuffleMaskConsecutive - Check if the shuffle mask indicies [MaskI, MaskE)
4648 /// correspond consecutively to elements from one of the vector operands,
4649 /// starting from its index OpIdx. Also tell OpNum which source vector operand.
4650 static
4651 bool isShuffleMaskConsecutive(ShuffleVectorSDNode *SVOp,
4652                               unsigned MaskI, unsigned MaskE, unsigned OpIdx,
4653                               unsigned NumElems, unsigned &OpNum) {
4654   bool SeenV1 = false;
4655   bool SeenV2 = false;
4656
4657   for (unsigned i = MaskI; i != MaskE; ++i, ++OpIdx) {
4658     int Idx = SVOp->getMaskElt(i);
4659     // Ignore undef indicies
4660     if (Idx < 0)
4661       continue;
4662
4663     if (Idx < (int)NumElems)
4664       SeenV1 = true;
4665     else
4666       SeenV2 = true;
4667
4668     // Only accept consecutive elements from the same vector
4669     if ((Idx % NumElems != OpIdx) || (SeenV1 && SeenV2))
4670       return false;
4671   }
4672
4673   OpNum = SeenV1 ? 0 : 1;
4674   return true;
4675 }
4676
4677 /// isVectorShiftRight - Returns true if the shuffle can be implemented as a
4678 /// logical left shift of a vector.
4679 static bool isVectorShiftRight(ShuffleVectorSDNode *SVOp, SelectionDAG &DAG,
4680                                bool &isLeft, SDValue &ShVal, unsigned &ShAmt) {
4681   unsigned NumElems = SVOp->getValueType(0).getVectorNumElements();
4682   unsigned NumZeros = getNumOfConsecutiveZeros(SVOp, NumElems,
4683               false /* check zeros from right */, DAG);
4684   unsigned OpSrc;
4685
4686   if (!NumZeros)
4687     return false;
4688
4689   // Considering the elements in the mask that are not consecutive zeros,
4690   // check if they consecutively come from only one of the source vectors.
4691   //
4692   //               V1 = {X, A, B, C}     0
4693   //                         \  \  \    /
4694   //   vector_shuffle V1, V2 <1, 2, 3, X>
4695   //
4696   if (!isShuffleMaskConsecutive(SVOp,
4697             0,                   // Mask Start Index
4698             NumElems-NumZeros,   // Mask End Index(exclusive)
4699             NumZeros,            // Where to start looking in the src vector
4700             NumElems,            // Number of elements in vector
4701             OpSrc))              // Which source operand ?
4702     return false;
4703
4704   isLeft = false;
4705   ShAmt = NumZeros;
4706   ShVal = SVOp->getOperand(OpSrc);
4707   return true;
4708 }
4709
4710 /// isVectorShiftLeft - Returns true if the shuffle can be implemented as a
4711 /// logical left shift of a vector.
4712 static bool isVectorShiftLeft(ShuffleVectorSDNode *SVOp, SelectionDAG &DAG,
4713                               bool &isLeft, SDValue &ShVal, unsigned &ShAmt) {
4714   unsigned NumElems = SVOp->getValueType(0).getVectorNumElements();
4715   unsigned NumZeros = getNumOfConsecutiveZeros(SVOp, NumElems,
4716               true /* check zeros from left */, DAG);
4717   unsigned OpSrc;
4718
4719   if (!NumZeros)
4720     return false;
4721
4722   // Considering the elements in the mask that are not consecutive zeros,
4723   // check if they consecutively come from only one of the source vectors.
4724   //
4725   //                           0    { A, B, X, X } = V2
4726   //                          / \    /  /
4727   //   vector_shuffle V1, V2 <X, X, 4, 5>
4728   //
4729   if (!isShuffleMaskConsecutive(SVOp,
4730             NumZeros,     // Mask Start Index
4731             NumElems,     // Mask End Index(exclusive)
4732             0,            // Where to start looking in the src vector
4733             NumElems,     // Number of elements in vector
4734             OpSrc))       // Which source operand ?
4735     return false;
4736
4737   isLeft = true;
4738   ShAmt = NumZeros;
4739   ShVal = SVOp->getOperand(OpSrc);
4740   return true;
4741 }
4742
4743 /// isVectorShift - Returns true if the shuffle can be implemented as a
4744 /// logical left or right shift of a vector.
4745 static bool isVectorShift(ShuffleVectorSDNode *SVOp, SelectionDAG &DAG,
4746                           bool &isLeft, SDValue &ShVal, unsigned &ShAmt) {
4747   // Although the logic below support any bitwidth size, there are no
4748   // shift instructions which handle more than 128-bit vectors.
4749   if (SVOp->getValueType(0).getSizeInBits() > 128)
4750     return false;
4751
4752   if (isVectorShiftLeft(SVOp, DAG, isLeft, ShVal, ShAmt) ||
4753       isVectorShiftRight(SVOp, DAG, isLeft, ShVal, ShAmt))
4754     return true;
4755
4756   return false;
4757 }
4758
4759 /// LowerBuildVectorv16i8 - Custom lower build_vector of v16i8.
4760 ///
4761 static SDValue LowerBuildVectorv16i8(SDValue Op, unsigned NonZeros,
4762                                        unsigned NumNonZero, unsigned NumZero,
4763                                        SelectionDAG &DAG,
4764                                        const X86Subtarget* Subtarget,
4765                                        const TargetLowering &TLI) {
4766   if (NumNonZero > 8)
4767     return SDValue();
4768
4769   DebugLoc dl = Op.getDebugLoc();
4770   SDValue V(0, 0);
4771   bool First = true;
4772   for (unsigned i = 0; i < 16; ++i) {
4773     bool ThisIsNonZero = (NonZeros & (1 << i)) != 0;
4774     if (ThisIsNonZero && First) {
4775       if (NumZero)
4776         V = getZeroVector(MVT::v8i16, Subtarget, DAG, dl);
4777       else
4778         V = DAG.getUNDEF(MVT::v8i16);
4779       First = false;
4780     }
4781
4782     if ((i & 1) != 0) {
4783       SDValue ThisElt(0, 0), LastElt(0, 0);
4784       bool LastIsNonZero = (NonZeros & (1 << (i-1))) != 0;
4785       if (LastIsNonZero) {
4786         LastElt = DAG.getNode(ISD::ZERO_EXTEND, dl,
4787                               MVT::i16, Op.getOperand(i-1));
4788       }
4789       if (ThisIsNonZero) {
4790         ThisElt = DAG.getNode(ISD::ZERO_EXTEND, dl, MVT::i16, Op.getOperand(i));
4791         ThisElt = DAG.getNode(ISD::SHL, dl, MVT::i16,
4792                               ThisElt, DAG.getConstant(8, MVT::i8));
4793         if (LastIsNonZero)
4794           ThisElt = DAG.getNode(ISD::OR, dl, MVT::i16, ThisElt, LastElt);
4795       } else
4796         ThisElt = LastElt;
4797
4798       if (ThisElt.getNode())
4799         V = DAG.getNode(ISD::INSERT_VECTOR_ELT, dl, MVT::v8i16, V, ThisElt,
4800                         DAG.getIntPtrConstant(i/2));
4801     }
4802   }
4803
4804   return DAG.getNode(ISD::BITCAST, dl, MVT::v16i8, V);
4805 }
4806
4807 /// LowerBuildVectorv8i16 - Custom lower build_vector of v8i16.
4808 ///
4809 static SDValue LowerBuildVectorv8i16(SDValue Op, unsigned NonZeros,
4810                                      unsigned NumNonZero, unsigned NumZero,
4811                                      SelectionDAG &DAG,
4812                                      const X86Subtarget* Subtarget,
4813                                      const TargetLowering &TLI) {
4814   if (NumNonZero > 4)
4815     return SDValue();
4816
4817   DebugLoc dl = Op.getDebugLoc();
4818   SDValue V(0, 0);
4819   bool First = true;
4820   for (unsigned i = 0; i < 8; ++i) {
4821     bool isNonZero = (NonZeros & (1 << i)) != 0;
4822     if (isNonZero) {
4823       if (First) {
4824         if (NumZero)
4825           V = getZeroVector(MVT::v8i16, Subtarget, DAG, dl);
4826         else
4827           V = DAG.getUNDEF(MVT::v8i16);
4828         First = false;
4829       }
4830       V = DAG.getNode(ISD::INSERT_VECTOR_ELT, dl,
4831                       MVT::v8i16, V, Op.getOperand(i),
4832                       DAG.getIntPtrConstant(i));
4833     }
4834   }
4835
4836   return V;
4837 }
4838
4839 /// getVShift - Return a vector logical shift node.
4840 ///
4841 static SDValue getVShift(bool isLeft, EVT VT, SDValue SrcOp,
4842                          unsigned NumBits, SelectionDAG &DAG,
4843                          const TargetLowering &TLI, DebugLoc dl) {
4844   assert(VT.getSizeInBits() == 128 && "Unknown type for VShift");
4845   EVT ShVT = MVT::v2i64;
4846   unsigned Opc = isLeft ? X86ISD::VSHLDQ : X86ISD::VSRLDQ;
4847   SrcOp = DAG.getNode(ISD::BITCAST, dl, ShVT, SrcOp);
4848   return DAG.getNode(ISD::BITCAST, dl, VT,
4849                      DAG.getNode(Opc, dl, ShVT, SrcOp,
4850                              DAG.getConstant(NumBits,
4851                                   TLI.getShiftAmountTy(SrcOp.getValueType()))));
4852 }
4853
4854 SDValue
4855 X86TargetLowering::LowerAsSplatVectorLoad(SDValue SrcOp, EVT VT, DebugLoc dl,
4856                                           SelectionDAG &DAG) const {
4857
4858   // Check if the scalar load can be widened into a vector load. And if
4859   // the address is "base + cst" see if the cst can be "absorbed" into
4860   // the shuffle mask.
4861   if (LoadSDNode *LD = dyn_cast<LoadSDNode>(SrcOp)) {
4862     SDValue Ptr = LD->getBasePtr();
4863     if (!ISD::isNormalLoad(LD) || LD->isVolatile())
4864       return SDValue();
4865     EVT PVT = LD->getValueType(0);
4866     if (PVT != MVT::i32 && PVT != MVT::f32)
4867       return SDValue();
4868
4869     int FI = -1;
4870     int64_t Offset = 0;
4871     if (FrameIndexSDNode *FINode = dyn_cast<FrameIndexSDNode>(Ptr)) {
4872       FI = FINode->getIndex();
4873       Offset = 0;
4874     } else if (DAG.isBaseWithConstantOffset(Ptr) &&
4875                isa<FrameIndexSDNode>(Ptr.getOperand(0))) {
4876       FI = cast<FrameIndexSDNode>(Ptr.getOperand(0))->getIndex();
4877       Offset = Ptr.getConstantOperandVal(1);
4878       Ptr = Ptr.getOperand(0);
4879     } else {
4880       return SDValue();
4881     }
4882
4883     // FIXME: 256-bit vector instructions don't require a strict alignment,
4884     // improve this code to support it better.
4885     unsigned RequiredAlign = VT.getSizeInBits()/8;
4886     SDValue Chain = LD->getChain();
4887     // Make sure the stack object alignment is at least 16 or 32.
4888     MachineFrameInfo *MFI = DAG.getMachineFunction().getFrameInfo();
4889     if (DAG.InferPtrAlignment(Ptr) < RequiredAlign) {
4890       if (MFI->isFixedObjectIndex(FI)) {
4891         // Can't change the alignment. FIXME: It's possible to compute
4892         // the exact stack offset and reference FI + adjust offset instead.
4893         // If someone *really* cares about this. That's the way to implement it.
4894         return SDValue();
4895       } else {
4896         MFI->setObjectAlignment(FI, RequiredAlign);
4897       }
4898     }
4899
4900     // (Offset % 16 or 32) must be multiple of 4. Then address is then
4901     // Ptr + (Offset & ~15).
4902     if (Offset < 0)
4903       return SDValue();
4904     if ((Offset % RequiredAlign) & 3)
4905       return SDValue();
4906     int64_t StartOffset = Offset & ~(RequiredAlign-1);
4907     if (StartOffset)
4908       Ptr = DAG.getNode(ISD::ADD, Ptr.getDebugLoc(), Ptr.getValueType(),
4909                         Ptr,DAG.getConstant(StartOffset, Ptr.getValueType()));
4910
4911     int EltNo = (Offset - StartOffset) >> 2;
4912     unsigned NumElems = VT.getVectorNumElements();
4913
4914     EVT NVT = EVT::getVectorVT(*DAG.getContext(), PVT, NumElems);
4915     SDValue V1 = DAG.getLoad(NVT, dl, Chain, Ptr,
4916                              LD->getPointerInfo().getWithOffset(StartOffset),
4917                              false, false, false, 0);
4918
4919     SmallVector<int, 8> Mask;
4920     for (unsigned i = 0; i != NumElems; ++i)
4921       Mask.push_back(EltNo);
4922
4923     return DAG.getVectorShuffle(NVT, dl, V1, DAG.getUNDEF(NVT), &Mask[0]);
4924   }
4925
4926   return SDValue();
4927 }
4928
4929 /// EltsFromConsecutiveLoads - Given the initializing elements 'Elts' of a
4930 /// vector of type 'VT', see if the elements can be replaced by a single large
4931 /// load which has the same value as a build_vector whose operands are 'elts'.
4932 ///
4933 /// Example: <load i32 *a, load i32 *a+4, undef, undef> -> zextload a
4934 ///
4935 /// FIXME: we'd also like to handle the case where the last elements are zero
4936 /// rather than undef via VZEXT_LOAD, but we do not detect that case today.
4937 /// There's even a handy isZeroNode for that purpose.
4938 static SDValue EltsFromConsecutiveLoads(EVT VT, SmallVectorImpl<SDValue> &Elts,
4939                                         DebugLoc &DL, SelectionDAG &DAG) {
4940   EVT EltVT = VT.getVectorElementType();
4941   unsigned NumElems = Elts.size();
4942
4943   LoadSDNode *LDBase = NULL;
4944   unsigned LastLoadedElt = -1U;
4945
4946   // For each element in the initializer, see if we've found a load or an undef.
4947   // If we don't find an initial load element, or later load elements are
4948   // non-consecutive, bail out.
4949   for (unsigned i = 0; i < NumElems; ++i) {
4950     SDValue Elt = Elts[i];
4951
4952     if (!Elt.getNode() ||
4953         (Elt.getOpcode() != ISD::UNDEF && !ISD::isNON_EXTLoad(Elt.getNode())))
4954       return SDValue();
4955     if (!LDBase) {
4956       if (Elt.getNode()->getOpcode() == ISD::UNDEF)
4957         return SDValue();
4958       LDBase = cast<LoadSDNode>(Elt.getNode());
4959       LastLoadedElt = i;
4960       continue;
4961     }
4962     if (Elt.getOpcode() == ISD::UNDEF)
4963       continue;
4964
4965     LoadSDNode *LD = cast<LoadSDNode>(Elt);
4966     if (!DAG.isConsecutiveLoad(LD, LDBase, EltVT.getSizeInBits()/8, i))
4967       return SDValue();
4968     LastLoadedElt = i;
4969   }
4970
4971   // If we have found an entire vector of loads and undefs, then return a large
4972   // load of the entire vector width starting at the base pointer.  If we found
4973   // consecutive loads for the low half, generate a vzext_load node.
4974   if (LastLoadedElt == NumElems - 1) {
4975     if (DAG.InferPtrAlignment(LDBase->getBasePtr()) >= 16)
4976       return DAG.getLoad(VT, DL, LDBase->getChain(), LDBase->getBasePtr(),
4977                          LDBase->getPointerInfo(),
4978                          LDBase->isVolatile(), LDBase->isNonTemporal(),
4979                          LDBase->isInvariant(), 0);
4980     return DAG.getLoad(VT, DL, LDBase->getChain(), LDBase->getBasePtr(),
4981                        LDBase->getPointerInfo(),
4982                        LDBase->isVolatile(), LDBase->isNonTemporal(),
4983                        LDBase->isInvariant(), LDBase->getAlignment());
4984   }
4985   if (NumElems == 4 && LastLoadedElt == 1 &&
4986       DAG.getTargetLoweringInfo().isTypeLegal(MVT::v2i64)) {
4987     SDVTList Tys = DAG.getVTList(MVT::v2i64, MVT::Other);
4988     SDValue Ops[] = { LDBase->getChain(), LDBase->getBasePtr() };
4989     SDValue ResNode =
4990         DAG.getMemIntrinsicNode(X86ISD::VZEXT_LOAD, DL, Tys, Ops, 2, MVT::i64,
4991                                 LDBase->getPointerInfo(),
4992                                 LDBase->getAlignment(),
4993                                 false/*isVolatile*/, true/*ReadMem*/,
4994                                 false/*WriteMem*/);
4995     return DAG.getNode(ISD::BITCAST, DL, VT, ResNode);
4996   }
4997   return SDValue();
4998 }
4999
5000 /// LowerVectorBroadcast - Attempt to use the vbroadcast instruction
5001 /// to generate a splat value for the following cases:
5002 /// 1. A splat BUILD_VECTOR which uses a single scalar load, or a constant.
5003 /// 2. A splat shuffle which uses a scalar_to_vector node which comes from
5004 /// a scalar load, or a constant.
5005 /// The VBROADCAST node is returned when a pattern is found,
5006 /// or SDValue() otherwise.
5007 SDValue
5008 X86TargetLowering::LowerVectorBroadcast(SDValue &Op, SelectionDAG &DAG) const {
5009   if (!Subtarget->hasAVX())
5010     return SDValue();
5011
5012   EVT VT = Op.getValueType();
5013   DebugLoc dl = Op.getDebugLoc();
5014
5015   assert((VT.is128BitVector() || VT.is256BitVector()) &&
5016          "Unsupported vector type for broadcast.");
5017
5018   SDValue Ld;
5019   bool ConstSplatVal;
5020
5021   switch (Op.getOpcode()) {
5022     default:
5023       // Unknown pattern found.
5024       return SDValue();
5025
5026     case ISD::BUILD_VECTOR: {
5027       // The BUILD_VECTOR node must be a splat.
5028       if (!isSplatVector(Op.getNode()))
5029         return SDValue();
5030
5031       Ld = Op.getOperand(0);
5032       ConstSplatVal = (Ld.getOpcode() == ISD::Constant ||
5033                      Ld.getOpcode() == ISD::ConstantFP);
5034
5035       // The suspected load node has several users. Make sure that all
5036       // of its users are from the BUILD_VECTOR node.
5037       // Constants may have multiple users.
5038       if (!ConstSplatVal && !Ld->hasNUsesOfValue(VT.getVectorNumElements(), 0))
5039         return SDValue();
5040       break;
5041     }
5042
5043     case ISD::VECTOR_SHUFFLE: {
5044       ShuffleVectorSDNode *SVOp = cast<ShuffleVectorSDNode>(Op);
5045
5046       // Shuffles must have a splat mask where the first element is
5047       // broadcasted.
5048       if ((!SVOp->isSplat()) || SVOp->getMaskElt(0) != 0)
5049         return SDValue();
5050
5051       SDValue Sc = Op.getOperand(0);
5052       if (Sc.getOpcode() != ISD::SCALAR_TO_VECTOR &&
5053           Sc.getOpcode() != ISD::BUILD_VECTOR) {
5054
5055         if (!Subtarget->hasAVX2())
5056           return SDValue();
5057
5058         // Use the register form of the broadcast instruction available on AVX2.
5059         if (VT.is256BitVector())
5060           Sc = Extract128BitVector(Sc, 0, DAG, dl);
5061         return DAG.getNode(X86ISD::VBROADCAST, dl, VT, Sc);
5062       }
5063
5064       Ld = Sc.getOperand(0);
5065       ConstSplatVal = (Ld.getOpcode() == ISD::Constant ||
5066                        Ld.getOpcode() == ISD::ConstantFP);
5067
5068       // The scalar_to_vector node and the suspected
5069       // load node must have exactly one user.
5070       // Constants may have multiple users.
5071       if (!ConstSplatVal && (!Sc.hasOneUse() || !Ld.hasOneUse()))
5072         return SDValue();
5073       break;
5074     }
5075   }
5076
5077   bool Is256 = VT.getSizeInBits() == 256;
5078
5079   // Handle the broadcasting a single constant scalar from the constant pool
5080   // into a vector. On Sandybridge it is still better to load a constant vector
5081   // from the constant pool and not to broadcast it from a scalar.
5082   if (ConstSplatVal && Subtarget->hasAVX2()) {
5083     EVT CVT = Ld.getValueType();
5084     assert(!CVT.isVector() && "Must not broadcast a vector type");
5085     unsigned ScalarSize = CVT.getSizeInBits();
5086
5087     if (ScalarSize == 32 || (Is256 && ScalarSize == 64)) {
5088       const Constant *C = 0;
5089       if (ConstantSDNode *CI = dyn_cast<ConstantSDNode>(Ld))
5090         C = CI->getConstantIntValue();
5091       else if (ConstantFPSDNode *CF = dyn_cast<ConstantFPSDNode>(Ld))
5092         C = CF->getConstantFPValue();
5093
5094       assert(C && "Invalid constant type");
5095
5096       SDValue CP = DAG.getConstantPool(C, getPointerTy());
5097       unsigned Alignment = cast<ConstantPoolSDNode>(CP)->getAlignment();
5098       Ld = DAG.getLoad(CVT, dl, DAG.getEntryNode(), CP,
5099                        MachinePointerInfo::getConstantPool(),
5100                        false, false, false, Alignment);
5101
5102       return DAG.getNode(X86ISD::VBROADCAST, dl, VT, Ld);
5103     }
5104   }
5105
5106   bool IsLoad = ISD::isNormalLoad(Ld.getNode());
5107   unsigned ScalarSize = Ld.getValueType().getSizeInBits();
5108
5109   // Handle AVX2 in-register broadcasts.
5110   if (!IsLoad && Subtarget->hasAVX2() &&
5111       (ScalarSize == 32 || (Is256 && ScalarSize == 64)))
5112     return DAG.getNode(X86ISD::VBROADCAST, dl, VT, Ld);
5113
5114   // The scalar source must be a normal load.
5115   if (!IsLoad)
5116     return SDValue();
5117
5118   if (ScalarSize == 32 || (Is256 && ScalarSize == 64))
5119     return DAG.getNode(X86ISD::VBROADCAST, dl, VT, Ld);
5120
5121   // The integer check is needed for the 64-bit into 128-bit so it doesn't match
5122   // double since there is no vbroadcastsd xmm
5123   if (Subtarget->hasAVX2() && Ld.getValueType().isInteger()) {
5124     if (ScalarSize == 8 || ScalarSize == 16 || ScalarSize == 64)
5125       return DAG.getNode(X86ISD::VBROADCAST, dl, VT, Ld);
5126   }
5127
5128   // Unsupported broadcast.
5129   return SDValue();
5130 }
5131
5132 SDValue
5133 X86TargetLowering::LowerBUILD_VECTOR(SDValue Op, SelectionDAG &DAG) const {
5134   DebugLoc dl = Op.getDebugLoc();
5135
5136   EVT VT = Op.getValueType();
5137   EVT ExtVT = VT.getVectorElementType();
5138   unsigned NumElems = Op.getNumOperands();
5139
5140   // Vectors containing all zeros can be matched by pxor and xorps later
5141   if (ISD::isBuildVectorAllZeros(Op.getNode())) {
5142     // Canonicalize this to <4 x i32> to 1) ensure the zero vectors are CSE'd
5143     // and 2) ensure that i64 scalars are eliminated on x86-32 hosts.
5144     if (VT == MVT::v4i32 || VT == MVT::v8i32)
5145       return Op;
5146
5147     return getZeroVector(VT, Subtarget, DAG, dl);
5148   }
5149
5150   // Vectors containing all ones can be matched by pcmpeqd on 128-bit width
5151   // vectors or broken into v4i32 operations on 256-bit vectors. AVX2 can use
5152   // vpcmpeqd on 256-bit vectors.
5153   if (ISD::isBuildVectorAllOnes(Op.getNode())) {
5154     if (VT == MVT::v4i32 || (VT == MVT::v8i32 && Subtarget->hasAVX2()))
5155       return Op;
5156
5157     return getOnesVector(VT, Subtarget->hasAVX2(), DAG, dl);
5158   }
5159
5160   SDValue Broadcast = LowerVectorBroadcast(Op, DAG);
5161   if (Broadcast.getNode())
5162     return Broadcast;
5163
5164   unsigned EVTBits = ExtVT.getSizeInBits();
5165
5166   unsigned NumZero  = 0;
5167   unsigned NumNonZero = 0;
5168   unsigned NonZeros = 0;
5169   bool IsAllConstants = true;
5170   SmallSet<SDValue, 8> Values;
5171   for (unsigned i = 0; i < NumElems; ++i) {
5172     SDValue Elt = Op.getOperand(i);
5173     if (Elt.getOpcode() == ISD::UNDEF)
5174       continue;
5175     Values.insert(Elt);
5176     if (Elt.getOpcode() != ISD::Constant &&
5177         Elt.getOpcode() != ISD::ConstantFP)
5178       IsAllConstants = false;
5179     if (X86::isZeroNode(Elt))
5180       NumZero++;
5181     else {
5182       NonZeros |= (1 << i);
5183       NumNonZero++;
5184     }
5185   }
5186
5187   // All undef vector. Return an UNDEF.  All zero vectors were handled above.
5188   if (NumNonZero == 0)
5189     return DAG.getUNDEF(VT);
5190
5191   // Special case for single non-zero, non-undef, element.
5192   if (NumNonZero == 1) {
5193     unsigned Idx = CountTrailingZeros_32(NonZeros);
5194     SDValue Item = Op.getOperand(Idx);
5195
5196     // If this is an insertion of an i64 value on x86-32, and if the top bits of
5197     // the value are obviously zero, truncate the value to i32 and do the
5198     // insertion that way.  Only do this if the value is non-constant or if the
5199     // value is a constant being inserted into element 0.  It is cheaper to do
5200     // a constant pool load than it is to do a movd + shuffle.
5201     if (ExtVT == MVT::i64 && !Subtarget->is64Bit() &&
5202         (!IsAllConstants || Idx == 0)) {
5203       if (DAG.MaskedValueIsZero(Item, APInt::getBitsSet(64, 32, 64))) {
5204         // Handle SSE only.
5205         assert(VT == MVT::v2i64 && "Expected an SSE value type!");
5206         EVT VecVT = MVT::v4i32;
5207         unsigned VecElts = 4;
5208
5209         // Truncate the value (which may itself be a constant) to i32, and
5210         // convert it to a vector with movd (S2V+shuffle to zero extend).
5211         Item = DAG.getNode(ISD::TRUNCATE, dl, MVT::i32, Item);
5212         Item = DAG.getNode(ISD::SCALAR_TO_VECTOR, dl, VecVT, Item);
5213         Item = getShuffleVectorZeroOrUndef(Item, 0, true, Subtarget, DAG);
5214
5215         // Now we have our 32-bit value zero extended in the low element of
5216         // a vector.  If Idx != 0, swizzle it into place.
5217         if (Idx != 0) {
5218           SmallVector<int, 4> Mask;
5219           Mask.push_back(Idx);
5220           for (unsigned i = 1; i != VecElts; ++i)
5221             Mask.push_back(i);
5222           Item = DAG.getVectorShuffle(VecVT, dl, Item, DAG.getUNDEF(VecVT),
5223                                       &Mask[0]);
5224         }
5225         return DAG.getNode(ISD::BITCAST, dl, VT, Item);
5226       }
5227     }
5228
5229     // If we have a constant or non-constant insertion into the low element of
5230     // a vector, we can do this with SCALAR_TO_VECTOR + shuffle of zero into
5231     // the rest of the elements.  This will be matched as movd/movq/movss/movsd
5232     // depending on what the source datatype is.
5233     if (Idx == 0) {
5234       if (NumZero == 0)
5235         return DAG.getNode(ISD::SCALAR_TO_VECTOR, dl, VT, Item);
5236
5237       if (ExtVT == MVT::i32 || ExtVT == MVT::f32 || ExtVT == MVT::f64 ||
5238           (ExtVT == MVT::i64 && Subtarget->is64Bit())) {
5239         if (VT.getSizeInBits() == 256) {
5240           SDValue ZeroVec = getZeroVector(VT, Subtarget, DAG, dl);
5241           return DAG.getNode(ISD::INSERT_VECTOR_ELT, dl, VT, ZeroVec,
5242                              Item, DAG.getIntPtrConstant(0));
5243         }
5244         assert(VT.getSizeInBits() == 128 && "Expected an SSE value type!");
5245         Item = DAG.getNode(ISD::SCALAR_TO_VECTOR, dl, VT, Item);
5246         // Turn it into a MOVL (i.e. movss, movsd, or movd) to a zero vector.
5247         return getShuffleVectorZeroOrUndef(Item, 0, true, Subtarget, DAG);
5248       }
5249
5250       if (ExtVT == MVT::i16 || ExtVT == MVT::i8) {
5251         Item = DAG.getNode(ISD::ZERO_EXTEND, dl, MVT::i32, Item);
5252         Item = DAG.getNode(ISD::SCALAR_TO_VECTOR, dl, MVT::v4i32, Item);
5253         if (VT.getSizeInBits() == 256) {
5254           SDValue ZeroVec = getZeroVector(MVT::v8i32, Subtarget, DAG, dl);
5255           Item = Insert128BitVector(ZeroVec, Item, 0, DAG, dl);
5256         } else {
5257           assert(VT.getSizeInBits() == 128 && "Expected an SSE value type!");
5258           Item = getShuffleVectorZeroOrUndef(Item, 0, true, Subtarget, DAG);
5259         }
5260         return DAG.getNode(ISD::BITCAST, dl, VT, Item);
5261       }
5262     }
5263
5264     // Is it a vector logical left shift?
5265     if (NumElems == 2 && Idx == 1 &&
5266         X86::isZeroNode(Op.getOperand(0)) &&
5267         !X86::isZeroNode(Op.getOperand(1))) {
5268       unsigned NumBits = VT.getSizeInBits();
5269       return getVShift(true, VT,
5270                        DAG.getNode(ISD::SCALAR_TO_VECTOR, dl,
5271                                    VT, Op.getOperand(1)),
5272                        NumBits/2, DAG, *this, dl);
5273     }
5274
5275     if (IsAllConstants) // Otherwise, it's better to do a constpool load.
5276       return SDValue();
5277
5278     // Otherwise, if this is a vector with i32 or f32 elements, and the element
5279     // is a non-constant being inserted into an element other than the low one,
5280     // we can't use a constant pool load.  Instead, use SCALAR_TO_VECTOR (aka
5281     // movd/movss) to move this into the low element, then shuffle it into
5282     // place.
5283     if (EVTBits == 32) {
5284       Item = DAG.getNode(ISD::SCALAR_TO_VECTOR, dl, VT, Item);
5285
5286       // Turn it into a shuffle of zero and zero-extended scalar to vector.
5287       Item = getShuffleVectorZeroOrUndef(Item, 0, NumZero > 0, Subtarget, DAG);
5288       SmallVector<int, 8> MaskVec;
5289       for (unsigned i = 0; i != NumElems; ++i)
5290         MaskVec.push_back(i == Idx ? 0 : 1);
5291       return DAG.getVectorShuffle(VT, dl, Item, DAG.getUNDEF(VT), &MaskVec[0]);
5292     }
5293   }
5294
5295   // Splat is obviously ok. Let legalizer expand it to a shuffle.
5296   if (Values.size() == 1) {
5297     if (EVTBits == 32) {
5298       // Instead of a shuffle like this:
5299       // shuffle (scalar_to_vector (load (ptr + 4))), undef, <0, 0, 0, 0>
5300       // Check if it's possible to issue this instead.
5301       // shuffle (vload ptr)), undef, <1, 1, 1, 1>
5302       unsigned Idx = CountTrailingZeros_32(NonZeros);
5303       SDValue Item = Op.getOperand(Idx);
5304       if (Op.getNode()->isOnlyUserOf(Item.getNode()))
5305         return LowerAsSplatVectorLoad(Item, VT, dl, DAG);
5306     }
5307     return SDValue();
5308   }
5309
5310   // A vector full of immediates; various special cases are already
5311   // handled, so this is best done with a single constant-pool load.
5312   if (IsAllConstants)
5313     return SDValue();
5314
5315   // For AVX-length vectors, build the individual 128-bit pieces and use
5316   // shuffles to put them in place.
5317   if (VT.getSizeInBits() == 256) {
5318     SmallVector<SDValue, 32> V;
5319     for (unsigned i = 0; i != NumElems; ++i)
5320       V.push_back(Op.getOperand(i));
5321
5322     EVT HVT = EVT::getVectorVT(*DAG.getContext(), ExtVT, NumElems/2);
5323
5324     // Build both the lower and upper subvector.
5325     SDValue Lower = DAG.getNode(ISD::BUILD_VECTOR, dl, HVT, &V[0], NumElems/2);
5326     SDValue Upper = DAG.getNode(ISD::BUILD_VECTOR, dl, HVT, &V[NumElems / 2],
5327                                 NumElems/2);
5328
5329     // Recreate the wider vector with the lower and upper part.
5330     return Concat128BitVectors(Lower, Upper, VT, NumElems, DAG, dl);
5331   }
5332
5333   // Let legalizer expand 2-wide build_vectors.
5334   if (EVTBits == 64) {
5335     if (NumNonZero == 1) {
5336       // One half is zero or undef.
5337       unsigned Idx = CountTrailingZeros_32(NonZeros);
5338       SDValue V2 = DAG.getNode(ISD::SCALAR_TO_VECTOR, dl, VT,
5339                                  Op.getOperand(Idx));
5340       return getShuffleVectorZeroOrUndef(V2, Idx, true, Subtarget, DAG);
5341     }
5342     return SDValue();
5343   }
5344
5345   // If element VT is < 32 bits, convert it to inserts into a zero vector.
5346   if (EVTBits == 8 && NumElems == 16) {
5347     SDValue V = LowerBuildVectorv16i8(Op, NonZeros,NumNonZero,NumZero, DAG,
5348                                         Subtarget, *this);
5349     if (V.getNode()) return V;
5350   }
5351
5352   if (EVTBits == 16 && NumElems == 8) {
5353     SDValue V = LowerBuildVectorv8i16(Op, NonZeros,NumNonZero,NumZero, DAG,
5354                                       Subtarget, *this);
5355     if (V.getNode()) return V;
5356   }
5357
5358   // If element VT is == 32 bits, turn it into a number of shuffles.
5359   SmallVector<SDValue, 8> V(NumElems);
5360   if (NumElems == 4 && NumZero > 0) {
5361     for (unsigned i = 0; i < 4; ++i) {
5362       bool isZero = !(NonZeros & (1 << i));
5363       if (isZero)
5364         V[i] = getZeroVector(VT, Subtarget, DAG, dl);
5365       else
5366         V[i] = DAG.getNode(ISD::SCALAR_TO_VECTOR, dl, VT, Op.getOperand(i));
5367     }
5368
5369     for (unsigned i = 0; i < 2; ++i) {
5370       switch ((NonZeros & (0x3 << i*2)) >> (i*2)) {
5371         default: break;
5372         case 0:
5373           V[i] = V[i*2];  // Must be a zero vector.
5374           break;
5375         case 1:
5376           V[i] = getMOVL(DAG, dl, VT, V[i*2+1], V[i*2]);
5377           break;
5378         case 2:
5379           V[i] = getMOVL(DAG, dl, VT, V[i*2], V[i*2+1]);
5380           break;
5381         case 3:
5382           V[i] = getUnpackl(DAG, dl, VT, V[i*2], V[i*2+1]);
5383           break;
5384       }
5385     }
5386
5387     bool Reverse1 = (NonZeros & 0x3) == 2;
5388     bool Reverse2 = ((NonZeros & (0x3 << 2)) >> 2) == 2;
5389     int MaskVec[] = {
5390       Reverse1 ? 1 : 0,
5391       Reverse1 ? 0 : 1,
5392       static_cast<int>(Reverse2 ? NumElems+1 : NumElems),
5393       static_cast<int>(Reverse2 ? NumElems   : NumElems+1)
5394     };
5395     return DAG.getVectorShuffle(VT, dl, V[0], V[1], &MaskVec[0]);
5396   }
5397
5398   if (Values.size() > 1 && VT.getSizeInBits() == 128) {
5399     // Check for a build vector of consecutive loads.
5400     for (unsigned i = 0; i < NumElems; ++i)
5401       V[i] = Op.getOperand(i);
5402
5403     // Check for elements which are consecutive loads.
5404     SDValue LD = EltsFromConsecutiveLoads(VT, V, dl, DAG);
5405     if (LD.getNode())
5406       return LD;
5407
5408     // For SSE 4.1, use insertps to put the high elements into the low element.
5409     if (getSubtarget()->hasSSE41()) {
5410       SDValue Result;
5411       if (Op.getOperand(0).getOpcode() != ISD::UNDEF)
5412         Result = DAG.getNode(ISD::SCALAR_TO_VECTOR, dl, VT, Op.getOperand(0));
5413       else
5414         Result = DAG.getUNDEF(VT);
5415
5416       for (unsigned i = 1; i < NumElems; ++i) {
5417         if (Op.getOperand(i).getOpcode() == ISD::UNDEF) continue;
5418         Result = DAG.getNode(ISD::INSERT_VECTOR_ELT, dl, VT, Result,
5419                              Op.getOperand(i), DAG.getIntPtrConstant(i));
5420       }
5421       return Result;
5422     }
5423
5424     // Otherwise, expand into a number of unpckl*, start by extending each of
5425     // our (non-undef) elements to the full vector width with the element in the
5426     // bottom slot of the vector (which generates no code for SSE).
5427     for (unsigned i = 0; i < NumElems; ++i) {
5428       if (Op.getOperand(i).getOpcode() != ISD::UNDEF)
5429         V[i] = DAG.getNode(ISD::SCALAR_TO_VECTOR, dl, VT, Op.getOperand(i));
5430       else
5431         V[i] = DAG.getUNDEF(VT);
5432     }
5433
5434     // Next, we iteratively mix elements, e.g. for v4f32:
5435     //   Step 1: unpcklps 0, 2 ==> X: <?, ?, 2, 0>
5436     //         : unpcklps 1, 3 ==> Y: <?, ?, 3, 1>
5437     //   Step 2: unpcklps X, Y ==>    <3, 2, 1, 0>
5438     unsigned EltStride = NumElems >> 1;
5439     while (EltStride != 0) {
5440       for (unsigned i = 0; i < EltStride; ++i) {
5441         // If V[i+EltStride] is undef and this is the first round of mixing,
5442         // then it is safe to just drop this shuffle: V[i] is already in the
5443         // right place, the one element (since it's the first round) being
5444         // inserted as undef can be dropped.  This isn't safe for successive
5445         // rounds because they will permute elements within both vectors.
5446         if (V[i+EltStride].getOpcode() == ISD::UNDEF &&
5447             EltStride == NumElems/2)
5448           continue;
5449
5450         V[i] = getUnpackl(DAG, dl, VT, V[i], V[i + EltStride]);
5451       }
5452       EltStride >>= 1;
5453     }
5454     return V[0];
5455   }
5456   return SDValue();
5457 }
5458
5459 // LowerMMXCONCAT_VECTORS - We support concatenate two MMX registers and place
5460 // them in a MMX register.  This is better than doing a stack convert.
5461 static SDValue LowerMMXCONCAT_VECTORS(SDValue Op, SelectionDAG &DAG) {
5462   DebugLoc dl = Op.getDebugLoc();
5463   EVT ResVT = Op.getValueType();
5464
5465   assert(ResVT == MVT::v2i64 || ResVT == MVT::v4i32 ||
5466          ResVT == MVT::v8i16 || ResVT == MVT::v16i8);
5467   int Mask[2];
5468   SDValue InVec = DAG.getNode(ISD::BITCAST,dl, MVT::v1i64, Op.getOperand(0));
5469   SDValue VecOp = DAG.getNode(X86ISD::MOVQ2DQ, dl, MVT::v2i64, InVec);
5470   InVec = Op.getOperand(1);
5471   if (InVec.getOpcode() == ISD::SCALAR_TO_VECTOR) {
5472     unsigned NumElts = ResVT.getVectorNumElements();
5473     VecOp = DAG.getNode(ISD::BITCAST, dl, ResVT, VecOp);
5474     VecOp = DAG.getNode(ISD::INSERT_VECTOR_ELT, dl, ResVT, VecOp,
5475                        InVec.getOperand(0), DAG.getIntPtrConstant(NumElts/2+1));
5476   } else {
5477     InVec = DAG.getNode(ISD::BITCAST, dl, MVT::v1i64, InVec);
5478     SDValue VecOp2 = DAG.getNode(X86ISD::MOVQ2DQ, dl, MVT::v2i64, InVec);
5479     Mask[0] = 0; Mask[1] = 2;
5480     VecOp = DAG.getVectorShuffle(MVT::v2i64, dl, VecOp, VecOp2, Mask);
5481   }
5482   return DAG.getNode(ISD::BITCAST, dl, ResVT, VecOp);
5483 }
5484
5485 // LowerAVXCONCAT_VECTORS - 256-bit AVX can use the vinsertf128 instruction
5486 // to create 256-bit vectors from two other 128-bit ones.
5487 static SDValue LowerAVXCONCAT_VECTORS(SDValue Op, SelectionDAG &DAG) {
5488   DebugLoc dl = Op.getDebugLoc();
5489   EVT ResVT = Op.getValueType();
5490
5491   assert(ResVT.getSizeInBits() == 256 && "Value type must be 256-bit wide");
5492
5493   SDValue V1 = Op.getOperand(0);
5494   SDValue V2 = Op.getOperand(1);
5495   unsigned NumElems = ResVT.getVectorNumElements();
5496
5497   return Concat128BitVectors(V1, V2, ResVT, NumElems, DAG, dl);
5498 }
5499
5500 SDValue
5501 X86TargetLowering::LowerCONCAT_VECTORS(SDValue Op, SelectionDAG &DAG) const {
5502   EVT ResVT = Op.getValueType();
5503
5504   assert(Op.getNumOperands() == 2);
5505   assert((ResVT.getSizeInBits() == 128 || ResVT.getSizeInBits() == 256) &&
5506          "Unsupported CONCAT_VECTORS for value type");
5507
5508   // We support concatenate two MMX registers and place them in a MMX register.
5509   // This is better than doing a stack convert.
5510   if (ResVT.is128BitVector())
5511     return LowerMMXCONCAT_VECTORS(Op, DAG);
5512
5513   // 256-bit AVX can use the vinsertf128 instruction to create 256-bit vectors
5514   // from two other 128-bit ones.
5515   return LowerAVXCONCAT_VECTORS(Op, DAG);
5516 }
5517
5518 // Try to lower a shuffle node into a simple blend instruction.
5519 static SDValue LowerVECTOR_SHUFFLEtoBlend(ShuffleVectorSDNode *SVOp,
5520                                           const X86Subtarget *Subtarget,
5521                                           SelectionDAG &DAG) {
5522   SDValue V1 = SVOp->getOperand(0);
5523   SDValue V2 = SVOp->getOperand(1);
5524   DebugLoc dl = SVOp->getDebugLoc();
5525   MVT VT = SVOp->getValueType(0).getSimpleVT();
5526   unsigned NumElems = VT.getVectorNumElements();
5527
5528   if (!Subtarget->hasSSE41())
5529     return SDValue();
5530
5531   unsigned ISDNo = 0;
5532   MVT OpTy;
5533
5534   switch (VT.SimpleTy) {
5535   default: return SDValue();
5536   case MVT::v8i16:
5537     ISDNo = X86ISD::BLENDPW;
5538     OpTy = MVT::v8i16;
5539     break;
5540   case MVT::v4i32:
5541   case MVT::v4f32:
5542     ISDNo = X86ISD::BLENDPS;
5543     OpTy = MVT::v4f32;
5544     break;
5545   case MVT::v2i64:
5546   case MVT::v2f64:
5547     ISDNo = X86ISD::BLENDPD;
5548     OpTy = MVT::v2f64;
5549     break;
5550   case MVT::v8i32:
5551   case MVT::v8f32:
5552     if (!Subtarget->hasAVX())
5553       return SDValue();
5554     ISDNo = X86ISD::BLENDPS;
5555     OpTy = MVT::v8f32;
5556     break;
5557   case MVT::v4i64:
5558   case MVT::v4f64:
5559     if (!Subtarget->hasAVX())
5560       return SDValue();
5561     ISDNo = X86ISD::BLENDPD;
5562     OpTy = MVT::v4f64;
5563     break;
5564   }
5565   assert(ISDNo && "Invalid Op Number");
5566
5567   unsigned MaskVals = 0;
5568
5569   for (unsigned i = 0; i != NumElems; ++i) {
5570     int EltIdx = SVOp->getMaskElt(i);
5571     if (EltIdx == (int)i || EltIdx < 0)
5572       MaskVals |= (1<<i);
5573     else if (EltIdx == (int)(i + NumElems))
5574       continue; // Bit is set to zero;
5575     else
5576       return SDValue();
5577   }
5578
5579   V1 = DAG.getNode(ISD::BITCAST, dl, OpTy, V1);
5580   V2 = DAG.getNode(ISD::BITCAST, dl, OpTy, V2);
5581   SDValue Ret =  DAG.getNode(ISDNo, dl, OpTy, V1, V2,
5582                              DAG.getConstant(MaskVals, MVT::i32));
5583   return DAG.getNode(ISD::BITCAST, dl, VT, Ret);
5584 }
5585
5586 // v8i16 shuffles - Prefer shuffles in the following order:
5587 // 1. [all]   pshuflw, pshufhw, optional move
5588 // 2. [ssse3] 1 x pshufb
5589 // 3. [ssse3] 2 x pshufb + 1 x por
5590 // 4. [all]   mov + pshuflw + pshufhw + N x (pextrw + pinsrw)
5591 SDValue
5592 X86TargetLowering::LowerVECTOR_SHUFFLEv8i16(SDValue Op,
5593                                             SelectionDAG &DAG) const {
5594   ShuffleVectorSDNode *SVOp = cast<ShuffleVectorSDNode>(Op);
5595   SDValue V1 = SVOp->getOperand(0);
5596   SDValue V2 = SVOp->getOperand(1);
5597   DebugLoc dl = SVOp->getDebugLoc();
5598   SmallVector<int, 8> MaskVals;
5599
5600   // Determine if more than 1 of the words in each of the low and high quadwords
5601   // of the result come from the same quadword of one of the two inputs.  Undef
5602   // mask values count as coming from any quadword, for better codegen.
5603   unsigned LoQuad[] = { 0, 0, 0, 0 };
5604   unsigned HiQuad[] = { 0, 0, 0, 0 };
5605   std::bitset<4> InputQuads;
5606   for (unsigned i = 0; i < 8; ++i) {
5607     unsigned *Quad = i < 4 ? LoQuad : HiQuad;
5608     int EltIdx = SVOp->getMaskElt(i);
5609     MaskVals.push_back(EltIdx);
5610     if (EltIdx < 0) {
5611       ++Quad[0];
5612       ++Quad[1];
5613       ++Quad[2];
5614       ++Quad[3];
5615       continue;
5616     }
5617     ++Quad[EltIdx / 4];
5618     InputQuads.set(EltIdx / 4);
5619   }
5620
5621   int BestLoQuad = -1;
5622   unsigned MaxQuad = 1;
5623   for (unsigned i = 0; i < 4; ++i) {
5624     if (LoQuad[i] > MaxQuad) {
5625       BestLoQuad = i;
5626       MaxQuad = LoQuad[i];
5627     }
5628   }
5629
5630   int BestHiQuad = -1;
5631   MaxQuad = 1;
5632   for (unsigned i = 0; i < 4; ++i) {
5633     if (HiQuad[i] > MaxQuad) {
5634       BestHiQuad = i;
5635       MaxQuad = HiQuad[i];
5636     }
5637   }
5638
5639   // For SSSE3, If all 8 words of the result come from only 1 quadword of each
5640   // of the two input vectors, shuffle them into one input vector so only a
5641   // single pshufb instruction is necessary. If There are more than 2 input
5642   // quads, disable the next transformation since it does not help SSSE3.
5643   bool V1Used = InputQuads[0] || InputQuads[1];
5644   bool V2Used = InputQuads[2] || InputQuads[3];
5645   if (Subtarget->hasSSSE3()) {
5646     if (InputQuads.count() == 2 && V1Used && V2Used) {
5647       BestLoQuad = InputQuads[0] ? 0 : 1;
5648       BestHiQuad = InputQuads[2] ? 2 : 3;
5649     }
5650     if (InputQuads.count() > 2) {
5651       BestLoQuad = -1;
5652       BestHiQuad = -1;
5653     }
5654   }
5655
5656   // If BestLoQuad or BestHiQuad are set, shuffle the quads together and update
5657   // the shuffle mask.  If a quad is scored as -1, that means that it contains
5658   // words from all 4 input quadwords.
5659   SDValue NewV;
5660   if (BestLoQuad >= 0 || BestHiQuad >= 0) {
5661     int MaskV[] = {
5662       BestLoQuad < 0 ? 0 : BestLoQuad,
5663       BestHiQuad < 0 ? 1 : BestHiQuad
5664     };
5665     NewV = DAG.getVectorShuffle(MVT::v2i64, dl,
5666                   DAG.getNode(ISD::BITCAST, dl, MVT::v2i64, V1),
5667                   DAG.getNode(ISD::BITCAST, dl, MVT::v2i64, V2), &MaskV[0]);
5668     NewV = DAG.getNode(ISD::BITCAST, dl, MVT::v8i16, NewV);
5669
5670     // Rewrite the MaskVals and assign NewV to V1 if NewV now contains all the
5671     // source words for the shuffle, to aid later transformations.
5672     bool AllWordsInNewV = true;
5673     bool InOrder[2] = { true, true };
5674     for (unsigned i = 0; i != 8; ++i) {
5675       int idx = MaskVals[i];
5676       if (idx != (int)i)
5677         InOrder[i/4] = false;
5678       if (idx < 0 || (idx/4) == BestLoQuad || (idx/4) == BestHiQuad)
5679         continue;
5680       AllWordsInNewV = false;
5681       break;
5682     }
5683
5684     bool pshuflw = AllWordsInNewV, pshufhw = AllWordsInNewV;
5685     if (AllWordsInNewV) {
5686       for (int i = 0; i != 8; ++i) {
5687         int idx = MaskVals[i];
5688         if (idx < 0)
5689           continue;
5690         idx = MaskVals[i] = (idx / 4) == BestLoQuad ? (idx & 3) : (idx & 3) + 4;
5691         if ((idx != i) && idx < 4)
5692           pshufhw = false;
5693         if ((idx != i) && idx > 3)
5694           pshuflw = false;
5695       }
5696       V1 = NewV;
5697       V2Used = false;
5698       BestLoQuad = 0;
5699       BestHiQuad = 1;
5700     }
5701
5702     // If we've eliminated the use of V2, and the new mask is a pshuflw or
5703     // pshufhw, that's as cheap as it gets.  Return the new shuffle.
5704     if ((pshufhw && InOrder[0]) || (pshuflw && InOrder[1])) {
5705       unsigned Opc = pshufhw ? X86ISD::PSHUFHW : X86ISD::PSHUFLW;
5706       unsigned TargetMask = 0;
5707       NewV = DAG.getVectorShuffle(MVT::v8i16, dl, NewV,
5708                                   DAG.getUNDEF(MVT::v8i16), &MaskVals[0]);
5709       ShuffleVectorSDNode *SVOp = cast<ShuffleVectorSDNode>(NewV.getNode());
5710       TargetMask = pshufhw ? getShufflePSHUFHWImmediate(SVOp):
5711                              getShufflePSHUFLWImmediate(SVOp);
5712       V1 = NewV.getOperand(0);
5713       return getTargetShuffleNode(Opc, dl, MVT::v8i16, V1, TargetMask, DAG);
5714     }
5715   }
5716
5717   // If we have SSSE3, and all words of the result are from 1 input vector,
5718   // case 2 is generated, otherwise case 3 is generated.  If no SSSE3
5719   // is present, fall back to case 4.
5720   if (Subtarget->hasSSSE3()) {
5721     SmallVector<SDValue,16> pshufbMask;
5722
5723     // If we have elements from both input vectors, set the high bit of the
5724     // shuffle mask element to zero out elements that come from V2 in the V1
5725     // mask, and elements that come from V1 in the V2 mask, so that the two
5726     // results can be OR'd together.
5727     bool TwoInputs = V1Used && V2Used;
5728     for (unsigned i = 0; i != 8; ++i) {
5729       int EltIdx = MaskVals[i] * 2;
5730       int Idx0 = (TwoInputs && (EltIdx >= 16)) ? 0x80 : EltIdx;
5731       int Idx1 = (TwoInputs && (EltIdx >= 16)) ? 0x80 : EltIdx+1;
5732       pshufbMask.push_back(DAG.getConstant(Idx0,   MVT::i8));
5733       pshufbMask.push_back(DAG.getConstant(Idx1, MVT::i8));
5734     }
5735     V1 = DAG.getNode(ISD::BITCAST, dl, MVT::v16i8, V1);
5736     V1 = DAG.getNode(X86ISD::PSHUFB, dl, MVT::v16i8, V1,
5737                      DAG.getNode(ISD::BUILD_VECTOR, dl,
5738                                  MVT::v16i8, &pshufbMask[0], 16));
5739     if (!TwoInputs)
5740       return DAG.getNode(ISD::BITCAST, dl, MVT::v8i16, V1);
5741
5742     // Calculate the shuffle mask for the second input, shuffle it, and
5743     // OR it with the first shuffled input.
5744     pshufbMask.clear();
5745     for (unsigned i = 0; i != 8; ++i) {
5746       int EltIdx = MaskVals[i] * 2;
5747       int Idx0 = (EltIdx < 16) ? 0x80 : EltIdx - 16;
5748       int Idx1 = (EltIdx < 16) ? 0x80 : EltIdx - 15;
5749       pshufbMask.push_back(DAG.getConstant(Idx0, MVT::i8));
5750       pshufbMask.push_back(DAG.getConstant(Idx1, MVT::i8));
5751     }
5752     V2 = DAG.getNode(ISD::BITCAST, dl, MVT::v16i8, V2);
5753     V2 = DAG.getNode(X86ISD::PSHUFB, dl, MVT::v16i8, V2,
5754                      DAG.getNode(ISD::BUILD_VECTOR, dl,
5755                                  MVT::v16i8, &pshufbMask[0], 16));
5756     V1 = DAG.getNode(ISD::OR, dl, MVT::v16i8, V1, V2);
5757     return DAG.getNode(ISD::BITCAST, dl, MVT::v8i16, V1);
5758   }
5759
5760   // If BestLoQuad >= 0, generate a pshuflw to put the low elements in order,
5761   // and update MaskVals with new element order.
5762   std::bitset<8> InOrder;
5763   if (BestLoQuad >= 0) {
5764     int MaskV[] = { -1, -1, -1, -1, 4, 5, 6, 7 };
5765     for (int i = 0; i != 4; ++i) {
5766       int idx = MaskVals[i];
5767       if (idx < 0) {
5768         InOrder.set(i);
5769       } else if ((idx / 4) == BestLoQuad) {
5770         MaskV[i] = idx & 3;
5771         InOrder.set(i);
5772       }
5773     }
5774     NewV = DAG.getVectorShuffle(MVT::v8i16, dl, NewV, DAG.getUNDEF(MVT::v8i16),
5775                                 &MaskV[0]);
5776
5777     if (NewV.getOpcode() == ISD::VECTOR_SHUFFLE && Subtarget->hasSSSE3()) {
5778       ShuffleVectorSDNode *SVOp = cast<ShuffleVectorSDNode>(NewV.getNode());
5779       NewV = getTargetShuffleNode(X86ISD::PSHUFLW, dl, MVT::v8i16,
5780                                   NewV.getOperand(0),
5781                                   getShufflePSHUFLWImmediate(SVOp), DAG);
5782     }
5783   }
5784
5785   // If BestHi >= 0, generate a pshufhw to put the high elements in order,
5786   // and update MaskVals with the new element order.
5787   if (BestHiQuad >= 0) {
5788     int MaskV[] = { 0, 1, 2, 3, -1, -1, -1, -1 };
5789     for (unsigned i = 4; i != 8; ++i) {
5790       int idx = MaskVals[i];
5791       if (idx < 0) {
5792         InOrder.set(i);
5793       } else if ((idx / 4) == BestHiQuad) {
5794         MaskV[i] = (idx & 3) + 4;
5795         InOrder.set(i);
5796       }
5797     }
5798     NewV = DAG.getVectorShuffle(MVT::v8i16, dl, NewV, DAG.getUNDEF(MVT::v8i16),
5799                                 &MaskV[0]);
5800
5801     if (NewV.getOpcode() == ISD::VECTOR_SHUFFLE && Subtarget->hasSSSE3()) {
5802       ShuffleVectorSDNode *SVOp = cast<ShuffleVectorSDNode>(NewV.getNode());
5803       NewV = getTargetShuffleNode(X86ISD::PSHUFHW, dl, MVT::v8i16,
5804                                   NewV.getOperand(0),
5805                                   getShufflePSHUFHWImmediate(SVOp), DAG);
5806     }
5807   }
5808
5809   // In case BestHi & BestLo were both -1, which means each quadword has a word
5810   // from each of the four input quadwords, calculate the InOrder bitvector now
5811   // before falling through to the insert/extract cleanup.
5812   if (BestLoQuad == -1 && BestHiQuad == -1) {
5813     NewV = V1;
5814     for (int i = 0; i != 8; ++i)
5815       if (MaskVals[i] < 0 || MaskVals[i] == i)
5816         InOrder.set(i);
5817   }
5818
5819   // The other elements are put in the right place using pextrw and pinsrw.
5820   for (unsigned i = 0; i != 8; ++i) {
5821     if (InOrder[i])
5822       continue;
5823     int EltIdx = MaskVals[i];
5824     if (EltIdx < 0)
5825       continue;
5826     SDValue ExtOp = (EltIdx < 8) ?
5827       DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, MVT::i16, V1,
5828                   DAG.getIntPtrConstant(EltIdx)) :
5829       DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, MVT::i16, V2,
5830                   DAG.getIntPtrConstant(EltIdx - 8));
5831     NewV = DAG.getNode(ISD::INSERT_VECTOR_ELT, dl, MVT::v8i16, NewV, ExtOp,
5832                        DAG.getIntPtrConstant(i));
5833   }
5834   return NewV;
5835 }
5836
5837 // v16i8 shuffles - Prefer shuffles in the following order:
5838 // 1. [ssse3] 1 x pshufb
5839 // 2. [ssse3] 2 x pshufb + 1 x por
5840 // 3. [all]   v8i16 shuffle + N x pextrw + rotate + pinsrw
5841 static
5842 SDValue LowerVECTOR_SHUFFLEv16i8(ShuffleVectorSDNode *SVOp,
5843                                  SelectionDAG &DAG,
5844                                  const X86TargetLowering &TLI) {
5845   SDValue V1 = SVOp->getOperand(0);
5846   SDValue V2 = SVOp->getOperand(1);
5847   DebugLoc dl = SVOp->getDebugLoc();
5848   ArrayRef<int> MaskVals = SVOp->getMask();
5849
5850   bool V2IsUndef = V2.getOpcode() == ISD::UNDEF;
5851
5852   // If we have SSSE3, case 1 is generated when all result bytes come from
5853   // one of  the inputs.  Otherwise, case 2 is generated.  If no SSSE3 is
5854   // present, fall back to case 3.
5855
5856   // If SSSE3, use 1 pshufb instruction per vector with elements in the result.
5857   if (TLI.getSubtarget()->hasSSSE3()) {
5858     SmallVector<SDValue,16> pshufbMask;
5859
5860     // If all result elements are from one input vector, then only translate
5861     // undef mask values to 0x80 (zero out result) in the pshufb mask.
5862     //
5863     // Otherwise, we have elements from both input vectors, and must zero out
5864     // elements that come from V2 in the first mask, and V1 in the second mask
5865     // so that we can OR them together.
5866     for (unsigned i = 0; i != 16; ++i) {
5867       int EltIdx = MaskVals[i];
5868       if (EltIdx < 0 || EltIdx >= 16)
5869         EltIdx = 0x80;
5870       pshufbMask.push_back(DAG.getConstant(EltIdx, MVT::i8));
5871     }
5872     V1 = DAG.getNode(X86ISD::PSHUFB, dl, MVT::v16i8, V1,
5873                      DAG.getNode(ISD::BUILD_VECTOR, dl,
5874                                  MVT::v16i8, &pshufbMask[0], 16));
5875     if (V2IsUndef)
5876       return V1;
5877
5878     // Calculate the shuffle mask for the second input, shuffle it, and
5879     // OR it with the first shuffled input.
5880     pshufbMask.clear();
5881     for (unsigned i = 0; i != 16; ++i) {
5882       int EltIdx = MaskVals[i];
5883       EltIdx = (EltIdx < 16) ? 0x80 : EltIdx - 16;
5884       pshufbMask.push_back(DAG.getConstant(EltIdx, MVT::i8));
5885     }
5886     V2 = DAG.getNode(X86ISD::PSHUFB, dl, MVT::v16i8, V2,
5887                      DAG.getNode(ISD::BUILD_VECTOR, dl,
5888                                  MVT::v16i8, &pshufbMask[0], 16));
5889     return DAG.getNode(ISD::OR, dl, MVT::v16i8, V1, V2);
5890   }
5891
5892   // No SSSE3 - Calculate in place words and then fix all out of place words
5893   // With 0-16 extracts & inserts.  Worst case is 16 bytes out of order from
5894   // the 16 different words that comprise the two doublequadword input vectors.
5895   V1 = DAG.getNode(ISD::BITCAST, dl, MVT::v8i16, V1);
5896   V2 = DAG.getNode(ISD::BITCAST, dl, MVT::v8i16, V2);
5897   SDValue NewV = V1;
5898   for (int i = 0; i != 8; ++i) {
5899     int Elt0 = MaskVals[i*2];
5900     int Elt1 = MaskVals[i*2+1];
5901
5902     // This word of the result is all undef, skip it.
5903     if (Elt0 < 0 && Elt1 < 0)
5904       continue;
5905
5906     // This word of the result is already in the correct place, skip it.
5907     if ((Elt0 == i*2) && (Elt1 == i*2+1))
5908       continue;
5909
5910     SDValue Elt0Src = Elt0 < 16 ? V1 : V2;
5911     SDValue Elt1Src = Elt1 < 16 ? V1 : V2;
5912     SDValue InsElt;
5913
5914     // If Elt0 and Elt1 are defined, are consecutive, and can be load
5915     // using a single extract together, load it and store it.
5916     if ((Elt0 >= 0) && ((Elt0 + 1) == Elt1) && ((Elt0 & 1) == 0)) {
5917       InsElt = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, MVT::i16, Elt1Src,
5918                            DAG.getIntPtrConstant(Elt1 / 2));
5919       NewV = DAG.getNode(ISD::INSERT_VECTOR_ELT, dl, MVT::v8i16, NewV, InsElt,
5920                         DAG.getIntPtrConstant(i));
5921       continue;
5922     }
5923
5924     // If Elt1 is defined, extract it from the appropriate source.  If the
5925     // source byte is not also odd, shift the extracted word left 8 bits
5926     // otherwise clear the bottom 8 bits if we need to do an or.
5927     if (Elt1 >= 0) {
5928       InsElt = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, MVT::i16, Elt1Src,
5929                            DAG.getIntPtrConstant(Elt1 / 2));
5930       if ((Elt1 & 1) == 0)
5931         InsElt = DAG.getNode(ISD::SHL, dl, MVT::i16, InsElt,
5932                              DAG.getConstant(8,
5933                                   TLI.getShiftAmountTy(InsElt.getValueType())));
5934       else if (Elt0 >= 0)
5935         InsElt = DAG.getNode(ISD::AND, dl, MVT::i16, InsElt,
5936                              DAG.getConstant(0xFF00, MVT::i16));
5937     }
5938     // If Elt0 is defined, extract it from the appropriate source.  If the
5939     // source byte is not also even, shift the extracted word right 8 bits. If
5940     // Elt1 was also defined, OR the extracted values together before
5941     // inserting them in the result.
5942     if (Elt0 >= 0) {
5943       SDValue InsElt0 = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, MVT::i16,
5944                                     Elt0Src, DAG.getIntPtrConstant(Elt0 / 2));
5945       if ((Elt0 & 1) != 0)
5946         InsElt0 = DAG.getNode(ISD::SRL, dl, MVT::i16, InsElt0,
5947                               DAG.getConstant(8,
5948                                  TLI.getShiftAmountTy(InsElt0.getValueType())));
5949       else if (Elt1 >= 0)
5950         InsElt0 = DAG.getNode(ISD::AND, dl, MVT::i16, InsElt0,
5951                              DAG.getConstant(0x00FF, MVT::i16));
5952       InsElt = Elt1 >= 0 ? DAG.getNode(ISD::OR, dl, MVT::i16, InsElt, InsElt0)
5953                          : InsElt0;
5954     }
5955     NewV = DAG.getNode(ISD::INSERT_VECTOR_ELT, dl, MVT::v8i16, NewV, InsElt,
5956                        DAG.getIntPtrConstant(i));
5957   }
5958   return DAG.getNode(ISD::BITCAST, dl, MVT::v16i8, NewV);
5959 }
5960
5961 /// RewriteAsNarrowerShuffle - Try rewriting v8i16 and v16i8 shuffles as 4 wide
5962 /// ones, or rewriting v4i32 / v4f32 as 2 wide ones if possible. This can be
5963 /// done when every pair / quad of shuffle mask elements point to elements in
5964 /// the right sequence. e.g.
5965 /// vector_shuffle X, Y, <2, 3, | 10, 11, | 0, 1, | 14, 15>
5966 static
5967 SDValue RewriteAsNarrowerShuffle(ShuffleVectorSDNode *SVOp,
5968                                  SelectionDAG &DAG, DebugLoc dl) {
5969   MVT VT = SVOp->getValueType(0).getSimpleVT();
5970   unsigned NumElems = VT.getVectorNumElements();
5971   MVT NewVT;
5972   unsigned Scale;
5973   switch (VT.SimpleTy) {
5974   default: llvm_unreachable("Unexpected!");
5975   case MVT::v4f32:  NewVT = MVT::v2f64; Scale = 2; break;
5976   case MVT::v4i32:  NewVT = MVT::v2i64; Scale = 2; break;
5977   case MVT::v8i16:  NewVT = MVT::v4i32; Scale = 2; break;
5978   case MVT::v16i8:  NewVT = MVT::v4i32; Scale = 4; break;
5979   case MVT::v16i16: NewVT = MVT::v8i32; Scale = 2; break;
5980   case MVT::v32i8:  NewVT = MVT::v8i32; Scale = 4; break;
5981   }
5982
5983   SmallVector<int, 8> MaskVec;
5984   for (unsigned i = 0; i != NumElems; i += Scale) {
5985     int StartIdx = -1;
5986     for (unsigned j = 0; j != Scale; ++j) {
5987       int EltIdx = SVOp->getMaskElt(i+j);
5988       if (EltIdx < 0)
5989         continue;
5990       if (StartIdx < 0)
5991         StartIdx = (EltIdx / Scale);
5992       if (EltIdx != (int)(StartIdx*Scale + j))
5993         return SDValue();
5994     }
5995     MaskVec.push_back(StartIdx);
5996   }
5997
5998   SDValue V1 = DAG.getNode(ISD::BITCAST, dl, NewVT, SVOp->getOperand(0));
5999   SDValue V2 = DAG.getNode(ISD::BITCAST, dl, NewVT, SVOp->getOperand(1));
6000   return DAG.getVectorShuffle(NewVT, dl, V1, V2, &MaskVec[0]);
6001 }
6002
6003 /// getVZextMovL - Return a zero-extending vector move low node.
6004 ///
6005 static SDValue getVZextMovL(EVT VT, EVT OpVT,
6006                             SDValue SrcOp, SelectionDAG &DAG,
6007                             const X86Subtarget *Subtarget, DebugLoc dl) {
6008   if (VT == MVT::v2f64 || VT == MVT::v4f32) {
6009     LoadSDNode *LD = NULL;
6010     if (!isScalarLoadToVector(SrcOp.getNode(), &LD))
6011       LD = dyn_cast<LoadSDNode>(SrcOp);
6012     if (!LD) {
6013       // movssrr and movsdrr do not clear top bits. Try to use movd, movq
6014       // instead.
6015       MVT ExtVT = (OpVT == MVT::v2f64) ? MVT::i64 : MVT::i32;
6016       if ((ExtVT != MVT::i64 || Subtarget->is64Bit()) &&
6017           SrcOp.getOpcode() == ISD::SCALAR_TO_VECTOR &&
6018           SrcOp.getOperand(0).getOpcode() == ISD::BITCAST &&
6019           SrcOp.getOperand(0).getOperand(0).getValueType() == ExtVT) {
6020         // PR2108
6021         OpVT = (OpVT == MVT::v2f64) ? MVT::v2i64 : MVT::v4i32;
6022         return DAG.getNode(ISD::BITCAST, dl, VT,
6023                            DAG.getNode(X86ISD::VZEXT_MOVL, dl, OpVT,
6024                                        DAG.getNode(ISD::SCALAR_TO_VECTOR, dl,
6025                                                    OpVT,
6026                                                    SrcOp.getOperand(0)
6027                                                           .getOperand(0))));
6028       }
6029     }
6030   }
6031
6032   return DAG.getNode(ISD::BITCAST, dl, VT,
6033                      DAG.getNode(X86ISD::VZEXT_MOVL, dl, OpVT,
6034                                  DAG.getNode(ISD::BITCAST, dl,
6035                                              OpVT, SrcOp)));
6036 }
6037
6038 /// LowerVECTOR_SHUFFLE_256 - Handle all 256-bit wide vectors shuffles
6039 /// which could not be matched by any known target speficic shuffle
6040 static SDValue
6041 LowerVECTOR_SHUFFLE_256(ShuffleVectorSDNode *SVOp, SelectionDAG &DAG) {
6042
6043   SDValue NewOp = Compact8x32ShuffleNode(SVOp, DAG);
6044   if (NewOp.getNode())
6045     return NewOp;
6046
6047   EVT VT = SVOp->getValueType(0);
6048
6049   unsigned NumElems = VT.getVectorNumElements();
6050   unsigned NumLaneElems = NumElems / 2;
6051
6052   DebugLoc dl = SVOp->getDebugLoc();
6053   MVT EltVT = VT.getVectorElementType().getSimpleVT();
6054   EVT NVT = MVT::getVectorVT(EltVT, NumLaneElems);
6055   SDValue Output[2];
6056
6057   SmallVector<int, 16> Mask;
6058   for (unsigned l = 0; l < 2; ++l) {
6059     // Build a shuffle mask for the output, discovering on the fly which
6060     // input vectors to use as shuffle operands (recorded in InputUsed).
6061     // If building a suitable shuffle vector proves too hard, then bail
6062     // out with UseBuildVector set.
6063     bool UseBuildVector = false;
6064     int InputUsed[2] = { -1, -1 }; // Not yet discovered.
6065     unsigned LaneStart = l * NumLaneElems;
6066     for (unsigned i = 0; i != NumLaneElems; ++i) {
6067       // The mask element.  This indexes into the input.
6068       int Idx = SVOp->getMaskElt(i+LaneStart);
6069       if (Idx < 0) {
6070         // the mask element does not index into any input vector.
6071         Mask.push_back(-1);
6072         continue;
6073       }
6074
6075       // The input vector this mask element indexes into.
6076       int Input = Idx / NumLaneElems;
6077
6078       // Turn the index into an offset from the start of the input vector.
6079       Idx -= Input * NumLaneElems;
6080
6081       // Find or create a shuffle vector operand to hold this input.
6082       unsigned OpNo;
6083       for (OpNo = 0; OpNo < array_lengthof(InputUsed); ++OpNo) {
6084         if (InputUsed[OpNo] == Input)
6085           // This input vector is already an operand.
6086           break;
6087         if (InputUsed[OpNo] < 0) {
6088           // Create a new operand for this input vector.
6089           InputUsed[OpNo] = Input;
6090           break;
6091         }
6092       }
6093
6094       if (OpNo >= array_lengthof(InputUsed)) {
6095         // More than two input vectors used!  Give up on trying to create a
6096         // shuffle vector.  Insert all elements into a BUILD_VECTOR instead.
6097         UseBuildVector = true;
6098         break;
6099       }
6100
6101       // Add the mask index for the new shuffle vector.
6102       Mask.push_back(Idx + OpNo * NumLaneElems);
6103     }
6104
6105     if (UseBuildVector) {
6106       SmallVector<SDValue, 16> SVOps;
6107       for (unsigned i = 0; i != NumLaneElems; ++i) {
6108         // The mask element.  This indexes into the input.
6109         int Idx = SVOp->getMaskElt(i+LaneStart);
6110         if (Idx < 0) {
6111           SVOps.push_back(DAG.getUNDEF(EltVT));
6112           continue;
6113         }
6114
6115         // The input vector this mask element indexes into.
6116         int Input = Idx / NumElems;
6117
6118         // Turn the index into an offset from the start of the input vector.
6119         Idx -= Input * NumElems;
6120
6121         // Extract the vector element by hand.
6122         SVOps.push_back(DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, EltVT,
6123                                     SVOp->getOperand(Input),
6124                                     DAG.getIntPtrConstant(Idx)));
6125       }
6126
6127       // Construct the output using a BUILD_VECTOR.
6128       Output[l] = DAG.getNode(ISD::BUILD_VECTOR, dl, NVT, &SVOps[0],
6129                               SVOps.size());
6130     } else if (InputUsed[0] < 0) {
6131       // No input vectors were used! The result is undefined.
6132       Output[l] = DAG.getUNDEF(NVT);
6133     } else {
6134       SDValue Op0 = Extract128BitVector(SVOp->getOperand(InputUsed[0] / 2),
6135                                         (InputUsed[0] % 2) * NumLaneElems,
6136                                         DAG, dl);
6137       // If only one input was used, use an undefined vector for the other.
6138       SDValue Op1 = (InputUsed[1] < 0) ? DAG.getUNDEF(NVT) :
6139         Extract128BitVector(SVOp->getOperand(InputUsed[1] / 2),
6140                             (InputUsed[1] % 2) * NumLaneElems, DAG, dl);
6141       // At least one input vector was used. Create a new shuffle vector.
6142       Output[l] = DAG.getVectorShuffle(NVT, dl, Op0, Op1, &Mask[0]);
6143     }
6144
6145     Mask.clear();
6146   }
6147
6148   // Concatenate the result back
6149   return DAG.getNode(ISD::CONCAT_VECTORS, dl, VT, Output[0], Output[1]);
6150 }
6151
6152 /// LowerVECTOR_SHUFFLE_128v4 - Handle all 128-bit wide vectors with
6153 /// 4 elements, and match them with several different shuffle types.
6154 static SDValue
6155 LowerVECTOR_SHUFFLE_128v4(ShuffleVectorSDNode *SVOp, SelectionDAG &DAG) {
6156   SDValue V1 = SVOp->getOperand(0);
6157   SDValue V2 = SVOp->getOperand(1);
6158   DebugLoc dl = SVOp->getDebugLoc();
6159   EVT VT = SVOp->getValueType(0);
6160
6161   assert(VT.getSizeInBits() == 128 && "Unsupported vector size");
6162
6163   std::pair<int, int> Locs[4];
6164   int Mask1[] = { -1, -1, -1, -1 };
6165   SmallVector<int, 8> PermMask(SVOp->getMask().begin(), SVOp->getMask().end());
6166
6167   unsigned NumHi = 0;
6168   unsigned NumLo = 0;
6169   for (unsigned i = 0; i != 4; ++i) {
6170     int Idx = PermMask[i];
6171     if (Idx < 0) {
6172       Locs[i] = std::make_pair(-1, -1);
6173     } else {
6174       assert(Idx < 8 && "Invalid VECTOR_SHUFFLE index!");
6175       if (Idx < 4) {
6176         Locs[i] = std::make_pair(0, NumLo);
6177         Mask1[NumLo] = Idx;
6178         NumLo++;
6179       } else {
6180         Locs[i] = std::make_pair(1, NumHi);
6181         if (2+NumHi < 4)
6182           Mask1[2+NumHi] = Idx;
6183         NumHi++;
6184       }
6185     }
6186   }
6187
6188   if (NumLo <= 2 && NumHi <= 2) {
6189     // If no more than two elements come from either vector. This can be
6190     // implemented with two shuffles. First shuffle gather the elements.
6191     // The second shuffle, which takes the first shuffle as both of its
6192     // vector operands, put the elements into the right order.
6193     V1 = DAG.getVectorShuffle(VT, dl, V1, V2, &Mask1[0]);
6194
6195     int Mask2[] = { -1, -1, -1, -1 };
6196
6197     for (unsigned i = 0; i != 4; ++i)
6198       if (Locs[i].first != -1) {
6199         unsigned Idx = (i < 2) ? 0 : 4;
6200         Idx += Locs[i].first * 2 + Locs[i].second;
6201         Mask2[i] = Idx;
6202       }
6203
6204     return DAG.getVectorShuffle(VT, dl, V1, V1, &Mask2[0]);
6205   }
6206
6207   if (NumLo == 3 || NumHi == 3) {
6208     // Otherwise, we must have three elements from one vector, call it X, and
6209     // one element from the other, call it Y.  First, use a shufps to build an
6210     // intermediate vector with the one element from Y and the element from X
6211     // that will be in the same half in the final destination (the indexes don't
6212     // matter). Then, use a shufps to build the final vector, taking the half
6213     // containing the element from Y from the intermediate, and the other half
6214     // from X.
6215     if (NumHi == 3) {
6216       // Normalize it so the 3 elements come from V1.
6217       CommuteVectorShuffleMask(PermMask, 4);
6218       std::swap(V1, V2);
6219     }
6220
6221     // Find the element from V2.
6222     unsigned HiIndex;
6223     for (HiIndex = 0; HiIndex < 3; ++HiIndex) {
6224       int Val = PermMask[HiIndex];
6225       if (Val < 0)
6226         continue;
6227       if (Val >= 4)
6228         break;
6229     }
6230
6231     Mask1[0] = PermMask[HiIndex];
6232     Mask1[1] = -1;
6233     Mask1[2] = PermMask[HiIndex^1];
6234     Mask1[3] = -1;
6235     V2 = DAG.getVectorShuffle(VT, dl, V1, V2, &Mask1[0]);
6236
6237     if (HiIndex >= 2) {
6238       Mask1[0] = PermMask[0];
6239       Mask1[1] = PermMask[1];
6240       Mask1[2] = HiIndex & 1 ? 6 : 4;
6241       Mask1[3] = HiIndex & 1 ? 4 : 6;
6242       return DAG.getVectorShuffle(VT, dl, V1, V2, &Mask1[0]);
6243     }
6244
6245     Mask1[0] = HiIndex & 1 ? 2 : 0;
6246     Mask1[1] = HiIndex & 1 ? 0 : 2;
6247     Mask1[2] = PermMask[2];
6248     Mask1[3] = PermMask[3];
6249     if (Mask1[2] >= 0)
6250       Mask1[2] += 4;
6251     if (Mask1[3] >= 0)
6252       Mask1[3] += 4;
6253     return DAG.getVectorShuffle(VT, dl, V2, V1, &Mask1[0]);
6254   }
6255
6256   // Break it into (shuffle shuffle_hi, shuffle_lo).
6257   int LoMask[] = { -1, -1, -1, -1 };
6258   int HiMask[] = { -1, -1, -1, -1 };
6259
6260   int *MaskPtr = LoMask;
6261   unsigned MaskIdx = 0;
6262   unsigned LoIdx = 0;
6263   unsigned HiIdx = 2;
6264   for (unsigned i = 0; i != 4; ++i) {
6265     if (i == 2) {
6266       MaskPtr = HiMask;
6267       MaskIdx = 1;
6268       LoIdx = 0;
6269       HiIdx = 2;
6270     }
6271     int Idx = PermMask[i];
6272     if (Idx < 0) {
6273       Locs[i] = std::make_pair(-1, -1);
6274     } else if (Idx < 4) {
6275       Locs[i] = std::make_pair(MaskIdx, LoIdx);
6276       MaskPtr[LoIdx] = Idx;
6277       LoIdx++;
6278     } else {
6279       Locs[i] = std::make_pair(MaskIdx, HiIdx);
6280       MaskPtr[HiIdx] = Idx;
6281       HiIdx++;
6282     }
6283   }
6284
6285   SDValue LoShuffle = DAG.getVectorShuffle(VT, dl, V1, V2, &LoMask[0]);
6286   SDValue HiShuffle = DAG.getVectorShuffle(VT, dl, V1, V2, &HiMask[0]);
6287   int MaskOps[] = { -1, -1, -1, -1 };
6288   for (unsigned i = 0; i != 4; ++i)
6289     if (Locs[i].first != -1)
6290       MaskOps[i] = Locs[i].first * 4 + Locs[i].second;
6291   return DAG.getVectorShuffle(VT, dl, LoShuffle, HiShuffle, &MaskOps[0]);
6292 }
6293
6294 static bool MayFoldVectorLoad(SDValue V) {
6295   if (V.hasOneUse() && V.getOpcode() == ISD::BITCAST)
6296     V = V.getOperand(0);
6297   if (V.hasOneUse() && V.getOpcode() == ISD::SCALAR_TO_VECTOR)
6298     V = V.getOperand(0);
6299   if (V.hasOneUse() && V.getOpcode() == ISD::BUILD_VECTOR &&
6300       V.getNumOperands() == 2 && V.getOperand(1).getOpcode() == ISD::UNDEF)
6301     // BUILD_VECTOR (load), undef
6302     V = V.getOperand(0);
6303   if (MayFoldLoad(V))
6304     return true;
6305   return false;
6306 }
6307
6308 // FIXME: the version above should always be used. Since there's
6309 // a bug where several vector shuffles can't be folded because the
6310 // DAG is not updated during lowering and a node claims to have two
6311 // uses while it only has one, use this version, and let isel match
6312 // another instruction if the load really happens to have more than
6313 // one use. Remove this version after this bug get fixed.
6314 // rdar://8434668, PR8156
6315 static bool RelaxedMayFoldVectorLoad(SDValue V) {
6316   if (V.hasOneUse() && V.getOpcode() == ISD::BITCAST)
6317     V = V.getOperand(0);
6318   if (V.hasOneUse() && V.getOpcode() == ISD::SCALAR_TO_VECTOR)
6319     V = V.getOperand(0);
6320   if (ISD::isNormalLoad(V.getNode()))
6321     return true;
6322   return false;
6323 }
6324
6325 static
6326 SDValue getMOVDDup(SDValue &Op, DebugLoc &dl, SDValue V1, SelectionDAG &DAG) {
6327   EVT VT = Op.getValueType();
6328
6329   // Canonizalize to v2f64.
6330   V1 = DAG.getNode(ISD::BITCAST, dl, MVT::v2f64, V1);
6331   return DAG.getNode(ISD::BITCAST, dl, VT,
6332                      getTargetShuffleNode(X86ISD::MOVDDUP, dl, MVT::v2f64,
6333                                           V1, DAG));
6334 }
6335
6336 static
6337 SDValue getMOVLowToHigh(SDValue &Op, DebugLoc &dl, SelectionDAG &DAG,
6338                         bool HasSSE2) {
6339   SDValue V1 = Op.getOperand(0);
6340   SDValue V2 = Op.getOperand(1);
6341   EVT VT = Op.getValueType();
6342
6343   assert(VT != MVT::v2i64 && "unsupported shuffle type");
6344
6345   if (HasSSE2 && VT == MVT::v2f64)
6346     return getTargetShuffleNode(X86ISD::MOVLHPD, dl, VT, V1, V2, DAG);
6347
6348   // v4f32 or v4i32: canonizalized to v4f32 (which is legal for SSE1)
6349   return DAG.getNode(ISD::BITCAST, dl, VT,
6350                      getTargetShuffleNode(X86ISD::MOVLHPS, dl, MVT::v4f32,
6351                            DAG.getNode(ISD::BITCAST, dl, MVT::v4f32, V1),
6352                            DAG.getNode(ISD::BITCAST, dl, MVT::v4f32, V2), DAG));
6353 }
6354
6355 static
6356 SDValue getMOVHighToLow(SDValue &Op, DebugLoc &dl, SelectionDAG &DAG) {
6357   SDValue V1 = Op.getOperand(0);
6358   SDValue V2 = Op.getOperand(1);
6359   EVT VT = Op.getValueType();
6360
6361   assert((VT == MVT::v4i32 || VT == MVT::v4f32) &&
6362          "unsupported shuffle type");
6363
6364   if (V2.getOpcode() == ISD::UNDEF)
6365     V2 = V1;
6366
6367   // v4i32 or v4f32
6368   return getTargetShuffleNode(X86ISD::MOVHLPS, dl, VT, V1, V2, DAG);
6369 }
6370
6371 static
6372 SDValue getMOVLP(SDValue &Op, DebugLoc &dl, SelectionDAG &DAG, bool HasSSE2) {
6373   SDValue V1 = Op.getOperand(0);
6374   SDValue V2 = Op.getOperand(1);
6375   EVT VT = Op.getValueType();
6376   unsigned NumElems = VT.getVectorNumElements();
6377
6378   // Use MOVLPS and MOVLPD in case V1 or V2 are loads. During isel, the second
6379   // operand of these instructions is only memory, so check if there's a
6380   // potencial load folding here, otherwise use SHUFPS or MOVSD to match the
6381   // same masks.
6382   bool CanFoldLoad = false;
6383
6384   // Trivial case, when V2 comes from a load.
6385   if (MayFoldVectorLoad(V2))
6386     CanFoldLoad = true;
6387
6388   // When V1 is a load, it can be folded later into a store in isel, example:
6389   //  (store (v4f32 (X86Movlps (load addr:$src1), VR128:$src2)), addr:$src1)
6390   //    turns into:
6391   //  (MOVLPSmr addr:$src1, VR128:$src2)
6392   // So, recognize this potential and also use MOVLPS or MOVLPD
6393   else if (MayFoldVectorLoad(V1) && MayFoldIntoStore(Op))
6394     CanFoldLoad = true;
6395
6396   ShuffleVectorSDNode *SVOp = cast<ShuffleVectorSDNode>(Op);
6397   if (CanFoldLoad) {
6398     if (HasSSE2 && NumElems == 2)
6399       return getTargetShuffleNode(X86ISD::MOVLPD, dl, VT, V1, V2, DAG);
6400
6401     if (NumElems == 4)
6402       // If we don't care about the second element, proceed to use movss.
6403       if (SVOp->getMaskElt(1) != -1)
6404         return getTargetShuffleNode(X86ISD::MOVLPS, dl, VT, V1, V2, DAG);
6405   }
6406
6407   // movl and movlp will both match v2i64, but v2i64 is never matched by
6408   // movl earlier because we make it strict to avoid messing with the movlp load
6409   // folding logic (see the code above getMOVLP call). Match it here then,
6410   // this is horrible, but will stay like this until we move all shuffle
6411   // matching to x86 specific nodes. Note that for the 1st condition all
6412   // types are matched with movsd.
6413   if (HasSSE2) {
6414     // FIXME: isMOVLMask should be checked and matched before getMOVLP,
6415     // as to remove this logic from here, as much as possible
6416     if (NumElems == 2 || !isMOVLMask(SVOp->getMask(), VT))
6417       return getTargetShuffleNode(X86ISD::MOVSD, dl, VT, V1, V2, DAG);
6418     return getTargetShuffleNode(X86ISD::MOVSS, dl, VT, V1, V2, DAG);
6419   }
6420
6421   assert(VT != MVT::v4i32 && "unsupported shuffle type");
6422
6423   // Invert the operand order and use SHUFPS to match it.
6424   return getTargetShuffleNode(X86ISD::SHUFP, dl, VT, V2, V1,
6425                               getShuffleSHUFImmediate(SVOp), DAG);
6426 }
6427
6428 SDValue
6429 X86TargetLowering::NormalizeVectorShuffle(SDValue Op, SelectionDAG &DAG) const {
6430   ShuffleVectorSDNode *SVOp = cast<ShuffleVectorSDNode>(Op);
6431   EVT VT = Op.getValueType();
6432   DebugLoc dl = Op.getDebugLoc();
6433   SDValue V1 = Op.getOperand(0);
6434   SDValue V2 = Op.getOperand(1);
6435
6436   if (isZeroShuffle(SVOp))
6437     return getZeroVector(VT, Subtarget, DAG, dl);
6438
6439   // Handle splat operations
6440   if (SVOp->isSplat()) {
6441     unsigned NumElem = VT.getVectorNumElements();
6442     int Size = VT.getSizeInBits();
6443
6444     // Use vbroadcast whenever the splat comes from a foldable load
6445     SDValue Broadcast = LowerVectorBroadcast(Op, DAG);
6446     if (Broadcast.getNode())
6447       return Broadcast;
6448
6449     // Handle splats by matching through known shuffle masks
6450     if ((Size == 128 && NumElem <= 4) ||
6451         (Size == 256 && NumElem < 8))
6452       return SDValue();
6453
6454     // All remaning splats are promoted to target supported vector shuffles.
6455     return PromoteSplat(SVOp, DAG);
6456   }
6457
6458   // If the shuffle can be profitably rewritten as a narrower shuffle, then
6459   // do it!
6460   if (VT == MVT::v8i16  || VT == MVT::v16i8 ||
6461       VT == MVT::v16i16 || VT == MVT::v32i8) {
6462     SDValue NewOp = RewriteAsNarrowerShuffle(SVOp, DAG, dl);
6463     if (NewOp.getNode())
6464       return DAG.getNode(ISD::BITCAST, dl, VT, NewOp);
6465   } else if ((VT == MVT::v4i32 ||
6466              (VT == MVT::v4f32 && Subtarget->hasSSE2()))) {
6467     // FIXME: Figure out a cleaner way to do this.
6468     // Try to make use of movq to zero out the top part.
6469     if (ISD::isBuildVectorAllZeros(V2.getNode())) {
6470       SDValue NewOp = RewriteAsNarrowerShuffle(SVOp, DAG, dl);
6471       if (NewOp.getNode()) {
6472         EVT NewVT = NewOp.getValueType();
6473         if (isCommutedMOVLMask(cast<ShuffleVectorSDNode>(NewOp)->getMask(),
6474                                NewVT, true, false))
6475           return getVZextMovL(VT, NewVT, NewOp.getOperand(0),
6476                               DAG, Subtarget, dl);
6477       }
6478     } else if (ISD::isBuildVectorAllZeros(V1.getNode())) {
6479       SDValue NewOp = RewriteAsNarrowerShuffle(SVOp, DAG, dl);
6480       if (NewOp.getNode()) {
6481         EVT NewVT = NewOp.getValueType();
6482         if (isMOVLMask(cast<ShuffleVectorSDNode>(NewOp)->getMask(), NewVT))
6483           return getVZextMovL(VT, NewVT, NewOp.getOperand(1),
6484                               DAG, Subtarget, dl);
6485       }
6486     }
6487   }
6488   return SDValue();
6489 }
6490
6491 SDValue
6492 X86TargetLowering::LowerVECTOR_SHUFFLE(SDValue Op, SelectionDAG &DAG) const {
6493   ShuffleVectorSDNode *SVOp = cast<ShuffleVectorSDNode>(Op);
6494   SDValue V1 = Op.getOperand(0);
6495   SDValue V2 = Op.getOperand(1);
6496   EVT VT = Op.getValueType();
6497   DebugLoc dl = Op.getDebugLoc();
6498   unsigned NumElems = VT.getVectorNumElements();
6499   bool V1IsUndef = V1.getOpcode() == ISD::UNDEF;
6500   bool V2IsUndef = V2.getOpcode() == ISD::UNDEF;
6501   bool V1IsSplat = false;
6502   bool V2IsSplat = false;
6503   bool HasSSE2 = Subtarget->hasSSE2();
6504   bool HasAVX    = Subtarget->hasAVX();
6505   bool HasAVX2   = Subtarget->hasAVX2();
6506   MachineFunction &MF = DAG.getMachineFunction();
6507   bool OptForSize = MF.getFunction()->hasFnAttr(Attribute::OptimizeForSize);
6508
6509   assert(VT.getSizeInBits() != 64 && "Can't lower MMX shuffles");
6510
6511   if (V1IsUndef && V2IsUndef)
6512     return DAG.getUNDEF(VT);
6513
6514   assert(!V1IsUndef && "Op 1 of shuffle should not be undef");
6515
6516   // Vector shuffle lowering takes 3 steps:
6517   //
6518   // 1) Normalize the input vectors. Here splats, zeroed vectors, profitable
6519   //    narrowing and commutation of operands should be handled.
6520   // 2) Matching of shuffles with known shuffle masks to x86 target specific
6521   //    shuffle nodes.
6522   // 3) Rewriting of unmatched masks into new generic shuffle operations,
6523   //    so the shuffle can be broken into other shuffles and the legalizer can
6524   //    try the lowering again.
6525   //
6526   // The general idea is that no vector_shuffle operation should be left to
6527   // be matched during isel, all of them must be converted to a target specific
6528   // node here.
6529
6530   // Normalize the input vectors. Here splats, zeroed vectors, profitable
6531   // narrowing and commutation of operands should be handled. The actual code
6532   // doesn't include all of those, work in progress...
6533   SDValue NewOp = NormalizeVectorShuffle(Op, DAG);
6534   if (NewOp.getNode())
6535     return NewOp;
6536
6537   SmallVector<int, 8> M(SVOp->getMask().begin(), SVOp->getMask().end());
6538
6539   // NOTE: isPSHUFDMask can also match both masks below (unpckl_undef and
6540   // unpckh_undef). Only use pshufd if speed is more important than size.
6541   if (OptForSize && isUNPCKL_v_undef_Mask(M, VT, HasAVX2))
6542     return getTargetShuffleNode(X86ISD::UNPCKL, dl, VT, V1, V1, DAG);
6543   if (OptForSize && isUNPCKH_v_undef_Mask(M, VT, HasAVX2))
6544     return getTargetShuffleNode(X86ISD::UNPCKH, dl, VT, V1, V1, DAG);
6545
6546   if (isMOVDDUPMask(M, VT) && Subtarget->hasSSE3() &&
6547       V2IsUndef && RelaxedMayFoldVectorLoad(V1))
6548     return getMOVDDup(Op, dl, V1, DAG);
6549
6550   if (isMOVHLPS_v_undef_Mask(M, VT))
6551     return getMOVHighToLow(Op, dl, DAG);
6552
6553   // Use to match splats
6554   if (HasSSE2 && isUNPCKHMask(M, VT, HasAVX2) && V2IsUndef &&
6555       (VT == MVT::v2f64 || VT == MVT::v2i64))
6556     return getTargetShuffleNode(X86ISD::UNPCKH, dl, VT, V1, V1, DAG);
6557
6558   if (isPSHUFDMask(M, VT)) {
6559     // The actual implementation will match the mask in the if above and then
6560     // during isel it can match several different instructions, not only pshufd
6561     // as its name says, sad but true, emulate the behavior for now...
6562     if (isMOVDDUPMask(M, VT) && ((VT == MVT::v4f32 || VT == MVT::v2i64)))
6563       return getTargetShuffleNode(X86ISD::MOVLHPS, dl, VT, V1, V1, DAG);
6564
6565     unsigned TargetMask = getShuffleSHUFImmediate(SVOp);
6566
6567     if (HasAVX && (VT == MVT::v4f32 || VT == MVT::v2f64))
6568       return getTargetShuffleNode(X86ISD::VPERMILP, dl, VT, V1, TargetMask, DAG);
6569
6570     if (HasSSE2 && (VT == MVT::v4f32 || VT == MVT::v4i32))
6571       return getTargetShuffleNode(X86ISD::PSHUFD, dl, VT, V1, TargetMask, DAG);
6572
6573     return getTargetShuffleNode(X86ISD::SHUFP, dl, VT, V1, V1,
6574                                 TargetMask, DAG);
6575   }
6576
6577   // Check if this can be converted into a logical shift.
6578   bool isLeft = false;
6579   unsigned ShAmt = 0;
6580   SDValue ShVal;
6581   bool isShift = HasSSE2 && isVectorShift(SVOp, DAG, isLeft, ShVal, ShAmt);
6582   if (isShift && ShVal.hasOneUse()) {
6583     // If the shifted value has multiple uses, it may be cheaper to use
6584     // v_set0 + movlhps or movhlps, etc.
6585     EVT EltVT = VT.getVectorElementType();
6586     ShAmt *= EltVT.getSizeInBits();
6587     return getVShift(isLeft, VT, ShVal, ShAmt, DAG, *this, dl);
6588   }
6589
6590   if (isMOVLMask(M, VT)) {
6591     if (ISD::isBuildVectorAllZeros(V1.getNode()))
6592       return getVZextMovL(VT, VT, V2, DAG, Subtarget, dl);
6593     if (!isMOVLPMask(M, VT)) {
6594       if (HasSSE2 && (VT == MVT::v2i64 || VT == MVT::v2f64))
6595         return getTargetShuffleNode(X86ISD::MOVSD, dl, VT, V1, V2, DAG);
6596
6597       if (VT == MVT::v4i32 || VT == MVT::v4f32)
6598         return getTargetShuffleNode(X86ISD::MOVSS, dl, VT, V1, V2, DAG);
6599     }
6600   }
6601
6602   // FIXME: fold these into legal mask.
6603   if (isMOVLHPSMask(M, VT) && !isUNPCKLMask(M, VT, HasAVX2))
6604     return getMOVLowToHigh(Op, dl, DAG, HasSSE2);
6605
6606   if (isMOVHLPSMask(M, VT))
6607     return getMOVHighToLow(Op, dl, DAG);
6608
6609   if (V2IsUndef && isMOVSHDUPMask(M, VT, Subtarget))
6610     return getTargetShuffleNode(X86ISD::MOVSHDUP, dl, VT, V1, DAG);
6611
6612   if (V2IsUndef && isMOVSLDUPMask(M, VT, Subtarget))
6613     return getTargetShuffleNode(X86ISD::MOVSLDUP, dl, VT, V1, DAG);
6614
6615   if (isMOVLPMask(M, VT))
6616     return getMOVLP(Op, dl, DAG, HasSSE2);
6617
6618   if (ShouldXformToMOVHLPS(M, VT) ||
6619       ShouldXformToMOVLP(V1.getNode(), V2.getNode(), M, VT))
6620     return CommuteVectorShuffle(SVOp, DAG);
6621
6622   if (isShift) {
6623     // No better options. Use a vshldq / vsrldq.
6624     EVT EltVT = VT.getVectorElementType();
6625     ShAmt *= EltVT.getSizeInBits();
6626     return getVShift(isLeft, VT, ShVal, ShAmt, DAG, *this, dl);
6627   }
6628
6629   bool Commuted = false;
6630   // FIXME: This should also accept a bitcast of a splat?  Be careful, not
6631   // 1,1,1,1 -> v8i16 though.
6632   V1IsSplat = isSplatVector(V1.getNode());
6633   V2IsSplat = isSplatVector(V2.getNode());
6634
6635   // Canonicalize the splat or undef, if present, to be on the RHS.
6636   if (!V2IsUndef && V1IsSplat && !V2IsSplat) {
6637     CommuteVectorShuffleMask(M, NumElems);
6638     std::swap(V1, V2);
6639     std::swap(V1IsSplat, V2IsSplat);
6640     Commuted = true;
6641   }
6642
6643   if (isCommutedMOVLMask(M, VT, V2IsSplat, V2IsUndef)) {
6644     // Shuffling low element of v1 into undef, just return v1.
6645     if (V2IsUndef)
6646       return V1;
6647     // If V2 is a splat, the mask may be malformed such as <4,3,3,3>, which
6648     // the instruction selector will not match, so get a canonical MOVL with
6649     // swapped operands to undo the commute.
6650     return getMOVL(DAG, dl, VT, V2, V1);
6651   }
6652
6653   if (isUNPCKLMask(M, VT, HasAVX2))
6654     return getTargetShuffleNode(X86ISD::UNPCKL, dl, VT, V1, V2, DAG);
6655
6656   if (isUNPCKHMask(M, VT, HasAVX2))
6657     return getTargetShuffleNode(X86ISD::UNPCKH, dl, VT, V1, V2, DAG);
6658
6659   if (V2IsSplat) {
6660     // Normalize mask so all entries that point to V2 points to its first
6661     // element then try to match unpck{h|l} again. If match, return a
6662     // new vector_shuffle with the corrected mask.p
6663     SmallVector<int, 8> NewMask(M.begin(), M.end());
6664     NormalizeMask(NewMask, NumElems);
6665     if (isUNPCKLMask(NewMask, VT, HasAVX2, true))
6666       return getTargetShuffleNode(X86ISD::UNPCKL, dl, VT, V1, V2, DAG);
6667     if (isUNPCKHMask(NewMask, VT, HasAVX2, true))
6668       return getTargetShuffleNode(X86ISD::UNPCKH, dl, VT, V1, V2, DAG);
6669   }
6670
6671   if (Commuted) {
6672     // Commute is back and try unpck* again.
6673     // FIXME: this seems wrong.
6674     CommuteVectorShuffleMask(M, NumElems);
6675     std::swap(V1, V2);
6676     std::swap(V1IsSplat, V2IsSplat);
6677     Commuted = false;
6678
6679     if (isUNPCKLMask(M, VT, HasAVX2))
6680       return getTargetShuffleNode(X86ISD::UNPCKL, dl, VT, V1, V2, DAG);
6681
6682     if (isUNPCKHMask(M, VT, HasAVX2))
6683       return getTargetShuffleNode(X86ISD::UNPCKH, dl, VT, V1, V2, DAG);
6684   }
6685
6686   // Normalize the node to match x86 shuffle ops if needed
6687   if (!V2IsUndef && (isSHUFPMask(M, VT, HasAVX, /* Commuted */ true)))
6688     return CommuteVectorShuffle(SVOp, DAG);
6689
6690   // The checks below are all present in isShuffleMaskLegal, but they are
6691   // inlined here right now to enable us to directly emit target specific
6692   // nodes, and remove one by one until they don't return Op anymore.
6693
6694   if (isPALIGNRMask(M, VT, Subtarget))
6695     return getTargetShuffleNode(X86ISD::PALIGN, dl, VT, V1, V2,
6696                                 getShufflePALIGNRImmediate(SVOp),
6697                                 DAG);
6698
6699   if (ShuffleVectorSDNode::isSplatMask(&M[0], VT) &&
6700       SVOp->getSplatIndex() == 0 && V2IsUndef) {
6701     if (VT == MVT::v2f64 || VT == MVT::v2i64)
6702       return getTargetShuffleNode(X86ISD::UNPCKL, dl, VT, V1, V1, DAG);
6703   }
6704
6705   if (isPSHUFHWMask(M, VT, HasAVX2))
6706     return getTargetShuffleNode(X86ISD::PSHUFHW, dl, VT, V1,
6707                                 getShufflePSHUFHWImmediate(SVOp),
6708                                 DAG);
6709
6710   if (isPSHUFLWMask(M, VT, HasAVX2))
6711     return getTargetShuffleNode(X86ISD::PSHUFLW, dl, VT, V1,
6712                                 getShufflePSHUFLWImmediate(SVOp),
6713                                 DAG);
6714
6715   if (isSHUFPMask(M, VT, HasAVX))
6716     return getTargetShuffleNode(X86ISD::SHUFP, dl, VT, V1, V2,
6717                                 getShuffleSHUFImmediate(SVOp), DAG);
6718
6719   if (isUNPCKL_v_undef_Mask(M, VT, HasAVX2))
6720     return getTargetShuffleNode(X86ISD::UNPCKL, dl, VT, V1, V1, DAG);
6721   if (isUNPCKH_v_undef_Mask(M, VT, HasAVX2))
6722     return getTargetShuffleNode(X86ISD::UNPCKH, dl, VT, V1, V1, DAG);
6723
6724   //===--------------------------------------------------------------------===//
6725   // Generate target specific nodes for 128 or 256-bit shuffles only
6726   // supported in the AVX instruction set.
6727   //
6728
6729   // Handle VMOVDDUPY permutations
6730   if (V2IsUndef && isMOVDDUPYMask(M, VT, HasAVX))
6731     return getTargetShuffleNode(X86ISD::MOVDDUP, dl, VT, V1, DAG);
6732
6733   // Handle VPERMILPS/D* permutations
6734   if (isVPERMILPMask(M, VT, HasAVX)) {
6735     if (HasAVX2 && VT == MVT::v8i32)
6736       return getTargetShuffleNode(X86ISD::PSHUFD, dl, VT, V1,
6737                                   getShuffleSHUFImmediate(SVOp), DAG);
6738     return getTargetShuffleNode(X86ISD::VPERMILP, dl, VT, V1,
6739                                 getShuffleSHUFImmediate(SVOp), DAG);
6740   }
6741
6742   // Handle VPERM2F128/VPERM2I128 permutations
6743   if (isVPERM2X128Mask(M, VT, HasAVX))
6744     return getTargetShuffleNode(X86ISD::VPERM2X128, dl, VT, V1,
6745                                 V2, getShuffleVPERM2X128Immediate(SVOp), DAG);
6746
6747   SDValue BlendOp = LowerVECTOR_SHUFFLEtoBlend(SVOp, Subtarget, DAG);
6748   if (BlendOp.getNode())
6749     return BlendOp;
6750
6751   if (V2IsUndef && HasAVX2 && (VT == MVT::v8i32 || VT == MVT::v8f32)) {
6752     SmallVector<SDValue, 8> permclMask;
6753     for (unsigned i = 0; i != 8; ++i) {
6754       permclMask.push_back(DAG.getConstant((M[i]>=0) ? M[i] : 0, MVT::i32));
6755     }
6756     SDValue Mask = DAG.getNode(ISD::BUILD_VECTOR, dl, MVT::v8i32,
6757                                &permclMask[0], 8);
6758     // Bitcast is for VPERMPS since mask is v8i32 but node takes v8f32
6759     return DAG.getNode(X86ISD::VPERMV, dl, VT,
6760                        DAG.getNode(ISD::BITCAST, dl, VT, Mask), V1);
6761   }
6762
6763   if (V2IsUndef && HasAVX2 && (VT == MVT::v4i64 || VT == MVT::v4f64))
6764     return getTargetShuffleNode(X86ISD::VPERMI, dl, VT, V1,
6765                                 getShuffleCLImmediate(SVOp), DAG);
6766
6767
6768   //===--------------------------------------------------------------------===//
6769   // Since no target specific shuffle was selected for this generic one,
6770   // lower it into other known shuffles. FIXME: this isn't true yet, but
6771   // this is the plan.
6772   //
6773
6774   // Handle v8i16 specifically since SSE can do byte extraction and insertion.
6775   if (VT == MVT::v8i16) {
6776     SDValue NewOp = LowerVECTOR_SHUFFLEv8i16(Op, DAG);
6777     if (NewOp.getNode())
6778       return NewOp;
6779   }
6780
6781   if (VT == MVT::v16i8) {
6782     SDValue NewOp = LowerVECTOR_SHUFFLEv16i8(SVOp, DAG, *this);
6783     if (NewOp.getNode())
6784       return NewOp;
6785   }
6786
6787   // Handle all 128-bit wide vectors with 4 elements, and match them with
6788   // several different shuffle types.
6789   if (NumElems == 4 && VT.getSizeInBits() == 128)
6790     return LowerVECTOR_SHUFFLE_128v4(SVOp, DAG);
6791
6792   // Handle general 256-bit shuffles
6793   if (VT.is256BitVector())
6794     return LowerVECTOR_SHUFFLE_256(SVOp, DAG);
6795
6796   return SDValue();
6797 }
6798
6799 SDValue
6800 X86TargetLowering::LowerEXTRACT_VECTOR_ELT_SSE4(SDValue Op,
6801                                                 SelectionDAG &DAG) const {
6802   EVT VT = Op.getValueType();
6803   DebugLoc dl = Op.getDebugLoc();
6804
6805   if (Op.getOperand(0).getValueType().getSizeInBits() != 128)
6806     return SDValue();
6807
6808   if (VT.getSizeInBits() == 8) {
6809     SDValue Extract = DAG.getNode(X86ISD::PEXTRB, dl, MVT::i32,
6810                                     Op.getOperand(0), Op.getOperand(1));
6811     SDValue Assert  = DAG.getNode(ISD::AssertZext, dl, MVT::i32, Extract,
6812                                     DAG.getValueType(VT));
6813     return DAG.getNode(ISD::TRUNCATE, dl, VT, Assert);
6814   }
6815
6816   if (VT.getSizeInBits() == 16) {
6817     unsigned Idx = cast<ConstantSDNode>(Op.getOperand(1))->getZExtValue();
6818     // If Idx is 0, it's cheaper to do a move instead of a pextrw.
6819     if (Idx == 0)
6820       return DAG.getNode(ISD::TRUNCATE, dl, MVT::i16,
6821                          DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, MVT::i32,
6822                                      DAG.getNode(ISD::BITCAST, dl,
6823                                                  MVT::v4i32,
6824                                                  Op.getOperand(0)),
6825                                      Op.getOperand(1)));
6826     SDValue Extract = DAG.getNode(X86ISD::PEXTRW, dl, MVT::i32,
6827                                     Op.getOperand(0), Op.getOperand(1));
6828     SDValue Assert  = DAG.getNode(ISD::AssertZext, dl, MVT::i32, Extract,
6829                                     DAG.getValueType(VT));
6830     return DAG.getNode(ISD::TRUNCATE, dl, VT, Assert);
6831   }
6832
6833   if (VT == MVT::f32) {
6834     // EXTRACTPS outputs to a GPR32 register which will require a movd to copy
6835     // the result back to FR32 register. It's only worth matching if the
6836     // result has a single use which is a store or a bitcast to i32.  And in
6837     // the case of a store, it's not worth it if the index is a constant 0,
6838     // because a MOVSSmr can be used instead, which is smaller and faster.
6839     if (!Op.hasOneUse())
6840       return SDValue();
6841     SDNode *User = *Op.getNode()->use_begin();
6842     if ((User->getOpcode() != ISD::STORE ||
6843          (isa<ConstantSDNode>(Op.getOperand(1)) &&
6844           cast<ConstantSDNode>(Op.getOperand(1))->isNullValue())) &&
6845         (User->getOpcode() != ISD::BITCAST ||
6846          User->getValueType(0) != MVT::i32))
6847       return SDValue();
6848     SDValue Extract = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, MVT::i32,
6849                                   DAG.getNode(ISD::BITCAST, dl, MVT::v4i32,
6850                                               Op.getOperand(0)),
6851                                               Op.getOperand(1));
6852     return DAG.getNode(ISD::BITCAST, dl, MVT::f32, Extract);
6853   }
6854
6855   if (VT == MVT::i32 || VT == MVT::i64) {
6856     // ExtractPS/pextrq works with constant index.
6857     if (isa<ConstantSDNode>(Op.getOperand(1)))
6858       return Op;
6859   }
6860   return SDValue();
6861 }
6862
6863
6864 SDValue
6865 X86TargetLowering::LowerEXTRACT_VECTOR_ELT(SDValue Op,
6866                                            SelectionDAG &DAG) const {
6867   if (!isa<ConstantSDNode>(Op.getOperand(1)))
6868     return SDValue();
6869
6870   SDValue Vec = Op.getOperand(0);
6871   EVT VecVT = Vec.getValueType();
6872
6873   // If this is a 256-bit vector result, first extract the 128-bit vector and
6874   // then extract the element from the 128-bit vector.
6875   if (VecVT.getSizeInBits() == 256) {
6876     DebugLoc dl = Op.getNode()->getDebugLoc();
6877     unsigned NumElems = VecVT.getVectorNumElements();
6878     SDValue Idx = Op.getOperand(1);
6879     unsigned IdxVal = cast<ConstantSDNode>(Idx)->getZExtValue();
6880
6881     // Get the 128-bit vector.
6882     Vec = Extract128BitVector(Vec, IdxVal, DAG, dl);
6883
6884     if (IdxVal >= NumElems/2)
6885       IdxVal -= NumElems/2;
6886     return DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, Op.getValueType(), Vec,
6887                        DAG.getConstant(IdxVal, MVT::i32));
6888   }
6889
6890   assert(Vec.getValueSizeInBits() <= 128 && "Unexpected vector length");
6891
6892   if (Subtarget->hasSSE41()) {
6893     SDValue Res = LowerEXTRACT_VECTOR_ELT_SSE4(Op, DAG);
6894     if (Res.getNode())
6895       return Res;
6896   }
6897
6898   EVT VT = Op.getValueType();
6899   DebugLoc dl = Op.getDebugLoc();
6900   // TODO: handle v16i8.
6901   if (VT.getSizeInBits() == 16) {
6902     SDValue Vec = Op.getOperand(0);
6903     unsigned Idx = cast<ConstantSDNode>(Op.getOperand(1))->getZExtValue();
6904     if (Idx == 0)
6905       return DAG.getNode(ISD::TRUNCATE, dl, MVT::i16,
6906                          DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, MVT::i32,
6907                                      DAG.getNode(ISD::BITCAST, dl,
6908                                                  MVT::v4i32, Vec),
6909                                      Op.getOperand(1)));
6910     // Transform it so it match pextrw which produces a 32-bit result.
6911     EVT EltVT = MVT::i32;
6912     SDValue Extract = DAG.getNode(X86ISD::PEXTRW, dl, EltVT,
6913                                     Op.getOperand(0), Op.getOperand(1));
6914     SDValue Assert  = DAG.getNode(ISD::AssertZext, dl, EltVT, Extract,
6915                                     DAG.getValueType(VT));
6916     return DAG.getNode(ISD::TRUNCATE, dl, VT, Assert);
6917   }
6918
6919   if (VT.getSizeInBits() == 32) {
6920     unsigned Idx = cast<ConstantSDNode>(Op.getOperand(1))->getZExtValue();
6921     if (Idx == 0)
6922       return Op;
6923
6924     // SHUFPS the element to the lowest double word, then movss.
6925     int Mask[4] = { static_cast<int>(Idx), -1, -1, -1 };
6926     EVT VVT = Op.getOperand(0).getValueType();
6927     SDValue Vec = DAG.getVectorShuffle(VVT, dl, Op.getOperand(0),
6928                                        DAG.getUNDEF(VVT), Mask);
6929     return DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, VT, Vec,
6930                        DAG.getIntPtrConstant(0));
6931   }
6932
6933   if (VT.getSizeInBits() == 64) {
6934     // FIXME: .td only matches this for <2 x f64>, not <2 x i64> on 32b
6935     // FIXME: seems like this should be unnecessary if mov{h,l}pd were taught
6936     //        to match extract_elt for f64.
6937     unsigned Idx = cast<ConstantSDNode>(Op.getOperand(1))->getZExtValue();
6938     if (Idx == 0)
6939       return Op;
6940
6941     // UNPCKHPD the element to the lowest double word, then movsd.
6942     // Note if the lower 64 bits of the result of the UNPCKHPD is then stored
6943     // to a f64mem, the whole operation is folded into a single MOVHPDmr.
6944     int Mask[2] = { 1, -1 };
6945     EVT VVT = Op.getOperand(0).getValueType();
6946     SDValue Vec = DAG.getVectorShuffle(VVT, dl, Op.getOperand(0),
6947                                        DAG.getUNDEF(VVT), Mask);
6948     return DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, VT, Vec,
6949                        DAG.getIntPtrConstant(0));
6950   }
6951
6952   return SDValue();
6953 }
6954
6955 SDValue
6956 X86TargetLowering::LowerINSERT_VECTOR_ELT_SSE4(SDValue Op,
6957                                                SelectionDAG &DAG) const {
6958   EVT VT = Op.getValueType();
6959   EVT EltVT = VT.getVectorElementType();
6960   DebugLoc dl = Op.getDebugLoc();
6961
6962   SDValue N0 = Op.getOperand(0);
6963   SDValue N1 = Op.getOperand(1);
6964   SDValue N2 = Op.getOperand(2);
6965
6966   if (VT.getSizeInBits() == 256)
6967     return SDValue();
6968
6969   if ((EltVT.getSizeInBits() == 8 || EltVT.getSizeInBits() == 16) &&
6970       isa<ConstantSDNode>(N2)) {
6971     unsigned Opc;
6972     if (VT == MVT::v8i16)
6973       Opc = X86ISD::PINSRW;
6974     else if (VT == MVT::v16i8)
6975       Opc = X86ISD::PINSRB;
6976     else
6977       Opc = X86ISD::PINSRB;
6978
6979     // Transform it so it match pinsr{b,w} which expects a GR32 as its second
6980     // argument.
6981     if (N1.getValueType() != MVT::i32)
6982       N1 = DAG.getNode(ISD::ANY_EXTEND, dl, MVT::i32, N1);
6983     if (N2.getValueType() != MVT::i32)
6984       N2 = DAG.getIntPtrConstant(cast<ConstantSDNode>(N2)->getZExtValue());
6985     return DAG.getNode(Opc, dl, VT, N0, N1, N2);
6986   }
6987
6988   if (EltVT == MVT::f32 && isa<ConstantSDNode>(N2)) {
6989     // Bits [7:6] of the constant are the source select.  This will always be
6990     //  zero here.  The DAG Combiner may combine an extract_elt index into these
6991     //  bits.  For example (insert (extract, 3), 2) could be matched by putting
6992     //  the '3' into bits [7:6] of X86ISD::INSERTPS.
6993     // Bits [5:4] of the constant are the destination select.  This is the
6994     //  value of the incoming immediate.
6995     // Bits [3:0] of the constant are the zero mask.  The DAG Combiner may
6996     //   combine either bitwise AND or insert of float 0.0 to set these bits.
6997     N2 = DAG.getIntPtrConstant(cast<ConstantSDNode>(N2)->getZExtValue() << 4);
6998     // Create this as a scalar to vector..
6999     N1 = DAG.getNode(ISD::SCALAR_TO_VECTOR, dl, MVT::v4f32, N1);
7000     return DAG.getNode(X86ISD::INSERTPS, dl, VT, N0, N1, N2);
7001   }
7002
7003   if ((EltVT == MVT::i32 || EltVT == MVT::i64) && isa<ConstantSDNode>(N2)) {
7004     // PINSR* works with constant index.
7005     return Op;
7006   }
7007   return SDValue();
7008 }
7009
7010 SDValue
7011 X86TargetLowering::LowerINSERT_VECTOR_ELT(SDValue Op, SelectionDAG &DAG) const {
7012   EVT VT = Op.getValueType();
7013   EVT EltVT = VT.getVectorElementType();
7014
7015   DebugLoc dl = Op.getDebugLoc();
7016   SDValue N0 = Op.getOperand(0);
7017   SDValue N1 = Op.getOperand(1);
7018   SDValue N2 = Op.getOperand(2);
7019
7020   // If this is a 256-bit vector result, first extract the 128-bit vector,
7021   // insert the element into the extracted half and then place it back.
7022   if (VT.getSizeInBits() == 256) {
7023     if (!isa<ConstantSDNode>(N2))
7024       return SDValue();
7025
7026     // Get the desired 128-bit vector half.
7027     unsigned NumElems = VT.getVectorNumElements();
7028     unsigned IdxVal = cast<ConstantSDNode>(N2)->getZExtValue();
7029     SDValue V = Extract128BitVector(N0, IdxVal, DAG, dl);
7030
7031     // Insert the element into the desired half.
7032     bool Upper = IdxVal >= NumElems/2;
7033     V = DAG.getNode(ISD::INSERT_VECTOR_ELT, dl, V.getValueType(), V, N1,
7034                  DAG.getConstant(Upper ? IdxVal-NumElems/2 : IdxVal, MVT::i32));
7035
7036     // Insert the changed part back to the 256-bit vector
7037     return Insert128BitVector(N0, V, IdxVal, DAG, dl);
7038   }
7039
7040   if (Subtarget->hasSSE41())
7041     return LowerINSERT_VECTOR_ELT_SSE4(Op, DAG);
7042
7043   if (EltVT == MVT::i8)
7044     return SDValue();
7045
7046   if (EltVT.getSizeInBits() == 16 && isa<ConstantSDNode>(N2)) {
7047     // Transform it so it match pinsrw which expects a 16-bit value in a GR32
7048     // as its second argument.
7049     if (N1.getValueType() != MVT::i32)
7050       N1 = DAG.getNode(ISD::ANY_EXTEND, dl, MVT::i32, N1);
7051     if (N2.getValueType() != MVT::i32)
7052       N2 = DAG.getIntPtrConstant(cast<ConstantSDNode>(N2)->getZExtValue());
7053     return DAG.getNode(X86ISD::PINSRW, dl, VT, N0, N1, N2);
7054   }
7055   return SDValue();
7056 }
7057
7058 SDValue
7059 X86TargetLowering::LowerSCALAR_TO_VECTOR(SDValue Op, SelectionDAG &DAG) const {
7060   LLVMContext *Context = DAG.getContext();
7061   DebugLoc dl = Op.getDebugLoc();
7062   EVT OpVT = Op.getValueType();
7063
7064   // If this is a 256-bit vector result, first insert into a 128-bit
7065   // vector and then insert into the 256-bit vector.
7066   if (OpVT.getSizeInBits() > 128) {
7067     // Insert into a 128-bit vector.
7068     EVT VT128 = EVT::getVectorVT(*Context,
7069                                  OpVT.getVectorElementType(),
7070                                  OpVT.getVectorNumElements() / 2);
7071
7072     Op = DAG.getNode(ISD::SCALAR_TO_VECTOR, dl, VT128, Op.getOperand(0));
7073
7074     // Insert the 128-bit vector.
7075     return Insert128BitVector(DAG.getUNDEF(OpVT), Op, 0, DAG, dl);
7076   }
7077
7078   if (OpVT == MVT::v1i64 &&
7079       Op.getOperand(0).getValueType() == MVT::i64)
7080     return DAG.getNode(ISD::SCALAR_TO_VECTOR, dl, MVT::v1i64, Op.getOperand(0));
7081
7082   SDValue AnyExt = DAG.getNode(ISD::ANY_EXTEND, dl, MVT::i32, Op.getOperand(0));
7083   assert(OpVT.getSizeInBits() == 128 && "Expected an SSE type!");
7084   return DAG.getNode(ISD::BITCAST, dl, OpVT,
7085                      DAG.getNode(ISD::SCALAR_TO_VECTOR, dl, MVT::v4i32,AnyExt));
7086 }
7087
7088 // Lower a node with an EXTRACT_SUBVECTOR opcode.  This may result in
7089 // a simple subregister reference or explicit instructions to grab
7090 // upper bits of a vector.
7091 SDValue
7092 X86TargetLowering::LowerEXTRACT_SUBVECTOR(SDValue Op, SelectionDAG &DAG) const {
7093   if (Subtarget->hasAVX()) {
7094     DebugLoc dl = Op.getNode()->getDebugLoc();
7095     SDValue Vec = Op.getNode()->getOperand(0);
7096     SDValue Idx = Op.getNode()->getOperand(1);
7097
7098     if (Op.getNode()->getValueType(0).getSizeInBits() == 128 &&
7099         Vec.getNode()->getValueType(0).getSizeInBits() == 256 &&
7100         isa<ConstantSDNode>(Idx)) {
7101       unsigned IdxVal = cast<ConstantSDNode>(Idx)->getZExtValue();
7102       return Extract128BitVector(Vec, IdxVal, DAG, dl);
7103     }
7104   }
7105   return SDValue();
7106 }
7107
7108 // Lower a node with an INSERT_SUBVECTOR opcode.  This may result in a
7109 // simple superregister reference or explicit instructions to insert
7110 // the upper bits of a vector.
7111 SDValue
7112 X86TargetLowering::LowerINSERT_SUBVECTOR(SDValue Op, SelectionDAG &DAG) const {
7113   if (Subtarget->hasAVX()) {
7114     DebugLoc dl = Op.getNode()->getDebugLoc();
7115     SDValue Vec = Op.getNode()->getOperand(0);
7116     SDValue SubVec = Op.getNode()->getOperand(1);
7117     SDValue Idx = Op.getNode()->getOperand(2);
7118
7119     if (Op.getNode()->getValueType(0).getSizeInBits() == 256 &&
7120         SubVec.getNode()->getValueType(0).getSizeInBits() == 128 &&
7121         isa<ConstantSDNode>(Idx)) {
7122       unsigned IdxVal = cast<ConstantSDNode>(Idx)->getZExtValue();
7123       return Insert128BitVector(Vec, SubVec, IdxVal, DAG, dl);
7124     }
7125   }
7126   return SDValue();
7127 }
7128
7129 // ConstantPool, JumpTable, GlobalAddress, and ExternalSymbol are lowered as
7130 // their target countpart wrapped in the X86ISD::Wrapper node. Suppose N is
7131 // one of the above mentioned nodes. It has to be wrapped because otherwise
7132 // Select(N) returns N. So the raw TargetGlobalAddress nodes, etc. can only
7133 // be used to form addressing mode. These wrapped nodes will be selected
7134 // into MOV32ri.
7135 SDValue
7136 X86TargetLowering::LowerConstantPool(SDValue Op, SelectionDAG &DAG) const {
7137   ConstantPoolSDNode *CP = cast<ConstantPoolSDNode>(Op);
7138
7139   // In PIC mode (unless we're in RIPRel PIC mode) we add an offset to the
7140   // global base reg.
7141   unsigned char OpFlag = 0;
7142   unsigned WrapperKind = X86ISD::Wrapper;
7143   CodeModel::Model M = getTargetMachine().getCodeModel();
7144
7145   if (Subtarget->isPICStyleRIPRel() &&
7146       (M == CodeModel::Small || M == CodeModel::Kernel))
7147     WrapperKind = X86ISD::WrapperRIP;
7148   else if (Subtarget->isPICStyleGOT())
7149     OpFlag = X86II::MO_GOTOFF;
7150   else if (Subtarget->isPICStyleStubPIC())
7151     OpFlag = X86II::MO_PIC_BASE_OFFSET;
7152
7153   SDValue Result = DAG.getTargetConstantPool(CP->getConstVal(), getPointerTy(),
7154                                              CP->getAlignment(),
7155                                              CP->getOffset(), OpFlag);
7156   DebugLoc DL = CP->getDebugLoc();
7157   Result = DAG.getNode(WrapperKind, DL, getPointerTy(), Result);
7158   // With PIC, the address is actually $g + Offset.
7159   if (OpFlag) {
7160     Result = DAG.getNode(ISD::ADD, DL, getPointerTy(),
7161                          DAG.getNode(X86ISD::GlobalBaseReg,
7162                                      DebugLoc(), getPointerTy()),
7163                          Result);
7164   }
7165
7166   return Result;
7167 }
7168
7169 SDValue X86TargetLowering::LowerJumpTable(SDValue Op, SelectionDAG &DAG) const {
7170   JumpTableSDNode *JT = cast<JumpTableSDNode>(Op);
7171
7172   // In PIC mode (unless we're in RIPRel PIC mode) we add an offset to the
7173   // global base reg.
7174   unsigned char OpFlag = 0;
7175   unsigned WrapperKind = X86ISD::Wrapper;
7176   CodeModel::Model M = getTargetMachine().getCodeModel();
7177
7178   if (Subtarget->isPICStyleRIPRel() &&
7179       (M == CodeModel::Small || M == CodeModel::Kernel))
7180     WrapperKind = X86ISD::WrapperRIP;
7181   else if (Subtarget->isPICStyleGOT())
7182     OpFlag = X86II::MO_GOTOFF;
7183   else if (Subtarget->isPICStyleStubPIC())
7184     OpFlag = X86II::MO_PIC_BASE_OFFSET;
7185
7186   SDValue Result = DAG.getTargetJumpTable(JT->getIndex(), getPointerTy(),
7187                                           OpFlag);
7188   DebugLoc DL = JT->getDebugLoc();
7189   Result = DAG.getNode(WrapperKind, DL, getPointerTy(), Result);
7190
7191   // With PIC, the address is actually $g + Offset.
7192   if (OpFlag)
7193     Result = DAG.getNode(ISD::ADD, DL, getPointerTy(),
7194                          DAG.getNode(X86ISD::GlobalBaseReg,
7195                                      DebugLoc(), getPointerTy()),
7196                          Result);
7197
7198   return Result;
7199 }
7200
7201 SDValue
7202 X86TargetLowering::LowerExternalSymbol(SDValue Op, SelectionDAG &DAG) const {
7203   const char *Sym = cast<ExternalSymbolSDNode>(Op)->getSymbol();
7204
7205   // In PIC mode (unless we're in RIPRel PIC mode) we add an offset to the
7206   // global base reg.
7207   unsigned char OpFlag = 0;
7208   unsigned WrapperKind = X86ISD::Wrapper;
7209   CodeModel::Model M = getTargetMachine().getCodeModel();
7210
7211   if (Subtarget->isPICStyleRIPRel() &&
7212       (M == CodeModel::Small || M == CodeModel::Kernel)) {
7213     if (Subtarget->isTargetDarwin() || Subtarget->isTargetELF())
7214       OpFlag = X86II::MO_GOTPCREL;
7215     WrapperKind = X86ISD::WrapperRIP;
7216   } else if (Subtarget->isPICStyleGOT()) {
7217     OpFlag = X86II::MO_GOT;
7218   } else if (Subtarget->isPICStyleStubPIC()) {
7219     OpFlag = X86II::MO_DARWIN_NONLAZY_PIC_BASE;
7220   } else if (Subtarget->isPICStyleStubNoDynamic()) {
7221     OpFlag = X86II::MO_DARWIN_NONLAZY;
7222   }
7223
7224   SDValue Result = DAG.getTargetExternalSymbol(Sym, getPointerTy(), OpFlag);
7225
7226   DebugLoc DL = Op.getDebugLoc();
7227   Result = DAG.getNode(WrapperKind, DL, getPointerTy(), Result);
7228
7229
7230   // With PIC, the address is actually $g + Offset.
7231   if (getTargetMachine().getRelocationModel() == Reloc::PIC_ &&
7232       !Subtarget->is64Bit()) {
7233     Result = DAG.getNode(ISD::ADD, DL, getPointerTy(),
7234                          DAG.getNode(X86ISD::GlobalBaseReg,
7235                                      DebugLoc(), getPointerTy()),
7236                          Result);
7237   }
7238
7239   // For symbols that require a load from a stub to get the address, emit the
7240   // load.
7241   if (isGlobalStubReference(OpFlag))
7242     Result = DAG.getLoad(getPointerTy(), DL, DAG.getEntryNode(), Result,
7243                          MachinePointerInfo::getGOT(), false, false, false, 0);
7244
7245   return Result;
7246 }
7247
7248 SDValue
7249 X86TargetLowering::LowerBlockAddress(SDValue Op, SelectionDAG &DAG) const {
7250   // Create the TargetBlockAddressAddress node.
7251   unsigned char OpFlags =
7252     Subtarget->ClassifyBlockAddressReference();
7253   CodeModel::Model M = getTargetMachine().getCodeModel();
7254   const BlockAddress *BA = cast<BlockAddressSDNode>(Op)->getBlockAddress();
7255   DebugLoc dl = Op.getDebugLoc();
7256   SDValue Result = DAG.getBlockAddress(BA, getPointerTy(),
7257                                        /*isTarget=*/true, OpFlags);
7258
7259   if (Subtarget->isPICStyleRIPRel() &&
7260       (M == CodeModel::Small || M == CodeModel::Kernel))
7261     Result = DAG.getNode(X86ISD::WrapperRIP, dl, getPointerTy(), Result);
7262   else
7263     Result = DAG.getNode(X86ISD::Wrapper, dl, getPointerTy(), Result);
7264
7265   // With PIC, the address is actually $g + Offset.
7266   if (isGlobalRelativeToPICBase(OpFlags)) {
7267     Result = DAG.getNode(ISD::ADD, dl, getPointerTy(),
7268                          DAG.getNode(X86ISD::GlobalBaseReg, dl, getPointerTy()),
7269                          Result);
7270   }
7271
7272   return Result;
7273 }
7274
7275 SDValue
7276 X86TargetLowering::LowerGlobalAddress(const GlobalValue *GV, DebugLoc dl,
7277                                       int64_t Offset,
7278                                       SelectionDAG &DAG) const {
7279   // Create the TargetGlobalAddress node, folding in the constant
7280   // offset if it is legal.
7281   unsigned char OpFlags =
7282     Subtarget->ClassifyGlobalReference(GV, getTargetMachine());
7283   CodeModel::Model M = getTargetMachine().getCodeModel();
7284   SDValue Result;
7285   if (OpFlags == X86II::MO_NO_FLAG &&
7286       X86::isOffsetSuitableForCodeModel(Offset, M)) {
7287     // A direct static reference to a global.
7288     Result = DAG.getTargetGlobalAddress(GV, dl, getPointerTy(), Offset);
7289     Offset = 0;
7290   } else {
7291     Result = DAG.getTargetGlobalAddress(GV, dl, getPointerTy(), 0, OpFlags);
7292   }
7293
7294   if (Subtarget->isPICStyleRIPRel() &&
7295       (M == CodeModel::Small || M == CodeModel::Kernel))
7296     Result = DAG.getNode(X86ISD::WrapperRIP, dl, getPointerTy(), Result);
7297   else
7298     Result = DAG.getNode(X86ISD::Wrapper, dl, getPointerTy(), Result);
7299
7300   // With PIC, the address is actually $g + Offset.
7301   if (isGlobalRelativeToPICBase(OpFlags)) {
7302     Result = DAG.getNode(ISD::ADD, dl, getPointerTy(),
7303                          DAG.getNode(X86ISD::GlobalBaseReg, dl, getPointerTy()),
7304                          Result);
7305   }
7306
7307   // For globals that require a load from a stub to get the address, emit the
7308   // load.
7309   if (isGlobalStubReference(OpFlags))
7310     Result = DAG.getLoad(getPointerTy(), dl, DAG.getEntryNode(), Result,
7311                          MachinePointerInfo::getGOT(), false, false, false, 0);
7312
7313   // If there was a non-zero offset that we didn't fold, create an explicit
7314   // addition for it.
7315   if (Offset != 0)
7316     Result = DAG.getNode(ISD::ADD, dl, getPointerTy(), Result,
7317                          DAG.getConstant(Offset, getPointerTy()));
7318
7319   return Result;
7320 }
7321
7322 SDValue
7323 X86TargetLowering::LowerGlobalAddress(SDValue Op, SelectionDAG &DAG) const {
7324   const GlobalValue *GV = cast<GlobalAddressSDNode>(Op)->getGlobal();
7325   int64_t Offset = cast<GlobalAddressSDNode>(Op)->getOffset();
7326   return LowerGlobalAddress(GV, Op.getDebugLoc(), Offset, DAG);
7327 }
7328
7329 static SDValue
7330 GetTLSADDR(SelectionDAG &DAG, SDValue Chain, GlobalAddressSDNode *GA,
7331            SDValue *InFlag, const EVT PtrVT, unsigned ReturnReg,
7332            unsigned char OperandFlags, bool LocalDynamic = false) {
7333   MachineFrameInfo *MFI = DAG.getMachineFunction().getFrameInfo();
7334   SDVTList NodeTys = DAG.getVTList(MVT::Other, MVT::Glue);
7335   DebugLoc dl = GA->getDebugLoc();
7336   SDValue TGA = DAG.getTargetGlobalAddress(GA->getGlobal(), dl,
7337                                            GA->getValueType(0),
7338                                            GA->getOffset(),
7339                                            OperandFlags);
7340
7341   X86ISD::NodeType CallType = LocalDynamic ? X86ISD::TLSBASEADDR
7342                                            : X86ISD::TLSADDR;
7343
7344   if (InFlag) {
7345     SDValue Ops[] = { Chain,  TGA, *InFlag };
7346     Chain = DAG.getNode(CallType, dl, NodeTys, Ops, 3);
7347   } else {
7348     SDValue Ops[]  = { Chain, TGA };
7349     Chain = DAG.getNode(CallType, dl, NodeTys, Ops, 2);
7350   }
7351
7352   // TLSADDR will be codegen'ed as call. Inform MFI that function has calls.
7353   MFI->setAdjustsStack(true);
7354
7355   SDValue Flag = Chain.getValue(1);
7356   return DAG.getCopyFromReg(Chain, dl, ReturnReg, PtrVT, Flag);
7357 }
7358
7359 // Lower ISD::GlobalTLSAddress using the "general dynamic" model, 32 bit
7360 static SDValue
7361 LowerToTLSGeneralDynamicModel32(GlobalAddressSDNode *GA, SelectionDAG &DAG,
7362                                 const EVT PtrVT) {
7363   SDValue InFlag;
7364   DebugLoc dl = GA->getDebugLoc();  // ? function entry point might be better
7365   SDValue Chain = DAG.getCopyToReg(DAG.getEntryNode(), dl, X86::EBX,
7366                                      DAG.getNode(X86ISD::GlobalBaseReg,
7367                                                  DebugLoc(), PtrVT), InFlag);
7368   InFlag = Chain.getValue(1);
7369
7370   return GetTLSADDR(DAG, Chain, GA, &InFlag, PtrVT, X86::EAX, X86II::MO_TLSGD);
7371 }
7372
7373 // Lower ISD::GlobalTLSAddress using the "general dynamic" model, 64 bit
7374 static SDValue
7375 LowerToTLSGeneralDynamicModel64(GlobalAddressSDNode *GA, SelectionDAG &DAG,
7376                                 const EVT PtrVT) {
7377   return GetTLSADDR(DAG, DAG.getEntryNode(), GA, NULL, PtrVT,
7378                     X86::RAX, X86II::MO_TLSGD);
7379 }
7380
7381 static SDValue LowerToTLSLocalDynamicModel(GlobalAddressSDNode *GA,
7382                                            SelectionDAG &DAG,
7383                                            const EVT PtrVT,
7384                                            bool is64Bit) {
7385   DebugLoc dl = GA->getDebugLoc();
7386
7387   // Get the start address of the TLS block for this module.
7388   X86MachineFunctionInfo* MFI = DAG.getMachineFunction()
7389       .getInfo<X86MachineFunctionInfo>();
7390   MFI->incNumLocalDynamicTLSAccesses();
7391
7392   SDValue Base;
7393   if (is64Bit) {
7394     Base = GetTLSADDR(DAG, DAG.getEntryNode(), GA, NULL, PtrVT, X86::RAX,
7395                       X86II::MO_TLSLD, /*LocalDynamic=*/true);
7396   } else {
7397     SDValue InFlag;
7398     SDValue Chain = DAG.getCopyToReg(DAG.getEntryNode(), dl, X86::EBX,
7399         DAG.getNode(X86ISD::GlobalBaseReg, DebugLoc(), PtrVT), InFlag);
7400     InFlag = Chain.getValue(1);
7401     Base = GetTLSADDR(DAG, Chain, GA, &InFlag, PtrVT, X86::EAX,
7402                       X86II::MO_TLSLDM, /*LocalDynamic=*/true);
7403   }
7404
7405   // Note: the CleanupLocalDynamicTLSPass will remove redundant computations
7406   // of Base.
7407
7408   // Build x@dtpoff.
7409   unsigned char OperandFlags = X86II::MO_DTPOFF;
7410   unsigned WrapperKind = X86ISD::Wrapper;
7411   SDValue TGA = DAG.getTargetGlobalAddress(GA->getGlobal(), dl,
7412                                            GA->getValueType(0),
7413                                            GA->getOffset(), OperandFlags);
7414   SDValue Offset = DAG.getNode(WrapperKind, dl, PtrVT, TGA);
7415
7416   // Add x@dtpoff with the base.
7417   return DAG.getNode(ISD::ADD, dl, PtrVT, Offset, Base);
7418 }
7419
7420 // Lower ISD::GlobalTLSAddress using the "initial exec" or "local exec" model.
7421 static SDValue LowerToTLSExecModel(GlobalAddressSDNode *GA, SelectionDAG &DAG,
7422                                    const EVT PtrVT, TLSModel::Model model,
7423                                    bool is64Bit, bool isPIC) {
7424   DebugLoc dl = GA->getDebugLoc();
7425
7426   // Get the Thread Pointer, which is %gs:0 (32-bit) or %fs:0 (64-bit).
7427   Value *Ptr = Constant::getNullValue(Type::getInt8PtrTy(*DAG.getContext(),
7428                                                          is64Bit ? 257 : 256));
7429
7430   SDValue ThreadPointer = DAG.getLoad(PtrVT, dl, DAG.getEntryNode(),
7431                                       DAG.getIntPtrConstant(0),
7432                                       MachinePointerInfo(Ptr),
7433                                       false, false, false, 0);
7434
7435   unsigned char OperandFlags = 0;
7436   // Most TLS accesses are not RIP relative, even on x86-64.  One exception is
7437   // initialexec.
7438   unsigned WrapperKind = X86ISD::Wrapper;
7439   if (model == TLSModel::LocalExec) {
7440     OperandFlags = is64Bit ? X86II::MO_TPOFF : X86II::MO_NTPOFF;
7441   } else if (model == TLSModel::InitialExec) {
7442     if (is64Bit) {
7443       OperandFlags = X86II::MO_GOTTPOFF;
7444       WrapperKind = X86ISD::WrapperRIP;
7445     } else {
7446       OperandFlags = isPIC ? X86II::MO_GOTNTPOFF : X86II::MO_INDNTPOFF;
7447     }
7448   } else {
7449     llvm_unreachable("Unexpected model");
7450   }
7451
7452   // emit "addl x@ntpoff,%eax" (local exec)
7453   // or "addl x@indntpoff,%eax" (initial exec)
7454   // or "addl x@gotntpoff(%ebx) ,%eax" (initial exec, 32-bit pic)
7455   SDValue TGA = DAG.getTargetGlobalAddress(GA->getGlobal(), dl,
7456                                            GA->getValueType(0),
7457                                            GA->getOffset(), OperandFlags);
7458   SDValue Offset = DAG.getNode(WrapperKind, dl, PtrVT, TGA);
7459
7460   if (model == TLSModel::InitialExec) {
7461     if (isPIC && !is64Bit) {
7462       Offset = DAG.getNode(ISD::ADD, dl, PtrVT,
7463                           DAG.getNode(X86ISD::GlobalBaseReg, DebugLoc(), PtrVT),
7464                            Offset);
7465     }
7466
7467     Offset = DAG.getLoad(PtrVT, dl, DAG.getEntryNode(), Offset,
7468                          MachinePointerInfo::getGOT(), false, false, false,
7469                          0);
7470   }
7471
7472   // The address of the thread local variable is the add of the thread
7473   // pointer with the offset of the variable.
7474   return DAG.getNode(ISD::ADD, dl, PtrVT, ThreadPointer, Offset);
7475 }
7476
7477 SDValue
7478 X86TargetLowering::LowerGlobalTLSAddress(SDValue Op, SelectionDAG &DAG) const {
7479
7480   GlobalAddressSDNode *GA = cast<GlobalAddressSDNode>(Op);
7481   const GlobalValue *GV = GA->getGlobal();
7482
7483   if (Subtarget->isTargetELF()) {
7484     TLSModel::Model model = getTargetMachine().getTLSModel(GV);
7485
7486     switch (model) {
7487       case TLSModel::GeneralDynamic:
7488         if (Subtarget->is64Bit())
7489           return LowerToTLSGeneralDynamicModel64(GA, DAG, getPointerTy());
7490         return LowerToTLSGeneralDynamicModel32(GA, DAG, getPointerTy());
7491       case TLSModel::LocalDynamic:
7492         return LowerToTLSLocalDynamicModel(GA, DAG, getPointerTy(),
7493                                            Subtarget->is64Bit());
7494       case TLSModel::InitialExec:
7495       case TLSModel::LocalExec:
7496         return LowerToTLSExecModel(GA, DAG, getPointerTy(), model,
7497                                    Subtarget->is64Bit(),
7498                          getTargetMachine().getRelocationModel() == Reloc::PIC_);
7499     }
7500     llvm_unreachable("Unknown TLS model.");
7501   }
7502
7503   if (Subtarget->isTargetDarwin()) {
7504     // Darwin only has one model of TLS.  Lower to that.
7505     unsigned char OpFlag = 0;
7506     unsigned WrapperKind = Subtarget->isPICStyleRIPRel() ?
7507                            X86ISD::WrapperRIP : X86ISD::Wrapper;
7508
7509     // In PIC mode (unless we're in RIPRel PIC mode) we add an offset to the
7510     // global base reg.
7511     bool PIC32 = (getTargetMachine().getRelocationModel() == Reloc::PIC_) &&
7512                   !Subtarget->is64Bit();
7513     if (PIC32)
7514       OpFlag = X86II::MO_TLVP_PIC_BASE;
7515     else
7516       OpFlag = X86II::MO_TLVP;
7517     DebugLoc DL = Op.getDebugLoc();
7518     SDValue Result = DAG.getTargetGlobalAddress(GA->getGlobal(), DL,
7519                                                 GA->getValueType(0),
7520                                                 GA->getOffset(), OpFlag);
7521     SDValue Offset = DAG.getNode(WrapperKind, DL, getPointerTy(), Result);
7522
7523     // With PIC32, the address is actually $g + Offset.
7524     if (PIC32)
7525       Offset = DAG.getNode(ISD::ADD, DL, getPointerTy(),
7526                            DAG.getNode(X86ISD::GlobalBaseReg,
7527                                        DebugLoc(), getPointerTy()),
7528                            Offset);
7529
7530     // Lowering the machine isd will make sure everything is in the right
7531     // location.
7532     SDValue Chain = DAG.getEntryNode();
7533     SDVTList NodeTys = DAG.getVTList(MVT::Other, MVT::Glue);
7534     SDValue Args[] = { Chain, Offset };
7535     Chain = DAG.getNode(X86ISD::TLSCALL, DL, NodeTys, Args, 2);
7536
7537     // TLSCALL will be codegen'ed as call. Inform MFI that function has calls.
7538     MachineFrameInfo *MFI = DAG.getMachineFunction().getFrameInfo();
7539     MFI->setAdjustsStack(true);
7540
7541     // And our return value (tls address) is in the standard call return value
7542     // location.
7543     unsigned Reg = Subtarget->is64Bit() ? X86::RAX : X86::EAX;
7544     return DAG.getCopyFromReg(Chain, DL, Reg, getPointerTy(),
7545                               Chain.getValue(1));
7546   }
7547
7548   if (Subtarget->isTargetWindows()) {
7549     // Just use the implicit TLS architecture
7550     // Need to generate someting similar to:
7551     //   mov     rdx, qword [gs:abs 58H]; Load pointer to ThreadLocalStorage
7552     //                                  ; from TEB
7553     //   mov     ecx, dword [rel _tls_index]: Load index (from C runtime)
7554     //   mov     rcx, qword [rdx+rcx*8]
7555     //   mov     eax, .tls$:tlsvar
7556     //   [rax+rcx] contains the address
7557     // Windows 64bit: gs:0x58
7558     // Windows 32bit: fs:__tls_array
7559
7560     // If GV is an alias then use the aliasee for determining
7561     // thread-localness.
7562     if (const GlobalAlias *GA = dyn_cast<GlobalAlias>(GV))
7563       GV = GA->resolveAliasedGlobal(false);
7564     DebugLoc dl = GA->getDebugLoc();
7565     SDValue Chain = DAG.getEntryNode();
7566
7567     // Get the Thread Pointer, which is %fs:__tls_array (32-bit) or
7568     // %gs:0x58 (64-bit).
7569     Value *Ptr = Constant::getNullValue(Subtarget->is64Bit()
7570                                         ? Type::getInt8PtrTy(*DAG.getContext(),
7571                                                              256)
7572                                         : Type::getInt32PtrTy(*DAG.getContext(),
7573                                                               257));
7574
7575     SDValue ThreadPointer = DAG.getLoad(getPointerTy(), dl, Chain,
7576                                         Subtarget->is64Bit()
7577                                         ? DAG.getIntPtrConstant(0x58)
7578                                         : DAG.getExternalSymbol("_tls_array",
7579                                                                 getPointerTy()),
7580                                         MachinePointerInfo(Ptr),
7581                                         false, false, false, 0);
7582
7583     // Load the _tls_index variable
7584     SDValue IDX = DAG.getExternalSymbol("_tls_index", getPointerTy());
7585     if (Subtarget->is64Bit())
7586       IDX = DAG.getExtLoad(ISD::ZEXTLOAD, dl, getPointerTy(), Chain,
7587                            IDX, MachinePointerInfo(), MVT::i32,
7588                            false, false, 0);
7589     else
7590       IDX = DAG.getLoad(getPointerTy(), dl, Chain, IDX, MachinePointerInfo(),
7591                         false, false, false, 0);
7592
7593     SDValue Scale = DAG.getConstant(Log2_64_Ceil(TD->getPointerSize()),
7594                                     getPointerTy());
7595     IDX = DAG.getNode(ISD::SHL, dl, getPointerTy(), IDX, Scale);
7596
7597     SDValue res = DAG.getNode(ISD::ADD, dl, getPointerTy(), ThreadPointer, IDX);
7598     res = DAG.getLoad(getPointerTy(), dl, Chain, res, MachinePointerInfo(),
7599                       false, false, false, 0);
7600
7601     // Get the offset of start of .tls section
7602     SDValue TGA = DAG.getTargetGlobalAddress(GA->getGlobal(), dl,
7603                                              GA->getValueType(0),
7604                                              GA->getOffset(), X86II::MO_SECREL);
7605     SDValue Offset = DAG.getNode(X86ISD::Wrapper, dl, getPointerTy(), TGA);
7606
7607     // The address of the thread local variable is the add of the thread
7608     // pointer with the offset of the variable.
7609     return DAG.getNode(ISD::ADD, dl, getPointerTy(), res, Offset);
7610   }
7611
7612   llvm_unreachable("TLS not implemented for this target.");
7613 }
7614
7615
7616 /// LowerShiftParts - Lower SRA_PARTS and friends, which return two i32 values
7617 /// and take a 2 x i32 value to shift plus a shift amount.
7618 SDValue X86TargetLowering::LowerShiftParts(SDValue Op, SelectionDAG &DAG) const{
7619   assert(Op.getNumOperands() == 3 && "Not a double-shift!");
7620   EVT VT = Op.getValueType();
7621   unsigned VTBits = VT.getSizeInBits();
7622   DebugLoc dl = Op.getDebugLoc();
7623   bool isSRA = Op.getOpcode() == ISD::SRA_PARTS;
7624   SDValue ShOpLo = Op.getOperand(0);
7625   SDValue ShOpHi = Op.getOperand(1);
7626   SDValue ShAmt  = Op.getOperand(2);
7627   SDValue Tmp1 = isSRA ? DAG.getNode(ISD::SRA, dl, VT, ShOpHi,
7628                                      DAG.getConstant(VTBits - 1, MVT::i8))
7629                        : DAG.getConstant(0, VT);
7630
7631   SDValue Tmp2, Tmp3;
7632   if (Op.getOpcode() == ISD::SHL_PARTS) {
7633     Tmp2 = DAG.getNode(X86ISD::SHLD, dl, VT, ShOpHi, ShOpLo, ShAmt);
7634     Tmp3 = DAG.getNode(ISD::SHL, dl, VT, ShOpLo, ShAmt);
7635   } else {
7636     Tmp2 = DAG.getNode(X86ISD::SHRD, dl, VT, ShOpLo, ShOpHi, ShAmt);
7637     Tmp3 = DAG.getNode(isSRA ? ISD::SRA : ISD::SRL, dl, VT, ShOpHi, ShAmt);
7638   }
7639
7640   SDValue AndNode = DAG.getNode(ISD::AND, dl, MVT::i8, ShAmt,
7641                                 DAG.getConstant(VTBits, MVT::i8));
7642   SDValue Cond = DAG.getNode(X86ISD::CMP, dl, MVT::i32,
7643                              AndNode, DAG.getConstant(0, MVT::i8));
7644
7645   SDValue Hi, Lo;
7646   SDValue CC = DAG.getConstant(X86::COND_NE, MVT::i8);
7647   SDValue Ops0[4] = { Tmp2, Tmp3, CC, Cond };
7648   SDValue Ops1[4] = { Tmp3, Tmp1, CC, Cond };
7649
7650   if (Op.getOpcode() == ISD::SHL_PARTS) {
7651     Hi = DAG.getNode(X86ISD::CMOV, dl, VT, Ops0, 4);
7652     Lo = DAG.getNode(X86ISD::CMOV, dl, VT, Ops1, 4);
7653   } else {
7654     Lo = DAG.getNode(X86ISD::CMOV, dl, VT, Ops0, 4);
7655     Hi = DAG.getNode(X86ISD::CMOV, dl, VT, Ops1, 4);
7656   }
7657
7658   SDValue Ops[2] = { Lo, Hi };
7659   return DAG.getMergeValues(Ops, 2, dl);
7660 }
7661
7662 SDValue X86TargetLowering::LowerSINT_TO_FP(SDValue Op,
7663                                            SelectionDAG &DAG) const {
7664   EVT SrcVT = Op.getOperand(0).getValueType();
7665
7666   if (SrcVT.isVector())
7667     return SDValue();
7668
7669   assert(SrcVT.getSimpleVT() <= MVT::i64 && SrcVT.getSimpleVT() >= MVT::i16 &&
7670          "Unknown SINT_TO_FP to lower!");
7671
7672   // These are really Legal; return the operand so the caller accepts it as
7673   // Legal.
7674   if (SrcVT == MVT::i32 && isScalarFPTypeInSSEReg(Op.getValueType()))
7675     return Op;
7676   if (SrcVT == MVT::i64 && isScalarFPTypeInSSEReg(Op.getValueType()) &&
7677       Subtarget->is64Bit()) {
7678     return Op;
7679   }
7680
7681   DebugLoc dl = Op.getDebugLoc();
7682   unsigned Size = SrcVT.getSizeInBits()/8;
7683   MachineFunction &MF = DAG.getMachineFunction();
7684   int SSFI = MF.getFrameInfo()->CreateStackObject(Size, Size, false);
7685   SDValue StackSlot = DAG.getFrameIndex(SSFI, getPointerTy());
7686   SDValue Chain = DAG.getStore(DAG.getEntryNode(), dl, Op.getOperand(0),
7687                                StackSlot,
7688                                MachinePointerInfo::getFixedStack(SSFI),
7689                                false, false, 0);
7690   return BuildFILD(Op, SrcVT, Chain, StackSlot, DAG);
7691 }
7692
7693 SDValue X86TargetLowering::BuildFILD(SDValue Op, EVT SrcVT, SDValue Chain,
7694                                      SDValue StackSlot,
7695                                      SelectionDAG &DAG) const {
7696   // Build the FILD
7697   DebugLoc DL = Op.getDebugLoc();
7698   SDVTList Tys;
7699   bool useSSE = isScalarFPTypeInSSEReg(Op.getValueType());
7700   if (useSSE)
7701     Tys = DAG.getVTList(MVT::f64, MVT::Other, MVT::Glue);
7702   else
7703     Tys = DAG.getVTList(Op.getValueType(), MVT::Other);
7704
7705   unsigned ByteSize = SrcVT.getSizeInBits()/8;
7706
7707   FrameIndexSDNode *FI = dyn_cast<FrameIndexSDNode>(StackSlot);
7708   MachineMemOperand *MMO;
7709   if (FI) {
7710     int SSFI = FI->getIndex();
7711     MMO =
7712       DAG.getMachineFunction()
7713       .getMachineMemOperand(MachinePointerInfo::getFixedStack(SSFI),
7714                             MachineMemOperand::MOLoad, ByteSize, ByteSize);
7715   } else {
7716     MMO = cast<LoadSDNode>(StackSlot)->getMemOperand();
7717     StackSlot = StackSlot.getOperand(1);
7718   }
7719   SDValue Ops[] = { Chain, StackSlot, DAG.getValueType(SrcVT) };
7720   SDValue Result = DAG.getMemIntrinsicNode(useSSE ? X86ISD::FILD_FLAG :
7721                                            X86ISD::FILD, DL,
7722                                            Tys, Ops, array_lengthof(Ops),
7723                                            SrcVT, MMO);
7724
7725   if (useSSE) {
7726     Chain = Result.getValue(1);
7727     SDValue InFlag = Result.getValue(2);
7728
7729     // FIXME: Currently the FST is flagged to the FILD_FLAG. This
7730     // shouldn't be necessary except that RFP cannot be live across
7731     // multiple blocks. When stackifier is fixed, they can be uncoupled.
7732     MachineFunction &MF = DAG.getMachineFunction();
7733     unsigned SSFISize = Op.getValueType().getSizeInBits()/8;
7734     int SSFI = MF.getFrameInfo()->CreateStackObject(SSFISize, SSFISize, false);
7735     SDValue StackSlot = DAG.getFrameIndex(SSFI, getPointerTy());
7736     Tys = DAG.getVTList(MVT::Other);
7737     SDValue Ops[] = {
7738       Chain, Result, StackSlot, DAG.getValueType(Op.getValueType()), InFlag
7739     };
7740     MachineMemOperand *MMO =
7741       DAG.getMachineFunction()
7742       .getMachineMemOperand(MachinePointerInfo::getFixedStack(SSFI),
7743                             MachineMemOperand::MOStore, SSFISize, SSFISize);
7744
7745     Chain = DAG.getMemIntrinsicNode(X86ISD::FST, DL, Tys,
7746                                     Ops, array_lengthof(Ops),
7747                                     Op.getValueType(), MMO);
7748     Result = DAG.getLoad(Op.getValueType(), DL, Chain, StackSlot,
7749                          MachinePointerInfo::getFixedStack(SSFI),
7750                          false, false, false, 0);
7751   }
7752
7753   return Result;
7754 }
7755
7756 // LowerUINT_TO_FP_i64 - 64-bit unsigned integer to double expansion.
7757 SDValue X86TargetLowering::LowerUINT_TO_FP_i64(SDValue Op,
7758                                                SelectionDAG &DAG) const {
7759   // This algorithm is not obvious. Here it is what we're trying to output:
7760   /*
7761      movq       %rax,  %xmm0
7762      punpckldq  (c0),  %xmm0  // c0: (uint4){ 0x43300000U, 0x45300000U, 0U, 0U }
7763      subpd      (c1),  %xmm0  // c1: (double2){ 0x1.0p52, 0x1.0p52 * 0x1.0p32 }
7764      #ifdef __SSE3__
7765        haddpd   %xmm0, %xmm0
7766      #else
7767        pshufd   $0x4e, %xmm0, %xmm1
7768        addpd    %xmm1, %xmm0
7769      #endif
7770   */
7771
7772   DebugLoc dl = Op.getDebugLoc();
7773   LLVMContext *Context = DAG.getContext();
7774
7775   // Build some magic constants.
7776   const uint32_t CV0[] = { 0x43300000, 0x45300000, 0, 0 };
7777   Constant *C0 = ConstantDataVector::get(*Context, CV0);
7778   SDValue CPIdx0 = DAG.getConstantPool(C0, getPointerTy(), 16);
7779
7780   SmallVector<Constant*,2> CV1;
7781   CV1.push_back(
7782         ConstantFP::get(*Context, APFloat(APInt(64, 0x4330000000000000ULL))));
7783   CV1.push_back(
7784         ConstantFP::get(*Context, APFloat(APInt(64, 0x4530000000000000ULL))));
7785   Constant *C1 = ConstantVector::get(CV1);
7786   SDValue CPIdx1 = DAG.getConstantPool(C1, getPointerTy(), 16);
7787
7788   // Load the 64-bit value into an XMM register.
7789   SDValue XR1 = DAG.getNode(ISD::SCALAR_TO_VECTOR, dl, MVT::v2i64,
7790                             Op.getOperand(0));
7791   SDValue CLod0 = DAG.getLoad(MVT::v4i32, dl, DAG.getEntryNode(), CPIdx0,
7792                               MachinePointerInfo::getConstantPool(),
7793                               false, false, false, 16);
7794   SDValue Unpck1 = getUnpackl(DAG, dl, MVT::v4i32,
7795                               DAG.getNode(ISD::BITCAST, dl, MVT::v4i32, XR1),
7796                               CLod0);
7797
7798   SDValue CLod1 = DAG.getLoad(MVT::v2f64, dl, CLod0.getValue(1), CPIdx1,
7799                               MachinePointerInfo::getConstantPool(),
7800                               false, false, false, 16);
7801   SDValue XR2F = DAG.getNode(ISD::BITCAST, dl, MVT::v2f64, Unpck1);
7802   SDValue Sub = DAG.getNode(ISD::FSUB, dl, MVT::v2f64, XR2F, CLod1);
7803   SDValue Result;
7804
7805   if (Subtarget->hasSSE3()) {
7806     // FIXME: The 'haddpd' instruction may be slower than 'movhlps + addsd'.
7807     Result = DAG.getNode(X86ISD::FHADD, dl, MVT::v2f64, Sub, Sub);
7808   } else {
7809     SDValue S2F = DAG.getNode(ISD::BITCAST, dl, MVT::v4i32, Sub);
7810     SDValue Shuffle = getTargetShuffleNode(X86ISD::PSHUFD, dl, MVT::v4i32,
7811                                            S2F, 0x4E, DAG);
7812     Result = DAG.getNode(ISD::FADD, dl, MVT::v2f64,
7813                          DAG.getNode(ISD::BITCAST, dl, MVT::v2f64, Shuffle),
7814                          Sub);
7815   }
7816
7817   return DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, MVT::f64, Result,
7818                      DAG.getIntPtrConstant(0));
7819 }
7820
7821 // LowerUINT_TO_FP_i32 - 32-bit unsigned integer to float expansion.
7822 SDValue X86TargetLowering::LowerUINT_TO_FP_i32(SDValue Op,
7823                                                SelectionDAG &DAG) const {
7824   DebugLoc dl = Op.getDebugLoc();
7825   // FP constant to bias correct the final result.
7826   SDValue Bias = DAG.getConstantFP(BitsToDouble(0x4330000000000000ULL),
7827                                    MVT::f64);
7828
7829   // Load the 32-bit value into an XMM register.
7830   SDValue Load = DAG.getNode(ISD::SCALAR_TO_VECTOR, dl, MVT::v4i32,
7831                              Op.getOperand(0));
7832
7833   // Zero out the upper parts of the register.
7834   Load = getShuffleVectorZeroOrUndef(Load, 0, true, Subtarget, DAG);
7835
7836   Load = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, MVT::f64,
7837                      DAG.getNode(ISD::BITCAST, dl, MVT::v2f64, Load),
7838                      DAG.getIntPtrConstant(0));
7839
7840   // Or the load with the bias.
7841   SDValue Or = DAG.getNode(ISD::OR, dl, MVT::v2i64,
7842                            DAG.getNode(ISD::BITCAST, dl, MVT::v2i64,
7843                                        DAG.getNode(ISD::SCALAR_TO_VECTOR, dl,
7844                                                    MVT::v2f64, Load)),
7845                            DAG.getNode(ISD::BITCAST, dl, MVT::v2i64,
7846                                        DAG.getNode(ISD::SCALAR_TO_VECTOR, dl,
7847                                                    MVT::v2f64, Bias)));
7848   Or = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, MVT::f64,
7849                    DAG.getNode(ISD::BITCAST, dl, MVT::v2f64, Or),
7850                    DAG.getIntPtrConstant(0));
7851
7852   // Subtract the bias.
7853   SDValue Sub = DAG.getNode(ISD::FSUB, dl, MVT::f64, Or, Bias);
7854
7855   // Handle final rounding.
7856   EVT DestVT = Op.getValueType();
7857
7858   if (DestVT.bitsLT(MVT::f64))
7859     return DAG.getNode(ISD::FP_ROUND, dl, DestVT, Sub,
7860                        DAG.getIntPtrConstant(0));
7861   if (DestVT.bitsGT(MVT::f64))
7862     return DAG.getNode(ISD::FP_EXTEND, dl, DestVT, Sub);
7863
7864   // Handle final rounding.
7865   return Sub;
7866 }
7867
7868 SDValue X86TargetLowering::LowerUINT_TO_FP(SDValue Op,
7869                                            SelectionDAG &DAG) const {
7870   SDValue N0 = Op.getOperand(0);
7871   DebugLoc dl = Op.getDebugLoc();
7872
7873   // Since UINT_TO_FP is legal (it's marked custom), dag combiner won't
7874   // optimize it to a SINT_TO_FP when the sign bit is known zero. Perform
7875   // the optimization here.
7876   if (DAG.SignBitIsZero(N0))
7877     return DAG.getNode(ISD::SINT_TO_FP, dl, Op.getValueType(), N0);
7878
7879   EVT SrcVT = N0.getValueType();
7880   EVT DstVT = Op.getValueType();
7881   if (SrcVT == MVT::i64 && DstVT == MVT::f64 && X86ScalarSSEf64)
7882     return LowerUINT_TO_FP_i64(Op, DAG);
7883   if (SrcVT == MVT::i32 && X86ScalarSSEf64)
7884     return LowerUINT_TO_FP_i32(Op, DAG);
7885   if (Subtarget->is64Bit() && SrcVT == MVT::i64 && DstVT == MVT::f32)
7886     return SDValue();
7887
7888   // Make a 64-bit buffer, and use it to build an FILD.
7889   SDValue StackSlot = DAG.CreateStackTemporary(MVT::i64);
7890   if (SrcVT == MVT::i32) {
7891     SDValue WordOff = DAG.getConstant(4, getPointerTy());
7892     SDValue OffsetSlot = DAG.getNode(ISD::ADD, dl,
7893                                      getPointerTy(), StackSlot, WordOff);
7894     SDValue Store1 = DAG.getStore(DAG.getEntryNode(), dl, Op.getOperand(0),
7895                                   StackSlot, MachinePointerInfo(),
7896                                   false, false, 0);
7897     SDValue Store2 = DAG.getStore(Store1, dl, DAG.getConstant(0, MVT::i32),
7898                                   OffsetSlot, MachinePointerInfo(),
7899                                   false, false, 0);
7900     SDValue Fild = BuildFILD(Op, MVT::i64, Store2, StackSlot, DAG);
7901     return Fild;
7902   }
7903
7904   assert(SrcVT == MVT::i64 && "Unexpected type in UINT_TO_FP");
7905   SDValue Store = DAG.getStore(DAG.getEntryNode(), dl, Op.getOperand(0),
7906                                StackSlot, MachinePointerInfo(),
7907                                false, false, 0);
7908   // For i64 source, we need to add the appropriate power of 2 if the input
7909   // was negative.  This is the same as the optimization in
7910   // DAGTypeLegalizer::ExpandIntOp_UNIT_TO_FP, and for it to be safe here,
7911   // we must be careful to do the computation in x87 extended precision, not
7912   // in SSE. (The generic code can't know it's OK to do this, or how to.)
7913   int SSFI = cast<FrameIndexSDNode>(StackSlot)->getIndex();
7914   MachineMemOperand *MMO =
7915     DAG.getMachineFunction()
7916     .getMachineMemOperand(MachinePointerInfo::getFixedStack(SSFI),
7917                           MachineMemOperand::MOLoad, 8, 8);
7918
7919   SDVTList Tys = DAG.getVTList(MVT::f80, MVT::Other);
7920   SDValue Ops[] = { Store, StackSlot, DAG.getValueType(MVT::i64) };
7921   SDValue Fild = DAG.getMemIntrinsicNode(X86ISD::FILD, dl, Tys, Ops, 3,
7922                                          MVT::i64, MMO);
7923
7924   APInt FF(32, 0x5F800000ULL);
7925
7926   // Check whether the sign bit is set.
7927   SDValue SignSet = DAG.getSetCC(dl, getSetCCResultType(MVT::i64),
7928                                  Op.getOperand(0), DAG.getConstant(0, MVT::i64),
7929                                  ISD::SETLT);
7930
7931   // Build a 64 bit pair (0, FF) in the constant pool, with FF in the lo bits.
7932   SDValue FudgePtr = DAG.getConstantPool(
7933                              ConstantInt::get(*DAG.getContext(), FF.zext(64)),
7934                                          getPointerTy());
7935
7936   // Get a pointer to FF if the sign bit was set, or to 0 otherwise.
7937   SDValue Zero = DAG.getIntPtrConstant(0);
7938   SDValue Four = DAG.getIntPtrConstant(4);
7939   SDValue Offset = DAG.getNode(ISD::SELECT, dl, Zero.getValueType(), SignSet,
7940                                Zero, Four);
7941   FudgePtr = DAG.getNode(ISD::ADD, dl, getPointerTy(), FudgePtr, Offset);
7942
7943   // Load the value out, extending it from f32 to f80.
7944   // FIXME: Avoid the extend by constructing the right constant pool?
7945   SDValue Fudge = DAG.getExtLoad(ISD::EXTLOAD, dl, MVT::f80, DAG.getEntryNode(),
7946                                  FudgePtr, MachinePointerInfo::getConstantPool(),
7947                                  MVT::f32, false, false, 4);
7948   // Extend everything to 80 bits to force it to be done on x87.
7949   SDValue Add = DAG.getNode(ISD::FADD, dl, MVT::f80, Fild, Fudge);
7950   return DAG.getNode(ISD::FP_ROUND, dl, DstVT, Add, DAG.getIntPtrConstant(0));
7951 }
7952
7953 std::pair<SDValue,SDValue> X86TargetLowering::
7954 FP_TO_INTHelper(SDValue Op, SelectionDAG &DAG, bool IsSigned, bool IsReplace) const {
7955   DebugLoc DL = Op.getDebugLoc();
7956
7957   EVT DstTy = Op.getValueType();
7958
7959   if (!IsSigned && !isIntegerTypeFTOL(DstTy)) {
7960     assert(DstTy == MVT::i32 && "Unexpected FP_TO_UINT");
7961     DstTy = MVT::i64;
7962   }
7963
7964   assert(DstTy.getSimpleVT() <= MVT::i64 &&
7965          DstTy.getSimpleVT() >= MVT::i16 &&
7966          "Unknown FP_TO_INT to lower!");
7967
7968   // These are really Legal.
7969   if (DstTy == MVT::i32 &&
7970       isScalarFPTypeInSSEReg(Op.getOperand(0).getValueType()))
7971     return std::make_pair(SDValue(), SDValue());
7972   if (Subtarget->is64Bit() &&
7973       DstTy == MVT::i64 &&
7974       isScalarFPTypeInSSEReg(Op.getOperand(0).getValueType()))
7975     return std::make_pair(SDValue(), SDValue());
7976
7977   // We lower FP->int64 either into FISTP64 followed by a load from a temporary
7978   // stack slot, or into the FTOL runtime function.
7979   MachineFunction &MF = DAG.getMachineFunction();
7980   unsigned MemSize = DstTy.getSizeInBits()/8;
7981   int SSFI = MF.getFrameInfo()->CreateStackObject(MemSize, MemSize, false);
7982   SDValue StackSlot = DAG.getFrameIndex(SSFI, getPointerTy());
7983
7984   unsigned Opc;
7985   if (!IsSigned && isIntegerTypeFTOL(DstTy))
7986     Opc = X86ISD::WIN_FTOL;
7987   else
7988     switch (DstTy.getSimpleVT().SimpleTy) {
7989     default: llvm_unreachable("Invalid FP_TO_SINT to lower!");
7990     case MVT::i16: Opc = X86ISD::FP_TO_INT16_IN_MEM; break;
7991     case MVT::i32: Opc = X86ISD::FP_TO_INT32_IN_MEM; break;
7992     case MVT::i64: Opc = X86ISD::FP_TO_INT64_IN_MEM; break;
7993     }
7994
7995   SDValue Chain = DAG.getEntryNode();
7996   SDValue Value = Op.getOperand(0);
7997   EVT TheVT = Op.getOperand(0).getValueType();
7998   // FIXME This causes a redundant load/store if the SSE-class value is already
7999   // in memory, such as if it is on the callstack.
8000   if (isScalarFPTypeInSSEReg(TheVT)) {
8001     assert(DstTy == MVT::i64 && "Invalid FP_TO_SINT to lower!");
8002     Chain = DAG.getStore(Chain, DL, Value, StackSlot,
8003                          MachinePointerInfo::getFixedStack(SSFI),
8004                          false, false, 0);
8005     SDVTList Tys = DAG.getVTList(Op.getOperand(0).getValueType(), MVT::Other);
8006     SDValue Ops[] = {
8007       Chain, StackSlot, DAG.getValueType(TheVT)
8008     };
8009
8010     MachineMemOperand *MMO =
8011       MF.getMachineMemOperand(MachinePointerInfo::getFixedStack(SSFI),
8012                               MachineMemOperand::MOLoad, MemSize, MemSize);
8013     Value = DAG.getMemIntrinsicNode(X86ISD::FLD, DL, Tys, Ops, 3,
8014                                     DstTy, MMO);
8015     Chain = Value.getValue(1);
8016     SSFI = MF.getFrameInfo()->CreateStackObject(MemSize, MemSize, false);
8017     StackSlot = DAG.getFrameIndex(SSFI, getPointerTy());
8018   }
8019
8020   MachineMemOperand *MMO =
8021     MF.getMachineMemOperand(MachinePointerInfo::getFixedStack(SSFI),
8022                             MachineMemOperand::MOStore, MemSize, MemSize);
8023
8024   if (Opc != X86ISD::WIN_FTOL) {
8025     // Build the FP_TO_INT*_IN_MEM
8026     SDValue Ops[] = { Chain, Value, StackSlot };
8027     SDValue FIST = DAG.getMemIntrinsicNode(Opc, DL, DAG.getVTList(MVT::Other),
8028                                            Ops, 3, DstTy, MMO);
8029     return std::make_pair(FIST, StackSlot);
8030   } else {
8031     SDValue ftol = DAG.getNode(X86ISD::WIN_FTOL, DL,
8032       DAG.getVTList(MVT::Other, MVT::Glue),
8033       Chain, Value);
8034     SDValue eax = DAG.getCopyFromReg(ftol, DL, X86::EAX,
8035       MVT::i32, ftol.getValue(1));
8036     SDValue edx = DAG.getCopyFromReg(eax.getValue(1), DL, X86::EDX,
8037       MVT::i32, eax.getValue(2));
8038     SDValue Ops[] = { eax, edx };
8039     SDValue pair = IsReplace
8040       ? DAG.getNode(ISD::BUILD_PAIR, DL, MVT::i64, Ops, 2)
8041       : DAG.getMergeValues(Ops, 2, DL);
8042     return std::make_pair(pair, SDValue());
8043   }
8044 }
8045
8046 SDValue X86TargetLowering::LowerFP_TO_SINT(SDValue Op,
8047                                            SelectionDAG &DAG) const {
8048   if (Op.getValueType().isVector())
8049     return SDValue();
8050
8051   std::pair<SDValue,SDValue> Vals = FP_TO_INTHelper(Op, DAG,
8052     /*IsSigned=*/ true, /*IsReplace=*/ false);
8053   SDValue FIST = Vals.first, StackSlot = Vals.second;
8054   // If FP_TO_INTHelper failed, the node is actually supposed to be Legal.
8055   if (FIST.getNode() == 0) return Op;
8056
8057   if (StackSlot.getNode())
8058     // Load the result.
8059     return DAG.getLoad(Op.getValueType(), Op.getDebugLoc(),
8060                        FIST, StackSlot, MachinePointerInfo(),
8061                        false, false, false, 0);
8062
8063   // The node is the result.
8064   return FIST;
8065 }
8066
8067 SDValue X86TargetLowering::LowerFP_TO_UINT(SDValue Op,
8068                                            SelectionDAG &DAG) const {
8069   std::pair<SDValue,SDValue> Vals = FP_TO_INTHelper(Op, DAG,
8070     /*IsSigned=*/ false, /*IsReplace=*/ false);
8071   SDValue FIST = Vals.first, StackSlot = Vals.second;
8072   assert(FIST.getNode() && "Unexpected failure");
8073
8074   if (StackSlot.getNode())
8075     // Load the result.
8076     return DAG.getLoad(Op.getValueType(), Op.getDebugLoc(),
8077                        FIST, StackSlot, MachinePointerInfo(),
8078                        false, false, false, 0);
8079
8080   // The node is the result.
8081   return FIST;
8082 }
8083
8084 SDValue X86TargetLowering::LowerFABS(SDValue Op,
8085                                      SelectionDAG &DAG) const {
8086   LLVMContext *Context = DAG.getContext();
8087   DebugLoc dl = Op.getDebugLoc();
8088   EVT VT = Op.getValueType();
8089   EVT EltVT = VT;
8090   if (VT.isVector())
8091     EltVT = VT.getVectorElementType();
8092   Constant *C;
8093   if (EltVT == MVT::f64) {
8094     C = ConstantVector::getSplat(2,
8095                 ConstantFP::get(*Context, APFloat(APInt(64, ~(1ULL << 63)))));
8096   } else {
8097     C = ConstantVector::getSplat(4,
8098                ConstantFP::get(*Context, APFloat(APInt(32, ~(1U << 31)))));
8099   }
8100   SDValue CPIdx = DAG.getConstantPool(C, getPointerTy(), 16);
8101   SDValue Mask = DAG.getLoad(VT, dl, DAG.getEntryNode(), CPIdx,
8102                              MachinePointerInfo::getConstantPool(),
8103                              false, false, false, 16);
8104   return DAG.getNode(X86ISD::FAND, dl, VT, Op.getOperand(0), Mask);
8105 }
8106
8107 SDValue X86TargetLowering::LowerFNEG(SDValue Op, SelectionDAG &DAG) const {
8108   LLVMContext *Context = DAG.getContext();
8109   DebugLoc dl = Op.getDebugLoc();
8110   EVT VT = Op.getValueType();
8111   EVT EltVT = VT;
8112   unsigned NumElts = VT == MVT::f64 ? 2 : 4;
8113   if (VT.isVector()) {
8114     EltVT = VT.getVectorElementType();
8115     NumElts = VT.getVectorNumElements();
8116   }
8117   Constant *C;
8118   if (EltVT == MVT::f64)
8119     C = ConstantFP::get(*Context, APFloat(APInt(64, 1ULL << 63)));
8120   else
8121     C = ConstantFP::get(*Context, APFloat(APInt(32, 1U << 31)));
8122   C = ConstantVector::getSplat(NumElts, C);
8123   SDValue CPIdx = DAG.getConstantPool(C, getPointerTy(), 16);
8124   SDValue Mask = DAG.getLoad(VT, dl, DAG.getEntryNode(), CPIdx,
8125                              MachinePointerInfo::getConstantPool(),
8126                              false, false, false, 16);
8127   if (VT.isVector()) {
8128     MVT XORVT = VT.getSizeInBits() == 128 ? MVT::v2i64 : MVT::v4i64;
8129     return DAG.getNode(ISD::BITCAST, dl, VT,
8130                        DAG.getNode(ISD::XOR, dl, XORVT,
8131                                    DAG.getNode(ISD::BITCAST, dl, XORVT,
8132                                                Op.getOperand(0)),
8133                                    DAG.getNode(ISD::BITCAST, dl, XORVT, Mask)));
8134   }
8135
8136   return DAG.getNode(X86ISD::FXOR, dl, VT, Op.getOperand(0), Mask);
8137 }
8138
8139 SDValue X86TargetLowering::LowerFCOPYSIGN(SDValue Op, SelectionDAG &DAG) const {
8140   LLVMContext *Context = DAG.getContext();
8141   SDValue Op0 = Op.getOperand(0);
8142   SDValue Op1 = Op.getOperand(1);
8143   DebugLoc dl = Op.getDebugLoc();
8144   EVT VT = Op.getValueType();
8145   EVT SrcVT = Op1.getValueType();
8146
8147   // If second operand is smaller, extend it first.
8148   if (SrcVT.bitsLT(VT)) {
8149     Op1 = DAG.getNode(ISD::FP_EXTEND, dl, VT, Op1);
8150     SrcVT = VT;
8151   }
8152   // And if it is bigger, shrink it first.
8153   if (SrcVT.bitsGT(VT)) {
8154     Op1 = DAG.getNode(ISD::FP_ROUND, dl, VT, Op1, DAG.getIntPtrConstant(1));
8155     SrcVT = VT;
8156   }
8157
8158   // At this point the operands and the result should have the same
8159   // type, and that won't be f80 since that is not custom lowered.
8160
8161   // First get the sign bit of second operand.
8162   SmallVector<Constant*,4> CV;
8163   if (SrcVT == MVT::f64) {
8164     CV.push_back(ConstantFP::get(*Context, APFloat(APInt(64, 1ULL << 63))));
8165     CV.push_back(ConstantFP::get(*Context, APFloat(APInt(64, 0))));
8166   } else {
8167     CV.push_back(ConstantFP::get(*Context, APFloat(APInt(32, 1U << 31))));
8168     CV.push_back(ConstantFP::get(*Context, APFloat(APInt(32, 0))));
8169     CV.push_back(ConstantFP::get(*Context, APFloat(APInt(32, 0))));
8170     CV.push_back(ConstantFP::get(*Context, APFloat(APInt(32, 0))));
8171   }
8172   Constant *C = ConstantVector::get(CV);
8173   SDValue CPIdx = DAG.getConstantPool(C, getPointerTy(), 16);
8174   SDValue Mask1 = DAG.getLoad(SrcVT, dl, DAG.getEntryNode(), CPIdx,
8175                               MachinePointerInfo::getConstantPool(),
8176                               false, false, false, 16);
8177   SDValue SignBit = DAG.getNode(X86ISD::FAND, dl, SrcVT, Op1, Mask1);
8178
8179   // Shift sign bit right or left if the two operands have different types.
8180   if (SrcVT.bitsGT(VT)) {
8181     // Op0 is MVT::f32, Op1 is MVT::f64.
8182     SignBit = DAG.getNode(ISD::SCALAR_TO_VECTOR, dl, MVT::v2f64, SignBit);
8183     SignBit = DAG.getNode(X86ISD::FSRL, dl, MVT::v2f64, SignBit,
8184                           DAG.getConstant(32, MVT::i32));
8185     SignBit = DAG.getNode(ISD::BITCAST, dl, MVT::v4f32, SignBit);
8186     SignBit = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, MVT::f32, SignBit,
8187                           DAG.getIntPtrConstant(0));
8188   }
8189
8190   // Clear first operand sign bit.
8191   CV.clear();
8192   if (VT == MVT::f64) {
8193     CV.push_back(ConstantFP::get(*Context, APFloat(APInt(64, ~(1ULL << 63)))));
8194     CV.push_back(ConstantFP::get(*Context, APFloat(APInt(64, 0))));
8195   } else {
8196     CV.push_back(ConstantFP::get(*Context, APFloat(APInt(32, ~(1U << 31)))));
8197     CV.push_back(ConstantFP::get(*Context, APFloat(APInt(32, 0))));
8198     CV.push_back(ConstantFP::get(*Context, APFloat(APInt(32, 0))));
8199     CV.push_back(ConstantFP::get(*Context, APFloat(APInt(32, 0))));
8200   }
8201   C = ConstantVector::get(CV);
8202   CPIdx = DAG.getConstantPool(C, getPointerTy(), 16);
8203   SDValue Mask2 = DAG.getLoad(VT, dl, DAG.getEntryNode(), CPIdx,
8204                               MachinePointerInfo::getConstantPool(),
8205                               false, false, false, 16);
8206   SDValue Val = DAG.getNode(X86ISD::FAND, dl, VT, Op0, Mask2);
8207
8208   // Or the value with the sign bit.
8209   return DAG.getNode(X86ISD::FOR, dl, VT, Val, SignBit);
8210 }
8211
8212 SDValue X86TargetLowering::LowerFGETSIGN(SDValue Op, SelectionDAG &DAG) const {
8213   SDValue N0 = Op.getOperand(0);
8214   DebugLoc dl = Op.getDebugLoc();
8215   EVT VT = Op.getValueType();
8216
8217   // Lower ISD::FGETSIGN to (AND (X86ISD::FGETSIGNx86 ...) 1).
8218   SDValue xFGETSIGN = DAG.getNode(X86ISD::FGETSIGNx86, dl, VT, N0,
8219                                   DAG.getConstant(1, VT));
8220   return DAG.getNode(ISD::AND, dl, VT, xFGETSIGN, DAG.getConstant(1, VT));
8221 }
8222
8223 /// Emit nodes that will be selected as "test Op0,Op0", or something
8224 /// equivalent.
8225 SDValue X86TargetLowering::EmitTest(SDValue Op, unsigned X86CC,
8226                                     SelectionDAG &DAG) const {
8227   DebugLoc dl = Op.getDebugLoc();
8228
8229   // CF and OF aren't always set the way we want. Determine which
8230   // of these we need.
8231   bool NeedCF = false;
8232   bool NeedOF = false;
8233   switch (X86CC) {
8234   default: break;
8235   case X86::COND_A: case X86::COND_AE:
8236   case X86::COND_B: case X86::COND_BE:
8237     NeedCF = true;
8238     break;
8239   case X86::COND_G: case X86::COND_GE:
8240   case X86::COND_L: case X86::COND_LE:
8241   case X86::COND_O: case X86::COND_NO:
8242     NeedOF = true;
8243     break;
8244   }
8245
8246   // See if we can use the EFLAGS value from the operand instead of
8247   // doing a separate TEST. TEST always sets OF and CF to 0, so unless
8248   // we prove that the arithmetic won't overflow, we can't use OF or CF.
8249   if (Op.getResNo() != 0 || NeedOF || NeedCF)
8250     // Emit a CMP with 0, which is the TEST pattern.
8251     return DAG.getNode(X86ISD::CMP, dl, MVT::i32, Op,
8252                        DAG.getConstant(0, Op.getValueType()));
8253
8254   unsigned Opcode = 0;
8255   unsigned NumOperands = 0;
8256   switch (Op.getNode()->getOpcode()) {
8257   case ISD::ADD:
8258     // Due to an isel shortcoming, be conservative if this add is likely to be
8259     // selected as part of a load-modify-store instruction. When the root node
8260     // in a match is a store, isel doesn't know how to remap non-chain non-flag
8261     // uses of other nodes in the match, such as the ADD in this case. This
8262     // leads to the ADD being left around and reselected, with the result being
8263     // two adds in the output.  Alas, even if none our users are stores, that
8264     // doesn't prove we're O.K.  Ergo, if we have any parents that aren't
8265     // CopyToReg or SETCC, eschew INC/DEC.  A better fix seems to require
8266     // climbing the DAG back to the root, and it doesn't seem to be worth the
8267     // effort.
8268     for (SDNode::use_iterator UI = Op.getNode()->use_begin(),
8269          UE = Op.getNode()->use_end(); UI != UE; ++UI)
8270       if (UI->getOpcode() != ISD::CopyToReg &&
8271           UI->getOpcode() != ISD::SETCC &&
8272           UI->getOpcode() != ISD::STORE)
8273         goto default_case;
8274
8275     if (ConstantSDNode *C =
8276         dyn_cast<ConstantSDNode>(Op.getNode()->getOperand(1))) {
8277       // An add of one will be selected as an INC.
8278       if (C->getAPIntValue() == 1) {
8279         Opcode = X86ISD::INC;
8280         NumOperands = 1;
8281         break;
8282       }
8283
8284       // An add of negative one (subtract of one) will be selected as a DEC.
8285       if (C->getAPIntValue().isAllOnesValue()) {
8286         Opcode = X86ISD::DEC;
8287         NumOperands = 1;
8288         break;
8289       }
8290     }
8291
8292     // Otherwise use a regular EFLAGS-setting add.
8293     Opcode = X86ISD::ADD;
8294     NumOperands = 2;
8295     break;
8296   case ISD::AND: {
8297     // If the primary and result isn't used, don't bother using X86ISD::AND,
8298     // because a TEST instruction will be better.
8299     bool NonFlagUse = false;
8300     for (SDNode::use_iterator UI = Op.getNode()->use_begin(),
8301            UE = Op.getNode()->use_end(); UI != UE; ++UI) {
8302       SDNode *User = *UI;
8303       unsigned UOpNo = UI.getOperandNo();
8304       if (User->getOpcode() == ISD::TRUNCATE && User->hasOneUse()) {
8305         // Look pass truncate.
8306         UOpNo = User->use_begin().getOperandNo();
8307         User = *User->use_begin();
8308       }
8309
8310       if (User->getOpcode() != ISD::BRCOND &&
8311           User->getOpcode() != ISD::SETCC &&
8312           (User->getOpcode() != ISD::SELECT || UOpNo != 0)) {
8313         NonFlagUse = true;
8314         break;
8315       }
8316     }
8317
8318     if (!NonFlagUse)
8319       break;
8320   }
8321     // FALL THROUGH
8322   case ISD::SUB:
8323   case ISD::OR:
8324   case ISD::XOR:
8325     // Due to the ISEL shortcoming noted above, be conservative if this op is
8326     // likely to be selected as part of a load-modify-store instruction.
8327     for (SDNode::use_iterator UI = Op.getNode()->use_begin(),
8328            UE = Op.getNode()->use_end(); UI != UE; ++UI)
8329       if (UI->getOpcode() == ISD::STORE)
8330         goto default_case;
8331
8332     // Otherwise use a regular EFLAGS-setting instruction.
8333     switch (Op.getNode()->getOpcode()) {
8334     default: llvm_unreachable("unexpected operator!");
8335     case ISD::SUB:
8336       Opcode = X86ISD::SUB;
8337       break;
8338     case ISD::OR:  Opcode = X86ISD::OR;  break;
8339     case ISD::XOR: Opcode = X86ISD::XOR; break;
8340     case ISD::AND: Opcode = X86ISD::AND; break;
8341     }
8342
8343     NumOperands = 2;
8344     break;
8345   case X86ISD::ADD:
8346   case X86ISD::SUB:
8347   case X86ISD::INC:
8348   case X86ISD::DEC:
8349   case X86ISD::OR:
8350   case X86ISD::XOR:
8351   case X86ISD::AND:
8352     return SDValue(Op.getNode(), 1);
8353   default:
8354   default_case:
8355     break;
8356   }
8357
8358   if (Opcode == 0)
8359     // Emit a CMP with 0, which is the TEST pattern.
8360     return DAG.getNode(X86ISD::CMP, dl, MVT::i32, Op,
8361                        DAG.getConstant(0, Op.getValueType()));
8362
8363   if (Opcode == X86ISD::CMP) {
8364     SDValue New = DAG.getNode(Opcode, dl, MVT::i32, Op.getOperand(0),
8365                               Op.getOperand(1));
8366     // We can't replace usage of SUB with CMP.
8367     // The SUB node will be removed later because there is no use of it.
8368     return SDValue(New.getNode(), 0);
8369   }
8370
8371   SDVTList VTs = DAG.getVTList(Op.getValueType(), MVT::i32);
8372   SmallVector<SDValue, 4> Ops;
8373   for (unsigned i = 0; i != NumOperands; ++i)
8374     Ops.push_back(Op.getOperand(i));
8375
8376   SDValue New = DAG.getNode(Opcode, dl, VTs, &Ops[0], NumOperands);
8377   DAG.ReplaceAllUsesWith(Op, New);
8378   return SDValue(New.getNode(), 1);
8379 }
8380
8381 /// Emit nodes that will be selected as "cmp Op0,Op1", or something
8382 /// equivalent.
8383 SDValue X86TargetLowering::EmitCmp(SDValue Op0, SDValue Op1, unsigned X86CC,
8384                                    SelectionDAG &DAG) const {
8385   if (ConstantSDNode *C = dyn_cast<ConstantSDNode>(Op1))
8386     if (C->getAPIntValue() == 0)
8387       return EmitTest(Op0, X86CC, DAG);
8388
8389   DebugLoc dl = Op0.getDebugLoc();
8390   if ((Op0.getValueType() == MVT::i8 || Op0.getValueType() == MVT::i16 ||
8391        Op0.getValueType() == MVT::i32 || Op0.getValueType() == MVT::i64)) {
8392     // Use SUB instead of CMP to enable CSE between SUB and CMP.
8393     SDVTList VTs = DAG.getVTList(Op0.getValueType(), MVT::i32);
8394     SDValue Sub = DAG.getNode(X86ISD::SUB, dl, VTs,
8395                               Op0, Op1);
8396     return SDValue(Sub.getNode(), 1);
8397   }
8398   return DAG.getNode(X86ISD::CMP, dl, MVT::i32, Op0, Op1);
8399 }
8400
8401 /// Convert a comparison if required by the subtarget.
8402 SDValue X86TargetLowering::ConvertCmpIfNecessary(SDValue Cmp,
8403                                                  SelectionDAG &DAG) const {
8404   // If the subtarget does not support the FUCOMI instruction, floating-point
8405   // comparisons have to be converted.
8406   if (Subtarget->hasCMov() ||
8407       Cmp.getOpcode() != X86ISD::CMP ||
8408       !Cmp.getOperand(0).getValueType().isFloatingPoint() ||
8409       !Cmp.getOperand(1).getValueType().isFloatingPoint())
8410     return Cmp;
8411
8412   // The instruction selector will select an FUCOM instruction instead of
8413   // FUCOMI, which writes the comparison result to FPSW instead of EFLAGS. Hence
8414   // build an SDNode sequence that transfers the result from FPSW into EFLAGS:
8415   // (X86sahf (trunc (srl (X86fp_stsw (trunc (X86cmp ...)), 8))))
8416   DebugLoc dl = Cmp.getDebugLoc();
8417   SDValue TruncFPSW = DAG.getNode(ISD::TRUNCATE, dl, MVT::i16, Cmp);
8418   SDValue FNStSW = DAG.getNode(X86ISD::FNSTSW16r, dl, MVT::i16, TruncFPSW);
8419   SDValue Srl = DAG.getNode(ISD::SRL, dl, MVT::i16, FNStSW,
8420                             DAG.getConstant(8, MVT::i8));
8421   SDValue TruncSrl = DAG.getNode(ISD::TRUNCATE, dl, MVT::i8, Srl);
8422   return DAG.getNode(X86ISD::SAHF, dl, MVT::i32, TruncSrl);
8423 }
8424
8425 /// LowerToBT - Result of 'and' is compared against zero. Turn it into a BT node
8426 /// if it's possible.
8427 SDValue X86TargetLowering::LowerToBT(SDValue And, ISD::CondCode CC,
8428                                      DebugLoc dl, SelectionDAG &DAG) const {
8429   SDValue Op0 = And.getOperand(0);
8430   SDValue Op1 = And.getOperand(1);
8431   if (Op0.getOpcode() == ISD::TRUNCATE)
8432     Op0 = Op0.getOperand(0);
8433   if (Op1.getOpcode() == ISD::TRUNCATE)
8434     Op1 = Op1.getOperand(0);
8435
8436   SDValue LHS, RHS;
8437   if (Op1.getOpcode() == ISD::SHL)
8438     std::swap(Op0, Op1);
8439   if (Op0.getOpcode() == ISD::SHL) {
8440     if (ConstantSDNode *And00C = dyn_cast<ConstantSDNode>(Op0.getOperand(0)))
8441       if (And00C->getZExtValue() == 1) {
8442         // If we looked past a truncate, check that it's only truncating away
8443         // known zeros.
8444         unsigned BitWidth = Op0.getValueSizeInBits();
8445         unsigned AndBitWidth = And.getValueSizeInBits();
8446         if (BitWidth > AndBitWidth) {
8447           APInt Zeros, Ones;
8448           DAG.ComputeMaskedBits(Op0, Zeros, Ones);
8449           if (Zeros.countLeadingOnes() < BitWidth - AndBitWidth)
8450             return SDValue();
8451         }
8452         LHS = Op1;
8453         RHS = Op0.getOperand(1);
8454       }
8455   } else if (Op1.getOpcode() == ISD::Constant) {
8456     ConstantSDNode *AndRHS = cast<ConstantSDNode>(Op1);
8457     uint64_t AndRHSVal = AndRHS->getZExtValue();
8458     SDValue AndLHS = Op0;
8459
8460     if (AndRHSVal == 1 && AndLHS.getOpcode() == ISD::SRL) {
8461       LHS = AndLHS.getOperand(0);
8462       RHS = AndLHS.getOperand(1);
8463     }
8464
8465     // Use BT if the immediate can't be encoded in a TEST instruction.
8466     if (!isUInt<32>(AndRHSVal) && isPowerOf2_64(AndRHSVal)) {
8467       LHS = AndLHS;
8468       RHS = DAG.getConstant(Log2_64_Ceil(AndRHSVal), LHS.getValueType());
8469     }
8470   }
8471
8472   if (LHS.getNode()) {
8473     // If LHS is i8, promote it to i32 with any_extend.  There is no i8 BT
8474     // instruction.  Since the shift amount is in-range-or-undefined, we know
8475     // that doing a bittest on the i32 value is ok.  We extend to i32 because
8476     // the encoding for the i16 version is larger than the i32 version.
8477     // Also promote i16 to i32 for performance / code size reason.
8478     if (LHS.getValueType() == MVT::i8 ||
8479         LHS.getValueType() == MVT::i16)
8480       LHS = DAG.getNode(ISD::ANY_EXTEND, dl, MVT::i32, LHS);
8481
8482     // If the operand types disagree, extend the shift amount to match.  Since
8483     // BT ignores high bits (like shifts) we can use anyextend.
8484     if (LHS.getValueType() != RHS.getValueType())
8485       RHS = DAG.getNode(ISD::ANY_EXTEND, dl, LHS.getValueType(), RHS);
8486
8487     SDValue BT = DAG.getNode(X86ISD::BT, dl, MVT::i32, LHS, RHS);
8488     unsigned Cond = CC == ISD::SETEQ ? X86::COND_AE : X86::COND_B;
8489     return DAG.getNode(X86ISD::SETCC, dl, MVT::i8,
8490                        DAG.getConstant(Cond, MVT::i8), BT);
8491   }
8492
8493   return SDValue();
8494 }
8495
8496 SDValue X86TargetLowering::LowerSETCC(SDValue Op, SelectionDAG &DAG) const {
8497
8498   if (Op.getValueType().isVector()) return LowerVSETCC(Op, DAG);
8499
8500   assert(Op.getValueType() == MVT::i8 && "SetCC type must be 8-bit integer");
8501   SDValue Op0 = Op.getOperand(0);
8502   SDValue Op1 = Op.getOperand(1);
8503   DebugLoc dl = Op.getDebugLoc();
8504   ISD::CondCode CC = cast<CondCodeSDNode>(Op.getOperand(2))->get();
8505
8506   // Optimize to BT if possible.
8507   // Lower (X & (1 << N)) == 0 to BT(X, N).
8508   // Lower ((X >>u N) & 1) != 0 to BT(X, N).
8509   // Lower ((X >>s N) & 1) != 0 to BT(X, N).
8510   if (Op0.getOpcode() == ISD::AND && Op0.hasOneUse() &&
8511       Op1.getOpcode() == ISD::Constant &&
8512       cast<ConstantSDNode>(Op1)->isNullValue() &&
8513       (CC == ISD::SETEQ || CC == ISD::SETNE)) {
8514     SDValue NewSetCC = LowerToBT(Op0, CC, dl, DAG);
8515     if (NewSetCC.getNode())
8516       return NewSetCC;
8517   }
8518
8519   // Look for X == 0, X == 1, X != 0, or X != 1.  We can simplify some forms of
8520   // these.
8521   if (Op1.getOpcode() == ISD::Constant &&
8522       (cast<ConstantSDNode>(Op1)->getZExtValue() == 1 ||
8523        cast<ConstantSDNode>(Op1)->isNullValue()) &&
8524       (CC == ISD::SETEQ || CC == ISD::SETNE)) {
8525
8526     // If the input is a setcc, then reuse the input setcc or use a new one with
8527     // the inverted condition.
8528     if (Op0.getOpcode() == X86ISD::SETCC) {
8529       X86::CondCode CCode = (X86::CondCode)Op0.getConstantOperandVal(0);
8530       bool Invert = (CC == ISD::SETNE) ^
8531         cast<ConstantSDNode>(Op1)->isNullValue();
8532       if (!Invert) return Op0;
8533
8534       CCode = X86::GetOppositeBranchCondition(CCode);
8535       return DAG.getNode(X86ISD::SETCC, dl, MVT::i8,
8536                          DAG.getConstant(CCode, MVT::i8), Op0.getOperand(1));
8537     }
8538   }
8539
8540   bool isFP = Op1.getValueType().isFloatingPoint();
8541   unsigned X86CC = TranslateX86CC(CC, isFP, Op0, Op1, DAG);
8542   if (X86CC == X86::COND_INVALID)
8543     return SDValue();
8544
8545   SDValue EFLAGS = EmitCmp(Op0, Op1, X86CC, DAG);
8546   EFLAGS = ConvertCmpIfNecessary(EFLAGS, DAG);
8547   return DAG.getNode(X86ISD::SETCC, dl, MVT::i8,
8548                      DAG.getConstant(X86CC, MVT::i8), EFLAGS);
8549 }
8550
8551 // Lower256IntVSETCC - Break a VSETCC 256-bit integer VSETCC into two new 128
8552 // ones, and then concatenate the result back.
8553 static SDValue Lower256IntVSETCC(SDValue Op, SelectionDAG &DAG) {
8554   EVT VT = Op.getValueType();
8555
8556   assert(VT.getSizeInBits() == 256 && Op.getOpcode() == ISD::SETCC &&
8557          "Unsupported value type for operation");
8558
8559   unsigned NumElems = VT.getVectorNumElements();
8560   DebugLoc dl = Op.getDebugLoc();
8561   SDValue CC = Op.getOperand(2);
8562
8563   // Extract the LHS vectors
8564   SDValue LHS = Op.getOperand(0);
8565   SDValue LHS1 = Extract128BitVector(LHS, 0, DAG, dl);
8566   SDValue LHS2 = Extract128BitVector(LHS, NumElems/2, DAG, dl);
8567
8568   // Extract the RHS vectors
8569   SDValue RHS = Op.getOperand(1);
8570   SDValue RHS1 = Extract128BitVector(RHS, 0, DAG, dl);
8571   SDValue RHS2 = Extract128BitVector(RHS, NumElems/2, DAG, dl);
8572
8573   // Issue the operation on the smaller types and concatenate the result back
8574   MVT EltVT = VT.getVectorElementType().getSimpleVT();
8575   EVT NewVT = MVT::getVectorVT(EltVT, NumElems/2);
8576   return DAG.getNode(ISD::CONCAT_VECTORS, dl, VT,
8577                      DAG.getNode(Op.getOpcode(), dl, NewVT, LHS1, RHS1, CC),
8578                      DAG.getNode(Op.getOpcode(), dl, NewVT, LHS2, RHS2, CC));
8579 }
8580
8581
8582 SDValue X86TargetLowering::LowerVSETCC(SDValue Op, SelectionDAG &DAG) const {
8583   SDValue Cond;
8584   SDValue Op0 = Op.getOperand(0);
8585   SDValue Op1 = Op.getOperand(1);
8586   SDValue CC = Op.getOperand(2);
8587   EVT VT = Op.getValueType();
8588   ISD::CondCode SetCCOpcode = cast<CondCodeSDNode>(CC)->get();
8589   bool isFP = Op.getOperand(1).getValueType().isFloatingPoint();
8590   DebugLoc dl = Op.getDebugLoc();
8591
8592   if (isFP) {
8593     unsigned SSECC = 8;
8594     EVT EltVT = Op0.getValueType().getVectorElementType();
8595     assert(EltVT == MVT::f32 || EltVT == MVT::f64); (void)EltVT;
8596
8597     bool Swap = false;
8598
8599     // SSE Condition code mapping:
8600     //  0 - EQ
8601     //  1 - LT
8602     //  2 - LE
8603     //  3 - UNORD
8604     //  4 - NEQ
8605     //  5 - NLT
8606     //  6 - NLE
8607     //  7 - ORD
8608     switch (SetCCOpcode) {
8609     default: break;
8610     case ISD::SETOEQ:
8611     case ISD::SETEQ:  SSECC = 0; break;
8612     case ISD::SETOGT:
8613     case ISD::SETGT: Swap = true; // Fallthrough
8614     case ISD::SETLT:
8615     case ISD::SETOLT: SSECC = 1; break;
8616     case ISD::SETOGE:
8617     case ISD::SETGE: Swap = true; // Fallthrough
8618     case ISD::SETLE:
8619     case ISD::SETOLE: SSECC = 2; break;
8620     case ISD::SETUO:  SSECC = 3; break;
8621     case ISD::SETUNE:
8622     case ISD::SETNE:  SSECC = 4; break;
8623     case ISD::SETULE: Swap = true;
8624     case ISD::SETUGE: SSECC = 5; break;
8625     case ISD::SETULT: Swap = true;
8626     case ISD::SETUGT: SSECC = 6; break;
8627     case ISD::SETO:   SSECC = 7; break;
8628     }
8629     if (Swap)
8630       std::swap(Op0, Op1);
8631
8632     // In the two special cases we can't handle, emit two comparisons.
8633     if (SSECC == 8) {
8634       if (SetCCOpcode == ISD::SETUEQ) {
8635         SDValue UNORD, EQ;
8636         UNORD = DAG.getNode(X86ISD::CMPP, dl, VT, Op0, Op1,
8637                             DAG.getConstant(3, MVT::i8));
8638         EQ = DAG.getNode(X86ISD::CMPP, dl, VT, Op0, Op1,
8639                          DAG.getConstant(0, MVT::i8));
8640         return DAG.getNode(ISD::OR, dl, VT, UNORD, EQ);
8641       }
8642       if (SetCCOpcode == ISD::SETONE) {
8643         SDValue ORD, NEQ;
8644         ORD = DAG.getNode(X86ISD::CMPP, dl, VT, Op0, Op1,
8645                           DAG.getConstant(7, MVT::i8));
8646         NEQ = DAG.getNode(X86ISD::CMPP, dl, VT, Op0, Op1,
8647                           DAG.getConstant(4, MVT::i8));
8648         return DAG.getNode(ISD::AND, dl, VT, ORD, NEQ);
8649       }
8650       llvm_unreachable("Illegal FP comparison");
8651     }
8652     // Handle all other FP comparisons here.
8653     return DAG.getNode(X86ISD::CMPP, dl, VT, Op0, Op1,
8654                        DAG.getConstant(SSECC, MVT::i8));
8655   }
8656
8657   // Break 256-bit integer vector compare into smaller ones.
8658   if (VT.getSizeInBits() == 256 && !Subtarget->hasAVX2())
8659     return Lower256IntVSETCC(Op, DAG);
8660
8661   // We are handling one of the integer comparisons here.  Since SSE only has
8662   // GT and EQ comparisons for integer, swapping operands and multiple
8663   // operations may be required for some comparisons.
8664   unsigned Opc = 0;
8665   bool Swap = false, Invert = false, FlipSigns = false;
8666
8667   switch (SetCCOpcode) {
8668   default: break;
8669   case ISD::SETNE:  Invert = true;
8670   case ISD::SETEQ:  Opc = X86ISD::PCMPEQ; break;
8671   case ISD::SETLT:  Swap = true;
8672   case ISD::SETGT:  Opc = X86ISD::PCMPGT; break;
8673   case ISD::SETGE:  Swap = true;
8674   case ISD::SETLE:  Opc = X86ISD::PCMPGT; Invert = true; break;
8675   case ISD::SETULT: Swap = true;
8676   case ISD::SETUGT: Opc = X86ISD::PCMPGT; FlipSigns = true; break;
8677   case ISD::SETUGE: Swap = true;
8678   case ISD::SETULE: Opc = X86ISD::PCMPGT; FlipSigns = true; Invert = true; break;
8679   }
8680   if (Swap)
8681     std::swap(Op0, Op1);
8682
8683   // Check that the operation in question is available (most are plain SSE2,
8684   // but PCMPGTQ and PCMPEQQ have different requirements).
8685   if (Opc == X86ISD::PCMPGT && VT == MVT::v2i64 && !Subtarget->hasSSE42())
8686     return SDValue();
8687   if (Opc == X86ISD::PCMPEQ && VT == MVT::v2i64 && !Subtarget->hasSSE41())
8688     return SDValue();
8689
8690   // Since SSE has no unsigned integer comparisons, we need to flip  the sign
8691   // bits of the inputs before performing those operations.
8692   if (FlipSigns) {
8693     EVT EltVT = VT.getVectorElementType();
8694     SDValue SignBit = DAG.getConstant(APInt::getSignBit(EltVT.getSizeInBits()),
8695                                       EltVT);
8696     std::vector<SDValue> SignBits(VT.getVectorNumElements(), SignBit);
8697     SDValue SignVec = DAG.getNode(ISD::BUILD_VECTOR, dl, VT, &SignBits[0],
8698                                     SignBits.size());
8699     Op0 = DAG.getNode(ISD::XOR, dl, VT, Op0, SignVec);
8700     Op1 = DAG.getNode(ISD::XOR, dl, VT, Op1, SignVec);
8701   }
8702
8703   SDValue Result = DAG.getNode(Opc, dl, VT, Op0, Op1);
8704
8705   // If the logical-not of the result is required, perform that now.
8706   if (Invert)
8707     Result = DAG.getNOT(dl, Result, VT);
8708
8709   return Result;
8710 }
8711
8712 // isX86LogicalCmp - Return true if opcode is a X86 logical comparison.
8713 static bool isX86LogicalCmp(SDValue Op) {
8714   unsigned Opc = Op.getNode()->getOpcode();
8715   if (Opc == X86ISD::CMP || Opc == X86ISD::COMI || Opc == X86ISD::UCOMI ||
8716       Opc == X86ISD::SAHF)
8717     return true;
8718   if (Op.getResNo() == 1 &&
8719       (Opc == X86ISD::ADD ||
8720        Opc == X86ISD::SUB ||
8721        Opc == X86ISD::ADC ||
8722        Opc == X86ISD::SBB ||
8723        Opc == X86ISD::SMUL ||
8724        Opc == X86ISD::UMUL ||
8725        Opc == X86ISD::INC ||
8726        Opc == X86ISD::DEC ||
8727        Opc == X86ISD::OR ||
8728        Opc == X86ISD::XOR ||
8729        Opc == X86ISD::AND))
8730     return true;
8731
8732   if (Op.getResNo() == 2 && Opc == X86ISD::UMUL)
8733     return true;
8734
8735   return false;
8736 }
8737
8738 static bool isZero(SDValue V) {
8739   ConstantSDNode *C = dyn_cast<ConstantSDNode>(V);
8740   return C && C->isNullValue();
8741 }
8742
8743 static bool isAllOnes(SDValue V) {
8744   ConstantSDNode *C = dyn_cast<ConstantSDNode>(V);
8745   return C && C->isAllOnesValue();
8746 }
8747
8748 static bool isTruncWithZeroHighBitsInput(SDValue V, SelectionDAG &DAG) {
8749   if (V.getOpcode() != ISD::TRUNCATE)
8750     return false;
8751
8752   SDValue VOp0 = V.getOperand(0);
8753   unsigned InBits = VOp0.getValueSizeInBits();
8754   unsigned Bits = V.getValueSizeInBits();
8755   return DAG.MaskedValueIsZero(VOp0, APInt::getHighBitsSet(InBits,InBits-Bits));
8756 }
8757
8758 SDValue X86TargetLowering::LowerSELECT(SDValue Op, SelectionDAG &DAG) const {
8759   bool addTest = true;
8760   SDValue Cond  = Op.getOperand(0);
8761   SDValue Op1 = Op.getOperand(1);
8762   SDValue Op2 = Op.getOperand(2);
8763   DebugLoc DL = Op.getDebugLoc();
8764   SDValue CC;
8765
8766   if (Cond.getOpcode() == ISD::SETCC) {
8767     SDValue NewCond = LowerSETCC(Cond, DAG);
8768     if (NewCond.getNode())
8769       Cond = NewCond;
8770   }
8771
8772   // (select (x == 0), -1, y) -> (sign_bit (x - 1)) | y
8773   // (select (x == 0), y, -1) -> ~(sign_bit (x - 1)) | y
8774   // (select (x != 0), y, -1) -> (sign_bit (x - 1)) | y
8775   // (select (x != 0), -1, y) -> ~(sign_bit (x - 1)) | y
8776   if (Cond.getOpcode() == X86ISD::SETCC &&
8777       Cond.getOperand(1).getOpcode() == X86ISD::CMP &&
8778       isZero(Cond.getOperand(1).getOperand(1))) {
8779     SDValue Cmp = Cond.getOperand(1);
8780
8781     unsigned CondCode =cast<ConstantSDNode>(Cond.getOperand(0))->getZExtValue();
8782
8783     if ((isAllOnes(Op1) || isAllOnes(Op2)) &&
8784         (CondCode == X86::COND_E || CondCode == X86::COND_NE)) {
8785       SDValue Y = isAllOnes(Op2) ? Op1 : Op2;
8786
8787       SDValue CmpOp0 = Cmp.getOperand(0);
8788       // Apply further optimizations for special cases
8789       // (select (x != 0), -1, 0) -> neg & sbb
8790       // (select (x == 0), 0, -1) -> neg & sbb
8791       if (ConstantSDNode *YC = dyn_cast<ConstantSDNode>(Y))
8792         if (YC->isNullValue() &&
8793             (isAllOnes(Op1) == (CondCode == X86::COND_NE))) {
8794           SDVTList VTs = DAG.getVTList(CmpOp0.getValueType(), MVT::i32);
8795           SDValue Neg = DAG.getNode(X86ISD::SUB, DL, VTs,
8796                                     DAG.getConstant(0, CmpOp0.getValueType()),
8797                                     CmpOp0);
8798           SDValue Res = DAG.getNode(X86ISD::SETCC_CARRY, DL, Op.getValueType(),
8799                                     DAG.getConstant(X86::COND_B, MVT::i8),
8800                                     SDValue(Neg.getNode(), 1));
8801           return Res;
8802         }
8803
8804       Cmp = DAG.getNode(X86ISD::CMP, DL, MVT::i32,
8805                         CmpOp0, DAG.getConstant(1, CmpOp0.getValueType()));
8806       Cmp = ConvertCmpIfNecessary(Cmp, DAG);
8807
8808       SDValue Res =   // Res = 0 or -1.
8809         DAG.getNode(X86ISD::SETCC_CARRY, DL, Op.getValueType(),
8810                     DAG.getConstant(X86::COND_B, MVT::i8), Cmp);
8811
8812       if (isAllOnes(Op1) != (CondCode == X86::COND_E))
8813         Res = DAG.getNOT(DL, Res, Res.getValueType());
8814
8815       ConstantSDNode *N2C = dyn_cast<ConstantSDNode>(Op2);
8816       if (N2C == 0 || !N2C->isNullValue())
8817         Res = DAG.getNode(ISD::OR, DL, Res.getValueType(), Res, Y);
8818       return Res;
8819     }
8820   }
8821
8822   // Look past (and (setcc_carry (cmp ...)), 1).
8823   if (Cond.getOpcode() == ISD::AND &&
8824       Cond.getOperand(0).getOpcode() == X86ISD::SETCC_CARRY) {
8825     ConstantSDNode *C = dyn_cast<ConstantSDNode>(Cond.getOperand(1));
8826     if (C && C->getAPIntValue() == 1)
8827       Cond = Cond.getOperand(0);
8828   }
8829
8830   // If condition flag is set by a X86ISD::CMP, then use it as the condition
8831   // setting operand in place of the X86ISD::SETCC.
8832   unsigned CondOpcode = Cond.getOpcode();
8833   if (CondOpcode == X86ISD::SETCC ||
8834       CondOpcode == X86ISD::SETCC_CARRY) {
8835     CC = Cond.getOperand(0);
8836
8837     SDValue Cmp = Cond.getOperand(1);
8838     unsigned Opc = Cmp.getOpcode();
8839     EVT VT = Op.getValueType();
8840
8841     bool IllegalFPCMov = false;
8842     if (VT.isFloatingPoint() && !VT.isVector() &&
8843         !isScalarFPTypeInSSEReg(VT))  // FPStack?
8844       IllegalFPCMov = !hasFPCMov(cast<ConstantSDNode>(CC)->getSExtValue());
8845
8846     if ((isX86LogicalCmp(Cmp) && !IllegalFPCMov) ||
8847         Opc == X86ISD::BT) { // FIXME
8848       Cond = Cmp;
8849       addTest = false;
8850     }
8851   } else if (CondOpcode == ISD::USUBO || CondOpcode == ISD::SSUBO ||
8852              CondOpcode == ISD::UADDO || CondOpcode == ISD::SADDO ||
8853              ((CondOpcode == ISD::UMULO || CondOpcode == ISD::SMULO) &&
8854               Cond.getOperand(0).getValueType() != MVT::i8)) {
8855     SDValue LHS = Cond.getOperand(0);
8856     SDValue RHS = Cond.getOperand(1);
8857     unsigned X86Opcode;
8858     unsigned X86Cond;
8859     SDVTList VTs;
8860     switch (CondOpcode) {
8861     case ISD::UADDO: X86Opcode = X86ISD::ADD; X86Cond = X86::COND_B; break;
8862     case ISD::SADDO: X86Opcode = X86ISD::ADD; X86Cond = X86::COND_O; break;
8863     case ISD::USUBO: X86Opcode = X86ISD::SUB; X86Cond = X86::COND_B; break;
8864     case ISD::SSUBO: X86Opcode = X86ISD::SUB; X86Cond = X86::COND_O; break;
8865     case ISD::UMULO: X86Opcode = X86ISD::UMUL; X86Cond = X86::COND_O; break;
8866     case ISD::SMULO: X86Opcode = X86ISD::SMUL; X86Cond = X86::COND_O; break;
8867     default: llvm_unreachable("unexpected overflowing operator");
8868     }
8869     if (CondOpcode == ISD::UMULO)
8870       VTs = DAG.getVTList(LHS.getValueType(), LHS.getValueType(),
8871                           MVT::i32);
8872     else
8873       VTs = DAG.getVTList(LHS.getValueType(), MVT::i32);
8874
8875     SDValue X86Op = DAG.getNode(X86Opcode, DL, VTs, LHS, RHS);
8876
8877     if (CondOpcode == ISD::UMULO)
8878       Cond = X86Op.getValue(2);
8879     else
8880       Cond = X86Op.getValue(1);
8881
8882     CC = DAG.getConstant(X86Cond, MVT::i8);
8883     addTest = false;
8884   }
8885
8886   if (addTest) {
8887     // Look pass the truncate if the high bits are known zero.
8888     if (isTruncWithZeroHighBitsInput(Cond, DAG))
8889         Cond = Cond.getOperand(0);
8890
8891     // We know the result of AND is compared against zero. Try to match
8892     // it to BT.
8893     if (Cond.getOpcode() == ISD::AND && Cond.hasOneUse()) {
8894       SDValue NewSetCC = LowerToBT(Cond, ISD::SETNE, DL, DAG);
8895       if (NewSetCC.getNode()) {
8896         CC = NewSetCC.getOperand(0);
8897         Cond = NewSetCC.getOperand(1);
8898         addTest = false;
8899       }
8900     }
8901   }
8902
8903   if (addTest) {
8904     CC = DAG.getConstant(X86::COND_NE, MVT::i8);
8905     Cond = EmitTest(Cond, X86::COND_NE, DAG);
8906   }
8907
8908   // a <  b ? -1 :  0 -> RES = ~setcc_carry
8909   // a <  b ?  0 : -1 -> RES = setcc_carry
8910   // a >= b ? -1 :  0 -> RES = setcc_carry
8911   // a >= b ?  0 : -1 -> RES = ~setcc_carry
8912   if (Cond.getOpcode() == X86ISD::SUB) {
8913     Cond = ConvertCmpIfNecessary(Cond, DAG);
8914     unsigned CondCode = cast<ConstantSDNode>(CC)->getZExtValue();
8915
8916     if ((CondCode == X86::COND_AE || CondCode == X86::COND_B) &&
8917         (isAllOnes(Op1) || isAllOnes(Op2)) && (isZero(Op1) || isZero(Op2))) {
8918       SDValue Res = DAG.getNode(X86ISD::SETCC_CARRY, DL, Op.getValueType(),
8919                                 DAG.getConstant(X86::COND_B, MVT::i8), Cond);
8920       if (isAllOnes(Op1) != (CondCode == X86::COND_B))
8921         return DAG.getNOT(DL, Res, Res.getValueType());
8922       return Res;
8923     }
8924   }
8925
8926   // X86ISD::CMOV means set the result (which is operand 1) to the RHS if
8927   // condition is true.
8928   SDVTList VTs = DAG.getVTList(Op.getValueType(), MVT::Glue);
8929   SDValue Ops[] = { Op2, Op1, CC, Cond };
8930   return DAG.getNode(X86ISD::CMOV, DL, VTs, Ops, array_lengthof(Ops));
8931 }
8932
8933 // isAndOrOfSingleUseSetCCs - Return true if node is an ISD::AND or
8934 // ISD::OR of two X86ISD::SETCC nodes each of which has no other use apart
8935 // from the AND / OR.
8936 static bool isAndOrOfSetCCs(SDValue Op, unsigned &Opc) {
8937   Opc = Op.getOpcode();
8938   if (Opc != ISD::OR && Opc != ISD::AND)
8939     return false;
8940   return (Op.getOperand(0).getOpcode() == X86ISD::SETCC &&
8941           Op.getOperand(0).hasOneUse() &&
8942           Op.getOperand(1).getOpcode() == X86ISD::SETCC &&
8943           Op.getOperand(1).hasOneUse());
8944 }
8945
8946 // isXor1OfSetCC - Return true if node is an ISD::XOR of a X86ISD::SETCC and
8947 // 1 and that the SETCC node has a single use.
8948 static bool isXor1OfSetCC(SDValue Op) {
8949   if (Op.getOpcode() != ISD::XOR)
8950     return false;
8951   ConstantSDNode *N1C = dyn_cast<ConstantSDNode>(Op.getOperand(1));
8952   if (N1C && N1C->getAPIntValue() == 1) {
8953     return Op.getOperand(0).getOpcode() == X86ISD::SETCC &&
8954       Op.getOperand(0).hasOneUse();
8955   }
8956   return false;
8957 }
8958
8959 SDValue X86TargetLowering::LowerBRCOND(SDValue Op, SelectionDAG &DAG) const {
8960   bool addTest = true;
8961   SDValue Chain = Op.getOperand(0);
8962   SDValue Cond  = Op.getOperand(1);
8963   SDValue Dest  = Op.getOperand(2);
8964   DebugLoc dl = Op.getDebugLoc();
8965   SDValue CC;
8966   bool Inverted = false;
8967
8968   if (Cond.getOpcode() == ISD::SETCC) {
8969     // Check for setcc([su]{add,sub,mul}o == 0).
8970     if (cast<CondCodeSDNode>(Cond.getOperand(2))->get() == ISD::SETEQ &&
8971         isa<ConstantSDNode>(Cond.getOperand(1)) &&
8972         cast<ConstantSDNode>(Cond.getOperand(1))->isNullValue() &&
8973         Cond.getOperand(0).getResNo() == 1 &&
8974         (Cond.getOperand(0).getOpcode() == ISD::SADDO ||
8975          Cond.getOperand(0).getOpcode() == ISD::UADDO ||
8976          Cond.getOperand(0).getOpcode() == ISD::SSUBO ||
8977          Cond.getOperand(0).getOpcode() == ISD::USUBO ||
8978          Cond.getOperand(0).getOpcode() == ISD::SMULO ||
8979          Cond.getOperand(0).getOpcode() == ISD::UMULO)) {
8980       Inverted = true;
8981       Cond = Cond.getOperand(0);
8982     } else {
8983       SDValue NewCond = LowerSETCC(Cond, DAG);
8984       if (NewCond.getNode())
8985         Cond = NewCond;
8986     }
8987   }
8988 #if 0
8989   // FIXME: LowerXALUO doesn't handle these!!
8990   else if (Cond.getOpcode() == X86ISD::ADD  ||
8991            Cond.getOpcode() == X86ISD::SUB  ||
8992            Cond.getOpcode() == X86ISD::SMUL ||
8993            Cond.getOpcode() == X86ISD::UMUL)
8994     Cond = LowerXALUO(Cond, DAG);
8995 #endif
8996
8997   // Look pass (and (setcc_carry (cmp ...)), 1).
8998   if (Cond.getOpcode() == ISD::AND &&
8999       Cond.getOperand(0).getOpcode() == X86ISD::SETCC_CARRY) {
9000     ConstantSDNode *C = dyn_cast<ConstantSDNode>(Cond.getOperand(1));
9001     if (C && C->getAPIntValue() == 1)
9002       Cond = Cond.getOperand(0);
9003   }
9004
9005   // If condition flag is set by a X86ISD::CMP, then use it as the condition
9006   // setting operand in place of the X86ISD::SETCC.
9007   unsigned CondOpcode = Cond.getOpcode();
9008   if (CondOpcode == X86ISD::SETCC ||
9009       CondOpcode == X86ISD::SETCC_CARRY) {
9010     CC = Cond.getOperand(0);
9011
9012     SDValue Cmp = Cond.getOperand(1);
9013     unsigned Opc = Cmp.getOpcode();
9014     // FIXME: WHY THE SPECIAL CASING OF LogicalCmp??
9015     if (isX86LogicalCmp(Cmp) || Opc == X86ISD::BT) {
9016       Cond = Cmp;
9017       addTest = false;
9018     } else {
9019       switch (cast<ConstantSDNode>(CC)->getZExtValue()) {
9020       default: break;
9021       case X86::COND_O:
9022       case X86::COND_B:
9023         // These can only come from an arithmetic instruction with overflow,
9024         // e.g. SADDO, UADDO.
9025         Cond = Cond.getNode()->getOperand(1);
9026         addTest = false;
9027         break;
9028       }
9029     }
9030   }
9031   CondOpcode = Cond.getOpcode();
9032   if (CondOpcode == ISD::UADDO || CondOpcode == ISD::SADDO ||
9033       CondOpcode == ISD::USUBO || CondOpcode == ISD::SSUBO ||
9034       ((CondOpcode == ISD::UMULO || CondOpcode == ISD::SMULO) &&
9035        Cond.getOperand(0).getValueType() != MVT::i8)) {
9036     SDValue LHS = Cond.getOperand(0);
9037     SDValue RHS = Cond.getOperand(1);
9038     unsigned X86Opcode;
9039     unsigned X86Cond;
9040     SDVTList VTs;
9041     switch (CondOpcode) {
9042     case ISD::UADDO: X86Opcode = X86ISD::ADD; X86Cond = X86::COND_B; break;
9043     case ISD::SADDO: X86Opcode = X86ISD::ADD; X86Cond = X86::COND_O; break;
9044     case ISD::USUBO: X86Opcode = X86ISD::SUB; X86Cond = X86::COND_B; break;
9045     case ISD::SSUBO: X86Opcode = X86ISD::SUB; X86Cond = X86::COND_O; break;
9046     case ISD::UMULO: X86Opcode = X86ISD::UMUL; X86Cond = X86::COND_O; break;
9047     case ISD::SMULO: X86Opcode = X86ISD::SMUL; X86Cond = X86::COND_O; break;
9048     default: llvm_unreachable("unexpected overflowing operator");
9049     }
9050     if (Inverted)
9051       X86Cond = X86::GetOppositeBranchCondition((X86::CondCode)X86Cond);
9052     if (CondOpcode == ISD::UMULO)
9053       VTs = DAG.getVTList(LHS.getValueType(), LHS.getValueType(),
9054                           MVT::i32);
9055     else
9056       VTs = DAG.getVTList(LHS.getValueType(), MVT::i32);
9057
9058     SDValue X86Op = DAG.getNode(X86Opcode, dl, VTs, LHS, RHS);
9059
9060     if (CondOpcode == ISD::UMULO)
9061       Cond = X86Op.getValue(2);
9062     else
9063       Cond = X86Op.getValue(1);
9064
9065     CC = DAG.getConstant(X86Cond, MVT::i8);
9066     addTest = false;
9067   } else {
9068     unsigned CondOpc;
9069     if (Cond.hasOneUse() && isAndOrOfSetCCs(Cond, CondOpc)) {
9070       SDValue Cmp = Cond.getOperand(0).getOperand(1);
9071       if (CondOpc == ISD::OR) {
9072         // Also, recognize the pattern generated by an FCMP_UNE. We can emit
9073         // two branches instead of an explicit OR instruction with a
9074         // separate test.
9075         if (Cmp == Cond.getOperand(1).getOperand(1) &&
9076             isX86LogicalCmp(Cmp)) {
9077           CC = Cond.getOperand(0).getOperand(0);
9078           Chain = DAG.getNode(X86ISD::BRCOND, dl, Op.getValueType(),
9079                               Chain, Dest, CC, Cmp);
9080           CC = Cond.getOperand(1).getOperand(0);
9081           Cond = Cmp;
9082           addTest = false;
9083         }
9084       } else { // ISD::AND
9085         // Also, recognize the pattern generated by an FCMP_OEQ. We can emit
9086         // two branches instead of an explicit AND instruction with a
9087         // separate test. However, we only do this if this block doesn't
9088         // have a fall-through edge, because this requires an explicit
9089         // jmp when the condition is false.
9090         if (Cmp == Cond.getOperand(1).getOperand(1) &&
9091             isX86LogicalCmp(Cmp) &&
9092             Op.getNode()->hasOneUse()) {
9093           X86::CondCode CCode =
9094             (X86::CondCode)Cond.getOperand(0).getConstantOperandVal(0);
9095           CCode = X86::GetOppositeBranchCondition(CCode);
9096           CC = DAG.getConstant(CCode, MVT::i8);
9097           SDNode *User = *Op.getNode()->use_begin();
9098           // Look for an unconditional branch following this conditional branch.
9099           // We need this because we need to reverse the successors in order
9100           // to implement FCMP_OEQ.
9101           if (User->getOpcode() == ISD::BR) {
9102             SDValue FalseBB = User->getOperand(1);
9103             SDNode *NewBR =
9104               DAG.UpdateNodeOperands(User, User->getOperand(0), Dest);
9105             assert(NewBR == User);
9106             (void)NewBR;
9107             Dest = FalseBB;
9108
9109             Chain = DAG.getNode(X86ISD::BRCOND, dl, Op.getValueType(),
9110                                 Chain, Dest, CC, Cmp);
9111             X86::CondCode CCode =
9112               (X86::CondCode)Cond.getOperand(1).getConstantOperandVal(0);
9113             CCode = X86::GetOppositeBranchCondition(CCode);
9114             CC = DAG.getConstant(CCode, MVT::i8);
9115             Cond = Cmp;
9116             addTest = false;
9117           }
9118         }
9119       }
9120     } else if (Cond.hasOneUse() && isXor1OfSetCC(Cond)) {
9121       // Recognize for xorb (setcc), 1 patterns. The xor inverts the condition.
9122       // It should be transformed during dag combiner except when the condition
9123       // is set by a arithmetics with overflow node.
9124       X86::CondCode CCode =
9125         (X86::CondCode)Cond.getOperand(0).getConstantOperandVal(0);
9126       CCode = X86::GetOppositeBranchCondition(CCode);
9127       CC = DAG.getConstant(CCode, MVT::i8);
9128       Cond = Cond.getOperand(0).getOperand(1);
9129       addTest = false;
9130     } else if (Cond.getOpcode() == ISD::SETCC &&
9131                cast<CondCodeSDNode>(Cond.getOperand(2))->get() == ISD::SETOEQ) {
9132       // For FCMP_OEQ, we can emit
9133       // two branches instead of an explicit AND instruction with a
9134       // separate test. However, we only do this if this block doesn't
9135       // have a fall-through edge, because this requires an explicit
9136       // jmp when the condition is false.
9137       if (Op.getNode()->hasOneUse()) {
9138         SDNode *User = *Op.getNode()->use_begin();
9139         // Look for an unconditional branch following this conditional branch.
9140         // We need this because we need to reverse the successors in order
9141         // to implement FCMP_OEQ.
9142         if (User->getOpcode() == ISD::BR) {
9143           SDValue FalseBB = User->getOperand(1);
9144           SDNode *NewBR =
9145             DAG.UpdateNodeOperands(User, User->getOperand(0), Dest);
9146           assert(NewBR == User);
9147           (void)NewBR;
9148           Dest = FalseBB;
9149
9150           SDValue Cmp = DAG.getNode(X86ISD::CMP, dl, MVT::i32,
9151                                     Cond.getOperand(0), Cond.getOperand(1));
9152           Cmp = ConvertCmpIfNecessary(Cmp, DAG);
9153           CC = DAG.getConstant(X86::COND_NE, MVT::i8);
9154           Chain = DAG.getNode(X86ISD::BRCOND, dl, Op.getValueType(),
9155                               Chain, Dest, CC, Cmp);
9156           CC = DAG.getConstant(X86::COND_P, MVT::i8);
9157           Cond = Cmp;
9158           addTest = false;
9159         }
9160       }
9161     } else if (Cond.getOpcode() == ISD::SETCC &&
9162                cast<CondCodeSDNode>(Cond.getOperand(2))->get() == ISD::SETUNE) {
9163       // For FCMP_UNE, we can emit
9164       // two branches instead of an explicit AND instruction with a
9165       // separate test. However, we only do this if this block doesn't
9166       // have a fall-through edge, because this requires an explicit
9167       // jmp when the condition is false.
9168       if (Op.getNode()->hasOneUse()) {
9169         SDNode *User = *Op.getNode()->use_begin();
9170         // Look for an unconditional branch following this conditional branch.
9171         // We need this because we need to reverse the successors in order
9172         // to implement FCMP_UNE.
9173         if (User->getOpcode() == ISD::BR) {
9174           SDValue FalseBB = User->getOperand(1);
9175           SDNode *NewBR =
9176             DAG.UpdateNodeOperands(User, User->getOperand(0), Dest);
9177           assert(NewBR == User);
9178           (void)NewBR;
9179
9180           SDValue Cmp = DAG.getNode(X86ISD::CMP, dl, MVT::i32,
9181                                     Cond.getOperand(0), Cond.getOperand(1));
9182           Cmp = ConvertCmpIfNecessary(Cmp, DAG);
9183           CC = DAG.getConstant(X86::COND_NE, MVT::i8);
9184           Chain = DAG.getNode(X86ISD::BRCOND, dl, Op.getValueType(),
9185                               Chain, Dest, CC, Cmp);
9186           CC = DAG.getConstant(X86::COND_NP, MVT::i8);
9187           Cond = Cmp;
9188           addTest = false;
9189           Dest = FalseBB;
9190         }
9191       }
9192     }
9193   }
9194
9195   if (addTest) {
9196     // Look pass the truncate if the high bits are known zero.
9197     if (isTruncWithZeroHighBitsInput(Cond, DAG))
9198         Cond = Cond.getOperand(0);
9199
9200     // We know the result of AND is compared against zero. Try to match
9201     // it to BT.
9202     if (Cond.getOpcode() == ISD::AND && Cond.hasOneUse()) {
9203       SDValue NewSetCC = LowerToBT(Cond, ISD::SETNE, dl, DAG);
9204       if (NewSetCC.getNode()) {
9205         CC = NewSetCC.getOperand(0);
9206         Cond = NewSetCC.getOperand(1);
9207         addTest = false;
9208       }
9209     }
9210   }
9211
9212   if (addTest) {
9213     CC = DAG.getConstant(X86::COND_NE, MVT::i8);
9214     Cond = EmitTest(Cond, X86::COND_NE, DAG);
9215   }
9216   Cond = ConvertCmpIfNecessary(Cond, DAG);
9217   return DAG.getNode(X86ISD::BRCOND, dl, Op.getValueType(),
9218                      Chain, Dest, CC, Cond);
9219 }
9220
9221
9222 // Lower dynamic stack allocation to _alloca call for Cygwin/Mingw targets.
9223 // Calls to _alloca is needed to probe the stack when allocating more than 4k
9224 // bytes in one go. Touching the stack at 4K increments is necessary to ensure
9225 // that the guard pages used by the OS virtual memory manager are allocated in
9226 // correct sequence.
9227 SDValue
9228 X86TargetLowering::LowerDYNAMIC_STACKALLOC(SDValue Op,
9229                                            SelectionDAG &DAG) const {
9230   assert((Subtarget->isTargetCygMing() || Subtarget->isTargetWindows() ||
9231           getTargetMachine().Options.EnableSegmentedStacks) &&
9232          "This should be used only on Windows targets or when segmented stacks "
9233          "are being used");
9234   assert(!Subtarget->isTargetEnvMacho() && "Not implemented");
9235   DebugLoc dl = Op.getDebugLoc();
9236
9237   // Get the inputs.
9238   SDValue Chain = Op.getOperand(0);
9239   SDValue Size  = Op.getOperand(1);
9240   // FIXME: Ensure alignment here
9241
9242   bool Is64Bit = Subtarget->is64Bit();
9243   EVT SPTy = Is64Bit ? MVT::i64 : MVT::i32;
9244
9245   if (getTargetMachine().Options.EnableSegmentedStacks) {
9246     MachineFunction &MF = DAG.getMachineFunction();
9247     MachineRegisterInfo &MRI = MF.getRegInfo();
9248
9249     if (Is64Bit) {
9250       // The 64 bit implementation of segmented stacks needs to clobber both r10
9251       // r11. This makes it impossible to use it along with nested parameters.
9252       const Function *F = MF.getFunction();
9253
9254       for (Function::const_arg_iterator I = F->arg_begin(), E = F->arg_end();
9255            I != E; ++I)
9256         if (I->hasNestAttr())
9257           report_fatal_error("Cannot use segmented stacks with functions that "
9258                              "have nested arguments.");
9259     }
9260
9261     const TargetRegisterClass *AddrRegClass =
9262       getRegClassFor(Subtarget->is64Bit() ? MVT::i64:MVT::i32);
9263     unsigned Vreg = MRI.createVirtualRegister(AddrRegClass);
9264     Chain = DAG.getCopyToReg(Chain, dl, Vreg, Size);
9265     SDValue Value = DAG.getNode(X86ISD::SEG_ALLOCA, dl, SPTy, Chain,
9266                                 DAG.getRegister(Vreg, SPTy));
9267     SDValue Ops1[2] = { Value, Chain };
9268     return DAG.getMergeValues(Ops1, 2, dl);
9269   } else {
9270     SDValue Flag;
9271     unsigned Reg = (Subtarget->is64Bit() ? X86::RAX : X86::EAX);
9272
9273     Chain = DAG.getCopyToReg(Chain, dl, Reg, Size, Flag);
9274     Flag = Chain.getValue(1);
9275     SDVTList NodeTys = DAG.getVTList(MVT::Other, MVT::Glue);
9276
9277     Chain = DAG.getNode(X86ISD::WIN_ALLOCA, dl, NodeTys, Chain, Flag);
9278     Flag = Chain.getValue(1);
9279
9280     Chain = DAG.getCopyFromReg(Chain, dl, X86StackPtr, SPTy).getValue(1);
9281
9282     SDValue Ops1[2] = { Chain.getValue(0), Chain };
9283     return DAG.getMergeValues(Ops1, 2, dl);
9284   }
9285 }
9286
9287 SDValue X86TargetLowering::LowerVASTART(SDValue Op, SelectionDAG &DAG) const {
9288   MachineFunction &MF = DAG.getMachineFunction();
9289   X86MachineFunctionInfo *FuncInfo = MF.getInfo<X86MachineFunctionInfo>();
9290
9291   const Value *SV = cast<SrcValueSDNode>(Op.getOperand(2))->getValue();
9292   DebugLoc DL = Op.getDebugLoc();
9293
9294   if (!Subtarget->is64Bit() || Subtarget->isTargetWin64()) {
9295     // vastart just stores the address of the VarArgsFrameIndex slot into the
9296     // memory location argument.
9297     SDValue FR = DAG.getFrameIndex(FuncInfo->getVarArgsFrameIndex(),
9298                                    getPointerTy());
9299     return DAG.getStore(Op.getOperand(0), DL, FR, Op.getOperand(1),
9300                         MachinePointerInfo(SV), false, false, 0);
9301   }
9302
9303   // __va_list_tag:
9304   //   gp_offset         (0 - 6 * 8)
9305   //   fp_offset         (48 - 48 + 8 * 16)
9306   //   overflow_arg_area (point to parameters coming in memory).
9307   //   reg_save_area
9308   SmallVector<SDValue, 8> MemOps;
9309   SDValue FIN = Op.getOperand(1);
9310   // Store gp_offset
9311   SDValue Store = DAG.getStore(Op.getOperand(0), DL,
9312                                DAG.getConstant(FuncInfo->getVarArgsGPOffset(),
9313                                                MVT::i32),
9314                                FIN, MachinePointerInfo(SV), false, false, 0);
9315   MemOps.push_back(Store);
9316
9317   // Store fp_offset
9318   FIN = DAG.getNode(ISD::ADD, DL, getPointerTy(),
9319                     FIN, DAG.getIntPtrConstant(4));
9320   Store = DAG.getStore(Op.getOperand(0), DL,
9321                        DAG.getConstant(FuncInfo->getVarArgsFPOffset(),
9322                                        MVT::i32),
9323                        FIN, MachinePointerInfo(SV, 4), false, false, 0);
9324   MemOps.push_back(Store);
9325
9326   // Store ptr to overflow_arg_area
9327   FIN = DAG.getNode(ISD::ADD, DL, getPointerTy(),
9328                     FIN, DAG.getIntPtrConstant(4));
9329   SDValue OVFIN = DAG.getFrameIndex(FuncInfo->getVarArgsFrameIndex(),
9330                                     getPointerTy());
9331   Store = DAG.getStore(Op.getOperand(0), DL, OVFIN, FIN,
9332                        MachinePointerInfo(SV, 8),
9333                        false, false, 0);
9334   MemOps.push_back(Store);
9335
9336   // Store ptr to reg_save_area.
9337   FIN = DAG.getNode(ISD::ADD, DL, getPointerTy(),
9338                     FIN, DAG.getIntPtrConstant(8));
9339   SDValue RSFIN = DAG.getFrameIndex(FuncInfo->getRegSaveFrameIndex(),
9340                                     getPointerTy());
9341   Store = DAG.getStore(Op.getOperand(0), DL, RSFIN, FIN,
9342                        MachinePointerInfo(SV, 16), false, false, 0);
9343   MemOps.push_back(Store);
9344   return DAG.getNode(ISD::TokenFactor, DL, MVT::Other,
9345                      &MemOps[0], MemOps.size());
9346 }
9347
9348 SDValue X86TargetLowering::LowerVAARG(SDValue Op, SelectionDAG &DAG) const {
9349   assert(Subtarget->is64Bit() &&
9350          "LowerVAARG only handles 64-bit va_arg!");
9351   assert((Subtarget->isTargetLinux() ||
9352           Subtarget->isTargetDarwin()) &&
9353           "Unhandled target in LowerVAARG");
9354   assert(Op.getNode()->getNumOperands() == 4);
9355   SDValue Chain = Op.getOperand(0);
9356   SDValue SrcPtr = Op.getOperand(1);
9357   const Value *SV = cast<SrcValueSDNode>(Op.getOperand(2))->getValue();
9358   unsigned Align = Op.getConstantOperandVal(3);
9359   DebugLoc dl = Op.getDebugLoc();
9360
9361   EVT ArgVT = Op.getNode()->getValueType(0);
9362   Type *ArgTy = ArgVT.getTypeForEVT(*DAG.getContext());
9363   uint32_t ArgSize = getTargetData()->getTypeAllocSize(ArgTy);
9364   uint8_t ArgMode;
9365
9366   // Decide which area this value should be read from.
9367   // TODO: Implement the AMD64 ABI in its entirety. This simple
9368   // selection mechanism works only for the basic types.
9369   if (ArgVT == MVT::f80) {
9370     llvm_unreachable("va_arg for f80 not yet implemented");
9371   } else if (ArgVT.isFloatingPoint() && ArgSize <= 16 /*bytes*/) {
9372     ArgMode = 2;  // Argument passed in XMM register. Use fp_offset.
9373   } else if (ArgVT.isInteger() && ArgSize <= 32 /*bytes*/) {
9374     ArgMode = 1;  // Argument passed in GPR64 register(s). Use gp_offset.
9375   } else {
9376     llvm_unreachable("Unhandled argument type in LowerVAARG");
9377   }
9378
9379   if (ArgMode == 2) {
9380     // Sanity Check: Make sure using fp_offset makes sense.
9381     assert(!getTargetMachine().Options.UseSoftFloat &&
9382            !(DAG.getMachineFunction()
9383                 .getFunction()->hasFnAttr(Attribute::NoImplicitFloat)) &&
9384            Subtarget->hasSSE1());
9385   }
9386
9387   // Insert VAARG_64 node into the DAG
9388   // VAARG_64 returns two values: Variable Argument Address, Chain
9389   SmallVector<SDValue, 11> InstOps;
9390   InstOps.push_back(Chain);
9391   InstOps.push_back(SrcPtr);
9392   InstOps.push_back(DAG.getConstant(ArgSize, MVT::i32));
9393   InstOps.push_back(DAG.getConstant(ArgMode, MVT::i8));
9394   InstOps.push_back(DAG.getConstant(Align, MVT::i32));
9395   SDVTList VTs = DAG.getVTList(getPointerTy(), MVT::Other);
9396   SDValue VAARG = DAG.getMemIntrinsicNode(X86ISD::VAARG_64, dl,
9397                                           VTs, &InstOps[0], InstOps.size(),
9398                                           MVT::i64,
9399                                           MachinePointerInfo(SV),
9400                                           /*Align=*/0,
9401                                           /*Volatile=*/false,
9402                                           /*ReadMem=*/true,
9403                                           /*WriteMem=*/true);
9404   Chain = VAARG.getValue(1);
9405
9406   // Load the next argument and return it
9407   return DAG.getLoad(ArgVT, dl,
9408                      Chain,
9409                      VAARG,
9410                      MachinePointerInfo(),
9411                      false, false, false, 0);
9412 }
9413
9414 SDValue X86TargetLowering::LowerVACOPY(SDValue Op, SelectionDAG &DAG) const {
9415   // X86-64 va_list is a struct { i32, i32, i8*, i8* }.
9416   assert(Subtarget->is64Bit() && "This code only handles 64-bit va_copy!");
9417   SDValue Chain = Op.getOperand(0);
9418   SDValue DstPtr = Op.getOperand(1);
9419   SDValue SrcPtr = Op.getOperand(2);
9420   const Value *DstSV = cast<SrcValueSDNode>(Op.getOperand(3))->getValue();
9421   const Value *SrcSV = cast<SrcValueSDNode>(Op.getOperand(4))->getValue();
9422   DebugLoc DL = Op.getDebugLoc();
9423
9424   return DAG.getMemcpy(Chain, DL, DstPtr, SrcPtr,
9425                        DAG.getIntPtrConstant(24), 8, /*isVolatile*/false,
9426                        false,
9427                        MachinePointerInfo(DstSV), MachinePointerInfo(SrcSV));
9428 }
9429
9430 // getTargetVShiftNOde - Handle vector element shifts where the shift amount
9431 // may or may not be a constant. Takes immediate version of shift as input.
9432 static SDValue getTargetVShiftNode(unsigned Opc, DebugLoc dl, EVT VT,
9433                                    SDValue SrcOp, SDValue ShAmt,
9434                                    SelectionDAG &DAG) {
9435   assert(ShAmt.getValueType() == MVT::i32 && "ShAmt is not i32");
9436
9437   if (isa<ConstantSDNode>(ShAmt)) {
9438     // Constant may be a TargetConstant. Use a regular constant.
9439     uint32_t ShiftAmt = cast<ConstantSDNode>(ShAmt)->getZExtValue();
9440     switch (Opc) {
9441       default: llvm_unreachable("Unknown target vector shift node");
9442       case X86ISD::VSHLI:
9443       case X86ISD::VSRLI:
9444       case X86ISD::VSRAI:
9445         return DAG.getNode(Opc, dl, VT, SrcOp,
9446                            DAG.getConstant(ShiftAmt, MVT::i32));
9447     }
9448   }
9449
9450   // Change opcode to non-immediate version
9451   switch (Opc) {
9452     default: llvm_unreachable("Unknown target vector shift node");
9453     case X86ISD::VSHLI: Opc = X86ISD::VSHL; break;
9454     case X86ISD::VSRLI: Opc = X86ISD::VSRL; break;
9455     case X86ISD::VSRAI: Opc = X86ISD::VSRA; break;
9456   }
9457
9458   // Need to build a vector containing shift amount
9459   // Shift amount is 32-bits, but SSE instructions read 64-bit, so fill with 0
9460   SDValue ShOps[4];
9461   ShOps[0] = ShAmt;
9462   ShOps[1] = DAG.getConstant(0, MVT::i32);
9463   ShOps[2] = DAG.getUNDEF(MVT::i32);
9464   ShOps[3] = DAG.getUNDEF(MVT::i32);
9465   ShAmt = DAG.getNode(ISD::BUILD_VECTOR, dl, MVT::v4i32, &ShOps[0], 4);
9466
9467   // The return type has to be a 128-bit type with the same element
9468   // type as the input type.
9469   MVT EltVT = VT.getVectorElementType().getSimpleVT();
9470   EVT ShVT = MVT::getVectorVT(EltVT, 128/EltVT.getSizeInBits());
9471
9472   ShAmt = DAG.getNode(ISD::BITCAST, dl, ShVT, ShAmt);
9473   return DAG.getNode(Opc, dl, VT, SrcOp, ShAmt);
9474 }
9475
9476 SDValue
9477 X86TargetLowering::LowerINTRINSIC_WO_CHAIN(SDValue Op, SelectionDAG &DAG) const {
9478   DebugLoc dl = Op.getDebugLoc();
9479   unsigned IntNo = cast<ConstantSDNode>(Op.getOperand(0))->getZExtValue();
9480   switch (IntNo) {
9481   default: return SDValue();    // Don't custom lower most intrinsics.
9482   // Comparison intrinsics.
9483   case Intrinsic::x86_sse_comieq_ss:
9484   case Intrinsic::x86_sse_comilt_ss:
9485   case Intrinsic::x86_sse_comile_ss:
9486   case Intrinsic::x86_sse_comigt_ss:
9487   case Intrinsic::x86_sse_comige_ss:
9488   case Intrinsic::x86_sse_comineq_ss:
9489   case Intrinsic::x86_sse_ucomieq_ss:
9490   case Intrinsic::x86_sse_ucomilt_ss:
9491   case Intrinsic::x86_sse_ucomile_ss:
9492   case Intrinsic::x86_sse_ucomigt_ss:
9493   case Intrinsic::x86_sse_ucomige_ss:
9494   case Intrinsic::x86_sse_ucomineq_ss:
9495   case Intrinsic::x86_sse2_comieq_sd:
9496   case Intrinsic::x86_sse2_comilt_sd:
9497   case Intrinsic::x86_sse2_comile_sd:
9498   case Intrinsic::x86_sse2_comigt_sd:
9499   case Intrinsic::x86_sse2_comige_sd:
9500   case Intrinsic::x86_sse2_comineq_sd:
9501   case Intrinsic::x86_sse2_ucomieq_sd:
9502   case Intrinsic::x86_sse2_ucomilt_sd:
9503   case Intrinsic::x86_sse2_ucomile_sd:
9504   case Intrinsic::x86_sse2_ucomigt_sd:
9505   case Intrinsic::x86_sse2_ucomige_sd:
9506   case Intrinsic::x86_sse2_ucomineq_sd: {
9507     unsigned Opc = 0;
9508     ISD::CondCode CC = ISD::SETCC_INVALID;
9509     switch (IntNo) {
9510     default: llvm_unreachable("Impossible intrinsic");  // Can't reach here.
9511     case Intrinsic::x86_sse_comieq_ss:
9512     case Intrinsic::x86_sse2_comieq_sd:
9513       Opc = X86ISD::COMI;
9514       CC = ISD::SETEQ;
9515       break;
9516     case Intrinsic::x86_sse_comilt_ss:
9517     case Intrinsic::x86_sse2_comilt_sd:
9518       Opc = X86ISD::COMI;
9519       CC = ISD::SETLT;
9520       break;
9521     case Intrinsic::x86_sse_comile_ss:
9522     case Intrinsic::x86_sse2_comile_sd:
9523       Opc = X86ISD::COMI;
9524       CC = ISD::SETLE;
9525       break;
9526     case Intrinsic::x86_sse_comigt_ss:
9527     case Intrinsic::x86_sse2_comigt_sd:
9528       Opc = X86ISD::COMI;
9529       CC = ISD::SETGT;
9530       break;
9531     case Intrinsic::x86_sse_comige_ss:
9532     case Intrinsic::x86_sse2_comige_sd:
9533       Opc = X86ISD::COMI;
9534       CC = ISD::SETGE;
9535       break;
9536     case Intrinsic::x86_sse_comineq_ss:
9537     case Intrinsic::x86_sse2_comineq_sd:
9538       Opc = X86ISD::COMI;
9539       CC = ISD::SETNE;
9540       break;
9541     case Intrinsic::x86_sse_ucomieq_ss:
9542     case Intrinsic::x86_sse2_ucomieq_sd:
9543       Opc = X86ISD::UCOMI;
9544       CC = ISD::SETEQ;
9545       break;
9546     case Intrinsic::x86_sse_ucomilt_ss:
9547     case Intrinsic::x86_sse2_ucomilt_sd:
9548       Opc = X86ISD::UCOMI;
9549       CC = ISD::SETLT;
9550       break;
9551     case Intrinsic::x86_sse_ucomile_ss:
9552     case Intrinsic::x86_sse2_ucomile_sd:
9553       Opc = X86ISD::UCOMI;
9554       CC = ISD::SETLE;
9555       break;
9556     case Intrinsic::x86_sse_ucomigt_ss:
9557     case Intrinsic::x86_sse2_ucomigt_sd:
9558       Opc = X86ISD::UCOMI;
9559       CC = ISD::SETGT;
9560       break;
9561     case Intrinsic::x86_sse_ucomige_ss:
9562     case Intrinsic::x86_sse2_ucomige_sd:
9563       Opc = X86ISD::UCOMI;
9564       CC = ISD::SETGE;
9565       break;
9566     case Intrinsic::x86_sse_ucomineq_ss:
9567     case Intrinsic::x86_sse2_ucomineq_sd:
9568       Opc = X86ISD::UCOMI;
9569       CC = ISD::SETNE;
9570       break;
9571     }
9572
9573     SDValue LHS = Op.getOperand(1);
9574     SDValue RHS = Op.getOperand(2);
9575     unsigned X86CC = TranslateX86CC(CC, true, LHS, RHS, DAG);
9576     assert(X86CC != X86::COND_INVALID && "Unexpected illegal condition!");
9577     SDValue Cond = DAG.getNode(Opc, dl, MVT::i32, LHS, RHS);
9578     SDValue SetCC = DAG.getNode(X86ISD::SETCC, dl, MVT::i8,
9579                                 DAG.getConstant(X86CC, MVT::i8), Cond);
9580     return DAG.getNode(ISD::ZERO_EXTEND, dl, MVT::i32, SetCC);
9581   }
9582   // Arithmetic intrinsics.
9583   case Intrinsic::x86_sse2_pmulu_dq:
9584   case Intrinsic::x86_avx2_pmulu_dq:
9585     return DAG.getNode(X86ISD::PMULUDQ, dl, Op.getValueType(),
9586                        Op.getOperand(1), Op.getOperand(2));
9587   case Intrinsic::x86_sse3_hadd_ps:
9588   case Intrinsic::x86_sse3_hadd_pd:
9589   case Intrinsic::x86_avx_hadd_ps_256:
9590   case Intrinsic::x86_avx_hadd_pd_256:
9591     return DAG.getNode(X86ISD::FHADD, dl, Op.getValueType(),
9592                        Op.getOperand(1), Op.getOperand(2));
9593   case Intrinsic::x86_sse3_hsub_ps:
9594   case Intrinsic::x86_sse3_hsub_pd:
9595   case Intrinsic::x86_avx_hsub_ps_256:
9596   case Intrinsic::x86_avx_hsub_pd_256:
9597     return DAG.getNode(X86ISD::FHSUB, dl, Op.getValueType(),
9598                        Op.getOperand(1), Op.getOperand(2));
9599   case Intrinsic::x86_ssse3_phadd_w_128:
9600   case Intrinsic::x86_ssse3_phadd_d_128:
9601   case Intrinsic::x86_avx2_phadd_w:
9602   case Intrinsic::x86_avx2_phadd_d:
9603     return DAG.getNode(X86ISD::HADD, dl, Op.getValueType(),
9604                        Op.getOperand(1), Op.getOperand(2));
9605   case Intrinsic::x86_ssse3_phsub_w_128:
9606   case Intrinsic::x86_ssse3_phsub_d_128:
9607   case Intrinsic::x86_avx2_phsub_w:
9608   case Intrinsic::x86_avx2_phsub_d:
9609     return DAG.getNode(X86ISD::HSUB, dl, Op.getValueType(),
9610                        Op.getOperand(1), Op.getOperand(2));
9611   case Intrinsic::x86_avx2_psllv_d:
9612   case Intrinsic::x86_avx2_psllv_q:
9613   case Intrinsic::x86_avx2_psllv_d_256:
9614   case Intrinsic::x86_avx2_psllv_q_256:
9615     return DAG.getNode(ISD::SHL, dl, Op.getValueType(),
9616                       Op.getOperand(1), Op.getOperand(2));
9617   case Intrinsic::x86_avx2_psrlv_d:
9618   case Intrinsic::x86_avx2_psrlv_q:
9619   case Intrinsic::x86_avx2_psrlv_d_256:
9620   case Intrinsic::x86_avx2_psrlv_q_256:
9621     return DAG.getNode(ISD::SRL, dl, Op.getValueType(),
9622                       Op.getOperand(1), Op.getOperand(2));
9623   case Intrinsic::x86_avx2_psrav_d:
9624   case Intrinsic::x86_avx2_psrav_d_256:
9625     return DAG.getNode(ISD::SRA, dl, Op.getValueType(),
9626                       Op.getOperand(1), Op.getOperand(2));
9627   case Intrinsic::x86_ssse3_pshuf_b_128:
9628   case Intrinsic::x86_avx2_pshuf_b:
9629     return DAG.getNode(X86ISD::PSHUFB, dl, Op.getValueType(),
9630                        Op.getOperand(1), Op.getOperand(2));
9631   case Intrinsic::x86_ssse3_psign_b_128:
9632   case Intrinsic::x86_ssse3_psign_w_128:
9633   case Intrinsic::x86_ssse3_psign_d_128:
9634   case Intrinsic::x86_avx2_psign_b:
9635   case Intrinsic::x86_avx2_psign_w:
9636   case Intrinsic::x86_avx2_psign_d:
9637     return DAG.getNode(X86ISD::PSIGN, dl, Op.getValueType(),
9638                        Op.getOperand(1), Op.getOperand(2));
9639   case Intrinsic::x86_sse41_insertps:
9640     return DAG.getNode(X86ISD::INSERTPS, dl, Op.getValueType(),
9641                        Op.getOperand(1), Op.getOperand(2), Op.getOperand(3));
9642   case Intrinsic::x86_avx_vperm2f128_ps_256:
9643   case Intrinsic::x86_avx_vperm2f128_pd_256:
9644   case Intrinsic::x86_avx_vperm2f128_si_256:
9645   case Intrinsic::x86_avx2_vperm2i128:
9646     return DAG.getNode(X86ISD::VPERM2X128, dl, Op.getValueType(),
9647                        Op.getOperand(1), Op.getOperand(2), Op.getOperand(3));
9648   case Intrinsic::x86_avx2_permd:
9649   case Intrinsic::x86_avx2_permps:
9650     // Operands intentionally swapped. Mask is last operand to intrinsic,
9651     // but second operand for node/intruction.
9652     return DAG.getNode(X86ISD::VPERMV, dl, Op.getValueType(),
9653                        Op.getOperand(2), Op.getOperand(1));
9654
9655   // ptest and testp intrinsics. The intrinsic these come from are designed to
9656   // return an integer value, not just an instruction so lower it to the ptest
9657   // or testp pattern and a setcc for the result.
9658   case Intrinsic::x86_sse41_ptestz:
9659   case Intrinsic::x86_sse41_ptestc:
9660   case Intrinsic::x86_sse41_ptestnzc:
9661   case Intrinsic::x86_avx_ptestz_256:
9662   case Intrinsic::x86_avx_ptestc_256:
9663   case Intrinsic::x86_avx_ptestnzc_256:
9664   case Intrinsic::x86_avx_vtestz_ps:
9665   case Intrinsic::x86_avx_vtestc_ps:
9666   case Intrinsic::x86_avx_vtestnzc_ps:
9667   case Intrinsic::x86_avx_vtestz_pd:
9668   case Intrinsic::x86_avx_vtestc_pd:
9669   case Intrinsic::x86_avx_vtestnzc_pd:
9670   case Intrinsic::x86_avx_vtestz_ps_256:
9671   case Intrinsic::x86_avx_vtestc_ps_256:
9672   case Intrinsic::x86_avx_vtestnzc_ps_256:
9673   case Intrinsic::x86_avx_vtestz_pd_256:
9674   case Intrinsic::x86_avx_vtestc_pd_256:
9675   case Intrinsic::x86_avx_vtestnzc_pd_256: {
9676     bool IsTestPacked = false;
9677     unsigned X86CC = 0;
9678     switch (IntNo) {
9679     default: llvm_unreachable("Bad fallthrough in Intrinsic lowering.");
9680     case Intrinsic::x86_avx_vtestz_ps:
9681     case Intrinsic::x86_avx_vtestz_pd:
9682     case Intrinsic::x86_avx_vtestz_ps_256:
9683     case Intrinsic::x86_avx_vtestz_pd_256:
9684       IsTestPacked = true; // Fallthrough
9685     case Intrinsic::x86_sse41_ptestz:
9686     case Intrinsic::x86_avx_ptestz_256:
9687       // ZF = 1
9688       X86CC = X86::COND_E;
9689       break;
9690     case Intrinsic::x86_avx_vtestc_ps:
9691     case Intrinsic::x86_avx_vtestc_pd:
9692     case Intrinsic::x86_avx_vtestc_ps_256:
9693     case Intrinsic::x86_avx_vtestc_pd_256:
9694       IsTestPacked = true; // Fallthrough
9695     case Intrinsic::x86_sse41_ptestc:
9696     case Intrinsic::x86_avx_ptestc_256:
9697       // CF = 1
9698       X86CC = X86::COND_B;
9699       break;
9700     case Intrinsic::x86_avx_vtestnzc_ps:
9701     case Intrinsic::x86_avx_vtestnzc_pd:
9702     case Intrinsic::x86_avx_vtestnzc_ps_256:
9703     case Intrinsic::x86_avx_vtestnzc_pd_256:
9704       IsTestPacked = true; // Fallthrough
9705     case Intrinsic::x86_sse41_ptestnzc:
9706     case Intrinsic::x86_avx_ptestnzc_256:
9707       // ZF and CF = 0
9708       X86CC = X86::COND_A;
9709       break;
9710     }
9711
9712     SDValue LHS = Op.getOperand(1);
9713     SDValue RHS = Op.getOperand(2);
9714     unsigned TestOpc = IsTestPacked ? X86ISD::TESTP : X86ISD::PTEST;
9715     SDValue Test = DAG.getNode(TestOpc, dl, MVT::i32, LHS, RHS);
9716     SDValue CC = DAG.getConstant(X86CC, MVT::i8);
9717     SDValue SetCC = DAG.getNode(X86ISD::SETCC, dl, MVT::i8, CC, Test);
9718     return DAG.getNode(ISD::ZERO_EXTEND, dl, MVT::i32, SetCC);
9719   }
9720
9721   // SSE/AVX shift intrinsics
9722   case Intrinsic::x86_sse2_psll_w:
9723   case Intrinsic::x86_sse2_psll_d:
9724   case Intrinsic::x86_sse2_psll_q:
9725   case Intrinsic::x86_avx2_psll_w:
9726   case Intrinsic::x86_avx2_psll_d:
9727   case Intrinsic::x86_avx2_psll_q:
9728     return DAG.getNode(X86ISD::VSHL, dl, Op.getValueType(),
9729                        Op.getOperand(1), Op.getOperand(2));
9730   case Intrinsic::x86_sse2_psrl_w:
9731   case Intrinsic::x86_sse2_psrl_d:
9732   case Intrinsic::x86_sse2_psrl_q:
9733   case Intrinsic::x86_avx2_psrl_w:
9734   case Intrinsic::x86_avx2_psrl_d:
9735   case Intrinsic::x86_avx2_psrl_q:
9736     return DAG.getNode(X86ISD::VSRL, dl, Op.getValueType(),
9737                        Op.getOperand(1), Op.getOperand(2));
9738   case Intrinsic::x86_sse2_psra_w:
9739   case Intrinsic::x86_sse2_psra_d:
9740   case Intrinsic::x86_avx2_psra_w:
9741   case Intrinsic::x86_avx2_psra_d:
9742     return DAG.getNode(X86ISD::VSRA, dl, Op.getValueType(),
9743                        Op.getOperand(1), Op.getOperand(2));
9744   case Intrinsic::x86_sse2_pslli_w:
9745   case Intrinsic::x86_sse2_pslli_d:
9746   case Intrinsic::x86_sse2_pslli_q:
9747   case Intrinsic::x86_avx2_pslli_w:
9748   case Intrinsic::x86_avx2_pslli_d:
9749   case Intrinsic::x86_avx2_pslli_q:
9750     return getTargetVShiftNode(X86ISD::VSHLI, dl, Op.getValueType(),
9751                                Op.getOperand(1), Op.getOperand(2), DAG);
9752   case Intrinsic::x86_sse2_psrli_w:
9753   case Intrinsic::x86_sse2_psrli_d:
9754   case Intrinsic::x86_sse2_psrli_q:
9755   case Intrinsic::x86_avx2_psrli_w:
9756   case Intrinsic::x86_avx2_psrli_d:
9757   case Intrinsic::x86_avx2_psrli_q:
9758     return getTargetVShiftNode(X86ISD::VSRLI, dl, Op.getValueType(),
9759                                Op.getOperand(1), Op.getOperand(2), DAG);
9760   case Intrinsic::x86_sse2_psrai_w:
9761   case Intrinsic::x86_sse2_psrai_d:
9762   case Intrinsic::x86_avx2_psrai_w:
9763   case Intrinsic::x86_avx2_psrai_d:
9764     return getTargetVShiftNode(X86ISD::VSRAI, dl, Op.getValueType(),
9765                                Op.getOperand(1), Op.getOperand(2), DAG);
9766   // Fix vector shift instructions where the last operand is a non-immediate
9767   // i32 value.
9768   case Intrinsic::x86_mmx_pslli_w:
9769   case Intrinsic::x86_mmx_pslli_d:
9770   case Intrinsic::x86_mmx_pslli_q:
9771   case Intrinsic::x86_mmx_psrli_w:
9772   case Intrinsic::x86_mmx_psrli_d:
9773   case Intrinsic::x86_mmx_psrli_q:
9774   case Intrinsic::x86_mmx_psrai_w:
9775   case Intrinsic::x86_mmx_psrai_d: {
9776     SDValue ShAmt = Op.getOperand(2);
9777     if (isa<ConstantSDNode>(ShAmt))
9778       return SDValue();
9779
9780     unsigned NewIntNo = 0;
9781     switch (IntNo) {
9782     case Intrinsic::x86_mmx_pslli_w:
9783       NewIntNo = Intrinsic::x86_mmx_psll_w;
9784       break;
9785     case Intrinsic::x86_mmx_pslli_d:
9786       NewIntNo = Intrinsic::x86_mmx_psll_d;
9787       break;
9788     case Intrinsic::x86_mmx_pslli_q:
9789       NewIntNo = Intrinsic::x86_mmx_psll_q;
9790       break;
9791     case Intrinsic::x86_mmx_psrli_w:
9792       NewIntNo = Intrinsic::x86_mmx_psrl_w;
9793       break;
9794     case Intrinsic::x86_mmx_psrli_d:
9795       NewIntNo = Intrinsic::x86_mmx_psrl_d;
9796       break;
9797     case Intrinsic::x86_mmx_psrli_q:
9798       NewIntNo = Intrinsic::x86_mmx_psrl_q;
9799       break;
9800     case Intrinsic::x86_mmx_psrai_w:
9801       NewIntNo = Intrinsic::x86_mmx_psra_w;
9802       break;
9803     case Intrinsic::x86_mmx_psrai_d:
9804       NewIntNo = Intrinsic::x86_mmx_psra_d;
9805       break;
9806     default: llvm_unreachable("Impossible intrinsic");  // Can't reach here.
9807     }
9808
9809     // The vector shift intrinsics with scalars uses 32b shift amounts but
9810     // the sse2/mmx shift instructions reads 64 bits. Set the upper 32 bits
9811     // to be zero.
9812     ShAmt =  DAG.getNode(ISD::BUILD_VECTOR, dl, MVT::v2i32, ShAmt,
9813                          DAG.getConstant(0, MVT::i32));
9814 // FIXME this must be lowered to get rid of the invalid type.
9815
9816     EVT VT = Op.getValueType();
9817     ShAmt = DAG.getNode(ISD::BITCAST, dl, VT, ShAmt);
9818     return DAG.getNode(ISD::INTRINSIC_WO_CHAIN, dl, VT,
9819                        DAG.getConstant(NewIntNo, MVT::i32),
9820                        Op.getOperand(1), ShAmt);
9821   }
9822   case Intrinsic::x86_sse42_pcmpistria128:
9823   case Intrinsic::x86_sse42_pcmpestria128:
9824   case Intrinsic::x86_sse42_pcmpistric128:
9825   case Intrinsic::x86_sse42_pcmpestric128:
9826   case Intrinsic::x86_sse42_pcmpistrio128:
9827   case Intrinsic::x86_sse42_pcmpestrio128:
9828   case Intrinsic::x86_sse42_pcmpistris128:
9829   case Intrinsic::x86_sse42_pcmpestris128:
9830   case Intrinsic::x86_sse42_pcmpistriz128:
9831   case Intrinsic::x86_sse42_pcmpestriz128: {
9832     unsigned Opcode;
9833     unsigned X86CC;
9834     switch (IntNo) {
9835     default: llvm_unreachable("Impossible intrinsic");  // Can't reach here.
9836     case Intrinsic::x86_sse42_pcmpistria128:
9837       Opcode = X86ISD::PCMPISTRI;
9838       X86CC = X86::COND_A;
9839       break;
9840     case Intrinsic::x86_sse42_pcmpestria128:
9841       Opcode = X86ISD::PCMPESTRI;
9842       X86CC = X86::COND_A;
9843       break;
9844     case Intrinsic::x86_sse42_pcmpistric128:
9845       Opcode = X86ISD::PCMPISTRI;
9846       X86CC = X86::COND_B;
9847       break;
9848     case Intrinsic::x86_sse42_pcmpestric128:
9849       Opcode = X86ISD::PCMPESTRI;
9850       X86CC = X86::COND_B;
9851       break;
9852     case Intrinsic::x86_sse42_pcmpistrio128:
9853       Opcode = X86ISD::PCMPISTRI;
9854       X86CC = X86::COND_O;
9855       break;
9856     case Intrinsic::x86_sse42_pcmpestrio128:
9857       Opcode = X86ISD::PCMPESTRI;
9858       X86CC = X86::COND_O;
9859       break;
9860     case Intrinsic::x86_sse42_pcmpistris128:
9861       Opcode = X86ISD::PCMPISTRI;
9862       X86CC = X86::COND_S;
9863       break;
9864     case Intrinsic::x86_sse42_pcmpestris128:
9865       Opcode = X86ISD::PCMPESTRI;
9866       X86CC = X86::COND_S;
9867       break;
9868     case Intrinsic::x86_sse42_pcmpistriz128:
9869       Opcode = X86ISD::PCMPISTRI;
9870       X86CC = X86::COND_E;
9871       break;
9872     case Intrinsic::x86_sse42_pcmpestriz128:
9873       Opcode = X86ISD::PCMPESTRI;
9874       X86CC = X86::COND_E;
9875       break;
9876     }
9877     SmallVector<SDValue, 5> NewOps;
9878     NewOps.append(Op->op_begin()+1, Op->op_end());
9879     SDVTList VTs = DAG.getVTList(Op.getValueType(), MVT::i32);
9880     SDValue PCMP = DAG.getNode(Opcode, dl, VTs, NewOps.data(), NewOps.size());
9881     SDValue SetCC = DAG.getNode(X86ISD::SETCC, dl, MVT::i8,
9882                                 DAG.getConstant(X86CC, MVT::i8),
9883                                 SDValue(PCMP.getNode(), 1));
9884     return DAG.getNode(ISD::ZERO_EXTEND, dl, MVT::i32, SetCC);
9885   }
9886   case Intrinsic::x86_sse42_pcmpistri128:
9887   case Intrinsic::x86_sse42_pcmpestri128: {
9888     unsigned Opcode;
9889     if (IntNo == Intrinsic::x86_sse42_pcmpistri128)
9890       Opcode = X86ISD::PCMPISTRI;
9891     else
9892       Opcode = X86ISD::PCMPESTRI;
9893
9894     SmallVector<SDValue, 5> NewOps;
9895     NewOps.append(Op->op_begin()+1, Op->op_end());
9896     SDVTList VTs = DAG.getVTList(Op.getValueType(), MVT::i32);
9897     return DAG.getNode(Opcode, dl, VTs, NewOps.data(), NewOps.size());
9898   }
9899   }
9900 }
9901
9902 SDValue
9903 X86TargetLowering::LowerINTRINSIC_W_CHAIN(SDValue Op, SelectionDAG &DAG) const {
9904   DebugLoc dl = Op.getDebugLoc();
9905   unsigned IntNo = cast<ConstantSDNode>(Op.getOperand(1))->getZExtValue();
9906   switch (IntNo) {
9907   default: return SDValue();    // Don't custom lower most intrinsics.
9908
9909   // RDRAND intrinsics.
9910   case Intrinsic::x86_rdrand_16:
9911   case Intrinsic::x86_rdrand_32:
9912   case Intrinsic::x86_rdrand_64: {
9913     // Emit the node with the right value type.
9914     SDVTList VTs = DAG.getVTList(Op->getValueType(0), MVT::Glue, MVT::Other);
9915     SDValue Result = DAG.getNode(X86ISD::RDRAND, dl, VTs, Op.getOperand(0));
9916
9917     // If the value returned by RDRAND was valid (CF=1), return 1. Otherwise
9918     // return the value from Rand, which is always 0, casted to i32.
9919     SDValue Ops[] = { DAG.getZExtOrTrunc(Result, dl, Op->getValueType(1)),
9920                       DAG.getConstant(1, Op->getValueType(1)),
9921                       DAG.getConstant(X86::COND_B, MVT::i32),
9922                       SDValue(Result.getNode(), 1) };
9923     SDValue isValid = DAG.getNode(X86ISD::CMOV, dl,
9924                                   DAG.getVTList(Op->getValueType(1), MVT::Glue),
9925                                   Ops, 4);
9926
9927     // Return { result, isValid, chain }.
9928     return DAG.getNode(ISD::MERGE_VALUES, dl, Op->getVTList(), Result, isValid,
9929                        SDValue(Result.getNode(), 2));
9930   }
9931   }
9932 }
9933
9934 SDValue X86TargetLowering::LowerRETURNADDR(SDValue Op,
9935                                            SelectionDAG &DAG) const {
9936   MachineFrameInfo *MFI = DAG.getMachineFunction().getFrameInfo();
9937   MFI->setReturnAddressIsTaken(true);
9938
9939   unsigned Depth = cast<ConstantSDNode>(Op.getOperand(0))->getZExtValue();
9940   DebugLoc dl = Op.getDebugLoc();
9941
9942   if (Depth > 0) {
9943     SDValue FrameAddr = LowerFRAMEADDR(Op, DAG);
9944     SDValue Offset =
9945       DAG.getConstant(TD->getPointerSize(),
9946                       Subtarget->is64Bit() ? MVT::i64 : MVT::i32);
9947     return DAG.getLoad(getPointerTy(), dl, DAG.getEntryNode(),
9948                        DAG.getNode(ISD::ADD, dl, getPointerTy(),
9949                                    FrameAddr, Offset),
9950                        MachinePointerInfo(), false, false, false, 0);
9951   }
9952
9953   // Just load the return address.
9954   SDValue RetAddrFI = getReturnAddressFrameIndex(DAG);
9955   return DAG.getLoad(getPointerTy(), dl, DAG.getEntryNode(),
9956                      RetAddrFI, MachinePointerInfo(), false, false, false, 0);
9957 }
9958
9959 SDValue X86TargetLowering::LowerFRAMEADDR(SDValue Op, SelectionDAG &DAG) const {
9960   MachineFrameInfo *MFI = DAG.getMachineFunction().getFrameInfo();
9961   MFI->setFrameAddressIsTaken(true);
9962
9963   EVT VT = Op.getValueType();
9964   DebugLoc dl = Op.getDebugLoc();  // FIXME probably not meaningful
9965   unsigned Depth = cast<ConstantSDNode>(Op.getOperand(0))->getZExtValue();
9966   unsigned FrameReg = Subtarget->is64Bit() ? X86::RBP : X86::EBP;
9967   SDValue FrameAddr = DAG.getCopyFromReg(DAG.getEntryNode(), dl, FrameReg, VT);
9968   while (Depth--)
9969     FrameAddr = DAG.getLoad(VT, dl, DAG.getEntryNode(), FrameAddr,
9970                             MachinePointerInfo(),
9971                             false, false, false, 0);
9972   return FrameAddr;
9973 }
9974
9975 SDValue X86TargetLowering::LowerFRAME_TO_ARGS_OFFSET(SDValue Op,
9976                                                      SelectionDAG &DAG) const {
9977   return DAG.getIntPtrConstant(2*TD->getPointerSize());
9978 }
9979
9980 SDValue X86TargetLowering::LowerEH_RETURN(SDValue Op, SelectionDAG &DAG) const {
9981   SDValue Chain     = Op.getOperand(0);
9982   SDValue Offset    = Op.getOperand(1);
9983   SDValue Handler   = Op.getOperand(2);
9984   DebugLoc dl       = Op.getDebugLoc();
9985
9986   SDValue Frame = DAG.getCopyFromReg(DAG.getEntryNode(), dl,
9987                                      Subtarget->is64Bit() ? X86::RBP : X86::EBP,
9988                                      getPointerTy());
9989   unsigned StoreAddrReg = (Subtarget->is64Bit() ? X86::RCX : X86::ECX);
9990
9991   SDValue StoreAddr = DAG.getNode(ISD::ADD, dl, getPointerTy(), Frame,
9992                                   DAG.getIntPtrConstant(TD->getPointerSize()));
9993   StoreAddr = DAG.getNode(ISD::ADD, dl, getPointerTy(), StoreAddr, Offset);
9994   Chain = DAG.getStore(Chain, dl, Handler, StoreAddr, MachinePointerInfo(),
9995                        false, false, 0);
9996   Chain = DAG.getCopyToReg(Chain, dl, StoreAddrReg, StoreAddr);
9997
9998   return DAG.getNode(X86ISD::EH_RETURN, dl,
9999                      MVT::Other,
10000                      Chain, DAG.getRegister(StoreAddrReg, getPointerTy()));
10001 }
10002
10003 SDValue X86TargetLowering::LowerADJUST_TRAMPOLINE(SDValue Op,
10004                                                   SelectionDAG &DAG) const {
10005   return Op.getOperand(0);
10006 }
10007
10008 SDValue X86TargetLowering::LowerINIT_TRAMPOLINE(SDValue Op,
10009                                                 SelectionDAG &DAG) const {
10010   SDValue Root = Op.getOperand(0);
10011   SDValue Trmp = Op.getOperand(1); // trampoline
10012   SDValue FPtr = Op.getOperand(2); // nested function
10013   SDValue Nest = Op.getOperand(3); // 'nest' parameter value
10014   DebugLoc dl  = Op.getDebugLoc();
10015
10016   const Value *TrmpAddr = cast<SrcValueSDNode>(Op.getOperand(4))->getValue();
10017
10018   if (Subtarget->is64Bit()) {
10019     SDValue OutChains[6];
10020
10021     // Large code-model.
10022     const unsigned char JMP64r  = 0xFF; // 64-bit jmp through register opcode.
10023     const unsigned char MOV64ri = 0xB8; // X86::MOV64ri opcode.
10024
10025     const unsigned char N86R10 = X86_MC::getX86RegNum(X86::R10);
10026     const unsigned char N86R11 = X86_MC::getX86RegNum(X86::R11);
10027
10028     const unsigned char REX_WB = 0x40 | 0x08 | 0x01; // REX prefix
10029
10030     // Load the pointer to the nested function into R11.
10031     unsigned OpCode = ((MOV64ri | N86R11) << 8) | REX_WB; // movabsq r11
10032     SDValue Addr = Trmp;
10033     OutChains[0] = DAG.getStore(Root, dl, DAG.getConstant(OpCode, MVT::i16),
10034                                 Addr, MachinePointerInfo(TrmpAddr),
10035                                 false, false, 0);
10036
10037     Addr = DAG.getNode(ISD::ADD, dl, MVT::i64, Trmp,
10038                        DAG.getConstant(2, MVT::i64));
10039     OutChains[1] = DAG.getStore(Root, dl, FPtr, Addr,
10040                                 MachinePointerInfo(TrmpAddr, 2),
10041                                 false, false, 2);
10042
10043     // Load the 'nest' parameter value into R10.
10044     // R10 is specified in X86CallingConv.td
10045     OpCode = ((MOV64ri | N86R10) << 8) | REX_WB; // movabsq r10
10046     Addr = DAG.getNode(ISD::ADD, dl, MVT::i64, Trmp,
10047                        DAG.getConstant(10, MVT::i64));
10048     OutChains[2] = DAG.getStore(Root, dl, DAG.getConstant(OpCode, MVT::i16),
10049                                 Addr, MachinePointerInfo(TrmpAddr, 10),
10050                                 false, false, 0);
10051
10052     Addr = DAG.getNode(ISD::ADD, dl, MVT::i64, Trmp,
10053                        DAG.getConstant(12, MVT::i64));
10054     OutChains[3] = DAG.getStore(Root, dl, Nest, Addr,
10055                                 MachinePointerInfo(TrmpAddr, 12),
10056                                 false, false, 2);
10057
10058     // Jump to the nested function.
10059     OpCode = (JMP64r << 8) | REX_WB; // jmpq *...
10060     Addr = DAG.getNode(ISD::ADD, dl, MVT::i64, Trmp,
10061                        DAG.getConstant(20, MVT::i64));
10062     OutChains[4] = DAG.getStore(Root, dl, DAG.getConstant(OpCode, MVT::i16),
10063                                 Addr, MachinePointerInfo(TrmpAddr, 20),
10064                                 false, false, 0);
10065
10066     unsigned char ModRM = N86R11 | (4 << 3) | (3 << 6); // ...r11
10067     Addr = DAG.getNode(ISD::ADD, dl, MVT::i64, Trmp,
10068                        DAG.getConstant(22, MVT::i64));
10069     OutChains[5] = DAG.getStore(Root, dl, DAG.getConstant(ModRM, MVT::i8), Addr,
10070                                 MachinePointerInfo(TrmpAddr, 22),
10071                                 false, false, 0);
10072
10073     return DAG.getNode(ISD::TokenFactor, dl, MVT::Other, OutChains, 6);
10074   } else {
10075     const Function *Func =
10076       cast<Function>(cast<SrcValueSDNode>(Op.getOperand(5))->getValue());
10077     CallingConv::ID CC = Func->getCallingConv();
10078     unsigned NestReg;
10079
10080     switch (CC) {
10081     default:
10082       llvm_unreachable("Unsupported calling convention");
10083     case CallingConv::C:
10084     case CallingConv::X86_StdCall: {
10085       // Pass 'nest' parameter in ECX.
10086       // Must be kept in sync with X86CallingConv.td
10087       NestReg = X86::ECX;
10088
10089       // Check that ECX wasn't needed by an 'inreg' parameter.
10090       FunctionType *FTy = Func->getFunctionType();
10091       const AttrListPtr &Attrs = Func->getAttributes();
10092
10093       if (!Attrs.isEmpty() && !Func->isVarArg()) {
10094         unsigned InRegCount = 0;
10095         unsigned Idx = 1;
10096
10097         for (FunctionType::param_iterator I = FTy->param_begin(),
10098              E = FTy->param_end(); I != E; ++I, ++Idx)
10099           if (Attrs.paramHasAttr(Idx, Attribute::InReg))
10100             // FIXME: should only count parameters that are lowered to integers.
10101             InRegCount += (TD->getTypeSizeInBits(*I) + 31) / 32;
10102
10103         if (InRegCount > 2) {
10104           report_fatal_error("Nest register in use - reduce number of inreg"
10105                              " parameters!");
10106         }
10107       }
10108       break;
10109     }
10110     case CallingConv::X86_FastCall:
10111     case CallingConv::X86_ThisCall:
10112     case CallingConv::Fast:
10113       // Pass 'nest' parameter in EAX.
10114       // Must be kept in sync with X86CallingConv.td
10115       NestReg = X86::EAX;
10116       break;
10117     }
10118
10119     SDValue OutChains[4];
10120     SDValue Addr, Disp;
10121
10122     Addr = DAG.getNode(ISD::ADD, dl, MVT::i32, Trmp,
10123                        DAG.getConstant(10, MVT::i32));
10124     Disp = DAG.getNode(ISD::SUB, dl, MVT::i32, FPtr, Addr);
10125
10126     // This is storing the opcode for MOV32ri.
10127     const unsigned char MOV32ri = 0xB8; // X86::MOV32ri's opcode byte.
10128     const unsigned char N86Reg = X86_MC::getX86RegNum(NestReg);
10129     OutChains[0] = DAG.getStore(Root, dl,
10130                                 DAG.getConstant(MOV32ri|N86Reg, MVT::i8),
10131                                 Trmp, MachinePointerInfo(TrmpAddr),
10132                                 false, false, 0);
10133
10134     Addr = DAG.getNode(ISD::ADD, dl, MVT::i32, Trmp,
10135                        DAG.getConstant(1, MVT::i32));
10136     OutChains[1] = DAG.getStore(Root, dl, Nest, Addr,
10137                                 MachinePointerInfo(TrmpAddr, 1),
10138                                 false, false, 1);
10139
10140     const unsigned char JMP = 0xE9; // jmp <32bit dst> opcode.
10141     Addr = DAG.getNode(ISD::ADD, dl, MVT::i32, Trmp,
10142                        DAG.getConstant(5, MVT::i32));
10143     OutChains[2] = DAG.getStore(Root, dl, DAG.getConstant(JMP, MVT::i8), Addr,
10144                                 MachinePointerInfo(TrmpAddr, 5),
10145                                 false, false, 1);
10146
10147     Addr = DAG.getNode(ISD::ADD, dl, MVT::i32, Trmp,
10148                        DAG.getConstant(6, MVT::i32));
10149     OutChains[3] = DAG.getStore(Root, dl, Disp, Addr,
10150                                 MachinePointerInfo(TrmpAddr, 6),
10151                                 false, false, 1);
10152
10153     return DAG.getNode(ISD::TokenFactor, dl, MVT::Other, OutChains, 4);
10154   }
10155 }
10156
10157 SDValue X86TargetLowering::LowerFLT_ROUNDS_(SDValue Op,
10158                                             SelectionDAG &DAG) const {
10159   /*
10160    The rounding mode is in bits 11:10 of FPSR, and has the following
10161    settings:
10162      00 Round to nearest
10163      01 Round to -inf
10164      10 Round to +inf
10165      11 Round to 0
10166
10167   FLT_ROUNDS, on the other hand, expects the following:
10168     -1 Undefined
10169      0 Round to 0
10170      1 Round to nearest
10171      2 Round to +inf
10172      3 Round to -inf
10173
10174   To perform the conversion, we do:
10175     (((((FPSR & 0x800) >> 11) | ((FPSR & 0x400) >> 9)) + 1) & 3)
10176   */
10177
10178   MachineFunction &MF = DAG.getMachineFunction();
10179   const TargetMachine &TM = MF.getTarget();
10180   const TargetFrameLowering &TFI = *TM.getFrameLowering();
10181   unsigned StackAlignment = TFI.getStackAlignment();
10182   EVT VT = Op.getValueType();
10183   DebugLoc DL = Op.getDebugLoc();
10184
10185   // Save FP Control Word to stack slot
10186   int SSFI = MF.getFrameInfo()->CreateStackObject(2, StackAlignment, false);
10187   SDValue StackSlot = DAG.getFrameIndex(SSFI, getPointerTy());
10188
10189
10190   MachineMemOperand *MMO =
10191    MF.getMachineMemOperand(MachinePointerInfo::getFixedStack(SSFI),
10192                            MachineMemOperand::MOStore, 2, 2);
10193
10194   SDValue Ops[] = { DAG.getEntryNode(), StackSlot };
10195   SDValue Chain = DAG.getMemIntrinsicNode(X86ISD::FNSTCW16m, DL,
10196                                           DAG.getVTList(MVT::Other),
10197                                           Ops, 2, MVT::i16, MMO);
10198
10199   // Load FP Control Word from stack slot
10200   SDValue CWD = DAG.getLoad(MVT::i16, DL, Chain, StackSlot,
10201                             MachinePointerInfo(), false, false, false, 0);
10202
10203   // Transform as necessary
10204   SDValue CWD1 =
10205     DAG.getNode(ISD::SRL, DL, MVT::i16,
10206                 DAG.getNode(ISD::AND, DL, MVT::i16,
10207                             CWD, DAG.getConstant(0x800, MVT::i16)),
10208                 DAG.getConstant(11, MVT::i8));
10209   SDValue CWD2 =
10210     DAG.getNode(ISD::SRL, DL, MVT::i16,
10211                 DAG.getNode(ISD::AND, DL, MVT::i16,
10212                             CWD, DAG.getConstant(0x400, MVT::i16)),
10213                 DAG.getConstant(9, MVT::i8));
10214
10215   SDValue RetVal =
10216     DAG.getNode(ISD::AND, DL, MVT::i16,
10217                 DAG.getNode(ISD::ADD, DL, MVT::i16,
10218                             DAG.getNode(ISD::OR, DL, MVT::i16, CWD1, CWD2),
10219                             DAG.getConstant(1, MVT::i16)),
10220                 DAG.getConstant(3, MVT::i16));
10221
10222
10223   return DAG.getNode((VT.getSizeInBits() < 16 ?
10224                       ISD::TRUNCATE : ISD::ZERO_EXTEND), DL, VT, RetVal);
10225 }
10226
10227 SDValue X86TargetLowering::LowerCTLZ(SDValue Op, SelectionDAG &DAG) const {
10228   EVT VT = Op.getValueType();
10229   EVT OpVT = VT;
10230   unsigned NumBits = VT.getSizeInBits();
10231   DebugLoc dl = Op.getDebugLoc();
10232
10233   Op = Op.getOperand(0);
10234   if (VT == MVT::i8) {
10235     // Zero extend to i32 since there is not an i8 bsr.
10236     OpVT = MVT::i32;
10237     Op = DAG.getNode(ISD::ZERO_EXTEND, dl, OpVT, Op);
10238   }
10239
10240   // Issue a bsr (scan bits in reverse) which also sets EFLAGS.
10241   SDVTList VTs = DAG.getVTList(OpVT, MVT::i32);
10242   Op = DAG.getNode(X86ISD::BSR, dl, VTs, Op);
10243
10244   // If src is zero (i.e. bsr sets ZF), returns NumBits.
10245   SDValue Ops[] = {
10246     Op,
10247     DAG.getConstant(NumBits+NumBits-1, OpVT),
10248     DAG.getConstant(X86::COND_E, MVT::i8),
10249     Op.getValue(1)
10250   };
10251   Op = DAG.getNode(X86ISD::CMOV, dl, OpVT, Ops, array_lengthof(Ops));
10252
10253   // Finally xor with NumBits-1.
10254   Op = DAG.getNode(ISD::XOR, dl, OpVT, Op, DAG.getConstant(NumBits-1, OpVT));
10255
10256   if (VT == MVT::i8)
10257     Op = DAG.getNode(ISD::TRUNCATE, dl, MVT::i8, Op);
10258   return Op;
10259 }
10260
10261 SDValue X86TargetLowering::LowerCTLZ_ZERO_UNDEF(SDValue Op,
10262                                                 SelectionDAG &DAG) const {
10263   EVT VT = Op.getValueType();
10264   EVT OpVT = VT;
10265   unsigned NumBits = VT.getSizeInBits();
10266   DebugLoc dl = Op.getDebugLoc();
10267
10268   Op = Op.getOperand(0);
10269   if (VT == MVT::i8) {
10270     // Zero extend to i32 since there is not an i8 bsr.
10271     OpVT = MVT::i32;
10272     Op = DAG.getNode(ISD::ZERO_EXTEND, dl, OpVT, Op);
10273   }
10274
10275   // Issue a bsr (scan bits in reverse).
10276   SDVTList VTs = DAG.getVTList(OpVT, MVT::i32);
10277   Op = DAG.getNode(X86ISD::BSR, dl, VTs, Op);
10278
10279   // And xor with NumBits-1.
10280   Op = DAG.getNode(ISD::XOR, dl, OpVT, Op, DAG.getConstant(NumBits-1, OpVT));
10281
10282   if (VT == MVT::i8)
10283     Op = DAG.getNode(ISD::TRUNCATE, dl, MVT::i8, Op);
10284   return Op;
10285 }
10286
10287 SDValue X86TargetLowering::LowerCTTZ(SDValue Op, SelectionDAG &DAG) const {
10288   EVT VT = Op.getValueType();
10289   unsigned NumBits = VT.getSizeInBits();
10290   DebugLoc dl = Op.getDebugLoc();
10291   Op = Op.getOperand(0);
10292
10293   // Issue a bsf (scan bits forward) which also sets EFLAGS.
10294   SDVTList VTs = DAG.getVTList(VT, MVT::i32);
10295   Op = DAG.getNode(X86ISD::BSF, dl, VTs, Op);
10296
10297   // If src is zero (i.e. bsf sets ZF), returns NumBits.
10298   SDValue Ops[] = {
10299     Op,
10300     DAG.getConstant(NumBits, VT),
10301     DAG.getConstant(X86::COND_E, MVT::i8),
10302     Op.getValue(1)
10303   };
10304   return DAG.getNode(X86ISD::CMOV, dl, VT, Ops, array_lengthof(Ops));
10305 }
10306
10307 // Lower256IntArith - Break a 256-bit integer operation into two new 128-bit
10308 // ones, and then concatenate the result back.
10309 static SDValue Lower256IntArith(SDValue Op, SelectionDAG &DAG) {
10310   EVT VT = Op.getValueType();
10311
10312   assert(VT.getSizeInBits() == 256 && VT.isInteger() &&
10313          "Unsupported value type for operation");
10314
10315   unsigned NumElems = VT.getVectorNumElements();
10316   DebugLoc dl = Op.getDebugLoc();
10317
10318   // Extract the LHS vectors
10319   SDValue LHS = Op.getOperand(0);
10320   SDValue LHS1 = Extract128BitVector(LHS, 0, DAG, dl);
10321   SDValue LHS2 = Extract128BitVector(LHS, NumElems/2, DAG, dl);
10322
10323   // Extract the RHS vectors
10324   SDValue RHS = Op.getOperand(1);
10325   SDValue RHS1 = Extract128BitVector(RHS, 0, DAG, dl);
10326   SDValue RHS2 = Extract128BitVector(RHS, NumElems/2, DAG, dl);
10327
10328   MVT EltVT = VT.getVectorElementType().getSimpleVT();
10329   EVT NewVT = MVT::getVectorVT(EltVT, NumElems/2);
10330
10331   return DAG.getNode(ISD::CONCAT_VECTORS, dl, VT,
10332                      DAG.getNode(Op.getOpcode(), dl, NewVT, LHS1, RHS1),
10333                      DAG.getNode(Op.getOpcode(), dl, NewVT, LHS2, RHS2));
10334 }
10335
10336 SDValue X86TargetLowering::LowerADD(SDValue Op, SelectionDAG &DAG) const {
10337   assert(Op.getValueType().getSizeInBits() == 256 &&
10338          Op.getValueType().isInteger() &&
10339          "Only handle AVX 256-bit vector integer operation");
10340   return Lower256IntArith(Op, DAG);
10341 }
10342
10343 SDValue X86TargetLowering::LowerSUB(SDValue Op, SelectionDAG &DAG) const {
10344   assert(Op.getValueType().getSizeInBits() == 256 &&
10345          Op.getValueType().isInteger() &&
10346          "Only handle AVX 256-bit vector integer operation");
10347   return Lower256IntArith(Op, DAG);
10348 }
10349
10350 SDValue X86TargetLowering::LowerMUL(SDValue Op, SelectionDAG &DAG) const {
10351   EVT VT = Op.getValueType();
10352
10353   // Decompose 256-bit ops into smaller 128-bit ops.
10354   if (VT.getSizeInBits() == 256 && !Subtarget->hasAVX2())
10355     return Lower256IntArith(Op, DAG);
10356
10357   assert((VT == MVT::v2i64 || VT == MVT::v4i64) &&
10358          "Only know how to lower V2I64/V4I64 multiply");
10359
10360   DebugLoc dl = Op.getDebugLoc();
10361
10362   //  Ahi = psrlqi(a, 32);
10363   //  Bhi = psrlqi(b, 32);
10364   //
10365   //  AloBlo = pmuludq(a, b);
10366   //  AloBhi = pmuludq(a, Bhi);
10367   //  AhiBlo = pmuludq(Ahi, b);
10368
10369   //  AloBhi = psllqi(AloBhi, 32);
10370   //  AhiBlo = psllqi(AhiBlo, 32);
10371   //  return AloBlo + AloBhi + AhiBlo;
10372
10373   SDValue A = Op.getOperand(0);
10374   SDValue B = Op.getOperand(1);
10375
10376   SDValue ShAmt = DAG.getConstant(32, MVT::i32);
10377
10378   SDValue Ahi = DAG.getNode(X86ISD::VSRLI, dl, VT, A, ShAmt);
10379   SDValue Bhi = DAG.getNode(X86ISD::VSRLI, dl, VT, B, ShAmt);
10380
10381   // Bit cast to 32-bit vectors for MULUDQ
10382   EVT MulVT = (VT == MVT::v2i64) ? MVT::v4i32 : MVT::v8i32;
10383   A = DAG.getNode(ISD::BITCAST, dl, MulVT, A);
10384   B = DAG.getNode(ISD::BITCAST, dl, MulVT, B);
10385   Ahi = DAG.getNode(ISD::BITCAST, dl, MulVT, Ahi);
10386   Bhi = DAG.getNode(ISD::BITCAST, dl, MulVT, Bhi);
10387
10388   SDValue AloBlo = DAG.getNode(X86ISD::PMULUDQ, dl, VT, A, B);
10389   SDValue AloBhi = DAG.getNode(X86ISD::PMULUDQ, dl, VT, A, Bhi);
10390   SDValue AhiBlo = DAG.getNode(X86ISD::PMULUDQ, dl, VT, Ahi, B);
10391
10392   AloBhi = DAG.getNode(X86ISD::VSHLI, dl, VT, AloBhi, ShAmt);
10393   AhiBlo = DAG.getNode(X86ISD::VSHLI, dl, VT, AhiBlo, ShAmt);
10394
10395   SDValue Res = DAG.getNode(ISD::ADD, dl, VT, AloBlo, AloBhi);
10396   return DAG.getNode(ISD::ADD, dl, VT, Res, AhiBlo);
10397 }
10398
10399 SDValue X86TargetLowering::LowerShift(SDValue Op, SelectionDAG &DAG) const {
10400
10401   EVT VT = Op.getValueType();
10402   DebugLoc dl = Op.getDebugLoc();
10403   SDValue R = Op.getOperand(0);
10404   SDValue Amt = Op.getOperand(1);
10405   LLVMContext *Context = DAG.getContext();
10406
10407   if (!Subtarget->hasSSE2())
10408     return SDValue();
10409
10410   // Optimize shl/srl/sra with constant shift amount.
10411   if (isSplatVector(Amt.getNode())) {
10412     SDValue SclrAmt = Amt->getOperand(0);
10413     if (ConstantSDNode *C = dyn_cast<ConstantSDNode>(SclrAmt)) {
10414       uint64_t ShiftAmt = C->getZExtValue();
10415
10416       if (VT == MVT::v2i64 || VT == MVT::v4i32 || VT == MVT::v8i16 ||
10417           (Subtarget->hasAVX2() &&
10418            (VT == MVT::v4i64 || VT == MVT::v8i32 || VT == MVT::v16i16))) {
10419         if (Op.getOpcode() == ISD::SHL)
10420           return DAG.getNode(X86ISD::VSHLI, dl, VT, R,
10421                              DAG.getConstant(ShiftAmt, MVT::i32));
10422         if (Op.getOpcode() == ISD::SRL)
10423           return DAG.getNode(X86ISD::VSRLI, dl, VT, R,
10424                              DAG.getConstant(ShiftAmt, MVT::i32));
10425         if (Op.getOpcode() == ISD::SRA && VT != MVT::v2i64 && VT != MVT::v4i64)
10426           return DAG.getNode(X86ISD::VSRAI, dl, VT, R,
10427                              DAG.getConstant(ShiftAmt, MVT::i32));
10428       }
10429
10430       if (VT == MVT::v16i8) {
10431         if (Op.getOpcode() == ISD::SHL) {
10432           // Make a large shift.
10433           SDValue SHL = DAG.getNode(X86ISD::VSHLI, dl, MVT::v8i16, R,
10434                                     DAG.getConstant(ShiftAmt, MVT::i32));
10435           SHL = DAG.getNode(ISD::BITCAST, dl, VT, SHL);
10436           // Zero out the rightmost bits.
10437           SmallVector<SDValue, 16> V(16,
10438                                      DAG.getConstant(uint8_t(-1U << ShiftAmt),
10439                                                      MVT::i8));
10440           return DAG.getNode(ISD::AND, dl, VT, SHL,
10441                              DAG.getNode(ISD::BUILD_VECTOR, dl, VT, &V[0], 16));
10442         }
10443         if (Op.getOpcode() == ISD::SRL) {
10444           // Make a large shift.
10445           SDValue SRL = DAG.getNode(X86ISD::VSRLI, dl, MVT::v8i16, R,
10446                                     DAG.getConstant(ShiftAmt, MVT::i32));
10447           SRL = DAG.getNode(ISD::BITCAST, dl, VT, SRL);
10448           // Zero out the leftmost bits.
10449           SmallVector<SDValue, 16> V(16,
10450                                      DAG.getConstant(uint8_t(-1U) >> ShiftAmt,
10451                                                      MVT::i8));
10452           return DAG.getNode(ISD::AND, dl, VT, SRL,
10453                              DAG.getNode(ISD::BUILD_VECTOR, dl, VT, &V[0], 16));
10454         }
10455         if (Op.getOpcode() == ISD::SRA) {
10456           if (ShiftAmt == 7) {
10457             // R s>> 7  ===  R s< 0
10458             SDValue Zeros = getZeroVector(VT, Subtarget, DAG, dl);
10459             return DAG.getNode(X86ISD::PCMPGT, dl, VT, Zeros, R);
10460           }
10461
10462           // R s>> a === ((R u>> a) ^ m) - m
10463           SDValue Res = DAG.getNode(ISD::SRL, dl, VT, R, Amt);
10464           SmallVector<SDValue, 16> V(16, DAG.getConstant(128 >> ShiftAmt,
10465                                                          MVT::i8));
10466           SDValue Mask = DAG.getNode(ISD::BUILD_VECTOR, dl, VT, &V[0], 16);
10467           Res = DAG.getNode(ISD::XOR, dl, VT, Res, Mask);
10468           Res = DAG.getNode(ISD::SUB, dl, VT, Res, Mask);
10469           return Res;
10470         }
10471         llvm_unreachable("Unknown shift opcode.");
10472       }
10473
10474       if (Subtarget->hasAVX2() && VT == MVT::v32i8) {
10475         if (Op.getOpcode() == ISD::SHL) {
10476           // Make a large shift.
10477           SDValue SHL = DAG.getNode(X86ISD::VSHLI, dl, MVT::v16i16, R,
10478                                     DAG.getConstant(ShiftAmt, MVT::i32));
10479           SHL = DAG.getNode(ISD::BITCAST, dl, VT, SHL);
10480           // Zero out the rightmost bits.
10481           SmallVector<SDValue, 32> V(32,
10482                                      DAG.getConstant(uint8_t(-1U << ShiftAmt),
10483                                                      MVT::i8));
10484           return DAG.getNode(ISD::AND, dl, VT, SHL,
10485                              DAG.getNode(ISD::BUILD_VECTOR, dl, VT, &V[0], 32));
10486         }
10487         if (Op.getOpcode() == ISD::SRL) {
10488           // Make a large shift.
10489           SDValue SRL = DAG.getNode(X86ISD::VSRLI, dl, MVT::v16i16, R,
10490                                     DAG.getConstant(ShiftAmt, MVT::i32));
10491           SRL = DAG.getNode(ISD::BITCAST, dl, VT, SRL);
10492           // Zero out the leftmost bits.
10493           SmallVector<SDValue, 32> V(32,
10494                                      DAG.getConstant(uint8_t(-1U) >> ShiftAmt,
10495                                                      MVT::i8));
10496           return DAG.getNode(ISD::AND, dl, VT, SRL,
10497                              DAG.getNode(ISD::BUILD_VECTOR, dl, VT, &V[0], 32));
10498         }
10499         if (Op.getOpcode() == ISD::SRA) {
10500           if (ShiftAmt == 7) {
10501             // R s>> 7  ===  R s< 0
10502             SDValue Zeros = getZeroVector(VT, Subtarget, DAG, dl);
10503             return DAG.getNode(X86ISD::PCMPGT, dl, VT, Zeros, R);
10504           }
10505
10506           // R s>> a === ((R u>> a) ^ m) - m
10507           SDValue Res = DAG.getNode(ISD::SRL, dl, VT, R, Amt);
10508           SmallVector<SDValue, 32> V(32, DAG.getConstant(128 >> ShiftAmt,
10509                                                          MVT::i8));
10510           SDValue Mask = DAG.getNode(ISD::BUILD_VECTOR, dl, VT, &V[0], 32);
10511           Res = DAG.getNode(ISD::XOR, dl, VT, Res, Mask);
10512           Res = DAG.getNode(ISD::SUB, dl, VT, Res, Mask);
10513           return Res;
10514         }
10515         llvm_unreachable("Unknown shift opcode.");
10516       }
10517     }
10518   }
10519
10520   // Lower SHL with variable shift amount.
10521   if (VT == MVT::v4i32 && Op->getOpcode() == ISD::SHL) {
10522     Op = DAG.getNode(X86ISD::VSHLI, dl, VT, Op.getOperand(1),
10523                      DAG.getConstant(23, MVT::i32));
10524
10525     const uint32_t CV[] = { 0x3f800000U, 0x3f800000U, 0x3f800000U, 0x3f800000U};
10526     Constant *C = ConstantDataVector::get(*Context, CV);
10527     SDValue CPIdx = DAG.getConstantPool(C, getPointerTy(), 16);
10528     SDValue Addend = DAG.getLoad(VT, dl, DAG.getEntryNode(), CPIdx,
10529                                  MachinePointerInfo::getConstantPool(),
10530                                  false, false, false, 16);
10531
10532     Op = DAG.getNode(ISD::ADD, dl, VT, Op, Addend);
10533     Op = DAG.getNode(ISD::BITCAST, dl, MVT::v4f32, Op);
10534     Op = DAG.getNode(ISD::FP_TO_SINT, dl, VT, Op);
10535     return DAG.getNode(ISD::MUL, dl, VT, Op, R);
10536   }
10537   if (VT == MVT::v16i8 && Op->getOpcode() == ISD::SHL) {
10538     assert(Subtarget->hasSSE2() && "Need SSE2 for pslli/pcmpeq.");
10539
10540     // a = a << 5;
10541     Op = DAG.getNode(X86ISD::VSHLI, dl, MVT::v8i16, Op.getOperand(1),
10542                      DAG.getConstant(5, MVT::i32));
10543     Op = DAG.getNode(ISD::BITCAST, dl, VT, Op);
10544
10545     // Turn 'a' into a mask suitable for VSELECT
10546     SDValue VSelM = DAG.getConstant(0x80, VT);
10547     SDValue OpVSel = DAG.getNode(ISD::AND, dl, VT, VSelM, Op);
10548     OpVSel = DAG.getNode(X86ISD::PCMPEQ, dl, VT, OpVSel, VSelM);
10549
10550     SDValue CM1 = DAG.getConstant(0x0f, VT);
10551     SDValue CM2 = DAG.getConstant(0x3f, VT);
10552
10553     // r = VSELECT(r, psllw(r & (char16)15, 4), a);
10554     SDValue M = DAG.getNode(ISD::AND, dl, VT, R, CM1);
10555     M = getTargetVShiftNode(X86ISD::VSHLI, dl, MVT::v8i16, M,
10556                             DAG.getConstant(4, MVT::i32), DAG);
10557     M = DAG.getNode(ISD::BITCAST, dl, VT, M);
10558     R = DAG.getNode(ISD::VSELECT, dl, VT, OpVSel, M, R);
10559
10560     // a += a
10561     Op = DAG.getNode(ISD::ADD, dl, VT, Op, Op);
10562     OpVSel = DAG.getNode(ISD::AND, dl, VT, VSelM, Op);
10563     OpVSel = DAG.getNode(X86ISD::PCMPEQ, dl, VT, OpVSel, VSelM);
10564
10565     // r = VSELECT(r, psllw(r & (char16)63, 2), a);
10566     M = DAG.getNode(ISD::AND, dl, VT, R, CM2);
10567     M = getTargetVShiftNode(X86ISD::VSHLI, dl, MVT::v8i16, M,
10568                             DAG.getConstant(2, MVT::i32), DAG);
10569     M = DAG.getNode(ISD::BITCAST, dl, VT, M);
10570     R = DAG.getNode(ISD::VSELECT, dl, VT, OpVSel, M, R);
10571
10572     // a += a
10573     Op = DAG.getNode(ISD::ADD, dl, VT, Op, Op);
10574     OpVSel = DAG.getNode(ISD::AND, dl, VT, VSelM, Op);
10575     OpVSel = DAG.getNode(X86ISD::PCMPEQ, dl, VT, OpVSel, VSelM);
10576
10577     // return VSELECT(r, r+r, a);
10578     R = DAG.getNode(ISD::VSELECT, dl, VT, OpVSel,
10579                     DAG.getNode(ISD::ADD, dl, VT, R, R), R);
10580     return R;
10581   }
10582
10583   // Decompose 256-bit shifts into smaller 128-bit shifts.
10584   if (VT.getSizeInBits() == 256) {
10585     unsigned NumElems = VT.getVectorNumElements();
10586     MVT EltVT = VT.getVectorElementType().getSimpleVT();
10587     EVT NewVT = MVT::getVectorVT(EltVT, NumElems/2);
10588
10589     // Extract the two vectors
10590     SDValue V1 = Extract128BitVector(R, 0, DAG, dl);
10591     SDValue V2 = Extract128BitVector(R, NumElems/2, DAG, dl);
10592
10593     // Recreate the shift amount vectors
10594     SDValue Amt1, Amt2;
10595     if (Amt.getOpcode() == ISD::BUILD_VECTOR) {
10596       // Constant shift amount
10597       SmallVector<SDValue, 4> Amt1Csts;
10598       SmallVector<SDValue, 4> Amt2Csts;
10599       for (unsigned i = 0; i != NumElems/2; ++i)
10600         Amt1Csts.push_back(Amt->getOperand(i));
10601       for (unsigned i = NumElems/2; i != NumElems; ++i)
10602         Amt2Csts.push_back(Amt->getOperand(i));
10603
10604       Amt1 = DAG.getNode(ISD::BUILD_VECTOR, dl, NewVT,
10605                                  &Amt1Csts[0], NumElems/2);
10606       Amt2 = DAG.getNode(ISD::BUILD_VECTOR, dl, NewVT,
10607                                  &Amt2Csts[0], NumElems/2);
10608     } else {
10609       // Variable shift amount
10610       Amt1 = Extract128BitVector(Amt, 0, DAG, dl);
10611       Amt2 = Extract128BitVector(Amt, NumElems/2, DAG, dl);
10612     }
10613
10614     // Issue new vector shifts for the smaller types
10615     V1 = DAG.getNode(Op.getOpcode(), dl, NewVT, V1, Amt1);
10616     V2 = DAG.getNode(Op.getOpcode(), dl, NewVT, V2, Amt2);
10617
10618     // Concatenate the result back
10619     return DAG.getNode(ISD::CONCAT_VECTORS, dl, VT, V1, V2);
10620   }
10621
10622   return SDValue();
10623 }
10624
10625 SDValue X86TargetLowering::LowerXALUO(SDValue Op, SelectionDAG &DAG) const {
10626   // Lower the "add/sub/mul with overflow" instruction into a regular ins plus
10627   // a "setcc" instruction that checks the overflow flag. The "brcond" lowering
10628   // looks for this combo and may remove the "setcc" instruction if the "setcc"
10629   // has only one use.
10630   SDNode *N = Op.getNode();
10631   SDValue LHS = N->getOperand(0);
10632   SDValue RHS = N->getOperand(1);
10633   unsigned BaseOp = 0;
10634   unsigned Cond = 0;
10635   DebugLoc DL = Op.getDebugLoc();
10636   switch (Op.getOpcode()) {
10637   default: llvm_unreachable("Unknown ovf instruction!");
10638   case ISD::SADDO:
10639     // A subtract of one will be selected as a INC. Note that INC doesn't
10640     // set CF, so we can't do this for UADDO.
10641     if (ConstantSDNode *C = dyn_cast<ConstantSDNode>(RHS))
10642       if (C->isOne()) {
10643         BaseOp = X86ISD::INC;
10644         Cond = X86::COND_O;
10645         break;
10646       }
10647     BaseOp = X86ISD::ADD;
10648     Cond = X86::COND_O;
10649     break;
10650   case ISD::UADDO:
10651     BaseOp = X86ISD::ADD;
10652     Cond = X86::COND_B;
10653     break;
10654   case ISD::SSUBO:
10655     // A subtract of one will be selected as a DEC. Note that DEC doesn't
10656     // set CF, so we can't do this for USUBO.
10657     if (ConstantSDNode *C = dyn_cast<ConstantSDNode>(RHS))
10658       if (C->isOne()) {
10659         BaseOp = X86ISD::DEC;
10660         Cond = X86::COND_O;
10661         break;
10662       }
10663     BaseOp = X86ISD::SUB;
10664     Cond = X86::COND_O;
10665     break;
10666   case ISD::USUBO:
10667     BaseOp = X86ISD::SUB;
10668     Cond = X86::COND_B;
10669     break;
10670   case ISD::SMULO:
10671     BaseOp = X86ISD::SMUL;
10672     Cond = X86::COND_O;
10673     break;
10674   case ISD::UMULO: { // i64, i8 = umulo lhs, rhs --> i64, i64, i32 umul lhs,rhs
10675     SDVTList VTs = DAG.getVTList(N->getValueType(0), N->getValueType(0),
10676                                  MVT::i32);
10677     SDValue Sum = DAG.getNode(X86ISD::UMUL, DL, VTs, LHS, RHS);
10678
10679     SDValue SetCC =
10680       DAG.getNode(X86ISD::SETCC, DL, MVT::i8,
10681                   DAG.getConstant(X86::COND_O, MVT::i32),
10682                   SDValue(Sum.getNode(), 2));
10683
10684     return DAG.getNode(ISD::MERGE_VALUES, DL, N->getVTList(), Sum, SetCC);
10685   }
10686   }
10687
10688   // Also sets EFLAGS.
10689   SDVTList VTs = DAG.getVTList(N->getValueType(0), MVT::i32);
10690   SDValue Sum = DAG.getNode(BaseOp, DL, VTs, LHS, RHS);
10691
10692   SDValue SetCC =
10693     DAG.getNode(X86ISD::SETCC, DL, N->getValueType(1),
10694                 DAG.getConstant(Cond, MVT::i32),
10695                 SDValue(Sum.getNode(), 1));
10696
10697   return DAG.getNode(ISD::MERGE_VALUES, DL, N->getVTList(), Sum, SetCC);
10698 }
10699
10700 SDValue X86TargetLowering::LowerSIGN_EXTEND_INREG(SDValue Op,
10701                                                   SelectionDAG &DAG) const {
10702   DebugLoc dl = Op.getDebugLoc();
10703   EVT ExtraVT = cast<VTSDNode>(Op.getOperand(1))->getVT();
10704   EVT VT = Op.getValueType();
10705
10706   if (!Subtarget->hasSSE2() || !VT.isVector())
10707     return SDValue();
10708
10709   unsigned BitsDiff = VT.getScalarType().getSizeInBits() -
10710                       ExtraVT.getScalarType().getSizeInBits();
10711   SDValue ShAmt = DAG.getConstant(BitsDiff, MVT::i32);
10712
10713   switch (VT.getSimpleVT().SimpleTy) {
10714     default: return SDValue();
10715     case MVT::v8i32:
10716     case MVT::v16i16:
10717       if (!Subtarget->hasAVX())
10718         return SDValue();
10719       if (!Subtarget->hasAVX2()) {
10720         // needs to be split
10721         unsigned NumElems = VT.getVectorNumElements();
10722
10723         // Extract the LHS vectors
10724         SDValue LHS = Op.getOperand(0);
10725         SDValue LHS1 = Extract128BitVector(LHS, 0, DAG, dl);
10726         SDValue LHS2 = Extract128BitVector(LHS, NumElems/2, DAG, dl);
10727
10728         MVT EltVT = VT.getVectorElementType().getSimpleVT();
10729         EVT NewVT = MVT::getVectorVT(EltVT, NumElems/2);
10730
10731         EVT ExtraEltVT = ExtraVT.getVectorElementType();
10732         unsigned ExtraNumElems = ExtraVT.getVectorNumElements();
10733         ExtraVT = EVT::getVectorVT(*DAG.getContext(), ExtraEltVT,
10734                                    ExtraNumElems/2);
10735         SDValue Extra = DAG.getValueType(ExtraVT);
10736
10737         LHS1 = DAG.getNode(Op.getOpcode(), dl, NewVT, LHS1, Extra);
10738         LHS2 = DAG.getNode(Op.getOpcode(), dl, NewVT, LHS2, Extra);
10739
10740         return DAG.getNode(ISD::CONCAT_VECTORS, dl, VT, LHS1, LHS2);;
10741       }
10742       // fall through
10743     case MVT::v4i32:
10744     case MVT::v8i16: {
10745       SDValue Tmp1 = getTargetVShiftNode(X86ISD::VSHLI, dl, VT,
10746                                          Op.getOperand(0), ShAmt, DAG);
10747       return getTargetVShiftNode(X86ISD::VSRAI, dl, VT, Tmp1, ShAmt, DAG);
10748     }
10749   }
10750 }
10751
10752
10753 SDValue X86TargetLowering::LowerMEMBARRIER(SDValue Op, SelectionDAG &DAG) const{
10754   DebugLoc dl = Op.getDebugLoc();
10755
10756   // Go ahead and emit the fence on x86-64 even if we asked for no-sse2.
10757   // There isn't any reason to disable it if the target processor supports it.
10758   if (!Subtarget->hasSSE2() && !Subtarget->is64Bit()) {
10759     SDValue Chain = Op.getOperand(0);
10760     SDValue Zero = DAG.getConstant(0, MVT::i32);
10761     SDValue Ops[] = {
10762       DAG.getRegister(X86::ESP, MVT::i32), // Base
10763       DAG.getTargetConstant(1, MVT::i8),   // Scale
10764       DAG.getRegister(0, MVT::i32),        // Index
10765       DAG.getTargetConstant(0, MVT::i32),  // Disp
10766       DAG.getRegister(0, MVT::i32),        // Segment.
10767       Zero,
10768       Chain
10769     };
10770     SDNode *Res =
10771       DAG.getMachineNode(X86::OR32mrLocked, dl, MVT::Other, Ops,
10772                           array_lengthof(Ops));
10773     return SDValue(Res, 0);
10774   }
10775
10776   unsigned isDev = cast<ConstantSDNode>(Op.getOperand(5))->getZExtValue();
10777   if (!isDev)
10778     return DAG.getNode(X86ISD::MEMBARRIER, dl, MVT::Other, Op.getOperand(0));
10779
10780   unsigned Op1 = cast<ConstantSDNode>(Op.getOperand(1))->getZExtValue();
10781   unsigned Op2 = cast<ConstantSDNode>(Op.getOperand(2))->getZExtValue();
10782   unsigned Op3 = cast<ConstantSDNode>(Op.getOperand(3))->getZExtValue();
10783   unsigned Op4 = cast<ConstantSDNode>(Op.getOperand(4))->getZExtValue();
10784
10785   // def : Pat<(membarrier (i8 0), (i8 0), (i8 0), (i8 1), (i8 1)), (SFENCE)>;
10786   if (!Op1 && !Op2 && !Op3 && Op4)
10787     return DAG.getNode(X86ISD::SFENCE, dl, MVT::Other, Op.getOperand(0));
10788
10789   // def : Pat<(membarrier (i8 1), (i8 0), (i8 0), (i8 0), (i8 1)), (LFENCE)>;
10790   if (Op1 && !Op2 && !Op3 && !Op4)
10791     return DAG.getNode(X86ISD::LFENCE, dl, MVT::Other, Op.getOperand(0));
10792
10793   // def : Pat<(membarrier (i8 imm), (i8 imm), (i8 imm), (i8 imm), (i8 1)),
10794   //           (MFENCE)>;
10795   return DAG.getNode(X86ISD::MFENCE, dl, MVT::Other, Op.getOperand(0));
10796 }
10797
10798 SDValue X86TargetLowering::LowerATOMIC_FENCE(SDValue Op,
10799                                              SelectionDAG &DAG) const {
10800   DebugLoc dl = Op.getDebugLoc();
10801   AtomicOrdering FenceOrdering = static_cast<AtomicOrdering>(
10802     cast<ConstantSDNode>(Op.getOperand(1))->getZExtValue());
10803   SynchronizationScope FenceScope = static_cast<SynchronizationScope>(
10804     cast<ConstantSDNode>(Op.getOperand(2))->getZExtValue());
10805
10806   // The only fence that needs an instruction is a sequentially-consistent
10807   // cross-thread fence.
10808   if (FenceOrdering == SequentiallyConsistent && FenceScope == CrossThread) {
10809     // Use mfence if we have SSE2 or we're on x86-64 (even if we asked for
10810     // no-sse2). There isn't any reason to disable it if the target processor
10811     // supports it.
10812     if (Subtarget->hasSSE2() || Subtarget->is64Bit())
10813       return DAG.getNode(X86ISD::MFENCE, dl, MVT::Other, Op.getOperand(0));
10814
10815     SDValue Chain = Op.getOperand(0);
10816     SDValue Zero = DAG.getConstant(0, MVT::i32);
10817     SDValue Ops[] = {
10818       DAG.getRegister(X86::ESP, MVT::i32), // Base
10819       DAG.getTargetConstant(1, MVT::i8),   // Scale
10820       DAG.getRegister(0, MVT::i32),        // Index
10821       DAG.getTargetConstant(0, MVT::i32),  // Disp
10822       DAG.getRegister(0, MVT::i32),        // Segment.
10823       Zero,
10824       Chain
10825     };
10826     SDNode *Res =
10827       DAG.getMachineNode(X86::OR32mrLocked, dl, MVT::Other, Ops,
10828                          array_lengthof(Ops));
10829     return SDValue(Res, 0);
10830   }
10831
10832   // MEMBARRIER is a compiler barrier; it codegens to a no-op.
10833   return DAG.getNode(X86ISD::MEMBARRIER, dl, MVT::Other, Op.getOperand(0));
10834 }
10835
10836
10837 SDValue X86TargetLowering::LowerCMP_SWAP(SDValue Op, SelectionDAG &DAG) const {
10838   EVT T = Op.getValueType();
10839   DebugLoc DL = Op.getDebugLoc();
10840   unsigned Reg = 0;
10841   unsigned size = 0;
10842   switch(T.getSimpleVT().SimpleTy) {
10843   default: llvm_unreachable("Invalid value type!");
10844   case MVT::i8:  Reg = X86::AL;  size = 1; break;
10845   case MVT::i16: Reg = X86::AX;  size = 2; break;
10846   case MVT::i32: Reg = X86::EAX; size = 4; break;
10847   case MVT::i64:
10848     assert(Subtarget->is64Bit() && "Node not type legal!");
10849     Reg = X86::RAX; size = 8;
10850     break;
10851   }
10852   SDValue cpIn = DAG.getCopyToReg(Op.getOperand(0), DL, Reg,
10853                                     Op.getOperand(2), SDValue());
10854   SDValue Ops[] = { cpIn.getValue(0),
10855                     Op.getOperand(1),
10856                     Op.getOperand(3),
10857                     DAG.getTargetConstant(size, MVT::i8),
10858                     cpIn.getValue(1) };
10859   SDVTList Tys = DAG.getVTList(MVT::Other, MVT::Glue);
10860   MachineMemOperand *MMO = cast<AtomicSDNode>(Op)->getMemOperand();
10861   SDValue Result = DAG.getMemIntrinsicNode(X86ISD::LCMPXCHG_DAG, DL, Tys,
10862                                            Ops, 5, T, MMO);
10863   SDValue cpOut =
10864     DAG.getCopyFromReg(Result.getValue(0), DL, Reg, T, Result.getValue(1));
10865   return cpOut;
10866 }
10867
10868 SDValue X86TargetLowering::LowerREADCYCLECOUNTER(SDValue Op,
10869                                                  SelectionDAG &DAG) const {
10870   assert(Subtarget->is64Bit() && "Result not type legalized?");
10871   SDVTList Tys = DAG.getVTList(MVT::Other, MVT::Glue);
10872   SDValue TheChain = Op.getOperand(0);
10873   DebugLoc dl = Op.getDebugLoc();
10874   SDValue rd = DAG.getNode(X86ISD::RDTSC_DAG, dl, Tys, &TheChain, 1);
10875   SDValue rax = DAG.getCopyFromReg(rd, dl, X86::RAX, MVT::i64, rd.getValue(1));
10876   SDValue rdx = DAG.getCopyFromReg(rax.getValue(1), dl, X86::RDX, MVT::i64,
10877                                    rax.getValue(2));
10878   SDValue Tmp = DAG.getNode(ISD::SHL, dl, MVT::i64, rdx,
10879                             DAG.getConstant(32, MVT::i8));
10880   SDValue Ops[] = {
10881     DAG.getNode(ISD::OR, dl, MVT::i64, rax, Tmp),
10882     rdx.getValue(1)
10883   };
10884   return DAG.getMergeValues(Ops, 2, dl);
10885 }
10886
10887 SDValue X86TargetLowering::LowerBITCAST(SDValue Op,
10888                                             SelectionDAG &DAG) const {
10889   EVT SrcVT = Op.getOperand(0).getValueType();
10890   EVT DstVT = Op.getValueType();
10891   assert(Subtarget->is64Bit() && !Subtarget->hasSSE2() &&
10892          Subtarget->hasMMX() && "Unexpected custom BITCAST");
10893   assert((DstVT == MVT::i64 ||
10894           (DstVT.isVector() && DstVT.getSizeInBits()==64)) &&
10895          "Unexpected custom BITCAST");
10896   // i64 <=> MMX conversions are Legal.
10897   if (SrcVT==MVT::i64 && DstVT.isVector())
10898     return Op;
10899   if (DstVT==MVT::i64 && SrcVT.isVector())
10900     return Op;
10901   // MMX <=> MMX conversions are Legal.
10902   if (SrcVT.isVector() && DstVT.isVector())
10903     return Op;
10904   // All other conversions need to be expanded.
10905   return SDValue();
10906 }
10907
10908 SDValue X86TargetLowering::LowerLOAD_SUB(SDValue Op, SelectionDAG &DAG) const {
10909   SDNode *Node = Op.getNode();
10910   DebugLoc dl = Node->getDebugLoc();
10911   EVT T = Node->getValueType(0);
10912   SDValue negOp = DAG.getNode(ISD::SUB, dl, T,
10913                               DAG.getConstant(0, T), Node->getOperand(2));
10914   return DAG.getAtomic(ISD::ATOMIC_LOAD_ADD, dl,
10915                        cast<AtomicSDNode>(Node)->getMemoryVT(),
10916                        Node->getOperand(0),
10917                        Node->getOperand(1), negOp,
10918                        cast<AtomicSDNode>(Node)->getSrcValue(),
10919                        cast<AtomicSDNode>(Node)->getAlignment(),
10920                        cast<AtomicSDNode>(Node)->getOrdering(),
10921                        cast<AtomicSDNode>(Node)->getSynchScope());
10922 }
10923
10924 static SDValue LowerATOMIC_STORE(SDValue Op, SelectionDAG &DAG) {
10925   SDNode *Node = Op.getNode();
10926   DebugLoc dl = Node->getDebugLoc();
10927   EVT VT = cast<AtomicSDNode>(Node)->getMemoryVT();
10928
10929   // Convert seq_cst store -> xchg
10930   // Convert wide store -> swap (-> cmpxchg8b/cmpxchg16b)
10931   // FIXME: On 32-bit, store -> fist or movq would be more efficient
10932   //        (The only way to get a 16-byte store is cmpxchg16b)
10933   // FIXME: 16-byte ATOMIC_SWAP isn't actually hooked up at the moment.
10934   if (cast<AtomicSDNode>(Node)->getOrdering() == SequentiallyConsistent ||
10935       !DAG.getTargetLoweringInfo().isTypeLegal(VT)) {
10936     SDValue Swap = DAG.getAtomic(ISD::ATOMIC_SWAP, dl,
10937                                  cast<AtomicSDNode>(Node)->getMemoryVT(),
10938                                  Node->getOperand(0),
10939                                  Node->getOperand(1), Node->getOperand(2),
10940                                  cast<AtomicSDNode>(Node)->getMemOperand(),
10941                                  cast<AtomicSDNode>(Node)->getOrdering(),
10942                                  cast<AtomicSDNode>(Node)->getSynchScope());
10943     return Swap.getValue(1);
10944   }
10945   // Other atomic stores have a simple pattern.
10946   return Op;
10947 }
10948
10949 static SDValue LowerADDC_ADDE_SUBC_SUBE(SDValue Op, SelectionDAG &DAG) {
10950   EVT VT = Op.getNode()->getValueType(0);
10951
10952   // Let legalize expand this if it isn't a legal type yet.
10953   if (!DAG.getTargetLoweringInfo().isTypeLegal(VT))
10954     return SDValue();
10955
10956   SDVTList VTs = DAG.getVTList(VT, MVT::i32);
10957
10958   unsigned Opc;
10959   bool ExtraOp = false;
10960   switch (Op.getOpcode()) {
10961   default: llvm_unreachable("Invalid code");
10962   case ISD::ADDC: Opc = X86ISD::ADD; break;
10963   case ISD::ADDE: Opc = X86ISD::ADC; ExtraOp = true; break;
10964   case ISD::SUBC: Opc = X86ISD::SUB; break;
10965   case ISD::SUBE: Opc = X86ISD::SBB; ExtraOp = true; break;
10966   }
10967
10968   if (!ExtraOp)
10969     return DAG.getNode(Opc, Op->getDebugLoc(), VTs, Op.getOperand(0),
10970                        Op.getOperand(1));
10971   return DAG.getNode(Opc, Op->getDebugLoc(), VTs, Op.getOperand(0),
10972                      Op.getOperand(1), Op.getOperand(2));
10973 }
10974
10975 /// LowerOperation - Provide custom lowering hooks for some operations.
10976 ///
10977 SDValue X86TargetLowering::LowerOperation(SDValue Op, SelectionDAG &DAG) const {
10978   switch (Op.getOpcode()) {
10979   default: llvm_unreachable("Should not custom lower this!");
10980   case ISD::SIGN_EXTEND_INREG:  return LowerSIGN_EXTEND_INREG(Op,DAG);
10981   case ISD::MEMBARRIER:         return LowerMEMBARRIER(Op,DAG);
10982   case ISD::ATOMIC_FENCE:       return LowerATOMIC_FENCE(Op,DAG);
10983   case ISD::ATOMIC_CMP_SWAP:    return LowerCMP_SWAP(Op,DAG);
10984   case ISD::ATOMIC_LOAD_SUB:    return LowerLOAD_SUB(Op,DAG);
10985   case ISD::ATOMIC_STORE:       return LowerATOMIC_STORE(Op,DAG);
10986   case ISD::BUILD_VECTOR:       return LowerBUILD_VECTOR(Op, DAG);
10987   case ISD::CONCAT_VECTORS:     return LowerCONCAT_VECTORS(Op, DAG);
10988   case ISD::VECTOR_SHUFFLE:     return LowerVECTOR_SHUFFLE(Op, DAG);
10989   case ISD::EXTRACT_VECTOR_ELT: return LowerEXTRACT_VECTOR_ELT(Op, DAG);
10990   case ISD::INSERT_VECTOR_ELT:  return LowerINSERT_VECTOR_ELT(Op, DAG);
10991   case ISD::EXTRACT_SUBVECTOR:  return LowerEXTRACT_SUBVECTOR(Op, DAG);
10992   case ISD::INSERT_SUBVECTOR:   return LowerINSERT_SUBVECTOR(Op, DAG);
10993   case ISD::SCALAR_TO_VECTOR:   return LowerSCALAR_TO_VECTOR(Op, DAG);
10994   case ISD::ConstantPool:       return LowerConstantPool(Op, DAG);
10995   case ISD::GlobalAddress:      return LowerGlobalAddress(Op, DAG);
10996   case ISD::GlobalTLSAddress:   return LowerGlobalTLSAddress(Op, DAG);
10997   case ISD::ExternalSymbol:     return LowerExternalSymbol(Op, DAG);
10998   case ISD::BlockAddress:       return LowerBlockAddress(Op, DAG);
10999   case ISD::SHL_PARTS:
11000   case ISD::SRA_PARTS:
11001   case ISD::SRL_PARTS:          return LowerShiftParts(Op, DAG);
11002   case ISD::SINT_TO_FP:         return LowerSINT_TO_FP(Op, DAG);
11003   case ISD::UINT_TO_FP:         return LowerUINT_TO_FP(Op, DAG);
11004   case ISD::FP_TO_SINT:         return LowerFP_TO_SINT(Op, DAG);
11005   case ISD::FP_TO_UINT:         return LowerFP_TO_UINT(Op, DAG);
11006   case ISD::FABS:               return LowerFABS(Op, DAG);
11007   case ISD::FNEG:               return LowerFNEG(Op, DAG);
11008   case ISD::FCOPYSIGN:          return LowerFCOPYSIGN(Op, DAG);
11009   case ISD::FGETSIGN:           return LowerFGETSIGN(Op, DAG);
11010   case ISD::SETCC:              return LowerSETCC(Op, DAG);
11011   case ISD::SELECT:             return LowerSELECT(Op, DAG);
11012   case ISD::BRCOND:             return LowerBRCOND(Op, DAG);
11013   case ISD::JumpTable:          return LowerJumpTable(Op, DAG);
11014   case ISD::VASTART:            return LowerVASTART(Op, DAG);
11015   case ISD::VAARG:              return LowerVAARG(Op, DAG);
11016   case ISD::VACOPY:             return LowerVACOPY(Op, DAG);
11017   case ISD::INTRINSIC_WO_CHAIN: return LowerINTRINSIC_WO_CHAIN(Op, DAG);
11018   case ISD::INTRINSIC_W_CHAIN:  return LowerINTRINSIC_W_CHAIN(Op, DAG);
11019   case ISD::RETURNADDR:         return LowerRETURNADDR(Op, DAG);
11020   case ISD::FRAMEADDR:          return LowerFRAMEADDR(Op, DAG);
11021   case ISD::FRAME_TO_ARGS_OFFSET:
11022                                 return LowerFRAME_TO_ARGS_OFFSET(Op, DAG);
11023   case ISD::DYNAMIC_STACKALLOC: return LowerDYNAMIC_STACKALLOC(Op, DAG);
11024   case ISD::EH_RETURN:          return LowerEH_RETURN(Op, DAG);
11025   case ISD::INIT_TRAMPOLINE:    return LowerINIT_TRAMPOLINE(Op, DAG);
11026   case ISD::ADJUST_TRAMPOLINE:  return LowerADJUST_TRAMPOLINE(Op, DAG);
11027   case ISD::FLT_ROUNDS_:        return LowerFLT_ROUNDS_(Op, DAG);
11028   case ISD::CTLZ:               return LowerCTLZ(Op, DAG);
11029   case ISD::CTLZ_ZERO_UNDEF:    return LowerCTLZ_ZERO_UNDEF(Op, DAG);
11030   case ISD::CTTZ:               return LowerCTTZ(Op, DAG);
11031   case ISD::MUL:                return LowerMUL(Op, DAG);
11032   case ISD::SRA:
11033   case ISD::SRL:
11034   case ISD::SHL:                return LowerShift(Op, DAG);
11035   case ISD::SADDO:
11036   case ISD::UADDO:
11037   case ISD::SSUBO:
11038   case ISD::USUBO:
11039   case ISD::SMULO:
11040   case ISD::UMULO:              return LowerXALUO(Op, DAG);
11041   case ISD::READCYCLECOUNTER:   return LowerREADCYCLECOUNTER(Op, DAG);
11042   case ISD::BITCAST:            return LowerBITCAST(Op, DAG);
11043   case ISD::ADDC:
11044   case ISD::ADDE:
11045   case ISD::SUBC:
11046   case ISD::SUBE:               return LowerADDC_ADDE_SUBC_SUBE(Op, DAG);
11047   case ISD::ADD:                return LowerADD(Op, DAG);
11048   case ISD::SUB:                return LowerSUB(Op, DAG);
11049   }
11050 }
11051
11052 static void ReplaceATOMIC_LOAD(SDNode *Node,
11053                                   SmallVectorImpl<SDValue> &Results,
11054                                   SelectionDAG &DAG) {
11055   DebugLoc dl = Node->getDebugLoc();
11056   EVT VT = cast<AtomicSDNode>(Node)->getMemoryVT();
11057
11058   // Convert wide load -> cmpxchg8b/cmpxchg16b
11059   // FIXME: On 32-bit, load -> fild or movq would be more efficient
11060   //        (The only way to get a 16-byte load is cmpxchg16b)
11061   // FIXME: 16-byte ATOMIC_CMP_SWAP isn't actually hooked up at the moment.
11062   SDValue Zero = DAG.getConstant(0, VT);
11063   SDValue Swap = DAG.getAtomic(ISD::ATOMIC_CMP_SWAP, dl, VT,
11064                                Node->getOperand(0),
11065                                Node->getOperand(1), Zero, Zero,
11066                                cast<AtomicSDNode>(Node)->getMemOperand(),
11067                                cast<AtomicSDNode>(Node)->getOrdering(),
11068                                cast<AtomicSDNode>(Node)->getSynchScope());
11069   Results.push_back(Swap.getValue(0));
11070   Results.push_back(Swap.getValue(1));
11071 }
11072
11073 void X86TargetLowering::
11074 ReplaceATOMIC_BINARY_64(SDNode *Node, SmallVectorImpl<SDValue>&Results,
11075                         SelectionDAG &DAG, unsigned NewOp) const {
11076   DebugLoc dl = Node->getDebugLoc();
11077   assert (Node->getValueType(0) == MVT::i64 &&
11078           "Only know how to expand i64 atomics");
11079
11080   SDValue Chain = Node->getOperand(0);
11081   SDValue In1 = Node->getOperand(1);
11082   SDValue In2L = DAG.getNode(ISD::EXTRACT_ELEMENT, dl, MVT::i32,
11083                              Node->getOperand(2), DAG.getIntPtrConstant(0));
11084   SDValue In2H = DAG.getNode(ISD::EXTRACT_ELEMENT, dl, MVT::i32,
11085                              Node->getOperand(2), DAG.getIntPtrConstant(1));
11086   SDValue Ops[] = { Chain, In1, In2L, In2H };
11087   SDVTList Tys = DAG.getVTList(MVT::i32, MVT::i32, MVT::Other);
11088   SDValue Result =
11089     DAG.getMemIntrinsicNode(NewOp, dl, Tys, Ops, 4, MVT::i64,
11090                             cast<MemSDNode>(Node)->getMemOperand());
11091   SDValue OpsF[] = { Result.getValue(0), Result.getValue(1)};
11092   Results.push_back(DAG.getNode(ISD::BUILD_PAIR, dl, MVT::i64, OpsF, 2));
11093   Results.push_back(Result.getValue(2));
11094 }
11095
11096 /// ReplaceNodeResults - Replace a node with an illegal result type
11097 /// with a new node built out of custom code.
11098 void X86TargetLowering::ReplaceNodeResults(SDNode *N,
11099                                            SmallVectorImpl<SDValue>&Results,
11100                                            SelectionDAG &DAG) const {
11101   DebugLoc dl = N->getDebugLoc();
11102   switch (N->getOpcode()) {
11103   default:
11104     llvm_unreachable("Do not know how to custom type legalize this operation!");
11105   case ISD::SIGN_EXTEND_INREG:
11106   case ISD::ADDC:
11107   case ISD::ADDE:
11108   case ISD::SUBC:
11109   case ISD::SUBE:
11110     // We don't want to expand or promote these.
11111     return;
11112   case ISD::FP_TO_SINT:
11113   case ISD::FP_TO_UINT: {
11114     bool IsSigned = N->getOpcode() == ISD::FP_TO_SINT;
11115
11116     if (!IsSigned && !isIntegerTypeFTOL(SDValue(N, 0).getValueType()))
11117       return;
11118
11119     std::pair<SDValue,SDValue> Vals =
11120         FP_TO_INTHelper(SDValue(N, 0), DAG, IsSigned, /*IsReplace=*/ true);
11121     SDValue FIST = Vals.first, StackSlot = Vals.second;
11122     if (FIST.getNode() != 0) {
11123       EVT VT = N->getValueType(0);
11124       // Return a load from the stack slot.
11125       if (StackSlot.getNode() != 0)
11126         Results.push_back(DAG.getLoad(VT, dl, FIST, StackSlot,
11127                                       MachinePointerInfo(),
11128                                       false, false, false, 0));
11129       else
11130         Results.push_back(FIST);
11131     }
11132     return;
11133   }
11134   case ISD::READCYCLECOUNTER: {
11135     SDVTList Tys = DAG.getVTList(MVT::Other, MVT::Glue);
11136     SDValue TheChain = N->getOperand(0);
11137     SDValue rd = DAG.getNode(X86ISD::RDTSC_DAG, dl, Tys, &TheChain, 1);
11138     SDValue eax = DAG.getCopyFromReg(rd, dl, X86::EAX, MVT::i32,
11139                                      rd.getValue(1));
11140     SDValue edx = DAG.getCopyFromReg(eax.getValue(1), dl, X86::EDX, MVT::i32,
11141                                      eax.getValue(2));
11142     // Use a buildpair to merge the two 32-bit values into a 64-bit one.
11143     SDValue Ops[] = { eax, edx };
11144     Results.push_back(DAG.getNode(ISD::BUILD_PAIR, dl, MVT::i64, Ops, 2));
11145     Results.push_back(edx.getValue(1));
11146     return;
11147   }
11148   case ISD::ATOMIC_CMP_SWAP: {
11149     EVT T = N->getValueType(0);
11150     assert((T == MVT::i64 || T == MVT::i128) && "can only expand cmpxchg pair");
11151     bool Regs64bit = T == MVT::i128;
11152     EVT HalfT = Regs64bit ? MVT::i64 : MVT::i32;
11153     SDValue cpInL, cpInH;
11154     cpInL = DAG.getNode(ISD::EXTRACT_ELEMENT, dl, HalfT, N->getOperand(2),
11155                         DAG.getConstant(0, HalfT));
11156     cpInH = DAG.getNode(ISD::EXTRACT_ELEMENT, dl, HalfT, N->getOperand(2),
11157                         DAG.getConstant(1, HalfT));
11158     cpInL = DAG.getCopyToReg(N->getOperand(0), dl,
11159                              Regs64bit ? X86::RAX : X86::EAX,
11160                              cpInL, SDValue());
11161     cpInH = DAG.getCopyToReg(cpInL.getValue(0), dl,
11162                              Regs64bit ? X86::RDX : X86::EDX,
11163                              cpInH, cpInL.getValue(1));
11164     SDValue swapInL, swapInH;
11165     swapInL = DAG.getNode(ISD::EXTRACT_ELEMENT, dl, HalfT, N->getOperand(3),
11166                           DAG.getConstant(0, HalfT));
11167     swapInH = DAG.getNode(ISD::EXTRACT_ELEMENT, dl, HalfT, N->getOperand(3),
11168                           DAG.getConstant(1, HalfT));
11169     swapInL = DAG.getCopyToReg(cpInH.getValue(0), dl,
11170                                Regs64bit ? X86::RBX : X86::EBX,
11171                                swapInL, cpInH.getValue(1));
11172     swapInH = DAG.getCopyToReg(swapInL.getValue(0), dl,
11173                                Regs64bit ? X86::RCX : X86::ECX,
11174                                swapInH, swapInL.getValue(1));
11175     SDValue Ops[] = { swapInH.getValue(0),
11176                       N->getOperand(1),
11177                       swapInH.getValue(1) };
11178     SDVTList Tys = DAG.getVTList(MVT::Other, MVT::Glue);
11179     MachineMemOperand *MMO = cast<AtomicSDNode>(N)->getMemOperand();
11180     unsigned Opcode = Regs64bit ? X86ISD::LCMPXCHG16_DAG :
11181                                   X86ISD::LCMPXCHG8_DAG;
11182     SDValue Result = DAG.getMemIntrinsicNode(Opcode, dl, Tys,
11183                                              Ops, 3, T, MMO);
11184     SDValue cpOutL = DAG.getCopyFromReg(Result.getValue(0), dl,
11185                                         Regs64bit ? X86::RAX : X86::EAX,
11186                                         HalfT, Result.getValue(1));
11187     SDValue cpOutH = DAG.getCopyFromReg(cpOutL.getValue(1), dl,
11188                                         Regs64bit ? X86::RDX : X86::EDX,
11189                                         HalfT, cpOutL.getValue(2));
11190     SDValue OpsF[] = { cpOutL.getValue(0), cpOutH.getValue(0)};
11191     Results.push_back(DAG.getNode(ISD::BUILD_PAIR, dl, T, OpsF, 2));
11192     Results.push_back(cpOutH.getValue(1));
11193     return;
11194   }
11195   case ISD::ATOMIC_LOAD_ADD:
11196     ReplaceATOMIC_BINARY_64(N, Results, DAG, X86ISD::ATOMADD64_DAG);
11197     return;
11198   case ISD::ATOMIC_LOAD_AND:
11199     ReplaceATOMIC_BINARY_64(N, Results, DAG, X86ISD::ATOMAND64_DAG);
11200     return;
11201   case ISD::ATOMIC_LOAD_NAND:
11202     ReplaceATOMIC_BINARY_64(N, Results, DAG, X86ISD::ATOMNAND64_DAG);
11203     return;
11204   case ISD::ATOMIC_LOAD_OR:
11205     ReplaceATOMIC_BINARY_64(N, Results, DAG, X86ISD::ATOMOR64_DAG);
11206     return;
11207   case ISD::ATOMIC_LOAD_SUB:
11208     ReplaceATOMIC_BINARY_64(N, Results, DAG, X86ISD::ATOMSUB64_DAG);
11209     return;
11210   case ISD::ATOMIC_LOAD_XOR:
11211     ReplaceATOMIC_BINARY_64(N, Results, DAG, X86ISD::ATOMXOR64_DAG);
11212     return;
11213   case ISD::ATOMIC_SWAP:
11214     ReplaceATOMIC_BINARY_64(N, Results, DAG, X86ISD::ATOMSWAP64_DAG);
11215     return;
11216   case ISD::ATOMIC_LOAD:
11217     ReplaceATOMIC_LOAD(N, Results, DAG);
11218   }
11219 }
11220
11221 const char *X86TargetLowering::getTargetNodeName(unsigned Opcode) const {
11222   switch (Opcode) {
11223   default: return NULL;
11224   case X86ISD::BSF:                return "X86ISD::BSF";
11225   case X86ISD::BSR:                return "X86ISD::BSR";
11226   case X86ISD::SHLD:               return "X86ISD::SHLD";
11227   case X86ISD::SHRD:               return "X86ISD::SHRD";
11228   case X86ISD::FAND:               return "X86ISD::FAND";
11229   case X86ISD::FOR:                return "X86ISD::FOR";
11230   case X86ISD::FXOR:               return "X86ISD::FXOR";
11231   case X86ISD::FSRL:               return "X86ISD::FSRL";
11232   case X86ISD::FILD:               return "X86ISD::FILD";
11233   case X86ISD::FILD_FLAG:          return "X86ISD::FILD_FLAG";
11234   case X86ISD::FP_TO_INT16_IN_MEM: return "X86ISD::FP_TO_INT16_IN_MEM";
11235   case X86ISD::FP_TO_INT32_IN_MEM: return "X86ISD::FP_TO_INT32_IN_MEM";
11236   case X86ISD::FP_TO_INT64_IN_MEM: return "X86ISD::FP_TO_INT64_IN_MEM";
11237   case X86ISD::FLD:                return "X86ISD::FLD";
11238   case X86ISD::FST:                return "X86ISD::FST";
11239   case X86ISD::CALL:               return "X86ISD::CALL";
11240   case X86ISD::RDTSC_DAG:          return "X86ISD::RDTSC_DAG";
11241   case X86ISD::BT:                 return "X86ISD::BT";
11242   case X86ISD::CMP:                return "X86ISD::CMP";
11243   case X86ISD::COMI:               return "X86ISD::COMI";
11244   case X86ISD::UCOMI:              return "X86ISD::UCOMI";
11245   case X86ISD::SETCC:              return "X86ISD::SETCC";
11246   case X86ISD::SETCC_CARRY:        return "X86ISD::SETCC_CARRY";
11247   case X86ISD::FSETCCsd:           return "X86ISD::FSETCCsd";
11248   case X86ISD::FSETCCss:           return "X86ISD::FSETCCss";
11249   case X86ISD::CMOV:               return "X86ISD::CMOV";
11250   case X86ISD::BRCOND:             return "X86ISD::BRCOND";
11251   case X86ISD::RET_FLAG:           return "X86ISD::RET_FLAG";
11252   case X86ISD::REP_STOS:           return "X86ISD::REP_STOS";
11253   case X86ISD::REP_MOVS:           return "X86ISD::REP_MOVS";
11254   case X86ISD::GlobalBaseReg:      return "X86ISD::GlobalBaseReg";
11255   case X86ISD::Wrapper:            return "X86ISD::Wrapper";
11256   case X86ISD::WrapperRIP:         return "X86ISD::WrapperRIP";
11257   case X86ISD::PEXTRB:             return "X86ISD::PEXTRB";
11258   case X86ISD::PEXTRW:             return "X86ISD::PEXTRW";
11259   case X86ISD::INSERTPS:           return "X86ISD::INSERTPS";
11260   case X86ISD::PINSRB:             return "X86ISD::PINSRB";
11261   case X86ISD::PINSRW:             return "X86ISD::PINSRW";
11262   case X86ISD::PSHUFB:             return "X86ISD::PSHUFB";
11263   case X86ISD::ANDNP:              return "X86ISD::ANDNP";
11264   case X86ISD::PSIGN:              return "X86ISD::PSIGN";
11265   case X86ISD::BLENDV:             return "X86ISD::BLENDV";
11266   case X86ISD::BLENDPW:            return "X86ISD::BLENDPW";
11267   case X86ISD::BLENDPS:            return "X86ISD::BLENDPS";
11268   case X86ISD::BLENDPD:            return "X86ISD::BLENDPD";
11269   case X86ISD::HADD:               return "X86ISD::HADD";
11270   case X86ISD::HSUB:               return "X86ISD::HSUB";
11271   case X86ISD::FHADD:              return "X86ISD::FHADD";
11272   case X86ISD::FHSUB:              return "X86ISD::FHSUB";
11273   case X86ISD::FMAX:               return "X86ISD::FMAX";
11274   case X86ISD::FMIN:               return "X86ISD::FMIN";
11275   case X86ISD::FRSQRT:             return "X86ISD::FRSQRT";
11276   case X86ISD::FRCP:               return "X86ISD::FRCP";
11277   case X86ISD::TLSADDR:            return "X86ISD::TLSADDR";
11278   case X86ISD::TLSBASEADDR:        return "X86ISD::TLSBASEADDR";
11279   case X86ISD::TLSCALL:            return "X86ISD::TLSCALL";
11280   case X86ISD::EH_RETURN:          return "X86ISD::EH_RETURN";
11281   case X86ISD::TC_RETURN:          return "X86ISD::TC_RETURN";
11282   case X86ISD::FNSTCW16m:          return "X86ISD::FNSTCW16m";
11283   case X86ISD::FNSTSW16r:          return "X86ISD::FNSTSW16r";
11284   case X86ISD::LCMPXCHG_DAG:       return "X86ISD::LCMPXCHG_DAG";
11285   case X86ISD::LCMPXCHG8_DAG:      return "X86ISD::LCMPXCHG8_DAG";
11286   case X86ISD::ATOMADD64_DAG:      return "X86ISD::ATOMADD64_DAG";
11287   case X86ISD::ATOMSUB64_DAG:      return "X86ISD::ATOMSUB64_DAG";
11288   case X86ISD::ATOMOR64_DAG:       return "X86ISD::ATOMOR64_DAG";
11289   case X86ISD::ATOMXOR64_DAG:      return "X86ISD::ATOMXOR64_DAG";
11290   case X86ISD::ATOMAND64_DAG:      return "X86ISD::ATOMAND64_DAG";
11291   case X86ISD::ATOMNAND64_DAG:     return "X86ISD::ATOMNAND64_DAG";
11292   case X86ISD::VZEXT_MOVL:         return "X86ISD::VZEXT_MOVL";
11293   case X86ISD::VZEXT_LOAD:         return "X86ISD::VZEXT_LOAD";
11294   case X86ISD::VSHLDQ:             return "X86ISD::VSHLDQ";
11295   case X86ISD::VSRLDQ:             return "X86ISD::VSRLDQ";
11296   case X86ISD::VSHL:               return "X86ISD::VSHL";
11297   case X86ISD::VSRL:               return "X86ISD::VSRL";
11298   case X86ISD::VSRA:               return "X86ISD::VSRA";
11299   case X86ISD::VSHLI:              return "X86ISD::VSHLI";
11300   case X86ISD::VSRLI:              return "X86ISD::VSRLI";
11301   case X86ISD::VSRAI:              return "X86ISD::VSRAI";
11302   case X86ISD::CMPP:               return "X86ISD::CMPP";
11303   case X86ISD::PCMPEQ:             return "X86ISD::PCMPEQ";
11304   case X86ISD::PCMPGT:             return "X86ISD::PCMPGT";
11305   case X86ISD::ADD:                return "X86ISD::ADD";
11306   case X86ISD::SUB:                return "X86ISD::SUB";
11307   case X86ISD::ADC:                return "X86ISD::ADC";
11308   case X86ISD::SBB:                return "X86ISD::SBB";
11309   case X86ISD::SMUL:               return "X86ISD::SMUL";
11310   case X86ISD::UMUL:               return "X86ISD::UMUL";
11311   case X86ISD::INC:                return "X86ISD::INC";
11312   case X86ISD::DEC:                return "X86ISD::DEC";
11313   case X86ISD::OR:                 return "X86ISD::OR";
11314   case X86ISD::XOR:                return "X86ISD::XOR";
11315   case X86ISD::AND:                return "X86ISD::AND";
11316   case X86ISD::ANDN:               return "X86ISD::ANDN";
11317   case X86ISD::BLSI:               return "X86ISD::BLSI";
11318   case X86ISD::BLSMSK:             return "X86ISD::BLSMSK";
11319   case X86ISD::BLSR:               return "X86ISD::BLSR";
11320   case X86ISD::MUL_IMM:            return "X86ISD::MUL_IMM";
11321   case X86ISD::PTEST:              return "X86ISD::PTEST";
11322   case X86ISD::TESTP:              return "X86ISD::TESTP";
11323   case X86ISD::PALIGN:             return "X86ISD::PALIGN";
11324   case X86ISD::PSHUFD:             return "X86ISD::PSHUFD";
11325   case X86ISD::PSHUFHW:            return "X86ISD::PSHUFHW";
11326   case X86ISD::PSHUFLW:            return "X86ISD::PSHUFLW";
11327   case X86ISD::SHUFP:              return "X86ISD::SHUFP";
11328   case X86ISD::MOVLHPS:            return "X86ISD::MOVLHPS";
11329   case X86ISD::MOVLHPD:            return "X86ISD::MOVLHPD";
11330   case X86ISD::MOVHLPS:            return "X86ISD::MOVHLPS";
11331   case X86ISD::MOVLPS:             return "X86ISD::MOVLPS";
11332   case X86ISD::MOVLPD:             return "X86ISD::MOVLPD";
11333   case X86ISD::MOVDDUP:            return "X86ISD::MOVDDUP";
11334   case X86ISD::MOVSHDUP:           return "X86ISD::MOVSHDUP";
11335   case X86ISD::MOVSLDUP:           return "X86ISD::MOVSLDUP";
11336   case X86ISD::MOVSD:              return "X86ISD::MOVSD";
11337   case X86ISD::MOVSS:              return "X86ISD::MOVSS";
11338   case X86ISD::UNPCKL:             return "X86ISD::UNPCKL";
11339   case X86ISD::UNPCKH:             return "X86ISD::UNPCKH";
11340   case X86ISD::VBROADCAST:         return "X86ISD::VBROADCAST";
11341   case X86ISD::VPERMILP:           return "X86ISD::VPERMILP";
11342   case X86ISD::VPERM2X128:         return "X86ISD::VPERM2X128";
11343   case X86ISD::VPERMV:             return "X86ISD::VPERMV";
11344   case X86ISD::VPERMI:             return "X86ISD::VPERMI";
11345   case X86ISD::PMULUDQ:            return "X86ISD::PMULUDQ";
11346   case X86ISD::VASTART_SAVE_XMM_REGS: return "X86ISD::VASTART_SAVE_XMM_REGS";
11347   case X86ISD::VAARG_64:           return "X86ISD::VAARG_64";
11348   case X86ISD::WIN_ALLOCA:         return "X86ISD::WIN_ALLOCA";
11349   case X86ISD::MEMBARRIER:         return "X86ISD::MEMBARRIER";
11350   case X86ISD::SEG_ALLOCA:         return "X86ISD::SEG_ALLOCA";
11351   case X86ISD::WIN_FTOL:           return "X86ISD::WIN_FTOL";
11352   case X86ISD::SAHF:               return "X86ISD::SAHF";
11353   case X86ISD::RDRAND:             return "X86ISD::RDRAND";
11354   case X86ISD::FMADD:              return "X86ISD::FMADD";
11355   case X86ISD::FMSUB:              return "X86ISD::FMSUB";
11356   case X86ISD::FNMADD:             return "X86ISD::FNMADD";
11357   case X86ISD::FNMSUB:             return "X86ISD::FNMSUB";
11358   case X86ISD::FMADDSUB:           return "X86ISD::FMADDSUB";
11359   case X86ISD::FMSUBADD:           return "X86ISD::FMSUBADD";
11360   }
11361 }
11362
11363 // isLegalAddressingMode - Return true if the addressing mode represented
11364 // by AM is legal for this target, for a load/store of the specified type.
11365 bool X86TargetLowering::isLegalAddressingMode(const AddrMode &AM,
11366                                               Type *Ty) const {
11367   // X86 supports extremely general addressing modes.
11368   CodeModel::Model M = getTargetMachine().getCodeModel();
11369   Reloc::Model R = getTargetMachine().getRelocationModel();
11370
11371   // X86 allows a sign-extended 32-bit immediate field as a displacement.
11372   if (!X86::isOffsetSuitableForCodeModel(AM.BaseOffs, M, AM.BaseGV != NULL))
11373     return false;
11374
11375   if (AM.BaseGV) {
11376     unsigned GVFlags =
11377       Subtarget->ClassifyGlobalReference(AM.BaseGV, getTargetMachine());
11378
11379     // If a reference to this global requires an extra load, we can't fold it.
11380     if (isGlobalStubReference(GVFlags))
11381       return false;
11382
11383     // If BaseGV requires a register for the PIC base, we cannot also have a
11384     // BaseReg specified.
11385     if (AM.HasBaseReg && isGlobalRelativeToPICBase(GVFlags))
11386       return false;
11387
11388     // If lower 4G is not available, then we must use rip-relative addressing.
11389     if ((M != CodeModel::Small || R != Reloc::Static) &&
11390         Subtarget->is64Bit() && (AM.BaseOffs || AM.Scale > 1))
11391       return false;
11392   }
11393
11394   switch (AM.Scale) {
11395   case 0:
11396   case 1:
11397   case 2:
11398   case 4:
11399   case 8:
11400     // These scales always work.
11401     break;
11402   case 3:
11403   case 5:
11404   case 9:
11405     // These scales are formed with basereg+scalereg.  Only accept if there is
11406     // no basereg yet.
11407     if (AM.HasBaseReg)
11408       return false;
11409     break;
11410   default:  // Other stuff never works.
11411     return false;
11412   }
11413
11414   return true;
11415 }
11416
11417
11418 bool X86TargetLowering::isTruncateFree(Type *Ty1, Type *Ty2) const {
11419   if (!Ty1->isIntegerTy() || !Ty2->isIntegerTy())
11420     return false;
11421   unsigned NumBits1 = Ty1->getPrimitiveSizeInBits();
11422   unsigned NumBits2 = Ty2->getPrimitiveSizeInBits();
11423   if (NumBits1 <= NumBits2)
11424     return false;
11425   return true;
11426 }
11427
11428 bool X86TargetLowering::isLegalICmpImmediate(int64_t Imm) const {
11429   return Imm == (int32_t)Imm;
11430 }
11431
11432 bool X86TargetLowering::isLegalAddImmediate(int64_t Imm) const {
11433   // Can also use sub to handle negated immediates.
11434   return Imm == (int32_t)Imm;
11435 }
11436
11437 bool X86TargetLowering::isTruncateFree(EVT VT1, EVT VT2) const {
11438   if (!VT1.isInteger() || !VT2.isInteger())
11439     return false;
11440   unsigned NumBits1 = VT1.getSizeInBits();
11441   unsigned NumBits2 = VT2.getSizeInBits();
11442   if (NumBits1 <= NumBits2)
11443     return false;
11444   return true;
11445 }
11446
11447 bool X86TargetLowering::isZExtFree(Type *Ty1, Type *Ty2) const {
11448   // x86-64 implicitly zero-extends 32-bit results in 64-bit registers.
11449   return Ty1->isIntegerTy(32) && Ty2->isIntegerTy(64) && Subtarget->is64Bit();
11450 }
11451
11452 bool X86TargetLowering::isZExtFree(EVT VT1, EVT VT2) const {
11453   // x86-64 implicitly zero-extends 32-bit results in 64-bit registers.
11454   return VT1 == MVT::i32 && VT2 == MVT::i64 && Subtarget->is64Bit();
11455 }
11456
11457 bool X86TargetLowering::isNarrowingProfitable(EVT VT1, EVT VT2) const {
11458   // i16 instructions are longer (0x66 prefix) and potentially slower.
11459   return !(VT1 == MVT::i32 && VT2 == MVT::i16);
11460 }
11461
11462 /// isShuffleMaskLegal - Targets can use this to indicate that they only
11463 /// support *some* VECTOR_SHUFFLE operations, those with specific masks.
11464 /// By default, if a target supports the VECTOR_SHUFFLE node, all mask values
11465 /// are assumed to be legal.
11466 bool
11467 X86TargetLowering::isShuffleMaskLegal(const SmallVectorImpl<int> &M,
11468                                       EVT VT) const {
11469   // Very little shuffling can be done for 64-bit vectors right now.
11470   if (VT.getSizeInBits() == 64)
11471     return false;
11472
11473   // FIXME: pshufb, blends, shifts.
11474   return (VT.getVectorNumElements() == 2 ||
11475           ShuffleVectorSDNode::isSplatMask(&M[0], VT) ||
11476           isMOVLMask(M, VT) ||
11477           isSHUFPMask(M, VT, Subtarget->hasAVX()) ||
11478           isPSHUFDMask(M, VT) ||
11479           isPSHUFHWMask(M, VT, Subtarget->hasAVX2()) ||
11480           isPSHUFLWMask(M, VT, Subtarget->hasAVX2()) ||
11481           isPALIGNRMask(M, VT, Subtarget) ||
11482           isUNPCKLMask(M, VT, Subtarget->hasAVX2()) ||
11483           isUNPCKHMask(M, VT, Subtarget->hasAVX2()) ||
11484           isUNPCKL_v_undef_Mask(M, VT, Subtarget->hasAVX2()) ||
11485           isUNPCKH_v_undef_Mask(M, VT, Subtarget->hasAVX2()));
11486 }
11487
11488 bool
11489 X86TargetLowering::isVectorClearMaskLegal(const SmallVectorImpl<int> &Mask,
11490                                           EVT VT) const {
11491   unsigned NumElts = VT.getVectorNumElements();
11492   // FIXME: This collection of masks seems suspect.
11493   if (NumElts == 2)
11494     return true;
11495   if (NumElts == 4 && VT.getSizeInBits() == 128) {
11496     return (isMOVLMask(Mask, VT)  ||
11497             isCommutedMOVLMask(Mask, VT, true) ||
11498             isSHUFPMask(Mask, VT, Subtarget->hasAVX()) ||
11499             isSHUFPMask(Mask, VT, Subtarget->hasAVX(), /* Commuted */ true));
11500   }
11501   return false;
11502 }
11503
11504 //===----------------------------------------------------------------------===//
11505 //                           X86 Scheduler Hooks
11506 //===----------------------------------------------------------------------===//
11507
11508 // private utility function
11509 MachineBasicBlock *
11510 X86TargetLowering::EmitAtomicBitwiseWithCustomInserter(MachineInstr *bInstr,
11511                                                        MachineBasicBlock *MBB,
11512                                                        unsigned regOpc,
11513                                                        unsigned immOpc,
11514                                                        unsigned LoadOpc,
11515                                                        unsigned CXchgOpc,
11516                                                        unsigned notOpc,
11517                                                        unsigned EAXreg,
11518                                                  const TargetRegisterClass *RC,
11519                                                        bool Invert) const {
11520   // For the atomic bitwise operator, we generate
11521   //   thisMBB:
11522   //   newMBB:
11523   //     ld  t1 = [bitinstr.addr]
11524   //     op  t2 = t1, [bitinstr.val]
11525   //     not t3 = t2  (if Invert)
11526   //     mov EAX = t1
11527   //     lcs dest = [bitinstr.addr], t3  [EAX is implicit]
11528   //     bz  newMBB
11529   //     fallthrough -->nextMBB
11530   const TargetInstrInfo *TII = getTargetMachine().getInstrInfo();
11531   const BasicBlock *LLVM_BB = MBB->getBasicBlock();
11532   MachineFunction::iterator MBBIter = MBB;
11533   ++MBBIter;
11534
11535   /// First build the CFG
11536   MachineFunction *F = MBB->getParent();
11537   MachineBasicBlock *thisMBB = MBB;
11538   MachineBasicBlock *newMBB = F->CreateMachineBasicBlock(LLVM_BB);
11539   MachineBasicBlock *nextMBB = F->CreateMachineBasicBlock(LLVM_BB);
11540   F->insert(MBBIter, newMBB);
11541   F->insert(MBBIter, nextMBB);
11542
11543   // Transfer the remainder of thisMBB and its successor edges to nextMBB.
11544   nextMBB->splice(nextMBB->begin(), thisMBB,
11545                   llvm::next(MachineBasicBlock::iterator(bInstr)),
11546                   thisMBB->end());
11547   nextMBB->transferSuccessorsAndUpdatePHIs(thisMBB);
11548
11549   // Update thisMBB to fall through to newMBB
11550   thisMBB->addSuccessor(newMBB);
11551
11552   // newMBB jumps to itself and fall through to nextMBB
11553   newMBB->addSuccessor(nextMBB);
11554   newMBB->addSuccessor(newMBB);
11555
11556   // Insert instructions into newMBB based on incoming instruction
11557   assert(bInstr->getNumOperands() < X86::AddrNumOperands + 4 &&
11558          "unexpected number of operands");
11559   DebugLoc dl = bInstr->getDebugLoc();
11560   MachineOperand& destOper = bInstr->getOperand(0);
11561   MachineOperand* argOpers[2 + X86::AddrNumOperands];
11562   int numArgs = bInstr->getNumOperands() - 1;
11563   for (int i=0; i < numArgs; ++i)
11564     argOpers[i] = &bInstr->getOperand(i+1);
11565
11566   // x86 address has 4 operands: base, index, scale, and displacement
11567   int lastAddrIndx = X86::AddrNumOperands - 1; // [0,3]
11568   int valArgIndx = lastAddrIndx + 1;
11569
11570   unsigned t1 = F->getRegInfo().createVirtualRegister(RC);
11571   MachineInstrBuilder MIB = BuildMI(newMBB, dl, TII->get(LoadOpc), t1);
11572   for (int i=0; i <= lastAddrIndx; ++i)
11573     (*MIB).addOperand(*argOpers[i]);
11574
11575   unsigned t2 = F->getRegInfo().createVirtualRegister(RC);
11576   assert((argOpers[valArgIndx]->isReg() ||
11577           argOpers[valArgIndx]->isImm()) &&
11578          "invalid operand");
11579   if (argOpers[valArgIndx]->isReg())
11580     MIB = BuildMI(newMBB, dl, TII->get(regOpc), t2);
11581   else
11582     MIB = BuildMI(newMBB, dl, TII->get(immOpc), t2);
11583   MIB.addReg(t1);
11584   (*MIB).addOperand(*argOpers[valArgIndx]);
11585
11586   unsigned t3 = F->getRegInfo().createVirtualRegister(RC);
11587   if (Invert) {
11588     MIB = BuildMI(newMBB, dl, TII->get(notOpc), t3).addReg(t2);
11589   }
11590   else
11591     t3 = t2;
11592
11593   MIB = BuildMI(newMBB, dl, TII->get(TargetOpcode::COPY), EAXreg);
11594   MIB.addReg(t1);
11595
11596   MIB = BuildMI(newMBB, dl, TII->get(CXchgOpc));
11597   for (int i=0; i <= lastAddrIndx; ++i)
11598     (*MIB).addOperand(*argOpers[i]);
11599   MIB.addReg(t3);
11600   assert(bInstr->hasOneMemOperand() && "Unexpected number of memoperand");
11601   (*MIB).setMemRefs(bInstr->memoperands_begin(),
11602                     bInstr->memoperands_end());
11603
11604   MIB = BuildMI(newMBB, dl, TII->get(TargetOpcode::COPY), destOper.getReg());
11605   MIB.addReg(EAXreg);
11606
11607   // insert branch
11608   BuildMI(newMBB, dl, TII->get(X86::JNE_4)).addMBB(newMBB);
11609
11610   bInstr->eraseFromParent();   // The pseudo instruction is gone now.
11611   return nextMBB;
11612 }
11613
11614 // private utility function:  64 bit atomics on 32 bit host.
11615 MachineBasicBlock *
11616 X86TargetLowering::EmitAtomicBit6432WithCustomInserter(MachineInstr *bInstr,
11617                                                        MachineBasicBlock *MBB,
11618                                                        unsigned regOpcL,
11619                                                        unsigned regOpcH,
11620                                                        unsigned immOpcL,
11621                                                        unsigned immOpcH,
11622                                                        bool Invert) const {
11623   // For the atomic bitwise operator, we generate
11624   //   thisMBB (instructions are in pairs, except cmpxchg8b)
11625   //     ld t1,t2 = [bitinstr.addr]
11626   //   newMBB:
11627   //     out1, out2 = phi (thisMBB, t1/t2) (newMBB, t3/t4)
11628   //     op  t5, t6 <- out1, out2, [bitinstr.val]
11629   //      (for SWAP, substitute:  mov t5, t6 <- [bitinstr.val])
11630   //     neg t7, t8 < t5, t6  (if Invert)
11631   //     mov ECX, EBX <- t5, t6
11632   //     mov EAX, EDX <- t1, t2
11633   //     cmpxchg8b [bitinstr.addr]  [EAX, EDX, EBX, ECX implicit]
11634   //     mov t3, t4 <- EAX, EDX
11635   //     bz  newMBB
11636   //     result in out1, out2
11637   //     fallthrough -->nextMBB
11638
11639   const TargetRegisterClass *RC = &X86::GR32RegClass;
11640   const unsigned LoadOpc = X86::MOV32rm;
11641   const unsigned NotOpc = X86::NOT32r;
11642   const TargetInstrInfo *TII = getTargetMachine().getInstrInfo();
11643   const BasicBlock *LLVM_BB = MBB->getBasicBlock();
11644   MachineFunction::iterator MBBIter = MBB;
11645   ++MBBIter;
11646
11647   /// First build the CFG
11648   MachineFunction *F = MBB->getParent();
11649   MachineBasicBlock *thisMBB = MBB;
11650   MachineBasicBlock *newMBB = F->CreateMachineBasicBlock(LLVM_BB);
11651   MachineBasicBlock *nextMBB = F->CreateMachineBasicBlock(LLVM_BB);
11652   F->insert(MBBIter, newMBB);
11653   F->insert(MBBIter, nextMBB);
11654
11655   // Transfer the remainder of thisMBB and its successor edges to nextMBB.
11656   nextMBB->splice(nextMBB->begin(), thisMBB,
11657                   llvm::next(MachineBasicBlock::iterator(bInstr)),
11658                   thisMBB->end());
11659   nextMBB->transferSuccessorsAndUpdatePHIs(thisMBB);
11660
11661   // Update thisMBB to fall through to newMBB
11662   thisMBB->addSuccessor(newMBB);
11663
11664   // newMBB jumps to itself and fall through to nextMBB
11665   newMBB->addSuccessor(nextMBB);
11666   newMBB->addSuccessor(newMBB);
11667
11668   DebugLoc dl = bInstr->getDebugLoc();
11669   // Insert instructions into newMBB based on incoming instruction
11670   // There are 8 "real" operands plus 9 implicit def/uses, ignored here.
11671   assert(bInstr->getNumOperands() < X86::AddrNumOperands + 14 &&
11672          "unexpected number of operands");
11673   MachineOperand& dest1Oper = bInstr->getOperand(0);
11674   MachineOperand& dest2Oper = bInstr->getOperand(1);
11675   MachineOperand* argOpers[2 + X86::AddrNumOperands];
11676   for (int i=0; i < 2 + X86::AddrNumOperands; ++i) {
11677     argOpers[i] = &bInstr->getOperand(i+2);
11678
11679     // We use some of the operands multiple times, so conservatively just
11680     // clear any kill flags that might be present.
11681     if (argOpers[i]->isReg() && argOpers[i]->isUse())
11682       argOpers[i]->setIsKill(false);
11683   }
11684
11685   // x86 address has 5 operands: base, index, scale, displacement, and segment.
11686   int lastAddrIndx = X86::AddrNumOperands - 1; // [0,3]
11687
11688   unsigned t1 = F->getRegInfo().createVirtualRegister(RC);
11689   MachineInstrBuilder MIB = BuildMI(thisMBB, dl, TII->get(LoadOpc), t1);
11690   for (int i=0; i <= lastAddrIndx; ++i)
11691     (*MIB).addOperand(*argOpers[i]);
11692   unsigned t2 = F->getRegInfo().createVirtualRegister(RC);
11693   MIB = BuildMI(thisMBB, dl, TII->get(LoadOpc), t2);
11694   // add 4 to displacement.
11695   for (int i=0; i <= lastAddrIndx-2; ++i)
11696     (*MIB).addOperand(*argOpers[i]);
11697   MachineOperand newOp3 = *(argOpers[3]);
11698   if (newOp3.isImm())
11699     newOp3.setImm(newOp3.getImm()+4);
11700   else
11701     newOp3.setOffset(newOp3.getOffset()+4);
11702   (*MIB).addOperand(newOp3);
11703   (*MIB).addOperand(*argOpers[lastAddrIndx]);
11704
11705   // t3/4 are defined later, at the bottom of the loop
11706   unsigned t3 = F->getRegInfo().createVirtualRegister(RC);
11707   unsigned t4 = F->getRegInfo().createVirtualRegister(RC);
11708   BuildMI(newMBB, dl, TII->get(X86::PHI), dest1Oper.getReg())
11709     .addReg(t1).addMBB(thisMBB).addReg(t3).addMBB(newMBB);
11710   BuildMI(newMBB, dl, TII->get(X86::PHI), dest2Oper.getReg())
11711     .addReg(t2).addMBB(thisMBB).addReg(t4).addMBB(newMBB);
11712
11713   // The subsequent operations should be using the destination registers of
11714   // the PHI instructions.
11715   t1 = dest1Oper.getReg();
11716   t2 = dest2Oper.getReg();
11717
11718   int valArgIndx = lastAddrIndx + 1;
11719   assert((argOpers[valArgIndx]->isReg() ||
11720           argOpers[valArgIndx]->isImm()) &&
11721          "invalid operand");
11722   unsigned t5 = F->getRegInfo().createVirtualRegister(RC);
11723   unsigned t6 = F->getRegInfo().createVirtualRegister(RC);
11724   if (argOpers[valArgIndx]->isReg())
11725     MIB = BuildMI(newMBB, dl, TII->get(regOpcL), t5);
11726   else
11727     MIB = BuildMI(newMBB, dl, TII->get(immOpcL), t5);
11728   if (regOpcL != X86::MOV32rr)
11729     MIB.addReg(t1);
11730   (*MIB).addOperand(*argOpers[valArgIndx]);
11731   assert(argOpers[valArgIndx + 1]->isReg() ==
11732          argOpers[valArgIndx]->isReg());
11733   assert(argOpers[valArgIndx + 1]->isImm() ==
11734          argOpers[valArgIndx]->isImm());
11735   if (argOpers[valArgIndx + 1]->isReg())
11736     MIB = BuildMI(newMBB, dl, TII->get(regOpcH), t6);
11737   else
11738     MIB = BuildMI(newMBB, dl, TII->get(immOpcH), t6);
11739   if (regOpcH != X86::MOV32rr)
11740     MIB.addReg(t2);
11741   (*MIB).addOperand(*argOpers[valArgIndx + 1]);
11742
11743   unsigned t7, t8;
11744   if (Invert) {
11745     t7 = F->getRegInfo().createVirtualRegister(RC);
11746     t8 = F->getRegInfo().createVirtualRegister(RC);
11747     MIB = BuildMI(newMBB, dl, TII->get(NotOpc), t7).addReg(t5);
11748     MIB = BuildMI(newMBB, dl, TII->get(NotOpc), t8).addReg(t6);
11749   } else {
11750     t7 = t5;
11751     t8 = t6;
11752   }
11753
11754   MIB = BuildMI(newMBB, dl, TII->get(TargetOpcode::COPY), X86::EAX);
11755   MIB.addReg(t1);
11756   MIB = BuildMI(newMBB, dl, TII->get(TargetOpcode::COPY), X86::EDX);
11757   MIB.addReg(t2);
11758
11759   MIB = BuildMI(newMBB, dl, TII->get(TargetOpcode::COPY), X86::EBX);
11760   MIB.addReg(t7);
11761   MIB = BuildMI(newMBB, dl, TII->get(TargetOpcode::COPY), X86::ECX);
11762   MIB.addReg(t8);
11763
11764   MIB = BuildMI(newMBB, dl, TII->get(X86::LCMPXCHG8B));
11765   for (int i=0; i <= lastAddrIndx; ++i)
11766     (*MIB).addOperand(*argOpers[i]);
11767
11768   assert(bInstr->hasOneMemOperand() && "Unexpected number of memoperand");
11769   (*MIB).setMemRefs(bInstr->memoperands_begin(),
11770                     bInstr->memoperands_end());
11771
11772   MIB = BuildMI(newMBB, dl, TII->get(TargetOpcode::COPY), t3);
11773   MIB.addReg(X86::EAX);
11774   MIB = BuildMI(newMBB, dl, TII->get(TargetOpcode::COPY), t4);
11775   MIB.addReg(X86::EDX);
11776
11777   // insert branch
11778   BuildMI(newMBB, dl, TII->get(X86::JNE_4)).addMBB(newMBB);
11779
11780   bInstr->eraseFromParent();   // The pseudo instruction is gone now.
11781   return nextMBB;
11782 }
11783
11784 // private utility function
11785 MachineBasicBlock *
11786 X86TargetLowering::EmitAtomicMinMaxWithCustomInserter(MachineInstr *mInstr,
11787                                                       MachineBasicBlock *MBB,
11788                                                       unsigned cmovOpc) const {
11789   // For the atomic min/max operator, we generate
11790   //   thisMBB:
11791   //   newMBB:
11792   //     ld t1 = [min/max.addr]
11793   //     mov t2 = [min/max.val]
11794   //     cmp  t1, t2
11795   //     cmov[cond] t2 = t1
11796   //     mov EAX = t1
11797   //     lcs dest = [bitinstr.addr], t2  [EAX is implicit]
11798   //     bz   newMBB
11799   //     fallthrough -->nextMBB
11800   //
11801   const TargetInstrInfo *TII = getTargetMachine().getInstrInfo();
11802   const BasicBlock *LLVM_BB = MBB->getBasicBlock();
11803   MachineFunction::iterator MBBIter = MBB;
11804   ++MBBIter;
11805
11806   /// First build the CFG
11807   MachineFunction *F = MBB->getParent();
11808   MachineBasicBlock *thisMBB = MBB;
11809   MachineBasicBlock *newMBB = F->CreateMachineBasicBlock(LLVM_BB);
11810   MachineBasicBlock *nextMBB = F->CreateMachineBasicBlock(LLVM_BB);
11811   F->insert(MBBIter, newMBB);
11812   F->insert(MBBIter, nextMBB);
11813
11814   // Transfer the remainder of thisMBB and its successor edges to nextMBB.
11815   nextMBB->splice(nextMBB->begin(), thisMBB,
11816                   llvm::next(MachineBasicBlock::iterator(mInstr)),
11817                   thisMBB->end());
11818   nextMBB->transferSuccessorsAndUpdatePHIs(thisMBB);
11819
11820   // Update thisMBB to fall through to newMBB
11821   thisMBB->addSuccessor(newMBB);
11822
11823   // newMBB jumps to newMBB and fall through to nextMBB
11824   newMBB->addSuccessor(nextMBB);
11825   newMBB->addSuccessor(newMBB);
11826
11827   DebugLoc dl = mInstr->getDebugLoc();
11828   // Insert instructions into newMBB based on incoming instruction
11829   assert(mInstr->getNumOperands() < X86::AddrNumOperands + 4 &&
11830          "unexpected number of operands");
11831   MachineOperand& destOper = mInstr->getOperand(0);
11832   MachineOperand* argOpers[2 + X86::AddrNumOperands];
11833   int numArgs = mInstr->getNumOperands() - 1;
11834   for (int i=0; i < numArgs; ++i)
11835     argOpers[i] = &mInstr->getOperand(i+1);
11836
11837   // x86 address has 4 operands: base, index, scale, and displacement
11838   int lastAddrIndx = X86::AddrNumOperands - 1; // [0,3]
11839   int valArgIndx = lastAddrIndx + 1;
11840
11841   unsigned t1 = F->getRegInfo().createVirtualRegister(&X86::GR32RegClass);
11842   MachineInstrBuilder MIB = BuildMI(newMBB, dl, TII->get(X86::MOV32rm), t1);
11843   for (int i=0; i <= lastAddrIndx; ++i)
11844     (*MIB).addOperand(*argOpers[i]);
11845
11846   // We only support register and immediate values
11847   assert((argOpers[valArgIndx]->isReg() ||
11848           argOpers[valArgIndx]->isImm()) &&
11849          "invalid operand");
11850
11851   unsigned t2 = F->getRegInfo().createVirtualRegister(&X86::GR32RegClass);
11852   if (argOpers[valArgIndx]->isReg())
11853     MIB = BuildMI(newMBB, dl, TII->get(TargetOpcode::COPY), t2);
11854   else
11855     MIB = BuildMI(newMBB, dl, TII->get(X86::MOV32rr), t2);
11856   (*MIB).addOperand(*argOpers[valArgIndx]);
11857
11858   MIB = BuildMI(newMBB, dl, TII->get(TargetOpcode::COPY), X86::EAX);
11859   MIB.addReg(t1);
11860
11861   MIB = BuildMI(newMBB, dl, TII->get(X86::CMP32rr));
11862   MIB.addReg(t1);
11863   MIB.addReg(t2);
11864
11865   // Generate movc
11866   unsigned t3 = F->getRegInfo().createVirtualRegister(&X86::GR32RegClass);
11867   MIB = BuildMI(newMBB, dl, TII->get(cmovOpc),t3);
11868   MIB.addReg(t2);
11869   MIB.addReg(t1);
11870
11871   // Cmp and exchange if none has modified the memory location
11872   MIB = BuildMI(newMBB, dl, TII->get(X86::LCMPXCHG32));
11873   for (int i=0; i <= lastAddrIndx; ++i)
11874     (*MIB).addOperand(*argOpers[i]);
11875   MIB.addReg(t3);
11876   assert(mInstr->hasOneMemOperand() && "Unexpected number of memoperand");
11877   (*MIB).setMemRefs(mInstr->memoperands_begin(),
11878                     mInstr->memoperands_end());
11879
11880   MIB = BuildMI(newMBB, dl, TII->get(TargetOpcode::COPY), destOper.getReg());
11881   MIB.addReg(X86::EAX);
11882
11883   // insert branch
11884   BuildMI(newMBB, dl, TII->get(X86::JNE_4)).addMBB(newMBB);
11885
11886   mInstr->eraseFromParent();   // The pseudo instruction is gone now.
11887   return nextMBB;
11888 }
11889
11890 // FIXME: When we get size specific XMM0 registers, i.e. XMM0_V16I8
11891 // or XMM0_V32I8 in AVX all of this code can be replaced with that
11892 // in the .td file.
11893 MachineBasicBlock *
11894 X86TargetLowering::EmitPCMP(MachineInstr *MI, MachineBasicBlock *BB,
11895                             unsigned numArgs, bool memArg) const {
11896   assert(Subtarget->hasSSE42() &&
11897          "Target must have SSE4.2 or AVX features enabled");
11898
11899   DebugLoc dl = MI->getDebugLoc();
11900   const TargetInstrInfo *TII = getTargetMachine().getInstrInfo();
11901   unsigned Opc;
11902   if (!Subtarget->hasAVX()) {
11903     if (memArg)
11904       Opc = numArgs == 3 ? X86::PCMPISTRM128rm : X86::PCMPESTRM128rm;
11905     else
11906       Opc = numArgs == 3 ? X86::PCMPISTRM128rr : X86::PCMPESTRM128rr;
11907   } else {
11908     if (memArg)
11909       Opc = numArgs == 3 ? X86::VPCMPISTRM128rm : X86::VPCMPESTRM128rm;
11910     else
11911       Opc = numArgs == 3 ? X86::VPCMPISTRM128rr : X86::VPCMPESTRM128rr;
11912   }
11913
11914   MachineInstrBuilder MIB = BuildMI(*BB, MI, dl, TII->get(Opc));
11915   for (unsigned i = 0; i < numArgs; ++i) {
11916     MachineOperand &Op = MI->getOperand(i+1);
11917     if (!(Op.isReg() && Op.isImplicit()))
11918       MIB.addOperand(Op);
11919   }
11920   BuildMI(*BB, MI, dl,
11921     TII->get(TargetOpcode::COPY), MI->getOperand(0).getReg())
11922     .addReg(X86::XMM0);
11923
11924   MI->eraseFromParent();
11925   return BB;
11926 }
11927
11928 MachineBasicBlock *
11929 X86TargetLowering::EmitMonitor(MachineInstr *MI, MachineBasicBlock *BB) const {
11930   DebugLoc dl = MI->getDebugLoc();
11931   const TargetInstrInfo *TII = getTargetMachine().getInstrInfo();
11932
11933   // Address into RAX/EAX, other two args into ECX, EDX.
11934   unsigned MemOpc = Subtarget->is64Bit() ? X86::LEA64r : X86::LEA32r;
11935   unsigned MemReg = Subtarget->is64Bit() ? X86::RAX : X86::EAX;
11936   MachineInstrBuilder MIB = BuildMI(*BB, MI, dl, TII->get(MemOpc), MemReg);
11937   for (int i = 0; i < X86::AddrNumOperands; ++i)
11938     MIB.addOperand(MI->getOperand(i));
11939
11940   unsigned ValOps = X86::AddrNumOperands;
11941   BuildMI(*BB, MI, dl, TII->get(TargetOpcode::COPY), X86::ECX)
11942     .addReg(MI->getOperand(ValOps).getReg());
11943   BuildMI(*BB, MI, dl, TII->get(TargetOpcode::COPY), X86::EDX)
11944     .addReg(MI->getOperand(ValOps+1).getReg());
11945
11946   // The instruction doesn't actually take any operands though.
11947   BuildMI(*BB, MI, dl, TII->get(X86::MONITORrrr));
11948
11949   MI->eraseFromParent(); // The pseudo is gone now.
11950   return BB;
11951 }
11952
11953 MachineBasicBlock *
11954 X86TargetLowering::EmitVAARG64WithCustomInserter(
11955                    MachineInstr *MI,
11956                    MachineBasicBlock *MBB) const {
11957   // Emit va_arg instruction on X86-64.
11958
11959   // Operands to this pseudo-instruction:
11960   // 0  ) Output        : destination address (reg)
11961   // 1-5) Input         : va_list address (addr, i64mem)
11962   // 6  ) ArgSize       : Size (in bytes) of vararg type
11963   // 7  ) ArgMode       : 0=overflow only, 1=use gp_offset, 2=use fp_offset
11964   // 8  ) Align         : Alignment of type
11965   // 9  ) EFLAGS (implicit-def)
11966
11967   assert(MI->getNumOperands() == 10 && "VAARG_64 should have 10 operands!");
11968   assert(X86::AddrNumOperands == 5 && "VAARG_64 assumes 5 address operands");
11969
11970   unsigned DestReg = MI->getOperand(0).getReg();
11971   MachineOperand &Base = MI->getOperand(1);
11972   MachineOperand &Scale = MI->getOperand(2);
11973   MachineOperand &Index = MI->getOperand(3);
11974   MachineOperand &Disp = MI->getOperand(4);
11975   MachineOperand &Segment = MI->getOperand(5);
11976   unsigned ArgSize = MI->getOperand(6).getImm();
11977   unsigned ArgMode = MI->getOperand(7).getImm();
11978   unsigned Align = MI->getOperand(8).getImm();
11979
11980   // Memory Reference
11981   assert(MI->hasOneMemOperand() && "Expected VAARG_64 to have one memoperand");
11982   MachineInstr::mmo_iterator MMOBegin = MI->memoperands_begin();
11983   MachineInstr::mmo_iterator MMOEnd = MI->memoperands_end();
11984
11985   // Machine Information
11986   const TargetInstrInfo *TII = getTargetMachine().getInstrInfo();
11987   MachineRegisterInfo &MRI = MBB->getParent()->getRegInfo();
11988   const TargetRegisterClass *AddrRegClass = getRegClassFor(MVT::i64);
11989   const TargetRegisterClass *OffsetRegClass = getRegClassFor(MVT::i32);
11990   DebugLoc DL = MI->getDebugLoc();
11991
11992   // struct va_list {
11993   //   i32   gp_offset
11994   //   i32   fp_offset
11995   //   i64   overflow_area (address)
11996   //   i64   reg_save_area (address)
11997   // }
11998   // sizeof(va_list) = 24
11999   // alignment(va_list) = 8
12000
12001   unsigned TotalNumIntRegs = 6;
12002   unsigned TotalNumXMMRegs = 8;
12003   bool UseGPOffset = (ArgMode == 1);
12004   bool UseFPOffset = (ArgMode == 2);
12005   unsigned MaxOffset = TotalNumIntRegs * 8 +
12006                        (UseFPOffset ? TotalNumXMMRegs * 16 : 0);
12007
12008   /* Align ArgSize to a multiple of 8 */
12009   unsigned ArgSizeA8 = (ArgSize + 7) & ~7;
12010   bool NeedsAlign = (Align > 8);
12011
12012   MachineBasicBlock *thisMBB = MBB;
12013   MachineBasicBlock *overflowMBB;
12014   MachineBasicBlock *offsetMBB;
12015   MachineBasicBlock *endMBB;
12016
12017   unsigned OffsetDestReg = 0;    // Argument address computed by offsetMBB
12018   unsigned OverflowDestReg = 0;  // Argument address computed by overflowMBB
12019   unsigned OffsetReg = 0;
12020
12021   if (!UseGPOffset && !UseFPOffset) {
12022     // If we only pull from the overflow region, we don't create a branch.
12023     // We don't need to alter control flow.
12024     OffsetDestReg = 0; // unused
12025     OverflowDestReg = DestReg;
12026
12027     offsetMBB = NULL;
12028     overflowMBB = thisMBB;
12029     endMBB = thisMBB;
12030   } else {
12031     // First emit code to check if gp_offset (or fp_offset) is below the bound.
12032     // If so, pull the argument from reg_save_area. (branch to offsetMBB)
12033     // If not, pull from overflow_area. (branch to overflowMBB)
12034     //
12035     //       thisMBB
12036     //         |     .
12037     //         |        .
12038     //     offsetMBB   overflowMBB
12039     //         |        .
12040     //         |     .
12041     //        endMBB
12042
12043     // Registers for the PHI in endMBB
12044     OffsetDestReg = MRI.createVirtualRegister(AddrRegClass);
12045     OverflowDestReg = MRI.createVirtualRegister(AddrRegClass);
12046
12047     const BasicBlock *LLVM_BB = MBB->getBasicBlock();
12048     MachineFunction *MF = MBB->getParent();
12049     overflowMBB = MF->CreateMachineBasicBlock(LLVM_BB);
12050     offsetMBB = MF->CreateMachineBasicBlock(LLVM_BB);
12051     endMBB = MF->CreateMachineBasicBlock(LLVM_BB);
12052
12053     MachineFunction::iterator MBBIter = MBB;
12054     ++MBBIter;
12055
12056     // Insert the new basic blocks
12057     MF->insert(MBBIter, offsetMBB);
12058     MF->insert(MBBIter, overflowMBB);
12059     MF->insert(MBBIter, endMBB);
12060
12061     // Transfer the remainder of MBB and its successor edges to endMBB.
12062     endMBB->splice(endMBB->begin(), thisMBB,
12063                     llvm::next(MachineBasicBlock::iterator(MI)),
12064                     thisMBB->end());
12065     endMBB->transferSuccessorsAndUpdatePHIs(thisMBB);
12066
12067     // Make offsetMBB and overflowMBB successors of thisMBB
12068     thisMBB->addSuccessor(offsetMBB);
12069     thisMBB->addSuccessor(overflowMBB);
12070
12071     // endMBB is a successor of both offsetMBB and overflowMBB
12072     offsetMBB->addSuccessor(endMBB);
12073     overflowMBB->addSuccessor(endMBB);
12074
12075     // Load the offset value into a register
12076     OffsetReg = MRI.createVirtualRegister(OffsetRegClass);
12077     BuildMI(thisMBB, DL, TII->get(X86::MOV32rm), OffsetReg)
12078       .addOperand(Base)
12079       .addOperand(Scale)
12080       .addOperand(Index)
12081       .addDisp(Disp, UseFPOffset ? 4 : 0)
12082       .addOperand(Segment)
12083       .setMemRefs(MMOBegin, MMOEnd);
12084
12085     // Check if there is enough room left to pull this argument.
12086     BuildMI(thisMBB, DL, TII->get(X86::CMP32ri))
12087       .addReg(OffsetReg)
12088       .addImm(MaxOffset + 8 - ArgSizeA8);
12089
12090     // Branch to "overflowMBB" if offset >= max
12091     // Fall through to "offsetMBB" otherwise
12092     BuildMI(thisMBB, DL, TII->get(X86::GetCondBranchFromCond(X86::COND_AE)))
12093       .addMBB(overflowMBB);
12094   }
12095
12096   // In offsetMBB, emit code to use the reg_save_area.
12097   if (offsetMBB) {
12098     assert(OffsetReg != 0);
12099
12100     // Read the reg_save_area address.
12101     unsigned RegSaveReg = MRI.createVirtualRegister(AddrRegClass);
12102     BuildMI(offsetMBB, DL, TII->get(X86::MOV64rm), RegSaveReg)
12103       .addOperand(Base)
12104       .addOperand(Scale)
12105       .addOperand(Index)
12106       .addDisp(Disp, 16)
12107       .addOperand(Segment)
12108       .setMemRefs(MMOBegin, MMOEnd);
12109
12110     // Zero-extend the offset
12111     unsigned OffsetReg64 = MRI.createVirtualRegister(AddrRegClass);
12112       BuildMI(offsetMBB, DL, TII->get(X86::SUBREG_TO_REG), OffsetReg64)
12113         .addImm(0)
12114         .addReg(OffsetReg)
12115         .addImm(X86::sub_32bit);
12116
12117     // Add the offset to the reg_save_area to get the final address.
12118     BuildMI(offsetMBB, DL, TII->get(X86::ADD64rr), OffsetDestReg)
12119       .addReg(OffsetReg64)
12120       .addReg(RegSaveReg);
12121
12122     // Compute the offset for the next argument
12123     unsigned NextOffsetReg = MRI.createVirtualRegister(OffsetRegClass);
12124     BuildMI(offsetMBB, DL, TII->get(X86::ADD32ri), NextOffsetReg)
12125       .addReg(OffsetReg)
12126       .addImm(UseFPOffset ? 16 : 8);
12127
12128     // Store it back into the va_list.
12129     BuildMI(offsetMBB, DL, TII->get(X86::MOV32mr))
12130       .addOperand(Base)
12131       .addOperand(Scale)
12132       .addOperand(Index)
12133       .addDisp(Disp, UseFPOffset ? 4 : 0)
12134       .addOperand(Segment)
12135       .addReg(NextOffsetReg)
12136       .setMemRefs(MMOBegin, MMOEnd);
12137
12138     // Jump to endMBB
12139     BuildMI(offsetMBB, DL, TII->get(X86::JMP_4))
12140       .addMBB(endMBB);
12141   }
12142
12143   //
12144   // Emit code to use overflow area
12145   //
12146
12147   // Load the overflow_area address into a register.
12148   unsigned OverflowAddrReg = MRI.createVirtualRegister(AddrRegClass);
12149   BuildMI(overflowMBB, DL, TII->get(X86::MOV64rm), OverflowAddrReg)
12150     .addOperand(Base)
12151     .addOperand(Scale)
12152     .addOperand(Index)
12153     .addDisp(Disp, 8)
12154     .addOperand(Segment)
12155     .setMemRefs(MMOBegin, MMOEnd);
12156
12157   // If we need to align it, do so. Otherwise, just copy the address
12158   // to OverflowDestReg.
12159   if (NeedsAlign) {
12160     // Align the overflow address
12161     assert((Align & (Align-1)) == 0 && "Alignment must be a power of 2");
12162     unsigned TmpReg = MRI.createVirtualRegister(AddrRegClass);
12163
12164     // aligned_addr = (addr + (align-1)) & ~(align-1)
12165     BuildMI(overflowMBB, DL, TII->get(X86::ADD64ri32), TmpReg)
12166       .addReg(OverflowAddrReg)
12167       .addImm(Align-1);
12168
12169     BuildMI(overflowMBB, DL, TII->get(X86::AND64ri32), OverflowDestReg)
12170       .addReg(TmpReg)
12171       .addImm(~(uint64_t)(Align-1));
12172   } else {
12173     BuildMI(overflowMBB, DL, TII->get(TargetOpcode::COPY), OverflowDestReg)
12174       .addReg(OverflowAddrReg);
12175   }
12176
12177   // Compute the next overflow address after this argument.
12178   // (the overflow address should be kept 8-byte aligned)
12179   unsigned NextAddrReg = MRI.createVirtualRegister(AddrRegClass);
12180   BuildMI(overflowMBB, DL, TII->get(X86::ADD64ri32), NextAddrReg)
12181     .addReg(OverflowDestReg)
12182     .addImm(ArgSizeA8);
12183
12184   // Store the new overflow address.
12185   BuildMI(overflowMBB, DL, TII->get(X86::MOV64mr))
12186     .addOperand(Base)
12187     .addOperand(Scale)
12188     .addOperand(Index)
12189     .addDisp(Disp, 8)
12190     .addOperand(Segment)
12191     .addReg(NextAddrReg)
12192     .setMemRefs(MMOBegin, MMOEnd);
12193
12194   // If we branched, emit the PHI to the front of endMBB.
12195   if (offsetMBB) {
12196     BuildMI(*endMBB, endMBB->begin(), DL,
12197             TII->get(X86::PHI), DestReg)
12198       .addReg(OffsetDestReg).addMBB(offsetMBB)
12199       .addReg(OverflowDestReg).addMBB(overflowMBB);
12200   }
12201
12202   // Erase the pseudo instruction
12203   MI->eraseFromParent();
12204
12205   return endMBB;
12206 }
12207
12208 MachineBasicBlock *
12209 X86TargetLowering::EmitVAStartSaveXMMRegsWithCustomInserter(
12210                                                  MachineInstr *MI,
12211                                                  MachineBasicBlock *MBB) const {
12212   // Emit code to save XMM registers to the stack. The ABI says that the
12213   // number of registers to save is given in %al, so it's theoretically
12214   // possible to do an indirect jump trick to avoid saving all of them,
12215   // however this code takes a simpler approach and just executes all
12216   // of the stores if %al is non-zero. It's less code, and it's probably
12217   // easier on the hardware branch predictor, and stores aren't all that
12218   // expensive anyway.
12219
12220   // Create the new basic blocks. One block contains all the XMM stores,
12221   // and one block is the final destination regardless of whether any
12222   // stores were performed.
12223   const BasicBlock *LLVM_BB = MBB->getBasicBlock();
12224   MachineFunction *F = MBB->getParent();
12225   MachineFunction::iterator MBBIter = MBB;
12226   ++MBBIter;
12227   MachineBasicBlock *XMMSaveMBB = F->CreateMachineBasicBlock(LLVM_BB);
12228   MachineBasicBlock *EndMBB = F->CreateMachineBasicBlock(LLVM_BB);
12229   F->insert(MBBIter, XMMSaveMBB);
12230   F->insert(MBBIter, EndMBB);
12231
12232   // Transfer the remainder of MBB and its successor edges to EndMBB.
12233   EndMBB->splice(EndMBB->begin(), MBB,
12234                  llvm::next(MachineBasicBlock::iterator(MI)),
12235                  MBB->end());
12236   EndMBB->transferSuccessorsAndUpdatePHIs(MBB);
12237
12238   // The original block will now fall through to the XMM save block.
12239   MBB->addSuccessor(XMMSaveMBB);
12240   // The XMMSaveMBB will fall through to the end block.
12241   XMMSaveMBB->addSuccessor(EndMBB);
12242
12243   // Now add the instructions.
12244   const TargetInstrInfo *TII = getTargetMachine().getInstrInfo();
12245   DebugLoc DL = MI->getDebugLoc();
12246
12247   unsigned CountReg = MI->getOperand(0).getReg();
12248   int64_t RegSaveFrameIndex = MI->getOperand(1).getImm();
12249   int64_t VarArgsFPOffset = MI->getOperand(2).getImm();
12250
12251   if (!Subtarget->isTargetWin64()) {
12252     // If %al is 0, branch around the XMM save block.
12253     BuildMI(MBB, DL, TII->get(X86::TEST8rr)).addReg(CountReg).addReg(CountReg);
12254     BuildMI(MBB, DL, TII->get(X86::JE_4)).addMBB(EndMBB);
12255     MBB->addSuccessor(EndMBB);
12256   }
12257
12258   unsigned MOVOpc = Subtarget->hasAVX() ? X86::VMOVAPSmr : X86::MOVAPSmr;
12259   // In the XMM save block, save all the XMM argument registers.
12260   for (int i = 3, e = MI->getNumOperands(); i != e; ++i) {
12261     int64_t Offset = (i - 3) * 16 + VarArgsFPOffset;
12262     MachineMemOperand *MMO =
12263       F->getMachineMemOperand(
12264           MachinePointerInfo::getFixedStack(RegSaveFrameIndex, Offset),
12265         MachineMemOperand::MOStore,
12266         /*Size=*/16, /*Align=*/16);
12267     BuildMI(XMMSaveMBB, DL, TII->get(MOVOpc))
12268       .addFrameIndex(RegSaveFrameIndex)
12269       .addImm(/*Scale=*/1)
12270       .addReg(/*IndexReg=*/0)
12271       .addImm(/*Disp=*/Offset)
12272       .addReg(/*Segment=*/0)
12273       .addReg(MI->getOperand(i).getReg())
12274       .addMemOperand(MMO);
12275   }
12276
12277   MI->eraseFromParent();   // The pseudo instruction is gone now.
12278
12279   return EndMBB;
12280 }
12281
12282 // The EFLAGS operand of SelectItr might be missing a kill marker
12283 // because there were multiple uses of EFLAGS, and ISel didn't know
12284 // which to mark. Figure out whether SelectItr should have had a
12285 // kill marker, and set it if it should. Returns the correct kill
12286 // marker value.
12287 static bool checkAndUpdateEFLAGSKill(MachineBasicBlock::iterator SelectItr,
12288                                      MachineBasicBlock* BB,
12289                                      const TargetRegisterInfo* TRI) {
12290   // Scan forward through BB for a use/def of EFLAGS.
12291   MachineBasicBlock::iterator miI(llvm::next(SelectItr));
12292   for (MachineBasicBlock::iterator miE = BB->end(); miI != miE; ++miI) {
12293     const MachineInstr& mi = *miI;
12294     if (mi.readsRegister(X86::EFLAGS))
12295       return false;
12296     if (mi.definesRegister(X86::EFLAGS))
12297       break; // Should have kill-flag - update below.
12298   }
12299
12300   // If we hit the end of the block, check whether EFLAGS is live into a
12301   // successor.
12302   if (miI == BB->end()) {
12303     for (MachineBasicBlock::succ_iterator sItr = BB->succ_begin(),
12304                                           sEnd = BB->succ_end();
12305          sItr != sEnd; ++sItr) {
12306       MachineBasicBlock* succ = *sItr;
12307       if (succ->isLiveIn(X86::EFLAGS))
12308         return false;
12309     }
12310   }
12311
12312   // We found a def, or hit the end of the basic block and EFLAGS wasn't live
12313   // out. SelectMI should have a kill flag on EFLAGS.
12314   SelectItr->addRegisterKilled(X86::EFLAGS, TRI);
12315   return true;
12316 }
12317
12318 MachineBasicBlock *
12319 X86TargetLowering::EmitLoweredSelect(MachineInstr *MI,
12320                                      MachineBasicBlock *BB) const {
12321   const TargetInstrInfo *TII = getTargetMachine().getInstrInfo();
12322   DebugLoc DL = MI->getDebugLoc();
12323
12324   // To "insert" a SELECT_CC instruction, we actually have to insert the
12325   // diamond control-flow pattern.  The incoming instruction knows the
12326   // destination vreg to set, the condition code register to branch on, the
12327   // true/false values to select between, and a branch opcode to use.
12328   const BasicBlock *LLVM_BB = BB->getBasicBlock();
12329   MachineFunction::iterator It = BB;
12330   ++It;
12331
12332   //  thisMBB:
12333   //  ...
12334   //   TrueVal = ...
12335   //   cmpTY ccX, r1, r2
12336   //   bCC copy1MBB
12337   //   fallthrough --> copy0MBB
12338   MachineBasicBlock *thisMBB = BB;
12339   MachineFunction *F = BB->getParent();
12340   MachineBasicBlock *copy0MBB = F->CreateMachineBasicBlock(LLVM_BB);
12341   MachineBasicBlock *sinkMBB = F->CreateMachineBasicBlock(LLVM_BB);
12342   F->insert(It, copy0MBB);
12343   F->insert(It, sinkMBB);
12344
12345   // If the EFLAGS register isn't dead in the terminator, then claim that it's
12346   // live into the sink and copy blocks.
12347   const TargetRegisterInfo* TRI = getTargetMachine().getRegisterInfo();
12348   if (!MI->killsRegister(X86::EFLAGS) &&
12349       !checkAndUpdateEFLAGSKill(MI, BB, TRI)) {
12350     copy0MBB->addLiveIn(X86::EFLAGS);
12351     sinkMBB->addLiveIn(X86::EFLAGS);
12352   }
12353
12354   // Transfer the remainder of BB and its successor edges to sinkMBB.
12355   sinkMBB->splice(sinkMBB->begin(), BB,
12356                   llvm::next(MachineBasicBlock::iterator(MI)),
12357                   BB->end());
12358   sinkMBB->transferSuccessorsAndUpdatePHIs(BB);
12359
12360   // Add the true and fallthrough blocks as its successors.
12361   BB->addSuccessor(copy0MBB);
12362   BB->addSuccessor(sinkMBB);
12363
12364   // Create the conditional branch instruction.
12365   unsigned Opc =
12366     X86::GetCondBranchFromCond((X86::CondCode)MI->getOperand(3).getImm());
12367   BuildMI(BB, DL, TII->get(Opc)).addMBB(sinkMBB);
12368
12369   //  copy0MBB:
12370   //   %FalseValue = ...
12371   //   # fallthrough to sinkMBB
12372   copy0MBB->addSuccessor(sinkMBB);
12373
12374   //  sinkMBB:
12375   //   %Result = phi [ %FalseValue, copy0MBB ], [ %TrueValue, thisMBB ]
12376   //  ...
12377   BuildMI(*sinkMBB, sinkMBB->begin(), DL,
12378           TII->get(X86::PHI), MI->getOperand(0).getReg())
12379     .addReg(MI->getOperand(1).getReg()).addMBB(copy0MBB)
12380     .addReg(MI->getOperand(2).getReg()).addMBB(thisMBB);
12381
12382   MI->eraseFromParent();   // The pseudo instruction is gone now.
12383   return sinkMBB;
12384 }
12385
12386 MachineBasicBlock *
12387 X86TargetLowering::EmitLoweredSegAlloca(MachineInstr *MI, MachineBasicBlock *BB,
12388                                         bool Is64Bit) const {
12389   const TargetInstrInfo *TII = getTargetMachine().getInstrInfo();
12390   DebugLoc DL = MI->getDebugLoc();
12391   MachineFunction *MF = BB->getParent();
12392   const BasicBlock *LLVM_BB = BB->getBasicBlock();
12393
12394   assert(getTargetMachine().Options.EnableSegmentedStacks);
12395
12396   unsigned TlsReg = Is64Bit ? X86::FS : X86::GS;
12397   unsigned TlsOffset = Is64Bit ? 0x70 : 0x30;
12398
12399   // BB:
12400   //  ... [Till the alloca]
12401   // If stacklet is not large enough, jump to mallocMBB
12402   //
12403   // bumpMBB:
12404   //  Allocate by subtracting from RSP
12405   //  Jump to continueMBB
12406   //
12407   // mallocMBB:
12408   //  Allocate by call to runtime
12409   //
12410   // continueMBB:
12411   //  ...
12412   //  [rest of original BB]
12413   //
12414
12415   MachineBasicBlock *mallocMBB = MF->CreateMachineBasicBlock(LLVM_BB);
12416   MachineBasicBlock *bumpMBB = MF->CreateMachineBasicBlock(LLVM_BB);
12417   MachineBasicBlock *continueMBB = MF->CreateMachineBasicBlock(LLVM_BB);
12418
12419   MachineRegisterInfo &MRI = MF->getRegInfo();
12420   const TargetRegisterClass *AddrRegClass =
12421     getRegClassFor(Is64Bit ? MVT::i64:MVT::i32);
12422
12423   unsigned mallocPtrVReg = MRI.createVirtualRegister(AddrRegClass),
12424     bumpSPPtrVReg = MRI.createVirtualRegister(AddrRegClass),
12425     tmpSPVReg = MRI.createVirtualRegister(AddrRegClass),
12426     SPLimitVReg = MRI.createVirtualRegister(AddrRegClass),
12427     sizeVReg = MI->getOperand(1).getReg(),
12428     physSPReg = Is64Bit ? X86::RSP : X86::ESP;
12429
12430   MachineFunction::iterator MBBIter = BB;
12431   ++MBBIter;
12432
12433   MF->insert(MBBIter, bumpMBB);
12434   MF->insert(MBBIter, mallocMBB);
12435   MF->insert(MBBIter, continueMBB);
12436
12437   continueMBB->splice(continueMBB->begin(), BB, llvm::next
12438                       (MachineBasicBlock::iterator(MI)), BB->end());
12439   continueMBB->transferSuccessorsAndUpdatePHIs(BB);
12440
12441   // Add code to the main basic block to check if the stack limit has been hit,
12442   // and if so, jump to mallocMBB otherwise to bumpMBB.
12443   BuildMI(BB, DL, TII->get(TargetOpcode::COPY), tmpSPVReg).addReg(physSPReg);
12444   BuildMI(BB, DL, TII->get(Is64Bit ? X86::SUB64rr:X86::SUB32rr), SPLimitVReg)
12445     .addReg(tmpSPVReg).addReg(sizeVReg);
12446   BuildMI(BB, DL, TII->get(Is64Bit ? X86::CMP64mr:X86::CMP32mr))
12447     .addReg(0).addImm(1).addReg(0).addImm(TlsOffset).addReg(TlsReg)
12448     .addReg(SPLimitVReg);
12449   BuildMI(BB, DL, TII->get(X86::JG_4)).addMBB(mallocMBB);
12450
12451   // bumpMBB simply decreases the stack pointer, since we know the current
12452   // stacklet has enough space.
12453   BuildMI(bumpMBB, DL, TII->get(TargetOpcode::COPY), physSPReg)
12454     .addReg(SPLimitVReg);
12455   BuildMI(bumpMBB, DL, TII->get(TargetOpcode::COPY), bumpSPPtrVReg)
12456     .addReg(SPLimitVReg);
12457   BuildMI(bumpMBB, DL, TII->get(X86::JMP_4)).addMBB(continueMBB);
12458
12459   // Calls into a routine in libgcc to allocate more space from the heap.
12460   const uint32_t *RegMask =
12461     getTargetMachine().getRegisterInfo()->getCallPreservedMask(CallingConv::C);
12462   if (Is64Bit) {
12463     BuildMI(mallocMBB, DL, TII->get(X86::MOV64rr), X86::RDI)
12464       .addReg(sizeVReg);
12465     BuildMI(mallocMBB, DL, TII->get(X86::CALL64pcrel32))
12466       .addExternalSymbol("__morestack_allocate_stack_space")
12467       .addRegMask(RegMask)
12468       .addReg(X86::RDI, RegState::Implicit)
12469       .addReg(X86::RAX, RegState::ImplicitDefine);
12470   } else {
12471     BuildMI(mallocMBB, DL, TII->get(X86::SUB32ri), physSPReg).addReg(physSPReg)
12472       .addImm(12);
12473     BuildMI(mallocMBB, DL, TII->get(X86::PUSH32r)).addReg(sizeVReg);
12474     BuildMI(mallocMBB, DL, TII->get(X86::CALLpcrel32))
12475       .addExternalSymbol("__morestack_allocate_stack_space")
12476       .addRegMask(RegMask)
12477       .addReg(X86::EAX, RegState::ImplicitDefine);
12478   }
12479
12480   if (!Is64Bit)
12481     BuildMI(mallocMBB, DL, TII->get(X86::ADD32ri), physSPReg).addReg(physSPReg)
12482       .addImm(16);
12483
12484   BuildMI(mallocMBB, DL, TII->get(TargetOpcode::COPY), mallocPtrVReg)
12485     .addReg(Is64Bit ? X86::RAX : X86::EAX);
12486   BuildMI(mallocMBB, DL, TII->get(X86::JMP_4)).addMBB(continueMBB);
12487
12488   // Set up the CFG correctly.
12489   BB->addSuccessor(bumpMBB);
12490   BB->addSuccessor(mallocMBB);
12491   mallocMBB->addSuccessor(continueMBB);
12492   bumpMBB->addSuccessor(continueMBB);
12493
12494   // Take care of the PHI nodes.
12495   BuildMI(*continueMBB, continueMBB->begin(), DL, TII->get(X86::PHI),
12496           MI->getOperand(0).getReg())
12497     .addReg(mallocPtrVReg).addMBB(mallocMBB)
12498     .addReg(bumpSPPtrVReg).addMBB(bumpMBB);
12499
12500   // Delete the original pseudo instruction.
12501   MI->eraseFromParent();
12502
12503   // And we're done.
12504   return continueMBB;
12505 }
12506
12507 MachineBasicBlock *
12508 X86TargetLowering::EmitLoweredWinAlloca(MachineInstr *MI,
12509                                           MachineBasicBlock *BB) const {
12510   const TargetInstrInfo *TII = getTargetMachine().getInstrInfo();
12511   DebugLoc DL = MI->getDebugLoc();
12512
12513   assert(!Subtarget->isTargetEnvMacho());
12514
12515   // The lowering is pretty easy: we're just emitting the call to _alloca.  The
12516   // non-trivial part is impdef of ESP.
12517
12518   if (Subtarget->isTargetWin64()) {
12519     if (Subtarget->isTargetCygMing()) {
12520       // ___chkstk(Mingw64):
12521       // Clobbers R10, R11, RAX and EFLAGS.
12522       // Updates RSP.
12523       BuildMI(*BB, MI, DL, TII->get(X86::W64ALLOCA))
12524         .addExternalSymbol("___chkstk")
12525         .addReg(X86::RAX, RegState::Implicit)
12526         .addReg(X86::RSP, RegState::Implicit)
12527         .addReg(X86::RAX, RegState::Define | RegState::Implicit)
12528         .addReg(X86::RSP, RegState::Define | RegState::Implicit)
12529         .addReg(X86::EFLAGS, RegState::Define | RegState::Implicit);
12530     } else {
12531       // __chkstk(MSVCRT): does not update stack pointer.
12532       // Clobbers R10, R11 and EFLAGS.
12533       // FIXME: RAX(allocated size) might be reused and not killed.
12534       BuildMI(*BB, MI, DL, TII->get(X86::W64ALLOCA))
12535         .addExternalSymbol("__chkstk")
12536         .addReg(X86::RAX, RegState::Implicit)
12537         .addReg(X86::EFLAGS, RegState::Define | RegState::Implicit);
12538       // RAX has the offset to subtracted from RSP.
12539       BuildMI(*BB, MI, DL, TII->get(X86::SUB64rr), X86::RSP)
12540         .addReg(X86::RSP)
12541         .addReg(X86::RAX);
12542     }
12543   } else {
12544     const char *StackProbeSymbol =
12545       Subtarget->isTargetWindows() ? "_chkstk" : "_alloca";
12546
12547     BuildMI(*BB, MI, DL, TII->get(X86::CALLpcrel32))
12548       .addExternalSymbol(StackProbeSymbol)
12549       .addReg(X86::EAX, RegState::Implicit)
12550       .addReg(X86::ESP, RegState::Implicit)
12551       .addReg(X86::EAX, RegState::Define | RegState::Implicit)
12552       .addReg(X86::ESP, RegState::Define | RegState::Implicit)
12553       .addReg(X86::EFLAGS, RegState::Define | RegState::Implicit);
12554   }
12555
12556   MI->eraseFromParent();   // The pseudo instruction is gone now.
12557   return BB;
12558 }
12559
12560 MachineBasicBlock *
12561 X86TargetLowering::EmitLoweredTLSCall(MachineInstr *MI,
12562                                       MachineBasicBlock *BB) const {
12563   // This is pretty easy.  We're taking the value that we received from
12564   // our load from the relocation, sticking it in either RDI (x86-64)
12565   // or EAX and doing an indirect call.  The return value will then
12566   // be in the normal return register.
12567   const X86InstrInfo *TII
12568     = static_cast<const X86InstrInfo*>(getTargetMachine().getInstrInfo());
12569   DebugLoc DL = MI->getDebugLoc();
12570   MachineFunction *F = BB->getParent();
12571
12572   assert(Subtarget->isTargetDarwin() && "Darwin only instr emitted?");
12573   assert(MI->getOperand(3).isGlobal() && "This should be a global");
12574
12575   // Get a register mask for the lowered call.
12576   // FIXME: The 32-bit calls have non-standard calling conventions. Use a
12577   // proper register mask.
12578   const uint32_t *RegMask =
12579     getTargetMachine().getRegisterInfo()->getCallPreservedMask(CallingConv::C);
12580   if (Subtarget->is64Bit()) {
12581     MachineInstrBuilder MIB = BuildMI(*BB, MI, DL,
12582                                       TII->get(X86::MOV64rm), X86::RDI)
12583     .addReg(X86::RIP)
12584     .addImm(0).addReg(0)
12585     .addGlobalAddress(MI->getOperand(3).getGlobal(), 0,
12586                       MI->getOperand(3).getTargetFlags())
12587     .addReg(0);
12588     MIB = BuildMI(*BB, MI, DL, TII->get(X86::CALL64m));
12589     addDirectMem(MIB, X86::RDI);
12590     MIB.addReg(X86::RAX, RegState::ImplicitDefine).addRegMask(RegMask);
12591   } else if (getTargetMachine().getRelocationModel() != Reloc::PIC_) {
12592     MachineInstrBuilder MIB = BuildMI(*BB, MI, DL,
12593                                       TII->get(X86::MOV32rm), X86::EAX)
12594     .addReg(0)
12595     .addImm(0).addReg(0)
12596     .addGlobalAddress(MI->getOperand(3).getGlobal(), 0,
12597                       MI->getOperand(3).getTargetFlags())
12598     .addReg(0);
12599     MIB = BuildMI(*BB, MI, DL, TII->get(X86::CALL32m));
12600     addDirectMem(MIB, X86::EAX);
12601     MIB.addReg(X86::EAX, RegState::ImplicitDefine).addRegMask(RegMask);
12602   } else {
12603     MachineInstrBuilder MIB = BuildMI(*BB, MI, DL,
12604                                       TII->get(X86::MOV32rm), X86::EAX)
12605     .addReg(TII->getGlobalBaseReg(F))
12606     .addImm(0).addReg(0)
12607     .addGlobalAddress(MI->getOperand(3).getGlobal(), 0,
12608                       MI->getOperand(3).getTargetFlags())
12609     .addReg(0);
12610     MIB = BuildMI(*BB, MI, DL, TII->get(X86::CALL32m));
12611     addDirectMem(MIB, X86::EAX);
12612     MIB.addReg(X86::EAX, RegState::ImplicitDefine).addRegMask(RegMask);
12613   }
12614
12615   MI->eraseFromParent(); // The pseudo instruction is gone now.
12616   return BB;
12617 }
12618
12619 MachineBasicBlock *
12620 X86TargetLowering::EmitInstrWithCustomInserter(MachineInstr *MI,
12621                                                MachineBasicBlock *BB) const {
12622   switch (MI->getOpcode()) {
12623   default: llvm_unreachable("Unexpected instr type to insert");
12624   case X86::TAILJMPd64:
12625   case X86::TAILJMPr64:
12626   case X86::TAILJMPm64:
12627     llvm_unreachable("TAILJMP64 would not be touched here.");
12628   case X86::TCRETURNdi64:
12629   case X86::TCRETURNri64:
12630   case X86::TCRETURNmi64:
12631     return BB;
12632   case X86::WIN_ALLOCA:
12633     return EmitLoweredWinAlloca(MI, BB);
12634   case X86::SEG_ALLOCA_32:
12635     return EmitLoweredSegAlloca(MI, BB, false);
12636   case X86::SEG_ALLOCA_64:
12637     return EmitLoweredSegAlloca(MI, BB, true);
12638   case X86::TLSCall_32:
12639   case X86::TLSCall_64:
12640     return EmitLoweredTLSCall(MI, BB);
12641   case X86::CMOV_GR8:
12642   case X86::CMOV_FR32:
12643   case X86::CMOV_FR64:
12644   case X86::CMOV_V4F32:
12645   case X86::CMOV_V2F64:
12646   case X86::CMOV_V2I64:
12647   case X86::CMOV_V8F32:
12648   case X86::CMOV_V4F64:
12649   case X86::CMOV_V4I64:
12650   case X86::CMOV_GR16:
12651   case X86::CMOV_GR32:
12652   case X86::CMOV_RFP32:
12653   case X86::CMOV_RFP64:
12654   case X86::CMOV_RFP80:
12655     return EmitLoweredSelect(MI, BB);
12656
12657   case X86::FP32_TO_INT16_IN_MEM:
12658   case X86::FP32_TO_INT32_IN_MEM:
12659   case X86::FP32_TO_INT64_IN_MEM:
12660   case X86::FP64_TO_INT16_IN_MEM:
12661   case X86::FP64_TO_INT32_IN_MEM:
12662   case X86::FP64_TO_INT64_IN_MEM:
12663   case X86::FP80_TO_INT16_IN_MEM:
12664   case X86::FP80_TO_INT32_IN_MEM:
12665   case X86::FP80_TO_INT64_IN_MEM: {
12666     const TargetInstrInfo *TII = getTargetMachine().getInstrInfo();
12667     DebugLoc DL = MI->getDebugLoc();
12668
12669     // Change the floating point control register to use "round towards zero"
12670     // mode when truncating to an integer value.
12671     MachineFunction *F = BB->getParent();
12672     int CWFrameIdx = F->getFrameInfo()->CreateStackObject(2, 2, false);
12673     addFrameReference(BuildMI(*BB, MI, DL,
12674                               TII->get(X86::FNSTCW16m)), CWFrameIdx);
12675
12676     // Load the old value of the high byte of the control word...
12677     unsigned OldCW =
12678       F->getRegInfo().createVirtualRegister(&X86::GR16RegClass);
12679     addFrameReference(BuildMI(*BB, MI, DL, TII->get(X86::MOV16rm), OldCW),
12680                       CWFrameIdx);
12681
12682     // Set the high part to be round to zero...
12683     addFrameReference(BuildMI(*BB, MI, DL, TII->get(X86::MOV16mi)), CWFrameIdx)
12684       .addImm(0xC7F);
12685
12686     // Reload the modified control word now...
12687     addFrameReference(BuildMI(*BB, MI, DL,
12688                               TII->get(X86::FLDCW16m)), CWFrameIdx);
12689
12690     // Restore the memory image of control word to original value
12691     addFrameReference(BuildMI(*BB, MI, DL, TII->get(X86::MOV16mr)), CWFrameIdx)
12692       .addReg(OldCW);
12693
12694     // Get the X86 opcode to use.
12695     unsigned Opc;
12696     switch (MI->getOpcode()) {
12697     default: llvm_unreachable("illegal opcode!");
12698     case X86::FP32_TO_INT16_IN_MEM: Opc = X86::IST_Fp16m32; break;
12699     case X86::FP32_TO_INT32_IN_MEM: Opc = X86::IST_Fp32m32; break;
12700     case X86::FP32_TO_INT64_IN_MEM: Opc = X86::IST_Fp64m32; break;
12701     case X86::FP64_TO_INT16_IN_MEM: Opc = X86::IST_Fp16m64; break;
12702     case X86::FP64_TO_INT32_IN_MEM: Opc = X86::IST_Fp32m64; break;
12703     case X86::FP64_TO_INT64_IN_MEM: Opc = X86::IST_Fp64m64; break;
12704     case X86::FP80_TO_INT16_IN_MEM: Opc = X86::IST_Fp16m80; break;
12705     case X86::FP80_TO_INT32_IN_MEM: Opc = X86::IST_Fp32m80; break;
12706     case X86::FP80_TO_INT64_IN_MEM: Opc = X86::IST_Fp64m80; break;
12707     }
12708
12709     X86AddressMode AM;
12710     MachineOperand &Op = MI->getOperand(0);
12711     if (Op.isReg()) {
12712       AM.BaseType = X86AddressMode::RegBase;
12713       AM.Base.Reg = Op.getReg();
12714     } else {
12715       AM.BaseType = X86AddressMode::FrameIndexBase;
12716       AM.Base.FrameIndex = Op.getIndex();
12717     }
12718     Op = MI->getOperand(1);
12719     if (Op.isImm())
12720       AM.Scale = Op.getImm();
12721     Op = MI->getOperand(2);
12722     if (Op.isImm())
12723       AM.IndexReg = Op.getImm();
12724     Op = MI->getOperand(3);
12725     if (Op.isGlobal()) {
12726       AM.GV = Op.getGlobal();
12727     } else {
12728       AM.Disp = Op.getImm();
12729     }
12730     addFullAddress(BuildMI(*BB, MI, DL, TII->get(Opc)), AM)
12731                       .addReg(MI->getOperand(X86::AddrNumOperands).getReg());
12732
12733     // Reload the original control word now.
12734     addFrameReference(BuildMI(*BB, MI, DL,
12735                               TII->get(X86::FLDCW16m)), CWFrameIdx);
12736
12737     MI->eraseFromParent();   // The pseudo instruction is gone now.
12738     return BB;
12739   }
12740     // String/text processing lowering.
12741   case X86::PCMPISTRM128REG:
12742   case X86::VPCMPISTRM128REG:
12743     return EmitPCMP(MI, BB, 3, false /* in-mem */);
12744   case X86::PCMPISTRM128MEM:
12745   case X86::VPCMPISTRM128MEM:
12746     return EmitPCMP(MI, BB, 3, true /* in-mem */);
12747   case X86::PCMPESTRM128REG:
12748   case X86::VPCMPESTRM128REG:
12749     return EmitPCMP(MI, BB, 5, false /* in mem */);
12750   case X86::PCMPESTRM128MEM:
12751   case X86::VPCMPESTRM128MEM:
12752     return EmitPCMP(MI, BB, 5, true /* in mem */);
12753
12754     // Thread synchronization.
12755   case X86::MONITOR:
12756     return EmitMonitor(MI, BB);
12757
12758     // Atomic Lowering.
12759   case X86::ATOMAND32:
12760     return EmitAtomicBitwiseWithCustomInserter(MI, BB, X86::AND32rr,
12761                                                X86::AND32ri, X86::MOV32rm,
12762                                                X86::LCMPXCHG32,
12763                                                X86::NOT32r, X86::EAX,
12764                                                &X86::GR32RegClass);
12765   case X86::ATOMOR32:
12766     return EmitAtomicBitwiseWithCustomInserter(MI, BB, X86::OR32rr,
12767                                                X86::OR32ri, X86::MOV32rm,
12768                                                X86::LCMPXCHG32,
12769                                                X86::NOT32r, X86::EAX,
12770                                                &X86::GR32RegClass);
12771   case X86::ATOMXOR32:
12772     return EmitAtomicBitwiseWithCustomInserter(MI, BB, X86::XOR32rr,
12773                                                X86::XOR32ri, X86::MOV32rm,
12774                                                X86::LCMPXCHG32,
12775                                                X86::NOT32r, X86::EAX,
12776                                                &X86::GR32RegClass);
12777   case X86::ATOMNAND32:
12778     return EmitAtomicBitwiseWithCustomInserter(MI, BB, X86::AND32rr,
12779                                                X86::AND32ri, X86::MOV32rm,
12780                                                X86::LCMPXCHG32,
12781                                                X86::NOT32r, X86::EAX,
12782                                                &X86::GR32RegClass, true);
12783   case X86::ATOMMIN32:
12784     return EmitAtomicMinMaxWithCustomInserter(MI, BB, X86::CMOVL32rr);
12785   case X86::ATOMMAX32:
12786     return EmitAtomicMinMaxWithCustomInserter(MI, BB, X86::CMOVG32rr);
12787   case X86::ATOMUMIN32:
12788     return EmitAtomicMinMaxWithCustomInserter(MI, BB, X86::CMOVB32rr);
12789   case X86::ATOMUMAX32:
12790     return EmitAtomicMinMaxWithCustomInserter(MI, BB, X86::CMOVA32rr);
12791
12792   case X86::ATOMAND16:
12793     return EmitAtomicBitwiseWithCustomInserter(MI, BB, X86::AND16rr,
12794                                                X86::AND16ri, X86::MOV16rm,
12795                                                X86::LCMPXCHG16,
12796                                                X86::NOT16r, X86::AX,
12797                                                &X86::GR16RegClass);
12798   case X86::ATOMOR16:
12799     return EmitAtomicBitwiseWithCustomInserter(MI, BB, X86::OR16rr,
12800                                                X86::OR16ri, X86::MOV16rm,
12801                                                X86::LCMPXCHG16,
12802                                                X86::NOT16r, X86::AX,
12803                                                &X86::GR16RegClass);
12804   case X86::ATOMXOR16:
12805     return EmitAtomicBitwiseWithCustomInserter(MI, BB, X86::XOR16rr,
12806                                                X86::XOR16ri, X86::MOV16rm,
12807                                                X86::LCMPXCHG16,
12808                                                X86::NOT16r, X86::AX,
12809                                                &X86::GR16RegClass);
12810   case X86::ATOMNAND16:
12811     return EmitAtomicBitwiseWithCustomInserter(MI, BB, X86::AND16rr,
12812                                                X86::AND16ri, X86::MOV16rm,
12813                                                X86::LCMPXCHG16,
12814                                                X86::NOT16r, X86::AX,
12815                                                &X86::GR16RegClass, true);
12816   case X86::ATOMMIN16:
12817     return EmitAtomicMinMaxWithCustomInserter(MI, BB, X86::CMOVL16rr);
12818   case X86::ATOMMAX16:
12819     return EmitAtomicMinMaxWithCustomInserter(MI, BB, X86::CMOVG16rr);
12820   case X86::ATOMUMIN16:
12821     return EmitAtomicMinMaxWithCustomInserter(MI, BB, X86::CMOVB16rr);
12822   case X86::ATOMUMAX16:
12823     return EmitAtomicMinMaxWithCustomInserter(MI, BB, X86::CMOVA16rr);
12824
12825   case X86::ATOMAND8:
12826     return EmitAtomicBitwiseWithCustomInserter(MI, BB, X86::AND8rr,
12827                                                X86::AND8ri, X86::MOV8rm,
12828                                                X86::LCMPXCHG8,
12829                                                X86::NOT8r, X86::AL,
12830                                                &X86::GR8RegClass);
12831   case X86::ATOMOR8:
12832     return EmitAtomicBitwiseWithCustomInserter(MI, BB, X86::OR8rr,
12833                                                X86::OR8ri, X86::MOV8rm,
12834                                                X86::LCMPXCHG8,
12835                                                X86::NOT8r, X86::AL,
12836                                                &X86::GR8RegClass);
12837   case X86::ATOMXOR8:
12838     return EmitAtomicBitwiseWithCustomInserter(MI, BB, X86::XOR8rr,
12839                                                X86::XOR8ri, X86::MOV8rm,
12840                                                X86::LCMPXCHG8,
12841                                                X86::NOT8r, X86::AL,
12842                                                &X86::GR8RegClass);
12843   case X86::ATOMNAND8:
12844     return EmitAtomicBitwiseWithCustomInserter(MI, BB, X86::AND8rr,
12845                                                X86::AND8ri, X86::MOV8rm,
12846                                                X86::LCMPXCHG8,
12847                                                X86::NOT8r, X86::AL,
12848                                                &X86::GR8RegClass, true);
12849   // FIXME: There are no CMOV8 instructions; MIN/MAX need some other way.
12850   // This group is for 64-bit host.
12851   case X86::ATOMAND64:
12852     return EmitAtomicBitwiseWithCustomInserter(MI, BB, X86::AND64rr,
12853                                                X86::AND64ri32, X86::MOV64rm,
12854                                                X86::LCMPXCHG64,
12855                                                X86::NOT64r, X86::RAX,
12856                                                &X86::GR64RegClass);
12857   case X86::ATOMOR64:
12858     return EmitAtomicBitwiseWithCustomInserter(MI, BB, X86::OR64rr,
12859                                                X86::OR64ri32, X86::MOV64rm,
12860                                                X86::LCMPXCHG64,
12861                                                X86::NOT64r, X86::RAX,
12862                                                &X86::GR64RegClass);
12863   case X86::ATOMXOR64:
12864     return EmitAtomicBitwiseWithCustomInserter(MI, BB, X86::XOR64rr,
12865                                                X86::XOR64ri32, X86::MOV64rm,
12866                                                X86::LCMPXCHG64,
12867                                                X86::NOT64r, X86::RAX,
12868                                                &X86::GR64RegClass);
12869   case X86::ATOMNAND64:
12870     return EmitAtomicBitwiseWithCustomInserter(MI, BB, X86::AND64rr,
12871                                                X86::AND64ri32, X86::MOV64rm,
12872                                                X86::LCMPXCHG64,
12873                                                X86::NOT64r, X86::RAX,
12874                                                &X86::GR64RegClass, true);
12875   case X86::ATOMMIN64:
12876     return EmitAtomicMinMaxWithCustomInserter(MI, BB, X86::CMOVL64rr);
12877   case X86::ATOMMAX64:
12878     return EmitAtomicMinMaxWithCustomInserter(MI, BB, X86::CMOVG64rr);
12879   case X86::ATOMUMIN64:
12880     return EmitAtomicMinMaxWithCustomInserter(MI, BB, X86::CMOVB64rr);
12881   case X86::ATOMUMAX64:
12882     return EmitAtomicMinMaxWithCustomInserter(MI, BB, X86::CMOVA64rr);
12883
12884   // This group does 64-bit operations on a 32-bit host.
12885   case X86::ATOMAND6432:
12886     return EmitAtomicBit6432WithCustomInserter(MI, BB,
12887                                                X86::AND32rr, X86::AND32rr,
12888                                                X86::AND32ri, X86::AND32ri,
12889                                                false);
12890   case X86::ATOMOR6432:
12891     return EmitAtomicBit6432WithCustomInserter(MI, BB,
12892                                                X86::OR32rr, X86::OR32rr,
12893                                                X86::OR32ri, X86::OR32ri,
12894                                                false);
12895   case X86::ATOMXOR6432:
12896     return EmitAtomicBit6432WithCustomInserter(MI, BB,
12897                                                X86::XOR32rr, X86::XOR32rr,
12898                                                X86::XOR32ri, X86::XOR32ri,
12899                                                false);
12900   case X86::ATOMNAND6432:
12901     return EmitAtomicBit6432WithCustomInserter(MI, BB,
12902                                                X86::AND32rr, X86::AND32rr,
12903                                                X86::AND32ri, X86::AND32ri,
12904                                                true);
12905   case X86::ATOMADD6432:
12906     return EmitAtomicBit6432WithCustomInserter(MI, BB,
12907                                                X86::ADD32rr, X86::ADC32rr,
12908                                                X86::ADD32ri, X86::ADC32ri,
12909                                                false);
12910   case X86::ATOMSUB6432:
12911     return EmitAtomicBit6432WithCustomInserter(MI, BB,
12912                                                X86::SUB32rr, X86::SBB32rr,
12913                                                X86::SUB32ri, X86::SBB32ri,
12914                                                false);
12915   case X86::ATOMSWAP6432:
12916     return EmitAtomicBit6432WithCustomInserter(MI, BB,
12917                                                X86::MOV32rr, X86::MOV32rr,
12918                                                X86::MOV32ri, X86::MOV32ri,
12919                                                false);
12920   case X86::VASTART_SAVE_XMM_REGS:
12921     return EmitVAStartSaveXMMRegsWithCustomInserter(MI, BB);
12922
12923   case X86::VAARG_64:
12924     return EmitVAARG64WithCustomInserter(MI, BB);
12925   }
12926 }
12927
12928 //===----------------------------------------------------------------------===//
12929 //                           X86 Optimization Hooks
12930 //===----------------------------------------------------------------------===//
12931
12932 void X86TargetLowering::computeMaskedBitsForTargetNode(const SDValue Op,
12933                                                        APInt &KnownZero,
12934                                                        APInt &KnownOne,
12935                                                        const SelectionDAG &DAG,
12936                                                        unsigned Depth) const {
12937   unsigned BitWidth = KnownZero.getBitWidth();
12938   unsigned Opc = Op.getOpcode();
12939   assert((Opc >= ISD::BUILTIN_OP_END ||
12940           Opc == ISD::INTRINSIC_WO_CHAIN ||
12941           Opc == ISD::INTRINSIC_W_CHAIN ||
12942           Opc == ISD::INTRINSIC_VOID) &&
12943          "Should use MaskedValueIsZero if you don't know whether Op"
12944          " is a target node!");
12945
12946   KnownZero = KnownOne = APInt(BitWidth, 0);   // Don't know anything.
12947   switch (Opc) {
12948   default: break;
12949   case X86ISD::ADD:
12950   case X86ISD::SUB:
12951   case X86ISD::ADC:
12952   case X86ISD::SBB:
12953   case X86ISD::SMUL:
12954   case X86ISD::UMUL:
12955   case X86ISD::INC:
12956   case X86ISD::DEC:
12957   case X86ISD::OR:
12958   case X86ISD::XOR:
12959   case X86ISD::AND:
12960     // These nodes' second result is a boolean.
12961     if (Op.getResNo() == 0)
12962       break;
12963     // Fallthrough
12964   case X86ISD::SETCC:
12965     KnownZero |= APInt::getHighBitsSet(BitWidth, BitWidth - 1);
12966     break;
12967   case ISD::INTRINSIC_WO_CHAIN: {
12968     unsigned IntId = cast<ConstantSDNode>(Op.getOperand(0))->getZExtValue();
12969     unsigned NumLoBits = 0;
12970     switch (IntId) {
12971     default: break;
12972     case Intrinsic::x86_sse_movmsk_ps:
12973     case Intrinsic::x86_avx_movmsk_ps_256:
12974     case Intrinsic::x86_sse2_movmsk_pd:
12975     case Intrinsic::x86_avx_movmsk_pd_256:
12976     case Intrinsic::x86_mmx_pmovmskb:
12977     case Intrinsic::x86_sse2_pmovmskb_128:
12978     case Intrinsic::x86_avx2_pmovmskb: {
12979       // High bits of movmskp{s|d}, pmovmskb are known zero.
12980       switch (IntId) {
12981         default: llvm_unreachable("Impossible intrinsic");  // Can't reach here.
12982         case Intrinsic::x86_sse_movmsk_ps:      NumLoBits = 4; break;
12983         case Intrinsic::x86_avx_movmsk_ps_256:  NumLoBits = 8; break;
12984         case Intrinsic::x86_sse2_movmsk_pd:     NumLoBits = 2; break;
12985         case Intrinsic::x86_avx_movmsk_pd_256:  NumLoBits = 4; break;
12986         case Intrinsic::x86_mmx_pmovmskb:       NumLoBits = 8; break;
12987         case Intrinsic::x86_sse2_pmovmskb_128:  NumLoBits = 16; break;
12988         case Intrinsic::x86_avx2_pmovmskb:      NumLoBits = 32; break;
12989       }
12990       KnownZero = APInt::getHighBitsSet(BitWidth, BitWidth - NumLoBits);
12991       break;
12992     }
12993     }
12994     break;
12995   }
12996   }
12997 }
12998
12999 unsigned X86TargetLowering::ComputeNumSignBitsForTargetNode(SDValue Op,
13000                                                          unsigned Depth) const {
13001   // SETCC_CARRY sets the dest to ~0 for true or 0 for false.
13002   if (Op.getOpcode() == X86ISD::SETCC_CARRY)
13003     return Op.getValueType().getScalarType().getSizeInBits();
13004
13005   // Fallback case.
13006   return 1;
13007 }
13008
13009 /// isGAPlusOffset - Returns true (and the GlobalValue and the offset) if the
13010 /// node is a GlobalAddress + offset.
13011 bool X86TargetLowering::isGAPlusOffset(SDNode *N,
13012                                        const GlobalValue* &GA,
13013                                        int64_t &Offset) const {
13014   if (N->getOpcode() == X86ISD::Wrapper) {
13015     if (isa<GlobalAddressSDNode>(N->getOperand(0))) {
13016       GA = cast<GlobalAddressSDNode>(N->getOperand(0))->getGlobal();
13017       Offset = cast<GlobalAddressSDNode>(N->getOperand(0))->getOffset();
13018       return true;
13019     }
13020   }
13021   return TargetLowering::isGAPlusOffset(N, GA, Offset);
13022 }
13023
13024 /// isShuffleHigh128VectorInsertLow - Checks whether the shuffle node is the
13025 /// same as extracting the high 128-bit part of 256-bit vector and then
13026 /// inserting the result into the low part of a new 256-bit vector
13027 static bool isShuffleHigh128VectorInsertLow(ShuffleVectorSDNode *SVOp) {
13028   EVT VT = SVOp->getValueType(0);
13029   unsigned NumElems = VT.getVectorNumElements();
13030
13031   // vector_shuffle <4, 5, 6, 7, u, u, u, u> or <2, 3, u, u>
13032   for (unsigned i = 0, j = NumElems/2; i != NumElems/2; ++i, ++j)
13033     if (!isUndefOrEqual(SVOp->getMaskElt(i), j) ||
13034         SVOp->getMaskElt(j) >= 0)
13035       return false;
13036
13037   return true;
13038 }
13039
13040 /// isShuffleLow128VectorInsertHigh - Checks whether the shuffle node is the
13041 /// same as extracting the low 128-bit part of 256-bit vector and then
13042 /// inserting the result into the high part of a new 256-bit vector
13043 static bool isShuffleLow128VectorInsertHigh(ShuffleVectorSDNode *SVOp) {
13044   EVT VT = SVOp->getValueType(0);
13045   unsigned NumElems = VT.getVectorNumElements();
13046
13047   // vector_shuffle <u, u, u, u, 0, 1, 2, 3> or <u, u, 0, 1>
13048   for (unsigned i = NumElems/2, j = 0; i != NumElems; ++i, ++j)
13049     if (!isUndefOrEqual(SVOp->getMaskElt(i), j) ||
13050         SVOp->getMaskElt(j) >= 0)
13051       return false;
13052
13053   return true;
13054 }
13055
13056 /// PerformShuffleCombine256 - Performs shuffle combines for 256-bit vectors.
13057 static SDValue PerformShuffleCombine256(SDNode *N, SelectionDAG &DAG,
13058                                         TargetLowering::DAGCombinerInfo &DCI,
13059                                         const X86Subtarget* Subtarget) {
13060   DebugLoc dl = N->getDebugLoc();
13061   ShuffleVectorSDNode *SVOp = cast<ShuffleVectorSDNode>(N);
13062   SDValue V1 = SVOp->getOperand(0);
13063   SDValue V2 = SVOp->getOperand(1);
13064   EVT VT = SVOp->getValueType(0);
13065   unsigned NumElems = VT.getVectorNumElements();
13066
13067   if (V1.getOpcode() == ISD::CONCAT_VECTORS &&
13068       V2.getOpcode() == ISD::CONCAT_VECTORS) {
13069     //
13070     //                   0,0,0,...
13071     //                      |
13072     //    V      UNDEF    BUILD_VECTOR    UNDEF
13073     //     \      /           \           /
13074     //  CONCAT_VECTOR         CONCAT_VECTOR
13075     //         \                  /
13076     //          \                /
13077     //          RESULT: V + zero extended
13078     //
13079     if (V2.getOperand(0).getOpcode() != ISD::BUILD_VECTOR ||
13080         V2.getOperand(1).getOpcode() != ISD::UNDEF ||
13081         V1.getOperand(1).getOpcode() != ISD::UNDEF)
13082       return SDValue();
13083
13084     if (!ISD::isBuildVectorAllZeros(V2.getOperand(0).getNode()))
13085       return SDValue();
13086
13087     // To match the shuffle mask, the first half of the mask should
13088     // be exactly the first vector, and all the rest a splat with the
13089     // first element of the second one.
13090     for (unsigned i = 0; i != NumElems/2; ++i)
13091       if (!isUndefOrEqual(SVOp->getMaskElt(i), i) ||
13092           !isUndefOrEqual(SVOp->getMaskElt(i+NumElems/2), NumElems))
13093         return SDValue();
13094
13095     // If V1 is coming from a vector load then just fold to a VZEXT_LOAD.
13096     if (LoadSDNode *Ld = dyn_cast<LoadSDNode>(V1.getOperand(0))) {
13097       if (Ld->hasNUsesOfValue(1, 0)) {
13098         SDVTList Tys = DAG.getVTList(MVT::v4i64, MVT::Other);
13099         SDValue Ops[] = { Ld->getChain(), Ld->getBasePtr() };
13100         SDValue ResNode =
13101           DAG.getMemIntrinsicNode(X86ISD::VZEXT_LOAD, dl, Tys, Ops, 2,
13102                                   Ld->getMemoryVT(),
13103                                   Ld->getPointerInfo(),
13104                                   Ld->getAlignment(),
13105                                   false/*isVolatile*/, true/*ReadMem*/,
13106                                   false/*WriteMem*/);
13107         return DAG.getNode(ISD::BITCAST, dl, VT, ResNode);
13108       }
13109     }
13110
13111     // Emit a zeroed vector and insert the desired subvector on its
13112     // first half.
13113     SDValue Zeros = getZeroVector(VT, Subtarget, DAG, dl);
13114     SDValue InsV = Insert128BitVector(Zeros, V1.getOperand(0), 0, DAG, dl);
13115     return DCI.CombineTo(N, InsV);
13116   }
13117
13118   //===--------------------------------------------------------------------===//
13119   // Combine some shuffles into subvector extracts and inserts:
13120   //
13121
13122   // vector_shuffle <4, 5, 6, 7, u, u, u, u> or <2, 3, u, u>
13123   if (isShuffleHigh128VectorInsertLow(SVOp)) {
13124     SDValue V = Extract128BitVector(V1, NumElems/2, DAG, dl);
13125     SDValue InsV = Insert128BitVector(DAG.getUNDEF(VT), V, 0, DAG, dl);
13126     return DCI.CombineTo(N, InsV);
13127   }
13128
13129   // vector_shuffle <u, u, u, u, 0, 1, 2, 3> or <u, u, 0, 1>
13130   if (isShuffleLow128VectorInsertHigh(SVOp)) {
13131     SDValue V = Extract128BitVector(V1, 0, DAG, dl);
13132     SDValue InsV = Insert128BitVector(DAG.getUNDEF(VT), V, NumElems/2, DAG, dl);
13133     return DCI.CombineTo(N, InsV);
13134   }
13135
13136   return SDValue();
13137 }
13138
13139 /// PerformShuffleCombine - Performs several different shuffle combines.
13140 static SDValue PerformShuffleCombine(SDNode *N, SelectionDAG &DAG,
13141                                      TargetLowering::DAGCombinerInfo &DCI,
13142                                      const X86Subtarget *Subtarget) {
13143   DebugLoc dl = N->getDebugLoc();
13144   EVT VT = N->getValueType(0);
13145
13146   // Don't create instructions with illegal types after legalize types has run.
13147   const TargetLowering &TLI = DAG.getTargetLoweringInfo();
13148   if (!DCI.isBeforeLegalize() && !TLI.isTypeLegal(VT.getVectorElementType()))
13149     return SDValue();
13150
13151   // Combine 256-bit vector shuffles. This is only profitable when in AVX mode
13152   if (Subtarget->hasAVX() && VT.getSizeInBits() == 256 &&
13153       N->getOpcode() == ISD::VECTOR_SHUFFLE)
13154     return PerformShuffleCombine256(N, DAG, DCI, Subtarget);
13155
13156   // Only handle 128 wide vector from here on.
13157   if (VT.getSizeInBits() != 128)
13158     return SDValue();
13159
13160   // Combine a vector_shuffle that is equal to build_vector load1, load2, load3,
13161   // load4, <0, 1, 2, 3> into a 128-bit load if the load addresses are
13162   // consecutive, non-overlapping, and in the right order.
13163   SmallVector<SDValue, 16> Elts;
13164   for (unsigned i = 0, e = VT.getVectorNumElements(); i != e; ++i)
13165     Elts.push_back(getShuffleScalarElt(N, i, DAG, 0));
13166
13167   return EltsFromConsecutiveLoads(VT, Elts, dl, DAG);
13168 }
13169
13170
13171 /// DCI, PerformTruncateCombine - Converts truncate operation to
13172 /// a sequence of vector shuffle operations.
13173 /// It is possible when we truncate 256-bit vector to 128-bit vector
13174
13175 SDValue X86TargetLowering::PerformTruncateCombine(SDNode *N, SelectionDAG &DAG,
13176                                                   DAGCombinerInfo &DCI) const {
13177   if (!DCI.isBeforeLegalizeOps())
13178     return SDValue();
13179
13180   if (!Subtarget->hasAVX())
13181     return SDValue();
13182
13183   EVT VT = N->getValueType(0);
13184   SDValue Op = N->getOperand(0);
13185   EVT OpVT = Op.getValueType();
13186   DebugLoc dl = N->getDebugLoc();
13187
13188   if ((VT == MVT::v4i32) && (OpVT == MVT::v4i64)) {
13189
13190     if (Subtarget->hasAVX2()) {
13191       // AVX2: v4i64 -> v4i32
13192
13193       // VPERMD
13194       static const int ShufMask[] = {0, 2, 4, 6, -1, -1, -1, -1};
13195
13196       Op = DAG.getNode(ISD::BITCAST, dl, MVT::v8i32, Op);
13197       Op = DAG.getVectorShuffle(MVT::v8i32, dl, Op, DAG.getUNDEF(MVT::v8i32),
13198                                 ShufMask);
13199
13200       return DAG.getNode(ISD::EXTRACT_SUBVECTOR, dl, VT, Op,
13201                          DAG.getIntPtrConstant(0));
13202     }
13203
13204     // AVX: v4i64 -> v4i32
13205     SDValue OpLo = DAG.getNode(ISD::EXTRACT_SUBVECTOR, dl, MVT::v2i64, Op,
13206                                DAG.getIntPtrConstant(0));
13207
13208     SDValue OpHi = DAG.getNode(ISD::EXTRACT_SUBVECTOR, dl, MVT::v2i64, Op,
13209                                DAG.getIntPtrConstant(2));
13210
13211     OpLo = DAG.getNode(ISD::BITCAST, dl, MVT::v4i32, OpLo);
13212     OpHi = DAG.getNode(ISD::BITCAST, dl, MVT::v4i32, OpHi);
13213
13214     // PSHUFD
13215     static const int ShufMask1[] = {0, 2, 0, 0};
13216
13217     OpLo = DAG.getVectorShuffle(VT, dl, OpLo, DAG.getUNDEF(VT), ShufMask1);
13218     OpHi = DAG.getVectorShuffle(VT, dl, OpHi, DAG.getUNDEF(VT), ShufMask1);
13219
13220     // MOVLHPS
13221     static const int ShufMask2[] = {0, 1, 4, 5};
13222
13223     return DAG.getVectorShuffle(VT, dl, OpLo, OpHi, ShufMask2);
13224   }
13225
13226   if ((VT == MVT::v8i16) && (OpVT == MVT::v8i32)) {
13227
13228     if (Subtarget->hasAVX2()) {
13229       // AVX2: v8i32 -> v8i16
13230
13231       Op = DAG.getNode(ISD::BITCAST, dl, MVT::v32i8, Op);
13232
13233       // PSHUFB
13234       SmallVector<SDValue,32> pshufbMask;
13235       for (unsigned i = 0; i < 2; ++i) {
13236         pshufbMask.push_back(DAG.getConstant(0x0, MVT::i8));
13237         pshufbMask.push_back(DAG.getConstant(0x1, MVT::i8));
13238         pshufbMask.push_back(DAG.getConstant(0x4, MVT::i8));
13239         pshufbMask.push_back(DAG.getConstant(0x5, MVT::i8));
13240         pshufbMask.push_back(DAG.getConstant(0x8, MVT::i8));
13241         pshufbMask.push_back(DAG.getConstant(0x9, MVT::i8));
13242         pshufbMask.push_back(DAG.getConstant(0xc, MVT::i8));
13243         pshufbMask.push_back(DAG.getConstant(0xd, MVT::i8));
13244         for (unsigned j = 0; j < 8; ++j)
13245           pshufbMask.push_back(DAG.getConstant(0x80, MVT::i8));
13246       }
13247       SDValue BV = DAG.getNode(ISD::BUILD_VECTOR, dl, MVT::v32i8,
13248                                &pshufbMask[0], 32);
13249       Op = DAG.getNode(X86ISD::PSHUFB, dl, MVT::v32i8, Op, BV);
13250
13251       Op = DAG.getNode(ISD::BITCAST, dl, MVT::v4i64, Op);
13252
13253       static const int ShufMask[] = {0,  2,  -1,  -1};
13254       Op = DAG.getVectorShuffle(MVT::v4i64, dl,  Op, DAG.getUNDEF(MVT::v4i64),
13255                                 &ShufMask[0]);
13256
13257       Op = DAG.getNode(ISD::EXTRACT_SUBVECTOR, dl, MVT::v2i64, Op,
13258                        DAG.getIntPtrConstant(0));
13259
13260       return DAG.getNode(ISD::BITCAST, dl, VT, Op);
13261     }
13262
13263     SDValue OpLo = DAG.getNode(ISD::EXTRACT_SUBVECTOR, dl, MVT::v4i32, Op,
13264                                DAG.getIntPtrConstant(0));
13265
13266     SDValue OpHi = DAG.getNode(ISD::EXTRACT_SUBVECTOR, dl, MVT::v4i32, Op,
13267                                DAG.getIntPtrConstant(4));
13268
13269     OpLo = DAG.getNode(ISD::BITCAST, dl, MVT::v16i8, OpLo);
13270     OpHi = DAG.getNode(ISD::BITCAST, dl, MVT::v16i8, OpHi);
13271
13272     // PSHUFB
13273     static const int ShufMask1[] = {0,  1,  4,  5,  8,  9, 12, 13,
13274                                    -1, -1, -1, -1, -1, -1, -1, -1};
13275
13276     OpLo = DAG.getVectorShuffle(MVT::v16i8, dl, OpLo, DAG.getUNDEF(MVT::v16i8),
13277                                 ShufMask1);
13278     OpHi = DAG.getVectorShuffle(MVT::v16i8, dl, OpHi, DAG.getUNDEF(MVT::v16i8),
13279                                 ShufMask1);
13280
13281     OpLo = DAG.getNode(ISD::BITCAST, dl, MVT::v4i32, OpLo);
13282     OpHi = DAG.getNode(ISD::BITCAST, dl, MVT::v4i32, OpHi);
13283
13284     // MOVLHPS
13285     static const int ShufMask2[] = {0, 1, 4, 5};
13286
13287     SDValue res = DAG.getVectorShuffle(MVT::v4i32, dl, OpLo, OpHi, ShufMask2);
13288     return DAG.getNode(ISD::BITCAST, dl, MVT::v8i16, res);
13289   }
13290
13291   return SDValue();
13292 }
13293
13294 /// XFormVExtractWithShuffleIntoLoad - Check if a vector extract from a target
13295 /// specific shuffle of a load can be folded into a single element load.
13296 /// Similar handling for VECTOR_SHUFFLE is performed by DAGCombiner, but
13297 /// shuffles have been customed lowered so we need to handle those here.
13298 static SDValue XFormVExtractWithShuffleIntoLoad(SDNode *N, SelectionDAG &DAG,
13299                                          TargetLowering::DAGCombinerInfo &DCI) {
13300   if (DCI.isBeforeLegalizeOps())
13301     return SDValue();
13302
13303   SDValue InVec = N->getOperand(0);
13304   SDValue EltNo = N->getOperand(1);
13305
13306   if (!isa<ConstantSDNode>(EltNo))
13307     return SDValue();
13308
13309   EVT VT = InVec.getValueType();
13310
13311   bool HasShuffleIntoBitcast = false;
13312   if (InVec.getOpcode() == ISD::BITCAST) {
13313     // Don't duplicate a load with other uses.
13314     if (!InVec.hasOneUse())
13315       return SDValue();
13316     EVT BCVT = InVec.getOperand(0).getValueType();
13317     if (BCVT.getVectorNumElements() != VT.getVectorNumElements())
13318       return SDValue();
13319     InVec = InVec.getOperand(0);
13320     HasShuffleIntoBitcast = true;
13321   }
13322
13323   if (!isTargetShuffle(InVec.getOpcode()))
13324     return SDValue();
13325
13326   // Don't duplicate a load with other uses.
13327   if (!InVec.hasOneUse())
13328     return SDValue();
13329
13330   SmallVector<int, 16> ShuffleMask;
13331   bool UnaryShuffle;
13332   if (!getTargetShuffleMask(InVec.getNode(), VT.getSimpleVT(), ShuffleMask,
13333                             UnaryShuffle))
13334     return SDValue();
13335
13336   // Select the input vector, guarding against out of range extract vector.
13337   unsigned NumElems = VT.getVectorNumElements();
13338   int Elt = cast<ConstantSDNode>(EltNo)->getZExtValue();
13339   int Idx = (Elt > (int)NumElems) ? -1 : ShuffleMask[Elt];
13340   SDValue LdNode = (Idx < (int)NumElems) ? InVec.getOperand(0)
13341                                          : InVec.getOperand(1);
13342
13343   // If inputs to shuffle are the same for both ops, then allow 2 uses
13344   unsigned AllowedUses = InVec.getOperand(0) == InVec.getOperand(1) ? 2 : 1;
13345
13346   if (LdNode.getOpcode() == ISD::BITCAST) {
13347     // Don't duplicate a load with other uses.
13348     if (!LdNode.getNode()->hasNUsesOfValue(AllowedUses, 0))
13349       return SDValue();
13350
13351     AllowedUses = 1; // only allow 1 load use if we have a bitcast
13352     LdNode = LdNode.getOperand(0);
13353   }
13354
13355   if (!ISD::isNormalLoad(LdNode.getNode()))
13356     return SDValue();
13357
13358   LoadSDNode *LN0 = cast<LoadSDNode>(LdNode);
13359
13360   if (!LN0 ||!LN0->hasNUsesOfValue(AllowedUses, 0) || LN0->isVolatile())
13361     return SDValue();
13362
13363   if (HasShuffleIntoBitcast) {
13364     // If there's a bitcast before the shuffle, check if the load type and
13365     // alignment is valid.
13366     unsigned Align = LN0->getAlignment();
13367     const TargetLowering &TLI = DAG.getTargetLoweringInfo();
13368     unsigned NewAlign = TLI.getTargetData()->
13369       getABITypeAlignment(VT.getTypeForEVT(*DAG.getContext()));
13370
13371     if (NewAlign > Align || !TLI.isOperationLegalOrCustom(ISD::LOAD, VT))
13372       return SDValue();
13373   }
13374
13375   // All checks match so transform back to vector_shuffle so that DAG combiner
13376   // can finish the job
13377   DebugLoc dl = N->getDebugLoc();
13378
13379   // Create shuffle node taking into account the case that its a unary shuffle
13380   SDValue Shuffle = (UnaryShuffle) ? DAG.getUNDEF(VT) : InVec.getOperand(1);
13381   Shuffle = DAG.getVectorShuffle(InVec.getValueType(), dl,
13382                                  InVec.getOperand(0), Shuffle,
13383                                  &ShuffleMask[0]);
13384   Shuffle = DAG.getNode(ISD::BITCAST, dl, VT, Shuffle);
13385   return DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, N->getValueType(0), Shuffle,
13386                      EltNo);
13387 }
13388
13389 /// PerformEXTRACT_VECTOR_ELTCombine - Detect vector gather/scatter index
13390 /// generation and convert it from being a bunch of shuffles and extracts
13391 /// to a simple store and scalar loads to extract the elements.
13392 static SDValue PerformEXTRACT_VECTOR_ELTCombine(SDNode *N, SelectionDAG &DAG,
13393                                          TargetLowering::DAGCombinerInfo &DCI) {
13394   SDValue NewOp = XFormVExtractWithShuffleIntoLoad(N, DAG, DCI);
13395   if (NewOp.getNode())
13396     return NewOp;
13397
13398   SDValue InputVector = N->getOperand(0);
13399
13400   // Only operate on vectors of 4 elements, where the alternative shuffling
13401   // gets to be more expensive.
13402   if (InputVector.getValueType() != MVT::v4i32)
13403     return SDValue();
13404
13405   // Check whether every use of InputVector is an EXTRACT_VECTOR_ELT with a
13406   // single use which is a sign-extend or zero-extend, and all elements are
13407   // used.
13408   SmallVector<SDNode *, 4> Uses;
13409   unsigned ExtractedElements = 0;
13410   for (SDNode::use_iterator UI = InputVector.getNode()->use_begin(),
13411        UE = InputVector.getNode()->use_end(); UI != UE; ++UI) {
13412     if (UI.getUse().getResNo() != InputVector.getResNo())
13413       return SDValue();
13414
13415     SDNode *Extract = *UI;
13416     if (Extract->getOpcode() != ISD::EXTRACT_VECTOR_ELT)
13417       return SDValue();
13418
13419     if (Extract->getValueType(0) != MVT::i32)
13420       return SDValue();
13421     if (!Extract->hasOneUse())
13422       return SDValue();
13423     if (Extract->use_begin()->getOpcode() != ISD::SIGN_EXTEND &&
13424         Extract->use_begin()->getOpcode() != ISD::ZERO_EXTEND)
13425       return SDValue();
13426     if (!isa<ConstantSDNode>(Extract->getOperand(1)))
13427       return SDValue();
13428
13429     // Record which element was extracted.
13430     ExtractedElements |=
13431       1 << cast<ConstantSDNode>(Extract->getOperand(1))->getZExtValue();
13432
13433     Uses.push_back(Extract);
13434   }
13435
13436   // If not all the elements were used, this may not be worthwhile.
13437   if (ExtractedElements != 15)
13438     return SDValue();
13439
13440   // Ok, we've now decided to do the transformation.
13441   DebugLoc dl = InputVector.getDebugLoc();
13442
13443   // Store the value to a temporary stack slot.
13444   SDValue StackPtr = DAG.CreateStackTemporary(InputVector.getValueType());
13445   SDValue Ch = DAG.getStore(DAG.getEntryNode(), dl, InputVector, StackPtr,
13446                             MachinePointerInfo(), false, false, 0);
13447
13448   // Replace each use (extract) with a load of the appropriate element.
13449   for (SmallVectorImpl<SDNode *>::iterator UI = Uses.begin(),
13450        UE = Uses.end(); UI != UE; ++UI) {
13451     SDNode *Extract = *UI;
13452
13453     // cOMpute the element's address.
13454     SDValue Idx = Extract->getOperand(1);
13455     unsigned EltSize =
13456         InputVector.getValueType().getVectorElementType().getSizeInBits()/8;
13457     uint64_t Offset = EltSize * cast<ConstantSDNode>(Idx)->getZExtValue();
13458     const TargetLowering &TLI = DAG.getTargetLoweringInfo();
13459     SDValue OffsetVal = DAG.getConstant(Offset, TLI.getPointerTy());
13460
13461     SDValue ScalarAddr = DAG.getNode(ISD::ADD, dl, TLI.getPointerTy(),
13462                                      StackPtr, OffsetVal);
13463
13464     // Load the scalar.
13465     SDValue LoadScalar = DAG.getLoad(Extract->getValueType(0), dl, Ch,
13466                                      ScalarAddr, MachinePointerInfo(),
13467                                      false, false, false, 0);
13468
13469     // Replace the exact with the load.
13470     DAG.ReplaceAllUsesOfValueWith(SDValue(Extract, 0), LoadScalar);
13471   }
13472
13473   // The replacement was made in place; don't return anything.
13474   return SDValue();
13475 }
13476
13477 /// PerformSELECTCombine - Do target-specific dag combines on SELECT and VSELECT
13478 /// nodes.
13479 static SDValue PerformSELECTCombine(SDNode *N, SelectionDAG &DAG,
13480                                     TargetLowering::DAGCombinerInfo &DCI,
13481                                     const X86Subtarget *Subtarget) {
13482   DebugLoc DL = N->getDebugLoc();
13483   SDValue Cond = N->getOperand(0);
13484   // Get the LHS/RHS of the select.
13485   SDValue LHS = N->getOperand(1);
13486   SDValue RHS = N->getOperand(2);
13487   EVT VT = LHS.getValueType();
13488
13489   // If we have SSE[12] support, try to form min/max nodes. SSE min/max
13490   // instructions match the semantics of the common C idiom x<y?x:y but not
13491   // x<=y?x:y, because of how they handle negative zero (which can be
13492   // ignored in unsafe-math mode).
13493   if (Cond.getOpcode() == ISD::SETCC && VT.isFloatingPoint() &&
13494       VT != MVT::f80 && DAG.getTargetLoweringInfo().isTypeLegal(VT) &&
13495       (Subtarget->hasSSE2() ||
13496        (Subtarget->hasSSE1() && VT.getScalarType() == MVT::f32))) {
13497     ISD::CondCode CC = cast<CondCodeSDNode>(Cond.getOperand(2))->get();
13498
13499     unsigned Opcode = 0;
13500     // Check for x CC y ? x : y.
13501     if (DAG.isEqualTo(LHS, Cond.getOperand(0)) &&
13502         DAG.isEqualTo(RHS, Cond.getOperand(1))) {
13503       switch (CC) {
13504       default: break;
13505       case ISD::SETULT:
13506         // Converting this to a min would handle NaNs incorrectly, and swapping
13507         // the operands would cause it to handle comparisons between positive
13508         // and negative zero incorrectly.
13509         if (!DAG.isKnownNeverNaN(LHS) || !DAG.isKnownNeverNaN(RHS)) {
13510           if (!DAG.getTarget().Options.UnsafeFPMath &&
13511               !(DAG.isKnownNeverZero(LHS) || DAG.isKnownNeverZero(RHS)))
13512             break;
13513           std::swap(LHS, RHS);
13514         }
13515         Opcode = X86ISD::FMIN;
13516         break;
13517       case ISD::SETOLE:
13518         // Converting this to a min would handle comparisons between positive
13519         // and negative zero incorrectly.
13520         if (!DAG.getTarget().Options.UnsafeFPMath &&
13521             !DAG.isKnownNeverZero(LHS) && !DAG.isKnownNeverZero(RHS))
13522           break;
13523         Opcode = X86ISD::FMIN;
13524         break;
13525       case ISD::SETULE:
13526         // Converting this to a min would handle both negative zeros and NaNs
13527         // incorrectly, but we can swap the operands to fix both.
13528         std::swap(LHS, RHS);
13529       case ISD::SETOLT:
13530       case ISD::SETLT:
13531       case ISD::SETLE:
13532         Opcode = X86ISD::FMIN;
13533         break;
13534
13535       case ISD::SETOGE:
13536         // Converting this to a max would handle comparisons between positive
13537         // and negative zero incorrectly.
13538         if (!DAG.getTarget().Options.UnsafeFPMath &&
13539             !DAG.isKnownNeverZero(LHS) && !DAG.isKnownNeverZero(RHS))
13540           break;
13541         Opcode = X86ISD::FMAX;
13542         break;
13543       case ISD::SETUGT:
13544         // Converting this to a max would handle NaNs incorrectly, and swapping
13545         // the operands would cause it to handle comparisons between positive
13546         // and negative zero incorrectly.
13547         if (!DAG.isKnownNeverNaN(LHS) || !DAG.isKnownNeverNaN(RHS)) {
13548           if (!DAG.getTarget().Options.UnsafeFPMath &&
13549               !(DAG.isKnownNeverZero(LHS) || DAG.isKnownNeverZero(RHS)))
13550             break;
13551           std::swap(LHS, RHS);
13552         }
13553         Opcode = X86ISD::FMAX;
13554         break;
13555       case ISD::SETUGE:
13556         // Converting this to a max would handle both negative zeros and NaNs
13557         // incorrectly, but we can swap the operands to fix both.
13558         std::swap(LHS, RHS);
13559       case ISD::SETOGT:
13560       case ISD::SETGT:
13561       case ISD::SETGE:
13562         Opcode = X86ISD::FMAX;
13563         break;
13564       }
13565     // Check for x CC y ? y : x -- a min/max with reversed arms.
13566     } else if (DAG.isEqualTo(LHS, Cond.getOperand(1)) &&
13567                DAG.isEqualTo(RHS, Cond.getOperand(0))) {
13568       switch (CC) {
13569       default: break;
13570       case ISD::SETOGE:
13571         // Converting this to a min would handle comparisons between positive
13572         // and negative zero incorrectly, and swapping the operands would
13573         // cause it to handle NaNs incorrectly.
13574         if (!DAG.getTarget().Options.UnsafeFPMath &&
13575             !(DAG.isKnownNeverZero(LHS) || DAG.isKnownNeverZero(RHS))) {
13576           if (!DAG.isKnownNeverNaN(LHS) || !DAG.isKnownNeverNaN(RHS))
13577             break;
13578           std::swap(LHS, RHS);
13579         }
13580         Opcode = X86ISD::FMIN;
13581         break;
13582       case ISD::SETUGT:
13583         // Converting this to a min would handle NaNs incorrectly.
13584         if (!DAG.getTarget().Options.UnsafeFPMath &&
13585             (!DAG.isKnownNeverNaN(LHS) || !DAG.isKnownNeverNaN(RHS)))
13586           break;
13587         Opcode = X86ISD::FMIN;
13588         break;
13589       case ISD::SETUGE:
13590         // Converting this to a min would handle both negative zeros and NaNs
13591         // incorrectly, but we can swap the operands to fix both.
13592         std::swap(LHS, RHS);
13593       case ISD::SETOGT:
13594       case ISD::SETGT:
13595       case ISD::SETGE:
13596         Opcode = X86ISD::FMIN;
13597         break;
13598
13599       case ISD::SETULT:
13600         // Converting this to a max would handle NaNs incorrectly.
13601         if (!DAG.isKnownNeverNaN(LHS) || !DAG.isKnownNeverNaN(RHS))
13602           break;
13603         Opcode = X86ISD::FMAX;
13604         break;
13605       case ISD::SETOLE:
13606         // Converting this to a max would handle comparisons between positive
13607         // and negative zero incorrectly, and swapping the operands would
13608         // cause it to handle NaNs incorrectly.
13609         if (!DAG.getTarget().Options.UnsafeFPMath &&
13610             !DAG.isKnownNeverZero(LHS) && !DAG.isKnownNeverZero(RHS)) {
13611           if (!DAG.isKnownNeverNaN(LHS) || !DAG.isKnownNeverNaN(RHS))
13612             break;
13613           std::swap(LHS, RHS);
13614         }
13615         Opcode = X86ISD::FMAX;
13616         break;
13617       case ISD::SETULE:
13618         // Converting this to a max would handle both negative zeros and NaNs
13619         // incorrectly, but we can swap the operands to fix both.
13620         std::swap(LHS, RHS);
13621       case ISD::SETOLT:
13622       case ISD::SETLT:
13623       case ISD::SETLE:
13624         Opcode = X86ISD::FMAX;
13625         break;
13626       }
13627     }
13628
13629     if (Opcode)
13630       return DAG.getNode(Opcode, DL, N->getValueType(0), LHS, RHS);
13631   }
13632
13633   // If this is a select between two integer constants, try to do some
13634   // optimizations.
13635   if (ConstantSDNode *TrueC = dyn_cast<ConstantSDNode>(LHS)) {
13636     if (ConstantSDNode *FalseC = dyn_cast<ConstantSDNode>(RHS))
13637       // Don't do this for crazy integer types.
13638       if (DAG.getTargetLoweringInfo().isTypeLegal(LHS.getValueType())) {
13639         // If this is efficiently invertible, canonicalize the LHSC/RHSC values
13640         // so that TrueC (the true value) is larger than FalseC.
13641         bool NeedsCondInvert = false;
13642
13643         if (TrueC->getAPIntValue().ult(FalseC->getAPIntValue()) &&
13644             // Efficiently invertible.
13645             (Cond.getOpcode() == ISD::SETCC ||  // setcc -> invertible.
13646              (Cond.getOpcode() == ISD::XOR &&   // xor(X, C) -> invertible.
13647               isa<ConstantSDNode>(Cond.getOperand(1))))) {
13648           NeedsCondInvert = true;
13649           std::swap(TrueC, FalseC);
13650         }
13651
13652         // Optimize C ? 8 : 0 -> zext(C) << 3.  Likewise for any pow2/0.
13653         if (FalseC->getAPIntValue() == 0 &&
13654             TrueC->getAPIntValue().isPowerOf2()) {
13655           if (NeedsCondInvert) // Invert the condition if needed.
13656             Cond = DAG.getNode(ISD::XOR, DL, Cond.getValueType(), Cond,
13657                                DAG.getConstant(1, Cond.getValueType()));
13658
13659           // Zero extend the condition if needed.
13660           Cond = DAG.getNode(ISD::ZERO_EXTEND, DL, LHS.getValueType(), Cond);
13661
13662           unsigned ShAmt = TrueC->getAPIntValue().logBase2();
13663           return DAG.getNode(ISD::SHL, DL, LHS.getValueType(), Cond,
13664                              DAG.getConstant(ShAmt, MVT::i8));
13665         }
13666
13667         // Optimize Cond ? cst+1 : cst -> zext(setcc(C)+cst.
13668         if (FalseC->getAPIntValue()+1 == TrueC->getAPIntValue()) {
13669           if (NeedsCondInvert) // Invert the condition if needed.
13670             Cond = DAG.getNode(ISD::XOR, DL, Cond.getValueType(), Cond,
13671                                DAG.getConstant(1, Cond.getValueType()));
13672
13673           // Zero extend the condition if needed.
13674           Cond = DAG.getNode(ISD::ZERO_EXTEND, DL,
13675                              FalseC->getValueType(0), Cond);
13676           return DAG.getNode(ISD::ADD, DL, Cond.getValueType(), Cond,
13677                              SDValue(FalseC, 0));
13678         }
13679
13680         // Optimize cases that will turn into an LEA instruction.  This requires
13681         // an i32 or i64 and an efficient multiplier (1, 2, 3, 4, 5, 8, 9).
13682         if (N->getValueType(0) == MVT::i32 || N->getValueType(0) == MVT::i64) {
13683           uint64_t Diff = TrueC->getZExtValue()-FalseC->getZExtValue();
13684           if (N->getValueType(0) == MVT::i32) Diff = (unsigned)Diff;
13685
13686           bool isFastMultiplier = false;
13687           if (Diff < 10) {
13688             switch ((unsigned char)Diff) {
13689               default: break;
13690               case 1:  // result = add base, cond
13691               case 2:  // result = lea base(    , cond*2)
13692               case 3:  // result = lea base(cond, cond*2)
13693               case 4:  // result = lea base(    , cond*4)
13694               case 5:  // result = lea base(cond, cond*4)
13695               case 8:  // result = lea base(    , cond*8)
13696               case 9:  // result = lea base(cond, cond*8)
13697                 isFastMultiplier = true;
13698                 break;
13699             }
13700           }
13701
13702           if (isFastMultiplier) {
13703             APInt Diff = TrueC->getAPIntValue()-FalseC->getAPIntValue();
13704             if (NeedsCondInvert) // Invert the condition if needed.
13705               Cond = DAG.getNode(ISD::XOR, DL, Cond.getValueType(), Cond,
13706                                  DAG.getConstant(1, Cond.getValueType()));
13707
13708             // Zero extend the condition if needed.
13709             Cond = DAG.getNode(ISD::ZERO_EXTEND, DL, FalseC->getValueType(0),
13710                                Cond);
13711             // Scale the condition by the difference.
13712             if (Diff != 1)
13713               Cond = DAG.getNode(ISD::MUL, DL, Cond.getValueType(), Cond,
13714                                  DAG.getConstant(Diff, Cond.getValueType()));
13715
13716             // Add the base if non-zero.
13717             if (FalseC->getAPIntValue() != 0)
13718               Cond = DAG.getNode(ISD::ADD, DL, Cond.getValueType(), Cond,
13719                                  SDValue(FalseC, 0));
13720             return Cond;
13721           }
13722         }
13723       }
13724   }
13725
13726   // Canonicalize max and min:
13727   // (x > y) ? x : y -> (x >= y) ? x : y
13728   // (x < y) ? x : y -> (x <= y) ? x : y
13729   // This allows use of COND_S / COND_NS (see TranslateX86CC) which eliminates
13730   // the need for an extra compare
13731   // against zero. e.g.
13732   // (x - y) > 0 : (x - y) ? 0 -> (x - y) >= 0 : (x - y) ? 0
13733   // subl   %esi, %edi
13734   // testl  %edi, %edi
13735   // movl   $0, %eax
13736   // cmovgl %edi, %eax
13737   // =>
13738   // xorl   %eax, %eax
13739   // subl   %esi, $edi
13740   // cmovsl %eax, %edi
13741   if (N->getOpcode() == ISD::SELECT && Cond.getOpcode() == ISD::SETCC &&
13742       DAG.isEqualTo(LHS, Cond.getOperand(0)) &&
13743       DAG.isEqualTo(RHS, Cond.getOperand(1))) {
13744     ISD::CondCode CC = cast<CondCodeSDNode>(Cond.getOperand(2))->get();
13745     switch (CC) {
13746     default: break;
13747     case ISD::SETLT:
13748     case ISD::SETGT: {
13749       ISD::CondCode NewCC = (CC == ISD::SETLT) ? ISD::SETLE : ISD::SETGE;
13750       Cond = DAG.getSetCC(Cond.getDebugLoc(), Cond.getValueType(),
13751                           Cond.getOperand(0), Cond.getOperand(1), NewCC);
13752       return DAG.getNode(ISD::SELECT, DL, VT, Cond, LHS, RHS);
13753     }
13754     }
13755   }
13756
13757   // If we know that this node is legal then we know that it is going to be
13758   // matched by one of the SSE/AVX BLEND instructions. These instructions only
13759   // depend on the highest bit in each word. Try to use SimplifyDemandedBits
13760   // to simplify previous instructions.
13761   const TargetLowering &TLI = DAG.getTargetLoweringInfo();
13762   if (N->getOpcode() == ISD::VSELECT && DCI.isBeforeLegalizeOps() &&
13763       !DCI.isBeforeLegalize() && TLI.isOperationLegal(ISD::VSELECT, VT)) {
13764     unsigned BitWidth = Cond.getValueType().getScalarType().getSizeInBits();
13765
13766     // Don't optimize vector selects that map to mask-registers.
13767     if (BitWidth == 1)
13768       return SDValue();
13769
13770     assert(BitWidth >= 8 && BitWidth <= 64 && "Invalid mask size");
13771     APInt DemandedMask = APInt::getHighBitsSet(BitWidth, 1);
13772
13773     APInt KnownZero, KnownOne;
13774     TargetLowering::TargetLoweringOpt TLO(DAG, DCI.isBeforeLegalize(),
13775                                           DCI.isBeforeLegalizeOps());
13776     if (TLO.ShrinkDemandedConstant(Cond, DemandedMask) ||
13777         TLI.SimplifyDemandedBits(Cond, DemandedMask, KnownZero, KnownOne, TLO))
13778       DCI.CommitTargetLoweringOpt(TLO);
13779   }
13780
13781   return SDValue();
13782 }
13783
13784 /// Optimize X86ISD::CMOV [LHS, RHS, CONDCODE (e.g. X86::COND_NE), CONDVAL]
13785 static SDValue PerformCMOVCombine(SDNode *N, SelectionDAG &DAG,
13786                                   TargetLowering::DAGCombinerInfo &DCI) {
13787   DebugLoc DL = N->getDebugLoc();
13788
13789   // If the flag operand isn't dead, don't touch this CMOV.
13790   if (N->getNumValues() == 2 && !SDValue(N, 1).use_empty())
13791     return SDValue();
13792
13793   SDValue FalseOp = N->getOperand(0);
13794   SDValue TrueOp = N->getOperand(1);
13795   X86::CondCode CC = (X86::CondCode)N->getConstantOperandVal(2);
13796   SDValue Cond = N->getOperand(3);
13797   if (CC == X86::COND_E || CC == X86::COND_NE) {
13798     switch (Cond.getOpcode()) {
13799     default: break;
13800     case X86ISD::BSR:
13801     case X86ISD::BSF:
13802       // If operand of BSR / BSF are proven never zero, then ZF cannot be set.
13803       if (DAG.isKnownNeverZero(Cond.getOperand(0)))
13804         return (CC == X86::COND_E) ? FalseOp : TrueOp;
13805     }
13806   }
13807
13808   // If this is a select between two integer constants, try to do some
13809   // optimizations.  Note that the operands are ordered the opposite of SELECT
13810   // operands.
13811   if (ConstantSDNode *TrueC = dyn_cast<ConstantSDNode>(TrueOp)) {
13812     if (ConstantSDNode *FalseC = dyn_cast<ConstantSDNode>(FalseOp)) {
13813       // Canonicalize the TrueC/FalseC values so that TrueC (the true value) is
13814       // larger than FalseC (the false value).
13815       if (TrueC->getAPIntValue().ult(FalseC->getAPIntValue())) {
13816         CC = X86::GetOppositeBranchCondition(CC);
13817         std::swap(TrueC, FalseC);
13818       }
13819
13820       // Optimize C ? 8 : 0 -> zext(setcc(C)) << 3.  Likewise for any pow2/0.
13821       // This is efficient for any integer data type (including i8/i16) and
13822       // shift amount.
13823       if (FalseC->getAPIntValue() == 0 && TrueC->getAPIntValue().isPowerOf2()) {
13824         Cond = DAG.getNode(X86ISD::SETCC, DL, MVT::i8,
13825                            DAG.getConstant(CC, MVT::i8), Cond);
13826
13827         // Zero extend the condition if needed.
13828         Cond = DAG.getNode(ISD::ZERO_EXTEND, DL, TrueC->getValueType(0), Cond);
13829
13830         unsigned ShAmt = TrueC->getAPIntValue().logBase2();
13831         Cond = DAG.getNode(ISD::SHL, DL, Cond.getValueType(), Cond,
13832                            DAG.getConstant(ShAmt, MVT::i8));
13833         if (N->getNumValues() == 2)  // Dead flag value?
13834           return DCI.CombineTo(N, Cond, SDValue());
13835         return Cond;
13836       }
13837
13838       // Optimize Cond ? cst+1 : cst -> zext(setcc(C)+cst.  This is efficient
13839       // for any integer data type, including i8/i16.
13840       if (FalseC->getAPIntValue()+1 == TrueC->getAPIntValue()) {
13841         Cond = DAG.getNode(X86ISD::SETCC, DL, MVT::i8,
13842                            DAG.getConstant(CC, MVT::i8), Cond);
13843
13844         // Zero extend the condition if needed.
13845         Cond = DAG.getNode(ISD::ZERO_EXTEND, DL,
13846                            FalseC->getValueType(0), Cond);
13847         Cond = DAG.getNode(ISD::ADD, DL, Cond.getValueType(), Cond,
13848                            SDValue(FalseC, 0));
13849
13850         if (N->getNumValues() == 2)  // Dead flag value?
13851           return DCI.CombineTo(N, Cond, SDValue());
13852         return Cond;
13853       }
13854
13855       // Optimize cases that will turn into an LEA instruction.  This requires
13856       // an i32 or i64 and an efficient multiplier (1, 2, 3, 4, 5, 8, 9).
13857       if (N->getValueType(0) == MVT::i32 || N->getValueType(0) == MVT::i64) {
13858         uint64_t Diff = TrueC->getZExtValue()-FalseC->getZExtValue();
13859         if (N->getValueType(0) == MVT::i32) Diff = (unsigned)Diff;
13860
13861         bool isFastMultiplier = false;
13862         if (Diff < 10) {
13863           switch ((unsigned char)Diff) {
13864           default: break;
13865           case 1:  // result = add base, cond
13866           case 2:  // result = lea base(    , cond*2)
13867           case 3:  // result = lea base(cond, cond*2)
13868           case 4:  // result = lea base(    , cond*4)
13869           case 5:  // result = lea base(cond, cond*4)
13870           case 8:  // result = lea base(    , cond*8)
13871           case 9:  // result = lea base(cond, cond*8)
13872             isFastMultiplier = true;
13873             break;
13874           }
13875         }
13876
13877         if (isFastMultiplier) {
13878           APInt Diff = TrueC->getAPIntValue()-FalseC->getAPIntValue();
13879           Cond = DAG.getNode(X86ISD::SETCC, DL, MVT::i8,
13880                              DAG.getConstant(CC, MVT::i8), Cond);
13881           // Zero extend the condition if needed.
13882           Cond = DAG.getNode(ISD::ZERO_EXTEND, DL, FalseC->getValueType(0),
13883                              Cond);
13884           // Scale the condition by the difference.
13885           if (Diff != 1)
13886             Cond = DAG.getNode(ISD::MUL, DL, Cond.getValueType(), Cond,
13887                                DAG.getConstant(Diff, Cond.getValueType()));
13888
13889           // Add the base if non-zero.
13890           if (FalseC->getAPIntValue() != 0)
13891             Cond = DAG.getNode(ISD::ADD, DL, Cond.getValueType(), Cond,
13892                                SDValue(FalseC, 0));
13893           if (N->getNumValues() == 2)  // Dead flag value?
13894             return DCI.CombineTo(N, Cond, SDValue());
13895           return Cond;
13896         }
13897       }
13898     }
13899   }
13900   return SDValue();
13901 }
13902
13903
13904 /// PerformMulCombine - Optimize a single multiply with constant into two
13905 /// in order to implement it with two cheaper instructions, e.g.
13906 /// LEA + SHL, LEA + LEA.
13907 static SDValue PerformMulCombine(SDNode *N, SelectionDAG &DAG,
13908                                  TargetLowering::DAGCombinerInfo &DCI) {
13909   if (DCI.isBeforeLegalize() || DCI.isCalledByLegalizer())
13910     return SDValue();
13911
13912   EVT VT = N->getValueType(0);
13913   if (VT != MVT::i64)
13914     return SDValue();
13915
13916   ConstantSDNode *C = dyn_cast<ConstantSDNode>(N->getOperand(1));
13917   if (!C)
13918     return SDValue();
13919   uint64_t MulAmt = C->getZExtValue();
13920   if (isPowerOf2_64(MulAmt) || MulAmt == 3 || MulAmt == 5 || MulAmt == 9)
13921     return SDValue();
13922
13923   uint64_t MulAmt1 = 0;
13924   uint64_t MulAmt2 = 0;
13925   if ((MulAmt % 9) == 0) {
13926     MulAmt1 = 9;
13927     MulAmt2 = MulAmt / 9;
13928   } else if ((MulAmt % 5) == 0) {
13929     MulAmt1 = 5;
13930     MulAmt2 = MulAmt / 5;
13931   } else if ((MulAmt % 3) == 0) {
13932     MulAmt1 = 3;
13933     MulAmt2 = MulAmt / 3;
13934   }
13935   if (MulAmt2 &&
13936       (isPowerOf2_64(MulAmt2) || MulAmt2 == 3 || MulAmt2 == 5 || MulAmt2 == 9)){
13937     DebugLoc DL = N->getDebugLoc();
13938
13939     if (isPowerOf2_64(MulAmt2) &&
13940         !(N->hasOneUse() && N->use_begin()->getOpcode() == ISD::ADD))
13941       // If second multiplifer is pow2, issue it first. We want the multiply by
13942       // 3, 5, or 9 to be folded into the addressing mode unless the lone use
13943       // is an add.
13944       std::swap(MulAmt1, MulAmt2);
13945
13946     SDValue NewMul;
13947     if (isPowerOf2_64(MulAmt1))
13948       NewMul = DAG.getNode(ISD::SHL, DL, VT, N->getOperand(0),
13949                            DAG.getConstant(Log2_64(MulAmt1), MVT::i8));
13950     else
13951       NewMul = DAG.getNode(X86ISD::MUL_IMM, DL, VT, N->getOperand(0),
13952                            DAG.getConstant(MulAmt1, VT));
13953
13954     if (isPowerOf2_64(MulAmt2))
13955       NewMul = DAG.getNode(ISD::SHL, DL, VT, NewMul,
13956                            DAG.getConstant(Log2_64(MulAmt2), MVT::i8));
13957     else
13958       NewMul = DAG.getNode(X86ISD::MUL_IMM, DL, VT, NewMul,
13959                            DAG.getConstant(MulAmt2, VT));
13960
13961     // Do not add new nodes to DAG combiner worklist.
13962     DCI.CombineTo(N, NewMul, false);
13963   }
13964   return SDValue();
13965 }
13966
13967 static SDValue PerformSHLCombine(SDNode *N, SelectionDAG &DAG) {
13968   SDValue N0 = N->getOperand(0);
13969   SDValue N1 = N->getOperand(1);
13970   ConstantSDNode *N1C = dyn_cast<ConstantSDNode>(N1);
13971   EVT VT = N0.getValueType();
13972
13973   // fold (shl (and (setcc_c), c1), c2) -> (and setcc_c, (c1 << c2))
13974   // since the result of setcc_c is all zero's or all ones.
13975   if (VT.isInteger() && !VT.isVector() &&
13976       N1C && N0.getOpcode() == ISD::AND &&
13977       N0.getOperand(1).getOpcode() == ISD::Constant) {
13978     SDValue N00 = N0.getOperand(0);
13979     if (N00.getOpcode() == X86ISD::SETCC_CARRY ||
13980         ((N00.getOpcode() == ISD::ANY_EXTEND ||
13981           N00.getOpcode() == ISD::ZERO_EXTEND) &&
13982          N00.getOperand(0).getOpcode() == X86ISD::SETCC_CARRY)) {
13983       APInt Mask = cast<ConstantSDNode>(N0.getOperand(1))->getAPIntValue();
13984       APInt ShAmt = N1C->getAPIntValue();
13985       Mask = Mask.shl(ShAmt);
13986       if (Mask != 0)
13987         return DAG.getNode(ISD::AND, N->getDebugLoc(), VT,
13988                            N00, DAG.getConstant(Mask, VT));
13989     }
13990   }
13991
13992
13993   // Hardware support for vector shifts is sparse which makes us scalarize the
13994   // vector operations in many cases. Also, on sandybridge ADD is faster than
13995   // shl.
13996   // (shl V, 1) -> add V,V
13997   if (isSplatVector(N1.getNode())) {
13998     assert(N0.getValueType().isVector() && "Invalid vector shift type");
13999     ConstantSDNode *N1C = dyn_cast<ConstantSDNode>(N1->getOperand(0));
14000     // We shift all of the values by one. In many cases we do not have
14001     // hardware support for this operation. This is better expressed as an ADD
14002     // of two values.
14003     if (N1C && (1 == N1C->getZExtValue())) {
14004       return DAG.getNode(ISD::ADD, N->getDebugLoc(), VT, N0, N0);
14005     }
14006   }
14007
14008   return SDValue();
14009 }
14010
14011 /// PerformShiftCombine - Transforms vector shift nodes to use vector shifts
14012 ///                       when possible.
14013 static SDValue PerformShiftCombine(SDNode* N, SelectionDAG &DAG,
14014                                    TargetLowering::DAGCombinerInfo &DCI,
14015                                    const X86Subtarget *Subtarget) {
14016   EVT VT = N->getValueType(0);
14017   if (N->getOpcode() == ISD::SHL) {
14018     SDValue V = PerformSHLCombine(N, DAG);
14019     if (V.getNode()) return V;
14020   }
14021
14022   // On X86 with SSE2 support, we can transform this to a vector shift if
14023   // all elements are shifted by the same amount.  We can't do this in legalize
14024   // because the a constant vector is typically transformed to a constant pool
14025   // so we have no knowledge of the shift amount.
14026   if (!Subtarget->hasSSE2())
14027     return SDValue();
14028
14029   if (VT != MVT::v2i64 && VT != MVT::v4i32 && VT != MVT::v8i16 &&
14030       (!Subtarget->hasAVX2() ||
14031        (VT != MVT::v4i64 && VT != MVT::v8i32 && VT != MVT::v16i16)))
14032     return SDValue();
14033
14034   SDValue ShAmtOp = N->getOperand(1);
14035   EVT EltVT = VT.getVectorElementType();
14036   DebugLoc DL = N->getDebugLoc();
14037   SDValue BaseShAmt = SDValue();
14038   if (ShAmtOp.getOpcode() == ISD::BUILD_VECTOR) {
14039     unsigned NumElts = VT.getVectorNumElements();
14040     unsigned i = 0;
14041     for (; i != NumElts; ++i) {
14042       SDValue Arg = ShAmtOp.getOperand(i);
14043       if (Arg.getOpcode() == ISD::UNDEF) continue;
14044       BaseShAmt = Arg;
14045       break;
14046     }
14047     // Handle the case where the build_vector is all undef
14048     // FIXME: Should DAG allow this?
14049     if (i == NumElts)
14050       return SDValue();
14051
14052     for (; i != NumElts; ++i) {
14053       SDValue Arg = ShAmtOp.getOperand(i);
14054       if (Arg.getOpcode() == ISD::UNDEF) continue;
14055       if (Arg != BaseShAmt) {
14056         return SDValue();
14057       }
14058     }
14059   } else if (ShAmtOp.getOpcode() == ISD::VECTOR_SHUFFLE &&
14060              cast<ShuffleVectorSDNode>(ShAmtOp)->isSplat()) {
14061     SDValue InVec = ShAmtOp.getOperand(0);
14062     if (InVec.getOpcode() == ISD::BUILD_VECTOR) {
14063       unsigned NumElts = InVec.getValueType().getVectorNumElements();
14064       unsigned i = 0;
14065       for (; i != NumElts; ++i) {
14066         SDValue Arg = InVec.getOperand(i);
14067         if (Arg.getOpcode() == ISD::UNDEF) continue;
14068         BaseShAmt = Arg;
14069         break;
14070       }
14071     } else if (InVec.getOpcode() == ISD::INSERT_VECTOR_ELT) {
14072        if (ConstantSDNode *C = dyn_cast<ConstantSDNode>(InVec.getOperand(2))) {
14073          unsigned SplatIdx= cast<ShuffleVectorSDNode>(ShAmtOp)->getSplatIndex();
14074          if (C->getZExtValue() == SplatIdx)
14075            BaseShAmt = InVec.getOperand(1);
14076        }
14077     }
14078     if (BaseShAmt.getNode() == 0) {
14079       // Don't create instructions with illegal types after legalize
14080       // types has run.
14081       if (!DAG.getTargetLoweringInfo().isTypeLegal(EltVT) &&
14082           !DCI.isBeforeLegalize())
14083         return SDValue();
14084
14085       BaseShAmt = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, DL, EltVT, ShAmtOp,
14086                               DAG.getIntPtrConstant(0));
14087     }
14088   } else
14089     return SDValue();
14090
14091   // The shift amount is an i32.
14092   if (EltVT.bitsGT(MVT::i32))
14093     BaseShAmt = DAG.getNode(ISD::TRUNCATE, DL, MVT::i32, BaseShAmt);
14094   else if (EltVT.bitsLT(MVT::i32))
14095     BaseShAmt = DAG.getNode(ISD::ZERO_EXTEND, DL, MVT::i32, BaseShAmt);
14096
14097   // The shift amount is identical so we can do a vector shift.
14098   SDValue  ValOp = N->getOperand(0);
14099   switch (N->getOpcode()) {
14100   default:
14101     llvm_unreachable("Unknown shift opcode!");
14102   case ISD::SHL:
14103     switch (VT.getSimpleVT().SimpleTy) {
14104     default: return SDValue();
14105     case MVT::v2i64:
14106     case MVT::v4i32:
14107     case MVT::v8i16:
14108     case MVT::v4i64:
14109     case MVT::v8i32:
14110     case MVT::v16i16:
14111       return getTargetVShiftNode(X86ISD::VSHLI, DL, VT, ValOp, BaseShAmt, DAG);
14112     }
14113   case ISD::SRA:
14114     switch (VT.getSimpleVT().SimpleTy) {
14115     default: return SDValue();
14116     case MVT::v4i32:
14117     case MVT::v8i16:
14118     case MVT::v8i32:
14119     case MVT::v16i16:
14120       return getTargetVShiftNode(X86ISD::VSRAI, DL, VT, ValOp, BaseShAmt, DAG);
14121     }
14122   case ISD::SRL:
14123     switch (VT.getSimpleVT().SimpleTy) {
14124     default: return SDValue();
14125     case MVT::v2i64:
14126     case MVT::v4i32:
14127     case MVT::v8i16:
14128     case MVT::v4i64:
14129     case MVT::v8i32:
14130     case MVT::v16i16:
14131       return getTargetVShiftNode(X86ISD::VSRLI, DL, VT, ValOp, BaseShAmt, DAG);
14132     }
14133   }
14134 }
14135
14136
14137 // CMPEQCombine - Recognize the distinctive  (AND (setcc ...) (setcc ..))
14138 // where both setccs reference the same FP CMP, and rewrite for CMPEQSS
14139 // and friends.  Likewise for OR -> CMPNEQSS.
14140 static SDValue CMPEQCombine(SDNode *N, SelectionDAG &DAG,
14141                             TargetLowering::DAGCombinerInfo &DCI,
14142                             const X86Subtarget *Subtarget) {
14143   unsigned opcode;
14144
14145   // SSE1 supports CMP{eq|ne}SS, and SSE2 added CMP{eq|ne}SD, but
14146   // we're requiring SSE2 for both.
14147   if (Subtarget->hasSSE2() && isAndOrOfSetCCs(SDValue(N, 0U), opcode)) {
14148     SDValue N0 = N->getOperand(0);
14149     SDValue N1 = N->getOperand(1);
14150     SDValue CMP0 = N0->getOperand(1);
14151     SDValue CMP1 = N1->getOperand(1);
14152     DebugLoc DL = N->getDebugLoc();
14153
14154     // The SETCCs should both refer to the same CMP.
14155     if (CMP0.getOpcode() != X86ISD::CMP || CMP0 != CMP1)
14156       return SDValue();
14157
14158     SDValue CMP00 = CMP0->getOperand(0);
14159     SDValue CMP01 = CMP0->getOperand(1);
14160     EVT     VT    = CMP00.getValueType();
14161
14162     if (VT == MVT::f32 || VT == MVT::f64) {
14163       bool ExpectingFlags = false;
14164       // Check for any users that want flags:
14165       for (SDNode::use_iterator UI = N->use_begin(),
14166              UE = N->use_end();
14167            !ExpectingFlags && UI != UE; ++UI)
14168         switch (UI->getOpcode()) {
14169         default:
14170         case ISD::BR_CC:
14171         case ISD::BRCOND:
14172         case ISD::SELECT:
14173           ExpectingFlags = true;
14174           break;
14175         case ISD::CopyToReg:
14176         case ISD::SIGN_EXTEND:
14177         case ISD::ZERO_EXTEND:
14178         case ISD::ANY_EXTEND:
14179           break;
14180         }
14181
14182       if (!ExpectingFlags) {
14183         enum X86::CondCode cc0 = (enum X86::CondCode)N0.getConstantOperandVal(0);
14184         enum X86::CondCode cc1 = (enum X86::CondCode)N1.getConstantOperandVal(0);
14185
14186         if (cc1 == X86::COND_E || cc1 == X86::COND_NE) {
14187           X86::CondCode tmp = cc0;
14188           cc0 = cc1;
14189           cc1 = tmp;
14190         }
14191
14192         if ((cc0 == X86::COND_E  && cc1 == X86::COND_NP) ||
14193             (cc0 == X86::COND_NE && cc1 == X86::COND_P)) {
14194           bool is64BitFP = (CMP00.getValueType() == MVT::f64);
14195           X86ISD::NodeType NTOperator = is64BitFP ?
14196             X86ISD::FSETCCsd : X86ISD::FSETCCss;
14197           // FIXME: need symbolic constants for these magic numbers.
14198           // See X86ATTInstPrinter.cpp:printSSECC().
14199           unsigned x86cc = (cc0 == X86::COND_E) ? 0 : 4;
14200           SDValue OnesOrZeroesF = DAG.getNode(NTOperator, DL, MVT::f32, CMP00, CMP01,
14201                                               DAG.getConstant(x86cc, MVT::i8));
14202           SDValue OnesOrZeroesI = DAG.getNode(ISD::BITCAST, DL, MVT::i32,
14203                                               OnesOrZeroesF);
14204           SDValue ANDed = DAG.getNode(ISD::AND, DL, MVT::i32, OnesOrZeroesI,
14205                                       DAG.getConstant(1, MVT::i32));
14206           SDValue OneBitOfTruth = DAG.getNode(ISD::TRUNCATE, DL, MVT::i8, ANDed);
14207           return OneBitOfTruth;
14208         }
14209       }
14210     }
14211   }
14212   return SDValue();
14213 }
14214
14215 /// CanFoldXORWithAllOnes - Test whether the XOR operand is a AllOnes vector
14216 /// so it can be folded inside ANDNP.
14217 static bool CanFoldXORWithAllOnes(const SDNode *N) {
14218   EVT VT = N->getValueType(0);
14219
14220   // Match direct AllOnes for 128 and 256-bit vectors
14221   if (ISD::isBuildVectorAllOnes(N))
14222     return true;
14223
14224   // Look through a bit convert.
14225   if (N->getOpcode() == ISD::BITCAST)
14226     N = N->getOperand(0).getNode();
14227
14228   // Sometimes the operand may come from a insert_subvector building a 256-bit
14229   // allones vector
14230   if (VT.getSizeInBits() == 256 &&
14231       N->getOpcode() == ISD::INSERT_SUBVECTOR) {
14232     SDValue V1 = N->getOperand(0);
14233     SDValue V2 = N->getOperand(1);
14234
14235     if (V1.getOpcode() == ISD::INSERT_SUBVECTOR &&
14236         V1.getOperand(0).getOpcode() == ISD::UNDEF &&
14237         ISD::isBuildVectorAllOnes(V1.getOperand(1).getNode()) &&
14238         ISD::isBuildVectorAllOnes(V2.getNode()))
14239       return true;
14240   }
14241
14242   return false;
14243 }
14244
14245 static SDValue PerformAndCombine(SDNode *N, SelectionDAG &DAG,
14246                                  TargetLowering::DAGCombinerInfo &DCI,
14247                                  const X86Subtarget *Subtarget) {
14248   if (DCI.isBeforeLegalizeOps())
14249     return SDValue();
14250
14251   SDValue R = CMPEQCombine(N, DAG, DCI, Subtarget);
14252   if (R.getNode())
14253     return R;
14254
14255   EVT VT = N->getValueType(0);
14256
14257   // Create ANDN, BLSI, and BLSR instructions
14258   // BLSI is X & (-X)
14259   // BLSR is X & (X-1)
14260   if (Subtarget->hasBMI() && (VT == MVT::i32 || VT == MVT::i64)) {
14261     SDValue N0 = N->getOperand(0);
14262     SDValue N1 = N->getOperand(1);
14263     DebugLoc DL = N->getDebugLoc();
14264
14265     // Check LHS for not
14266     if (N0.getOpcode() == ISD::XOR && isAllOnes(N0.getOperand(1)))
14267       return DAG.getNode(X86ISD::ANDN, DL, VT, N0.getOperand(0), N1);
14268     // Check RHS for not
14269     if (N1.getOpcode() == ISD::XOR && isAllOnes(N1.getOperand(1)))
14270       return DAG.getNode(X86ISD::ANDN, DL, VT, N1.getOperand(0), N0);
14271
14272     // Check LHS for neg
14273     if (N0.getOpcode() == ISD::SUB && N0.getOperand(1) == N1 &&
14274         isZero(N0.getOperand(0)))
14275       return DAG.getNode(X86ISD::BLSI, DL, VT, N1);
14276
14277     // Check RHS for neg
14278     if (N1.getOpcode() == ISD::SUB && N1.getOperand(1) == N0 &&
14279         isZero(N1.getOperand(0)))
14280       return DAG.getNode(X86ISD::BLSI, DL, VT, N0);
14281
14282     // Check LHS for X-1
14283     if (N0.getOpcode() == ISD::ADD && N0.getOperand(0) == N1 &&
14284         isAllOnes(N0.getOperand(1)))
14285       return DAG.getNode(X86ISD::BLSR, DL, VT, N1);
14286
14287     // Check RHS for X-1
14288     if (N1.getOpcode() == ISD::ADD && N1.getOperand(0) == N0 &&
14289         isAllOnes(N1.getOperand(1)))
14290       return DAG.getNode(X86ISD::BLSR, DL, VT, N0);
14291
14292     return SDValue();
14293   }
14294
14295   // Want to form ANDNP nodes:
14296   // 1) In the hopes of then easily combining them with OR and AND nodes
14297   //    to form PBLEND/PSIGN.
14298   // 2) To match ANDN packed intrinsics
14299   if (VT != MVT::v2i64 && VT != MVT::v4i64)
14300     return SDValue();
14301
14302   SDValue N0 = N->getOperand(0);
14303   SDValue N1 = N->getOperand(1);
14304   DebugLoc DL = N->getDebugLoc();
14305
14306   // Check LHS for vnot
14307   if (N0.getOpcode() == ISD::XOR &&
14308       //ISD::isBuildVectorAllOnes(N0.getOperand(1).getNode()))
14309       CanFoldXORWithAllOnes(N0.getOperand(1).getNode()))
14310     return DAG.getNode(X86ISD::ANDNP, DL, VT, N0.getOperand(0), N1);
14311
14312   // Check RHS for vnot
14313   if (N1.getOpcode() == ISD::XOR &&
14314       //ISD::isBuildVectorAllOnes(N1.getOperand(1).getNode()))
14315       CanFoldXORWithAllOnes(N1.getOperand(1).getNode()))
14316     return DAG.getNode(X86ISD::ANDNP, DL, VT, N1.getOperand(0), N0);
14317
14318   return SDValue();
14319 }
14320
14321 static SDValue PerformOrCombine(SDNode *N, SelectionDAG &DAG,
14322                                 TargetLowering::DAGCombinerInfo &DCI,
14323                                 const X86Subtarget *Subtarget) {
14324   if (DCI.isBeforeLegalizeOps())
14325     return SDValue();
14326
14327   SDValue R = CMPEQCombine(N, DAG, DCI, Subtarget);
14328   if (R.getNode())
14329     return R;
14330
14331   EVT VT = N->getValueType(0);
14332
14333   SDValue N0 = N->getOperand(0);
14334   SDValue N1 = N->getOperand(1);
14335
14336   // look for psign/blend
14337   if (VT == MVT::v2i64 || VT == MVT::v4i64) {
14338     if (!Subtarget->hasSSSE3() ||
14339         (VT == MVT::v4i64 && !Subtarget->hasAVX2()))
14340       return SDValue();
14341
14342     // Canonicalize pandn to RHS
14343     if (N0.getOpcode() == X86ISD::ANDNP)
14344       std::swap(N0, N1);
14345     // or (and (m, y), (pandn m, x))
14346     if (N0.getOpcode() == ISD::AND && N1.getOpcode() == X86ISD::ANDNP) {
14347       SDValue Mask = N1.getOperand(0);
14348       SDValue X    = N1.getOperand(1);
14349       SDValue Y;
14350       if (N0.getOperand(0) == Mask)
14351         Y = N0.getOperand(1);
14352       if (N0.getOperand(1) == Mask)
14353         Y = N0.getOperand(0);
14354
14355       // Check to see if the mask appeared in both the AND and ANDNP and
14356       if (!Y.getNode())
14357         return SDValue();
14358
14359       // Validate that X, Y, and Mask are BIT_CONVERTS, and see through them.
14360       // Look through mask bitcast.
14361       if (Mask.getOpcode() == ISD::BITCAST)
14362         Mask = Mask.getOperand(0);
14363       if (X.getOpcode() == ISD::BITCAST)
14364         X = X.getOperand(0);
14365       if (Y.getOpcode() == ISD::BITCAST)
14366         Y = Y.getOperand(0);
14367
14368       EVT MaskVT = Mask.getValueType();
14369
14370       // Validate that the Mask operand is a vector sra node.
14371       // FIXME: what to do for bytes, since there is a psignb/pblendvb, but
14372       // there is no psrai.b
14373       if (Mask.getOpcode() != X86ISD::VSRAI)
14374         return SDValue();
14375
14376       // Check that the SRA is all signbits.
14377       SDValue SraC = Mask.getOperand(1);
14378       unsigned SraAmt  = cast<ConstantSDNode>(SraC)->getZExtValue();
14379       unsigned EltBits = MaskVT.getVectorElementType().getSizeInBits();
14380       if ((SraAmt + 1) != EltBits)
14381         return SDValue();
14382
14383       DebugLoc DL = N->getDebugLoc();
14384
14385       // Now we know we at least have a plendvb with the mask val.  See if
14386       // we can form a psignb/w/d.
14387       // psign = x.type == y.type == mask.type && y = sub(0, x);
14388       if (Y.getOpcode() == ISD::SUB && Y.getOperand(1) == X &&
14389           ISD::isBuildVectorAllZeros(Y.getOperand(0).getNode()) &&
14390           X.getValueType() == MaskVT && Y.getValueType() == MaskVT) {
14391         assert((EltBits == 8 || EltBits == 16 || EltBits == 32) &&
14392                "Unsupported VT for PSIGN");
14393         Mask = DAG.getNode(X86ISD::PSIGN, DL, MaskVT, X, Mask.getOperand(0));
14394         return DAG.getNode(ISD::BITCAST, DL, VT, Mask);
14395       }
14396       // PBLENDVB only available on SSE 4.1
14397       if (!Subtarget->hasSSE41())
14398         return SDValue();
14399
14400       EVT BlendVT = (VT == MVT::v4i64) ? MVT::v32i8 : MVT::v16i8;
14401
14402       X = DAG.getNode(ISD::BITCAST, DL, BlendVT, X);
14403       Y = DAG.getNode(ISD::BITCAST, DL, BlendVT, Y);
14404       Mask = DAG.getNode(ISD::BITCAST, DL, BlendVT, Mask);
14405       Mask = DAG.getNode(ISD::VSELECT, DL, BlendVT, Mask, Y, X);
14406       return DAG.getNode(ISD::BITCAST, DL, VT, Mask);
14407     }
14408   }
14409
14410   if (VT != MVT::i16 && VT != MVT::i32 && VT != MVT::i64)
14411     return SDValue();
14412
14413   // fold (or (x << c) | (y >> (64 - c))) ==> (shld64 x, y, c)
14414   if (N0.getOpcode() == ISD::SRL && N1.getOpcode() == ISD::SHL)
14415     std::swap(N0, N1);
14416   if (N0.getOpcode() != ISD::SHL || N1.getOpcode() != ISD::SRL)
14417     return SDValue();
14418   if (!N0.hasOneUse() || !N1.hasOneUse())
14419     return SDValue();
14420
14421   SDValue ShAmt0 = N0.getOperand(1);
14422   if (ShAmt0.getValueType() != MVT::i8)
14423     return SDValue();
14424   SDValue ShAmt1 = N1.getOperand(1);
14425   if (ShAmt1.getValueType() != MVT::i8)
14426     return SDValue();
14427   if (ShAmt0.getOpcode() == ISD::TRUNCATE)
14428     ShAmt0 = ShAmt0.getOperand(0);
14429   if (ShAmt1.getOpcode() == ISD::TRUNCATE)
14430     ShAmt1 = ShAmt1.getOperand(0);
14431
14432   DebugLoc DL = N->getDebugLoc();
14433   unsigned Opc = X86ISD::SHLD;
14434   SDValue Op0 = N0.getOperand(0);
14435   SDValue Op1 = N1.getOperand(0);
14436   if (ShAmt0.getOpcode() == ISD::SUB) {
14437     Opc = X86ISD::SHRD;
14438     std::swap(Op0, Op1);
14439     std::swap(ShAmt0, ShAmt1);
14440   }
14441
14442   unsigned Bits = VT.getSizeInBits();
14443   if (ShAmt1.getOpcode() == ISD::SUB) {
14444     SDValue Sum = ShAmt1.getOperand(0);
14445     if (ConstantSDNode *SumC = dyn_cast<ConstantSDNode>(Sum)) {
14446       SDValue ShAmt1Op1 = ShAmt1.getOperand(1);
14447       if (ShAmt1Op1.getNode()->getOpcode() == ISD::TRUNCATE)
14448         ShAmt1Op1 = ShAmt1Op1.getOperand(0);
14449       if (SumC->getSExtValue() == Bits && ShAmt1Op1 == ShAmt0)
14450         return DAG.getNode(Opc, DL, VT,
14451                            Op0, Op1,
14452                            DAG.getNode(ISD::TRUNCATE, DL,
14453                                        MVT::i8, ShAmt0));
14454     }
14455   } else if (ConstantSDNode *ShAmt1C = dyn_cast<ConstantSDNode>(ShAmt1)) {
14456     ConstantSDNode *ShAmt0C = dyn_cast<ConstantSDNode>(ShAmt0);
14457     if (ShAmt0C &&
14458         ShAmt0C->getSExtValue() + ShAmt1C->getSExtValue() == Bits)
14459       return DAG.getNode(Opc, DL, VT,
14460                          N0.getOperand(0), N1.getOperand(0),
14461                          DAG.getNode(ISD::TRUNCATE, DL,
14462                                        MVT::i8, ShAmt0));
14463   }
14464
14465   return SDValue();
14466 }
14467
14468 // Generate NEG and CMOV for integer abs.
14469 static SDValue performIntegerAbsCombine(SDNode *N, SelectionDAG &DAG) {
14470   EVT VT = N->getValueType(0);
14471
14472   // Since X86 does not have CMOV for 8-bit integer, we don't convert
14473   // 8-bit integer abs to NEG and CMOV.
14474   if (VT.isInteger() && VT.getSizeInBits() == 8)
14475     return SDValue();
14476
14477   SDValue N0 = N->getOperand(0);
14478   SDValue N1 = N->getOperand(1);
14479   DebugLoc DL = N->getDebugLoc();
14480
14481   // Check pattern of XOR(ADD(X,Y), Y) where Y is SRA(X, size(X)-1)
14482   // and change it to SUB and CMOV.
14483   if (VT.isInteger() && N->getOpcode() == ISD::XOR &&
14484       N0.getOpcode() == ISD::ADD &&
14485       N0.getOperand(1) == N1 &&
14486       N1.getOpcode() == ISD::SRA &&
14487       N1.getOperand(0) == N0.getOperand(0))
14488     if (ConstantSDNode *Y1C = dyn_cast<ConstantSDNode>(N1.getOperand(1)))
14489       if (Y1C->getAPIntValue() == VT.getSizeInBits()-1) {
14490         // Generate SUB & CMOV.
14491         SDValue Neg = DAG.getNode(X86ISD::SUB, DL, DAG.getVTList(VT, MVT::i32),
14492                                   DAG.getConstant(0, VT), N0.getOperand(0));
14493
14494         SDValue Ops[] = { N0.getOperand(0), Neg,
14495                           DAG.getConstant(X86::COND_GE, MVT::i8),
14496                           SDValue(Neg.getNode(), 1) };
14497         return DAG.getNode(X86ISD::CMOV, DL, DAG.getVTList(VT, MVT::Glue),
14498                            Ops, array_lengthof(Ops));
14499       }
14500   return SDValue();
14501 }
14502
14503 // PerformXorCombine - Attempts to turn XOR nodes into BLSMSK nodes
14504 static SDValue PerformXorCombine(SDNode *N, SelectionDAG &DAG,
14505                                  TargetLowering::DAGCombinerInfo &DCI,
14506                                  const X86Subtarget *Subtarget) {
14507   if (DCI.isBeforeLegalizeOps())
14508     return SDValue();
14509
14510   if (Subtarget->hasCMov()) {
14511     SDValue RV = performIntegerAbsCombine(N, DAG);
14512     if (RV.getNode())
14513       return RV;
14514   }
14515
14516   // Try forming BMI if it is available.
14517   if (!Subtarget->hasBMI())
14518     return SDValue();
14519
14520   EVT VT = N->getValueType(0);
14521
14522   if (VT != MVT::i32 && VT != MVT::i64)
14523     return SDValue();
14524
14525   assert(Subtarget->hasBMI() && "Creating BLSMSK requires BMI instructions");
14526
14527   // Create BLSMSK instructions by finding X ^ (X-1)
14528   SDValue N0 = N->getOperand(0);
14529   SDValue N1 = N->getOperand(1);
14530   DebugLoc DL = N->getDebugLoc();
14531
14532   if (N0.getOpcode() == ISD::ADD && N0.getOperand(0) == N1 &&
14533       isAllOnes(N0.getOperand(1)))
14534     return DAG.getNode(X86ISD::BLSMSK, DL, VT, N1);
14535
14536   if (N1.getOpcode() == ISD::ADD && N1.getOperand(0) == N0 &&
14537       isAllOnes(N1.getOperand(1)))
14538     return DAG.getNode(X86ISD::BLSMSK, DL, VT, N0);
14539
14540   return SDValue();
14541 }
14542
14543 /// PerformLOADCombine - Do target-specific dag combines on LOAD nodes.
14544 static SDValue PerformLOADCombine(SDNode *N, SelectionDAG &DAG,
14545                                   TargetLowering::DAGCombinerInfo &DCI,
14546                                   const X86Subtarget *Subtarget) {
14547   LoadSDNode *Ld = cast<LoadSDNode>(N);
14548   EVT RegVT = Ld->getValueType(0);
14549   EVT MemVT = Ld->getMemoryVT();
14550   DebugLoc dl = Ld->getDebugLoc();
14551   const TargetLowering &TLI = DAG.getTargetLoweringInfo();
14552
14553   ISD::LoadExtType Ext = Ld->getExtensionType();
14554
14555   // If this is a vector EXT Load then attempt to optimize it using a
14556   // shuffle. We need SSE4 for the shuffles.
14557   // TODO: It is possible to support ZExt by zeroing the undef values
14558   // during the shuffle phase or after the shuffle.
14559   if (RegVT.isVector() && RegVT.isInteger() &&
14560       Ext == ISD::EXTLOAD && Subtarget->hasSSE41()) {
14561     assert(MemVT != RegVT && "Cannot extend to the same type");
14562     assert(MemVT.isVector() && "Must load a vector from memory");
14563
14564     unsigned NumElems = RegVT.getVectorNumElements();
14565     unsigned RegSz = RegVT.getSizeInBits();
14566     unsigned MemSz = MemVT.getSizeInBits();
14567     assert(RegSz > MemSz && "Register size must be greater than the mem size");
14568
14569     // All sizes must be a power of two.
14570     if (!isPowerOf2_32(RegSz * MemSz * NumElems))
14571       return SDValue();
14572
14573     // Attempt to load the original value using scalar loads.
14574     // Find the largest scalar type that divides the total loaded size.
14575     MVT SclrLoadTy = MVT::i8;
14576     for (unsigned tp = MVT::FIRST_INTEGER_VALUETYPE;
14577          tp < MVT::LAST_INTEGER_VALUETYPE; ++tp) {
14578       MVT Tp = (MVT::SimpleValueType)tp;
14579       if (TLI.isTypeLegal(Tp) && ((MemSz % Tp.getSizeInBits()) == 0)) {
14580         SclrLoadTy = Tp;
14581       }
14582     }
14583
14584     // On 32bit systems, we can't save 64bit integers. Try bitcasting to F64.
14585     if (TLI.isTypeLegal(MVT::f64) && SclrLoadTy.getSizeInBits() < 64 &&
14586         (64 <= MemSz))
14587       SclrLoadTy = MVT::f64;
14588
14589     // Calculate the number of scalar loads that we need to perform
14590     // in order to load our vector from memory.
14591     unsigned NumLoads = MemSz / SclrLoadTy.getSizeInBits();
14592
14593     // Represent our vector as a sequence of elements which are the
14594     // largest scalar that we can load.
14595     EVT LoadUnitVecVT = EVT::getVectorVT(*DAG.getContext(), SclrLoadTy,
14596       RegSz/SclrLoadTy.getSizeInBits());
14597
14598     // Represent the data using the same element type that is stored in
14599     // memory. In practice, we ''widen'' MemVT.
14600     EVT WideVecVT = EVT::getVectorVT(*DAG.getContext(), MemVT.getScalarType(),
14601                                   RegSz/MemVT.getScalarType().getSizeInBits());
14602
14603     assert(WideVecVT.getSizeInBits() == LoadUnitVecVT.getSizeInBits() &&
14604       "Invalid vector type");
14605
14606     // We can't shuffle using an illegal type.
14607     if (!TLI.isTypeLegal(WideVecVT))
14608       return SDValue();
14609
14610     SmallVector<SDValue, 8> Chains;
14611     SDValue Ptr = Ld->getBasePtr();
14612     SDValue Increment = DAG.getConstant(SclrLoadTy.getSizeInBits()/8,
14613                                         TLI.getPointerTy());
14614     SDValue Res = DAG.getUNDEF(LoadUnitVecVT);
14615
14616     for (unsigned i = 0; i < NumLoads; ++i) {
14617       // Perform a single load.
14618       SDValue ScalarLoad = DAG.getLoad(SclrLoadTy, dl, Ld->getChain(),
14619                                        Ptr, Ld->getPointerInfo(),
14620                                        Ld->isVolatile(), Ld->isNonTemporal(),
14621                                        Ld->isInvariant(), Ld->getAlignment());
14622       Chains.push_back(ScalarLoad.getValue(1));
14623       // Create the first element type using SCALAR_TO_VECTOR in order to avoid
14624       // another round of DAGCombining.
14625       if (i == 0)
14626         Res = DAG.getNode(ISD::SCALAR_TO_VECTOR, dl, LoadUnitVecVT, ScalarLoad);
14627       else
14628         Res = DAG.getNode(ISD::INSERT_VECTOR_ELT, dl, LoadUnitVecVT, Res,
14629                           ScalarLoad, DAG.getIntPtrConstant(i));
14630
14631       Ptr = DAG.getNode(ISD::ADD, dl, Ptr.getValueType(), Ptr, Increment);
14632     }
14633
14634     SDValue TF = DAG.getNode(ISD::TokenFactor, dl, MVT::Other, &Chains[0],
14635                                Chains.size());
14636
14637     // Bitcast the loaded value to a vector of the original element type, in
14638     // the size of the target vector type.
14639     SDValue SlicedVec = DAG.getNode(ISD::BITCAST, dl, WideVecVT, Res);
14640     unsigned SizeRatio = RegSz/MemSz;
14641
14642     // Redistribute the loaded elements into the different locations.
14643     SmallVector<int, 8> ShuffleVec(NumElems * SizeRatio, -1);
14644     for (unsigned i = 0; i != NumElems; ++i)
14645       ShuffleVec[i*SizeRatio] = i;
14646
14647     SDValue Shuff = DAG.getVectorShuffle(WideVecVT, dl, SlicedVec,
14648                                          DAG.getUNDEF(WideVecVT),
14649                                          &ShuffleVec[0]);
14650
14651     // Bitcast to the requested type.
14652     Shuff = DAG.getNode(ISD::BITCAST, dl, RegVT, Shuff);
14653     // Replace the original load with the new sequence
14654     // and return the new chain.
14655     return DCI.CombineTo(N, Shuff, TF, true);
14656   }
14657
14658   return SDValue();
14659 }
14660
14661 /// PerformSTORECombine - Do target-specific dag combines on STORE nodes.
14662 static SDValue PerformSTORECombine(SDNode *N, SelectionDAG &DAG,
14663                                    const X86Subtarget *Subtarget) {
14664   StoreSDNode *St = cast<StoreSDNode>(N);
14665   EVT VT = St->getValue().getValueType();
14666   EVT StVT = St->getMemoryVT();
14667   DebugLoc dl = St->getDebugLoc();
14668   SDValue StoredVal = St->getOperand(1);
14669   const TargetLowering &TLI = DAG.getTargetLoweringInfo();
14670
14671   // If we are saving a concatenation of two XMM registers, perform two stores.
14672   // On Sandy Bridge, 256-bit memory operations are executed by two
14673   // 128-bit ports. However, on Haswell it is better to issue a single 256-bit
14674   // memory  operation.
14675   if (VT.getSizeInBits() == 256 && !Subtarget->hasAVX2() &&
14676       StoredVal.getNode()->getOpcode() == ISD::CONCAT_VECTORS &&
14677       StoredVal.getNumOperands() == 2) {
14678     SDValue Value0 = StoredVal.getOperand(0);
14679     SDValue Value1 = StoredVal.getOperand(1);
14680
14681     SDValue Stride = DAG.getConstant(16, TLI.getPointerTy());
14682     SDValue Ptr0 = St->getBasePtr();
14683     SDValue Ptr1 = DAG.getNode(ISD::ADD, dl, Ptr0.getValueType(), Ptr0, Stride);
14684
14685     SDValue Ch0 = DAG.getStore(St->getChain(), dl, Value0, Ptr0,
14686                                 St->getPointerInfo(), St->isVolatile(),
14687                                 St->isNonTemporal(), St->getAlignment());
14688     SDValue Ch1 = DAG.getStore(St->getChain(), dl, Value1, Ptr1,
14689                                 St->getPointerInfo(), St->isVolatile(),
14690                                 St->isNonTemporal(), St->getAlignment());
14691     return DAG.getNode(ISD::TokenFactor, dl, MVT::Other, Ch0, Ch1);
14692   }
14693
14694   // Optimize trunc store (of multiple scalars) to shuffle and store.
14695   // First, pack all of the elements in one place. Next, store to memory
14696   // in fewer chunks.
14697   if (St->isTruncatingStore() && VT.isVector()) {
14698     const TargetLowering &TLI = DAG.getTargetLoweringInfo();
14699     unsigned NumElems = VT.getVectorNumElements();
14700     assert(StVT != VT && "Cannot truncate to the same type");
14701     unsigned FromSz = VT.getVectorElementType().getSizeInBits();
14702     unsigned ToSz = StVT.getVectorElementType().getSizeInBits();
14703
14704     // From, To sizes and ElemCount must be pow of two
14705     if (!isPowerOf2_32(NumElems * FromSz * ToSz)) return SDValue();
14706     // We are going to use the original vector elt for storing.
14707     // Accumulated smaller vector elements must be a multiple of the store size.
14708     if (0 != (NumElems * FromSz) % ToSz) return SDValue();
14709
14710     unsigned SizeRatio  = FromSz / ToSz;
14711
14712     assert(SizeRatio * NumElems * ToSz == VT.getSizeInBits());
14713
14714     // Create a type on which we perform the shuffle
14715     EVT WideVecVT = EVT::getVectorVT(*DAG.getContext(),
14716             StVT.getScalarType(), NumElems*SizeRatio);
14717
14718     assert(WideVecVT.getSizeInBits() == VT.getSizeInBits());
14719
14720     SDValue WideVec = DAG.getNode(ISD::BITCAST, dl, WideVecVT, St->getValue());
14721     SmallVector<int, 8> ShuffleVec(NumElems * SizeRatio, -1);
14722     for (unsigned i = 0; i != NumElems; ++i)
14723       ShuffleVec[i] = i * SizeRatio;
14724
14725     // Can't shuffle using an illegal type.
14726     if (!TLI.isTypeLegal(WideVecVT))
14727       return SDValue();
14728
14729     SDValue Shuff = DAG.getVectorShuffle(WideVecVT, dl, WideVec,
14730                                          DAG.getUNDEF(WideVecVT),
14731                                          &ShuffleVec[0]);
14732     // At this point all of the data is stored at the bottom of the
14733     // register. We now need to save it to mem.
14734
14735     // Find the largest store unit
14736     MVT StoreType = MVT::i8;
14737     for (unsigned tp = MVT::FIRST_INTEGER_VALUETYPE;
14738          tp < MVT::LAST_INTEGER_VALUETYPE; ++tp) {
14739       MVT Tp = (MVT::SimpleValueType)tp;
14740       if (TLI.isTypeLegal(Tp) && Tp.getSizeInBits() <= NumElems * ToSz)
14741         StoreType = Tp;
14742     }
14743
14744     // On 32bit systems, we can't save 64bit integers. Try bitcasting to F64.
14745     if (TLI.isTypeLegal(MVT::f64) && StoreType.getSizeInBits() < 64 &&
14746         (64 <= NumElems * ToSz))
14747       StoreType = MVT::f64;
14748
14749     // Bitcast the original vector into a vector of store-size units
14750     EVT StoreVecVT = EVT::getVectorVT(*DAG.getContext(),
14751             StoreType, VT.getSizeInBits()/StoreType.getSizeInBits());
14752     assert(StoreVecVT.getSizeInBits() == VT.getSizeInBits());
14753     SDValue ShuffWide = DAG.getNode(ISD::BITCAST, dl, StoreVecVT, Shuff);
14754     SmallVector<SDValue, 8> Chains;
14755     SDValue Increment = DAG.getConstant(StoreType.getSizeInBits()/8,
14756                                         TLI.getPointerTy());
14757     SDValue Ptr = St->getBasePtr();
14758
14759     // Perform one or more big stores into memory.
14760     for (unsigned i=0, e=(ToSz*NumElems)/StoreType.getSizeInBits(); i!=e; ++i) {
14761       SDValue SubVec = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl,
14762                                    StoreType, ShuffWide,
14763                                    DAG.getIntPtrConstant(i));
14764       SDValue Ch = DAG.getStore(St->getChain(), dl, SubVec, Ptr,
14765                                 St->getPointerInfo(), St->isVolatile(),
14766                                 St->isNonTemporal(), St->getAlignment());
14767       Ptr = DAG.getNode(ISD::ADD, dl, Ptr.getValueType(), Ptr, Increment);
14768       Chains.push_back(Ch);
14769     }
14770
14771     return DAG.getNode(ISD::TokenFactor, dl, MVT::Other, &Chains[0],
14772                                Chains.size());
14773   }
14774
14775
14776   // Turn load->store of MMX types into GPR load/stores.  This avoids clobbering
14777   // the FP state in cases where an emms may be missing.
14778   // A preferable solution to the general problem is to figure out the right
14779   // places to insert EMMS.  This qualifies as a quick hack.
14780
14781   // Similarly, turn load->store of i64 into double load/stores in 32-bit mode.
14782   if (VT.getSizeInBits() != 64)
14783     return SDValue();
14784
14785   const Function *F = DAG.getMachineFunction().getFunction();
14786   bool NoImplicitFloatOps = F->hasFnAttr(Attribute::NoImplicitFloat);
14787   bool F64IsLegal = !DAG.getTarget().Options.UseSoftFloat && !NoImplicitFloatOps
14788                      && Subtarget->hasSSE2();
14789   if ((VT.isVector() ||
14790        (VT == MVT::i64 && F64IsLegal && !Subtarget->is64Bit())) &&
14791       isa<LoadSDNode>(St->getValue()) &&
14792       !cast<LoadSDNode>(St->getValue())->isVolatile() &&
14793       St->getChain().hasOneUse() && !St->isVolatile()) {
14794     SDNode* LdVal = St->getValue().getNode();
14795     LoadSDNode *Ld = 0;
14796     int TokenFactorIndex = -1;
14797     SmallVector<SDValue, 8> Ops;
14798     SDNode* ChainVal = St->getChain().getNode();
14799     // Must be a store of a load.  We currently handle two cases:  the load
14800     // is a direct child, and it's under an intervening TokenFactor.  It is
14801     // possible to dig deeper under nested TokenFactors.
14802     if (ChainVal == LdVal)
14803       Ld = cast<LoadSDNode>(St->getChain());
14804     else if (St->getValue().hasOneUse() &&
14805              ChainVal->getOpcode() == ISD::TokenFactor) {
14806       for (unsigned i = 0, e = ChainVal->getNumOperands(); i != e; ++i) {
14807         if (ChainVal->getOperand(i).getNode() == LdVal) {
14808           TokenFactorIndex = i;
14809           Ld = cast<LoadSDNode>(St->getValue());
14810         } else
14811           Ops.push_back(ChainVal->getOperand(i));
14812       }
14813     }
14814
14815     if (!Ld || !ISD::isNormalLoad(Ld))
14816       return SDValue();
14817
14818     // If this is not the MMX case, i.e. we are just turning i64 load/store
14819     // into f64 load/store, avoid the transformation if there are multiple
14820     // uses of the loaded value.
14821     if (!VT.isVector() && !Ld->hasNUsesOfValue(1, 0))
14822       return SDValue();
14823
14824     DebugLoc LdDL = Ld->getDebugLoc();
14825     DebugLoc StDL = N->getDebugLoc();
14826     // If we are a 64-bit capable x86, lower to a single movq load/store pair.
14827     // Otherwise, if it's legal to use f64 SSE instructions, use f64 load/store
14828     // pair instead.
14829     if (Subtarget->is64Bit() || F64IsLegal) {
14830       EVT LdVT = Subtarget->is64Bit() ? MVT::i64 : MVT::f64;
14831       SDValue NewLd = DAG.getLoad(LdVT, LdDL, Ld->getChain(), Ld->getBasePtr(),
14832                                   Ld->getPointerInfo(), Ld->isVolatile(),
14833                                   Ld->isNonTemporal(), Ld->isInvariant(),
14834                                   Ld->getAlignment());
14835       SDValue NewChain = NewLd.getValue(1);
14836       if (TokenFactorIndex != -1) {
14837         Ops.push_back(NewChain);
14838         NewChain = DAG.getNode(ISD::TokenFactor, LdDL, MVT::Other, &Ops[0],
14839                                Ops.size());
14840       }
14841       return DAG.getStore(NewChain, StDL, NewLd, St->getBasePtr(),
14842                           St->getPointerInfo(),
14843                           St->isVolatile(), St->isNonTemporal(),
14844                           St->getAlignment());
14845     }
14846
14847     // Otherwise, lower to two pairs of 32-bit loads / stores.
14848     SDValue LoAddr = Ld->getBasePtr();
14849     SDValue HiAddr = DAG.getNode(ISD::ADD, LdDL, MVT::i32, LoAddr,
14850                                  DAG.getConstant(4, MVT::i32));
14851
14852     SDValue LoLd = DAG.getLoad(MVT::i32, LdDL, Ld->getChain(), LoAddr,
14853                                Ld->getPointerInfo(),
14854                                Ld->isVolatile(), Ld->isNonTemporal(),
14855                                Ld->isInvariant(), Ld->getAlignment());
14856     SDValue HiLd = DAG.getLoad(MVT::i32, LdDL, Ld->getChain(), HiAddr,
14857                                Ld->getPointerInfo().getWithOffset(4),
14858                                Ld->isVolatile(), Ld->isNonTemporal(),
14859                                Ld->isInvariant(),
14860                                MinAlign(Ld->getAlignment(), 4));
14861
14862     SDValue NewChain = LoLd.getValue(1);
14863     if (TokenFactorIndex != -1) {
14864       Ops.push_back(LoLd);
14865       Ops.push_back(HiLd);
14866       NewChain = DAG.getNode(ISD::TokenFactor, LdDL, MVT::Other, &Ops[0],
14867                              Ops.size());
14868     }
14869
14870     LoAddr = St->getBasePtr();
14871     HiAddr = DAG.getNode(ISD::ADD, StDL, MVT::i32, LoAddr,
14872                          DAG.getConstant(4, MVT::i32));
14873
14874     SDValue LoSt = DAG.getStore(NewChain, StDL, LoLd, LoAddr,
14875                                 St->getPointerInfo(),
14876                                 St->isVolatile(), St->isNonTemporal(),
14877                                 St->getAlignment());
14878     SDValue HiSt = DAG.getStore(NewChain, StDL, HiLd, HiAddr,
14879                                 St->getPointerInfo().getWithOffset(4),
14880                                 St->isVolatile(),
14881                                 St->isNonTemporal(),
14882                                 MinAlign(St->getAlignment(), 4));
14883     return DAG.getNode(ISD::TokenFactor, StDL, MVT::Other, LoSt, HiSt);
14884   }
14885   return SDValue();
14886 }
14887
14888 /// isHorizontalBinOp - Return 'true' if this vector operation is "horizontal"
14889 /// and return the operands for the horizontal operation in LHS and RHS.  A
14890 /// horizontal operation performs the binary operation on successive elements
14891 /// of its first operand, then on successive elements of its second operand,
14892 /// returning the resulting values in a vector.  For example, if
14893 ///   A = < float a0, float a1, float a2, float a3 >
14894 /// and
14895 ///   B = < float b0, float b1, float b2, float b3 >
14896 /// then the result of doing a horizontal operation on A and B is
14897 ///   A horizontal-op B = < a0 op a1, a2 op a3, b0 op b1, b2 op b3 >.
14898 /// In short, LHS and RHS are inspected to see if LHS op RHS is of the form
14899 /// A horizontal-op B, for some already available A and B, and if so then LHS is
14900 /// set to A, RHS to B, and the routine returns 'true'.
14901 /// Note that the binary operation should have the property that if one of the
14902 /// operands is UNDEF then the result is UNDEF.
14903 static bool isHorizontalBinOp(SDValue &LHS, SDValue &RHS, bool IsCommutative) {
14904   // Look for the following pattern: if
14905   //   A = < float a0, float a1, float a2, float a3 >
14906   //   B = < float b0, float b1, float b2, float b3 >
14907   // and
14908   //   LHS = VECTOR_SHUFFLE A, B, <0, 2, 4, 6>
14909   //   RHS = VECTOR_SHUFFLE A, B, <1, 3, 5, 7>
14910   // then LHS op RHS = < a0 op a1, a2 op a3, b0 op b1, b2 op b3 >
14911   // which is A horizontal-op B.
14912
14913   // At least one of the operands should be a vector shuffle.
14914   if (LHS.getOpcode() != ISD::VECTOR_SHUFFLE &&
14915       RHS.getOpcode() != ISD::VECTOR_SHUFFLE)
14916     return false;
14917
14918   EVT VT = LHS.getValueType();
14919
14920   assert((VT.is128BitVector() || VT.is256BitVector()) &&
14921          "Unsupported vector type for horizontal add/sub");
14922
14923   // Handle 128 and 256-bit vector lengths. AVX defines horizontal add/sub to
14924   // operate independently on 128-bit lanes.
14925   unsigned NumElts = VT.getVectorNumElements();
14926   unsigned NumLanes = VT.getSizeInBits()/128;
14927   unsigned NumLaneElts = NumElts / NumLanes;
14928   assert((NumLaneElts % 2 == 0) &&
14929          "Vector type should have an even number of elements in each lane");
14930   unsigned HalfLaneElts = NumLaneElts/2;
14931
14932   // View LHS in the form
14933   //   LHS = VECTOR_SHUFFLE A, B, LMask
14934   // If LHS is not a shuffle then pretend it is the shuffle
14935   //   LHS = VECTOR_SHUFFLE LHS, undef, <0, 1, ..., N-1>
14936   // NOTE: in what follows a default initialized SDValue represents an UNDEF of
14937   // type VT.
14938   SDValue A, B;
14939   SmallVector<int, 16> LMask(NumElts);
14940   if (LHS.getOpcode() == ISD::VECTOR_SHUFFLE) {
14941     if (LHS.getOperand(0).getOpcode() != ISD::UNDEF)
14942       A = LHS.getOperand(0);
14943     if (LHS.getOperand(1).getOpcode() != ISD::UNDEF)
14944       B = LHS.getOperand(1);
14945     ArrayRef<int> Mask = cast<ShuffleVectorSDNode>(LHS.getNode())->getMask();
14946     std::copy(Mask.begin(), Mask.end(), LMask.begin());
14947   } else {
14948     if (LHS.getOpcode() != ISD::UNDEF)
14949       A = LHS;
14950     for (unsigned i = 0; i != NumElts; ++i)
14951       LMask[i] = i;
14952   }
14953
14954   // Likewise, view RHS in the form
14955   //   RHS = VECTOR_SHUFFLE C, D, RMask
14956   SDValue C, D;
14957   SmallVector<int, 16> RMask(NumElts);
14958   if (RHS.getOpcode() == ISD::VECTOR_SHUFFLE) {
14959     if (RHS.getOperand(0).getOpcode() != ISD::UNDEF)
14960       C = RHS.getOperand(0);
14961     if (RHS.getOperand(1).getOpcode() != ISD::UNDEF)
14962       D = RHS.getOperand(1);
14963     ArrayRef<int> Mask = cast<ShuffleVectorSDNode>(RHS.getNode())->getMask();
14964     std::copy(Mask.begin(), Mask.end(), RMask.begin());
14965   } else {
14966     if (RHS.getOpcode() != ISD::UNDEF)
14967       C = RHS;
14968     for (unsigned i = 0; i != NumElts; ++i)
14969       RMask[i] = i;
14970   }
14971
14972   // Check that the shuffles are both shuffling the same vectors.
14973   if (!(A == C && B == D) && !(A == D && B == C))
14974     return false;
14975
14976   // If everything is UNDEF then bail out: it would be better to fold to UNDEF.
14977   if (!A.getNode() && !B.getNode())
14978     return false;
14979
14980   // If A and B occur in reverse order in RHS, then "swap" them (which means
14981   // rewriting the mask).
14982   if (A != C)
14983     CommuteVectorShuffleMask(RMask, NumElts);
14984
14985   // At this point LHS and RHS are equivalent to
14986   //   LHS = VECTOR_SHUFFLE A, B, LMask
14987   //   RHS = VECTOR_SHUFFLE A, B, RMask
14988   // Check that the masks correspond to performing a horizontal operation.
14989   for (unsigned i = 0; i != NumElts; ++i) {
14990     int LIdx = LMask[i], RIdx = RMask[i];
14991
14992     // Ignore any UNDEF components.
14993     if (LIdx < 0 || RIdx < 0 ||
14994         (!A.getNode() && (LIdx < (int)NumElts || RIdx < (int)NumElts)) ||
14995         (!B.getNode() && (LIdx >= (int)NumElts || RIdx >= (int)NumElts)))
14996       continue;
14997
14998     // Check that successive elements are being operated on.  If not, this is
14999     // not a horizontal operation.
15000     unsigned Src = (i/HalfLaneElts) % 2; // each lane is split between srcs
15001     unsigned LaneStart = (i/NumLaneElts) * NumLaneElts;
15002     int Index = 2*(i%HalfLaneElts) + NumElts*Src + LaneStart;
15003     if (!(LIdx == Index && RIdx == Index + 1) &&
15004         !(IsCommutative && LIdx == Index + 1 && RIdx == Index))
15005       return false;
15006   }
15007
15008   LHS = A.getNode() ? A : B; // If A is 'UNDEF', use B for it.
15009   RHS = B.getNode() ? B : A; // If B is 'UNDEF', use A for it.
15010   return true;
15011 }
15012
15013 /// PerformFADDCombine - Do target-specific dag combines on floating point adds.
15014 static SDValue PerformFADDCombine(SDNode *N, SelectionDAG &DAG,
15015                                   const X86Subtarget *Subtarget) {
15016   EVT VT = N->getValueType(0);
15017   SDValue LHS = N->getOperand(0);
15018   SDValue RHS = N->getOperand(1);
15019
15020   // Try to synthesize horizontal adds from adds of shuffles.
15021   if (((Subtarget->hasSSE3() && (VT == MVT::v4f32 || VT == MVT::v2f64)) ||
15022        (Subtarget->hasAVX() && (VT == MVT::v8f32 || VT == MVT::v4f64))) &&
15023       isHorizontalBinOp(LHS, RHS, true))
15024     return DAG.getNode(X86ISD::FHADD, N->getDebugLoc(), VT, LHS, RHS);
15025   return SDValue();
15026 }
15027
15028 /// PerformFSUBCombine - Do target-specific dag combines on floating point subs.
15029 static SDValue PerformFSUBCombine(SDNode *N, SelectionDAG &DAG,
15030                                   const X86Subtarget *Subtarget) {
15031   EVT VT = N->getValueType(0);
15032   SDValue LHS = N->getOperand(0);
15033   SDValue RHS = N->getOperand(1);
15034
15035   // Try to synthesize horizontal subs from subs of shuffles.
15036   if (((Subtarget->hasSSE3() && (VT == MVT::v4f32 || VT == MVT::v2f64)) ||
15037        (Subtarget->hasAVX() && (VT == MVT::v8f32 || VT == MVT::v4f64))) &&
15038       isHorizontalBinOp(LHS, RHS, false))
15039     return DAG.getNode(X86ISD::FHSUB, N->getDebugLoc(), VT, LHS, RHS);
15040   return SDValue();
15041 }
15042
15043 /// PerformFORCombine - Do target-specific dag combines on X86ISD::FOR and
15044 /// X86ISD::FXOR nodes.
15045 static SDValue PerformFORCombine(SDNode *N, SelectionDAG &DAG) {
15046   assert(N->getOpcode() == X86ISD::FOR || N->getOpcode() == X86ISD::FXOR);
15047   // F[X]OR(0.0, x) -> x
15048   // F[X]OR(x, 0.0) -> x
15049   if (ConstantFPSDNode *C = dyn_cast<ConstantFPSDNode>(N->getOperand(0)))
15050     if (C->getValueAPF().isPosZero())
15051       return N->getOperand(1);
15052   if (ConstantFPSDNode *C = dyn_cast<ConstantFPSDNode>(N->getOperand(1)))
15053     if (C->getValueAPF().isPosZero())
15054       return N->getOperand(0);
15055   return SDValue();
15056 }
15057
15058 /// PerformFANDCombine - Do target-specific dag combines on X86ISD::FAND nodes.
15059 static SDValue PerformFANDCombine(SDNode *N, SelectionDAG &DAG) {
15060   // FAND(0.0, x) -> 0.0
15061   // FAND(x, 0.0) -> 0.0
15062   if (ConstantFPSDNode *C = dyn_cast<ConstantFPSDNode>(N->getOperand(0)))
15063     if (C->getValueAPF().isPosZero())
15064       return N->getOperand(0);
15065   if (ConstantFPSDNode *C = dyn_cast<ConstantFPSDNode>(N->getOperand(1)))
15066     if (C->getValueAPF().isPosZero())
15067       return N->getOperand(1);
15068   return SDValue();
15069 }
15070
15071 static SDValue PerformBTCombine(SDNode *N,
15072                                 SelectionDAG &DAG,
15073                                 TargetLowering::DAGCombinerInfo &DCI) {
15074   // BT ignores high bits in the bit index operand.
15075   SDValue Op1 = N->getOperand(1);
15076   if (Op1.hasOneUse()) {
15077     unsigned BitWidth = Op1.getValueSizeInBits();
15078     APInt DemandedMask = APInt::getLowBitsSet(BitWidth, Log2_32(BitWidth));
15079     APInt KnownZero, KnownOne;
15080     TargetLowering::TargetLoweringOpt TLO(DAG, !DCI.isBeforeLegalize(),
15081                                           !DCI.isBeforeLegalizeOps());
15082     const TargetLowering &TLI = DAG.getTargetLoweringInfo();
15083     if (TLO.ShrinkDemandedConstant(Op1, DemandedMask) ||
15084         TLI.SimplifyDemandedBits(Op1, DemandedMask, KnownZero, KnownOne, TLO))
15085       DCI.CommitTargetLoweringOpt(TLO);
15086   }
15087   return SDValue();
15088 }
15089
15090 static SDValue PerformVZEXT_MOVLCombine(SDNode *N, SelectionDAG &DAG) {
15091   SDValue Op = N->getOperand(0);
15092   if (Op.getOpcode() == ISD::BITCAST)
15093     Op = Op.getOperand(0);
15094   EVT VT = N->getValueType(0), OpVT = Op.getValueType();
15095   if (Op.getOpcode() == X86ISD::VZEXT_LOAD &&
15096       VT.getVectorElementType().getSizeInBits() ==
15097       OpVT.getVectorElementType().getSizeInBits()) {
15098     return DAG.getNode(ISD::BITCAST, N->getDebugLoc(), VT, Op);
15099   }
15100   return SDValue();
15101 }
15102
15103 static SDValue PerformSExtCombine(SDNode *N, SelectionDAG &DAG,
15104                                   TargetLowering::DAGCombinerInfo &DCI,
15105                                   const X86Subtarget *Subtarget) {
15106   if (!DCI.isBeforeLegalizeOps())
15107     return SDValue();
15108
15109   if (!Subtarget->hasAVX())
15110     return SDValue();
15111
15112   EVT VT = N->getValueType(0);
15113   SDValue Op = N->getOperand(0);
15114   EVT OpVT = Op.getValueType();
15115   DebugLoc dl = N->getDebugLoc();
15116
15117   if ((VT == MVT::v4i64 && OpVT == MVT::v4i32) ||
15118       (VT == MVT::v8i32 && OpVT == MVT::v8i16)) {
15119
15120     if (Subtarget->hasAVX2())
15121       return DAG.getNode(X86ISD::VSEXT_MOVL, dl, VT, Op);
15122
15123     // Optimize vectors in AVX mode
15124     // Sign extend  v8i16 to v8i32 and
15125     //              v4i32 to v4i64
15126     //
15127     // Divide input vector into two parts
15128     // for v4i32 the shuffle mask will be { 0, 1, -1, -1} {2, 3, -1, -1}
15129     // use vpmovsx instruction to extend v4i32 -> v2i64; v8i16 -> v4i32
15130     // concat the vectors to original VT
15131
15132     unsigned NumElems = OpVT.getVectorNumElements();
15133     SmallVector<int,8> ShufMask1(NumElems, -1);
15134     for (unsigned i = 0; i != NumElems/2; ++i)
15135       ShufMask1[i] = i;
15136
15137     SDValue OpLo = DAG.getVectorShuffle(OpVT, dl, Op, DAG.getUNDEF(OpVT),
15138                                         &ShufMask1[0]);
15139
15140     SmallVector<int,8> ShufMask2(NumElems, -1);
15141     for (unsigned i = 0; i != NumElems/2; ++i)
15142       ShufMask2[i] = i + NumElems/2;
15143
15144     SDValue OpHi = DAG.getVectorShuffle(OpVT, dl, Op, DAG.getUNDEF(OpVT),
15145                                         &ShufMask2[0]);
15146
15147     EVT HalfVT = EVT::getVectorVT(*DAG.getContext(), VT.getScalarType(),
15148                                   VT.getVectorNumElements()/2);
15149
15150     OpLo = DAG.getNode(X86ISD::VSEXT_MOVL, dl, HalfVT, OpLo);
15151     OpHi = DAG.getNode(X86ISD::VSEXT_MOVL, dl, HalfVT, OpHi);
15152
15153     return DAG.getNode(ISD::CONCAT_VECTORS, dl, VT, OpLo, OpHi);
15154   }
15155   return SDValue();
15156 }
15157
15158 static SDValue PerformFMACombine(SDNode *N, SelectionDAG &DAG, 
15159                                  const X86Subtarget* Subtarget) {
15160   DebugLoc dl = N->getDebugLoc();
15161   EVT VT = N->getValueType(0);
15162
15163   EVT ScalarVT = VT.getScalarType();
15164   if ((ScalarVT != MVT::f32 && ScalarVT != MVT::f64) || !Subtarget->hasFMA())
15165     return SDValue();
15166
15167   SDValue A = N->getOperand(0);
15168   SDValue B = N->getOperand(1);
15169   SDValue C = N->getOperand(2);
15170
15171   bool NegA = (A.getOpcode() == ISD::FNEG);
15172   bool NegB = (B.getOpcode() == ISD::FNEG);
15173   bool NegC = (C.getOpcode() == ISD::FNEG);
15174
15175   // Negative multiplication when NegA xor NegB 
15176   bool NegMul = (NegA != NegB); 
15177   if (NegA)
15178     A = A.getOperand(0);
15179   if (NegB)
15180     B = B.getOperand(0);
15181   if (NegC)
15182     C = C.getOperand(0);
15183
15184   unsigned Opcode;
15185   if (!NegMul)
15186     Opcode = (!NegC)? X86ISD::FMADD : X86ISD::FMSUB;
15187   else
15188     Opcode = (!NegC)? X86ISD::FNMADD : X86ISD::FNMSUB;
15189   return DAG.getNode(Opcode, dl, VT, A, B, C);
15190 }
15191
15192 static SDValue PerformZExtCombine(SDNode *N, SelectionDAG &DAG,
15193                                   TargetLowering::DAGCombinerInfo &DCI,
15194                                   const X86Subtarget *Subtarget) {
15195   // (i32 zext (and (i8  x86isd::setcc_carry), 1)) ->
15196   //           (and (i32 x86isd::setcc_carry), 1)
15197   // This eliminates the zext. This transformation is necessary because
15198   // ISD::SETCC is always legalized to i8.
15199   DebugLoc dl = N->getDebugLoc();
15200   SDValue N0 = N->getOperand(0);
15201   EVT VT = N->getValueType(0);
15202   EVT OpVT = N0.getValueType();
15203
15204   if (N0.getOpcode() == ISD::AND &&
15205       N0.hasOneUse() &&
15206       N0.getOperand(0).hasOneUse()) {
15207     SDValue N00 = N0.getOperand(0);
15208     if (N00.getOpcode() != X86ISD::SETCC_CARRY)
15209       return SDValue();
15210     ConstantSDNode *C = dyn_cast<ConstantSDNode>(N0.getOperand(1));
15211     if (!C || C->getZExtValue() != 1)
15212       return SDValue();
15213     return DAG.getNode(ISD::AND, dl, VT,
15214                        DAG.getNode(X86ISD::SETCC_CARRY, dl, VT,
15215                                    N00.getOperand(0), N00.getOperand(1)),
15216                        DAG.getConstant(1, VT));
15217   }
15218
15219   // Optimize vectors in AVX mode:
15220   //
15221   //   v8i16 -> v8i32
15222   //   Use vpunpcklwd for 4 lower elements  v8i16 -> v4i32.
15223   //   Use vpunpckhwd for 4 upper elements  v8i16 -> v4i32.
15224   //   Concat upper and lower parts.
15225   //
15226   //   v4i32 -> v4i64
15227   //   Use vpunpckldq for 4 lower elements  v4i32 -> v2i64.
15228   //   Use vpunpckhdq for 4 upper elements  v4i32 -> v2i64.
15229   //   Concat upper and lower parts.
15230   //
15231   if (!DCI.isBeforeLegalizeOps())
15232     return SDValue();
15233
15234   if (!Subtarget->hasAVX())
15235     return SDValue();
15236
15237   if (((VT == MVT::v8i32) && (OpVT == MVT::v8i16)) ||
15238       ((VT == MVT::v4i64) && (OpVT == MVT::v4i32)))  {
15239
15240     if (Subtarget->hasAVX2())
15241       return DAG.getNode(X86ISD::VZEXT_MOVL, dl, VT, N0);
15242
15243     SDValue ZeroVec = getZeroVector(OpVT, Subtarget, DAG, dl);
15244     SDValue OpLo = getUnpackl(DAG, dl, OpVT, N0, ZeroVec);
15245     SDValue OpHi = getUnpackh(DAG, dl, OpVT, N0, ZeroVec);
15246
15247     EVT HVT = EVT::getVectorVT(*DAG.getContext(), VT.getVectorElementType(),
15248                                VT.getVectorNumElements()/2);
15249
15250     OpLo = DAG.getNode(ISD::BITCAST, dl, HVT, OpLo);
15251     OpHi = DAG.getNode(ISD::BITCAST, dl, HVT, OpHi);
15252
15253     return DAG.getNode(ISD::CONCAT_VECTORS, dl, VT, OpLo, OpHi);
15254   }
15255
15256   return SDValue();
15257 }
15258
15259 // Optimize x == -y --> x+y == 0
15260 //          x != -y --> x+y != 0
15261 static SDValue PerformISDSETCCCombine(SDNode *N, SelectionDAG &DAG) {
15262   ISD::CondCode CC = cast<CondCodeSDNode>(N->getOperand(2))->get();
15263   SDValue LHS = N->getOperand(0);
15264   SDValue RHS = N->getOperand(1);
15265
15266   if ((CC == ISD::SETNE || CC == ISD::SETEQ) && LHS.getOpcode() == ISD::SUB)
15267     if (ConstantSDNode *C = dyn_cast<ConstantSDNode>(LHS.getOperand(0)))
15268       if (C->getAPIntValue() == 0 && LHS.hasOneUse()) {
15269         SDValue addV = DAG.getNode(ISD::ADD, N->getDebugLoc(),
15270                                    LHS.getValueType(), RHS, LHS.getOperand(1));
15271         return DAG.getSetCC(N->getDebugLoc(), N->getValueType(0),
15272                             addV, DAG.getConstant(0, addV.getValueType()), CC);
15273       }
15274   if ((CC == ISD::SETNE || CC == ISD::SETEQ) && RHS.getOpcode() == ISD::SUB)
15275     if (ConstantSDNode *C = dyn_cast<ConstantSDNode>(RHS.getOperand(0)))
15276       if (C->getAPIntValue() == 0 && RHS.hasOneUse()) {
15277         SDValue addV = DAG.getNode(ISD::ADD, N->getDebugLoc(),
15278                                    RHS.getValueType(), LHS, RHS.getOperand(1));
15279         return DAG.getSetCC(N->getDebugLoc(), N->getValueType(0),
15280                             addV, DAG.getConstant(0, addV.getValueType()), CC);
15281       }
15282   return SDValue();
15283 }
15284
15285 // Optimize  RES = X86ISD::SETCC CONDCODE, EFLAG_INPUT
15286 static SDValue PerformSETCCCombine(SDNode *N, SelectionDAG &DAG) {
15287   unsigned X86CC = N->getConstantOperandVal(0);
15288   SDValue EFLAG = N->getOperand(1);
15289   DebugLoc DL = N->getDebugLoc();
15290
15291   // Materialize "setb reg" as "sbb reg,reg", since it can be extended without
15292   // a zext and produces an all-ones bit which is more useful than 0/1 in some
15293   // cases.
15294   if (X86CC == X86::COND_B)
15295     return DAG.getNode(ISD::AND, DL, MVT::i8,
15296                        DAG.getNode(X86ISD::SETCC_CARRY, DL, MVT::i8,
15297                                    DAG.getConstant(X86CC, MVT::i8), EFLAG),
15298                        DAG.getConstant(1, MVT::i8));
15299
15300   return SDValue();
15301 }
15302
15303 static SDValue PerformUINT_TO_FPCombine(SDNode *N, SelectionDAG &DAG) {
15304   SDValue Op0 = N->getOperand(0);
15305   EVT InVT = Op0->getValueType(0);
15306
15307   // UINT_TO_FP(v4i8) -> SINT_TO_FP(ZEXT(v4i8 to v4i32))
15308   if (InVT == MVT::v8i8 || InVT == MVT::v4i8) {
15309     DebugLoc dl = N->getDebugLoc();
15310     MVT DstVT = InVT == MVT::v4i8 ? MVT::v4i32 : MVT::v8i32;
15311     SDValue P = DAG.getNode(ISD::ZERO_EXTEND, dl, DstVT, Op0);
15312     // Notice that we use SINT_TO_FP because we know that the high bits
15313     // are zero and SINT_TO_FP is better supported by the hardware.
15314     return DAG.getNode(ISD::SINT_TO_FP, dl, N->getValueType(0), P);
15315   }
15316
15317   return SDValue();
15318 }
15319
15320 static SDValue PerformSINT_TO_FPCombine(SDNode *N, SelectionDAG &DAG,
15321                                         const X86TargetLowering *XTLI) {
15322   SDValue Op0 = N->getOperand(0);
15323   EVT InVT = Op0->getValueType(0);
15324
15325   // SINT_TO_FP(v4i8) -> SINT_TO_FP(SEXT(v4i8 to v4i32))
15326   if (InVT == MVT::v8i8 || InVT == MVT::v4i8) {
15327     DebugLoc dl = N->getDebugLoc();
15328     MVT DstVT = InVT == MVT::v4i8 ? MVT::v4i32 : MVT::v8i32;
15329     SDValue P = DAG.getNode(ISD::SIGN_EXTEND, dl, DstVT, Op0);
15330     return DAG.getNode(ISD::SINT_TO_FP, dl, N->getValueType(0), P);
15331   }
15332
15333   // Transform (SINT_TO_FP (i64 ...)) into an x87 operation if we have
15334   // a 32-bit target where SSE doesn't support i64->FP operations.
15335   if (Op0.getOpcode() == ISD::LOAD) {
15336     LoadSDNode *Ld = cast<LoadSDNode>(Op0.getNode());
15337     EVT VT = Ld->getValueType(0);
15338     if (!Ld->isVolatile() && !N->getValueType(0).isVector() &&
15339         ISD::isNON_EXTLoad(Op0.getNode()) && Op0.hasOneUse() &&
15340         !XTLI->getSubtarget()->is64Bit() &&
15341         !DAG.getTargetLoweringInfo().isTypeLegal(VT)) {
15342       SDValue FILDChain = XTLI->BuildFILD(SDValue(N, 0), Ld->getValueType(0),
15343                                           Ld->getChain(), Op0, DAG);
15344       DAG.ReplaceAllUsesOfValueWith(Op0.getValue(1), FILDChain.getValue(1));
15345       return FILDChain;
15346     }
15347   }
15348   return SDValue();
15349 }
15350
15351 static SDValue PerformFP_TO_SINTCombine(SDNode *N, SelectionDAG &DAG) {
15352   EVT VT = N->getValueType(0);
15353
15354   // v4i8 = FP_TO_SINT() -> v4i8 = TRUNCATE (V4i32 = FP_TO_SINT()
15355   if (VT == MVT::v8i8 || VT == MVT::v4i8) {
15356     DebugLoc dl = N->getDebugLoc();
15357     MVT DstVT = VT == MVT::v4i8 ? MVT::v4i32 : MVT::v8i32;
15358     SDValue I = DAG.getNode(ISD::FP_TO_SINT, dl, DstVT, N->getOperand(0));
15359     return DAG.getNode(ISD::TRUNCATE, dl, VT, I);
15360   }
15361
15362   return SDValue();
15363 }
15364
15365 // Optimize RES, EFLAGS = X86ISD::ADC LHS, RHS, EFLAGS
15366 static SDValue PerformADCCombine(SDNode *N, SelectionDAG &DAG,
15367                                  X86TargetLowering::DAGCombinerInfo &DCI) {
15368   // If the LHS and RHS of the ADC node are zero, then it can't overflow and
15369   // the result is either zero or one (depending on the input carry bit).
15370   // Strength reduce this down to a "set on carry" aka SETCC_CARRY&1.
15371   if (X86::isZeroNode(N->getOperand(0)) &&
15372       X86::isZeroNode(N->getOperand(1)) &&
15373       // We don't have a good way to replace an EFLAGS use, so only do this when
15374       // dead right now.
15375       SDValue(N, 1).use_empty()) {
15376     DebugLoc DL = N->getDebugLoc();
15377     EVT VT = N->getValueType(0);
15378     SDValue CarryOut = DAG.getConstant(0, N->getValueType(1));
15379     SDValue Res1 = DAG.getNode(ISD::AND, DL, VT,
15380                                DAG.getNode(X86ISD::SETCC_CARRY, DL, VT,
15381                                            DAG.getConstant(X86::COND_B,MVT::i8),
15382                                            N->getOperand(2)),
15383                                DAG.getConstant(1, VT));
15384     return DCI.CombineTo(N, Res1, CarryOut);
15385   }
15386
15387   return SDValue();
15388 }
15389
15390 // fold (add Y, (sete  X, 0)) -> adc  0, Y
15391 //      (add Y, (setne X, 0)) -> sbb -1, Y
15392 //      (sub (sete  X, 0), Y) -> sbb  0, Y
15393 //      (sub (setne X, 0), Y) -> adc -1, Y
15394 static SDValue OptimizeConditionalInDecrement(SDNode *N, SelectionDAG &DAG) {
15395   DebugLoc DL = N->getDebugLoc();
15396
15397   // Look through ZExts.
15398   SDValue Ext = N->getOperand(N->getOpcode() == ISD::SUB ? 1 : 0);
15399   if (Ext.getOpcode() != ISD::ZERO_EXTEND || !Ext.hasOneUse())
15400     return SDValue();
15401
15402   SDValue SetCC = Ext.getOperand(0);
15403   if (SetCC.getOpcode() != X86ISD::SETCC || !SetCC.hasOneUse())
15404     return SDValue();
15405
15406   X86::CondCode CC = (X86::CondCode)SetCC.getConstantOperandVal(0);
15407   if (CC != X86::COND_E && CC != X86::COND_NE)
15408     return SDValue();
15409
15410   SDValue Cmp = SetCC.getOperand(1);
15411   if (Cmp.getOpcode() != X86ISD::CMP || !Cmp.hasOneUse() ||
15412       !X86::isZeroNode(Cmp.getOperand(1)) ||
15413       !Cmp.getOperand(0).getValueType().isInteger())
15414     return SDValue();
15415
15416   SDValue CmpOp0 = Cmp.getOperand(0);
15417   SDValue NewCmp = DAG.getNode(X86ISD::CMP, DL, MVT::i32, CmpOp0,
15418                                DAG.getConstant(1, CmpOp0.getValueType()));
15419
15420   SDValue OtherVal = N->getOperand(N->getOpcode() == ISD::SUB ? 0 : 1);
15421   if (CC == X86::COND_NE)
15422     return DAG.getNode(N->getOpcode() == ISD::SUB ? X86ISD::ADC : X86ISD::SBB,
15423                        DL, OtherVal.getValueType(), OtherVal,
15424                        DAG.getConstant(-1ULL, OtherVal.getValueType()), NewCmp);
15425   return DAG.getNode(N->getOpcode() == ISD::SUB ? X86ISD::SBB : X86ISD::ADC,
15426                      DL, OtherVal.getValueType(), OtherVal,
15427                      DAG.getConstant(0, OtherVal.getValueType()), NewCmp);
15428 }
15429
15430 /// PerformADDCombine - Do target-specific dag combines on integer adds.
15431 static SDValue PerformAddCombine(SDNode *N, SelectionDAG &DAG,
15432                                  const X86Subtarget *Subtarget) {
15433   EVT VT = N->getValueType(0);
15434   SDValue Op0 = N->getOperand(0);
15435   SDValue Op1 = N->getOperand(1);
15436
15437   // Try to synthesize horizontal adds from adds of shuffles.
15438   if (((Subtarget->hasSSSE3() && (VT == MVT::v8i16 || VT == MVT::v4i32)) ||
15439        (Subtarget->hasAVX2() && (VT == MVT::v16i16 || VT == MVT::v8i32))) &&
15440       isHorizontalBinOp(Op0, Op1, true))
15441     return DAG.getNode(X86ISD::HADD, N->getDebugLoc(), VT, Op0, Op1);
15442
15443   return OptimizeConditionalInDecrement(N, DAG);
15444 }
15445
15446 static SDValue PerformSubCombine(SDNode *N, SelectionDAG &DAG,
15447                                  const X86Subtarget *Subtarget) {
15448   SDValue Op0 = N->getOperand(0);
15449   SDValue Op1 = N->getOperand(1);
15450
15451   // X86 can't encode an immediate LHS of a sub. See if we can push the
15452   // negation into a preceding instruction.
15453   if (ConstantSDNode *C = dyn_cast<ConstantSDNode>(Op0)) {
15454     // If the RHS of the sub is a XOR with one use and a constant, invert the
15455     // immediate. Then add one to the LHS of the sub so we can turn
15456     // X-Y -> X+~Y+1, saving one register.
15457     if (Op1->hasOneUse() && Op1.getOpcode() == ISD::XOR &&
15458         isa<ConstantSDNode>(Op1.getOperand(1))) {
15459       APInt XorC = cast<ConstantSDNode>(Op1.getOperand(1))->getAPIntValue();
15460       EVT VT = Op0.getValueType();
15461       SDValue NewXor = DAG.getNode(ISD::XOR, Op1.getDebugLoc(), VT,
15462                                    Op1.getOperand(0),
15463                                    DAG.getConstant(~XorC, VT));
15464       return DAG.getNode(ISD::ADD, N->getDebugLoc(), VT, NewXor,
15465                          DAG.getConstant(C->getAPIntValue()+1, VT));
15466     }
15467   }
15468
15469   // Try to synthesize horizontal adds from adds of shuffles.
15470   EVT VT = N->getValueType(0);
15471   if (((Subtarget->hasSSSE3() && (VT == MVT::v8i16 || VT == MVT::v4i32)) ||
15472        (Subtarget->hasAVX2() && (VT == MVT::v16i16 || VT == MVT::v8i32))) &&
15473       isHorizontalBinOp(Op0, Op1, true))
15474     return DAG.getNode(X86ISD::HSUB, N->getDebugLoc(), VT, Op0, Op1);
15475
15476   return OptimizeConditionalInDecrement(N, DAG);
15477 }
15478
15479 SDValue X86TargetLowering::PerformDAGCombine(SDNode *N,
15480                                              DAGCombinerInfo &DCI) const {
15481   SelectionDAG &DAG = DCI.DAG;
15482   switch (N->getOpcode()) {
15483   default: break;
15484   case ISD::EXTRACT_VECTOR_ELT:
15485     return PerformEXTRACT_VECTOR_ELTCombine(N, DAG, DCI);
15486   case ISD::VSELECT:
15487   case ISD::SELECT:         return PerformSELECTCombine(N, DAG, DCI, Subtarget);
15488   case X86ISD::CMOV:        return PerformCMOVCombine(N, DAG, DCI);
15489   case ISD::ADD:            return PerformAddCombine(N, DAG, Subtarget);
15490   case ISD::SUB:            return PerformSubCombine(N, DAG, Subtarget);
15491   case X86ISD::ADC:         return PerformADCCombine(N, DAG, DCI);
15492   case ISD::MUL:            return PerformMulCombine(N, DAG, DCI);
15493   case ISD::SHL:
15494   case ISD::SRA:
15495   case ISD::SRL:            return PerformShiftCombine(N, DAG, DCI, Subtarget);
15496   case ISD::AND:            return PerformAndCombine(N, DAG, DCI, Subtarget);
15497   case ISD::OR:             return PerformOrCombine(N, DAG, DCI, Subtarget);
15498   case ISD::XOR:            return PerformXorCombine(N, DAG, DCI, Subtarget);
15499   case ISD::LOAD:           return PerformLOADCombine(N, DAG, DCI, Subtarget);
15500   case ISD::STORE:          return PerformSTORECombine(N, DAG, Subtarget);
15501   case ISD::UINT_TO_FP:     return PerformUINT_TO_FPCombine(N, DAG);
15502   case ISD::SINT_TO_FP:     return PerformSINT_TO_FPCombine(N, DAG, this);
15503   case ISD::FP_TO_SINT:     return PerformFP_TO_SINTCombine(N, DAG);
15504   case ISD::FADD:           return PerformFADDCombine(N, DAG, Subtarget);
15505   case ISD::FSUB:           return PerformFSUBCombine(N, DAG, Subtarget);
15506   case X86ISD::FXOR:
15507   case X86ISD::FOR:         return PerformFORCombine(N, DAG);
15508   case X86ISD::FAND:        return PerformFANDCombine(N, DAG);
15509   case X86ISD::BT:          return PerformBTCombine(N, DAG, DCI);
15510   case X86ISD::VZEXT_MOVL:  return PerformVZEXT_MOVLCombine(N, DAG);
15511   case ISD::ANY_EXTEND:
15512   case ISD::ZERO_EXTEND:    return PerformZExtCombine(N, DAG, DCI, Subtarget);
15513   case ISD::SIGN_EXTEND:    return PerformSExtCombine(N, DAG, DCI, Subtarget);
15514   case ISD::TRUNCATE:       return PerformTruncateCombine(N, DAG, DCI);
15515   case ISD::SETCC:          return PerformISDSETCCCombine(N, DAG);
15516   case X86ISD::SETCC:       return PerformSETCCCombine(N, DAG);
15517   case X86ISD::SHUFP:       // Handle all target specific shuffles
15518   case X86ISD::PALIGN:
15519   case X86ISD::UNPCKH:
15520   case X86ISD::UNPCKL:
15521   case X86ISD::MOVHLPS:
15522   case X86ISD::MOVLHPS:
15523   case X86ISD::PSHUFD:
15524   case X86ISD::PSHUFHW:
15525   case X86ISD::PSHUFLW:
15526   case X86ISD::MOVSS:
15527   case X86ISD::MOVSD:
15528   case X86ISD::VPERMILP:
15529   case X86ISD::VPERM2X128:
15530   case ISD::VECTOR_SHUFFLE: return PerformShuffleCombine(N, DAG, DCI,Subtarget);
15531   case ISD::FMA:            return PerformFMACombine(N, DAG, Subtarget);
15532   }
15533
15534   return SDValue();
15535 }
15536
15537 /// isTypeDesirableForOp - Return true if the target has native support for
15538 /// the specified value type and it is 'desirable' to use the type for the
15539 /// given node type. e.g. On x86 i16 is legal, but undesirable since i16
15540 /// instruction encodings are longer and some i16 instructions are slow.
15541 bool X86TargetLowering::isTypeDesirableForOp(unsigned Opc, EVT VT) const {
15542   if (!isTypeLegal(VT))
15543     return false;
15544   if (VT != MVT::i16)
15545     return true;
15546
15547   switch (Opc) {
15548   default:
15549     return true;
15550   case ISD::LOAD:
15551   case ISD::SIGN_EXTEND:
15552   case ISD::ZERO_EXTEND:
15553   case ISD::ANY_EXTEND:
15554   case ISD::SHL:
15555   case ISD::SRL:
15556   case ISD::SUB:
15557   case ISD::ADD:
15558   case ISD::MUL:
15559   case ISD::AND:
15560   case ISD::OR:
15561   case ISD::XOR:
15562     return false;
15563   }
15564 }
15565
15566 /// IsDesirableToPromoteOp - This method query the target whether it is
15567 /// beneficial for dag combiner to promote the specified node. If true, it
15568 /// should return the desired promotion type by reference.
15569 bool X86TargetLowering::IsDesirableToPromoteOp(SDValue Op, EVT &PVT) const {
15570   EVT VT = Op.getValueType();
15571   if (VT != MVT::i16)
15572     return false;
15573
15574   bool Promote = false;
15575   bool Commute = false;
15576   switch (Op.getOpcode()) {
15577   default: break;
15578   case ISD::LOAD: {
15579     LoadSDNode *LD = cast<LoadSDNode>(Op);
15580     // If the non-extending load has a single use and it's not live out, then it
15581     // might be folded.
15582     if (LD->getExtensionType() == ISD::NON_EXTLOAD /*&&
15583                                                      Op.hasOneUse()*/) {
15584       for (SDNode::use_iterator UI = Op.getNode()->use_begin(),
15585              UE = Op.getNode()->use_end(); UI != UE; ++UI) {
15586         // The only case where we'd want to promote LOAD (rather then it being
15587         // promoted as an operand is when it's only use is liveout.
15588         if (UI->getOpcode() != ISD::CopyToReg)
15589           return false;
15590       }
15591     }
15592     Promote = true;
15593     break;
15594   }
15595   case ISD::SIGN_EXTEND:
15596   case ISD::ZERO_EXTEND:
15597   case ISD::ANY_EXTEND:
15598     Promote = true;
15599     break;
15600   case ISD::SHL:
15601   case ISD::SRL: {
15602     SDValue N0 = Op.getOperand(0);
15603     // Look out for (store (shl (load), x)).
15604     if (MayFoldLoad(N0) && MayFoldIntoStore(Op))
15605       return false;
15606     Promote = true;
15607     break;
15608   }
15609   case ISD::ADD:
15610   case ISD::MUL:
15611   case ISD::AND:
15612   case ISD::OR:
15613   case ISD::XOR:
15614     Commute = true;
15615     // fallthrough
15616   case ISD::SUB: {
15617     SDValue N0 = Op.getOperand(0);
15618     SDValue N1 = Op.getOperand(1);
15619     if (!Commute && MayFoldLoad(N1))
15620       return false;
15621     // Avoid disabling potential load folding opportunities.
15622     if (MayFoldLoad(N0) && (!isa<ConstantSDNode>(N1) || MayFoldIntoStore(Op)))
15623       return false;
15624     if (MayFoldLoad(N1) && (!isa<ConstantSDNode>(N0) || MayFoldIntoStore(Op)))
15625       return false;
15626     Promote = true;
15627   }
15628   }
15629
15630   PVT = MVT::i32;
15631   return Promote;
15632 }
15633
15634 //===----------------------------------------------------------------------===//
15635 //                           X86 Inline Assembly Support
15636 //===----------------------------------------------------------------------===//
15637
15638 namespace {
15639   // Helper to match a string separated by whitespace.
15640   bool matchAsmImpl(StringRef s, ArrayRef<const StringRef *> args) {
15641     s = s.substr(s.find_first_not_of(" \t")); // Skip leading whitespace.
15642
15643     for (unsigned i = 0, e = args.size(); i != e; ++i) {
15644       StringRef piece(*args[i]);
15645       if (!s.startswith(piece)) // Check if the piece matches.
15646         return false;
15647
15648       s = s.substr(piece.size());
15649       StringRef::size_type pos = s.find_first_not_of(" \t");
15650       if (pos == 0) // We matched a prefix.
15651         return false;
15652
15653       s = s.substr(pos);
15654     }
15655
15656     return s.empty();
15657   }
15658   const VariadicFunction1<bool, StringRef, StringRef, matchAsmImpl> matchAsm={};
15659 }
15660
15661 bool X86TargetLowering::ExpandInlineAsm(CallInst *CI) const {
15662   InlineAsm *IA = cast<InlineAsm>(CI->getCalledValue());
15663
15664   std::string AsmStr = IA->getAsmString();
15665
15666   IntegerType *Ty = dyn_cast<IntegerType>(CI->getType());
15667   if (!Ty || Ty->getBitWidth() % 16 != 0)
15668     return false;
15669
15670   // TODO: should remove alternatives from the asmstring: "foo {a|b}" -> "foo a"
15671   SmallVector<StringRef, 4> AsmPieces;
15672   SplitString(AsmStr, AsmPieces, ";\n");
15673
15674   switch (AsmPieces.size()) {
15675   default: return false;
15676   case 1:
15677     // FIXME: this should verify that we are targeting a 486 or better.  If not,
15678     // we will turn this bswap into something that will be lowered to logical
15679     // ops instead of emitting the bswap asm.  For now, we don't support 486 or
15680     // lower so don't worry about this.
15681     // bswap $0
15682     if (matchAsm(AsmPieces[0], "bswap", "$0") ||
15683         matchAsm(AsmPieces[0], "bswapl", "$0") ||
15684         matchAsm(AsmPieces[0], "bswapq", "$0") ||
15685         matchAsm(AsmPieces[0], "bswap", "${0:q}") ||
15686         matchAsm(AsmPieces[0], "bswapl", "${0:q}") ||
15687         matchAsm(AsmPieces[0], "bswapq", "${0:q}")) {
15688       // No need to check constraints, nothing other than the equivalent of
15689       // "=r,0" would be valid here.
15690       return IntrinsicLowering::LowerToByteSwap(CI);
15691     }
15692
15693     // rorw $$8, ${0:w}  -->  llvm.bswap.i16
15694     if (CI->getType()->isIntegerTy(16) &&
15695         IA->getConstraintString().compare(0, 5, "=r,0,") == 0 &&
15696         (matchAsm(AsmPieces[0], "rorw", "$$8,", "${0:w}") ||
15697          matchAsm(AsmPieces[0], "rolw", "$$8,", "${0:w}"))) {
15698       AsmPieces.clear();
15699       const std::string &ConstraintsStr = IA->getConstraintString();
15700       SplitString(StringRef(ConstraintsStr).substr(5), AsmPieces, ",");
15701       std::sort(AsmPieces.begin(), AsmPieces.end());
15702       if (AsmPieces.size() == 4 &&
15703           AsmPieces[0] == "~{cc}" &&
15704           AsmPieces[1] == "~{dirflag}" &&
15705           AsmPieces[2] == "~{flags}" &&
15706           AsmPieces[3] == "~{fpsr}")
15707       return IntrinsicLowering::LowerToByteSwap(CI);
15708     }
15709     break;
15710   case 3:
15711     if (CI->getType()->isIntegerTy(32) &&
15712         IA->getConstraintString().compare(0, 5, "=r,0,") == 0 &&
15713         matchAsm(AsmPieces[0], "rorw", "$$8,", "${0:w}") &&
15714         matchAsm(AsmPieces[1], "rorl", "$$16,", "$0") &&
15715         matchAsm(AsmPieces[2], "rorw", "$$8,", "${0:w}")) {
15716       AsmPieces.clear();
15717       const std::string &ConstraintsStr = IA->getConstraintString();
15718       SplitString(StringRef(ConstraintsStr).substr(5), AsmPieces, ",");
15719       std::sort(AsmPieces.begin(), AsmPieces.end());
15720       if (AsmPieces.size() == 4 &&
15721           AsmPieces[0] == "~{cc}" &&
15722           AsmPieces[1] == "~{dirflag}" &&
15723           AsmPieces[2] == "~{flags}" &&
15724           AsmPieces[3] == "~{fpsr}")
15725         return IntrinsicLowering::LowerToByteSwap(CI);
15726     }
15727
15728     if (CI->getType()->isIntegerTy(64)) {
15729       InlineAsm::ConstraintInfoVector Constraints = IA->ParseConstraints();
15730       if (Constraints.size() >= 2 &&
15731           Constraints[0].Codes.size() == 1 && Constraints[0].Codes[0] == "A" &&
15732           Constraints[1].Codes.size() == 1 && Constraints[1].Codes[0] == "0") {
15733         // bswap %eax / bswap %edx / xchgl %eax, %edx  -> llvm.bswap.i64
15734         if (matchAsm(AsmPieces[0], "bswap", "%eax") &&
15735             matchAsm(AsmPieces[1], "bswap", "%edx") &&
15736             matchAsm(AsmPieces[2], "xchgl", "%eax,", "%edx"))
15737           return IntrinsicLowering::LowerToByteSwap(CI);
15738       }
15739     }
15740     break;
15741   }
15742   return false;
15743 }
15744
15745
15746
15747 /// getConstraintType - Given a constraint letter, return the type of
15748 /// constraint it is for this target.
15749 X86TargetLowering::ConstraintType
15750 X86TargetLowering::getConstraintType(const std::string &Constraint) const {
15751   if (Constraint.size() == 1) {
15752     switch (Constraint[0]) {
15753     case 'R':
15754     case 'q':
15755     case 'Q':
15756     case 'f':
15757     case 't':
15758     case 'u':
15759     case 'y':
15760     case 'x':
15761     case 'Y':
15762     case 'l':
15763       return C_RegisterClass;
15764     case 'a':
15765     case 'b':
15766     case 'c':
15767     case 'd':
15768     case 'S':
15769     case 'D':
15770     case 'A':
15771       return C_Register;
15772     case 'I':
15773     case 'J':
15774     case 'K':
15775     case 'L':
15776     case 'M':
15777     case 'N':
15778     case 'G':
15779     case 'C':
15780     case 'e':
15781     case 'Z':
15782       return C_Other;
15783     default:
15784       break;
15785     }
15786   }
15787   return TargetLowering::getConstraintType(Constraint);
15788 }
15789
15790 /// Examine constraint type and operand type and determine a weight value.
15791 /// This object must already have been set up with the operand type
15792 /// and the current alternative constraint selected.
15793 TargetLowering::ConstraintWeight
15794   X86TargetLowering::getSingleConstraintMatchWeight(
15795     AsmOperandInfo &info, const char *constraint) const {
15796   ConstraintWeight weight = CW_Invalid;
15797   Value *CallOperandVal = info.CallOperandVal;
15798     // If we don't have a value, we can't do a match,
15799     // but allow it at the lowest weight.
15800   if (CallOperandVal == NULL)
15801     return CW_Default;
15802   Type *type = CallOperandVal->getType();
15803   // Look at the constraint type.
15804   switch (*constraint) {
15805   default:
15806     weight = TargetLowering::getSingleConstraintMatchWeight(info, constraint);
15807   case 'R':
15808   case 'q':
15809   case 'Q':
15810   case 'a':
15811   case 'b':
15812   case 'c':
15813   case 'd':
15814   case 'S':
15815   case 'D':
15816   case 'A':
15817     if (CallOperandVal->getType()->isIntegerTy())
15818       weight = CW_SpecificReg;
15819     break;
15820   case 'f':
15821   case 't':
15822   case 'u':
15823       if (type->isFloatingPointTy())
15824         weight = CW_SpecificReg;
15825       break;
15826   case 'y':
15827       if (type->isX86_MMXTy() && Subtarget->hasMMX())
15828         weight = CW_SpecificReg;
15829       break;
15830   case 'x':
15831   case 'Y':
15832     if (((type->getPrimitiveSizeInBits() == 128) && Subtarget->hasSSE1()) ||
15833         ((type->getPrimitiveSizeInBits() == 256) && Subtarget->hasAVX()))
15834       weight = CW_Register;
15835     break;
15836   case 'I':
15837     if (ConstantInt *C = dyn_cast<ConstantInt>(info.CallOperandVal)) {
15838       if (C->getZExtValue() <= 31)
15839         weight = CW_Constant;
15840     }
15841     break;
15842   case 'J':
15843     if (ConstantInt *C = dyn_cast<ConstantInt>(CallOperandVal)) {
15844       if (C->getZExtValue() <= 63)
15845         weight = CW_Constant;
15846     }
15847     break;
15848   case 'K':
15849     if (ConstantInt *C = dyn_cast<ConstantInt>(CallOperandVal)) {
15850       if ((C->getSExtValue() >= -0x80) && (C->getSExtValue() <= 0x7f))
15851         weight = CW_Constant;
15852     }
15853     break;
15854   case 'L':
15855     if (ConstantInt *C = dyn_cast<ConstantInt>(CallOperandVal)) {
15856       if ((C->getZExtValue() == 0xff) || (C->getZExtValue() == 0xffff))
15857         weight = CW_Constant;
15858     }
15859     break;
15860   case 'M':
15861     if (ConstantInt *C = dyn_cast<ConstantInt>(CallOperandVal)) {
15862       if (C->getZExtValue() <= 3)
15863         weight = CW_Constant;
15864     }
15865     break;
15866   case 'N':
15867     if (ConstantInt *C = dyn_cast<ConstantInt>(CallOperandVal)) {
15868       if (C->getZExtValue() <= 0xff)
15869         weight = CW_Constant;
15870     }
15871     break;
15872   case 'G':
15873   case 'C':
15874     if (dyn_cast<ConstantFP>(CallOperandVal)) {
15875       weight = CW_Constant;
15876     }
15877     break;
15878   case 'e':
15879     if (ConstantInt *C = dyn_cast<ConstantInt>(CallOperandVal)) {
15880       if ((C->getSExtValue() >= -0x80000000LL) &&
15881           (C->getSExtValue() <= 0x7fffffffLL))
15882         weight = CW_Constant;
15883     }
15884     break;
15885   case 'Z':
15886     if (ConstantInt *C = dyn_cast<ConstantInt>(CallOperandVal)) {
15887       if (C->getZExtValue() <= 0xffffffff)
15888         weight = CW_Constant;
15889     }
15890     break;
15891   }
15892   return weight;
15893 }
15894
15895 /// LowerXConstraint - try to replace an X constraint, which matches anything,
15896 /// with another that has more specific requirements based on the type of the
15897 /// corresponding operand.
15898 const char *X86TargetLowering::
15899 LowerXConstraint(EVT ConstraintVT) const {
15900   // FP X constraints get lowered to SSE1/2 registers if available, otherwise
15901   // 'f' like normal targets.
15902   if (ConstraintVT.isFloatingPoint()) {
15903     if (Subtarget->hasSSE2())
15904       return "Y";
15905     if (Subtarget->hasSSE1())
15906       return "x";
15907   }
15908
15909   return TargetLowering::LowerXConstraint(ConstraintVT);
15910 }
15911
15912 /// LowerAsmOperandForConstraint - Lower the specified operand into the Ops
15913 /// vector.  If it is invalid, don't add anything to Ops.
15914 void X86TargetLowering::LowerAsmOperandForConstraint(SDValue Op,
15915                                                      std::string &Constraint,
15916                                                      std::vector<SDValue>&Ops,
15917                                                      SelectionDAG &DAG) const {
15918   SDValue Result(0, 0);
15919
15920   // Only support length 1 constraints for now.
15921   if (Constraint.length() > 1) return;
15922
15923   char ConstraintLetter = Constraint[0];
15924   switch (ConstraintLetter) {
15925   default: break;
15926   case 'I':
15927     if (ConstantSDNode *C = dyn_cast<ConstantSDNode>(Op)) {
15928       if (C->getZExtValue() <= 31) {
15929         Result = DAG.getTargetConstant(C->getZExtValue(), Op.getValueType());
15930         break;
15931       }
15932     }
15933     return;
15934   case 'J':
15935     if (ConstantSDNode *C = dyn_cast<ConstantSDNode>(Op)) {
15936       if (C->getZExtValue() <= 63) {
15937         Result = DAG.getTargetConstant(C->getZExtValue(), Op.getValueType());
15938         break;
15939       }
15940     }
15941     return;
15942   case 'K':
15943     if (ConstantSDNode *C = dyn_cast<ConstantSDNode>(Op)) {
15944       if ((int8_t)C->getSExtValue() == C->getSExtValue()) {
15945         Result = DAG.getTargetConstant(C->getZExtValue(), Op.getValueType());
15946         break;
15947       }
15948     }
15949     return;
15950   case 'N':
15951     if (ConstantSDNode *C = dyn_cast<ConstantSDNode>(Op)) {
15952       if (C->getZExtValue() <= 255) {
15953         Result = DAG.getTargetConstant(C->getZExtValue(), Op.getValueType());
15954         break;
15955       }
15956     }
15957     return;
15958   case 'e': {
15959     // 32-bit signed value
15960     if (ConstantSDNode *C = dyn_cast<ConstantSDNode>(Op)) {
15961       if (ConstantInt::isValueValidForType(Type::getInt32Ty(*DAG.getContext()),
15962                                            C->getSExtValue())) {
15963         // Widen to 64 bits here to get it sign extended.
15964         Result = DAG.getTargetConstant(C->getSExtValue(), MVT::i64);
15965         break;
15966       }
15967     // FIXME gcc accepts some relocatable values here too, but only in certain
15968     // memory models; it's complicated.
15969     }
15970     return;
15971   }
15972   case 'Z': {
15973     // 32-bit unsigned value
15974     if (ConstantSDNode *C = dyn_cast<ConstantSDNode>(Op)) {
15975       if (ConstantInt::isValueValidForType(Type::getInt32Ty(*DAG.getContext()),
15976                                            C->getZExtValue())) {
15977         Result = DAG.getTargetConstant(C->getZExtValue(), Op.getValueType());
15978         break;
15979       }
15980     }
15981     // FIXME gcc accepts some relocatable values here too, but only in certain
15982     // memory models; it's complicated.
15983     return;
15984   }
15985   case 'i': {
15986     // Literal immediates are always ok.
15987     if (ConstantSDNode *CST = dyn_cast<ConstantSDNode>(Op)) {
15988       // Widen to 64 bits here to get it sign extended.
15989       Result = DAG.getTargetConstant(CST->getSExtValue(), MVT::i64);
15990       break;
15991     }
15992
15993     // In any sort of PIC mode addresses need to be computed at runtime by
15994     // adding in a register or some sort of table lookup.  These can't
15995     // be used as immediates.
15996     if (Subtarget->isPICStyleGOT() || Subtarget->isPICStyleStubPIC())
15997       return;
15998
15999     // If we are in non-pic codegen mode, we allow the address of a global (with
16000     // an optional displacement) to be used with 'i'.
16001     GlobalAddressSDNode *GA = 0;
16002     int64_t Offset = 0;
16003
16004     // Match either (GA), (GA+C), (GA+C1+C2), etc.
16005     while (1) {
16006       if ((GA = dyn_cast<GlobalAddressSDNode>(Op))) {
16007         Offset += GA->getOffset();
16008         break;
16009       } else if (Op.getOpcode() == ISD::ADD) {
16010         if (ConstantSDNode *C = dyn_cast<ConstantSDNode>(Op.getOperand(1))) {
16011           Offset += C->getZExtValue();
16012           Op = Op.getOperand(0);
16013           continue;
16014         }
16015       } else if (Op.getOpcode() == ISD::SUB) {
16016         if (ConstantSDNode *C = dyn_cast<ConstantSDNode>(Op.getOperand(1))) {
16017           Offset += -C->getZExtValue();
16018           Op = Op.getOperand(0);
16019           continue;
16020         }
16021       }
16022
16023       // Otherwise, this isn't something we can handle, reject it.
16024       return;
16025     }
16026
16027     const GlobalValue *GV = GA->getGlobal();
16028     // If we require an extra load to get this address, as in PIC mode, we
16029     // can't accept it.
16030     if (isGlobalStubReference(Subtarget->ClassifyGlobalReference(GV,
16031                                                         getTargetMachine())))
16032       return;
16033
16034     Result = DAG.getTargetGlobalAddress(GV, Op.getDebugLoc(),
16035                                         GA->getValueType(0), Offset);
16036     break;
16037   }
16038   }
16039
16040   if (Result.getNode()) {
16041     Ops.push_back(Result);
16042     return;
16043   }
16044   return TargetLowering::LowerAsmOperandForConstraint(Op, Constraint, Ops, DAG);
16045 }
16046
16047 std::pair<unsigned, const TargetRegisterClass*>
16048 X86TargetLowering::getRegForInlineAsmConstraint(const std::string &Constraint,
16049                                                 EVT VT) const {
16050   // First, see if this is a constraint that directly corresponds to an LLVM
16051   // register class.
16052   if (Constraint.size() == 1) {
16053     // GCC Constraint Letters
16054     switch (Constraint[0]) {
16055     default: break;
16056       // TODO: Slight differences here in allocation order and leaving
16057       // RIP in the class. Do they matter any more here than they do
16058       // in the normal allocation?
16059     case 'q':   // GENERAL_REGS in 64-bit mode, Q_REGS in 32-bit mode.
16060       if (Subtarget->is64Bit()) {
16061         if (VT == MVT::i32 || VT == MVT::f32)
16062           return std::make_pair(0U, &X86::GR32RegClass);
16063         if (VT == MVT::i16)
16064           return std::make_pair(0U, &X86::GR16RegClass);
16065         if (VT == MVT::i8 || VT == MVT::i1)
16066           return std::make_pair(0U, &X86::GR8RegClass);
16067         if (VT == MVT::i64 || VT == MVT::f64)
16068           return std::make_pair(0U, &X86::GR64RegClass);
16069         break;
16070       }
16071       // 32-bit fallthrough
16072     case 'Q':   // Q_REGS
16073       if (VT == MVT::i32 || VT == MVT::f32)
16074         return std::make_pair(0U, &X86::GR32_ABCDRegClass);
16075       if (VT == MVT::i16)
16076         return std::make_pair(0U, &X86::GR16_ABCDRegClass);
16077       if (VT == MVT::i8 || VT == MVT::i1)
16078         return std::make_pair(0U, &X86::GR8_ABCD_LRegClass);
16079       if (VT == MVT::i64)
16080         return std::make_pair(0U, &X86::GR64_ABCDRegClass);
16081       break;
16082     case 'r':   // GENERAL_REGS
16083     case 'l':   // INDEX_REGS
16084       if (VT == MVT::i8 || VT == MVT::i1)
16085         return std::make_pair(0U, &X86::GR8RegClass);
16086       if (VT == MVT::i16)
16087         return std::make_pair(0U, &X86::GR16RegClass);
16088       if (VT == MVT::i32 || VT == MVT::f32 || !Subtarget->is64Bit())
16089         return std::make_pair(0U, &X86::GR32RegClass);
16090       return std::make_pair(0U, &X86::GR64RegClass);
16091     case 'R':   // LEGACY_REGS
16092       if (VT == MVT::i8 || VT == MVT::i1)
16093         return std::make_pair(0U, &X86::GR8_NOREXRegClass);
16094       if (VT == MVT::i16)
16095         return std::make_pair(0U, &X86::GR16_NOREXRegClass);
16096       if (VT == MVT::i32 || !Subtarget->is64Bit())
16097         return std::make_pair(0U, &X86::GR32_NOREXRegClass);
16098       return std::make_pair(0U, &X86::GR64_NOREXRegClass);
16099     case 'f':  // FP Stack registers.
16100       // If SSE is enabled for this VT, use f80 to ensure the isel moves the
16101       // value to the correct fpstack register class.
16102       if (VT == MVT::f32 && !isScalarFPTypeInSSEReg(VT))
16103         return std::make_pair(0U, &X86::RFP32RegClass);
16104       if (VT == MVT::f64 && !isScalarFPTypeInSSEReg(VT))
16105         return std::make_pair(0U, &X86::RFP64RegClass);
16106       return std::make_pair(0U, &X86::RFP80RegClass);
16107     case 'y':   // MMX_REGS if MMX allowed.
16108       if (!Subtarget->hasMMX()) break;
16109       return std::make_pair(0U, &X86::VR64RegClass);
16110     case 'Y':   // SSE_REGS if SSE2 allowed
16111       if (!Subtarget->hasSSE2()) break;
16112       // FALL THROUGH.
16113     case 'x':   // SSE_REGS if SSE1 allowed or AVX_REGS if AVX allowed
16114       if (!Subtarget->hasSSE1()) break;
16115
16116       switch (VT.getSimpleVT().SimpleTy) {
16117       default: break;
16118       // Scalar SSE types.
16119       case MVT::f32:
16120       case MVT::i32:
16121         return std::make_pair(0U, &X86::FR32RegClass);
16122       case MVT::f64:
16123       case MVT::i64:
16124         return std::make_pair(0U, &X86::FR64RegClass);
16125       // Vector types.
16126       case MVT::v16i8:
16127       case MVT::v8i16:
16128       case MVT::v4i32:
16129       case MVT::v2i64:
16130       case MVT::v4f32:
16131       case MVT::v2f64:
16132         return std::make_pair(0U, &X86::VR128RegClass);
16133       // AVX types.
16134       case MVT::v32i8:
16135       case MVT::v16i16:
16136       case MVT::v8i32:
16137       case MVT::v4i64:
16138       case MVT::v8f32:
16139       case MVT::v4f64:
16140         return std::make_pair(0U, &X86::VR256RegClass);
16141       }
16142       break;
16143     }
16144   }
16145
16146   // Use the default implementation in TargetLowering to convert the register
16147   // constraint into a member of a register class.
16148   std::pair<unsigned, const TargetRegisterClass*> Res;
16149   Res = TargetLowering::getRegForInlineAsmConstraint(Constraint, VT);
16150
16151   // Not found as a standard register?
16152   if (Res.second == 0) {
16153     // Map st(0) -> st(7) -> ST0
16154     if (Constraint.size() == 7 && Constraint[0] == '{' &&
16155         tolower(Constraint[1]) == 's' &&
16156         tolower(Constraint[2]) == 't' &&
16157         Constraint[3] == '(' &&
16158         (Constraint[4] >= '0' && Constraint[4] <= '7') &&
16159         Constraint[5] == ')' &&
16160         Constraint[6] == '}') {
16161
16162       Res.first = X86::ST0+Constraint[4]-'0';
16163       Res.second = &X86::RFP80RegClass;
16164       return Res;
16165     }
16166
16167     // GCC allows "st(0)" to be called just plain "st".
16168     if (StringRef("{st}").equals_lower(Constraint)) {
16169       Res.first = X86::ST0;
16170       Res.second = &X86::RFP80RegClass;
16171       return Res;
16172     }
16173
16174     // flags -> EFLAGS
16175     if (StringRef("{flags}").equals_lower(Constraint)) {
16176       Res.first = X86::EFLAGS;
16177       Res.second = &X86::CCRRegClass;
16178       return Res;
16179     }
16180
16181     // 'A' means EAX + EDX.
16182     if (Constraint == "A") {
16183       Res.first = X86::EAX;
16184       Res.second = &X86::GR32_ADRegClass;
16185       return Res;
16186     }
16187     return Res;
16188   }
16189
16190   // Otherwise, check to see if this is a register class of the wrong value
16191   // type.  For example, we want to map "{ax},i32" -> {eax}, we don't want it to
16192   // turn into {ax},{dx}.
16193   if (Res.second->hasType(VT))
16194     return Res;   // Correct type already, nothing to do.
16195
16196   // All of the single-register GCC register classes map their values onto
16197   // 16-bit register pieces "ax","dx","cx","bx","si","di","bp","sp".  If we
16198   // really want an 8-bit or 32-bit register, map to the appropriate register
16199   // class and return the appropriate register.
16200   if (Res.second == &X86::GR16RegClass) {
16201     if (VT == MVT::i8) {
16202       unsigned DestReg = 0;
16203       switch (Res.first) {
16204       default: break;
16205       case X86::AX: DestReg = X86::AL; break;
16206       case X86::DX: DestReg = X86::DL; break;
16207       case X86::CX: DestReg = X86::CL; break;
16208       case X86::BX: DestReg = X86::BL; break;
16209       }
16210       if (DestReg) {
16211         Res.first = DestReg;
16212         Res.second = &X86::GR8RegClass;
16213       }
16214     } else if (VT == MVT::i32) {
16215       unsigned DestReg = 0;
16216       switch (Res.first) {
16217       default: break;
16218       case X86::AX: DestReg = X86::EAX; break;
16219       case X86::DX: DestReg = X86::EDX; break;
16220       case X86::CX: DestReg = X86::ECX; break;
16221       case X86::BX: DestReg = X86::EBX; break;
16222       case X86::SI: DestReg = X86::ESI; break;
16223       case X86::DI: DestReg = X86::EDI; break;
16224       case X86::BP: DestReg = X86::EBP; break;
16225       case X86::SP: DestReg = X86::ESP; break;
16226       }
16227       if (DestReg) {
16228         Res.first = DestReg;
16229         Res.second = &X86::GR32RegClass;
16230       }
16231     } else if (VT == MVT::i64) {
16232       unsigned DestReg = 0;
16233       switch (Res.first) {
16234       default: break;
16235       case X86::AX: DestReg = X86::RAX; break;
16236       case X86::DX: DestReg = X86::RDX; break;
16237       case X86::CX: DestReg = X86::RCX; break;
16238       case X86::BX: DestReg = X86::RBX; break;
16239       case X86::SI: DestReg = X86::RSI; break;
16240       case X86::DI: DestReg = X86::RDI; break;
16241       case X86::BP: DestReg = X86::RBP; break;
16242       case X86::SP: DestReg = X86::RSP; break;
16243       }
16244       if (DestReg) {
16245         Res.first = DestReg;
16246         Res.second = &X86::GR64RegClass;
16247       }
16248     }
16249   } else if (Res.second == &X86::FR32RegClass ||
16250              Res.second == &X86::FR64RegClass ||
16251              Res.second == &X86::VR128RegClass) {
16252     // Handle references to XMM physical registers that got mapped into the
16253     // wrong class.  This can happen with constraints like {xmm0} where the
16254     // target independent register mapper will just pick the first match it can
16255     // find, ignoring the required type.
16256
16257     if (VT == MVT::f32 || VT == MVT::i32)
16258       Res.second = &X86::FR32RegClass;
16259     else if (VT == MVT::f64 || VT == MVT::i64)
16260       Res.second = &X86::FR64RegClass;
16261     else if (X86::VR128RegClass.hasType(VT))
16262       Res.second = &X86::VR128RegClass;
16263     else if (X86::VR256RegClass.hasType(VT))
16264       Res.second = &X86::VR256RegClass;
16265   }
16266
16267   return Res;
16268 }