[X86] Factor out new helper getPSHUFB
[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 "Utils/X86ShuffleDecode.h"
18 #include "X86CallingConv.h"
19 #include "X86InstrBuilder.h"
20 #include "X86MachineFunctionInfo.h"
21 #include "X86TargetMachine.h"
22 #include "X86TargetObjectFile.h"
23 #include "llvm/ADT/SmallSet.h"
24 #include "llvm/ADT/Statistic.h"
25 #include "llvm/ADT/StringExtras.h"
26 #include "llvm/ADT/VariadicFunction.h"
27 #include "llvm/CodeGen/IntrinsicLowering.h"
28 #include "llvm/CodeGen/MachineFrameInfo.h"
29 #include "llvm/CodeGen/MachineFunction.h"
30 #include "llvm/CodeGen/MachineInstrBuilder.h"
31 #include "llvm/CodeGen/MachineJumpTableInfo.h"
32 #include "llvm/CodeGen/MachineModuleInfo.h"
33 #include "llvm/CodeGen/MachineRegisterInfo.h"
34 #include "llvm/IR/CallSite.h"
35 #include "llvm/IR/CallingConv.h"
36 #include "llvm/IR/Constants.h"
37 #include "llvm/IR/DerivedTypes.h"
38 #include "llvm/IR/Function.h"
39 #include "llvm/IR/GlobalAlias.h"
40 #include "llvm/IR/GlobalVariable.h"
41 #include "llvm/IR/Instructions.h"
42 #include "llvm/IR/Intrinsics.h"
43 #include "llvm/MC/MCAsmInfo.h"
44 #include "llvm/MC/MCContext.h"
45 #include "llvm/MC/MCExpr.h"
46 #include "llvm/MC/MCSymbol.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 #include <cctype>
53 using namespace llvm;
54
55 STATISTIC(NumTailCalls, "Number of tail calls");
56
57 // Forward declarations.
58 static SDValue getMOVL(SelectionDAG &DAG, SDLoc dl, EVT VT, SDValue V1,
59                        SDValue V2);
60
61 static SDValue ExtractSubVector(SDValue Vec, unsigned IdxVal,
62                                 SelectionDAG &DAG, SDLoc dl,
63                                 unsigned vectorWidth) {
64   assert((vectorWidth == 128 || vectorWidth == 256) &&
65          "Unsupported vector width");
66   EVT VT = Vec.getValueType();
67   EVT ElVT = VT.getVectorElementType();
68   unsigned Factor = VT.getSizeInBits()/vectorWidth;
69   EVT ResultVT = EVT::getVectorVT(*DAG.getContext(), ElVT,
70                                   VT.getVectorNumElements()/Factor);
71
72   // Extract from UNDEF is UNDEF.
73   if (Vec.getOpcode() == ISD::UNDEF)
74     return DAG.getUNDEF(ResultVT);
75
76   // Extract the relevant vectorWidth bits.  Generate an EXTRACT_SUBVECTOR
77   unsigned ElemsPerChunk = vectorWidth / ElVT.getSizeInBits();
78
79   // This is the index of the first element of the vectorWidth-bit chunk
80   // we want.
81   unsigned NormalizedIdxVal = (((IdxVal * ElVT.getSizeInBits()) / vectorWidth)
82                                * ElemsPerChunk);
83
84   // If the input is a buildvector just emit a smaller one.
85   if (Vec.getOpcode() == ISD::BUILD_VECTOR)
86     return DAG.getNode(ISD::BUILD_VECTOR, dl, ResultVT,
87                        Vec->op_begin()+NormalizedIdxVal, ElemsPerChunk);
88
89   SDValue VecIdx = DAG.getIntPtrConstant(NormalizedIdxVal);
90   SDValue Result = DAG.getNode(ISD::EXTRACT_SUBVECTOR, dl, ResultVT, Vec,
91                                VecIdx);
92
93   return Result;
94
95 }
96 /// Generate a DAG to grab 128-bits from a vector > 128 bits.  This
97 /// sets things up to match to an AVX VEXTRACTF128 / VEXTRACTI128
98 /// or AVX-512 VEXTRACTF32x4 / VEXTRACTI32x4
99 /// instructions or a simple subregister reference. Idx is an index in the
100 /// 128 bits we want.  It need not be aligned to a 128-bit bounday.  That makes
101 /// lowering EXTRACT_VECTOR_ELT operations easier.
102 static SDValue Extract128BitVector(SDValue Vec, unsigned IdxVal,
103                                    SelectionDAG &DAG, SDLoc dl) {
104   assert((Vec.getValueType().is256BitVector() ||
105           Vec.getValueType().is512BitVector()) && "Unexpected vector size!");
106   return ExtractSubVector(Vec, IdxVal, DAG, dl, 128);
107 }
108
109 /// Generate a DAG to grab 256-bits from a 512-bit vector.
110 static SDValue Extract256BitVector(SDValue Vec, unsigned IdxVal,
111                                    SelectionDAG &DAG, SDLoc dl) {
112   assert(Vec.getValueType().is512BitVector() && "Unexpected vector size!");
113   return ExtractSubVector(Vec, IdxVal, DAG, dl, 256);
114 }
115
116 static SDValue InsertSubVector(SDValue Result, SDValue Vec,
117                                unsigned IdxVal, SelectionDAG &DAG,
118                                SDLoc dl, unsigned vectorWidth) {
119   assert((vectorWidth == 128 || vectorWidth == 256) &&
120          "Unsupported vector width");
121   // Inserting UNDEF is Result
122   if (Vec.getOpcode() == ISD::UNDEF)
123     return Result;
124   EVT VT = Vec.getValueType();
125   EVT ElVT = VT.getVectorElementType();
126   EVT ResultVT = Result.getValueType();
127
128   // Insert the relevant vectorWidth bits.
129   unsigned ElemsPerChunk = vectorWidth/ElVT.getSizeInBits();
130
131   // This is the index of the first element of the vectorWidth-bit chunk
132   // we want.
133   unsigned NormalizedIdxVal = (((IdxVal * ElVT.getSizeInBits())/vectorWidth)
134                                * ElemsPerChunk);
135
136   SDValue VecIdx = DAG.getIntPtrConstant(NormalizedIdxVal);
137   return DAG.getNode(ISD::INSERT_SUBVECTOR, dl, ResultVT, Result, Vec,
138                      VecIdx);
139 }
140 /// Generate a DAG to put 128-bits into a vector > 128 bits.  This
141 /// sets things up to match to an AVX VINSERTF128/VINSERTI128 or
142 /// AVX-512 VINSERTF32x4/VINSERTI32x4 instructions or a
143 /// simple superregister reference.  Idx is an index in the 128 bits
144 /// we want.  It need not be aligned to a 128-bit bounday.  That makes
145 /// lowering INSERT_VECTOR_ELT operations easier.
146 static SDValue Insert128BitVector(SDValue Result, SDValue Vec,
147                                   unsigned IdxVal, SelectionDAG &DAG,
148                                   SDLoc dl) {
149   assert(Vec.getValueType().is128BitVector() && "Unexpected vector size!");
150   return InsertSubVector(Result, Vec, IdxVal, DAG, dl, 128);
151 }
152
153 static SDValue Insert256BitVector(SDValue Result, SDValue Vec,
154                                   unsigned IdxVal, SelectionDAG &DAG,
155                                   SDLoc dl) {
156   assert(Vec.getValueType().is256BitVector() && "Unexpected vector size!");
157   return InsertSubVector(Result, Vec, IdxVal, DAG, dl, 256);
158 }
159
160 /// Concat two 128-bit vectors into a 256 bit vector using VINSERTF128
161 /// instructions. This is used because creating CONCAT_VECTOR nodes of
162 /// BUILD_VECTORS returns a larger BUILD_VECTOR while we're trying to lower
163 /// large BUILD_VECTORS.
164 static SDValue Concat128BitVectors(SDValue V1, SDValue V2, EVT VT,
165                                    unsigned NumElems, SelectionDAG &DAG,
166                                    SDLoc dl) {
167   SDValue V = Insert128BitVector(DAG.getUNDEF(VT), V1, 0, DAG, dl);
168   return Insert128BitVector(V, V2, NumElems/2, DAG, dl);
169 }
170
171 static SDValue Concat256BitVectors(SDValue V1, SDValue V2, EVT VT,
172                                    unsigned NumElems, SelectionDAG &DAG,
173                                    SDLoc dl) {
174   SDValue V = Insert256BitVector(DAG.getUNDEF(VT), V1, 0, DAG, dl);
175   return Insert256BitVector(V, V2, NumElems/2, DAG, dl);
176 }
177
178 static TargetLoweringObjectFile *createTLOF(X86TargetMachine &TM) {
179   const X86Subtarget *Subtarget = &TM.getSubtarget<X86Subtarget>();
180   bool is64Bit = Subtarget->is64Bit();
181
182   if (Subtarget->isTargetMacho()) {
183     if (is64Bit)
184       return new X86_64MachoTargetObjectFile();
185     return new TargetLoweringObjectFileMachO();
186   }
187
188   if (Subtarget->isTargetLinux())
189     return new X86LinuxTargetObjectFile();
190   if (Subtarget->isTargetELF())
191     return new TargetLoweringObjectFileELF();
192   if (Subtarget->isTargetWindows())
193     return new X86WindowsTargetObjectFile();
194   if (Subtarget->isTargetCOFF())
195     return new TargetLoweringObjectFileCOFF();
196   llvm_unreachable("unknown subtarget type");
197 }
198
199 X86TargetLowering::X86TargetLowering(X86TargetMachine &TM)
200   : TargetLowering(TM, createTLOF(TM)) {
201   Subtarget = &TM.getSubtarget<X86Subtarget>();
202   X86ScalarSSEf64 = Subtarget->hasSSE2();
203   X86ScalarSSEf32 = Subtarget->hasSSE1();
204   TD = getDataLayout();
205
206   resetOperationActions();
207 }
208
209 void X86TargetLowering::resetOperationActions() {
210   const TargetMachine &TM = getTargetMachine();
211   static bool FirstTimeThrough = true;
212
213   // If none of the target options have changed, then we don't need to reset the
214   // operation actions.
215   if (!FirstTimeThrough && TO == TM.Options) return;
216
217   if (!FirstTimeThrough) {
218     // Reinitialize the actions.
219     initActions();
220     FirstTimeThrough = false;
221   }
222
223   TO = TM.Options;
224
225   // Set up the TargetLowering object.
226   static const MVT IntVTs[] = { MVT::i8, MVT::i16, MVT::i32, MVT::i64 };
227
228   // X86 is weird, it always uses i8 for shift amounts and setcc results.
229   setBooleanContents(ZeroOrOneBooleanContent);
230   // X86-SSE is even stranger. It uses -1 or 0 for vector masks.
231   setBooleanVectorContents(ZeroOrNegativeOneBooleanContent);
232
233   // For 64-bit since we have so many registers use the ILP scheduler, for
234   // 32-bit code use the register pressure specific scheduling.
235   // For Atom, always use ILP scheduling.
236   if (Subtarget->isAtom())
237     setSchedulingPreference(Sched::ILP);
238   else if (Subtarget->is64Bit())
239     setSchedulingPreference(Sched::ILP);
240   else
241     setSchedulingPreference(Sched::RegPressure);
242   const X86RegisterInfo *RegInfo =
243     static_cast<const X86RegisterInfo*>(TM.getRegisterInfo());
244   setStackPointerRegisterToSaveRestore(RegInfo->getStackRegister());
245
246   // Bypass expensive divides on Atom when compiling with O2
247   if (Subtarget->hasSlowDivide() && TM.getOptLevel() >= CodeGenOpt::Default) {
248     addBypassSlowDiv(32, 8);
249     if (Subtarget->is64Bit())
250       addBypassSlowDiv(64, 16);
251   }
252
253   if (Subtarget->isTargetWindows() && !Subtarget->isTargetCygMing()) {
254     // Setup Windows compiler runtime calls.
255     setLibcallName(RTLIB::SDIV_I64, "_alldiv");
256     setLibcallName(RTLIB::UDIV_I64, "_aulldiv");
257     setLibcallName(RTLIB::SREM_I64, "_allrem");
258     setLibcallName(RTLIB::UREM_I64, "_aullrem");
259     setLibcallName(RTLIB::MUL_I64, "_allmul");
260     setLibcallCallingConv(RTLIB::SDIV_I64, CallingConv::X86_StdCall);
261     setLibcallCallingConv(RTLIB::UDIV_I64, CallingConv::X86_StdCall);
262     setLibcallCallingConv(RTLIB::SREM_I64, CallingConv::X86_StdCall);
263     setLibcallCallingConv(RTLIB::UREM_I64, CallingConv::X86_StdCall);
264     setLibcallCallingConv(RTLIB::MUL_I64, CallingConv::X86_StdCall);
265
266     // The _ftol2 runtime function has an unusual calling conv, which
267     // is modeled by a special pseudo-instruction.
268     setLibcallName(RTLIB::FPTOUINT_F64_I64, 0);
269     setLibcallName(RTLIB::FPTOUINT_F32_I64, 0);
270     setLibcallName(RTLIB::FPTOUINT_F64_I32, 0);
271     setLibcallName(RTLIB::FPTOUINT_F32_I32, 0);
272   }
273
274   if (Subtarget->isTargetDarwin()) {
275     // Darwin should use _setjmp/_longjmp instead of setjmp/longjmp.
276     setUseUnderscoreSetJmp(false);
277     setUseUnderscoreLongJmp(false);
278   } else if (Subtarget->isTargetMingw()) {
279     // MS runtime is weird: it exports _setjmp, but longjmp!
280     setUseUnderscoreSetJmp(true);
281     setUseUnderscoreLongJmp(false);
282   } else {
283     setUseUnderscoreSetJmp(true);
284     setUseUnderscoreLongJmp(true);
285   }
286
287   // Set up the register classes.
288   addRegisterClass(MVT::i8, &X86::GR8RegClass);
289   addRegisterClass(MVT::i16, &X86::GR16RegClass);
290   addRegisterClass(MVT::i32, &X86::GR32RegClass);
291   if (Subtarget->is64Bit())
292     addRegisterClass(MVT::i64, &X86::GR64RegClass);
293
294   setLoadExtAction(ISD::SEXTLOAD, MVT::i1, Promote);
295
296   // We don't accept any truncstore of integer registers.
297   setTruncStoreAction(MVT::i64, MVT::i32, Expand);
298   setTruncStoreAction(MVT::i64, MVT::i16, Expand);
299   setTruncStoreAction(MVT::i64, MVT::i8 , Expand);
300   setTruncStoreAction(MVT::i32, MVT::i16, Expand);
301   setTruncStoreAction(MVT::i32, MVT::i8 , Expand);
302   setTruncStoreAction(MVT::i16, MVT::i8,  Expand);
303
304   // SETOEQ and SETUNE require checking two conditions.
305   setCondCodeAction(ISD::SETOEQ, MVT::f32, Expand);
306   setCondCodeAction(ISD::SETOEQ, MVT::f64, Expand);
307   setCondCodeAction(ISD::SETOEQ, MVT::f80, Expand);
308   setCondCodeAction(ISD::SETUNE, MVT::f32, Expand);
309   setCondCodeAction(ISD::SETUNE, MVT::f64, Expand);
310   setCondCodeAction(ISD::SETUNE, MVT::f80, Expand);
311
312   // Promote all UINT_TO_FP to larger SINT_TO_FP's, as X86 doesn't have this
313   // operation.
314   setOperationAction(ISD::UINT_TO_FP       , MVT::i1   , Promote);
315   setOperationAction(ISD::UINT_TO_FP       , MVT::i8   , Promote);
316   setOperationAction(ISD::UINT_TO_FP       , MVT::i16  , Promote);
317
318   if (Subtarget->is64Bit()) {
319     setOperationAction(ISD::UINT_TO_FP     , MVT::i32  , Promote);
320     setOperationAction(ISD::UINT_TO_FP     , MVT::i64  , Custom);
321   } else if (!TM.Options.UseSoftFloat) {
322     // We have an algorithm for SSE2->double, and we turn this into a
323     // 64-bit FILD followed by conditional FADD for other targets.
324     setOperationAction(ISD::UINT_TO_FP     , MVT::i64  , Custom);
325     // We have an algorithm for SSE2, and we turn this into a 64-bit
326     // FILD for other targets.
327     setOperationAction(ISD::UINT_TO_FP     , MVT::i32  , Custom);
328   }
329
330   // Promote i1/i8 SINT_TO_FP to larger SINT_TO_FP's, as X86 doesn't have
331   // this operation.
332   setOperationAction(ISD::SINT_TO_FP       , MVT::i1   , Promote);
333   setOperationAction(ISD::SINT_TO_FP       , MVT::i8   , Promote);
334
335   if (!TM.Options.UseSoftFloat) {
336     // SSE has no i16 to fp conversion, only i32
337     if (X86ScalarSSEf32) {
338       setOperationAction(ISD::SINT_TO_FP     , MVT::i16  , Promote);
339       // f32 and f64 cases are Legal, f80 case is not
340       setOperationAction(ISD::SINT_TO_FP     , MVT::i32  , Custom);
341     } else {
342       setOperationAction(ISD::SINT_TO_FP     , MVT::i16  , Custom);
343       setOperationAction(ISD::SINT_TO_FP     , MVT::i32  , Custom);
344     }
345   } else {
346     setOperationAction(ISD::SINT_TO_FP     , MVT::i16  , Promote);
347     setOperationAction(ISD::SINT_TO_FP     , MVT::i32  , Promote);
348   }
349
350   // In 32-bit mode these are custom lowered.  In 64-bit mode F32 and F64
351   // are Legal, f80 is custom lowered.
352   setOperationAction(ISD::FP_TO_SINT     , MVT::i64  , Custom);
353   setOperationAction(ISD::SINT_TO_FP     , MVT::i64  , Custom);
354
355   // Promote i1/i8 FP_TO_SINT to larger FP_TO_SINTS's, as X86 doesn't have
356   // this operation.
357   setOperationAction(ISD::FP_TO_SINT       , MVT::i1   , Promote);
358   setOperationAction(ISD::FP_TO_SINT       , MVT::i8   , Promote);
359
360   if (X86ScalarSSEf32) {
361     setOperationAction(ISD::FP_TO_SINT     , MVT::i16  , Promote);
362     // f32 and f64 cases are Legal, f80 case is not
363     setOperationAction(ISD::FP_TO_SINT     , MVT::i32  , Custom);
364   } else {
365     setOperationAction(ISD::FP_TO_SINT     , MVT::i16  , Custom);
366     setOperationAction(ISD::FP_TO_SINT     , MVT::i32  , Custom);
367   }
368
369   // Handle FP_TO_UINT by promoting the destination to a larger signed
370   // conversion.
371   setOperationAction(ISD::FP_TO_UINT       , MVT::i1   , Promote);
372   setOperationAction(ISD::FP_TO_UINT       , MVT::i8   , Promote);
373   setOperationAction(ISD::FP_TO_UINT       , MVT::i16  , Promote);
374
375   if (Subtarget->is64Bit()) {
376     setOperationAction(ISD::FP_TO_UINT     , MVT::i64  , Expand);
377     setOperationAction(ISD::FP_TO_UINT     , MVT::i32  , Promote);
378   } else if (!TM.Options.UseSoftFloat) {
379     // Since AVX is a superset of SSE3, only check for SSE here.
380     if (Subtarget->hasSSE1() && !Subtarget->hasSSE3())
381       // Expand FP_TO_UINT into a select.
382       // FIXME: We would like to use a Custom expander here eventually to do
383       // the optimal thing for SSE vs. the default expansion in the legalizer.
384       setOperationAction(ISD::FP_TO_UINT   , MVT::i32  , Expand);
385     else
386       // With SSE3 we can use fisttpll to convert to a signed i64; without
387       // SSE, we're stuck with a fistpll.
388       setOperationAction(ISD::FP_TO_UINT   , MVT::i32  , Custom);
389   }
390
391   if (isTargetFTOL()) {
392     // Use the _ftol2 runtime function, which has a pseudo-instruction
393     // to handle its weird calling convention.
394     setOperationAction(ISD::FP_TO_UINT     , MVT::i64  , Custom);
395   }
396
397   // TODO: when we have SSE, these could be more efficient, by using movd/movq.
398   if (!X86ScalarSSEf64) {
399     setOperationAction(ISD::BITCAST        , MVT::f32  , Expand);
400     setOperationAction(ISD::BITCAST        , MVT::i32  , Expand);
401     if (Subtarget->is64Bit()) {
402       setOperationAction(ISD::BITCAST      , MVT::f64  , Expand);
403       // Without SSE, i64->f64 goes through memory.
404       setOperationAction(ISD::BITCAST      , MVT::i64  , Expand);
405     }
406   }
407
408   // Scalar integer divide and remainder are lowered to use operations that
409   // produce two results, to match the available instructions. This exposes
410   // the two-result form to trivial CSE, which is able to combine x/y and x%y
411   // into a single instruction.
412   //
413   // Scalar integer multiply-high is also lowered to use two-result
414   // operations, to match the available instructions. However, plain multiply
415   // (low) operations are left as Legal, as there are single-result
416   // instructions for this in x86. Using the two-result multiply instructions
417   // when both high and low results are needed must be arranged by dagcombine.
418   for (unsigned i = 0; i != array_lengthof(IntVTs); ++i) {
419     MVT VT = IntVTs[i];
420     setOperationAction(ISD::MULHS, VT, Expand);
421     setOperationAction(ISD::MULHU, VT, Expand);
422     setOperationAction(ISD::SDIV, VT, Expand);
423     setOperationAction(ISD::UDIV, VT, Expand);
424     setOperationAction(ISD::SREM, VT, Expand);
425     setOperationAction(ISD::UREM, VT, Expand);
426
427     // Add/Sub overflow ops with MVT::Glues are lowered to EFLAGS dependences.
428     setOperationAction(ISD::ADDC, VT, Custom);
429     setOperationAction(ISD::ADDE, VT, Custom);
430     setOperationAction(ISD::SUBC, VT, Custom);
431     setOperationAction(ISD::SUBE, VT, Custom);
432   }
433
434   setOperationAction(ISD::BR_JT            , MVT::Other, Expand);
435   setOperationAction(ISD::BRCOND           , MVT::Other, Custom);
436   setOperationAction(ISD::BR_CC            , MVT::f32,   Expand);
437   setOperationAction(ISD::BR_CC            , MVT::f64,   Expand);
438   setOperationAction(ISD::BR_CC            , MVT::f80,   Expand);
439   setOperationAction(ISD::BR_CC            , MVT::i8,    Expand);
440   setOperationAction(ISD::BR_CC            , MVT::i16,   Expand);
441   setOperationAction(ISD::BR_CC            , MVT::i32,   Expand);
442   setOperationAction(ISD::BR_CC            , MVT::i64,   Expand);
443   setOperationAction(ISD::SELECT_CC        , MVT::Other, Expand);
444   if (Subtarget->is64Bit())
445     setOperationAction(ISD::SIGN_EXTEND_INREG, MVT::i32, Legal);
446   setOperationAction(ISD::SIGN_EXTEND_INREG, MVT::i16  , Legal);
447   setOperationAction(ISD::SIGN_EXTEND_INREG, MVT::i8   , Legal);
448   setOperationAction(ISD::SIGN_EXTEND_INREG, MVT::i1   , Expand);
449   setOperationAction(ISD::FP_ROUND_INREG   , MVT::f32  , Expand);
450   setOperationAction(ISD::FREM             , MVT::f32  , Expand);
451   setOperationAction(ISD::FREM             , MVT::f64  , Expand);
452   setOperationAction(ISD::FREM             , MVT::f80  , Expand);
453   setOperationAction(ISD::FLT_ROUNDS_      , MVT::i32  , Custom);
454
455   // Promote the i8 variants and force them on up to i32 which has a shorter
456   // encoding.
457   setOperationAction(ISD::CTTZ             , MVT::i8   , Promote);
458   AddPromotedToType (ISD::CTTZ             , MVT::i8   , MVT::i32);
459   setOperationAction(ISD::CTTZ_ZERO_UNDEF  , MVT::i8   , Promote);
460   AddPromotedToType (ISD::CTTZ_ZERO_UNDEF  , MVT::i8   , MVT::i32);
461   if (Subtarget->hasBMI()) {
462     setOperationAction(ISD::CTTZ_ZERO_UNDEF, MVT::i16  , Expand);
463     setOperationAction(ISD::CTTZ_ZERO_UNDEF, MVT::i32  , Expand);
464     if (Subtarget->is64Bit())
465       setOperationAction(ISD::CTTZ_ZERO_UNDEF, MVT::i64, Expand);
466   } else {
467     setOperationAction(ISD::CTTZ           , MVT::i16  , Custom);
468     setOperationAction(ISD::CTTZ           , MVT::i32  , Custom);
469     if (Subtarget->is64Bit())
470       setOperationAction(ISD::CTTZ         , MVT::i64  , Custom);
471   }
472
473   if (Subtarget->hasLZCNT()) {
474     // When promoting the i8 variants, force them to i32 for a shorter
475     // encoding.
476     setOperationAction(ISD::CTLZ           , MVT::i8   , Promote);
477     AddPromotedToType (ISD::CTLZ           , MVT::i8   , MVT::i32);
478     setOperationAction(ISD::CTLZ_ZERO_UNDEF, MVT::i8   , Promote);
479     AddPromotedToType (ISD::CTLZ_ZERO_UNDEF, MVT::i8   , MVT::i32);
480     setOperationAction(ISD::CTLZ_ZERO_UNDEF, MVT::i16  , Expand);
481     setOperationAction(ISD::CTLZ_ZERO_UNDEF, MVT::i32  , Expand);
482     if (Subtarget->is64Bit())
483       setOperationAction(ISD::CTLZ_ZERO_UNDEF, MVT::i64, Expand);
484   } else {
485     setOperationAction(ISD::CTLZ           , MVT::i8   , Custom);
486     setOperationAction(ISD::CTLZ           , MVT::i16  , Custom);
487     setOperationAction(ISD::CTLZ           , MVT::i32  , Custom);
488     setOperationAction(ISD::CTLZ_ZERO_UNDEF, MVT::i8   , Custom);
489     setOperationAction(ISD::CTLZ_ZERO_UNDEF, MVT::i16  , Custom);
490     setOperationAction(ISD::CTLZ_ZERO_UNDEF, MVT::i32  , Custom);
491     if (Subtarget->is64Bit()) {
492       setOperationAction(ISD::CTLZ         , MVT::i64  , Custom);
493       setOperationAction(ISD::CTLZ_ZERO_UNDEF, MVT::i64, Custom);
494     }
495   }
496
497   if (Subtarget->hasPOPCNT()) {
498     setOperationAction(ISD::CTPOP          , MVT::i8   , Promote);
499   } else {
500     setOperationAction(ISD::CTPOP          , MVT::i8   , Expand);
501     setOperationAction(ISD::CTPOP          , MVT::i16  , Expand);
502     setOperationAction(ISD::CTPOP          , MVT::i32  , Expand);
503     if (Subtarget->is64Bit())
504       setOperationAction(ISD::CTPOP        , MVT::i64  , Expand);
505   }
506
507   setOperationAction(ISD::READCYCLECOUNTER , MVT::i64  , Custom);
508
509   if (!Subtarget->hasMOVBE())
510     setOperationAction(ISD::BSWAP          , MVT::i16  , Expand);
511
512   // These should be promoted to a larger select which is supported.
513   setOperationAction(ISD::SELECT          , MVT::i1   , Promote);
514   // X86 wants to expand cmov itself.
515   setOperationAction(ISD::SELECT          , MVT::i8   , Custom);
516   setOperationAction(ISD::SELECT          , MVT::i16  , Custom);
517   setOperationAction(ISD::SELECT          , MVT::i32  , Custom);
518   setOperationAction(ISD::SELECT          , MVT::f32  , Custom);
519   setOperationAction(ISD::SELECT          , MVT::f64  , Custom);
520   setOperationAction(ISD::SELECT          , MVT::f80  , Custom);
521   setOperationAction(ISD::SETCC           , MVT::i8   , Custom);
522   setOperationAction(ISD::SETCC           , MVT::i16  , Custom);
523   setOperationAction(ISD::SETCC           , MVT::i32  , Custom);
524   setOperationAction(ISD::SETCC           , MVT::f32  , Custom);
525   setOperationAction(ISD::SETCC           , MVT::f64  , Custom);
526   setOperationAction(ISD::SETCC           , MVT::f80  , Custom);
527   if (Subtarget->is64Bit()) {
528     setOperationAction(ISD::SELECT        , MVT::i64  , Custom);
529     setOperationAction(ISD::SETCC         , MVT::i64  , Custom);
530   }
531   setOperationAction(ISD::EH_RETURN       , MVT::Other, Custom);
532   // NOTE: EH_SJLJ_SETJMP/_LONGJMP supported here is NOT intended to support
533   // SjLj exception handling but a light-weight setjmp/longjmp replacement to
534   // support continuation, user-level threading, and etc.. As a result, no
535   // other SjLj exception interfaces are implemented and please don't build
536   // your own exception handling based on them.
537   // LLVM/Clang supports zero-cost DWARF exception handling.
538   setOperationAction(ISD::EH_SJLJ_SETJMP, MVT::i32, Custom);
539   setOperationAction(ISD::EH_SJLJ_LONGJMP, MVT::Other, Custom);
540
541   // Darwin ABI issue.
542   setOperationAction(ISD::ConstantPool    , MVT::i32  , Custom);
543   setOperationAction(ISD::JumpTable       , MVT::i32  , Custom);
544   setOperationAction(ISD::GlobalAddress   , MVT::i32  , Custom);
545   setOperationAction(ISD::GlobalTLSAddress, MVT::i32  , Custom);
546   if (Subtarget->is64Bit())
547     setOperationAction(ISD::GlobalTLSAddress, MVT::i64, Custom);
548   setOperationAction(ISD::ExternalSymbol  , MVT::i32  , Custom);
549   setOperationAction(ISD::BlockAddress    , MVT::i32  , Custom);
550   if (Subtarget->is64Bit()) {
551     setOperationAction(ISD::ConstantPool  , MVT::i64  , Custom);
552     setOperationAction(ISD::JumpTable     , MVT::i64  , Custom);
553     setOperationAction(ISD::GlobalAddress , MVT::i64  , Custom);
554     setOperationAction(ISD::ExternalSymbol, MVT::i64  , Custom);
555     setOperationAction(ISD::BlockAddress  , MVT::i64  , Custom);
556   }
557   // 64-bit addm sub, shl, sra, srl (iff 32-bit x86)
558   setOperationAction(ISD::SHL_PARTS       , MVT::i32  , Custom);
559   setOperationAction(ISD::SRA_PARTS       , MVT::i32  , Custom);
560   setOperationAction(ISD::SRL_PARTS       , MVT::i32  , Custom);
561   if (Subtarget->is64Bit()) {
562     setOperationAction(ISD::SHL_PARTS     , MVT::i64  , Custom);
563     setOperationAction(ISD::SRA_PARTS     , MVT::i64  , Custom);
564     setOperationAction(ISD::SRL_PARTS     , MVT::i64  , Custom);
565   }
566
567   if (Subtarget->hasSSE1())
568     setOperationAction(ISD::PREFETCH      , MVT::Other, Legal);
569
570   setOperationAction(ISD::ATOMIC_FENCE  , MVT::Other, Custom);
571
572   // Expand certain atomics
573   for (unsigned i = 0; i != array_lengthof(IntVTs); ++i) {
574     MVT VT = IntVTs[i];
575     setOperationAction(ISD::ATOMIC_CMP_SWAP, VT, Custom);
576     setOperationAction(ISD::ATOMIC_LOAD_SUB, VT, Custom);
577     setOperationAction(ISD::ATOMIC_STORE, VT, Custom);
578   }
579
580   if (!Subtarget->is64Bit()) {
581     setOperationAction(ISD::ATOMIC_LOAD, MVT::i64, Custom);
582     setOperationAction(ISD::ATOMIC_LOAD_ADD, MVT::i64, Custom);
583     setOperationAction(ISD::ATOMIC_LOAD_SUB, MVT::i64, Custom);
584     setOperationAction(ISD::ATOMIC_LOAD_AND, MVT::i64, Custom);
585     setOperationAction(ISD::ATOMIC_LOAD_OR, MVT::i64, Custom);
586     setOperationAction(ISD::ATOMIC_LOAD_XOR, MVT::i64, Custom);
587     setOperationAction(ISD::ATOMIC_LOAD_NAND, MVT::i64, Custom);
588     setOperationAction(ISD::ATOMIC_SWAP, MVT::i64, Custom);
589     setOperationAction(ISD::ATOMIC_LOAD_MAX, MVT::i64, Custom);
590     setOperationAction(ISD::ATOMIC_LOAD_MIN, MVT::i64, Custom);
591     setOperationAction(ISD::ATOMIC_LOAD_UMAX, MVT::i64, Custom);
592     setOperationAction(ISD::ATOMIC_LOAD_UMIN, MVT::i64, Custom);
593   }
594
595   if (Subtarget->hasCmpxchg16b()) {
596     setOperationAction(ISD::ATOMIC_CMP_SWAP, MVT::i128, Custom);
597   }
598
599   // FIXME - use subtarget debug flags
600   if (!Subtarget->isTargetDarwin() &&
601       !Subtarget->isTargetELF() &&
602       !Subtarget->isTargetCygMing()) {
603     setOperationAction(ISD::EH_LABEL, MVT::Other, Expand);
604   }
605
606   if (Subtarget->is64Bit()) {
607     setExceptionPointerRegister(X86::RAX);
608     setExceptionSelectorRegister(X86::RDX);
609   } else {
610     setExceptionPointerRegister(X86::EAX);
611     setExceptionSelectorRegister(X86::EDX);
612   }
613   setOperationAction(ISD::FRAME_TO_ARGS_OFFSET, MVT::i32, Custom);
614   setOperationAction(ISD::FRAME_TO_ARGS_OFFSET, MVT::i64, Custom);
615
616   setOperationAction(ISD::INIT_TRAMPOLINE, MVT::Other, Custom);
617   setOperationAction(ISD::ADJUST_TRAMPOLINE, MVT::Other, Custom);
618
619   setOperationAction(ISD::TRAP, MVT::Other, Legal);
620   setOperationAction(ISD::DEBUGTRAP, MVT::Other, Legal);
621
622   // VASTART needs to be custom lowered to use the VarArgsFrameIndex
623   setOperationAction(ISD::VASTART           , MVT::Other, Custom);
624   setOperationAction(ISD::VAEND             , MVT::Other, Expand);
625   if (Subtarget->is64Bit() && !Subtarget->isTargetWin64()) {
626     // TargetInfo::X86_64ABIBuiltinVaList
627     setOperationAction(ISD::VAARG           , MVT::Other, Custom);
628     setOperationAction(ISD::VACOPY          , MVT::Other, Custom);
629   } else {
630     // TargetInfo::CharPtrBuiltinVaList
631     setOperationAction(ISD::VAARG           , MVT::Other, Expand);
632     setOperationAction(ISD::VACOPY          , MVT::Other, Expand);
633   }
634
635   setOperationAction(ISD::STACKSAVE,          MVT::Other, Expand);
636   setOperationAction(ISD::STACKRESTORE,       MVT::Other, Expand);
637
638   if (Subtarget->isOSWindows() && !Subtarget->isTargetMacho())
639     setOperationAction(ISD::DYNAMIC_STACKALLOC, Subtarget->is64Bit() ?
640                        MVT::i64 : MVT::i32, Custom);
641   else if (TM.Options.EnableSegmentedStacks)
642     setOperationAction(ISD::DYNAMIC_STACKALLOC, Subtarget->is64Bit() ?
643                        MVT::i64 : MVT::i32, Custom);
644   else
645     setOperationAction(ISD::DYNAMIC_STACKALLOC, Subtarget->is64Bit() ?
646                        MVT::i64 : MVT::i32, Expand);
647
648   if (!TM.Options.UseSoftFloat && X86ScalarSSEf64) {
649     // f32 and f64 use SSE.
650     // Set up the FP register classes.
651     addRegisterClass(MVT::f32, &X86::FR32RegClass);
652     addRegisterClass(MVT::f64, &X86::FR64RegClass);
653
654     // Use ANDPD to simulate FABS.
655     setOperationAction(ISD::FABS , MVT::f64, Custom);
656     setOperationAction(ISD::FABS , MVT::f32, Custom);
657
658     // Use XORP to simulate FNEG.
659     setOperationAction(ISD::FNEG , MVT::f64, Custom);
660     setOperationAction(ISD::FNEG , MVT::f32, Custom);
661
662     // Use ANDPD and ORPD to simulate FCOPYSIGN.
663     setOperationAction(ISD::FCOPYSIGN, MVT::f64, Custom);
664     setOperationAction(ISD::FCOPYSIGN, MVT::f32, Custom);
665
666     // Lower this to FGETSIGNx86 plus an AND.
667     setOperationAction(ISD::FGETSIGN, MVT::i64, Custom);
668     setOperationAction(ISD::FGETSIGN, MVT::i32, Custom);
669
670     // We don't support sin/cos/fmod
671     setOperationAction(ISD::FSIN   , MVT::f64, Expand);
672     setOperationAction(ISD::FCOS   , MVT::f64, Expand);
673     setOperationAction(ISD::FSINCOS, MVT::f64, Expand);
674     setOperationAction(ISD::FSIN   , MVT::f32, Expand);
675     setOperationAction(ISD::FCOS   , MVT::f32, Expand);
676     setOperationAction(ISD::FSINCOS, MVT::f32, Expand);
677
678     // Expand FP immediates into loads from the stack, except for the special
679     // cases we handle.
680     addLegalFPImmediate(APFloat(+0.0)); // xorpd
681     addLegalFPImmediate(APFloat(+0.0f)); // xorps
682   } else if (!TM.Options.UseSoftFloat && X86ScalarSSEf32) {
683     // Use SSE for f32, x87 for f64.
684     // Set up the FP register classes.
685     addRegisterClass(MVT::f32, &X86::FR32RegClass);
686     addRegisterClass(MVT::f64, &X86::RFP64RegClass);
687
688     // Use ANDPS to simulate FABS.
689     setOperationAction(ISD::FABS , MVT::f32, Custom);
690
691     // Use XORP to simulate FNEG.
692     setOperationAction(ISD::FNEG , MVT::f32, Custom);
693
694     setOperationAction(ISD::UNDEF,     MVT::f64, Expand);
695
696     // Use ANDPS and ORPS to simulate FCOPYSIGN.
697     setOperationAction(ISD::FCOPYSIGN, MVT::f64, Expand);
698     setOperationAction(ISD::FCOPYSIGN, MVT::f32, Custom);
699
700     // We don't support sin/cos/fmod
701     setOperationAction(ISD::FSIN   , MVT::f32, Expand);
702     setOperationAction(ISD::FCOS   , MVT::f32, Expand);
703     setOperationAction(ISD::FSINCOS, MVT::f32, Expand);
704
705     // Special cases we handle for FP constants.
706     addLegalFPImmediate(APFloat(+0.0f)); // xorps
707     addLegalFPImmediate(APFloat(+0.0)); // FLD0
708     addLegalFPImmediate(APFloat(+1.0)); // FLD1
709     addLegalFPImmediate(APFloat(-0.0)); // FLD0/FCHS
710     addLegalFPImmediate(APFloat(-1.0)); // FLD1/FCHS
711
712     if (!TM.Options.UnsafeFPMath) {
713       setOperationAction(ISD::FSIN   , MVT::f64, Expand);
714       setOperationAction(ISD::FCOS   , MVT::f64, Expand);
715       setOperationAction(ISD::FSINCOS, MVT::f64, Expand);
716     }
717   } else if (!TM.Options.UseSoftFloat) {
718     // f32 and f64 in x87.
719     // Set up the FP register classes.
720     addRegisterClass(MVT::f64, &X86::RFP64RegClass);
721     addRegisterClass(MVT::f32, &X86::RFP32RegClass);
722
723     setOperationAction(ISD::UNDEF,     MVT::f64, Expand);
724     setOperationAction(ISD::UNDEF,     MVT::f32, Expand);
725     setOperationAction(ISD::FCOPYSIGN, MVT::f64, Expand);
726     setOperationAction(ISD::FCOPYSIGN, MVT::f32, Expand);
727
728     if (!TM.Options.UnsafeFPMath) {
729       setOperationAction(ISD::FSIN   , MVT::f64, Expand);
730       setOperationAction(ISD::FSIN   , MVT::f32, Expand);
731       setOperationAction(ISD::FCOS   , MVT::f64, Expand);
732       setOperationAction(ISD::FCOS   , MVT::f32, Expand);
733       setOperationAction(ISD::FSINCOS, MVT::f64, Expand);
734       setOperationAction(ISD::FSINCOS, MVT::f32, Expand);
735     }
736     addLegalFPImmediate(APFloat(+0.0)); // FLD0
737     addLegalFPImmediate(APFloat(+1.0)); // FLD1
738     addLegalFPImmediate(APFloat(-0.0)); // FLD0/FCHS
739     addLegalFPImmediate(APFloat(-1.0)); // FLD1/FCHS
740     addLegalFPImmediate(APFloat(+0.0f)); // FLD0
741     addLegalFPImmediate(APFloat(+1.0f)); // FLD1
742     addLegalFPImmediate(APFloat(-0.0f)); // FLD0/FCHS
743     addLegalFPImmediate(APFloat(-1.0f)); // FLD1/FCHS
744   }
745
746   // We don't support FMA.
747   setOperationAction(ISD::FMA, MVT::f64, Expand);
748   setOperationAction(ISD::FMA, MVT::f32, Expand);
749
750   // Long double always uses X87.
751   if (!TM.Options.UseSoftFloat) {
752     addRegisterClass(MVT::f80, &X86::RFP80RegClass);
753     setOperationAction(ISD::UNDEF,     MVT::f80, Expand);
754     setOperationAction(ISD::FCOPYSIGN, MVT::f80, Expand);
755     {
756       APFloat TmpFlt = APFloat::getZero(APFloat::x87DoubleExtended);
757       addLegalFPImmediate(TmpFlt);  // FLD0
758       TmpFlt.changeSign();
759       addLegalFPImmediate(TmpFlt);  // FLD0/FCHS
760
761       bool ignored;
762       APFloat TmpFlt2(+1.0);
763       TmpFlt2.convert(APFloat::x87DoubleExtended, APFloat::rmNearestTiesToEven,
764                       &ignored);
765       addLegalFPImmediate(TmpFlt2);  // FLD1
766       TmpFlt2.changeSign();
767       addLegalFPImmediate(TmpFlt2);  // FLD1/FCHS
768     }
769
770     if (!TM.Options.UnsafeFPMath) {
771       setOperationAction(ISD::FSIN   , MVT::f80, Expand);
772       setOperationAction(ISD::FCOS   , MVT::f80, Expand);
773       setOperationAction(ISD::FSINCOS, MVT::f80, Expand);
774     }
775
776     setOperationAction(ISD::FFLOOR, MVT::f80, Expand);
777     setOperationAction(ISD::FCEIL,  MVT::f80, Expand);
778     setOperationAction(ISD::FTRUNC, MVT::f80, Expand);
779     setOperationAction(ISD::FRINT,  MVT::f80, Expand);
780     setOperationAction(ISD::FNEARBYINT, MVT::f80, Expand);
781     setOperationAction(ISD::FMA, MVT::f80, Expand);
782   }
783
784   // Always use a library call for pow.
785   setOperationAction(ISD::FPOW             , MVT::f32  , Expand);
786   setOperationAction(ISD::FPOW             , MVT::f64  , Expand);
787   setOperationAction(ISD::FPOW             , MVT::f80  , Expand);
788
789   setOperationAction(ISD::FLOG, MVT::f80, Expand);
790   setOperationAction(ISD::FLOG2, MVT::f80, Expand);
791   setOperationAction(ISD::FLOG10, MVT::f80, Expand);
792   setOperationAction(ISD::FEXP, MVT::f80, Expand);
793   setOperationAction(ISD::FEXP2, MVT::f80, Expand);
794
795   // First set operation action for all vector types to either promote
796   // (for widening) or expand (for scalarization). Then we will selectively
797   // turn on ones that can be effectively codegen'd.
798   for (int i = MVT::FIRST_VECTOR_VALUETYPE;
799            i <= MVT::LAST_VECTOR_VALUETYPE; ++i) {
800     MVT VT = (MVT::SimpleValueType)i;
801     setOperationAction(ISD::ADD , VT, Expand);
802     setOperationAction(ISD::SUB , VT, Expand);
803     setOperationAction(ISD::FADD, VT, Expand);
804     setOperationAction(ISD::FNEG, VT, Expand);
805     setOperationAction(ISD::FSUB, VT, Expand);
806     setOperationAction(ISD::MUL , VT, Expand);
807     setOperationAction(ISD::FMUL, VT, Expand);
808     setOperationAction(ISD::SDIV, VT, Expand);
809     setOperationAction(ISD::UDIV, VT, Expand);
810     setOperationAction(ISD::FDIV, VT, Expand);
811     setOperationAction(ISD::SREM, VT, Expand);
812     setOperationAction(ISD::UREM, VT, Expand);
813     setOperationAction(ISD::LOAD, VT, Expand);
814     setOperationAction(ISD::VECTOR_SHUFFLE, VT, Expand);
815     setOperationAction(ISD::EXTRACT_VECTOR_ELT, VT,Expand);
816     setOperationAction(ISD::INSERT_VECTOR_ELT, VT, Expand);
817     setOperationAction(ISD::EXTRACT_SUBVECTOR, VT,Expand);
818     setOperationAction(ISD::INSERT_SUBVECTOR, VT,Expand);
819     setOperationAction(ISD::FABS, VT, Expand);
820     setOperationAction(ISD::FSIN, VT, Expand);
821     setOperationAction(ISD::FSINCOS, VT, Expand);
822     setOperationAction(ISD::FCOS, VT, Expand);
823     setOperationAction(ISD::FSINCOS, VT, Expand);
824     setOperationAction(ISD::FREM, VT, Expand);
825     setOperationAction(ISD::FMA,  VT, Expand);
826     setOperationAction(ISD::FPOWI, VT, Expand);
827     setOperationAction(ISD::FSQRT, VT, Expand);
828     setOperationAction(ISD::FCOPYSIGN, VT, Expand);
829     setOperationAction(ISD::FFLOOR, VT, Expand);
830     setOperationAction(ISD::FCEIL, VT, Expand);
831     setOperationAction(ISD::FTRUNC, VT, Expand);
832     setOperationAction(ISD::FRINT, VT, Expand);
833     setOperationAction(ISD::FNEARBYINT, VT, Expand);
834     setOperationAction(ISD::SMUL_LOHI, VT, Expand);
835     setOperationAction(ISD::UMUL_LOHI, VT, Expand);
836     setOperationAction(ISD::SDIVREM, VT, Expand);
837     setOperationAction(ISD::UDIVREM, VT, Expand);
838     setOperationAction(ISD::FPOW, VT, Expand);
839     setOperationAction(ISD::CTPOP, VT, Expand);
840     setOperationAction(ISD::CTTZ, VT, Expand);
841     setOperationAction(ISD::CTTZ_ZERO_UNDEF, VT, Expand);
842     setOperationAction(ISD::CTLZ, VT, Expand);
843     setOperationAction(ISD::CTLZ_ZERO_UNDEF, VT, Expand);
844     setOperationAction(ISD::SHL, VT, Expand);
845     setOperationAction(ISD::SRA, VT, Expand);
846     setOperationAction(ISD::SRL, VT, Expand);
847     setOperationAction(ISD::ROTL, VT, Expand);
848     setOperationAction(ISD::ROTR, VT, Expand);
849     setOperationAction(ISD::BSWAP, VT, Expand);
850     setOperationAction(ISD::SETCC, VT, Expand);
851     setOperationAction(ISD::FLOG, VT, Expand);
852     setOperationAction(ISD::FLOG2, VT, Expand);
853     setOperationAction(ISD::FLOG10, VT, Expand);
854     setOperationAction(ISD::FEXP, VT, Expand);
855     setOperationAction(ISD::FEXP2, VT, Expand);
856     setOperationAction(ISD::FP_TO_UINT, VT, Expand);
857     setOperationAction(ISD::FP_TO_SINT, VT, Expand);
858     setOperationAction(ISD::UINT_TO_FP, VT, Expand);
859     setOperationAction(ISD::SINT_TO_FP, VT, Expand);
860     setOperationAction(ISD::SIGN_EXTEND_INREG, VT,Expand);
861     setOperationAction(ISD::TRUNCATE, VT, Expand);
862     setOperationAction(ISD::SIGN_EXTEND, VT, Expand);
863     setOperationAction(ISD::ZERO_EXTEND, VT, Expand);
864     setOperationAction(ISD::ANY_EXTEND, VT, Expand);
865     setOperationAction(ISD::VSELECT, VT, Expand);
866     for (int InnerVT = MVT::FIRST_VECTOR_VALUETYPE;
867              InnerVT <= MVT::LAST_VECTOR_VALUETYPE; ++InnerVT)
868       setTruncStoreAction(VT,
869                           (MVT::SimpleValueType)InnerVT, Expand);
870     setLoadExtAction(ISD::SEXTLOAD, VT, Expand);
871     setLoadExtAction(ISD::ZEXTLOAD, VT, Expand);
872     setLoadExtAction(ISD::EXTLOAD, VT, Expand);
873   }
874
875   // FIXME: In order to prevent SSE instructions being expanded to MMX ones
876   // with -msoft-float, disable use of MMX as well.
877   if (!TM.Options.UseSoftFloat && Subtarget->hasMMX()) {
878     addRegisterClass(MVT::x86mmx, &X86::VR64RegClass);
879     // No operations on x86mmx supported, everything uses intrinsics.
880   }
881
882   // MMX-sized vectors (other than x86mmx) are expected to be expanded
883   // into smaller operations.
884   setOperationAction(ISD::MULHS,              MVT::v8i8,  Expand);
885   setOperationAction(ISD::MULHS,              MVT::v4i16, Expand);
886   setOperationAction(ISD::MULHS,              MVT::v2i32, Expand);
887   setOperationAction(ISD::MULHS,              MVT::v1i64, Expand);
888   setOperationAction(ISD::AND,                MVT::v8i8,  Expand);
889   setOperationAction(ISD::AND,                MVT::v4i16, Expand);
890   setOperationAction(ISD::AND,                MVT::v2i32, Expand);
891   setOperationAction(ISD::AND,                MVT::v1i64, Expand);
892   setOperationAction(ISD::OR,                 MVT::v8i8,  Expand);
893   setOperationAction(ISD::OR,                 MVT::v4i16, Expand);
894   setOperationAction(ISD::OR,                 MVT::v2i32, Expand);
895   setOperationAction(ISD::OR,                 MVT::v1i64, Expand);
896   setOperationAction(ISD::XOR,                MVT::v8i8,  Expand);
897   setOperationAction(ISD::XOR,                MVT::v4i16, Expand);
898   setOperationAction(ISD::XOR,                MVT::v2i32, Expand);
899   setOperationAction(ISD::XOR,                MVT::v1i64, Expand);
900   setOperationAction(ISD::SCALAR_TO_VECTOR,   MVT::v8i8,  Expand);
901   setOperationAction(ISD::SCALAR_TO_VECTOR,   MVT::v4i16, Expand);
902   setOperationAction(ISD::SCALAR_TO_VECTOR,   MVT::v2i32, Expand);
903   setOperationAction(ISD::SCALAR_TO_VECTOR,   MVT::v1i64, Expand);
904   setOperationAction(ISD::INSERT_VECTOR_ELT,  MVT::v1i64, Expand);
905   setOperationAction(ISD::SELECT,             MVT::v8i8,  Expand);
906   setOperationAction(ISD::SELECT,             MVT::v4i16, Expand);
907   setOperationAction(ISD::SELECT,             MVT::v2i32, Expand);
908   setOperationAction(ISD::SELECT,             MVT::v1i64, Expand);
909   setOperationAction(ISD::BITCAST,            MVT::v8i8,  Expand);
910   setOperationAction(ISD::BITCAST,            MVT::v4i16, Expand);
911   setOperationAction(ISD::BITCAST,            MVT::v2i32, Expand);
912   setOperationAction(ISD::BITCAST,            MVT::v1i64, Expand);
913
914   if (!TM.Options.UseSoftFloat && Subtarget->hasSSE1()) {
915     addRegisterClass(MVT::v4f32, &X86::VR128RegClass);
916
917     setOperationAction(ISD::FADD,               MVT::v4f32, Legal);
918     setOperationAction(ISD::FSUB,               MVT::v4f32, Legal);
919     setOperationAction(ISD::FMUL,               MVT::v4f32, Legal);
920     setOperationAction(ISD::FDIV,               MVT::v4f32, Legal);
921     setOperationAction(ISD::FSQRT,              MVT::v4f32, Legal);
922     setOperationAction(ISD::FNEG,               MVT::v4f32, Custom);
923     setOperationAction(ISD::FABS,               MVT::v4f32, Custom);
924     setOperationAction(ISD::LOAD,               MVT::v4f32, Legal);
925     setOperationAction(ISD::BUILD_VECTOR,       MVT::v4f32, Custom);
926     setOperationAction(ISD::VECTOR_SHUFFLE,     MVT::v4f32, Custom);
927     setOperationAction(ISD::EXTRACT_VECTOR_ELT, MVT::v4f32, Custom);
928     setOperationAction(ISD::SELECT,             MVT::v4f32, Custom);
929   }
930
931   if (!TM.Options.UseSoftFloat && Subtarget->hasSSE2()) {
932     addRegisterClass(MVT::v2f64, &X86::VR128RegClass);
933
934     // FIXME: Unfortunately -soft-float and -no-implicit-float means XMM
935     // registers cannot be used even for integer operations.
936     addRegisterClass(MVT::v16i8, &X86::VR128RegClass);
937     addRegisterClass(MVT::v8i16, &X86::VR128RegClass);
938     addRegisterClass(MVT::v4i32, &X86::VR128RegClass);
939     addRegisterClass(MVT::v2i64, &X86::VR128RegClass);
940
941     setOperationAction(ISD::ADD,                MVT::v16i8, Legal);
942     setOperationAction(ISD::ADD,                MVT::v8i16, Legal);
943     setOperationAction(ISD::ADD,                MVT::v4i32, Legal);
944     setOperationAction(ISD::ADD,                MVT::v2i64, Legal);
945     setOperationAction(ISD::MUL,                MVT::v4i32, Custom);
946     setOperationAction(ISD::MUL,                MVT::v2i64, Custom);
947     setOperationAction(ISD::SUB,                MVT::v16i8, Legal);
948     setOperationAction(ISD::SUB,                MVT::v8i16, Legal);
949     setOperationAction(ISD::SUB,                MVT::v4i32, Legal);
950     setOperationAction(ISD::SUB,                MVT::v2i64, Legal);
951     setOperationAction(ISD::MUL,                MVT::v8i16, Legal);
952     setOperationAction(ISD::FADD,               MVT::v2f64, Legal);
953     setOperationAction(ISD::FSUB,               MVT::v2f64, Legal);
954     setOperationAction(ISD::FMUL,               MVT::v2f64, Legal);
955     setOperationAction(ISD::FDIV,               MVT::v2f64, Legal);
956     setOperationAction(ISD::FSQRT,              MVT::v2f64, Legal);
957     setOperationAction(ISD::FNEG,               MVT::v2f64, Custom);
958     setOperationAction(ISD::FABS,               MVT::v2f64, Custom);
959
960     setOperationAction(ISD::SETCC,              MVT::v2i64, Custom);
961     setOperationAction(ISD::SETCC,              MVT::v16i8, Custom);
962     setOperationAction(ISD::SETCC,              MVT::v8i16, Custom);
963     setOperationAction(ISD::SETCC,              MVT::v4i32, Custom);
964
965     setOperationAction(ISD::SCALAR_TO_VECTOR,   MVT::v16i8, Custom);
966     setOperationAction(ISD::SCALAR_TO_VECTOR,   MVT::v8i16, Custom);
967     setOperationAction(ISD::INSERT_VECTOR_ELT,  MVT::v8i16, Custom);
968     setOperationAction(ISD::INSERT_VECTOR_ELT,  MVT::v4i32, Custom);
969     setOperationAction(ISD::INSERT_VECTOR_ELT,  MVT::v4f32, Custom);
970
971     // Custom lower build_vector, vector_shuffle, and extract_vector_elt.
972     for (int i = MVT::v16i8; i != MVT::v2i64; ++i) {
973       MVT VT = (MVT::SimpleValueType)i;
974       // Do not attempt to custom lower non-power-of-2 vectors
975       if (!isPowerOf2_32(VT.getVectorNumElements()))
976         continue;
977       // Do not attempt to custom lower non-128-bit vectors
978       if (!VT.is128BitVector())
979         continue;
980       setOperationAction(ISD::BUILD_VECTOR,       VT, Custom);
981       setOperationAction(ISD::VECTOR_SHUFFLE,     VT, Custom);
982       setOperationAction(ISD::EXTRACT_VECTOR_ELT, VT, Custom);
983     }
984
985     setOperationAction(ISD::BUILD_VECTOR,       MVT::v2f64, Custom);
986     setOperationAction(ISD::BUILD_VECTOR,       MVT::v2i64, Custom);
987     setOperationAction(ISD::VECTOR_SHUFFLE,     MVT::v2f64, Custom);
988     setOperationAction(ISD::VECTOR_SHUFFLE,     MVT::v2i64, Custom);
989     setOperationAction(ISD::INSERT_VECTOR_ELT,  MVT::v2f64, Custom);
990     setOperationAction(ISD::EXTRACT_VECTOR_ELT, MVT::v2f64, Custom);
991
992     if (Subtarget->is64Bit()) {
993       setOperationAction(ISD::INSERT_VECTOR_ELT,  MVT::v2i64, Custom);
994       setOperationAction(ISD::EXTRACT_VECTOR_ELT, MVT::v2i64, Custom);
995     }
996
997     // Promote v16i8, v8i16, v4i32 load, select, and, or, xor to v2i64.
998     for (int i = MVT::v16i8; i != MVT::v2i64; ++i) {
999       MVT VT = (MVT::SimpleValueType)i;
1000
1001       // Do not attempt to promote non-128-bit vectors
1002       if (!VT.is128BitVector())
1003         continue;
1004
1005       setOperationAction(ISD::AND,    VT, Promote);
1006       AddPromotedToType (ISD::AND,    VT, MVT::v2i64);
1007       setOperationAction(ISD::OR,     VT, Promote);
1008       AddPromotedToType (ISD::OR,     VT, MVT::v2i64);
1009       setOperationAction(ISD::XOR,    VT, Promote);
1010       AddPromotedToType (ISD::XOR,    VT, MVT::v2i64);
1011       setOperationAction(ISD::LOAD,   VT, Promote);
1012       AddPromotedToType (ISD::LOAD,   VT, MVT::v2i64);
1013       setOperationAction(ISD::SELECT, VT, Promote);
1014       AddPromotedToType (ISD::SELECT, VT, MVT::v2i64);
1015     }
1016
1017     setTruncStoreAction(MVT::f64, MVT::f32, Expand);
1018
1019     // Custom lower v2i64 and v2f64 selects.
1020     setOperationAction(ISD::LOAD,               MVT::v2f64, Legal);
1021     setOperationAction(ISD::LOAD,               MVT::v2i64, Legal);
1022     setOperationAction(ISD::SELECT,             MVT::v2f64, Custom);
1023     setOperationAction(ISD::SELECT,             MVT::v2i64, Custom);
1024
1025     setOperationAction(ISD::FP_TO_SINT,         MVT::v4i32, Legal);
1026     setOperationAction(ISD::SINT_TO_FP,         MVT::v4i32, Legal);
1027
1028     setOperationAction(ISD::UINT_TO_FP,         MVT::v4i8,  Custom);
1029     setOperationAction(ISD::UINT_TO_FP,         MVT::v4i16, Custom);
1030     // As there is no 64-bit GPR available, we need build a special custom
1031     // sequence to convert from v2i32 to v2f32.
1032     if (!Subtarget->is64Bit())
1033       setOperationAction(ISD::UINT_TO_FP,       MVT::v2f32, Custom);
1034
1035     setOperationAction(ISD::FP_EXTEND,          MVT::v2f32, Custom);
1036     setOperationAction(ISD::FP_ROUND,           MVT::v2f32, Custom);
1037
1038     setLoadExtAction(ISD::EXTLOAD,              MVT::v2f32, Legal);
1039   }
1040
1041   if (!TM.Options.UseSoftFloat && Subtarget->hasSSE41()) {
1042     setOperationAction(ISD::FFLOOR,             MVT::f32,   Legal);
1043     setOperationAction(ISD::FCEIL,              MVT::f32,   Legal);
1044     setOperationAction(ISD::FTRUNC,             MVT::f32,   Legal);
1045     setOperationAction(ISD::FRINT,              MVT::f32,   Legal);
1046     setOperationAction(ISD::FNEARBYINT,         MVT::f32,   Legal);
1047     setOperationAction(ISD::FFLOOR,             MVT::f64,   Legal);
1048     setOperationAction(ISD::FCEIL,              MVT::f64,   Legal);
1049     setOperationAction(ISD::FTRUNC,             MVT::f64,   Legal);
1050     setOperationAction(ISD::FRINT,              MVT::f64,   Legal);
1051     setOperationAction(ISD::FNEARBYINT,         MVT::f64,   Legal);
1052
1053     setOperationAction(ISD::FFLOOR,             MVT::v4f32, Legal);
1054     setOperationAction(ISD::FCEIL,              MVT::v4f32, Legal);
1055     setOperationAction(ISD::FTRUNC,             MVT::v4f32, Legal);
1056     setOperationAction(ISD::FRINT,              MVT::v4f32, Legal);
1057     setOperationAction(ISD::FNEARBYINT,         MVT::v4f32, Legal);
1058     setOperationAction(ISD::FFLOOR,             MVT::v2f64, Legal);
1059     setOperationAction(ISD::FCEIL,              MVT::v2f64, Legal);
1060     setOperationAction(ISD::FTRUNC,             MVT::v2f64, Legal);
1061     setOperationAction(ISD::FRINT,              MVT::v2f64, Legal);
1062     setOperationAction(ISD::FNEARBYINT,         MVT::v2f64, Legal);
1063
1064     // FIXME: Do we need to handle scalar-to-vector here?
1065     setOperationAction(ISD::MUL,                MVT::v4i32, Legal);
1066
1067     setOperationAction(ISD::VSELECT,            MVT::v2f64, Legal);
1068     setOperationAction(ISD::VSELECT,            MVT::v2i64, Legal);
1069     setOperationAction(ISD::VSELECT,            MVT::v16i8, Legal);
1070     setOperationAction(ISD::VSELECT,            MVT::v4i32, Legal);
1071     setOperationAction(ISD::VSELECT,            MVT::v4f32, Legal);
1072
1073     // i8 and i16 vectors are custom , because the source register and source
1074     // source memory operand types are not the same width.  f32 vectors are
1075     // custom since the immediate controlling the insert encodes additional
1076     // information.
1077     setOperationAction(ISD::INSERT_VECTOR_ELT,  MVT::v16i8, Custom);
1078     setOperationAction(ISD::INSERT_VECTOR_ELT,  MVT::v8i16, Custom);
1079     setOperationAction(ISD::INSERT_VECTOR_ELT,  MVT::v4i32, Custom);
1080     setOperationAction(ISD::INSERT_VECTOR_ELT,  MVT::v4f32, Custom);
1081
1082     setOperationAction(ISD::EXTRACT_VECTOR_ELT, MVT::v16i8, Custom);
1083     setOperationAction(ISD::EXTRACT_VECTOR_ELT, MVT::v8i16, Custom);
1084     setOperationAction(ISD::EXTRACT_VECTOR_ELT, MVT::v4i32, Custom);
1085     setOperationAction(ISD::EXTRACT_VECTOR_ELT, MVT::v4f32, Custom);
1086
1087     // FIXME: these should be Legal but thats only for the case where
1088     // the index is constant.  For now custom expand to deal with that.
1089     if (Subtarget->is64Bit()) {
1090       setOperationAction(ISD::INSERT_VECTOR_ELT,  MVT::v2i64, Custom);
1091       setOperationAction(ISD::EXTRACT_VECTOR_ELT, MVT::v2i64, Custom);
1092     }
1093   }
1094
1095   if (Subtarget->hasSSE2()) {
1096     setOperationAction(ISD::SRL,               MVT::v8i16, Custom);
1097     setOperationAction(ISD::SRL,               MVT::v16i8, Custom);
1098
1099     setOperationAction(ISD::SHL,               MVT::v8i16, Custom);
1100     setOperationAction(ISD::SHL,               MVT::v16i8, Custom);
1101
1102     setOperationAction(ISD::SRA,               MVT::v8i16, Custom);
1103     setOperationAction(ISD::SRA,               MVT::v16i8, Custom);
1104
1105     // In the customized shift lowering, the legal cases in AVX2 will be
1106     // recognized.
1107     setOperationAction(ISD::SRL,               MVT::v2i64, Custom);
1108     setOperationAction(ISD::SRL,               MVT::v4i32, Custom);
1109
1110     setOperationAction(ISD::SHL,               MVT::v2i64, Custom);
1111     setOperationAction(ISD::SHL,               MVT::v4i32, Custom);
1112
1113     setOperationAction(ISD::SRA,               MVT::v4i32, Custom);
1114
1115     setOperationAction(ISD::SDIV,              MVT::v8i16, Custom);
1116     setOperationAction(ISD::SDIV,              MVT::v4i32, Custom);
1117   }
1118
1119   if (!TM.Options.UseSoftFloat && Subtarget->hasFp256()) {
1120     addRegisterClass(MVT::v32i8,  &X86::VR256RegClass);
1121     addRegisterClass(MVT::v16i16, &X86::VR256RegClass);
1122     addRegisterClass(MVT::v8i32,  &X86::VR256RegClass);
1123     addRegisterClass(MVT::v8f32,  &X86::VR256RegClass);
1124     addRegisterClass(MVT::v4i64,  &X86::VR256RegClass);
1125     addRegisterClass(MVT::v4f64,  &X86::VR256RegClass);
1126
1127     setOperationAction(ISD::LOAD,               MVT::v8f32, Legal);
1128     setOperationAction(ISD::LOAD,               MVT::v4f64, Legal);
1129     setOperationAction(ISD::LOAD,               MVT::v4i64, Legal);
1130
1131     setOperationAction(ISD::FADD,               MVT::v8f32, Legal);
1132     setOperationAction(ISD::FSUB,               MVT::v8f32, Legal);
1133     setOperationAction(ISD::FMUL,               MVT::v8f32, Legal);
1134     setOperationAction(ISD::FDIV,               MVT::v8f32, Legal);
1135     setOperationAction(ISD::FSQRT,              MVT::v8f32, Legal);
1136     setOperationAction(ISD::FFLOOR,             MVT::v8f32, Legal);
1137     setOperationAction(ISD::FCEIL,              MVT::v8f32, Legal);
1138     setOperationAction(ISD::FTRUNC,             MVT::v8f32, Legal);
1139     setOperationAction(ISD::FRINT,              MVT::v8f32, Legal);
1140     setOperationAction(ISD::FNEARBYINT,         MVT::v8f32, Legal);
1141     setOperationAction(ISD::FNEG,               MVT::v8f32, Custom);
1142     setOperationAction(ISD::FABS,               MVT::v8f32, Custom);
1143
1144     setOperationAction(ISD::FADD,               MVT::v4f64, Legal);
1145     setOperationAction(ISD::FSUB,               MVT::v4f64, Legal);
1146     setOperationAction(ISD::FMUL,               MVT::v4f64, Legal);
1147     setOperationAction(ISD::FDIV,               MVT::v4f64, Legal);
1148     setOperationAction(ISD::FSQRT,              MVT::v4f64, Legal);
1149     setOperationAction(ISD::FFLOOR,             MVT::v4f64, Legal);
1150     setOperationAction(ISD::FCEIL,              MVT::v4f64, Legal);
1151     setOperationAction(ISD::FTRUNC,             MVT::v4f64, Legal);
1152     setOperationAction(ISD::FRINT,              MVT::v4f64, Legal);
1153     setOperationAction(ISD::FNEARBYINT,         MVT::v4f64, Legal);
1154     setOperationAction(ISD::FNEG,               MVT::v4f64, Custom);
1155     setOperationAction(ISD::FABS,               MVT::v4f64, Custom);
1156
1157     // (fp_to_int:v8i16 (v8f32 ..)) requires the result type to be promoted
1158     // even though v8i16 is a legal type.
1159     setOperationAction(ISD::FP_TO_SINT,         MVT::v8i16, Promote);
1160     setOperationAction(ISD::FP_TO_UINT,         MVT::v8i16, Promote);
1161     setOperationAction(ISD::FP_TO_SINT,         MVT::v8i32, Legal);
1162
1163     setOperationAction(ISD::SINT_TO_FP,         MVT::v8i16, Promote);
1164     setOperationAction(ISD::SINT_TO_FP,         MVT::v8i32, Legal);
1165     setOperationAction(ISD::FP_ROUND,           MVT::v4f32, Legal);
1166
1167     setOperationAction(ISD::UINT_TO_FP,         MVT::v8i8,  Custom);
1168     setOperationAction(ISD::UINT_TO_FP,         MVT::v8i16, Custom);
1169
1170     setLoadExtAction(ISD::EXTLOAD,              MVT::v4f32, Legal);
1171
1172     setOperationAction(ISD::SRL,               MVT::v16i16, Custom);
1173     setOperationAction(ISD::SRL,               MVT::v32i8, Custom);
1174
1175     setOperationAction(ISD::SHL,               MVT::v16i16, Custom);
1176     setOperationAction(ISD::SHL,               MVT::v32i8, Custom);
1177
1178     setOperationAction(ISD::SRA,               MVT::v16i16, Custom);
1179     setOperationAction(ISD::SRA,               MVT::v32i8, Custom);
1180
1181     setOperationAction(ISD::SDIV,              MVT::v16i16, Custom);
1182
1183     setOperationAction(ISD::SETCC,             MVT::v32i8, Custom);
1184     setOperationAction(ISD::SETCC,             MVT::v16i16, Custom);
1185     setOperationAction(ISD::SETCC,             MVT::v8i32, Custom);
1186     setOperationAction(ISD::SETCC,             MVT::v4i64, Custom);
1187
1188     setOperationAction(ISD::SELECT,            MVT::v4f64, Custom);
1189     setOperationAction(ISD::SELECT,            MVT::v4i64, Custom);
1190     setOperationAction(ISD::SELECT,            MVT::v8f32, Custom);
1191
1192     setOperationAction(ISD::VSELECT,           MVT::v4f64, Legal);
1193     setOperationAction(ISD::VSELECT,           MVT::v4i64, Legal);
1194     setOperationAction(ISD::VSELECT,           MVT::v8i32, Legal);
1195     setOperationAction(ISD::VSELECT,           MVT::v8f32, Legal);
1196
1197     setOperationAction(ISD::SIGN_EXTEND,       MVT::v4i64, Custom);
1198     setOperationAction(ISD::SIGN_EXTEND,       MVT::v8i32, Custom);
1199     setOperationAction(ISD::SIGN_EXTEND,       MVT::v16i16, Custom);
1200     setOperationAction(ISD::ZERO_EXTEND,       MVT::v4i64, Custom);
1201     setOperationAction(ISD::ZERO_EXTEND,       MVT::v8i32, Custom);
1202     setOperationAction(ISD::ZERO_EXTEND,       MVT::v16i16, Custom);
1203     setOperationAction(ISD::ANY_EXTEND,        MVT::v4i64, Custom);
1204     setOperationAction(ISD::ANY_EXTEND,        MVT::v8i32, Custom);
1205     setOperationAction(ISD::ANY_EXTEND,        MVT::v16i16, Custom);
1206     setOperationAction(ISD::TRUNCATE,          MVT::v16i8, Custom);
1207     setOperationAction(ISD::TRUNCATE,          MVT::v8i16, Custom);
1208     setOperationAction(ISD::TRUNCATE,          MVT::v4i32, Custom);
1209
1210     if (Subtarget->hasFMA() || Subtarget->hasFMA4()) {
1211       setOperationAction(ISD::FMA,             MVT::v8f32, Legal);
1212       setOperationAction(ISD::FMA,             MVT::v4f64, Legal);
1213       setOperationAction(ISD::FMA,             MVT::v4f32, Legal);
1214       setOperationAction(ISD::FMA,             MVT::v2f64, Legal);
1215       setOperationAction(ISD::FMA,             MVT::f32, Legal);
1216       setOperationAction(ISD::FMA,             MVT::f64, Legal);
1217     }
1218
1219     if (Subtarget->hasInt256()) {
1220       setOperationAction(ISD::ADD,             MVT::v4i64, Legal);
1221       setOperationAction(ISD::ADD,             MVT::v8i32, Legal);
1222       setOperationAction(ISD::ADD,             MVT::v16i16, Legal);
1223       setOperationAction(ISD::ADD,             MVT::v32i8, Legal);
1224
1225       setOperationAction(ISD::SUB,             MVT::v4i64, Legal);
1226       setOperationAction(ISD::SUB,             MVT::v8i32, Legal);
1227       setOperationAction(ISD::SUB,             MVT::v16i16, Legal);
1228       setOperationAction(ISD::SUB,             MVT::v32i8, Legal);
1229
1230       setOperationAction(ISD::MUL,             MVT::v4i64, Custom);
1231       setOperationAction(ISD::MUL,             MVT::v8i32, Legal);
1232       setOperationAction(ISD::MUL,             MVT::v16i16, Legal);
1233       // Don't lower v32i8 because there is no 128-bit byte mul
1234
1235       setOperationAction(ISD::VSELECT,         MVT::v32i8, Legal);
1236
1237       setOperationAction(ISD::SDIV,            MVT::v8i32, Custom);
1238     } else {
1239       setOperationAction(ISD::ADD,             MVT::v4i64, Custom);
1240       setOperationAction(ISD::ADD,             MVT::v8i32, Custom);
1241       setOperationAction(ISD::ADD,             MVT::v16i16, Custom);
1242       setOperationAction(ISD::ADD,             MVT::v32i8, Custom);
1243
1244       setOperationAction(ISD::SUB,             MVT::v4i64, Custom);
1245       setOperationAction(ISD::SUB,             MVT::v8i32, Custom);
1246       setOperationAction(ISD::SUB,             MVT::v16i16, Custom);
1247       setOperationAction(ISD::SUB,             MVT::v32i8, Custom);
1248
1249       setOperationAction(ISD::MUL,             MVT::v4i64, Custom);
1250       setOperationAction(ISD::MUL,             MVT::v8i32, Custom);
1251       setOperationAction(ISD::MUL,             MVT::v16i16, Custom);
1252       // Don't lower v32i8 because there is no 128-bit byte mul
1253     }
1254
1255     // In the customized shift lowering, the legal cases in AVX2 will be
1256     // recognized.
1257     setOperationAction(ISD::SRL,               MVT::v4i64, Custom);
1258     setOperationAction(ISD::SRL,               MVT::v8i32, Custom);
1259
1260     setOperationAction(ISD::SHL,               MVT::v4i64, Custom);
1261     setOperationAction(ISD::SHL,               MVT::v8i32, Custom);
1262
1263     setOperationAction(ISD::SRA,               MVT::v8i32, Custom);
1264
1265     // Custom lower several nodes for 256-bit types.
1266     for (int i = MVT::FIRST_VECTOR_VALUETYPE;
1267              i <= MVT::LAST_VECTOR_VALUETYPE; ++i) {
1268       MVT VT = (MVT::SimpleValueType)i;
1269
1270       // Extract subvector is special because the value type
1271       // (result) is 128-bit but the source is 256-bit wide.
1272       if (VT.is128BitVector())
1273         setOperationAction(ISD::EXTRACT_SUBVECTOR, VT, Custom);
1274
1275       // Do not attempt to custom lower other non-256-bit vectors
1276       if (!VT.is256BitVector())
1277         continue;
1278
1279       setOperationAction(ISD::BUILD_VECTOR,       VT, Custom);
1280       setOperationAction(ISD::VECTOR_SHUFFLE,     VT, Custom);
1281       setOperationAction(ISD::INSERT_VECTOR_ELT,  VT, Custom);
1282       setOperationAction(ISD::EXTRACT_VECTOR_ELT, VT, Custom);
1283       setOperationAction(ISD::SCALAR_TO_VECTOR,   VT, Custom);
1284       setOperationAction(ISD::INSERT_SUBVECTOR,   VT, Custom);
1285       setOperationAction(ISD::CONCAT_VECTORS,     VT, Custom);
1286     }
1287
1288     // Promote v32i8, v16i16, v8i32 select, and, or, xor to v4i64.
1289     for (int i = MVT::v32i8; i != MVT::v4i64; ++i) {
1290       MVT VT = (MVT::SimpleValueType)i;
1291
1292       // Do not attempt to promote non-256-bit vectors
1293       if (!VT.is256BitVector())
1294         continue;
1295
1296       setOperationAction(ISD::AND,    VT, Promote);
1297       AddPromotedToType (ISD::AND,    VT, MVT::v4i64);
1298       setOperationAction(ISD::OR,     VT, Promote);
1299       AddPromotedToType (ISD::OR,     VT, MVT::v4i64);
1300       setOperationAction(ISD::XOR,    VT, Promote);
1301       AddPromotedToType (ISD::XOR,    VT, MVT::v4i64);
1302       setOperationAction(ISD::LOAD,   VT, Promote);
1303       AddPromotedToType (ISD::LOAD,   VT, MVT::v4i64);
1304       setOperationAction(ISD::SELECT, VT, Promote);
1305       AddPromotedToType (ISD::SELECT, VT, MVT::v4i64);
1306     }
1307   }
1308
1309   if (!TM.Options.UseSoftFloat && Subtarget->hasAVX512()) {
1310     addRegisterClass(MVT::v16i32, &X86::VR512RegClass);
1311     addRegisterClass(MVT::v16f32, &X86::VR512RegClass);
1312     addRegisterClass(MVT::v8i64,  &X86::VR512RegClass);
1313     addRegisterClass(MVT::v8f64,  &X86::VR512RegClass);
1314
1315     addRegisterClass(MVT::i1,     &X86::VK1RegClass);
1316     addRegisterClass(MVT::v8i1,   &X86::VK8RegClass);
1317     addRegisterClass(MVT::v16i1,  &X86::VK16RegClass);
1318
1319     setOperationAction(ISD::BR_CC,              MVT::i1,    Expand);
1320     setOperationAction(ISD::SETCC,              MVT::i1,    Custom);
1321     setOperationAction(ISD::XOR,                MVT::i1,    Legal);
1322     setOperationAction(ISD::OR,                 MVT::i1,    Legal);
1323     setOperationAction(ISD::AND,                MVT::i1,    Legal);
1324     setLoadExtAction(ISD::EXTLOAD,              MVT::v8f32, Legal);
1325     setOperationAction(ISD::LOAD,               MVT::v16f32, Legal);
1326     setOperationAction(ISD::LOAD,               MVT::v8f64, Legal);
1327     setOperationAction(ISD::LOAD,               MVT::v8i64, Legal);
1328     setOperationAction(ISD::LOAD,               MVT::v16i32, Legal);
1329     setOperationAction(ISD::LOAD,               MVT::v16i1, Legal);
1330
1331     setOperationAction(ISD::FADD,               MVT::v16f32, Legal);
1332     setOperationAction(ISD::FSUB,               MVT::v16f32, Legal);
1333     setOperationAction(ISD::FMUL,               MVT::v16f32, Legal);
1334     setOperationAction(ISD::FDIV,               MVT::v16f32, Legal);
1335     setOperationAction(ISD::FSQRT,              MVT::v16f32, Legal);
1336     setOperationAction(ISD::FNEG,               MVT::v16f32, Custom);
1337
1338     setOperationAction(ISD::FADD,               MVT::v8f64, Legal);
1339     setOperationAction(ISD::FSUB,               MVT::v8f64, Legal);
1340     setOperationAction(ISD::FMUL,               MVT::v8f64, Legal);
1341     setOperationAction(ISD::FDIV,               MVT::v8f64, Legal);
1342     setOperationAction(ISD::FSQRT,              MVT::v8f64, Legal);
1343     setOperationAction(ISD::FNEG,               MVT::v8f64, Custom);
1344     setOperationAction(ISD::FMA,                MVT::v8f64, Legal);
1345     setOperationAction(ISD::FMA,                MVT::v16f32, Legal);
1346     setOperationAction(ISD::SDIV,               MVT::v16i32, Custom);
1347
1348     setOperationAction(ISD::FP_TO_SINT,         MVT::i32, Legal);
1349     setOperationAction(ISD::FP_TO_UINT,         MVT::i32, Legal);
1350     setOperationAction(ISD::SINT_TO_FP,         MVT::i32, Legal);
1351     setOperationAction(ISD::UINT_TO_FP,         MVT::i32, Legal);
1352     if (Subtarget->is64Bit()) {
1353       setOperationAction(ISD::FP_TO_UINT,       MVT::i64, Legal);
1354       setOperationAction(ISD::FP_TO_SINT,       MVT::i64, Legal);
1355       setOperationAction(ISD::SINT_TO_FP,       MVT::i64, Legal);
1356       setOperationAction(ISD::UINT_TO_FP,       MVT::i64, Legal);
1357     }
1358     setOperationAction(ISD::FP_TO_SINT,         MVT::v16i32, Legal);
1359     setOperationAction(ISD::FP_TO_UINT,         MVT::v16i32, Legal);
1360     setOperationAction(ISD::FP_TO_UINT,         MVT::v8i32, Legal);
1361     setOperationAction(ISD::SINT_TO_FP,         MVT::v16i32, Legal);
1362     setOperationAction(ISD::UINT_TO_FP,         MVT::v16i32, Legal);
1363     setOperationAction(ISD::UINT_TO_FP,         MVT::v8i32, Legal);
1364     setOperationAction(ISD::FP_ROUND,           MVT::v8f32, Legal);
1365     setOperationAction(ISD::FP_EXTEND,          MVT::v8f32, Legal);
1366
1367     setOperationAction(ISD::TRUNCATE,           MVT::i1, Custom);
1368     setOperationAction(ISD::TRUNCATE,           MVT::v16i8, Custom);
1369     setOperationAction(ISD::TRUNCATE,           MVT::v8i32, Custom);
1370     setOperationAction(ISD::TRUNCATE,           MVT::v8i1, Custom);
1371     setOperationAction(ISD::TRUNCATE,           MVT::v16i1, Custom);
1372     setOperationAction(ISD::TRUNCATE,           MVT::v16i16, Custom);
1373     setOperationAction(ISD::ZERO_EXTEND,        MVT::v16i32, Custom);
1374     setOperationAction(ISD::ZERO_EXTEND,        MVT::v8i64, Custom);
1375     setOperationAction(ISD::SIGN_EXTEND,        MVT::v16i32, Custom);
1376     setOperationAction(ISD::SIGN_EXTEND,        MVT::v8i64, Custom);
1377     setOperationAction(ISD::SIGN_EXTEND,        MVT::v16i8, Custom);
1378     setOperationAction(ISD::SIGN_EXTEND,        MVT::v8i16, Custom);
1379     setOperationAction(ISD::SIGN_EXTEND,        MVT::v16i16, Custom);
1380
1381     setOperationAction(ISD::CONCAT_VECTORS,     MVT::v8f64,  Custom);
1382     setOperationAction(ISD::CONCAT_VECTORS,     MVT::v8i64,  Custom);
1383     setOperationAction(ISD::CONCAT_VECTORS,     MVT::v16f32,  Custom);
1384     setOperationAction(ISD::CONCAT_VECTORS,     MVT::v16i32,  Custom);
1385     setOperationAction(ISD::CONCAT_VECTORS,     MVT::v8i1,    Custom);
1386     setOperationAction(ISD::CONCAT_VECTORS,     MVT::v16i1, Legal);
1387
1388     setOperationAction(ISD::SETCC,              MVT::v16i1, Custom);
1389     setOperationAction(ISD::SETCC,              MVT::v8i1, Custom);
1390
1391     setOperationAction(ISD::MUL,              MVT::v8i64, Custom);
1392
1393     setOperationAction(ISD::EXTRACT_VECTOR_ELT, MVT::v8i1,  Custom);
1394     setOperationAction(ISD::EXTRACT_VECTOR_ELT, MVT::v16i1, Custom);
1395     setOperationAction(ISD::BUILD_VECTOR,       MVT::v8i1, Custom);
1396     setOperationAction(ISD::BUILD_VECTOR,       MVT::v16i1, Custom);
1397     setOperationAction(ISD::SELECT,             MVT::v8f64, Custom);
1398     setOperationAction(ISD::SELECT,             MVT::v8i64, Custom);
1399     setOperationAction(ISD::SELECT,             MVT::v16f32, Custom);
1400
1401     setOperationAction(ISD::ADD,                MVT::v8i64, Legal);
1402     setOperationAction(ISD::ADD,                MVT::v16i32, Legal);
1403
1404     setOperationAction(ISD::SUB,                MVT::v8i64, Legal);
1405     setOperationAction(ISD::SUB,                MVT::v16i32, Legal);
1406
1407     setOperationAction(ISD::MUL,                MVT::v16i32, Legal);
1408
1409     setOperationAction(ISD::SRL,                MVT::v8i64, Custom);
1410     setOperationAction(ISD::SRL,                MVT::v16i32, Custom);
1411
1412     setOperationAction(ISD::SHL,                MVT::v8i64, Custom);
1413     setOperationAction(ISD::SHL,                MVT::v16i32, Custom);
1414
1415     setOperationAction(ISD::SRA,                MVT::v8i64, Custom);
1416     setOperationAction(ISD::SRA,                MVT::v16i32, Custom);
1417
1418     setOperationAction(ISD::AND,                MVT::v8i64, Legal);
1419     setOperationAction(ISD::OR,                 MVT::v8i64, Legal);
1420     setOperationAction(ISD::XOR,                MVT::v8i64, Legal);
1421     setOperationAction(ISD::AND,                MVT::v16i32, Legal);
1422     setOperationAction(ISD::OR,                 MVT::v16i32, Legal);
1423     setOperationAction(ISD::XOR,                MVT::v16i32, Legal);
1424
1425     // Custom lower several nodes.
1426     for (int i = MVT::FIRST_VECTOR_VALUETYPE;
1427              i <= MVT::LAST_VECTOR_VALUETYPE; ++i) {
1428       MVT VT = (MVT::SimpleValueType)i;
1429
1430       unsigned EltSize = VT.getVectorElementType().getSizeInBits();
1431       // Extract subvector is special because the value type
1432       // (result) is 256/128-bit but the source is 512-bit wide.
1433       if (VT.is128BitVector() || VT.is256BitVector())
1434         setOperationAction(ISD::EXTRACT_SUBVECTOR, VT, Custom);
1435
1436       if (VT.getVectorElementType() == MVT::i1)
1437         setOperationAction(ISD::EXTRACT_SUBVECTOR, VT, Legal);
1438
1439       // Do not attempt to custom lower other non-512-bit vectors
1440       if (!VT.is512BitVector())
1441         continue;
1442
1443       if ( EltSize >= 32) {
1444         setOperationAction(ISD::VECTOR_SHUFFLE,      VT, Custom);
1445         setOperationAction(ISD::INSERT_VECTOR_ELT,   VT, Custom);
1446         setOperationAction(ISD::BUILD_VECTOR,        VT, Custom);
1447         setOperationAction(ISD::VSELECT,             VT, Legal);
1448         setOperationAction(ISD::EXTRACT_VECTOR_ELT,  VT, Custom);
1449         setOperationAction(ISD::SCALAR_TO_VECTOR,    VT, Custom);
1450         setOperationAction(ISD::INSERT_SUBVECTOR,    VT, Custom);
1451       }
1452     }
1453     for (int i = MVT::v32i8; i != MVT::v8i64; ++i) {
1454       MVT VT = (MVT::SimpleValueType)i;
1455
1456       // Do not attempt to promote non-256-bit vectors
1457       if (!VT.is512BitVector())
1458         continue;
1459
1460       setOperationAction(ISD::SELECT, VT, Promote);
1461       AddPromotedToType (ISD::SELECT, VT, MVT::v8i64);
1462     }
1463   }// has  AVX-512
1464
1465   // SIGN_EXTEND_INREGs are evaluated by the extend type. Handle the expansion
1466   // of this type with custom code.
1467   for (int VT = MVT::FIRST_VECTOR_VALUETYPE;
1468            VT != MVT::LAST_VECTOR_VALUETYPE; VT++) {
1469     setOperationAction(ISD::SIGN_EXTEND_INREG, (MVT::SimpleValueType)VT,
1470                        Custom);
1471   }
1472
1473   // We want to custom lower some of our intrinsics.
1474   setOperationAction(ISD::INTRINSIC_WO_CHAIN, MVT::Other, Custom);
1475   setOperationAction(ISD::INTRINSIC_W_CHAIN, MVT::Other, Custom);
1476   setOperationAction(ISD::INTRINSIC_VOID, MVT::Other, Custom);
1477
1478   // Only custom-lower 64-bit SADDO and friends on 64-bit because we don't
1479   // handle type legalization for these operations here.
1480   //
1481   // FIXME: We really should do custom legalization for addition and
1482   // subtraction on x86-32 once PR3203 is fixed.  We really can't do much better
1483   // than generic legalization for 64-bit multiplication-with-overflow, though.
1484   for (unsigned i = 0, e = 3+Subtarget->is64Bit(); i != e; ++i) {
1485     // Add/Sub/Mul with overflow operations are custom lowered.
1486     MVT VT = IntVTs[i];
1487     setOperationAction(ISD::SADDO, VT, Custom);
1488     setOperationAction(ISD::UADDO, VT, Custom);
1489     setOperationAction(ISD::SSUBO, VT, Custom);
1490     setOperationAction(ISD::USUBO, VT, Custom);
1491     setOperationAction(ISD::SMULO, VT, Custom);
1492     setOperationAction(ISD::UMULO, VT, Custom);
1493   }
1494
1495   // There are no 8-bit 3-address imul/mul instructions
1496   setOperationAction(ISD::SMULO, MVT::i8, Expand);
1497   setOperationAction(ISD::UMULO, MVT::i8, Expand);
1498
1499   if (!Subtarget->is64Bit()) {
1500     // These libcalls are not available in 32-bit.
1501     setLibcallName(RTLIB::SHL_I128, 0);
1502     setLibcallName(RTLIB::SRL_I128, 0);
1503     setLibcallName(RTLIB::SRA_I128, 0);
1504   }
1505
1506   // Combine sin / cos into one node or libcall if possible.
1507   if (Subtarget->hasSinCos()) {
1508     setLibcallName(RTLIB::SINCOS_F32, "sincosf");
1509     setLibcallName(RTLIB::SINCOS_F64, "sincos");
1510     if (Subtarget->isTargetDarwin()) {
1511       // For MacOSX, we don't want to the normal expansion of a libcall to
1512       // sincos. We want to issue a libcall to __sincos_stret to avoid memory
1513       // traffic.
1514       setOperationAction(ISD::FSINCOS, MVT::f64, Custom);
1515       setOperationAction(ISD::FSINCOS, MVT::f32, Custom);
1516     }
1517   }
1518
1519   // We have target-specific dag combine patterns for the following nodes:
1520   setTargetDAGCombine(ISD::VECTOR_SHUFFLE);
1521   setTargetDAGCombine(ISD::EXTRACT_VECTOR_ELT);
1522   setTargetDAGCombine(ISD::VSELECT);
1523   setTargetDAGCombine(ISD::SELECT);
1524   setTargetDAGCombine(ISD::SHL);
1525   setTargetDAGCombine(ISD::SRA);
1526   setTargetDAGCombine(ISD::SRL);
1527   setTargetDAGCombine(ISD::OR);
1528   setTargetDAGCombine(ISD::AND);
1529   setTargetDAGCombine(ISD::ADD);
1530   setTargetDAGCombine(ISD::FADD);
1531   setTargetDAGCombine(ISD::FSUB);
1532   setTargetDAGCombine(ISD::FMA);
1533   setTargetDAGCombine(ISD::SUB);
1534   setTargetDAGCombine(ISD::LOAD);
1535   setTargetDAGCombine(ISD::STORE);
1536   setTargetDAGCombine(ISD::ZERO_EXTEND);
1537   setTargetDAGCombine(ISD::ANY_EXTEND);
1538   setTargetDAGCombine(ISD::SIGN_EXTEND);
1539   setTargetDAGCombine(ISD::SIGN_EXTEND_INREG);
1540   setTargetDAGCombine(ISD::TRUNCATE);
1541   setTargetDAGCombine(ISD::SINT_TO_FP);
1542   setTargetDAGCombine(ISD::SETCC);
1543   if (Subtarget->is64Bit())
1544     setTargetDAGCombine(ISD::MUL);
1545   setTargetDAGCombine(ISD::XOR);
1546
1547   computeRegisterProperties();
1548
1549   // On Darwin, -Os means optimize for size without hurting performance,
1550   // do not reduce the limit.
1551   MaxStoresPerMemset = 16; // For @llvm.memset -> sequence of stores
1552   MaxStoresPerMemsetOptSize = Subtarget->isTargetDarwin() ? 16 : 8;
1553   MaxStoresPerMemcpy = 8; // For @llvm.memcpy -> sequence of stores
1554   MaxStoresPerMemcpyOptSize = Subtarget->isTargetDarwin() ? 8 : 4;
1555   MaxStoresPerMemmove = 8; // For @llvm.memmove -> sequence of stores
1556   MaxStoresPerMemmoveOptSize = Subtarget->isTargetDarwin() ? 8 : 4;
1557   setPrefLoopAlignment(4); // 2^4 bytes.
1558
1559   // Predictable cmov don't hurt on atom because it's in-order.
1560   PredictableSelectIsExpensive = !Subtarget->isAtom();
1561
1562   setPrefFunctionAlignment(4); // 2^4 bytes.
1563 }
1564
1565 EVT X86TargetLowering::getSetCCResultType(LLVMContext &, EVT VT) const {
1566   if (!VT.isVector())
1567     return Subtarget->hasAVX512() ? MVT::i1: MVT::i8;
1568
1569   if (Subtarget->hasAVX512())
1570     switch(VT.getVectorNumElements()) {
1571     case  8: return MVT::v8i1;
1572     case 16: return MVT::v16i1;
1573   }
1574
1575   return VT.changeVectorElementTypeToInteger();
1576 }
1577
1578 /// getMaxByValAlign - Helper for getByValTypeAlignment to determine
1579 /// the desired ByVal argument alignment.
1580 static void getMaxByValAlign(Type *Ty, unsigned &MaxAlign) {
1581   if (MaxAlign == 16)
1582     return;
1583   if (VectorType *VTy = dyn_cast<VectorType>(Ty)) {
1584     if (VTy->getBitWidth() == 128)
1585       MaxAlign = 16;
1586   } else if (ArrayType *ATy = dyn_cast<ArrayType>(Ty)) {
1587     unsigned EltAlign = 0;
1588     getMaxByValAlign(ATy->getElementType(), EltAlign);
1589     if (EltAlign > MaxAlign)
1590       MaxAlign = EltAlign;
1591   } else if (StructType *STy = dyn_cast<StructType>(Ty)) {
1592     for (unsigned i = 0, e = STy->getNumElements(); i != e; ++i) {
1593       unsigned EltAlign = 0;
1594       getMaxByValAlign(STy->getElementType(i), EltAlign);
1595       if (EltAlign > MaxAlign)
1596         MaxAlign = EltAlign;
1597       if (MaxAlign == 16)
1598         break;
1599     }
1600   }
1601 }
1602
1603 /// getByValTypeAlignment - Return the desired alignment for ByVal aggregate
1604 /// function arguments in the caller parameter area. For X86, aggregates
1605 /// that contain SSE vectors are placed at 16-byte boundaries while the rest
1606 /// are at 4-byte boundaries.
1607 unsigned X86TargetLowering::getByValTypeAlignment(Type *Ty) const {
1608   if (Subtarget->is64Bit()) {
1609     // Max of 8 and alignment of type.
1610     unsigned TyAlign = TD->getABITypeAlignment(Ty);
1611     if (TyAlign > 8)
1612       return TyAlign;
1613     return 8;
1614   }
1615
1616   unsigned Align = 4;
1617   if (Subtarget->hasSSE1())
1618     getMaxByValAlign(Ty, Align);
1619   return Align;
1620 }
1621
1622 /// getOptimalMemOpType - Returns the target specific optimal type for load
1623 /// and store operations as a result of memset, memcpy, and memmove
1624 /// lowering. If DstAlign is zero that means it's safe to destination
1625 /// alignment can satisfy any constraint. Similarly if SrcAlign is zero it
1626 /// means there isn't a need to check it against alignment requirement,
1627 /// probably because the source does not need to be loaded. If 'IsMemset' is
1628 /// true, that means it's expanding a memset. If 'ZeroMemset' is true, that
1629 /// means it's a memset of zero. 'MemcpyStrSrc' indicates whether the memcpy
1630 /// source is constant so it does not need to be loaded.
1631 /// It returns EVT::Other if the type should be determined using generic
1632 /// target-independent logic.
1633 EVT
1634 X86TargetLowering::getOptimalMemOpType(uint64_t Size,
1635                                        unsigned DstAlign, unsigned SrcAlign,
1636                                        bool IsMemset, bool ZeroMemset,
1637                                        bool MemcpyStrSrc,
1638                                        MachineFunction &MF) const {
1639   const Function *F = MF.getFunction();
1640   if ((!IsMemset || ZeroMemset) &&
1641       !F->getAttributes().hasAttribute(AttributeSet::FunctionIndex,
1642                                        Attribute::NoImplicitFloat)) {
1643     if (Size >= 16 &&
1644         (Subtarget->isUnalignedMemAccessFast() ||
1645          ((DstAlign == 0 || DstAlign >= 16) &&
1646           (SrcAlign == 0 || SrcAlign >= 16)))) {
1647       if (Size >= 32) {
1648         if (Subtarget->hasInt256())
1649           return MVT::v8i32;
1650         if (Subtarget->hasFp256())
1651           return MVT::v8f32;
1652       }
1653       if (Subtarget->hasSSE2())
1654         return MVT::v4i32;
1655       if (Subtarget->hasSSE1())
1656         return MVT::v4f32;
1657     } else if (!MemcpyStrSrc && Size >= 8 &&
1658                !Subtarget->is64Bit() &&
1659                Subtarget->hasSSE2()) {
1660       // Do not use f64 to lower memcpy if source is string constant. It's
1661       // better to use i32 to avoid the loads.
1662       return MVT::f64;
1663     }
1664   }
1665   if (Subtarget->is64Bit() && Size >= 8)
1666     return MVT::i64;
1667   return MVT::i32;
1668 }
1669
1670 bool X86TargetLowering::isSafeMemOpType(MVT VT) const {
1671   if (VT == MVT::f32)
1672     return X86ScalarSSEf32;
1673   else if (VT == MVT::f64)
1674     return X86ScalarSSEf64;
1675   return true;
1676 }
1677
1678 bool
1679 X86TargetLowering::allowsUnalignedMemoryAccesses(EVT VT,
1680                                                  unsigned,
1681                                                  bool *Fast) const {
1682   if (Fast)
1683     *Fast = Subtarget->isUnalignedMemAccessFast();
1684   return true;
1685 }
1686
1687 /// getJumpTableEncoding - Return the entry encoding for a jump table in the
1688 /// current function.  The returned value is a member of the
1689 /// MachineJumpTableInfo::JTEntryKind enum.
1690 unsigned X86TargetLowering::getJumpTableEncoding() const {
1691   // In GOT pic mode, each entry in the jump table is emitted as a @GOTOFF
1692   // symbol.
1693   if (getTargetMachine().getRelocationModel() == Reloc::PIC_ &&
1694       Subtarget->isPICStyleGOT())
1695     return MachineJumpTableInfo::EK_Custom32;
1696
1697   // Otherwise, use the normal jump table encoding heuristics.
1698   return TargetLowering::getJumpTableEncoding();
1699 }
1700
1701 const MCExpr *
1702 X86TargetLowering::LowerCustomJumpTableEntry(const MachineJumpTableInfo *MJTI,
1703                                              const MachineBasicBlock *MBB,
1704                                              unsigned uid,MCContext &Ctx) const{
1705   assert(getTargetMachine().getRelocationModel() == Reloc::PIC_ &&
1706          Subtarget->isPICStyleGOT());
1707   // In 32-bit ELF systems, our jump table entries are formed with @GOTOFF
1708   // entries.
1709   return MCSymbolRefExpr::Create(MBB->getSymbol(),
1710                                  MCSymbolRefExpr::VK_GOTOFF, Ctx);
1711 }
1712
1713 /// getPICJumpTableRelocaBase - Returns relocation base for the given PIC
1714 /// jumptable.
1715 SDValue X86TargetLowering::getPICJumpTableRelocBase(SDValue Table,
1716                                                     SelectionDAG &DAG) const {
1717   if (!Subtarget->is64Bit())
1718     // This doesn't have SDLoc associated with it, but is not really the
1719     // same as a Register.
1720     return DAG.getNode(X86ISD::GlobalBaseReg, SDLoc(), getPointerTy());
1721   return Table;
1722 }
1723
1724 /// getPICJumpTableRelocBaseExpr - This returns the relocation base for the
1725 /// given PIC jumptable, the same as getPICJumpTableRelocBase, but as an
1726 /// MCExpr.
1727 const MCExpr *X86TargetLowering::
1728 getPICJumpTableRelocBaseExpr(const MachineFunction *MF, unsigned JTI,
1729                              MCContext &Ctx) const {
1730   // X86-64 uses RIP relative addressing based on the jump table label.
1731   if (Subtarget->isPICStyleRIPRel())
1732     return TargetLowering::getPICJumpTableRelocBaseExpr(MF, JTI, Ctx);
1733
1734   // Otherwise, the reference is relative to the PIC base.
1735   return MCSymbolRefExpr::Create(MF->getPICBaseSymbol(), Ctx);
1736 }
1737
1738 // FIXME: Why this routine is here? Move to RegInfo!
1739 std::pair<const TargetRegisterClass*, uint8_t>
1740 X86TargetLowering::findRepresentativeClass(MVT VT) const{
1741   const TargetRegisterClass *RRC = 0;
1742   uint8_t Cost = 1;
1743   switch (VT.SimpleTy) {
1744   default:
1745     return TargetLowering::findRepresentativeClass(VT);
1746   case MVT::i8: case MVT::i16: case MVT::i32: case MVT::i64:
1747     RRC = Subtarget->is64Bit() ?
1748       (const TargetRegisterClass*)&X86::GR64RegClass :
1749       (const TargetRegisterClass*)&X86::GR32RegClass;
1750     break;
1751   case MVT::x86mmx:
1752     RRC = &X86::VR64RegClass;
1753     break;
1754   case MVT::f32: case MVT::f64:
1755   case MVT::v16i8: case MVT::v8i16: case MVT::v4i32: case MVT::v2i64:
1756   case MVT::v4f32: case MVT::v2f64:
1757   case MVT::v32i8: case MVT::v8i32: case MVT::v4i64: case MVT::v8f32:
1758   case MVT::v4f64:
1759     RRC = &X86::VR128RegClass;
1760     break;
1761   }
1762   return std::make_pair(RRC, Cost);
1763 }
1764
1765 bool X86TargetLowering::getStackCookieLocation(unsigned &AddressSpace,
1766                                                unsigned &Offset) const {
1767   if (!Subtarget->isTargetLinux())
1768     return false;
1769
1770   if (Subtarget->is64Bit()) {
1771     // %fs:0x28, unless we're using a Kernel code model, in which case it's %gs:
1772     Offset = 0x28;
1773     if (getTargetMachine().getCodeModel() == CodeModel::Kernel)
1774       AddressSpace = 256;
1775     else
1776       AddressSpace = 257;
1777   } else {
1778     // %gs:0x14 on i386
1779     Offset = 0x14;
1780     AddressSpace = 256;
1781   }
1782   return true;
1783 }
1784
1785 bool X86TargetLowering::isNoopAddrSpaceCast(unsigned SrcAS,
1786                                             unsigned DestAS) const {
1787   assert(SrcAS != DestAS && "Expected different address spaces!");
1788
1789   return SrcAS < 256 && DestAS < 256;
1790 }
1791
1792 //===----------------------------------------------------------------------===//
1793 //               Return Value Calling Convention Implementation
1794 //===----------------------------------------------------------------------===//
1795
1796 #include "X86GenCallingConv.inc"
1797
1798 bool
1799 X86TargetLowering::CanLowerReturn(CallingConv::ID CallConv,
1800                                   MachineFunction &MF, bool isVarArg,
1801                         const SmallVectorImpl<ISD::OutputArg> &Outs,
1802                         LLVMContext &Context) const {
1803   SmallVector<CCValAssign, 16> RVLocs;
1804   CCState CCInfo(CallConv, isVarArg, MF, getTargetMachine(),
1805                  RVLocs, Context);
1806   return CCInfo.CheckReturn(Outs, RetCC_X86);
1807 }
1808
1809 const uint16_t *X86TargetLowering::getScratchRegisters(CallingConv::ID) const {
1810   static const uint16_t ScratchRegs[] = { X86::R11, 0 };
1811   return ScratchRegs;
1812 }
1813
1814 SDValue
1815 X86TargetLowering::LowerReturn(SDValue Chain,
1816                                CallingConv::ID CallConv, bool isVarArg,
1817                                const SmallVectorImpl<ISD::OutputArg> &Outs,
1818                                const SmallVectorImpl<SDValue> &OutVals,
1819                                SDLoc dl, SelectionDAG &DAG) const {
1820   MachineFunction &MF = DAG.getMachineFunction();
1821   X86MachineFunctionInfo *FuncInfo = MF.getInfo<X86MachineFunctionInfo>();
1822
1823   SmallVector<CCValAssign, 16> RVLocs;
1824   CCState CCInfo(CallConv, isVarArg, MF, getTargetMachine(),
1825                  RVLocs, *DAG.getContext());
1826   CCInfo.AnalyzeReturn(Outs, RetCC_X86);
1827
1828   SDValue Flag;
1829   SmallVector<SDValue, 6> RetOps;
1830   RetOps.push_back(Chain); // Operand #0 = Chain (updated below)
1831   // Operand #1 = Bytes To Pop
1832   RetOps.push_back(DAG.getTargetConstant(FuncInfo->getBytesToPopOnReturn(),
1833                    MVT::i16));
1834
1835   // Copy the result values into the output registers.
1836   for (unsigned i = 0; i != RVLocs.size(); ++i) {
1837     CCValAssign &VA = RVLocs[i];
1838     assert(VA.isRegLoc() && "Can only return in registers!");
1839     SDValue ValToCopy = OutVals[i];
1840     EVT ValVT = ValToCopy.getValueType();
1841
1842     // Promote values to the appropriate types
1843     if (VA.getLocInfo() == CCValAssign::SExt)
1844       ValToCopy = DAG.getNode(ISD::SIGN_EXTEND, dl, VA.getLocVT(), ValToCopy);
1845     else if (VA.getLocInfo() == CCValAssign::ZExt)
1846       ValToCopy = DAG.getNode(ISD::ZERO_EXTEND, dl, VA.getLocVT(), ValToCopy);
1847     else if (VA.getLocInfo() == CCValAssign::AExt)
1848       ValToCopy = DAG.getNode(ISD::ANY_EXTEND, dl, VA.getLocVT(), ValToCopy);
1849     else if (VA.getLocInfo() == CCValAssign::BCvt)
1850       ValToCopy = DAG.getNode(ISD::BITCAST, dl, VA.getLocVT(), ValToCopy);
1851
1852     assert(VA.getLocInfo() != CCValAssign::FPExt &&
1853            "Unexpected FP-extend for return value.");  
1854
1855     // If this is x86-64, and we disabled SSE, we can't return FP values,
1856     // or SSE or MMX vectors.
1857     if ((ValVT == MVT::f32 || ValVT == MVT::f64 ||
1858          VA.getLocReg() == X86::XMM0 || VA.getLocReg() == X86::XMM1) &&
1859           (Subtarget->is64Bit() && !Subtarget->hasSSE1())) {
1860       report_fatal_error("SSE register return with SSE disabled");
1861     }
1862     // Likewise we can't return F64 values with SSE1 only.  gcc does so, but
1863     // llvm-gcc has never done it right and no one has noticed, so this
1864     // should be OK for now.
1865     if (ValVT == MVT::f64 &&
1866         (Subtarget->is64Bit() && !Subtarget->hasSSE2()))
1867       report_fatal_error("SSE2 register return with SSE2 disabled");
1868
1869     // Returns in ST0/ST1 are handled specially: these are pushed as operands to
1870     // the RET instruction and handled by the FP Stackifier.
1871     if (VA.getLocReg() == X86::ST0 ||
1872         VA.getLocReg() == X86::ST1) {
1873       // If this is a copy from an xmm register to ST(0), use an FPExtend to
1874       // change the value to the FP stack register class.
1875       if (isScalarFPTypeInSSEReg(VA.getValVT()))
1876         ValToCopy = DAG.getNode(ISD::FP_EXTEND, dl, MVT::f80, ValToCopy);
1877       RetOps.push_back(ValToCopy);
1878       // Don't emit a copytoreg.
1879       continue;
1880     }
1881
1882     // 64-bit vector (MMX) values are returned in XMM0 / XMM1 except for v1i64
1883     // which is returned in RAX / RDX.
1884     if (Subtarget->is64Bit()) {
1885       if (ValVT == MVT::x86mmx) {
1886         if (VA.getLocReg() == X86::XMM0 || VA.getLocReg() == X86::XMM1) {
1887           ValToCopy = DAG.getNode(ISD::BITCAST, dl, MVT::i64, ValToCopy);
1888           ValToCopy = DAG.getNode(ISD::SCALAR_TO_VECTOR, dl, MVT::v2i64,
1889                                   ValToCopy);
1890           // If we don't have SSE2 available, convert to v4f32 so the generated
1891           // register is legal.
1892           if (!Subtarget->hasSSE2())
1893             ValToCopy = DAG.getNode(ISD::BITCAST, dl, MVT::v4f32,ValToCopy);
1894         }
1895       }
1896     }
1897
1898     Chain = DAG.getCopyToReg(Chain, dl, VA.getLocReg(), ValToCopy, Flag);
1899     Flag = Chain.getValue(1);
1900     RetOps.push_back(DAG.getRegister(VA.getLocReg(), VA.getLocVT()));
1901   }
1902
1903   // The x86-64 ABIs require that for returning structs by value we copy
1904   // the sret argument into %rax/%eax (depending on ABI) for the return.
1905   // Win32 requires us to put the sret argument to %eax as well.
1906   // We saved the argument into a virtual register in the entry block,
1907   // so now we copy the value out and into %rax/%eax.
1908   if (DAG.getMachineFunction().getFunction()->hasStructRetAttr() &&
1909       (Subtarget->is64Bit() || Subtarget->isTargetWindows())) {
1910     MachineFunction &MF = DAG.getMachineFunction();
1911     X86MachineFunctionInfo *FuncInfo = MF.getInfo<X86MachineFunctionInfo>();
1912     unsigned Reg = FuncInfo->getSRetReturnReg();
1913     assert(Reg &&
1914            "SRetReturnReg should have been set in LowerFormalArguments().");
1915     SDValue Val = DAG.getCopyFromReg(Chain, dl, Reg, getPointerTy());
1916
1917     unsigned RetValReg
1918         = (Subtarget->is64Bit() && !Subtarget->isTarget64BitILP32()) ?
1919           X86::RAX : X86::EAX;
1920     Chain = DAG.getCopyToReg(Chain, dl, RetValReg, Val, Flag);
1921     Flag = Chain.getValue(1);
1922
1923     // RAX/EAX now acts like a return value.
1924     RetOps.push_back(DAG.getRegister(RetValReg, getPointerTy()));
1925   }
1926
1927   RetOps[0] = Chain;  // Update chain.
1928
1929   // Add the flag if we have it.
1930   if (Flag.getNode())
1931     RetOps.push_back(Flag);
1932
1933   return DAG.getNode(X86ISD::RET_FLAG, dl,
1934                      MVT::Other, &RetOps[0], RetOps.size());
1935 }
1936
1937 bool X86TargetLowering::isUsedByReturnOnly(SDNode *N, SDValue &Chain) const {
1938   if (N->getNumValues() != 1)
1939     return false;
1940   if (!N->hasNUsesOfValue(1, 0))
1941     return false;
1942
1943   SDValue TCChain = Chain;
1944   SDNode *Copy = *N->use_begin();
1945   if (Copy->getOpcode() == ISD::CopyToReg) {
1946     // If the copy has a glue operand, we conservatively assume it isn't safe to
1947     // perform a tail call.
1948     if (Copy->getOperand(Copy->getNumOperands()-1).getValueType() == MVT::Glue)
1949       return false;
1950     TCChain = Copy->getOperand(0);
1951   } else if (Copy->getOpcode() != ISD::FP_EXTEND)
1952     return false;
1953
1954   bool HasRet = false;
1955   for (SDNode::use_iterator UI = Copy->use_begin(), UE = Copy->use_end();
1956        UI != UE; ++UI) {
1957     if (UI->getOpcode() != X86ISD::RET_FLAG)
1958       return false;
1959     HasRet = true;
1960   }
1961
1962   if (!HasRet)
1963     return false;
1964
1965   Chain = TCChain;
1966   return true;
1967 }
1968
1969 MVT
1970 X86TargetLowering::getTypeForExtArgOrReturn(MVT VT,
1971                                             ISD::NodeType ExtendKind) const {
1972   MVT ReturnMVT;
1973   // TODO: Is this also valid on 32-bit?
1974   if (Subtarget->is64Bit() && VT == MVT::i1 && ExtendKind == ISD::ZERO_EXTEND)
1975     ReturnMVT = MVT::i8;
1976   else
1977     ReturnMVT = MVT::i32;
1978
1979   MVT MinVT = getRegisterType(ReturnMVT);
1980   return VT.bitsLT(MinVT) ? MinVT : VT;
1981 }
1982
1983 /// LowerCallResult - Lower the result values of a call into the
1984 /// appropriate copies out of appropriate physical registers.
1985 ///
1986 SDValue
1987 X86TargetLowering::LowerCallResult(SDValue Chain, SDValue InFlag,
1988                                    CallingConv::ID CallConv, bool isVarArg,
1989                                    const SmallVectorImpl<ISD::InputArg> &Ins,
1990                                    SDLoc dl, SelectionDAG &DAG,
1991                                    SmallVectorImpl<SDValue> &InVals) const {
1992
1993   // Assign locations to each value returned by this call.
1994   SmallVector<CCValAssign, 16> RVLocs;
1995   bool Is64Bit = Subtarget->is64Bit();
1996   CCState CCInfo(CallConv, isVarArg, DAG.getMachineFunction(),
1997                  getTargetMachine(), RVLocs, *DAG.getContext());
1998   CCInfo.AnalyzeCallResult(Ins, RetCC_X86);
1999
2000   // Copy all of the result registers out of their specified physreg.
2001   for (unsigned i = 0, e = RVLocs.size(); i != e; ++i) {
2002     CCValAssign &VA = RVLocs[i];
2003     EVT CopyVT = VA.getValVT();
2004
2005     // If this is x86-64, and we disabled SSE, we can't return FP values
2006     if ((CopyVT == MVT::f32 || CopyVT == MVT::f64) &&
2007         ((Is64Bit || Ins[i].Flags.isInReg()) && !Subtarget->hasSSE1())) {
2008       report_fatal_error("SSE register return with SSE disabled");
2009     }
2010
2011     SDValue Val;
2012
2013     // If this is a call to a function that returns an fp value on the floating
2014     // point stack, we must guarantee the value is popped from the stack, so
2015     // a CopyFromReg is not good enough - the copy instruction may be eliminated
2016     // if the return value is not used. We use the FpPOP_RETVAL instruction
2017     // instead.
2018     if (VA.getLocReg() == X86::ST0 || VA.getLocReg() == X86::ST1) {
2019       // If we prefer to use the value in xmm registers, copy it out as f80 and
2020       // use a truncate to move it from fp stack reg to xmm reg.
2021       if (isScalarFPTypeInSSEReg(VA.getValVT())) CopyVT = MVT::f80;
2022       SDValue Ops[] = { Chain, InFlag };
2023       Chain = SDValue(DAG.getMachineNode(X86::FpPOP_RETVAL, dl, CopyVT,
2024                                          MVT::Other, MVT::Glue, Ops), 1);
2025       Val = Chain.getValue(0);
2026
2027       // Round the f80 to the right size, which also moves it to the appropriate
2028       // xmm register.
2029       if (CopyVT != VA.getValVT())
2030         Val = DAG.getNode(ISD::FP_ROUND, dl, VA.getValVT(), Val,
2031                           // This truncation won't change the value.
2032                           DAG.getIntPtrConstant(1));
2033     } else {
2034       Chain = DAG.getCopyFromReg(Chain, dl, VA.getLocReg(),
2035                                  CopyVT, InFlag).getValue(1);
2036       Val = Chain.getValue(0);
2037     }
2038     InFlag = Chain.getValue(2);
2039     InVals.push_back(Val);
2040   }
2041
2042   return Chain;
2043 }
2044
2045 //===----------------------------------------------------------------------===//
2046 //                C & StdCall & Fast Calling Convention implementation
2047 //===----------------------------------------------------------------------===//
2048 //  StdCall calling convention seems to be standard for many Windows' API
2049 //  routines and around. It differs from C calling convention just a little:
2050 //  callee should clean up the stack, not caller. Symbols should be also
2051 //  decorated in some fancy way :) It doesn't support any vector arguments.
2052 //  For info on fast calling convention see Fast Calling Convention (tail call)
2053 //  implementation LowerX86_32FastCCCallTo.
2054
2055 /// CallIsStructReturn - Determines whether a call uses struct return
2056 /// semantics.
2057 enum StructReturnType {
2058   NotStructReturn,
2059   RegStructReturn,
2060   StackStructReturn
2061 };
2062 static StructReturnType
2063 callIsStructReturn(const SmallVectorImpl<ISD::OutputArg> &Outs) {
2064   if (Outs.empty())
2065     return NotStructReturn;
2066
2067   const ISD::ArgFlagsTy &Flags = Outs[0].Flags;
2068   if (!Flags.isSRet())
2069     return NotStructReturn;
2070   if (Flags.isInReg())
2071     return RegStructReturn;
2072   return StackStructReturn;
2073 }
2074
2075 /// ArgsAreStructReturn - Determines whether a function uses struct
2076 /// return semantics.
2077 static StructReturnType
2078 argsAreStructReturn(const SmallVectorImpl<ISD::InputArg> &Ins) {
2079   if (Ins.empty())
2080     return NotStructReturn;
2081
2082   const ISD::ArgFlagsTy &Flags = Ins[0].Flags;
2083   if (!Flags.isSRet())
2084     return NotStructReturn;
2085   if (Flags.isInReg())
2086     return RegStructReturn;
2087   return StackStructReturn;
2088 }
2089
2090 /// CreateCopyOfByValArgument - Make a copy of an aggregate at address specified
2091 /// by "Src" to address "Dst" with size and alignment information specified by
2092 /// the specific parameter attribute. The copy will be passed as a byval
2093 /// function parameter.
2094 static SDValue
2095 CreateCopyOfByValArgument(SDValue Src, SDValue Dst, SDValue Chain,
2096                           ISD::ArgFlagsTy Flags, SelectionDAG &DAG,
2097                           SDLoc dl) {
2098   SDValue SizeNode = DAG.getConstant(Flags.getByValSize(), MVT::i32);
2099
2100   return DAG.getMemcpy(Chain, dl, Dst, Src, SizeNode, Flags.getByValAlign(),
2101                        /*isVolatile*/false, /*AlwaysInline=*/true,
2102                        MachinePointerInfo(), MachinePointerInfo());
2103 }
2104
2105 /// IsTailCallConvention - Return true if the calling convention is one that
2106 /// supports tail call optimization.
2107 static bool IsTailCallConvention(CallingConv::ID CC) {
2108   return (CC == CallingConv::Fast || CC == CallingConv::GHC ||
2109           CC == CallingConv::HiPE);
2110 }
2111
2112 /// \brief Return true if the calling convention is a C calling convention.
2113 static bool IsCCallConvention(CallingConv::ID CC) {
2114   return (CC == CallingConv::C || CC == CallingConv::X86_64_Win64 ||
2115           CC == CallingConv::X86_64_SysV);
2116 }
2117
2118 bool X86TargetLowering::mayBeEmittedAsTailCall(CallInst *CI) const {
2119   if (!CI->isTailCall() || getTargetMachine().Options.DisableTailCalls)
2120     return false;
2121
2122   CallSite CS(CI);
2123   CallingConv::ID CalleeCC = CS.getCallingConv();
2124   if (!IsTailCallConvention(CalleeCC) && !IsCCallConvention(CalleeCC))
2125     return false;
2126
2127   return true;
2128 }
2129
2130 /// FuncIsMadeTailCallSafe - Return true if the function is being made into
2131 /// a tailcall target by changing its ABI.
2132 static bool FuncIsMadeTailCallSafe(CallingConv::ID CC,
2133                                    bool GuaranteedTailCallOpt) {
2134   return GuaranteedTailCallOpt && IsTailCallConvention(CC);
2135 }
2136
2137 SDValue
2138 X86TargetLowering::LowerMemArgument(SDValue Chain,
2139                                     CallingConv::ID CallConv,
2140                                     const SmallVectorImpl<ISD::InputArg> &Ins,
2141                                     SDLoc dl, SelectionDAG &DAG,
2142                                     const CCValAssign &VA,
2143                                     MachineFrameInfo *MFI,
2144                                     unsigned i) const {
2145   // Create the nodes corresponding to a load from this parameter slot.
2146   ISD::ArgFlagsTy Flags = Ins[i].Flags;
2147   bool AlwaysUseMutable = FuncIsMadeTailCallSafe(CallConv,
2148                               getTargetMachine().Options.GuaranteedTailCallOpt);
2149   bool isImmutable = !AlwaysUseMutable && !Flags.isByVal();
2150   EVT ValVT;
2151
2152   // If value is passed by pointer we have address passed instead of the value
2153   // itself.
2154   if (VA.getLocInfo() == CCValAssign::Indirect)
2155     ValVT = VA.getLocVT();
2156   else
2157     ValVT = VA.getValVT();
2158
2159   // FIXME: For now, all byval parameter objects are marked mutable. This can be
2160   // changed with more analysis.
2161   // In case of tail call optimization mark all arguments mutable. Since they
2162   // could be overwritten by lowering of arguments in case of a tail call.
2163   if (Flags.isByVal()) {
2164     unsigned Bytes = Flags.getByValSize();
2165     if (Bytes == 0) Bytes = 1; // Don't create zero-sized stack objects.
2166     int FI = MFI->CreateFixedObject(Bytes, VA.getLocMemOffset(), isImmutable);
2167     return DAG.getFrameIndex(FI, getPointerTy());
2168   } else {
2169     int FI = MFI->CreateFixedObject(ValVT.getSizeInBits()/8,
2170                                     VA.getLocMemOffset(), isImmutable);
2171     SDValue FIN = DAG.getFrameIndex(FI, getPointerTy());
2172     return DAG.getLoad(ValVT, dl, Chain, FIN,
2173                        MachinePointerInfo::getFixedStack(FI),
2174                        false, false, false, 0);
2175   }
2176 }
2177
2178 SDValue
2179 X86TargetLowering::LowerFormalArguments(SDValue Chain,
2180                                         CallingConv::ID CallConv,
2181                                         bool isVarArg,
2182                                       const SmallVectorImpl<ISD::InputArg> &Ins,
2183                                         SDLoc dl,
2184                                         SelectionDAG &DAG,
2185                                         SmallVectorImpl<SDValue> &InVals)
2186                                           const {
2187   MachineFunction &MF = DAG.getMachineFunction();
2188   X86MachineFunctionInfo *FuncInfo = MF.getInfo<X86MachineFunctionInfo>();
2189
2190   const Function* Fn = MF.getFunction();
2191   if (Fn->hasExternalLinkage() &&
2192       Subtarget->isTargetCygMing() &&
2193       Fn->getName() == "main")
2194     FuncInfo->setForceFramePointer(true);
2195
2196   MachineFrameInfo *MFI = MF.getFrameInfo();
2197   bool Is64Bit = Subtarget->is64Bit();
2198   bool IsWin64 = Subtarget->isCallingConvWin64(CallConv);
2199
2200   assert(!(isVarArg && IsTailCallConvention(CallConv)) &&
2201          "Var args not supported with calling convention fastcc, ghc or hipe");
2202
2203   // Assign locations to all of the incoming arguments.
2204   SmallVector<CCValAssign, 16> ArgLocs;
2205   CCState CCInfo(CallConv, isVarArg, MF, getTargetMachine(),
2206                  ArgLocs, *DAG.getContext());
2207
2208   // Allocate shadow area for Win64
2209   if (IsWin64)
2210     CCInfo.AllocateStack(32, 8);
2211
2212   CCInfo.AnalyzeFormalArguments(Ins, CC_X86);
2213
2214   unsigned LastVal = ~0U;
2215   SDValue ArgValue;
2216   for (unsigned i = 0, e = ArgLocs.size(); i != e; ++i) {
2217     CCValAssign &VA = ArgLocs[i];
2218     // TODO: If an arg is passed in two places (e.g. reg and stack), skip later
2219     // places.
2220     assert(VA.getValNo() != LastVal &&
2221            "Don't support value assigned to multiple locs yet");
2222     (void)LastVal;
2223     LastVal = VA.getValNo();
2224
2225     if (VA.isRegLoc()) {
2226       EVT RegVT = VA.getLocVT();
2227       const TargetRegisterClass *RC;
2228       if (RegVT == MVT::i32)
2229         RC = &X86::GR32RegClass;
2230       else if (Is64Bit && RegVT == MVT::i64)
2231         RC = &X86::GR64RegClass;
2232       else if (RegVT == MVT::f32)
2233         RC = &X86::FR32RegClass;
2234       else if (RegVT == MVT::f64)
2235         RC = &X86::FR64RegClass;
2236       else if (RegVT.is512BitVector())
2237         RC = &X86::VR512RegClass;
2238       else if (RegVT.is256BitVector())
2239         RC = &X86::VR256RegClass;
2240       else if (RegVT.is128BitVector())
2241         RC = &X86::VR128RegClass;
2242       else if (RegVT == MVT::x86mmx)
2243         RC = &X86::VR64RegClass;
2244       else if (RegVT == MVT::i1)
2245         RC = &X86::VK1RegClass;
2246       else if (RegVT == MVT::v8i1)
2247         RC = &X86::VK8RegClass;
2248       else if (RegVT == MVT::v16i1)
2249         RC = &X86::VK16RegClass;
2250       else
2251         llvm_unreachable("Unknown argument type!");
2252
2253       unsigned Reg = MF.addLiveIn(VA.getLocReg(), RC);
2254       ArgValue = DAG.getCopyFromReg(Chain, dl, Reg, RegVT);
2255
2256       // If this is an 8 or 16-bit value, it is really passed promoted to 32
2257       // bits.  Insert an assert[sz]ext to capture this, then truncate to the
2258       // right size.
2259       if (VA.getLocInfo() == CCValAssign::SExt)
2260         ArgValue = DAG.getNode(ISD::AssertSext, dl, RegVT, ArgValue,
2261                                DAG.getValueType(VA.getValVT()));
2262       else if (VA.getLocInfo() == CCValAssign::ZExt)
2263         ArgValue = DAG.getNode(ISD::AssertZext, dl, RegVT, ArgValue,
2264                                DAG.getValueType(VA.getValVT()));
2265       else if (VA.getLocInfo() == CCValAssign::BCvt)
2266         ArgValue = DAG.getNode(ISD::BITCAST, dl, VA.getValVT(), ArgValue);
2267
2268       if (VA.isExtInLoc()) {
2269         // Handle MMX values passed in XMM regs.
2270         if (RegVT.isVector())
2271           ArgValue = DAG.getNode(X86ISD::MOVDQ2Q, dl, VA.getValVT(), ArgValue);
2272         else
2273           ArgValue = DAG.getNode(ISD::TRUNCATE, dl, VA.getValVT(), ArgValue);
2274       }
2275     } else {
2276       assert(VA.isMemLoc());
2277       ArgValue = LowerMemArgument(Chain, CallConv, Ins, dl, DAG, VA, MFI, i);
2278     }
2279
2280     // If value is passed via pointer - do a load.
2281     if (VA.getLocInfo() == CCValAssign::Indirect)
2282       ArgValue = DAG.getLoad(VA.getValVT(), dl, Chain, ArgValue,
2283                              MachinePointerInfo(), false, false, false, 0);
2284
2285     InVals.push_back(ArgValue);
2286   }
2287
2288   // The x86-64 ABIs require that for returning structs by value we copy
2289   // the sret argument into %rax/%eax (depending on ABI) for the return.
2290   // Win32 requires us to put the sret argument to %eax as well.
2291   // Save the argument into a virtual register so that we can access it
2292   // from the return points.
2293   if (MF.getFunction()->hasStructRetAttr() &&
2294       (Subtarget->is64Bit() || Subtarget->isTargetWindows())) {
2295     X86MachineFunctionInfo *FuncInfo = MF.getInfo<X86MachineFunctionInfo>();
2296     unsigned Reg = FuncInfo->getSRetReturnReg();
2297     if (!Reg) {
2298       MVT PtrTy = getPointerTy();
2299       Reg = MF.getRegInfo().createVirtualRegister(getRegClassFor(PtrTy));
2300       FuncInfo->setSRetReturnReg(Reg);
2301     }
2302     SDValue Copy = DAG.getCopyToReg(DAG.getEntryNode(), dl, Reg, InVals[0]);
2303     Chain = DAG.getNode(ISD::TokenFactor, dl, MVT::Other, Copy, Chain);
2304   }
2305
2306   unsigned StackSize = CCInfo.getNextStackOffset();
2307   // Align stack specially for tail calls.
2308   if (FuncIsMadeTailCallSafe(CallConv,
2309                              MF.getTarget().Options.GuaranteedTailCallOpt))
2310     StackSize = GetAlignedArgumentStackSize(StackSize, DAG);
2311
2312   // If the function takes variable number of arguments, make a frame index for
2313   // the start of the first vararg value... for expansion of llvm.va_start.
2314   if (isVarArg) {
2315     if (Is64Bit || (CallConv != CallingConv::X86_FastCall &&
2316                     CallConv != CallingConv::X86_ThisCall)) {
2317       FuncInfo->setVarArgsFrameIndex(MFI->CreateFixedObject(1, StackSize,true));
2318     }
2319     if (Is64Bit) {
2320       unsigned TotalNumIntRegs = 0, TotalNumXMMRegs = 0;
2321
2322       // FIXME: We should really autogenerate these arrays
2323       static const uint16_t GPR64ArgRegsWin64[] = {
2324         X86::RCX, X86::RDX, X86::R8,  X86::R9
2325       };
2326       static const uint16_t GPR64ArgRegs64Bit[] = {
2327         X86::RDI, X86::RSI, X86::RDX, X86::RCX, X86::R8, X86::R9
2328       };
2329       static const uint16_t XMMArgRegs64Bit[] = {
2330         X86::XMM0, X86::XMM1, X86::XMM2, X86::XMM3,
2331         X86::XMM4, X86::XMM5, X86::XMM6, X86::XMM7
2332       };
2333       const uint16_t *GPR64ArgRegs;
2334       unsigned NumXMMRegs = 0;
2335
2336       if (IsWin64) {
2337         // The XMM registers which might contain var arg parameters are shadowed
2338         // in their paired GPR.  So we only need to save the GPR to their home
2339         // slots.
2340         TotalNumIntRegs = 4;
2341         GPR64ArgRegs = GPR64ArgRegsWin64;
2342       } else {
2343         TotalNumIntRegs = 6; TotalNumXMMRegs = 8;
2344         GPR64ArgRegs = GPR64ArgRegs64Bit;
2345
2346         NumXMMRegs = CCInfo.getFirstUnallocated(XMMArgRegs64Bit,
2347                                                 TotalNumXMMRegs);
2348       }
2349       unsigned NumIntRegs = CCInfo.getFirstUnallocated(GPR64ArgRegs,
2350                                                        TotalNumIntRegs);
2351
2352       bool NoImplicitFloatOps = Fn->getAttributes().
2353         hasAttribute(AttributeSet::FunctionIndex, Attribute::NoImplicitFloat);
2354       assert(!(NumXMMRegs && !Subtarget->hasSSE1()) &&
2355              "SSE register cannot be used when SSE is disabled!");
2356       assert(!(NumXMMRegs && MF.getTarget().Options.UseSoftFloat &&
2357                NoImplicitFloatOps) &&
2358              "SSE register cannot be used when SSE is disabled!");
2359       if (MF.getTarget().Options.UseSoftFloat || NoImplicitFloatOps ||
2360           !Subtarget->hasSSE1())
2361         // Kernel mode asks for SSE to be disabled, so don't push them
2362         // on the stack.
2363         TotalNumXMMRegs = 0;
2364
2365       if (IsWin64) {
2366         const TargetFrameLowering &TFI = *getTargetMachine().getFrameLowering();
2367         // Get to the caller-allocated home save location.  Add 8 to account
2368         // for the return address.
2369         int HomeOffset = TFI.getOffsetOfLocalArea() + 8;
2370         FuncInfo->setRegSaveFrameIndex(
2371           MFI->CreateFixedObject(1, NumIntRegs * 8 + HomeOffset, false));
2372         // Fixup to set vararg frame on shadow area (4 x i64).
2373         if (NumIntRegs < 4)
2374           FuncInfo->setVarArgsFrameIndex(FuncInfo->getRegSaveFrameIndex());
2375       } else {
2376         // For X86-64, if there are vararg parameters that are passed via
2377         // registers, then we must store them to their spots on the stack so
2378         // they may be loaded by deferencing the result of va_next.
2379         FuncInfo->setVarArgsGPOffset(NumIntRegs * 8);
2380         FuncInfo->setVarArgsFPOffset(TotalNumIntRegs * 8 + NumXMMRegs * 16);
2381         FuncInfo->setRegSaveFrameIndex(
2382           MFI->CreateStackObject(TotalNumIntRegs * 8 + TotalNumXMMRegs * 16, 16,
2383                                false));
2384       }
2385
2386       // Store the integer parameter registers.
2387       SmallVector<SDValue, 8> MemOps;
2388       SDValue RSFIN = DAG.getFrameIndex(FuncInfo->getRegSaveFrameIndex(),
2389                                         getPointerTy());
2390       unsigned Offset = FuncInfo->getVarArgsGPOffset();
2391       for (; NumIntRegs != TotalNumIntRegs; ++NumIntRegs) {
2392         SDValue FIN = DAG.getNode(ISD::ADD, dl, getPointerTy(), RSFIN,
2393                                   DAG.getIntPtrConstant(Offset));
2394         unsigned VReg = MF.addLiveIn(GPR64ArgRegs[NumIntRegs],
2395                                      &X86::GR64RegClass);
2396         SDValue Val = DAG.getCopyFromReg(Chain, dl, VReg, MVT::i64);
2397         SDValue Store =
2398           DAG.getStore(Val.getValue(1), dl, Val, FIN,
2399                        MachinePointerInfo::getFixedStack(
2400                          FuncInfo->getRegSaveFrameIndex(), Offset),
2401                        false, false, 0);
2402         MemOps.push_back(Store);
2403         Offset += 8;
2404       }
2405
2406       if (TotalNumXMMRegs != 0 && NumXMMRegs != TotalNumXMMRegs) {
2407         // Now store the XMM (fp + vector) parameter registers.
2408         SmallVector<SDValue, 11> SaveXMMOps;
2409         SaveXMMOps.push_back(Chain);
2410
2411         unsigned AL = MF.addLiveIn(X86::AL, &X86::GR8RegClass);
2412         SDValue ALVal = DAG.getCopyFromReg(DAG.getEntryNode(), dl, AL, MVT::i8);
2413         SaveXMMOps.push_back(ALVal);
2414
2415         SaveXMMOps.push_back(DAG.getIntPtrConstant(
2416                                FuncInfo->getRegSaveFrameIndex()));
2417         SaveXMMOps.push_back(DAG.getIntPtrConstant(
2418                                FuncInfo->getVarArgsFPOffset()));
2419
2420         for (; NumXMMRegs != TotalNumXMMRegs; ++NumXMMRegs) {
2421           unsigned VReg = MF.addLiveIn(XMMArgRegs64Bit[NumXMMRegs],
2422                                        &X86::VR128RegClass);
2423           SDValue Val = DAG.getCopyFromReg(Chain, dl, VReg, MVT::v4f32);
2424           SaveXMMOps.push_back(Val);
2425         }
2426         MemOps.push_back(DAG.getNode(X86ISD::VASTART_SAVE_XMM_REGS, dl,
2427                                      MVT::Other,
2428                                      &SaveXMMOps[0], SaveXMMOps.size()));
2429       }
2430
2431       if (!MemOps.empty())
2432         Chain = DAG.getNode(ISD::TokenFactor, dl, MVT::Other,
2433                             &MemOps[0], MemOps.size());
2434     }
2435   }
2436
2437   // Some CCs need callee pop.
2438   if (X86::isCalleePop(CallConv, Is64Bit, isVarArg,
2439                        MF.getTarget().Options.GuaranteedTailCallOpt)) {
2440     FuncInfo->setBytesToPopOnReturn(StackSize); // Callee pops everything.
2441   } else {
2442     FuncInfo->setBytesToPopOnReturn(0); // Callee pops nothing.
2443     // If this is an sret function, the return should pop the hidden pointer.
2444     if (!Is64Bit && !IsTailCallConvention(CallConv) &&
2445         !Subtarget->getTargetTriple().isOSMSVCRT() &&
2446         argsAreStructReturn(Ins) == StackStructReturn)
2447       FuncInfo->setBytesToPopOnReturn(4);
2448   }
2449
2450   if (!Is64Bit) {
2451     // RegSaveFrameIndex is X86-64 only.
2452     FuncInfo->setRegSaveFrameIndex(0xAAAAAAA);
2453     if (CallConv == CallingConv::X86_FastCall ||
2454         CallConv == CallingConv::X86_ThisCall)
2455       // fastcc functions can't have varargs.
2456       FuncInfo->setVarArgsFrameIndex(0xAAAAAAA);
2457   }
2458
2459   FuncInfo->setArgumentStackSize(StackSize);
2460
2461   return Chain;
2462 }
2463
2464 SDValue
2465 X86TargetLowering::LowerMemOpCallTo(SDValue Chain,
2466                                     SDValue StackPtr, SDValue Arg,
2467                                     SDLoc dl, SelectionDAG &DAG,
2468                                     const CCValAssign &VA,
2469                                     ISD::ArgFlagsTy Flags) const {
2470   unsigned LocMemOffset = VA.getLocMemOffset();
2471   SDValue PtrOff = DAG.getIntPtrConstant(LocMemOffset);
2472   PtrOff = DAG.getNode(ISD::ADD, dl, getPointerTy(), StackPtr, PtrOff);
2473   if (Flags.isByVal())
2474     return CreateCopyOfByValArgument(Arg, PtrOff, Chain, Flags, DAG, dl);
2475
2476   return DAG.getStore(Chain, dl, Arg, PtrOff,
2477                       MachinePointerInfo::getStack(LocMemOffset),
2478                       false, false, 0);
2479 }
2480
2481 /// EmitTailCallLoadRetAddr - Emit a load of return address if tail call
2482 /// optimization is performed and it is required.
2483 SDValue
2484 X86TargetLowering::EmitTailCallLoadRetAddr(SelectionDAG &DAG,
2485                                            SDValue &OutRetAddr, SDValue Chain,
2486                                            bool IsTailCall, bool Is64Bit,
2487                                            int FPDiff, SDLoc dl) const {
2488   // Adjust the Return address stack slot.
2489   EVT VT = getPointerTy();
2490   OutRetAddr = getReturnAddressFrameIndex(DAG);
2491
2492   // Load the "old" Return address.
2493   OutRetAddr = DAG.getLoad(VT, dl, Chain, OutRetAddr, MachinePointerInfo(),
2494                            false, false, false, 0);
2495   return SDValue(OutRetAddr.getNode(), 1);
2496 }
2497
2498 /// EmitTailCallStoreRetAddr - Emit a store of the return address if tail call
2499 /// optimization is performed and it is required (FPDiff!=0).
2500 static SDValue
2501 EmitTailCallStoreRetAddr(SelectionDAG & DAG, MachineFunction &MF,
2502                          SDValue Chain, SDValue RetAddrFrIdx, EVT PtrVT,
2503                          unsigned SlotSize, int FPDiff, SDLoc dl) {
2504   // Store the return address to the appropriate stack slot.
2505   if (!FPDiff) return Chain;
2506   // Calculate the new stack slot for the return address.
2507   int NewReturnAddrFI =
2508     MF.getFrameInfo()->CreateFixedObject(SlotSize, (int64_t)FPDiff - SlotSize,
2509                                          false);
2510   SDValue NewRetAddrFrIdx = DAG.getFrameIndex(NewReturnAddrFI, PtrVT);
2511   Chain = DAG.getStore(Chain, dl, RetAddrFrIdx, NewRetAddrFrIdx,
2512                        MachinePointerInfo::getFixedStack(NewReturnAddrFI),
2513                        false, false, 0);
2514   return Chain;
2515 }
2516
2517 SDValue
2518 X86TargetLowering::LowerCall(TargetLowering::CallLoweringInfo &CLI,
2519                              SmallVectorImpl<SDValue> &InVals) const {
2520   SelectionDAG &DAG                     = CLI.DAG;
2521   SDLoc &dl                             = CLI.DL;
2522   SmallVectorImpl<ISD::OutputArg> &Outs = CLI.Outs;
2523   SmallVectorImpl<SDValue> &OutVals     = CLI.OutVals;
2524   SmallVectorImpl<ISD::InputArg> &Ins   = CLI.Ins;
2525   SDValue Chain                         = CLI.Chain;
2526   SDValue Callee                        = CLI.Callee;
2527   CallingConv::ID CallConv              = CLI.CallConv;
2528   bool &isTailCall                      = CLI.IsTailCall;
2529   bool isVarArg                         = CLI.IsVarArg;
2530
2531   MachineFunction &MF = DAG.getMachineFunction();
2532   bool Is64Bit        = Subtarget->is64Bit();
2533   bool IsWin64        = Subtarget->isCallingConvWin64(CallConv);
2534   StructReturnType SR = callIsStructReturn(Outs);
2535   bool IsSibcall      = false;
2536
2537   if (MF.getTarget().Options.DisableTailCalls)
2538     isTailCall = false;
2539
2540   if (isTailCall) {
2541     // Check if it's really possible to do a tail call.
2542     isTailCall = IsEligibleForTailCallOptimization(Callee, CallConv,
2543                     isVarArg, SR != NotStructReturn,
2544                     MF.getFunction()->hasStructRetAttr(), CLI.RetTy,
2545                     Outs, OutVals, Ins, DAG);
2546
2547     // Sibcalls are automatically detected tailcalls which do not require
2548     // ABI changes.
2549     if (!MF.getTarget().Options.GuaranteedTailCallOpt && isTailCall)
2550       IsSibcall = true;
2551
2552     if (isTailCall)
2553       ++NumTailCalls;
2554   }
2555
2556   assert(!(isVarArg && IsTailCallConvention(CallConv)) &&
2557          "Var args not supported with calling convention fastcc, ghc or hipe");
2558
2559   // Analyze operands of the call, assigning locations to each operand.
2560   SmallVector<CCValAssign, 16> ArgLocs;
2561   CCState CCInfo(CallConv, isVarArg, MF, getTargetMachine(),
2562                  ArgLocs, *DAG.getContext());
2563
2564   // Allocate shadow area for Win64
2565   if (IsWin64)
2566     CCInfo.AllocateStack(32, 8);
2567
2568   CCInfo.AnalyzeCallOperands(Outs, CC_X86);
2569
2570   // Get a count of how many bytes are to be pushed on the stack.
2571   unsigned NumBytes = CCInfo.getNextStackOffset();
2572   if (IsSibcall)
2573     // This is a sibcall. The memory operands are available in caller's
2574     // own caller's stack.
2575     NumBytes = 0;
2576   else if (getTargetMachine().Options.GuaranteedTailCallOpt &&
2577            IsTailCallConvention(CallConv))
2578     NumBytes = GetAlignedArgumentStackSize(NumBytes, DAG);
2579
2580   int FPDiff = 0;
2581   if (isTailCall && !IsSibcall) {
2582     // Lower arguments at fp - stackoffset + fpdiff.
2583     X86MachineFunctionInfo *X86Info = MF.getInfo<X86MachineFunctionInfo>();
2584     unsigned NumBytesCallerPushed = X86Info->getBytesToPopOnReturn();
2585
2586     FPDiff = NumBytesCallerPushed - NumBytes;
2587
2588     // Set the delta of movement of the returnaddr stackslot.
2589     // But only set if delta is greater than previous delta.
2590     if (FPDiff < X86Info->getTCReturnAddrDelta())
2591       X86Info->setTCReturnAddrDelta(FPDiff);
2592   }
2593
2594   unsigned NumBytesToPush = NumBytes;
2595   unsigned NumBytesToPop = NumBytes;
2596
2597   // If we have an inalloca argument, all stack space has already been allocated
2598   // for us and be right at the top of the stack.  We don't support multiple
2599   // arguments passed in memory when using inalloca.
2600   if (!Outs.empty() && Outs.back().Flags.isInAlloca()) {
2601     NumBytesToPush = 0;
2602     assert(ArgLocs.back().getLocMemOffset() == 0 &&
2603            "an inalloca argument must be the only memory argument");
2604   }
2605
2606   if (!IsSibcall)
2607     Chain = DAG.getCALLSEQ_START(
2608         Chain, DAG.getIntPtrConstant(NumBytesToPush, true), dl);
2609
2610   SDValue RetAddrFrIdx;
2611   // Load return address for tail calls.
2612   if (isTailCall && FPDiff)
2613     Chain = EmitTailCallLoadRetAddr(DAG, RetAddrFrIdx, Chain, isTailCall,
2614                                     Is64Bit, FPDiff, dl);
2615
2616   SmallVector<std::pair<unsigned, SDValue>, 8> RegsToPass;
2617   SmallVector<SDValue, 8> MemOpChains;
2618   SDValue StackPtr;
2619
2620   // Walk the register/memloc assignments, inserting copies/loads.  In the case
2621   // of tail call optimization arguments are handle later.
2622   const X86RegisterInfo *RegInfo =
2623     static_cast<const X86RegisterInfo*>(getTargetMachine().getRegisterInfo());
2624   for (unsigned i = 0, e = ArgLocs.size(); i != e; ++i) {
2625     // Skip inalloca arguments, they have already been written.
2626     ISD::ArgFlagsTy Flags = Outs[i].Flags;
2627     if (Flags.isInAlloca())
2628       continue;
2629
2630     CCValAssign &VA = ArgLocs[i];
2631     EVT RegVT = VA.getLocVT();
2632     SDValue Arg = OutVals[i];
2633     bool isByVal = Flags.isByVal();
2634
2635     // Promote the value if needed.
2636     switch (VA.getLocInfo()) {
2637     default: llvm_unreachable("Unknown loc info!");
2638     case CCValAssign::Full: break;
2639     case CCValAssign::SExt:
2640       Arg = DAG.getNode(ISD::SIGN_EXTEND, dl, RegVT, Arg);
2641       break;
2642     case CCValAssign::ZExt:
2643       Arg = DAG.getNode(ISD::ZERO_EXTEND, dl, RegVT, Arg);
2644       break;
2645     case CCValAssign::AExt:
2646       if (RegVT.is128BitVector()) {
2647         // Special case: passing MMX values in XMM registers.
2648         Arg = DAG.getNode(ISD::BITCAST, dl, MVT::i64, Arg);
2649         Arg = DAG.getNode(ISD::SCALAR_TO_VECTOR, dl, MVT::v2i64, Arg);
2650         Arg = getMOVL(DAG, dl, MVT::v2i64, DAG.getUNDEF(MVT::v2i64), Arg);
2651       } else
2652         Arg = DAG.getNode(ISD::ANY_EXTEND, dl, RegVT, Arg);
2653       break;
2654     case CCValAssign::BCvt:
2655       Arg = DAG.getNode(ISD::BITCAST, dl, RegVT, Arg);
2656       break;
2657     case CCValAssign::Indirect: {
2658       // Store the argument.
2659       SDValue SpillSlot = DAG.CreateStackTemporary(VA.getValVT());
2660       int FI = cast<FrameIndexSDNode>(SpillSlot)->getIndex();
2661       Chain = DAG.getStore(Chain, dl, Arg, SpillSlot,
2662                            MachinePointerInfo::getFixedStack(FI),
2663                            false, false, 0);
2664       Arg = SpillSlot;
2665       break;
2666     }
2667     }
2668
2669     if (VA.isRegLoc()) {
2670       RegsToPass.push_back(std::make_pair(VA.getLocReg(), Arg));
2671       if (isVarArg && IsWin64) {
2672         // Win64 ABI requires argument XMM reg to be copied to the corresponding
2673         // shadow reg if callee is a varargs function.
2674         unsigned ShadowReg = 0;
2675         switch (VA.getLocReg()) {
2676         case X86::XMM0: ShadowReg = X86::RCX; break;
2677         case X86::XMM1: ShadowReg = X86::RDX; break;
2678         case X86::XMM2: ShadowReg = X86::R8; break;
2679         case X86::XMM3: ShadowReg = X86::R9; break;
2680         }
2681         if (ShadowReg)
2682           RegsToPass.push_back(std::make_pair(ShadowReg, Arg));
2683       }
2684     } else if (!IsSibcall && (!isTailCall || isByVal)) {
2685       assert(VA.isMemLoc());
2686       if (StackPtr.getNode() == 0)
2687         StackPtr = DAG.getCopyFromReg(Chain, dl, RegInfo->getStackRegister(),
2688                                       getPointerTy());
2689       MemOpChains.push_back(LowerMemOpCallTo(Chain, StackPtr, Arg,
2690                                              dl, DAG, VA, Flags));
2691     }
2692   }
2693
2694   if (!MemOpChains.empty())
2695     Chain = DAG.getNode(ISD::TokenFactor, dl, MVT::Other,
2696                         &MemOpChains[0], MemOpChains.size());
2697
2698   if (Subtarget->isPICStyleGOT()) {
2699     // ELF / PIC requires GOT in the EBX register before function calls via PLT
2700     // GOT pointer.
2701     if (!isTailCall) {
2702       RegsToPass.push_back(std::make_pair(unsigned(X86::EBX),
2703                DAG.getNode(X86ISD::GlobalBaseReg, SDLoc(), getPointerTy())));
2704     } else {
2705       // If we are tail calling and generating PIC/GOT style code load the
2706       // address of the callee into ECX. The value in ecx is used as target of
2707       // the tail jump. This is done to circumvent the ebx/callee-saved problem
2708       // for tail calls on PIC/GOT architectures. Normally we would just put the
2709       // address of GOT into ebx and then call target@PLT. But for tail calls
2710       // ebx would be restored (since ebx is callee saved) before jumping to the
2711       // target@PLT.
2712
2713       // Note: The actual moving to ECX is done further down.
2714       GlobalAddressSDNode *G = dyn_cast<GlobalAddressSDNode>(Callee);
2715       if (G && !G->getGlobal()->hasHiddenVisibility() &&
2716           !G->getGlobal()->hasProtectedVisibility())
2717         Callee = LowerGlobalAddress(Callee, DAG);
2718       else if (isa<ExternalSymbolSDNode>(Callee))
2719         Callee = LowerExternalSymbol(Callee, DAG);
2720     }
2721   }
2722
2723   if (Is64Bit && isVarArg && !IsWin64) {
2724     // From AMD64 ABI document:
2725     // For calls that may call functions that use varargs or stdargs
2726     // (prototype-less calls or calls to functions containing ellipsis (...) in
2727     // the declaration) %al is used as hidden argument to specify the number
2728     // of SSE registers used. The contents of %al do not need to match exactly
2729     // the number of registers, but must be an ubound on the number of SSE
2730     // registers used and is in the range 0 - 8 inclusive.
2731
2732     // Count the number of XMM registers allocated.
2733     static const uint16_t XMMArgRegs[] = {
2734       X86::XMM0, X86::XMM1, X86::XMM2, X86::XMM3,
2735       X86::XMM4, X86::XMM5, X86::XMM6, X86::XMM7
2736     };
2737     unsigned NumXMMRegs = CCInfo.getFirstUnallocated(XMMArgRegs, 8);
2738     assert((Subtarget->hasSSE1() || !NumXMMRegs)
2739            && "SSE registers cannot be used when SSE is disabled");
2740
2741     RegsToPass.push_back(std::make_pair(unsigned(X86::AL),
2742                                         DAG.getConstant(NumXMMRegs, MVT::i8)));
2743   }
2744
2745   // For tail calls lower the arguments to the 'real' stack slot.
2746   if (isTailCall) {
2747     // Force all the incoming stack arguments to be loaded from the stack
2748     // before any new outgoing arguments are stored to the stack, because the
2749     // outgoing stack slots may alias the incoming argument stack slots, and
2750     // the alias isn't otherwise explicit. This is slightly more conservative
2751     // than necessary, because it means that each store effectively depends
2752     // on every argument instead of just those arguments it would clobber.
2753     SDValue ArgChain = DAG.getStackArgumentTokenFactor(Chain);
2754
2755     SmallVector<SDValue, 8> MemOpChains2;
2756     SDValue FIN;
2757     int FI = 0;
2758     if (getTargetMachine().Options.GuaranteedTailCallOpt) {
2759       for (unsigned i = 0, e = ArgLocs.size(); i != e; ++i) {
2760         CCValAssign &VA = ArgLocs[i];
2761         if (VA.isRegLoc())
2762           continue;
2763         assert(VA.isMemLoc());
2764         SDValue Arg = OutVals[i];
2765         ISD::ArgFlagsTy Flags = Outs[i].Flags;
2766         // Create frame index.
2767         int32_t Offset = VA.getLocMemOffset()+FPDiff;
2768         uint32_t OpSize = (VA.getLocVT().getSizeInBits()+7)/8;
2769         FI = MF.getFrameInfo()->CreateFixedObject(OpSize, Offset, true);
2770         FIN = DAG.getFrameIndex(FI, getPointerTy());
2771
2772         if (Flags.isByVal()) {
2773           // Copy relative to framepointer.
2774           SDValue Source = DAG.getIntPtrConstant(VA.getLocMemOffset());
2775           if (StackPtr.getNode() == 0)
2776             StackPtr = DAG.getCopyFromReg(Chain, dl,
2777                                           RegInfo->getStackRegister(),
2778                                           getPointerTy());
2779           Source = DAG.getNode(ISD::ADD, dl, getPointerTy(), StackPtr, Source);
2780
2781           MemOpChains2.push_back(CreateCopyOfByValArgument(Source, FIN,
2782                                                            ArgChain,
2783                                                            Flags, DAG, dl));
2784         } else {
2785           // Store relative to framepointer.
2786           MemOpChains2.push_back(
2787             DAG.getStore(ArgChain, dl, Arg, FIN,
2788                          MachinePointerInfo::getFixedStack(FI),
2789                          false, false, 0));
2790         }
2791       }
2792     }
2793
2794     if (!MemOpChains2.empty())
2795       Chain = DAG.getNode(ISD::TokenFactor, dl, MVT::Other,
2796                           &MemOpChains2[0], MemOpChains2.size());
2797
2798     // Store the return address to the appropriate stack slot.
2799     Chain = EmitTailCallStoreRetAddr(DAG, MF, Chain, RetAddrFrIdx,
2800                                      getPointerTy(), RegInfo->getSlotSize(),
2801                                      FPDiff, dl);
2802   }
2803
2804   // Build a sequence of copy-to-reg nodes chained together with token chain
2805   // and flag operands which copy the outgoing args into registers.
2806   SDValue InFlag;
2807   for (unsigned i = 0, e = RegsToPass.size(); i != e; ++i) {
2808     Chain = DAG.getCopyToReg(Chain, dl, RegsToPass[i].first,
2809                              RegsToPass[i].second, InFlag);
2810     InFlag = Chain.getValue(1);
2811   }
2812
2813   if (getTargetMachine().getCodeModel() == CodeModel::Large) {
2814     assert(Is64Bit && "Large code model is only legal in 64-bit mode.");
2815     // In the 64-bit large code model, we have to make all calls
2816     // through a register, since the call instruction's 32-bit
2817     // pc-relative offset may not be large enough to hold the whole
2818     // address.
2819   } else if (GlobalAddressSDNode *G = dyn_cast<GlobalAddressSDNode>(Callee)) {
2820     // If the callee is a GlobalAddress node (quite common, every direct call
2821     // is) turn it into a TargetGlobalAddress node so that legalize doesn't hack
2822     // it.
2823
2824     // We should use extra load for direct calls to dllimported functions in
2825     // non-JIT mode.
2826     const GlobalValue *GV = G->getGlobal();
2827     if (!GV->hasDLLImportStorageClass()) {
2828       unsigned char OpFlags = 0;
2829       bool ExtraLoad = false;
2830       unsigned WrapperKind = ISD::DELETED_NODE;
2831
2832       // On ELF targets, in both X86-64 and X86-32 mode, direct calls to
2833       // external symbols most go through the PLT in PIC mode.  If the symbol
2834       // has hidden or protected visibility, or if it is static or local, then
2835       // we don't need to use the PLT - we can directly call it.
2836       if (Subtarget->isTargetELF() &&
2837           getTargetMachine().getRelocationModel() == Reloc::PIC_ &&
2838           GV->hasDefaultVisibility() && !GV->hasLocalLinkage()) {
2839         OpFlags = X86II::MO_PLT;
2840       } else if (Subtarget->isPICStyleStubAny() &&
2841                  (GV->isDeclaration() || GV->isWeakForLinker()) &&
2842                  (!Subtarget->getTargetTriple().isMacOSX() ||
2843                   Subtarget->getTargetTriple().isMacOSXVersionLT(10, 5))) {
2844         // PC-relative references to external symbols should go through $stub,
2845         // unless we're building with the leopard linker or later, which
2846         // automatically synthesizes these stubs.
2847         OpFlags = X86II::MO_DARWIN_STUB;
2848       } else if (Subtarget->isPICStyleRIPRel() &&
2849                  isa<Function>(GV) &&
2850                  cast<Function>(GV)->getAttributes().
2851                    hasAttribute(AttributeSet::FunctionIndex,
2852                                 Attribute::NonLazyBind)) {
2853         // If the function is marked as non-lazy, generate an indirect call
2854         // which loads from the GOT directly. This avoids runtime overhead
2855         // at the cost of eager binding (and one extra byte of encoding).
2856         OpFlags = X86II::MO_GOTPCREL;
2857         WrapperKind = X86ISD::WrapperRIP;
2858         ExtraLoad = true;
2859       }
2860
2861       Callee = DAG.getTargetGlobalAddress(GV, dl, getPointerTy(),
2862                                           G->getOffset(), OpFlags);
2863
2864       // Add a wrapper if needed.
2865       if (WrapperKind != ISD::DELETED_NODE)
2866         Callee = DAG.getNode(X86ISD::WrapperRIP, dl, getPointerTy(), Callee);
2867       // Add extra indirection if needed.
2868       if (ExtraLoad)
2869         Callee = DAG.getLoad(getPointerTy(), dl, DAG.getEntryNode(), Callee,
2870                              MachinePointerInfo::getGOT(),
2871                              false, false, false, 0);
2872     }
2873   } else if (ExternalSymbolSDNode *S = dyn_cast<ExternalSymbolSDNode>(Callee)) {
2874     unsigned char OpFlags = 0;
2875
2876     // On ELF targets, in either X86-64 or X86-32 mode, direct calls to
2877     // external symbols should go through the PLT.
2878     if (Subtarget->isTargetELF() &&
2879         getTargetMachine().getRelocationModel() == Reloc::PIC_) {
2880       OpFlags = X86II::MO_PLT;
2881     } else if (Subtarget->isPICStyleStubAny() &&
2882                (!Subtarget->getTargetTriple().isMacOSX() ||
2883                 Subtarget->getTargetTriple().isMacOSXVersionLT(10, 5))) {
2884       // PC-relative references to external symbols should go through $stub,
2885       // unless we're building with the leopard linker or later, which
2886       // automatically synthesizes these stubs.
2887       OpFlags = X86II::MO_DARWIN_STUB;
2888     }
2889
2890     Callee = DAG.getTargetExternalSymbol(S->getSymbol(), getPointerTy(),
2891                                          OpFlags);
2892   }
2893
2894   // Returns a chain & a flag for retval copy to use.
2895   SDVTList NodeTys = DAG.getVTList(MVT::Other, MVT::Glue);
2896   SmallVector<SDValue, 8> Ops;
2897
2898   if (!IsSibcall && isTailCall) {
2899     Chain = DAG.getCALLSEQ_END(Chain,
2900                                DAG.getIntPtrConstant(NumBytesToPop, true),
2901                                DAG.getIntPtrConstant(0, true), InFlag, dl);
2902     InFlag = Chain.getValue(1);
2903   }
2904
2905   Ops.push_back(Chain);
2906   Ops.push_back(Callee);
2907
2908   if (isTailCall)
2909     Ops.push_back(DAG.getConstant(FPDiff, MVT::i32));
2910
2911   // Add argument registers to the end of the list so that they are known live
2912   // into the call.
2913   for (unsigned i = 0, e = RegsToPass.size(); i != e; ++i)
2914     Ops.push_back(DAG.getRegister(RegsToPass[i].first,
2915                                   RegsToPass[i].second.getValueType()));
2916
2917   // Add a register mask operand representing the call-preserved registers.
2918   const TargetRegisterInfo *TRI = getTargetMachine().getRegisterInfo();
2919   const uint32_t *Mask = TRI->getCallPreservedMask(CallConv);
2920   assert(Mask && "Missing call preserved mask for calling convention");
2921   Ops.push_back(DAG.getRegisterMask(Mask));
2922
2923   if (InFlag.getNode())
2924     Ops.push_back(InFlag);
2925
2926   if (isTailCall) {
2927     // We used to do:
2928     //// If this is the first return lowered for this function, add the regs
2929     //// to the liveout set for the function.
2930     // This isn't right, although it's probably harmless on x86; liveouts
2931     // should be computed from returns not tail calls.  Consider a void
2932     // function making a tail call to a function returning int.
2933     return DAG.getNode(X86ISD::TC_RETURN, dl, NodeTys, &Ops[0], Ops.size());
2934   }
2935
2936   Chain = DAG.getNode(X86ISD::CALL, dl, NodeTys, &Ops[0], Ops.size());
2937   InFlag = Chain.getValue(1);
2938
2939   // Create the CALLSEQ_END node.
2940   unsigned NumBytesForCalleeToPop;
2941   if (X86::isCalleePop(CallConv, Is64Bit, isVarArg,
2942                        getTargetMachine().Options.GuaranteedTailCallOpt))
2943     NumBytesForCalleeToPop = NumBytes;    // Callee pops everything
2944   else if (!Is64Bit && !IsTailCallConvention(CallConv) &&
2945            !Subtarget->getTargetTriple().isOSMSVCRT() &&
2946            SR == StackStructReturn)
2947     // If this is a call to a struct-return function, the callee
2948     // pops the hidden struct pointer, so we have to push it back.
2949     // This is common for Darwin/X86, Linux & Mingw32 targets.
2950     // For MSVC Win32 targets, the caller pops the hidden struct pointer.
2951     NumBytesForCalleeToPop = 4;
2952   else
2953     NumBytesForCalleeToPop = 0;  // Callee pops nothing.
2954
2955   // Returns a flag for retval copy to use.
2956   if (!IsSibcall) {
2957     Chain = DAG.getCALLSEQ_END(Chain,
2958                                DAG.getIntPtrConstant(NumBytesToPop, true),
2959                                DAG.getIntPtrConstant(NumBytesForCalleeToPop,
2960                                                      true),
2961                                InFlag, dl);
2962     InFlag = Chain.getValue(1);
2963   }
2964
2965   // Handle result values, copying them out of physregs into vregs that we
2966   // return.
2967   return LowerCallResult(Chain, InFlag, CallConv, isVarArg,
2968                          Ins, dl, DAG, InVals);
2969 }
2970
2971 //===----------------------------------------------------------------------===//
2972 //                Fast Calling Convention (tail call) implementation
2973 //===----------------------------------------------------------------------===//
2974
2975 //  Like std call, callee cleans arguments, convention except that ECX is
2976 //  reserved for storing the tail called function address. Only 2 registers are
2977 //  free for argument passing (inreg). Tail call optimization is performed
2978 //  provided:
2979 //                * tailcallopt is enabled
2980 //                * caller/callee are fastcc
2981 //  On X86_64 architecture with GOT-style position independent code only local
2982 //  (within module) calls are supported at the moment.
2983 //  To keep the stack aligned according to platform abi the function
2984 //  GetAlignedArgumentStackSize ensures that argument delta is always multiples
2985 //  of stack alignment. (Dynamic linkers need this - darwin's dyld for example)
2986 //  If a tail called function callee has more arguments than the caller the
2987 //  caller needs to make sure that there is room to move the RETADDR to. This is
2988 //  achieved by reserving an area the size of the argument delta right after the
2989 //  original REtADDR, but before the saved framepointer or the spilled registers
2990 //  e.g. caller(arg1, arg2) calls callee(arg1, arg2,arg3,arg4)
2991 //  stack layout:
2992 //    arg1
2993 //    arg2
2994 //    RETADDR
2995 //    [ new RETADDR
2996 //      move area ]
2997 //    (possible EBP)
2998 //    ESI
2999 //    EDI
3000 //    local1 ..
3001
3002 /// GetAlignedArgumentStackSize - Make the stack size align e.g 16n + 12 aligned
3003 /// for a 16 byte align requirement.
3004 unsigned
3005 X86TargetLowering::GetAlignedArgumentStackSize(unsigned StackSize,
3006                                                SelectionDAG& DAG) const {
3007   MachineFunction &MF = DAG.getMachineFunction();
3008   const TargetMachine &TM = MF.getTarget();
3009   const X86RegisterInfo *RegInfo =
3010     static_cast<const X86RegisterInfo*>(TM.getRegisterInfo());
3011   const TargetFrameLowering &TFI = *TM.getFrameLowering();
3012   unsigned StackAlignment = TFI.getStackAlignment();
3013   uint64_t AlignMask = StackAlignment - 1;
3014   int64_t Offset = StackSize;
3015   unsigned SlotSize = RegInfo->getSlotSize();
3016   if ( (Offset & AlignMask) <= (StackAlignment - SlotSize) ) {
3017     // Number smaller than 12 so just add the difference.
3018     Offset += ((StackAlignment - SlotSize) - (Offset & AlignMask));
3019   } else {
3020     // Mask out lower bits, add stackalignment once plus the 12 bytes.
3021     Offset = ((~AlignMask) & Offset) + StackAlignment +
3022       (StackAlignment-SlotSize);
3023   }
3024   return Offset;
3025 }
3026
3027 /// MatchingStackOffset - Return true if the given stack call argument is
3028 /// already available in the same position (relatively) of the caller's
3029 /// incoming argument stack.
3030 static
3031 bool MatchingStackOffset(SDValue Arg, unsigned Offset, ISD::ArgFlagsTy Flags,
3032                          MachineFrameInfo *MFI, const MachineRegisterInfo *MRI,
3033                          const X86InstrInfo *TII) {
3034   unsigned Bytes = Arg.getValueType().getSizeInBits() / 8;
3035   int FI = INT_MAX;
3036   if (Arg.getOpcode() == ISD::CopyFromReg) {
3037     unsigned VR = cast<RegisterSDNode>(Arg.getOperand(1))->getReg();
3038     if (!TargetRegisterInfo::isVirtualRegister(VR))
3039       return false;
3040     MachineInstr *Def = MRI->getVRegDef(VR);
3041     if (!Def)
3042       return false;
3043     if (!Flags.isByVal()) {
3044       if (!TII->isLoadFromStackSlot(Def, FI))
3045         return false;
3046     } else {
3047       unsigned Opcode = Def->getOpcode();
3048       if ((Opcode == X86::LEA32r || Opcode == X86::LEA64r) &&
3049           Def->getOperand(1).isFI()) {
3050         FI = Def->getOperand(1).getIndex();
3051         Bytes = Flags.getByValSize();
3052       } else
3053         return false;
3054     }
3055   } else if (LoadSDNode *Ld = dyn_cast<LoadSDNode>(Arg)) {
3056     if (Flags.isByVal())
3057       // ByVal argument is passed in as a pointer but it's now being
3058       // dereferenced. e.g.
3059       // define @foo(%struct.X* %A) {
3060       //   tail call @bar(%struct.X* byval %A)
3061       // }
3062       return false;
3063     SDValue Ptr = Ld->getBasePtr();
3064     FrameIndexSDNode *FINode = dyn_cast<FrameIndexSDNode>(Ptr);
3065     if (!FINode)
3066       return false;
3067     FI = FINode->getIndex();
3068   } else if (Arg.getOpcode() == ISD::FrameIndex && Flags.isByVal()) {
3069     FrameIndexSDNode *FINode = cast<FrameIndexSDNode>(Arg);
3070     FI = FINode->getIndex();
3071     Bytes = Flags.getByValSize();
3072   } else
3073     return false;
3074
3075   assert(FI != INT_MAX);
3076   if (!MFI->isFixedObjectIndex(FI))
3077     return false;
3078   return Offset == MFI->getObjectOffset(FI) && Bytes == MFI->getObjectSize(FI);
3079 }
3080
3081 /// IsEligibleForTailCallOptimization - Check whether the call is eligible
3082 /// for tail call optimization. Targets which want to do tail call
3083 /// optimization should implement this function.
3084 bool
3085 X86TargetLowering::IsEligibleForTailCallOptimization(SDValue Callee,
3086                                                      CallingConv::ID CalleeCC,
3087                                                      bool isVarArg,
3088                                                      bool isCalleeStructRet,
3089                                                      bool isCallerStructRet,
3090                                                      Type *RetTy,
3091                                     const SmallVectorImpl<ISD::OutputArg> &Outs,
3092                                     const SmallVectorImpl<SDValue> &OutVals,
3093                                     const SmallVectorImpl<ISD::InputArg> &Ins,
3094                                                      SelectionDAG &DAG) const {
3095   if (!IsTailCallConvention(CalleeCC) && !IsCCallConvention(CalleeCC))
3096     return false;
3097
3098   // If -tailcallopt is specified, make fastcc functions tail-callable.
3099   const MachineFunction &MF = DAG.getMachineFunction();
3100   const Function *CallerF = MF.getFunction();
3101
3102   // If the function return type is x86_fp80 and the callee return type is not,
3103   // then the FP_EXTEND of the call result is not a nop. It's not safe to
3104   // perform a tailcall optimization here.
3105   if (CallerF->getReturnType()->isX86_FP80Ty() && !RetTy->isX86_FP80Ty())
3106     return false;
3107
3108   CallingConv::ID CallerCC = CallerF->getCallingConv();
3109   bool CCMatch = CallerCC == CalleeCC;
3110   bool IsCalleeWin64 = Subtarget->isCallingConvWin64(CalleeCC);
3111   bool IsCallerWin64 = Subtarget->isCallingConvWin64(CallerCC);
3112
3113   if (getTargetMachine().Options.GuaranteedTailCallOpt) {
3114     if (IsTailCallConvention(CalleeCC) && CCMatch)
3115       return true;
3116     return false;
3117   }
3118
3119   // Look for obvious safe cases to perform tail call optimization that do not
3120   // require ABI changes. This is what gcc calls sibcall.
3121
3122   // Can't do sibcall if stack needs to be dynamically re-aligned. PEI needs to
3123   // emit a special epilogue.
3124   const X86RegisterInfo *RegInfo =
3125     static_cast<const X86RegisterInfo*>(getTargetMachine().getRegisterInfo());
3126   if (RegInfo->needsStackRealignment(MF))
3127     return false;
3128
3129   // Also avoid sibcall optimization if either caller or callee uses struct
3130   // return semantics.
3131   if (isCalleeStructRet || isCallerStructRet)
3132     return false;
3133
3134   // An stdcall/thiscall caller is expected to clean up its arguments; the
3135   // callee isn't going to do that.
3136   // FIXME: this is more restrictive than needed. We could produce a tailcall
3137   // when the stack adjustment matches. For example, with a thiscall that takes
3138   // only one argument.
3139   if (!CCMatch && (CallerCC == CallingConv::X86_StdCall ||
3140                    CallerCC == CallingConv::X86_ThisCall))
3141     return false;
3142
3143   // Do not sibcall optimize vararg calls unless all arguments are passed via
3144   // registers.
3145   if (isVarArg && !Outs.empty()) {
3146
3147     // Optimizing for varargs on Win64 is unlikely to be safe without
3148     // additional testing.
3149     if (IsCalleeWin64 || IsCallerWin64)
3150       return false;
3151
3152     SmallVector<CCValAssign, 16> ArgLocs;
3153     CCState CCInfo(CalleeCC, isVarArg, DAG.getMachineFunction(),
3154                    getTargetMachine(), ArgLocs, *DAG.getContext());
3155
3156     CCInfo.AnalyzeCallOperands(Outs, CC_X86);
3157     for (unsigned i = 0, e = ArgLocs.size(); i != e; ++i)
3158       if (!ArgLocs[i].isRegLoc())
3159         return false;
3160   }
3161
3162   // If the call result is in ST0 / ST1, it needs to be popped off the x87
3163   // stack.  Therefore, if it's not used by the call it is not safe to optimize
3164   // this into a sibcall.
3165   bool Unused = false;
3166   for (unsigned i = 0, e = Ins.size(); i != e; ++i) {
3167     if (!Ins[i].Used) {
3168       Unused = true;
3169       break;
3170     }
3171   }
3172   if (Unused) {
3173     SmallVector<CCValAssign, 16> RVLocs;
3174     CCState CCInfo(CalleeCC, false, DAG.getMachineFunction(),
3175                    getTargetMachine(), RVLocs, *DAG.getContext());
3176     CCInfo.AnalyzeCallResult(Ins, RetCC_X86);
3177     for (unsigned i = 0, e = RVLocs.size(); i != e; ++i) {
3178       CCValAssign &VA = RVLocs[i];
3179       if (VA.getLocReg() == X86::ST0 || VA.getLocReg() == X86::ST1)
3180         return false;
3181     }
3182   }
3183
3184   // If the calling conventions do not match, then we'd better make sure the
3185   // results are returned in the same way as what the caller expects.
3186   if (!CCMatch) {
3187     SmallVector<CCValAssign, 16> RVLocs1;
3188     CCState CCInfo1(CalleeCC, false, DAG.getMachineFunction(),
3189                     getTargetMachine(), RVLocs1, *DAG.getContext());
3190     CCInfo1.AnalyzeCallResult(Ins, RetCC_X86);
3191
3192     SmallVector<CCValAssign, 16> RVLocs2;
3193     CCState CCInfo2(CallerCC, false, DAG.getMachineFunction(),
3194                     getTargetMachine(), RVLocs2, *DAG.getContext());
3195     CCInfo2.AnalyzeCallResult(Ins, RetCC_X86);
3196
3197     if (RVLocs1.size() != RVLocs2.size())
3198       return false;
3199     for (unsigned i = 0, e = RVLocs1.size(); i != e; ++i) {
3200       if (RVLocs1[i].isRegLoc() != RVLocs2[i].isRegLoc())
3201         return false;
3202       if (RVLocs1[i].getLocInfo() != RVLocs2[i].getLocInfo())
3203         return false;
3204       if (RVLocs1[i].isRegLoc()) {
3205         if (RVLocs1[i].getLocReg() != RVLocs2[i].getLocReg())
3206           return false;
3207       } else {
3208         if (RVLocs1[i].getLocMemOffset() != RVLocs2[i].getLocMemOffset())
3209           return false;
3210       }
3211     }
3212   }
3213
3214   // If the callee takes no arguments then go on to check the results of the
3215   // call.
3216   if (!Outs.empty()) {
3217     // Check if stack adjustment is needed. For now, do not do this if any
3218     // argument is passed on the stack.
3219     SmallVector<CCValAssign, 16> ArgLocs;
3220     CCState CCInfo(CalleeCC, isVarArg, DAG.getMachineFunction(),
3221                    getTargetMachine(), ArgLocs, *DAG.getContext());
3222
3223     // Allocate shadow area for Win64
3224     if (IsCalleeWin64)
3225       CCInfo.AllocateStack(32, 8);
3226
3227     CCInfo.AnalyzeCallOperands(Outs, CC_X86);
3228     if (CCInfo.getNextStackOffset()) {
3229       MachineFunction &MF = DAG.getMachineFunction();
3230       if (MF.getInfo<X86MachineFunctionInfo>()->getBytesToPopOnReturn())
3231         return false;
3232
3233       // Check if the arguments are already laid out in the right way as
3234       // the caller's fixed stack objects.
3235       MachineFrameInfo *MFI = MF.getFrameInfo();
3236       const MachineRegisterInfo *MRI = &MF.getRegInfo();
3237       const X86InstrInfo *TII =
3238         ((const X86TargetMachine&)getTargetMachine()).getInstrInfo();
3239       for (unsigned i = 0, e = ArgLocs.size(); i != e; ++i) {
3240         CCValAssign &VA = ArgLocs[i];
3241         SDValue Arg = OutVals[i];
3242         ISD::ArgFlagsTy Flags = Outs[i].Flags;
3243         if (VA.getLocInfo() == CCValAssign::Indirect)
3244           return false;
3245         if (!VA.isRegLoc()) {
3246           if (!MatchingStackOffset(Arg, VA.getLocMemOffset(), Flags,
3247                                    MFI, MRI, TII))
3248             return false;
3249         }
3250       }
3251     }
3252
3253     // If the tailcall address may be in a register, then make sure it's
3254     // possible to register allocate for it. In 32-bit, the call address can
3255     // only target EAX, EDX, or ECX since the tail call must be scheduled after
3256     // callee-saved registers are restored. These happen to be the same
3257     // registers used to pass 'inreg' arguments so watch out for those.
3258     if (!Subtarget->is64Bit() &&
3259         ((!isa<GlobalAddressSDNode>(Callee) &&
3260           !isa<ExternalSymbolSDNode>(Callee)) ||
3261          getTargetMachine().getRelocationModel() == Reloc::PIC_)) {
3262       unsigned NumInRegs = 0;
3263       // In PIC we need an extra register to formulate the address computation
3264       // for the callee.
3265       unsigned MaxInRegs =
3266           (getTargetMachine().getRelocationModel() == Reloc::PIC_) ? 2 : 3;
3267
3268       for (unsigned i = 0, e = ArgLocs.size(); i != e; ++i) {
3269         CCValAssign &VA = ArgLocs[i];
3270         if (!VA.isRegLoc())
3271           continue;
3272         unsigned Reg = VA.getLocReg();
3273         switch (Reg) {
3274         default: break;
3275         case X86::EAX: case X86::EDX: case X86::ECX:
3276           if (++NumInRegs == MaxInRegs)
3277             return false;
3278           break;
3279         }
3280       }
3281     }
3282   }
3283
3284   return true;
3285 }
3286
3287 FastISel *
3288 X86TargetLowering::createFastISel(FunctionLoweringInfo &funcInfo,
3289                                   const TargetLibraryInfo *libInfo) const {
3290   return X86::createFastISel(funcInfo, libInfo);
3291 }
3292
3293 //===----------------------------------------------------------------------===//
3294 //                           Other Lowering Hooks
3295 //===----------------------------------------------------------------------===//
3296
3297 static bool MayFoldLoad(SDValue Op) {
3298   return Op.hasOneUse() && ISD::isNormalLoad(Op.getNode());
3299 }
3300
3301 static bool MayFoldIntoStore(SDValue Op) {
3302   return Op.hasOneUse() && ISD::isNormalStore(*Op.getNode()->use_begin());
3303 }
3304
3305 static bool isTargetShuffle(unsigned Opcode) {
3306   switch(Opcode) {
3307   default: return false;
3308   case X86ISD::PSHUFD:
3309   case X86ISD::PSHUFHW:
3310   case X86ISD::PSHUFLW:
3311   case X86ISD::SHUFP:
3312   case X86ISD::PALIGNR:
3313   case X86ISD::MOVLHPS:
3314   case X86ISD::MOVLHPD:
3315   case X86ISD::MOVHLPS:
3316   case X86ISD::MOVLPS:
3317   case X86ISD::MOVLPD:
3318   case X86ISD::MOVSHDUP:
3319   case X86ISD::MOVSLDUP:
3320   case X86ISD::MOVDDUP:
3321   case X86ISD::MOVSS:
3322   case X86ISD::MOVSD:
3323   case X86ISD::UNPCKL:
3324   case X86ISD::UNPCKH:
3325   case X86ISD::VPERMILP:
3326   case X86ISD::VPERM2X128:
3327   case X86ISD::VPERMI:
3328     return true;
3329   }
3330 }
3331
3332 static SDValue getTargetShuffleNode(unsigned Opc, SDLoc dl, EVT VT,
3333                                     SDValue V1, SelectionDAG &DAG) {
3334   switch(Opc) {
3335   default: llvm_unreachable("Unknown x86 shuffle node");
3336   case X86ISD::MOVSHDUP:
3337   case X86ISD::MOVSLDUP:
3338   case X86ISD::MOVDDUP:
3339     return DAG.getNode(Opc, dl, VT, V1);
3340   }
3341 }
3342
3343 static SDValue getTargetShuffleNode(unsigned Opc, SDLoc dl, EVT VT,
3344                                     SDValue V1, unsigned TargetMask,
3345                                     SelectionDAG &DAG) {
3346   switch(Opc) {
3347   default: llvm_unreachable("Unknown x86 shuffle node");
3348   case X86ISD::PSHUFD:
3349   case X86ISD::PSHUFHW:
3350   case X86ISD::PSHUFLW:
3351   case X86ISD::VPERMILP:
3352   case X86ISD::VPERMI:
3353     return DAG.getNode(Opc, dl, VT, V1, DAG.getConstant(TargetMask, MVT::i8));
3354   }
3355 }
3356
3357 static SDValue getTargetShuffleNode(unsigned Opc, SDLoc dl, EVT VT,
3358                                     SDValue V1, SDValue V2, unsigned TargetMask,
3359                                     SelectionDAG &DAG) {
3360   switch(Opc) {
3361   default: llvm_unreachable("Unknown x86 shuffle node");
3362   case X86ISD::PALIGNR:
3363   case X86ISD::SHUFP:
3364   case X86ISD::VPERM2X128:
3365     return DAG.getNode(Opc, dl, VT, V1, V2,
3366                        DAG.getConstant(TargetMask, MVT::i8));
3367   }
3368 }
3369
3370 static SDValue getTargetShuffleNode(unsigned Opc, SDLoc dl, EVT VT,
3371                                     SDValue V1, SDValue V2, SelectionDAG &DAG) {
3372   switch(Opc) {
3373   default: llvm_unreachable("Unknown x86 shuffle node");
3374   case X86ISD::MOVLHPS:
3375   case X86ISD::MOVLHPD:
3376   case X86ISD::MOVHLPS:
3377   case X86ISD::MOVLPS:
3378   case X86ISD::MOVLPD:
3379   case X86ISD::MOVSS:
3380   case X86ISD::MOVSD:
3381   case X86ISD::UNPCKL:
3382   case X86ISD::UNPCKH:
3383     return DAG.getNode(Opc, dl, VT, V1, V2);
3384   }
3385 }
3386
3387 SDValue X86TargetLowering::getReturnAddressFrameIndex(SelectionDAG &DAG) const {
3388   MachineFunction &MF = DAG.getMachineFunction();
3389   const X86RegisterInfo *RegInfo =
3390     static_cast<const X86RegisterInfo*>(getTargetMachine().getRegisterInfo());
3391   X86MachineFunctionInfo *FuncInfo = MF.getInfo<X86MachineFunctionInfo>();
3392   int ReturnAddrIndex = FuncInfo->getRAIndex();
3393
3394   if (ReturnAddrIndex == 0) {
3395     // Set up a frame object for the return address.
3396     unsigned SlotSize = RegInfo->getSlotSize();
3397     ReturnAddrIndex = MF.getFrameInfo()->CreateFixedObject(SlotSize,
3398                                                            -(int64_t)SlotSize,
3399                                                            false);
3400     FuncInfo->setRAIndex(ReturnAddrIndex);
3401   }
3402
3403   return DAG.getFrameIndex(ReturnAddrIndex, getPointerTy());
3404 }
3405
3406 bool X86::isOffsetSuitableForCodeModel(int64_t Offset, CodeModel::Model M,
3407                                        bool hasSymbolicDisplacement) {
3408   // Offset should fit into 32 bit immediate field.
3409   if (!isInt<32>(Offset))
3410     return false;
3411
3412   // If we don't have a symbolic displacement - we don't have any extra
3413   // restrictions.
3414   if (!hasSymbolicDisplacement)
3415     return true;
3416
3417   // FIXME: Some tweaks might be needed for medium code model.
3418   if (M != CodeModel::Small && M != CodeModel::Kernel)
3419     return false;
3420
3421   // For small code model we assume that latest object is 16MB before end of 31
3422   // bits boundary. We may also accept pretty large negative constants knowing
3423   // that all objects are in the positive half of address space.
3424   if (M == CodeModel::Small && Offset < 16*1024*1024)
3425     return true;
3426
3427   // For kernel code model we know that all object resist in the negative half
3428   // of 32bits address space. We may not accept negative offsets, since they may
3429   // be just off and we may accept pretty large positive ones.
3430   if (M == CodeModel::Kernel && Offset > 0)
3431     return true;
3432
3433   return false;
3434 }
3435
3436 /// isCalleePop - Determines whether the callee is required to pop its
3437 /// own arguments. Callee pop is necessary to support tail calls.
3438 bool X86::isCalleePop(CallingConv::ID CallingConv,
3439                       bool is64Bit, bool IsVarArg, bool TailCallOpt) {
3440   if (IsVarArg)
3441     return false;
3442
3443   switch (CallingConv) {
3444   default:
3445     return false;
3446   case CallingConv::X86_StdCall:
3447     return !is64Bit;
3448   case CallingConv::X86_FastCall:
3449     return !is64Bit;
3450   case CallingConv::X86_ThisCall:
3451     return !is64Bit;
3452   case CallingConv::Fast:
3453     return TailCallOpt;
3454   case CallingConv::GHC:
3455     return TailCallOpt;
3456   case CallingConv::HiPE:
3457     return TailCallOpt;
3458   }
3459 }
3460
3461 /// \brief Return true if the condition is an unsigned comparison operation.
3462 static bool isX86CCUnsigned(unsigned X86CC) {
3463   switch (X86CC) {
3464   default: llvm_unreachable("Invalid integer condition!");
3465   case X86::COND_E:     return true;
3466   case X86::COND_G:     return false;
3467   case X86::COND_GE:    return false;
3468   case X86::COND_L:     return false;
3469   case X86::COND_LE:    return false;
3470   case X86::COND_NE:    return true;
3471   case X86::COND_B:     return true;
3472   case X86::COND_A:     return true;
3473   case X86::COND_BE:    return true;
3474   case X86::COND_AE:    return true;
3475   }
3476   llvm_unreachable("covered switch fell through?!");
3477 }
3478
3479 /// TranslateX86CC - do a one to one translation of a ISD::CondCode to the X86
3480 /// specific condition code, returning the condition code and the LHS/RHS of the
3481 /// comparison to make.
3482 static unsigned TranslateX86CC(ISD::CondCode SetCCOpcode, bool isFP,
3483                                SDValue &LHS, SDValue &RHS, SelectionDAG &DAG) {
3484   if (!isFP) {
3485     if (ConstantSDNode *RHSC = dyn_cast<ConstantSDNode>(RHS)) {
3486       if (SetCCOpcode == ISD::SETGT && RHSC->isAllOnesValue()) {
3487         // X > -1   -> X == 0, jump !sign.
3488         RHS = DAG.getConstant(0, RHS.getValueType());
3489         return X86::COND_NS;
3490       }
3491       if (SetCCOpcode == ISD::SETLT && RHSC->isNullValue()) {
3492         // X < 0   -> X == 0, jump on sign.
3493         return X86::COND_S;
3494       }
3495       if (SetCCOpcode == ISD::SETLT && RHSC->getZExtValue() == 1) {
3496         // X < 1   -> X <= 0
3497         RHS = DAG.getConstant(0, RHS.getValueType());
3498         return X86::COND_LE;
3499       }
3500     }
3501
3502     switch (SetCCOpcode) {
3503     default: llvm_unreachable("Invalid integer condition!");
3504     case ISD::SETEQ:  return X86::COND_E;
3505     case ISD::SETGT:  return X86::COND_G;
3506     case ISD::SETGE:  return X86::COND_GE;
3507     case ISD::SETLT:  return X86::COND_L;
3508     case ISD::SETLE:  return X86::COND_LE;
3509     case ISD::SETNE:  return X86::COND_NE;
3510     case ISD::SETULT: return X86::COND_B;
3511     case ISD::SETUGT: return X86::COND_A;
3512     case ISD::SETULE: return X86::COND_BE;
3513     case ISD::SETUGE: return X86::COND_AE;
3514     }
3515   }
3516
3517   // First determine if it is required or is profitable to flip the operands.
3518
3519   // If LHS is a foldable load, but RHS is not, flip the condition.
3520   if (ISD::isNON_EXTLoad(LHS.getNode()) &&
3521       !ISD::isNON_EXTLoad(RHS.getNode())) {
3522     SetCCOpcode = getSetCCSwappedOperands(SetCCOpcode);
3523     std::swap(LHS, RHS);
3524   }
3525
3526   switch (SetCCOpcode) {
3527   default: break;
3528   case ISD::SETOLT:
3529   case ISD::SETOLE:
3530   case ISD::SETUGT:
3531   case ISD::SETUGE:
3532     std::swap(LHS, RHS);
3533     break;
3534   }
3535
3536   // On a floating point condition, the flags are set as follows:
3537   // ZF  PF  CF   op
3538   //  0 | 0 | 0 | X > Y
3539   //  0 | 0 | 1 | X < Y
3540   //  1 | 0 | 0 | X == Y
3541   //  1 | 1 | 1 | unordered
3542   switch (SetCCOpcode) {
3543   default: llvm_unreachable("Condcode should be pre-legalized away");
3544   case ISD::SETUEQ:
3545   case ISD::SETEQ:   return X86::COND_E;
3546   case ISD::SETOLT:              // flipped
3547   case ISD::SETOGT:
3548   case ISD::SETGT:   return X86::COND_A;
3549   case ISD::SETOLE:              // flipped
3550   case ISD::SETOGE:
3551   case ISD::SETGE:   return X86::COND_AE;
3552   case ISD::SETUGT:              // flipped
3553   case ISD::SETULT:
3554   case ISD::SETLT:   return X86::COND_B;
3555   case ISD::SETUGE:              // flipped
3556   case ISD::SETULE:
3557   case ISD::SETLE:   return X86::COND_BE;
3558   case ISD::SETONE:
3559   case ISD::SETNE:   return X86::COND_NE;
3560   case ISD::SETUO:   return X86::COND_P;
3561   case ISD::SETO:    return X86::COND_NP;
3562   case ISD::SETOEQ:
3563   case ISD::SETUNE:  return X86::COND_INVALID;
3564   }
3565 }
3566
3567 /// hasFPCMov - is there a floating point cmov for the specific X86 condition
3568 /// code. Current x86 isa includes the following FP cmov instructions:
3569 /// fcmovb, fcomvbe, fcomve, fcmovu, fcmovae, fcmova, fcmovne, fcmovnu.
3570 static bool hasFPCMov(unsigned X86CC) {
3571   switch (X86CC) {
3572   default:
3573     return false;
3574   case X86::COND_B:
3575   case X86::COND_BE:
3576   case X86::COND_E:
3577   case X86::COND_P:
3578   case X86::COND_A:
3579   case X86::COND_AE:
3580   case X86::COND_NE:
3581   case X86::COND_NP:
3582     return true;
3583   }
3584 }
3585
3586 /// isFPImmLegal - Returns true if the target can instruction select the
3587 /// specified FP immediate natively. If false, the legalizer will
3588 /// materialize the FP immediate as a load from a constant pool.
3589 bool X86TargetLowering::isFPImmLegal(const APFloat &Imm, EVT VT) const {
3590   for (unsigned i = 0, e = LegalFPImmediates.size(); i != e; ++i) {
3591     if (Imm.bitwiseIsEqual(LegalFPImmediates[i]))
3592       return true;
3593   }
3594   return false;
3595 }
3596
3597 /// \brief Returns true if it is beneficial to convert a load of a constant
3598 /// to just the constant itself.
3599 bool X86TargetLowering::shouldConvertConstantLoadToIntImm(const APInt &Imm,
3600                                                           Type *Ty) const {
3601   assert(Ty->isIntegerTy());
3602
3603   unsigned BitSize = Ty->getPrimitiveSizeInBits();
3604   if (BitSize == 0 || BitSize > 64)
3605     return false;
3606   return true;
3607 }
3608
3609 /// isUndefOrInRange - Return true if Val is undef or if its value falls within
3610 /// the specified range (L, H].
3611 static bool isUndefOrInRange(int Val, int Low, int Hi) {
3612   return (Val < 0) || (Val >= Low && Val < Hi);
3613 }
3614
3615 /// isUndefOrEqual - Val is either less than zero (undef) or equal to the
3616 /// specified value.
3617 static bool isUndefOrEqual(int Val, int CmpVal) {
3618   return (Val < 0 || Val == CmpVal);
3619 }
3620
3621 /// isSequentialOrUndefInRange - Return true if every element in Mask, beginning
3622 /// from position Pos and ending in Pos+Size, falls within the specified
3623 /// sequential range (L, L+Pos]. or is undef.
3624 static bool isSequentialOrUndefInRange(ArrayRef<int> Mask,
3625                                        unsigned Pos, unsigned Size, int Low) {
3626   for (unsigned i = Pos, e = Pos+Size; i != e; ++i, ++Low)
3627     if (!isUndefOrEqual(Mask[i], Low))
3628       return false;
3629   return true;
3630 }
3631
3632 /// isPSHUFDMask - Return true if the node specifies a shuffle of elements that
3633 /// is suitable for input to PSHUFD or PSHUFW.  That is, it doesn't reference
3634 /// the second operand.
3635 static bool isPSHUFDMask(ArrayRef<int> Mask, MVT VT) {
3636   if (VT == MVT::v4f32 || VT == MVT::v4i32 )
3637     return (Mask[0] < 4 && Mask[1] < 4 && Mask[2] < 4 && Mask[3] < 4);
3638   if (VT == MVT::v2f64 || VT == MVT::v2i64)
3639     return (Mask[0] < 2 && Mask[1] < 2);
3640   return false;
3641 }
3642
3643 /// isPSHUFHWMask - Return true if the node specifies a shuffle of elements that
3644 /// is suitable for input to PSHUFHW.
3645 static bool isPSHUFHWMask(ArrayRef<int> Mask, MVT VT, bool HasInt256) {
3646   if (VT != MVT::v8i16 && (!HasInt256 || VT != MVT::v16i16))
3647     return false;
3648
3649   // Lower quadword copied in order or undef.
3650   if (!isSequentialOrUndefInRange(Mask, 0, 4, 0))
3651     return false;
3652
3653   // Upper quadword shuffled.
3654   for (unsigned i = 4; i != 8; ++i)
3655     if (!isUndefOrInRange(Mask[i], 4, 8))
3656       return false;
3657
3658   if (VT == MVT::v16i16) {
3659     // Lower quadword copied in order or undef.
3660     if (!isSequentialOrUndefInRange(Mask, 8, 4, 8))
3661       return false;
3662
3663     // Upper quadword shuffled.
3664     for (unsigned i = 12; i != 16; ++i)
3665       if (!isUndefOrInRange(Mask[i], 12, 16))
3666         return false;
3667   }
3668
3669   return true;
3670 }
3671
3672 /// isPSHUFLWMask - Return true if the node specifies a shuffle of elements that
3673 /// is suitable for input to PSHUFLW.
3674 static bool isPSHUFLWMask(ArrayRef<int> Mask, MVT VT, bool HasInt256) {
3675   if (VT != MVT::v8i16 && (!HasInt256 || VT != MVT::v16i16))
3676     return false;
3677
3678   // Upper quadword copied in order.
3679   if (!isSequentialOrUndefInRange(Mask, 4, 4, 4))
3680     return false;
3681
3682   // Lower quadword shuffled.
3683   for (unsigned i = 0; i != 4; ++i)
3684     if (!isUndefOrInRange(Mask[i], 0, 4))
3685       return false;
3686
3687   if (VT == MVT::v16i16) {
3688     // Upper quadword copied in order.
3689     if (!isSequentialOrUndefInRange(Mask, 12, 4, 12))
3690       return false;
3691
3692     // Lower quadword shuffled.
3693     for (unsigned i = 8; i != 12; ++i)
3694       if (!isUndefOrInRange(Mask[i], 8, 12))
3695         return false;
3696   }
3697
3698   return true;
3699 }
3700
3701 /// isPALIGNRMask - Return true if the node specifies a shuffle of elements that
3702 /// is suitable for input to PALIGNR.
3703 static bool isPALIGNRMask(ArrayRef<int> Mask, MVT VT,
3704                           const X86Subtarget *Subtarget) {
3705   if ((VT.is128BitVector() && !Subtarget->hasSSSE3()) ||
3706       (VT.is256BitVector() && !Subtarget->hasInt256()))
3707     return false;
3708
3709   unsigned NumElts = VT.getVectorNumElements();
3710   unsigned NumLanes = VT.is512BitVector() ? 1: VT.getSizeInBits()/128;
3711   unsigned NumLaneElts = NumElts/NumLanes;
3712
3713   // Do not handle 64-bit element shuffles with palignr.
3714   if (NumLaneElts == 2)
3715     return false;
3716
3717   for (unsigned l = 0; l != NumElts; l+=NumLaneElts) {
3718     unsigned i;
3719     for (i = 0; i != NumLaneElts; ++i) {
3720       if (Mask[i+l] >= 0)
3721         break;
3722     }
3723
3724     // Lane is all undef, go to next lane
3725     if (i == NumLaneElts)
3726       continue;
3727
3728     int Start = Mask[i+l];
3729
3730     // Make sure its in this lane in one of the sources
3731     if (!isUndefOrInRange(Start, l, l+NumLaneElts) &&
3732         !isUndefOrInRange(Start, l+NumElts, l+NumElts+NumLaneElts))
3733       return false;
3734
3735     // If not lane 0, then we must match lane 0
3736     if (l != 0 && Mask[i] >= 0 && !isUndefOrEqual(Start, Mask[i]+l))
3737       return false;
3738
3739     // Correct second source to be contiguous with first source
3740     if (Start >= (int)NumElts)
3741       Start -= NumElts - NumLaneElts;
3742
3743     // Make sure we're shifting in the right direction.
3744     if (Start <= (int)(i+l))
3745       return false;
3746
3747     Start -= i;
3748
3749     // Check the rest of the elements to see if they are consecutive.
3750     for (++i; i != NumLaneElts; ++i) {
3751       int Idx = Mask[i+l];
3752
3753       // Make sure its in this lane
3754       if (!isUndefOrInRange(Idx, l, l+NumLaneElts) &&
3755           !isUndefOrInRange(Idx, l+NumElts, l+NumElts+NumLaneElts))
3756         return false;
3757
3758       // If not lane 0, then we must match lane 0
3759       if (l != 0 && Mask[i] >= 0 && !isUndefOrEqual(Idx, Mask[i]+l))
3760         return false;
3761
3762       if (Idx >= (int)NumElts)
3763         Idx -= NumElts - NumLaneElts;
3764
3765       if (!isUndefOrEqual(Idx, Start+i))
3766         return false;
3767
3768     }
3769   }
3770
3771   return true;
3772 }
3773
3774 /// CommuteVectorShuffleMask - Change values in a shuffle permute mask assuming
3775 /// the two vector operands have swapped position.
3776 static void CommuteVectorShuffleMask(SmallVectorImpl<int> &Mask,
3777                                      unsigned NumElems) {
3778   for (unsigned i = 0; i != NumElems; ++i) {
3779     int idx = Mask[i];
3780     if (idx < 0)
3781       continue;
3782     else if (idx < (int)NumElems)
3783       Mask[i] = idx + NumElems;
3784     else
3785       Mask[i] = idx - NumElems;
3786   }
3787 }
3788
3789 /// isSHUFPMask - Return true if the specified VECTOR_SHUFFLE operand
3790 /// specifies a shuffle of elements that is suitable for input to 128/256-bit
3791 /// SHUFPS and SHUFPD. If Commuted is true, then it checks for sources to be
3792 /// reverse of what x86 shuffles want.
3793 static bool isSHUFPMask(ArrayRef<int> Mask, MVT VT, bool Commuted = false) {
3794
3795   unsigned NumElems = VT.getVectorNumElements();
3796   unsigned NumLanes = VT.getSizeInBits()/128;
3797   unsigned NumLaneElems = NumElems/NumLanes;
3798
3799   if (NumLaneElems != 2 && NumLaneElems != 4)
3800     return false;
3801
3802   unsigned EltSize = VT.getVectorElementType().getSizeInBits();
3803   bool symetricMaskRequired =
3804     (VT.getSizeInBits() >= 256) && (EltSize == 32);
3805
3806   // VSHUFPSY divides the resulting vector into 4 chunks.
3807   // The sources are also splitted into 4 chunks, and each destination
3808   // chunk must come from a different source chunk.
3809   //
3810   //  SRC1 =>   X7    X6    X5    X4    X3    X2    X1    X0
3811   //  SRC2 =>   Y7    Y6    Y5    Y4    Y3    Y2    Y1    Y9
3812   //
3813   //  DST  =>  Y7..Y4,   Y7..Y4,   X7..X4,   X7..X4,
3814   //           Y3..Y0,   Y3..Y0,   X3..X0,   X3..X0
3815   //
3816   // VSHUFPDY divides the resulting vector into 4 chunks.
3817   // The sources are also splitted into 4 chunks, and each destination
3818   // chunk must come from a different source chunk.
3819   //
3820   //  SRC1 =>      X3       X2       X1       X0
3821   //  SRC2 =>      Y3       Y2       Y1       Y0
3822   //
3823   //  DST  =>  Y3..Y2,  X3..X2,  Y1..Y0,  X1..X0
3824   //
3825   SmallVector<int, 4> MaskVal(NumLaneElems, -1);
3826   unsigned HalfLaneElems = NumLaneElems/2;
3827   for (unsigned l = 0; l != NumElems; l += NumLaneElems) {
3828     for (unsigned i = 0; i != NumLaneElems; ++i) {
3829       int Idx = Mask[i+l];
3830       unsigned RngStart = l + ((Commuted == (i<HalfLaneElems)) ? NumElems : 0);
3831       if (!isUndefOrInRange(Idx, RngStart, RngStart+NumLaneElems))
3832         return false;
3833       // For VSHUFPSY, the mask of the second half must be the same as the
3834       // first but with the appropriate offsets. This works in the same way as
3835       // VPERMILPS works with masks.
3836       if (!symetricMaskRequired || Idx < 0)
3837         continue;
3838       if (MaskVal[i] < 0) {
3839         MaskVal[i] = Idx - l;
3840         continue;
3841       }
3842       if ((signed)(Idx - l) != MaskVal[i])
3843         return false;
3844     }
3845   }
3846
3847   return true;
3848 }
3849
3850 /// isMOVHLPSMask - Return true if the specified VECTOR_SHUFFLE operand
3851 /// specifies a shuffle of elements that is suitable for input to MOVHLPS.
3852 static bool isMOVHLPSMask(ArrayRef<int> Mask, MVT VT) {
3853   if (!VT.is128BitVector())
3854     return false;
3855
3856   unsigned NumElems = VT.getVectorNumElements();
3857
3858   if (NumElems != 4)
3859     return false;
3860
3861   // Expect bit0 == 6, bit1 == 7, bit2 == 2, bit3 == 3
3862   return isUndefOrEqual(Mask[0], 6) &&
3863          isUndefOrEqual(Mask[1], 7) &&
3864          isUndefOrEqual(Mask[2], 2) &&
3865          isUndefOrEqual(Mask[3], 3);
3866 }
3867
3868 /// isMOVHLPS_v_undef_Mask - Special case of isMOVHLPSMask for canonical form
3869 /// of vector_shuffle v, v, <2, 3, 2, 3>, i.e. vector_shuffle v, undef,
3870 /// <2, 3, 2, 3>
3871 static bool isMOVHLPS_v_undef_Mask(ArrayRef<int> Mask, MVT VT) {
3872   if (!VT.is128BitVector())
3873     return false;
3874
3875   unsigned NumElems = VT.getVectorNumElements();
3876
3877   if (NumElems != 4)
3878     return false;
3879
3880   return isUndefOrEqual(Mask[0], 2) &&
3881          isUndefOrEqual(Mask[1], 3) &&
3882          isUndefOrEqual(Mask[2], 2) &&
3883          isUndefOrEqual(Mask[3], 3);
3884 }
3885
3886 /// isMOVLPMask - Return true if the specified VECTOR_SHUFFLE operand
3887 /// specifies a shuffle of elements that is suitable for input to MOVLP{S|D}.
3888 static bool isMOVLPMask(ArrayRef<int> Mask, MVT VT) {
3889   if (!VT.is128BitVector())
3890     return false;
3891
3892   unsigned NumElems = VT.getVectorNumElements();
3893
3894   if (NumElems != 2 && NumElems != 4)
3895     return false;
3896
3897   for (unsigned i = 0, e = NumElems/2; i != e; ++i)
3898     if (!isUndefOrEqual(Mask[i], i + NumElems))
3899       return false;
3900
3901   for (unsigned i = NumElems/2, e = NumElems; i != e; ++i)
3902     if (!isUndefOrEqual(Mask[i], i))
3903       return false;
3904
3905   return true;
3906 }
3907
3908 /// isMOVLHPSMask - Return true if the specified VECTOR_SHUFFLE operand
3909 /// specifies a shuffle of elements that is suitable for input to MOVLHPS.
3910 static bool isMOVLHPSMask(ArrayRef<int> Mask, MVT VT) {
3911   if (!VT.is128BitVector())
3912     return false;
3913
3914   unsigned NumElems = VT.getVectorNumElements();
3915
3916   if (NumElems != 2 && NumElems != 4)
3917     return false;
3918
3919   for (unsigned i = 0, e = NumElems/2; i != e; ++i)
3920     if (!isUndefOrEqual(Mask[i], i))
3921       return false;
3922
3923   for (unsigned i = 0, e = NumElems/2; i != e; ++i)
3924     if (!isUndefOrEqual(Mask[i + e], i + NumElems))
3925       return false;
3926
3927   return true;
3928 }
3929
3930 //
3931 // Some special combinations that can be optimized.
3932 //
3933 static
3934 SDValue Compact8x32ShuffleNode(ShuffleVectorSDNode *SVOp,
3935                                SelectionDAG &DAG) {
3936   MVT VT = SVOp->getSimpleValueType(0);
3937   SDLoc dl(SVOp);
3938
3939   if (VT != MVT::v8i32 && VT != MVT::v8f32)
3940     return SDValue();
3941
3942   ArrayRef<int> Mask = SVOp->getMask();
3943
3944   // These are the special masks that may be optimized.
3945   static const int MaskToOptimizeEven[] = {0, 8, 2, 10, 4, 12, 6, 14};
3946   static const int MaskToOptimizeOdd[]  = {1, 9, 3, 11, 5, 13, 7, 15};
3947   bool MatchEvenMask = true;
3948   bool MatchOddMask  = true;
3949   for (int i=0; i<8; ++i) {
3950     if (!isUndefOrEqual(Mask[i], MaskToOptimizeEven[i]))
3951       MatchEvenMask = false;
3952     if (!isUndefOrEqual(Mask[i], MaskToOptimizeOdd[i]))
3953       MatchOddMask = false;
3954   }
3955
3956   if (!MatchEvenMask && !MatchOddMask)
3957     return SDValue();
3958
3959   SDValue UndefNode = DAG.getNode(ISD::UNDEF, dl, VT);
3960
3961   SDValue Op0 = SVOp->getOperand(0);
3962   SDValue Op1 = SVOp->getOperand(1);
3963
3964   if (MatchEvenMask) {
3965     // Shift the second operand right to 32 bits.
3966     static const int ShiftRightMask[] = {-1, 0, -1, 2, -1, 4, -1, 6 };
3967     Op1 = DAG.getVectorShuffle(VT, dl, Op1, UndefNode, ShiftRightMask);
3968   } else {
3969     // Shift the first operand left to 32 bits.
3970     static const int ShiftLeftMask[] = {1, -1, 3, -1, 5, -1, 7, -1 };
3971     Op0 = DAG.getVectorShuffle(VT, dl, Op0, UndefNode, ShiftLeftMask);
3972   }
3973   static const int BlendMask[] = {0, 9, 2, 11, 4, 13, 6, 15};
3974   return DAG.getVectorShuffle(VT, dl, Op0, Op1, BlendMask);
3975 }
3976
3977 /// isUNPCKLMask - Return true if the specified VECTOR_SHUFFLE operand
3978 /// specifies a shuffle of elements that is suitable for input to UNPCKL.
3979 static bool isUNPCKLMask(ArrayRef<int> Mask, MVT VT,
3980                          bool HasInt256, bool V2IsSplat = false) {
3981
3982   assert(VT.getSizeInBits() >= 128 &&
3983          "Unsupported vector type for unpckl");
3984
3985   // AVX defines UNPCK* to operate independently on 128-bit lanes.
3986   unsigned NumLanes;
3987   unsigned NumOf256BitLanes;
3988   unsigned NumElts = VT.getVectorNumElements();
3989   if (VT.is256BitVector()) {
3990     if (NumElts != 4 && NumElts != 8 &&
3991         (!HasInt256 || (NumElts != 16 && NumElts != 32)))
3992     return false;
3993     NumLanes = 2;
3994     NumOf256BitLanes = 1;
3995   } else if (VT.is512BitVector()) {
3996     assert(VT.getScalarType().getSizeInBits() >= 32 &&
3997            "Unsupported vector type for unpckh");
3998     NumLanes = 2;
3999     NumOf256BitLanes = 2;
4000   } else {
4001     NumLanes = 1;
4002     NumOf256BitLanes = 1;
4003   }
4004
4005   unsigned NumEltsInStride = NumElts/NumOf256BitLanes;
4006   unsigned NumLaneElts = NumEltsInStride/NumLanes;
4007
4008   for (unsigned l256 = 0; l256 < NumOf256BitLanes; l256 += 1) {
4009     for (unsigned l = 0; l != NumEltsInStride; l += NumLaneElts) {
4010       for (unsigned i = 0, j = l; i != NumLaneElts; i += 2, ++j) {
4011         int BitI  = Mask[l256*NumEltsInStride+l+i];
4012         int BitI1 = Mask[l256*NumEltsInStride+l+i+1];
4013         if (!isUndefOrEqual(BitI, j+l256*NumElts))
4014           return false;
4015         if (V2IsSplat && !isUndefOrEqual(BitI1, NumElts))
4016           return false;
4017         if (!isUndefOrEqual(BitI1, j+l256*NumElts+NumEltsInStride))
4018           return false;
4019       }
4020     }
4021   }
4022   return true;
4023 }
4024
4025 /// isUNPCKHMask - Return true if the specified VECTOR_SHUFFLE operand
4026 /// specifies a shuffle of elements that is suitable for input to UNPCKH.
4027 static bool isUNPCKHMask(ArrayRef<int> Mask, MVT VT,
4028                          bool HasInt256, bool V2IsSplat = false) {
4029   assert(VT.getSizeInBits() >= 128 &&
4030          "Unsupported vector type for unpckh");
4031
4032   // AVX defines UNPCK* to operate independently on 128-bit lanes.
4033   unsigned NumLanes;
4034   unsigned NumOf256BitLanes;
4035   unsigned NumElts = VT.getVectorNumElements();
4036   if (VT.is256BitVector()) {
4037     if (NumElts != 4 && NumElts != 8 &&
4038         (!HasInt256 || (NumElts != 16 && NumElts != 32)))
4039     return false;
4040     NumLanes = 2;
4041     NumOf256BitLanes = 1;
4042   } else if (VT.is512BitVector()) {
4043     assert(VT.getScalarType().getSizeInBits() >= 32 &&
4044            "Unsupported vector type for unpckh");
4045     NumLanes = 2;
4046     NumOf256BitLanes = 2;
4047   } else {
4048     NumLanes = 1;
4049     NumOf256BitLanes = 1;
4050   }
4051
4052   unsigned NumEltsInStride = NumElts/NumOf256BitLanes;
4053   unsigned NumLaneElts = NumEltsInStride/NumLanes;
4054
4055   for (unsigned l256 = 0; l256 < NumOf256BitLanes; l256 += 1) {
4056     for (unsigned l = 0; l != NumEltsInStride; l += NumLaneElts) {
4057       for (unsigned i = 0, j = l+NumLaneElts/2; i != NumLaneElts; i += 2, ++j) {
4058         int BitI  = Mask[l256*NumEltsInStride+l+i];
4059         int BitI1 = Mask[l256*NumEltsInStride+l+i+1];
4060         if (!isUndefOrEqual(BitI, j+l256*NumElts))
4061           return false;
4062         if (V2IsSplat && !isUndefOrEqual(BitI1, NumElts))
4063           return false;
4064         if (!isUndefOrEqual(BitI1, j+l256*NumElts+NumEltsInStride))
4065           return false;
4066       }
4067     }
4068   }
4069   return true;
4070 }
4071
4072 /// isUNPCKL_v_undef_Mask - Special case of isUNPCKLMask for canonical form
4073 /// of vector_shuffle v, v, <0, 4, 1, 5>, i.e. vector_shuffle v, undef,
4074 /// <0, 0, 1, 1>
4075 static bool isUNPCKL_v_undef_Mask(ArrayRef<int> Mask, MVT VT, bool HasInt256) {
4076   unsigned NumElts = VT.getVectorNumElements();
4077   bool Is256BitVec = VT.is256BitVector();
4078
4079   if (VT.is512BitVector())
4080     return false;
4081   assert((VT.is128BitVector() || VT.is256BitVector()) &&
4082          "Unsupported vector type for unpckh");
4083
4084   if (Is256BitVec && NumElts != 4 && NumElts != 8 &&
4085       (!HasInt256 || (NumElts != 16 && NumElts != 32)))
4086     return false;
4087
4088   // For 256-bit i64/f64, use MOVDDUPY instead, so reject the matching pattern
4089   // FIXME: Need a better way to get rid of this, there's no latency difference
4090   // between UNPCKLPD and MOVDDUP, the later should always be checked first and
4091   // the former later. We should also remove the "_undef" special mask.
4092   if (NumElts == 4 && Is256BitVec)
4093     return false;
4094
4095   // Handle 128 and 256-bit vector lengths. AVX defines UNPCK* to operate
4096   // independently on 128-bit lanes.
4097   unsigned NumLanes = VT.getSizeInBits()/128;
4098   unsigned NumLaneElts = NumElts/NumLanes;
4099
4100   for (unsigned l = 0; l != NumElts; l += NumLaneElts) {
4101     for (unsigned i = 0, j = l; i != NumLaneElts; i += 2, ++j) {
4102       int BitI  = Mask[l+i];
4103       int BitI1 = Mask[l+i+1];
4104
4105       if (!isUndefOrEqual(BitI, j))
4106         return false;
4107       if (!isUndefOrEqual(BitI1, j))
4108         return false;
4109     }
4110   }
4111
4112   return true;
4113 }
4114
4115 /// isUNPCKH_v_undef_Mask - Special case of isUNPCKHMask for canonical form
4116 /// of vector_shuffle v, v, <2, 6, 3, 7>, i.e. vector_shuffle v, undef,
4117 /// <2, 2, 3, 3>
4118 static bool isUNPCKH_v_undef_Mask(ArrayRef<int> Mask, MVT VT, bool HasInt256) {
4119   unsigned NumElts = VT.getVectorNumElements();
4120
4121   if (VT.is512BitVector())
4122     return false;
4123
4124   assert((VT.is128BitVector() || VT.is256BitVector()) &&
4125          "Unsupported vector type for unpckh");
4126
4127   if (VT.is256BitVector() && NumElts != 4 && NumElts != 8 &&
4128       (!HasInt256 || (NumElts != 16 && NumElts != 32)))
4129     return false;
4130
4131   // Handle 128 and 256-bit vector lengths. AVX defines UNPCK* to operate
4132   // independently on 128-bit lanes.
4133   unsigned NumLanes = VT.getSizeInBits()/128;
4134   unsigned NumLaneElts = NumElts/NumLanes;
4135
4136   for (unsigned l = 0; l != NumElts; l += NumLaneElts) {
4137     for (unsigned i = 0, j = l+NumLaneElts/2; i != NumLaneElts; i += 2, ++j) {
4138       int BitI  = Mask[l+i];
4139       int BitI1 = Mask[l+i+1];
4140       if (!isUndefOrEqual(BitI, j))
4141         return false;
4142       if (!isUndefOrEqual(BitI1, j))
4143         return false;
4144     }
4145   }
4146   return true;
4147 }
4148
4149 /// isMOVLMask - Return true if the specified VECTOR_SHUFFLE operand
4150 /// specifies a shuffle of elements that is suitable for input to MOVSS,
4151 /// MOVSD, and MOVD, i.e. setting the lowest element.
4152 static bool isMOVLMask(ArrayRef<int> Mask, EVT VT) {
4153   if (VT.getVectorElementType().getSizeInBits() < 32)
4154     return false;
4155   if (!VT.is128BitVector())
4156     return false;
4157
4158   unsigned NumElts = VT.getVectorNumElements();
4159
4160   if (!isUndefOrEqual(Mask[0], NumElts))
4161     return false;
4162
4163   for (unsigned i = 1; i != NumElts; ++i)
4164     if (!isUndefOrEqual(Mask[i], i))
4165       return false;
4166
4167   return true;
4168 }
4169
4170 /// isVPERM2X128Mask - Match 256-bit shuffles where the elements are considered
4171 /// as permutations between 128-bit chunks or halves. As an example: this
4172 /// shuffle bellow:
4173 ///   vector_shuffle <4, 5, 6, 7, 12, 13, 14, 15>
4174 /// The first half comes from the second half of V1 and the second half from the
4175 /// the second half of V2.
4176 static bool isVPERM2X128Mask(ArrayRef<int> Mask, MVT VT, bool HasFp256) {
4177   if (!HasFp256 || !VT.is256BitVector())
4178     return false;
4179
4180   // The shuffle result is divided into half A and half B. In total the two
4181   // sources have 4 halves, namely: C, D, E, F. The final values of A and
4182   // B must come from C, D, E or F.
4183   unsigned HalfSize = VT.getVectorNumElements()/2;
4184   bool MatchA = false, MatchB = false;
4185
4186   // Check if A comes from one of C, D, E, F.
4187   for (unsigned Half = 0; Half != 4; ++Half) {
4188     if (isSequentialOrUndefInRange(Mask, 0, HalfSize, Half*HalfSize)) {
4189       MatchA = true;
4190       break;
4191     }
4192   }
4193
4194   // Check if B comes from one of C, D, E, F.
4195   for (unsigned Half = 0; Half != 4; ++Half) {
4196     if (isSequentialOrUndefInRange(Mask, HalfSize, HalfSize, Half*HalfSize)) {
4197       MatchB = true;
4198       break;
4199     }
4200   }
4201
4202   return MatchA && MatchB;
4203 }
4204
4205 /// getShuffleVPERM2X128Immediate - Return the appropriate immediate to shuffle
4206 /// the specified VECTOR_MASK mask with VPERM2F128/VPERM2I128 instructions.
4207 static unsigned getShuffleVPERM2X128Immediate(ShuffleVectorSDNode *SVOp) {
4208   MVT VT = SVOp->getSimpleValueType(0);
4209
4210   unsigned HalfSize = VT.getVectorNumElements()/2;
4211
4212   unsigned FstHalf = 0, SndHalf = 0;
4213   for (unsigned i = 0; i < HalfSize; ++i) {
4214     if (SVOp->getMaskElt(i) > 0) {
4215       FstHalf = SVOp->getMaskElt(i)/HalfSize;
4216       break;
4217     }
4218   }
4219   for (unsigned i = HalfSize; i < HalfSize*2; ++i) {
4220     if (SVOp->getMaskElt(i) > 0) {
4221       SndHalf = SVOp->getMaskElt(i)/HalfSize;
4222       break;
4223     }
4224   }
4225
4226   return (FstHalf | (SndHalf << 4));
4227 }
4228
4229 // Symetric in-lane mask. Each lane has 4 elements (for imm8)
4230 static bool isPermImmMask(ArrayRef<int> Mask, MVT VT, unsigned& Imm8) {
4231   unsigned EltSize = VT.getVectorElementType().getSizeInBits();
4232   if (EltSize < 32)
4233     return false;
4234
4235   unsigned NumElts = VT.getVectorNumElements();
4236   Imm8 = 0;
4237   if (VT.is128BitVector() || (VT.is256BitVector() && EltSize == 64)) {
4238     for (unsigned i = 0; i != NumElts; ++i) {
4239       if (Mask[i] < 0)
4240         continue;
4241       Imm8 |= Mask[i] << (i*2);
4242     }
4243     return true;
4244   }
4245
4246   unsigned LaneSize = 4;
4247   SmallVector<int, 4> MaskVal(LaneSize, -1);
4248
4249   for (unsigned l = 0; l != NumElts; l += LaneSize) {
4250     for (unsigned i = 0; i != LaneSize; ++i) {
4251       if (!isUndefOrInRange(Mask[i+l], l, l+LaneSize))
4252         return false;
4253       if (Mask[i+l] < 0)
4254         continue;
4255       if (MaskVal[i] < 0) {
4256         MaskVal[i] = Mask[i+l] - l;
4257         Imm8 |= MaskVal[i] << (i*2);
4258         continue;
4259       }
4260       if (Mask[i+l] != (signed)(MaskVal[i]+l))
4261         return false;
4262     }
4263   }
4264   return true;
4265 }
4266
4267 /// isVPERMILPMask - Return true if the specified VECTOR_SHUFFLE operand
4268 /// specifies a shuffle of elements that is suitable for input to VPERMILPD*.
4269 /// Note that VPERMIL mask matching is different depending whether theunderlying
4270 /// type is 32 or 64. In the VPERMILPS the high half of the mask should point
4271 /// to the same elements of the low, but to the higher half of the source.
4272 /// In VPERMILPD the two lanes could be shuffled independently of each other
4273 /// with the same restriction that lanes can't be crossed. Also handles PSHUFDY.
4274 static bool isVPERMILPMask(ArrayRef<int> Mask, MVT VT) {
4275   unsigned EltSize = VT.getVectorElementType().getSizeInBits();
4276   if (VT.getSizeInBits() < 256 || EltSize < 32)
4277     return false;
4278   bool symetricMaskRequired = (EltSize == 32);
4279   unsigned NumElts = VT.getVectorNumElements();
4280
4281   unsigned NumLanes = VT.getSizeInBits()/128;
4282   unsigned LaneSize = NumElts/NumLanes;
4283   // 2 or 4 elements in one lane
4284
4285   SmallVector<int, 4> ExpectedMaskVal(LaneSize, -1);
4286   for (unsigned l = 0; l != NumElts; l += LaneSize) {
4287     for (unsigned i = 0; i != LaneSize; ++i) {
4288       if (!isUndefOrInRange(Mask[i+l], l, l+LaneSize))
4289         return false;
4290       if (symetricMaskRequired) {
4291         if (ExpectedMaskVal[i] < 0 && Mask[i+l] >= 0) {
4292           ExpectedMaskVal[i] = Mask[i+l] - l;
4293           continue;
4294         }
4295         if (!isUndefOrEqual(Mask[i+l], ExpectedMaskVal[i]+l))
4296           return false;
4297       }
4298     }
4299   }
4300   return true;
4301 }
4302
4303 /// isCommutedMOVLMask - Returns true if the shuffle mask is except the reverse
4304 /// of what x86 movss want. X86 movs requires the lowest  element to be lowest
4305 /// element of vector 2 and the other elements to come from vector 1 in order.
4306 static bool isCommutedMOVLMask(ArrayRef<int> Mask, MVT VT,
4307                                bool V2IsSplat = false, bool V2IsUndef = false) {
4308   if (!VT.is128BitVector())
4309     return false;
4310
4311   unsigned NumOps = VT.getVectorNumElements();
4312   if (NumOps != 2 && NumOps != 4 && NumOps != 8 && NumOps != 16)
4313     return false;
4314
4315   if (!isUndefOrEqual(Mask[0], 0))
4316     return false;
4317
4318   for (unsigned i = 1; i != NumOps; ++i)
4319     if (!(isUndefOrEqual(Mask[i], i+NumOps) ||
4320           (V2IsUndef && isUndefOrInRange(Mask[i], NumOps, NumOps*2)) ||
4321           (V2IsSplat && isUndefOrEqual(Mask[i], NumOps))))
4322       return false;
4323
4324   return true;
4325 }
4326
4327 /// isMOVSHDUPMask - Return true if the specified VECTOR_SHUFFLE operand
4328 /// specifies a shuffle of elements that is suitable for input to MOVSHDUP.
4329 /// Masks to match: <1, 1, 3, 3> or <1, 1, 3, 3, 5, 5, 7, 7>
4330 static bool isMOVSHDUPMask(ArrayRef<int> Mask, MVT VT,
4331                            const X86Subtarget *Subtarget) {
4332   if (!Subtarget->hasSSE3())
4333     return false;
4334
4335   unsigned NumElems = VT.getVectorNumElements();
4336
4337   if ((VT.is128BitVector() && NumElems != 4) ||
4338       (VT.is256BitVector() && NumElems != 8) ||
4339       (VT.is512BitVector() && NumElems != 16))
4340     return false;
4341
4342   // "i+1" is the value the indexed mask element must have
4343   for (unsigned i = 0; i != NumElems; i += 2)
4344     if (!isUndefOrEqual(Mask[i], i+1) ||
4345         !isUndefOrEqual(Mask[i+1], i+1))
4346       return false;
4347
4348   return true;
4349 }
4350
4351 /// isMOVSLDUPMask - Return true if the specified VECTOR_SHUFFLE operand
4352 /// specifies a shuffle of elements that is suitable for input to MOVSLDUP.
4353 /// Masks to match: <0, 0, 2, 2> or <0, 0, 2, 2, 4, 4, 6, 6>
4354 static bool isMOVSLDUPMask(ArrayRef<int> Mask, MVT VT,
4355                            const X86Subtarget *Subtarget) {
4356   if (!Subtarget->hasSSE3())
4357     return false;
4358
4359   unsigned NumElems = VT.getVectorNumElements();
4360
4361   if ((VT.is128BitVector() && NumElems != 4) ||
4362       (VT.is256BitVector() && NumElems != 8) ||
4363       (VT.is512BitVector() && NumElems != 16))
4364     return false;
4365
4366   // "i" is the value the indexed mask element must have
4367   for (unsigned i = 0; i != NumElems; i += 2)
4368     if (!isUndefOrEqual(Mask[i], i) ||
4369         !isUndefOrEqual(Mask[i+1], i))
4370       return false;
4371
4372   return true;
4373 }
4374
4375 /// isMOVDDUPYMask - Return true if the specified VECTOR_SHUFFLE operand
4376 /// specifies a shuffle of elements that is suitable for input to 256-bit
4377 /// version of MOVDDUP.
4378 static bool isMOVDDUPYMask(ArrayRef<int> Mask, MVT VT, bool HasFp256) {
4379   if (!HasFp256 || !VT.is256BitVector())
4380     return false;
4381
4382   unsigned NumElts = VT.getVectorNumElements();
4383   if (NumElts != 4)
4384     return false;
4385
4386   for (unsigned i = 0; i != NumElts/2; ++i)
4387     if (!isUndefOrEqual(Mask[i], 0))
4388       return false;
4389   for (unsigned i = NumElts/2; i != NumElts; ++i)
4390     if (!isUndefOrEqual(Mask[i], NumElts/2))
4391       return false;
4392   return true;
4393 }
4394
4395 /// isMOVDDUPMask - Return true if the specified VECTOR_SHUFFLE operand
4396 /// specifies a shuffle of elements that is suitable for input to 128-bit
4397 /// version of MOVDDUP.
4398 static bool isMOVDDUPMask(ArrayRef<int> Mask, MVT VT) {
4399   if (!VT.is128BitVector())
4400     return false;
4401
4402   unsigned e = VT.getVectorNumElements() / 2;
4403   for (unsigned i = 0; i != e; ++i)
4404     if (!isUndefOrEqual(Mask[i], i))
4405       return false;
4406   for (unsigned i = 0; i != e; ++i)
4407     if (!isUndefOrEqual(Mask[e+i], i))
4408       return false;
4409   return true;
4410 }
4411
4412 /// isVEXTRACTIndex - Return true if the specified
4413 /// EXTRACT_SUBVECTOR operand specifies a vector extract that is
4414 /// suitable for instruction that extract 128 or 256 bit vectors
4415 static bool isVEXTRACTIndex(SDNode *N, unsigned vecWidth) {
4416   assert((vecWidth == 128 || vecWidth == 256) && "Unexpected vector width");
4417   if (!isa<ConstantSDNode>(N->getOperand(1).getNode()))
4418     return false;
4419
4420   // The index should be aligned on a vecWidth-bit boundary.
4421   uint64_t Index =
4422     cast<ConstantSDNode>(N->getOperand(1).getNode())->getZExtValue();
4423
4424   MVT VT = N->getSimpleValueType(0);
4425   unsigned ElSize = VT.getVectorElementType().getSizeInBits();
4426   bool Result = (Index * ElSize) % vecWidth == 0;
4427
4428   return Result;
4429 }
4430
4431 /// isVINSERTIndex - Return true if the specified INSERT_SUBVECTOR
4432 /// operand specifies a subvector insert that is suitable for input to
4433 /// insertion of 128 or 256-bit subvectors
4434 static bool isVINSERTIndex(SDNode *N, unsigned vecWidth) {
4435   assert((vecWidth == 128 || vecWidth == 256) && "Unexpected vector width");
4436   if (!isa<ConstantSDNode>(N->getOperand(2).getNode()))
4437     return false;
4438   // The index should be aligned on a vecWidth-bit boundary.
4439   uint64_t Index =
4440     cast<ConstantSDNode>(N->getOperand(2).getNode())->getZExtValue();
4441
4442   MVT VT = N->getSimpleValueType(0);
4443   unsigned ElSize = VT.getVectorElementType().getSizeInBits();
4444   bool Result = (Index * ElSize) % vecWidth == 0;
4445
4446   return Result;
4447 }
4448
4449 bool X86::isVINSERT128Index(SDNode *N) {
4450   return isVINSERTIndex(N, 128);
4451 }
4452
4453 bool X86::isVINSERT256Index(SDNode *N) {
4454   return isVINSERTIndex(N, 256);
4455 }
4456
4457 bool X86::isVEXTRACT128Index(SDNode *N) {
4458   return isVEXTRACTIndex(N, 128);
4459 }
4460
4461 bool X86::isVEXTRACT256Index(SDNode *N) {
4462   return isVEXTRACTIndex(N, 256);
4463 }
4464
4465 /// getShuffleSHUFImmediate - Return the appropriate immediate to shuffle
4466 /// the specified VECTOR_SHUFFLE mask with PSHUF* and SHUFP* instructions.
4467 /// Handles 128-bit and 256-bit.
4468 static unsigned getShuffleSHUFImmediate(ShuffleVectorSDNode *N) {
4469   MVT VT = N->getSimpleValueType(0);
4470
4471   assert((VT.getSizeInBits() >= 128) &&
4472          "Unsupported vector type for PSHUF/SHUFP");
4473
4474   // Handle 128 and 256-bit vector lengths. AVX defines PSHUF/SHUFP to operate
4475   // independently on 128-bit lanes.
4476   unsigned NumElts = VT.getVectorNumElements();
4477   unsigned NumLanes = VT.getSizeInBits()/128;
4478   unsigned NumLaneElts = NumElts/NumLanes;
4479
4480   assert((NumLaneElts == 2 || NumLaneElts == 4 || NumLaneElts == 8) &&
4481          "Only supports 2, 4 or 8 elements per lane");
4482
4483   unsigned Shift = (NumLaneElts >= 4) ? 1 : 0;
4484   unsigned Mask = 0;
4485   for (unsigned i = 0; i != NumElts; ++i) {
4486     int Elt = N->getMaskElt(i);
4487     if (Elt < 0) continue;
4488     Elt &= NumLaneElts - 1;
4489     unsigned ShAmt = (i << Shift) % 8;
4490     Mask |= Elt << ShAmt;
4491   }
4492
4493   return Mask;
4494 }
4495
4496 /// getShufflePSHUFHWImmediate - Return the appropriate immediate to shuffle
4497 /// the specified VECTOR_SHUFFLE mask with the PSHUFHW instruction.
4498 static unsigned getShufflePSHUFHWImmediate(ShuffleVectorSDNode *N) {
4499   MVT VT = N->getSimpleValueType(0);
4500
4501   assert((VT == MVT::v8i16 || VT == MVT::v16i16) &&
4502          "Unsupported vector type for PSHUFHW");
4503
4504   unsigned NumElts = VT.getVectorNumElements();
4505
4506   unsigned Mask = 0;
4507   for (unsigned l = 0; l != NumElts; l += 8) {
4508     // 8 nodes per lane, but we only care about the last 4.
4509     for (unsigned i = 0; i < 4; ++i) {
4510       int Elt = N->getMaskElt(l+i+4);
4511       if (Elt < 0) continue;
4512       Elt &= 0x3; // only 2-bits.
4513       Mask |= Elt << (i * 2);
4514     }
4515   }
4516
4517   return Mask;
4518 }
4519
4520 /// getShufflePSHUFLWImmediate - Return the appropriate immediate to shuffle
4521 /// the specified VECTOR_SHUFFLE mask with the PSHUFLW instruction.
4522 static unsigned getShufflePSHUFLWImmediate(ShuffleVectorSDNode *N) {
4523   MVT VT = N->getSimpleValueType(0);
4524
4525   assert((VT == MVT::v8i16 || VT == MVT::v16i16) &&
4526          "Unsupported vector type for PSHUFHW");
4527
4528   unsigned NumElts = VT.getVectorNumElements();
4529
4530   unsigned Mask = 0;
4531   for (unsigned l = 0; l != NumElts; l += 8) {
4532     // 8 nodes per lane, but we only care about the first 4.
4533     for (unsigned i = 0; i < 4; ++i) {
4534       int Elt = N->getMaskElt(l+i);
4535       if (Elt < 0) continue;
4536       Elt &= 0x3; // only 2-bits
4537       Mask |= Elt << (i * 2);
4538     }
4539   }
4540
4541   return Mask;
4542 }
4543
4544 /// getShufflePALIGNRImmediate - Return the appropriate immediate to shuffle
4545 /// the specified VECTOR_SHUFFLE mask with the PALIGNR instruction.
4546 static unsigned getShufflePALIGNRImmediate(ShuffleVectorSDNode *SVOp) {
4547   MVT VT = SVOp->getSimpleValueType(0);
4548   unsigned EltSize = VT.is512BitVector() ? 1 :
4549     VT.getVectorElementType().getSizeInBits() >> 3;
4550
4551   unsigned NumElts = VT.getVectorNumElements();
4552   unsigned NumLanes = VT.is512BitVector() ? 1 : VT.getSizeInBits()/128;
4553   unsigned NumLaneElts = NumElts/NumLanes;
4554
4555   int Val = 0;
4556   unsigned i;
4557   for (i = 0; i != NumElts; ++i) {
4558     Val = SVOp->getMaskElt(i);
4559     if (Val >= 0)
4560       break;
4561   }
4562   if (Val >= (int)NumElts)
4563     Val -= NumElts - NumLaneElts;
4564
4565   assert(Val - i > 0 && "PALIGNR imm should be positive");
4566   return (Val - i) * EltSize;
4567 }
4568
4569 static unsigned getExtractVEXTRACTImmediate(SDNode *N, unsigned vecWidth) {
4570   assert((vecWidth == 128 || vecWidth == 256) && "Unsupported vector width");
4571   if (!isa<ConstantSDNode>(N->getOperand(1).getNode()))
4572     llvm_unreachable("Illegal extract subvector for VEXTRACT");
4573
4574   uint64_t Index =
4575     cast<ConstantSDNode>(N->getOperand(1).getNode())->getZExtValue();
4576
4577   MVT VecVT = N->getOperand(0).getSimpleValueType();
4578   MVT ElVT = VecVT.getVectorElementType();
4579
4580   unsigned NumElemsPerChunk = vecWidth / ElVT.getSizeInBits();
4581   return Index / NumElemsPerChunk;
4582 }
4583
4584 static unsigned getInsertVINSERTImmediate(SDNode *N, unsigned vecWidth) {
4585   assert((vecWidth == 128 || vecWidth == 256) && "Unsupported vector width");
4586   if (!isa<ConstantSDNode>(N->getOperand(2).getNode()))
4587     llvm_unreachable("Illegal insert subvector for VINSERT");
4588
4589   uint64_t Index =
4590     cast<ConstantSDNode>(N->getOperand(2).getNode())->getZExtValue();
4591
4592   MVT VecVT = N->getSimpleValueType(0);
4593   MVT ElVT = VecVT.getVectorElementType();
4594
4595   unsigned NumElemsPerChunk = vecWidth / ElVT.getSizeInBits();
4596   return Index / NumElemsPerChunk;
4597 }
4598
4599 /// getExtractVEXTRACT128Immediate - Return the appropriate immediate
4600 /// to extract the specified EXTRACT_SUBVECTOR index with VEXTRACTF128
4601 /// and VINSERTI128 instructions.
4602 unsigned X86::getExtractVEXTRACT128Immediate(SDNode *N) {
4603   return getExtractVEXTRACTImmediate(N, 128);
4604 }
4605
4606 /// getExtractVEXTRACT256Immediate - Return the appropriate immediate
4607 /// to extract the specified EXTRACT_SUBVECTOR index with VEXTRACTF64x4
4608 /// and VINSERTI64x4 instructions.
4609 unsigned X86::getExtractVEXTRACT256Immediate(SDNode *N) {
4610   return getExtractVEXTRACTImmediate(N, 256);
4611 }
4612
4613 /// getInsertVINSERT128Immediate - Return the appropriate immediate
4614 /// to insert at the specified INSERT_SUBVECTOR index with VINSERTF128
4615 /// and VINSERTI128 instructions.
4616 unsigned X86::getInsertVINSERT128Immediate(SDNode *N) {
4617   return getInsertVINSERTImmediate(N, 128);
4618 }
4619
4620 /// getInsertVINSERT256Immediate - Return the appropriate immediate
4621 /// to insert at the specified INSERT_SUBVECTOR index with VINSERTF46x4
4622 /// and VINSERTI64x4 instructions.
4623 unsigned X86::getInsertVINSERT256Immediate(SDNode *N) {
4624   return getInsertVINSERTImmediate(N, 256);
4625 }
4626
4627 /// isZeroNode - Returns true if Elt is a constant zero or a floating point
4628 /// constant +0.0.
4629 bool X86::isZeroNode(SDValue Elt) {
4630   if (ConstantSDNode *CN = dyn_cast<ConstantSDNode>(Elt))
4631     return CN->isNullValue();
4632   if (ConstantFPSDNode *CFP = dyn_cast<ConstantFPSDNode>(Elt))
4633     return CFP->getValueAPF().isPosZero();
4634   return false;
4635 }
4636
4637 /// CommuteVectorShuffle - Swap vector_shuffle operands as well as values in
4638 /// their permute mask.
4639 static SDValue CommuteVectorShuffle(ShuffleVectorSDNode *SVOp,
4640                                     SelectionDAG &DAG) {
4641   MVT VT = SVOp->getSimpleValueType(0);
4642   unsigned NumElems = VT.getVectorNumElements();
4643   SmallVector<int, 8> MaskVec;
4644
4645   for (unsigned i = 0; i != NumElems; ++i) {
4646     int Idx = SVOp->getMaskElt(i);
4647     if (Idx >= 0) {
4648       if (Idx < (int)NumElems)
4649         Idx += NumElems;
4650       else
4651         Idx -= NumElems;
4652     }
4653     MaskVec.push_back(Idx);
4654   }
4655   return DAG.getVectorShuffle(VT, SDLoc(SVOp), SVOp->getOperand(1),
4656                               SVOp->getOperand(0), &MaskVec[0]);
4657 }
4658
4659 /// ShouldXformToMOVHLPS - Return true if the node should be transformed to
4660 /// match movhlps. The lower half elements should come from upper half of
4661 /// V1 (and in order), and the upper half elements should come from the upper
4662 /// half of V2 (and in order).
4663 static bool ShouldXformToMOVHLPS(ArrayRef<int> Mask, MVT VT) {
4664   if (!VT.is128BitVector())
4665     return false;
4666   if (VT.getVectorNumElements() != 4)
4667     return false;
4668   for (unsigned i = 0, e = 2; i != e; ++i)
4669     if (!isUndefOrEqual(Mask[i], i+2))
4670       return false;
4671   for (unsigned i = 2; i != 4; ++i)
4672     if (!isUndefOrEqual(Mask[i], i+4))
4673       return false;
4674   return true;
4675 }
4676
4677 /// isScalarLoadToVector - Returns true if the node is a scalar load that
4678 /// is promoted to a vector. It also returns the LoadSDNode by reference if
4679 /// required.
4680 static bool isScalarLoadToVector(SDNode *N, LoadSDNode **LD = NULL) {
4681   if (N->getOpcode() != ISD::SCALAR_TO_VECTOR)
4682     return false;
4683   N = N->getOperand(0).getNode();
4684   if (!ISD::isNON_EXTLoad(N))
4685     return false;
4686   if (LD)
4687     *LD = cast<LoadSDNode>(N);
4688   return true;
4689 }
4690
4691 // Test whether the given value is a vector value which will be legalized
4692 // into a load.
4693 static bool WillBeConstantPoolLoad(SDNode *N) {
4694   if (N->getOpcode() != ISD::BUILD_VECTOR)
4695     return false;
4696
4697   // Check for any non-constant elements.
4698   for (unsigned i = 0, e = N->getNumOperands(); i != e; ++i)
4699     switch (N->getOperand(i).getNode()->getOpcode()) {
4700     case ISD::UNDEF:
4701     case ISD::ConstantFP:
4702     case ISD::Constant:
4703       break;
4704     default:
4705       return false;
4706     }
4707
4708   // Vectors of all-zeros and all-ones are materialized with special
4709   // instructions rather than being loaded.
4710   return !ISD::isBuildVectorAllZeros(N) &&
4711          !ISD::isBuildVectorAllOnes(N);
4712 }
4713
4714 /// ShouldXformToMOVLP{S|D} - Return true if the node should be transformed to
4715 /// match movlp{s|d}. The lower half elements should come from lower half of
4716 /// V1 (and in order), and the upper half elements should come from the upper
4717 /// half of V2 (and in order). And since V1 will become the source of the
4718 /// MOVLP, it must be either a vector load or a scalar load to vector.
4719 static bool ShouldXformToMOVLP(SDNode *V1, SDNode *V2,
4720                                ArrayRef<int> Mask, MVT VT) {
4721   if (!VT.is128BitVector())
4722     return false;
4723
4724   if (!ISD::isNON_EXTLoad(V1) && !isScalarLoadToVector(V1))
4725     return false;
4726   // Is V2 is a vector load, don't do this transformation. We will try to use
4727   // load folding shufps op.
4728   if (ISD::isNON_EXTLoad(V2) || WillBeConstantPoolLoad(V2))
4729     return false;
4730
4731   unsigned NumElems = VT.getVectorNumElements();
4732
4733   if (NumElems != 2 && NumElems != 4)
4734     return false;
4735   for (unsigned i = 0, e = NumElems/2; i != e; ++i)
4736     if (!isUndefOrEqual(Mask[i], i))
4737       return false;
4738   for (unsigned i = NumElems/2, e = NumElems; i != e; ++i)
4739     if (!isUndefOrEqual(Mask[i], i+NumElems))
4740       return false;
4741   return true;
4742 }
4743
4744 /// isSplatVector - Returns true if N is a BUILD_VECTOR node whose elements are
4745 /// all the same.
4746 static bool isSplatVector(SDNode *N) {
4747   if (N->getOpcode() != ISD::BUILD_VECTOR)
4748     return false;
4749
4750   SDValue SplatValue = N->getOperand(0);
4751   for (unsigned i = 1, e = N->getNumOperands(); i != e; ++i)
4752     if (N->getOperand(i) != SplatValue)
4753       return false;
4754   return true;
4755 }
4756
4757 /// isZeroShuffle - Returns true if N is a VECTOR_SHUFFLE that can be resolved
4758 /// to an zero vector.
4759 /// FIXME: move to dag combiner / method on ShuffleVectorSDNode
4760 static bool isZeroShuffle(ShuffleVectorSDNode *N) {
4761   SDValue V1 = N->getOperand(0);
4762   SDValue V2 = N->getOperand(1);
4763   unsigned NumElems = N->getValueType(0).getVectorNumElements();
4764   for (unsigned i = 0; i != NumElems; ++i) {
4765     int Idx = N->getMaskElt(i);
4766     if (Idx >= (int)NumElems) {
4767       unsigned Opc = V2.getOpcode();
4768       if (Opc == ISD::UNDEF || ISD::isBuildVectorAllZeros(V2.getNode()))
4769         continue;
4770       if (Opc != ISD::BUILD_VECTOR ||
4771           !X86::isZeroNode(V2.getOperand(Idx-NumElems)))
4772         return false;
4773     } else if (Idx >= 0) {
4774       unsigned Opc = V1.getOpcode();
4775       if (Opc == ISD::UNDEF || ISD::isBuildVectorAllZeros(V1.getNode()))
4776         continue;
4777       if (Opc != ISD::BUILD_VECTOR ||
4778           !X86::isZeroNode(V1.getOperand(Idx)))
4779         return false;
4780     }
4781   }
4782   return true;
4783 }
4784
4785 /// getZeroVector - Returns a vector of specified type with all zero elements.
4786 ///
4787 static SDValue getZeroVector(EVT VT, const X86Subtarget *Subtarget,
4788                              SelectionDAG &DAG, SDLoc dl) {
4789   assert(VT.isVector() && "Expected a vector type");
4790
4791   // Always build SSE zero vectors as <4 x i32> bitcasted
4792   // to their dest type. This ensures they get CSE'd.
4793   SDValue Vec;
4794   if (VT.is128BitVector()) {  // SSE
4795     if (Subtarget->hasSSE2()) {  // SSE2
4796       SDValue Cst = DAG.getTargetConstant(0, MVT::i32);
4797       Vec = DAG.getNode(ISD::BUILD_VECTOR, dl, MVT::v4i32, Cst, Cst, Cst, Cst);
4798     } else { // SSE1
4799       SDValue Cst = DAG.getTargetConstantFP(+0.0, MVT::f32);
4800       Vec = DAG.getNode(ISD::BUILD_VECTOR, dl, MVT::v4f32, Cst, Cst, Cst, Cst);
4801     }
4802   } else if (VT.is256BitVector()) { // AVX
4803     if (Subtarget->hasInt256()) { // AVX2
4804       SDValue Cst = DAG.getTargetConstant(0, MVT::i32);
4805       SDValue Ops[] = { Cst, Cst, Cst, Cst, Cst, Cst, Cst, Cst };
4806       Vec = DAG.getNode(ISD::BUILD_VECTOR, dl, MVT::v8i32, Ops,
4807                         array_lengthof(Ops));
4808     } else {
4809       // 256-bit logic and arithmetic instructions in AVX are all
4810       // floating-point, no support for integer ops. Emit fp zeroed vectors.
4811       SDValue Cst = DAG.getTargetConstantFP(+0.0, MVT::f32);
4812       SDValue Ops[] = { Cst, Cst, Cst, Cst, Cst, Cst, Cst, Cst };
4813       Vec = DAG.getNode(ISD::BUILD_VECTOR, dl, MVT::v8f32, Ops,
4814                         array_lengthof(Ops));
4815     }
4816   } else if (VT.is512BitVector()) { // AVX-512
4817       SDValue Cst = DAG.getTargetConstant(0, MVT::i32);
4818       SDValue Ops[] = { Cst, Cst, Cst, Cst, Cst, Cst, Cst, Cst,
4819                         Cst, Cst, Cst, Cst, Cst, Cst, Cst, Cst };
4820       Vec = DAG.getNode(ISD::BUILD_VECTOR, dl, MVT::v16i32, Ops, 16);
4821   } else if (VT.getScalarType() == MVT::i1) {
4822     assert(VT.getVectorNumElements() <= 16 && "Unexpected vector type");
4823     SDValue Cst = DAG.getTargetConstant(0, MVT::i1);
4824     SDValue Ops[] = { Cst, Cst, Cst, Cst, Cst, Cst, Cst, Cst,
4825                       Cst, Cst, Cst, Cst, Cst, Cst, Cst, Cst };
4826     return DAG.getNode(ISD::BUILD_VECTOR, dl, VT,
4827                        Ops, VT.getVectorNumElements());
4828   } else
4829     llvm_unreachable("Unexpected vector type");
4830
4831   return DAG.getNode(ISD::BITCAST, dl, VT, Vec);
4832 }
4833
4834 /// getOnesVector - Returns a vector of specified type with all bits set.
4835 /// Always build ones vectors as <4 x i32> or <8 x i32>. For 256-bit types with
4836 /// no AVX2 supprt, use two <4 x i32> inserted in a <8 x i32> appropriately.
4837 /// Then bitcast to their original type, ensuring they get CSE'd.
4838 static SDValue getOnesVector(MVT VT, bool HasInt256, SelectionDAG &DAG,
4839                              SDLoc dl) {
4840   assert(VT.isVector() && "Expected a vector type");
4841
4842   SDValue Cst = DAG.getTargetConstant(~0U, MVT::i32);
4843   SDValue Vec;
4844   if (VT.is256BitVector()) {
4845     if (HasInt256) { // AVX2
4846       SDValue Ops[] = { Cst, Cst, Cst, Cst, Cst, Cst, Cst, Cst };
4847       Vec = DAG.getNode(ISD::BUILD_VECTOR, dl, MVT::v8i32, Ops,
4848                         array_lengthof(Ops));
4849     } else { // AVX
4850       Vec = DAG.getNode(ISD::BUILD_VECTOR, dl, MVT::v4i32, Cst, Cst, Cst, Cst);
4851       Vec = Concat128BitVectors(Vec, Vec, MVT::v8i32, 8, DAG, dl);
4852     }
4853   } else if (VT.is128BitVector()) {
4854     Vec = DAG.getNode(ISD::BUILD_VECTOR, dl, MVT::v4i32, Cst, Cst, Cst, Cst);
4855   } else
4856     llvm_unreachable("Unexpected vector type");
4857
4858   return DAG.getNode(ISD::BITCAST, dl, VT, Vec);
4859 }
4860
4861 /// NormalizeMask - V2 is a splat, modify the mask (if needed) so all elements
4862 /// that point to V2 points to its first element.
4863 static void NormalizeMask(SmallVectorImpl<int> &Mask, unsigned NumElems) {
4864   for (unsigned i = 0; i != NumElems; ++i) {
4865     if (Mask[i] > (int)NumElems) {
4866       Mask[i] = NumElems;
4867     }
4868   }
4869 }
4870
4871 /// getMOVLMask - Returns a vector_shuffle mask for an movs{s|d}, movd
4872 /// operation of specified width.
4873 static SDValue getMOVL(SelectionDAG &DAG, SDLoc dl, EVT VT, SDValue V1,
4874                        SDValue V2) {
4875   unsigned NumElems = VT.getVectorNumElements();
4876   SmallVector<int, 8> Mask;
4877   Mask.push_back(NumElems);
4878   for (unsigned i = 1; i != NumElems; ++i)
4879     Mask.push_back(i);
4880   return DAG.getVectorShuffle(VT, dl, V1, V2, &Mask[0]);
4881 }
4882
4883 /// getUnpackl - Returns a vector_shuffle node for an unpackl operation.
4884 static SDValue getUnpackl(SelectionDAG &DAG, SDLoc dl, MVT VT, SDValue V1,
4885                           SDValue V2) {
4886   unsigned NumElems = VT.getVectorNumElements();
4887   SmallVector<int, 8> Mask;
4888   for (unsigned i = 0, e = NumElems/2; i != e; ++i) {
4889     Mask.push_back(i);
4890     Mask.push_back(i + NumElems);
4891   }
4892   return DAG.getVectorShuffle(VT, dl, V1, V2, &Mask[0]);
4893 }
4894
4895 /// getUnpackh - Returns a vector_shuffle node for an unpackh operation.
4896 static SDValue getUnpackh(SelectionDAG &DAG, SDLoc dl, MVT VT, SDValue V1,
4897                           SDValue V2) {
4898   unsigned NumElems = VT.getVectorNumElements();
4899   SmallVector<int, 8> Mask;
4900   for (unsigned i = 0, Half = NumElems/2; i != Half; ++i) {
4901     Mask.push_back(i + Half);
4902     Mask.push_back(i + NumElems + Half);
4903   }
4904   return DAG.getVectorShuffle(VT, dl, V1, V2, &Mask[0]);
4905 }
4906
4907 // PromoteSplati8i16 - All i16 and i8 vector types can't be used directly by
4908 // a generic shuffle instruction because the target has no such instructions.
4909 // Generate shuffles which repeat i16 and i8 several times until they can be
4910 // represented by v4f32 and then be manipulated by target suported shuffles.
4911 static SDValue PromoteSplati8i16(SDValue V, SelectionDAG &DAG, int &EltNo) {
4912   MVT VT = V.getSimpleValueType();
4913   int NumElems = VT.getVectorNumElements();
4914   SDLoc dl(V);
4915
4916   while (NumElems > 4) {
4917     if (EltNo < NumElems/2) {
4918       V = getUnpackl(DAG, dl, VT, V, V);
4919     } else {
4920       V = getUnpackh(DAG, dl, VT, V, V);
4921       EltNo -= NumElems/2;
4922     }
4923     NumElems >>= 1;
4924   }
4925   return V;
4926 }
4927
4928 /// getLegalSplat - Generate a legal splat with supported x86 shuffles
4929 static SDValue getLegalSplat(SelectionDAG &DAG, SDValue V, int EltNo) {
4930   MVT VT = V.getSimpleValueType();
4931   SDLoc dl(V);
4932
4933   if (VT.is128BitVector()) {
4934     V = DAG.getNode(ISD::BITCAST, dl, MVT::v4f32, V);
4935     int SplatMask[4] = { EltNo, EltNo, EltNo, EltNo };
4936     V = DAG.getVectorShuffle(MVT::v4f32, dl, V, DAG.getUNDEF(MVT::v4f32),
4937                              &SplatMask[0]);
4938   } else if (VT.is256BitVector()) {
4939     // To use VPERMILPS to splat scalars, the second half of indicies must
4940     // refer to the higher part, which is a duplication of the lower one,
4941     // because VPERMILPS can only handle in-lane permutations.
4942     int SplatMask[8] = { EltNo, EltNo, EltNo, EltNo,
4943                          EltNo+4, EltNo+4, EltNo+4, EltNo+4 };
4944
4945     V = DAG.getNode(ISD::BITCAST, dl, MVT::v8f32, V);
4946     V = DAG.getVectorShuffle(MVT::v8f32, dl, V, DAG.getUNDEF(MVT::v8f32),
4947                              &SplatMask[0]);
4948   } else
4949     llvm_unreachable("Vector size not supported");
4950
4951   return DAG.getNode(ISD::BITCAST, dl, VT, V);
4952 }
4953
4954 /// PromoteSplat - Splat is promoted to target supported vector shuffles.
4955 static SDValue PromoteSplat(ShuffleVectorSDNode *SV, SelectionDAG &DAG) {
4956   MVT SrcVT = SV->getSimpleValueType(0);
4957   SDValue V1 = SV->getOperand(0);
4958   SDLoc dl(SV);
4959
4960   int EltNo = SV->getSplatIndex();
4961   int NumElems = SrcVT.getVectorNumElements();
4962   bool Is256BitVec = SrcVT.is256BitVector();
4963
4964   assert(((SrcVT.is128BitVector() && NumElems > 4) || Is256BitVec) &&
4965          "Unknown how to promote splat for type");
4966
4967   // Extract the 128-bit part containing the splat element and update
4968   // the splat element index when it refers to the higher register.
4969   if (Is256BitVec) {
4970     V1 = Extract128BitVector(V1, EltNo, DAG, dl);
4971     if (EltNo >= NumElems/2)
4972       EltNo -= NumElems/2;
4973   }
4974
4975   // All i16 and i8 vector types can't be used directly by a generic shuffle
4976   // instruction because the target has no such instruction. Generate shuffles
4977   // which repeat i16 and i8 several times until they fit in i32, and then can
4978   // be manipulated by target suported shuffles.
4979   MVT EltVT = SrcVT.getVectorElementType();
4980   if (EltVT == MVT::i8 || EltVT == MVT::i16)
4981     V1 = PromoteSplati8i16(V1, DAG, EltNo);
4982
4983   // Recreate the 256-bit vector and place the same 128-bit vector
4984   // into the low and high part. This is necessary because we want
4985   // to use VPERM* to shuffle the vectors
4986   if (Is256BitVec) {
4987     V1 = DAG.getNode(ISD::CONCAT_VECTORS, dl, SrcVT, V1, V1);
4988   }
4989
4990   return getLegalSplat(DAG, V1, EltNo);
4991 }
4992
4993 /// getShuffleVectorZeroOrUndef - Return a vector_shuffle of the specified
4994 /// vector of zero or undef vector.  This produces a shuffle where the low
4995 /// element of V2 is swizzled into the zero/undef vector, landing at element
4996 /// Idx.  This produces a shuffle mask like 4,1,2,3 (idx=0) or  0,1,2,4 (idx=3).
4997 static SDValue getShuffleVectorZeroOrUndef(SDValue V2, unsigned Idx,
4998                                            bool IsZero,
4999                                            const X86Subtarget *Subtarget,
5000                                            SelectionDAG &DAG) {
5001   MVT VT = V2.getSimpleValueType();
5002   SDValue V1 = IsZero
5003     ? getZeroVector(VT, Subtarget, DAG, SDLoc(V2)) : DAG.getUNDEF(VT);
5004   unsigned NumElems = VT.getVectorNumElements();
5005   SmallVector<int, 16> MaskVec;
5006   for (unsigned i = 0; i != NumElems; ++i)
5007     // If this is the insertion idx, put the low elt of V2 here.
5008     MaskVec.push_back(i == Idx ? NumElems : i);
5009   return DAG.getVectorShuffle(VT, SDLoc(V2), V1, V2, &MaskVec[0]);
5010 }
5011
5012 /// getTargetShuffleMask - Calculates the shuffle mask corresponding to the
5013 /// target specific opcode. Returns true if the Mask could be calculated.
5014 /// Sets IsUnary to true if only uses one source.
5015 static bool getTargetShuffleMask(SDNode *N, MVT VT,
5016                                  SmallVectorImpl<int> &Mask, bool &IsUnary) {
5017   unsigned NumElems = VT.getVectorNumElements();
5018   SDValue ImmN;
5019
5020   IsUnary = false;
5021   switch(N->getOpcode()) {
5022   case X86ISD::SHUFP:
5023     ImmN = N->getOperand(N->getNumOperands()-1);
5024     DecodeSHUFPMask(VT, cast<ConstantSDNode>(ImmN)->getZExtValue(), Mask);
5025     break;
5026   case X86ISD::UNPCKH:
5027     DecodeUNPCKHMask(VT, Mask);
5028     break;
5029   case X86ISD::UNPCKL:
5030     DecodeUNPCKLMask(VT, Mask);
5031     break;
5032   case X86ISD::MOVHLPS:
5033     DecodeMOVHLPSMask(NumElems, Mask);
5034     break;
5035   case X86ISD::MOVLHPS:
5036     DecodeMOVLHPSMask(NumElems, Mask);
5037     break;
5038   case X86ISD::PALIGNR:
5039     ImmN = N->getOperand(N->getNumOperands()-1);
5040     DecodePALIGNRMask(VT, cast<ConstantSDNode>(ImmN)->getZExtValue(), Mask);
5041     break;
5042   case X86ISD::PSHUFD:
5043   case X86ISD::VPERMILP:
5044     ImmN = N->getOperand(N->getNumOperands()-1);
5045     DecodePSHUFMask(VT, cast<ConstantSDNode>(ImmN)->getZExtValue(), Mask);
5046     IsUnary = true;
5047     break;
5048   case X86ISD::PSHUFHW:
5049     ImmN = N->getOperand(N->getNumOperands()-1);
5050     DecodePSHUFHWMask(VT, cast<ConstantSDNode>(ImmN)->getZExtValue(), Mask);
5051     IsUnary = true;
5052     break;
5053   case X86ISD::PSHUFLW:
5054     ImmN = N->getOperand(N->getNumOperands()-1);
5055     DecodePSHUFLWMask(VT, cast<ConstantSDNode>(ImmN)->getZExtValue(), Mask);
5056     IsUnary = true;
5057     break;
5058   case X86ISD::VPERMI:
5059     ImmN = N->getOperand(N->getNumOperands()-1);
5060     DecodeVPERMMask(cast<ConstantSDNode>(ImmN)->getZExtValue(), Mask);
5061     IsUnary = true;
5062     break;
5063   case X86ISD::MOVSS:
5064   case X86ISD::MOVSD: {
5065     // The index 0 always comes from the first element of the second source,
5066     // this is why MOVSS and MOVSD are used in the first place. The other
5067     // elements come from the other positions of the first source vector
5068     Mask.push_back(NumElems);
5069     for (unsigned i = 1; i != NumElems; ++i) {
5070       Mask.push_back(i);
5071     }
5072     break;
5073   }
5074   case X86ISD::VPERM2X128:
5075     ImmN = N->getOperand(N->getNumOperands()-1);
5076     DecodeVPERM2X128Mask(VT, cast<ConstantSDNode>(ImmN)->getZExtValue(), Mask);
5077     if (Mask.empty()) return false;
5078     break;
5079   case X86ISD::MOVDDUP:
5080   case X86ISD::MOVLHPD:
5081   case X86ISD::MOVLPD:
5082   case X86ISD::MOVLPS:
5083   case X86ISD::MOVSHDUP:
5084   case X86ISD::MOVSLDUP:
5085     // Not yet implemented
5086     return false;
5087   default: llvm_unreachable("unknown target shuffle node");
5088   }
5089
5090   return true;
5091 }
5092
5093 /// getShuffleScalarElt - Returns the scalar element that will make up the ith
5094 /// element of the result of the vector shuffle.
5095 static SDValue getShuffleScalarElt(SDNode *N, unsigned Index, SelectionDAG &DAG,
5096                                    unsigned Depth) {
5097   if (Depth == 6)
5098     return SDValue();  // Limit search depth.
5099
5100   SDValue V = SDValue(N, 0);
5101   EVT VT = V.getValueType();
5102   unsigned Opcode = V.getOpcode();
5103
5104   // Recurse into ISD::VECTOR_SHUFFLE node to find scalars.
5105   if (const ShuffleVectorSDNode *SV = dyn_cast<ShuffleVectorSDNode>(N)) {
5106     int Elt = SV->getMaskElt(Index);
5107
5108     if (Elt < 0)
5109       return DAG.getUNDEF(VT.getVectorElementType());
5110
5111     unsigned NumElems = VT.getVectorNumElements();
5112     SDValue NewV = (Elt < (int)NumElems) ? SV->getOperand(0)
5113                                          : SV->getOperand(1);
5114     return getShuffleScalarElt(NewV.getNode(), Elt % NumElems, DAG, Depth+1);
5115   }
5116
5117   // Recurse into target specific vector shuffles to find scalars.
5118   if (isTargetShuffle(Opcode)) {
5119     MVT ShufVT = V.getSimpleValueType();
5120     unsigned NumElems = ShufVT.getVectorNumElements();
5121     SmallVector<int, 16> ShuffleMask;
5122     bool IsUnary;
5123
5124     if (!getTargetShuffleMask(N, ShufVT, ShuffleMask, IsUnary))
5125       return SDValue();
5126
5127     int Elt = ShuffleMask[Index];
5128     if (Elt < 0)
5129       return DAG.getUNDEF(ShufVT.getVectorElementType());
5130
5131     SDValue NewV = (Elt < (int)NumElems) ? N->getOperand(0)
5132                                          : N->getOperand(1);
5133     return getShuffleScalarElt(NewV.getNode(), Elt % NumElems, DAG,
5134                                Depth+1);
5135   }
5136
5137   // Actual nodes that may contain scalar elements
5138   if (Opcode == ISD::BITCAST) {
5139     V = V.getOperand(0);
5140     EVT SrcVT = V.getValueType();
5141     unsigned NumElems = VT.getVectorNumElements();
5142
5143     if (!SrcVT.isVector() || SrcVT.getVectorNumElements() != NumElems)
5144       return SDValue();
5145   }
5146
5147   if (V.getOpcode() == ISD::SCALAR_TO_VECTOR)
5148     return (Index == 0) ? V.getOperand(0)
5149                         : DAG.getUNDEF(VT.getVectorElementType());
5150
5151   if (V.getOpcode() == ISD::BUILD_VECTOR)
5152     return V.getOperand(Index);
5153
5154   return SDValue();
5155 }
5156
5157 /// getNumOfConsecutiveZeros - Return the number of elements of a vector
5158 /// shuffle operation which come from a consecutively from a zero. The
5159 /// search can start in two different directions, from left or right.
5160 /// We count undefs as zeros until PreferredNum is reached.
5161 static unsigned getNumOfConsecutiveZeros(ShuffleVectorSDNode *SVOp,
5162                                          unsigned NumElems, bool ZerosFromLeft,
5163                                          SelectionDAG &DAG,
5164                                          unsigned PreferredNum = -1U) {
5165   unsigned NumZeros = 0;
5166   for (unsigned i = 0; i != NumElems; ++i) {
5167     unsigned Index = ZerosFromLeft ? i : NumElems - i - 1;
5168     SDValue Elt = getShuffleScalarElt(SVOp, Index, DAG, 0);
5169     if (!Elt.getNode())
5170       break;
5171
5172     if (X86::isZeroNode(Elt))
5173       ++NumZeros;
5174     else if (Elt.getOpcode() == ISD::UNDEF) // Undef as zero up to PreferredNum.
5175       NumZeros = std::min(NumZeros + 1, PreferredNum);
5176     else
5177       break;
5178   }
5179
5180   return NumZeros;
5181 }
5182
5183 /// isShuffleMaskConsecutive - Check if the shuffle mask indicies [MaskI, MaskE)
5184 /// correspond consecutively to elements from one of the vector operands,
5185 /// starting from its index OpIdx. Also tell OpNum which source vector operand.
5186 static
5187 bool isShuffleMaskConsecutive(ShuffleVectorSDNode *SVOp,
5188                               unsigned MaskI, unsigned MaskE, unsigned OpIdx,
5189                               unsigned NumElems, unsigned &OpNum) {
5190   bool SeenV1 = false;
5191   bool SeenV2 = false;
5192
5193   for (unsigned i = MaskI; i != MaskE; ++i, ++OpIdx) {
5194     int Idx = SVOp->getMaskElt(i);
5195     // Ignore undef indicies
5196     if (Idx < 0)
5197       continue;
5198
5199     if (Idx < (int)NumElems)
5200       SeenV1 = true;
5201     else
5202       SeenV2 = true;
5203
5204     // Only accept consecutive elements from the same vector
5205     if ((Idx % NumElems != OpIdx) || (SeenV1 && SeenV2))
5206       return false;
5207   }
5208
5209   OpNum = SeenV1 ? 0 : 1;
5210   return true;
5211 }
5212
5213 /// isVectorShiftRight - Returns true if the shuffle can be implemented as a
5214 /// logical left shift of a vector.
5215 static bool isVectorShiftRight(ShuffleVectorSDNode *SVOp, SelectionDAG &DAG,
5216                                bool &isLeft, SDValue &ShVal, unsigned &ShAmt) {
5217   unsigned NumElems =
5218     SVOp->getSimpleValueType(0).getVectorNumElements();
5219   unsigned NumZeros = getNumOfConsecutiveZeros(
5220       SVOp, NumElems, false /* check zeros from right */, DAG,
5221       SVOp->getMaskElt(0));
5222   unsigned OpSrc;
5223
5224   if (!NumZeros)
5225     return false;
5226
5227   // Considering the elements in the mask that are not consecutive zeros,
5228   // check if they consecutively come from only one of the source vectors.
5229   //
5230   //               V1 = {X, A, B, C}     0
5231   //                         \  \  \    /
5232   //   vector_shuffle V1, V2 <1, 2, 3, X>
5233   //
5234   if (!isShuffleMaskConsecutive(SVOp,
5235             0,                   // Mask Start Index
5236             NumElems-NumZeros,   // Mask End Index(exclusive)
5237             NumZeros,            // Where to start looking in the src vector
5238             NumElems,            // Number of elements in vector
5239             OpSrc))              // Which source operand ?
5240     return false;
5241
5242   isLeft = false;
5243   ShAmt = NumZeros;
5244   ShVal = SVOp->getOperand(OpSrc);
5245   return true;
5246 }
5247
5248 /// isVectorShiftLeft - Returns true if the shuffle can be implemented as a
5249 /// logical left shift of a vector.
5250 static bool isVectorShiftLeft(ShuffleVectorSDNode *SVOp, SelectionDAG &DAG,
5251                               bool &isLeft, SDValue &ShVal, unsigned &ShAmt) {
5252   unsigned NumElems =
5253     SVOp->getSimpleValueType(0).getVectorNumElements();
5254   unsigned NumZeros = getNumOfConsecutiveZeros(
5255       SVOp, NumElems, true /* check zeros from left */, DAG,
5256       NumElems - SVOp->getMaskElt(NumElems - 1) - 1);
5257   unsigned OpSrc;
5258
5259   if (!NumZeros)
5260     return false;
5261
5262   // Considering the elements in the mask that are not consecutive zeros,
5263   // check if they consecutively come from only one of the source vectors.
5264   //
5265   //                           0    { A, B, X, X } = V2
5266   //                          / \    /  /
5267   //   vector_shuffle V1, V2 <X, X, 4, 5>
5268   //
5269   if (!isShuffleMaskConsecutive(SVOp,
5270             NumZeros,     // Mask Start Index
5271             NumElems,     // Mask End Index(exclusive)
5272             0,            // Where to start looking in the src vector
5273             NumElems,     // Number of elements in vector
5274             OpSrc))       // Which source operand ?
5275     return false;
5276
5277   isLeft = true;
5278   ShAmt = NumZeros;
5279   ShVal = SVOp->getOperand(OpSrc);
5280   return true;
5281 }
5282
5283 /// isVectorShift - Returns true if the shuffle can be implemented as a
5284 /// logical left or right shift of a vector.
5285 static bool isVectorShift(ShuffleVectorSDNode *SVOp, SelectionDAG &DAG,
5286                           bool &isLeft, SDValue &ShVal, unsigned &ShAmt) {
5287   // Although the logic below support any bitwidth size, there are no
5288   // shift instructions which handle more than 128-bit vectors.
5289   if (!SVOp->getSimpleValueType(0).is128BitVector())
5290     return false;
5291
5292   if (isVectorShiftLeft(SVOp, DAG, isLeft, ShVal, ShAmt) ||
5293       isVectorShiftRight(SVOp, DAG, isLeft, ShVal, ShAmt))
5294     return true;
5295
5296   return false;
5297 }
5298
5299 /// LowerBuildVectorv16i8 - Custom lower build_vector of v16i8.
5300 ///
5301 static SDValue LowerBuildVectorv16i8(SDValue Op, unsigned NonZeros,
5302                                        unsigned NumNonZero, unsigned NumZero,
5303                                        SelectionDAG &DAG,
5304                                        const X86Subtarget* Subtarget,
5305                                        const TargetLowering &TLI) {
5306   if (NumNonZero > 8)
5307     return SDValue();
5308
5309   SDLoc dl(Op);
5310   SDValue V(0, 0);
5311   bool First = true;
5312   for (unsigned i = 0; i < 16; ++i) {
5313     bool ThisIsNonZero = (NonZeros & (1 << i)) != 0;
5314     if (ThisIsNonZero && First) {
5315       if (NumZero)
5316         V = getZeroVector(MVT::v8i16, Subtarget, DAG, dl);
5317       else
5318         V = DAG.getUNDEF(MVT::v8i16);
5319       First = false;
5320     }
5321
5322     if ((i & 1) != 0) {
5323       SDValue ThisElt(0, 0), LastElt(0, 0);
5324       bool LastIsNonZero = (NonZeros & (1 << (i-1))) != 0;
5325       if (LastIsNonZero) {
5326         LastElt = DAG.getNode(ISD::ZERO_EXTEND, dl,
5327                               MVT::i16, Op.getOperand(i-1));
5328       }
5329       if (ThisIsNonZero) {
5330         ThisElt = DAG.getNode(ISD::ZERO_EXTEND, dl, MVT::i16, Op.getOperand(i));
5331         ThisElt = DAG.getNode(ISD::SHL, dl, MVT::i16,
5332                               ThisElt, DAG.getConstant(8, MVT::i8));
5333         if (LastIsNonZero)
5334           ThisElt = DAG.getNode(ISD::OR, dl, MVT::i16, ThisElt, LastElt);
5335       } else
5336         ThisElt = LastElt;
5337
5338       if (ThisElt.getNode())
5339         V = DAG.getNode(ISD::INSERT_VECTOR_ELT, dl, MVT::v8i16, V, ThisElt,
5340                         DAG.getIntPtrConstant(i/2));
5341     }
5342   }
5343
5344   return DAG.getNode(ISD::BITCAST, dl, MVT::v16i8, V);
5345 }
5346
5347 /// LowerBuildVectorv8i16 - Custom lower build_vector of v8i16.
5348 ///
5349 static SDValue LowerBuildVectorv8i16(SDValue Op, unsigned NonZeros,
5350                                      unsigned NumNonZero, unsigned NumZero,
5351                                      SelectionDAG &DAG,
5352                                      const X86Subtarget* Subtarget,
5353                                      const TargetLowering &TLI) {
5354   if (NumNonZero > 4)
5355     return SDValue();
5356
5357   SDLoc dl(Op);
5358   SDValue V(0, 0);
5359   bool First = true;
5360   for (unsigned i = 0; i < 8; ++i) {
5361     bool isNonZero = (NonZeros & (1 << i)) != 0;
5362     if (isNonZero) {
5363       if (First) {
5364         if (NumZero)
5365           V = getZeroVector(MVT::v8i16, Subtarget, DAG, dl);
5366         else
5367           V = DAG.getUNDEF(MVT::v8i16);
5368         First = false;
5369       }
5370       V = DAG.getNode(ISD::INSERT_VECTOR_ELT, dl,
5371                       MVT::v8i16, V, Op.getOperand(i),
5372                       DAG.getIntPtrConstant(i));
5373     }
5374   }
5375
5376   return V;
5377 }
5378
5379 /// getVShift - Return a vector logical shift node.
5380 ///
5381 static SDValue getVShift(bool isLeft, EVT VT, SDValue SrcOp,
5382                          unsigned NumBits, SelectionDAG &DAG,
5383                          const TargetLowering &TLI, SDLoc dl) {
5384   assert(VT.is128BitVector() && "Unknown type for VShift");
5385   EVT ShVT = MVT::v2i64;
5386   unsigned Opc = isLeft ? X86ISD::VSHLDQ : X86ISD::VSRLDQ;
5387   SrcOp = DAG.getNode(ISD::BITCAST, dl, ShVT, SrcOp);
5388   return DAG.getNode(ISD::BITCAST, dl, VT,
5389                      DAG.getNode(Opc, dl, ShVT, SrcOp,
5390                              DAG.getConstant(NumBits,
5391                                   TLI.getScalarShiftAmountTy(SrcOp.getValueType()))));
5392 }
5393
5394 static SDValue
5395 LowerAsSplatVectorLoad(SDValue SrcOp, MVT VT, SDLoc dl, SelectionDAG &DAG) {
5396
5397   // Check if the scalar load can be widened into a vector load. And if
5398   // the address is "base + cst" see if the cst can be "absorbed" into
5399   // the shuffle mask.
5400   if (LoadSDNode *LD = dyn_cast<LoadSDNode>(SrcOp)) {
5401     SDValue Ptr = LD->getBasePtr();
5402     if (!ISD::isNormalLoad(LD) || LD->isVolatile())
5403       return SDValue();
5404     EVT PVT = LD->getValueType(0);
5405     if (PVT != MVT::i32 && PVT != MVT::f32)
5406       return SDValue();
5407
5408     int FI = -1;
5409     int64_t Offset = 0;
5410     if (FrameIndexSDNode *FINode = dyn_cast<FrameIndexSDNode>(Ptr)) {
5411       FI = FINode->getIndex();
5412       Offset = 0;
5413     } else if (DAG.isBaseWithConstantOffset(Ptr) &&
5414                isa<FrameIndexSDNode>(Ptr.getOperand(0))) {
5415       FI = cast<FrameIndexSDNode>(Ptr.getOperand(0))->getIndex();
5416       Offset = Ptr.getConstantOperandVal(1);
5417       Ptr = Ptr.getOperand(0);
5418     } else {
5419       return SDValue();
5420     }
5421
5422     // FIXME: 256-bit vector instructions don't require a strict alignment,
5423     // improve this code to support it better.
5424     unsigned RequiredAlign = VT.getSizeInBits()/8;
5425     SDValue Chain = LD->getChain();
5426     // Make sure the stack object alignment is at least 16 or 32.
5427     MachineFrameInfo *MFI = DAG.getMachineFunction().getFrameInfo();
5428     if (DAG.InferPtrAlignment(Ptr) < RequiredAlign) {
5429       if (MFI->isFixedObjectIndex(FI)) {
5430         // Can't change the alignment. FIXME: It's possible to compute
5431         // the exact stack offset and reference FI + adjust offset instead.
5432         // If someone *really* cares about this. That's the way to implement it.
5433         return SDValue();
5434       } else {
5435         MFI->setObjectAlignment(FI, RequiredAlign);
5436       }
5437     }
5438
5439     // (Offset % 16 or 32) must be multiple of 4. Then address is then
5440     // Ptr + (Offset & ~15).
5441     if (Offset < 0)
5442       return SDValue();
5443     if ((Offset % RequiredAlign) & 3)
5444       return SDValue();
5445     int64_t StartOffset = Offset & ~(RequiredAlign-1);
5446     if (StartOffset)
5447       Ptr = DAG.getNode(ISD::ADD, SDLoc(Ptr), Ptr.getValueType(),
5448                         Ptr,DAG.getConstant(StartOffset, Ptr.getValueType()));
5449
5450     int EltNo = (Offset - StartOffset) >> 2;
5451     unsigned NumElems = VT.getVectorNumElements();
5452
5453     EVT NVT = EVT::getVectorVT(*DAG.getContext(), PVT, NumElems);
5454     SDValue V1 = DAG.getLoad(NVT, dl, Chain, Ptr,
5455                              LD->getPointerInfo().getWithOffset(StartOffset),
5456                              false, false, false, 0);
5457
5458     SmallVector<int, 8> Mask;
5459     for (unsigned i = 0; i != NumElems; ++i)
5460       Mask.push_back(EltNo);
5461
5462     return DAG.getVectorShuffle(NVT, dl, V1, DAG.getUNDEF(NVT), &Mask[0]);
5463   }
5464
5465   return SDValue();
5466 }
5467
5468 /// EltsFromConsecutiveLoads - Given the initializing elements 'Elts' of a
5469 /// vector of type 'VT', see if the elements can be replaced by a single large
5470 /// load which has the same value as a build_vector whose operands are 'elts'.
5471 ///
5472 /// Example: <load i32 *a, load i32 *a+4, undef, undef> -> zextload a
5473 ///
5474 /// FIXME: we'd also like to handle the case where the last elements are zero
5475 /// rather than undef via VZEXT_LOAD, but we do not detect that case today.
5476 /// There's even a handy isZeroNode for that purpose.
5477 static SDValue EltsFromConsecutiveLoads(EVT VT, SmallVectorImpl<SDValue> &Elts,
5478                                         SDLoc &DL, SelectionDAG &DAG,
5479                                         bool isAfterLegalize) {
5480   EVT EltVT = VT.getVectorElementType();
5481   unsigned NumElems = Elts.size();
5482
5483   LoadSDNode *LDBase = NULL;
5484   unsigned LastLoadedElt = -1U;
5485
5486   // For each element in the initializer, see if we've found a load or an undef.
5487   // If we don't find an initial load element, or later load elements are
5488   // non-consecutive, bail out.
5489   for (unsigned i = 0; i < NumElems; ++i) {
5490     SDValue Elt = Elts[i];
5491
5492     if (!Elt.getNode() ||
5493         (Elt.getOpcode() != ISD::UNDEF && !ISD::isNON_EXTLoad(Elt.getNode())))
5494       return SDValue();
5495     if (!LDBase) {
5496       if (Elt.getNode()->getOpcode() == ISD::UNDEF)
5497         return SDValue();
5498       LDBase = cast<LoadSDNode>(Elt.getNode());
5499       LastLoadedElt = i;
5500       continue;
5501     }
5502     if (Elt.getOpcode() == ISD::UNDEF)
5503       continue;
5504
5505     LoadSDNode *LD = cast<LoadSDNode>(Elt);
5506     if (!DAG.isConsecutiveLoad(LD, LDBase, EltVT.getSizeInBits()/8, i))
5507       return SDValue();
5508     LastLoadedElt = i;
5509   }
5510
5511   // If we have found an entire vector of loads and undefs, then return a large
5512   // load of the entire vector width starting at the base pointer.  If we found
5513   // consecutive loads for the low half, generate a vzext_load node.
5514   if (LastLoadedElt == NumElems - 1) {
5515
5516     if (isAfterLegalize &&
5517         !DAG.getTargetLoweringInfo().isOperationLegal(ISD::LOAD, VT))
5518       return SDValue();
5519
5520     SDValue NewLd = SDValue();
5521
5522     if (DAG.InferPtrAlignment(LDBase->getBasePtr()) >= 16)
5523       NewLd = DAG.getLoad(VT, DL, LDBase->getChain(), LDBase->getBasePtr(),
5524                           LDBase->getPointerInfo(),
5525                           LDBase->isVolatile(), LDBase->isNonTemporal(),
5526                           LDBase->isInvariant(), 0);
5527     NewLd = DAG.getLoad(VT, DL, LDBase->getChain(), LDBase->getBasePtr(),
5528                         LDBase->getPointerInfo(),
5529                         LDBase->isVolatile(), LDBase->isNonTemporal(),
5530                         LDBase->isInvariant(), LDBase->getAlignment());
5531
5532     if (LDBase->hasAnyUseOfValue(1)) {
5533       SDValue NewChain = DAG.getNode(ISD::TokenFactor, DL, MVT::Other,
5534                                      SDValue(LDBase, 1),
5535                                      SDValue(NewLd.getNode(), 1));
5536       DAG.ReplaceAllUsesOfValueWith(SDValue(LDBase, 1), NewChain);
5537       DAG.UpdateNodeOperands(NewChain.getNode(), SDValue(LDBase, 1),
5538                              SDValue(NewLd.getNode(), 1));
5539     }
5540
5541     return NewLd;
5542   }
5543   if (NumElems == 4 && LastLoadedElt == 1 &&
5544       DAG.getTargetLoweringInfo().isTypeLegal(MVT::v2i64)) {
5545     SDVTList Tys = DAG.getVTList(MVT::v2i64, MVT::Other);
5546     SDValue Ops[] = { LDBase->getChain(), LDBase->getBasePtr() };
5547     SDValue ResNode =
5548         DAG.getMemIntrinsicNode(X86ISD::VZEXT_LOAD, DL, Tys, Ops,
5549                                 array_lengthof(Ops), MVT::i64,
5550                                 LDBase->getPointerInfo(),
5551                                 LDBase->getAlignment(),
5552                                 false/*isVolatile*/, true/*ReadMem*/,
5553                                 false/*WriteMem*/);
5554
5555     // Make sure the newly-created LOAD is in the same position as LDBase in
5556     // terms of dependency. We create a TokenFactor for LDBase and ResNode, and
5557     // update uses of LDBase's output chain to use the TokenFactor.
5558     if (LDBase->hasAnyUseOfValue(1)) {
5559       SDValue NewChain = DAG.getNode(ISD::TokenFactor, DL, MVT::Other,
5560                              SDValue(LDBase, 1), SDValue(ResNode.getNode(), 1));
5561       DAG.ReplaceAllUsesOfValueWith(SDValue(LDBase, 1), NewChain);
5562       DAG.UpdateNodeOperands(NewChain.getNode(), SDValue(LDBase, 1),
5563                              SDValue(ResNode.getNode(), 1));
5564     }
5565
5566     return DAG.getNode(ISD::BITCAST, DL, VT, ResNode);
5567   }
5568   return SDValue();
5569 }
5570
5571 /// LowerVectorBroadcast - Attempt to use the vbroadcast instruction
5572 /// to generate a splat value for the following cases:
5573 /// 1. A splat BUILD_VECTOR which uses a single scalar load, or a constant.
5574 /// 2. A splat shuffle which uses a scalar_to_vector node which comes from
5575 /// a scalar load, or a constant.
5576 /// The VBROADCAST node is returned when a pattern is found,
5577 /// or SDValue() otherwise.
5578 static SDValue LowerVectorBroadcast(SDValue Op, const X86Subtarget* Subtarget,
5579                                     SelectionDAG &DAG) {
5580   if (!Subtarget->hasFp256())
5581     return SDValue();
5582
5583   MVT VT = Op.getSimpleValueType();
5584   SDLoc dl(Op);
5585
5586   assert((VT.is128BitVector() || VT.is256BitVector() || VT.is512BitVector()) &&
5587          "Unsupported vector type for broadcast.");
5588
5589   SDValue Ld;
5590   bool ConstSplatVal;
5591
5592   switch (Op.getOpcode()) {
5593     default:
5594       // Unknown pattern found.
5595       return SDValue();
5596
5597     case ISD::BUILD_VECTOR: {
5598       // The BUILD_VECTOR node must be a splat.
5599       if (!isSplatVector(Op.getNode()))
5600         return SDValue();
5601
5602       Ld = Op.getOperand(0);
5603       ConstSplatVal = (Ld.getOpcode() == ISD::Constant ||
5604                      Ld.getOpcode() == ISD::ConstantFP);
5605
5606       // The suspected load node has several users. Make sure that all
5607       // of its users are from the BUILD_VECTOR node.
5608       // Constants may have multiple users.
5609       if (!ConstSplatVal && !Ld->hasNUsesOfValue(VT.getVectorNumElements(), 0))
5610         return SDValue();
5611       break;
5612     }
5613
5614     case ISD::VECTOR_SHUFFLE: {
5615       ShuffleVectorSDNode *SVOp = cast<ShuffleVectorSDNode>(Op);
5616
5617       // Shuffles must have a splat mask where the first element is
5618       // broadcasted.
5619       if ((!SVOp->isSplat()) || SVOp->getMaskElt(0) != 0)
5620         return SDValue();
5621
5622       SDValue Sc = Op.getOperand(0);
5623       if (Sc.getOpcode() != ISD::SCALAR_TO_VECTOR &&
5624           Sc.getOpcode() != ISD::BUILD_VECTOR) {
5625
5626         if (!Subtarget->hasInt256())
5627           return SDValue();
5628
5629         // Use the register form of the broadcast instruction available on AVX2.
5630         if (VT.getSizeInBits() >= 256)
5631           Sc = Extract128BitVector(Sc, 0, DAG, dl);
5632         return DAG.getNode(X86ISD::VBROADCAST, dl, VT, Sc);
5633       }
5634
5635       Ld = Sc.getOperand(0);
5636       ConstSplatVal = (Ld.getOpcode() == ISD::Constant ||
5637                        Ld.getOpcode() == ISD::ConstantFP);
5638
5639       // The scalar_to_vector node and the suspected
5640       // load node must have exactly one user.
5641       // Constants may have multiple users.
5642
5643       // AVX-512 has register version of the broadcast
5644       bool hasRegVer = Subtarget->hasAVX512() && VT.is512BitVector() &&
5645         Ld.getValueType().getSizeInBits() >= 32;
5646       if (!ConstSplatVal && ((!Sc.hasOneUse() || !Ld.hasOneUse()) &&
5647           !hasRegVer))
5648         return SDValue();
5649       break;
5650     }
5651   }
5652
5653   bool IsGE256 = (VT.getSizeInBits() >= 256);
5654
5655   // Handle the broadcasting a single constant scalar from the constant pool
5656   // into a vector. On Sandybridge it is still better to load a constant vector
5657   // from the constant pool and not to broadcast it from a scalar.
5658   if (ConstSplatVal && Subtarget->hasInt256()) {
5659     EVT CVT = Ld.getValueType();
5660     assert(!CVT.isVector() && "Must not broadcast a vector type");
5661     unsigned ScalarSize = CVT.getSizeInBits();
5662
5663     if (ScalarSize == 32 || (IsGE256 && ScalarSize == 64)) {
5664       const Constant *C = 0;
5665       if (ConstantSDNode *CI = dyn_cast<ConstantSDNode>(Ld))
5666         C = CI->getConstantIntValue();
5667       else if (ConstantFPSDNode *CF = dyn_cast<ConstantFPSDNode>(Ld))
5668         C = CF->getConstantFPValue();
5669
5670       assert(C && "Invalid constant type");
5671
5672       const TargetLowering &TLI = DAG.getTargetLoweringInfo();
5673       SDValue CP = DAG.getConstantPool(C, TLI.getPointerTy());
5674       unsigned Alignment = cast<ConstantPoolSDNode>(CP)->getAlignment();
5675       Ld = DAG.getLoad(CVT, dl, DAG.getEntryNode(), CP,
5676                        MachinePointerInfo::getConstantPool(),
5677                        false, false, false, Alignment);
5678
5679       return DAG.getNode(X86ISD::VBROADCAST, dl, VT, Ld);
5680     }
5681   }
5682
5683   bool IsLoad = ISD::isNormalLoad(Ld.getNode());
5684   unsigned ScalarSize = Ld.getValueType().getSizeInBits();
5685
5686   // Handle AVX2 in-register broadcasts.
5687   if (!IsLoad && Subtarget->hasInt256() &&
5688       (ScalarSize == 32 || (IsGE256 && ScalarSize == 64)))
5689     return DAG.getNode(X86ISD::VBROADCAST, dl, VT, Ld);
5690
5691   // The scalar source must be a normal load.
5692   if (!IsLoad)
5693     return SDValue();
5694
5695   if (ScalarSize == 32 || (IsGE256 && ScalarSize == 64))
5696     return DAG.getNode(X86ISD::VBROADCAST, dl, VT, Ld);
5697
5698   // The integer check is needed for the 64-bit into 128-bit so it doesn't match
5699   // double since there is no vbroadcastsd xmm
5700   if (Subtarget->hasInt256() && Ld.getValueType().isInteger()) {
5701     if (ScalarSize == 8 || ScalarSize == 16 || ScalarSize == 64)
5702       return DAG.getNode(X86ISD::VBROADCAST, dl, VT, Ld);
5703   }
5704
5705   // Unsupported broadcast.
5706   return SDValue();
5707 }
5708
5709 static SDValue buildFromShuffleMostly(SDValue Op, SelectionDAG &DAG) {
5710   MVT VT = Op.getSimpleValueType();
5711
5712   // Skip if insert_vec_elt is not supported.
5713   const TargetLowering &TLI = DAG.getTargetLoweringInfo();
5714   if (!TLI.isOperationLegalOrCustom(ISD::INSERT_VECTOR_ELT, VT))
5715     return SDValue();
5716
5717   SDLoc DL(Op);
5718   unsigned NumElems = Op.getNumOperands();
5719
5720   SDValue VecIn1;
5721   SDValue VecIn2;
5722   SmallVector<unsigned, 4> InsertIndices;
5723   SmallVector<int, 8> Mask(NumElems, -1);
5724
5725   for (unsigned i = 0; i != NumElems; ++i) {
5726     unsigned Opc = Op.getOperand(i).getOpcode();
5727
5728     if (Opc == ISD::UNDEF)
5729       continue;
5730
5731     if (Opc != ISD::EXTRACT_VECTOR_ELT) {
5732       // Quit if more than 1 elements need inserting.
5733       if (InsertIndices.size() > 1)
5734         return SDValue();
5735
5736       InsertIndices.push_back(i);
5737       continue;
5738     }
5739
5740     SDValue ExtractedFromVec = Op.getOperand(i).getOperand(0);
5741     SDValue ExtIdx = Op.getOperand(i).getOperand(1);
5742
5743     // Quit if extracted from vector of different type.
5744     if (ExtractedFromVec.getValueType() != VT)
5745       return SDValue();
5746
5747     // Quit if non-constant index.
5748     if (!isa<ConstantSDNode>(ExtIdx))
5749       return SDValue();
5750
5751     if (VecIn1.getNode() == 0)
5752       VecIn1 = ExtractedFromVec;
5753     else if (VecIn1 != ExtractedFromVec) {
5754       if (VecIn2.getNode() == 0)
5755         VecIn2 = ExtractedFromVec;
5756       else if (VecIn2 != ExtractedFromVec)
5757         // Quit if more than 2 vectors to shuffle
5758         return SDValue();
5759     }
5760
5761     unsigned Idx = cast<ConstantSDNode>(ExtIdx)->getZExtValue();
5762
5763     if (ExtractedFromVec == VecIn1)
5764       Mask[i] = Idx;
5765     else if (ExtractedFromVec == VecIn2)
5766       Mask[i] = Idx + NumElems;
5767   }
5768
5769   if (VecIn1.getNode() == 0)
5770     return SDValue();
5771
5772   VecIn2 = VecIn2.getNode() ? VecIn2 : DAG.getUNDEF(VT);
5773   SDValue NV = DAG.getVectorShuffle(VT, DL, VecIn1, VecIn2, &Mask[0]);
5774   for (unsigned i = 0, e = InsertIndices.size(); i != e; ++i) {
5775     unsigned Idx = InsertIndices[i];
5776     NV = DAG.getNode(ISD::INSERT_VECTOR_ELT, DL, VT, NV, Op.getOperand(Idx),
5777                      DAG.getIntPtrConstant(Idx));
5778   }
5779
5780   return NV;
5781 }
5782
5783 // Lower BUILD_VECTOR operation for v8i1 and v16i1 types.
5784 SDValue
5785 X86TargetLowering::LowerBUILD_VECTORvXi1(SDValue Op, SelectionDAG &DAG) const {
5786
5787   MVT VT = Op.getSimpleValueType();
5788   assert((VT.getVectorElementType() == MVT::i1) && (VT.getSizeInBits() <= 16) &&
5789          "Unexpected type in LowerBUILD_VECTORvXi1!");
5790
5791   SDLoc dl(Op);
5792   if (ISD::isBuildVectorAllZeros(Op.getNode())) {
5793     SDValue Cst = DAG.getTargetConstant(0, MVT::i1);
5794     SDValue Ops[] = { Cst, Cst, Cst, Cst, Cst, Cst, Cst, Cst,
5795                       Cst, Cst, Cst, Cst, Cst, Cst, Cst, Cst };
5796     return DAG.getNode(ISD::BUILD_VECTOR, dl, VT,
5797                        Ops, VT.getVectorNumElements());
5798   }
5799
5800   if (ISD::isBuildVectorAllOnes(Op.getNode())) {
5801     SDValue Cst = DAG.getTargetConstant(1, MVT::i1);
5802     SDValue Ops[] = { Cst, Cst, Cst, Cst, Cst, Cst, Cst, Cst,
5803                       Cst, Cst, Cst, Cst, Cst, Cst, Cst, Cst };
5804     return DAG.getNode(ISD::BUILD_VECTOR, dl, VT,
5805                        Ops, VT.getVectorNumElements());
5806   }
5807
5808   bool AllContants = true;
5809   uint64_t Immediate = 0;
5810   int NonConstIdx = -1;
5811   bool IsSplat = true;
5812   for (unsigned idx = 0, e = Op.getNumOperands(); idx < e; ++idx) {
5813     SDValue In = Op.getOperand(idx);
5814     if (In.getOpcode() == ISD::UNDEF)
5815       continue;
5816     if (!isa<ConstantSDNode>(In)) {
5817       AllContants = false;
5818       NonConstIdx = idx;
5819     }
5820     else if (cast<ConstantSDNode>(In)->getZExtValue())
5821       Immediate |= (1ULL << idx);
5822     if (In != Op.getOperand(0))
5823       IsSplat = false;
5824   }
5825
5826   if (AllContants) {
5827     SDValue FullMask = DAG.getNode(ISD::BITCAST, dl, MVT::v16i1,
5828       DAG.getConstant(Immediate, MVT::i16));
5829     return DAG.getNode(ISD::EXTRACT_SUBVECTOR, dl, VT, FullMask,
5830                        DAG.getIntPtrConstant(0));
5831   }
5832
5833   if (!IsSplat && (NonConstIdx != 0))
5834     llvm_unreachable("Unsupported BUILD_VECTOR operation");
5835   MVT SelectVT = (VT == MVT::v16i1)? MVT::i16 : MVT::i8;
5836   SDValue Select;
5837   if (IsSplat)
5838     Select = DAG.getNode(ISD::SELECT, dl, SelectVT, Op.getOperand(0),
5839                           DAG.getConstant(-1, SelectVT),
5840                           DAG.getConstant(0, SelectVT));
5841   else
5842     Select = DAG.getNode(ISD::SELECT, dl, SelectVT, Op.getOperand(0),
5843                          DAG.getConstant((Immediate | 1), SelectVT),
5844                          DAG.getConstant(Immediate, SelectVT));
5845   return DAG.getNode(ISD::BITCAST, dl, VT, Select);
5846 }
5847
5848 SDValue
5849 X86TargetLowering::LowerBUILD_VECTOR(SDValue Op, SelectionDAG &DAG) const {
5850   SDLoc dl(Op);
5851
5852   MVT VT = Op.getSimpleValueType();
5853   MVT ExtVT = VT.getVectorElementType();
5854   unsigned NumElems = Op.getNumOperands();
5855
5856   // Generate vectors for predicate vectors.
5857   if (VT.getScalarType() == MVT::i1 && Subtarget->hasAVX512())
5858     return LowerBUILD_VECTORvXi1(Op, DAG);
5859
5860   // Vectors containing all zeros can be matched by pxor and xorps later
5861   if (ISD::isBuildVectorAllZeros(Op.getNode())) {
5862     // Canonicalize this to <4 x i32> to 1) ensure the zero vectors are CSE'd
5863     // and 2) ensure that i64 scalars are eliminated on x86-32 hosts.
5864     if (VT == MVT::v4i32 || VT == MVT::v8i32 || VT == MVT::v16i32)
5865       return Op;
5866
5867     return getZeroVector(VT, Subtarget, DAG, dl);
5868   }
5869
5870   // Vectors containing all ones can be matched by pcmpeqd on 128-bit width
5871   // vectors or broken into v4i32 operations on 256-bit vectors. AVX2 can use
5872   // vpcmpeqd on 256-bit vectors.
5873   if (Subtarget->hasSSE2() && ISD::isBuildVectorAllOnes(Op.getNode())) {
5874     if (VT == MVT::v4i32 || (VT == MVT::v8i32 && Subtarget->hasInt256()))
5875       return Op;
5876
5877     if (!VT.is512BitVector())
5878       return getOnesVector(VT, Subtarget->hasInt256(), DAG, dl);
5879   }
5880
5881   SDValue Broadcast = LowerVectorBroadcast(Op, Subtarget, DAG);
5882   if (Broadcast.getNode())
5883     return Broadcast;
5884
5885   unsigned EVTBits = ExtVT.getSizeInBits();
5886
5887   unsigned NumZero  = 0;
5888   unsigned NumNonZero = 0;
5889   unsigned NonZeros = 0;
5890   bool IsAllConstants = true;
5891   SmallSet<SDValue, 8> Values;
5892   for (unsigned i = 0; i < NumElems; ++i) {
5893     SDValue Elt = Op.getOperand(i);
5894     if (Elt.getOpcode() == ISD::UNDEF)
5895       continue;
5896     Values.insert(Elt);
5897     if (Elt.getOpcode() != ISD::Constant &&
5898         Elt.getOpcode() != ISD::ConstantFP)
5899       IsAllConstants = false;
5900     if (X86::isZeroNode(Elt))
5901       NumZero++;
5902     else {
5903       NonZeros |= (1 << i);
5904       NumNonZero++;
5905     }
5906   }
5907
5908   // All undef vector. Return an UNDEF.  All zero vectors were handled above.
5909   if (NumNonZero == 0)
5910     return DAG.getUNDEF(VT);
5911
5912   // Special case for single non-zero, non-undef, element.
5913   if (NumNonZero == 1) {
5914     unsigned Idx = countTrailingZeros(NonZeros);
5915     SDValue Item = Op.getOperand(Idx);
5916
5917     // If this is an insertion of an i64 value on x86-32, and if the top bits of
5918     // the value are obviously zero, truncate the value to i32 and do the
5919     // insertion that way.  Only do this if the value is non-constant or if the
5920     // value is a constant being inserted into element 0.  It is cheaper to do
5921     // a constant pool load than it is to do a movd + shuffle.
5922     if (ExtVT == MVT::i64 && !Subtarget->is64Bit() &&
5923         (!IsAllConstants || Idx == 0)) {
5924       if (DAG.MaskedValueIsZero(Item, APInt::getBitsSet(64, 32, 64))) {
5925         // Handle SSE only.
5926         assert(VT == MVT::v2i64 && "Expected an SSE value type!");
5927         EVT VecVT = MVT::v4i32;
5928         unsigned VecElts = 4;
5929
5930         // Truncate the value (which may itself be a constant) to i32, and
5931         // convert it to a vector with movd (S2V+shuffle to zero extend).
5932         Item = DAG.getNode(ISD::TRUNCATE, dl, MVT::i32, Item);
5933         Item = DAG.getNode(ISD::SCALAR_TO_VECTOR, dl, VecVT, Item);
5934         Item = getShuffleVectorZeroOrUndef(Item, 0, true, Subtarget, DAG);
5935
5936         // Now we have our 32-bit value zero extended in the low element of
5937         // a vector.  If Idx != 0, swizzle it into place.
5938         if (Idx != 0) {
5939           SmallVector<int, 4> Mask;
5940           Mask.push_back(Idx);
5941           for (unsigned i = 1; i != VecElts; ++i)
5942             Mask.push_back(i);
5943           Item = DAG.getVectorShuffle(VecVT, dl, Item, DAG.getUNDEF(VecVT),
5944                                       &Mask[0]);
5945         }
5946         return DAG.getNode(ISD::BITCAST, dl, VT, Item);
5947       }
5948     }
5949
5950     // If we have a constant or non-constant insertion into the low element of
5951     // a vector, we can do this with SCALAR_TO_VECTOR + shuffle of zero into
5952     // the rest of the elements.  This will be matched as movd/movq/movss/movsd
5953     // depending on what the source datatype is.
5954     if (Idx == 0) {
5955       if (NumZero == 0)
5956         return DAG.getNode(ISD::SCALAR_TO_VECTOR, dl, VT, Item);
5957
5958       if (ExtVT == MVT::i32 || ExtVT == MVT::f32 || ExtVT == MVT::f64 ||
5959           (ExtVT == MVT::i64 && Subtarget->is64Bit())) {
5960         if (VT.is256BitVector() || VT.is512BitVector()) {
5961           SDValue ZeroVec = getZeroVector(VT, Subtarget, DAG, dl);
5962           return DAG.getNode(ISD::INSERT_VECTOR_ELT, dl, VT, ZeroVec,
5963                              Item, DAG.getIntPtrConstant(0));
5964         }
5965         assert(VT.is128BitVector() && "Expected an SSE value type!");
5966         Item = DAG.getNode(ISD::SCALAR_TO_VECTOR, dl, VT, Item);
5967         // Turn it into a MOVL (i.e. movss, movsd, or movd) to a zero vector.
5968         return getShuffleVectorZeroOrUndef(Item, 0, true, Subtarget, DAG);
5969       }
5970
5971       if (ExtVT == MVT::i16 || ExtVT == MVT::i8) {
5972         Item = DAG.getNode(ISD::ZERO_EXTEND, dl, MVT::i32, Item);
5973         Item = DAG.getNode(ISD::SCALAR_TO_VECTOR, dl, MVT::v4i32, Item);
5974         if (VT.is256BitVector()) {
5975           SDValue ZeroVec = getZeroVector(MVT::v8i32, Subtarget, DAG, dl);
5976           Item = Insert128BitVector(ZeroVec, Item, 0, DAG, dl);
5977         } else {
5978           assert(VT.is128BitVector() && "Expected an SSE value type!");
5979           Item = getShuffleVectorZeroOrUndef(Item, 0, true, Subtarget, DAG);
5980         }
5981         return DAG.getNode(ISD::BITCAST, dl, VT, Item);
5982       }
5983     }
5984
5985     // Is it a vector logical left shift?
5986     if (NumElems == 2 && Idx == 1 &&
5987         X86::isZeroNode(Op.getOperand(0)) &&
5988         !X86::isZeroNode(Op.getOperand(1))) {
5989       unsigned NumBits = VT.getSizeInBits();
5990       return getVShift(true, VT,
5991                        DAG.getNode(ISD::SCALAR_TO_VECTOR, dl,
5992                                    VT, Op.getOperand(1)),
5993                        NumBits/2, DAG, *this, dl);
5994     }
5995
5996     if (IsAllConstants) // Otherwise, it's better to do a constpool load.
5997       return SDValue();
5998
5999     // Otherwise, if this is a vector with i32 or f32 elements, and the element
6000     // is a non-constant being inserted into an element other than the low one,
6001     // we can't use a constant pool load.  Instead, use SCALAR_TO_VECTOR (aka
6002     // movd/movss) to move this into the low element, then shuffle it into
6003     // place.
6004     if (EVTBits == 32) {
6005       Item = DAG.getNode(ISD::SCALAR_TO_VECTOR, dl, VT, Item);
6006
6007       // Turn it into a shuffle of zero and zero-extended scalar to vector.
6008       Item = getShuffleVectorZeroOrUndef(Item, 0, NumZero > 0, Subtarget, DAG);
6009       SmallVector<int, 8> MaskVec;
6010       for (unsigned i = 0; i != NumElems; ++i)
6011         MaskVec.push_back(i == Idx ? 0 : 1);
6012       return DAG.getVectorShuffle(VT, dl, Item, DAG.getUNDEF(VT), &MaskVec[0]);
6013     }
6014   }
6015
6016   // Splat is obviously ok. Let legalizer expand it to a shuffle.
6017   if (Values.size() == 1) {
6018     if (EVTBits == 32) {
6019       // Instead of a shuffle like this:
6020       // shuffle (scalar_to_vector (load (ptr + 4))), undef, <0, 0, 0, 0>
6021       // Check if it's possible to issue this instead.
6022       // shuffle (vload ptr)), undef, <1, 1, 1, 1>
6023       unsigned Idx = countTrailingZeros(NonZeros);
6024       SDValue Item = Op.getOperand(Idx);
6025       if (Op.getNode()->isOnlyUserOf(Item.getNode()))
6026         return LowerAsSplatVectorLoad(Item, VT, dl, DAG);
6027     }
6028     return SDValue();
6029   }
6030
6031   // A vector full of immediates; various special cases are already
6032   // handled, so this is best done with a single constant-pool load.
6033   if (IsAllConstants)
6034     return SDValue();
6035
6036   // For AVX-length vectors, build the individual 128-bit pieces and use
6037   // shuffles to put them in place.
6038   if (VT.is256BitVector() || VT.is512BitVector()) {
6039     SmallVector<SDValue, 64> V;
6040     for (unsigned i = 0; i != NumElems; ++i)
6041       V.push_back(Op.getOperand(i));
6042
6043     EVT HVT = EVT::getVectorVT(*DAG.getContext(), ExtVT, NumElems/2);
6044
6045     // Build both the lower and upper subvector.
6046     SDValue Lower = DAG.getNode(ISD::BUILD_VECTOR, dl, HVT, &V[0], NumElems/2);
6047     SDValue Upper = DAG.getNode(ISD::BUILD_VECTOR, dl, HVT, &V[NumElems / 2],
6048                                 NumElems/2);
6049
6050     // Recreate the wider vector with the lower and upper part.
6051     if (VT.is256BitVector())
6052       return Concat128BitVectors(Lower, Upper, VT, NumElems, DAG, dl);
6053     return Concat256BitVectors(Lower, Upper, VT, NumElems, DAG, dl);
6054   }
6055
6056   // Let legalizer expand 2-wide build_vectors.
6057   if (EVTBits == 64) {
6058     if (NumNonZero == 1) {
6059       // One half is zero or undef.
6060       unsigned Idx = countTrailingZeros(NonZeros);
6061       SDValue V2 = DAG.getNode(ISD::SCALAR_TO_VECTOR, dl, VT,
6062                                  Op.getOperand(Idx));
6063       return getShuffleVectorZeroOrUndef(V2, Idx, true, Subtarget, DAG);
6064     }
6065     return SDValue();
6066   }
6067
6068   // If element VT is < 32 bits, convert it to inserts into a zero vector.
6069   if (EVTBits == 8 && NumElems == 16) {
6070     SDValue V = LowerBuildVectorv16i8(Op, NonZeros,NumNonZero,NumZero, DAG,
6071                                         Subtarget, *this);
6072     if (V.getNode()) return V;
6073   }
6074
6075   if (EVTBits == 16 && NumElems == 8) {
6076     SDValue V = LowerBuildVectorv8i16(Op, NonZeros,NumNonZero,NumZero, DAG,
6077                                       Subtarget, *this);
6078     if (V.getNode()) return V;
6079   }
6080
6081   // If element VT is == 32 bits, turn it into a number of shuffles.
6082   SmallVector<SDValue, 8> V(NumElems);
6083   if (NumElems == 4 && NumZero > 0) {
6084     for (unsigned i = 0; i < 4; ++i) {
6085       bool isZero = !(NonZeros & (1 << i));
6086       if (isZero)
6087         V[i] = getZeroVector(VT, Subtarget, DAG, dl);
6088       else
6089         V[i] = DAG.getNode(ISD::SCALAR_TO_VECTOR, dl, VT, Op.getOperand(i));
6090     }
6091
6092     for (unsigned i = 0; i < 2; ++i) {
6093       switch ((NonZeros & (0x3 << i*2)) >> (i*2)) {
6094         default: break;
6095         case 0:
6096           V[i] = V[i*2];  // Must be a zero vector.
6097           break;
6098         case 1:
6099           V[i] = getMOVL(DAG, dl, VT, V[i*2+1], V[i*2]);
6100           break;
6101         case 2:
6102           V[i] = getMOVL(DAG, dl, VT, V[i*2], V[i*2+1]);
6103           break;
6104         case 3:
6105           V[i] = getUnpackl(DAG, dl, VT, V[i*2], V[i*2+1]);
6106           break;
6107       }
6108     }
6109
6110     bool Reverse1 = (NonZeros & 0x3) == 2;
6111     bool Reverse2 = ((NonZeros & (0x3 << 2)) >> 2) == 2;
6112     int MaskVec[] = {
6113       Reverse1 ? 1 : 0,
6114       Reverse1 ? 0 : 1,
6115       static_cast<int>(Reverse2 ? NumElems+1 : NumElems),
6116       static_cast<int>(Reverse2 ? NumElems   : NumElems+1)
6117     };
6118     return DAG.getVectorShuffle(VT, dl, V[0], V[1], &MaskVec[0]);
6119   }
6120
6121   if (Values.size() > 1 && VT.is128BitVector()) {
6122     // Check for a build vector of consecutive loads.
6123     for (unsigned i = 0; i < NumElems; ++i)
6124       V[i] = Op.getOperand(i);
6125
6126     // Check for elements which are consecutive loads.
6127     SDValue LD = EltsFromConsecutiveLoads(VT, V, dl, DAG, false);
6128     if (LD.getNode())
6129       return LD;
6130
6131     // Check for a build vector from mostly shuffle plus few inserting.
6132     SDValue Sh = buildFromShuffleMostly(Op, DAG);
6133     if (Sh.getNode())
6134       return Sh;
6135
6136     // For SSE 4.1, use insertps to put the high elements into the low element.
6137     if (getSubtarget()->hasSSE41()) {
6138       SDValue Result;
6139       if (Op.getOperand(0).getOpcode() != ISD::UNDEF)
6140         Result = DAG.getNode(ISD::SCALAR_TO_VECTOR, dl, VT, Op.getOperand(0));
6141       else
6142         Result = DAG.getUNDEF(VT);
6143
6144       for (unsigned i = 1; i < NumElems; ++i) {
6145         if (Op.getOperand(i).getOpcode() == ISD::UNDEF) continue;
6146         Result = DAG.getNode(ISD::INSERT_VECTOR_ELT, dl, VT, Result,
6147                              Op.getOperand(i), DAG.getIntPtrConstant(i));
6148       }
6149       return Result;
6150     }
6151
6152     // Otherwise, expand into a number of unpckl*, start by extending each of
6153     // our (non-undef) elements to the full vector width with the element in the
6154     // bottom slot of the vector (which generates no code for SSE).
6155     for (unsigned i = 0; i < NumElems; ++i) {
6156       if (Op.getOperand(i).getOpcode() != ISD::UNDEF)
6157         V[i] = DAG.getNode(ISD::SCALAR_TO_VECTOR, dl, VT, Op.getOperand(i));
6158       else
6159         V[i] = DAG.getUNDEF(VT);
6160     }
6161
6162     // Next, we iteratively mix elements, e.g. for v4f32:
6163     //   Step 1: unpcklps 0, 2 ==> X: <?, ?, 2, 0>
6164     //         : unpcklps 1, 3 ==> Y: <?, ?, 3, 1>
6165     //   Step 2: unpcklps X, Y ==>    <3, 2, 1, 0>
6166     unsigned EltStride = NumElems >> 1;
6167     while (EltStride != 0) {
6168       for (unsigned i = 0; i < EltStride; ++i) {
6169         // If V[i+EltStride] is undef and this is the first round of mixing,
6170         // then it is safe to just drop this shuffle: V[i] is already in the
6171         // right place, the one element (since it's the first round) being
6172         // inserted as undef can be dropped.  This isn't safe for successive
6173         // rounds because they will permute elements within both vectors.
6174         if (V[i+EltStride].getOpcode() == ISD::UNDEF &&
6175             EltStride == NumElems/2)
6176           continue;
6177
6178         V[i] = getUnpackl(DAG, dl, VT, V[i], V[i + EltStride]);
6179       }
6180       EltStride >>= 1;
6181     }
6182     return V[0];
6183   }
6184   return SDValue();
6185 }
6186
6187 // LowerAVXCONCAT_VECTORS - 256-bit AVX can use the vinsertf128 instruction
6188 // to create 256-bit vectors from two other 128-bit ones.
6189 static SDValue LowerAVXCONCAT_VECTORS(SDValue Op, SelectionDAG &DAG) {
6190   SDLoc dl(Op);
6191   MVT ResVT = Op.getSimpleValueType();
6192
6193   assert((ResVT.is256BitVector() ||
6194           ResVT.is512BitVector()) && "Value type must be 256-/512-bit wide");
6195
6196   SDValue V1 = Op.getOperand(0);
6197   SDValue V2 = Op.getOperand(1);
6198   unsigned NumElems = ResVT.getVectorNumElements();
6199   if(ResVT.is256BitVector())
6200     return Concat128BitVectors(V1, V2, ResVT, NumElems, DAG, dl);
6201
6202   if (Op.getNumOperands() == 4) {
6203     MVT HalfVT = MVT::getVectorVT(ResVT.getScalarType(),
6204                                 ResVT.getVectorNumElements()/2);
6205     SDValue V3 = Op.getOperand(2);
6206     SDValue V4 = Op.getOperand(3);
6207     return Concat256BitVectors(Concat128BitVectors(V1, V2, HalfVT, NumElems/2, DAG, dl),
6208       Concat128BitVectors(V3, V4, HalfVT, NumElems/2, DAG, dl), ResVT, NumElems, DAG, dl);
6209   }
6210   return Concat256BitVectors(V1, V2, ResVT, NumElems, DAG, dl);
6211 }
6212
6213 static SDValue LowerCONCAT_VECTORS(SDValue Op, SelectionDAG &DAG) {
6214   MVT LLVM_ATTRIBUTE_UNUSED VT = Op.getSimpleValueType();
6215   assert((VT.is256BitVector() && Op.getNumOperands() == 2) ||
6216          (VT.is512BitVector() && (Op.getNumOperands() == 2 ||
6217           Op.getNumOperands() == 4)));
6218
6219   // AVX can use the vinsertf128 instruction to create 256-bit vectors
6220   // from two other 128-bit ones.
6221
6222   // 512-bit vector may contain 2 256-bit vectors or 4 128-bit vectors
6223   return LowerAVXCONCAT_VECTORS(Op, DAG);
6224 }
6225
6226 // Try to lower a shuffle node into a simple blend instruction.
6227 static SDValue
6228 LowerVECTOR_SHUFFLEtoBlend(ShuffleVectorSDNode *SVOp,
6229                            const X86Subtarget *Subtarget, SelectionDAG &DAG) {
6230   SDValue V1 = SVOp->getOperand(0);
6231   SDValue V2 = SVOp->getOperand(1);
6232   SDLoc dl(SVOp);
6233   MVT VT = SVOp->getSimpleValueType(0);
6234   MVT EltVT = VT.getVectorElementType();
6235   unsigned NumElems = VT.getVectorNumElements();
6236
6237   // There is no blend with immediate in AVX-512.
6238   if (VT.is512BitVector())
6239     return SDValue();
6240
6241   if (!Subtarget->hasSSE41() || EltVT == MVT::i8)
6242     return SDValue();
6243   if (!Subtarget->hasInt256() && VT == MVT::v16i16)
6244     return SDValue();
6245
6246   // Check the mask for BLEND and build the value.
6247   unsigned MaskValue = 0;
6248   // There are 2 lanes if (NumElems > 8), and 1 lane otherwise.
6249   unsigned NumLanes = (NumElems-1)/8 + 1;
6250   unsigned NumElemsInLane = NumElems / NumLanes;
6251
6252   // Blend for v16i16 should be symetric for the both lanes.
6253   for (unsigned i = 0; i < NumElemsInLane; ++i) {
6254
6255     int SndLaneEltIdx = (NumLanes == 2) ?
6256       SVOp->getMaskElt(i + NumElemsInLane) : -1;
6257     int EltIdx = SVOp->getMaskElt(i);
6258
6259     if ((EltIdx < 0 || EltIdx == (int)i) &&
6260         (SndLaneEltIdx < 0 || SndLaneEltIdx == (int)(i + NumElemsInLane)))
6261       continue;
6262
6263     if (((unsigned)EltIdx == (i + NumElems)) &&
6264         (SndLaneEltIdx < 0 ||
6265          (unsigned)SndLaneEltIdx == i + NumElems + NumElemsInLane))
6266       MaskValue |= (1<<i);
6267     else
6268       return SDValue();
6269   }
6270
6271   // Convert i32 vectors to floating point if it is not AVX2.
6272   // AVX2 introduced VPBLENDD instruction for 128 and 256-bit vectors.
6273   MVT BlendVT = VT;
6274   if (EltVT == MVT::i64 || (EltVT == MVT::i32 && !Subtarget->hasInt256())) {
6275     BlendVT = MVT::getVectorVT(MVT::getFloatingPointVT(EltVT.getSizeInBits()),
6276                                NumElems);
6277     V1 = DAG.getNode(ISD::BITCAST, dl, VT, V1);
6278     V2 = DAG.getNode(ISD::BITCAST, dl, VT, V2);
6279   }
6280
6281   SDValue Ret = DAG.getNode(X86ISD::BLENDI, dl, BlendVT, V1, V2,
6282                             DAG.getConstant(MaskValue, MVT::i32));
6283   return DAG.getNode(ISD::BITCAST, dl, VT, Ret);
6284 }
6285
6286 /// In vector type \p VT, return true if the element at index \p InputIdx
6287 /// falls on a different 128-bit lane than \p OutputIdx.
6288 static bool ShuffleCrosses128bitLane(MVT VT, unsigned InputIdx,
6289                                      unsigned OutputIdx) {
6290   unsigned EltSize = VT.getVectorElementType().getSizeInBits();
6291   return InputIdx * EltSize / 128 != OutputIdx * EltSize / 128;
6292 }
6293
6294 /// Generate a PSHUFB if possible.  Selects elements from \p V1 according to
6295 /// \p MaskVals.  MaskVals[OutputIdx] = InputIdx specifies that we want to
6296 /// shuffle the element at InputIdx in V1 to OutputIdx in the result.  If \p
6297 /// MaskVals refers to elements outside of \p V1 or is undef (-1), insert a
6298 /// zero.
6299 static SDValue getPSHUFB(ArrayRef<int> MaskVals, SDValue V1, SDLoc &dl,
6300                          SelectionDAG &DAG) {
6301   MVT VT = V1.getSimpleValueType();
6302   assert(VT.is128BitVector() || VT.is256BitVector());
6303
6304   MVT EltVT = VT.getVectorElementType();
6305   unsigned EltSizeInBytes = EltVT.getSizeInBits() / 8;
6306   unsigned NumElts = VT.getVectorNumElements();
6307
6308   SmallVector<SDValue, 32> PshufbMask;
6309   for (unsigned OutputIdx = 0; OutputIdx < NumElts; ++OutputIdx) {
6310     int InputIdx = MaskVals[OutputIdx];
6311     unsigned InputByteIdx;
6312
6313     if (InputIdx < 0 || NumElts <= (unsigned)InputIdx)
6314       InputByteIdx = 0x80;
6315     else {
6316       // Cross lane is not allowed.
6317       if (ShuffleCrosses128bitLane(VT, InputIdx, OutputIdx))
6318         return SDValue();
6319       InputByteIdx = InputIdx * EltSizeInBytes;
6320       // Index is an byte offset within the 128-bit lane.
6321       InputByteIdx &= 0xf;
6322     }
6323
6324     for (unsigned j = 0; j < EltSizeInBytes; ++j) {
6325       PshufbMask.push_back(DAG.getConstant(InputByteIdx, MVT::i8));
6326       if (InputByteIdx != 0x80)
6327         ++InputByteIdx;
6328     }
6329   }
6330
6331   MVT ShufVT = MVT::getVectorVT(MVT::i8, PshufbMask.size());
6332   if (ShufVT != VT)
6333     V1 = DAG.getNode(ISD::BITCAST, dl, ShufVT, V1);
6334   return DAG.getNode(X86ISD::PSHUFB, dl, ShufVT, V1,
6335                      DAG.getNode(ISD::BUILD_VECTOR, dl, ShufVT,
6336                                  PshufbMask.data(), PshufbMask.size()));
6337 }
6338
6339 // v8i16 shuffles - Prefer shuffles in the following order:
6340 // 1. [all]   pshuflw, pshufhw, optional move
6341 // 2. [ssse3] 1 x pshufb
6342 // 3. [ssse3] 2 x pshufb + 1 x por
6343 // 4. [all]   mov + pshuflw + pshufhw + N x (pextrw + pinsrw)
6344 static SDValue
6345 LowerVECTOR_SHUFFLEv8i16(SDValue Op, const X86Subtarget *Subtarget,
6346                          SelectionDAG &DAG) {
6347   ShuffleVectorSDNode *SVOp = cast<ShuffleVectorSDNode>(Op);
6348   SDValue V1 = SVOp->getOperand(0);
6349   SDValue V2 = SVOp->getOperand(1);
6350   SDLoc dl(SVOp);
6351   SmallVector<int, 8> MaskVals;
6352
6353   // Determine if more than 1 of the words in each of the low and high quadwords
6354   // of the result come from the same quadword of one of the two inputs.  Undef
6355   // mask values count as coming from any quadword, for better codegen.
6356   //
6357   // Lo/HiQuad[i] = j indicates how many words from the ith quad of the input
6358   // feeds this quad.  For i, 0 and 1 refer to V1, 2 and 3 refer to V2.
6359   unsigned LoQuad[] = { 0, 0, 0, 0 };
6360   unsigned HiQuad[] = { 0, 0, 0, 0 };
6361   // Indices of quads used.
6362   std::bitset<4> InputQuads;
6363   for (unsigned i = 0; i < 8; ++i) {
6364     unsigned *Quad = i < 4 ? LoQuad : HiQuad;
6365     int EltIdx = SVOp->getMaskElt(i);
6366     MaskVals.push_back(EltIdx);
6367     if (EltIdx < 0) {
6368       ++Quad[0];
6369       ++Quad[1];
6370       ++Quad[2];
6371       ++Quad[3];
6372       continue;
6373     }
6374     ++Quad[EltIdx / 4];
6375     InputQuads.set(EltIdx / 4);
6376   }
6377
6378   int BestLoQuad = -1;
6379   unsigned MaxQuad = 1;
6380   for (unsigned i = 0; i < 4; ++i) {
6381     if (LoQuad[i] > MaxQuad) {
6382       BestLoQuad = i;
6383       MaxQuad = LoQuad[i];
6384     }
6385   }
6386
6387   int BestHiQuad = -1;
6388   MaxQuad = 1;
6389   for (unsigned i = 0; i < 4; ++i) {
6390     if (HiQuad[i] > MaxQuad) {
6391       BestHiQuad = i;
6392       MaxQuad = HiQuad[i];
6393     }
6394   }
6395
6396   // For SSSE3, If all 8 words of the result come from only 1 quadword of each
6397   // of the two input vectors, shuffle them into one input vector so only a
6398   // single pshufb instruction is necessary. If there are more than 2 input
6399   // quads, disable the next transformation since it does not help SSSE3.
6400   bool V1Used = InputQuads[0] || InputQuads[1];
6401   bool V2Used = InputQuads[2] || InputQuads[3];
6402   if (Subtarget->hasSSSE3()) {
6403     if (InputQuads.count() == 2 && V1Used && V2Used) {
6404       BestLoQuad = InputQuads[0] ? 0 : 1;
6405       BestHiQuad = InputQuads[2] ? 2 : 3;
6406     }
6407     if (InputQuads.count() > 2) {
6408       BestLoQuad = -1;
6409       BestHiQuad = -1;
6410     }
6411   }
6412
6413   // If BestLoQuad or BestHiQuad are set, shuffle the quads together and update
6414   // the shuffle mask.  If a quad is scored as -1, that means that it contains
6415   // words from all 4 input quadwords.
6416   SDValue NewV;
6417   if (BestLoQuad >= 0 || BestHiQuad >= 0) {
6418     int MaskV[] = {
6419       BestLoQuad < 0 ? 0 : BestLoQuad,
6420       BestHiQuad < 0 ? 1 : BestHiQuad
6421     };
6422     NewV = DAG.getVectorShuffle(MVT::v2i64, dl,
6423                   DAG.getNode(ISD::BITCAST, dl, MVT::v2i64, V1),
6424                   DAG.getNode(ISD::BITCAST, dl, MVT::v2i64, V2), &MaskV[0]);
6425     NewV = DAG.getNode(ISD::BITCAST, dl, MVT::v8i16, NewV);
6426
6427     // Rewrite the MaskVals and assign NewV to V1 if NewV now contains all the
6428     // source words for the shuffle, to aid later transformations.
6429     bool AllWordsInNewV = true;
6430     bool InOrder[2] = { true, true };
6431     for (unsigned i = 0; i != 8; ++i) {
6432       int idx = MaskVals[i];
6433       if (idx != (int)i)
6434         InOrder[i/4] = false;
6435       if (idx < 0 || (idx/4) == BestLoQuad || (idx/4) == BestHiQuad)
6436         continue;
6437       AllWordsInNewV = false;
6438       break;
6439     }
6440
6441     bool pshuflw = AllWordsInNewV, pshufhw = AllWordsInNewV;
6442     if (AllWordsInNewV) {
6443       for (int i = 0; i != 8; ++i) {
6444         int idx = MaskVals[i];
6445         if (idx < 0)
6446           continue;
6447         idx = MaskVals[i] = (idx / 4) == BestLoQuad ? (idx & 3) : (idx & 3) + 4;
6448         if ((idx != i) && idx < 4)
6449           pshufhw = false;
6450         if ((idx != i) && idx > 3)
6451           pshuflw = false;
6452       }
6453       V1 = NewV;
6454       V2Used = false;
6455       BestLoQuad = 0;
6456       BestHiQuad = 1;
6457     }
6458
6459     // If we've eliminated the use of V2, and the new mask is a pshuflw or
6460     // pshufhw, that's as cheap as it gets.  Return the new shuffle.
6461     if ((pshufhw && InOrder[0]) || (pshuflw && InOrder[1])) {
6462       unsigned Opc = pshufhw ? X86ISD::PSHUFHW : X86ISD::PSHUFLW;
6463       unsigned TargetMask = 0;
6464       NewV = DAG.getVectorShuffle(MVT::v8i16, dl, NewV,
6465                                   DAG.getUNDEF(MVT::v8i16), &MaskVals[0]);
6466       ShuffleVectorSDNode *SVOp = cast<ShuffleVectorSDNode>(NewV.getNode());
6467       TargetMask = pshufhw ? getShufflePSHUFHWImmediate(SVOp):
6468                              getShufflePSHUFLWImmediate(SVOp);
6469       V1 = NewV.getOperand(0);
6470       return getTargetShuffleNode(Opc, dl, MVT::v8i16, V1, TargetMask, DAG);
6471     }
6472   }
6473
6474   // Promote splats to a larger type which usually leads to more efficient code.
6475   // FIXME: Is this true if pshufb is available?
6476   if (SVOp->isSplat())
6477     return PromoteSplat(SVOp, DAG);
6478
6479   // If we have SSSE3, and all words of the result are from 1 input vector,
6480   // case 2 is generated, otherwise case 3 is generated.  If no SSSE3
6481   // is present, fall back to case 4.
6482   if (Subtarget->hasSSSE3()) {
6483     SmallVector<SDValue,16> pshufbMask;
6484
6485     // If we have elements from both input vectors, set the high bit of the
6486     // shuffle mask element to zero out elements that come from V2 in the V1
6487     // mask, and elements that come from V1 in the V2 mask, so that the two
6488     // results can be OR'd together.
6489     bool TwoInputs = V1Used && V2Used;
6490     V1 = getPSHUFB(MaskVals, V1, dl, DAG);
6491     if (!TwoInputs)
6492       return DAG.getNode(ISD::BITCAST, dl, MVT::v8i16, V1);
6493
6494     // Calculate the shuffle mask for the second input, shuffle it, and
6495     // OR it with the first shuffled input.
6496     CommuteVectorShuffleMask(MaskVals, 8);
6497     V2 = getPSHUFB(MaskVals, V2, dl, DAG);
6498     V1 = DAG.getNode(ISD::OR, dl, MVT::v16i8, V1, V2);
6499     return DAG.getNode(ISD::BITCAST, dl, MVT::v8i16, V1);
6500   }
6501
6502   // If BestLoQuad >= 0, generate a pshuflw to put the low elements in order,
6503   // and update MaskVals with new element order.
6504   std::bitset<8> InOrder;
6505   if (BestLoQuad >= 0) {
6506     int MaskV[] = { -1, -1, -1, -1, 4, 5, 6, 7 };
6507     for (int i = 0; i != 4; ++i) {
6508       int idx = MaskVals[i];
6509       if (idx < 0) {
6510         InOrder.set(i);
6511       } else if ((idx / 4) == BestLoQuad) {
6512         MaskV[i] = idx & 3;
6513         InOrder.set(i);
6514       }
6515     }
6516     NewV = DAG.getVectorShuffle(MVT::v8i16, dl, NewV, DAG.getUNDEF(MVT::v8i16),
6517                                 &MaskV[0]);
6518
6519     if (NewV.getOpcode() == ISD::VECTOR_SHUFFLE && Subtarget->hasSSSE3()) {
6520       ShuffleVectorSDNode *SVOp = cast<ShuffleVectorSDNode>(NewV.getNode());
6521       NewV = getTargetShuffleNode(X86ISD::PSHUFLW, dl, MVT::v8i16,
6522                                   NewV.getOperand(0),
6523                                   getShufflePSHUFLWImmediate(SVOp), DAG);
6524     }
6525   }
6526
6527   // If BestHi >= 0, generate a pshufhw to put the high elements in order,
6528   // and update MaskVals with the new element order.
6529   if (BestHiQuad >= 0) {
6530     int MaskV[] = { 0, 1, 2, 3, -1, -1, -1, -1 };
6531     for (unsigned i = 4; i != 8; ++i) {
6532       int idx = MaskVals[i];
6533       if (idx < 0) {
6534         InOrder.set(i);
6535       } else if ((idx / 4) == BestHiQuad) {
6536         MaskV[i] = (idx & 3) + 4;
6537         InOrder.set(i);
6538       }
6539     }
6540     NewV = DAG.getVectorShuffle(MVT::v8i16, dl, NewV, DAG.getUNDEF(MVT::v8i16),
6541                                 &MaskV[0]);
6542
6543     if (NewV.getOpcode() == ISD::VECTOR_SHUFFLE && Subtarget->hasSSSE3()) {
6544       ShuffleVectorSDNode *SVOp = cast<ShuffleVectorSDNode>(NewV.getNode());
6545       NewV = getTargetShuffleNode(X86ISD::PSHUFHW, dl, MVT::v8i16,
6546                                   NewV.getOperand(0),
6547                                   getShufflePSHUFHWImmediate(SVOp), DAG);
6548     }
6549   }
6550
6551   // In case BestHi & BestLo were both -1, which means each quadword has a word
6552   // from each of the four input quadwords, calculate the InOrder bitvector now
6553   // before falling through to the insert/extract cleanup.
6554   if (BestLoQuad == -1 && BestHiQuad == -1) {
6555     NewV = V1;
6556     for (int i = 0; i != 8; ++i)
6557       if (MaskVals[i] < 0 || MaskVals[i] == i)
6558         InOrder.set(i);
6559   }
6560
6561   // The other elements are put in the right place using pextrw and pinsrw.
6562   for (unsigned i = 0; i != 8; ++i) {
6563     if (InOrder[i])
6564       continue;
6565     int EltIdx = MaskVals[i];
6566     if (EltIdx < 0)
6567       continue;
6568     SDValue ExtOp = (EltIdx < 8) ?
6569       DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, MVT::i16, V1,
6570                   DAG.getIntPtrConstant(EltIdx)) :
6571       DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, MVT::i16, V2,
6572                   DAG.getIntPtrConstant(EltIdx - 8));
6573     NewV = DAG.getNode(ISD::INSERT_VECTOR_ELT, dl, MVT::v8i16, NewV, ExtOp,
6574                        DAG.getIntPtrConstant(i));
6575   }
6576   return NewV;
6577 }
6578
6579 // v16i8 shuffles - Prefer shuffles in the following order:
6580 // 1. [ssse3] 1 x pshufb
6581 // 2. [ssse3] 2 x pshufb + 1 x por
6582 // 3. [all]   v8i16 shuffle + N x pextrw + rotate + pinsrw
6583 static SDValue LowerVECTOR_SHUFFLEv16i8(ShuffleVectorSDNode *SVOp,
6584                                         const X86Subtarget* Subtarget,
6585                                         SelectionDAG &DAG) {
6586   const TargetLowering &TLI = DAG.getTargetLoweringInfo();
6587   SDValue V1 = SVOp->getOperand(0);
6588   SDValue V2 = SVOp->getOperand(1);
6589   SDLoc dl(SVOp);
6590   ArrayRef<int> MaskVals = SVOp->getMask();
6591
6592   // Promote splats to a larger type which usually leads to more efficient code.
6593   // FIXME: Is this true if pshufb is available?
6594   if (SVOp->isSplat())
6595     return PromoteSplat(SVOp, DAG);
6596
6597   // If we have SSSE3, case 1 is generated when all result bytes come from
6598   // one of  the inputs.  Otherwise, case 2 is generated.  If no SSSE3 is
6599   // present, fall back to case 3.
6600
6601   // If SSSE3, use 1 pshufb instruction per vector with elements in the result.
6602   if (Subtarget->hasSSSE3()) {
6603     SmallVector<SDValue,16> pshufbMask;
6604
6605     // If all result elements are from one input vector, then only translate
6606     // undef mask values to 0x80 (zero out result) in the pshufb mask.
6607     //
6608     // Otherwise, we have elements from both input vectors, and must zero out
6609     // elements that come from V2 in the first mask, and V1 in the second mask
6610     // so that we can OR them together.
6611     for (unsigned i = 0; i != 16; ++i) {
6612       int EltIdx = MaskVals[i];
6613       if (EltIdx < 0 || EltIdx >= 16)
6614         EltIdx = 0x80;
6615       pshufbMask.push_back(DAG.getConstant(EltIdx, MVT::i8));
6616     }
6617     V1 = DAG.getNode(X86ISD::PSHUFB, dl, MVT::v16i8, V1,
6618                      DAG.getNode(ISD::BUILD_VECTOR, dl,
6619                                  MVT::v16i8, &pshufbMask[0], 16));
6620
6621     // As PSHUFB will zero elements with negative indices, it's safe to ignore
6622     // the 2nd operand if it's undefined or zero.
6623     if (V2.getOpcode() == ISD::UNDEF ||
6624         ISD::isBuildVectorAllZeros(V2.getNode()))
6625       return V1;
6626
6627     // Calculate the shuffle mask for the second input, shuffle it, and
6628     // OR it with the first shuffled input.
6629     pshufbMask.clear();
6630     for (unsigned i = 0; i != 16; ++i) {
6631       int EltIdx = MaskVals[i];
6632       EltIdx = (EltIdx < 16) ? 0x80 : EltIdx - 16;
6633       pshufbMask.push_back(DAG.getConstant(EltIdx, MVT::i8));
6634     }
6635     V2 = DAG.getNode(X86ISD::PSHUFB, dl, MVT::v16i8, V2,
6636                      DAG.getNode(ISD::BUILD_VECTOR, dl,
6637                                  MVT::v16i8, &pshufbMask[0], 16));
6638     return DAG.getNode(ISD::OR, dl, MVT::v16i8, V1, V2);
6639   }
6640
6641   // No SSSE3 - Calculate in place words and then fix all out of place words
6642   // With 0-16 extracts & inserts.  Worst case is 16 bytes out of order from
6643   // the 16 different words that comprise the two doublequadword input vectors.
6644   V1 = DAG.getNode(ISD::BITCAST, dl, MVT::v8i16, V1);
6645   V2 = DAG.getNode(ISD::BITCAST, dl, MVT::v8i16, V2);
6646   SDValue NewV = V1;
6647   for (int i = 0; i != 8; ++i) {
6648     int Elt0 = MaskVals[i*2];
6649     int Elt1 = MaskVals[i*2+1];
6650
6651     // This word of the result is all undef, skip it.
6652     if (Elt0 < 0 && Elt1 < 0)
6653       continue;
6654
6655     // This word of the result is already in the correct place, skip it.
6656     if ((Elt0 == i*2) && (Elt1 == i*2+1))
6657       continue;
6658
6659     SDValue Elt0Src = Elt0 < 16 ? V1 : V2;
6660     SDValue Elt1Src = Elt1 < 16 ? V1 : V2;
6661     SDValue InsElt;
6662
6663     // If Elt0 and Elt1 are defined, are consecutive, and can be load
6664     // using a single extract together, load it and store it.
6665     if ((Elt0 >= 0) && ((Elt0 + 1) == Elt1) && ((Elt0 & 1) == 0)) {
6666       InsElt = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, MVT::i16, Elt1Src,
6667                            DAG.getIntPtrConstant(Elt1 / 2));
6668       NewV = DAG.getNode(ISD::INSERT_VECTOR_ELT, dl, MVT::v8i16, NewV, InsElt,
6669                         DAG.getIntPtrConstant(i));
6670       continue;
6671     }
6672
6673     // If Elt1 is defined, extract it from the appropriate source.  If the
6674     // source byte is not also odd, shift the extracted word left 8 bits
6675     // otherwise clear the bottom 8 bits if we need to do an or.
6676     if (Elt1 >= 0) {
6677       InsElt = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, MVT::i16, Elt1Src,
6678                            DAG.getIntPtrConstant(Elt1 / 2));
6679       if ((Elt1 & 1) == 0)
6680         InsElt = DAG.getNode(ISD::SHL, dl, MVT::i16, InsElt,
6681                              DAG.getConstant(8,
6682                                   TLI.getShiftAmountTy(InsElt.getValueType())));
6683       else if (Elt0 >= 0)
6684         InsElt = DAG.getNode(ISD::AND, dl, MVT::i16, InsElt,
6685                              DAG.getConstant(0xFF00, MVT::i16));
6686     }
6687     // If Elt0 is defined, extract it from the appropriate source.  If the
6688     // source byte is not also even, shift the extracted word right 8 bits. If
6689     // Elt1 was also defined, OR the extracted values together before
6690     // inserting them in the result.
6691     if (Elt0 >= 0) {
6692       SDValue InsElt0 = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, MVT::i16,
6693                                     Elt0Src, DAG.getIntPtrConstant(Elt0 / 2));
6694       if ((Elt0 & 1) != 0)
6695         InsElt0 = DAG.getNode(ISD::SRL, dl, MVT::i16, InsElt0,
6696                               DAG.getConstant(8,
6697                                  TLI.getShiftAmountTy(InsElt0.getValueType())));
6698       else if (Elt1 >= 0)
6699         InsElt0 = DAG.getNode(ISD::AND, dl, MVT::i16, InsElt0,
6700                              DAG.getConstant(0x00FF, MVT::i16));
6701       InsElt = Elt1 >= 0 ? DAG.getNode(ISD::OR, dl, MVT::i16, InsElt, InsElt0)
6702                          : InsElt0;
6703     }
6704     NewV = DAG.getNode(ISD::INSERT_VECTOR_ELT, dl, MVT::v8i16, NewV, InsElt,
6705                        DAG.getIntPtrConstant(i));
6706   }
6707   return DAG.getNode(ISD::BITCAST, dl, MVT::v16i8, NewV);
6708 }
6709
6710 // v32i8 shuffles - Translate to VPSHUFB if possible.
6711 static
6712 SDValue LowerVECTOR_SHUFFLEv32i8(ShuffleVectorSDNode *SVOp,
6713                                  const X86Subtarget *Subtarget,
6714                                  SelectionDAG &DAG) {
6715   MVT VT = SVOp->getSimpleValueType(0);
6716   SDValue V1 = SVOp->getOperand(0);
6717   SDValue V2 = SVOp->getOperand(1);
6718   SDLoc dl(SVOp);
6719   SmallVector<int, 32> MaskVals(SVOp->getMask().begin(), SVOp->getMask().end());
6720
6721   bool V2IsUndef = V2.getOpcode() == ISD::UNDEF;
6722   bool V1IsAllZero = ISD::isBuildVectorAllZeros(V1.getNode());
6723   bool V2IsAllZero = ISD::isBuildVectorAllZeros(V2.getNode());
6724
6725   // VPSHUFB may be generated if
6726   // (1) one of input vector is undefined or zeroinitializer.
6727   // The mask value 0x80 puts 0 in the corresponding slot of the vector.
6728   // And (2) the mask indexes don't cross the 128-bit lane.
6729   if (VT != MVT::v32i8 || !Subtarget->hasInt256() ||
6730       (!V2IsUndef && !V2IsAllZero && !V1IsAllZero))
6731     return SDValue();
6732
6733   if (V1IsAllZero && !V2IsAllZero) {
6734     CommuteVectorShuffleMask(MaskVals, 32);
6735     V1 = V2;
6736   }
6737   return getPSHUFB(MaskVals, V1, dl, DAG);
6738 }
6739
6740 /// RewriteAsNarrowerShuffle - Try rewriting v8i16 and v16i8 shuffles as 4 wide
6741 /// ones, or rewriting v4i32 / v4f32 as 2 wide ones if possible. This can be
6742 /// done when every pair / quad of shuffle mask elements point to elements in
6743 /// the right sequence. e.g.
6744 /// vector_shuffle X, Y, <2, 3, | 10, 11, | 0, 1, | 14, 15>
6745 static
6746 SDValue RewriteAsNarrowerShuffle(ShuffleVectorSDNode *SVOp,
6747                                  SelectionDAG &DAG) {
6748   MVT VT = SVOp->getSimpleValueType(0);
6749   SDLoc dl(SVOp);
6750   unsigned NumElems = VT.getVectorNumElements();
6751   MVT NewVT;
6752   unsigned Scale;
6753   switch (VT.SimpleTy) {
6754   default: llvm_unreachable("Unexpected!");
6755   case MVT::v4f32:  NewVT = MVT::v2f64; Scale = 2; break;
6756   case MVT::v4i32:  NewVT = MVT::v2i64; Scale = 2; break;
6757   case MVT::v8i16:  NewVT = MVT::v4i32; Scale = 2; break;
6758   case MVT::v16i8:  NewVT = MVT::v4i32; Scale = 4; break;
6759   case MVT::v16i16: NewVT = MVT::v8i32; Scale = 2; break;
6760   case MVT::v32i8:  NewVT = MVT::v8i32; Scale = 4; break;
6761   }
6762
6763   SmallVector<int, 8> MaskVec;
6764   for (unsigned i = 0; i != NumElems; i += Scale) {
6765     int StartIdx = -1;
6766     for (unsigned j = 0; j != Scale; ++j) {
6767       int EltIdx = SVOp->getMaskElt(i+j);
6768       if (EltIdx < 0)
6769         continue;
6770       if (StartIdx < 0)
6771         StartIdx = (EltIdx / Scale);
6772       if (EltIdx != (int)(StartIdx*Scale + j))
6773         return SDValue();
6774     }
6775     MaskVec.push_back(StartIdx);
6776   }
6777
6778   SDValue V1 = DAG.getNode(ISD::BITCAST, dl, NewVT, SVOp->getOperand(0));
6779   SDValue V2 = DAG.getNode(ISD::BITCAST, dl, NewVT, SVOp->getOperand(1));
6780   return DAG.getVectorShuffle(NewVT, dl, V1, V2, &MaskVec[0]);
6781 }
6782
6783 /// getVZextMovL - Return a zero-extending vector move low node.
6784 ///
6785 static SDValue getVZextMovL(MVT VT, MVT OpVT,
6786                             SDValue SrcOp, SelectionDAG &DAG,
6787                             const X86Subtarget *Subtarget, SDLoc dl) {
6788   if (VT == MVT::v2f64 || VT == MVT::v4f32) {
6789     LoadSDNode *LD = NULL;
6790     if (!isScalarLoadToVector(SrcOp.getNode(), &LD))
6791       LD = dyn_cast<LoadSDNode>(SrcOp);
6792     if (!LD) {
6793       // movssrr and movsdrr do not clear top bits. Try to use movd, movq
6794       // instead.
6795       MVT ExtVT = (OpVT == MVT::v2f64) ? MVT::i64 : MVT::i32;
6796       if ((ExtVT != MVT::i64 || Subtarget->is64Bit()) &&
6797           SrcOp.getOpcode() == ISD::SCALAR_TO_VECTOR &&
6798           SrcOp.getOperand(0).getOpcode() == ISD::BITCAST &&
6799           SrcOp.getOperand(0).getOperand(0).getValueType() == ExtVT) {
6800         // PR2108
6801         OpVT = (OpVT == MVT::v2f64) ? MVT::v2i64 : MVT::v4i32;
6802         return DAG.getNode(ISD::BITCAST, dl, VT,
6803                            DAG.getNode(X86ISD::VZEXT_MOVL, dl, OpVT,
6804                                        DAG.getNode(ISD::SCALAR_TO_VECTOR, dl,
6805                                                    OpVT,
6806                                                    SrcOp.getOperand(0)
6807                                                           .getOperand(0))));
6808       }
6809     }
6810   }
6811
6812   return DAG.getNode(ISD::BITCAST, dl, VT,
6813                      DAG.getNode(X86ISD::VZEXT_MOVL, dl, OpVT,
6814                                  DAG.getNode(ISD::BITCAST, dl,
6815                                              OpVT, SrcOp)));
6816 }
6817
6818 /// LowerVECTOR_SHUFFLE_256 - Handle all 256-bit wide vectors shuffles
6819 /// which could not be matched by any known target speficic shuffle
6820 static SDValue
6821 LowerVECTOR_SHUFFLE_256(ShuffleVectorSDNode *SVOp, SelectionDAG &DAG) {
6822
6823   SDValue NewOp = Compact8x32ShuffleNode(SVOp, DAG);
6824   if (NewOp.getNode())
6825     return NewOp;
6826
6827   MVT VT = SVOp->getSimpleValueType(0);
6828
6829   unsigned NumElems = VT.getVectorNumElements();
6830   unsigned NumLaneElems = NumElems / 2;
6831
6832   SDLoc dl(SVOp);
6833   MVT EltVT = VT.getVectorElementType();
6834   MVT NVT = MVT::getVectorVT(EltVT, NumLaneElems);
6835   SDValue Output[2];
6836
6837   SmallVector<int, 16> Mask;
6838   for (unsigned l = 0; l < 2; ++l) {
6839     // Build a shuffle mask for the output, discovering on the fly which
6840     // input vectors to use as shuffle operands (recorded in InputUsed).
6841     // If building a suitable shuffle vector proves too hard, then bail
6842     // out with UseBuildVector set.
6843     bool UseBuildVector = false;
6844     int InputUsed[2] = { -1, -1 }; // Not yet discovered.
6845     unsigned LaneStart = l * NumLaneElems;
6846     for (unsigned i = 0; i != NumLaneElems; ++i) {
6847       // The mask element.  This indexes into the input.
6848       int Idx = SVOp->getMaskElt(i+LaneStart);
6849       if (Idx < 0) {
6850         // the mask element does not index into any input vector.
6851         Mask.push_back(-1);
6852         continue;
6853       }
6854
6855       // The input vector this mask element indexes into.
6856       int Input = Idx / NumLaneElems;
6857
6858       // Turn the index into an offset from the start of the input vector.
6859       Idx -= Input * NumLaneElems;
6860
6861       // Find or create a shuffle vector operand to hold this input.
6862       unsigned OpNo;
6863       for (OpNo = 0; OpNo < array_lengthof(InputUsed); ++OpNo) {
6864         if (InputUsed[OpNo] == Input)
6865           // This input vector is already an operand.
6866           break;
6867         if (InputUsed[OpNo] < 0) {
6868           // Create a new operand for this input vector.
6869           InputUsed[OpNo] = Input;
6870           break;
6871         }
6872       }
6873
6874       if (OpNo >= array_lengthof(InputUsed)) {
6875         // More than two input vectors used!  Give up on trying to create a
6876         // shuffle vector.  Insert all elements into a BUILD_VECTOR instead.
6877         UseBuildVector = true;
6878         break;
6879       }
6880
6881       // Add the mask index for the new shuffle vector.
6882       Mask.push_back(Idx + OpNo * NumLaneElems);
6883     }
6884
6885     if (UseBuildVector) {
6886       SmallVector<SDValue, 16> SVOps;
6887       for (unsigned i = 0; i != NumLaneElems; ++i) {
6888         // The mask element.  This indexes into the input.
6889         int Idx = SVOp->getMaskElt(i+LaneStart);
6890         if (Idx < 0) {
6891           SVOps.push_back(DAG.getUNDEF(EltVT));
6892           continue;
6893         }
6894
6895         // The input vector this mask element indexes into.
6896         int Input = Idx / NumElems;
6897
6898         // Turn the index into an offset from the start of the input vector.
6899         Idx -= Input * NumElems;
6900
6901         // Extract the vector element by hand.
6902         SVOps.push_back(DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, EltVT,
6903                                     SVOp->getOperand(Input),
6904                                     DAG.getIntPtrConstant(Idx)));
6905       }
6906
6907       // Construct the output using a BUILD_VECTOR.
6908       Output[l] = DAG.getNode(ISD::BUILD_VECTOR, dl, NVT, &SVOps[0],
6909                               SVOps.size());
6910     } else if (InputUsed[0] < 0) {
6911       // No input vectors were used! The result is undefined.
6912       Output[l] = DAG.getUNDEF(NVT);
6913     } else {
6914       SDValue Op0 = Extract128BitVector(SVOp->getOperand(InputUsed[0] / 2),
6915                                         (InputUsed[0] % 2) * NumLaneElems,
6916                                         DAG, dl);
6917       // If only one input was used, use an undefined vector for the other.
6918       SDValue Op1 = (InputUsed[1] < 0) ? DAG.getUNDEF(NVT) :
6919         Extract128BitVector(SVOp->getOperand(InputUsed[1] / 2),
6920                             (InputUsed[1] % 2) * NumLaneElems, DAG, dl);
6921       // At least one input vector was used. Create a new shuffle vector.
6922       Output[l] = DAG.getVectorShuffle(NVT, dl, Op0, Op1, &Mask[0]);
6923     }
6924
6925     Mask.clear();
6926   }
6927
6928   // Concatenate the result back
6929   return DAG.getNode(ISD::CONCAT_VECTORS, dl, VT, Output[0], Output[1]);
6930 }
6931
6932 /// LowerVECTOR_SHUFFLE_128v4 - Handle all 128-bit wide vectors with
6933 /// 4 elements, and match them with several different shuffle types.
6934 static SDValue
6935 LowerVECTOR_SHUFFLE_128v4(ShuffleVectorSDNode *SVOp, SelectionDAG &DAG) {
6936   SDValue V1 = SVOp->getOperand(0);
6937   SDValue V2 = SVOp->getOperand(1);
6938   SDLoc dl(SVOp);
6939   MVT VT = SVOp->getSimpleValueType(0);
6940
6941   assert(VT.is128BitVector() && "Unsupported vector size");
6942
6943   std::pair<int, int> Locs[4];
6944   int Mask1[] = { -1, -1, -1, -1 };
6945   SmallVector<int, 8> PermMask(SVOp->getMask().begin(), SVOp->getMask().end());
6946
6947   unsigned NumHi = 0;
6948   unsigned NumLo = 0;
6949   for (unsigned i = 0; i != 4; ++i) {
6950     int Idx = PermMask[i];
6951     if (Idx < 0) {
6952       Locs[i] = std::make_pair(-1, -1);
6953     } else {
6954       assert(Idx < 8 && "Invalid VECTOR_SHUFFLE index!");
6955       if (Idx < 4) {
6956         Locs[i] = std::make_pair(0, NumLo);
6957         Mask1[NumLo] = Idx;
6958         NumLo++;
6959       } else {
6960         Locs[i] = std::make_pair(1, NumHi);
6961         if (2+NumHi < 4)
6962           Mask1[2+NumHi] = Idx;
6963         NumHi++;
6964       }
6965     }
6966   }
6967
6968   if (NumLo <= 2 && NumHi <= 2) {
6969     // If no more than two elements come from either vector. This can be
6970     // implemented with two shuffles. First shuffle gather the elements.
6971     // The second shuffle, which takes the first shuffle as both of its
6972     // vector operands, put the elements into the right order.
6973     V1 = DAG.getVectorShuffle(VT, dl, V1, V2, &Mask1[0]);
6974
6975     int Mask2[] = { -1, -1, -1, -1 };
6976
6977     for (unsigned i = 0; i != 4; ++i)
6978       if (Locs[i].first != -1) {
6979         unsigned Idx = (i < 2) ? 0 : 4;
6980         Idx += Locs[i].first * 2 + Locs[i].second;
6981         Mask2[i] = Idx;
6982       }
6983
6984     return DAG.getVectorShuffle(VT, dl, V1, V1, &Mask2[0]);
6985   }
6986
6987   if (NumLo == 3 || NumHi == 3) {
6988     // Otherwise, we must have three elements from one vector, call it X, and
6989     // one element from the other, call it Y.  First, use a shufps to build an
6990     // intermediate vector with the one element from Y and the element from X
6991     // that will be in the same half in the final destination (the indexes don't
6992     // matter). Then, use a shufps to build the final vector, taking the half
6993     // containing the element from Y from the intermediate, and the other half
6994     // from X.
6995     if (NumHi == 3) {
6996       // Normalize it so the 3 elements come from V1.
6997       CommuteVectorShuffleMask(PermMask, 4);
6998       std::swap(V1, V2);
6999     }
7000
7001     // Find the element from V2.
7002     unsigned HiIndex;
7003     for (HiIndex = 0; HiIndex < 3; ++HiIndex) {
7004       int Val = PermMask[HiIndex];
7005       if (Val < 0)
7006         continue;
7007       if (Val >= 4)
7008         break;
7009     }
7010
7011     Mask1[0] = PermMask[HiIndex];
7012     Mask1[1] = -1;
7013     Mask1[2] = PermMask[HiIndex^1];
7014     Mask1[3] = -1;
7015     V2 = DAG.getVectorShuffle(VT, dl, V1, V2, &Mask1[0]);
7016
7017     if (HiIndex >= 2) {
7018       Mask1[0] = PermMask[0];
7019       Mask1[1] = PermMask[1];
7020       Mask1[2] = HiIndex & 1 ? 6 : 4;
7021       Mask1[3] = HiIndex & 1 ? 4 : 6;
7022       return DAG.getVectorShuffle(VT, dl, V1, V2, &Mask1[0]);
7023     }
7024
7025     Mask1[0] = HiIndex & 1 ? 2 : 0;
7026     Mask1[1] = HiIndex & 1 ? 0 : 2;
7027     Mask1[2] = PermMask[2];
7028     Mask1[3] = PermMask[3];
7029     if (Mask1[2] >= 0)
7030       Mask1[2] += 4;
7031     if (Mask1[3] >= 0)
7032       Mask1[3] += 4;
7033     return DAG.getVectorShuffle(VT, dl, V2, V1, &Mask1[0]);
7034   }
7035
7036   // Break it into (shuffle shuffle_hi, shuffle_lo).
7037   int LoMask[] = { -1, -1, -1, -1 };
7038   int HiMask[] = { -1, -1, -1, -1 };
7039
7040   int *MaskPtr = LoMask;
7041   unsigned MaskIdx = 0;
7042   unsigned LoIdx = 0;
7043   unsigned HiIdx = 2;
7044   for (unsigned i = 0; i != 4; ++i) {
7045     if (i == 2) {
7046       MaskPtr = HiMask;
7047       MaskIdx = 1;
7048       LoIdx = 0;
7049       HiIdx = 2;
7050     }
7051     int Idx = PermMask[i];
7052     if (Idx < 0) {
7053       Locs[i] = std::make_pair(-1, -1);
7054     } else if (Idx < 4) {
7055       Locs[i] = std::make_pair(MaskIdx, LoIdx);
7056       MaskPtr[LoIdx] = Idx;
7057       LoIdx++;
7058     } else {
7059       Locs[i] = std::make_pair(MaskIdx, HiIdx);
7060       MaskPtr[HiIdx] = Idx;
7061       HiIdx++;
7062     }
7063   }
7064
7065   SDValue LoShuffle = DAG.getVectorShuffle(VT, dl, V1, V2, &LoMask[0]);
7066   SDValue HiShuffle = DAG.getVectorShuffle(VT, dl, V1, V2, &HiMask[0]);
7067   int MaskOps[] = { -1, -1, -1, -1 };
7068   for (unsigned i = 0; i != 4; ++i)
7069     if (Locs[i].first != -1)
7070       MaskOps[i] = Locs[i].first * 4 + Locs[i].second;
7071   return DAG.getVectorShuffle(VT, dl, LoShuffle, HiShuffle, &MaskOps[0]);
7072 }
7073
7074 static bool MayFoldVectorLoad(SDValue V) {
7075   while (V.hasOneUse() && V.getOpcode() == ISD::BITCAST)
7076     V = V.getOperand(0);
7077
7078   if (V.hasOneUse() && V.getOpcode() == ISD::SCALAR_TO_VECTOR)
7079     V = V.getOperand(0);
7080   if (V.hasOneUse() && V.getOpcode() == ISD::BUILD_VECTOR &&
7081       V.getNumOperands() == 2 && V.getOperand(1).getOpcode() == ISD::UNDEF)
7082     // BUILD_VECTOR (load), undef
7083     V = V.getOperand(0);
7084
7085   return MayFoldLoad(V);
7086 }
7087
7088 static
7089 SDValue getMOVDDup(SDValue &Op, SDLoc &dl, SDValue V1, SelectionDAG &DAG) {
7090   MVT VT = Op.getSimpleValueType();
7091
7092   // Canonizalize to v2f64.
7093   V1 = DAG.getNode(ISD::BITCAST, dl, MVT::v2f64, V1);
7094   return DAG.getNode(ISD::BITCAST, dl, VT,
7095                      getTargetShuffleNode(X86ISD::MOVDDUP, dl, MVT::v2f64,
7096                                           V1, DAG));
7097 }
7098
7099 static
7100 SDValue getMOVLowToHigh(SDValue &Op, SDLoc &dl, SelectionDAG &DAG,
7101                         bool HasSSE2) {
7102   SDValue V1 = Op.getOperand(0);
7103   SDValue V2 = Op.getOperand(1);
7104   MVT VT = Op.getSimpleValueType();
7105
7106   assert(VT != MVT::v2i64 && "unsupported shuffle type");
7107
7108   if (HasSSE2 && VT == MVT::v2f64)
7109     return getTargetShuffleNode(X86ISD::MOVLHPD, dl, VT, V1, V2, DAG);
7110
7111   // v4f32 or v4i32: canonizalized to v4f32 (which is legal for SSE1)
7112   return DAG.getNode(ISD::BITCAST, dl, VT,
7113                      getTargetShuffleNode(X86ISD::MOVLHPS, dl, MVT::v4f32,
7114                            DAG.getNode(ISD::BITCAST, dl, MVT::v4f32, V1),
7115                            DAG.getNode(ISD::BITCAST, dl, MVT::v4f32, V2), DAG));
7116 }
7117
7118 static
7119 SDValue getMOVHighToLow(SDValue &Op, SDLoc &dl, SelectionDAG &DAG) {
7120   SDValue V1 = Op.getOperand(0);
7121   SDValue V2 = Op.getOperand(1);
7122   MVT VT = Op.getSimpleValueType();
7123
7124   assert((VT == MVT::v4i32 || VT == MVT::v4f32) &&
7125          "unsupported shuffle type");
7126
7127   if (V2.getOpcode() == ISD::UNDEF)
7128     V2 = V1;
7129
7130   // v4i32 or v4f32
7131   return getTargetShuffleNode(X86ISD::MOVHLPS, dl, VT, V1, V2, DAG);
7132 }
7133
7134 static
7135 SDValue getMOVLP(SDValue &Op, SDLoc &dl, SelectionDAG &DAG, bool HasSSE2) {
7136   SDValue V1 = Op.getOperand(0);
7137   SDValue V2 = Op.getOperand(1);
7138   MVT VT = Op.getSimpleValueType();
7139   unsigned NumElems = VT.getVectorNumElements();
7140
7141   // Use MOVLPS and MOVLPD in case V1 or V2 are loads. During isel, the second
7142   // operand of these instructions is only memory, so check if there's a
7143   // potencial load folding here, otherwise use SHUFPS or MOVSD to match the
7144   // same masks.
7145   bool CanFoldLoad = false;
7146
7147   // Trivial case, when V2 comes from a load.
7148   if (MayFoldVectorLoad(V2))
7149     CanFoldLoad = true;
7150
7151   // When V1 is a load, it can be folded later into a store in isel, example:
7152   //  (store (v4f32 (X86Movlps (load addr:$src1), VR128:$src2)), addr:$src1)
7153   //    turns into:
7154   //  (MOVLPSmr addr:$src1, VR128:$src2)
7155   // So, recognize this potential and also use MOVLPS or MOVLPD
7156   else if (MayFoldVectorLoad(V1) && MayFoldIntoStore(Op))
7157     CanFoldLoad = true;
7158
7159   ShuffleVectorSDNode *SVOp = cast<ShuffleVectorSDNode>(Op);
7160   if (CanFoldLoad) {
7161     if (HasSSE2 && NumElems == 2)
7162       return getTargetShuffleNode(X86ISD::MOVLPD, dl, VT, V1, V2, DAG);
7163
7164     if (NumElems == 4)
7165       // If we don't care about the second element, proceed to use movss.
7166       if (SVOp->getMaskElt(1) != -1)
7167         return getTargetShuffleNode(X86ISD::MOVLPS, dl, VT, V1, V2, DAG);
7168   }
7169
7170   // movl and movlp will both match v2i64, but v2i64 is never matched by
7171   // movl earlier because we make it strict to avoid messing with the movlp load
7172   // folding logic (see the code above getMOVLP call). Match it here then,
7173   // this is horrible, but will stay like this until we move all shuffle
7174   // matching to x86 specific nodes. Note that for the 1st condition all
7175   // types are matched with movsd.
7176   if (HasSSE2) {
7177     // FIXME: isMOVLMask should be checked and matched before getMOVLP,
7178     // as to remove this logic from here, as much as possible
7179     if (NumElems == 2 || !isMOVLMask(SVOp->getMask(), VT))
7180       return getTargetShuffleNode(X86ISD::MOVSD, dl, VT, V1, V2, DAG);
7181     return getTargetShuffleNode(X86ISD::MOVSS, dl, VT, V1, V2, DAG);
7182   }
7183
7184   assert(VT != MVT::v4i32 && "unsupported shuffle type");
7185
7186   // Invert the operand order and use SHUFPS to match it.
7187   return getTargetShuffleNode(X86ISD::SHUFP, dl, VT, V2, V1,
7188                               getShuffleSHUFImmediate(SVOp), DAG);
7189 }
7190
7191 // Reduce a vector shuffle to zext.
7192 static SDValue LowerVectorIntExtend(SDValue Op, const X86Subtarget *Subtarget,
7193                                     SelectionDAG &DAG) {
7194   // PMOVZX is only available from SSE41.
7195   if (!Subtarget->hasSSE41())
7196     return SDValue();
7197
7198   MVT VT = Op.getSimpleValueType();
7199
7200   // Only AVX2 support 256-bit vector integer extending.
7201   if (!Subtarget->hasInt256() && VT.is256BitVector())
7202     return SDValue();
7203
7204   ShuffleVectorSDNode *SVOp = cast<ShuffleVectorSDNode>(Op);
7205   SDLoc DL(Op);
7206   SDValue V1 = Op.getOperand(0);
7207   SDValue V2 = Op.getOperand(1);
7208   unsigned NumElems = VT.getVectorNumElements();
7209
7210   // Extending is an unary operation and the element type of the source vector
7211   // won't be equal to or larger than i64.
7212   if (V2.getOpcode() != ISD::UNDEF || !VT.isInteger() ||
7213       VT.getVectorElementType() == MVT::i64)
7214     return SDValue();
7215
7216   // Find the expansion ratio, e.g. expanding from i8 to i32 has a ratio of 4.
7217   unsigned Shift = 1; // Start from 2, i.e. 1 << 1.
7218   while ((1U << Shift) < NumElems) {
7219     if (SVOp->getMaskElt(1U << Shift) == 1)
7220       break;
7221     Shift += 1;
7222     // The maximal ratio is 8, i.e. from i8 to i64.
7223     if (Shift > 3)
7224       return SDValue();
7225   }
7226
7227   // Check the shuffle mask.
7228   unsigned Mask = (1U << Shift) - 1;
7229   for (unsigned i = 0; i != NumElems; ++i) {
7230     int EltIdx = SVOp->getMaskElt(i);
7231     if ((i & Mask) != 0 && EltIdx != -1)
7232       return SDValue();
7233     if ((i & Mask) == 0 && (unsigned)EltIdx != (i >> Shift))
7234       return SDValue();
7235   }
7236
7237   unsigned NBits = VT.getVectorElementType().getSizeInBits() << Shift;
7238   MVT NeVT = MVT::getIntegerVT(NBits);
7239   MVT NVT = MVT::getVectorVT(NeVT, NumElems >> Shift);
7240
7241   if (!DAG.getTargetLoweringInfo().isTypeLegal(NVT))
7242     return SDValue();
7243
7244   // Simplify the operand as it's prepared to be fed into shuffle.
7245   unsigned SignificantBits = NVT.getSizeInBits() >> Shift;
7246   if (V1.getOpcode() == ISD::BITCAST &&
7247       V1.getOperand(0).getOpcode() == ISD::SCALAR_TO_VECTOR &&
7248       V1.getOperand(0).getOperand(0).getOpcode() == ISD::EXTRACT_VECTOR_ELT &&
7249       V1.getOperand(0).getOperand(0)
7250         .getSimpleValueType().getSizeInBits() == SignificantBits) {
7251     // (bitcast (sclr2vec (ext_vec_elt x))) -> (bitcast x)
7252     SDValue V = V1.getOperand(0).getOperand(0).getOperand(0);
7253     ConstantSDNode *CIdx =
7254       dyn_cast<ConstantSDNode>(V1.getOperand(0).getOperand(0).getOperand(1));
7255     // If it's foldable, i.e. normal load with single use, we will let code
7256     // selection to fold it. Otherwise, we will short the conversion sequence.
7257     if (CIdx && CIdx->getZExtValue() == 0 &&
7258         (!ISD::isNormalLoad(V.getNode()) || !V.hasOneUse())) {
7259       MVT FullVT = V.getSimpleValueType();
7260       MVT V1VT = V1.getSimpleValueType();
7261       if (FullVT.getSizeInBits() > V1VT.getSizeInBits()) {
7262         // The "ext_vec_elt" node is wider than the result node.
7263         // In this case we should extract subvector from V.
7264         // (bitcast (sclr2vec (ext_vec_elt x))) -> (bitcast (extract_subvector x)).
7265         unsigned Ratio = FullVT.getSizeInBits() / V1VT.getSizeInBits();
7266         MVT SubVecVT = MVT::getVectorVT(FullVT.getVectorElementType(),
7267                                         FullVT.getVectorNumElements()/Ratio);
7268         V = DAG.getNode(ISD::EXTRACT_SUBVECTOR, DL, SubVecVT, V,
7269                         DAG.getIntPtrConstant(0));
7270       }
7271       V1 = DAG.getNode(ISD::BITCAST, DL, V1VT, V);
7272     }
7273   }
7274
7275   return DAG.getNode(ISD::BITCAST, DL, VT,
7276                      DAG.getNode(X86ISD::VZEXT, DL, NVT, V1));
7277 }
7278
7279 static SDValue
7280 NormalizeVectorShuffle(SDValue Op, const X86Subtarget *Subtarget,
7281                        SelectionDAG &DAG) {
7282   ShuffleVectorSDNode *SVOp = cast<ShuffleVectorSDNode>(Op);
7283   MVT VT = Op.getSimpleValueType();
7284   SDLoc dl(Op);
7285   SDValue V1 = Op.getOperand(0);
7286   SDValue V2 = Op.getOperand(1);
7287
7288   if (isZeroShuffle(SVOp))
7289     return getZeroVector(VT, Subtarget, DAG, dl);
7290
7291   // Handle splat operations
7292   if (SVOp->isSplat()) {
7293     // Use vbroadcast whenever the splat comes from a foldable load
7294     SDValue Broadcast = LowerVectorBroadcast(Op, Subtarget, DAG);
7295     if (Broadcast.getNode())
7296       return Broadcast;
7297   }
7298
7299   // Check integer expanding shuffles.
7300   SDValue NewOp = LowerVectorIntExtend(Op, Subtarget, DAG);
7301   if (NewOp.getNode())
7302     return NewOp;
7303
7304   // If the shuffle can be profitably rewritten as a narrower shuffle, then
7305   // do it!
7306   if (VT == MVT::v8i16  || VT == MVT::v16i8 ||
7307       VT == MVT::v16i16 || VT == MVT::v32i8) {
7308     SDValue NewOp = RewriteAsNarrowerShuffle(SVOp, DAG);
7309     if (NewOp.getNode())
7310       return DAG.getNode(ISD::BITCAST, dl, VT, NewOp);
7311   } else if ((VT == MVT::v4i32 ||
7312              (VT == MVT::v4f32 && Subtarget->hasSSE2()))) {
7313     // FIXME: Figure out a cleaner way to do this.
7314     // Try to make use of movq to zero out the top part.
7315     if (ISD::isBuildVectorAllZeros(V2.getNode())) {
7316       SDValue NewOp = RewriteAsNarrowerShuffle(SVOp, DAG);
7317       if (NewOp.getNode()) {
7318         MVT NewVT = NewOp.getSimpleValueType();
7319         if (isCommutedMOVLMask(cast<ShuffleVectorSDNode>(NewOp)->getMask(),
7320                                NewVT, true, false))
7321           return getVZextMovL(VT, NewVT, NewOp.getOperand(0),
7322                               DAG, Subtarget, dl);
7323       }
7324     } else if (ISD::isBuildVectorAllZeros(V1.getNode())) {
7325       SDValue NewOp = RewriteAsNarrowerShuffle(SVOp, DAG);
7326       if (NewOp.getNode()) {
7327         MVT NewVT = NewOp.getSimpleValueType();
7328         if (isMOVLMask(cast<ShuffleVectorSDNode>(NewOp)->getMask(), NewVT))
7329           return getVZextMovL(VT, NewVT, NewOp.getOperand(1),
7330                               DAG, Subtarget, dl);
7331       }
7332     }
7333   }
7334   return SDValue();
7335 }
7336
7337 SDValue
7338 X86TargetLowering::LowerVECTOR_SHUFFLE(SDValue Op, SelectionDAG &DAG) const {
7339   ShuffleVectorSDNode *SVOp = cast<ShuffleVectorSDNode>(Op);
7340   SDValue V1 = Op.getOperand(0);
7341   SDValue V2 = Op.getOperand(1);
7342   MVT VT = Op.getSimpleValueType();
7343   SDLoc dl(Op);
7344   unsigned NumElems = VT.getVectorNumElements();
7345   bool V1IsUndef = V1.getOpcode() == ISD::UNDEF;
7346   bool V2IsUndef = V2.getOpcode() == ISD::UNDEF;
7347   bool V1IsSplat = false;
7348   bool V2IsSplat = false;
7349   bool HasSSE2 = Subtarget->hasSSE2();
7350   bool HasFp256    = Subtarget->hasFp256();
7351   bool HasInt256   = Subtarget->hasInt256();
7352   MachineFunction &MF = DAG.getMachineFunction();
7353   bool OptForSize = MF.getFunction()->getAttributes().
7354     hasAttribute(AttributeSet::FunctionIndex, Attribute::OptimizeForSize);
7355
7356   assert(VT.getSizeInBits() != 64 && "Can't lower MMX shuffles");
7357
7358   if (V1IsUndef && V2IsUndef)
7359     return DAG.getUNDEF(VT);
7360
7361   // When we create a shuffle node we put the UNDEF node to second operand,
7362   // but in some cases the first operand may be transformed to UNDEF.
7363   // In this case we should just commute the node.
7364   if (V1IsUndef)
7365     return CommuteVectorShuffle(SVOp, DAG);
7366
7367   // Vector shuffle lowering takes 3 steps:
7368   //
7369   // 1) Normalize the input vectors. Here splats, zeroed vectors, profitable
7370   //    narrowing and commutation of operands should be handled.
7371   // 2) Matching of shuffles with known shuffle masks to x86 target specific
7372   //    shuffle nodes.
7373   // 3) Rewriting of unmatched masks into new generic shuffle operations,
7374   //    so the shuffle can be broken into other shuffles and the legalizer can
7375   //    try the lowering again.
7376   //
7377   // The general idea is that no vector_shuffle operation should be left to
7378   // be matched during isel, all of them must be converted to a target specific
7379   // node here.
7380
7381   // Normalize the input vectors. Here splats, zeroed vectors, profitable
7382   // narrowing and commutation of operands should be handled. The actual code
7383   // doesn't include all of those, work in progress...
7384   SDValue NewOp = NormalizeVectorShuffle(Op, Subtarget, DAG);
7385   if (NewOp.getNode())
7386     return NewOp;
7387
7388   SmallVector<int, 8> M(SVOp->getMask().begin(), SVOp->getMask().end());
7389
7390   // NOTE: isPSHUFDMask can also match both masks below (unpckl_undef and
7391   // unpckh_undef). Only use pshufd if speed is more important than size.
7392   if (OptForSize && isUNPCKL_v_undef_Mask(M, VT, HasInt256))
7393     return getTargetShuffleNode(X86ISD::UNPCKL, dl, VT, V1, V1, DAG);
7394   if (OptForSize && isUNPCKH_v_undef_Mask(M, VT, HasInt256))
7395     return getTargetShuffleNode(X86ISD::UNPCKH, dl, VT, V1, V1, DAG);
7396
7397   if (isMOVDDUPMask(M, VT) && Subtarget->hasSSE3() &&
7398       V2IsUndef && MayFoldVectorLoad(V1))
7399     return getMOVDDup(Op, dl, V1, DAG);
7400
7401   if (isMOVHLPS_v_undef_Mask(M, VT))
7402     return getMOVHighToLow(Op, dl, DAG);
7403
7404   // Use to match splats
7405   if (HasSSE2 && isUNPCKHMask(M, VT, HasInt256) && V2IsUndef &&
7406       (VT == MVT::v2f64 || VT == MVT::v2i64))
7407     return getTargetShuffleNode(X86ISD::UNPCKH, dl, VT, V1, V1, DAG);
7408
7409   if (isPSHUFDMask(M, VT)) {
7410     // The actual implementation will match the mask in the if above and then
7411     // during isel it can match several different instructions, not only pshufd
7412     // as its name says, sad but true, emulate the behavior for now...
7413     if (isMOVDDUPMask(M, VT) && ((VT == MVT::v4f32 || VT == MVT::v2i64)))
7414       return getTargetShuffleNode(X86ISD::MOVLHPS, dl, VT, V1, V1, DAG);
7415
7416     unsigned TargetMask = getShuffleSHUFImmediate(SVOp);
7417
7418     if (HasSSE2 && (VT == MVT::v4f32 || VT == MVT::v4i32))
7419       return getTargetShuffleNode(X86ISD::PSHUFD, dl, VT, V1, TargetMask, DAG);
7420
7421     if (HasFp256 && (VT == MVT::v4f32 || VT == MVT::v2f64))
7422       return getTargetShuffleNode(X86ISD::VPERMILP, dl, VT, V1, TargetMask,
7423                                   DAG);
7424
7425     return getTargetShuffleNode(X86ISD::SHUFP, dl, VT, V1, V1,
7426                                 TargetMask, DAG);
7427   }
7428
7429   if (isPALIGNRMask(M, VT, Subtarget))
7430     return getTargetShuffleNode(X86ISD::PALIGNR, dl, VT, V1, V2,
7431                                 getShufflePALIGNRImmediate(SVOp),
7432                                 DAG);
7433
7434   // Check if this can be converted into a logical shift.
7435   bool isLeft = false;
7436   unsigned ShAmt = 0;
7437   SDValue ShVal;
7438   bool isShift = HasSSE2 && isVectorShift(SVOp, DAG, isLeft, ShVal, ShAmt);
7439   if (isShift && ShVal.hasOneUse()) {
7440     // If the shifted value has multiple uses, it may be cheaper to use
7441     // v_set0 + movlhps or movhlps, etc.
7442     MVT EltVT = VT.getVectorElementType();
7443     ShAmt *= EltVT.getSizeInBits();
7444     return getVShift(isLeft, VT, ShVal, ShAmt, DAG, *this, dl);
7445   }
7446
7447   if (isMOVLMask(M, VT)) {
7448     if (ISD::isBuildVectorAllZeros(V1.getNode()))
7449       return getVZextMovL(VT, VT, V2, DAG, Subtarget, dl);
7450     if (!isMOVLPMask(M, VT)) {
7451       if (HasSSE2 && (VT == MVT::v2i64 || VT == MVT::v2f64))
7452         return getTargetShuffleNode(X86ISD::MOVSD, dl, VT, V1, V2, DAG);
7453
7454       if (VT == MVT::v4i32 || VT == MVT::v4f32)
7455         return getTargetShuffleNode(X86ISD::MOVSS, dl, VT, V1, V2, DAG);
7456     }
7457   }
7458
7459   // FIXME: fold these into legal mask.
7460   if (isMOVLHPSMask(M, VT) && !isUNPCKLMask(M, VT, HasInt256))
7461     return getMOVLowToHigh(Op, dl, DAG, HasSSE2);
7462
7463   if (isMOVHLPSMask(M, VT))
7464     return getMOVHighToLow(Op, dl, DAG);
7465
7466   if (V2IsUndef && isMOVSHDUPMask(M, VT, Subtarget))
7467     return getTargetShuffleNode(X86ISD::MOVSHDUP, dl, VT, V1, DAG);
7468
7469   if (V2IsUndef && isMOVSLDUPMask(M, VT, Subtarget))
7470     return getTargetShuffleNode(X86ISD::MOVSLDUP, dl, VT, V1, DAG);
7471
7472   if (isMOVLPMask(M, VT))
7473     return getMOVLP(Op, dl, DAG, HasSSE2);
7474
7475   if (ShouldXformToMOVHLPS(M, VT) ||
7476       ShouldXformToMOVLP(V1.getNode(), V2.getNode(), M, VT))
7477     return CommuteVectorShuffle(SVOp, DAG);
7478
7479   if (isShift) {
7480     // No better options. Use a vshldq / vsrldq.
7481     MVT EltVT = VT.getVectorElementType();
7482     ShAmt *= EltVT.getSizeInBits();
7483     return getVShift(isLeft, VT, ShVal, ShAmt, DAG, *this, dl);
7484   }
7485
7486   bool Commuted = false;
7487   // FIXME: This should also accept a bitcast of a splat?  Be careful, not
7488   // 1,1,1,1 -> v8i16 though.
7489   V1IsSplat = isSplatVector(V1.getNode());
7490   V2IsSplat = isSplatVector(V2.getNode());
7491
7492   // Canonicalize the splat or undef, if present, to be on the RHS.
7493   if (!V2IsUndef && V1IsSplat && !V2IsSplat) {
7494     CommuteVectorShuffleMask(M, NumElems);
7495     std::swap(V1, V2);
7496     std::swap(V1IsSplat, V2IsSplat);
7497     Commuted = true;
7498   }
7499
7500   if (isCommutedMOVLMask(M, VT, V2IsSplat, V2IsUndef)) {
7501     // Shuffling low element of v1 into undef, just return v1.
7502     if (V2IsUndef)
7503       return V1;
7504     // If V2 is a splat, the mask may be malformed such as <4,3,3,3>, which
7505     // the instruction selector will not match, so get a canonical MOVL with
7506     // swapped operands to undo the commute.
7507     return getMOVL(DAG, dl, VT, V2, V1);
7508   }
7509
7510   if (isUNPCKLMask(M, VT, HasInt256))
7511     return getTargetShuffleNode(X86ISD::UNPCKL, dl, VT, V1, V2, DAG);
7512
7513   if (isUNPCKHMask(M, VT, HasInt256))
7514     return getTargetShuffleNode(X86ISD::UNPCKH, dl, VT, V1, V2, DAG);
7515
7516   if (V2IsSplat) {
7517     // Normalize mask so all entries that point to V2 points to its first
7518     // element then try to match unpck{h|l} again. If match, return a
7519     // new vector_shuffle with the corrected mask.p
7520     SmallVector<int, 8> NewMask(M.begin(), M.end());
7521     NormalizeMask(NewMask, NumElems);
7522     if (isUNPCKLMask(NewMask, VT, HasInt256, true))
7523       return getTargetShuffleNode(X86ISD::UNPCKL, dl, VT, V1, V2, DAG);
7524     if (isUNPCKHMask(NewMask, VT, HasInt256, true))
7525       return getTargetShuffleNode(X86ISD::UNPCKH, dl, VT, V1, V2, DAG);
7526   }
7527
7528   if (Commuted) {
7529     // Commute is back and try unpck* again.
7530     // FIXME: this seems wrong.
7531     CommuteVectorShuffleMask(M, NumElems);
7532     std::swap(V1, V2);
7533     std::swap(V1IsSplat, V2IsSplat);
7534
7535     if (isUNPCKLMask(M, VT, HasInt256))
7536       return getTargetShuffleNode(X86ISD::UNPCKL, dl, VT, V1, V2, DAG);
7537
7538     if (isUNPCKHMask(M, VT, HasInt256))
7539       return getTargetShuffleNode(X86ISD::UNPCKH, dl, VT, V1, V2, DAG);
7540   }
7541
7542   // Normalize the node to match x86 shuffle ops if needed
7543   if (!V2IsUndef && (isSHUFPMask(M, VT, /* Commuted */ true)))
7544     return CommuteVectorShuffle(SVOp, DAG);
7545
7546   // The checks below are all present in isShuffleMaskLegal, but they are
7547   // inlined here right now to enable us to directly emit target specific
7548   // nodes, and remove one by one until they don't return Op anymore.
7549
7550   if (ShuffleVectorSDNode::isSplatMask(&M[0], VT) &&
7551       SVOp->getSplatIndex() == 0 && V2IsUndef) {
7552     if (VT == MVT::v2f64 || VT == MVT::v2i64)
7553       return getTargetShuffleNode(X86ISD::UNPCKL, dl, VT, V1, V1, DAG);
7554   }
7555
7556   if (isPSHUFHWMask(M, VT, HasInt256))
7557     return getTargetShuffleNode(X86ISD::PSHUFHW, dl, VT, V1,
7558                                 getShufflePSHUFHWImmediate(SVOp),
7559                                 DAG);
7560
7561   if (isPSHUFLWMask(M, VT, HasInt256))
7562     return getTargetShuffleNode(X86ISD::PSHUFLW, dl, VT, V1,
7563                                 getShufflePSHUFLWImmediate(SVOp),
7564                                 DAG);
7565
7566   if (isSHUFPMask(M, VT))
7567     return getTargetShuffleNode(X86ISD::SHUFP, dl, VT, V1, V2,
7568                                 getShuffleSHUFImmediate(SVOp), DAG);
7569
7570   if (isUNPCKL_v_undef_Mask(M, VT, HasInt256))
7571     return getTargetShuffleNode(X86ISD::UNPCKL, dl, VT, V1, V1, DAG);
7572   if (isUNPCKH_v_undef_Mask(M, VT, HasInt256))
7573     return getTargetShuffleNode(X86ISD::UNPCKH, dl, VT, V1, V1, DAG);
7574
7575   //===--------------------------------------------------------------------===//
7576   // Generate target specific nodes for 128 or 256-bit shuffles only
7577   // supported in the AVX instruction set.
7578   //
7579
7580   // Handle VMOVDDUPY permutations
7581   if (V2IsUndef && isMOVDDUPYMask(M, VT, HasFp256))
7582     return getTargetShuffleNode(X86ISD::MOVDDUP, dl, VT, V1, DAG);
7583
7584   // Handle VPERMILPS/D* permutations
7585   if (isVPERMILPMask(M, VT)) {
7586     if ((HasInt256 && VT == MVT::v8i32) || VT == MVT::v16i32)
7587       return getTargetShuffleNode(X86ISD::PSHUFD, dl, VT, V1,
7588                                   getShuffleSHUFImmediate(SVOp), DAG);
7589     return getTargetShuffleNode(X86ISD::VPERMILP, dl, VT, V1,
7590                                 getShuffleSHUFImmediate(SVOp), DAG);
7591   }
7592
7593   // Handle VPERM2F128/VPERM2I128 permutations
7594   if (isVPERM2X128Mask(M, VT, HasFp256))
7595     return getTargetShuffleNode(X86ISD::VPERM2X128, dl, VT, V1,
7596                                 V2, getShuffleVPERM2X128Immediate(SVOp), DAG);
7597
7598   SDValue BlendOp = LowerVECTOR_SHUFFLEtoBlend(SVOp, Subtarget, DAG);
7599   if (BlendOp.getNode())
7600     return BlendOp;
7601
7602   unsigned Imm8;
7603   if (V2IsUndef && HasInt256 && isPermImmMask(M, VT, Imm8))
7604     return getTargetShuffleNode(X86ISD::VPERMI, dl, VT, V1, Imm8, DAG);
7605
7606   if ((V2IsUndef && HasInt256 && VT.is256BitVector() && NumElems == 8) ||
7607       VT.is512BitVector()) {
7608     MVT MaskEltVT = MVT::getIntegerVT(VT.getVectorElementType().getSizeInBits());
7609     MVT MaskVectorVT = MVT::getVectorVT(MaskEltVT, NumElems);
7610     SmallVector<SDValue, 16> permclMask;
7611     for (unsigned i = 0; i != NumElems; ++i) {
7612       permclMask.push_back(DAG.getConstant((M[i]>=0) ? M[i] : 0, MaskEltVT));
7613     }
7614
7615     SDValue Mask = DAG.getNode(ISD::BUILD_VECTOR, dl, MaskVectorVT,
7616                                 &permclMask[0], NumElems);
7617     if (V2IsUndef)
7618       // Bitcast is for VPERMPS since mask is v8i32 but node takes v8f32
7619       return DAG.getNode(X86ISD::VPERMV, dl, VT,
7620                           DAG.getNode(ISD::BITCAST, dl, VT, Mask), V1);
7621     return DAG.getNode(X86ISD::VPERMV3, dl, VT, V1,
7622                        DAG.getNode(ISD::BITCAST, dl, VT, Mask), V2);
7623   }
7624
7625   //===--------------------------------------------------------------------===//
7626   // Since no target specific shuffle was selected for this generic one,
7627   // lower it into other known shuffles. FIXME: this isn't true yet, but
7628   // this is the plan.
7629   //
7630
7631   // Handle v8i16 specifically since SSE can do byte extraction and insertion.
7632   if (VT == MVT::v8i16) {
7633     SDValue NewOp = LowerVECTOR_SHUFFLEv8i16(Op, Subtarget, DAG);
7634     if (NewOp.getNode())
7635       return NewOp;
7636   }
7637
7638   if (VT == MVT::v16i8) {
7639     SDValue NewOp = LowerVECTOR_SHUFFLEv16i8(SVOp, Subtarget, DAG);
7640     if (NewOp.getNode())
7641       return NewOp;
7642   }
7643
7644   if (VT == MVT::v32i8) {
7645     SDValue NewOp = LowerVECTOR_SHUFFLEv32i8(SVOp, Subtarget, DAG);
7646     if (NewOp.getNode())
7647       return NewOp;
7648   }
7649
7650   // Handle all 128-bit wide vectors with 4 elements, and match them with
7651   // several different shuffle types.
7652   if (NumElems == 4 && VT.is128BitVector())
7653     return LowerVECTOR_SHUFFLE_128v4(SVOp, DAG);
7654
7655   // Handle general 256-bit shuffles
7656   if (VT.is256BitVector())
7657     return LowerVECTOR_SHUFFLE_256(SVOp, DAG);
7658
7659   return SDValue();
7660 }
7661
7662 static SDValue LowerEXTRACT_VECTOR_ELT_SSE4(SDValue Op, SelectionDAG &DAG) {
7663   MVT VT = Op.getSimpleValueType();
7664   SDLoc dl(Op);
7665
7666   if (!Op.getOperand(0).getSimpleValueType().is128BitVector())
7667     return SDValue();
7668
7669   if (VT.getSizeInBits() == 8) {
7670     SDValue Extract = DAG.getNode(X86ISD::PEXTRB, dl, MVT::i32,
7671                                   Op.getOperand(0), Op.getOperand(1));
7672     SDValue Assert  = DAG.getNode(ISD::AssertZext, dl, MVT::i32, Extract,
7673                                   DAG.getValueType(VT));
7674     return DAG.getNode(ISD::TRUNCATE, dl, VT, Assert);
7675   }
7676
7677   if (VT.getSizeInBits() == 16) {
7678     unsigned Idx = cast<ConstantSDNode>(Op.getOperand(1))->getZExtValue();
7679     // If Idx is 0, it's cheaper to do a move instead of a pextrw.
7680     if (Idx == 0)
7681       return DAG.getNode(ISD::TRUNCATE, dl, MVT::i16,
7682                          DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, MVT::i32,
7683                                      DAG.getNode(ISD::BITCAST, dl,
7684                                                  MVT::v4i32,
7685                                                  Op.getOperand(0)),
7686                                      Op.getOperand(1)));
7687     SDValue Extract = DAG.getNode(X86ISD::PEXTRW, dl, MVT::i32,
7688                                   Op.getOperand(0), Op.getOperand(1));
7689     SDValue Assert  = DAG.getNode(ISD::AssertZext, dl, MVT::i32, Extract,
7690                                   DAG.getValueType(VT));
7691     return DAG.getNode(ISD::TRUNCATE, dl, VT, Assert);
7692   }
7693
7694   if (VT == MVT::f32) {
7695     // EXTRACTPS outputs to a GPR32 register which will require a movd to copy
7696     // the result back to FR32 register. It's only worth matching if the
7697     // result has a single use which is a store or a bitcast to i32.  And in
7698     // the case of a store, it's not worth it if the index is a constant 0,
7699     // because a MOVSSmr can be used instead, which is smaller and faster.
7700     if (!Op.hasOneUse())
7701       return SDValue();
7702     SDNode *User = *Op.getNode()->use_begin();
7703     if ((User->getOpcode() != ISD::STORE ||
7704          (isa<ConstantSDNode>(Op.getOperand(1)) &&
7705           cast<ConstantSDNode>(Op.getOperand(1))->isNullValue())) &&
7706         (User->getOpcode() != ISD::BITCAST ||
7707          User->getValueType(0) != MVT::i32))
7708       return SDValue();
7709     SDValue Extract = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, MVT::i32,
7710                                   DAG.getNode(ISD::BITCAST, dl, MVT::v4i32,
7711                                               Op.getOperand(0)),
7712                                               Op.getOperand(1));
7713     return DAG.getNode(ISD::BITCAST, dl, MVT::f32, Extract);
7714   }
7715
7716   if (VT == MVT::i32 || VT == MVT::i64) {
7717     // ExtractPS/pextrq works with constant index.
7718     if (isa<ConstantSDNode>(Op.getOperand(1)))
7719       return Op;
7720   }
7721   return SDValue();
7722 }
7723
7724 /// Extract one bit from mask vector, like v16i1 or v8i1.
7725 /// AVX-512 feature.
7726 SDValue
7727 X86TargetLowering::ExtractBitFromMaskVector(SDValue Op, SelectionDAG &DAG) const {
7728   SDValue Vec = Op.getOperand(0);
7729   SDLoc dl(Vec);
7730   MVT VecVT = Vec.getSimpleValueType();
7731   SDValue Idx = Op.getOperand(1);
7732   MVT EltVT = Op.getSimpleValueType();
7733
7734   assert((EltVT == MVT::i1) && "Unexpected operands in ExtractBitFromMaskVector");
7735
7736   // variable index can't be handled in mask registers,
7737   // extend vector to VR512
7738   if (!isa<ConstantSDNode>(Idx)) {
7739     MVT ExtVT = (VecVT == MVT::v8i1 ?  MVT::v8i64 : MVT::v16i32);
7740     SDValue Ext = DAG.getNode(ISD::ZERO_EXTEND, dl, ExtVT, Vec);
7741     SDValue Elt = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl,
7742                               ExtVT.getVectorElementType(), Ext, Idx);
7743     return DAG.getNode(ISD::TRUNCATE, dl, EltVT, Elt);
7744   }
7745
7746   unsigned IdxVal = cast<ConstantSDNode>(Idx)->getZExtValue();
7747   const TargetRegisterClass* rc = getRegClassFor(VecVT);
7748   unsigned MaxSift = rc->getSize()*8 - 1;
7749   Vec = DAG.getNode(X86ISD::VSHLI, dl, VecVT, Vec,
7750                     DAG.getConstant(MaxSift - IdxVal, MVT::i8));
7751   Vec = DAG.getNode(X86ISD::VSRLI, dl, VecVT, Vec,
7752                     DAG.getConstant(MaxSift, MVT::i8));
7753   return DAG.getNode(X86ISD::VEXTRACT, dl, MVT::i1, Vec,
7754                        DAG.getIntPtrConstant(0));
7755 }
7756
7757 SDValue
7758 X86TargetLowering::LowerEXTRACT_VECTOR_ELT(SDValue Op,
7759                                            SelectionDAG &DAG) const {
7760   SDLoc dl(Op);
7761   SDValue Vec = Op.getOperand(0);
7762   MVT VecVT = Vec.getSimpleValueType();
7763   SDValue Idx = Op.getOperand(1);
7764
7765   if (Op.getSimpleValueType() == MVT::i1)
7766     return ExtractBitFromMaskVector(Op, DAG);
7767
7768   if (!isa<ConstantSDNode>(Idx)) {
7769     if (VecVT.is512BitVector() ||
7770         (VecVT.is256BitVector() && Subtarget->hasInt256() &&
7771          VecVT.getVectorElementType().getSizeInBits() == 32)) {
7772
7773       MVT MaskEltVT =
7774         MVT::getIntegerVT(VecVT.getVectorElementType().getSizeInBits());
7775       MVT MaskVT = MVT::getVectorVT(MaskEltVT, VecVT.getSizeInBits() /
7776                                     MaskEltVT.getSizeInBits());
7777
7778       Idx = DAG.getZExtOrTrunc(Idx, dl, MaskEltVT);
7779       SDValue Mask = DAG.getNode(X86ISD::VINSERT, dl, MaskVT,
7780                                 getZeroVector(MaskVT, Subtarget, DAG, dl),
7781                                 Idx, DAG.getConstant(0, getPointerTy()));
7782       SDValue Perm = DAG.getNode(X86ISD::VPERMV, dl, VecVT, Mask, Vec);
7783       return DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, Op.getValueType(),
7784                         Perm, DAG.getConstant(0, getPointerTy()));
7785     }
7786     return SDValue();
7787   }
7788
7789   // If this is a 256-bit vector result, first extract the 128-bit vector and
7790   // then extract the element from the 128-bit vector.
7791   if (VecVT.is256BitVector() || VecVT.is512BitVector()) {
7792
7793     unsigned IdxVal = cast<ConstantSDNode>(Idx)->getZExtValue();
7794     // Get the 128-bit vector.
7795     Vec = Extract128BitVector(Vec, IdxVal, DAG, dl);
7796     MVT EltVT = VecVT.getVectorElementType();
7797
7798     unsigned ElemsPerChunk = 128 / EltVT.getSizeInBits();
7799
7800     //if (IdxVal >= NumElems/2)
7801     //  IdxVal -= NumElems/2;
7802     IdxVal -= (IdxVal/ElemsPerChunk)*ElemsPerChunk;
7803     return DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, Op.getValueType(), Vec,
7804                        DAG.getConstant(IdxVal, MVT::i32));
7805   }
7806
7807   assert(VecVT.is128BitVector() && "Unexpected vector length");
7808
7809   if (Subtarget->hasSSE41()) {
7810     SDValue Res = LowerEXTRACT_VECTOR_ELT_SSE4(Op, DAG);
7811     if (Res.getNode())
7812       return Res;
7813   }
7814
7815   MVT VT = Op.getSimpleValueType();
7816   // TODO: handle v16i8.
7817   if (VT.getSizeInBits() == 16) {
7818     SDValue Vec = Op.getOperand(0);
7819     unsigned Idx = cast<ConstantSDNode>(Op.getOperand(1))->getZExtValue();
7820     if (Idx == 0)
7821       return DAG.getNode(ISD::TRUNCATE, dl, MVT::i16,
7822                          DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, MVT::i32,
7823                                      DAG.getNode(ISD::BITCAST, dl,
7824                                                  MVT::v4i32, Vec),
7825                                      Op.getOperand(1)));
7826     // Transform it so it match pextrw which produces a 32-bit result.
7827     MVT EltVT = MVT::i32;
7828     SDValue Extract = DAG.getNode(X86ISD::PEXTRW, dl, EltVT,
7829                                   Op.getOperand(0), Op.getOperand(1));
7830     SDValue Assert  = DAG.getNode(ISD::AssertZext, dl, EltVT, Extract,
7831                                   DAG.getValueType(VT));
7832     return DAG.getNode(ISD::TRUNCATE, dl, VT, Assert);
7833   }
7834
7835   if (VT.getSizeInBits() == 32) {
7836     unsigned Idx = cast<ConstantSDNode>(Op.getOperand(1))->getZExtValue();
7837     if (Idx == 0)
7838       return Op;
7839
7840     // SHUFPS the element to the lowest double word, then movss.
7841     int Mask[4] = { static_cast<int>(Idx), -1, -1, -1 };
7842     MVT VVT = Op.getOperand(0).getSimpleValueType();
7843     SDValue Vec = DAG.getVectorShuffle(VVT, dl, Op.getOperand(0),
7844                                        DAG.getUNDEF(VVT), Mask);
7845     return DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, VT, Vec,
7846                        DAG.getIntPtrConstant(0));
7847   }
7848
7849   if (VT.getSizeInBits() == 64) {
7850     // FIXME: .td only matches this for <2 x f64>, not <2 x i64> on 32b
7851     // FIXME: seems like this should be unnecessary if mov{h,l}pd were taught
7852     //        to match extract_elt for f64.
7853     unsigned Idx = cast<ConstantSDNode>(Op.getOperand(1))->getZExtValue();
7854     if (Idx == 0)
7855       return Op;
7856
7857     // UNPCKHPD the element to the lowest double word, then movsd.
7858     // Note if the lower 64 bits of the result of the UNPCKHPD is then stored
7859     // to a f64mem, the whole operation is folded into a single MOVHPDmr.
7860     int Mask[2] = { 1, -1 };
7861     MVT VVT = Op.getOperand(0).getSimpleValueType();
7862     SDValue Vec = DAG.getVectorShuffle(VVT, dl, Op.getOperand(0),
7863                                        DAG.getUNDEF(VVT), Mask);
7864     return DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, VT, Vec,
7865                        DAG.getIntPtrConstant(0));
7866   }
7867
7868   return SDValue();
7869 }
7870
7871 static SDValue LowerINSERT_VECTOR_ELT_SSE4(SDValue Op, SelectionDAG &DAG) {
7872   MVT VT = Op.getSimpleValueType();
7873   MVT EltVT = VT.getVectorElementType();
7874   SDLoc dl(Op);
7875
7876   SDValue N0 = Op.getOperand(0);
7877   SDValue N1 = Op.getOperand(1);
7878   SDValue N2 = Op.getOperand(2);
7879
7880   if (!VT.is128BitVector())
7881     return SDValue();
7882
7883   if ((EltVT.getSizeInBits() == 8 || EltVT.getSizeInBits() == 16) &&
7884       isa<ConstantSDNode>(N2)) {
7885     unsigned Opc;
7886     if (VT == MVT::v8i16)
7887       Opc = X86ISD::PINSRW;
7888     else if (VT == MVT::v16i8)
7889       Opc = X86ISD::PINSRB;
7890     else
7891       Opc = X86ISD::PINSRB;
7892
7893     // Transform it so it match pinsr{b,w} which expects a GR32 as its second
7894     // argument.
7895     if (N1.getValueType() != MVT::i32)
7896       N1 = DAG.getNode(ISD::ANY_EXTEND, dl, MVT::i32, N1);
7897     if (N2.getValueType() != MVT::i32)
7898       N2 = DAG.getIntPtrConstant(cast<ConstantSDNode>(N2)->getZExtValue());
7899     return DAG.getNode(Opc, dl, VT, N0, N1, N2);
7900   }
7901
7902   if (EltVT == MVT::f32 && isa<ConstantSDNode>(N2)) {
7903     // Bits [7:6] of the constant are the source select.  This will always be
7904     //  zero here.  The DAG Combiner may combine an extract_elt index into these
7905     //  bits.  For example (insert (extract, 3), 2) could be matched by putting
7906     //  the '3' into bits [7:6] of X86ISD::INSERTPS.
7907     // Bits [5:4] of the constant are the destination select.  This is the
7908     //  value of the incoming immediate.
7909     // Bits [3:0] of the constant are the zero mask.  The DAG Combiner may
7910     //   combine either bitwise AND or insert of float 0.0 to set these bits.
7911     N2 = DAG.getIntPtrConstant(cast<ConstantSDNode>(N2)->getZExtValue() << 4);
7912     // Create this as a scalar to vector..
7913     N1 = DAG.getNode(ISD::SCALAR_TO_VECTOR, dl, MVT::v4f32, N1);
7914     return DAG.getNode(X86ISD::INSERTPS, dl, VT, N0, N1, N2);
7915   }
7916
7917   if ((EltVT == MVT::i32 || EltVT == MVT::i64) && isa<ConstantSDNode>(N2)) {
7918     // PINSR* works with constant index.
7919     return Op;
7920   }
7921   return SDValue();
7922 }
7923
7924 SDValue
7925 X86TargetLowering::LowerINSERT_VECTOR_ELT(SDValue Op, SelectionDAG &DAG) const {
7926   MVT VT = Op.getSimpleValueType();
7927   MVT EltVT = VT.getVectorElementType();
7928
7929   SDLoc dl(Op);
7930   SDValue N0 = Op.getOperand(0);
7931   SDValue N1 = Op.getOperand(1);
7932   SDValue N2 = Op.getOperand(2);
7933
7934   // If this is a 256-bit vector result, first extract the 128-bit vector,
7935   // insert the element into the extracted half and then place it back.
7936   if (VT.is256BitVector() || VT.is512BitVector()) {
7937     if (!isa<ConstantSDNode>(N2))
7938       return SDValue();
7939
7940     // Get the desired 128-bit vector half.
7941     unsigned IdxVal = cast<ConstantSDNode>(N2)->getZExtValue();
7942     SDValue V = Extract128BitVector(N0, IdxVal, DAG, dl);
7943
7944     // Insert the element into the desired half.
7945     unsigned NumEltsIn128 = 128/EltVT.getSizeInBits();
7946     unsigned IdxIn128 = IdxVal - (IdxVal/NumEltsIn128) * NumEltsIn128;
7947
7948     V = DAG.getNode(ISD::INSERT_VECTOR_ELT, dl, V.getValueType(), V, N1,
7949                     DAG.getConstant(IdxIn128, MVT::i32));
7950
7951     // Insert the changed part back to the 256-bit vector
7952     return Insert128BitVector(N0, V, IdxVal, DAG, dl);
7953   }
7954
7955   if (Subtarget->hasSSE41())
7956     return LowerINSERT_VECTOR_ELT_SSE4(Op, DAG);
7957
7958   if (EltVT == MVT::i8)
7959     return SDValue();
7960
7961   if (EltVT.getSizeInBits() == 16 && isa<ConstantSDNode>(N2)) {
7962     // Transform it so it match pinsrw which expects a 16-bit value in a GR32
7963     // as its second argument.
7964     if (N1.getValueType() != MVT::i32)
7965       N1 = DAG.getNode(ISD::ANY_EXTEND, dl, MVT::i32, N1);
7966     if (N2.getValueType() != MVT::i32)
7967       N2 = DAG.getIntPtrConstant(cast<ConstantSDNode>(N2)->getZExtValue());
7968     return DAG.getNode(X86ISD::PINSRW, dl, VT, N0, N1, N2);
7969   }
7970   return SDValue();
7971 }
7972
7973 static SDValue LowerSCALAR_TO_VECTOR(SDValue Op, SelectionDAG &DAG) {
7974   SDLoc dl(Op);
7975   MVT OpVT = Op.getSimpleValueType();
7976
7977   // If this is a 256-bit vector result, first insert into a 128-bit
7978   // vector and then insert into the 256-bit vector.
7979   if (!OpVT.is128BitVector()) {
7980     // Insert into a 128-bit vector.
7981     unsigned SizeFactor = OpVT.getSizeInBits()/128;
7982     MVT VT128 = MVT::getVectorVT(OpVT.getVectorElementType(),
7983                                  OpVT.getVectorNumElements() / SizeFactor);
7984
7985     Op = DAG.getNode(ISD::SCALAR_TO_VECTOR, dl, VT128, Op.getOperand(0));
7986
7987     // Insert the 128-bit vector.
7988     return Insert128BitVector(DAG.getUNDEF(OpVT), Op, 0, DAG, dl);
7989   }
7990
7991   if (OpVT == MVT::v1i64 &&
7992       Op.getOperand(0).getValueType() == MVT::i64)
7993     return DAG.getNode(ISD::SCALAR_TO_VECTOR, dl, MVT::v1i64, Op.getOperand(0));
7994
7995   SDValue AnyExt = DAG.getNode(ISD::ANY_EXTEND, dl, MVT::i32, Op.getOperand(0));
7996   assert(OpVT.is128BitVector() && "Expected an SSE type!");
7997   return DAG.getNode(ISD::BITCAST, dl, OpVT,
7998                      DAG.getNode(ISD::SCALAR_TO_VECTOR, dl, MVT::v4i32,AnyExt));
7999 }
8000
8001 // Lower a node with an EXTRACT_SUBVECTOR opcode.  This may result in
8002 // a simple subregister reference or explicit instructions to grab
8003 // upper bits of a vector.
8004 static SDValue LowerEXTRACT_SUBVECTOR(SDValue Op, const X86Subtarget *Subtarget,
8005                                       SelectionDAG &DAG) {
8006   SDLoc dl(Op);
8007   SDValue In =  Op.getOperand(0);
8008   SDValue Idx = Op.getOperand(1);
8009   unsigned IdxVal = cast<ConstantSDNode>(Idx)->getZExtValue();
8010   MVT ResVT   = Op.getSimpleValueType();
8011   MVT InVT    = In.getSimpleValueType();
8012
8013   if (Subtarget->hasFp256()) {
8014     if (ResVT.is128BitVector() &&
8015         (InVT.is256BitVector() || InVT.is512BitVector()) &&
8016         isa<ConstantSDNode>(Idx)) {
8017       return Extract128BitVector(In, IdxVal, DAG, dl);
8018     }
8019     if (ResVT.is256BitVector() && InVT.is512BitVector() &&
8020         isa<ConstantSDNode>(Idx)) {
8021       return Extract256BitVector(In, IdxVal, DAG, dl);
8022     }
8023   }
8024   return SDValue();
8025 }
8026
8027 // Lower a node with an INSERT_SUBVECTOR opcode.  This may result in a
8028 // simple superregister reference or explicit instructions to insert
8029 // the upper bits of a vector.
8030 static SDValue LowerINSERT_SUBVECTOR(SDValue Op, const X86Subtarget *Subtarget,
8031                                      SelectionDAG &DAG) {
8032   if (Subtarget->hasFp256()) {
8033     SDLoc dl(Op.getNode());
8034     SDValue Vec = Op.getNode()->getOperand(0);
8035     SDValue SubVec = Op.getNode()->getOperand(1);
8036     SDValue Idx = Op.getNode()->getOperand(2);
8037
8038     if ((Op.getNode()->getSimpleValueType(0).is256BitVector() ||
8039          Op.getNode()->getSimpleValueType(0).is512BitVector()) &&
8040         SubVec.getNode()->getSimpleValueType(0).is128BitVector() &&
8041         isa<ConstantSDNode>(Idx)) {
8042       unsigned IdxVal = cast<ConstantSDNode>(Idx)->getZExtValue();
8043       return Insert128BitVector(Vec, SubVec, IdxVal, DAG, dl);
8044     }
8045
8046     if (Op.getNode()->getSimpleValueType(0).is512BitVector() &&
8047         SubVec.getNode()->getSimpleValueType(0).is256BitVector() &&
8048         isa<ConstantSDNode>(Idx)) {
8049       unsigned IdxVal = cast<ConstantSDNode>(Idx)->getZExtValue();
8050       return Insert256BitVector(Vec, SubVec, IdxVal, DAG, dl);
8051     }
8052   }
8053   return SDValue();
8054 }
8055
8056 // ConstantPool, JumpTable, GlobalAddress, and ExternalSymbol are lowered as
8057 // their target countpart wrapped in the X86ISD::Wrapper node. Suppose N is
8058 // one of the above mentioned nodes. It has to be wrapped because otherwise
8059 // Select(N) returns N. So the raw TargetGlobalAddress nodes, etc. can only
8060 // be used to form addressing mode. These wrapped nodes will be selected
8061 // into MOV32ri.
8062 SDValue
8063 X86TargetLowering::LowerConstantPool(SDValue Op, SelectionDAG &DAG) const {
8064   ConstantPoolSDNode *CP = cast<ConstantPoolSDNode>(Op);
8065
8066   // In PIC mode (unless we're in RIPRel PIC mode) we add an offset to the
8067   // global base reg.
8068   unsigned char OpFlag = 0;
8069   unsigned WrapperKind = X86ISD::Wrapper;
8070   CodeModel::Model M = getTargetMachine().getCodeModel();
8071
8072   if (Subtarget->isPICStyleRIPRel() &&
8073       (M == CodeModel::Small || M == CodeModel::Kernel))
8074     WrapperKind = X86ISD::WrapperRIP;
8075   else if (Subtarget->isPICStyleGOT())
8076     OpFlag = X86II::MO_GOTOFF;
8077   else if (Subtarget->isPICStyleStubPIC())
8078     OpFlag = X86II::MO_PIC_BASE_OFFSET;
8079
8080   SDValue Result = DAG.getTargetConstantPool(CP->getConstVal(), getPointerTy(),
8081                                              CP->getAlignment(),
8082                                              CP->getOffset(), OpFlag);
8083   SDLoc DL(CP);
8084   Result = DAG.getNode(WrapperKind, DL, getPointerTy(), Result);
8085   // With PIC, the address is actually $g + Offset.
8086   if (OpFlag) {
8087     Result = DAG.getNode(ISD::ADD, DL, getPointerTy(),
8088                          DAG.getNode(X86ISD::GlobalBaseReg,
8089                                      SDLoc(), getPointerTy()),
8090                          Result);
8091   }
8092
8093   return Result;
8094 }
8095
8096 SDValue X86TargetLowering::LowerJumpTable(SDValue Op, SelectionDAG &DAG) const {
8097   JumpTableSDNode *JT = cast<JumpTableSDNode>(Op);
8098
8099   // In PIC mode (unless we're in RIPRel PIC mode) we add an offset to the
8100   // global base reg.
8101   unsigned char OpFlag = 0;
8102   unsigned WrapperKind = X86ISD::Wrapper;
8103   CodeModel::Model M = getTargetMachine().getCodeModel();
8104
8105   if (Subtarget->isPICStyleRIPRel() &&
8106       (M == CodeModel::Small || M == CodeModel::Kernel))
8107     WrapperKind = X86ISD::WrapperRIP;
8108   else if (Subtarget->isPICStyleGOT())
8109     OpFlag = X86II::MO_GOTOFF;
8110   else if (Subtarget->isPICStyleStubPIC())
8111     OpFlag = X86II::MO_PIC_BASE_OFFSET;
8112
8113   SDValue Result = DAG.getTargetJumpTable(JT->getIndex(), getPointerTy(),
8114                                           OpFlag);
8115   SDLoc DL(JT);
8116   Result = DAG.getNode(WrapperKind, DL, getPointerTy(), Result);
8117
8118   // With PIC, the address is actually $g + Offset.
8119   if (OpFlag)
8120     Result = DAG.getNode(ISD::ADD, DL, getPointerTy(),
8121                          DAG.getNode(X86ISD::GlobalBaseReg,
8122                                      SDLoc(), getPointerTy()),
8123                          Result);
8124
8125   return Result;
8126 }
8127
8128 SDValue
8129 X86TargetLowering::LowerExternalSymbol(SDValue Op, SelectionDAG &DAG) const {
8130   const char *Sym = cast<ExternalSymbolSDNode>(Op)->getSymbol();
8131
8132   // In PIC mode (unless we're in RIPRel PIC mode) we add an offset to the
8133   // global base reg.
8134   unsigned char OpFlag = 0;
8135   unsigned WrapperKind = X86ISD::Wrapper;
8136   CodeModel::Model M = getTargetMachine().getCodeModel();
8137
8138   if (Subtarget->isPICStyleRIPRel() &&
8139       (M == CodeModel::Small || M == CodeModel::Kernel)) {
8140     if (Subtarget->isTargetDarwin() || Subtarget->isTargetELF())
8141       OpFlag = X86II::MO_GOTPCREL;
8142     WrapperKind = X86ISD::WrapperRIP;
8143   } else if (Subtarget->isPICStyleGOT()) {
8144     OpFlag = X86II::MO_GOT;
8145   } else if (Subtarget->isPICStyleStubPIC()) {
8146     OpFlag = X86II::MO_DARWIN_NONLAZY_PIC_BASE;
8147   } else if (Subtarget->isPICStyleStubNoDynamic()) {
8148     OpFlag = X86II::MO_DARWIN_NONLAZY;
8149   }
8150
8151   SDValue Result = DAG.getTargetExternalSymbol(Sym, getPointerTy(), OpFlag);
8152
8153   SDLoc DL(Op);
8154   Result = DAG.getNode(WrapperKind, DL, getPointerTy(), Result);
8155
8156   // With PIC, the address is actually $g + Offset.
8157   if (getTargetMachine().getRelocationModel() == Reloc::PIC_ &&
8158       !Subtarget->is64Bit()) {
8159     Result = DAG.getNode(ISD::ADD, DL, getPointerTy(),
8160                          DAG.getNode(X86ISD::GlobalBaseReg,
8161                                      SDLoc(), getPointerTy()),
8162                          Result);
8163   }
8164
8165   // For symbols that require a load from a stub to get the address, emit the
8166   // load.
8167   if (isGlobalStubReference(OpFlag))
8168     Result = DAG.getLoad(getPointerTy(), DL, DAG.getEntryNode(), Result,
8169                          MachinePointerInfo::getGOT(), false, false, false, 0);
8170
8171   return Result;
8172 }
8173
8174 SDValue
8175 X86TargetLowering::LowerBlockAddress(SDValue Op, SelectionDAG &DAG) const {
8176   // Create the TargetBlockAddressAddress node.
8177   unsigned char OpFlags =
8178     Subtarget->ClassifyBlockAddressReference();
8179   CodeModel::Model M = getTargetMachine().getCodeModel();
8180   const BlockAddress *BA = cast<BlockAddressSDNode>(Op)->getBlockAddress();
8181   int64_t Offset = cast<BlockAddressSDNode>(Op)->getOffset();
8182   SDLoc dl(Op);
8183   SDValue Result = DAG.getTargetBlockAddress(BA, getPointerTy(), Offset,
8184                                              OpFlags);
8185
8186   if (Subtarget->isPICStyleRIPRel() &&
8187       (M == CodeModel::Small || M == CodeModel::Kernel))
8188     Result = DAG.getNode(X86ISD::WrapperRIP, dl, getPointerTy(), Result);
8189   else
8190     Result = DAG.getNode(X86ISD::Wrapper, dl, getPointerTy(), Result);
8191
8192   // With PIC, the address is actually $g + Offset.
8193   if (isGlobalRelativeToPICBase(OpFlags)) {
8194     Result = DAG.getNode(ISD::ADD, dl, getPointerTy(),
8195                          DAG.getNode(X86ISD::GlobalBaseReg, dl, getPointerTy()),
8196                          Result);
8197   }
8198
8199   return Result;
8200 }
8201
8202 SDValue
8203 X86TargetLowering::LowerGlobalAddress(const GlobalValue *GV, SDLoc dl,
8204                                       int64_t Offset, SelectionDAG &DAG) const {
8205   // Create the TargetGlobalAddress node, folding in the constant
8206   // offset if it is legal.
8207   unsigned char OpFlags =
8208     Subtarget->ClassifyGlobalReference(GV, getTargetMachine());
8209   CodeModel::Model M = getTargetMachine().getCodeModel();
8210   SDValue Result;
8211   if (OpFlags == X86II::MO_NO_FLAG &&
8212       X86::isOffsetSuitableForCodeModel(Offset, M)) {
8213     // A direct static reference to a global.
8214     Result = DAG.getTargetGlobalAddress(GV, dl, getPointerTy(), Offset);
8215     Offset = 0;
8216   } else {
8217     Result = DAG.getTargetGlobalAddress(GV, dl, getPointerTy(), 0, OpFlags);
8218   }
8219
8220   if (Subtarget->isPICStyleRIPRel() &&
8221       (M == CodeModel::Small || M == CodeModel::Kernel))
8222     Result = DAG.getNode(X86ISD::WrapperRIP, dl, getPointerTy(), Result);
8223   else
8224     Result = DAG.getNode(X86ISD::Wrapper, dl, getPointerTy(), Result);
8225
8226   // With PIC, the address is actually $g + Offset.
8227   if (isGlobalRelativeToPICBase(OpFlags)) {
8228     Result = DAG.getNode(ISD::ADD, dl, getPointerTy(),
8229                          DAG.getNode(X86ISD::GlobalBaseReg, dl, getPointerTy()),
8230                          Result);
8231   }
8232
8233   // For globals that require a load from a stub to get the address, emit the
8234   // load.
8235   if (isGlobalStubReference(OpFlags))
8236     Result = DAG.getLoad(getPointerTy(), dl, DAG.getEntryNode(), Result,
8237                          MachinePointerInfo::getGOT(), false, false, false, 0);
8238
8239   // If there was a non-zero offset that we didn't fold, create an explicit
8240   // addition for it.
8241   if (Offset != 0)
8242     Result = DAG.getNode(ISD::ADD, dl, getPointerTy(), Result,
8243                          DAG.getConstant(Offset, getPointerTy()));
8244
8245   return Result;
8246 }
8247
8248 SDValue
8249 X86TargetLowering::LowerGlobalAddress(SDValue Op, SelectionDAG &DAG) const {
8250   const GlobalValue *GV = cast<GlobalAddressSDNode>(Op)->getGlobal();
8251   int64_t Offset = cast<GlobalAddressSDNode>(Op)->getOffset();
8252   return LowerGlobalAddress(GV, SDLoc(Op), Offset, DAG);
8253 }
8254
8255 static SDValue
8256 GetTLSADDR(SelectionDAG &DAG, SDValue Chain, GlobalAddressSDNode *GA,
8257            SDValue *InFlag, const EVT PtrVT, unsigned ReturnReg,
8258            unsigned char OperandFlags, bool LocalDynamic = false) {
8259   MachineFrameInfo *MFI = DAG.getMachineFunction().getFrameInfo();
8260   SDVTList NodeTys = DAG.getVTList(MVT::Other, MVT::Glue);
8261   SDLoc dl(GA);
8262   SDValue TGA = DAG.getTargetGlobalAddress(GA->getGlobal(), dl,
8263                                            GA->getValueType(0),
8264                                            GA->getOffset(),
8265                                            OperandFlags);
8266
8267   X86ISD::NodeType CallType = LocalDynamic ? X86ISD::TLSBASEADDR
8268                                            : X86ISD::TLSADDR;
8269
8270   if (InFlag) {
8271     SDValue Ops[] = { Chain,  TGA, *InFlag };
8272     Chain = DAG.getNode(CallType, dl, NodeTys, Ops, array_lengthof(Ops));
8273   } else {
8274     SDValue Ops[]  = { Chain, TGA };
8275     Chain = DAG.getNode(CallType, dl, NodeTys, Ops, array_lengthof(Ops));
8276   }
8277
8278   // TLSADDR will be codegen'ed as call. Inform MFI that function has calls.
8279   MFI->setAdjustsStack(true);
8280
8281   SDValue Flag = Chain.getValue(1);
8282   return DAG.getCopyFromReg(Chain, dl, ReturnReg, PtrVT, Flag);
8283 }
8284
8285 // Lower ISD::GlobalTLSAddress using the "general dynamic" model, 32 bit
8286 static SDValue
8287 LowerToTLSGeneralDynamicModel32(GlobalAddressSDNode *GA, SelectionDAG &DAG,
8288                                 const EVT PtrVT) {
8289   SDValue InFlag;
8290   SDLoc dl(GA);  // ? function entry point might be better
8291   SDValue Chain = DAG.getCopyToReg(DAG.getEntryNode(), dl, X86::EBX,
8292                                    DAG.getNode(X86ISD::GlobalBaseReg,
8293                                                SDLoc(), PtrVT), InFlag);
8294   InFlag = Chain.getValue(1);
8295
8296   return GetTLSADDR(DAG, Chain, GA, &InFlag, PtrVT, X86::EAX, X86II::MO_TLSGD);
8297 }
8298
8299 // Lower ISD::GlobalTLSAddress using the "general dynamic" model, 64 bit
8300 static SDValue
8301 LowerToTLSGeneralDynamicModel64(GlobalAddressSDNode *GA, SelectionDAG &DAG,
8302                                 const EVT PtrVT) {
8303   return GetTLSADDR(DAG, DAG.getEntryNode(), GA, NULL, PtrVT,
8304                     X86::RAX, X86II::MO_TLSGD);
8305 }
8306
8307 static SDValue LowerToTLSLocalDynamicModel(GlobalAddressSDNode *GA,
8308                                            SelectionDAG &DAG,
8309                                            const EVT PtrVT,
8310                                            bool is64Bit) {
8311   SDLoc dl(GA);
8312
8313   // Get the start address of the TLS block for this module.
8314   X86MachineFunctionInfo* MFI = DAG.getMachineFunction()
8315       .getInfo<X86MachineFunctionInfo>();
8316   MFI->incNumLocalDynamicTLSAccesses();
8317
8318   SDValue Base;
8319   if (is64Bit) {
8320     Base = GetTLSADDR(DAG, DAG.getEntryNode(), GA, NULL, PtrVT, X86::RAX,
8321                       X86II::MO_TLSLD, /*LocalDynamic=*/true);
8322   } else {
8323     SDValue InFlag;
8324     SDValue Chain = DAG.getCopyToReg(DAG.getEntryNode(), dl, X86::EBX,
8325         DAG.getNode(X86ISD::GlobalBaseReg, SDLoc(), PtrVT), InFlag);
8326     InFlag = Chain.getValue(1);
8327     Base = GetTLSADDR(DAG, Chain, GA, &InFlag, PtrVT, X86::EAX,
8328                       X86II::MO_TLSLDM, /*LocalDynamic=*/true);
8329   }
8330
8331   // Note: the CleanupLocalDynamicTLSPass will remove redundant computations
8332   // of Base.
8333
8334   // Build x@dtpoff.
8335   unsigned char OperandFlags = X86II::MO_DTPOFF;
8336   unsigned WrapperKind = X86ISD::Wrapper;
8337   SDValue TGA = DAG.getTargetGlobalAddress(GA->getGlobal(), dl,
8338                                            GA->getValueType(0),
8339                                            GA->getOffset(), OperandFlags);
8340   SDValue Offset = DAG.getNode(WrapperKind, dl, PtrVT, TGA);
8341
8342   // Add x@dtpoff with the base.
8343   return DAG.getNode(ISD::ADD, dl, PtrVT, Offset, Base);
8344 }
8345
8346 // Lower ISD::GlobalTLSAddress using the "initial exec" or "local exec" model.
8347 static SDValue LowerToTLSExecModel(GlobalAddressSDNode *GA, SelectionDAG &DAG,
8348                                    const EVT PtrVT, TLSModel::Model model,
8349                                    bool is64Bit, bool isPIC) {
8350   SDLoc dl(GA);
8351
8352   // Get the Thread Pointer, which is %gs:0 (32-bit) or %fs:0 (64-bit).
8353   Value *Ptr = Constant::getNullValue(Type::getInt8PtrTy(*DAG.getContext(),
8354                                                          is64Bit ? 257 : 256));
8355
8356   SDValue ThreadPointer =
8357       DAG.getLoad(PtrVT, dl, DAG.getEntryNode(), DAG.getIntPtrConstant(0),
8358                   MachinePointerInfo(Ptr), false, false, false, 0);
8359
8360   unsigned char OperandFlags = 0;
8361   // Most TLS accesses are not RIP relative, even on x86-64.  One exception is
8362   // initialexec.
8363   unsigned WrapperKind = X86ISD::Wrapper;
8364   if (model == TLSModel::LocalExec) {
8365     OperandFlags = is64Bit ? X86II::MO_TPOFF : X86II::MO_NTPOFF;
8366   } else if (model == TLSModel::InitialExec) {
8367     if (is64Bit) {
8368       OperandFlags = X86II::MO_GOTTPOFF;
8369       WrapperKind = X86ISD::WrapperRIP;
8370     } else {
8371       OperandFlags = isPIC ? X86II::MO_GOTNTPOFF : X86II::MO_INDNTPOFF;
8372     }
8373   } else {
8374     llvm_unreachable("Unexpected model");
8375   }
8376
8377   // emit "addl x@ntpoff,%eax" (local exec)
8378   // or "addl x@indntpoff,%eax" (initial exec)
8379   // or "addl x@gotntpoff(%ebx) ,%eax" (initial exec, 32-bit pic)
8380   SDValue TGA =
8381       DAG.getTargetGlobalAddress(GA->getGlobal(), dl, GA->getValueType(0),
8382                                  GA->getOffset(), OperandFlags);
8383   SDValue Offset = DAG.getNode(WrapperKind, dl, PtrVT, TGA);
8384
8385   if (model == TLSModel::InitialExec) {
8386     if (isPIC && !is64Bit) {
8387       Offset = DAG.getNode(ISD::ADD, dl, PtrVT,
8388                            DAG.getNode(X86ISD::GlobalBaseReg, SDLoc(), PtrVT),
8389                            Offset);
8390     }
8391
8392     Offset = DAG.getLoad(PtrVT, dl, DAG.getEntryNode(), Offset,
8393                          MachinePointerInfo::getGOT(), false, false, false, 0);
8394   }
8395
8396   // The address of the thread local variable is the add of the thread
8397   // pointer with the offset of the variable.
8398   return DAG.getNode(ISD::ADD, dl, PtrVT, ThreadPointer, Offset);
8399 }
8400
8401 SDValue
8402 X86TargetLowering::LowerGlobalTLSAddress(SDValue Op, SelectionDAG &DAG) const {
8403
8404   GlobalAddressSDNode *GA = cast<GlobalAddressSDNode>(Op);
8405   const GlobalValue *GV = GA->getGlobal();
8406
8407   if (Subtarget->isTargetELF()) {
8408     TLSModel::Model model = getTargetMachine().getTLSModel(GV);
8409
8410     switch (model) {
8411       case TLSModel::GeneralDynamic:
8412         if (Subtarget->is64Bit())
8413           return LowerToTLSGeneralDynamicModel64(GA, DAG, getPointerTy());
8414         return LowerToTLSGeneralDynamicModel32(GA, DAG, getPointerTy());
8415       case TLSModel::LocalDynamic:
8416         return LowerToTLSLocalDynamicModel(GA, DAG, getPointerTy(),
8417                                            Subtarget->is64Bit());
8418       case TLSModel::InitialExec:
8419       case TLSModel::LocalExec:
8420         return LowerToTLSExecModel(GA, DAG, getPointerTy(), model,
8421                                    Subtarget->is64Bit(),
8422                         getTargetMachine().getRelocationModel() == Reloc::PIC_);
8423     }
8424     llvm_unreachable("Unknown TLS model.");
8425   }
8426
8427   if (Subtarget->isTargetDarwin()) {
8428     // Darwin only has one model of TLS.  Lower to that.
8429     unsigned char OpFlag = 0;
8430     unsigned WrapperKind = Subtarget->isPICStyleRIPRel() ?
8431                            X86ISD::WrapperRIP : X86ISD::Wrapper;
8432
8433     // In PIC mode (unless we're in RIPRel PIC mode) we add an offset to the
8434     // global base reg.
8435     bool PIC32 = (getTargetMachine().getRelocationModel() == Reloc::PIC_) &&
8436                   !Subtarget->is64Bit();
8437     if (PIC32)
8438       OpFlag = X86II::MO_TLVP_PIC_BASE;
8439     else
8440       OpFlag = X86II::MO_TLVP;
8441     SDLoc DL(Op);
8442     SDValue Result = DAG.getTargetGlobalAddress(GA->getGlobal(), DL,
8443                                                 GA->getValueType(0),
8444                                                 GA->getOffset(), OpFlag);
8445     SDValue Offset = DAG.getNode(WrapperKind, DL, getPointerTy(), Result);
8446
8447     // With PIC32, the address is actually $g + Offset.
8448     if (PIC32)
8449       Offset = DAG.getNode(ISD::ADD, DL, getPointerTy(),
8450                            DAG.getNode(X86ISD::GlobalBaseReg,
8451                                        SDLoc(), getPointerTy()),
8452                            Offset);
8453
8454     // Lowering the machine isd will make sure everything is in the right
8455     // location.
8456     SDValue Chain = DAG.getEntryNode();
8457     SDVTList NodeTys = DAG.getVTList(MVT::Other, MVT::Glue);
8458     SDValue Args[] = { Chain, Offset };
8459     Chain = DAG.getNode(X86ISD::TLSCALL, DL, NodeTys, Args, 2);
8460
8461     // TLSCALL will be codegen'ed as call. Inform MFI that function has calls.
8462     MachineFrameInfo *MFI = DAG.getMachineFunction().getFrameInfo();
8463     MFI->setAdjustsStack(true);
8464
8465     // And our return value (tls address) is in the standard call return value
8466     // location.
8467     unsigned Reg = Subtarget->is64Bit() ? X86::RAX : X86::EAX;
8468     return DAG.getCopyFromReg(Chain, DL, Reg, getPointerTy(),
8469                               Chain.getValue(1));
8470   }
8471
8472   if (Subtarget->isTargetWindows() || Subtarget->isTargetMingw()) {
8473     // Just use the implicit TLS architecture
8474     // Need to generate someting similar to:
8475     //   mov     rdx, qword [gs:abs 58H]; Load pointer to ThreadLocalStorage
8476     //                                  ; from TEB
8477     //   mov     ecx, dword [rel _tls_index]: Load index (from C runtime)
8478     //   mov     rcx, qword [rdx+rcx*8]
8479     //   mov     eax, .tls$:tlsvar
8480     //   [rax+rcx] contains the address
8481     // Windows 64bit: gs:0x58
8482     // Windows 32bit: fs:__tls_array
8483
8484     // If GV is an alias then use the aliasee for determining
8485     // thread-localness.
8486     if (const GlobalAlias *GA = dyn_cast<GlobalAlias>(GV))
8487       GV = GA->resolveAliasedGlobal(false);
8488     SDLoc dl(GA);
8489     SDValue Chain = DAG.getEntryNode();
8490
8491     // Get the Thread Pointer, which is %fs:__tls_array (32-bit) or
8492     // %gs:0x58 (64-bit). On MinGW, __tls_array is not available, so directly
8493     // use its literal value of 0x2C.
8494     Value *Ptr = Constant::getNullValue(Subtarget->is64Bit()
8495                                         ? Type::getInt8PtrTy(*DAG.getContext(),
8496                                                              256)
8497                                         : Type::getInt32PtrTy(*DAG.getContext(),
8498                                                               257));
8499
8500     SDValue TlsArray = Subtarget->is64Bit() ? DAG.getIntPtrConstant(0x58) :
8501       (Subtarget->isTargetMingw() ? DAG.getIntPtrConstant(0x2C) :
8502         DAG.getExternalSymbol("_tls_array", getPointerTy()));
8503
8504     SDValue ThreadPointer = DAG.getLoad(getPointerTy(), dl, Chain, TlsArray,
8505                                         MachinePointerInfo(Ptr),
8506                                         false, false, false, 0);
8507
8508     // Load the _tls_index variable
8509     SDValue IDX = DAG.getExternalSymbol("_tls_index", getPointerTy());
8510     if (Subtarget->is64Bit())
8511       IDX = DAG.getExtLoad(ISD::ZEXTLOAD, dl, getPointerTy(), Chain,
8512                            IDX, MachinePointerInfo(), MVT::i32,
8513                            false, false, 0);
8514     else
8515       IDX = DAG.getLoad(getPointerTy(), dl, Chain, IDX, MachinePointerInfo(),
8516                         false, false, false, 0);
8517
8518     SDValue Scale = DAG.getConstant(Log2_64_Ceil(TD->getPointerSize()),
8519                                     getPointerTy());
8520     IDX = DAG.getNode(ISD::SHL, dl, getPointerTy(), IDX, Scale);
8521
8522     SDValue res = DAG.getNode(ISD::ADD, dl, getPointerTy(), ThreadPointer, IDX);
8523     res = DAG.getLoad(getPointerTy(), dl, Chain, res, MachinePointerInfo(),
8524                       false, false, false, 0);
8525
8526     // Get the offset of start of .tls section
8527     SDValue TGA = DAG.getTargetGlobalAddress(GA->getGlobal(), dl,
8528                                              GA->getValueType(0),
8529                                              GA->getOffset(), X86II::MO_SECREL);
8530     SDValue Offset = DAG.getNode(X86ISD::Wrapper, dl, getPointerTy(), TGA);
8531
8532     // The address of the thread local variable is the add of the thread
8533     // pointer with the offset of the variable.
8534     return DAG.getNode(ISD::ADD, dl, getPointerTy(), res, Offset);
8535   }
8536
8537   llvm_unreachable("TLS not implemented for this target.");
8538 }
8539
8540 /// LowerShiftParts - Lower SRA_PARTS and friends, which return two i32 values
8541 /// and take a 2 x i32 value to shift plus a shift amount.
8542 static SDValue LowerShiftParts(SDValue Op, SelectionDAG &DAG) {
8543   assert(Op.getNumOperands() == 3 && "Not a double-shift!");
8544   MVT VT = Op.getSimpleValueType();
8545   unsigned VTBits = VT.getSizeInBits();
8546   SDLoc dl(Op);
8547   bool isSRA = Op.getOpcode() == ISD::SRA_PARTS;
8548   SDValue ShOpLo = Op.getOperand(0);
8549   SDValue ShOpHi = Op.getOperand(1);
8550   SDValue ShAmt  = Op.getOperand(2);
8551   // X86ISD::SHLD and X86ISD::SHRD have defined overflow behavior but the
8552   // generic ISD nodes haven't. Insert an AND to be safe, it's optimized away
8553   // during isel.
8554   SDValue SafeShAmt = DAG.getNode(ISD::AND, dl, MVT::i8, ShAmt,
8555                                   DAG.getConstant(VTBits - 1, MVT::i8));
8556   SDValue Tmp1 = isSRA ? DAG.getNode(ISD::SRA, dl, VT, ShOpHi,
8557                                      DAG.getConstant(VTBits - 1, MVT::i8))
8558                        : DAG.getConstant(0, VT);
8559
8560   SDValue Tmp2, Tmp3;
8561   if (Op.getOpcode() == ISD::SHL_PARTS) {
8562     Tmp2 = DAG.getNode(X86ISD::SHLD, dl, VT, ShOpHi, ShOpLo, ShAmt);
8563     Tmp3 = DAG.getNode(ISD::SHL, dl, VT, ShOpLo, SafeShAmt);
8564   } else {
8565     Tmp2 = DAG.getNode(X86ISD::SHRD, dl, VT, ShOpLo, ShOpHi, ShAmt);
8566     Tmp3 = DAG.getNode(isSRA ? ISD::SRA : ISD::SRL, dl, VT, ShOpHi, SafeShAmt);
8567   }
8568
8569   // If the shift amount is larger or equal than the width of a part we can't
8570   // rely on the results of shld/shrd. Insert a test and select the appropriate
8571   // values for large shift amounts.
8572   SDValue AndNode = DAG.getNode(ISD::AND, dl, MVT::i8, ShAmt,
8573                                 DAG.getConstant(VTBits, MVT::i8));
8574   SDValue Cond = DAG.getNode(X86ISD::CMP, dl, MVT::i32,
8575                              AndNode, DAG.getConstant(0, MVT::i8));
8576
8577   SDValue Hi, Lo;
8578   SDValue CC = DAG.getConstant(X86::COND_NE, MVT::i8);
8579   SDValue Ops0[4] = { Tmp2, Tmp3, CC, Cond };
8580   SDValue Ops1[4] = { Tmp3, Tmp1, CC, Cond };
8581
8582   if (Op.getOpcode() == ISD::SHL_PARTS) {
8583     Hi = DAG.getNode(X86ISD::CMOV, dl, VT, Ops0, 4);
8584     Lo = DAG.getNode(X86ISD::CMOV, dl, VT, Ops1, 4);
8585   } else {
8586     Lo = DAG.getNode(X86ISD::CMOV, dl, VT, Ops0, 4);
8587     Hi = DAG.getNode(X86ISD::CMOV, dl, VT, Ops1, 4);
8588   }
8589
8590   SDValue Ops[2] = { Lo, Hi };
8591   return DAG.getMergeValues(Ops, array_lengthof(Ops), dl);
8592 }
8593
8594 SDValue X86TargetLowering::LowerSINT_TO_FP(SDValue Op,
8595                                            SelectionDAG &DAG) const {
8596   MVT SrcVT = Op.getOperand(0).getSimpleValueType();
8597
8598   if (SrcVT.isVector())
8599     return SDValue();
8600
8601   assert(SrcVT <= MVT::i64 && SrcVT >= MVT::i16 &&
8602          "Unknown SINT_TO_FP to lower!");
8603
8604   // These are really Legal; return the operand so the caller accepts it as
8605   // Legal.
8606   if (SrcVT == MVT::i32 && isScalarFPTypeInSSEReg(Op.getValueType()))
8607     return Op;
8608   if (SrcVT == MVT::i64 && isScalarFPTypeInSSEReg(Op.getValueType()) &&
8609       Subtarget->is64Bit()) {
8610     return Op;
8611   }
8612
8613   SDLoc dl(Op);
8614   unsigned Size = SrcVT.getSizeInBits()/8;
8615   MachineFunction &MF = DAG.getMachineFunction();
8616   int SSFI = MF.getFrameInfo()->CreateStackObject(Size, Size, false);
8617   SDValue StackSlot = DAG.getFrameIndex(SSFI, getPointerTy());
8618   SDValue Chain = DAG.getStore(DAG.getEntryNode(), dl, Op.getOperand(0),
8619                                StackSlot,
8620                                MachinePointerInfo::getFixedStack(SSFI),
8621                                false, false, 0);
8622   return BuildFILD(Op, SrcVT, Chain, StackSlot, DAG);
8623 }
8624
8625 SDValue X86TargetLowering::BuildFILD(SDValue Op, EVT SrcVT, SDValue Chain,
8626                                      SDValue StackSlot,
8627                                      SelectionDAG &DAG) const {
8628   // Build the FILD
8629   SDLoc DL(Op);
8630   SDVTList Tys;
8631   bool useSSE = isScalarFPTypeInSSEReg(Op.getValueType());
8632   if (useSSE)
8633     Tys = DAG.getVTList(MVT::f64, MVT::Other, MVT::Glue);
8634   else
8635     Tys = DAG.getVTList(Op.getValueType(), MVT::Other);
8636
8637   unsigned ByteSize = SrcVT.getSizeInBits()/8;
8638
8639   FrameIndexSDNode *FI = dyn_cast<FrameIndexSDNode>(StackSlot);
8640   MachineMemOperand *MMO;
8641   if (FI) {
8642     int SSFI = FI->getIndex();
8643     MMO =
8644       DAG.getMachineFunction()
8645       .getMachineMemOperand(MachinePointerInfo::getFixedStack(SSFI),
8646                             MachineMemOperand::MOLoad, ByteSize, ByteSize);
8647   } else {
8648     MMO = cast<LoadSDNode>(StackSlot)->getMemOperand();
8649     StackSlot = StackSlot.getOperand(1);
8650   }
8651   SDValue Ops[] = { Chain, StackSlot, DAG.getValueType(SrcVT) };
8652   SDValue Result = DAG.getMemIntrinsicNode(useSSE ? X86ISD::FILD_FLAG :
8653                                            X86ISD::FILD, DL,
8654                                            Tys, Ops, array_lengthof(Ops),
8655                                            SrcVT, MMO);
8656
8657   if (useSSE) {
8658     Chain = Result.getValue(1);
8659     SDValue InFlag = Result.getValue(2);
8660
8661     // FIXME: Currently the FST is flagged to the FILD_FLAG. This
8662     // shouldn't be necessary except that RFP cannot be live across
8663     // multiple blocks. When stackifier is fixed, they can be uncoupled.
8664     MachineFunction &MF = DAG.getMachineFunction();
8665     unsigned SSFISize = Op.getValueType().getSizeInBits()/8;
8666     int SSFI = MF.getFrameInfo()->CreateStackObject(SSFISize, SSFISize, false);
8667     SDValue StackSlot = DAG.getFrameIndex(SSFI, getPointerTy());
8668     Tys = DAG.getVTList(MVT::Other);
8669     SDValue Ops[] = {
8670       Chain, Result, StackSlot, DAG.getValueType(Op.getValueType()), InFlag
8671     };
8672     MachineMemOperand *MMO =
8673       DAG.getMachineFunction()
8674       .getMachineMemOperand(MachinePointerInfo::getFixedStack(SSFI),
8675                             MachineMemOperand::MOStore, SSFISize, SSFISize);
8676
8677     Chain = DAG.getMemIntrinsicNode(X86ISD::FST, DL, Tys,
8678                                     Ops, array_lengthof(Ops),
8679                                     Op.getValueType(), MMO);
8680     Result = DAG.getLoad(Op.getValueType(), DL, Chain, StackSlot,
8681                          MachinePointerInfo::getFixedStack(SSFI),
8682                          false, false, false, 0);
8683   }
8684
8685   return Result;
8686 }
8687
8688 // LowerUINT_TO_FP_i64 - 64-bit unsigned integer to double expansion.
8689 SDValue X86TargetLowering::LowerUINT_TO_FP_i64(SDValue Op,
8690                                                SelectionDAG &DAG) const {
8691   // This algorithm is not obvious. Here it is what we're trying to output:
8692   /*
8693      movq       %rax,  %xmm0
8694      punpckldq  (c0),  %xmm0  // c0: (uint4){ 0x43300000U, 0x45300000U, 0U, 0U }
8695      subpd      (c1),  %xmm0  // c1: (double2){ 0x1.0p52, 0x1.0p52 * 0x1.0p32 }
8696      #ifdef __SSE3__
8697        haddpd   %xmm0, %xmm0
8698      #else
8699        pshufd   $0x4e, %xmm0, %xmm1
8700        addpd    %xmm1, %xmm0
8701      #endif
8702   */
8703
8704   SDLoc dl(Op);
8705   LLVMContext *Context = DAG.getContext();
8706
8707   // Build some magic constants.
8708   static const uint32_t CV0[] = { 0x43300000, 0x45300000, 0, 0 };
8709   Constant *C0 = ConstantDataVector::get(*Context, CV0);
8710   SDValue CPIdx0 = DAG.getConstantPool(C0, getPointerTy(), 16);
8711
8712   SmallVector<Constant*,2> CV1;
8713   CV1.push_back(
8714     ConstantFP::get(*Context, APFloat(APFloat::IEEEdouble,
8715                                       APInt(64, 0x4330000000000000ULL))));
8716   CV1.push_back(
8717     ConstantFP::get(*Context, APFloat(APFloat::IEEEdouble,
8718                                       APInt(64, 0x4530000000000000ULL))));
8719   Constant *C1 = ConstantVector::get(CV1);
8720   SDValue CPIdx1 = DAG.getConstantPool(C1, getPointerTy(), 16);
8721
8722   // Load the 64-bit value into an XMM register.
8723   SDValue XR1 = DAG.getNode(ISD::SCALAR_TO_VECTOR, dl, MVT::v2i64,
8724                             Op.getOperand(0));
8725   SDValue CLod0 = DAG.getLoad(MVT::v4i32, dl, DAG.getEntryNode(), CPIdx0,
8726                               MachinePointerInfo::getConstantPool(),
8727                               false, false, false, 16);
8728   SDValue Unpck1 = getUnpackl(DAG, dl, MVT::v4i32,
8729                               DAG.getNode(ISD::BITCAST, dl, MVT::v4i32, XR1),
8730                               CLod0);
8731
8732   SDValue CLod1 = DAG.getLoad(MVT::v2f64, dl, CLod0.getValue(1), CPIdx1,
8733                               MachinePointerInfo::getConstantPool(),
8734                               false, false, false, 16);
8735   SDValue XR2F = DAG.getNode(ISD::BITCAST, dl, MVT::v2f64, Unpck1);
8736   SDValue Sub = DAG.getNode(ISD::FSUB, dl, MVT::v2f64, XR2F, CLod1);
8737   SDValue Result;
8738
8739   if (Subtarget->hasSSE3()) {
8740     // FIXME: The 'haddpd' instruction may be slower than 'movhlps + addsd'.
8741     Result = DAG.getNode(X86ISD::FHADD, dl, MVT::v2f64, Sub, Sub);
8742   } else {
8743     SDValue S2F = DAG.getNode(ISD::BITCAST, dl, MVT::v4i32, Sub);
8744     SDValue Shuffle = getTargetShuffleNode(X86ISD::PSHUFD, dl, MVT::v4i32,
8745                                            S2F, 0x4E, DAG);
8746     Result = DAG.getNode(ISD::FADD, dl, MVT::v2f64,
8747                          DAG.getNode(ISD::BITCAST, dl, MVT::v2f64, Shuffle),
8748                          Sub);
8749   }
8750
8751   return DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, MVT::f64, Result,
8752                      DAG.getIntPtrConstant(0));
8753 }
8754
8755 // LowerUINT_TO_FP_i32 - 32-bit unsigned integer to float expansion.
8756 SDValue X86TargetLowering::LowerUINT_TO_FP_i32(SDValue Op,
8757                                                SelectionDAG &DAG) const {
8758   SDLoc dl(Op);
8759   // FP constant to bias correct the final result.
8760   SDValue Bias = DAG.getConstantFP(BitsToDouble(0x4330000000000000ULL),
8761                                    MVT::f64);
8762
8763   // Load the 32-bit value into an XMM register.
8764   SDValue Load = DAG.getNode(ISD::SCALAR_TO_VECTOR, dl, MVT::v4i32,
8765                              Op.getOperand(0));
8766
8767   // Zero out the upper parts of the register.
8768   Load = getShuffleVectorZeroOrUndef(Load, 0, true, Subtarget, DAG);
8769
8770   Load = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, MVT::f64,
8771                      DAG.getNode(ISD::BITCAST, dl, MVT::v2f64, Load),
8772                      DAG.getIntPtrConstant(0));
8773
8774   // Or the load with the bias.
8775   SDValue Or = DAG.getNode(ISD::OR, dl, MVT::v2i64,
8776                            DAG.getNode(ISD::BITCAST, dl, MVT::v2i64,
8777                                        DAG.getNode(ISD::SCALAR_TO_VECTOR, dl,
8778                                                    MVT::v2f64, Load)),
8779                            DAG.getNode(ISD::BITCAST, dl, MVT::v2i64,
8780                                        DAG.getNode(ISD::SCALAR_TO_VECTOR, dl,
8781                                                    MVT::v2f64, Bias)));
8782   Or = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, MVT::f64,
8783                    DAG.getNode(ISD::BITCAST, dl, MVT::v2f64, Or),
8784                    DAG.getIntPtrConstant(0));
8785
8786   // Subtract the bias.
8787   SDValue Sub = DAG.getNode(ISD::FSUB, dl, MVT::f64, Or, Bias);
8788
8789   // Handle final rounding.
8790   EVT DestVT = Op.getValueType();
8791
8792   if (DestVT.bitsLT(MVT::f64))
8793     return DAG.getNode(ISD::FP_ROUND, dl, DestVT, Sub,
8794                        DAG.getIntPtrConstant(0));
8795   if (DestVT.bitsGT(MVT::f64))
8796     return DAG.getNode(ISD::FP_EXTEND, dl, DestVT, Sub);
8797
8798   // Handle final rounding.
8799   return Sub;
8800 }
8801
8802 SDValue X86TargetLowering::lowerUINT_TO_FP_vec(SDValue Op,
8803                                                SelectionDAG &DAG) const {
8804   SDValue N0 = Op.getOperand(0);
8805   MVT SVT = N0.getSimpleValueType();
8806   SDLoc dl(Op);
8807
8808   assert((SVT == MVT::v4i8 || SVT == MVT::v4i16 ||
8809           SVT == MVT::v8i8 || SVT == MVT::v8i16) &&
8810          "Custom UINT_TO_FP is not supported!");
8811
8812   MVT NVT = MVT::getVectorVT(MVT::i32, SVT.getVectorNumElements());
8813   return DAG.getNode(ISD::SINT_TO_FP, dl, Op.getValueType(),
8814                      DAG.getNode(ISD::ZERO_EXTEND, dl, NVT, N0));
8815 }
8816
8817 SDValue X86TargetLowering::LowerUINT_TO_FP(SDValue Op,
8818                                            SelectionDAG &DAG) const {
8819   SDValue N0 = Op.getOperand(0);
8820   SDLoc dl(Op);
8821
8822   if (Op.getValueType().isVector())
8823     return lowerUINT_TO_FP_vec(Op, DAG);
8824
8825   // Since UINT_TO_FP is legal (it's marked custom), dag combiner won't
8826   // optimize it to a SINT_TO_FP when the sign bit is known zero. Perform
8827   // the optimization here.
8828   if (DAG.SignBitIsZero(N0))
8829     return DAG.getNode(ISD::SINT_TO_FP, dl, Op.getValueType(), N0);
8830
8831   MVT SrcVT = N0.getSimpleValueType();
8832   MVT DstVT = Op.getSimpleValueType();
8833   if (SrcVT == MVT::i64 && DstVT == MVT::f64 && X86ScalarSSEf64)
8834     return LowerUINT_TO_FP_i64(Op, DAG);
8835   if (SrcVT == MVT::i32 && X86ScalarSSEf64)
8836     return LowerUINT_TO_FP_i32(Op, DAG);
8837   if (Subtarget->is64Bit() && SrcVT == MVT::i64 && DstVT == MVT::f32)
8838     return SDValue();
8839
8840   // Make a 64-bit buffer, and use it to build an FILD.
8841   SDValue StackSlot = DAG.CreateStackTemporary(MVT::i64);
8842   if (SrcVT == MVT::i32) {
8843     SDValue WordOff = DAG.getConstant(4, getPointerTy());
8844     SDValue OffsetSlot = DAG.getNode(ISD::ADD, dl,
8845                                      getPointerTy(), StackSlot, WordOff);
8846     SDValue Store1 = DAG.getStore(DAG.getEntryNode(), dl, Op.getOperand(0),
8847                                   StackSlot, MachinePointerInfo(),
8848                                   false, false, 0);
8849     SDValue Store2 = DAG.getStore(Store1, dl, DAG.getConstant(0, MVT::i32),
8850                                   OffsetSlot, MachinePointerInfo(),
8851                                   false, false, 0);
8852     SDValue Fild = BuildFILD(Op, MVT::i64, Store2, StackSlot, DAG);
8853     return Fild;
8854   }
8855
8856   assert(SrcVT == MVT::i64 && "Unexpected type in UINT_TO_FP");
8857   SDValue Store = DAG.getStore(DAG.getEntryNode(), dl, Op.getOperand(0),
8858                                StackSlot, MachinePointerInfo(),
8859                                false, false, 0);
8860   // For i64 source, we need to add the appropriate power of 2 if the input
8861   // was negative.  This is the same as the optimization in
8862   // DAGTypeLegalizer::ExpandIntOp_UNIT_TO_FP, and for it to be safe here,
8863   // we must be careful to do the computation in x87 extended precision, not
8864   // in SSE. (The generic code can't know it's OK to do this, or how to.)
8865   int SSFI = cast<FrameIndexSDNode>(StackSlot)->getIndex();
8866   MachineMemOperand *MMO =
8867     DAG.getMachineFunction()
8868     .getMachineMemOperand(MachinePointerInfo::getFixedStack(SSFI),
8869                           MachineMemOperand::MOLoad, 8, 8);
8870
8871   SDVTList Tys = DAG.getVTList(MVT::f80, MVT::Other);
8872   SDValue Ops[] = { Store, StackSlot, DAG.getValueType(MVT::i64) };
8873   SDValue Fild = DAG.getMemIntrinsicNode(X86ISD::FILD, dl, Tys, Ops,
8874                                          array_lengthof(Ops), MVT::i64, MMO);
8875
8876   APInt FF(32, 0x5F800000ULL);
8877
8878   // Check whether the sign bit is set.
8879   SDValue SignSet = DAG.getSetCC(dl,
8880                                  getSetCCResultType(*DAG.getContext(), MVT::i64),
8881                                  Op.getOperand(0), DAG.getConstant(0, MVT::i64),
8882                                  ISD::SETLT);
8883
8884   // Build a 64 bit pair (0, FF) in the constant pool, with FF in the lo bits.
8885   SDValue FudgePtr = DAG.getConstantPool(
8886                              ConstantInt::get(*DAG.getContext(), FF.zext(64)),
8887                                          getPointerTy());
8888
8889   // Get a pointer to FF if the sign bit was set, or to 0 otherwise.
8890   SDValue Zero = DAG.getIntPtrConstant(0);
8891   SDValue Four = DAG.getIntPtrConstant(4);
8892   SDValue Offset = DAG.getNode(ISD::SELECT, dl, Zero.getValueType(), SignSet,
8893                                Zero, Four);
8894   FudgePtr = DAG.getNode(ISD::ADD, dl, getPointerTy(), FudgePtr, Offset);
8895
8896   // Load the value out, extending it from f32 to f80.
8897   // FIXME: Avoid the extend by constructing the right constant pool?
8898   SDValue Fudge = DAG.getExtLoad(ISD::EXTLOAD, dl, MVT::f80, DAG.getEntryNode(),
8899                                  FudgePtr, MachinePointerInfo::getConstantPool(),
8900                                  MVT::f32, false, false, 4);
8901   // Extend everything to 80 bits to force it to be done on x87.
8902   SDValue Add = DAG.getNode(ISD::FADD, dl, MVT::f80, Fild, Fudge);
8903   return DAG.getNode(ISD::FP_ROUND, dl, DstVT, Add, DAG.getIntPtrConstant(0));
8904 }
8905
8906 std::pair<SDValue,SDValue>
8907 X86TargetLowering:: FP_TO_INTHelper(SDValue Op, SelectionDAG &DAG,
8908                                     bool IsSigned, bool IsReplace) const {
8909   SDLoc DL(Op);
8910
8911   EVT DstTy = Op.getValueType();
8912
8913   if (!IsSigned && !isIntegerTypeFTOL(DstTy)) {
8914     assert(DstTy == MVT::i32 && "Unexpected FP_TO_UINT");
8915     DstTy = MVT::i64;
8916   }
8917
8918   assert(DstTy.getSimpleVT() <= MVT::i64 &&
8919          DstTy.getSimpleVT() >= MVT::i16 &&
8920          "Unknown FP_TO_INT to lower!");
8921
8922   // These are really Legal.
8923   if (DstTy == MVT::i32 &&
8924       isScalarFPTypeInSSEReg(Op.getOperand(0).getValueType()))
8925     return std::make_pair(SDValue(), SDValue());
8926   if (Subtarget->is64Bit() &&
8927       DstTy == MVT::i64 &&
8928       isScalarFPTypeInSSEReg(Op.getOperand(0).getValueType()))
8929     return std::make_pair(SDValue(), SDValue());
8930
8931   // We lower FP->int64 either into FISTP64 followed by a load from a temporary
8932   // stack slot, or into the FTOL runtime function.
8933   MachineFunction &MF = DAG.getMachineFunction();
8934   unsigned MemSize = DstTy.getSizeInBits()/8;
8935   int SSFI = MF.getFrameInfo()->CreateStackObject(MemSize, MemSize, false);
8936   SDValue StackSlot = DAG.getFrameIndex(SSFI, getPointerTy());
8937
8938   unsigned Opc;
8939   if (!IsSigned && isIntegerTypeFTOL(DstTy))
8940     Opc = X86ISD::WIN_FTOL;
8941   else
8942     switch (DstTy.getSimpleVT().SimpleTy) {
8943     default: llvm_unreachable("Invalid FP_TO_SINT to lower!");
8944     case MVT::i16: Opc = X86ISD::FP_TO_INT16_IN_MEM; break;
8945     case MVT::i32: Opc = X86ISD::FP_TO_INT32_IN_MEM; break;
8946     case MVT::i64: Opc = X86ISD::FP_TO_INT64_IN_MEM; break;
8947     }
8948
8949   SDValue Chain = DAG.getEntryNode();
8950   SDValue Value = Op.getOperand(0);
8951   EVT TheVT = Op.getOperand(0).getValueType();
8952   // FIXME This causes a redundant load/store if the SSE-class value is already
8953   // in memory, such as if it is on the callstack.
8954   if (isScalarFPTypeInSSEReg(TheVT)) {
8955     assert(DstTy == MVT::i64 && "Invalid FP_TO_SINT to lower!");
8956     Chain = DAG.getStore(Chain, DL, Value, StackSlot,
8957                          MachinePointerInfo::getFixedStack(SSFI),
8958                          false, false, 0);
8959     SDVTList Tys = DAG.getVTList(Op.getOperand(0).getValueType(), MVT::Other);
8960     SDValue Ops[] = {
8961       Chain, StackSlot, DAG.getValueType(TheVT)
8962     };
8963
8964     MachineMemOperand *MMO =
8965       MF.getMachineMemOperand(MachinePointerInfo::getFixedStack(SSFI),
8966                               MachineMemOperand::MOLoad, MemSize, MemSize);
8967     Value = DAG.getMemIntrinsicNode(X86ISD::FLD, DL, Tys, Ops,
8968                                     array_lengthof(Ops), DstTy, MMO);
8969     Chain = Value.getValue(1);
8970     SSFI = MF.getFrameInfo()->CreateStackObject(MemSize, MemSize, false);
8971     StackSlot = DAG.getFrameIndex(SSFI, getPointerTy());
8972   }
8973
8974   MachineMemOperand *MMO =
8975     MF.getMachineMemOperand(MachinePointerInfo::getFixedStack(SSFI),
8976                             MachineMemOperand::MOStore, MemSize, MemSize);
8977
8978   if (Opc != X86ISD::WIN_FTOL) {
8979     // Build the FP_TO_INT*_IN_MEM
8980     SDValue Ops[] = { Chain, Value, StackSlot };
8981     SDValue FIST = DAG.getMemIntrinsicNode(Opc, DL, DAG.getVTList(MVT::Other),
8982                                            Ops, array_lengthof(Ops), DstTy,
8983                                            MMO);
8984     return std::make_pair(FIST, StackSlot);
8985   } else {
8986     SDValue ftol = DAG.getNode(X86ISD::WIN_FTOL, DL,
8987       DAG.getVTList(MVT::Other, MVT::Glue),
8988       Chain, Value);
8989     SDValue eax = DAG.getCopyFromReg(ftol, DL, X86::EAX,
8990       MVT::i32, ftol.getValue(1));
8991     SDValue edx = DAG.getCopyFromReg(eax.getValue(1), DL, X86::EDX,
8992       MVT::i32, eax.getValue(2));
8993     SDValue Ops[] = { eax, edx };
8994     SDValue pair = IsReplace
8995       ? DAG.getNode(ISD::BUILD_PAIR, DL, MVT::i64, Ops, array_lengthof(Ops))
8996       : DAG.getMergeValues(Ops, array_lengthof(Ops), DL);
8997     return std::make_pair(pair, SDValue());
8998   }
8999 }
9000
9001 static SDValue LowerAVXExtend(SDValue Op, SelectionDAG &DAG,
9002                               const X86Subtarget *Subtarget) {
9003   MVT VT = Op->getSimpleValueType(0);
9004   SDValue In = Op->getOperand(0);
9005   MVT InVT = In.getSimpleValueType();
9006   SDLoc dl(Op);
9007
9008   // Optimize vectors in AVX mode:
9009   //
9010   //   v8i16 -> v8i32
9011   //   Use vpunpcklwd for 4 lower elements  v8i16 -> v4i32.
9012   //   Use vpunpckhwd for 4 upper elements  v8i16 -> v4i32.
9013   //   Concat upper and lower parts.
9014   //
9015   //   v4i32 -> v4i64
9016   //   Use vpunpckldq for 4 lower elements  v4i32 -> v2i64.
9017   //   Use vpunpckhdq for 4 upper elements  v4i32 -> v2i64.
9018   //   Concat upper and lower parts.
9019   //
9020
9021   if (((VT != MVT::v16i16) || (InVT != MVT::v16i8)) &&
9022       ((VT != MVT::v8i32) || (InVT != MVT::v8i16)) &&
9023       ((VT != MVT::v4i64) || (InVT != MVT::v4i32)))
9024     return SDValue();
9025
9026   if (Subtarget->hasInt256())
9027     return DAG.getNode(X86ISD::VZEXT, dl, VT, In);
9028
9029   SDValue ZeroVec = getZeroVector(InVT, Subtarget, DAG, dl);
9030   SDValue Undef = DAG.getUNDEF(InVT);
9031   bool NeedZero = Op.getOpcode() == ISD::ZERO_EXTEND;
9032   SDValue OpLo = getUnpackl(DAG, dl, InVT, In, NeedZero ? ZeroVec : Undef);
9033   SDValue OpHi = getUnpackh(DAG, dl, InVT, In, NeedZero ? ZeroVec : Undef);
9034
9035   MVT HVT = MVT::getVectorVT(VT.getVectorElementType(),
9036                              VT.getVectorNumElements()/2);
9037
9038   OpLo = DAG.getNode(ISD::BITCAST, dl, HVT, OpLo);
9039   OpHi = DAG.getNode(ISD::BITCAST, dl, HVT, OpHi);
9040
9041   return DAG.getNode(ISD::CONCAT_VECTORS, dl, VT, OpLo, OpHi);
9042 }
9043
9044 static  SDValue LowerZERO_EXTEND_AVX512(SDValue Op,
9045                                         SelectionDAG &DAG) {
9046   MVT VT = Op->getSimpleValueType(0);
9047   SDValue In = Op->getOperand(0);
9048   MVT InVT = In.getSimpleValueType();
9049   SDLoc DL(Op);
9050   unsigned int NumElts = VT.getVectorNumElements();
9051   if (NumElts != 8 && NumElts != 16)
9052     return SDValue();
9053
9054   if (VT.is512BitVector() && InVT.getVectorElementType() != MVT::i1)
9055     return DAG.getNode(X86ISD::VZEXT, DL, VT, In);
9056
9057   EVT ExtVT = (NumElts == 8)? MVT::v8i64 : MVT::v16i32;
9058   const TargetLowering &TLI = DAG.getTargetLoweringInfo();
9059   // Now we have only mask extension
9060   assert(InVT.getVectorElementType() == MVT::i1);
9061   SDValue Cst = DAG.getTargetConstant(1, ExtVT.getScalarType());
9062   const Constant *C = (dyn_cast<ConstantSDNode>(Cst))->getConstantIntValue();
9063   SDValue CP = DAG.getConstantPool(C, TLI.getPointerTy());
9064   unsigned Alignment = cast<ConstantPoolSDNode>(CP)->getAlignment();
9065   SDValue Ld = DAG.getLoad(Cst.getValueType(), DL, DAG.getEntryNode(), CP,
9066                            MachinePointerInfo::getConstantPool(),
9067                            false, false, false, Alignment);
9068
9069   SDValue Brcst = DAG.getNode(X86ISD::VBROADCASTM, DL, ExtVT, In, Ld);
9070   if (VT.is512BitVector())
9071     return Brcst;
9072   return DAG.getNode(X86ISD::VTRUNC, DL, VT, Brcst);
9073 }
9074
9075 static SDValue LowerANY_EXTEND(SDValue Op, const X86Subtarget *Subtarget,
9076                                SelectionDAG &DAG) {
9077   if (Subtarget->hasFp256()) {
9078     SDValue Res = LowerAVXExtend(Op, DAG, Subtarget);
9079     if (Res.getNode())
9080       return Res;
9081   }
9082
9083   return SDValue();
9084 }
9085
9086 static SDValue LowerZERO_EXTEND(SDValue Op, const X86Subtarget *Subtarget,
9087                                 SelectionDAG &DAG) {
9088   SDLoc DL(Op);
9089   MVT VT = Op.getSimpleValueType();
9090   SDValue In = Op.getOperand(0);
9091   MVT SVT = In.getSimpleValueType();
9092
9093   if (VT.is512BitVector() || SVT.getVectorElementType() == MVT::i1)
9094     return LowerZERO_EXTEND_AVX512(Op, DAG);
9095
9096   if (Subtarget->hasFp256()) {
9097     SDValue Res = LowerAVXExtend(Op, DAG, Subtarget);
9098     if (Res.getNode())
9099       return Res;
9100   }
9101
9102   assert(!VT.is256BitVector() || !SVT.is128BitVector() ||
9103          VT.getVectorNumElements() != SVT.getVectorNumElements());
9104   return SDValue();
9105 }
9106
9107 SDValue X86TargetLowering::LowerTRUNCATE(SDValue Op, SelectionDAG &DAG) const {
9108   SDLoc DL(Op);
9109   MVT VT = Op.getSimpleValueType();
9110   SDValue In = Op.getOperand(0);
9111   MVT InVT = In.getSimpleValueType();
9112
9113   if (VT == MVT::i1) {
9114     assert((InVT.isInteger() && (InVT.getSizeInBits() <= 64)) &&
9115            "Invalid scalar TRUNCATE operation");
9116     if (InVT == MVT::i32)
9117       return SDValue();
9118     if (InVT.getSizeInBits() == 64)
9119       In = DAG.getNode(ISD::EXTRACT_SUBVECTOR, DL, MVT::i32, In);
9120     else if (InVT.getSizeInBits() < 32)
9121       In = DAG.getNode(ISD::ANY_EXTEND, DL, MVT::i32, In);
9122     return DAG.getNode(ISD::TRUNCATE, DL, VT, In);
9123   }
9124   assert(VT.getVectorNumElements() == InVT.getVectorNumElements() &&
9125          "Invalid TRUNCATE operation");
9126
9127   if (InVT.is512BitVector() || VT.getVectorElementType() == MVT::i1) {
9128     if (VT.getVectorElementType().getSizeInBits() >=8)
9129       return DAG.getNode(X86ISD::VTRUNC, DL, VT, In);
9130
9131     assert(VT.getVectorElementType() == MVT::i1 && "Unexpected vector type");
9132     unsigned NumElts = InVT.getVectorNumElements();
9133     assert ((NumElts == 8 || NumElts == 16) && "Unexpected vector type");
9134     if (InVT.getSizeInBits() < 512) {
9135       MVT ExtVT = (NumElts == 16)? MVT::v16i32 : MVT::v8i64;
9136       In = DAG.getNode(ISD::SIGN_EXTEND, DL, ExtVT, In);
9137       InVT = ExtVT;
9138     }
9139     
9140     SDValue Cst = DAG.getTargetConstant(1, InVT.getVectorElementType());
9141     const Constant *C = (dyn_cast<ConstantSDNode>(Cst))->getConstantIntValue();
9142     SDValue CP = DAG.getConstantPool(C, getPointerTy());
9143     unsigned Alignment = cast<ConstantPoolSDNode>(CP)->getAlignment();
9144     SDValue Ld = DAG.getLoad(Cst.getValueType(), DL, DAG.getEntryNode(), CP,
9145                            MachinePointerInfo::getConstantPool(),
9146                            false, false, false, Alignment);
9147     SDValue OneV = DAG.getNode(X86ISD::VBROADCAST, DL, InVT, Ld);
9148     SDValue And = DAG.getNode(ISD::AND, DL, InVT, OneV, In);
9149     return DAG.getNode(X86ISD::TESTM, DL, VT, And, And);
9150   }
9151
9152   if ((VT == MVT::v4i32) && (InVT == MVT::v4i64)) {
9153     // On AVX2, v4i64 -> v4i32 becomes VPERMD.
9154     if (Subtarget->hasInt256()) {
9155       static const int ShufMask[] = {0, 2, 4, 6, -1, -1, -1, -1};
9156       In = DAG.getNode(ISD::BITCAST, DL, MVT::v8i32, In);
9157       In = DAG.getVectorShuffle(MVT::v8i32, DL, In, DAG.getUNDEF(MVT::v8i32),
9158                                 ShufMask);
9159       return DAG.getNode(ISD::EXTRACT_SUBVECTOR, DL, VT, In,
9160                          DAG.getIntPtrConstant(0));
9161     }
9162
9163     SDValue OpLo = DAG.getNode(ISD::EXTRACT_SUBVECTOR, DL, MVT::v2i64, In,
9164                                DAG.getIntPtrConstant(0));
9165     SDValue OpHi = DAG.getNode(ISD::EXTRACT_SUBVECTOR, DL, MVT::v2i64, In,
9166                                DAG.getIntPtrConstant(2));
9167     OpLo = DAG.getNode(ISD::BITCAST, DL, MVT::v4i32, OpLo);
9168     OpHi = DAG.getNode(ISD::BITCAST, DL, MVT::v4i32, OpHi);
9169     static const int ShufMask[] = {0, 2, 4, 6};
9170     return DAG.getVectorShuffle(VT, DL, OpLo, OpHi, ShufMask);
9171   }
9172
9173   if ((VT == MVT::v8i16) && (InVT == MVT::v8i32)) {
9174     // On AVX2, v8i32 -> v8i16 becomed PSHUFB.
9175     if (Subtarget->hasInt256()) {
9176       In = DAG.getNode(ISD::BITCAST, DL, MVT::v32i8, In);
9177
9178       SmallVector<SDValue,32> pshufbMask;
9179       for (unsigned i = 0; i < 2; ++i) {
9180         pshufbMask.push_back(DAG.getConstant(0x0, MVT::i8));
9181         pshufbMask.push_back(DAG.getConstant(0x1, MVT::i8));
9182         pshufbMask.push_back(DAG.getConstant(0x4, MVT::i8));
9183         pshufbMask.push_back(DAG.getConstant(0x5, MVT::i8));
9184         pshufbMask.push_back(DAG.getConstant(0x8, MVT::i8));
9185         pshufbMask.push_back(DAG.getConstant(0x9, MVT::i8));
9186         pshufbMask.push_back(DAG.getConstant(0xc, MVT::i8));
9187         pshufbMask.push_back(DAG.getConstant(0xd, MVT::i8));
9188         for (unsigned j = 0; j < 8; ++j)
9189           pshufbMask.push_back(DAG.getConstant(0x80, MVT::i8));
9190       }
9191       SDValue BV = DAG.getNode(ISD::BUILD_VECTOR, DL, MVT::v32i8,
9192                                &pshufbMask[0], 32);
9193       In = DAG.getNode(X86ISD::PSHUFB, DL, MVT::v32i8, In, BV);
9194       In = DAG.getNode(ISD::BITCAST, DL, MVT::v4i64, In);
9195
9196       static const int ShufMask[] = {0,  2,  -1,  -1};
9197       In = DAG.getVectorShuffle(MVT::v4i64, DL,  In, DAG.getUNDEF(MVT::v4i64),
9198                                 &ShufMask[0]);
9199       In = DAG.getNode(ISD::EXTRACT_SUBVECTOR, DL, MVT::v2i64, In,
9200                        DAG.getIntPtrConstant(0));
9201       return DAG.getNode(ISD::BITCAST, DL, VT, In);
9202     }
9203
9204     SDValue OpLo = DAG.getNode(ISD::EXTRACT_SUBVECTOR, DL, MVT::v4i32, In,
9205                                DAG.getIntPtrConstant(0));
9206
9207     SDValue OpHi = DAG.getNode(ISD::EXTRACT_SUBVECTOR, DL, MVT::v4i32, In,
9208                                DAG.getIntPtrConstant(4));
9209
9210     OpLo = DAG.getNode(ISD::BITCAST, DL, MVT::v16i8, OpLo);
9211     OpHi = DAG.getNode(ISD::BITCAST, DL, MVT::v16i8, OpHi);
9212
9213     // The PSHUFB mask:
9214     static const int ShufMask1[] = {0,  1,  4,  5,  8,  9, 12, 13,
9215                                    -1, -1, -1, -1, -1, -1, -1, -1};
9216
9217     SDValue Undef = DAG.getUNDEF(MVT::v16i8);
9218     OpLo = DAG.getVectorShuffle(MVT::v16i8, DL, OpLo, Undef, ShufMask1);
9219     OpHi = DAG.getVectorShuffle(MVT::v16i8, DL, OpHi, Undef, ShufMask1);
9220
9221     OpLo = DAG.getNode(ISD::BITCAST, DL, MVT::v4i32, OpLo);
9222     OpHi = DAG.getNode(ISD::BITCAST, DL, MVT::v4i32, OpHi);
9223
9224     // The MOVLHPS Mask:
9225     static const int ShufMask2[] = {0, 1, 4, 5};
9226     SDValue res = DAG.getVectorShuffle(MVT::v4i32, DL, OpLo, OpHi, ShufMask2);
9227     return DAG.getNode(ISD::BITCAST, DL, MVT::v8i16, res);
9228   }
9229
9230   // Handle truncation of V256 to V128 using shuffles.
9231   if (!VT.is128BitVector() || !InVT.is256BitVector())
9232     return SDValue();
9233
9234   assert(Subtarget->hasFp256() && "256-bit vector without AVX!");
9235
9236   unsigned NumElems = VT.getVectorNumElements();
9237   MVT NVT = MVT::getVectorVT(VT.getVectorElementType(), NumElems * 2);
9238
9239   SmallVector<int, 16> MaskVec(NumElems * 2, -1);
9240   // Prepare truncation shuffle mask
9241   for (unsigned i = 0; i != NumElems; ++i)
9242     MaskVec[i] = i * 2;
9243   SDValue V = DAG.getVectorShuffle(NVT, DL,
9244                                    DAG.getNode(ISD::BITCAST, DL, NVT, In),
9245                                    DAG.getUNDEF(NVT), &MaskVec[0]);
9246   return DAG.getNode(ISD::EXTRACT_SUBVECTOR, DL, VT, V,
9247                      DAG.getIntPtrConstant(0));
9248 }
9249
9250 SDValue X86TargetLowering::LowerFP_TO_SINT(SDValue Op,
9251                                            SelectionDAG &DAG) const {
9252   assert(!Op.getSimpleValueType().isVector());
9253
9254   std::pair<SDValue,SDValue> Vals = FP_TO_INTHelper(Op, DAG,
9255     /*IsSigned=*/ true, /*IsReplace=*/ false);
9256   SDValue FIST = Vals.first, StackSlot = Vals.second;
9257   // If FP_TO_INTHelper failed, the node is actually supposed to be Legal.
9258   if (FIST.getNode() == 0) return Op;
9259
9260   if (StackSlot.getNode())
9261     // Load the result.
9262     return DAG.getLoad(Op.getValueType(), SDLoc(Op),
9263                        FIST, StackSlot, MachinePointerInfo(),
9264                        false, false, false, 0);
9265
9266   // The node is the result.
9267   return FIST;
9268 }
9269
9270 SDValue X86TargetLowering::LowerFP_TO_UINT(SDValue Op,
9271                                            SelectionDAG &DAG) const {
9272   std::pair<SDValue,SDValue> Vals = FP_TO_INTHelper(Op, DAG,
9273     /*IsSigned=*/ false, /*IsReplace=*/ false);
9274   SDValue FIST = Vals.first, StackSlot = Vals.second;
9275   assert(FIST.getNode() && "Unexpected failure");
9276
9277   if (StackSlot.getNode())
9278     // Load the result.
9279     return DAG.getLoad(Op.getValueType(), SDLoc(Op),
9280                        FIST, StackSlot, MachinePointerInfo(),
9281                        false, false, false, 0);
9282
9283   // The node is the result.
9284   return FIST;
9285 }
9286
9287 static SDValue LowerFP_EXTEND(SDValue Op, SelectionDAG &DAG) {
9288   SDLoc DL(Op);
9289   MVT VT = Op.getSimpleValueType();
9290   SDValue In = Op.getOperand(0);
9291   MVT SVT = In.getSimpleValueType();
9292
9293   assert(SVT == MVT::v2f32 && "Only customize MVT::v2f32 type legalization!");
9294
9295   return DAG.getNode(X86ISD::VFPEXT, DL, VT,
9296                      DAG.getNode(ISD::CONCAT_VECTORS, DL, MVT::v4f32,
9297                                  In, DAG.getUNDEF(SVT)));
9298 }
9299
9300 static SDValue LowerFABS(SDValue Op, SelectionDAG &DAG) {
9301   LLVMContext *Context = DAG.getContext();
9302   SDLoc dl(Op);
9303   MVT VT = Op.getSimpleValueType();
9304   MVT EltVT = VT;
9305   unsigned NumElts = VT == MVT::f64 ? 2 : 4;
9306   if (VT.isVector()) {
9307     EltVT = VT.getVectorElementType();
9308     NumElts = VT.getVectorNumElements();
9309   }
9310   Constant *C;
9311   if (EltVT == MVT::f64)
9312     C = ConstantFP::get(*Context, APFloat(APFloat::IEEEdouble,
9313                                           APInt(64, ~(1ULL << 63))));
9314   else
9315     C = ConstantFP::get(*Context, APFloat(APFloat::IEEEsingle,
9316                                           APInt(32, ~(1U << 31))));
9317   C = ConstantVector::getSplat(NumElts, C);
9318   const TargetLowering &TLI = DAG.getTargetLoweringInfo();
9319   SDValue CPIdx = DAG.getConstantPool(C, TLI.getPointerTy());
9320   unsigned Alignment = cast<ConstantPoolSDNode>(CPIdx)->getAlignment();
9321   SDValue Mask = DAG.getLoad(VT, dl, DAG.getEntryNode(), CPIdx,
9322                              MachinePointerInfo::getConstantPool(),
9323                              false, false, false, Alignment);
9324   if (VT.isVector()) {
9325     MVT ANDVT = VT.is128BitVector() ? MVT::v2i64 : MVT::v4i64;
9326     return DAG.getNode(ISD::BITCAST, dl, VT,
9327                        DAG.getNode(ISD::AND, dl, ANDVT,
9328                                    DAG.getNode(ISD::BITCAST, dl, ANDVT,
9329                                                Op.getOperand(0)),
9330                                    DAG.getNode(ISD::BITCAST, dl, ANDVT, Mask)));
9331   }
9332   return DAG.getNode(X86ISD::FAND, dl, VT, Op.getOperand(0), Mask);
9333 }
9334
9335 static SDValue LowerFNEG(SDValue Op, SelectionDAG &DAG) {
9336   LLVMContext *Context = DAG.getContext();
9337   SDLoc dl(Op);
9338   MVT VT = Op.getSimpleValueType();
9339   MVT EltVT = VT;
9340   unsigned NumElts = VT == MVT::f64 ? 2 : 4;
9341   if (VT.isVector()) {
9342     EltVT = VT.getVectorElementType();
9343     NumElts = VT.getVectorNumElements();
9344   }
9345   Constant *C;
9346   if (EltVT == MVT::f64)
9347     C = ConstantFP::get(*Context, APFloat(APFloat::IEEEdouble,
9348                                           APInt(64, 1ULL << 63)));
9349   else
9350     C = ConstantFP::get(*Context, APFloat(APFloat::IEEEsingle,
9351                                           APInt(32, 1U << 31)));
9352   C = ConstantVector::getSplat(NumElts, C);
9353   const TargetLowering &TLI = DAG.getTargetLoweringInfo();
9354   SDValue CPIdx = DAG.getConstantPool(C, TLI.getPointerTy());
9355   unsigned Alignment = cast<ConstantPoolSDNode>(CPIdx)->getAlignment();
9356   SDValue Mask = DAG.getLoad(VT, dl, DAG.getEntryNode(), CPIdx,
9357                              MachinePointerInfo::getConstantPool(),
9358                              false, false, false, Alignment);
9359   if (VT.isVector()) {
9360     MVT XORVT = MVT::getVectorVT(MVT::i64, VT.getSizeInBits()/64);
9361     return DAG.getNode(ISD::BITCAST, dl, VT,
9362                        DAG.getNode(ISD::XOR, dl, XORVT,
9363                                    DAG.getNode(ISD::BITCAST, dl, XORVT,
9364                                                Op.getOperand(0)),
9365                                    DAG.getNode(ISD::BITCAST, dl, XORVT, Mask)));
9366   }
9367
9368   return DAG.getNode(X86ISD::FXOR, dl, VT, Op.getOperand(0), Mask);
9369 }
9370
9371 static SDValue LowerFCOPYSIGN(SDValue Op, SelectionDAG &DAG) {
9372   const TargetLowering &TLI = DAG.getTargetLoweringInfo();
9373   LLVMContext *Context = DAG.getContext();
9374   SDValue Op0 = Op.getOperand(0);
9375   SDValue Op1 = Op.getOperand(1);
9376   SDLoc dl(Op);
9377   MVT VT = Op.getSimpleValueType();
9378   MVT SrcVT = Op1.getSimpleValueType();
9379
9380   // If second operand is smaller, extend it first.
9381   if (SrcVT.bitsLT(VT)) {
9382     Op1 = DAG.getNode(ISD::FP_EXTEND, dl, VT, Op1);
9383     SrcVT = VT;
9384   }
9385   // And if it is bigger, shrink it first.
9386   if (SrcVT.bitsGT(VT)) {
9387     Op1 = DAG.getNode(ISD::FP_ROUND, dl, VT, Op1, DAG.getIntPtrConstant(1));
9388     SrcVT = VT;
9389   }
9390
9391   // At this point the operands and the result should have the same
9392   // type, and that won't be f80 since that is not custom lowered.
9393
9394   // First get the sign bit of second operand.
9395   SmallVector<Constant*,4> CV;
9396   if (SrcVT == MVT::f64) {
9397     const fltSemantics &Sem = APFloat::IEEEdouble;
9398     CV.push_back(ConstantFP::get(*Context, APFloat(Sem, APInt(64, 1ULL << 63))));
9399     CV.push_back(ConstantFP::get(*Context, APFloat(Sem, APInt(64, 0))));
9400   } else {
9401     const fltSemantics &Sem = APFloat::IEEEsingle;
9402     CV.push_back(ConstantFP::get(*Context, APFloat(Sem, APInt(32, 1U << 31))));
9403     CV.push_back(ConstantFP::get(*Context, APFloat(Sem, APInt(32, 0))));
9404     CV.push_back(ConstantFP::get(*Context, APFloat(Sem, APInt(32, 0))));
9405     CV.push_back(ConstantFP::get(*Context, APFloat(Sem, APInt(32, 0))));
9406   }
9407   Constant *C = ConstantVector::get(CV);
9408   SDValue CPIdx = DAG.getConstantPool(C, TLI.getPointerTy(), 16);
9409   SDValue Mask1 = DAG.getLoad(SrcVT, dl, DAG.getEntryNode(), CPIdx,
9410                               MachinePointerInfo::getConstantPool(),
9411                               false, false, false, 16);
9412   SDValue SignBit = DAG.getNode(X86ISD::FAND, dl, SrcVT, Op1, Mask1);
9413
9414   // Shift sign bit right or left if the two operands have different types.
9415   if (SrcVT.bitsGT(VT)) {
9416     // Op0 is MVT::f32, Op1 is MVT::f64.
9417     SignBit = DAG.getNode(ISD::SCALAR_TO_VECTOR, dl, MVT::v2f64, SignBit);
9418     SignBit = DAG.getNode(X86ISD::FSRL, dl, MVT::v2f64, SignBit,
9419                           DAG.getConstant(32, MVT::i32));
9420     SignBit = DAG.getNode(ISD::BITCAST, dl, MVT::v4f32, SignBit);
9421     SignBit = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, MVT::f32, SignBit,
9422                           DAG.getIntPtrConstant(0));
9423   }
9424
9425   // Clear first operand sign bit.
9426   CV.clear();
9427   if (VT == MVT::f64) {
9428     const fltSemantics &Sem = APFloat::IEEEdouble;
9429     CV.push_back(ConstantFP::get(*Context, APFloat(Sem,
9430                                                    APInt(64, ~(1ULL << 63)))));
9431     CV.push_back(ConstantFP::get(*Context, APFloat(Sem, APInt(64, 0))));
9432   } else {
9433     const fltSemantics &Sem = APFloat::IEEEsingle;
9434     CV.push_back(ConstantFP::get(*Context, APFloat(Sem,
9435                                                    APInt(32, ~(1U << 31)))));
9436     CV.push_back(ConstantFP::get(*Context, APFloat(Sem, APInt(32, 0))));
9437     CV.push_back(ConstantFP::get(*Context, APFloat(Sem, APInt(32, 0))));
9438     CV.push_back(ConstantFP::get(*Context, APFloat(Sem, APInt(32, 0))));
9439   }
9440   C = ConstantVector::get(CV);
9441   CPIdx = DAG.getConstantPool(C, TLI.getPointerTy(), 16);
9442   SDValue Mask2 = DAG.getLoad(VT, dl, DAG.getEntryNode(), CPIdx,
9443                               MachinePointerInfo::getConstantPool(),
9444                               false, false, false, 16);
9445   SDValue Val = DAG.getNode(X86ISD::FAND, dl, VT, Op0, Mask2);
9446
9447   // Or the value with the sign bit.
9448   return DAG.getNode(X86ISD::FOR, dl, VT, Val, SignBit);
9449 }
9450
9451 static SDValue LowerFGETSIGN(SDValue Op, SelectionDAG &DAG) {
9452   SDValue N0 = Op.getOperand(0);
9453   SDLoc dl(Op);
9454   MVT VT = Op.getSimpleValueType();
9455
9456   // Lower ISD::FGETSIGN to (AND (X86ISD::FGETSIGNx86 ...) 1).
9457   SDValue xFGETSIGN = DAG.getNode(X86ISD::FGETSIGNx86, dl, VT, N0,
9458                                   DAG.getConstant(1, VT));
9459   return DAG.getNode(ISD::AND, dl, VT, xFGETSIGN, DAG.getConstant(1, VT));
9460 }
9461
9462 // LowerVectorAllZeroTest - Check whether an OR'd tree is PTEST-able.
9463 //
9464 static SDValue LowerVectorAllZeroTest(SDValue Op, const X86Subtarget *Subtarget,
9465                                       SelectionDAG &DAG) {
9466   assert(Op.getOpcode() == ISD::OR && "Only check OR'd tree.");
9467
9468   if (!Subtarget->hasSSE41())
9469     return SDValue();
9470
9471   if (!Op->hasOneUse())
9472     return SDValue();
9473
9474   SDNode *N = Op.getNode();
9475   SDLoc DL(N);
9476
9477   SmallVector<SDValue, 8> Opnds;
9478   DenseMap<SDValue, unsigned> VecInMap;
9479   SmallVector<SDValue, 8> VecIns;
9480   EVT VT = MVT::Other;
9481
9482   // Recognize a special case where a vector is casted into wide integer to
9483   // test all 0s.
9484   Opnds.push_back(N->getOperand(0));
9485   Opnds.push_back(N->getOperand(1));
9486
9487   for (unsigned Slot = 0, e = Opnds.size(); Slot < e; ++Slot) {
9488     SmallVectorImpl<SDValue>::const_iterator I = Opnds.begin() + Slot;
9489     // BFS traverse all OR'd operands.
9490     if (I->getOpcode() == ISD::OR) {
9491       Opnds.push_back(I->getOperand(0));
9492       Opnds.push_back(I->getOperand(1));
9493       // Re-evaluate the number of nodes to be traversed.
9494       e += 2; // 2 more nodes (LHS and RHS) are pushed.
9495       continue;
9496     }
9497
9498     // Quit if a non-EXTRACT_VECTOR_ELT
9499     if (I->getOpcode() != ISD::EXTRACT_VECTOR_ELT)
9500       return SDValue();
9501
9502     // Quit if without a constant index.
9503     SDValue Idx = I->getOperand(1);
9504     if (!isa<ConstantSDNode>(Idx))
9505       return SDValue();
9506
9507     SDValue ExtractedFromVec = I->getOperand(0);
9508     DenseMap<SDValue, unsigned>::iterator M = VecInMap.find(ExtractedFromVec);
9509     if (M == VecInMap.end()) {
9510       VT = ExtractedFromVec.getValueType();
9511       // Quit if not 128/256-bit vector.
9512       if (!VT.is128BitVector() && !VT.is256BitVector())
9513         return SDValue();
9514       // Quit if not the same type.
9515       if (VecInMap.begin() != VecInMap.end() &&
9516           VT != VecInMap.begin()->first.getValueType())
9517         return SDValue();
9518       M = VecInMap.insert(std::make_pair(ExtractedFromVec, 0)).first;
9519       VecIns.push_back(ExtractedFromVec);
9520     }
9521     M->second |= 1U << cast<ConstantSDNode>(Idx)->getZExtValue();
9522   }
9523
9524   assert((VT.is128BitVector() || VT.is256BitVector()) &&
9525          "Not extracted from 128-/256-bit vector.");
9526
9527   unsigned FullMask = (1U << VT.getVectorNumElements()) - 1U;
9528
9529   for (DenseMap<SDValue, unsigned>::const_iterator
9530         I = VecInMap.begin(), E = VecInMap.end(); I != E; ++I) {
9531     // Quit if not all elements are used.
9532     if (I->second != FullMask)
9533       return SDValue();
9534   }
9535
9536   EVT TestVT = VT.is128BitVector() ? MVT::v2i64 : MVT::v4i64;
9537
9538   // Cast all vectors into TestVT for PTEST.
9539   for (unsigned i = 0, e = VecIns.size(); i < e; ++i)
9540     VecIns[i] = DAG.getNode(ISD::BITCAST, DL, TestVT, VecIns[i]);
9541
9542   // If more than one full vectors are evaluated, OR them first before PTEST.
9543   for (unsigned Slot = 0, e = VecIns.size(); e - Slot > 1; Slot += 2, e += 1) {
9544     // Each iteration will OR 2 nodes and append the result until there is only
9545     // 1 node left, i.e. the final OR'd value of all vectors.
9546     SDValue LHS = VecIns[Slot];
9547     SDValue RHS = VecIns[Slot + 1];
9548     VecIns.push_back(DAG.getNode(ISD::OR, DL, TestVT, LHS, RHS));
9549   }
9550
9551   return DAG.getNode(X86ISD::PTEST, DL, MVT::i32,
9552                      VecIns.back(), VecIns.back());
9553 }
9554
9555 /// Emit nodes that will be selected as "test Op0,Op0", or something
9556 /// equivalent.
9557 SDValue X86TargetLowering::EmitTest(SDValue Op, unsigned X86CC,
9558                                     SelectionDAG &DAG) const {
9559   SDLoc dl(Op);
9560
9561   if (Op.getValueType() == MVT::i1)
9562     // KORTEST instruction should be selected
9563     return DAG.getNode(X86ISD::CMP, dl, MVT::i32, Op,
9564                        DAG.getConstant(0, Op.getValueType()));
9565
9566   // CF and OF aren't always set the way we want. Determine which
9567   // of these we need.
9568   bool NeedCF = false;
9569   bool NeedOF = false;
9570   switch (X86CC) {
9571   default: break;
9572   case X86::COND_A: case X86::COND_AE:
9573   case X86::COND_B: case X86::COND_BE:
9574     NeedCF = true;
9575     break;
9576   case X86::COND_G: case X86::COND_GE:
9577   case X86::COND_L: case X86::COND_LE:
9578   case X86::COND_O: case X86::COND_NO:
9579     NeedOF = true;
9580     break;
9581   }
9582   // See if we can use the EFLAGS value from the operand instead of
9583   // doing a separate TEST. TEST always sets OF and CF to 0, so unless
9584   // we prove that the arithmetic won't overflow, we can't use OF or CF.
9585   if (Op.getResNo() != 0 || NeedOF || NeedCF) {
9586     // Emit a CMP with 0, which is the TEST pattern.
9587     //if (Op.getValueType() == MVT::i1)
9588     //  return DAG.getNode(X86ISD::CMP, dl, MVT::i1, Op,
9589     //                     DAG.getConstant(0, MVT::i1));
9590     return DAG.getNode(X86ISD::CMP, dl, MVT::i32, Op,
9591                        DAG.getConstant(0, Op.getValueType()));
9592   }
9593   unsigned Opcode = 0;
9594   unsigned NumOperands = 0;
9595
9596   // Truncate operations may prevent the merge of the SETCC instruction
9597   // and the arithmetic instruction before it. Attempt to truncate the operands
9598   // of the arithmetic instruction and use a reduced bit-width instruction.
9599   bool NeedTruncation = false;
9600   SDValue ArithOp = Op;
9601   if (Op->getOpcode() == ISD::TRUNCATE && Op->hasOneUse()) {
9602     SDValue Arith = Op->getOperand(0);
9603     // Both the trunc and the arithmetic op need to have one user each.
9604     if (Arith->hasOneUse())
9605       switch (Arith.getOpcode()) {
9606         default: break;
9607         case ISD::ADD:
9608         case ISD::SUB:
9609         case ISD::AND:
9610         case ISD::OR:
9611         case ISD::XOR: {
9612           NeedTruncation = true;
9613           ArithOp = Arith;
9614         }
9615       }
9616   }
9617
9618   // NOTICE: In the code below we use ArithOp to hold the arithmetic operation
9619   // which may be the result of a CAST.  We use the variable 'Op', which is the
9620   // non-casted variable when we check for possible users.
9621   switch (ArithOp.getOpcode()) {
9622   case ISD::ADD:
9623     // Due to an isel shortcoming, be conservative if this add is likely to be
9624     // selected as part of a load-modify-store instruction. When the root node
9625     // in a match is a store, isel doesn't know how to remap non-chain non-flag
9626     // uses of other nodes in the match, such as the ADD in this case. This
9627     // leads to the ADD being left around and reselected, with the result being
9628     // two adds in the output.  Alas, even if none our users are stores, that
9629     // doesn't prove we're O.K.  Ergo, if we have any parents that aren't
9630     // CopyToReg or SETCC, eschew INC/DEC.  A better fix seems to require
9631     // climbing the DAG back to the root, and it doesn't seem to be worth the
9632     // effort.
9633     for (SDNode::use_iterator UI = Op.getNode()->use_begin(),
9634          UE = Op.getNode()->use_end(); UI != UE; ++UI)
9635       if (UI->getOpcode() != ISD::CopyToReg &&
9636           UI->getOpcode() != ISD::SETCC &&
9637           UI->getOpcode() != ISD::STORE)
9638         goto default_case;
9639
9640     if (ConstantSDNode *C =
9641         dyn_cast<ConstantSDNode>(ArithOp.getNode()->getOperand(1))) {
9642       // An add of one will be selected as an INC.
9643       if (C->getAPIntValue() == 1) {
9644         Opcode = X86ISD::INC;
9645         NumOperands = 1;
9646         break;
9647       }
9648
9649       // An add of negative one (subtract of one) will be selected as a DEC.
9650       if (C->getAPIntValue().isAllOnesValue()) {
9651         Opcode = X86ISD::DEC;
9652         NumOperands = 1;
9653         break;
9654       }
9655     }
9656
9657     // Otherwise use a regular EFLAGS-setting add.
9658     Opcode = X86ISD::ADD;
9659     NumOperands = 2;
9660     break;
9661   case ISD::AND: {
9662     // If the primary and result isn't used, don't bother using X86ISD::AND,
9663     // because a TEST instruction will be better.
9664     bool NonFlagUse = false;
9665     for (SDNode::use_iterator UI = Op.getNode()->use_begin(),
9666            UE = Op.getNode()->use_end(); UI != UE; ++UI) {
9667       SDNode *User = *UI;
9668       unsigned UOpNo = UI.getOperandNo();
9669       if (User->getOpcode() == ISD::TRUNCATE && User->hasOneUse()) {
9670         // Look pass truncate.
9671         UOpNo = User->use_begin().getOperandNo();
9672         User = *User->use_begin();
9673       }
9674
9675       if (User->getOpcode() != ISD::BRCOND &&
9676           User->getOpcode() != ISD::SETCC &&
9677           !(User->getOpcode() == ISD::SELECT && UOpNo == 0)) {
9678         NonFlagUse = true;
9679         break;
9680       }
9681     }
9682
9683     if (!NonFlagUse)
9684       break;
9685   }
9686     // FALL THROUGH
9687   case ISD::SUB:
9688   case ISD::OR:
9689   case ISD::XOR:
9690     // Due to the ISEL shortcoming noted above, be conservative if this op is
9691     // likely to be selected as part of a load-modify-store instruction.
9692     for (SDNode::use_iterator UI = Op.getNode()->use_begin(),
9693            UE = Op.getNode()->use_end(); UI != UE; ++UI)
9694       if (UI->getOpcode() == ISD::STORE)
9695         goto default_case;
9696
9697     // Otherwise use a regular EFLAGS-setting instruction.
9698     switch (ArithOp.getOpcode()) {
9699     default: llvm_unreachable("unexpected operator!");
9700     case ISD::SUB: Opcode = X86ISD::SUB; break;
9701     case ISD::XOR: Opcode = X86ISD::XOR; break;
9702     case ISD::AND: Opcode = X86ISD::AND; break;
9703     case ISD::OR: {
9704       if (!NeedTruncation && (X86CC == X86::COND_E || X86CC == X86::COND_NE)) {
9705         SDValue EFLAGS = LowerVectorAllZeroTest(Op, Subtarget, DAG);
9706         if (EFLAGS.getNode())
9707           return EFLAGS;
9708       }
9709       Opcode = X86ISD::OR;
9710       break;
9711     }
9712     }
9713
9714     NumOperands = 2;
9715     break;
9716   case X86ISD::ADD:
9717   case X86ISD::SUB:
9718   case X86ISD::INC:
9719   case X86ISD::DEC:
9720   case X86ISD::OR:
9721   case X86ISD::XOR:
9722   case X86ISD::AND:
9723     return SDValue(Op.getNode(), 1);
9724   default:
9725   default_case:
9726     break;
9727   }
9728
9729   // If we found that truncation is beneficial, perform the truncation and
9730   // update 'Op'.
9731   if (NeedTruncation) {
9732     EVT VT = Op.getValueType();
9733     SDValue WideVal = Op->getOperand(0);
9734     EVT WideVT = WideVal.getValueType();
9735     unsigned ConvertedOp = 0;
9736     // Use a target machine opcode to prevent further DAGCombine
9737     // optimizations that may separate the arithmetic operations
9738     // from the setcc node.
9739     switch (WideVal.getOpcode()) {
9740       default: break;
9741       case ISD::ADD: ConvertedOp = X86ISD::ADD; break;
9742       case ISD::SUB: ConvertedOp = X86ISD::SUB; break;
9743       case ISD::AND: ConvertedOp = X86ISD::AND; break;
9744       case ISD::OR:  ConvertedOp = X86ISD::OR;  break;
9745       case ISD::XOR: ConvertedOp = X86ISD::XOR; break;
9746     }
9747
9748     if (ConvertedOp) {
9749       const TargetLowering &TLI = DAG.getTargetLoweringInfo();
9750       if (TLI.isOperationLegal(WideVal.getOpcode(), WideVT)) {
9751         SDValue V0 = DAG.getNode(ISD::TRUNCATE, dl, VT, WideVal.getOperand(0));
9752         SDValue V1 = DAG.getNode(ISD::TRUNCATE, dl, VT, WideVal.getOperand(1));
9753         Op = DAG.getNode(ConvertedOp, dl, VT, V0, V1);
9754       }
9755     }
9756   }
9757
9758   if (Opcode == 0)
9759     // Emit a CMP with 0, which is the TEST pattern.
9760     return DAG.getNode(X86ISD::CMP, dl, MVT::i32, Op,
9761                        DAG.getConstant(0, Op.getValueType()));
9762
9763   SDVTList VTs = DAG.getVTList(Op.getValueType(), MVT::i32);
9764   SmallVector<SDValue, 4> Ops;
9765   for (unsigned i = 0; i != NumOperands; ++i)
9766     Ops.push_back(Op.getOperand(i));
9767
9768   SDValue New = DAG.getNode(Opcode, dl, VTs, &Ops[0], NumOperands);
9769   DAG.ReplaceAllUsesWith(Op, New);
9770   return SDValue(New.getNode(), 1);
9771 }
9772
9773 /// Emit nodes that will be selected as "cmp Op0,Op1", or something
9774 /// equivalent.
9775 SDValue X86TargetLowering::EmitCmp(SDValue Op0, SDValue Op1, unsigned X86CC,
9776                                    SelectionDAG &DAG) const {
9777   SDLoc dl(Op0);
9778   if (ConstantSDNode *C = dyn_cast<ConstantSDNode>(Op1)) {
9779     if (C->getAPIntValue() == 0)
9780       return EmitTest(Op0, X86CC, DAG);
9781
9782      if (Op0.getValueType() == MVT::i1)
9783        llvm_unreachable("Unexpected comparison operation for MVT::i1 operands");
9784   }
9785  
9786   if ((Op0.getValueType() == MVT::i8 || Op0.getValueType() == MVT::i16 ||
9787        Op0.getValueType() == MVT::i32 || Op0.getValueType() == MVT::i64)) {
9788     // Do the comparison at i32 if it's smaller. This avoids subregister
9789     // aliasing issues. Keep the smaller reference if we're optimizing for
9790     // size, however, as that'll allow better folding of memory operations.
9791     if (Op0.getValueType() != MVT::i32 && Op0.getValueType() != MVT::i64 &&
9792         !DAG.getMachineFunction().getFunction()->getAttributes().hasAttribute(
9793              AttributeSet::FunctionIndex, Attribute::MinSize)) {
9794       unsigned ExtendOp =
9795           isX86CCUnsigned(X86CC) ? ISD::ZERO_EXTEND : ISD::SIGN_EXTEND;
9796       Op0 = DAG.getNode(ExtendOp, dl, MVT::i32, Op0);
9797       Op1 = DAG.getNode(ExtendOp, dl, MVT::i32, Op1);
9798     }
9799     // Use SUB instead of CMP to enable CSE between SUB and CMP.
9800     SDVTList VTs = DAG.getVTList(Op0.getValueType(), MVT::i32);
9801     SDValue Sub = DAG.getNode(X86ISD::SUB, dl, VTs,
9802                               Op0, Op1);
9803     return SDValue(Sub.getNode(), 1);
9804   }
9805   return DAG.getNode(X86ISD::CMP, dl, MVT::i32, Op0, Op1);
9806 }
9807
9808 /// Convert a comparison if required by the subtarget.
9809 SDValue X86TargetLowering::ConvertCmpIfNecessary(SDValue Cmp,
9810                                                  SelectionDAG &DAG) const {
9811   // If the subtarget does not support the FUCOMI instruction, floating-point
9812   // comparisons have to be converted.
9813   if (Subtarget->hasCMov() ||
9814       Cmp.getOpcode() != X86ISD::CMP ||
9815       !Cmp.getOperand(0).getValueType().isFloatingPoint() ||
9816       !Cmp.getOperand(1).getValueType().isFloatingPoint())
9817     return Cmp;
9818
9819   // The instruction selector will select an FUCOM instruction instead of
9820   // FUCOMI, which writes the comparison result to FPSW instead of EFLAGS. Hence
9821   // build an SDNode sequence that transfers the result from FPSW into EFLAGS:
9822   // (X86sahf (trunc (srl (X86fp_stsw (trunc (X86cmp ...)), 8))))
9823   SDLoc dl(Cmp);
9824   SDValue TruncFPSW = DAG.getNode(ISD::TRUNCATE, dl, MVT::i16, Cmp);
9825   SDValue FNStSW = DAG.getNode(X86ISD::FNSTSW16r, dl, MVT::i16, TruncFPSW);
9826   SDValue Srl = DAG.getNode(ISD::SRL, dl, MVT::i16, FNStSW,
9827                             DAG.getConstant(8, MVT::i8));
9828   SDValue TruncSrl = DAG.getNode(ISD::TRUNCATE, dl, MVT::i8, Srl);
9829   return DAG.getNode(X86ISD::SAHF, dl, MVT::i32, TruncSrl);
9830 }
9831
9832 static bool isAllOnes(SDValue V) {
9833   ConstantSDNode *C = dyn_cast<ConstantSDNode>(V);
9834   return C && C->isAllOnesValue();
9835 }
9836
9837 /// LowerToBT - Result of 'and' is compared against zero. Turn it into a BT node
9838 /// if it's possible.
9839 SDValue X86TargetLowering::LowerToBT(SDValue And, ISD::CondCode CC,
9840                                      SDLoc dl, SelectionDAG &DAG) const {
9841   SDValue Op0 = And.getOperand(0);
9842   SDValue Op1 = And.getOperand(1);
9843   if (Op0.getOpcode() == ISD::TRUNCATE)
9844     Op0 = Op0.getOperand(0);
9845   if (Op1.getOpcode() == ISD::TRUNCATE)
9846     Op1 = Op1.getOperand(0);
9847
9848   SDValue LHS, RHS;
9849   if (Op1.getOpcode() == ISD::SHL)
9850     std::swap(Op0, Op1);
9851   if (Op0.getOpcode() == ISD::SHL) {
9852     if (ConstantSDNode *And00C = dyn_cast<ConstantSDNode>(Op0.getOperand(0)))
9853       if (And00C->getZExtValue() == 1) {
9854         // If we looked past a truncate, check that it's only truncating away
9855         // known zeros.
9856         unsigned BitWidth = Op0.getValueSizeInBits();
9857         unsigned AndBitWidth = And.getValueSizeInBits();
9858         if (BitWidth > AndBitWidth) {
9859           APInt Zeros, Ones;
9860           DAG.ComputeMaskedBits(Op0, Zeros, Ones);
9861           if (Zeros.countLeadingOnes() < BitWidth - AndBitWidth)
9862             return SDValue();
9863         }
9864         LHS = Op1;
9865         RHS = Op0.getOperand(1);
9866       }
9867   } else if (Op1.getOpcode() == ISD::Constant) {
9868     ConstantSDNode *AndRHS = cast<ConstantSDNode>(Op1);
9869     uint64_t AndRHSVal = AndRHS->getZExtValue();
9870     SDValue AndLHS = Op0;
9871
9872     if (AndRHSVal == 1 && AndLHS.getOpcode() == ISD::SRL) {
9873       LHS = AndLHS.getOperand(0);
9874       RHS = AndLHS.getOperand(1);
9875     }
9876
9877     // Use BT if the immediate can't be encoded in a TEST instruction.
9878     if (!isUInt<32>(AndRHSVal) && isPowerOf2_64(AndRHSVal)) {
9879       LHS = AndLHS;
9880       RHS = DAG.getConstant(Log2_64_Ceil(AndRHSVal), LHS.getValueType());
9881     }
9882   }
9883
9884   if (LHS.getNode()) {
9885     // If LHS is i8, promote it to i32 with any_extend.  There is no i8 BT
9886     // instruction.  Since the shift amount is in-range-or-undefined, we know
9887     // that doing a bittest on the i32 value is ok.  We extend to i32 because
9888     // the encoding for the i16 version is larger than the i32 version.
9889     // Also promote i16 to i32 for performance / code size reason.
9890     if (LHS.getValueType() == MVT::i8 ||
9891         LHS.getValueType() == MVT::i16)
9892       LHS = DAG.getNode(ISD::ANY_EXTEND, dl, MVT::i32, LHS);
9893
9894     // If the operand types disagree, extend the shift amount to match.  Since
9895     // BT ignores high bits (like shifts) we can use anyextend.
9896     if (LHS.getValueType() != RHS.getValueType())
9897       RHS = DAG.getNode(ISD::ANY_EXTEND, dl, LHS.getValueType(), RHS);
9898
9899     SDValue BT = DAG.getNode(X86ISD::BT, dl, MVT::i32, LHS, RHS);
9900     X86::CondCode Cond = CC == ISD::SETEQ ? X86::COND_AE : X86::COND_B;
9901     return DAG.getNode(X86ISD::SETCC, dl, MVT::i8,
9902                        DAG.getConstant(Cond, MVT::i8), BT);
9903   }
9904
9905   return SDValue();
9906 }
9907
9908 /// \brief - Turns an ISD::CondCode into a value suitable for SSE floating point
9909 /// mask CMPs.
9910 static int translateX86FSETCC(ISD::CondCode SetCCOpcode, SDValue &Op0,
9911                               SDValue &Op1) {
9912   unsigned SSECC;
9913   bool Swap = false;
9914
9915   // SSE Condition code mapping:
9916   //  0 - EQ
9917   //  1 - LT
9918   //  2 - LE
9919   //  3 - UNORD
9920   //  4 - NEQ
9921   //  5 - NLT
9922   //  6 - NLE
9923   //  7 - ORD
9924   switch (SetCCOpcode) {
9925   default: llvm_unreachable("Unexpected SETCC condition");
9926   case ISD::SETOEQ:
9927   case ISD::SETEQ:  SSECC = 0; break;
9928   case ISD::SETOGT:
9929   case ISD::SETGT:  Swap = true; // Fallthrough
9930   case ISD::SETLT:
9931   case ISD::SETOLT: SSECC = 1; break;
9932   case ISD::SETOGE:
9933   case ISD::SETGE:  Swap = true; // Fallthrough
9934   case ISD::SETLE:
9935   case ISD::SETOLE: SSECC = 2; break;
9936   case ISD::SETUO:  SSECC = 3; break;
9937   case ISD::SETUNE:
9938   case ISD::SETNE:  SSECC = 4; break;
9939   case ISD::SETULE: Swap = true; // Fallthrough
9940   case ISD::SETUGE: SSECC = 5; break;
9941   case ISD::SETULT: Swap = true; // Fallthrough
9942   case ISD::SETUGT: SSECC = 6; break;
9943   case ISD::SETO:   SSECC = 7; break;
9944   case ISD::SETUEQ:
9945   case ISD::SETONE: SSECC = 8; break;
9946   }
9947   if (Swap)
9948     std::swap(Op0, Op1);
9949
9950   return SSECC;
9951 }
9952
9953 // Lower256IntVSETCC - Break a VSETCC 256-bit integer VSETCC into two new 128
9954 // ones, and then concatenate the result back.
9955 static SDValue Lower256IntVSETCC(SDValue Op, SelectionDAG &DAG) {
9956   MVT VT = Op.getSimpleValueType();
9957
9958   assert(VT.is256BitVector() && Op.getOpcode() == ISD::SETCC &&
9959          "Unsupported value type for operation");
9960
9961   unsigned NumElems = VT.getVectorNumElements();
9962   SDLoc dl(Op);
9963   SDValue CC = Op.getOperand(2);
9964
9965   // Extract the LHS vectors
9966   SDValue LHS = Op.getOperand(0);
9967   SDValue LHS1 = Extract128BitVector(LHS, 0, DAG, dl);
9968   SDValue LHS2 = Extract128BitVector(LHS, NumElems/2, DAG, dl);
9969
9970   // Extract the RHS vectors
9971   SDValue RHS = Op.getOperand(1);
9972   SDValue RHS1 = Extract128BitVector(RHS, 0, DAG, dl);
9973   SDValue RHS2 = Extract128BitVector(RHS, NumElems/2, DAG, dl);
9974
9975   // Issue the operation on the smaller types and concatenate the result back
9976   MVT EltVT = VT.getVectorElementType();
9977   MVT NewVT = MVT::getVectorVT(EltVT, NumElems/2);
9978   return DAG.getNode(ISD::CONCAT_VECTORS, dl, VT,
9979                      DAG.getNode(Op.getOpcode(), dl, NewVT, LHS1, RHS1, CC),
9980                      DAG.getNode(Op.getOpcode(), dl, NewVT, LHS2, RHS2, CC));
9981 }
9982
9983 static SDValue LowerIntVSETCC_AVX512(SDValue Op, SelectionDAG &DAG,
9984                                      const X86Subtarget *Subtarget) {
9985   SDValue Op0 = Op.getOperand(0);
9986   SDValue Op1 = Op.getOperand(1);
9987   SDValue CC = Op.getOperand(2);
9988   MVT VT = Op.getSimpleValueType();
9989   SDLoc dl(Op);
9990
9991   assert(Op0.getValueType().getVectorElementType().getSizeInBits() >= 32 &&
9992          Op.getValueType().getScalarType() == MVT::i1 &&
9993          "Cannot set masked compare for this operation");
9994
9995   ISD::CondCode SetCCOpcode = cast<CondCodeSDNode>(CC)->get();
9996   unsigned  Opc = 0;
9997   bool Unsigned = false;
9998   bool Swap = false;
9999   unsigned SSECC;
10000   switch (SetCCOpcode) {
10001   default: llvm_unreachable("Unexpected SETCC condition");
10002   case ISD::SETNE:  SSECC = 4; break;
10003   case ISD::SETEQ:  Opc = X86ISD::PCMPEQM; break;
10004   case ISD::SETUGT: SSECC = 6; Unsigned = true; break;
10005   case ISD::SETLT:  Swap = true; //fall-through
10006   case ISD::SETGT:  Opc = X86ISD::PCMPGTM; break;
10007   case ISD::SETULT: SSECC = 1; Unsigned = true; break;
10008   case ISD::SETUGE: SSECC = 5; Unsigned = true; break; //NLT
10009   case ISD::SETGE:  Swap = true; SSECC = 2; break; // LE + swap
10010   case ISD::SETULE: Unsigned = true; //fall-through
10011   case ISD::SETLE:  SSECC = 2; break;
10012   }
10013
10014   if (Swap)
10015     std::swap(Op0, Op1);
10016   if (Opc)
10017     return DAG.getNode(Opc, dl, VT, Op0, Op1);
10018   Opc = Unsigned ? X86ISD::CMPMU: X86ISD::CMPM;
10019   return DAG.getNode(Opc, dl, VT, Op0, Op1,
10020                      DAG.getConstant(SSECC, MVT::i8));
10021 }
10022
10023 /// \brief Try to turn a VSETULT into a VSETULE by modifying its second
10024 /// operand \p Op1.  If non-trivial (for example because it's not constant)
10025 /// return an empty value.
10026 static SDValue ChangeVSETULTtoVSETULE(SDValue Op1, SelectionDAG &DAG)
10027 {
10028   BuildVectorSDNode *BV = dyn_cast<BuildVectorSDNode>(Op1.getNode());
10029   if (!BV)
10030     return SDValue();
10031
10032   MVT VT = Op1.getSimpleValueType();
10033   MVT EVT = VT.getVectorElementType();
10034   unsigned n = VT.getVectorNumElements();
10035   SmallVector<SDValue, 8> ULTOp1;
10036
10037   for (unsigned i = 0; i < n; ++i) {
10038     ConstantSDNode *Elt = dyn_cast<ConstantSDNode>(BV->getOperand(i));
10039     if (!Elt || Elt->isOpaque() || Elt->getValueType(0) != EVT)
10040       return SDValue();
10041
10042     // Avoid underflow.
10043     APInt Val = Elt->getAPIntValue();
10044     if (Val == 0)
10045       return SDValue();
10046
10047     ULTOp1.push_back(DAG.getConstant(Val - 1, EVT));
10048   }
10049
10050   return DAG.getNode(ISD::BUILD_VECTOR, SDLoc(Op1), VT, ULTOp1.data(),
10051                      ULTOp1.size());
10052 }
10053
10054 static SDValue LowerVSETCC(SDValue Op, const X86Subtarget *Subtarget,
10055                            SelectionDAG &DAG) {
10056   SDValue Op0 = Op.getOperand(0);
10057   SDValue Op1 = Op.getOperand(1);
10058   SDValue CC = Op.getOperand(2);
10059   MVT VT = Op.getSimpleValueType();
10060   ISD::CondCode SetCCOpcode = cast<CondCodeSDNode>(CC)->get();
10061   bool isFP = Op.getOperand(1).getSimpleValueType().isFloatingPoint();
10062   SDLoc dl(Op);
10063
10064   if (isFP) {
10065 #ifndef NDEBUG
10066     MVT EltVT = Op0.getSimpleValueType().getVectorElementType();
10067     assert(EltVT == MVT::f32 || EltVT == MVT::f64);
10068 #endif
10069
10070     unsigned SSECC = translateX86FSETCC(SetCCOpcode, Op0, Op1);
10071     unsigned Opc = X86ISD::CMPP;
10072     if (Subtarget->hasAVX512() && VT.getVectorElementType() == MVT::i1) {
10073       assert(VT.getVectorNumElements() <= 16);
10074       Opc = X86ISD::CMPM;
10075     }
10076     // In the two special cases we can't handle, emit two comparisons.
10077     if (SSECC == 8) {
10078       unsigned CC0, CC1;
10079       unsigned CombineOpc;
10080       if (SetCCOpcode == ISD::SETUEQ) {
10081         CC0 = 3; CC1 = 0; CombineOpc = ISD::OR;
10082       } else {
10083         assert(SetCCOpcode == ISD::SETONE);
10084         CC0 = 7; CC1 = 4; CombineOpc = ISD::AND;
10085       }
10086
10087       SDValue Cmp0 = DAG.getNode(Opc, dl, VT, Op0, Op1,
10088                                  DAG.getConstant(CC0, MVT::i8));
10089       SDValue Cmp1 = DAG.getNode(Opc, dl, VT, Op0, Op1,
10090                                  DAG.getConstant(CC1, MVT::i8));
10091       return DAG.getNode(CombineOpc, dl, VT, Cmp0, Cmp1);
10092     }
10093     // Handle all other FP comparisons here.
10094     return DAG.getNode(Opc, dl, VT, Op0, Op1,
10095                        DAG.getConstant(SSECC, MVT::i8));
10096   }
10097
10098   // Break 256-bit integer vector compare into smaller ones.
10099   if (VT.is256BitVector() && !Subtarget->hasInt256())
10100     return Lower256IntVSETCC(Op, DAG);
10101
10102   bool MaskResult = (VT.getVectorElementType() == MVT::i1);
10103   EVT OpVT = Op1.getValueType();
10104   if (Subtarget->hasAVX512()) {
10105     if (Op1.getValueType().is512BitVector() ||
10106         (MaskResult && OpVT.getVectorElementType().getSizeInBits() >= 32))
10107       return LowerIntVSETCC_AVX512(Op, DAG, Subtarget);
10108
10109     // In AVX-512 architecture setcc returns mask with i1 elements,
10110     // But there is no compare instruction for i8 and i16 elements.
10111     // We are not talking about 512-bit operands in this case, these
10112     // types are illegal.
10113     if (MaskResult &&
10114         (OpVT.getVectorElementType().getSizeInBits() < 32 &&
10115          OpVT.getVectorElementType().getSizeInBits() >= 8))
10116       return DAG.getNode(ISD::TRUNCATE, dl, VT,
10117                          DAG.getNode(ISD::SETCC, dl, OpVT, Op0, Op1, CC));
10118   }
10119
10120   // We are handling one of the integer comparisons here.  Since SSE only has
10121   // GT and EQ comparisons for integer, swapping operands and multiple
10122   // operations may be required for some comparisons.
10123   unsigned Opc;
10124   bool Swap = false, Invert = false, FlipSigns = false, MinMax = false;
10125   bool Subus = false;
10126
10127   switch (SetCCOpcode) {
10128   default: llvm_unreachable("Unexpected SETCC condition");
10129   case ISD::SETNE:  Invert = true;
10130   case ISD::SETEQ:  Opc = X86ISD::PCMPEQ; break;
10131   case ISD::SETLT:  Swap = true;
10132   case ISD::SETGT:  Opc = X86ISD::PCMPGT; break;
10133   case ISD::SETGE:  Swap = true;
10134   case ISD::SETLE:  Opc = X86ISD::PCMPGT;
10135                     Invert = true; break;
10136   case ISD::SETULT: Swap = true;
10137   case ISD::SETUGT: Opc = X86ISD::PCMPGT;
10138                     FlipSigns = true; break;
10139   case ISD::SETUGE: Swap = true;
10140   case ISD::SETULE: Opc = X86ISD::PCMPGT;
10141                     FlipSigns = true; Invert = true; break;
10142   }
10143
10144   // Special case: Use min/max operations for SETULE/SETUGE
10145   MVT VET = VT.getVectorElementType();
10146   bool hasMinMax =
10147        (Subtarget->hasSSE41() && (VET >= MVT::i8 && VET <= MVT::i32))
10148     || (Subtarget->hasSSE2()  && (VET == MVT::i8));
10149
10150   if (hasMinMax) {
10151     switch (SetCCOpcode) {
10152     default: break;
10153     case ISD::SETULE: Opc = X86ISD::UMIN; MinMax = true; break;
10154     case ISD::SETUGE: Opc = X86ISD::UMAX; MinMax = true; break;
10155     }
10156
10157     if (MinMax) { Swap = false; Invert = false; FlipSigns = false; }
10158   }
10159
10160   bool hasSubus = Subtarget->hasSSE2() && (VET == MVT::i8 || VET == MVT::i16);
10161   if (!MinMax && hasSubus) {
10162     // As another special case, use PSUBUS[BW] when it's profitable. E.g. for
10163     // Op0 u<= Op1:
10164     //   t = psubus Op0, Op1
10165     //   pcmpeq t, <0..0>
10166     switch (SetCCOpcode) {
10167     default: break;
10168     case ISD::SETULT: {
10169       // If the comparison is against a constant we can turn this into a
10170       // setule.  With psubus, setule does not require a swap.  This is
10171       // beneficial because the constant in the register is no longer
10172       // destructed as the destination so it can be hoisted out of a loop.
10173       // Only do this pre-AVX since vpcmp* is no longer destructive.
10174       if (Subtarget->hasAVX())
10175         break;
10176       SDValue ULEOp1 = ChangeVSETULTtoVSETULE(Op1, DAG);
10177       if (ULEOp1.getNode()) {
10178         Op1 = ULEOp1;
10179         Subus = true; Invert = false; Swap = false;
10180       }
10181       break;
10182     }
10183     // Psubus is better than flip-sign because it requires no inversion.
10184     case ISD::SETUGE: Subus = true; Invert = false; Swap = true;  break;
10185     case ISD::SETULE: Subus = true; Invert = false; Swap = false; break;
10186     }
10187
10188     if (Subus) {
10189       Opc = X86ISD::SUBUS;
10190       FlipSigns = false;
10191     }
10192   }
10193
10194   if (Swap)
10195     std::swap(Op0, Op1);
10196
10197   // Check that the operation in question is available (most are plain SSE2,
10198   // but PCMPGTQ and PCMPEQQ have different requirements).
10199   if (VT == MVT::v2i64) {
10200     if (Opc == X86ISD::PCMPGT && !Subtarget->hasSSE42()) {
10201       assert(Subtarget->hasSSE2() && "Don't know how to lower!");
10202
10203       // First cast everything to the right type.
10204       Op0 = DAG.getNode(ISD::BITCAST, dl, MVT::v4i32, Op0);
10205       Op1 = DAG.getNode(ISD::BITCAST, dl, MVT::v4i32, Op1);
10206
10207       // Since SSE has no unsigned integer comparisons, we need to flip the sign
10208       // bits of the inputs before performing those operations. The lower
10209       // compare is always unsigned.
10210       SDValue SB;
10211       if (FlipSigns) {
10212         SB = DAG.getConstant(0x80000000U, MVT::v4i32);
10213       } else {
10214         SDValue Sign = DAG.getConstant(0x80000000U, MVT::i32);
10215         SDValue Zero = DAG.getConstant(0x00000000U, MVT::i32);
10216         SB = DAG.getNode(ISD::BUILD_VECTOR, dl, MVT::v4i32,
10217                          Sign, Zero, Sign, Zero);
10218       }
10219       Op0 = DAG.getNode(ISD::XOR, dl, MVT::v4i32, Op0, SB);
10220       Op1 = DAG.getNode(ISD::XOR, dl, MVT::v4i32, Op1, SB);
10221
10222       // Emulate PCMPGTQ with (hi1 > hi2) | ((hi1 == hi2) & (lo1 > lo2))
10223       SDValue GT = DAG.getNode(X86ISD::PCMPGT, dl, MVT::v4i32, Op0, Op1);
10224       SDValue EQ = DAG.getNode(X86ISD::PCMPEQ, dl, MVT::v4i32, Op0, Op1);
10225
10226       // Create masks for only the low parts/high parts of the 64 bit integers.
10227       static const int MaskHi[] = { 1, 1, 3, 3 };
10228       static const int MaskLo[] = { 0, 0, 2, 2 };
10229       SDValue EQHi = DAG.getVectorShuffle(MVT::v4i32, dl, EQ, EQ, MaskHi);
10230       SDValue GTLo = DAG.getVectorShuffle(MVT::v4i32, dl, GT, GT, MaskLo);
10231       SDValue GTHi = DAG.getVectorShuffle(MVT::v4i32, dl, GT, GT, MaskHi);
10232
10233       SDValue Result = DAG.getNode(ISD::AND, dl, MVT::v4i32, EQHi, GTLo);
10234       Result = DAG.getNode(ISD::OR, dl, MVT::v4i32, Result, GTHi);
10235
10236       if (Invert)
10237         Result = DAG.getNOT(dl, Result, MVT::v4i32);
10238
10239       return DAG.getNode(ISD::BITCAST, dl, VT, Result);
10240     }
10241
10242     if (Opc == X86ISD::PCMPEQ && !Subtarget->hasSSE41()) {
10243       // If pcmpeqq is missing but pcmpeqd is available synthesize pcmpeqq with
10244       // pcmpeqd + pshufd + pand.
10245       assert(Subtarget->hasSSE2() && !FlipSigns && "Don't know how to lower!");
10246
10247       // First cast everything to the right type.
10248       Op0 = DAG.getNode(ISD::BITCAST, dl, MVT::v4i32, Op0);
10249       Op1 = DAG.getNode(ISD::BITCAST, dl, MVT::v4i32, Op1);
10250
10251       // Do the compare.
10252       SDValue Result = DAG.getNode(Opc, dl, MVT::v4i32, Op0, Op1);
10253
10254       // Make sure the lower and upper halves are both all-ones.
10255       static const int Mask[] = { 1, 0, 3, 2 };
10256       SDValue Shuf = DAG.getVectorShuffle(MVT::v4i32, dl, Result, Result, Mask);
10257       Result = DAG.getNode(ISD::AND, dl, MVT::v4i32, Result, Shuf);
10258
10259       if (Invert)
10260         Result = DAG.getNOT(dl, Result, MVT::v4i32);
10261
10262       return DAG.getNode(ISD::BITCAST, dl, VT, Result);
10263     }
10264   }
10265
10266   // Since SSE has no unsigned integer comparisons, we need to flip the sign
10267   // bits of the inputs before performing those operations.
10268   if (FlipSigns) {
10269     EVT EltVT = VT.getVectorElementType();
10270     SDValue SB = DAG.getConstant(APInt::getSignBit(EltVT.getSizeInBits()), VT);
10271     Op0 = DAG.getNode(ISD::XOR, dl, VT, Op0, SB);
10272     Op1 = DAG.getNode(ISD::XOR, dl, VT, Op1, SB);
10273   }
10274
10275   SDValue Result = DAG.getNode(Opc, dl, VT, Op0, Op1);
10276
10277   // If the logical-not of the result is required, perform that now.
10278   if (Invert)
10279     Result = DAG.getNOT(dl, Result, VT);
10280
10281   if (MinMax)
10282     Result = DAG.getNode(X86ISD::PCMPEQ, dl, VT, Op0, Result);
10283
10284   if (Subus)
10285     Result = DAG.getNode(X86ISD::PCMPEQ, dl, VT, Result,
10286                          getZeroVector(VT, Subtarget, DAG, dl));
10287
10288   return Result;
10289 }
10290
10291 SDValue X86TargetLowering::LowerSETCC(SDValue Op, SelectionDAG &DAG) const {
10292
10293   MVT VT = Op.getSimpleValueType();
10294
10295   if (VT.isVector()) return LowerVSETCC(Op, Subtarget, DAG);
10296
10297   assert(((!Subtarget->hasAVX512() && VT == MVT::i8) || (VT == MVT::i1))
10298          && "SetCC type must be 8-bit or 1-bit integer");
10299   SDValue Op0 = Op.getOperand(0);
10300   SDValue Op1 = Op.getOperand(1);
10301   SDLoc dl(Op);
10302   ISD::CondCode CC = cast<CondCodeSDNode>(Op.getOperand(2))->get();
10303
10304   // Optimize to BT if possible.
10305   // Lower (X & (1 << N)) == 0 to BT(X, N).
10306   // Lower ((X >>u N) & 1) != 0 to BT(X, N).
10307   // Lower ((X >>s N) & 1) != 0 to BT(X, N).
10308   if (Op0.getOpcode() == ISD::AND && Op0.hasOneUse() &&
10309       Op1.getOpcode() == ISD::Constant &&
10310       cast<ConstantSDNode>(Op1)->isNullValue() &&
10311       (CC == ISD::SETEQ || CC == ISD::SETNE)) {
10312     SDValue NewSetCC = LowerToBT(Op0, CC, dl, DAG);
10313     if (NewSetCC.getNode())
10314       return NewSetCC;
10315   }
10316
10317   // Look for X == 0, X == 1, X != 0, or X != 1.  We can simplify some forms of
10318   // these.
10319   if (Op1.getOpcode() == ISD::Constant &&
10320       (cast<ConstantSDNode>(Op1)->getZExtValue() == 1 ||
10321        cast<ConstantSDNode>(Op1)->isNullValue()) &&
10322       (CC == ISD::SETEQ || CC == ISD::SETNE)) {
10323
10324     // If the input is a setcc, then reuse the input setcc or use a new one with
10325     // the inverted condition.
10326     if (Op0.getOpcode() == X86ISD::SETCC) {
10327       X86::CondCode CCode = (X86::CondCode)Op0.getConstantOperandVal(0);
10328       bool Invert = (CC == ISD::SETNE) ^
10329         cast<ConstantSDNode>(Op1)->isNullValue();
10330       if (!Invert)
10331         return Op0;
10332
10333       CCode = X86::GetOppositeBranchCondition(CCode);
10334       SDValue SetCC = DAG.getNode(X86ISD::SETCC, dl, MVT::i8,
10335                                   DAG.getConstant(CCode, MVT::i8),
10336                                   Op0.getOperand(1));
10337       if (VT == MVT::i1)
10338         return DAG.getNode(ISD::TRUNCATE, dl, MVT::i1, SetCC);
10339       return SetCC;
10340     }
10341   }
10342   if ((Op0.getValueType() == MVT::i1) && (Op1.getOpcode() == ISD::Constant) &&
10343       (cast<ConstantSDNode>(Op1)->getZExtValue() == 1) &&
10344       (CC == ISD::SETEQ || CC == ISD::SETNE)) {
10345
10346     ISD::CondCode NewCC = ISD::getSetCCInverse(CC, true);
10347     return DAG.getSetCC(dl, VT, Op0, DAG.getConstant(0, MVT::i1), NewCC);
10348   }
10349
10350   bool isFP = Op1.getSimpleValueType().isFloatingPoint();
10351   unsigned X86CC = TranslateX86CC(CC, isFP, Op0, Op1, DAG);
10352   if (X86CC == X86::COND_INVALID)
10353     return SDValue();
10354
10355   SDValue EFLAGS = EmitCmp(Op0, Op1, X86CC, DAG);
10356   EFLAGS = ConvertCmpIfNecessary(EFLAGS, DAG);
10357   SDValue SetCC = DAG.getNode(X86ISD::SETCC, dl, MVT::i8,
10358                               DAG.getConstant(X86CC, MVT::i8), EFLAGS);
10359   if (VT == MVT::i1)
10360     return DAG.getNode(ISD::TRUNCATE, dl, MVT::i1, SetCC);
10361   return SetCC;
10362 }
10363
10364 // isX86LogicalCmp - Return true if opcode is a X86 logical comparison.
10365 static bool isX86LogicalCmp(SDValue Op) {
10366   unsigned Opc = Op.getNode()->getOpcode();
10367   if (Opc == X86ISD::CMP || Opc == X86ISD::COMI || Opc == X86ISD::UCOMI ||
10368       Opc == X86ISD::SAHF)
10369     return true;
10370   if (Op.getResNo() == 1 &&
10371       (Opc == X86ISD::ADD ||
10372        Opc == X86ISD::SUB ||
10373        Opc == X86ISD::ADC ||
10374        Opc == X86ISD::SBB ||
10375        Opc == X86ISD::SMUL ||
10376        Opc == X86ISD::UMUL ||
10377        Opc == X86ISD::INC ||
10378        Opc == X86ISD::DEC ||
10379        Opc == X86ISD::OR ||
10380        Opc == X86ISD::XOR ||
10381        Opc == X86ISD::AND))
10382     return true;
10383
10384   if (Op.getResNo() == 2 && Opc == X86ISD::UMUL)
10385     return true;
10386
10387   return false;
10388 }
10389
10390 static bool isZero(SDValue V) {
10391   ConstantSDNode *C = dyn_cast<ConstantSDNode>(V);
10392   return C && C->isNullValue();
10393 }
10394
10395 static bool isTruncWithZeroHighBitsInput(SDValue V, SelectionDAG &DAG) {
10396   if (V.getOpcode() != ISD::TRUNCATE)
10397     return false;
10398
10399   SDValue VOp0 = V.getOperand(0);
10400   unsigned InBits = VOp0.getValueSizeInBits();
10401   unsigned Bits = V.getValueSizeInBits();
10402   return DAG.MaskedValueIsZero(VOp0, APInt::getHighBitsSet(InBits,InBits-Bits));
10403 }
10404
10405 SDValue X86TargetLowering::LowerSELECT(SDValue Op, SelectionDAG &DAG) const {
10406   bool addTest = true;
10407   SDValue Cond  = Op.getOperand(0);
10408   SDValue Op1 = Op.getOperand(1);
10409   SDValue Op2 = Op.getOperand(2);
10410   SDLoc DL(Op);
10411   EVT VT = Op1.getValueType();
10412   SDValue CC;
10413
10414   // Lower fp selects into a CMP/AND/ANDN/OR sequence when the necessary SSE ops
10415   // are available. Otherwise fp cmovs get lowered into a less efficient branch
10416   // sequence later on.
10417   if (Cond.getOpcode() == ISD::SETCC &&
10418       ((Subtarget->hasSSE2() && (VT == MVT::f32 || VT == MVT::f64)) ||
10419        (Subtarget->hasSSE1() && VT == MVT::f32)) &&
10420       VT == Cond.getOperand(0).getValueType() && Cond->hasOneUse()) {
10421     SDValue CondOp0 = Cond.getOperand(0), CondOp1 = Cond.getOperand(1);
10422     int SSECC = translateX86FSETCC(
10423         cast<CondCodeSDNode>(Cond.getOperand(2))->get(), CondOp0, CondOp1);
10424
10425     if (SSECC != 8) {
10426       if (Subtarget->hasAVX512()) {
10427         SDValue Cmp = DAG.getNode(X86ISD::FSETCC, DL, MVT::i1, CondOp0, CondOp1,
10428                                   DAG.getConstant(SSECC, MVT::i8));
10429         return DAG.getNode(X86ISD::SELECT, DL, VT, Cmp, Op1, Op2);
10430       }
10431       SDValue Cmp = DAG.getNode(X86ISD::FSETCC, DL, VT, CondOp0, CondOp1,
10432                                 DAG.getConstant(SSECC, MVT::i8));
10433       SDValue AndN = DAG.getNode(X86ISD::FANDN, DL, VT, Cmp, Op2);
10434       SDValue And = DAG.getNode(X86ISD::FAND, DL, VT, Cmp, Op1);
10435       return DAG.getNode(X86ISD::FOR, DL, VT, AndN, And);
10436     }
10437   }
10438
10439   if (Cond.getOpcode() == ISD::SETCC) {
10440     SDValue NewCond = LowerSETCC(Cond, DAG);
10441     if (NewCond.getNode())
10442       Cond = NewCond;
10443   }
10444
10445   // (select (x == 0), -1, y) -> (sign_bit (x - 1)) | y
10446   // (select (x == 0), y, -1) -> ~(sign_bit (x - 1)) | y
10447   // (select (x != 0), y, -1) -> (sign_bit (x - 1)) | y
10448   // (select (x != 0), -1, y) -> ~(sign_bit (x - 1)) | y
10449   if (Cond.getOpcode() == X86ISD::SETCC &&
10450       Cond.getOperand(1).getOpcode() == X86ISD::CMP &&
10451       isZero(Cond.getOperand(1).getOperand(1))) {
10452     SDValue Cmp = Cond.getOperand(1);
10453
10454     unsigned CondCode =cast<ConstantSDNode>(Cond.getOperand(0))->getZExtValue();
10455
10456     if ((isAllOnes(Op1) || isAllOnes(Op2)) &&
10457         (CondCode == X86::COND_E || CondCode == X86::COND_NE)) {
10458       SDValue Y = isAllOnes(Op2) ? Op1 : Op2;
10459
10460       SDValue CmpOp0 = Cmp.getOperand(0);
10461       // Apply further optimizations for special cases
10462       // (select (x != 0), -1, 0) -> neg & sbb
10463       // (select (x == 0), 0, -1) -> neg & sbb
10464       if (ConstantSDNode *YC = dyn_cast<ConstantSDNode>(Y))
10465         if (YC->isNullValue() &&
10466             (isAllOnes(Op1) == (CondCode == X86::COND_NE))) {
10467           SDVTList VTs = DAG.getVTList(CmpOp0.getValueType(), MVT::i32);
10468           SDValue Neg = DAG.getNode(X86ISD::SUB, DL, VTs,
10469                                     DAG.getConstant(0, CmpOp0.getValueType()),
10470                                     CmpOp0);
10471           SDValue Res = DAG.getNode(X86ISD::SETCC_CARRY, DL, Op.getValueType(),
10472                                     DAG.getConstant(X86::COND_B, MVT::i8),
10473                                     SDValue(Neg.getNode(), 1));
10474           return Res;
10475         }
10476
10477       Cmp = DAG.getNode(X86ISD::CMP, DL, MVT::i32,
10478                         CmpOp0, DAG.getConstant(1, CmpOp0.getValueType()));
10479       Cmp = ConvertCmpIfNecessary(Cmp, DAG);
10480
10481       SDValue Res =   // Res = 0 or -1.
10482         DAG.getNode(X86ISD::SETCC_CARRY, DL, Op.getValueType(),
10483                     DAG.getConstant(X86::COND_B, MVT::i8), Cmp);
10484
10485       if (isAllOnes(Op1) != (CondCode == X86::COND_E))
10486         Res = DAG.getNOT(DL, Res, Res.getValueType());
10487
10488       ConstantSDNode *N2C = dyn_cast<ConstantSDNode>(Op2);
10489       if (N2C == 0 || !N2C->isNullValue())
10490         Res = DAG.getNode(ISD::OR, DL, Res.getValueType(), Res, Y);
10491       return Res;
10492     }
10493   }
10494
10495   // Look past (and (setcc_carry (cmp ...)), 1).
10496   if (Cond.getOpcode() == ISD::AND &&
10497       Cond.getOperand(0).getOpcode() == X86ISD::SETCC_CARRY) {
10498     ConstantSDNode *C = dyn_cast<ConstantSDNode>(Cond.getOperand(1));
10499     if (C && C->getAPIntValue() == 1)
10500       Cond = Cond.getOperand(0);
10501   }
10502
10503   // If condition flag is set by a X86ISD::CMP, then use it as the condition
10504   // setting operand in place of the X86ISD::SETCC.
10505   unsigned CondOpcode = Cond.getOpcode();
10506   if (CondOpcode == X86ISD::SETCC ||
10507       CondOpcode == X86ISD::SETCC_CARRY) {
10508     CC = Cond.getOperand(0);
10509
10510     SDValue Cmp = Cond.getOperand(1);
10511     unsigned Opc = Cmp.getOpcode();
10512     MVT VT = Op.getSimpleValueType();
10513
10514     bool IllegalFPCMov = false;
10515     if (VT.isFloatingPoint() && !VT.isVector() &&
10516         !isScalarFPTypeInSSEReg(VT))  // FPStack?
10517       IllegalFPCMov = !hasFPCMov(cast<ConstantSDNode>(CC)->getSExtValue());
10518
10519     if ((isX86LogicalCmp(Cmp) && !IllegalFPCMov) ||
10520         Opc == X86ISD::BT) { // FIXME
10521       Cond = Cmp;
10522       addTest = false;
10523     }
10524   } else if (CondOpcode == ISD::USUBO || CondOpcode == ISD::SSUBO ||
10525              CondOpcode == ISD::UADDO || CondOpcode == ISD::SADDO ||
10526              ((CondOpcode == ISD::UMULO || CondOpcode == ISD::SMULO) &&
10527               Cond.getOperand(0).getValueType() != MVT::i8)) {
10528     SDValue LHS = Cond.getOperand(0);
10529     SDValue RHS = Cond.getOperand(1);
10530     unsigned X86Opcode;
10531     unsigned X86Cond;
10532     SDVTList VTs;
10533     switch (CondOpcode) {
10534     case ISD::UADDO: X86Opcode = X86ISD::ADD; X86Cond = X86::COND_B; break;
10535     case ISD::SADDO: X86Opcode = X86ISD::ADD; X86Cond = X86::COND_O; break;
10536     case ISD::USUBO: X86Opcode = X86ISD::SUB; X86Cond = X86::COND_B; break;
10537     case ISD::SSUBO: X86Opcode = X86ISD::SUB; X86Cond = X86::COND_O; break;
10538     case ISD::UMULO: X86Opcode = X86ISD::UMUL; X86Cond = X86::COND_O; break;
10539     case ISD::SMULO: X86Opcode = X86ISD::SMUL; X86Cond = X86::COND_O; break;
10540     default: llvm_unreachable("unexpected overflowing operator");
10541     }
10542     if (CondOpcode == ISD::UMULO)
10543       VTs = DAG.getVTList(LHS.getValueType(), LHS.getValueType(),
10544                           MVT::i32);
10545     else
10546       VTs = DAG.getVTList(LHS.getValueType(), MVT::i32);
10547
10548     SDValue X86Op = DAG.getNode(X86Opcode, DL, VTs, LHS, RHS);
10549
10550     if (CondOpcode == ISD::UMULO)
10551       Cond = X86Op.getValue(2);
10552     else
10553       Cond = X86Op.getValue(1);
10554
10555     CC = DAG.getConstant(X86Cond, MVT::i8);
10556     addTest = false;
10557   }
10558
10559   if (addTest) {
10560     // Look pass the truncate if the high bits are known zero.
10561     if (isTruncWithZeroHighBitsInput(Cond, DAG))
10562         Cond = Cond.getOperand(0);
10563
10564     // We know the result of AND is compared against zero. Try to match
10565     // it to BT.
10566     if (Cond.getOpcode() == ISD::AND && Cond.hasOneUse()) {
10567       SDValue NewSetCC = LowerToBT(Cond, ISD::SETNE, DL, DAG);
10568       if (NewSetCC.getNode()) {
10569         CC = NewSetCC.getOperand(0);
10570         Cond = NewSetCC.getOperand(1);
10571         addTest = false;
10572       }
10573     }
10574   }
10575
10576   if (addTest) {
10577     CC = DAG.getConstant(X86::COND_NE, MVT::i8);
10578     Cond = EmitTest(Cond, X86::COND_NE, DAG);
10579   }
10580
10581   // a <  b ? -1 :  0 -> RES = ~setcc_carry
10582   // a <  b ?  0 : -1 -> RES = setcc_carry
10583   // a >= b ? -1 :  0 -> RES = setcc_carry
10584   // a >= b ?  0 : -1 -> RES = ~setcc_carry
10585   if (Cond.getOpcode() == X86ISD::SUB) {
10586     Cond = ConvertCmpIfNecessary(Cond, DAG);
10587     unsigned CondCode = cast<ConstantSDNode>(CC)->getZExtValue();
10588
10589     if ((CondCode == X86::COND_AE || CondCode == X86::COND_B) &&
10590         (isAllOnes(Op1) || isAllOnes(Op2)) && (isZero(Op1) || isZero(Op2))) {
10591       SDValue Res = DAG.getNode(X86ISD::SETCC_CARRY, DL, Op.getValueType(),
10592                                 DAG.getConstant(X86::COND_B, MVT::i8), Cond);
10593       if (isAllOnes(Op1) != (CondCode == X86::COND_B))
10594         return DAG.getNOT(DL, Res, Res.getValueType());
10595       return Res;
10596     }
10597   }
10598
10599   // X86 doesn't have an i8 cmov. If both operands are the result of a truncate
10600   // widen the cmov and push the truncate through. This avoids introducing a new
10601   // branch during isel and doesn't add any extensions.
10602   if (Op.getValueType() == MVT::i8 &&
10603       Op1.getOpcode() == ISD::TRUNCATE && Op2.getOpcode() == ISD::TRUNCATE) {
10604     SDValue T1 = Op1.getOperand(0), T2 = Op2.getOperand(0);
10605     if (T1.getValueType() == T2.getValueType() &&
10606         // Blacklist CopyFromReg to avoid partial register stalls.
10607         T1.getOpcode() != ISD::CopyFromReg && T2.getOpcode()!=ISD::CopyFromReg){
10608       SDVTList VTs = DAG.getVTList(T1.getValueType(), MVT::Glue);
10609       SDValue Cmov = DAG.getNode(X86ISD::CMOV, DL, VTs, T2, T1, CC, Cond);
10610       return DAG.getNode(ISD::TRUNCATE, DL, Op.getValueType(), Cmov);
10611     }
10612   }
10613
10614   // X86ISD::CMOV means set the result (which is operand 1) to the RHS if
10615   // condition is true.
10616   SDVTList VTs = DAG.getVTList(Op.getValueType(), MVT::Glue);
10617   SDValue Ops[] = { Op2, Op1, CC, Cond };
10618   return DAG.getNode(X86ISD::CMOV, DL, VTs, Ops, array_lengthof(Ops));
10619 }
10620
10621 static SDValue LowerSIGN_EXTEND_AVX512(SDValue Op, SelectionDAG &DAG) {
10622   MVT VT = Op->getSimpleValueType(0);
10623   SDValue In = Op->getOperand(0);
10624   MVT InVT = In.getSimpleValueType();
10625   SDLoc dl(Op);
10626
10627   unsigned int NumElts = VT.getVectorNumElements();
10628   if (NumElts != 8 && NumElts != 16)
10629     return SDValue();
10630
10631   if (VT.is512BitVector() && InVT.getVectorElementType() != MVT::i1)
10632     return DAG.getNode(X86ISD::VSEXT, dl, VT, In);
10633
10634   const TargetLowering &TLI = DAG.getTargetLoweringInfo();
10635   assert (InVT.getVectorElementType() == MVT::i1 && "Unexpected vector type");
10636
10637   MVT ExtVT = (NumElts == 8) ? MVT::v8i64 : MVT::v16i32;
10638   Constant *C = ConstantInt::get(*DAG.getContext(),
10639     APInt::getAllOnesValue(ExtVT.getScalarType().getSizeInBits()));
10640
10641   SDValue CP = DAG.getConstantPool(C, TLI.getPointerTy());
10642   unsigned Alignment = cast<ConstantPoolSDNode>(CP)->getAlignment();
10643   SDValue Ld = DAG.getLoad(ExtVT.getScalarType(), dl, DAG.getEntryNode(), CP,
10644                           MachinePointerInfo::getConstantPool(),
10645                           false, false, false, Alignment);
10646   SDValue Brcst = DAG.getNode(X86ISD::VBROADCASTM, dl, ExtVT, In, Ld);
10647   if (VT.is512BitVector())
10648     return Brcst;
10649   return DAG.getNode(X86ISD::VTRUNC, dl, VT, Brcst);
10650 }
10651
10652 static SDValue LowerSIGN_EXTEND(SDValue Op, const X86Subtarget *Subtarget,
10653                                 SelectionDAG &DAG) {
10654   MVT VT = Op->getSimpleValueType(0);
10655   SDValue In = Op->getOperand(0);
10656   MVT InVT = In.getSimpleValueType();
10657   SDLoc dl(Op);
10658
10659   if (VT.is512BitVector() || InVT.getVectorElementType() == MVT::i1)
10660     return LowerSIGN_EXTEND_AVX512(Op, DAG);
10661
10662   if ((VT != MVT::v4i64 || InVT != MVT::v4i32) &&
10663       (VT != MVT::v8i32 || InVT != MVT::v8i16) &&
10664       (VT != MVT::v16i16 || InVT != MVT::v16i8))
10665     return SDValue();
10666
10667   if (Subtarget->hasInt256())
10668     return DAG.getNode(X86ISD::VSEXT, dl, VT, In);
10669
10670   // Optimize vectors in AVX mode
10671   // Sign extend  v8i16 to v8i32 and
10672   //              v4i32 to v4i64
10673   //
10674   // Divide input vector into two parts
10675   // for v4i32 the shuffle mask will be { 0, 1, -1, -1} {2, 3, -1, -1}
10676   // use vpmovsx instruction to extend v4i32 -> v2i64; v8i16 -> v4i32
10677   // concat the vectors to original VT
10678
10679   unsigned NumElems = InVT.getVectorNumElements();
10680   SDValue Undef = DAG.getUNDEF(InVT);
10681
10682   SmallVector<int,8> ShufMask1(NumElems, -1);
10683   for (unsigned i = 0; i != NumElems/2; ++i)
10684     ShufMask1[i] = i;
10685
10686   SDValue OpLo = DAG.getVectorShuffle(InVT, dl, In, Undef, &ShufMask1[0]);
10687
10688   SmallVector<int,8> ShufMask2(NumElems, -1);
10689   for (unsigned i = 0; i != NumElems/2; ++i)
10690     ShufMask2[i] = i + NumElems/2;
10691
10692   SDValue OpHi = DAG.getVectorShuffle(InVT, dl, In, Undef, &ShufMask2[0]);
10693
10694   MVT HalfVT = MVT::getVectorVT(VT.getScalarType(),
10695                                 VT.getVectorNumElements()/2);
10696
10697   OpLo = DAG.getNode(X86ISD::VSEXT, dl, HalfVT, OpLo);
10698   OpHi = DAG.getNode(X86ISD::VSEXT, dl, HalfVT, OpHi);
10699
10700   return DAG.getNode(ISD::CONCAT_VECTORS, dl, VT, OpLo, OpHi);
10701 }
10702
10703 // isAndOrOfSingleUseSetCCs - Return true if node is an ISD::AND or
10704 // ISD::OR of two X86ISD::SETCC nodes each of which has no other use apart
10705 // from the AND / OR.
10706 static bool isAndOrOfSetCCs(SDValue Op, unsigned &Opc) {
10707   Opc = Op.getOpcode();
10708   if (Opc != ISD::OR && Opc != ISD::AND)
10709     return false;
10710   return (Op.getOperand(0).getOpcode() == X86ISD::SETCC &&
10711           Op.getOperand(0).hasOneUse() &&
10712           Op.getOperand(1).getOpcode() == X86ISD::SETCC &&
10713           Op.getOperand(1).hasOneUse());
10714 }
10715
10716 // isXor1OfSetCC - Return true if node is an ISD::XOR of a X86ISD::SETCC and
10717 // 1 and that the SETCC node has a single use.
10718 static bool isXor1OfSetCC(SDValue Op) {
10719   if (Op.getOpcode() != ISD::XOR)
10720     return false;
10721   ConstantSDNode *N1C = dyn_cast<ConstantSDNode>(Op.getOperand(1));
10722   if (N1C && N1C->getAPIntValue() == 1) {
10723     return Op.getOperand(0).getOpcode() == X86ISD::SETCC &&
10724       Op.getOperand(0).hasOneUse();
10725   }
10726   return false;
10727 }
10728
10729 SDValue X86TargetLowering::LowerBRCOND(SDValue Op, SelectionDAG &DAG) const {
10730   bool addTest = true;
10731   SDValue Chain = Op.getOperand(0);
10732   SDValue Cond  = Op.getOperand(1);
10733   SDValue Dest  = Op.getOperand(2);
10734   SDLoc dl(Op);
10735   SDValue CC;
10736   bool Inverted = false;
10737
10738   if (Cond.getOpcode() == ISD::SETCC) {
10739     // Check for setcc([su]{add,sub,mul}o == 0).
10740     if (cast<CondCodeSDNode>(Cond.getOperand(2))->get() == ISD::SETEQ &&
10741         isa<ConstantSDNode>(Cond.getOperand(1)) &&
10742         cast<ConstantSDNode>(Cond.getOperand(1))->isNullValue() &&
10743         Cond.getOperand(0).getResNo() == 1 &&
10744         (Cond.getOperand(0).getOpcode() == ISD::SADDO ||
10745          Cond.getOperand(0).getOpcode() == ISD::UADDO ||
10746          Cond.getOperand(0).getOpcode() == ISD::SSUBO ||
10747          Cond.getOperand(0).getOpcode() == ISD::USUBO ||
10748          Cond.getOperand(0).getOpcode() == ISD::SMULO ||
10749          Cond.getOperand(0).getOpcode() == ISD::UMULO)) {
10750       Inverted = true;
10751       Cond = Cond.getOperand(0);
10752     } else {
10753       SDValue NewCond = LowerSETCC(Cond, DAG);
10754       if (NewCond.getNode())
10755         Cond = NewCond;
10756     }
10757   }
10758 #if 0
10759   // FIXME: LowerXALUO doesn't handle these!!
10760   else if (Cond.getOpcode() == X86ISD::ADD  ||
10761            Cond.getOpcode() == X86ISD::SUB  ||
10762            Cond.getOpcode() == X86ISD::SMUL ||
10763            Cond.getOpcode() == X86ISD::UMUL)
10764     Cond = LowerXALUO(Cond, DAG);
10765 #endif
10766
10767   // Look pass (and (setcc_carry (cmp ...)), 1).
10768   if (Cond.getOpcode() == ISD::AND &&
10769       Cond.getOperand(0).getOpcode() == X86ISD::SETCC_CARRY) {
10770     ConstantSDNode *C = dyn_cast<ConstantSDNode>(Cond.getOperand(1));
10771     if (C && C->getAPIntValue() == 1)
10772       Cond = Cond.getOperand(0);
10773   }
10774
10775   // If condition flag is set by a X86ISD::CMP, then use it as the condition
10776   // setting operand in place of the X86ISD::SETCC.
10777   unsigned CondOpcode = Cond.getOpcode();
10778   if (CondOpcode == X86ISD::SETCC ||
10779       CondOpcode == X86ISD::SETCC_CARRY) {
10780     CC = Cond.getOperand(0);
10781
10782     SDValue Cmp = Cond.getOperand(1);
10783     unsigned Opc = Cmp.getOpcode();
10784     // FIXME: WHY THE SPECIAL CASING OF LogicalCmp??
10785     if (isX86LogicalCmp(Cmp) || Opc == X86ISD::BT) {
10786       Cond = Cmp;
10787       addTest = false;
10788     } else {
10789       switch (cast<ConstantSDNode>(CC)->getZExtValue()) {
10790       default: break;
10791       case X86::COND_O:
10792       case X86::COND_B:
10793         // These can only come from an arithmetic instruction with overflow,
10794         // e.g. SADDO, UADDO.
10795         Cond = Cond.getNode()->getOperand(1);
10796         addTest = false;
10797         break;
10798       }
10799     }
10800   }
10801   CondOpcode = Cond.getOpcode();
10802   if (CondOpcode == ISD::UADDO || CondOpcode == ISD::SADDO ||
10803       CondOpcode == ISD::USUBO || CondOpcode == ISD::SSUBO ||
10804       ((CondOpcode == ISD::UMULO || CondOpcode == ISD::SMULO) &&
10805        Cond.getOperand(0).getValueType() != MVT::i8)) {
10806     SDValue LHS = Cond.getOperand(0);
10807     SDValue RHS = Cond.getOperand(1);
10808     unsigned X86Opcode;
10809     unsigned X86Cond;
10810     SDVTList VTs;
10811     // Keep this in sync with LowerXALUO, otherwise we might create redundant
10812     // instructions that can't be removed afterwards (i.e. X86ISD::ADD and
10813     // X86ISD::INC).
10814     switch (CondOpcode) {
10815     case ISD::UADDO: X86Opcode = X86ISD::ADD; X86Cond = X86::COND_B; break;
10816     case ISD::SADDO:
10817       if (ConstantSDNode *C = dyn_cast<ConstantSDNode>(RHS))
10818         if (C->isOne()) {
10819           X86Opcode = X86ISD::INC; X86Cond = X86::COND_O;
10820           break;
10821         }
10822       X86Opcode = X86ISD::ADD; X86Cond = X86::COND_O; break;
10823     case ISD::USUBO: X86Opcode = X86ISD::SUB; X86Cond = X86::COND_B; break;
10824     case ISD::SSUBO:
10825       if (ConstantSDNode *C = dyn_cast<ConstantSDNode>(RHS))
10826         if (C->isOne()) {
10827           X86Opcode = X86ISD::DEC; X86Cond = X86::COND_O;
10828           break;
10829         }
10830       X86Opcode = X86ISD::SUB; X86Cond = X86::COND_O; break;
10831     case ISD::UMULO: X86Opcode = X86ISD::UMUL; X86Cond = X86::COND_O; break;
10832     case ISD::SMULO: X86Opcode = X86ISD::SMUL; X86Cond = X86::COND_O; break;
10833     default: llvm_unreachable("unexpected overflowing operator");
10834     }
10835     if (Inverted)
10836       X86Cond = X86::GetOppositeBranchCondition((X86::CondCode)X86Cond);
10837     if (CondOpcode == ISD::UMULO)
10838       VTs = DAG.getVTList(LHS.getValueType(), LHS.getValueType(),
10839                           MVT::i32);
10840     else
10841       VTs = DAG.getVTList(LHS.getValueType(), MVT::i32);
10842
10843     SDValue X86Op = DAG.getNode(X86Opcode, dl, VTs, LHS, RHS);
10844
10845     if (CondOpcode == ISD::UMULO)
10846       Cond = X86Op.getValue(2);
10847     else
10848       Cond = X86Op.getValue(1);
10849
10850     CC = DAG.getConstant(X86Cond, MVT::i8);
10851     addTest = false;
10852   } else {
10853     unsigned CondOpc;
10854     if (Cond.hasOneUse() && isAndOrOfSetCCs(Cond, CondOpc)) {
10855       SDValue Cmp = Cond.getOperand(0).getOperand(1);
10856       if (CondOpc == ISD::OR) {
10857         // Also, recognize the pattern generated by an FCMP_UNE. We can emit
10858         // two branches instead of an explicit OR instruction with a
10859         // separate test.
10860         if (Cmp == Cond.getOperand(1).getOperand(1) &&
10861             isX86LogicalCmp(Cmp)) {
10862           CC = Cond.getOperand(0).getOperand(0);
10863           Chain = DAG.getNode(X86ISD::BRCOND, dl, Op.getValueType(),
10864                               Chain, Dest, CC, Cmp);
10865           CC = Cond.getOperand(1).getOperand(0);
10866           Cond = Cmp;
10867           addTest = false;
10868         }
10869       } else { // ISD::AND
10870         // Also, recognize the pattern generated by an FCMP_OEQ. We can emit
10871         // two branches instead of an explicit AND instruction with a
10872         // separate test. However, we only do this if this block doesn't
10873         // have a fall-through edge, because this requires an explicit
10874         // jmp when the condition is false.
10875         if (Cmp == Cond.getOperand(1).getOperand(1) &&
10876             isX86LogicalCmp(Cmp) &&
10877             Op.getNode()->hasOneUse()) {
10878           X86::CondCode CCode =
10879             (X86::CondCode)Cond.getOperand(0).getConstantOperandVal(0);
10880           CCode = X86::GetOppositeBranchCondition(CCode);
10881           CC = DAG.getConstant(CCode, MVT::i8);
10882           SDNode *User = *Op.getNode()->use_begin();
10883           // Look for an unconditional branch following this conditional branch.
10884           // We need this because we need to reverse the successors in order
10885           // to implement FCMP_OEQ.
10886           if (User->getOpcode() == ISD::BR) {
10887             SDValue FalseBB = User->getOperand(1);
10888             SDNode *NewBR =
10889               DAG.UpdateNodeOperands(User, User->getOperand(0), Dest);
10890             assert(NewBR == User);
10891             (void)NewBR;
10892             Dest = FalseBB;
10893
10894             Chain = DAG.getNode(X86ISD::BRCOND, dl, Op.getValueType(),
10895                                 Chain, Dest, CC, Cmp);
10896             X86::CondCode CCode =
10897               (X86::CondCode)Cond.getOperand(1).getConstantOperandVal(0);
10898             CCode = X86::GetOppositeBranchCondition(CCode);
10899             CC = DAG.getConstant(CCode, MVT::i8);
10900             Cond = Cmp;
10901             addTest = false;
10902           }
10903         }
10904       }
10905     } else if (Cond.hasOneUse() && isXor1OfSetCC(Cond)) {
10906       // Recognize for xorb (setcc), 1 patterns. The xor inverts the condition.
10907       // It should be transformed during dag combiner except when the condition
10908       // is set by a arithmetics with overflow node.
10909       X86::CondCode CCode =
10910         (X86::CondCode)Cond.getOperand(0).getConstantOperandVal(0);
10911       CCode = X86::GetOppositeBranchCondition(CCode);
10912       CC = DAG.getConstant(CCode, MVT::i8);
10913       Cond = Cond.getOperand(0).getOperand(1);
10914       addTest = false;
10915     } else if (Cond.getOpcode() == ISD::SETCC &&
10916                cast<CondCodeSDNode>(Cond.getOperand(2))->get() == ISD::SETOEQ) {
10917       // For FCMP_OEQ, we can emit
10918       // two branches instead of an explicit AND instruction with a
10919       // separate test. However, we only do this if this block doesn't
10920       // have a fall-through edge, because this requires an explicit
10921       // jmp when the condition is false.
10922       if (Op.getNode()->hasOneUse()) {
10923         SDNode *User = *Op.getNode()->use_begin();
10924         // Look for an unconditional branch following this conditional branch.
10925         // We need this because we need to reverse the successors in order
10926         // to implement FCMP_OEQ.
10927         if (User->getOpcode() == ISD::BR) {
10928           SDValue FalseBB = User->getOperand(1);
10929           SDNode *NewBR =
10930             DAG.UpdateNodeOperands(User, User->getOperand(0), Dest);
10931           assert(NewBR == User);
10932           (void)NewBR;
10933           Dest = FalseBB;
10934
10935           SDValue Cmp = DAG.getNode(X86ISD::CMP, dl, MVT::i32,
10936                                     Cond.getOperand(0), Cond.getOperand(1));
10937           Cmp = ConvertCmpIfNecessary(Cmp, DAG);
10938           CC = DAG.getConstant(X86::COND_NE, MVT::i8);
10939           Chain = DAG.getNode(X86ISD::BRCOND, dl, Op.getValueType(),
10940                               Chain, Dest, CC, Cmp);
10941           CC = DAG.getConstant(X86::COND_P, MVT::i8);
10942           Cond = Cmp;
10943           addTest = false;
10944         }
10945       }
10946     } else if (Cond.getOpcode() == ISD::SETCC &&
10947                cast<CondCodeSDNode>(Cond.getOperand(2))->get() == ISD::SETUNE) {
10948       // For FCMP_UNE, we can emit
10949       // two branches instead of an explicit AND instruction with a
10950       // separate test. However, we only do this if this block doesn't
10951       // have a fall-through edge, because this requires an explicit
10952       // jmp when the condition is false.
10953       if (Op.getNode()->hasOneUse()) {
10954         SDNode *User = *Op.getNode()->use_begin();
10955         // Look for an unconditional branch following this conditional branch.
10956         // We need this because we need to reverse the successors in order
10957         // to implement FCMP_UNE.
10958         if (User->getOpcode() == ISD::BR) {
10959           SDValue FalseBB = User->getOperand(1);
10960           SDNode *NewBR =
10961             DAG.UpdateNodeOperands(User, User->getOperand(0), Dest);
10962           assert(NewBR == User);
10963           (void)NewBR;
10964
10965           SDValue Cmp = DAG.getNode(X86ISD::CMP, dl, MVT::i32,
10966                                     Cond.getOperand(0), Cond.getOperand(1));
10967           Cmp = ConvertCmpIfNecessary(Cmp, DAG);
10968           CC = DAG.getConstant(X86::COND_NE, MVT::i8);
10969           Chain = DAG.getNode(X86ISD::BRCOND, dl, Op.getValueType(),
10970                               Chain, Dest, CC, Cmp);
10971           CC = DAG.getConstant(X86::COND_NP, MVT::i8);
10972           Cond = Cmp;
10973           addTest = false;
10974           Dest = FalseBB;
10975         }
10976       }
10977     }
10978   }
10979
10980   if (addTest) {
10981     // Look pass the truncate if the high bits are known zero.
10982     if (isTruncWithZeroHighBitsInput(Cond, DAG))
10983         Cond = Cond.getOperand(0);
10984
10985     // We know the result of AND is compared against zero. Try to match
10986     // it to BT.
10987     if (Cond.getOpcode() == ISD::AND && Cond.hasOneUse()) {
10988       SDValue NewSetCC = LowerToBT(Cond, ISD::SETNE, dl, DAG);
10989       if (NewSetCC.getNode()) {
10990         CC = NewSetCC.getOperand(0);
10991         Cond = NewSetCC.getOperand(1);
10992         addTest = false;
10993       }
10994     }
10995   }
10996
10997   if (addTest) {
10998     CC = DAG.getConstant(X86::COND_NE, MVT::i8);
10999     Cond = EmitTest(Cond, X86::COND_NE, DAG);
11000   }
11001   Cond = ConvertCmpIfNecessary(Cond, DAG);
11002   return DAG.getNode(X86ISD::BRCOND, dl, Op.getValueType(),
11003                      Chain, Dest, CC, Cond);
11004 }
11005
11006 // Lower dynamic stack allocation to _alloca call for Cygwin/Mingw targets.
11007 // Calls to _alloca is needed to probe the stack when allocating more than 4k
11008 // bytes in one go. Touching the stack at 4K increments is necessary to ensure
11009 // that the guard pages used by the OS virtual memory manager are allocated in
11010 // correct sequence.
11011 SDValue
11012 X86TargetLowering::LowerDYNAMIC_STACKALLOC(SDValue Op,
11013                                            SelectionDAG &DAG) const {
11014   assert((Subtarget->isTargetCygMing() || Subtarget->isTargetWindows() ||
11015           getTargetMachine().Options.EnableSegmentedStacks) &&
11016          "This should be used only on Windows targets or when segmented stacks "
11017          "are being used");
11018   assert(!Subtarget->isTargetMacho() && "Not implemented");
11019   SDLoc dl(Op);
11020
11021   // Get the inputs.
11022   SDValue Chain = Op.getOperand(0);
11023   SDValue Size  = Op.getOperand(1);
11024   unsigned Align = cast<ConstantSDNode>(Op.getOperand(2))->getZExtValue();
11025   EVT VT = Op.getNode()->getValueType(0);
11026
11027   bool Is64Bit = Subtarget->is64Bit();
11028   EVT SPTy = Is64Bit ? MVT::i64 : MVT::i32;
11029
11030   if (getTargetMachine().Options.EnableSegmentedStacks) {
11031     MachineFunction &MF = DAG.getMachineFunction();
11032     MachineRegisterInfo &MRI = MF.getRegInfo();
11033
11034     if (Is64Bit) {
11035       // The 64 bit implementation of segmented stacks needs to clobber both r10
11036       // r11. This makes it impossible to use it along with nested parameters.
11037       const Function *F = MF.getFunction();
11038
11039       for (Function::const_arg_iterator I = F->arg_begin(), E = F->arg_end();
11040            I != E; ++I)
11041         if (I->hasNestAttr())
11042           report_fatal_error("Cannot use segmented stacks with functions that "
11043                              "have nested arguments.");
11044     }
11045
11046     const TargetRegisterClass *AddrRegClass =
11047       getRegClassFor(Subtarget->is64Bit() ? MVT::i64:MVT::i32);
11048     unsigned Vreg = MRI.createVirtualRegister(AddrRegClass);
11049     Chain = DAG.getCopyToReg(Chain, dl, Vreg, Size);
11050     SDValue Value = DAG.getNode(X86ISD::SEG_ALLOCA, dl, SPTy, Chain,
11051                                 DAG.getRegister(Vreg, SPTy));
11052     SDValue Ops1[2] = { Value, Chain };
11053     return DAG.getMergeValues(Ops1, 2, dl);
11054   } else {
11055     SDValue Flag;
11056     unsigned Reg = (Subtarget->is64Bit() ? X86::RAX : X86::EAX);
11057
11058     Chain = DAG.getCopyToReg(Chain, dl, Reg, Size, Flag);
11059     Flag = Chain.getValue(1);
11060     SDVTList NodeTys = DAG.getVTList(MVT::Other, MVT::Glue);
11061
11062     Chain = DAG.getNode(X86ISD::WIN_ALLOCA, dl, NodeTys, Chain, Flag);
11063
11064     const X86RegisterInfo *RegInfo =
11065       static_cast<const X86RegisterInfo*>(getTargetMachine().getRegisterInfo());
11066     unsigned SPReg = RegInfo->getStackRegister();
11067     SDValue SP = DAG.getCopyFromReg(Chain, dl, SPReg, SPTy);
11068     Chain = SP.getValue(1);
11069
11070     if (Align) {
11071       SP = DAG.getNode(ISD::AND, dl, VT, SP.getValue(0),
11072                        DAG.getConstant(-(uint64_t)Align, VT));
11073       Chain = DAG.getCopyToReg(Chain, dl, SPReg, SP);
11074     }
11075
11076     SDValue Ops1[2] = { SP, Chain };
11077     return DAG.getMergeValues(Ops1, 2, dl);
11078   }
11079 }
11080
11081 SDValue X86TargetLowering::LowerVASTART(SDValue Op, SelectionDAG &DAG) const {
11082   MachineFunction &MF = DAG.getMachineFunction();
11083   X86MachineFunctionInfo *FuncInfo = MF.getInfo<X86MachineFunctionInfo>();
11084
11085   const Value *SV = cast<SrcValueSDNode>(Op.getOperand(2))->getValue();
11086   SDLoc DL(Op);
11087
11088   if (!Subtarget->is64Bit() || Subtarget->isTargetWin64()) {
11089     // vastart just stores the address of the VarArgsFrameIndex slot into the
11090     // memory location argument.
11091     SDValue FR = DAG.getFrameIndex(FuncInfo->getVarArgsFrameIndex(),
11092                                    getPointerTy());
11093     return DAG.getStore(Op.getOperand(0), DL, FR, Op.getOperand(1),
11094                         MachinePointerInfo(SV), false, false, 0);
11095   }
11096
11097   // __va_list_tag:
11098   //   gp_offset         (0 - 6 * 8)
11099   //   fp_offset         (48 - 48 + 8 * 16)
11100   //   overflow_arg_area (point to parameters coming in memory).
11101   //   reg_save_area
11102   SmallVector<SDValue, 8> MemOps;
11103   SDValue FIN = Op.getOperand(1);
11104   // Store gp_offset
11105   SDValue Store = DAG.getStore(Op.getOperand(0), DL,
11106                                DAG.getConstant(FuncInfo->getVarArgsGPOffset(),
11107                                                MVT::i32),
11108                                FIN, MachinePointerInfo(SV), false, false, 0);
11109   MemOps.push_back(Store);
11110
11111   // Store fp_offset
11112   FIN = DAG.getNode(ISD::ADD, DL, getPointerTy(),
11113                     FIN, DAG.getIntPtrConstant(4));
11114   Store = DAG.getStore(Op.getOperand(0), DL,
11115                        DAG.getConstant(FuncInfo->getVarArgsFPOffset(),
11116                                        MVT::i32),
11117                        FIN, MachinePointerInfo(SV, 4), false, false, 0);
11118   MemOps.push_back(Store);
11119
11120   // Store ptr to overflow_arg_area
11121   FIN = DAG.getNode(ISD::ADD, DL, getPointerTy(),
11122                     FIN, DAG.getIntPtrConstant(4));
11123   SDValue OVFIN = DAG.getFrameIndex(FuncInfo->getVarArgsFrameIndex(),
11124                                     getPointerTy());
11125   Store = DAG.getStore(Op.getOperand(0), DL, OVFIN, FIN,
11126                        MachinePointerInfo(SV, 8),
11127                        false, false, 0);
11128   MemOps.push_back(Store);
11129
11130   // Store ptr to reg_save_area.
11131   FIN = DAG.getNode(ISD::ADD, DL, getPointerTy(),
11132                     FIN, DAG.getIntPtrConstant(8));
11133   SDValue RSFIN = DAG.getFrameIndex(FuncInfo->getRegSaveFrameIndex(),
11134                                     getPointerTy());
11135   Store = DAG.getStore(Op.getOperand(0), DL, RSFIN, FIN,
11136                        MachinePointerInfo(SV, 16), false, false, 0);
11137   MemOps.push_back(Store);
11138   return DAG.getNode(ISD::TokenFactor, DL, MVT::Other,
11139                      &MemOps[0], MemOps.size());
11140 }
11141
11142 SDValue X86TargetLowering::LowerVAARG(SDValue Op, SelectionDAG &DAG) const {
11143   assert(Subtarget->is64Bit() &&
11144          "LowerVAARG only handles 64-bit va_arg!");
11145   assert((Subtarget->isTargetLinux() ||
11146           Subtarget->isTargetDarwin()) &&
11147           "Unhandled target in LowerVAARG");
11148   assert(Op.getNode()->getNumOperands() == 4);
11149   SDValue Chain = Op.getOperand(0);
11150   SDValue SrcPtr = Op.getOperand(1);
11151   const Value *SV = cast<SrcValueSDNode>(Op.getOperand(2))->getValue();
11152   unsigned Align = Op.getConstantOperandVal(3);
11153   SDLoc dl(Op);
11154
11155   EVT ArgVT = Op.getNode()->getValueType(0);
11156   Type *ArgTy = ArgVT.getTypeForEVT(*DAG.getContext());
11157   uint32_t ArgSize = getDataLayout()->getTypeAllocSize(ArgTy);
11158   uint8_t ArgMode;
11159
11160   // Decide which area this value should be read from.
11161   // TODO: Implement the AMD64 ABI in its entirety. This simple
11162   // selection mechanism works only for the basic types.
11163   if (ArgVT == MVT::f80) {
11164     llvm_unreachable("va_arg for f80 not yet implemented");
11165   } else if (ArgVT.isFloatingPoint() && ArgSize <= 16 /*bytes*/) {
11166     ArgMode = 2;  // Argument passed in XMM register. Use fp_offset.
11167   } else if (ArgVT.isInteger() && ArgSize <= 32 /*bytes*/) {
11168     ArgMode = 1;  // Argument passed in GPR64 register(s). Use gp_offset.
11169   } else {
11170     llvm_unreachable("Unhandled argument type in LowerVAARG");
11171   }
11172
11173   if (ArgMode == 2) {
11174     // Sanity Check: Make sure using fp_offset makes sense.
11175     assert(!getTargetMachine().Options.UseSoftFloat &&
11176            !(DAG.getMachineFunction()
11177                 .getFunction()->getAttributes()
11178                 .hasAttribute(AttributeSet::FunctionIndex,
11179                               Attribute::NoImplicitFloat)) &&
11180            Subtarget->hasSSE1());
11181   }
11182
11183   // Insert VAARG_64 node into the DAG
11184   // VAARG_64 returns two values: Variable Argument Address, Chain
11185   SmallVector<SDValue, 11> InstOps;
11186   InstOps.push_back(Chain);
11187   InstOps.push_back(SrcPtr);
11188   InstOps.push_back(DAG.getConstant(ArgSize, MVT::i32));
11189   InstOps.push_back(DAG.getConstant(ArgMode, MVT::i8));
11190   InstOps.push_back(DAG.getConstant(Align, MVT::i32));
11191   SDVTList VTs = DAG.getVTList(getPointerTy(), MVT::Other);
11192   SDValue VAARG = DAG.getMemIntrinsicNode(X86ISD::VAARG_64, dl,
11193                                           VTs, &InstOps[0], InstOps.size(),
11194                                           MVT::i64,
11195                                           MachinePointerInfo(SV),
11196                                           /*Align=*/0,
11197                                           /*Volatile=*/false,
11198                                           /*ReadMem=*/true,
11199                                           /*WriteMem=*/true);
11200   Chain = VAARG.getValue(1);
11201
11202   // Load the next argument and return it
11203   return DAG.getLoad(ArgVT, dl,
11204                      Chain,
11205                      VAARG,
11206                      MachinePointerInfo(),
11207                      false, false, false, 0);
11208 }
11209
11210 static SDValue LowerVACOPY(SDValue Op, const X86Subtarget *Subtarget,
11211                            SelectionDAG &DAG) {
11212   // X86-64 va_list is a struct { i32, i32, i8*, i8* }.
11213   assert(Subtarget->is64Bit() && "This code only handles 64-bit va_copy!");
11214   SDValue Chain = Op.getOperand(0);
11215   SDValue DstPtr = Op.getOperand(1);
11216   SDValue SrcPtr = Op.getOperand(2);
11217   const Value *DstSV = cast<SrcValueSDNode>(Op.getOperand(3))->getValue();
11218   const Value *SrcSV = cast<SrcValueSDNode>(Op.getOperand(4))->getValue();
11219   SDLoc DL(Op);
11220
11221   return DAG.getMemcpy(Chain, DL, DstPtr, SrcPtr,
11222                        DAG.getIntPtrConstant(24), 8, /*isVolatile*/false,
11223                        false,
11224                        MachinePointerInfo(DstSV), MachinePointerInfo(SrcSV));
11225 }
11226
11227 // getTargetVShiftByConstNode - Handle vector element shifts where the shift
11228 // amount is a constant. Takes immediate version of shift as input.
11229 static SDValue getTargetVShiftByConstNode(unsigned Opc, SDLoc dl, MVT VT,
11230                                           SDValue SrcOp, uint64_t ShiftAmt,
11231                                           SelectionDAG &DAG) {
11232   MVT ElementType = VT.getVectorElementType();
11233
11234   // Check for ShiftAmt >= element width
11235   if (ShiftAmt >= ElementType.getSizeInBits()) {
11236     if (Opc == X86ISD::VSRAI)
11237       ShiftAmt = ElementType.getSizeInBits() - 1;
11238     else
11239       return DAG.getConstant(0, VT);
11240   }
11241
11242   assert((Opc == X86ISD::VSHLI || Opc == X86ISD::VSRLI || Opc == X86ISD::VSRAI)
11243          && "Unknown target vector shift-by-constant node");
11244
11245   // Fold this packed vector shift into a build vector if SrcOp is a
11246   // vector of Constants or UNDEFs, and SrcOp valuetype is the same as VT.
11247   if (VT == SrcOp.getSimpleValueType() &&
11248       ISD::isBuildVectorOfConstantSDNodes(SrcOp.getNode())) {
11249     SmallVector<SDValue, 8> Elts;
11250     unsigned NumElts = SrcOp->getNumOperands();
11251     ConstantSDNode *ND;
11252
11253     switch(Opc) {
11254     default: llvm_unreachable(0);
11255     case X86ISD::VSHLI:
11256       for (unsigned i=0; i!=NumElts; ++i) {
11257         SDValue CurrentOp = SrcOp->getOperand(i);
11258         if (CurrentOp->getOpcode() == ISD::UNDEF) {
11259           Elts.push_back(CurrentOp);
11260           continue;
11261         }
11262         ND = cast<ConstantSDNode>(CurrentOp);
11263         const APInt &C = ND->getAPIntValue();
11264         Elts.push_back(DAG.getConstant(C.shl(ShiftAmt), ElementType));
11265       }
11266       break;
11267     case X86ISD::VSRLI:
11268       for (unsigned i=0; i!=NumElts; ++i) {
11269         SDValue CurrentOp = SrcOp->getOperand(i);
11270         if (CurrentOp->getOpcode() == ISD::UNDEF) {
11271           Elts.push_back(CurrentOp);
11272           continue;
11273         }
11274         ND = cast<ConstantSDNode>(CurrentOp);
11275         const APInt &C = ND->getAPIntValue();
11276         Elts.push_back(DAG.getConstant(C.lshr(ShiftAmt), ElementType));
11277       }
11278       break;
11279     case X86ISD::VSRAI:
11280       for (unsigned i=0; i!=NumElts; ++i) {
11281         SDValue CurrentOp = SrcOp->getOperand(i);
11282         if (CurrentOp->getOpcode() == ISD::UNDEF) {
11283           Elts.push_back(CurrentOp);
11284           continue;
11285         }
11286         ND = cast<ConstantSDNode>(CurrentOp);
11287         const APInt &C = ND->getAPIntValue();
11288         Elts.push_back(DAG.getConstant(C.ashr(ShiftAmt), ElementType));
11289       }
11290       break;
11291     }
11292
11293     return DAG.getNode(ISD::BUILD_VECTOR, dl, VT, &Elts[0], NumElts);
11294   }
11295
11296   return DAG.getNode(Opc, dl, VT, SrcOp, DAG.getConstant(ShiftAmt, MVT::i8));
11297 }
11298
11299 // getTargetVShiftNode - Handle vector element shifts where the shift amount
11300 // may or may not be a constant. Takes immediate version of shift as input.
11301 static SDValue getTargetVShiftNode(unsigned Opc, SDLoc dl, MVT VT,
11302                                    SDValue SrcOp, SDValue ShAmt,
11303                                    SelectionDAG &DAG) {
11304   assert(ShAmt.getValueType() == MVT::i32 && "ShAmt is not i32");
11305
11306   // Catch shift-by-constant.
11307   if (ConstantSDNode *CShAmt = dyn_cast<ConstantSDNode>(ShAmt))
11308     return getTargetVShiftByConstNode(Opc, dl, VT, SrcOp,
11309                                       CShAmt->getZExtValue(), DAG);
11310
11311   // Change opcode to non-immediate version
11312   switch (Opc) {
11313     default: llvm_unreachable("Unknown target vector shift node");
11314     case X86ISD::VSHLI: Opc = X86ISD::VSHL; break;
11315     case X86ISD::VSRLI: Opc = X86ISD::VSRL; break;
11316     case X86ISD::VSRAI: Opc = X86ISD::VSRA; break;
11317   }
11318
11319   // Need to build a vector containing shift amount
11320   // Shift amount is 32-bits, but SSE instructions read 64-bit, so fill with 0
11321   SDValue ShOps[4];
11322   ShOps[0] = ShAmt;
11323   ShOps[1] = DAG.getConstant(0, MVT::i32);
11324   ShOps[2] = ShOps[3] = DAG.getUNDEF(MVT::i32);
11325   ShAmt = DAG.getNode(ISD::BUILD_VECTOR, dl, MVT::v4i32, &ShOps[0], 4);
11326
11327   // The return type has to be a 128-bit type with the same element
11328   // type as the input type.
11329   MVT EltVT = VT.getVectorElementType();
11330   EVT ShVT = MVT::getVectorVT(EltVT, 128/EltVT.getSizeInBits());
11331
11332   ShAmt = DAG.getNode(ISD::BITCAST, dl, ShVT, ShAmt);
11333   return DAG.getNode(Opc, dl, VT, SrcOp, ShAmt);
11334 }
11335
11336 static SDValue LowerINTRINSIC_WO_CHAIN(SDValue Op, SelectionDAG &DAG) {
11337   SDLoc dl(Op);
11338   unsigned IntNo = cast<ConstantSDNode>(Op.getOperand(0))->getZExtValue();
11339   switch (IntNo) {
11340   default: return SDValue();    // Don't custom lower most intrinsics.
11341   // Comparison intrinsics.
11342   case Intrinsic::x86_sse_comieq_ss:
11343   case Intrinsic::x86_sse_comilt_ss:
11344   case Intrinsic::x86_sse_comile_ss:
11345   case Intrinsic::x86_sse_comigt_ss:
11346   case Intrinsic::x86_sse_comige_ss:
11347   case Intrinsic::x86_sse_comineq_ss:
11348   case Intrinsic::x86_sse_ucomieq_ss:
11349   case Intrinsic::x86_sse_ucomilt_ss:
11350   case Intrinsic::x86_sse_ucomile_ss:
11351   case Intrinsic::x86_sse_ucomigt_ss:
11352   case Intrinsic::x86_sse_ucomige_ss:
11353   case Intrinsic::x86_sse_ucomineq_ss:
11354   case Intrinsic::x86_sse2_comieq_sd:
11355   case Intrinsic::x86_sse2_comilt_sd:
11356   case Intrinsic::x86_sse2_comile_sd:
11357   case Intrinsic::x86_sse2_comigt_sd:
11358   case Intrinsic::x86_sse2_comige_sd:
11359   case Intrinsic::x86_sse2_comineq_sd:
11360   case Intrinsic::x86_sse2_ucomieq_sd:
11361   case Intrinsic::x86_sse2_ucomilt_sd:
11362   case Intrinsic::x86_sse2_ucomile_sd:
11363   case Intrinsic::x86_sse2_ucomigt_sd:
11364   case Intrinsic::x86_sse2_ucomige_sd:
11365   case Intrinsic::x86_sse2_ucomineq_sd: {
11366     unsigned Opc;
11367     ISD::CondCode CC;
11368     switch (IntNo) {
11369     default: llvm_unreachable("Impossible intrinsic");  // Can't reach here.
11370     case Intrinsic::x86_sse_comieq_ss:
11371     case Intrinsic::x86_sse2_comieq_sd:
11372       Opc = X86ISD::COMI;
11373       CC = ISD::SETEQ;
11374       break;
11375     case Intrinsic::x86_sse_comilt_ss:
11376     case Intrinsic::x86_sse2_comilt_sd:
11377       Opc = X86ISD::COMI;
11378       CC = ISD::SETLT;
11379       break;
11380     case Intrinsic::x86_sse_comile_ss:
11381     case Intrinsic::x86_sse2_comile_sd:
11382       Opc = X86ISD::COMI;
11383       CC = ISD::SETLE;
11384       break;
11385     case Intrinsic::x86_sse_comigt_ss:
11386     case Intrinsic::x86_sse2_comigt_sd:
11387       Opc = X86ISD::COMI;
11388       CC = ISD::SETGT;
11389       break;
11390     case Intrinsic::x86_sse_comige_ss:
11391     case Intrinsic::x86_sse2_comige_sd:
11392       Opc = X86ISD::COMI;
11393       CC = ISD::SETGE;
11394       break;
11395     case Intrinsic::x86_sse_comineq_ss:
11396     case Intrinsic::x86_sse2_comineq_sd:
11397       Opc = X86ISD::COMI;
11398       CC = ISD::SETNE;
11399       break;
11400     case Intrinsic::x86_sse_ucomieq_ss:
11401     case Intrinsic::x86_sse2_ucomieq_sd:
11402       Opc = X86ISD::UCOMI;
11403       CC = ISD::SETEQ;
11404       break;
11405     case Intrinsic::x86_sse_ucomilt_ss:
11406     case Intrinsic::x86_sse2_ucomilt_sd:
11407       Opc = X86ISD::UCOMI;
11408       CC = ISD::SETLT;
11409       break;
11410     case Intrinsic::x86_sse_ucomile_ss:
11411     case Intrinsic::x86_sse2_ucomile_sd:
11412       Opc = X86ISD::UCOMI;
11413       CC = ISD::SETLE;
11414       break;
11415     case Intrinsic::x86_sse_ucomigt_ss:
11416     case Intrinsic::x86_sse2_ucomigt_sd:
11417       Opc = X86ISD::UCOMI;
11418       CC = ISD::SETGT;
11419       break;
11420     case Intrinsic::x86_sse_ucomige_ss:
11421     case Intrinsic::x86_sse2_ucomige_sd:
11422       Opc = X86ISD::UCOMI;
11423       CC = ISD::SETGE;
11424       break;
11425     case Intrinsic::x86_sse_ucomineq_ss:
11426     case Intrinsic::x86_sse2_ucomineq_sd:
11427       Opc = X86ISD::UCOMI;
11428       CC = ISD::SETNE;
11429       break;
11430     }
11431
11432     SDValue LHS = Op.getOperand(1);
11433     SDValue RHS = Op.getOperand(2);
11434     unsigned X86CC = TranslateX86CC(CC, true, LHS, RHS, DAG);
11435     assert(X86CC != X86::COND_INVALID && "Unexpected illegal condition!");
11436     SDValue Cond = DAG.getNode(Opc, dl, MVT::i32, LHS, RHS);
11437     SDValue SetCC = DAG.getNode(X86ISD::SETCC, dl, MVT::i8,
11438                                 DAG.getConstant(X86CC, MVT::i8), Cond);
11439     return DAG.getNode(ISD::ZERO_EXTEND, dl, MVT::i32, SetCC);
11440   }
11441
11442   // Arithmetic intrinsics.
11443   case Intrinsic::x86_sse2_pmulu_dq:
11444   case Intrinsic::x86_avx2_pmulu_dq:
11445     return DAG.getNode(X86ISD::PMULUDQ, dl, Op.getValueType(),
11446                        Op.getOperand(1), Op.getOperand(2));
11447
11448   // SSE2/AVX2 sub with unsigned saturation intrinsics
11449   case Intrinsic::x86_sse2_psubus_b:
11450   case Intrinsic::x86_sse2_psubus_w:
11451   case Intrinsic::x86_avx2_psubus_b:
11452   case Intrinsic::x86_avx2_psubus_w:
11453     return DAG.getNode(X86ISD::SUBUS, dl, Op.getValueType(),
11454                        Op.getOperand(1), Op.getOperand(2));
11455
11456   // SSE3/AVX horizontal add/sub intrinsics
11457   case Intrinsic::x86_sse3_hadd_ps:
11458   case Intrinsic::x86_sse3_hadd_pd:
11459   case Intrinsic::x86_avx_hadd_ps_256:
11460   case Intrinsic::x86_avx_hadd_pd_256:
11461   case Intrinsic::x86_sse3_hsub_ps:
11462   case Intrinsic::x86_sse3_hsub_pd:
11463   case Intrinsic::x86_avx_hsub_ps_256:
11464   case Intrinsic::x86_avx_hsub_pd_256:
11465   case Intrinsic::x86_ssse3_phadd_w_128:
11466   case Intrinsic::x86_ssse3_phadd_d_128:
11467   case Intrinsic::x86_avx2_phadd_w:
11468   case Intrinsic::x86_avx2_phadd_d:
11469   case Intrinsic::x86_ssse3_phsub_w_128:
11470   case Intrinsic::x86_ssse3_phsub_d_128:
11471   case Intrinsic::x86_avx2_phsub_w:
11472   case Intrinsic::x86_avx2_phsub_d: {
11473     unsigned Opcode;
11474     switch (IntNo) {
11475     default: llvm_unreachable("Impossible intrinsic");  // Can't reach here.
11476     case Intrinsic::x86_sse3_hadd_ps:
11477     case Intrinsic::x86_sse3_hadd_pd:
11478     case Intrinsic::x86_avx_hadd_ps_256:
11479     case Intrinsic::x86_avx_hadd_pd_256:
11480       Opcode = X86ISD::FHADD;
11481       break;
11482     case Intrinsic::x86_sse3_hsub_ps:
11483     case Intrinsic::x86_sse3_hsub_pd:
11484     case Intrinsic::x86_avx_hsub_ps_256:
11485     case Intrinsic::x86_avx_hsub_pd_256:
11486       Opcode = X86ISD::FHSUB;
11487       break;
11488     case Intrinsic::x86_ssse3_phadd_w_128:
11489     case Intrinsic::x86_ssse3_phadd_d_128:
11490     case Intrinsic::x86_avx2_phadd_w:
11491     case Intrinsic::x86_avx2_phadd_d:
11492       Opcode = X86ISD::HADD;
11493       break;
11494     case Intrinsic::x86_ssse3_phsub_w_128:
11495     case Intrinsic::x86_ssse3_phsub_d_128:
11496     case Intrinsic::x86_avx2_phsub_w:
11497     case Intrinsic::x86_avx2_phsub_d:
11498       Opcode = X86ISD::HSUB;
11499       break;
11500     }
11501     return DAG.getNode(Opcode, dl, Op.getValueType(),
11502                        Op.getOperand(1), Op.getOperand(2));
11503   }
11504
11505   // SSE2/SSE41/AVX2 integer max/min intrinsics.
11506   case Intrinsic::x86_sse2_pmaxu_b:
11507   case Intrinsic::x86_sse41_pmaxuw:
11508   case Intrinsic::x86_sse41_pmaxud:
11509   case Intrinsic::x86_avx2_pmaxu_b:
11510   case Intrinsic::x86_avx2_pmaxu_w:
11511   case Intrinsic::x86_avx2_pmaxu_d:
11512   case Intrinsic::x86_sse2_pminu_b:
11513   case Intrinsic::x86_sse41_pminuw:
11514   case Intrinsic::x86_sse41_pminud:
11515   case Intrinsic::x86_avx2_pminu_b:
11516   case Intrinsic::x86_avx2_pminu_w:
11517   case Intrinsic::x86_avx2_pminu_d:
11518   case Intrinsic::x86_sse41_pmaxsb:
11519   case Intrinsic::x86_sse2_pmaxs_w:
11520   case Intrinsic::x86_sse41_pmaxsd:
11521   case Intrinsic::x86_avx2_pmaxs_b:
11522   case Intrinsic::x86_avx2_pmaxs_w:
11523   case Intrinsic::x86_avx2_pmaxs_d:
11524   case Intrinsic::x86_sse41_pminsb:
11525   case Intrinsic::x86_sse2_pmins_w:
11526   case Intrinsic::x86_sse41_pminsd:
11527   case Intrinsic::x86_avx2_pmins_b:
11528   case Intrinsic::x86_avx2_pmins_w:
11529   case Intrinsic::x86_avx2_pmins_d: {
11530     unsigned Opcode;
11531     switch (IntNo) {
11532     default: llvm_unreachable("Impossible intrinsic");  // Can't reach here.
11533     case Intrinsic::x86_sse2_pmaxu_b:
11534     case Intrinsic::x86_sse41_pmaxuw:
11535     case Intrinsic::x86_sse41_pmaxud:
11536     case Intrinsic::x86_avx2_pmaxu_b:
11537     case Intrinsic::x86_avx2_pmaxu_w:
11538     case Intrinsic::x86_avx2_pmaxu_d:
11539       Opcode = X86ISD::UMAX;
11540       break;
11541     case Intrinsic::x86_sse2_pminu_b:
11542     case Intrinsic::x86_sse41_pminuw:
11543     case Intrinsic::x86_sse41_pminud:
11544     case Intrinsic::x86_avx2_pminu_b:
11545     case Intrinsic::x86_avx2_pminu_w:
11546     case Intrinsic::x86_avx2_pminu_d:
11547       Opcode = X86ISD::UMIN;
11548       break;
11549     case Intrinsic::x86_sse41_pmaxsb:
11550     case Intrinsic::x86_sse2_pmaxs_w:
11551     case Intrinsic::x86_sse41_pmaxsd:
11552     case Intrinsic::x86_avx2_pmaxs_b:
11553     case Intrinsic::x86_avx2_pmaxs_w:
11554     case Intrinsic::x86_avx2_pmaxs_d:
11555       Opcode = X86ISD::SMAX;
11556       break;
11557     case Intrinsic::x86_sse41_pminsb:
11558     case Intrinsic::x86_sse2_pmins_w:
11559     case Intrinsic::x86_sse41_pminsd:
11560     case Intrinsic::x86_avx2_pmins_b:
11561     case Intrinsic::x86_avx2_pmins_w:
11562     case Intrinsic::x86_avx2_pmins_d:
11563       Opcode = X86ISD::SMIN;
11564       break;
11565     }
11566     return DAG.getNode(Opcode, dl, Op.getValueType(),
11567                        Op.getOperand(1), Op.getOperand(2));
11568   }
11569
11570   // SSE/SSE2/AVX floating point max/min intrinsics.
11571   case Intrinsic::x86_sse_max_ps:
11572   case Intrinsic::x86_sse2_max_pd:
11573   case Intrinsic::x86_avx_max_ps_256:
11574   case Intrinsic::x86_avx_max_pd_256:
11575   case Intrinsic::x86_sse_min_ps:
11576   case Intrinsic::x86_sse2_min_pd:
11577   case Intrinsic::x86_avx_min_ps_256:
11578   case Intrinsic::x86_avx_min_pd_256: {
11579     unsigned Opcode;
11580     switch (IntNo) {
11581     default: llvm_unreachable("Impossible intrinsic");  // Can't reach here.
11582     case Intrinsic::x86_sse_max_ps:
11583     case Intrinsic::x86_sse2_max_pd:
11584     case Intrinsic::x86_avx_max_ps_256:
11585     case Intrinsic::x86_avx_max_pd_256:
11586       Opcode = X86ISD::FMAX;
11587       break;
11588     case Intrinsic::x86_sse_min_ps:
11589     case Intrinsic::x86_sse2_min_pd:
11590     case Intrinsic::x86_avx_min_ps_256:
11591     case Intrinsic::x86_avx_min_pd_256:
11592       Opcode = X86ISD::FMIN;
11593       break;
11594     }
11595     return DAG.getNode(Opcode, dl, Op.getValueType(),
11596                        Op.getOperand(1), Op.getOperand(2));
11597   }
11598
11599   // AVX2 variable shift intrinsics
11600   case Intrinsic::x86_avx2_psllv_d:
11601   case Intrinsic::x86_avx2_psllv_q:
11602   case Intrinsic::x86_avx2_psllv_d_256:
11603   case Intrinsic::x86_avx2_psllv_q_256:
11604   case Intrinsic::x86_avx2_psrlv_d:
11605   case Intrinsic::x86_avx2_psrlv_q:
11606   case Intrinsic::x86_avx2_psrlv_d_256:
11607   case Intrinsic::x86_avx2_psrlv_q_256:
11608   case Intrinsic::x86_avx2_psrav_d:
11609   case Intrinsic::x86_avx2_psrav_d_256: {
11610     unsigned Opcode;
11611     switch (IntNo) {
11612     default: llvm_unreachable("Impossible intrinsic");  // Can't reach here.
11613     case Intrinsic::x86_avx2_psllv_d:
11614     case Intrinsic::x86_avx2_psllv_q:
11615     case Intrinsic::x86_avx2_psllv_d_256:
11616     case Intrinsic::x86_avx2_psllv_q_256:
11617       Opcode = ISD::SHL;
11618       break;
11619     case Intrinsic::x86_avx2_psrlv_d:
11620     case Intrinsic::x86_avx2_psrlv_q:
11621     case Intrinsic::x86_avx2_psrlv_d_256:
11622     case Intrinsic::x86_avx2_psrlv_q_256:
11623       Opcode = ISD::SRL;
11624       break;
11625     case Intrinsic::x86_avx2_psrav_d:
11626     case Intrinsic::x86_avx2_psrav_d_256:
11627       Opcode = ISD::SRA;
11628       break;
11629     }
11630     return DAG.getNode(Opcode, dl, Op.getValueType(),
11631                        Op.getOperand(1), Op.getOperand(2));
11632   }
11633
11634   case Intrinsic::x86_ssse3_pshuf_b_128:
11635   case Intrinsic::x86_avx2_pshuf_b:
11636     return DAG.getNode(X86ISD::PSHUFB, dl, Op.getValueType(),
11637                        Op.getOperand(1), Op.getOperand(2));
11638
11639   case Intrinsic::x86_ssse3_psign_b_128:
11640   case Intrinsic::x86_ssse3_psign_w_128:
11641   case Intrinsic::x86_ssse3_psign_d_128:
11642   case Intrinsic::x86_avx2_psign_b:
11643   case Intrinsic::x86_avx2_psign_w:
11644   case Intrinsic::x86_avx2_psign_d:
11645     return DAG.getNode(X86ISD::PSIGN, dl, Op.getValueType(),
11646                        Op.getOperand(1), Op.getOperand(2));
11647
11648   case Intrinsic::x86_sse41_insertps:
11649     return DAG.getNode(X86ISD::INSERTPS, dl, Op.getValueType(),
11650                        Op.getOperand(1), Op.getOperand(2), Op.getOperand(3));
11651
11652   case Intrinsic::x86_avx_vperm2f128_ps_256:
11653   case Intrinsic::x86_avx_vperm2f128_pd_256:
11654   case Intrinsic::x86_avx_vperm2f128_si_256:
11655   case Intrinsic::x86_avx2_vperm2i128:
11656     return DAG.getNode(X86ISD::VPERM2X128, dl, Op.getValueType(),
11657                        Op.getOperand(1), Op.getOperand(2), Op.getOperand(3));
11658
11659   case Intrinsic::x86_avx2_permd:
11660   case Intrinsic::x86_avx2_permps:
11661     // Operands intentionally swapped. Mask is last operand to intrinsic,
11662     // but second operand for node/instruction.
11663     return DAG.getNode(X86ISD::VPERMV, dl, Op.getValueType(),
11664                        Op.getOperand(2), Op.getOperand(1));
11665
11666   case Intrinsic::x86_sse_sqrt_ps:
11667   case Intrinsic::x86_sse2_sqrt_pd:
11668   case Intrinsic::x86_avx_sqrt_ps_256:
11669   case Intrinsic::x86_avx_sqrt_pd_256:
11670     return DAG.getNode(ISD::FSQRT, dl, Op.getValueType(), Op.getOperand(1));
11671
11672   // ptest and testp intrinsics. The intrinsic these come from are designed to
11673   // return an integer value, not just an instruction so lower it to the ptest
11674   // or testp pattern and a setcc for the result.
11675   case Intrinsic::x86_sse41_ptestz:
11676   case Intrinsic::x86_sse41_ptestc:
11677   case Intrinsic::x86_sse41_ptestnzc:
11678   case Intrinsic::x86_avx_ptestz_256:
11679   case Intrinsic::x86_avx_ptestc_256:
11680   case Intrinsic::x86_avx_ptestnzc_256:
11681   case Intrinsic::x86_avx_vtestz_ps:
11682   case Intrinsic::x86_avx_vtestc_ps:
11683   case Intrinsic::x86_avx_vtestnzc_ps:
11684   case Intrinsic::x86_avx_vtestz_pd:
11685   case Intrinsic::x86_avx_vtestc_pd:
11686   case Intrinsic::x86_avx_vtestnzc_pd:
11687   case Intrinsic::x86_avx_vtestz_ps_256:
11688   case Intrinsic::x86_avx_vtestc_ps_256:
11689   case Intrinsic::x86_avx_vtestnzc_ps_256:
11690   case Intrinsic::x86_avx_vtestz_pd_256:
11691   case Intrinsic::x86_avx_vtestc_pd_256:
11692   case Intrinsic::x86_avx_vtestnzc_pd_256: {
11693     bool IsTestPacked = false;
11694     unsigned X86CC;
11695     switch (IntNo) {
11696     default: llvm_unreachable("Bad fallthrough in Intrinsic lowering.");
11697     case Intrinsic::x86_avx_vtestz_ps:
11698     case Intrinsic::x86_avx_vtestz_pd:
11699     case Intrinsic::x86_avx_vtestz_ps_256:
11700     case Intrinsic::x86_avx_vtestz_pd_256:
11701       IsTestPacked = true; // Fallthrough
11702     case Intrinsic::x86_sse41_ptestz:
11703     case Intrinsic::x86_avx_ptestz_256:
11704       // ZF = 1
11705       X86CC = X86::COND_E;
11706       break;
11707     case Intrinsic::x86_avx_vtestc_ps:
11708     case Intrinsic::x86_avx_vtestc_pd:
11709     case Intrinsic::x86_avx_vtestc_ps_256:
11710     case Intrinsic::x86_avx_vtestc_pd_256:
11711       IsTestPacked = true; // Fallthrough
11712     case Intrinsic::x86_sse41_ptestc:
11713     case Intrinsic::x86_avx_ptestc_256:
11714       // CF = 1
11715       X86CC = X86::COND_B;
11716       break;
11717     case Intrinsic::x86_avx_vtestnzc_ps:
11718     case Intrinsic::x86_avx_vtestnzc_pd:
11719     case Intrinsic::x86_avx_vtestnzc_ps_256:
11720     case Intrinsic::x86_avx_vtestnzc_pd_256:
11721       IsTestPacked = true; // Fallthrough
11722     case Intrinsic::x86_sse41_ptestnzc:
11723     case Intrinsic::x86_avx_ptestnzc_256:
11724       // ZF and CF = 0
11725       X86CC = X86::COND_A;
11726       break;
11727     }
11728
11729     SDValue LHS = Op.getOperand(1);
11730     SDValue RHS = Op.getOperand(2);
11731     unsigned TestOpc = IsTestPacked ? X86ISD::TESTP : X86ISD::PTEST;
11732     SDValue Test = DAG.getNode(TestOpc, dl, MVT::i32, LHS, RHS);
11733     SDValue CC = DAG.getConstant(X86CC, MVT::i8);
11734     SDValue SetCC = DAG.getNode(X86ISD::SETCC, dl, MVT::i8, CC, Test);
11735     return DAG.getNode(ISD::ZERO_EXTEND, dl, MVT::i32, SetCC);
11736   }
11737   case Intrinsic::x86_avx512_kortestz_w:
11738   case Intrinsic::x86_avx512_kortestc_w: {
11739     unsigned X86CC = (IntNo == Intrinsic::x86_avx512_kortestz_w)? X86::COND_E: X86::COND_B;
11740     SDValue LHS = DAG.getNode(ISD::BITCAST, dl, MVT::v16i1, Op.getOperand(1));
11741     SDValue RHS = DAG.getNode(ISD::BITCAST, dl, MVT::v16i1, Op.getOperand(2));
11742     SDValue CC = DAG.getConstant(X86CC, MVT::i8);
11743     SDValue Test = DAG.getNode(X86ISD::KORTEST, dl, MVT::i32, LHS, RHS);
11744     SDValue SetCC = DAG.getNode(X86ISD::SETCC, dl, MVT::i1, CC, Test);
11745     return DAG.getNode(ISD::ZERO_EXTEND, dl, MVT::i32, SetCC);
11746   }
11747
11748   // SSE/AVX shift intrinsics
11749   case Intrinsic::x86_sse2_psll_w:
11750   case Intrinsic::x86_sse2_psll_d:
11751   case Intrinsic::x86_sse2_psll_q:
11752   case Intrinsic::x86_avx2_psll_w:
11753   case Intrinsic::x86_avx2_psll_d:
11754   case Intrinsic::x86_avx2_psll_q:
11755   case Intrinsic::x86_sse2_psrl_w:
11756   case Intrinsic::x86_sse2_psrl_d:
11757   case Intrinsic::x86_sse2_psrl_q:
11758   case Intrinsic::x86_avx2_psrl_w:
11759   case Intrinsic::x86_avx2_psrl_d:
11760   case Intrinsic::x86_avx2_psrl_q:
11761   case Intrinsic::x86_sse2_psra_w:
11762   case Intrinsic::x86_sse2_psra_d:
11763   case Intrinsic::x86_avx2_psra_w:
11764   case Intrinsic::x86_avx2_psra_d: {
11765     unsigned Opcode;
11766     switch (IntNo) {
11767     default: llvm_unreachable("Impossible intrinsic");  // Can't reach here.
11768     case Intrinsic::x86_sse2_psll_w:
11769     case Intrinsic::x86_sse2_psll_d:
11770     case Intrinsic::x86_sse2_psll_q:
11771     case Intrinsic::x86_avx2_psll_w:
11772     case Intrinsic::x86_avx2_psll_d:
11773     case Intrinsic::x86_avx2_psll_q:
11774       Opcode = X86ISD::VSHL;
11775       break;
11776     case Intrinsic::x86_sse2_psrl_w:
11777     case Intrinsic::x86_sse2_psrl_d:
11778     case Intrinsic::x86_sse2_psrl_q:
11779     case Intrinsic::x86_avx2_psrl_w:
11780     case Intrinsic::x86_avx2_psrl_d:
11781     case Intrinsic::x86_avx2_psrl_q:
11782       Opcode = X86ISD::VSRL;
11783       break;
11784     case Intrinsic::x86_sse2_psra_w:
11785     case Intrinsic::x86_sse2_psra_d:
11786     case Intrinsic::x86_avx2_psra_w:
11787     case Intrinsic::x86_avx2_psra_d:
11788       Opcode = X86ISD::VSRA;
11789       break;
11790     }
11791     return DAG.getNode(Opcode, dl, Op.getValueType(),
11792                        Op.getOperand(1), Op.getOperand(2));
11793   }
11794
11795   // SSE/AVX immediate shift intrinsics
11796   case Intrinsic::x86_sse2_pslli_w:
11797   case Intrinsic::x86_sse2_pslli_d:
11798   case Intrinsic::x86_sse2_pslli_q:
11799   case Intrinsic::x86_avx2_pslli_w:
11800   case Intrinsic::x86_avx2_pslli_d:
11801   case Intrinsic::x86_avx2_pslli_q:
11802   case Intrinsic::x86_sse2_psrli_w:
11803   case Intrinsic::x86_sse2_psrli_d:
11804   case Intrinsic::x86_sse2_psrli_q:
11805   case Intrinsic::x86_avx2_psrli_w:
11806   case Intrinsic::x86_avx2_psrli_d:
11807   case Intrinsic::x86_avx2_psrli_q:
11808   case Intrinsic::x86_sse2_psrai_w:
11809   case Intrinsic::x86_sse2_psrai_d:
11810   case Intrinsic::x86_avx2_psrai_w:
11811   case Intrinsic::x86_avx2_psrai_d: {
11812     unsigned Opcode;
11813     switch (IntNo) {
11814     default: llvm_unreachable("Impossible intrinsic");  // Can't reach here.
11815     case Intrinsic::x86_sse2_pslli_w:
11816     case Intrinsic::x86_sse2_pslli_d:
11817     case Intrinsic::x86_sse2_pslli_q:
11818     case Intrinsic::x86_avx2_pslli_w:
11819     case Intrinsic::x86_avx2_pslli_d:
11820     case Intrinsic::x86_avx2_pslli_q:
11821       Opcode = X86ISD::VSHLI;
11822       break;
11823     case Intrinsic::x86_sse2_psrli_w:
11824     case Intrinsic::x86_sse2_psrli_d:
11825     case Intrinsic::x86_sse2_psrli_q:
11826     case Intrinsic::x86_avx2_psrli_w:
11827     case Intrinsic::x86_avx2_psrli_d:
11828     case Intrinsic::x86_avx2_psrli_q:
11829       Opcode = X86ISD::VSRLI;
11830       break;
11831     case Intrinsic::x86_sse2_psrai_w:
11832     case Intrinsic::x86_sse2_psrai_d:
11833     case Intrinsic::x86_avx2_psrai_w:
11834     case Intrinsic::x86_avx2_psrai_d:
11835       Opcode = X86ISD::VSRAI;
11836       break;
11837     }
11838     return getTargetVShiftNode(Opcode, dl, Op.getSimpleValueType(),
11839                                Op.getOperand(1), Op.getOperand(2), DAG);
11840   }
11841
11842   case Intrinsic::x86_sse42_pcmpistria128:
11843   case Intrinsic::x86_sse42_pcmpestria128:
11844   case Intrinsic::x86_sse42_pcmpistric128:
11845   case Intrinsic::x86_sse42_pcmpestric128:
11846   case Intrinsic::x86_sse42_pcmpistrio128:
11847   case Intrinsic::x86_sse42_pcmpestrio128:
11848   case Intrinsic::x86_sse42_pcmpistris128:
11849   case Intrinsic::x86_sse42_pcmpestris128:
11850   case Intrinsic::x86_sse42_pcmpistriz128:
11851   case Intrinsic::x86_sse42_pcmpestriz128: {
11852     unsigned Opcode;
11853     unsigned X86CC;
11854     switch (IntNo) {
11855     default: llvm_unreachable("Impossible intrinsic");  // Can't reach here.
11856     case Intrinsic::x86_sse42_pcmpistria128:
11857       Opcode = X86ISD::PCMPISTRI;
11858       X86CC = X86::COND_A;
11859       break;
11860     case Intrinsic::x86_sse42_pcmpestria128:
11861       Opcode = X86ISD::PCMPESTRI;
11862       X86CC = X86::COND_A;
11863       break;
11864     case Intrinsic::x86_sse42_pcmpistric128:
11865       Opcode = X86ISD::PCMPISTRI;
11866       X86CC = X86::COND_B;
11867       break;
11868     case Intrinsic::x86_sse42_pcmpestric128:
11869       Opcode = X86ISD::PCMPESTRI;
11870       X86CC = X86::COND_B;
11871       break;
11872     case Intrinsic::x86_sse42_pcmpistrio128:
11873       Opcode = X86ISD::PCMPISTRI;
11874       X86CC = X86::COND_O;
11875       break;
11876     case Intrinsic::x86_sse42_pcmpestrio128:
11877       Opcode = X86ISD::PCMPESTRI;
11878       X86CC = X86::COND_O;
11879       break;
11880     case Intrinsic::x86_sse42_pcmpistris128:
11881       Opcode = X86ISD::PCMPISTRI;
11882       X86CC = X86::COND_S;
11883       break;
11884     case Intrinsic::x86_sse42_pcmpestris128:
11885       Opcode = X86ISD::PCMPESTRI;
11886       X86CC = X86::COND_S;
11887       break;
11888     case Intrinsic::x86_sse42_pcmpistriz128:
11889       Opcode = X86ISD::PCMPISTRI;
11890       X86CC = X86::COND_E;
11891       break;
11892     case Intrinsic::x86_sse42_pcmpestriz128:
11893       Opcode = X86ISD::PCMPESTRI;
11894       X86CC = X86::COND_E;
11895       break;
11896     }
11897     SmallVector<SDValue, 5> NewOps(Op->op_begin()+1, Op->op_end());
11898     SDVTList VTs = DAG.getVTList(Op.getValueType(), MVT::i32);
11899     SDValue PCMP = DAG.getNode(Opcode, dl, VTs, NewOps.data(), NewOps.size());
11900     SDValue SetCC = DAG.getNode(X86ISD::SETCC, dl, MVT::i8,
11901                                 DAG.getConstant(X86CC, MVT::i8),
11902                                 SDValue(PCMP.getNode(), 1));
11903     return DAG.getNode(ISD::ZERO_EXTEND, dl, MVT::i32, SetCC);
11904   }
11905
11906   case Intrinsic::x86_sse42_pcmpistri128:
11907   case Intrinsic::x86_sse42_pcmpestri128: {
11908     unsigned Opcode;
11909     if (IntNo == Intrinsic::x86_sse42_pcmpistri128)
11910       Opcode = X86ISD::PCMPISTRI;
11911     else
11912       Opcode = X86ISD::PCMPESTRI;
11913
11914     SmallVector<SDValue, 5> NewOps(Op->op_begin()+1, Op->op_end());
11915     SDVTList VTs = DAG.getVTList(Op.getValueType(), MVT::i32);
11916     return DAG.getNode(Opcode, dl, VTs, NewOps.data(), NewOps.size());
11917   }
11918   case Intrinsic::x86_fma_vfmadd_ps:
11919   case Intrinsic::x86_fma_vfmadd_pd:
11920   case Intrinsic::x86_fma_vfmsub_ps:
11921   case Intrinsic::x86_fma_vfmsub_pd:
11922   case Intrinsic::x86_fma_vfnmadd_ps:
11923   case Intrinsic::x86_fma_vfnmadd_pd:
11924   case Intrinsic::x86_fma_vfnmsub_ps:
11925   case Intrinsic::x86_fma_vfnmsub_pd:
11926   case Intrinsic::x86_fma_vfmaddsub_ps:
11927   case Intrinsic::x86_fma_vfmaddsub_pd:
11928   case Intrinsic::x86_fma_vfmsubadd_ps:
11929   case Intrinsic::x86_fma_vfmsubadd_pd:
11930   case Intrinsic::x86_fma_vfmadd_ps_256:
11931   case Intrinsic::x86_fma_vfmadd_pd_256:
11932   case Intrinsic::x86_fma_vfmsub_ps_256:
11933   case Intrinsic::x86_fma_vfmsub_pd_256:
11934   case Intrinsic::x86_fma_vfnmadd_ps_256:
11935   case Intrinsic::x86_fma_vfnmadd_pd_256:
11936   case Intrinsic::x86_fma_vfnmsub_ps_256:
11937   case Intrinsic::x86_fma_vfnmsub_pd_256:
11938   case Intrinsic::x86_fma_vfmaddsub_ps_256:
11939   case Intrinsic::x86_fma_vfmaddsub_pd_256:
11940   case Intrinsic::x86_fma_vfmsubadd_ps_256:
11941   case Intrinsic::x86_fma_vfmsubadd_pd_256:
11942   case Intrinsic::x86_fma_vfmadd_ps_512:
11943   case Intrinsic::x86_fma_vfmadd_pd_512:
11944   case Intrinsic::x86_fma_vfmsub_ps_512:
11945   case Intrinsic::x86_fma_vfmsub_pd_512:
11946   case Intrinsic::x86_fma_vfnmadd_ps_512:
11947   case Intrinsic::x86_fma_vfnmadd_pd_512:
11948   case Intrinsic::x86_fma_vfnmsub_ps_512:
11949   case Intrinsic::x86_fma_vfnmsub_pd_512:
11950   case Intrinsic::x86_fma_vfmaddsub_ps_512:
11951   case Intrinsic::x86_fma_vfmaddsub_pd_512:
11952   case Intrinsic::x86_fma_vfmsubadd_ps_512:
11953   case Intrinsic::x86_fma_vfmsubadd_pd_512: {
11954     unsigned Opc;
11955     switch (IntNo) {
11956     default: llvm_unreachable("Impossible intrinsic");  // Can't reach here.
11957     case Intrinsic::x86_fma_vfmadd_ps:
11958     case Intrinsic::x86_fma_vfmadd_pd:
11959     case Intrinsic::x86_fma_vfmadd_ps_256:
11960     case Intrinsic::x86_fma_vfmadd_pd_256:
11961     case Intrinsic::x86_fma_vfmadd_ps_512:
11962     case Intrinsic::x86_fma_vfmadd_pd_512:
11963       Opc = X86ISD::FMADD;
11964       break;
11965     case Intrinsic::x86_fma_vfmsub_ps:
11966     case Intrinsic::x86_fma_vfmsub_pd:
11967     case Intrinsic::x86_fma_vfmsub_ps_256:
11968     case Intrinsic::x86_fma_vfmsub_pd_256:
11969     case Intrinsic::x86_fma_vfmsub_ps_512:
11970     case Intrinsic::x86_fma_vfmsub_pd_512:
11971       Opc = X86ISD::FMSUB;
11972       break;
11973     case Intrinsic::x86_fma_vfnmadd_ps:
11974     case Intrinsic::x86_fma_vfnmadd_pd:
11975     case Intrinsic::x86_fma_vfnmadd_ps_256:
11976     case Intrinsic::x86_fma_vfnmadd_pd_256:
11977     case Intrinsic::x86_fma_vfnmadd_ps_512:
11978     case Intrinsic::x86_fma_vfnmadd_pd_512:
11979       Opc = X86ISD::FNMADD;
11980       break;
11981     case Intrinsic::x86_fma_vfnmsub_ps:
11982     case Intrinsic::x86_fma_vfnmsub_pd:
11983     case Intrinsic::x86_fma_vfnmsub_ps_256:
11984     case Intrinsic::x86_fma_vfnmsub_pd_256:
11985     case Intrinsic::x86_fma_vfnmsub_ps_512:
11986     case Intrinsic::x86_fma_vfnmsub_pd_512:
11987       Opc = X86ISD::FNMSUB;
11988       break;
11989     case Intrinsic::x86_fma_vfmaddsub_ps:
11990     case Intrinsic::x86_fma_vfmaddsub_pd:
11991     case Intrinsic::x86_fma_vfmaddsub_ps_256:
11992     case Intrinsic::x86_fma_vfmaddsub_pd_256:
11993     case Intrinsic::x86_fma_vfmaddsub_ps_512:
11994     case Intrinsic::x86_fma_vfmaddsub_pd_512:
11995       Opc = X86ISD::FMADDSUB;
11996       break;
11997     case Intrinsic::x86_fma_vfmsubadd_ps:
11998     case Intrinsic::x86_fma_vfmsubadd_pd:
11999     case Intrinsic::x86_fma_vfmsubadd_ps_256:
12000     case Intrinsic::x86_fma_vfmsubadd_pd_256:
12001     case Intrinsic::x86_fma_vfmsubadd_ps_512:
12002     case Intrinsic::x86_fma_vfmsubadd_pd_512:
12003       Opc = X86ISD::FMSUBADD;
12004       break;
12005     }
12006
12007     return DAG.getNode(Opc, dl, Op.getValueType(), Op.getOperand(1),
12008                        Op.getOperand(2), Op.getOperand(3));
12009   }
12010   }
12011 }
12012
12013 static SDValue getGatherNode(unsigned Opc, SDValue Op, SelectionDAG &DAG,
12014                              SDValue Base, SDValue Index,
12015                              SDValue ScaleOp, SDValue Chain,
12016                              const X86Subtarget * Subtarget) {
12017   SDLoc dl(Op);
12018   ConstantSDNode *C = dyn_cast<ConstantSDNode>(ScaleOp);
12019   assert(C && "Invalid scale type");
12020   SDValue Scale = DAG.getTargetConstant(C->getZExtValue(), MVT::i8);
12021   SDValue Src = getZeroVector(Op.getValueType(), Subtarget, DAG, dl);
12022   EVT MaskVT = MVT::getVectorVT(MVT::i1,
12023                              Index.getSimpleValueType().getVectorNumElements());
12024   SDValue MaskInReg = DAG.getConstant(~0, MaskVT);
12025   SDVTList VTs = DAG.getVTList(Op.getValueType(), MaskVT, MVT::Other);
12026   SDValue Disp = DAG.getTargetConstant(0, MVT::i32);
12027   SDValue Segment = DAG.getRegister(0, MVT::i32);
12028   SDValue Ops[] = {Src, MaskInReg, Base, Scale, Index, Disp, Segment, Chain};
12029   SDNode *Res = DAG.getMachineNode(Opc, dl, VTs, Ops);
12030   SDValue RetOps[] = { SDValue(Res, 0), SDValue(Res, 2) };
12031   return DAG.getMergeValues(RetOps, array_lengthof(RetOps), dl);
12032 }
12033
12034 static SDValue getMGatherNode(unsigned Opc, SDValue Op, SelectionDAG &DAG,
12035                               SDValue Src, SDValue Mask, SDValue Base,
12036                               SDValue Index, SDValue ScaleOp, SDValue Chain,
12037                               const X86Subtarget * Subtarget) {
12038   SDLoc dl(Op);
12039   ConstantSDNode *C = dyn_cast<ConstantSDNode>(ScaleOp);
12040   assert(C && "Invalid scale type");
12041   SDValue Scale = DAG.getTargetConstant(C->getZExtValue(), MVT::i8);
12042   EVT MaskVT = MVT::getVectorVT(MVT::i1,
12043                              Index.getSimpleValueType().getVectorNumElements());
12044   SDValue MaskInReg = DAG.getNode(ISD::BITCAST, dl, MaskVT, Mask);
12045   SDVTList VTs = DAG.getVTList(Op.getValueType(), MaskVT, MVT::Other);
12046   SDValue Disp = DAG.getTargetConstant(0, MVT::i32);
12047   SDValue Segment = DAG.getRegister(0, MVT::i32);
12048   if (Src.getOpcode() == ISD::UNDEF)
12049     Src = getZeroVector(Op.getValueType(), Subtarget, DAG, dl);
12050   SDValue Ops[] = {Src, MaskInReg, Base, Scale, Index, Disp, Segment, Chain};
12051   SDNode *Res = DAG.getMachineNode(Opc, dl, VTs, Ops);
12052   SDValue RetOps[] = { SDValue(Res, 0), SDValue(Res, 2) };
12053   return DAG.getMergeValues(RetOps, array_lengthof(RetOps), dl);
12054 }
12055
12056 static SDValue getScatterNode(unsigned Opc, SDValue Op, SelectionDAG &DAG,
12057                               SDValue Src, SDValue Base, SDValue Index,
12058                               SDValue ScaleOp, SDValue Chain) {
12059   SDLoc dl(Op);
12060   ConstantSDNode *C = dyn_cast<ConstantSDNode>(ScaleOp);
12061   assert(C && "Invalid scale type");
12062   SDValue Scale = DAG.getTargetConstant(C->getZExtValue(), MVT::i8);
12063   SDValue Disp = DAG.getTargetConstant(0, MVT::i32);
12064   SDValue Segment = DAG.getRegister(0, MVT::i32);
12065   EVT MaskVT = MVT::getVectorVT(MVT::i1,
12066                              Index.getSimpleValueType().getVectorNumElements());
12067   SDValue MaskInReg = DAG.getConstant(~0, MaskVT);
12068   SDVTList VTs = DAG.getVTList(MaskVT, MVT::Other);
12069   SDValue Ops[] = {Base, Scale, Index, Disp, Segment, MaskInReg, Src, Chain};
12070   SDNode *Res = DAG.getMachineNode(Opc, dl, VTs, Ops);
12071   return SDValue(Res, 1);
12072 }
12073
12074 static SDValue getMScatterNode(unsigned Opc, SDValue Op, SelectionDAG &DAG,
12075                                SDValue Src, SDValue Mask, SDValue Base,
12076                                SDValue Index, SDValue ScaleOp, SDValue Chain) {
12077   SDLoc dl(Op);
12078   ConstantSDNode *C = dyn_cast<ConstantSDNode>(ScaleOp);
12079   assert(C && "Invalid scale type");
12080   SDValue Scale = DAG.getTargetConstant(C->getZExtValue(), MVT::i8);
12081   SDValue Disp = DAG.getTargetConstant(0, MVT::i32);
12082   SDValue Segment = DAG.getRegister(0, MVT::i32);
12083   EVT MaskVT = MVT::getVectorVT(MVT::i1,
12084                              Index.getSimpleValueType().getVectorNumElements());
12085   SDValue MaskInReg = DAG.getNode(ISD::BITCAST, dl, MaskVT, Mask);
12086   SDVTList VTs = DAG.getVTList(MaskVT, MVT::Other);
12087   SDValue Ops[] = {Base, Scale, Index, Disp, Segment, MaskInReg, Src, Chain};
12088   SDNode *Res = DAG.getMachineNode(Opc, dl, VTs, Ops);
12089   return SDValue(Res, 1);
12090 }
12091
12092 static SDValue LowerINTRINSIC_W_CHAIN(SDValue Op, const X86Subtarget *Subtarget,
12093                                       SelectionDAG &DAG) {
12094   SDLoc dl(Op);
12095   unsigned IntNo = cast<ConstantSDNode>(Op.getOperand(1))->getZExtValue();
12096   switch (IntNo) {
12097   default: return SDValue();    // Don't custom lower most intrinsics.
12098
12099   // RDRAND/RDSEED intrinsics.
12100   case Intrinsic::x86_rdrand_16:
12101   case Intrinsic::x86_rdrand_32:
12102   case Intrinsic::x86_rdrand_64:
12103   case Intrinsic::x86_rdseed_16:
12104   case Intrinsic::x86_rdseed_32:
12105   case Intrinsic::x86_rdseed_64: {
12106     unsigned Opcode = (IntNo == Intrinsic::x86_rdseed_16 ||
12107                        IntNo == Intrinsic::x86_rdseed_32 ||
12108                        IntNo == Intrinsic::x86_rdseed_64) ? X86ISD::RDSEED :
12109                                                             X86ISD::RDRAND;
12110     // Emit the node with the right value type.
12111     SDVTList VTs = DAG.getVTList(Op->getValueType(0), MVT::Glue, MVT::Other);
12112     SDValue Result = DAG.getNode(Opcode, dl, VTs, Op.getOperand(0));
12113
12114     // If the value returned by RDRAND/RDSEED was valid (CF=1), return 1.
12115     // Otherwise return the value from Rand, which is always 0, casted to i32.
12116     SDValue Ops[] = { DAG.getZExtOrTrunc(Result, dl, Op->getValueType(1)),
12117                       DAG.getConstant(1, Op->getValueType(1)),
12118                       DAG.getConstant(X86::COND_B, MVT::i32),
12119                       SDValue(Result.getNode(), 1) };
12120     SDValue isValid = DAG.getNode(X86ISD::CMOV, dl,
12121                                   DAG.getVTList(Op->getValueType(1), MVT::Glue),
12122                                   Ops, array_lengthof(Ops));
12123
12124     // Return { result, isValid, chain }.
12125     return DAG.getNode(ISD::MERGE_VALUES, dl, Op->getVTList(), Result, isValid,
12126                        SDValue(Result.getNode(), 2));
12127   }
12128   //int_gather(index, base, scale);
12129   case Intrinsic::x86_avx512_gather_qpd_512:
12130   case Intrinsic::x86_avx512_gather_qps_512:
12131   case Intrinsic::x86_avx512_gather_dpd_512:
12132   case Intrinsic::x86_avx512_gather_qpi_512:
12133   case Intrinsic::x86_avx512_gather_qpq_512:
12134   case Intrinsic::x86_avx512_gather_dpq_512:
12135   case Intrinsic::x86_avx512_gather_dps_512:
12136   case Intrinsic::x86_avx512_gather_dpi_512: {
12137     unsigned Opc;
12138     switch (IntNo) {
12139     default: llvm_unreachable("Impossible intrinsic");  // Can't reach here.
12140     case Intrinsic::x86_avx512_gather_qps_512: Opc = X86::VGATHERQPSZrm; break;
12141     case Intrinsic::x86_avx512_gather_qpd_512: Opc = X86::VGATHERQPDZrm; break;
12142     case Intrinsic::x86_avx512_gather_dpd_512: Opc = X86::VGATHERDPDZrm; break;
12143     case Intrinsic::x86_avx512_gather_dps_512: Opc = X86::VGATHERDPSZrm; break;
12144     case Intrinsic::x86_avx512_gather_qpi_512: Opc = X86::VPGATHERQDZrm; break;
12145     case Intrinsic::x86_avx512_gather_qpq_512: Opc = X86::VPGATHERQQZrm; break;
12146     case Intrinsic::x86_avx512_gather_dpi_512: Opc = X86::VPGATHERDDZrm; break;
12147     case Intrinsic::x86_avx512_gather_dpq_512: Opc = X86::VPGATHERDQZrm; break;
12148     }
12149     SDValue Chain = Op.getOperand(0);
12150     SDValue Index = Op.getOperand(2);
12151     SDValue Base  = Op.getOperand(3);
12152     SDValue Scale = Op.getOperand(4);
12153     return getGatherNode(Opc, Op, DAG, Base, Index, Scale, Chain, Subtarget);
12154   }
12155   //int_gather_mask(v1, mask, index, base, scale);
12156   case Intrinsic::x86_avx512_gather_qps_mask_512:
12157   case Intrinsic::x86_avx512_gather_qpd_mask_512:
12158   case Intrinsic::x86_avx512_gather_dpd_mask_512:
12159   case Intrinsic::x86_avx512_gather_dps_mask_512:
12160   case Intrinsic::x86_avx512_gather_qpi_mask_512:
12161   case Intrinsic::x86_avx512_gather_qpq_mask_512:
12162   case Intrinsic::x86_avx512_gather_dpi_mask_512:
12163   case Intrinsic::x86_avx512_gather_dpq_mask_512: {
12164     unsigned Opc;
12165     switch (IntNo) {
12166     default: llvm_unreachable("Impossible intrinsic");  // Can't reach here.
12167     case Intrinsic::x86_avx512_gather_qps_mask_512:
12168       Opc = X86::VGATHERQPSZrm; break;
12169     case Intrinsic::x86_avx512_gather_qpd_mask_512:
12170       Opc = X86::VGATHERQPDZrm; break;
12171     case Intrinsic::x86_avx512_gather_dpd_mask_512:
12172       Opc = X86::VGATHERDPDZrm; break;
12173     case Intrinsic::x86_avx512_gather_dps_mask_512:
12174       Opc = X86::VGATHERDPSZrm; break;
12175     case Intrinsic::x86_avx512_gather_qpi_mask_512:
12176       Opc = X86::VPGATHERQDZrm; break;
12177     case Intrinsic::x86_avx512_gather_qpq_mask_512:
12178       Opc = X86::VPGATHERQQZrm; break;
12179     case Intrinsic::x86_avx512_gather_dpi_mask_512:
12180       Opc = X86::VPGATHERDDZrm; break;
12181     case Intrinsic::x86_avx512_gather_dpq_mask_512:
12182       Opc = X86::VPGATHERDQZrm; break;
12183     }
12184     SDValue Chain = Op.getOperand(0);
12185     SDValue Src   = Op.getOperand(2);
12186     SDValue Mask  = Op.getOperand(3);
12187     SDValue Index = Op.getOperand(4);
12188     SDValue Base  = Op.getOperand(5);
12189     SDValue Scale = Op.getOperand(6);
12190     return getMGatherNode(Opc, Op, DAG, Src, Mask, Base, Index, Scale, Chain,
12191                           Subtarget);
12192   }
12193   //int_scatter(base, index, v1, scale);
12194   case Intrinsic::x86_avx512_scatter_qpd_512:
12195   case Intrinsic::x86_avx512_scatter_qps_512:
12196   case Intrinsic::x86_avx512_scatter_dpd_512:
12197   case Intrinsic::x86_avx512_scatter_qpi_512:
12198   case Intrinsic::x86_avx512_scatter_qpq_512:
12199   case Intrinsic::x86_avx512_scatter_dpq_512:
12200   case Intrinsic::x86_avx512_scatter_dps_512:
12201   case Intrinsic::x86_avx512_scatter_dpi_512: {
12202     unsigned Opc;
12203     switch (IntNo) {
12204     default: llvm_unreachable("Impossible intrinsic");  // Can't reach here.
12205     case Intrinsic::x86_avx512_scatter_qpd_512:
12206       Opc = X86::VSCATTERQPDZmr; break;
12207     case Intrinsic::x86_avx512_scatter_qps_512:
12208       Opc = X86::VSCATTERQPSZmr; break;
12209     case Intrinsic::x86_avx512_scatter_dpd_512:
12210       Opc = X86::VSCATTERDPDZmr; break;
12211     case Intrinsic::x86_avx512_scatter_dps_512:
12212       Opc = X86::VSCATTERDPSZmr; break;
12213     case Intrinsic::x86_avx512_scatter_qpi_512:
12214       Opc = X86::VPSCATTERQDZmr; break;
12215     case Intrinsic::x86_avx512_scatter_qpq_512:
12216       Opc = X86::VPSCATTERQQZmr; break;
12217     case Intrinsic::x86_avx512_scatter_dpq_512:
12218       Opc = X86::VPSCATTERDQZmr; break;
12219     case Intrinsic::x86_avx512_scatter_dpi_512:
12220       Opc = X86::VPSCATTERDDZmr; break;
12221     }
12222     SDValue Chain = Op.getOperand(0);
12223     SDValue Base  = Op.getOperand(2);
12224     SDValue Index = Op.getOperand(3);
12225     SDValue Src   = Op.getOperand(4);
12226     SDValue Scale = Op.getOperand(5);
12227     return getScatterNode(Opc, Op, DAG, Src, Base, Index, Scale, Chain);
12228   }
12229   //int_scatter_mask(base, mask, index, v1, scale);
12230   case Intrinsic::x86_avx512_scatter_qps_mask_512:
12231   case Intrinsic::x86_avx512_scatter_qpd_mask_512:
12232   case Intrinsic::x86_avx512_scatter_dpd_mask_512:
12233   case Intrinsic::x86_avx512_scatter_dps_mask_512:
12234   case Intrinsic::x86_avx512_scatter_qpi_mask_512:
12235   case Intrinsic::x86_avx512_scatter_qpq_mask_512:
12236   case Intrinsic::x86_avx512_scatter_dpi_mask_512:
12237   case Intrinsic::x86_avx512_scatter_dpq_mask_512: {
12238     unsigned Opc;
12239     switch (IntNo) {
12240     default: llvm_unreachable("Impossible intrinsic");  // Can't reach here.
12241     case Intrinsic::x86_avx512_scatter_qpd_mask_512:
12242       Opc = X86::VSCATTERQPDZmr; break;
12243     case Intrinsic::x86_avx512_scatter_qps_mask_512:
12244       Opc = X86::VSCATTERQPSZmr; break;
12245     case Intrinsic::x86_avx512_scatter_dpd_mask_512:
12246       Opc = X86::VSCATTERDPDZmr; break;
12247     case Intrinsic::x86_avx512_scatter_dps_mask_512:
12248       Opc = X86::VSCATTERDPSZmr; break;
12249     case Intrinsic::x86_avx512_scatter_qpi_mask_512:
12250       Opc = X86::VPSCATTERQDZmr; break;
12251     case Intrinsic::x86_avx512_scatter_qpq_mask_512:
12252       Opc = X86::VPSCATTERQQZmr; break;
12253     case Intrinsic::x86_avx512_scatter_dpq_mask_512:
12254       Opc = X86::VPSCATTERDQZmr; break;
12255     case Intrinsic::x86_avx512_scatter_dpi_mask_512:
12256       Opc = X86::VPSCATTERDDZmr; break;
12257     }
12258     SDValue Chain = Op.getOperand(0);
12259     SDValue Base  = Op.getOperand(2);
12260     SDValue Mask  = Op.getOperand(3);
12261     SDValue Index = Op.getOperand(4);
12262     SDValue Src   = Op.getOperand(5);
12263     SDValue Scale = Op.getOperand(6);
12264     return getMScatterNode(Opc, Op, DAG, Src, Mask, Base, Index, Scale, Chain);
12265   }
12266   // XTEST intrinsics.
12267   case Intrinsic::x86_xtest: {
12268     SDVTList VTs = DAG.getVTList(Op->getValueType(0), MVT::Other);
12269     SDValue InTrans = DAG.getNode(X86ISD::XTEST, dl, VTs, Op.getOperand(0));
12270     SDValue SetCC = DAG.getNode(X86ISD::SETCC, dl, MVT::i8,
12271                                 DAG.getConstant(X86::COND_NE, MVT::i8),
12272                                 InTrans);
12273     SDValue Ret = DAG.getNode(ISD::ZERO_EXTEND, dl, Op->getValueType(0), SetCC);
12274     return DAG.getNode(ISD::MERGE_VALUES, dl, Op->getVTList(),
12275                        Ret, SDValue(InTrans.getNode(), 1));
12276   }
12277   }
12278 }
12279
12280 SDValue X86TargetLowering::LowerRETURNADDR(SDValue Op,
12281                                            SelectionDAG &DAG) const {
12282   MachineFrameInfo *MFI = DAG.getMachineFunction().getFrameInfo();
12283   MFI->setReturnAddressIsTaken(true);
12284
12285   if (verifyReturnAddressArgumentIsConstant(Op, DAG))
12286     return SDValue();
12287
12288   unsigned Depth = cast<ConstantSDNode>(Op.getOperand(0))->getZExtValue();
12289   SDLoc dl(Op);
12290   EVT PtrVT = getPointerTy();
12291
12292   if (Depth > 0) {
12293     SDValue FrameAddr = LowerFRAMEADDR(Op, DAG);
12294     const X86RegisterInfo *RegInfo =
12295       static_cast<const X86RegisterInfo*>(getTargetMachine().getRegisterInfo());
12296     SDValue Offset = DAG.getConstant(RegInfo->getSlotSize(), PtrVT);
12297     return DAG.getLoad(PtrVT, dl, DAG.getEntryNode(),
12298                        DAG.getNode(ISD::ADD, dl, PtrVT,
12299                                    FrameAddr, Offset),
12300                        MachinePointerInfo(), false, false, false, 0);
12301   }
12302
12303   // Just load the return address.
12304   SDValue RetAddrFI = getReturnAddressFrameIndex(DAG);
12305   return DAG.getLoad(PtrVT, dl, DAG.getEntryNode(),
12306                      RetAddrFI, MachinePointerInfo(), false, false, false, 0);
12307 }
12308
12309 SDValue X86TargetLowering::LowerFRAMEADDR(SDValue Op, SelectionDAG &DAG) const {
12310   MachineFrameInfo *MFI = DAG.getMachineFunction().getFrameInfo();
12311   MFI->setFrameAddressIsTaken(true);
12312
12313   EVT VT = Op.getValueType();
12314   SDLoc dl(Op);  // FIXME probably not meaningful
12315   unsigned Depth = cast<ConstantSDNode>(Op.getOperand(0))->getZExtValue();
12316   const X86RegisterInfo *RegInfo =
12317     static_cast<const X86RegisterInfo*>(getTargetMachine().getRegisterInfo());
12318   unsigned FrameReg = RegInfo->getFrameRegister(DAG.getMachineFunction());
12319   assert(((FrameReg == X86::RBP && VT == MVT::i64) ||
12320           (FrameReg == X86::EBP && VT == MVT::i32)) &&
12321          "Invalid Frame Register!");
12322   SDValue FrameAddr = DAG.getCopyFromReg(DAG.getEntryNode(), dl, FrameReg, VT);
12323   while (Depth--)
12324     FrameAddr = DAG.getLoad(VT, dl, DAG.getEntryNode(), FrameAddr,
12325                             MachinePointerInfo(),
12326                             false, false, false, 0);
12327   return FrameAddr;
12328 }
12329
12330 SDValue X86TargetLowering::LowerFRAME_TO_ARGS_OFFSET(SDValue Op,
12331                                                      SelectionDAG &DAG) const {
12332   const X86RegisterInfo *RegInfo =
12333     static_cast<const X86RegisterInfo*>(getTargetMachine().getRegisterInfo());
12334   return DAG.getIntPtrConstant(2 * RegInfo->getSlotSize());
12335 }
12336
12337 SDValue X86TargetLowering::LowerEH_RETURN(SDValue Op, SelectionDAG &DAG) const {
12338   SDValue Chain     = Op.getOperand(0);
12339   SDValue Offset    = Op.getOperand(1);
12340   SDValue Handler   = Op.getOperand(2);
12341   SDLoc dl      (Op);
12342
12343   EVT PtrVT = getPointerTy();
12344   const X86RegisterInfo *RegInfo =
12345     static_cast<const X86RegisterInfo*>(getTargetMachine().getRegisterInfo());
12346   unsigned FrameReg = RegInfo->getFrameRegister(DAG.getMachineFunction());
12347   assert(((FrameReg == X86::RBP && PtrVT == MVT::i64) ||
12348           (FrameReg == X86::EBP && PtrVT == MVT::i32)) &&
12349          "Invalid Frame Register!");
12350   SDValue Frame = DAG.getCopyFromReg(DAG.getEntryNode(), dl, FrameReg, PtrVT);
12351   unsigned StoreAddrReg = (PtrVT == MVT::i64) ? X86::RCX : X86::ECX;
12352
12353   SDValue StoreAddr = DAG.getNode(ISD::ADD, dl, PtrVT, Frame,
12354                                  DAG.getIntPtrConstant(RegInfo->getSlotSize()));
12355   StoreAddr = DAG.getNode(ISD::ADD, dl, PtrVT, StoreAddr, Offset);
12356   Chain = DAG.getStore(Chain, dl, Handler, StoreAddr, MachinePointerInfo(),
12357                        false, false, 0);
12358   Chain = DAG.getCopyToReg(Chain, dl, StoreAddrReg, StoreAddr);
12359
12360   return DAG.getNode(X86ISD::EH_RETURN, dl, MVT::Other, Chain,
12361                      DAG.getRegister(StoreAddrReg, PtrVT));
12362 }
12363
12364 SDValue X86TargetLowering::lowerEH_SJLJ_SETJMP(SDValue Op,
12365                                                SelectionDAG &DAG) const {
12366   SDLoc DL(Op);
12367   return DAG.getNode(X86ISD::EH_SJLJ_SETJMP, DL,
12368                      DAG.getVTList(MVT::i32, MVT::Other),
12369                      Op.getOperand(0), Op.getOperand(1));
12370 }
12371
12372 SDValue X86TargetLowering::lowerEH_SJLJ_LONGJMP(SDValue Op,
12373                                                 SelectionDAG &DAG) const {
12374   SDLoc DL(Op);
12375   return DAG.getNode(X86ISD::EH_SJLJ_LONGJMP, DL, MVT::Other,
12376                      Op.getOperand(0), Op.getOperand(1));
12377 }
12378
12379 static SDValue LowerADJUST_TRAMPOLINE(SDValue Op, SelectionDAG &DAG) {
12380   return Op.getOperand(0);
12381 }
12382
12383 SDValue X86TargetLowering::LowerINIT_TRAMPOLINE(SDValue Op,
12384                                                 SelectionDAG &DAG) const {
12385   SDValue Root = Op.getOperand(0);
12386   SDValue Trmp = Op.getOperand(1); // trampoline
12387   SDValue FPtr = Op.getOperand(2); // nested function
12388   SDValue Nest = Op.getOperand(3); // 'nest' parameter value
12389   SDLoc dl (Op);
12390
12391   const Value *TrmpAddr = cast<SrcValueSDNode>(Op.getOperand(4))->getValue();
12392   const TargetRegisterInfo* TRI = getTargetMachine().getRegisterInfo();
12393
12394   if (Subtarget->is64Bit()) {
12395     SDValue OutChains[6];
12396
12397     // Large code-model.
12398     const unsigned char JMP64r  = 0xFF; // 64-bit jmp through register opcode.
12399     const unsigned char MOV64ri = 0xB8; // X86::MOV64ri opcode.
12400
12401     const unsigned char N86R10 = TRI->getEncodingValue(X86::R10) & 0x7;
12402     const unsigned char N86R11 = TRI->getEncodingValue(X86::R11) & 0x7;
12403
12404     const unsigned char REX_WB = 0x40 | 0x08 | 0x01; // REX prefix
12405
12406     // Load the pointer to the nested function into R11.
12407     unsigned OpCode = ((MOV64ri | N86R11) << 8) | REX_WB; // movabsq r11
12408     SDValue Addr = Trmp;
12409     OutChains[0] = DAG.getStore(Root, dl, DAG.getConstant(OpCode, MVT::i16),
12410                                 Addr, MachinePointerInfo(TrmpAddr),
12411                                 false, false, 0);
12412
12413     Addr = DAG.getNode(ISD::ADD, dl, MVT::i64, Trmp,
12414                        DAG.getConstant(2, MVT::i64));
12415     OutChains[1] = DAG.getStore(Root, dl, FPtr, Addr,
12416                                 MachinePointerInfo(TrmpAddr, 2),
12417                                 false, false, 2);
12418
12419     // Load the 'nest' parameter value into R10.
12420     // R10 is specified in X86CallingConv.td
12421     OpCode = ((MOV64ri | N86R10) << 8) | REX_WB; // movabsq r10
12422     Addr = DAG.getNode(ISD::ADD, dl, MVT::i64, Trmp,
12423                        DAG.getConstant(10, MVT::i64));
12424     OutChains[2] = DAG.getStore(Root, dl, DAG.getConstant(OpCode, MVT::i16),
12425                                 Addr, MachinePointerInfo(TrmpAddr, 10),
12426                                 false, false, 0);
12427
12428     Addr = DAG.getNode(ISD::ADD, dl, MVT::i64, Trmp,
12429                        DAG.getConstant(12, MVT::i64));
12430     OutChains[3] = DAG.getStore(Root, dl, Nest, Addr,
12431                                 MachinePointerInfo(TrmpAddr, 12),
12432                                 false, false, 2);
12433
12434     // Jump to the nested function.
12435     OpCode = (JMP64r << 8) | REX_WB; // jmpq *...
12436     Addr = DAG.getNode(ISD::ADD, dl, MVT::i64, Trmp,
12437                        DAG.getConstant(20, MVT::i64));
12438     OutChains[4] = DAG.getStore(Root, dl, DAG.getConstant(OpCode, MVT::i16),
12439                                 Addr, MachinePointerInfo(TrmpAddr, 20),
12440                                 false, false, 0);
12441
12442     unsigned char ModRM = N86R11 | (4 << 3) | (3 << 6); // ...r11
12443     Addr = DAG.getNode(ISD::ADD, dl, MVT::i64, Trmp,
12444                        DAG.getConstant(22, MVT::i64));
12445     OutChains[5] = DAG.getStore(Root, dl, DAG.getConstant(ModRM, MVT::i8), Addr,
12446                                 MachinePointerInfo(TrmpAddr, 22),
12447                                 false, false, 0);
12448
12449     return DAG.getNode(ISD::TokenFactor, dl, MVT::Other, OutChains, 6);
12450   } else {
12451     const Function *Func =
12452       cast<Function>(cast<SrcValueSDNode>(Op.getOperand(5))->getValue());
12453     CallingConv::ID CC = Func->getCallingConv();
12454     unsigned NestReg;
12455
12456     switch (CC) {
12457     default:
12458       llvm_unreachable("Unsupported calling convention");
12459     case CallingConv::C:
12460     case CallingConv::X86_StdCall: {
12461       // Pass 'nest' parameter in ECX.
12462       // Must be kept in sync with X86CallingConv.td
12463       NestReg = X86::ECX;
12464
12465       // Check that ECX wasn't needed by an 'inreg' parameter.
12466       FunctionType *FTy = Func->getFunctionType();
12467       const AttributeSet &Attrs = Func->getAttributes();
12468
12469       if (!Attrs.isEmpty() && !Func->isVarArg()) {
12470         unsigned InRegCount = 0;
12471         unsigned Idx = 1;
12472
12473         for (FunctionType::param_iterator I = FTy->param_begin(),
12474              E = FTy->param_end(); I != E; ++I, ++Idx)
12475           if (Attrs.hasAttribute(Idx, Attribute::InReg))
12476             // FIXME: should only count parameters that are lowered to integers.
12477             InRegCount += (TD->getTypeSizeInBits(*I) + 31) / 32;
12478
12479         if (InRegCount > 2) {
12480           report_fatal_error("Nest register in use - reduce number of inreg"
12481                              " parameters!");
12482         }
12483       }
12484       break;
12485     }
12486     case CallingConv::X86_FastCall:
12487     case CallingConv::X86_ThisCall:
12488     case CallingConv::Fast:
12489       // Pass 'nest' parameter in EAX.
12490       // Must be kept in sync with X86CallingConv.td
12491       NestReg = X86::EAX;
12492       break;
12493     }
12494
12495     SDValue OutChains[4];
12496     SDValue Addr, Disp;
12497
12498     Addr = DAG.getNode(ISD::ADD, dl, MVT::i32, Trmp,
12499                        DAG.getConstant(10, MVT::i32));
12500     Disp = DAG.getNode(ISD::SUB, dl, MVT::i32, FPtr, Addr);
12501
12502     // This is storing the opcode for MOV32ri.
12503     const unsigned char MOV32ri = 0xB8; // X86::MOV32ri's opcode byte.
12504     const unsigned char N86Reg = TRI->getEncodingValue(NestReg) & 0x7;
12505     OutChains[0] = DAG.getStore(Root, dl,
12506                                 DAG.getConstant(MOV32ri|N86Reg, MVT::i8),
12507                                 Trmp, MachinePointerInfo(TrmpAddr),
12508                                 false, false, 0);
12509
12510     Addr = DAG.getNode(ISD::ADD, dl, MVT::i32, Trmp,
12511                        DAG.getConstant(1, MVT::i32));
12512     OutChains[1] = DAG.getStore(Root, dl, Nest, Addr,
12513                                 MachinePointerInfo(TrmpAddr, 1),
12514                                 false, false, 1);
12515
12516     const unsigned char JMP = 0xE9; // jmp <32bit dst> opcode.
12517     Addr = DAG.getNode(ISD::ADD, dl, MVT::i32, Trmp,
12518                        DAG.getConstant(5, MVT::i32));
12519     OutChains[2] = DAG.getStore(Root, dl, DAG.getConstant(JMP, MVT::i8), Addr,
12520                                 MachinePointerInfo(TrmpAddr, 5),
12521                                 false, false, 1);
12522
12523     Addr = DAG.getNode(ISD::ADD, dl, MVT::i32, Trmp,
12524                        DAG.getConstant(6, MVT::i32));
12525     OutChains[3] = DAG.getStore(Root, dl, Disp, Addr,
12526                                 MachinePointerInfo(TrmpAddr, 6),
12527                                 false, false, 1);
12528
12529     return DAG.getNode(ISD::TokenFactor, dl, MVT::Other, OutChains, 4);
12530   }
12531 }
12532
12533 SDValue X86TargetLowering::LowerFLT_ROUNDS_(SDValue Op,
12534                                             SelectionDAG &DAG) const {
12535   /*
12536    The rounding mode is in bits 11:10 of FPSR, and has the following
12537    settings:
12538      00 Round to nearest
12539      01 Round to -inf
12540      10 Round to +inf
12541      11 Round to 0
12542
12543   FLT_ROUNDS, on the other hand, expects the following:
12544     -1 Undefined
12545      0 Round to 0
12546      1 Round to nearest
12547      2 Round to +inf
12548      3 Round to -inf
12549
12550   To perform the conversion, we do:
12551     (((((FPSR & 0x800) >> 11) | ((FPSR & 0x400) >> 9)) + 1) & 3)
12552   */
12553
12554   MachineFunction &MF = DAG.getMachineFunction();
12555   const TargetMachine &TM = MF.getTarget();
12556   const TargetFrameLowering &TFI = *TM.getFrameLowering();
12557   unsigned StackAlignment = TFI.getStackAlignment();
12558   MVT VT = Op.getSimpleValueType();
12559   SDLoc DL(Op);
12560
12561   // Save FP Control Word to stack slot
12562   int SSFI = MF.getFrameInfo()->CreateStackObject(2, StackAlignment, false);
12563   SDValue StackSlot = DAG.getFrameIndex(SSFI, getPointerTy());
12564
12565   MachineMemOperand *MMO =
12566    MF.getMachineMemOperand(MachinePointerInfo::getFixedStack(SSFI),
12567                            MachineMemOperand::MOStore, 2, 2);
12568
12569   SDValue Ops[] = { DAG.getEntryNode(), StackSlot };
12570   SDValue Chain = DAG.getMemIntrinsicNode(X86ISD::FNSTCW16m, DL,
12571                                           DAG.getVTList(MVT::Other),
12572                                           Ops, array_lengthof(Ops), MVT::i16,
12573                                           MMO);
12574
12575   // Load FP Control Word from stack slot
12576   SDValue CWD = DAG.getLoad(MVT::i16, DL, Chain, StackSlot,
12577                             MachinePointerInfo(), false, false, false, 0);
12578
12579   // Transform as necessary
12580   SDValue CWD1 =
12581     DAG.getNode(ISD::SRL, DL, MVT::i16,
12582                 DAG.getNode(ISD::AND, DL, MVT::i16,
12583                             CWD, DAG.getConstant(0x800, MVT::i16)),
12584                 DAG.getConstant(11, MVT::i8));
12585   SDValue CWD2 =
12586     DAG.getNode(ISD::SRL, DL, MVT::i16,
12587                 DAG.getNode(ISD::AND, DL, MVT::i16,
12588                             CWD, DAG.getConstant(0x400, MVT::i16)),
12589                 DAG.getConstant(9, MVT::i8));
12590
12591   SDValue RetVal =
12592     DAG.getNode(ISD::AND, DL, MVT::i16,
12593                 DAG.getNode(ISD::ADD, DL, MVT::i16,
12594                             DAG.getNode(ISD::OR, DL, MVT::i16, CWD1, CWD2),
12595                             DAG.getConstant(1, MVT::i16)),
12596                 DAG.getConstant(3, MVT::i16));
12597
12598   return DAG.getNode((VT.getSizeInBits() < 16 ?
12599                       ISD::TRUNCATE : ISD::ZERO_EXTEND), DL, VT, RetVal);
12600 }
12601
12602 static SDValue LowerCTLZ(SDValue Op, SelectionDAG &DAG) {
12603   MVT VT = Op.getSimpleValueType();
12604   EVT OpVT = VT;
12605   unsigned NumBits = VT.getSizeInBits();
12606   SDLoc dl(Op);
12607
12608   Op = Op.getOperand(0);
12609   if (VT == MVT::i8) {
12610     // Zero extend to i32 since there is not an i8 bsr.
12611     OpVT = MVT::i32;
12612     Op = DAG.getNode(ISD::ZERO_EXTEND, dl, OpVT, Op);
12613   }
12614
12615   // Issue a bsr (scan bits in reverse) which also sets EFLAGS.
12616   SDVTList VTs = DAG.getVTList(OpVT, MVT::i32);
12617   Op = DAG.getNode(X86ISD::BSR, dl, VTs, Op);
12618
12619   // If src is zero (i.e. bsr sets ZF), returns NumBits.
12620   SDValue Ops[] = {
12621     Op,
12622     DAG.getConstant(NumBits+NumBits-1, OpVT),
12623     DAG.getConstant(X86::COND_E, MVT::i8),
12624     Op.getValue(1)
12625   };
12626   Op = DAG.getNode(X86ISD::CMOV, dl, OpVT, Ops, array_lengthof(Ops));
12627
12628   // Finally xor with NumBits-1.
12629   Op = DAG.getNode(ISD::XOR, dl, OpVT, Op, DAG.getConstant(NumBits-1, OpVT));
12630
12631   if (VT == MVT::i8)
12632     Op = DAG.getNode(ISD::TRUNCATE, dl, MVT::i8, Op);
12633   return Op;
12634 }
12635
12636 static SDValue LowerCTLZ_ZERO_UNDEF(SDValue Op, SelectionDAG &DAG) {
12637   MVT VT = Op.getSimpleValueType();
12638   EVT OpVT = VT;
12639   unsigned NumBits = VT.getSizeInBits();
12640   SDLoc dl(Op);
12641
12642   Op = Op.getOperand(0);
12643   if (VT == MVT::i8) {
12644     // Zero extend to i32 since there is not an i8 bsr.
12645     OpVT = MVT::i32;
12646     Op = DAG.getNode(ISD::ZERO_EXTEND, dl, OpVT, Op);
12647   }
12648
12649   // Issue a bsr (scan bits in reverse).
12650   SDVTList VTs = DAG.getVTList(OpVT, MVT::i32);
12651   Op = DAG.getNode(X86ISD::BSR, dl, VTs, Op);
12652
12653   // And xor with NumBits-1.
12654   Op = DAG.getNode(ISD::XOR, dl, OpVT, Op, DAG.getConstant(NumBits-1, OpVT));
12655
12656   if (VT == MVT::i8)
12657     Op = DAG.getNode(ISD::TRUNCATE, dl, MVT::i8, Op);
12658   return Op;
12659 }
12660
12661 static SDValue LowerCTTZ(SDValue Op, SelectionDAG &DAG) {
12662   MVT VT = Op.getSimpleValueType();
12663   unsigned NumBits = VT.getSizeInBits();
12664   SDLoc dl(Op);
12665   Op = Op.getOperand(0);
12666
12667   // Issue a bsf (scan bits forward) which also sets EFLAGS.
12668   SDVTList VTs = DAG.getVTList(VT, MVT::i32);
12669   Op = DAG.getNode(X86ISD::BSF, dl, VTs, Op);
12670
12671   // If src is zero (i.e. bsf sets ZF), returns NumBits.
12672   SDValue Ops[] = {
12673     Op,
12674     DAG.getConstant(NumBits, VT),
12675     DAG.getConstant(X86::COND_E, MVT::i8),
12676     Op.getValue(1)
12677   };
12678   return DAG.getNode(X86ISD::CMOV, dl, VT, Ops, array_lengthof(Ops));
12679 }
12680
12681 // Lower256IntArith - Break a 256-bit integer operation into two new 128-bit
12682 // ones, and then concatenate the result back.
12683 static SDValue Lower256IntArith(SDValue Op, SelectionDAG &DAG) {
12684   MVT VT = Op.getSimpleValueType();
12685
12686   assert(VT.is256BitVector() && VT.isInteger() &&
12687          "Unsupported value type for operation");
12688
12689   unsigned NumElems = VT.getVectorNumElements();
12690   SDLoc dl(Op);
12691
12692   // Extract the LHS vectors
12693   SDValue LHS = Op.getOperand(0);
12694   SDValue LHS1 = Extract128BitVector(LHS, 0, DAG, dl);
12695   SDValue LHS2 = Extract128BitVector(LHS, NumElems/2, DAG, dl);
12696
12697   // Extract the RHS vectors
12698   SDValue RHS = Op.getOperand(1);
12699   SDValue RHS1 = Extract128BitVector(RHS, 0, DAG, dl);
12700   SDValue RHS2 = Extract128BitVector(RHS, NumElems/2, DAG, dl);
12701
12702   MVT EltVT = VT.getVectorElementType();
12703   MVT NewVT = MVT::getVectorVT(EltVT, NumElems/2);
12704
12705   return DAG.getNode(ISD::CONCAT_VECTORS, dl, VT,
12706                      DAG.getNode(Op.getOpcode(), dl, NewVT, LHS1, RHS1),
12707                      DAG.getNode(Op.getOpcode(), dl, NewVT, LHS2, RHS2));
12708 }
12709
12710 static SDValue LowerADD(SDValue Op, SelectionDAG &DAG) {
12711   assert(Op.getSimpleValueType().is256BitVector() &&
12712          Op.getSimpleValueType().isInteger() &&
12713          "Only handle AVX 256-bit vector integer operation");
12714   return Lower256IntArith(Op, DAG);
12715 }
12716
12717 static SDValue LowerSUB(SDValue Op, SelectionDAG &DAG) {
12718   assert(Op.getSimpleValueType().is256BitVector() &&
12719          Op.getSimpleValueType().isInteger() &&
12720          "Only handle AVX 256-bit vector integer operation");
12721   return Lower256IntArith(Op, DAG);
12722 }
12723
12724 static SDValue LowerMUL(SDValue Op, const X86Subtarget *Subtarget,
12725                         SelectionDAG &DAG) {
12726   SDLoc dl(Op);
12727   MVT VT = Op.getSimpleValueType();
12728
12729   // Decompose 256-bit ops into smaller 128-bit ops.
12730   if (VT.is256BitVector() && !Subtarget->hasInt256())
12731     return Lower256IntArith(Op, DAG);
12732
12733   SDValue A = Op.getOperand(0);
12734   SDValue B = Op.getOperand(1);
12735
12736   // Lower v4i32 mul as 2x shuffle, 2x pmuludq, 2x shuffle.
12737   if (VT == MVT::v4i32) {
12738     assert(Subtarget->hasSSE2() && !Subtarget->hasSSE41() &&
12739            "Should not custom lower when pmuldq is available!");
12740
12741     // Extract the odd parts.
12742     static const int UnpackMask[] = { 1, -1, 3, -1 };
12743     SDValue Aodds = DAG.getVectorShuffle(VT, dl, A, A, UnpackMask);
12744     SDValue Bodds = DAG.getVectorShuffle(VT, dl, B, B, UnpackMask);
12745
12746     // Multiply the even parts.
12747     SDValue Evens = DAG.getNode(X86ISD::PMULUDQ, dl, MVT::v2i64, A, B);
12748     // Now multiply odd parts.
12749     SDValue Odds = DAG.getNode(X86ISD::PMULUDQ, dl, MVT::v2i64, Aodds, Bodds);
12750
12751     Evens = DAG.getNode(ISD::BITCAST, dl, VT, Evens);
12752     Odds = DAG.getNode(ISD::BITCAST, dl, VT, Odds);
12753
12754     // Merge the two vectors back together with a shuffle. This expands into 2
12755     // shuffles.
12756     static const int ShufMask[] = { 0, 4, 2, 6 };
12757     return DAG.getVectorShuffle(VT, dl, Evens, Odds, ShufMask);
12758   }
12759
12760   assert((VT == MVT::v2i64 || VT == MVT::v4i64 || VT == MVT::v8i64) &&
12761          "Only know how to lower V2I64/V4I64/V8I64 multiply");
12762
12763   //  Ahi = psrlqi(a, 32);
12764   //  Bhi = psrlqi(b, 32);
12765   //
12766   //  AloBlo = pmuludq(a, b);
12767   //  AloBhi = pmuludq(a, Bhi);
12768   //  AhiBlo = pmuludq(Ahi, b);
12769
12770   //  AloBhi = psllqi(AloBhi, 32);
12771   //  AhiBlo = psllqi(AhiBlo, 32);
12772   //  return AloBlo + AloBhi + AhiBlo;
12773
12774   SDValue Ahi = getTargetVShiftByConstNode(X86ISD::VSRLI, dl, VT, A, 32, DAG);
12775   SDValue Bhi = getTargetVShiftByConstNode(X86ISD::VSRLI, dl, VT, B, 32, DAG);
12776
12777   // Bit cast to 32-bit vectors for MULUDQ
12778   EVT MulVT = (VT == MVT::v2i64) ? MVT::v4i32 :
12779                                   (VT == MVT::v4i64) ? MVT::v8i32 : MVT::v16i32;
12780   A = DAG.getNode(ISD::BITCAST, dl, MulVT, A);
12781   B = DAG.getNode(ISD::BITCAST, dl, MulVT, B);
12782   Ahi = DAG.getNode(ISD::BITCAST, dl, MulVT, Ahi);
12783   Bhi = DAG.getNode(ISD::BITCAST, dl, MulVT, Bhi);
12784
12785   SDValue AloBlo = DAG.getNode(X86ISD::PMULUDQ, dl, VT, A, B);
12786   SDValue AloBhi = DAG.getNode(X86ISD::PMULUDQ, dl, VT, A, Bhi);
12787   SDValue AhiBlo = DAG.getNode(X86ISD::PMULUDQ, dl, VT, Ahi, B);
12788
12789   AloBhi = getTargetVShiftByConstNode(X86ISD::VSHLI, dl, VT, AloBhi, 32, DAG);
12790   AhiBlo = getTargetVShiftByConstNode(X86ISD::VSHLI, dl, VT, AhiBlo, 32, DAG);
12791
12792   SDValue Res = DAG.getNode(ISD::ADD, dl, VT, AloBlo, AloBhi);
12793   return DAG.getNode(ISD::ADD, dl, VT, Res, AhiBlo);
12794 }
12795
12796 static SDValue LowerSDIV(SDValue Op, SelectionDAG &DAG) {
12797   MVT VT = Op.getSimpleValueType();
12798   MVT EltTy = VT.getVectorElementType();
12799   unsigned NumElts = VT.getVectorNumElements();
12800   SDValue N0 = Op.getOperand(0);
12801   SDLoc dl(Op);
12802
12803   // Lower sdiv X, pow2-const.
12804   BuildVectorSDNode *C = dyn_cast<BuildVectorSDNode>(Op.getOperand(1));
12805   if (!C)
12806     return SDValue();
12807
12808   APInt SplatValue, SplatUndef;
12809   unsigned SplatBitSize;
12810   bool HasAnyUndefs;
12811   if (!C->isConstantSplat(SplatValue, SplatUndef, SplatBitSize,
12812                           HasAnyUndefs) ||
12813       EltTy.getSizeInBits() < SplatBitSize)
12814     return SDValue();
12815
12816   if ((SplatValue != 0) &&
12817       (SplatValue.isPowerOf2() || (-SplatValue).isPowerOf2())) {
12818     unsigned Lg2 = SplatValue.countTrailingZeros();
12819     // Splat the sign bit.
12820     SmallVector<SDValue, 16> Sz(NumElts,
12821                                 DAG.getConstant(EltTy.getSizeInBits() - 1,
12822                                                 EltTy));
12823     SDValue SGN = DAG.getNode(ISD::SRA, dl, VT, N0,
12824                               DAG.getNode(ISD::BUILD_VECTOR, dl, VT, &Sz[0],
12825                                           NumElts));
12826     // Add (N0 < 0) ? abs2 - 1 : 0;
12827     SmallVector<SDValue, 16> Amt(NumElts,
12828                                  DAG.getConstant(EltTy.getSizeInBits() - Lg2,
12829                                                  EltTy));
12830     SDValue SRL = DAG.getNode(ISD::SRL, dl, VT, SGN,
12831                               DAG.getNode(ISD::BUILD_VECTOR, dl, VT, &Amt[0],
12832                                           NumElts));
12833     SDValue ADD = DAG.getNode(ISD::ADD, dl, VT, N0, SRL);
12834     SmallVector<SDValue, 16> Lg2Amt(NumElts, DAG.getConstant(Lg2, EltTy));
12835     SDValue SRA = DAG.getNode(ISD::SRA, dl, VT, ADD,
12836                               DAG.getNode(ISD::BUILD_VECTOR, dl, VT, &Lg2Amt[0],
12837                                           NumElts));
12838
12839     // If we're dividing by a positive value, we're done.  Otherwise, we must
12840     // negate the result.
12841     if (SplatValue.isNonNegative())
12842       return SRA;
12843
12844     SmallVector<SDValue, 16> V(NumElts, DAG.getConstant(0, EltTy));
12845     SDValue Zero = DAG.getNode(ISD::BUILD_VECTOR, dl, VT, &V[0], NumElts);
12846     return DAG.getNode(ISD::SUB, dl, VT, Zero, SRA);
12847   }
12848   return SDValue();
12849 }
12850
12851 static SDValue LowerScalarImmediateShift(SDValue Op, SelectionDAG &DAG,
12852                                          const X86Subtarget *Subtarget) {
12853   MVT VT = Op.getSimpleValueType();
12854   SDLoc dl(Op);
12855   SDValue R = Op.getOperand(0);
12856   SDValue Amt = Op.getOperand(1);
12857
12858   // Optimize shl/srl/sra with constant shift amount.
12859   if (isSplatVector(Amt.getNode())) {
12860     SDValue SclrAmt = Amt->getOperand(0);
12861     if (ConstantSDNode *C = dyn_cast<ConstantSDNode>(SclrAmt)) {
12862       uint64_t ShiftAmt = C->getZExtValue();
12863
12864       if (VT == MVT::v2i64 || VT == MVT::v4i32 || VT == MVT::v8i16 ||
12865           (Subtarget->hasInt256() &&
12866            (VT == MVT::v4i64 || VT == MVT::v8i32 || VT == MVT::v16i16)) ||
12867           (Subtarget->hasAVX512() &&
12868            (VT == MVT::v8i64 || VT == MVT::v16i32))) {
12869         if (Op.getOpcode() == ISD::SHL)
12870           return getTargetVShiftByConstNode(X86ISD::VSHLI, dl, VT, R, ShiftAmt,
12871                                             DAG);
12872         if (Op.getOpcode() == ISD::SRL)
12873           return getTargetVShiftByConstNode(X86ISD::VSRLI, dl, VT, R, ShiftAmt,
12874                                             DAG);
12875         if (Op.getOpcode() == ISD::SRA && VT != MVT::v2i64 && VT != MVT::v4i64)
12876           return getTargetVShiftByConstNode(X86ISD::VSRAI, dl, VT, R, ShiftAmt,
12877                                             DAG);
12878       }
12879
12880       if (VT == MVT::v16i8) {
12881         if (Op.getOpcode() == ISD::SHL) {
12882           // Make a large shift.
12883           SDValue SHL = getTargetVShiftByConstNode(X86ISD::VSHLI, dl,
12884                                                    MVT::v8i16, R, ShiftAmt,
12885                                                    DAG);
12886           SHL = DAG.getNode(ISD::BITCAST, dl, VT, SHL);
12887           // Zero out the rightmost bits.
12888           SmallVector<SDValue, 16> V(16,
12889                                      DAG.getConstant(uint8_t(-1U << ShiftAmt),
12890                                                      MVT::i8));
12891           return DAG.getNode(ISD::AND, dl, VT, SHL,
12892                              DAG.getNode(ISD::BUILD_VECTOR, dl, VT, &V[0], 16));
12893         }
12894         if (Op.getOpcode() == ISD::SRL) {
12895           // Make a large shift.
12896           SDValue SRL = getTargetVShiftByConstNode(X86ISD::VSRLI, dl,
12897                                                    MVT::v8i16, R, ShiftAmt,
12898                                                    DAG);
12899           SRL = DAG.getNode(ISD::BITCAST, dl, VT, SRL);
12900           // Zero out the leftmost bits.
12901           SmallVector<SDValue, 16> V(16,
12902                                      DAG.getConstant(uint8_t(-1U) >> ShiftAmt,
12903                                                      MVT::i8));
12904           return DAG.getNode(ISD::AND, dl, VT, SRL,
12905                              DAG.getNode(ISD::BUILD_VECTOR, dl, VT, &V[0], 16));
12906         }
12907         if (Op.getOpcode() == ISD::SRA) {
12908           if (ShiftAmt == 7) {
12909             // R s>> 7  ===  R s< 0
12910             SDValue Zeros = getZeroVector(VT, Subtarget, DAG, dl);
12911             return DAG.getNode(X86ISD::PCMPGT, dl, VT, Zeros, R);
12912           }
12913
12914           // R s>> a === ((R u>> a) ^ m) - m
12915           SDValue Res = DAG.getNode(ISD::SRL, dl, VT, R, Amt);
12916           SmallVector<SDValue, 16> V(16, DAG.getConstant(128 >> ShiftAmt,
12917                                                          MVT::i8));
12918           SDValue Mask = DAG.getNode(ISD::BUILD_VECTOR, dl, VT, &V[0], 16);
12919           Res = DAG.getNode(ISD::XOR, dl, VT, Res, Mask);
12920           Res = DAG.getNode(ISD::SUB, dl, VT, Res, Mask);
12921           return Res;
12922         }
12923         llvm_unreachable("Unknown shift opcode.");
12924       }
12925
12926       if (Subtarget->hasInt256() && VT == MVT::v32i8) {
12927         if (Op.getOpcode() == ISD::SHL) {
12928           // Make a large shift.
12929           SDValue SHL = getTargetVShiftByConstNode(X86ISD::VSHLI, dl,
12930                                                    MVT::v16i16, R, ShiftAmt,
12931                                                    DAG);
12932           SHL = DAG.getNode(ISD::BITCAST, dl, VT, SHL);
12933           // Zero out the rightmost bits.
12934           SmallVector<SDValue, 32> V(32,
12935                                      DAG.getConstant(uint8_t(-1U << ShiftAmt),
12936                                                      MVT::i8));
12937           return DAG.getNode(ISD::AND, dl, VT, SHL,
12938                              DAG.getNode(ISD::BUILD_VECTOR, dl, VT, &V[0], 32));
12939         }
12940         if (Op.getOpcode() == ISD::SRL) {
12941           // Make a large shift.
12942           SDValue SRL = getTargetVShiftByConstNode(X86ISD::VSRLI, dl,
12943                                                    MVT::v16i16, R, ShiftAmt,
12944                                                    DAG);
12945           SRL = DAG.getNode(ISD::BITCAST, dl, VT, SRL);
12946           // Zero out the leftmost bits.
12947           SmallVector<SDValue, 32> V(32,
12948                                      DAG.getConstant(uint8_t(-1U) >> ShiftAmt,
12949                                                      MVT::i8));
12950           return DAG.getNode(ISD::AND, dl, VT, SRL,
12951                              DAG.getNode(ISD::BUILD_VECTOR, dl, VT, &V[0], 32));
12952         }
12953         if (Op.getOpcode() == ISD::SRA) {
12954           if (ShiftAmt == 7) {
12955             // R s>> 7  ===  R s< 0
12956             SDValue Zeros = getZeroVector(VT, Subtarget, DAG, dl);
12957             return DAG.getNode(X86ISD::PCMPGT, dl, VT, Zeros, R);
12958           }
12959
12960           // R s>> a === ((R u>> a) ^ m) - m
12961           SDValue Res = DAG.getNode(ISD::SRL, dl, VT, R, Amt);
12962           SmallVector<SDValue, 32> V(32, DAG.getConstant(128 >> ShiftAmt,
12963                                                          MVT::i8));
12964           SDValue Mask = DAG.getNode(ISD::BUILD_VECTOR, dl, VT, &V[0], 32);
12965           Res = DAG.getNode(ISD::XOR, dl, VT, Res, Mask);
12966           Res = DAG.getNode(ISD::SUB, dl, VT, Res, Mask);
12967           return Res;
12968         }
12969         llvm_unreachable("Unknown shift opcode.");
12970       }
12971     }
12972   }
12973
12974   // Special case in 32-bit mode, where i64 is expanded into high and low parts.
12975   if (!Subtarget->is64Bit() &&
12976       (VT == MVT::v2i64 || (Subtarget->hasInt256() && VT == MVT::v4i64)) &&
12977       Amt.getOpcode() == ISD::BITCAST &&
12978       Amt.getOperand(0).getOpcode() == ISD::BUILD_VECTOR) {
12979     Amt = Amt.getOperand(0);
12980     unsigned Ratio = Amt.getSimpleValueType().getVectorNumElements() /
12981                      VT.getVectorNumElements();
12982     unsigned RatioInLog2 = Log2_32_Ceil(Ratio);
12983     uint64_t ShiftAmt = 0;
12984     for (unsigned i = 0; i != Ratio; ++i) {
12985       ConstantSDNode *C = dyn_cast<ConstantSDNode>(Amt.getOperand(i));
12986       if (C == 0)
12987         return SDValue();
12988       // 6 == Log2(64)
12989       ShiftAmt |= C->getZExtValue() << (i * (1 << (6 - RatioInLog2)));
12990     }
12991     // Check remaining shift amounts.
12992     for (unsigned i = Ratio; i != Amt.getNumOperands(); i += Ratio) {
12993       uint64_t ShAmt = 0;
12994       for (unsigned j = 0; j != Ratio; ++j) {
12995         ConstantSDNode *C =
12996           dyn_cast<ConstantSDNode>(Amt.getOperand(i + j));
12997         if (C == 0)
12998           return SDValue();
12999         // 6 == Log2(64)
13000         ShAmt |= C->getZExtValue() << (j * (1 << (6 - RatioInLog2)));
13001       }
13002       if (ShAmt != ShiftAmt)
13003         return SDValue();
13004     }
13005     switch (Op.getOpcode()) {
13006     default:
13007       llvm_unreachable("Unknown shift opcode!");
13008     case ISD::SHL:
13009       return getTargetVShiftByConstNode(X86ISD::VSHLI, dl, VT, R, ShiftAmt,
13010                                         DAG);
13011     case ISD::SRL:
13012       return getTargetVShiftByConstNode(X86ISD::VSRLI, dl, VT, R, ShiftAmt,
13013                                         DAG);
13014     case ISD::SRA:
13015       return getTargetVShiftByConstNode(X86ISD::VSRAI, dl, VT, R, ShiftAmt,
13016                                         DAG);
13017     }
13018   }
13019
13020   return SDValue();
13021 }
13022
13023 static SDValue LowerScalarVariableShift(SDValue Op, SelectionDAG &DAG,
13024                                         const X86Subtarget* Subtarget) {
13025   MVT VT = Op.getSimpleValueType();
13026   SDLoc dl(Op);
13027   SDValue R = Op.getOperand(0);
13028   SDValue Amt = Op.getOperand(1);
13029
13030   if ((VT == MVT::v2i64 && Op.getOpcode() != ISD::SRA) ||
13031       VT == MVT::v4i32 || VT == MVT::v8i16 ||
13032       (Subtarget->hasInt256() &&
13033        ((VT == MVT::v4i64 && Op.getOpcode() != ISD::SRA) ||
13034         VT == MVT::v8i32 || VT == MVT::v16i16)) ||
13035        (Subtarget->hasAVX512() && (VT == MVT::v8i64 || VT == MVT::v16i32))) {
13036     SDValue BaseShAmt;
13037     EVT EltVT = VT.getVectorElementType();
13038
13039     if (Amt.getOpcode() == ISD::BUILD_VECTOR) {
13040       unsigned NumElts = VT.getVectorNumElements();
13041       unsigned i, j;
13042       for (i = 0; i != NumElts; ++i) {
13043         if (Amt.getOperand(i).getOpcode() == ISD::UNDEF)
13044           continue;
13045         break;
13046       }
13047       for (j = i; j != NumElts; ++j) {
13048         SDValue Arg = Amt.getOperand(j);
13049         if (Arg.getOpcode() == ISD::UNDEF) continue;
13050         if (Arg != Amt.getOperand(i))
13051           break;
13052       }
13053       if (i != NumElts && j == NumElts)
13054         BaseShAmt = Amt.getOperand(i);
13055     } else {
13056       if (Amt.getOpcode() == ISD::EXTRACT_SUBVECTOR)
13057         Amt = Amt.getOperand(0);
13058       if (Amt.getOpcode() == ISD::VECTOR_SHUFFLE &&
13059                cast<ShuffleVectorSDNode>(Amt)->isSplat()) {
13060         SDValue InVec = Amt.getOperand(0);
13061         if (InVec.getOpcode() == ISD::BUILD_VECTOR) {
13062           unsigned NumElts = InVec.getValueType().getVectorNumElements();
13063           unsigned i = 0;
13064           for (; i != NumElts; ++i) {
13065             SDValue Arg = InVec.getOperand(i);
13066             if (Arg.getOpcode() == ISD::UNDEF) continue;
13067             BaseShAmt = Arg;
13068             break;
13069           }
13070         } else if (InVec.getOpcode() == ISD::INSERT_VECTOR_ELT) {
13071            if (ConstantSDNode *C =
13072                dyn_cast<ConstantSDNode>(InVec.getOperand(2))) {
13073              unsigned SplatIdx =
13074                cast<ShuffleVectorSDNode>(Amt)->getSplatIndex();
13075              if (C->getZExtValue() == SplatIdx)
13076                BaseShAmt = InVec.getOperand(1);
13077            }
13078         }
13079         if (BaseShAmt.getNode() == 0)
13080           BaseShAmt = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, EltVT, Amt,
13081                                   DAG.getIntPtrConstant(0));
13082       }
13083     }
13084
13085     if (BaseShAmt.getNode()) {
13086       if (EltVT.bitsGT(MVT::i32))
13087         BaseShAmt = DAG.getNode(ISD::TRUNCATE, dl, MVT::i32, BaseShAmt);
13088       else if (EltVT.bitsLT(MVT::i32))
13089         BaseShAmt = DAG.getNode(ISD::ZERO_EXTEND, dl, MVT::i32, BaseShAmt);
13090
13091       switch (Op.getOpcode()) {
13092       default:
13093         llvm_unreachable("Unknown shift opcode!");
13094       case ISD::SHL:
13095         switch (VT.SimpleTy) {
13096         default: return SDValue();
13097         case MVT::v2i64:
13098         case MVT::v4i32:
13099         case MVT::v8i16:
13100         case MVT::v4i64:
13101         case MVT::v8i32:
13102         case MVT::v16i16:
13103         case MVT::v16i32:
13104         case MVT::v8i64:
13105           return getTargetVShiftNode(X86ISD::VSHLI, dl, VT, R, BaseShAmt, DAG);
13106         }
13107       case ISD::SRA:
13108         switch (VT.SimpleTy) {
13109         default: return SDValue();
13110         case MVT::v4i32:
13111         case MVT::v8i16:
13112         case MVT::v8i32:
13113         case MVT::v16i16:
13114         case MVT::v16i32:
13115         case MVT::v8i64:
13116           return getTargetVShiftNode(X86ISD::VSRAI, dl, VT, R, BaseShAmt, DAG);
13117         }
13118       case ISD::SRL:
13119         switch (VT.SimpleTy) {
13120         default: return SDValue();
13121         case MVT::v2i64:
13122         case MVT::v4i32:
13123         case MVT::v8i16:
13124         case MVT::v4i64:
13125         case MVT::v8i32:
13126         case MVT::v16i16:
13127         case MVT::v16i32:
13128         case MVT::v8i64:
13129           return getTargetVShiftNode(X86ISD::VSRLI, dl, VT, R, BaseShAmt, DAG);
13130         }
13131       }
13132     }
13133   }
13134
13135   // Special case in 32-bit mode, where i64 is expanded into high and low parts.
13136   if (!Subtarget->is64Bit() &&
13137       (VT == MVT::v2i64 || (Subtarget->hasInt256() && VT == MVT::v4i64) ||
13138       (Subtarget->hasAVX512() && VT == MVT::v8i64)) &&
13139       Amt.getOpcode() == ISD::BITCAST &&
13140       Amt.getOperand(0).getOpcode() == ISD::BUILD_VECTOR) {
13141     Amt = Amt.getOperand(0);
13142     unsigned Ratio = Amt.getSimpleValueType().getVectorNumElements() /
13143                      VT.getVectorNumElements();
13144     std::vector<SDValue> Vals(Ratio);
13145     for (unsigned i = 0; i != Ratio; ++i)
13146       Vals[i] = Amt.getOperand(i);
13147     for (unsigned i = Ratio; i != Amt.getNumOperands(); i += Ratio) {
13148       for (unsigned j = 0; j != Ratio; ++j)
13149         if (Vals[j] != Amt.getOperand(i + j))
13150           return SDValue();
13151     }
13152     switch (Op.getOpcode()) {
13153     default:
13154       llvm_unreachable("Unknown shift opcode!");
13155     case ISD::SHL:
13156       return DAG.getNode(X86ISD::VSHL, dl, VT, R, Op.getOperand(1));
13157     case ISD::SRL:
13158       return DAG.getNode(X86ISD::VSRL, dl, VT, R, Op.getOperand(1));
13159     case ISD::SRA:
13160       return DAG.getNode(X86ISD::VSRA, dl, VT, R, Op.getOperand(1));
13161     }
13162   }
13163
13164   return SDValue();
13165 }
13166
13167 static SDValue LowerShift(SDValue Op, const X86Subtarget* Subtarget,
13168                           SelectionDAG &DAG) {
13169
13170   MVT VT = Op.getSimpleValueType();
13171   SDLoc dl(Op);
13172   SDValue R = Op.getOperand(0);
13173   SDValue Amt = Op.getOperand(1);
13174   SDValue V;
13175
13176   if (!Subtarget->hasSSE2())
13177     return SDValue();
13178
13179   V = LowerScalarImmediateShift(Op, DAG, Subtarget);
13180   if (V.getNode())
13181     return V;
13182
13183   V = LowerScalarVariableShift(Op, DAG, Subtarget);
13184   if (V.getNode())
13185       return V;
13186
13187   if (Subtarget->hasAVX512() && (VT == MVT::v16i32 || VT == MVT::v8i64))
13188     return Op;
13189   // AVX2 has VPSLLV/VPSRAV/VPSRLV.
13190   if (Subtarget->hasInt256()) {
13191     if (Op.getOpcode() == ISD::SRL &&
13192         (VT == MVT::v2i64 || VT == MVT::v4i32 ||
13193          VT == MVT::v4i64 || VT == MVT::v8i32))
13194       return Op;
13195     if (Op.getOpcode() == ISD::SHL &&
13196         (VT == MVT::v2i64 || VT == MVT::v4i32 ||
13197          VT == MVT::v4i64 || VT == MVT::v8i32))
13198       return Op;
13199     if (Op.getOpcode() == ISD::SRA && (VT == MVT::v4i32 || VT == MVT::v8i32))
13200       return Op;
13201   }
13202
13203   // If possible, lower this packed shift into a vector multiply instead of
13204   // expanding it into a sequence of scalar shifts.
13205   // Do this only if the vector shift count is a constant build_vector.
13206   if (Op.getOpcode() == ISD::SHL && 
13207       (VT == MVT::v8i16 || VT == MVT::v4i32 ||
13208        (Subtarget->hasInt256() && VT == MVT::v16i16)) &&
13209       ISD::isBuildVectorOfConstantSDNodes(Amt.getNode())) {
13210     SmallVector<SDValue, 8> Elts;
13211     EVT SVT = VT.getScalarType();
13212     unsigned SVTBits = SVT.getSizeInBits();
13213     const APInt &One = APInt(SVTBits, 1);
13214     unsigned NumElems = VT.getVectorNumElements();
13215
13216     for (unsigned i=0; i !=NumElems; ++i) {
13217       SDValue Op = Amt->getOperand(i);
13218       if (Op->getOpcode() == ISD::UNDEF) {
13219         Elts.push_back(Op);
13220         continue;
13221       }
13222
13223       ConstantSDNode *ND = cast<ConstantSDNode>(Op);
13224       const APInt &C = APInt(SVTBits, ND->getAPIntValue().getZExtValue());
13225       uint64_t ShAmt = C.getZExtValue();
13226       if (ShAmt >= SVTBits) {
13227         Elts.push_back(DAG.getUNDEF(SVT));
13228         continue;
13229       }
13230       Elts.push_back(DAG.getConstant(One.shl(ShAmt), SVT));
13231     }
13232     SDValue BV = DAG.getNode(ISD::BUILD_VECTOR, dl, VT, &Elts[0], NumElems);
13233     return DAG.getNode(ISD::MUL, dl, VT, R, BV);
13234   }
13235
13236   // Lower SHL with variable shift amount.
13237   if (VT == MVT::v4i32 && Op->getOpcode() == ISD::SHL) {
13238     Op = DAG.getNode(ISD::SHL, dl, VT, Amt, DAG.getConstant(23, VT));
13239
13240     Op = DAG.getNode(ISD::ADD, dl, VT, Op, DAG.getConstant(0x3f800000U, VT));
13241     Op = DAG.getNode(ISD::BITCAST, dl, MVT::v4f32, Op);
13242     Op = DAG.getNode(ISD::FP_TO_SINT, dl, VT, Op);
13243     return DAG.getNode(ISD::MUL, dl, VT, Op, R);
13244   }
13245
13246   if (VT == MVT::v16i8 && Op->getOpcode() == ISD::SHL) {
13247     assert(Subtarget->hasSSE2() && "Need SSE2 for pslli/pcmpeq.");
13248
13249     // a = a << 5;
13250     Op = DAG.getNode(ISD::SHL, dl, VT, Amt, DAG.getConstant(5, VT));
13251     Op = DAG.getNode(ISD::BITCAST, dl, VT, Op);
13252
13253     // Turn 'a' into a mask suitable for VSELECT
13254     SDValue VSelM = DAG.getConstant(0x80, VT);
13255     SDValue OpVSel = DAG.getNode(ISD::AND, dl, VT, VSelM, Op);
13256     OpVSel = DAG.getNode(X86ISD::PCMPEQ, dl, VT, OpVSel, VSelM);
13257
13258     SDValue CM1 = DAG.getConstant(0x0f, VT);
13259     SDValue CM2 = DAG.getConstant(0x3f, VT);
13260
13261     // r = VSELECT(r, psllw(r & (char16)15, 4), a);
13262     SDValue M = DAG.getNode(ISD::AND, dl, VT, R, CM1);
13263     M = getTargetVShiftByConstNode(X86ISD::VSHLI, dl, MVT::v8i16, M, 4, DAG);
13264     M = DAG.getNode(ISD::BITCAST, dl, VT, M);
13265     R = DAG.getNode(ISD::VSELECT, dl, VT, OpVSel, M, R);
13266
13267     // a += a
13268     Op = DAG.getNode(ISD::ADD, dl, VT, Op, Op);
13269     OpVSel = DAG.getNode(ISD::AND, dl, VT, VSelM, Op);
13270     OpVSel = DAG.getNode(X86ISD::PCMPEQ, dl, VT, OpVSel, VSelM);
13271
13272     // r = VSELECT(r, psllw(r & (char16)63, 2), a);
13273     M = DAG.getNode(ISD::AND, dl, VT, R, CM2);
13274     M = getTargetVShiftByConstNode(X86ISD::VSHLI, dl, MVT::v8i16, M, 2, DAG);
13275     M = DAG.getNode(ISD::BITCAST, dl, VT, M);
13276     R = DAG.getNode(ISD::VSELECT, dl, VT, OpVSel, M, R);
13277
13278     // a += a
13279     Op = DAG.getNode(ISD::ADD, dl, VT, Op, Op);
13280     OpVSel = DAG.getNode(ISD::AND, dl, VT, VSelM, Op);
13281     OpVSel = DAG.getNode(X86ISD::PCMPEQ, dl, VT, OpVSel, VSelM);
13282
13283     // return VSELECT(r, r+r, a);
13284     R = DAG.getNode(ISD::VSELECT, dl, VT, OpVSel,
13285                     DAG.getNode(ISD::ADD, dl, VT, R, R), R);
13286     return R;
13287   }
13288
13289   // It's worth extending once and using the v8i32 shifts for 16-bit types, but
13290   // the extra overheads to get from v16i8 to v8i32 make the existing SSE
13291   // solution better.
13292   if (Subtarget->hasInt256() && VT == MVT::v8i16) {
13293     MVT NewVT = VT == MVT::v8i16 ? MVT::v8i32 : MVT::v16i16;
13294     unsigned ExtOpc =
13295         Op.getOpcode() == ISD::SRA ? ISD::SIGN_EXTEND : ISD::ZERO_EXTEND;
13296     R = DAG.getNode(ExtOpc, dl, NewVT, R);
13297     Amt = DAG.getNode(ISD::ANY_EXTEND, dl, NewVT, Amt);
13298     return DAG.getNode(ISD::TRUNCATE, dl, VT,
13299                        DAG.getNode(Op.getOpcode(), dl, NewVT, R, Amt));
13300     }
13301
13302   // Decompose 256-bit shifts into smaller 128-bit shifts.
13303   if (VT.is256BitVector()) {
13304     unsigned NumElems = VT.getVectorNumElements();
13305     MVT EltVT = VT.getVectorElementType();
13306     EVT NewVT = MVT::getVectorVT(EltVT, NumElems/2);
13307
13308     // Extract the two vectors
13309     SDValue V1 = Extract128BitVector(R, 0, DAG, dl);
13310     SDValue V2 = Extract128BitVector(R, NumElems/2, DAG, dl);
13311
13312     // Recreate the shift amount vectors
13313     SDValue Amt1, Amt2;
13314     if (Amt.getOpcode() == ISD::BUILD_VECTOR) {
13315       // Constant shift amount
13316       SmallVector<SDValue, 4> Amt1Csts;
13317       SmallVector<SDValue, 4> Amt2Csts;
13318       for (unsigned i = 0; i != NumElems/2; ++i)
13319         Amt1Csts.push_back(Amt->getOperand(i));
13320       for (unsigned i = NumElems/2; i != NumElems; ++i)
13321         Amt2Csts.push_back(Amt->getOperand(i));
13322
13323       Amt1 = DAG.getNode(ISD::BUILD_VECTOR, dl, NewVT,
13324                                  &Amt1Csts[0], NumElems/2);
13325       Amt2 = DAG.getNode(ISD::BUILD_VECTOR, dl, NewVT,
13326                                  &Amt2Csts[0], NumElems/2);
13327     } else {
13328       // Variable shift amount
13329       Amt1 = Extract128BitVector(Amt, 0, DAG, dl);
13330       Amt2 = Extract128BitVector(Amt, NumElems/2, DAG, dl);
13331     }
13332
13333     // Issue new vector shifts for the smaller types
13334     V1 = DAG.getNode(Op.getOpcode(), dl, NewVT, V1, Amt1);
13335     V2 = DAG.getNode(Op.getOpcode(), dl, NewVT, V2, Amt2);
13336
13337     // Concatenate the result back
13338     return DAG.getNode(ISD::CONCAT_VECTORS, dl, VT, V1, V2);
13339   }
13340
13341   return SDValue();
13342 }
13343
13344 static SDValue LowerXALUO(SDValue Op, SelectionDAG &DAG) {
13345   // Lower the "add/sub/mul with overflow" instruction into a regular ins plus
13346   // a "setcc" instruction that checks the overflow flag. The "brcond" lowering
13347   // looks for this combo and may remove the "setcc" instruction if the "setcc"
13348   // has only one use.
13349   SDNode *N = Op.getNode();
13350   SDValue LHS = N->getOperand(0);
13351   SDValue RHS = N->getOperand(1);
13352   unsigned BaseOp = 0;
13353   unsigned Cond = 0;
13354   SDLoc DL(Op);
13355   switch (Op.getOpcode()) {
13356   default: llvm_unreachable("Unknown ovf instruction!");
13357   case ISD::SADDO:
13358     // A subtract of one will be selected as a INC. Note that INC doesn't
13359     // set CF, so we can't do this for UADDO.
13360     if (ConstantSDNode *C = dyn_cast<ConstantSDNode>(RHS))
13361       if (C->isOne()) {
13362         BaseOp = X86ISD::INC;
13363         Cond = X86::COND_O;
13364         break;
13365       }
13366     BaseOp = X86ISD::ADD;
13367     Cond = X86::COND_O;
13368     break;
13369   case ISD::UADDO:
13370     BaseOp = X86ISD::ADD;
13371     Cond = X86::COND_B;
13372     break;
13373   case ISD::SSUBO:
13374     // A subtract of one will be selected as a DEC. Note that DEC doesn't
13375     // set CF, so we can't do this for USUBO.
13376     if (ConstantSDNode *C = dyn_cast<ConstantSDNode>(RHS))
13377       if (C->isOne()) {
13378         BaseOp = X86ISD::DEC;
13379         Cond = X86::COND_O;
13380         break;
13381       }
13382     BaseOp = X86ISD::SUB;
13383     Cond = X86::COND_O;
13384     break;
13385   case ISD::USUBO:
13386     BaseOp = X86ISD::SUB;
13387     Cond = X86::COND_B;
13388     break;
13389   case ISD::SMULO:
13390     BaseOp = X86ISD::SMUL;
13391     Cond = X86::COND_O;
13392     break;
13393   case ISD::UMULO: { // i64, i8 = umulo lhs, rhs --> i64, i64, i32 umul lhs,rhs
13394     SDVTList VTs = DAG.getVTList(N->getValueType(0), N->getValueType(0),
13395                                  MVT::i32);
13396     SDValue Sum = DAG.getNode(X86ISD::UMUL, DL, VTs, LHS, RHS);
13397
13398     SDValue SetCC =
13399       DAG.getNode(X86ISD::SETCC, DL, MVT::i8,
13400                   DAG.getConstant(X86::COND_O, MVT::i32),
13401                   SDValue(Sum.getNode(), 2));
13402
13403     return DAG.getNode(ISD::MERGE_VALUES, DL, N->getVTList(), Sum, SetCC);
13404   }
13405   }
13406
13407   // Also sets EFLAGS.
13408   SDVTList VTs = DAG.getVTList(N->getValueType(0), MVT::i32);
13409   SDValue Sum = DAG.getNode(BaseOp, DL, VTs, LHS, RHS);
13410
13411   SDValue SetCC =
13412     DAG.getNode(X86ISD::SETCC, DL, N->getValueType(1),
13413                 DAG.getConstant(Cond, MVT::i32),
13414                 SDValue(Sum.getNode(), 1));
13415
13416   return DAG.getNode(ISD::MERGE_VALUES, DL, N->getVTList(), Sum, SetCC);
13417 }
13418
13419 SDValue X86TargetLowering::LowerSIGN_EXTEND_INREG(SDValue Op,
13420                                                   SelectionDAG &DAG) const {
13421   SDLoc dl(Op);
13422   EVT ExtraVT = cast<VTSDNode>(Op.getOperand(1))->getVT();
13423   MVT VT = Op.getSimpleValueType();
13424
13425   if (!Subtarget->hasSSE2() || !VT.isVector())
13426     return SDValue();
13427
13428   unsigned BitsDiff = VT.getScalarType().getSizeInBits() -
13429                       ExtraVT.getScalarType().getSizeInBits();
13430
13431   switch (VT.SimpleTy) {
13432     default: return SDValue();
13433     case MVT::v8i32:
13434     case MVT::v16i16:
13435       if (!Subtarget->hasFp256())
13436         return SDValue();
13437       if (!Subtarget->hasInt256()) {
13438         // needs to be split
13439         unsigned NumElems = VT.getVectorNumElements();
13440
13441         // Extract the LHS vectors
13442         SDValue LHS = Op.getOperand(0);
13443         SDValue LHS1 = Extract128BitVector(LHS, 0, DAG, dl);
13444         SDValue LHS2 = Extract128BitVector(LHS, NumElems/2, DAG, dl);
13445
13446         MVT EltVT = VT.getVectorElementType();
13447         EVT NewVT = MVT::getVectorVT(EltVT, NumElems/2);
13448
13449         EVT ExtraEltVT = ExtraVT.getVectorElementType();
13450         unsigned ExtraNumElems = ExtraVT.getVectorNumElements();
13451         ExtraVT = EVT::getVectorVT(*DAG.getContext(), ExtraEltVT,
13452                                    ExtraNumElems/2);
13453         SDValue Extra = DAG.getValueType(ExtraVT);
13454
13455         LHS1 = DAG.getNode(Op.getOpcode(), dl, NewVT, LHS1, Extra);
13456         LHS2 = DAG.getNode(Op.getOpcode(), dl, NewVT, LHS2, Extra);
13457
13458         return DAG.getNode(ISD::CONCAT_VECTORS, dl, VT, LHS1, LHS2);
13459       }
13460       // fall through
13461     case MVT::v4i32:
13462     case MVT::v8i16: {
13463       SDValue Op0 = Op.getOperand(0);
13464       SDValue Op00 = Op0.getOperand(0);
13465       SDValue Tmp1;
13466       // Hopefully, this VECTOR_SHUFFLE is just a VZEXT.
13467       if (Op0.getOpcode() == ISD::BITCAST &&
13468           Op00.getOpcode() == ISD::VECTOR_SHUFFLE) {
13469         // (sext (vzext x)) -> (vsext x)
13470         Tmp1 = LowerVectorIntExtend(Op00, Subtarget, DAG);
13471         if (Tmp1.getNode()) {
13472           EVT ExtraEltVT = ExtraVT.getVectorElementType();
13473           // This folding is only valid when the in-reg type is a vector of i8,
13474           // i16, or i32.
13475           if (ExtraEltVT == MVT::i8 || ExtraEltVT == MVT::i16 ||
13476               ExtraEltVT == MVT::i32) {
13477             SDValue Tmp1Op0 = Tmp1.getOperand(0);
13478             assert(Tmp1Op0.getOpcode() == X86ISD::VZEXT &&
13479                    "This optimization is invalid without a VZEXT.");
13480             return DAG.getNode(X86ISD::VSEXT, dl, VT, Tmp1Op0.getOperand(0));
13481           }
13482           Op0 = Tmp1;
13483         }
13484       }
13485
13486       // If the above didn't work, then just use Shift-Left + Shift-Right.
13487       Tmp1 = getTargetVShiftByConstNode(X86ISD::VSHLI, dl, VT, Op0, BitsDiff,
13488                                         DAG);
13489       return getTargetVShiftByConstNode(X86ISD::VSRAI, dl, VT, Tmp1, BitsDiff,
13490                                         DAG);
13491     }
13492   }
13493 }
13494
13495 static SDValue LowerATOMIC_FENCE(SDValue Op, const X86Subtarget *Subtarget,
13496                                  SelectionDAG &DAG) {
13497   SDLoc dl(Op);
13498   AtomicOrdering FenceOrdering = static_cast<AtomicOrdering>(
13499     cast<ConstantSDNode>(Op.getOperand(1))->getZExtValue());
13500   SynchronizationScope FenceScope = static_cast<SynchronizationScope>(
13501     cast<ConstantSDNode>(Op.getOperand(2))->getZExtValue());
13502
13503   // The only fence that needs an instruction is a sequentially-consistent
13504   // cross-thread fence.
13505   if (FenceOrdering == SequentiallyConsistent && FenceScope == CrossThread) {
13506     // Use mfence if we have SSE2 or we're on x86-64 (even if we asked for
13507     // no-sse2). There isn't any reason to disable it if the target processor
13508     // supports it.
13509     if (Subtarget->hasSSE2() || Subtarget->is64Bit())
13510       return DAG.getNode(X86ISD::MFENCE, dl, MVT::Other, Op.getOperand(0));
13511
13512     SDValue Chain = Op.getOperand(0);
13513     SDValue Zero = DAG.getConstant(0, MVT::i32);
13514     SDValue Ops[] = {
13515       DAG.getRegister(X86::ESP, MVT::i32), // Base
13516       DAG.getTargetConstant(1, MVT::i8),   // Scale
13517       DAG.getRegister(0, MVT::i32),        // Index
13518       DAG.getTargetConstant(0, MVT::i32),  // Disp
13519       DAG.getRegister(0, MVT::i32),        // Segment.
13520       Zero,
13521       Chain
13522     };
13523     SDNode *Res = DAG.getMachineNode(X86::OR32mrLocked, dl, MVT::Other, Ops);
13524     return SDValue(Res, 0);
13525   }
13526
13527   // MEMBARRIER is a compiler barrier; it codegens to a no-op.
13528   return DAG.getNode(X86ISD::MEMBARRIER, dl, MVT::Other, Op.getOperand(0));
13529 }
13530
13531 static SDValue LowerCMP_SWAP(SDValue Op, const X86Subtarget *Subtarget,
13532                              SelectionDAG &DAG) {
13533   MVT T = Op.getSimpleValueType();
13534   SDLoc DL(Op);
13535   unsigned Reg = 0;
13536   unsigned size = 0;
13537   switch(T.SimpleTy) {
13538   default: llvm_unreachable("Invalid value type!");
13539   case MVT::i8:  Reg = X86::AL;  size = 1; break;
13540   case MVT::i16: Reg = X86::AX;  size = 2; break;
13541   case MVT::i32: Reg = X86::EAX; size = 4; break;
13542   case MVT::i64:
13543     assert(Subtarget->is64Bit() && "Node not type legal!");
13544     Reg = X86::RAX; size = 8;
13545     break;
13546   }
13547   SDValue cpIn = DAG.getCopyToReg(Op.getOperand(0), DL, Reg,
13548                                     Op.getOperand(2), SDValue());
13549   SDValue Ops[] = { cpIn.getValue(0),
13550                     Op.getOperand(1),
13551                     Op.getOperand(3),
13552                     DAG.getTargetConstant(size, MVT::i8),
13553                     cpIn.getValue(1) };
13554   SDVTList Tys = DAG.getVTList(MVT::Other, MVT::Glue);
13555   MachineMemOperand *MMO = cast<AtomicSDNode>(Op)->getMemOperand();
13556   SDValue Result = DAG.getMemIntrinsicNode(X86ISD::LCMPXCHG_DAG, DL, Tys,
13557                                            Ops, array_lengthof(Ops), T, MMO);
13558   SDValue cpOut =
13559     DAG.getCopyFromReg(Result.getValue(0), DL, Reg, T, Result.getValue(1));
13560   return cpOut;
13561 }
13562
13563 static SDValue LowerREADCYCLECOUNTER(SDValue Op, const X86Subtarget *Subtarget,
13564                                      SelectionDAG &DAG) {
13565   assert(Subtarget->is64Bit() && "Result not type legalized?");
13566   SDVTList Tys = DAG.getVTList(MVT::Other, MVT::Glue);
13567   SDValue TheChain = Op.getOperand(0);
13568   SDLoc dl(Op);
13569   SDValue rd = DAG.getNode(X86ISD::RDTSC_DAG, dl, Tys, &TheChain, 1);
13570   SDValue rax = DAG.getCopyFromReg(rd, dl, X86::RAX, MVT::i64, rd.getValue(1));
13571   SDValue rdx = DAG.getCopyFromReg(rax.getValue(1), dl, X86::RDX, MVT::i64,
13572                                    rax.getValue(2));
13573   SDValue Tmp = DAG.getNode(ISD::SHL, dl, MVT::i64, rdx,
13574                             DAG.getConstant(32, MVT::i8));
13575   SDValue Ops[] = {
13576     DAG.getNode(ISD::OR, dl, MVT::i64, rax, Tmp),
13577     rdx.getValue(1)
13578   };
13579   return DAG.getMergeValues(Ops, array_lengthof(Ops), dl);
13580 }
13581
13582 static SDValue LowerBITCAST(SDValue Op, const X86Subtarget *Subtarget,
13583                             SelectionDAG &DAG) {
13584   MVT SrcVT = Op.getOperand(0).getSimpleValueType();
13585   MVT DstVT = Op.getSimpleValueType();
13586   assert(Subtarget->is64Bit() && !Subtarget->hasSSE2() &&
13587          Subtarget->hasMMX() && "Unexpected custom BITCAST");
13588   assert((DstVT == MVT::i64 ||
13589           (DstVT.isVector() && DstVT.getSizeInBits()==64)) &&
13590          "Unexpected custom BITCAST");
13591   // i64 <=> MMX conversions are Legal.
13592   if (SrcVT==MVT::i64 && DstVT.isVector())
13593     return Op;
13594   if (DstVT==MVT::i64 && SrcVT.isVector())
13595     return Op;
13596   // MMX <=> MMX conversions are Legal.
13597   if (SrcVT.isVector() && DstVT.isVector())
13598     return Op;
13599   // All other conversions need to be expanded.
13600   return SDValue();
13601 }
13602
13603 static SDValue LowerLOAD_SUB(SDValue Op, SelectionDAG &DAG) {
13604   SDNode *Node = Op.getNode();
13605   SDLoc dl(Node);
13606   EVT T = Node->getValueType(0);
13607   SDValue negOp = DAG.getNode(ISD::SUB, dl, T,
13608                               DAG.getConstant(0, T), Node->getOperand(2));
13609   return DAG.getAtomic(ISD::ATOMIC_LOAD_ADD, dl,
13610                        cast<AtomicSDNode>(Node)->getMemoryVT(),
13611                        Node->getOperand(0),
13612                        Node->getOperand(1), negOp,
13613                        cast<AtomicSDNode>(Node)->getSrcValue(),
13614                        cast<AtomicSDNode>(Node)->getAlignment(),
13615                        cast<AtomicSDNode>(Node)->getOrdering(),
13616                        cast<AtomicSDNode>(Node)->getSynchScope());
13617 }
13618
13619 static SDValue LowerATOMIC_STORE(SDValue Op, SelectionDAG &DAG) {
13620   SDNode *Node = Op.getNode();
13621   SDLoc dl(Node);
13622   EVT VT = cast<AtomicSDNode>(Node)->getMemoryVT();
13623
13624   // Convert seq_cst store -> xchg
13625   // Convert wide store -> swap (-> cmpxchg8b/cmpxchg16b)
13626   // FIXME: On 32-bit, store -> fist or movq would be more efficient
13627   //        (The only way to get a 16-byte store is cmpxchg16b)
13628   // FIXME: 16-byte ATOMIC_SWAP isn't actually hooked up at the moment.
13629   if (cast<AtomicSDNode>(Node)->getOrdering() == SequentiallyConsistent ||
13630       !DAG.getTargetLoweringInfo().isTypeLegal(VT)) {
13631     SDValue Swap = DAG.getAtomic(ISD::ATOMIC_SWAP, dl,
13632                                  cast<AtomicSDNode>(Node)->getMemoryVT(),
13633                                  Node->getOperand(0),
13634                                  Node->getOperand(1), Node->getOperand(2),
13635                                  cast<AtomicSDNode>(Node)->getMemOperand(),
13636                                  cast<AtomicSDNode>(Node)->getOrdering(),
13637                                  cast<AtomicSDNode>(Node)->getSynchScope());
13638     return Swap.getValue(1);
13639   }
13640   // Other atomic stores have a simple pattern.
13641   return Op;
13642 }
13643
13644 static SDValue LowerADDC_ADDE_SUBC_SUBE(SDValue Op, SelectionDAG &DAG) {
13645   EVT VT = Op.getNode()->getSimpleValueType(0);
13646
13647   // Let legalize expand this if it isn't a legal type yet.
13648   if (!DAG.getTargetLoweringInfo().isTypeLegal(VT))
13649     return SDValue();
13650
13651   SDVTList VTs = DAG.getVTList(VT, MVT::i32);
13652
13653   unsigned Opc;
13654   bool ExtraOp = false;
13655   switch (Op.getOpcode()) {
13656   default: llvm_unreachable("Invalid code");
13657   case ISD::ADDC: Opc = X86ISD::ADD; break;
13658   case ISD::ADDE: Opc = X86ISD::ADC; ExtraOp = true; break;
13659   case ISD::SUBC: Opc = X86ISD::SUB; break;
13660   case ISD::SUBE: Opc = X86ISD::SBB; ExtraOp = true; break;
13661   }
13662
13663   if (!ExtraOp)
13664     return DAG.getNode(Opc, SDLoc(Op), VTs, Op.getOperand(0),
13665                        Op.getOperand(1));
13666   return DAG.getNode(Opc, SDLoc(Op), VTs, Op.getOperand(0),
13667                      Op.getOperand(1), Op.getOperand(2));
13668 }
13669
13670 static SDValue LowerFSINCOS(SDValue Op, const X86Subtarget *Subtarget,
13671                             SelectionDAG &DAG) {
13672   assert(Subtarget->isTargetDarwin() && Subtarget->is64Bit());
13673
13674   // For MacOSX, we want to call an alternative entry point: __sincos_stret,
13675   // which returns the values as { float, float } (in XMM0) or
13676   // { double, double } (which is returned in XMM0, XMM1).
13677   SDLoc dl(Op);
13678   SDValue Arg = Op.getOperand(0);
13679   EVT ArgVT = Arg.getValueType();
13680   Type *ArgTy = ArgVT.getTypeForEVT(*DAG.getContext());
13681
13682   TargetLowering::ArgListTy Args;
13683   TargetLowering::ArgListEntry Entry;
13684
13685   Entry.Node = Arg;
13686   Entry.Ty = ArgTy;
13687   Entry.isSExt = false;
13688   Entry.isZExt = false;
13689   Args.push_back(Entry);
13690
13691   bool isF64 = ArgVT == MVT::f64;
13692   // Only optimize x86_64 for now. i386 is a bit messy. For f32,
13693   // the small struct {f32, f32} is returned in (eax, edx). For f64,
13694   // the results are returned via SRet in memory.
13695   const char *LibcallName =  isF64 ? "__sincos_stret" : "__sincosf_stret";
13696   const TargetLowering &TLI = DAG.getTargetLoweringInfo();
13697   SDValue Callee = DAG.getExternalSymbol(LibcallName, TLI.getPointerTy());
13698
13699   Type *RetTy = isF64
13700     ? (Type*)StructType::get(ArgTy, ArgTy, NULL)
13701     : (Type*)VectorType::get(ArgTy, 4);
13702   TargetLowering::
13703     CallLoweringInfo CLI(DAG.getEntryNode(), RetTy,
13704                          false, false, false, false, 0,
13705                          CallingConv::C, /*isTaillCall=*/false,
13706                          /*doesNotRet=*/false, /*isReturnValueUsed*/true,
13707                          Callee, Args, DAG, dl);
13708   std::pair<SDValue, SDValue> CallResult = TLI.LowerCallTo(CLI);
13709
13710   if (isF64)
13711     // Returned in xmm0 and xmm1.
13712     return CallResult.first;
13713
13714   // Returned in bits 0:31 and 32:64 xmm0.
13715   SDValue SinVal = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, ArgVT,
13716                                CallResult.first, DAG.getIntPtrConstant(0));
13717   SDValue CosVal = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, ArgVT,
13718                                CallResult.first, DAG.getIntPtrConstant(1));
13719   SDVTList Tys = DAG.getVTList(ArgVT, ArgVT);
13720   return DAG.getNode(ISD::MERGE_VALUES, dl, Tys, SinVal, CosVal);
13721 }
13722
13723 /// LowerOperation - Provide custom lowering hooks for some operations.
13724 ///
13725 SDValue X86TargetLowering::LowerOperation(SDValue Op, SelectionDAG &DAG) const {
13726   switch (Op.getOpcode()) {
13727   default: llvm_unreachable("Should not custom lower this!");
13728   case ISD::SIGN_EXTEND_INREG:  return LowerSIGN_EXTEND_INREG(Op,DAG);
13729   case ISD::ATOMIC_FENCE:       return LowerATOMIC_FENCE(Op, Subtarget, DAG);
13730   case ISD::ATOMIC_CMP_SWAP:    return LowerCMP_SWAP(Op, Subtarget, DAG);
13731   case ISD::ATOMIC_LOAD_SUB:    return LowerLOAD_SUB(Op,DAG);
13732   case ISD::ATOMIC_STORE:       return LowerATOMIC_STORE(Op,DAG);
13733   case ISD::BUILD_VECTOR:       return LowerBUILD_VECTOR(Op, DAG);
13734   case ISD::CONCAT_VECTORS:     return LowerCONCAT_VECTORS(Op, DAG);
13735   case ISD::VECTOR_SHUFFLE:     return LowerVECTOR_SHUFFLE(Op, DAG);
13736   case ISD::EXTRACT_VECTOR_ELT: return LowerEXTRACT_VECTOR_ELT(Op, DAG);
13737   case ISD::INSERT_VECTOR_ELT:  return LowerINSERT_VECTOR_ELT(Op, DAG);
13738   case ISD::EXTRACT_SUBVECTOR:  return LowerEXTRACT_SUBVECTOR(Op,Subtarget,DAG);
13739   case ISD::INSERT_SUBVECTOR:   return LowerINSERT_SUBVECTOR(Op, Subtarget,DAG);
13740   case ISD::SCALAR_TO_VECTOR:   return LowerSCALAR_TO_VECTOR(Op, DAG);
13741   case ISD::ConstantPool:       return LowerConstantPool(Op, DAG);
13742   case ISD::GlobalAddress:      return LowerGlobalAddress(Op, DAG);
13743   case ISD::GlobalTLSAddress:   return LowerGlobalTLSAddress(Op, DAG);
13744   case ISD::ExternalSymbol:     return LowerExternalSymbol(Op, DAG);
13745   case ISD::BlockAddress:       return LowerBlockAddress(Op, DAG);
13746   case ISD::SHL_PARTS:
13747   case ISD::SRA_PARTS:
13748   case ISD::SRL_PARTS:          return LowerShiftParts(Op, DAG);
13749   case ISD::SINT_TO_FP:         return LowerSINT_TO_FP(Op, DAG);
13750   case ISD::UINT_TO_FP:         return LowerUINT_TO_FP(Op, DAG);
13751   case ISD::TRUNCATE:           return LowerTRUNCATE(Op, DAG);
13752   case ISD::ZERO_EXTEND:        return LowerZERO_EXTEND(Op, Subtarget, DAG);
13753   case ISD::SIGN_EXTEND:        return LowerSIGN_EXTEND(Op, Subtarget, DAG);
13754   case ISD::ANY_EXTEND:         return LowerANY_EXTEND(Op, Subtarget, DAG);
13755   case ISD::FP_TO_SINT:         return LowerFP_TO_SINT(Op, DAG);
13756   case ISD::FP_TO_UINT:         return LowerFP_TO_UINT(Op, DAG);
13757   case ISD::FP_EXTEND:          return LowerFP_EXTEND(Op, DAG);
13758   case ISD::FABS:               return LowerFABS(Op, DAG);
13759   case ISD::FNEG:               return LowerFNEG(Op, DAG);
13760   case ISD::FCOPYSIGN:          return LowerFCOPYSIGN(Op, DAG);
13761   case ISD::FGETSIGN:           return LowerFGETSIGN(Op, DAG);
13762   case ISD::SETCC:              return LowerSETCC(Op, DAG);
13763   case ISD::SELECT:             return LowerSELECT(Op, DAG);
13764   case ISD::BRCOND:             return LowerBRCOND(Op, DAG);
13765   case ISD::JumpTable:          return LowerJumpTable(Op, DAG);
13766   case ISD::VASTART:            return LowerVASTART(Op, DAG);
13767   case ISD::VAARG:              return LowerVAARG(Op, DAG);
13768   case ISD::VACOPY:             return LowerVACOPY(Op, Subtarget, DAG);
13769   case ISD::INTRINSIC_WO_CHAIN: return LowerINTRINSIC_WO_CHAIN(Op, DAG);
13770   case ISD::INTRINSIC_VOID:
13771   case ISD::INTRINSIC_W_CHAIN:  return LowerINTRINSIC_W_CHAIN(Op, Subtarget, DAG);
13772   case ISD::RETURNADDR:         return LowerRETURNADDR(Op, DAG);
13773   case ISD::FRAMEADDR:          return LowerFRAMEADDR(Op, DAG);
13774   case ISD::FRAME_TO_ARGS_OFFSET:
13775                                 return LowerFRAME_TO_ARGS_OFFSET(Op, DAG);
13776   case ISD::DYNAMIC_STACKALLOC: return LowerDYNAMIC_STACKALLOC(Op, DAG);
13777   case ISD::EH_RETURN:          return LowerEH_RETURN(Op, DAG);
13778   case ISD::EH_SJLJ_SETJMP:     return lowerEH_SJLJ_SETJMP(Op, DAG);
13779   case ISD::EH_SJLJ_LONGJMP:    return lowerEH_SJLJ_LONGJMP(Op, DAG);
13780   case ISD::INIT_TRAMPOLINE:    return LowerINIT_TRAMPOLINE(Op, DAG);
13781   case ISD::ADJUST_TRAMPOLINE:  return LowerADJUST_TRAMPOLINE(Op, DAG);
13782   case ISD::FLT_ROUNDS_:        return LowerFLT_ROUNDS_(Op, DAG);
13783   case ISD::CTLZ:               return LowerCTLZ(Op, DAG);
13784   case ISD::CTLZ_ZERO_UNDEF:    return LowerCTLZ_ZERO_UNDEF(Op, DAG);
13785   case ISD::CTTZ:               return LowerCTTZ(Op, DAG);
13786   case ISD::MUL:                return LowerMUL(Op, Subtarget, DAG);
13787   case ISD::SRA:
13788   case ISD::SRL:
13789   case ISD::SHL:                return LowerShift(Op, Subtarget, DAG);
13790   case ISD::SADDO:
13791   case ISD::UADDO:
13792   case ISD::SSUBO:
13793   case ISD::USUBO:
13794   case ISD::SMULO:
13795   case ISD::UMULO:              return LowerXALUO(Op, DAG);
13796   case ISD::READCYCLECOUNTER:   return LowerREADCYCLECOUNTER(Op, Subtarget,DAG);
13797   case ISD::BITCAST:            return LowerBITCAST(Op, Subtarget, DAG);
13798   case ISD::ADDC:
13799   case ISD::ADDE:
13800   case ISD::SUBC:
13801   case ISD::SUBE:               return LowerADDC_ADDE_SUBC_SUBE(Op, DAG);
13802   case ISD::ADD:                return LowerADD(Op, DAG);
13803   case ISD::SUB:                return LowerSUB(Op, DAG);
13804   case ISD::SDIV:               return LowerSDIV(Op, DAG);
13805   case ISD::FSINCOS:            return LowerFSINCOS(Op, Subtarget, DAG);
13806   }
13807 }
13808
13809 static void ReplaceATOMIC_LOAD(SDNode *Node,
13810                                   SmallVectorImpl<SDValue> &Results,
13811                                   SelectionDAG &DAG) {
13812   SDLoc dl(Node);
13813   EVT VT = cast<AtomicSDNode>(Node)->getMemoryVT();
13814
13815   // Convert wide load -> cmpxchg8b/cmpxchg16b
13816   // FIXME: On 32-bit, load -> fild or movq would be more efficient
13817   //        (The only way to get a 16-byte load is cmpxchg16b)
13818   // FIXME: 16-byte ATOMIC_CMP_SWAP isn't actually hooked up at the moment.
13819   SDValue Zero = DAG.getConstant(0, VT);
13820   SDValue Swap = DAG.getAtomic(ISD::ATOMIC_CMP_SWAP, dl, VT,
13821                                Node->getOperand(0),
13822                                Node->getOperand(1), Zero, Zero,
13823                                cast<AtomicSDNode>(Node)->getMemOperand(),
13824                                cast<AtomicSDNode>(Node)->getOrdering(),
13825                                cast<AtomicSDNode>(Node)->getOrdering(),
13826                                cast<AtomicSDNode>(Node)->getSynchScope());
13827   Results.push_back(Swap.getValue(0));
13828   Results.push_back(Swap.getValue(1));
13829 }
13830
13831 static void
13832 ReplaceATOMIC_BINARY_64(SDNode *Node, SmallVectorImpl<SDValue>&Results,
13833                         SelectionDAG &DAG, unsigned NewOp) {
13834   SDLoc dl(Node);
13835   assert (Node->getValueType(0) == MVT::i64 &&
13836           "Only know how to expand i64 atomics");
13837
13838   SDValue Chain = Node->getOperand(0);
13839   SDValue In1 = Node->getOperand(1);
13840   SDValue In2L = DAG.getNode(ISD::EXTRACT_ELEMENT, dl, MVT::i32,
13841                              Node->getOperand(2), DAG.getIntPtrConstant(0));
13842   SDValue In2H = DAG.getNode(ISD::EXTRACT_ELEMENT, dl, MVT::i32,
13843                              Node->getOperand(2), DAG.getIntPtrConstant(1));
13844   SDValue Ops[] = { Chain, In1, In2L, In2H };
13845   SDVTList Tys = DAG.getVTList(MVT::i32, MVT::i32, MVT::Other);
13846   SDValue Result =
13847     DAG.getMemIntrinsicNode(NewOp, dl, Tys, Ops, array_lengthof(Ops), MVT::i64,
13848                             cast<MemSDNode>(Node)->getMemOperand());
13849   SDValue OpsF[] = { Result.getValue(0), Result.getValue(1)};
13850   Results.push_back(DAG.getNode(ISD::BUILD_PAIR, dl, MVT::i64, OpsF, 2));
13851   Results.push_back(Result.getValue(2));
13852 }
13853
13854 /// ReplaceNodeResults - Replace a node with an illegal result type
13855 /// with a new node built out of custom code.
13856 void X86TargetLowering::ReplaceNodeResults(SDNode *N,
13857                                            SmallVectorImpl<SDValue>&Results,
13858                                            SelectionDAG &DAG) const {
13859   SDLoc dl(N);
13860   const TargetLowering &TLI = DAG.getTargetLoweringInfo();
13861   switch (N->getOpcode()) {
13862   default:
13863     llvm_unreachable("Do not know how to custom type legalize this operation!");
13864   case ISD::SIGN_EXTEND_INREG:
13865   case ISD::ADDC:
13866   case ISD::ADDE:
13867   case ISD::SUBC:
13868   case ISD::SUBE:
13869     // We don't want to expand or promote these.
13870     return;
13871   case ISD::FP_TO_SINT:
13872   case ISD::FP_TO_UINT: {
13873     bool IsSigned = N->getOpcode() == ISD::FP_TO_SINT;
13874
13875     if (!IsSigned && !isIntegerTypeFTOL(SDValue(N, 0).getValueType()))
13876       return;
13877
13878     std::pair<SDValue,SDValue> Vals =
13879         FP_TO_INTHelper(SDValue(N, 0), DAG, IsSigned, /*IsReplace=*/ true);
13880     SDValue FIST = Vals.first, StackSlot = Vals.second;
13881     if (FIST.getNode() != 0) {
13882       EVT VT = N->getValueType(0);
13883       // Return a load from the stack slot.
13884       if (StackSlot.getNode() != 0)
13885         Results.push_back(DAG.getLoad(VT, dl, FIST, StackSlot,
13886                                       MachinePointerInfo(),
13887                                       false, false, false, 0));
13888       else
13889         Results.push_back(FIST);
13890     }
13891     return;
13892   }
13893   case ISD::UINT_TO_FP: {
13894     assert(Subtarget->hasSSE2() && "Requires at least SSE2!");
13895     if (N->getOperand(0).getValueType() != MVT::v2i32 ||
13896         N->getValueType(0) != MVT::v2f32)
13897       return;
13898     SDValue ZExtIn = DAG.getNode(ISD::ZERO_EXTEND, dl, MVT::v2i64,
13899                                  N->getOperand(0));
13900     SDValue Bias = DAG.getConstantFP(BitsToDouble(0x4330000000000000ULL),
13901                                      MVT::f64);
13902     SDValue VBias = DAG.getNode(ISD::BUILD_VECTOR, dl, MVT::v2f64, Bias, Bias);
13903     SDValue Or = DAG.getNode(ISD::OR, dl, MVT::v2i64, ZExtIn,
13904                              DAG.getNode(ISD::BITCAST, dl, MVT::v2i64, VBias));
13905     Or = DAG.getNode(ISD::BITCAST, dl, MVT::v2f64, Or);
13906     SDValue Sub = DAG.getNode(ISD::FSUB, dl, MVT::v2f64, Or, VBias);
13907     Results.push_back(DAG.getNode(X86ISD::VFPROUND, dl, MVT::v4f32, Sub));
13908     return;
13909   }
13910   case ISD::FP_ROUND: {
13911     if (!TLI.isTypeLegal(N->getOperand(0).getValueType()))
13912         return;
13913     SDValue V = DAG.getNode(X86ISD::VFPROUND, dl, MVT::v4f32, N->getOperand(0));
13914     Results.push_back(V);
13915     return;
13916   }
13917   case ISD::READCYCLECOUNTER: {
13918     SDVTList Tys = DAG.getVTList(MVT::Other, MVT::Glue);
13919     SDValue TheChain = N->getOperand(0);
13920     SDValue rd = DAG.getNode(X86ISD::RDTSC_DAG, dl, Tys, &TheChain, 1);
13921     SDValue eax = DAG.getCopyFromReg(rd, dl, X86::EAX, MVT::i32,
13922                                      rd.getValue(1));
13923     SDValue edx = DAG.getCopyFromReg(eax.getValue(1), dl, X86::EDX, MVT::i32,
13924                                      eax.getValue(2));
13925     // Use a buildpair to merge the two 32-bit values into a 64-bit one.
13926     SDValue Ops[] = { eax, edx };
13927     Results.push_back(DAG.getNode(ISD::BUILD_PAIR, dl, MVT::i64, Ops,
13928                                   array_lengthof(Ops)));
13929     Results.push_back(edx.getValue(1));
13930     return;
13931   }
13932   case ISD::ATOMIC_CMP_SWAP: {
13933     EVT T = N->getValueType(0);
13934     assert((T == MVT::i64 || T == MVT::i128) && "can only expand cmpxchg pair");
13935     bool Regs64bit = T == MVT::i128;
13936     EVT HalfT = Regs64bit ? MVT::i64 : MVT::i32;
13937     SDValue cpInL, cpInH;
13938     cpInL = DAG.getNode(ISD::EXTRACT_ELEMENT, dl, HalfT, N->getOperand(2),
13939                         DAG.getConstant(0, HalfT));
13940     cpInH = DAG.getNode(ISD::EXTRACT_ELEMENT, dl, HalfT, N->getOperand(2),
13941                         DAG.getConstant(1, HalfT));
13942     cpInL = DAG.getCopyToReg(N->getOperand(0), dl,
13943                              Regs64bit ? X86::RAX : X86::EAX,
13944                              cpInL, SDValue());
13945     cpInH = DAG.getCopyToReg(cpInL.getValue(0), dl,
13946                              Regs64bit ? X86::RDX : X86::EDX,
13947                              cpInH, cpInL.getValue(1));
13948     SDValue swapInL, swapInH;
13949     swapInL = DAG.getNode(ISD::EXTRACT_ELEMENT, dl, HalfT, N->getOperand(3),
13950                           DAG.getConstant(0, HalfT));
13951     swapInH = DAG.getNode(ISD::EXTRACT_ELEMENT, dl, HalfT, N->getOperand(3),
13952                           DAG.getConstant(1, HalfT));
13953     swapInL = DAG.getCopyToReg(cpInH.getValue(0), dl,
13954                                Regs64bit ? X86::RBX : X86::EBX,
13955                                swapInL, cpInH.getValue(1));
13956     swapInH = DAG.getCopyToReg(swapInL.getValue(0), dl,
13957                                Regs64bit ? X86::RCX : X86::ECX,
13958                                swapInH, swapInL.getValue(1));
13959     SDValue Ops[] = { swapInH.getValue(0),
13960                       N->getOperand(1),
13961                       swapInH.getValue(1) };
13962     SDVTList Tys = DAG.getVTList(MVT::Other, MVT::Glue);
13963     MachineMemOperand *MMO = cast<AtomicSDNode>(N)->getMemOperand();
13964     unsigned Opcode = Regs64bit ? X86ISD::LCMPXCHG16_DAG :
13965                                   X86ISD::LCMPXCHG8_DAG;
13966     SDValue Result = DAG.getMemIntrinsicNode(Opcode, dl, Tys,
13967                                              Ops, array_lengthof(Ops), T, MMO);
13968     SDValue cpOutL = DAG.getCopyFromReg(Result.getValue(0), dl,
13969                                         Regs64bit ? X86::RAX : X86::EAX,
13970                                         HalfT, Result.getValue(1));
13971     SDValue cpOutH = DAG.getCopyFromReg(cpOutL.getValue(1), dl,
13972                                         Regs64bit ? X86::RDX : X86::EDX,
13973                                         HalfT, cpOutL.getValue(2));
13974     SDValue OpsF[] = { cpOutL.getValue(0), cpOutH.getValue(0)};
13975     Results.push_back(DAG.getNode(ISD::BUILD_PAIR, dl, T, OpsF, 2));
13976     Results.push_back(cpOutH.getValue(1));
13977     return;
13978   }
13979   case ISD::ATOMIC_LOAD_ADD:
13980   case ISD::ATOMIC_LOAD_AND:
13981   case ISD::ATOMIC_LOAD_NAND:
13982   case ISD::ATOMIC_LOAD_OR:
13983   case ISD::ATOMIC_LOAD_SUB:
13984   case ISD::ATOMIC_LOAD_XOR:
13985   case ISD::ATOMIC_LOAD_MAX:
13986   case ISD::ATOMIC_LOAD_MIN:
13987   case ISD::ATOMIC_LOAD_UMAX:
13988   case ISD::ATOMIC_LOAD_UMIN:
13989   case ISD::ATOMIC_SWAP: {
13990     unsigned Opc;
13991     switch (N->getOpcode()) {
13992     default: llvm_unreachable("Unexpected opcode");
13993     case ISD::ATOMIC_LOAD_ADD:
13994       Opc = X86ISD::ATOMADD64_DAG;
13995       break;
13996     case ISD::ATOMIC_LOAD_AND:
13997       Opc = X86ISD::ATOMAND64_DAG;
13998       break;
13999     case ISD::ATOMIC_LOAD_NAND:
14000       Opc = X86ISD::ATOMNAND64_DAG;
14001       break;
14002     case ISD::ATOMIC_LOAD_OR:
14003       Opc = X86ISD::ATOMOR64_DAG;
14004       break;
14005     case ISD::ATOMIC_LOAD_SUB:
14006       Opc = X86ISD::ATOMSUB64_DAG;
14007       break;
14008     case ISD::ATOMIC_LOAD_XOR:
14009       Opc = X86ISD::ATOMXOR64_DAG;
14010       break;
14011     case ISD::ATOMIC_LOAD_MAX:
14012       Opc = X86ISD::ATOMMAX64_DAG;
14013       break;
14014     case ISD::ATOMIC_LOAD_MIN:
14015       Opc = X86ISD::ATOMMIN64_DAG;
14016       break;
14017     case ISD::ATOMIC_LOAD_UMAX:
14018       Opc = X86ISD::ATOMUMAX64_DAG;
14019       break;
14020     case ISD::ATOMIC_LOAD_UMIN:
14021       Opc = X86ISD::ATOMUMIN64_DAG;
14022       break;
14023     case ISD::ATOMIC_SWAP:
14024       Opc = X86ISD::ATOMSWAP64_DAG;
14025       break;
14026     }
14027     ReplaceATOMIC_BINARY_64(N, Results, DAG, Opc);
14028     return;
14029   }
14030   case ISD::ATOMIC_LOAD:
14031     ReplaceATOMIC_LOAD(N, Results, DAG);
14032   }
14033 }
14034
14035 const char *X86TargetLowering::getTargetNodeName(unsigned Opcode) const {
14036   switch (Opcode) {
14037   default: return NULL;
14038   case X86ISD::BSF:                return "X86ISD::BSF";
14039   case X86ISD::BSR:                return "X86ISD::BSR";
14040   case X86ISD::SHLD:               return "X86ISD::SHLD";
14041   case X86ISD::SHRD:               return "X86ISD::SHRD";
14042   case X86ISD::FAND:               return "X86ISD::FAND";
14043   case X86ISD::FANDN:              return "X86ISD::FANDN";
14044   case X86ISD::FOR:                return "X86ISD::FOR";
14045   case X86ISD::FXOR:               return "X86ISD::FXOR";
14046   case X86ISD::FSRL:               return "X86ISD::FSRL";
14047   case X86ISD::FILD:               return "X86ISD::FILD";
14048   case X86ISD::FILD_FLAG:          return "X86ISD::FILD_FLAG";
14049   case X86ISD::FP_TO_INT16_IN_MEM: return "X86ISD::FP_TO_INT16_IN_MEM";
14050   case X86ISD::FP_TO_INT32_IN_MEM: return "X86ISD::FP_TO_INT32_IN_MEM";
14051   case X86ISD::FP_TO_INT64_IN_MEM: return "X86ISD::FP_TO_INT64_IN_MEM";
14052   case X86ISD::FLD:                return "X86ISD::FLD";
14053   case X86ISD::FST:                return "X86ISD::FST";
14054   case X86ISD::CALL:               return "X86ISD::CALL";
14055   case X86ISD::RDTSC_DAG:          return "X86ISD::RDTSC_DAG";
14056   case X86ISD::BT:                 return "X86ISD::BT";
14057   case X86ISD::CMP:                return "X86ISD::CMP";
14058   case X86ISD::COMI:               return "X86ISD::COMI";
14059   case X86ISD::UCOMI:              return "X86ISD::UCOMI";
14060   case X86ISD::CMPM:               return "X86ISD::CMPM";
14061   case X86ISD::CMPMU:              return "X86ISD::CMPMU";
14062   case X86ISD::SETCC:              return "X86ISD::SETCC";
14063   case X86ISD::SETCC_CARRY:        return "X86ISD::SETCC_CARRY";
14064   case X86ISD::FSETCC:             return "X86ISD::FSETCC";
14065   case X86ISD::CMOV:               return "X86ISD::CMOV";
14066   case X86ISD::BRCOND:             return "X86ISD::BRCOND";
14067   case X86ISD::RET_FLAG:           return "X86ISD::RET_FLAG";
14068   case X86ISD::REP_STOS:           return "X86ISD::REP_STOS";
14069   case X86ISD::REP_MOVS:           return "X86ISD::REP_MOVS";
14070   case X86ISD::GlobalBaseReg:      return "X86ISD::GlobalBaseReg";
14071   case X86ISD::Wrapper:            return "X86ISD::Wrapper";
14072   case X86ISD::WrapperRIP:         return "X86ISD::WrapperRIP";
14073   case X86ISD::PEXTRB:             return "X86ISD::PEXTRB";
14074   case X86ISD::PEXTRW:             return "X86ISD::PEXTRW";
14075   case X86ISD::INSERTPS:           return "X86ISD::INSERTPS";
14076   case X86ISD::PINSRB:             return "X86ISD::PINSRB";
14077   case X86ISD::PINSRW:             return "X86ISD::PINSRW";
14078   case X86ISD::PSHUFB:             return "X86ISD::PSHUFB";
14079   case X86ISD::ANDNP:              return "X86ISD::ANDNP";
14080   case X86ISD::PSIGN:              return "X86ISD::PSIGN";
14081   case X86ISD::BLENDV:             return "X86ISD::BLENDV";
14082   case X86ISD::BLENDI:             return "X86ISD::BLENDI";
14083   case X86ISD::SUBUS:              return "X86ISD::SUBUS";
14084   case X86ISD::HADD:               return "X86ISD::HADD";
14085   case X86ISD::HSUB:               return "X86ISD::HSUB";
14086   case X86ISD::FHADD:              return "X86ISD::FHADD";
14087   case X86ISD::FHSUB:              return "X86ISD::FHSUB";
14088   case X86ISD::UMAX:               return "X86ISD::UMAX";
14089   case X86ISD::UMIN:               return "X86ISD::UMIN";
14090   case X86ISD::SMAX:               return "X86ISD::SMAX";
14091   case X86ISD::SMIN:               return "X86ISD::SMIN";
14092   case X86ISD::FMAX:               return "X86ISD::FMAX";
14093   case X86ISD::FMIN:               return "X86ISD::FMIN";
14094   case X86ISD::FMAXC:              return "X86ISD::FMAXC";
14095   case X86ISD::FMINC:              return "X86ISD::FMINC";
14096   case X86ISD::FRSQRT:             return "X86ISD::FRSQRT";
14097   case X86ISD::FRCP:               return "X86ISD::FRCP";
14098   case X86ISD::TLSADDR:            return "X86ISD::TLSADDR";
14099   case X86ISD::TLSBASEADDR:        return "X86ISD::TLSBASEADDR";
14100   case X86ISD::TLSCALL:            return "X86ISD::TLSCALL";
14101   case X86ISD::EH_SJLJ_SETJMP:     return "X86ISD::EH_SJLJ_SETJMP";
14102   case X86ISD::EH_SJLJ_LONGJMP:    return "X86ISD::EH_SJLJ_LONGJMP";
14103   case X86ISD::EH_RETURN:          return "X86ISD::EH_RETURN";
14104   case X86ISD::TC_RETURN:          return "X86ISD::TC_RETURN";
14105   case X86ISD::FNSTCW16m:          return "X86ISD::FNSTCW16m";
14106   case X86ISD::FNSTSW16r:          return "X86ISD::FNSTSW16r";
14107   case X86ISD::LCMPXCHG_DAG:       return "X86ISD::LCMPXCHG_DAG";
14108   case X86ISD::LCMPXCHG8_DAG:      return "X86ISD::LCMPXCHG8_DAG";
14109   case X86ISD::ATOMADD64_DAG:      return "X86ISD::ATOMADD64_DAG";
14110   case X86ISD::ATOMSUB64_DAG:      return "X86ISD::ATOMSUB64_DAG";
14111   case X86ISD::ATOMOR64_DAG:       return "X86ISD::ATOMOR64_DAG";
14112   case X86ISD::ATOMXOR64_DAG:      return "X86ISD::ATOMXOR64_DAG";
14113   case X86ISD::ATOMAND64_DAG:      return "X86ISD::ATOMAND64_DAG";
14114   case X86ISD::ATOMNAND64_DAG:     return "X86ISD::ATOMNAND64_DAG";
14115   case X86ISD::VZEXT_MOVL:         return "X86ISD::VZEXT_MOVL";
14116   case X86ISD::VZEXT_LOAD:         return "X86ISD::VZEXT_LOAD";
14117   case X86ISD::VZEXT:              return "X86ISD::VZEXT";
14118   case X86ISD::VSEXT:              return "X86ISD::VSEXT";
14119   case X86ISD::VTRUNC:             return "X86ISD::VTRUNC";
14120   case X86ISD::VTRUNCM:            return "X86ISD::VTRUNCM";
14121   case X86ISD::VINSERT:            return "X86ISD::VINSERT";
14122   case X86ISD::VFPEXT:             return "X86ISD::VFPEXT";
14123   case X86ISD::VFPROUND:           return "X86ISD::VFPROUND";
14124   case X86ISD::VSHLDQ:             return "X86ISD::VSHLDQ";
14125   case X86ISD::VSRLDQ:             return "X86ISD::VSRLDQ";
14126   case X86ISD::VSHL:               return "X86ISD::VSHL";
14127   case X86ISD::VSRL:               return "X86ISD::VSRL";
14128   case X86ISD::VSRA:               return "X86ISD::VSRA";
14129   case X86ISD::VSHLI:              return "X86ISD::VSHLI";
14130   case X86ISD::VSRLI:              return "X86ISD::VSRLI";
14131   case X86ISD::VSRAI:              return "X86ISD::VSRAI";
14132   case X86ISD::CMPP:               return "X86ISD::CMPP";
14133   case X86ISD::PCMPEQ:             return "X86ISD::PCMPEQ";
14134   case X86ISD::PCMPGT:             return "X86ISD::PCMPGT";
14135   case X86ISD::PCMPEQM:            return "X86ISD::PCMPEQM";
14136   case X86ISD::PCMPGTM:            return "X86ISD::PCMPGTM";
14137   case X86ISD::ADD:                return "X86ISD::ADD";
14138   case X86ISD::SUB:                return "X86ISD::SUB";
14139   case X86ISD::ADC:                return "X86ISD::ADC";
14140   case X86ISD::SBB:                return "X86ISD::SBB";
14141   case X86ISD::SMUL:               return "X86ISD::SMUL";
14142   case X86ISD::UMUL:               return "X86ISD::UMUL";
14143   case X86ISD::INC:                return "X86ISD::INC";
14144   case X86ISD::DEC:                return "X86ISD::DEC";
14145   case X86ISD::OR:                 return "X86ISD::OR";
14146   case X86ISD::XOR:                return "X86ISD::XOR";
14147   case X86ISD::AND:                return "X86ISD::AND";
14148   case X86ISD::BZHI:               return "X86ISD::BZHI";
14149   case X86ISD::BEXTR:              return "X86ISD::BEXTR";
14150   case X86ISD::MUL_IMM:            return "X86ISD::MUL_IMM";
14151   case X86ISD::PTEST:              return "X86ISD::PTEST";
14152   case X86ISD::TESTP:              return "X86ISD::TESTP";
14153   case X86ISD::TESTM:              return "X86ISD::TESTM";
14154   case X86ISD::TESTNM:             return "X86ISD::TESTNM";
14155   case X86ISD::KORTEST:            return "X86ISD::KORTEST";
14156   case X86ISD::PALIGNR:            return "X86ISD::PALIGNR";
14157   case X86ISD::PSHUFD:             return "X86ISD::PSHUFD";
14158   case X86ISD::PSHUFHW:            return "X86ISD::PSHUFHW";
14159   case X86ISD::PSHUFLW:            return "X86ISD::PSHUFLW";
14160   case X86ISD::SHUFP:              return "X86ISD::SHUFP";
14161   case X86ISD::MOVLHPS:            return "X86ISD::MOVLHPS";
14162   case X86ISD::MOVLHPD:            return "X86ISD::MOVLHPD";
14163   case X86ISD::MOVHLPS:            return "X86ISD::MOVHLPS";
14164   case X86ISD::MOVLPS:             return "X86ISD::MOVLPS";
14165   case X86ISD::MOVLPD:             return "X86ISD::MOVLPD";
14166   case X86ISD::MOVDDUP:            return "X86ISD::MOVDDUP";
14167   case X86ISD::MOVSHDUP:           return "X86ISD::MOVSHDUP";
14168   case X86ISD::MOVSLDUP:           return "X86ISD::MOVSLDUP";
14169   case X86ISD::MOVSD:              return "X86ISD::MOVSD";
14170   case X86ISD::MOVSS:              return "X86ISD::MOVSS";
14171   case X86ISD::UNPCKL:             return "X86ISD::UNPCKL";
14172   case X86ISD::UNPCKH:             return "X86ISD::UNPCKH";
14173   case X86ISD::VBROADCAST:         return "X86ISD::VBROADCAST";
14174   case X86ISD::VBROADCASTM:        return "X86ISD::VBROADCASTM";
14175   case X86ISD::VPERMILP:           return "X86ISD::VPERMILP";
14176   case X86ISD::VPERM2X128:         return "X86ISD::VPERM2X128";
14177   case X86ISD::VPERMV:             return "X86ISD::VPERMV";
14178   case X86ISD::VPERMV3:            return "X86ISD::VPERMV3";
14179   case X86ISD::VPERMIV3:           return "X86ISD::VPERMIV3";
14180   case X86ISD::VPERMI:             return "X86ISD::VPERMI";
14181   case X86ISD::PMULUDQ:            return "X86ISD::PMULUDQ";
14182   case X86ISD::VASTART_SAVE_XMM_REGS: return "X86ISD::VASTART_SAVE_XMM_REGS";
14183   case X86ISD::VAARG_64:           return "X86ISD::VAARG_64";
14184   case X86ISD::WIN_ALLOCA:         return "X86ISD::WIN_ALLOCA";
14185   case X86ISD::MEMBARRIER:         return "X86ISD::MEMBARRIER";
14186   case X86ISD::SEG_ALLOCA:         return "X86ISD::SEG_ALLOCA";
14187   case X86ISD::WIN_FTOL:           return "X86ISD::WIN_FTOL";
14188   case X86ISD::SAHF:               return "X86ISD::SAHF";
14189   case X86ISD::RDRAND:             return "X86ISD::RDRAND";
14190   case X86ISD::RDSEED:             return "X86ISD::RDSEED";
14191   case X86ISD::FMADD:              return "X86ISD::FMADD";
14192   case X86ISD::FMSUB:              return "X86ISD::FMSUB";
14193   case X86ISD::FNMADD:             return "X86ISD::FNMADD";
14194   case X86ISD::FNMSUB:             return "X86ISD::FNMSUB";
14195   case X86ISD::FMADDSUB:           return "X86ISD::FMADDSUB";
14196   case X86ISD::FMSUBADD:           return "X86ISD::FMSUBADD";
14197   case X86ISD::PCMPESTRI:          return "X86ISD::PCMPESTRI";
14198   case X86ISD::PCMPISTRI:          return "X86ISD::PCMPISTRI";
14199   case X86ISD::XTEST:              return "X86ISD::XTEST";
14200   }
14201 }
14202
14203 // isLegalAddressingMode - Return true if the addressing mode represented
14204 // by AM is legal for this target, for a load/store of the specified type.
14205 bool X86TargetLowering::isLegalAddressingMode(const AddrMode &AM,
14206                                               Type *Ty) const {
14207   // X86 supports extremely general addressing modes.
14208   CodeModel::Model M = getTargetMachine().getCodeModel();
14209   Reloc::Model R = getTargetMachine().getRelocationModel();
14210
14211   // X86 allows a sign-extended 32-bit immediate field as a displacement.
14212   if (!X86::isOffsetSuitableForCodeModel(AM.BaseOffs, M, AM.BaseGV != NULL))
14213     return false;
14214
14215   if (AM.BaseGV) {
14216     unsigned GVFlags =
14217       Subtarget->ClassifyGlobalReference(AM.BaseGV, getTargetMachine());
14218
14219     // If a reference to this global requires an extra load, we can't fold it.
14220     if (isGlobalStubReference(GVFlags))
14221       return false;
14222
14223     // If BaseGV requires a register for the PIC base, we cannot also have a
14224     // BaseReg specified.
14225     if (AM.HasBaseReg && isGlobalRelativeToPICBase(GVFlags))
14226       return false;
14227
14228     // If lower 4G is not available, then we must use rip-relative addressing.
14229     if ((M != CodeModel::Small || R != Reloc::Static) &&
14230         Subtarget->is64Bit() && (AM.BaseOffs || AM.Scale > 1))
14231       return false;
14232   }
14233
14234   switch (AM.Scale) {
14235   case 0:
14236   case 1:
14237   case 2:
14238   case 4:
14239   case 8:
14240     // These scales always work.
14241     break;
14242   case 3:
14243   case 5:
14244   case 9:
14245     // These scales are formed with basereg+scalereg.  Only accept if there is
14246     // no basereg yet.
14247     if (AM.HasBaseReg)
14248       return false;
14249     break;
14250   default:  // Other stuff never works.
14251     return false;
14252   }
14253
14254   return true;
14255 }
14256
14257 bool X86TargetLowering::isVectorShiftByScalarCheap(Type *Ty) const {
14258   unsigned Bits = Ty->getScalarSizeInBits();
14259
14260   // 8-bit shifts are always expensive, but versions with a scalar amount aren't
14261   // particularly cheaper than those without.
14262   if (Bits == 8)
14263     return false;
14264
14265   // On AVX2 there are new vpsllv[dq] instructions (and other shifts), that make
14266   // variable shifts just as cheap as scalar ones.
14267   if (Subtarget->hasInt256() && (Bits == 32 || Bits == 64))
14268     return false;
14269
14270   // Otherwise, it's significantly cheaper to shift by a scalar amount than by a
14271   // fully general vector.
14272   return true;
14273 }
14274
14275 bool X86TargetLowering::isTruncateFree(Type *Ty1, Type *Ty2) const {
14276   if (!Ty1->isIntegerTy() || !Ty2->isIntegerTy())
14277     return false;
14278   unsigned NumBits1 = Ty1->getPrimitiveSizeInBits();
14279   unsigned NumBits2 = Ty2->getPrimitiveSizeInBits();
14280   return NumBits1 > NumBits2;
14281 }
14282
14283 bool X86TargetLowering::allowTruncateForTailCall(Type *Ty1, Type *Ty2) const {
14284   if (!Ty1->isIntegerTy() || !Ty2->isIntegerTy())
14285     return false;
14286
14287   if (!isTypeLegal(EVT::getEVT(Ty1)))
14288     return false;
14289
14290   assert(Ty1->getPrimitiveSizeInBits() <= 64 && "i128 is probably not a noop");
14291
14292   // Assuming the caller doesn't have a zeroext or signext return parameter,
14293   // truncation all the way down to i1 is valid.
14294   return true;
14295 }
14296
14297 bool X86TargetLowering::isLegalICmpImmediate(int64_t Imm) const {
14298   return isInt<32>(Imm);
14299 }
14300
14301 bool X86TargetLowering::isLegalAddImmediate(int64_t Imm) const {
14302   // Can also use sub to handle negated immediates.
14303   return isInt<32>(Imm);
14304 }
14305
14306 bool X86TargetLowering::isTruncateFree(EVT VT1, EVT VT2) const {
14307   if (!VT1.isInteger() || !VT2.isInteger())
14308     return false;
14309   unsigned NumBits1 = VT1.getSizeInBits();
14310   unsigned NumBits2 = VT2.getSizeInBits();
14311   return NumBits1 > NumBits2;
14312 }
14313
14314 bool X86TargetLowering::isZExtFree(Type *Ty1, Type *Ty2) const {
14315   // x86-64 implicitly zero-extends 32-bit results in 64-bit registers.
14316   return Ty1->isIntegerTy(32) && Ty2->isIntegerTy(64) && Subtarget->is64Bit();
14317 }
14318
14319 bool X86TargetLowering::isZExtFree(EVT VT1, EVT VT2) const {
14320   // x86-64 implicitly zero-extends 32-bit results in 64-bit registers.
14321   return VT1 == MVT::i32 && VT2 == MVT::i64 && Subtarget->is64Bit();
14322 }
14323
14324 bool X86TargetLowering::isZExtFree(SDValue Val, EVT VT2) const {
14325   EVT VT1 = Val.getValueType();
14326   if (isZExtFree(VT1, VT2))
14327     return true;
14328
14329   if (Val.getOpcode() != ISD::LOAD)
14330     return false;
14331
14332   if (!VT1.isSimple() || !VT1.isInteger() ||
14333       !VT2.isSimple() || !VT2.isInteger())
14334     return false;
14335
14336   switch (VT1.getSimpleVT().SimpleTy) {
14337   default: break;
14338   case MVT::i8:
14339   case MVT::i16:
14340   case MVT::i32:
14341     // X86 has 8, 16, and 32-bit zero-extending loads.
14342     return true;
14343   }
14344
14345   return false;
14346 }
14347
14348 bool
14349 X86TargetLowering::isFMAFasterThanFMulAndFAdd(EVT VT) const {
14350   if (!(Subtarget->hasFMA() || Subtarget->hasFMA4()))
14351     return false;
14352
14353   VT = VT.getScalarType();
14354
14355   if (!VT.isSimple())
14356     return false;
14357
14358   switch (VT.getSimpleVT().SimpleTy) {
14359   case MVT::f32:
14360   case MVT::f64:
14361     return true;
14362   default:
14363     break;
14364   }
14365
14366   return false;
14367 }
14368
14369 bool X86TargetLowering::isNarrowingProfitable(EVT VT1, EVT VT2) const {
14370   // i16 instructions are longer (0x66 prefix) and potentially slower.
14371   return !(VT1 == MVT::i32 && VT2 == MVT::i16);
14372 }
14373
14374 /// isShuffleMaskLegal - Targets can use this to indicate that they only
14375 /// support *some* VECTOR_SHUFFLE operations, those with specific masks.
14376 /// By default, if a target supports the VECTOR_SHUFFLE node, all mask values
14377 /// are assumed to be legal.
14378 bool
14379 X86TargetLowering::isShuffleMaskLegal(const SmallVectorImpl<int> &M,
14380                                       EVT VT) const {
14381   if (!VT.isSimple())
14382     return false;
14383
14384   MVT SVT = VT.getSimpleVT();
14385
14386   // Very little shuffling can be done for 64-bit vectors right now.
14387   if (VT.getSizeInBits() == 64)
14388     return false;
14389
14390   // FIXME: pshufb, blends, shifts.
14391   return (SVT.getVectorNumElements() == 2 ||
14392           ShuffleVectorSDNode::isSplatMask(&M[0], VT) ||
14393           isMOVLMask(M, SVT) ||
14394           isSHUFPMask(M, SVT) ||
14395           isPSHUFDMask(M, SVT) ||
14396           isPSHUFHWMask(M, SVT, Subtarget->hasInt256()) ||
14397           isPSHUFLWMask(M, SVT, Subtarget->hasInt256()) ||
14398           isPALIGNRMask(M, SVT, Subtarget) ||
14399           isUNPCKLMask(M, SVT, Subtarget->hasInt256()) ||
14400           isUNPCKHMask(M, SVT, Subtarget->hasInt256()) ||
14401           isUNPCKL_v_undef_Mask(M, SVT, Subtarget->hasInt256()) ||
14402           isUNPCKH_v_undef_Mask(M, SVT, Subtarget->hasInt256()));
14403 }
14404
14405 bool
14406 X86TargetLowering::isVectorClearMaskLegal(const SmallVectorImpl<int> &Mask,
14407                                           EVT VT) const {
14408   if (!VT.isSimple())
14409     return false;
14410
14411   MVT SVT = VT.getSimpleVT();
14412   unsigned NumElts = SVT.getVectorNumElements();
14413   // FIXME: This collection of masks seems suspect.
14414   if (NumElts == 2)
14415     return true;
14416   if (NumElts == 4 && SVT.is128BitVector()) {
14417     return (isMOVLMask(Mask, SVT)  ||
14418             isCommutedMOVLMask(Mask, SVT, true) ||
14419             isSHUFPMask(Mask, SVT) ||
14420             isSHUFPMask(Mask, SVT, /* Commuted */ true));
14421   }
14422   return false;
14423 }
14424
14425 //===----------------------------------------------------------------------===//
14426 //                           X86 Scheduler Hooks
14427 //===----------------------------------------------------------------------===//
14428
14429 /// Utility function to emit xbegin specifying the start of an RTM region.
14430 static MachineBasicBlock *EmitXBegin(MachineInstr *MI, MachineBasicBlock *MBB,
14431                                      const TargetInstrInfo *TII) {
14432   DebugLoc DL = MI->getDebugLoc();
14433
14434   const BasicBlock *BB = MBB->getBasicBlock();
14435   MachineFunction::iterator I = MBB;
14436   ++I;
14437
14438   // For the v = xbegin(), we generate
14439   //
14440   // thisMBB:
14441   //  xbegin sinkMBB
14442   //
14443   // mainMBB:
14444   //  eax = -1
14445   //
14446   // sinkMBB:
14447   //  v = eax
14448
14449   MachineBasicBlock *thisMBB = MBB;
14450   MachineFunction *MF = MBB->getParent();
14451   MachineBasicBlock *mainMBB = MF->CreateMachineBasicBlock(BB);
14452   MachineBasicBlock *sinkMBB = MF->CreateMachineBasicBlock(BB);
14453   MF->insert(I, mainMBB);
14454   MF->insert(I, sinkMBB);
14455
14456   // Transfer the remainder of BB and its successor edges to sinkMBB.
14457   sinkMBB->splice(sinkMBB->begin(), MBB,
14458                   std::next(MachineBasicBlock::iterator(MI)), MBB->end());
14459   sinkMBB->transferSuccessorsAndUpdatePHIs(MBB);
14460
14461   // thisMBB:
14462   //  xbegin sinkMBB
14463   //  # fallthrough to mainMBB
14464   //  # abortion to sinkMBB
14465   BuildMI(thisMBB, DL, TII->get(X86::XBEGIN_4)).addMBB(sinkMBB);
14466   thisMBB->addSuccessor(mainMBB);
14467   thisMBB->addSuccessor(sinkMBB);
14468
14469   // mainMBB:
14470   //  EAX = -1
14471   BuildMI(mainMBB, DL, TII->get(X86::MOV32ri), X86::EAX).addImm(-1);
14472   mainMBB->addSuccessor(sinkMBB);
14473
14474   // sinkMBB:
14475   // EAX is live into the sinkMBB
14476   sinkMBB->addLiveIn(X86::EAX);
14477   BuildMI(*sinkMBB, sinkMBB->begin(), DL,
14478           TII->get(TargetOpcode::COPY), MI->getOperand(0).getReg())
14479     .addReg(X86::EAX);
14480
14481   MI->eraseFromParent();
14482   return sinkMBB;
14483 }
14484
14485 // Get CMPXCHG opcode for the specified data type.
14486 static unsigned getCmpXChgOpcode(EVT VT) {
14487   switch (VT.getSimpleVT().SimpleTy) {
14488   case MVT::i8:  return X86::LCMPXCHG8;
14489   case MVT::i16: return X86::LCMPXCHG16;
14490   case MVT::i32: return X86::LCMPXCHG32;
14491   case MVT::i64: return X86::LCMPXCHG64;
14492   default:
14493     break;
14494   }
14495   llvm_unreachable("Invalid operand size!");
14496 }
14497
14498 // Get LOAD opcode for the specified data type.
14499 static unsigned getLoadOpcode(EVT VT) {
14500   switch (VT.getSimpleVT().SimpleTy) {
14501   case MVT::i8:  return X86::MOV8rm;
14502   case MVT::i16: return X86::MOV16rm;
14503   case MVT::i32: return X86::MOV32rm;
14504   case MVT::i64: return X86::MOV64rm;
14505   default:
14506     break;
14507   }
14508   llvm_unreachable("Invalid operand size!");
14509 }
14510
14511 // Get opcode of the non-atomic one from the specified atomic instruction.
14512 static unsigned getNonAtomicOpcode(unsigned Opc) {
14513   switch (Opc) {
14514   case X86::ATOMAND8:  return X86::AND8rr;
14515   case X86::ATOMAND16: return X86::AND16rr;
14516   case X86::ATOMAND32: return X86::AND32rr;
14517   case X86::ATOMAND64: return X86::AND64rr;
14518   case X86::ATOMOR8:   return X86::OR8rr;
14519   case X86::ATOMOR16:  return X86::OR16rr;
14520   case X86::ATOMOR32:  return X86::OR32rr;
14521   case X86::ATOMOR64:  return X86::OR64rr;
14522   case X86::ATOMXOR8:  return X86::XOR8rr;
14523   case X86::ATOMXOR16: return X86::XOR16rr;
14524   case X86::ATOMXOR32: return X86::XOR32rr;
14525   case X86::ATOMXOR64: return X86::XOR64rr;
14526   }
14527   llvm_unreachable("Unhandled atomic-load-op opcode!");
14528 }
14529
14530 // Get opcode of the non-atomic one from the specified atomic instruction with
14531 // extra opcode.
14532 static unsigned getNonAtomicOpcodeWithExtraOpc(unsigned Opc,
14533                                                unsigned &ExtraOpc) {
14534   switch (Opc) {
14535   case X86::ATOMNAND8:  ExtraOpc = X86::NOT8r;   return X86::AND8rr;
14536   case X86::ATOMNAND16: ExtraOpc = X86::NOT16r;  return X86::AND16rr;
14537   case X86::ATOMNAND32: ExtraOpc = X86::NOT32r;  return X86::AND32rr;
14538   case X86::ATOMNAND64: ExtraOpc = X86::NOT64r;  return X86::AND64rr;
14539   case X86::ATOMMAX8:   ExtraOpc = X86::CMP8rr;  return X86::CMOVL32rr;
14540   case X86::ATOMMAX16:  ExtraOpc = X86::CMP16rr; return X86::CMOVL16rr;
14541   case X86::ATOMMAX32:  ExtraOpc = X86::CMP32rr; return X86::CMOVL32rr;
14542   case X86::ATOMMAX64:  ExtraOpc = X86::CMP64rr; return X86::CMOVL64rr;
14543   case X86::ATOMMIN8:   ExtraOpc = X86::CMP8rr;  return X86::CMOVG32rr;
14544   case X86::ATOMMIN16:  ExtraOpc = X86::CMP16rr; return X86::CMOVG16rr;
14545   case X86::ATOMMIN32:  ExtraOpc = X86::CMP32rr; return X86::CMOVG32rr;
14546   case X86::ATOMMIN64:  ExtraOpc = X86::CMP64rr; return X86::CMOVG64rr;
14547   case X86::ATOMUMAX8:  ExtraOpc = X86::CMP8rr;  return X86::CMOVB32rr;
14548   case X86::ATOMUMAX16: ExtraOpc = X86::CMP16rr; return X86::CMOVB16rr;
14549   case X86::ATOMUMAX32: ExtraOpc = X86::CMP32rr; return X86::CMOVB32rr;
14550   case X86::ATOMUMAX64: ExtraOpc = X86::CMP64rr; return X86::CMOVB64rr;
14551   case X86::ATOMUMIN8:  ExtraOpc = X86::CMP8rr;  return X86::CMOVA32rr;
14552   case X86::ATOMUMIN16: ExtraOpc = X86::CMP16rr; return X86::CMOVA16rr;
14553   case X86::ATOMUMIN32: ExtraOpc = X86::CMP32rr; return X86::CMOVA32rr;
14554   case X86::ATOMUMIN64: ExtraOpc = X86::CMP64rr; return X86::CMOVA64rr;
14555   }
14556   llvm_unreachable("Unhandled atomic-load-op opcode!");
14557 }
14558
14559 // Get opcode of the non-atomic one from the specified atomic instruction for
14560 // 64-bit data type on 32-bit target.
14561 static unsigned getNonAtomic6432Opcode(unsigned Opc, unsigned &HiOpc) {
14562   switch (Opc) {
14563   case X86::ATOMAND6432:  HiOpc = X86::AND32rr; return X86::AND32rr;
14564   case X86::ATOMOR6432:   HiOpc = X86::OR32rr;  return X86::OR32rr;
14565   case X86::ATOMXOR6432:  HiOpc = X86::XOR32rr; return X86::XOR32rr;
14566   case X86::ATOMADD6432:  HiOpc = X86::ADC32rr; return X86::ADD32rr;
14567   case X86::ATOMSUB6432:  HiOpc = X86::SBB32rr; return X86::SUB32rr;
14568   case X86::ATOMSWAP6432: HiOpc = X86::MOV32rr; return X86::MOV32rr;
14569   case X86::ATOMMAX6432:  HiOpc = X86::SETLr;   return X86::SETLr;
14570   case X86::ATOMMIN6432:  HiOpc = X86::SETGr;   return X86::SETGr;
14571   case X86::ATOMUMAX6432: HiOpc = X86::SETBr;   return X86::SETBr;
14572   case X86::ATOMUMIN6432: HiOpc = X86::SETAr;   return X86::SETAr;
14573   }
14574   llvm_unreachable("Unhandled atomic-load-op opcode!");
14575 }
14576
14577 // Get opcode of the non-atomic one from the specified atomic instruction for
14578 // 64-bit data type on 32-bit target with extra opcode.
14579 static unsigned getNonAtomic6432OpcodeWithExtraOpc(unsigned Opc,
14580                                                    unsigned &HiOpc,
14581                                                    unsigned &ExtraOpc) {
14582   switch (Opc) {
14583   case X86::ATOMNAND6432:
14584     ExtraOpc = X86::NOT32r;
14585     HiOpc = X86::AND32rr;
14586     return X86::AND32rr;
14587   }
14588   llvm_unreachable("Unhandled atomic-load-op opcode!");
14589 }
14590
14591 // Get pseudo CMOV opcode from the specified data type.
14592 static unsigned getPseudoCMOVOpc(EVT VT) {
14593   switch (VT.getSimpleVT().SimpleTy) {
14594   case MVT::i8:  return X86::CMOV_GR8;
14595   case MVT::i16: return X86::CMOV_GR16;
14596   case MVT::i32: return X86::CMOV_GR32;
14597   default:
14598     break;
14599   }
14600   llvm_unreachable("Unknown CMOV opcode!");
14601 }
14602
14603 // EmitAtomicLoadArith - emit the code sequence for pseudo atomic instructions.
14604 // They will be translated into a spin-loop or compare-exchange loop from
14605 //
14606 //    ...
14607 //    dst = atomic-fetch-op MI.addr, MI.val
14608 //    ...
14609 //
14610 // to
14611 //
14612 //    ...
14613 //    t1 = LOAD MI.addr
14614 // loop:
14615 //    t4 = phi(t1, t3 / loop)
14616 //    t2 = OP MI.val, t4
14617 //    EAX = t4
14618 //    LCMPXCHG [MI.addr], t2, [EAX is implicitly used & defined]
14619 //    t3 = EAX
14620 //    JNE loop
14621 // sink:
14622 //    dst = t3
14623 //    ...
14624 MachineBasicBlock *
14625 X86TargetLowering::EmitAtomicLoadArith(MachineInstr *MI,
14626                                        MachineBasicBlock *MBB) const {
14627   const TargetInstrInfo *TII = getTargetMachine().getInstrInfo();
14628   DebugLoc DL = MI->getDebugLoc();
14629
14630   MachineFunction *MF = MBB->getParent();
14631   MachineRegisterInfo &MRI = MF->getRegInfo();
14632
14633   const BasicBlock *BB = MBB->getBasicBlock();
14634   MachineFunction::iterator I = MBB;
14635   ++I;
14636
14637   assert(MI->getNumOperands() <= X86::AddrNumOperands + 4 &&
14638          "Unexpected number of operands");
14639
14640   assert(MI->hasOneMemOperand() &&
14641          "Expected atomic-load-op to have one memoperand");
14642
14643   // Memory Reference
14644   MachineInstr::mmo_iterator MMOBegin = MI->memoperands_begin();
14645   MachineInstr::mmo_iterator MMOEnd = MI->memoperands_end();
14646
14647   unsigned DstReg, SrcReg;
14648   unsigned MemOpndSlot;
14649
14650   unsigned CurOp = 0;
14651
14652   DstReg = MI->getOperand(CurOp++).getReg();
14653   MemOpndSlot = CurOp;
14654   CurOp += X86::AddrNumOperands;
14655   SrcReg = MI->getOperand(CurOp++).getReg();
14656
14657   const TargetRegisterClass *RC = MRI.getRegClass(DstReg);
14658   MVT::SimpleValueType VT = *RC->vt_begin();
14659   unsigned t1 = MRI.createVirtualRegister(RC);
14660   unsigned t2 = MRI.createVirtualRegister(RC);
14661   unsigned t3 = MRI.createVirtualRegister(RC);
14662   unsigned t4 = MRI.createVirtualRegister(RC);
14663   unsigned PhyReg = getX86SubSuperRegister(X86::EAX, VT);
14664
14665   unsigned LCMPXCHGOpc = getCmpXChgOpcode(VT);
14666   unsigned LOADOpc = getLoadOpcode(VT);
14667
14668   // For the atomic load-arith operator, we generate
14669   //
14670   //  thisMBB:
14671   //    t1 = LOAD [MI.addr]
14672   //  mainMBB:
14673   //    t4 = phi(t1 / thisMBB, t3 / mainMBB)
14674   //    t1 = OP MI.val, EAX
14675   //    EAX = t4
14676   //    LCMPXCHG [MI.addr], t1, [EAX is implicitly used & defined]
14677   //    t3 = EAX
14678   //    JNE mainMBB
14679   //  sinkMBB:
14680   //    dst = t3
14681
14682   MachineBasicBlock *thisMBB = MBB;
14683   MachineBasicBlock *mainMBB = MF->CreateMachineBasicBlock(BB);
14684   MachineBasicBlock *sinkMBB = MF->CreateMachineBasicBlock(BB);
14685   MF->insert(I, mainMBB);
14686   MF->insert(I, sinkMBB);
14687
14688   MachineInstrBuilder MIB;
14689
14690   // Transfer the remainder of BB and its successor edges to sinkMBB.
14691   sinkMBB->splice(sinkMBB->begin(), MBB,
14692                   std::next(MachineBasicBlock::iterator(MI)), MBB->end());
14693   sinkMBB->transferSuccessorsAndUpdatePHIs(MBB);
14694
14695   // thisMBB:
14696   MIB = BuildMI(thisMBB, DL, TII->get(LOADOpc), t1);
14697   for (unsigned i = 0; i < X86::AddrNumOperands; ++i) {
14698     MachineOperand NewMO = MI->getOperand(MemOpndSlot + i);
14699     if (NewMO.isReg())
14700       NewMO.setIsKill(false);
14701     MIB.addOperand(NewMO);
14702   }
14703   for (MachineInstr::mmo_iterator MMOI = MMOBegin; MMOI != MMOEnd; ++MMOI) {
14704     unsigned flags = (*MMOI)->getFlags();
14705     flags = (flags & ~MachineMemOperand::MOStore) | MachineMemOperand::MOLoad;
14706     MachineMemOperand *MMO =
14707       MF->getMachineMemOperand((*MMOI)->getPointerInfo(), flags,
14708                                (*MMOI)->getSize(),
14709                                (*MMOI)->getBaseAlignment(),
14710                                (*MMOI)->getTBAAInfo(),
14711                                (*MMOI)->getRanges());
14712     MIB.addMemOperand(MMO);
14713   }
14714
14715   thisMBB->addSuccessor(mainMBB);
14716
14717   // mainMBB:
14718   MachineBasicBlock *origMainMBB = mainMBB;
14719
14720   // Add a PHI.
14721   MachineInstr *Phi = BuildMI(mainMBB, DL, TII->get(X86::PHI), t4)
14722                         .addReg(t1).addMBB(thisMBB).addReg(t3).addMBB(mainMBB);
14723
14724   unsigned Opc = MI->getOpcode();
14725   switch (Opc) {
14726   default:
14727     llvm_unreachable("Unhandled atomic-load-op opcode!");
14728   case X86::ATOMAND8:
14729   case X86::ATOMAND16:
14730   case X86::ATOMAND32:
14731   case X86::ATOMAND64:
14732   case X86::ATOMOR8:
14733   case X86::ATOMOR16:
14734   case X86::ATOMOR32:
14735   case X86::ATOMOR64:
14736   case X86::ATOMXOR8:
14737   case X86::ATOMXOR16:
14738   case X86::ATOMXOR32:
14739   case X86::ATOMXOR64: {
14740     unsigned ARITHOpc = getNonAtomicOpcode(Opc);
14741     BuildMI(mainMBB, DL, TII->get(ARITHOpc), t2).addReg(SrcReg)
14742       .addReg(t4);
14743     break;
14744   }
14745   case X86::ATOMNAND8:
14746   case X86::ATOMNAND16:
14747   case X86::ATOMNAND32:
14748   case X86::ATOMNAND64: {
14749     unsigned Tmp = MRI.createVirtualRegister(RC);
14750     unsigned NOTOpc;
14751     unsigned ANDOpc = getNonAtomicOpcodeWithExtraOpc(Opc, NOTOpc);
14752     BuildMI(mainMBB, DL, TII->get(ANDOpc), Tmp).addReg(SrcReg)
14753       .addReg(t4);
14754     BuildMI(mainMBB, DL, TII->get(NOTOpc), t2).addReg(Tmp);
14755     break;
14756   }
14757   case X86::ATOMMAX8:
14758   case X86::ATOMMAX16:
14759   case X86::ATOMMAX32:
14760   case X86::ATOMMAX64:
14761   case X86::ATOMMIN8:
14762   case X86::ATOMMIN16:
14763   case X86::ATOMMIN32:
14764   case X86::ATOMMIN64:
14765   case X86::ATOMUMAX8:
14766   case X86::ATOMUMAX16:
14767   case X86::ATOMUMAX32:
14768   case X86::ATOMUMAX64:
14769   case X86::ATOMUMIN8:
14770   case X86::ATOMUMIN16:
14771   case X86::ATOMUMIN32:
14772   case X86::ATOMUMIN64: {
14773     unsigned CMPOpc;
14774     unsigned CMOVOpc = getNonAtomicOpcodeWithExtraOpc(Opc, CMPOpc);
14775
14776     BuildMI(mainMBB, DL, TII->get(CMPOpc))
14777       .addReg(SrcReg)
14778       .addReg(t4);
14779
14780     if (Subtarget->hasCMov()) {
14781       if (VT != MVT::i8) {
14782         // Native support
14783         BuildMI(mainMBB, DL, TII->get(CMOVOpc), t2)
14784           .addReg(SrcReg)
14785           .addReg(t4);
14786       } else {
14787         // Promote i8 to i32 to use CMOV32
14788         const TargetRegisterInfo* TRI = getTargetMachine().getRegisterInfo();
14789         const TargetRegisterClass *RC32 =
14790           TRI->getSubClassWithSubReg(getRegClassFor(MVT::i32), X86::sub_8bit);
14791         unsigned SrcReg32 = MRI.createVirtualRegister(RC32);
14792         unsigned AccReg32 = MRI.createVirtualRegister(RC32);
14793         unsigned Tmp = MRI.createVirtualRegister(RC32);
14794
14795         unsigned Undef = MRI.createVirtualRegister(RC32);
14796         BuildMI(mainMBB, DL, TII->get(TargetOpcode::IMPLICIT_DEF), Undef);
14797
14798         BuildMI(mainMBB, DL, TII->get(TargetOpcode::INSERT_SUBREG), SrcReg32)
14799           .addReg(Undef)
14800           .addReg(SrcReg)
14801           .addImm(X86::sub_8bit);
14802         BuildMI(mainMBB, DL, TII->get(TargetOpcode::INSERT_SUBREG), AccReg32)
14803           .addReg(Undef)
14804           .addReg(t4)
14805           .addImm(X86::sub_8bit);
14806
14807         BuildMI(mainMBB, DL, TII->get(CMOVOpc), Tmp)
14808           .addReg(SrcReg32)
14809           .addReg(AccReg32);
14810
14811         BuildMI(mainMBB, DL, TII->get(TargetOpcode::COPY), t2)
14812           .addReg(Tmp, 0, X86::sub_8bit);
14813       }
14814     } else {
14815       // Use pseudo select and lower them.
14816       assert((VT == MVT::i8 || VT == MVT::i16 || VT == MVT::i32) &&
14817              "Invalid atomic-load-op transformation!");
14818       unsigned SelOpc = getPseudoCMOVOpc(VT);
14819       X86::CondCode CC = X86::getCondFromCMovOpc(CMOVOpc);
14820       assert(CC != X86::COND_INVALID && "Invalid atomic-load-op transformation!");
14821       MIB = BuildMI(mainMBB, DL, TII->get(SelOpc), t2)
14822               .addReg(SrcReg).addReg(t4)
14823               .addImm(CC);
14824       mainMBB = EmitLoweredSelect(MIB, mainMBB);
14825       // Replace the original PHI node as mainMBB is changed after CMOV
14826       // lowering.
14827       BuildMI(*origMainMBB, Phi, DL, TII->get(X86::PHI), t4)
14828         .addReg(t1).addMBB(thisMBB).addReg(t3).addMBB(mainMBB);
14829       Phi->eraseFromParent();
14830     }
14831     break;
14832   }
14833   }
14834
14835   // Copy PhyReg back from virtual register.
14836   BuildMI(mainMBB, DL, TII->get(TargetOpcode::COPY), PhyReg)
14837     .addReg(t4);
14838
14839   MIB = BuildMI(mainMBB, DL, TII->get(LCMPXCHGOpc));
14840   for (unsigned i = 0; i < X86::AddrNumOperands; ++i) {
14841     MachineOperand NewMO = MI->getOperand(MemOpndSlot + i);
14842     if (NewMO.isReg())
14843       NewMO.setIsKill(false);
14844     MIB.addOperand(NewMO);
14845   }
14846   MIB.addReg(t2);
14847   MIB.setMemRefs(MMOBegin, MMOEnd);
14848
14849   // Copy PhyReg back to virtual register.
14850   BuildMI(mainMBB, DL, TII->get(TargetOpcode::COPY), t3)
14851     .addReg(PhyReg);
14852
14853   BuildMI(mainMBB, DL, TII->get(X86::JNE_4)).addMBB(origMainMBB);
14854
14855   mainMBB->addSuccessor(origMainMBB);
14856   mainMBB->addSuccessor(sinkMBB);
14857
14858   // sinkMBB:
14859   BuildMI(*sinkMBB, sinkMBB->begin(), DL,
14860           TII->get(TargetOpcode::COPY), DstReg)
14861     .addReg(t3);
14862
14863   MI->eraseFromParent();
14864   return sinkMBB;
14865 }
14866
14867 // EmitAtomicLoadArith6432 - emit the code sequence for pseudo atomic
14868 // instructions. They will be translated into a spin-loop or compare-exchange
14869 // loop from
14870 //
14871 //    ...
14872 //    dst = atomic-fetch-op MI.addr, MI.val
14873 //    ...
14874 //
14875 // to
14876 //
14877 //    ...
14878 //    t1L = LOAD [MI.addr + 0]
14879 //    t1H = LOAD [MI.addr + 4]
14880 // loop:
14881 //    t4L = phi(t1L, t3L / loop)
14882 //    t4H = phi(t1H, t3H / loop)
14883 //    t2L = OP MI.val.lo, t4L
14884 //    t2H = OP MI.val.hi, t4H
14885 //    EAX = t4L
14886 //    EDX = t4H
14887 //    EBX = t2L
14888 //    ECX = t2H
14889 //    LCMPXCHG8B [MI.addr], [ECX:EBX & EDX:EAX are implicitly used and EDX:EAX is implicitly defined]
14890 //    t3L = EAX
14891 //    t3H = EDX
14892 //    JNE loop
14893 // sink:
14894 //    dstL = t3L
14895 //    dstH = t3H
14896 //    ...
14897 MachineBasicBlock *
14898 X86TargetLowering::EmitAtomicLoadArith6432(MachineInstr *MI,
14899                                            MachineBasicBlock *MBB) const {
14900   const TargetInstrInfo *TII = getTargetMachine().getInstrInfo();
14901   DebugLoc DL = MI->getDebugLoc();
14902
14903   MachineFunction *MF = MBB->getParent();
14904   MachineRegisterInfo &MRI = MF->getRegInfo();
14905
14906   const BasicBlock *BB = MBB->getBasicBlock();
14907   MachineFunction::iterator I = MBB;
14908   ++I;
14909
14910   assert(MI->getNumOperands() <= X86::AddrNumOperands + 7 &&
14911          "Unexpected number of operands");
14912
14913   assert(MI->hasOneMemOperand() &&
14914          "Expected atomic-load-op32 to have one memoperand");
14915
14916   // Memory Reference
14917   MachineInstr::mmo_iterator MMOBegin = MI->memoperands_begin();
14918   MachineInstr::mmo_iterator MMOEnd = MI->memoperands_end();
14919
14920   unsigned DstLoReg, DstHiReg;
14921   unsigned SrcLoReg, SrcHiReg;
14922   unsigned MemOpndSlot;
14923
14924   unsigned CurOp = 0;
14925
14926   DstLoReg = MI->getOperand(CurOp++).getReg();
14927   DstHiReg = MI->getOperand(CurOp++).getReg();
14928   MemOpndSlot = CurOp;
14929   CurOp += X86::AddrNumOperands;
14930   SrcLoReg = MI->getOperand(CurOp++).getReg();
14931   SrcHiReg = MI->getOperand(CurOp++).getReg();
14932
14933   const TargetRegisterClass *RC = &X86::GR32RegClass;
14934   const TargetRegisterClass *RC8 = &X86::GR8RegClass;
14935
14936   unsigned t1L = MRI.createVirtualRegister(RC);
14937   unsigned t1H = MRI.createVirtualRegister(RC);
14938   unsigned t2L = MRI.createVirtualRegister(RC);
14939   unsigned t2H = MRI.createVirtualRegister(RC);
14940   unsigned t3L = MRI.createVirtualRegister(RC);
14941   unsigned t3H = MRI.createVirtualRegister(RC);
14942   unsigned t4L = MRI.createVirtualRegister(RC);
14943   unsigned t4H = MRI.createVirtualRegister(RC);
14944
14945   unsigned LCMPXCHGOpc = X86::LCMPXCHG8B;
14946   unsigned LOADOpc = X86::MOV32rm;
14947
14948   // For the atomic load-arith operator, we generate
14949   //
14950   //  thisMBB:
14951   //    t1L = LOAD [MI.addr + 0]
14952   //    t1H = LOAD [MI.addr + 4]
14953   //  mainMBB:
14954   //    t4L = phi(t1L / thisMBB, t3L / mainMBB)
14955   //    t4H = phi(t1H / thisMBB, t3H / mainMBB)
14956   //    t2L = OP MI.val.lo, t4L
14957   //    t2H = OP MI.val.hi, t4H
14958   //    EBX = t2L
14959   //    ECX = t2H
14960   //    LCMPXCHG8B [MI.addr], [ECX:EBX & EDX:EAX are implicitly used and EDX:EAX is implicitly defined]
14961   //    t3L = EAX
14962   //    t3H = EDX
14963   //    JNE loop
14964   //  sinkMBB:
14965   //    dstL = t3L
14966   //    dstH = t3H
14967
14968   MachineBasicBlock *thisMBB = MBB;
14969   MachineBasicBlock *mainMBB = MF->CreateMachineBasicBlock(BB);
14970   MachineBasicBlock *sinkMBB = MF->CreateMachineBasicBlock(BB);
14971   MF->insert(I, mainMBB);
14972   MF->insert(I, sinkMBB);
14973
14974   MachineInstrBuilder MIB;
14975
14976   // Transfer the remainder of BB and its successor edges to sinkMBB.
14977   sinkMBB->splice(sinkMBB->begin(), MBB,
14978                   std::next(MachineBasicBlock::iterator(MI)), MBB->end());
14979   sinkMBB->transferSuccessorsAndUpdatePHIs(MBB);
14980
14981   // thisMBB:
14982   // Lo
14983   MIB = BuildMI(thisMBB, DL, TII->get(LOADOpc), t1L);
14984   for (unsigned i = 0; i < X86::AddrNumOperands; ++i) {
14985     MachineOperand NewMO = MI->getOperand(MemOpndSlot + i);
14986     if (NewMO.isReg())
14987       NewMO.setIsKill(false);
14988     MIB.addOperand(NewMO);
14989   }
14990   for (MachineInstr::mmo_iterator MMOI = MMOBegin; MMOI != MMOEnd; ++MMOI) {
14991     unsigned flags = (*MMOI)->getFlags();
14992     flags = (flags & ~MachineMemOperand::MOStore) | MachineMemOperand::MOLoad;
14993     MachineMemOperand *MMO =
14994       MF->getMachineMemOperand((*MMOI)->getPointerInfo(), flags,
14995                                (*MMOI)->getSize(),
14996                                (*MMOI)->getBaseAlignment(),
14997                                (*MMOI)->getTBAAInfo(),
14998                                (*MMOI)->getRanges());
14999     MIB.addMemOperand(MMO);
15000   };
15001   MachineInstr *LowMI = MIB;
15002
15003   // Hi
15004   MIB = BuildMI(thisMBB, DL, TII->get(LOADOpc), t1H);
15005   for (unsigned i = 0; i < X86::AddrNumOperands; ++i) {
15006     if (i == X86::AddrDisp) {
15007       MIB.addDisp(MI->getOperand(MemOpndSlot + i), 4); // 4 == sizeof(i32)
15008     } else {
15009       MachineOperand NewMO = MI->getOperand(MemOpndSlot + i);
15010       if (NewMO.isReg())
15011         NewMO.setIsKill(false);
15012       MIB.addOperand(NewMO);
15013     }
15014   }
15015   MIB.setMemRefs(LowMI->memoperands_begin(), LowMI->memoperands_end());
15016
15017   thisMBB->addSuccessor(mainMBB);
15018
15019   // mainMBB:
15020   MachineBasicBlock *origMainMBB = mainMBB;
15021
15022   // Add PHIs.
15023   MachineInstr *PhiL = BuildMI(mainMBB, DL, TII->get(X86::PHI), t4L)
15024                         .addReg(t1L).addMBB(thisMBB).addReg(t3L).addMBB(mainMBB);
15025   MachineInstr *PhiH = BuildMI(mainMBB, DL, TII->get(X86::PHI), t4H)
15026                         .addReg(t1H).addMBB(thisMBB).addReg(t3H).addMBB(mainMBB);
15027
15028   unsigned Opc = MI->getOpcode();
15029   switch (Opc) {
15030   default:
15031     llvm_unreachable("Unhandled atomic-load-op6432 opcode!");
15032   case X86::ATOMAND6432:
15033   case X86::ATOMOR6432:
15034   case X86::ATOMXOR6432:
15035   case X86::ATOMADD6432:
15036   case X86::ATOMSUB6432: {
15037     unsigned HiOpc;
15038     unsigned LoOpc = getNonAtomic6432Opcode(Opc, HiOpc);
15039     BuildMI(mainMBB, DL, TII->get(LoOpc), t2L).addReg(t4L)
15040       .addReg(SrcLoReg);
15041     BuildMI(mainMBB, DL, TII->get(HiOpc), t2H).addReg(t4H)
15042       .addReg(SrcHiReg);
15043     break;
15044   }
15045   case X86::ATOMNAND6432: {
15046     unsigned HiOpc, NOTOpc;
15047     unsigned LoOpc = getNonAtomic6432OpcodeWithExtraOpc(Opc, HiOpc, NOTOpc);
15048     unsigned TmpL = MRI.createVirtualRegister(RC);
15049     unsigned TmpH = MRI.createVirtualRegister(RC);
15050     BuildMI(mainMBB, DL, TII->get(LoOpc), TmpL).addReg(SrcLoReg)
15051       .addReg(t4L);
15052     BuildMI(mainMBB, DL, TII->get(HiOpc), TmpH).addReg(SrcHiReg)
15053       .addReg(t4H);
15054     BuildMI(mainMBB, DL, TII->get(NOTOpc), t2L).addReg(TmpL);
15055     BuildMI(mainMBB, DL, TII->get(NOTOpc), t2H).addReg(TmpH);
15056     break;
15057   }
15058   case X86::ATOMMAX6432:
15059   case X86::ATOMMIN6432:
15060   case X86::ATOMUMAX6432:
15061   case X86::ATOMUMIN6432: {
15062     unsigned HiOpc;
15063     unsigned LoOpc = getNonAtomic6432Opcode(Opc, HiOpc);
15064     unsigned cL = MRI.createVirtualRegister(RC8);
15065     unsigned cH = MRI.createVirtualRegister(RC8);
15066     unsigned cL32 = MRI.createVirtualRegister(RC);
15067     unsigned cH32 = MRI.createVirtualRegister(RC);
15068     unsigned cc = MRI.createVirtualRegister(RC);
15069     // cl := cmp src_lo, lo
15070     BuildMI(mainMBB, DL, TII->get(X86::CMP32rr))
15071       .addReg(SrcLoReg).addReg(t4L);
15072     BuildMI(mainMBB, DL, TII->get(LoOpc), cL);
15073     BuildMI(mainMBB, DL, TII->get(X86::MOVZX32rr8), cL32).addReg(cL);
15074     // ch := cmp src_hi, hi
15075     BuildMI(mainMBB, DL, TII->get(X86::CMP32rr))
15076       .addReg(SrcHiReg).addReg(t4H);
15077     BuildMI(mainMBB, DL, TII->get(HiOpc), cH);
15078     BuildMI(mainMBB, DL, TII->get(X86::MOVZX32rr8), cH32).addReg(cH);
15079     // cc := if (src_hi == hi) ? cl : ch;
15080     if (Subtarget->hasCMov()) {
15081       BuildMI(mainMBB, DL, TII->get(X86::CMOVE32rr), cc)
15082         .addReg(cH32).addReg(cL32);
15083     } else {
15084       MIB = BuildMI(mainMBB, DL, TII->get(X86::CMOV_GR32), cc)
15085               .addReg(cH32).addReg(cL32)
15086               .addImm(X86::COND_E);
15087       mainMBB = EmitLoweredSelect(MIB, mainMBB);
15088     }
15089     BuildMI(mainMBB, DL, TII->get(X86::TEST32rr)).addReg(cc).addReg(cc);
15090     if (Subtarget->hasCMov()) {
15091       BuildMI(mainMBB, DL, TII->get(X86::CMOVNE32rr), t2L)
15092         .addReg(SrcLoReg).addReg(t4L);
15093       BuildMI(mainMBB, DL, TII->get(X86::CMOVNE32rr), t2H)
15094         .addReg(SrcHiReg).addReg(t4H);
15095     } else {
15096       MIB = BuildMI(mainMBB, DL, TII->get(X86::CMOV_GR32), t2L)
15097               .addReg(SrcLoReg).addReg(t4L)
15098               .addImm(X86::COND_NE);
15099       mainMBB = EmitLoweredSelect(MIB, mainMBB);
15100       // As the lowered CMOV won't clobber EFLAGS, we could reuse it for the
15101       // 2nd CMOV lowering.
15102       mainMBB->addLiveIn(X86::EFLAGS);
15103       MIB = BuildMI(mainMBB, DL, TII->get(X86::CMOV_GR32), t2H)
15104               .addReg(SrcHiReg).addReg(t4H)
15105               .addImm(X86::COND_NE);
15106       mainMBB = EmitLoweredSelect(MIB, mainMBB);
15107       // Replace the original PHI node as mainMBB is changed after CMOV
15108       // lowering.
15109       BuildMI(*origMainMBB, PhiL, DL, TII->get(X86::PHI), t4L)
15110         .addReg(t1L).addMBB(thisMBB).addReg(t3L).addMBB(mainMBB);
15111       BuildMI(*origMainMBB, PhiH, DL, TII->get(X86::PHI), t4H)
15112         .addReg(t1H).addMBB(thisMBB).addReg(t3H).addMBB(mainMBB);
15113       PhiL->eraseFromParent();
15114       PhiH->eraseFromParent();
15115     }
15116     break;
15117   }
15118   case X86::ATOMSWAP6432: {
15119     unsigned HiOpc;
15120     unsigned LoOpc = getNonAtomic6432Opcode(Opc, HiOpc);
15121     BuildMI(mainMBB, DL, TII->get(LoOpc), t2L).addReg(SrcLoReg);
15122     BuildMI(mainMBB, DL, TII->get(HiOpc), t2H).addReg(SrcHiReg);
15123     break;
15124   }
15125   }
15126
15127   // Copy EDX:EAX back from HiReg:LoReg
15128   BuildMI(mainMBB, DL, TII->get(TargetOpcode::COPY), X86::EAX).addReg(t4L);
15129   BuildMI(mainMBB, DL, TII->get(TargetOpcode::COPY), X86::EDX).addReg(t4H);
15130   // Copy ECX:EBX from t1H:t1L
15131   BuildMI(mainMBB, DL, TII->get(TargetOpcode::COPY), X86::EBX).addReg(t2L);
15132   BuildMI(mainMBB, DL, TII->get(TargetOpcode::COPY), X86::ECX).addReg(t2H);
15133
15134   MIB = BuildMI(mainMBB, DL, TII->get(LCMPXCHGOpc));
15135   for (unsigned i = 0; i < X86::AddrNumOperands; ++i) {
15136     MachineOperand NewMO = MI->getOperand(MemOpndSlot + i);
15137     if (NewMO.isReg())
15138       NewMO.setIsKill(false);
15139     MIB.addOperand(NewMO);
15140   }
15141   MIB.setMemRefs(MMOBegin, MMOEnd);
15142
15143   // Copy EDX:EAX back to t3H:t3L
15144   BuildMI(mainMBB, DL, TII->get(TargetOpcode::COPY), t3L).addReg(X86::EAX);
15145   BuildMI(mainMBB, DL, TII->get(TargetOpcode::COPY), t3H).addReg(X86::EDX);
15146
15147   BuildMI(mainMBB, DL, TII->get(X86::JNE_4)).addMBB(origMainMBB);
15148
15149   mainMBB->addSuccessor(origMainMBB);
15150   mainMBB->addSuccessor(sinkMBB);
15151
15152   // sinkMBB:
15153   BuildMI(*sinkMBB, sinkMBB->begin(), DL,
15154           TII->get(TargetOpcode::COPY), DstLoReg)
15155     .addReg(t3L);
15156   BuildMI(*sinkMBB, sinkMBB->begin(), DL,
15157           TII->get(TargetOpcode::COPY), DstHiReg)
15158     .addReg(t3H);
15159
15160   MI->eraseFromParent();
15161   return sinkMBB;
15162 }
15163
15164 // FIXME: When we get size specific XMM0 registers, i.e. XMM0_V16I8
15165 // or XMM0_V32I8 in AVX all of this code can be replaced with that
15166 // in the .td file.
15167 static MachineBasicBlock *EmitPCMPSTRM(MachineInstr *MI, MachineBasicBlock *BB,
15168                                        const TargetInstrInfo *TII) {
15169   unsigned Opc;
15170   switch (MI->getOpcode()) {
15171   default: llvm_unreachable("illegal opcode!");
15172   case X86::PCMPISTRM128REG:  Opc = X86::PCMPISTRM128rr;  break;
15173   case X86::VPCMPISTRM128REG: Opc = X86::VPCMPISTRM128rr; break;
15174   case X86::PCMPISTRM128MEM:  Opc = X86::PCMPISTRM128rm;  break;
15175   case X86::VPCMPISTRM128MEM: Opc = X86::VPCMPISTRM128rm; break;
15176   case X86::PCMPESTRM128REG:  Opc = X86::PCMPESTRM128rr;  break;
15177   case X86::VPCMPESTRM128REG: Opc = X86::VPCMPESTRM128rr; break;
15178   case X86::PCMPESTRM128MEM:  Opc = X86::PCMPESTRM128rm;  break;
15179   case X86::VPCMPESTRM128MEM: Opc = X86::VPCMPESTRM128rm; break;
15180   }
15181
15182   DebugLoc dl = MI->getDebugLoc();
15183   MachineInstrBuilder MIB = BuildMI(*BB, MI, dl, TII->get(Opc));
15184
15185   unsigned NumArgs = MI->getNumOperands();
15186   for (unsigned i = 1; i < NumArgs; ++i) {
15187     MachineOperand &Op = MI->getOperand(i);
15188     if (!(Op.isReg() && Op.isImplicit()))
15189       MIB.addOperand(Op);
15190   }
15191   if (MI->hasOneMemOperand())
15192     MIB->setMemRefs(MI->memoperands_begin(), MI->memoperands_end());
15193
15194   BuildMI(*BB, MI, dl,
15195     TII->get(TargetOpcode::COPY), MI->getOperand(0).getReg())
15196     .addReg(X86::XMM0);
15197
15198   MI->eraseFromParent();
15199   return BB;
15200 }
15201
15202 // FIXME: Custom handling because TableGen doesn't support multiple implicit
15203 // defs in an instruction pattern
15204 static MachineBasicBlock *EmitPCMPSTRI(MachineInstr *MI, MachineBasicBlock *BB,
15205                                        const TargetInstrInfo *TII) {
15206   unsigned Opc;
15207   switch (MI->getOpcode()) {
15208   default: llvm_unreachable("illegal opcode!");
15209   case X86::PCMPISTRIREG:  Opc = X86::PCMPISTRIrr;  break;
15210   case X86::VPCMPISTRIREG: Opc = X86::VPCMPISTRIrr; break;
15211   case X86::PCMPISTRIMEM:  Opc = X86::PCMPISTRIrm;  break;
15212   case X86::VPCMPISTRIMEM: Opc = X86::VPCMPISTRIrm; break;
15213   case X86::PCMPESTRIREG:  Opc = X86::PCMPESTRIrr;  break;
15214   case X86::VPCMPESTRIREG: Opc = X86::VPCMPESTRIrr; break;
15215   case X86::PCMPESTRIMEM:  Opc = X86::PCMPESTRIrm;  break;
15216   case X86::VPCMPESTRIMEM: Opc = X86::VPCMPESTRIrm; break;
15217   }
15218
15219   DebugLoc dl = MI->getDebugLoc();
15220   MachineInstrBuilder MIB = BuildMI(*BB, MI, dl, TII->get(Opc));
15221
15222   unsigned NumArgs = MI->getNumOperands(); // remove the results
15223   for (unsigned i = 1; i < NumArgs; ++i) {
15224     MachineOperand &Op = MI->getOperand(i);
15225     if (!(Op.isReg() && Op.isImplicit()))
15226       MIB.addOperand(Op);
15227   }
15228   if (MI->hasOneMemOperand())
15229     MIB->setMemRefs(MI->memoperands_begin(), MI->memoperands_end());
15230
15231   BuildMI(*BB, MI, dl,
15232     TII->get(TargetOpcode::COPY), MI->getOperand(0).getReg())
15233     .addReg(X86::ECX);
15234
15235   MI->eraseFromParent();
15236   return BB;
15237 }
15238
15239 static MachineBasicBlock * EmitMonitor(MachineInstr *MI, MachineBasicBlock *BB,
15240                                        const TargetInstrInfo *TII,
15241                                        const X86Subtarget* Subtarget) {
15242   DebugLoc dl = MI->getDebugLoc();
15243
15244   // Address into RAX/EAX, other two args into ECX, EDX.
15245   unsigned MemOpc = Subtarget->is64Bit() ? X86::LEA64r : X86::LEA32r;
15246   unsigned MemReg = Subtarget->is64Bit() ? X86::RAX : X86::EAX;
15247   MachineInstrBuilder MIB = BuildMI(*BB, MI, dl, TII->get(MemOpc), MemReg);
15248   for (int i = 0; i < X86::AddrNumOperands; ++i)
15249     MIB.addOperand(MI->getOperand(i));
15250
15251   unsigned ValOps = X86::AddrNumOperands;
15252   BuildMI(*BB, MI, dl, TII->get(TargetOpcode::COPY), X86::ECX)
15253     .addReg(MI->getOperand(ValOps).getReg());
15254   BuildMI(*BB, MI, dl, TII->get(TargetOpcode::COPY), X86::EDX)
15255     .addReg(MI->getOperand(ValOps+1).getReg());
15256
15257   // The instruction doesn't actually take any operands though.
15258   BuildMI(*BB, MI, dl, TII->get(X86::MONITORrrr));
15259
15260   MI->eraseFromParent(); // The pseudo is gone now.
15261   return BB;
15262 }
15263
15264 MachineBasicBlock *
15265 X86TargetLowering::EmitVAARG64WithCustomInserter(
15266                    MachineInstr *MI,
15267                    MachineBasicBlock *MBB) const {
15268   // Emit va_arg instruction on X86-64.
15269
15270   // Operands to this pseudo-instruction:
15271   // 0  ) Output        : destination address (reg)
15272   // 1-5) Input         : va_list address (addr, i64mem)
15273   // 6  ) ArgSize       : Size (in bytes) of vararg type
15274   // 7  ) ArgMode       : 0=overflow only, 1=use gp_offset, 2=use fp_offset
15275   // 8  ) Align         : Alignment of type
15276   // 9  ) EFLAGS (implicit-def)
15277
15278   assert(MI->getNumOperands() == 10 && "VAARG_64 should have 10 operands!");
15279   assert(X86::AddrNumOperands == 5 && "VAARG_64 assumes 5 address operands");
15280
15281   unsigned DestReg = MI->getOperand(0).getReg();
15282   MachineOperand &Base = MI->getOperand(1);
15283   MachineOperand &Scale = MI->getOperand(2);
15284   MachineOperand &Index = MI->getOperand(3);
15285   MachineOperand &Disp = MI->getOperand(4);
15286   MachineOperand &Segment = MI->getOperand(5);
15287   unsigned ArgSize = MI->getOperand(6).getImm();
15288   unsigned ArgMode = MI->getOperand(7).getImm();
15289   unsigned Align = MI->getOperand(8).getImm();
15290
15291   // Memory Reference
15292   assert(MI->hasOneMemOperand() && "Expected VAARG_64 to have one memoperand");
15293   MachineInstr::mmo_iterator MMOBegin = MI->memoperands_begin();
15294   MachineInstr::mmo_iterator MMOEnd = MI->memoperands_end();
15295
15296   // Machine Information
15297   const TargetInstrInfo *TII = getTargetMachine().getInstrInfo();
15298   MachineRegisterInfo &MRI = MBB->getParent()->getRegInfo();
15299   const TargetRegisterClass *AddrRegClass = getRegClassFor(MVT::i64);
15300   const TargetRegisterClass *OffsetRegClass = getRegClassFor(MVT::i32);
15301   DebugLoc DL = MI->getDebugLoc();
15302
15303   // struct va_list {
15304   //   i32   gp_offset
15305   //   i32   fp_offset
15306   //   i64   overflow_area (address)
15307   //   i64   reg_save_area (address)
15308   // }
15309   // sizeof(va_list) = 24
15310   // alignment(va_list) = 8
15311
15312   unsigned TotalNumIntRegs = 6;
15313   unsigned TotalNumXMMRegs = 8;
15314   bool UseGPOffset = (ArgMode == 1);
15315   bool UseFPOffset = (ArgMode == 2);
15316   unsigned MaxOffset = TotalNumIntRegs * 8 +
15317                        (UseFPOffset ? TotalNumXMMRegs * 16 : 0);
15318
15319   /* Align ArgSize to a multiple of 8 */
15320   unsigned ArgSizeA8 = (ArgSize + 7) & ~7;
15321   bool NeedsAlign = (Align > 8);
15322
15323   MachineBasicBlock *thisMBB = MBB;
15324   MachineBasicBlock *overflowMBB;
15325   MachineBasicBlock *offsetMBB;
15326   MachineBasicBlock *endMBB;
15327
15328   unsigned OffsetDestReg = 0;    // Argument address computed by offsetMBB
15329   unsigned OverflowDestReg = 0;  // Argument address computed by overflowMBB
15330   unsigned OffsetReg = 0;
15331
15332   if (!UseGPOffset && !UseFPOffset) {
15333     // If we only pull from the overflow region, we don't create a branch.
15334     // We don't need to alter control flow.
15335     OffsetDestReg = 0; // unused
15336     OverflowDestReg = DestReg;
15337
15338     offsetMBB = NULL;
15339     overflowMBB = thisMBB;
15340     endMBB = thisMBB;
15341   } else {
15342     // First emit code to check if gp_offset (or fp_offset) is below the bound.
15343     // If so, pull the argument from reg_save_area. (branch to offsetMBB)
15344     // If not, pull from overflow_area. (branch to overflowMBB)
15345     //
15346     //       thisMBB
15347     //         |     .
15348     //         |        .
15349     //     offsetMBB   overflowMBB
15350     //         |        .
15351     //         |     .
15352     //        endMBB
15353
15354     // Registers for the PHI in endMBB
15355     OffsetDestReg = MRI.createVirtualRegister(AddrRegClass);
15356     OverflowDestReg = MRI.createVirtualRegister(AddrRegClass);
15357
15358     const BasicBlock *LLVM_BB = MBB->getBasicBlock();
15359     MachineFunction *MF = MBB->getParent();
15360     overflowMBB = MF->CreateMachineBasicBlock(LLVM_BB);
15361     offsetMBB = MF->CreateMachineBasicBlock(LLVM_BB);
15362     endMBB = MF->CreateMachineBasicBlock(LLVM_BB);
15363
15364     MachineFunction::iterator MBBIter = MBB;
15365     ++MBBIter;
15366
15367     // Insert the new basic blocks
15368     MF->insert(MBBIter, offsetMBB);
15369     MF->insert(MBBIter, overflowMBB);
15370     MF->insert(MBBIter, endMBB);
15371
15372     // Transfer the remainder of MBB and its successor edges to endMBB.
15373     endMBB->splice(endMBB->begin(), thisMBB,
15374                    std::next(MachineBasicBlock::iterator(MI)), thisMBB->end());
15375     endMBB->transferSuccessorsAndUpdatePHIs(thisMBB);
15376
15377     // Make offsetMBB and overflowMBB successors of thisMBB
15378     thisMBB->addSuccessor(offsetMBB);
15379     thisMBB->addSuccessor(overflowMBB);
15380
15381     // endMBB is a successor of both offsetMBB and overflowMBB
15382     offsetMBB->addSuccessor(endMBB);
15383     overflowMBB->addSuccessor(endMBB);
15384
15385     // Load the offset value into a register
15386     OffsetReg = MRI.createVirtualRegister(OffsetRegClass);
15387     BuildMI(thisMBB, DL, TII->get(X86::MOV32rm), OffsetReg)
15388       .addOperand(Base)
15389       .addOperand(Scale)
15390       .addOperand(Index)
15391       .addDisp(Disp, UseFPOffset ? 4 : 0)
15392       .addOperand(Segment)
15393       .setMemRefs(MMOBegin, MMOEnd);
15394
15395     // Check if there is enough room left to pull this argument.
15396     BuildMI(thisMBB, DL, TII->get(X86::CMP32ri))
15397       .addReg(OffsetReg)
15398       .addImm(MaxOffset + 8 - ArgSizeA8);
15399
15400     // Branch to "overflowMBB" if offset >= max
15401     // Fall through to "offsetMBB" otherwise
15402     BuildMI(thisMBB, DL, TII->get(X86::GetCondBranchFromCond(X86::COND_AE)))
15403       .addMBB(overflowMBB);
15404   }
15405
15406   // In offsetMBB, emit code to use the reg_save_area.
15407   if (offsetMBB) {
15408     assert(OffsetReg != 0);
15409
15410     // Read the reg_save_area address.
15411     unsigned RegSaveReg = MRI.createVirtualRegister(AddrRegClass);
15412     BuildMI(offsetMBB, DL, TII->get(X86::MOV64rm), RegSaveReg)
15413       .addOperand(Base)
15414       .addOperand(Scale)
15415       .addOperand(Index)
15416       .addDisp(Disp, 16)
15417       .addOperand(Segment)
15418       .setMemRefs(MMOBegin, MMOEnd);
15419
15420     // Zero-extend the offset
15421     unsigned OffsetReg64 = MRI.createVirtualRegister(AddrRegClass);
15422       BuildMI(offsetMBB, DL, TII->get(X86::SUBREG_TO_REG), OffsetReg64)
15423         .addImm(0)
15424         .addReg(OffsetReg)
15425         .addImm(X86::sub_32bit);
15426
15427     // Add the offset to the reg_save_area to get the final address.
15428     BuildMI(offsetMBB, DL, TII->get(X86::ADD64rr), OffsetDestReg)
15429       .addReg(OffsetReg64)
15430       .addReg(RegSaveReg);
15431
15432     // Compute the offset for the next argument
15433     unsigned NextOffsetReg = MRI.createVirtualRegister(OffsetRegClass);
15434     BuildMI(offsetMBB, DL, TII->get(X86::ADD32ri), NextOffsetReg)
15435       .addReg(OffsetReg)
15436       .addImm(UseFPOffset ? 16 : 8);
15437
15438     // Store it back into the va_list.
15439     BuildMI(offsetMBB, DL, TII->get(X86::MOV32mr))
15440       .addOperand(Base)
15441       .addOperand(Scale)
15442       .addOperand(Index)
15443       .addDisp(Disp, UseFPOffset ? 4 : 0)
15444       .addOperand(Segment)
15445       .addReg(NextOffsetReg)
15446       .setMemRefs(MMOBegin, MMOEnd);
15447
15448     // Jump to endMBB
15449     BuildMI(offsetMBB, DL, TII->get(X86::JMP_4))
15450       .addMBB(endMBB);
15451   }
15452
15453   //
15454   // Emit code to use overflow area
15455   //
15456
15457   // Load the overflow_area address into a register.
15458   unsigned OverflowAddrReg = MRI.createVirtualRegister(AddrRegClass);
15459   BuildMI(overflowMBB, DL, TII->get(X86::MOV64rm), OverflowAddrReg)
15460     .addOperand(Base)
15461     .addOperand(Scale)
15462     .addOperand(Index)
15463     .addDisp(Disp, 8)
15464     .addOperand(Segment)
15465     .setMemRefs(MMOBegin, MMOEnd);
15466
15467   // If we need to align it, do so. Otherwise, just copy the address
15468   // to OverflowDestReg.
15469   if (NeedsAlign) {
15470     // Align the overflow address
15471     assert((Align & (Align-1)) == 0 && "Alignment must be a power of 2");
15472     unsigned TmpReg = MRI.createVirtualRegister(AddrRegClass);
15473
15474     // aligned_addr = (addr + (align-1)) & ~(align-1)
15475     BuildMI(overflowMBB, DL, TII->get(X86::ADD64ri32), TmpReg)
15476       .addReg(OverflowAddrReg)
15477       .addImm(Align-1);
15478
15479     BuildMI(overflowMBB, DL, TII->get(X86::AND64ri32), OverflowDestReg)
15480       .addReg(TmpReg)
15481       .addImm(~(uint64_t)(Align-1));
15482   } else {
15483     BuildMI(overflowMBB, DL, TII->get(TargetOpcode::COPY), OverflowDestReg)
15484       .addReg(OverflowAddrReg);
15485   }
15486
15487   // Compute the next overflow address after this argument.
15488   // (the overflow address should be kept 8-byte aligned)
15489   unsigned NextAddrReg = MRI.createVirtualRegister(AddrRegClass);
15490   BuildMI(overflowMBB, DL, TII->get(X86::ADD64ri32), NextAddrReg)
15491     .addReg(OverflowDestReg)
15492     .addImm(ArgSizeA8);
15493
15494   // Store the new overflow address.
15495   BuildMI(overflowMBB, DL, TII->get(X86::MOV64mr))
15496     .addOperand(Base)
15497     .addOperand(Scale)
15498     .addOperand(Index)
15499     .addDisp(Disp, 8)
15500     .addOperand(Segment)
15501     .addReg(NextAddrReg)
15502     .setMemRefs(MMOBegin, MMOEnd);
15503
15504   // If we branched, emit the PHI to the front of endMBB.
15505   if (offsetMBB) {
15506     BuildMI(*endMBB, endMBB->begin(), DL,
15507             TII->get(X86::PHI), DestReg)
15508       .addReg(OffsetDestReg).addMBB(offsetMBB)
15509       .addReg(OverflowDestReg).addMBB(overflowMBB);
15510   }
15511
15512   // Erase the pseudo instruction
15513   MI->eraseFromParent();
15514
15515   return endMBB;
15516 }
15517
15518 MachineBasicBlock *
15519 X86TargetLowering::EmitVAStartSaveXMMRegsWithCustomInserter(
15520                                                  MachineInstr *MI,
15521                                                  MachineBasicBlock *MBB) const {
15522   // Emit code to save XMM registers to the stack. The ABI says that the
15523   // number of registers to save is given in %al, so it's theoretically
15524   // possible to do an indirect jump trick to avoid saving all of them,
15525   // however this code takes a simpler approach and just executes all
15526   // of the stores if %al is non-zero. It's less code, and it's probably
15527   // easier on the hardware branch predictor, and stores aren't all that
15528   // expensive anyway.
15529
15530   // Create the new basic blocks. One block contains all the XMM stores,
15531   // and one block is the final destination regardless of whether any
15532   // stores were performed.
15533   const BasicBlock *LLVM_BB = MBB->getBasicBlock();
15534   MachineFunction *F = MBB->getParent();
15535   MachineFunction::iterator MBBIter = MBB;
15536   ++MBBIter;
15537   MachineBasicBlock *XMMSaveMBB = F->CreateMachineBasicBlock(LLVM_BB);
15538   MachineBasicBlock *EndMBB = F->CreateMachineBasicBlock(LLVM_BB);
15539   F->insert(MBBIter, XMMSaveMBB);
15540   F->insert(MBBIter, EndMBB);
15541
15542   // Transfer the remainder of MBB and its successor edges to EndMBB.
15543   EndMBB->splice(EndMBB->begin(), MBB,
15544                  std::next(MachineBasicBlock::iterator(MI)), MBB->end());
15545   EndMBB->transferSuccessorsAndUpdatePHIs(MBB);
15546
15547   // The original block will now fall through to the XMM save block.
15548   MBB->addSuccessor(XMMSaveMBB);
15549   // The XMMSaveMBB will fall through to the end block.
15550   XMMSaveMBB->addSuccessor(EndMBB);
15551
15552   // Now add the instructions.
15553   const TargetInstrInfo *TII = getTargetMachine().getInstrInfo();
15554   DebugLoc DL = MI->getDebugLoc();
15555
15556   unsigned CountReg = MI->getOperand(0).getReg();
15557   int64_t RegSaveFrameIndex = MI->getOperand(1).getImm();
15558   int64_t VarArgsFPOffset = MI->getOperand(2).getImm();
15559
15560   if (!Subtarget->isTargetWin64()) {
15561     // If %al is 0, branch around the XMM save block.
15562     BuildMI(MBB, DL, TII->get(X86::TEST8rr)).addReg(CountReg).addReg(CountReg);
15563     BuildMI(MBB, DL, TII->get(X86::JE_4)).addMBB(EndMBB);
15564     MBB->addSuccessor(EndMBB);
15565   }
15566
15567   // Make sure the last operand is EFLAGS, which gets clobbered by the branch
15568   // that was just emitted, but clearly shouldn't be "saved".
15569   assert((MI->getNumOperands() <= 3 ||
15570           !MI->getOperand(MI->getNumOperands() - 1).isReg() ||
15571           MI->getOperand(MI->getNumOperands() - 1).getReg() == X86::EFLAGS)
15572          && "Expected last argument to be EFLAGS");
15573   unsigned MOVOpc = Subtarget->hasFp256() ? X86::VMOVAPSmr : X86::MOVAPSmr;
15574   // In the XMM save block, save all the XMM argument registers.
15575   for (int i = 3, e = MI->getNumOperands() - 1; i != e; ++i) {
15576     int64_t Offset = (i - 3) * 16 + VarArgsFPOffset;
15577     MachineMemOperand *MMO =
15578       F->getMachineMemOperand(
15579           MachinePointerInfo::getFixedStack(RegSaveFrameIndex, Offset),
15580         MachineMemOperand::MOStore,
15581         /*Size=*/16, /*Align=*/16);
15582     BuildMI(XMMSaveMBB, DL, TII->get(MOVOpc))
15583       .addFrameIndex(RegSaveFrameIndex)
15584       .addImm(/*Scale=*/1)
15585       .addReg(/*IndexReg=*/0)
15586       .addImm(/*Disp=*/Offset)
15587       .addReg(/*Segment=*/0)
15588       .addReg(MI->getOperand(i).getReg())
15589       .addMemOperand(MMO);
15590   }
15591
15592   MI->eraseFromParent();   // The pseudo instruction is gone now.
15593
15594   return EndMBB;
15595 }
15596
15597 // The EFLAGS operand of SelectItr might be missing a kill marker
15598 // because there were multiple uses of EFLAGS, and ISel didn't know
15599 // which to mark. Figure out whether SelectItr should have had a
15600 // kill marker, and set it if it should. Returns the correct kill
15601 // marker value.
15602 static bool checkAndUpdateEFLAGSKill(MachineBasicBlock::iterator SelectItr,
15603                                      MachineBasicBlock* BB,
15604                                      const TargetRegisterInfo* TRI) {
15605   // Scan forward through BB for a use/def of EFLAGS.
15606   MachineBasicBlock::iterator miI(std::next(SelectItr));
15607   for (MachineBasicBlock::iterator miE = BB->end(); miI != miE; ++miI) {
15608     const MachineInstr& mi = *miI;
15609     if (mi.readsRegister(X86::EFLAGS))
15610       return false;
15611     if (mi.definesRegister(X86::EFLAGS))
15612       break; // Should have kill-flag - update below.
15613   }
15614
15615   // If we hit the end of the block, check whether EFLAGS is live into a
15616   // successor.
15617   if (miI == BB->end()) {
15618     for (MachineBasicBlock::succ_iterator sItr = BB->succ_begin(),
15619                                           sEnd = BB->succ_end();
15620          sItr != sEnd; ++sItr) {
15621       MachineBasicBlock* succ = *sItr;
15622       if (succ->isLiveIn(X86::EFLAGS))
15623         return false;
15624     }
15625   }
15626
15627   // We found a def, or hit the end of the basic block and EFLAGS wasn't live
15628   // out. SelectMI should have a kill flag on EFLAGS.
15629   SelectItr->addRegisterKilled(X86::EFLAGS, TRI);
15630   return true;
15631 }
15632
15633 MachineBasicBlock *
15634 X86TargetLowering::EmitLoweredSelect(MachineInstr *MI,
15635                                      MachineBasicBlock *BB) const {
15636   const TargetInstrInfo *TII = getTargetMachine().getInstrInfo();
15637   DebugLoc DL = MI->getDebugLoc();
15638
15639   // To "insert" a SELECT_CC instruction, we actually have to insert the
15640   // diamond control-flow pattern.  The incoming instruction knows the
15641   // destination vreg to set, the condition code register to branch on, the
15642   // true/false values to select between, and a branch opcode to use.
15643   const BasicBlock *LLVM_BB = BB->getBasicBlock();
15644   MachineFunction::iterator It = BB;
15645   ++It;
15646
15647   //  thisMBB:
15648   //  ...
15649   //   TrueVal = ...
15650   //   cmpTY ccX, r1, r2
15651   //   bCC copy1MBB
15652   //   fallthrough --> copy0MBB
15653   MachineBasicBlock *thisMBB = BB;
15654   MachineFunction *F = BB->getParent();
15655   MachineBasicBlock *copy0MBB = F->CreateMachineBasicBlock(LLVM_BB);
15656   MachineBasicBlock *sinkMBB = F->CreateMachineBasicBlock(LLVM_BB);
15657   F->insert(It, copy0MBB);
15658   F->insert(It, sinkMBB);
15659
15660   // If the EFLAGS register isn't dead in the terminator, then claim that it's
15661   // live into the sink and copy blocks.
15662   const TargetRegisterInfo* TRI = getTargetMachine().getRegisterInfo();
15663   if (!MI->killsRegister(X86::EFLAGS) &&
15664       !checkAndUpdateEFLAGSKill(MI, BB, TRI)) {
15665     copy0MBB->addLiveIn(X86::EFLAGS);
15666     sinkMBB->addLiveIn(X86::EFLAGS);
15667   }
15668
15669   // Transfer the remainder of BB and its successor edges to sinkMBB.
15670   sinkMBB->splice(sinkMBB->begin(), BB,
15671                   std::next(MachineBasicBlock::iterator(MI)), BB->end());
15672   sinkMBB->transferSuccessorsAndUpdatePHIs(BB);
15673
15674   // Add the true and fallthrough blocks as its successors.
15675   BB->addSuccessor(copy0MBB);
15676   BB->addSuccessor(sinkMBB);
15677
15678   // Create the conditional branch instruction.
15679   unsigned Opc =
15680     X86::GetCondBranchFromCond((X86::CondCode)MI->getOperand(3).getImm());
15681   BuildMI(BB, DL, TII->get(Opc)).addMBB(sinkMBB);
15682
15683   //  copy0MBB:
15684   //   %FalseValue = ...
15685   //   # fallthrough to sinkMBB
15686   copy0MBB->addSuccessor(sinkMBB);
15687
15688   //  sinkMBB:
15689   //   %Result = phi [ %FalseValue, copy0MBB ], [ %TrueValue, thisMBB ]
15690   //  ...
15691   BuildMI(*sinkMBB, sinkMBB->begin(), DL,
15692           TII->get(X86::PHI), MI->getOperand(0).getReg())
15693     .addReg(MI->getOperand(1).getReg()).addMBB(copy0MBB)
15694     .addReg(MI->getOperand(2).getReg()).addMBB(thisMBB);
15695
15696   MI->eraseFromParent();   // The pseudo instruction is gone now.
15697   return sinkMBB;
15698 }
15699
15700 MachineBasicBlock *
15701 X86TargetLowering::EmitLoweredSegAlloca(MachineInstr *MI, MachineBasicBlock *BB,
15702                                         bool Is64Bit) const {
15703   const TargetInstrInfo *TII = getTargetMachine().getInstrInfo();
15704   DebugLoc DL = MI->getDebugLoc();
15705   MachineFunction *MF = BB->getParent();
15706   const BasicBlock *LLVM_BB = BB->getBasicBlock();
15707
15708   assert(getTargetMachine().Options.EnableSegmentedStacks);
15709
15710   unsigned TlsReg = Is64Bit ? X86::FS : X86::GS;
15711   unsigned TlsOffset = Is64Bit ? 0x70 : 0x30;
15712
15713   // BB:
15714   //  ... [Till the alloca]
15715   // If stacklet is not large enough, jump to mallocMBB
15716   //
15717   // bumpMBB:
15718   //  Allocate by subtracting from RSP
15719   //  Jump to continueMBB
15720   //
15721   // mallocMBB:
15722   //  Allocate by call to runtime
15723   //
15724   // continueMBB:
15725   //  ...
15726   //  [rest of original BB]
15727   //
15728
15729   MachineBasicBlock *mallocMBB = MF->CreateMachineBasicBlock(LLVM_BB);
15730   MachineBasicBlock *bumpMBB = MF->CreateMachineBasicBlock(LLVM_BB);
15731   MachineBasicBlock *continueMBB = MF->CreateMachineBasicBlock(LLVM_BB);
15732
15733   MachineRegisterInfo &MRI = MF->getRegInfo();
15734   const TargetRegisterClass *AddrRegClass =
15735     getRegClassFor(Is64Bit ? MVT::i64:MVT::i32);
15736
15737   unsigned mallocPtrVReg = MRI.createVirtualRegister(AddrRegClass),
15738     bumpSPPtrVReg = MRI.createVirtualRegister(AddrRegClass),
15739     tmpSPVReg = MRI.createVirtualRegister(AddrRegClass),
15740     SPLimitVReg = MRI.createVirtualRegister(AddrRegClass),
15741     sizeVReg = MI->getOperand(1).getReg(),
15742     physSPReg = Is64Bit ? X86::RSP : X86::ESP;
15743
15744   MachineFunction::iterator MBBIter = BB;
15745   ++MBBIter;
15746
15747   MF->insert(MBBIter, bumpMBB);
15748   MF->insert(MBBIter, mallocMBB);
15749   MF->insert(MBBIter, continueMBB);
15750
15751   continueMBB->splice(continueMBB->begin(), BB,
15752                       std::next(MachineBasicBlock::iterator(MI)), BB->end());
15753   continueMBB->transferSuccessorsAndUpdatePHIs(BB);
15754
15755   // Add code to the main basic block to check if the stack limit has been hit,
15756   // and if so, jump to mallocMBB otherwise to bumpMBB.
15757   BuildMI(BB, DL, TII->get(TargetOpcode::COPY), tmpSPVReg).addReg(physSPReg);
15758   BuildMI(BB, DL, TII->get(Is64Bit ? X86::SUB64rr:X86::SUB32rr), SPLimitVReg)
15759     .addReg(tmpSPVReg).addReg(sizeVReg);
15760   BuildMI(BB, DL, TII->get(Is64Bit ? X86::CMP64mr:X86::CMP32mr))
15761     .addReg(0).addImm(1).addReg(0).addImm(TlsOffset).addReg(TlsReg)
15762     .addReg(SPLimitVReg);
15763   BuildMI(BB, DL, TII->get(X86::JG_4)).addMBB(mallocMBB);
15764
15765   // bumpMBB simply decreases the stack pointer, since we know the current
15766   // stacklet has enough space.
15767   BuildMI(bumpMBB, DL, TII->get(TargetOpcode::COPY), physSPReg)
15768     .addReg(SPLimitVReg);
15769   BuildMI(bumpMBB, DL, TII->get(TargetOpcode::COPY), bumpSPPtrVReg)
15770     .addReg(SPLimitVReg);
15771   BuildMI(bumpMBB, DL, TII->get(X86::JMP_4)).addMBB(continueMBB);
15772
15773   // Calls into a routine in libgcc to allocate more space from the heap.
15774   const uint32_t *RegMask =
15775     getTargetMachine().getRegisterInfo()->getCallPreservedMask(CallingConv::C);
15776   if (Is64Bit) {
15777     BuildMI(mallocMBB, DL, TII->get(X86::MOV64rr), X86::RDI)
15778       .addReg(sizeVReg);
15779     BuildMI(mallocMBB, DL, TII->get(X86::CALL64pcrel32))
15780       .addExternalSymbol("__morestack_allocate_stack_space")
15781       .addRegMask(RegMask)
15782       .addReg(X86::RDI, RegState::Implicit)
15783       .addReg(X86::RAX, RegState::ImplicitDefine);
15784   } else {
15785     BuildMI(mallocMBB, DL, TII->get(X86::SUB32ri), physSPReg).addReg(physSPReg)
15786       .addImm(12);
15787     BuildMI(mallocMBB, DL, TII->get(X86::PUSH32r)).addReg(sizeVReg);
15788     BuildMI(mallocMBB, DL, TII->get(X86::CALLpcrel32))
15789       .addExternalSymbol("__morestack_allocate_stack_space")
15790       .addRegMask(RegMask)
15791       .addReg(X86::EAX, RegState::ImplicitDefine);
15792   }
15793
15794   if (!Is64Bit)
15795     BuildMI(mallocMBB, DL, TII->get(X86::ADD32ri), physSPReg).addReg(physSPReg)
15796       .addImm(16);
15797
15798   BuildMI(mallocMBB, DL, TII->get(TargetOpcode::COPY), mallocPtrVReg)
15799     .addReg(Is64Bit ? X86::RAX : X86::EAX);
15800   BuildMI(mallocMBB, DL, TII->get(X86::JMP_4)).addMBB(continueMBB);
15801
15802   // Set up the CFG correctly.
15803   BB->addSuccessor(bumpMBB);
15804   BB->addSuccessor(mallocMBB);
15805   mallocMBB->addSuccessor(continueMBB);
15806   bumpMBB->addSuccessor(continueMBB);
15807
15808   // Take care of the PHI nodes.
15809   BuildMI(*continueMBB, continueMBB->begin(), DL, TII->get(X86::PHI),
15810           MI->getOperand(0).getReg())
15811     .addReg(mallocPtrVReg).addMBB(mallocMBB)
15812     .addReg(bumpSPPtrVReg).addMBB(bumpMBB);
15813
15814   // Delete the original pseudo instruction.
15815   MI->eraseFromParent();
15816
15817   // And we're done.
15818   return continueMBB;
15819 }
15820
15821 MachineBasicBlock *
15822 X86TargetLowering::EmitLoweredWinAlloca(MachineInstr *MI,
15823                                           MachineBasicBlock *BB) const {
15824   const TargetInstrInfo *TII = getTargetMachine().getInstrInfo();
15825   DebugLoc DL = MI->getDebugLoc();
15826
15827   assert(!Subtarget->isTargetMacho());
15828
15829   // The lowering is pretty easy: we're just emitting the call to _alloca.  The
15830   // non-trivial part is impdef of ESP.
15831
15832   if (Subtarget->isTargetWin64()) {
15833     if (Subtarget->isTargetCygMing()) {
15834       // ___chkstk(Mingw64):
15835       // Clobbers R10, R11, RAX and EFLAGS.
15836       // Updates RSP.
15837       BuildMI(*BB, MI, DL, TII->get(X86::W64ALLOCA))
15838         .addExternalSymbol("___chkstk")
15839         .addReg(X86::RAX, RegState::Implicit)
15840         .addReg(X86::RSP, RegState::Implicit)
15841         .addReg(X86::RAX, RegState::Define | RegState::Implicit)
15842         .addReg(X86::RSP, RegState::Define | RegState::Implicit)
15843         .addReg(X86::EFLAGS, RegState::Define | RegState::Implicit);
15844     } else {
15845       // __chkstk(MSVCRT): does not update stack pointer.
15846       // Clobbers R10, R11 and EFLAGS.
15847       BuildMI(*BB, MI, DL, TII->get(X86::W64ALLOCA))
15848         .addExternalSymbol("__chkstk")
15849         .addReg(X86::RAX, RegState::Implicit)
15850         .addReg(X86::EFLAGS, RegState::Define | RegState::Implicit);
15851       // RAX has the offset to be subtracted from RSP.
15852       BuildMI(*BB, MI, DL, TII->get(X86::SUB64rr), X86::RSP)
15853         .addReg(X86::RSP)
15854         .addReg(X86::RAX);
15855     }
15856   } else {
15857     const char *StackProbeSymbol =
15858       Subtarget->isTargetWindows() ? "_chkstk" : "_alloca";
15859
15860     BuildMI(*BB, MI, DL, TII->get(X86::CALLpcrel32))
15861       .addExternalSymbol(StackProbeSymbol)
15862       .addReg(X86::EAX, RegState::Implicit)
15863       .addReg(X86::ESP, RegState::Implicit)
15864       .addReg(X86::EAX, RegState::Define | RegState::Implicit)
15865       .addReg(X86::ESP, RegState::Define | RegState::Implicit)
15866       .addReg(X86::EFLAGS, RegState::Define | RegState::Implicit);
15867   }
15868
15869   MI->eraseFromParent();   // The pseudo instruction is gone now.
15870   return BB;
15871 }
15872
15873 MachineBasicBlock *
15874 X86TargetLowering::EmitLoweredTLSCall(MachineInstr *MI,
15875                                       MachineBasicBlock *BB) const {
15876   // This is pretty easy.  We're taking the value that we received from
15877   // our load from the relocation, sticking it in either RDI (x86-64)
15878   // or EAX and doing an indirect call.  The return value will then
15879   // be in the normal return register.
15880   const X86InstrInfo *TII
15881     = static_cast<const X86InstrInfo*>(getTargetMachine().getInstrInfo());
15882   DebugLoc DL = MI->getDebugLoc();
15883   MachineFunction *F = BB->getParent();
15884
15885   assert(Subtarget->isTargetDarwin() && "Darwin only instr emitted?");
15886   assert(MI->getOperand(3).isGlobal() && "This should be a global");
15887
15888   // Get a register mask for the lowered call.
15889   // FIXME: The 32-bit calls have non-standard calling conventions. Use a
15890   // proper register mask.
15891   const uint32_t *RegMask =
15892     getTargetMachine().getRegisterInfo()->getCallPreservedMask(CallingConv::C);
15893   if (Subtarget->is64Bit()) {
15894     MachineInstrBuilder MIB = BuildMI(*BB, MI, DL,
15895                                       TII->get(X86::MOV64rm), X86::RDI)
15896     .addReg(X86::RIP)
15897     .addImm(0).addReg(0)
15898     .addGlobalAddress(MI->getOperand(3).getGlobal(), 0,
15899                       MI->getOperand(3).getTargetFlags())
15900     .addReg(0);
15901     MIB = BuildMI(*BB, MI, DL, TII->get(X86::CALL64m));
15902     addDirectMem(MIB, X86::RDI);
15903     MIB.addReg(X86::RAX, RegState::ImplicitDefine).addRegMask(RegMask);
15904   } else if (getTargetMachine().getRelocationModel() != Reloc::PIC_) {
15905     MachineInstrBuilder MIB = BuildMI(*BB, MI, DL,
15906                                       TII->get(X86::MOV32rm), X86::EAX)
15907     .addReg(0)
15908     .addImm(0).addReg(0)
15909     .addGlobalAddress(MI->getOperand(3).getGlobal(), 0,
15910                       MI->getOperand(3).getTargetFlags())
15911     .addReg(0);
15912     MIB = BuildMI(*BB, MI, DL, TII->get(X86::CALL32m));
15913     addDirectMem(MIB, X86::EAX);
15914     MIB.addReg(X86::EAX, RegState::ImplicitDefine).addRegMask(RegMask);
15915   } else {
15916     MachineInstrBuilder MIB = BuildMI(*BB, MI, DL,
15917                                       TII->get(X86::MOV32rm), X86::EAX)
15918     .addReg(TII->getGlobalBaseReg(F))
15919     .addImm(0).addReg(0)
15920     .addGlobalAddress(MI->getOperand(3).getGlobal(), 0,
15921                       MI->getOperand(3).getTargetFlags())
15922     .addReg(0);
15923     MIB = BuildMI(*BB, MI, DL, TII->get(X86::CALL32m));
15924     addDirectMem(MIB, X86::EAX);
15925     MIB.addReg(X86::EAX, RegState::ImplicitDefine).addRegMask(RegMask);
15926   }
15927
15928   MI->eraseFromParent(); // The pseudo instruction is gone now.
15929   return BB;
15930 }
15931
15932 MachineBasicBlock *
15933 X86TargetLowering::emitEHSjLjSetJmp(MachineInstr *MI,
15934                                     MachineBasicBlock *MBB) const {
15935   DebugLoc DL = MI->getDebugLoc();
15936   const TargetInstrInfo *TII = getTargetMachine().getInstrInfo();
15937
15938   MachineFunction *MF = MBB->getParent();
15939   MachineRegisterInfo &MRI = MF->getRegInfo();
15940
15941   const BasicBlock *BB = MBB->getBasicBlock();
15942   MachineFunction::iterator I = MBB;
15943   ++I;
15944
15945   // Memory Reference
15946   MachineInstr::mmo_iterator MMOBegin = MI->memoperands_begin();
15947   MachineInstr::mmo_iterator MMOEnd = MI->memoperands_end();
15948
15949   unsigned DstReg;
15950   unsigned MemOpndSlot = 0;
15951
15952   unsigned CurOp = 0;
15953
15954   DstReg = MI->getOperand(CurOp++).getReg();
15955   const TargetRegisterClass *RC = MRI.getRegClass(DstReg);
15956   assert(RC->hasType(MVT::i32) && "Invalid destination!");
15957   unsigned mainDstReg = MRI.createVirtualRegister(RC);
15958   unsigned restoreDstReg = MRI.createVirtualRegister(RC);
15959
15960   MemOpndSlot = CurOp;
15961
15962   MVT PVT = getPointerTy();
15963   assert((PVT == MVT::i64 || PVT == MVT::i32) &&
15964          "Invalid Pointer Size!");
15965
15966   // For v = setjmp(buf), we generate
15967   //
15968   // thisMBB:
15969   //  buf[LabelOffset] = restoreMBB
15970   //  SjLjSetup restoreMBB
15971   //
15972   // mainMBB:
15973   //  v_main = 0
15974   //
15975   // sinkMBB:
15976   //  v = phi(main, restore)
15977   //
15978   // restoreMBB:
15979   //  v_restore = 1
15980
15981   MachineBasicBlock *thisMBB = MBB;
15982   MachineBasicBlock *mainMBB = MF->CreateMachineBasicBlock(BB);
15983   MachineBasicBlock *sinkMBB = MF->CreateMachineBasicBlock(BB);
15984   MachineBasicBlock *restoreMBB = MF->CreateMachineBasicBlock(BB);
15985   MF->insert(I, mainMBB);
15986   MF->insert(I, sinkMBB);
15987   MF->push_back(restoreMBB);
15988
15989   MachineInstrBuilder MIB;
15990
15991   // Transfer the remainder of BB and its successor edges to sinkMBB.
15992   sinkMBB->splice(sinkMBB->begin(), MBB,
15993                   std::next(MachineBasicBlock::iterator(MI)), MBB->end());
15994   sinkMBB->transferSuccessorsAndUpdatePHIs(MBB);
15995
15996   // thisMBB:
15997   unsigned PtrStoreOpc = 0;
15998   unsigned LabelReg = 0;
15999   const int64_t LabelOffset = 1 * PVT.getStoreSize();
16000   Reloc::Model RM = getTargetMachine().getRelocationModel();
16001   bool UseImmLabel = (getTargetMachine().getCodeModel() == CodeModel::Small) &&
16002                      (RM == Reloc::Static || RM == Reloc::DynamicNoPIC);
16003
16004   // Prepare IP either in reg or imm.
16005   if (!UseImmLabel) {
16006     PtrStoreOpc = (PVT == MVT::i64) ? X86::MOV64mr : X86::MOV32mr;
16007     const TargetRegisterClass *PtrRC = getRegClassFor(PVT);
16008     LabelReg = MRI.createVirtualRegister(PtrRC);
16009     if (Subtarget->is64Bit()) {
16010       MIB = BuildMI(*thisMBB, MI, DL, TII->get(X86::LEA64r), LabelReg)
16011               .addReg(X86::RIP)
16012               .addImm(0)
16013               .addReg(0)
16014               .addMBB(restoreMBB)
16015               .addReg(0);
16016     } else {
16017       const X86InstrInfo *XII = static_cast<const X86InstrInfo*>(TII);
16018       MIB = BuildMI(*thisMBB, MI, DL, TII->get(X86::LEA32r), LabelReg)
16019               .addReg(XII->getGlobalBaseReg(MF))
16020               .addImm(0)
16021               .addReg(0)
16022               .addMBB(restoreMBB, Subtarget->ClassifyBlockAddressReference())
16023               .addReg(0);
16024     }
16025   } else
16026     PtrStoreOpc = (PVT == MVT::i64) ? X86::MOV64mi32 : X86::MOV32mi;
16027   // Store IP
16028   MIB = BuildMI(*thisMBB, MI, DL, TII->get(PtrStoreOpc));
16029   for (unsigned i = 0; i < X86::AddrNumOperands; ++i) {
16030     if (i == X86::AddrDisp)
16031       MIB.addDisp(MI->getOperand(MemOpndSlot + i), LabelOffset);
16032     else
16033       MIB.addOperand(MI->getOperand(MemOpndSlot + i));
16034   }
16035   if (!UseImmLabel)
16036     MIB.addReg(LabelReg);
16037   else
16038     MIB.addMBB(restoreMBB);
16039   MIB.setMemRefs(MMOBegin, MMOEnd);
16040   // Setup
16041   MIB = BuildMI(*thisMBB, MI, DL, TII->get(X86::EH_SjLj_Setup))
16042           .addMBB(restoreMBB);
16043
16044   const X86RegisterInfo *RegInfo =
16045     static_cast<const X86RegisterInfo*>(getTargetMachine().getRegisterInfo());
16046   MIB.addRegMask(RegInfo->getNoPreservedMask());
16047   thisMBB->addSuccessor(mainMBB);
16048   thisMBB->addSuccessor(restoreMBB);
16049
16050   // mainMBB:
16051   //  EAX = 0
16052   BuildMI(mainMBB, DL, TII->get(X86::MOV32r0), mainDstReg);
16053   mainMBB->addSuccessor(sinkMBB);
16054
16055   // sinkMBB:
16056   BuildMI(*sinkMBB, sinkMBB->begin(), DL,
16057           TII->get(X86::PHI), DstReg)
16058     .addReg(mainDstReg).addMBB(mainMBB)
16059     .addReg(restoreDstReg).addMBB(restoreMBB);
16060
16061   // restoreMBB:
16062   BuildMI(restoreMBB, DL, TII->get(X86::MOV32ri), restoreDstReg).addImm(1);
16063   BuildMI(restoreMBB, DL, TII->get(X86::JMP_4)).addMBB(sinkMBB);
16064   restoreMBB->addSuccessor(sinkMBB);
16065
16066   MI->eraseFromParent();
16067   return sinkMBB;
16068 }
16069
16070 MachineBasicBlock *
16071 X86TargetLowering::emitEHSjLjLongJmp(MachineInstr *MI,
16072                                      MachineBasicBlock *MBB) const {
16073   DebugLoc DL = MI->getDebugLoc();
16074   const TargetInstrInfo *TII = getTargetMachine().getInstrInfo();
16075
16076   MachineFunction *MF = MBB->getParent();
16077   MachineRegisterInfo &MRI = MF->getRegInfo();
16078
16079   // Memory Reference
16080   MachineInstr::mmo_iterator MMOBegin = MI->memoperands_begin();
16081   MachineInstr::mmo_iterator MMOEnd = MI->memoperands_end();
16082
16083   MVT PVT = getPointerTy();
16084   assert((PVT == MVT::i64 || PVT == MVT::i32) &&
16085          "Invalid Pointer Size!");
16086
16087   const TargetRegisterClass *RC =
16088     (PVT == MVT::i64) ? &X86::GR64RegClass : &X86::GR32RegClass;
16089   unsigned Tmp = MRI.createVirtualRegister(RC);
16090   // Since FP is only updated here but NOT referenced, it's treated as GPR.
16091   const X86RegisterInfo *RegInfo =
16092     static_cast<const X86RegisterInfo*>(getTargetMachine().getRegisterInfo());
16093   unsigned FP = (PVT == MVT::i64) ? X86::RBP : X86::EBP;
16094   unsigned SP = RegInfo->getStackRegister();
16095
16096   MachineInstrBuilder MIB;
16097
16098   const int64_t LabelOffset = 1 * PVT.getStoreSize();
16099   const int64_t SPOffset = 2 * PVT.getStoreSize();
16100
16101   unsigned PtrLoadOpc = (PVT == MVT::i64) ? X86::MOV64rm : X86::MOV32rm;
16102   unsigned IJmpOpc = (PVT == MVT::i64) ? X86::JMP64r : X86::JMP32r;
16103
16104   // Reload FP
16105   MIB = BuildMI(*MBB, MI, DL, TII->get(PtrLoadOpc), FP);
16106   for (unsigned i = 0; i < X86::AddrNumOperands; ++i)
16107     MIB.addOperand(MI->getOperand(i));
16108   MIB.setMemRefs(MMOBegin, MMOEnd);
16109   // Reload IP
16110   MIB = BuildMI(*MBB, MI, DL, TII->get(PtrLoadOpc), Tmp);
16111   for (unsigned i = 0; i < X86::AddrNumOperands; ++i) {
16112     if (i == X86::AddrDisp)
16113       MIB.addDisp(MI->getOperand(i), LabelOffset);
16114     else
16115       MIB.addOperand(MI->getOperand(i));
16116   }
16117   MIB.setMemRefs(MMOBegin, MMOEnd);
16118   // Reload SP
16119   MIB = BuildMI(*MBB, MI, DL, TII->get(PtrLoadOpc), SP);
16120   for (unsigned i = 0; i < X86::AddrNumOperands; ++i) {
16121     if (i == X86::AddrDisp)
16122       MIB.addDisp(MI->getOperand(i), SPOffset);
16123     else
16124       MIB.addOperand(MI->getOperand(i));
16125   }
16126   MIB.setMemRefs(MMOBegin, MMOEnd);
16127   // Jump
16128   BuildMI(*MBB, MI, DL, TII->get(IJmpOpc)).addReg(Tmp);
16129
16130   MI->eraseFromParent();
16131   return MBB;
16132 }
16133
16134 // Replace 213-type (isel default) FMA3 instructions with 231-type for
16135 // accumulator loops. Writing back to the accumulator allows the coalescer
16136 // to remove extra copies in the loop.   
16137 MachineBasicBlock *
16138 X86TargetLowering::emitFMA3Instr(MachineInstr *MI,
16139                                  MachineBasicBlock *MBB) const {
16140   MachineOperand &AddendOp = MI->getOperand(3);
16141
16142   // Bail out early if the addend isn't a register - we can't switch these.
16143   if (!AddendOp.isReg())
16144     return MBB;
16145
16146   MachineFunction &MF = *MBB->getParent();
16147   MachineRegisterInfo &MRI = MF.getRegInfo();
16148
16149   // Check whether the addend is defined by a PHI:
16150   assert(MRI.hasOneDef(AddendOp.getReg()) && "Multiple defs in SSA?");
16151   MachineInstr &AddendDef = *MRI.def_instr_begin(AddendOp.getReg());
16152   if (!AddendDef.isPHI())
16153     return MBB;
16154
16155   // Look for the following pattern:
16156   // loop:
16157   //   %addend = phi [%entry, 0], [%loop, %result]
16158   //   ...
16159   //   %result<tied1> = FMA213 %m2<tied0>, %m1, %addend
16160
16161   // Replace with:
16162   //   loop:
16163   //   %addend = phi [%entry, 0], [%loop, %result]
16164   //   ...
16165   //   %result<tied1> = FMA231 %addend<tied0>, %m1, %m2
16166
16167   for (unsigned i = 1, e = AddendDef.getNumOperands(); i < e; i += 2) {
16168     assert(AddendDef.getOperand(i).isReg());
16169     MachineOperand PHISrcOp = AddendDef.getOperand(i);
16170     MachineInstr &PHISrcInst = *MRI.def_instr_begin(PHISrcOp.getReg());
16171     if (&PHISrcInst == MI) {
16172       // Found a matching instruction.
16173       unsigned NewFMAOpc = 0;
16174       switch (MI->getOpcode()) {
16175         case X86::VFMADDPDr213r: NewFMAOpc = X86::VFMADDPDr231r; break;
16176         case X86::VFMADDPSr213r: NewFMAOpc = X86::VFMADDPSr231r; break;
16177         case X86::VFMADDSDr213r: NewFMAOpc = X86::VFMADDSDr231r; break;
16178         case X86::VFMADDSSr213r: NewFMAOpc = X86::VFMADDSSr231r; break;
16179         case X86::VFMSUBPDr213r: NewFMAOpc = X86::VFMSUBPDr231r; break;
16180         case X86::VFMSUBPSr213r: NewFMAOpc = X86::VFMSUBPSr231r; break;
16181         case X86::VFMSUBSDr213r: NewFMAOpc = X86::VFMSUBSDr231r; break;
16182         case X86::VFMSUBSSr213r: NewFMAOpc = X86::VFMSUBSSr231r; break;
16183         case X86::VFNMADDPDr213r: NewFMAOpc = X86::VFNMADDPDr231r; break;
16184         case X86::VFNMADDPSr213r: NewFMAOpc = X86::VFNMADDPSr231r; break;
16185         case X86::VFNMADDSDr213r: NewFMAOpc = X86::VFNMADDSDr231r; break;
16186         case X86::VFNMADDSSr213r: NewFMAOpc = X86::VFNMADDSSr231r; break;
16187         case X86::VFNMSUBPDr213r: NewFMAOpc = X86::VFNMSUBPDr231r; break;
16188         case X86::VFNMSUBPSr213r: NewFMAOpc = X86::VFNMSUBPSr231r; break;
16189         case X86::VFNMSUBSDr213r: NewFMAOpc = X86::VFNMSUBSDr231r; break;
16190         case X86::VFNMSUBSSr213r: NewFMAOpc = X86::VFNMSUBSSr231r; break;
16191         case X86::VFMADDPDr213rY: NewFMAOpc = X86::VFMADDPDr231rY; break;
16192         case X86::VFMADDPSr213rY: NewFMAOpc = X86::VFMADDPSr231rY; break;
16193         case X86::VFMSUBPDr213rY: NewFMAOpc = X86::VFMSUBPDr231rY; break;
16194         case X86::VFMSUBPSr213rY: NewFMAOpc = X86::VFMSUBPSr231rY; break;
16195         case X86::VFNMADDPDr213rY: NewFMAOpc = X86::VFNMADDPDr231rY; break;
16196         case X86::VFNMADDPSr213rY: NewFMAOpc = X86::VFNMADDPSr231rY; break;
16197         case X86::VFNMSUBPDr213rY: NewFMAOpc = X86::VFNMSUBPDr231rY; break;
16198         case X86::VFNMSUBPSr213rY: NewFMAOpc = X86::VFNMSUBPSr231rY; break;
16199         default: llvm_unreachable("Unrecognized FMA variant.");
16200       }
16201
16202       const TargetInstrInfo &TII = *MF.getTarget().getInstrInfo();
16203       MachineInstrBuilder MIB =
16204         BuildMI(MF, MI->getDebugLoc(), TII.get(NewFMAOpc))
16205         .addOperand(MI->getOperand(0))
16206         .addOperand(MI->getOperand(3))
16207         .addOperand(MI->getOperand(2))
16208         .addOperand(MI->getOperand(1));
16209       MBB->insert(MachineBasicBlock::iterator(MI), MIB);
16210       MI->eraseFromParent();
16211     }
16212   }
16213
16214   return MBB;
16215 }
16216
16217 MachineBasicBlock *
16218 X86TargetLowering::EmitInstrWithCustomInserter(MachineInstr *MI,
16219                                                MachineBasicBlock *BB) const {
16220   switch (MI->getOpcode()) {
16221   default: llvm_unreachable("Unexpected instr type to insert");
16222   case X86::TAILJMPd64:
16223   case X86::TAILJMPr64:
16224   case X86::TAILJMPm64:
16225     llvm_unreachable("TAILJMP64 would not be touched here.");
16226   case X86::TCRETURNdi64:
16227   case X86::TCRETURNri64:
16228   case X86::TCRETURNmi64:
16229     return BB;
16230   case X86::WIN_ALLOCA:
16231     return EmitLoweredWinAlloca(MI, BB);
16232   case X86::SEG_ALLOCA_32:
16233     return EmitLoweredSegAlloca(MI, BB, false);
16234   case X86::SEG_ALLOCA_64:
16235     return EmitLoweredSegAlloca(MI, BB, true);
16236   case X86::TLSCall_32:
16237   case X86::TLSCall_64:
16238     return EmitLoweredTLSCall(MI, BB);
16239   case X86::CMOV_GR8:
16240   case X86::CMOV_FR32:
16241   case X86::CMOV_FR64:
16242   case X86::CMOV_V4F32:
16243   case X86::CMOV_V2F64:
16244   case X86::CMOV_V2I64:
16245   case X86::CMOV_V8F32:
16246   case X86::CMOV_V4F64:
16247   case X86::CMOV_V4I64:
16248   case X86::CMOV_V16F32:
16249   case X86::CMOV_V8F64:
16250   case X86::CMOV_V8I64:
16251   case X86::CMOV_GR16:
16252   case X86::CMOV_GR32:
16253   case X86::CMOV_RFP32:
16254   case X86::CMOV_RFP64:
16255   case X86::CMOV_RFP80:
16256     return EmitLoweredSelect(MI, BB);
16257
16258   case X86::FP32_TO_INT16_IN_MEM:
16259   case X86::FP32_TO_INT32_IN_MEM:
16260   case X86::FP32_TO_INT64_IN_MEM:
16261   case X86::FP64_TO_INT16_IN_MEM:
16262   case X86::FP64_TO_INT32_IN_MEM:
16263   case X86::FP64_TO_INT64_IN_MEM:
16264   case X86::FP80_TO_INT16_IN_MEM:
16265   case X86::FP80_TO_INT32_IN_MEM:
16266   case X86::FP80_TO_INT64_IN_MEM: {
16267     const TargetInstrInfo *TII = getTargetMachine().getInstrInfo();
16268     DebugLoc DL = MI->getDebugLoc();
16269
16270     // Change the floating point control register to use "round towards zero"
16271     // mode when truncating to an integer value.
16272     MachineFunction *F = BB->getParent();
16273     int CWFrameIdx = F->getFrameInfo()->CreateStackObject(2, 2, false);
16274     addFrameReference(BuildMI(*BB, MI, DL,
16275                               TII->get(X86::FNSTCW16m)), CWFrameIdx);
16276
16277     // Load the old value of the high byte of the control word...
16278     unsigned OldCW =
16279       F->getRegInfo().createVirtualRegister(&X86::GR16RegClass);
16280     addFrameReference(BuildMI(*BB, MI, DL, TII->get(X86::MOV16rm), OldCW),
16281                       CWFrameIdx);
16282
16283     // Set the high part to be round to zero...
16284     addFrameReference(BuildMI(*BB, MI, DL, TII->get(X86::MOV16mi)), CWFrameIdx)
16285       .addImm(0xC7F);
16286
16287     // Reload the modified control word now...
16288     addFrameReference(BuildMI(*BB, MI, DL,
16289                               TII->get(X86::FLDCW16m)), CWFrameIdx);
16290
16291     // Restore the memory image of control word to original value
16292     addFrameReference(BuildMI(*BB, MI, DL, TII->get(X86::MOV16mr)), CWFrameIdx)
16293       .addReg(OldCW);
16294
16295     // Get the X86 opcode to use.
16296     unsigned Opc;
16297     switch (MI->getOpcode()) {
16298     default: llvm_unreachable("illegal opcode!");
16299     case X86::FP32_TO_INT16_IN_MEM: Opc = X86::IST_Fp16m32; break;
16300     case X86::FP32_TO_INT32_IN_MEM: Opc = X86::IST_Fp32m32; break;
16301     case X86::FP32_TO_INT64_IN_MEM: Opc = X86::IST_Fp64m32; break;
16302     case X86::FP64_TO_INT16_IN_MEM: Opc = X86::IST_Fp16m64; break;
16303     case X86::FP64_TO_INT32_IN_MEM: Opc = X86::IST_Fp32m64; break;
16304     case X86::FP64_TO_INT64_IN_MEM: Opc = X86::IST_Fp64m64; break;
16305     case X86::FP80_TO_INT16_IN_MEM: Opc = X86::IST_Fp16m80; break;
16306     case X86::FP80_TO_INT32_IN_MEM: Opc = X86::IST_Fp32m80; break;
16307     case X86::FP80_TO_INT64_IN_MEM: Opc = X86::IST_Fp64m80; break;
16308     }
16309
16310     X86AddressMode AM;
16311     MachineOperand &Op = MI->getOperand(0);
16312     if (Op.isReg()) {
16313       AM.BaseType = X86AddressMode::RegBase;
16314       AM.Base.Reg = Op.getReg();
16315     } else {
16316       AM.BaseType = X86AddressMode::FrameIndexBase;
16317       AM.Base.FrameIndex = Op.getIndex();
16318     }
16319     Op = MI->getOperand(1);
16320     if (Op.isImm())
16321       AM.Scale = Op.getImm();
16322     Op = MI->getOperand(2);
16323     if (Op.isImm())
16324       AM.IndexReg = Op.getImm();
16325     Op = MI->getOperand(3);
16326     if (Op.isGlobal()) {
16327       AM.GV = Op.getGlobal();
16328     } else {
16329       AM.Disp = Op.getImm();
16330     }
16331     addFullAddress(BuildMI(*BB, MI, DL, TII->get(Opc)), AM)
16332                       .addReg(MI->getOperand(X86::AddrNumOperands).getReg());
16333
16334     // Reload the original control word now.
16335     addFrameReference(BuildMI(*BB, MI, DL,
16336                               TII->get(X86::FLDCW16m)), CWFrameIdx);
16337
16338     MI->eraseFromParent();   // The pseudo instruction is gone now.
16339     return BB;
16340   }
16341     // String/text processing lowering.
16342   case X86::PCMPISTRM128REG:
16343   case X86::VPCMPISTRM128REG:
16344   case X86::PCMPISTRM128MEM:
16345   case X86::VPCMPISTRM128MEM:
16346   case X86::PCMPESTRM128REG:
16347   case X86::VPCMPESTRM128REG:
16348   case X86::PCMPESTRM128MEM:
16349   case X86::VPCMPESTRM128MEM:
16350     assert(Subtarget->hasSSE42() &&
16351            "Target must have SSE4.2 or AVX features enabled");
16352     return EmitPCMPSTRM(MI, BB, getTargetMachine().getInstrInfo());
16353
16354   // String/text processing lowering.
16355   case X86::PCMPISTRIREG:
16356   case X86::VPCMPISTRIREG:
16357   case X86::PCMPISTRIMEM:
16358   case X86::VPCMPISTRIMEM:
16359   case X86::PCMPESTRIREG:
16360   case X86::VPCMPESTRIREG:
16361   case X86::PCMPESTRIMEM:
16362   case X86::VPCMPESTRIMEM:
16363     assert(Subtarget->hasSSE42() &&
16364            "Target must have SSE4.2 or AVX features enabled");
16365     return EmitPCMPSTRI(MI, BB, getTargetMachine().getInstrInfo());
16366
16367   // Thread synchronization.
16368   case X86::MONITOR:
16369     return EmitMonitor(MI, BB, getTargetMachine().getInstrInfo(), Subtarget);
16370
16371   // xbegin
16372   case X86::XBEGIN:
16373     return EmitXBegin(MI, BB, getTargetMachine().getInstrInfo());
16374
16375   // Atomic Lowering.
16376   case X86::ATOMAND8:
16377   case X86::ATOMAND16:
16378   case X86::ATOMAND32:
16379   case X86::ATOMAND64:
16380     // Fall through
16381   case X86::ATOMOR8:
16382   case X86::ATOMOR16:
16383   case X86::ATOMOR32:
16384   case X86::ATOMOR64:
16385     // Fall through
16386   case X86::ATOMXOR16:
16387   case X86::ATOMXOR8:
16388   case X86::ATOMXOR32:
16389   case X86::ATOMXOR64:
16390     // Fall through
16391   case X86::ATOMNAND8:
16392   case X86::ATOMNAND16:
16393   case X86::ATOMNAND32:
16394   case X86::ATOMNAND64:
16395     // Fall through
16396   case X86::ATOMMAX8:
16397   case X86::ATOMMAX16:
16398   case X86::ATOMMAX32:
16399   case X86::ATOMMAX64:
16400     // Fall through
16401   case X86::ATOMMIN8:
16402   case X86::ATOMMIN16:
16403   case X86::ATOMMIN32:
16404   case X86::ATOMMIN64:
16405     // Fall through
16406   case X86::ATOMUMAX8:
16407   case X86::ATOMUMAX16:
16408   case X86::ATOMUMAX32:
16409   case X86::ATOMUMAX64:
16410     // Fall through
16411   case X86::ATOMUMIN8:
16412   case X86::ATOMUMIN16:
16413   case X86::ATOMUMIN32:
16414   case X86::ATOMUMIN64:
16415     return EmitAtomicLoadArith(MI, BB);
16416
16417   // This group does 64-bit operations on a 32-bit host.
16418   case X86::ATOMAND6432:
16419   case X86::ATOMOR6432:
16420   case X86::ATOMXOR6432:
16421   case X86::ATOMNAND6432:
16422   case X86::ATOMADD6432:
16423   case X86::ATOMSUB6432:
16424   case X86::ATOMMAX6432:
16425   case X86::ATOMMIN6432:
16426   case X86::ATOMUMAX6432:
16427   case X86::ATOMUMIN6432:
16428   case X86::ATOMSWAP6432:
16429     return EmitAtomicLoadArith6432(MI, BB);
16430
16431   case X86::VASTART_SAVE_XMM_REGS:
16432     return EmitVAStartSaveXMMRegsWithCustomInserter(MI, BB);
16433
16434   case X86::VAARG_64:
16435     return EmitVAARG64WithCustomInserter(MI, BB);
16436
16437   case X86::EH_SjLj_SetJmp32:
16438   case X86::EH_SjLj_SetJmp64:
16439     return emitEHSjLjSetJmp(MI, BB);
16440
16441   case X86::EH_SjLj_LongJmp32:
16442   case X86::EH_SjLj_LongJmp64:
16443     return emitEHSjLjLongJmp(MI, BB);
16444
16445   case TargetOpcode::STACKMAP:
16446   case TargetOpcode::PATCHPOINT:
16447     return emitPatchPoint(MI, BB);
16448
16449   case X86::VFMADDPDr213r:
16450   case X86::VFMADDPSr213r:
16451   case X86::VFMADDSDr213r:
16452   case X86::VFMADDSSr213r:
16453   case X86::VFMSUBPDr213r:
16454   case X86::VFMSUBPSr213r:
16455   case X86::VFMSUBSDr213r:
16456   case X86::VFMSUBSSr213r:
16457   case X86::VFNMADDPDr213r:
16458   case X86::VFNMADDPSr213r:
16459   case X86::VFNMADDSDr213r:
16460   case X86::VFNMADDSSr213r:
16461   case X86::VFNMSUBPDr213r:
16462   case X86::VFNMSUBPSr213r:
16463   case X86::VFNMSUBSDr213r:
16464   case X86::VFNMSUBSSr213r:
16465   case X86::VFMADDPDr213rY:
16466   case X86::VFMADDPSr213rY:
16467   case X86::VFMSUBPDr213rY:
16468   case X86::VFMSUBPSr213rY:
16469   case X86::VFNMADDPDr213rY:
16470   case X86::VFNMADDPSr213rY:
16471   case X86::VFNMSUBPDr213rY:
16472   case X86::VFNMSUBPSr213rY:
16473     return emitFMA3Instr(MI, BB);
16474   }
16475 }
16476
16477 //===----------------------------------------------------------------------===//
16478 //                           X86 Optimization Hooks
16479 //===----------------------------------------------------------------------===//
16480
16481 void X86TargetLowering::computeMaskedBitsForTargetNode(const SDValue Op,
16482                                                        APInt &KnownZero,
16483                                                        APInt &KnownOne,
16484                                                        const SelectionDAG &DAG,
16485                                                        unsigned Depth) const {
16486   unsigned BitWidth = KnownZero.getBitWidth();
16487   unsigned Opc = Op.getOpcode();
16488   assert((Opc >= ISD::BUILTIN_OP_END ||
16489           Opc == ISD::INTRINSIC_WO_CHAIN ||
16490           Opc == ISD::INTRINSIC_W_CHAIN ||
16491           Opc == ISD::INTRINSIC_VOID) &&
16492          "Should use MaskedValueIsZero if you don't know whether Op"
16493          " is a target node!");
16494
16495   KnownZero = KnownOne = APInt(BitWidth, 0);   // Don't know anything.
16496   switch (Opc) {
16497   default: break;
16498   case X86ISD::ADD:
16499   case X86ISD::SUB:
16500   case X86ISD::ADC:
16501   case X86ISD::SBB:
16502   case X86ISD::SMUL:
16503   case X86ISD::UMUL:
16504   case X86ISD::INC:
16505   case X86ISD::DEC:
16506   case X86ISD::OR:
16507   case X86ISD::XOR:
16508   case X86ISD::AND:
16509     // These nodes' second result is a boolean.
16510     if (Op.getResNo() == 0)
16511       break;
16512     // Fallthrough
16513   case X86ISD::SETCC:
16514     KnownZero |= APInt::getHighBitsSet(BitWidth, BitWidth - 1);
16515     break;
16516   case ISD::INTRINSIC_WO_CHAIN: {
16517     unsigned IntId = cast<ConstantSDNode>(Op.getOperand(0))->getZExtValue();
16518     unsigned NumLoBits = 0;
16519     switch (IntId) {
16520     default: break;
16521     case Intrinsic::x86_sse_movmsk_ps:
16522     case Intrinsic::x86_avx_movmsk_ps_256:
16523     case Intrinsic::x86_sse2_movmsk_pd:
16524     case Intrinsic::x86_avx_movmsk_pd_256:
16525     case Intrinsic::x86_mmx_pmovmskb:
16526     case Intrinsic::x86_sse2_pmovmskb_128:
16527     case Intrinsic::x86_avx2_pmovmskb: {
16528       // High bits of movmskp{s|d}, pmovmskb are known zero.
16529       switch (IntId) {
16530         default: llvm_unreachable("Impossible intrinsic");  // Can't reach here.
16531         case Intrinsic::x86_sse_movmsk_ps:      NumLoBits = 4; break;
16532         case Intrinsic::x86_avx_movmsk_ps_256:  NumLoBits = 8; break;
16533         case Intrinsic::x86_sse2_movmsk_pd:     NumLoBits = 2; break;
16534         case Intrinsic::x86_avx_movmsk_pd_256:  NumLoBits = 4; break;
16535         case Intrinsic::x86_mmx_pmovmskb:       NumLoBits = 8; break;
16536         case Intrinsic::x86_sse2_pmovmskb_128:  NumLoBits = 16; break;
16537         case Intrinsic::x86_avx2_pmovmskb:      NumLoBits = 32; break;
16538       }
16539       KnownZero = APInt::getHighBitsSet(BitWidth, BitWidth - NumLoBits);
16540       break;
16541     }
16542     }
16543     break;
16544   }
16545   }
16546 }
16547
16548 unsigned X86TargetLowering::ComputeNumSignBitsForTargetNode(SDValue Op,
16549                                                          unsigned Depth) const {
16550   // SETCC_CARRY sets the dest to ~0 for true or 0 for false.
16551   if (Op.getOpcode() == X86ISD::SETCC_CARRY)
16552     return Op.getValueType().getScalarType().getSizeInBits();
16553
16554   // Fallback case.
16555   return 1;
16556 }
16557
16558 /// isGAPlusOffset - Returns true (and the GlobalValue and the offset) if the
16559 /// node is a GlobalAddress + offset.
16560 bool X86TargetLowering::isGAPlusOffset(SDNode *N,
16561                                        const GlobalValue* &GA,
16562                                        int64_t &Offset) const {
16563   if (N->getOpcode() == X86ISD::Wrapper) {
16564     if (isa<GlobalAddressSDNode>(N->getOperand(0))) {
16565       GA = cast<GlobalAddressSDNode>(N->getOperand(0))->getGlobal();
16566       Offset = cast<GlobalAddressSDNode>(N->getOperand(0))->getOffset();
16567       return true;
16568     }
16569   }
16570   return TargetLowering::isGAPlusOffset(N, GA, Offset);
16571 }
16572
16573 /// isShuffleHigh128VectorInsertLow - Checks whether the shuffle node is the
16574 /// same as extracting the high 128-bit part of 256-bit vector and then
16575 /// inserting the result into the low part of a new 256-bit vector
16576 static bool isShuffleHigh128VectorInsertLow(ShuffleVectorSDNode *SVOp) {
16577   EVT VT = SVOp->getValueType(0);
16578   unsigned NumElems = VT.getVectorNumElements();
16579
16580   // vector_shuffle <4, 5, 6, 7, u, u, u, u> or <2, 3, u, u>
16581   for (unsigned i = 0, j = NumElems/2; i != NumElems/2; ++i, ++j)
16582     if (!isUndefOrEqual(SVOp->getMaskElt(i), j) ||
16583         SVOp->getMaskElt(j) >= 0)
16584       return false;
16585
16586   return true;
16587 }
16588
16589 /// isShuffleLow128VectorInsertHigh - Checks whether the shuffle node is the
16590 /// same as extracting the low 128-bit part of 256-bit vector and then
16591 /// inserting the result into the high part of a new 256-bit vector
16592 static bool isShuffleLow128VectorInsertHigh(ShuffleVectorSDNode *SVOp) {
16593   EVT VT = SVOp->getValueType(0);
16594   unsigned NumElems = VT.getVectorNumElements();
16595
16596   // vector_shuffle <u, u, u, u, 0, 1, 2, 3> or <u, u, 0, 1>
16597   for (unsigned i = NumElems/2, j = 0; i != NumElems; ++i, ++j)
16598     if (!isUndefOrEqual(SVOp->getMaskElt(i), j) ||
16599         SVOp->getMaskElt(j) >= 0)
16600       return false;
16601
16602   return true;
16603 }
16604
16605 /// PerformShuffleCombine256 - Performs shuffle combines for 256-bit vectors.
16606 static SDValue PerformShuffleCombine256(SDNode *N, SelectionDAG &DAG,
16607                                         TargetLowering::DAGCombinerInfo &DCI,
16608                                         const X86Subtarget* Subtarget) {
16609   SDLoc dl(N);
16610   ShuffleVectorSDNode *SVOp = cast<ShuffleVectorSDNode>(N);
16611   SDValue V1 = SVOp->getOperand(0);
16612   SDValue V2 = SVOp->getOperand(1);
16613   EVT VT = SVOp->getValueType(0);
16614   unsigned NumElems = VT.getVectorNumElements();
16615
16616   if (V1.getOpcode() == ISD::CONCAT_VECTORS &&
16617       V2.getOpcode() == ISD::CONCAT_VECTORS) {
16618     //
16619     //                   0,0,0,...
16620     //                      |
16621     //    V      UNDEF    BUILD_VECTOR    UNDEF
16622     //     \      /           \           /
16623     //  CONCAT_VECTOR         CONCAT_VECTOR
16624     //         \                  /
16625     //          \                /
16626     //          RESULT: V + zero extended
16627     //
16628     if (V2.getOperand(0).getOpcode() != ISD::BUILD_VECTOR ||
16629         V2.getOperand(1).getOpcode() != ISD::UNDEF ||
16630         V1.getOperand(1).getOpcode() != ISD::UNDEF)
16631       return SDValue();
16632
16633     if (!ISD::isBuildVectorAllZeros(V2.getOperand(0).getNode()))
16634       return SDValue();
16635
16636     // To match the shuffle mask, the first half of the mask should
16637     // be exactly the first vector, and all the rest a splat with the
16638     // first element of the second one.
16639     for (unsigned i = 0; i != NumElems/2; ++i)
16640       if (!isUndefOrEqual(SVOp->getMaskElt(i), i) ||
16641           !isUndefOrEqual(SVOp->getMaskElt(i+NumElems/2), NumElems))
16642         return SDValue();
16643
16644     // If V1 is coming from a vector load then just fold to a VZEXT_LOAD.
16645     if (LoadSDNode *Ld = dyn_cast<LoadSDNode>(V1.getOperand(0))) {
16646       if (Ld->hasNUsesOfValue(1, 0)) {
16647         SDVTList Tys = DAG.getVTList(MVT::v4i64, MVT::Other);
16648         SDValue Ops[] = { Ld->getChain(), Ld->getBasePtr() };
16649         SDValue ResNode =
16650           DAG.getMemIntrinsicNode(X86ISD::VZEXT_LOAD, dl, Tys, Ops,
16651                                   array_lengthof(Ops),
16652                                   Ld->getMemoryVT(),
16653                                   Ld->getPointerInfo(),
16654                                   Ld->getAlignment(),
16655                                   false/*isVolatile*/, true/*ReadMem*/,
16656                                   false/*WriteMem*/);
16657
16658         // Make sure the newly-created LOAD is in the same position as Ld in
16659         // terms of dependency. We create a TokenFactor for Ld and ResNode,
16660         // and update uses of Ld's output chain to use the TokenFactor.
16661         if (Ld->hasAnyUseOfValue(1)) {
16662           SDValue NewChain = DAG.getNode(ISD::TokenFactor, dl, MVT::Other,
16663                              SDValue(Ld, 1), SDValue(ResNode.getNode(), 1));
16664           DAG.ReplaceAllUsesOfValueWith(SDValue(Ld, 1), NewChain);
16665           DAG.UpdateNodeOperands(NewChain.getNode(), SDValue(Ld, 1),
16666                                  SDValue(ResNode.getNode(), 1));
16667         }
16668
16669         return DAG.getNode(ISD::BITCAST, dl, VT, ResNode);
16670       }
16671     }
16672
16673     // Emit a zeroed vector and insert the desired subvector on its
16674     // first half.
16675     SDValue Zeros = getZeroVector(VT, Subtarget, DAG, dl);
16676     SDValue InsV = Insert128BitVector(Zeros, V1.getOperand(0), 0, DAG, dl);
16677     return DCI.CombineTo(N, InsV);
16678   }
16679
16680   //===--------------------------------------------------------------------===//
16681   // Combine some shuffles into subvector extracts and inserts:
16682   //
16683
16684   // vector_shuffle <4, 5, 6, 7, u, u, u, u> or <2, 3, u, u>
16685   if (isShuffleHigh128VectorInsertLow(SVOp)) {
16686     SDValue V = Extract128BitVector(V1, NumElems/2, DAG, dl);
16687     SDValue InsV = Insert128BitVector(DAG.getUNDEF(VT), V, 0, DAG, dl);
16688     return DCI.CombineTo(N, InsV);
16689   }
16690
16691   // vector_shuffle <u, u, u, u, 0, 1, 2, 3> or <u, u, 0, 1>
16692   if (isShuffleLow128VectorInsertHigh(SVOp)) {
16693     SDValue V = Extract128BitVector(V1, 0, DAG, dl);
16694     SDValue InsV = Insert128BitVector(DAG.getUNDEF(VT), V, NumElems/2, DAG, dl);
16695     return DCI.CombineTo(N, InsV);
16696   }
16697
16698   return SDValue();
16699 }
16700
16701 /// PerformShuffleCombine - Performs several different shuffle combines.
16702 static SDValue PerformShuffleCombine(SDNode *N, SelectionDAG &DAG,
16703                                      TargetLowering::DAGCombinerInfo &DCI,
16704                                      const X86Subtarget *Subtarget) {
16705   SDLoc dl(N);
16706   EVT VT = N->getValueType(0);
16707
16708   // Don't create instructions with illegal types after legalize types has run.
16709   const TargetLowering &TLI = DAG.getTargetLoweringInfo();
16710   if (!DCI.isBeforeLegalize() && !TLI.isTypeLegal(VT.getVectorElementType()))
16711     return SDValue();
16712
16713   // Combine 256-bit vector shuffles. This is only profitable when in AVX mode
16714   if (Subtarget->hasFp256() && VT.is256BitVector() &&
16715       N->getOpcode() == ISD::VECTOR_SHUFFLE)
16716     return PerformShuffleCombine256(N, DAG, DCI, Subtarget);
16717
16718   // Only handle 128 wide vector from here on.
16719   if (!VT.is128BitVector())
16720     return SDValue();
16721
16722   // Combine a vector_shuffle that is equal to build_vector load1, load2, load3,
16723   // load4, <0, 1, 2, 3> into a 128-bit load if the load addresses are
16724   // consecutive, non-overlapping, and in the right order.
16725   SmallVector<SDValue, 16> Elts;
16726   for (unsigned i = 0, e = VT.getVectorNumElements(); i != e; ++i)
16727     Elts.push_back(getShuffleScalarElt(N, i, DAG, 0));
16728
16729   return EltsFromConsecutiveLoads(VT, Elts, dl, DAG, true);
16730 }
16731
16732 /// PerformTruncateCombine - Converts truncate operation to
16733 /// a sequence of vector shuffle operations.
16734 /// It is possible when we truncate 256-bit vector to 128-bit vector
16735 static SDValue PerformTruncateCombine(SDNode *N, SelectionDAG &DAG,
16736                                       TargetLowering::DAGCombinerInfo &DCI,
16737                                       const X86Subtarget *Subtarget)  {
16738   return SDValue();
16739 }
16740
16741 /// XFormVExtractWithShuffleIntoLoad - Check if a vector extract from a target
16742 /// specific shuffle of a load can be folded into a single element load.
16743 /// Similar handling for VECTOR_SHUFFLE is performed by DAGCombiner, but
16744 /// shuffles have been customed lowered so we need to handle those here.
16745 static SDValue XFormVExtractWithShuffleIntoLoad(SDNode *N, SelectionDAG &DAG,
16746                                          TargetLowering::DAGCombinerInfo &DCI) {
16747   if (DCI.isBeforeLegalizeOps())
16748     return SDValue();
16749
16750   SDValue InVec = N->getOperand(0);
16751   SDValue EltNo = N->getOperand(1);
16752
16753   if (!isa<ConstantSDNode>(EltNo))
16754     return SDValue();
16755
16756   EVT VT = InVec.getValueType();
16757
16758   bool HasShuffleIntoBitcast = false;
16759   if (InVec.getOpcode() == ISD::BITCAST) {
16760     // Don't duplicate a load with other uses.
16761     if (!InVec.hasOneUse())
16762       return SDValue();
16763     EVT BCVT = InVec.getOperand(0).getValueType();
16764     if (BCVT.getVectorNumElements() != VT.getVectorNumElements())
16765       return SDValue();
16766     InVec = InVec.getOperand(0);
16767     HasShuffleIntoBitcast = true;
16768   }
16769
16770   if (!isTargetShuffle(InVec.getOpcode()))
16771     return SDValue();
16772
16773   // Don't duplicate a load with other uses.
16774   if (!InVec.hasOneUse())
16775     return SDValue();
16776
16777   SmallVector<int, 16> ShuffleMask;
16778   bool UnaryShuffle;
16779   if (!getTargetShuffleMask(InVec.getNode(), VT.getSimpleVT(), ShuffleMask,
16780                             UnaryShuffle))
16781     return SDValue();
16782
16783   // Select the input vector, guarding against out of range extract vector.
16784   unsigned NumElems = VT.getVectorNumElements();
16785   int Elt = cast<ConstantSDNode>(EltNo)->getZExtValue();
16786   int Idx = (Elt > (int)NumElems) ? -1 : ShuffleMask[Elt];
16787   SDValue LdNode = (Idx < (int)NumElems) ? InVec.getOperand(0)
16788                                          : InVec.getOperand(1);
16789
16790   // If inputs to shuffle are the same for both ops, then allow 2 uses
16791   unsigned AllowedUses = InVec.getOperand(0) == InVec.getOperand(1) ? 2 : 1;
16792
16793   if (LdNode.getOpcode() == ISD::BITCAST) {
16794     // Don't duplicate a load with other uses.
16795     if (!LdNode.getNode()->hasNUsesOfValue(AllowedUses, 0))
16796       return SDValue();
16797
16798     AllowedUses = 1; // only allow 1 load use if we have a bitcast
16799     LdNode = LdNode.getOperand(0);
16800   }
16801
16802   if (!ISD::isNormalLoad(LdNode.getNode()))
16803     return SDValue();
16804
16805   LoadSDNode *LN0 = cast<LoadSDNode>(LdNode);
16806
16807   if (!LN0 ||!LN0->hasNUsesOfValue(AllowedUses, 0) || LN0->isVolatile())
16808     return SDValue();
16809
16810   if (HasShuffleIntoBitcast) {
16811     // If there's a bitcast before the shuffle, check if the load type and
16812     // alignment is valid.
16813     unsigned Align = LN0->getAlignment();
16814     const TargetLowering &TLI = DAG.getTargetLoweringInfo();
16815     unsigned NewAlign = TLI.getDataLayout()->
16816       getABITypeAlignment(VT.getTypeForEVT(*DAG.getContext()));
16817
16818     if (NewAlign > Align || !TLI.isOperationLegalOrCustom(ISD::LOAD, VT))
16819       return SDValue();
16820   }
16821
16822   // All checks match so transform back to vector_shuffle so that DAG combiner
16823   // can finish the job
16824   SDLoc dl(N);
16825
16826   // Create shuffle node taking into account the case that its a unary shuffle
16827   SDValue Shuffle = (UnaryShuffle) ? DAG.getUNDEF(VT) : InVec.getOperand(1);
16828   Shuffle = DAG.getVectorShuffle(InVec.getValueType(), dl,
16829                                  InVec.getOperand(0), Shuffle,
16830                                  &ShuffleMask[0]);
16831   Shuffle = DAG.getNode(ISD::BITCAST, dl, VT, Shuffle);
16832   return DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, N->getValueType(0), Shuffle,
16833                      EltNo);
16834 }
16835
16836 /// PerformEXTRACT_VECTOR_ELTCombine - Detect vector gather/scatter index
16837 /// generation and convert it from being a bunch of shuffles and extracts
16838 /// to a simple store and scalar loads to extract the elements.
16839 static SDValue PerformEXTRACT_VECTOR_ELTCombine(SDNode *N, SelectionDAG &DAG,
16840                                          TargetLowering::DAGCombinerInfo &DCI) {
16841   SDValue NewOp = XFormVExtractWithShuffleIntoLoad(N, DAG, DCI);
16842   if (NewOp.getNode())
16843     return NewOp;
16844
16845   SDValue InputVector = N->getOperand(0);
16846
16847   // Detect whether we are trying to convert from mmx to i32 and the bitcast
16848   // from mmx to v2i32 has a single usage.
16849   if (InputVector.getNode()->getOpcode() == llvm::ISD::BITCAST &&
16850       InputVector.getNode()->getOperand(0).getValueType() == MVT::x86mmx &&
16851       InputVector.hasOneUse() && N->getValueType(0) == MVT::i32)
16852     return DAG.getNode(X86ISD::MMX_MOVD2W, SDLoc(InputVector),
16853                        N->getValueType(0),
16854                        InputVector.getNode()->getOperand(0));
16855
16856   // Only operate on vectors of 4 elements, where the alternative shuffling
16857   // gets to be more expensive.
16858   if (InputVector.getValueType() != MVT::v4i32)
16859     return SDValue();
16860
16861   // Check whether every use of InputVector is an EXTRACT_VECTOR_ELT with a
16862   // single use which is a sign-extend or zero-extend, and all elements are
16863   // used.
16864   SmallVector<SDNode *, 4> Uses;
16865   unsigned ExtractedElements = 0;
16866   for (SDNode::use_iterator UI = InputVector.getNode()->use_begin(),
16867        UE = InputVector.getNode()->use_end(); UI != UE; ++UI) {
16868     if (UI.getUse().getResNo() != InputVector.getResNo())
16869       return SDValue();
16870
16871     SDNode *Extract = *UI;
16872     if (Extract->getOpcode() != ISD::EXTRACT_VECTOR_ELT)
16873       return SDValue();
16874
16875     if (Extract->getValueType(0) != MVT::i32)
16876       return SDValue();
16877     if (!Extract->hasOneUse())
16878       return SDValue();
16879     if (Extract->use_begin()->getOpcode() != ISD::SIGN_EXTEND &&
16880         Extract->use_begin()->getOpcode() != ISD::ZERO_EXTEND)
16881       return SDValue();
16882     if (!isa<ConstantSDNode>(Extract->getOperand(1)))
16883       return SDValue();
16884
16885     // Record which element was extracted.
16886     ExtractedElements |=
16887       1 << cast<ConstantSDNode>(Extract->getOperand(1))->getZExtValue();
16888
16889     Uses.push_back(Extract);
16890   }
16891
16892   // If not all the elements were used, this may not be worthwhile.
16893   if (ExtractedElements != 15)
16894     return SDValue();
16895
16896   // Ok, we've now decided to do the transformation.
16897   SDLoc dl(InputVector);
16898
16899   // Store the value to a temporary stack slot.
16900   SDValue StackPtr = DAG.CreateStackTemporary(InputVector.getValueType());
16901   SDValue Ch = DAG.getStore(DAG.getEntryNode(), dl, InputVector, StackPtr,
16902                             MachinePointerInfo(), false, false, 0);
16903
16904   // Replace each use (extract) with a load of the appropriate element.
16905   for (SmallVectorImpl<SDNode *>::iterator UI = Uses.begin(),
16906        UE = Uses.end(); UI != UE; ++UI) {
16907     SDNode *Extract = *UI;
16908
16909     // cOMpute the element's address.
16910     SDValue Idx = Extract->getOperand(1);
16911     unsigned EltSize =
16912         InputVector.getValueType().getVectorElementType().getSizeInBits()/8;
16913     uint64_t Offset = EltSize * cast<ConstantSDNode>(Idx)->getZExtValue();
16914     const TargetLowering &TLI = DAG.getTargetLoweringInfo();
16915     SDValue OffsetVal = DAG.getConstant(Offset, TLI.getPointerTy());
16916
16917     SDValue ScalarAddr = DAG.getNode(ISD::ADD, dl, TLI.getPointerTy(),
16918                                      StackPtr, OffsetVal);
16919
16920     // Load the scalar.
16921     SDValue LoadScalar = DAG.getLoad(Extract->getValueType(0), dl, Ch,
16922                                      ScalarAddr, MachinePointerInfo(),
16923                                      false, false, false, 0);
16924
16925     // Replace the exact with the load.
16926     DAG.ReplaceAllUsesOfValueWith(SDValue(Extract, 0), LoadScalar);
16927   }
16928
16929   // The replacement was made in place; don't return anything.
16930   return SDValue();
16931 }
16932
16933 /// \brief Matches a VSELECT onto min/max or return 0 if the node doesn't match.
16934 static std::pair<unsigned, bool>
16935 matchIntegerMINMAX(SDValue Cond, EVT VT, SDValue LHS, SDValue RHS,
16936                    SelectionDAG &DAG, const X86Subtarget *Subtarget) {
16937   if (!VT.isVector())
16938     return std::make_pair(0, false);
16939
16940   bool NeedSplit = false;
16941   switch (VT.getSimpleVT().SimpleTy) {
16942   default: return std::make_pair(0, false);
16943   case MVT::v32i8:
16944   case MVT::v16i16:
16945   case MVT::v8i32:
16946     if (!Subtarget->hasAVX2())
16947       NeedSplit = true;
16948     if (!Subtarget->hasAVX())
16949       return std::make_pair(0, false);
16950     break;
16951   case MVT::v16i8:
16952   case MVT::v8i16:
16953   case MVT::v4i32:
16954     if (!Subtarget->hasSSE2())
16955       return std::make_pair(0, false);
16956   }
16957
16958   // SSE2 has only a small subset of the operations.
16959   bool hasUnsigned = Subtarget->hasSSE41() ||
16960                      (Subtarget->hasSSE2() && VT == MVT::v16i8);
16961   bool hasSigned = Subtarget->hasSSE41() ||
16962                    (Subtarget->hasSSE2() && VT == MVT::v8i16);
16963
16964   ISD::CondCode CC = cast<CondCodeSDNode>(Cond.getOperand(2))->get();
16965
16966   unsigned Opc = 0;
16967   // Check for x CC y ? x : y.
16968   if (DAG.isEqualTo(LHS, Cond.getOperand(0)) &&
16969       DAG.isEqualTo(RHS, Cond.getOperand(1))) {
16970     switch (CC) {
16971     default: break;
16972     case ISD::SETULT:
16973     case ISD::SETULE:
16974       Opc = hasUnsigned ? X86ISD::UMIN : 0; break;
16975     case ISD::SETUGT:
16976     case ISD::SETUGE:
16977       Opc = hasUnsigned ? X86ISD::UMAX : 0; break;
16978     case ISD::SETLT:
16979     case ISD::SETLE:
16980       Opc = hasSigned ? X86ISD::SMIN : 0; break;
16981     case ISD::SETGT:
16982     case ISD::SETGE:
16983       Opc = hasSigned ? X86ISD::SMAX : 0; break;
16984     }
16985   // Check for x CC y ? y : x -- a min/max with reversed arms.
16986   } else if (DAG.isEqualTo(LHS, Cond.getOperand(1)) &&
16987              DAG.isEqualTo(RHS, Cond.getOperand(0))) {
16988     switch (CC) {
16989     default: break;
16990     case ISD::SETULT:
16991     case ISD::SETULE:
16992       Opc = hasUnsigned ? X86ISD::UMAX : 0; break;
16993     case ISD::SETUGT:
16994     case ISD::SETUGE:
16995       Opc = hasUnsigned ? X86ISD::UMIN : 0; break;
16996     case ISD::SETLT:
16997     case ISD::SETLE:
16998       Opc = hasSigned ? X86ISD::SMAX : 0; break;
16999     case ISD::SETGT:
17000     case ISD::SETGE:
17001       Opc = hasSigned ? X86ISD::SMIN : 0; break;
17002     }
17003   }
17004
17005   return std::make_pair(Opc, NeedSplit);
17006 }
17007
17008 /// PerformSELECTCombine - Do target-specific dag combines on SELECT and VSELECT
17009 /// nodes.
17010 static SDValue PerformSELECTCombine(SDNode *N, SelectionDAG &DAG,
17011                                     TargetLowering::DAGCombinerInfo &DCI,
17012                                     const X86Subtarget *Subtarget) {
17013   SDLoc DL(N);
17014   SDValue Cond = N->getOperand(0);
17015   // Get the LHS/RHS of the select.
17016   SDValue LHS = N->getOperand(1);
17017   SDValue RHS = N->getOperand(2);
17018   EVT VT = LHS.getValueType();
17019   const TargetLowering &TLI = DAG.getTargetLoweringInfo();
17020
17021   // If we have SSE[12] support, try to form min/max nodes. SSE min/max
17022   // instructions match the semantics of the common C idiom x<y?x:y but not
17023   // x<=y?x:y, because of how they handle negative zero (which can be
17024   // ignored in unsafe-math mode).
17025   if (Cond.getOpcode() == ISD::SETCC && VT.isFloatingPoint() &&
17026       VT != MVT::f80 && TLI.isTypeLegal(VT) &&
17027       (Subtarget->hasSSE2() ||
17028        (Subtarget->hasSSE1() && VT.getScalarType() == MVT::f32))) {
17029     ISD::CondCode CC = cast<CondCodeSDNode>(Cond.getOperand(2))->get();
17030
17031     unsigned Opcode = 0;
17032     // Check for x CC y ? x : y.
17033     if (DAG.isEqualTo(LHS, Cond.getOperand(0)) &&
17034         DAG.isEqualTo(RHS, Cond.getOperand(1))) {
17035       switch (CC) {
17036       default: break;
17037       case ISD::SETULT:
17038         // Converting this to a min would handle NaNs incorrectly, and swapping
17039         // the operands would cause it to handle comparisons between positive
17040         // and negative zero incorrectly.
17041         if (!DAG.isKnownNeverNaN(LHS) || !DAG.isKnownNeverNaN(RHS)) {
17042           if (!DAG.getTarget().Options.UnsafeFPMath &&
17043               !(DAG.isKnownNeverZero(LHS) || DAG.isKnownNeverZero(RHS)))
17044             break;
17045           std::swap(LHS, RHS);
17046         }
17047         Opcode = X86ISD::FMIN;
17048         break;
17049       case ISD::SETOLE:
17050         // Converting this to a min would handle comparisons between positive
17051         // and negative zero incorrectly.
17052         if (!DAG.getTarget().Options.UnsafeFPMath &&
17053             !DAG.isKnownNeverZero(LHS) && !DAG.isKnownNeverZero(RHS))
17054           break;
17055         Opcode = X86ISD::FMIN;
17056         break;
17057       case ISD::SETULE:
17058         // Converting this to a min would handle both negative zeros and NaNs
17059         // incorrectly, but we can swap the operands to fix both.
17060         std::swap(LHS, RHS);
17061       case ISD::SETOLT:
17062       case ISD::SETLT:
17063       case ISD::SETLE:
17064         Opcode = X86ISD::FMIN;
17065         break;
17066
17067       case ISD::SETOGE:
17068         // Converting this to a max would handle comparisons between positive
17069         // and negative zero incorrectly.
17070         if (!DAG.getTarget().Options.UnsafeFPMath &&
17071             !DAG.isKnownNeverZero(LHS) && !DAG.isKnownNeverZero(RHS))
17072           break;
17073         Opcode = X86ISD::FMAX;
17074         break;
17075       case ISD::SETUGT:
17076         // Converting this to a max would handle NaNs incorrectly, and swapping
17077         // the operands would cause it to handle comparisons between positive
17078         // and negative zero incorrectly.
17079         if (!DAG.isKnownNeverNaN(LHS) || !DAG.isKnownNeverNaN(RHS)) {
17080           if (!DAG.getTarget().Options.UnsafeFPMath &&
17081               !(DAG.isKnownNeverZero(LHS) || DAG.isKnownNeverZero(RHS)))
17082             break;
17083           std::swap(LHS, RHS);
17084         }
17085         Opcode = X86ISD::FMAX;
17086         break;
17087       case ISD::SETUGE:
17088         // Converting this to a max would handle both negative zeros and NaNs
17089         // incorrectly, but we can swap the operands to fix both.
17090         std::swap(LHS, RHS);
17091       case ISD::SETOGT:
17092       case ISD::SETGT:
17093       case ISD::SETGE:
17094         Opcode = X86ISD::FMAX;
17095         break;
17096       }
17097     // Check for x CC y ? y : x -- a min/max with reversed arms.
17098     } else if (DAG.isEqualTo(LHS, Cond.getOperand(1)) &&
17099                DAG.isEqualTo(RHS, Cond.getOperand(0))) {
17100       switch (CC) {
17101       default: break;
17102       case ISD::SETOGE:
17103         // Converting this to a min would handle comparisons between positive
17104         // and negative zero incorrectly, and swapping the operands would
17105         // cause it to handle NaNs incorrectly.
17106         if (!DAG.getTarget().Options.UnsafeFPMath &&
17107             !(DAG.isKnownNeverZero(LHS) || DAG.isKnownNeverZero(RHS))) {
17108           if (!DAG.isKnownNeverNaN(LHS) || !DAG.isKnownNeverNaN(RHS))
17109             break;
17110           std::swap(LHS, RHS);
17111         }
17112         Opcode = X86ISD::FMIN;
17113         break;
17114       case ISD::SETUGT:
17115         // Converting this to a min would handle NaNs incorrectly.
17116         if (!DAG.getTarget().Options.UnsafeFPMath &&
17117             (!DAG.isKnownNeverNaN(LHS) || !DAG.isKnownNeverNaN(RHS)))
17118           break;
17119         Opcode = X86ISD::FMIN;
17120         break;
17121       case ISD::SETUGE:
17122         // Converting this to a min would handle both negative zeros and NaNs
17123         // incorrectly, but we can swap the operands to fix both.
17124         std::swap(LHS, RHS);
17125       case ISD::SETOGT:
17126       case ISD::SETGT:
17127       case ISD::SETGE:
17128         Opcode = X86ISD::FMIN;
17129         break;
17130
17131       case ISD::SETULT:
17132         // Converting this to a max would handle NaNs incorrectly.
17133         if (!DAG.isKnownNeverNaN(LHS) || !DAG.isKnownNeverNaN(RHS))
17134           break;
17135         Opcode = X86ISD::FMAX;
17136         break;
17137       case ISD::SETOLE:
17138         // Converting this to a max would handle comparisons between positive
17139         // and negative zero incorrectly, and swapping the operands would
17140         // cause it to handle NaNs incorrectly.
17141         if (!DAG.getTarget().Options.UnsafeFPMath &&
17142             !DAG.isKnownNeverZero(LHS) && !DAG.isKnownNeverZero(RHS)) {
17143           if (!DAG.isKnownNeverNaN(LHS) || !DAG.isKnownNeverNaN(RHS))
17144             break;
17145           std::swap(LHS, RHS);
17146         }
17147         Opcode = X86ISD::FMAX;
17148         break;
17149       case ISD::SETULE:
17150         // Converting this to a max would handle both negative zeros and NaNs
17151         // incorrectly, but we can swap the operands to fix both.
17152         std::swap(LHS, RHS);
17153       case ISD::SETOLT:
17154       case ISD::SETLT:
17155       case ISD::SETLE:
17156         Opcode = X86ISD::FMAX;
17157         break;
17158       }
17159     }
17160
17161     if (Opcode)
17162       return DAG.getNode(Opcode, DL, N->getValueType(0), LHS, RHS);
17163   }
17164
17165   EVT CondVT = Cond.getValueType();
17166   if (Subtarget->hasAVX512() && VT.isVector() && CondVT.isVector() &&
17167       CondVT.getVectorElementType() == MVT::i1) {
17168     // v16i8 (select v16i1, v16i8, v16i8) does not have a proper
17169     // lowering on AVX-512. In this case we convert it to
17170     // v16i8 (select v16i8, v16i8, v16i8) and use AVX instruction.
17171     // The same situation for all 128 and 256-bit vectors of i8 and i16
17172     EVT OpVT = LHS.getValueType();
17173     if ((OpVT.is128BitVector() || OpVT.is256BitVector()) &&
17174         (OpVT.getVectorElementType() == MVT::i8 ||
17175          OpVT.getVectorElementType() == MVT::i16)) {
17176       Cond = DAG.getNode(ISD::SIGN_EXTEND, DL, OpVT, Cond);
17177       DCI.AddToWorklist(Cond.getNode());
17178       return DAG.getNode(N->getOpcode(), DL, OpVT, Cond, LHS, RHS);
17179     }
17180   }
17181   // If this is a select between two integer constants, try to do some
17182   // optimizations.
17183   if (ConstantSDNode *TrueC = dyn_cast<ConstantSDNode>(LHS)) {
17184     if (ConstantSDNode *FalseC = dyn_cast<ConstantSDNode>(RHS))
17185       // Don't do this for crazy integer types.
17186       if (DAG.getTargetLoweringInfo().isTypeLegal(LHS.getValueType())) {
17187         // If this is efficiently invertible, canonicalize the LHSC/RHSC values
17188         // so that TrueC (the true value) is larger than FalseC.
17189         bool NeedsCondInvert = false;
17190
17191         if (TrueC->getAPIntValue().ult(FalseC->getAPIntValue()) &&
17192             // Efficiently invertible.
17193             (Cond.getOpcode() == ISD::SETCC ||  // setcc -> invertible.
17194              (Cond.getOpcode() == ISD::XOR &&   // xor(X, C) -> invertible.
17195               isa<ConstantSDNode>(Cond.getOperand(1))))) {
17196           NeedsCondInvert = true;
17197           std::swap(TrueC, FalseC);
17198         }
17199
17200         // Optimize C ? 8 : 0 -> zext(C) << 3.  Likewise for any pow2/0.
17201         if (FalseC->getAPIntValue() == 0 &&
17202             TrueC->getAPIntValue().isPowerOf2()) {
17203           if (NeedsCondInvert) // Invert the condition if needed.
17204             Cond = DAG.getNode(ISD::XOR, DL, Cond.getValueType(), Cond,
17205                                DAG.getConstant(1, Cond.getValueType()));
17206
17207           // Zero extend the condition if needed.
17208           Cond = DAG.getNode(ISD::ZERO_EXTEND, DL, LHS.getValueType(), Cond);
17209
17210           unsigned ShAmt = TrueC->getAPIntValue().logBase2();
17211           return DAG.getNode(ISD::SHL, DL, LHS.getValueType(), Cond,
17212                              DAG.getConstant(ShAmt, MVT::i8));
17213         }
17214
17215         // Optimize Cond ? cst+1 : cst -> zext(setcc(C)+cst.
17216         if (FalseC->getAPIntValue()+1 == TrueC->getAPIntValue()) {
17217           if (NeedsCondInvert) // Invert the condition if needed.
17218             Cond = DAG.getNode(ISD::XOR, DL, Cond.getValueType(), Cond,
17219                                DAG.getConstant(1, Cond.getValueType()));
17220
17221           // Zero extend the condition if needed.
17222           Cond = DAG.getNode(ISD::ZERO_EXTEND, DL,
17223                              FalseC->getValueType(0), Cond);
17224           return DAG.getNode(ISD::ADD, DL, Cond.getValueType(), Cond,
17225                              SDValue(FalseC, 0));
17226         }
17227
17228         // Optimize cases that will turn into an LEA instruction.  This requires
17229         // an i32 or i64 and an efficient multiplier (1, 2, 3, 4, 5, 8, 9).
17230         if (N->getValueType(0) == MVT::i32 || N->getValueType(0) == MVT::i64) {
17231           uint64_t Diff = TrueC->getZExtValue()-FalseC->getZExtValue();
17232           if (N->getValueType(0) == MVT::i32) Diff = (unsigned)Diff;
17233
17234           bool isFastMultiplier = false;
17235           if (Diff < 10) {
17236             switch ((unsigned char)Diff) {
17237               default: break;
17238               case 1:  // result = add base, cond
17239               case 2:  // result = lea base(    , cond*2)
17240               case 3:  // result = lea base(cond, cond*2)
17241               case 4:  // result = lea base(    , cond*4)
17242               case 5:  // result = lea base(cond, cond*4)
17243               case 8:  // result = lea base(    , cond*8)
17244               case 9:  // result = lea base(cond, cond*8)
17245                 isFastMultiplier = true;
17246                 break;
17247             }
17248           }
17249
17250           if (isFastMultiplier) {
17251             APInt Diff = TrueC->getAPIntValue()-FalseC->getAPIntValue();
17252             if (NeedsCondInvert) // Invert the condition if needed.
17253               Cond = DAG.getNode(ISD::XOR, DL, Cond.getValueType(), Cond,
17254                                  DAG.getConstant(1, Cond.getValueType()));
17255
17256             // Zero extend the condition if needed.
17257             Cond = DAG.getNode(ISD::ZERO_EXTEND, DL, FalseC->getValueType(0),
17258                                Cond);
17259             // Scale the condition by the difference.
17260             if (Diff != 1)
17261               Cond = DAG.getNode(ISD::MUL, DL, Cond.getValueType(), Cond,
17262                                  DAG.getConstant(Diff, Cond.getValueType()));
17263
17264             // Add the base if non-zero.
17265             if (FalseC->getAPIntValue() != 0)
17266               Cond = DAG.getNode(ISD::ADD, DL, Cond.getValueType(), Cond,
17267                                  SDValue(FalseC, 0));
17268             return Cond;
17269           }
17270         }
17271       }
17272   }
17273
17274   // Canonicalize max and min:
17275   // (x > y) ? x : y -> (x >= y) ? x : y
17276   // (x < y) ? x : y -> (x <= y) ? x : y
17277   // This allows use of COND_S / COND_NS (see TranslateX86CC) which eliminates
17278   // the need for an extra compare
17279   // against zero. e.g.
17280   // (x - y) > 0 : (x - y) ? 0 -> (x - y) >= 0 : (x - y) ? 0
17281   // subl   %esi, %edi
17282   // testl  %edi, %edi
17283   // movl   $0, %eax
17284   // cmovgl %edi, %eax
17285   // =>
17286   // xorl   %eax, %eax
17287   // subl   %esi, $edi
17288   // cmovsl %eax, %edi
17289   if (N->getOpcode() == ISD::SELECT && Cond.getOpcode() == ISD::SETCC &&
17290       DAG.isEqualTo(LHS, Cond.getOperand(0)) &&
17291       DAG.isEqualTo(RHS, Cond.getOperand(1))) {
17292     ISD::CondCode CC = cast<CondCodeSDNode>(Cond.getOperand(2))->get();
17293     switch (CC) {
17294     default: break;
17295     case ISD::SETLT:
17296     case ISD::SETGT: {
17297       ISD::CondCode NewCC = (CC == ISD::SETLT) ? ISD::SETLE : ISD::SETGE;
17298       Cond = DAG.getSetCC(SDLoc(Cond), Cond.getValueType(),
17299                           Cond.getOperand(0), Cond.getOperand(1), NewCC);
17300       return DAG.getNode(ISD::SELECT, DL, VT, Cond, LHS, RHS);
17301     }
17302     }
17303   }
17304
17305   // Early exit check
17306   if (!TLI.isTypeLegal(VT))
17307     return SDValue();
17308
17309   // Match VSELECTs into subs with unsigned saturation.
17310   if (N->getOpcode() == ISD::VSELECT && Cond.getOpcode() == ISD::SETCC &&
17311       // psubus is available in SSE2 and AVX2 for i8 and i16 vectors.
17312       ((Subtarget->hasSSE2() && (VT == MVT::v16i8 || VT == MVT::v8i16)) ||
17313        (Subtarget->hasAVX2() && (VT == MVT::v32i8 || VT == MVT::v16i16)))) {
17314     ISD::CondCode CC = cast<CondCodeSDNode>(Cond.getOperand(2))->get();
17315
17316     // Check if one of the arms of the VSELECT is a zero vector. If it's on the
17317     // left side invert the predicate to simplify logic below.
17318     SDValue Other;
17319     if (ISD::isBuildVectorAllZeros(LHS.getNode())) {
17320       Other = RHS;
17321       CC = ISD::getSetCCInverse(CC, true);
17322     } else if (ISD::isBuildVectorAllZeros(RHS.getNode())) {
17323       Other = LHS;
17324     }
17325
17326     if (Other.getNode() && Other->getNumOperands() == 2 &&
17327         DAG.isEqualTo(Other->getOperand(0), Cond.getOperand(0))) {
17328       SDValue OpLHS = Other->getOperand(0), OpRHS = Other->getOperand(1);
17329       SDValue CondRHS = Cond->getOperand(1);
17330
17331       // Look for a general sub with unsigned saturation first.
17332       // x >= y ? x-y : 0 --> subus x, y
17333       // x >  y ? x-y : 0 --> subus x, y
17334       if ((CC == ISD::SETUGE || CC == ISD::SETUGT) &&
17335           Other->getOpcode() == ISD::SUB && DAG.isEqualTo(OpRHS, CondRHS))
17336         return DAG.getNode(X86ISD::SUBUS, DL, VT, OpLHS, OpRHS);
17337
17338       // If the RHS is a constant we have to reverse the const canonicalization.
17339       // x > C-1 ? x+-C : 0 --> subus x, C
17340       if (CC == ISD::SETUGT && Other->getOpcode() == ISD::ADD &&
17341           isSplatVector(CondRHS.getNode()) && isSplatVector(OpRHS.getNode())) {
17342         APInt A = cast<ConstantSDNode>(OpRHS.getOperand(0))->getAPIntValue();
17343         if (CondRHS.getConstantOperandVal(0) == -A-1)
17344           return DAG.getNode(X86ISD::SUBUS, DL, VT, OpLHS,
17345                              DAG.getConstant(-A, VT));
17346       }
17347
17348       // Another special case: If C was a sign bit, the sub has been
17349       // canonicalized into a xor.
17350       // FIXME: Would it be better to use ComputeMaskedBits to determine whether
17351       //        it's safe to decanonicalize the xor?
17352       // x s< 0 ? x^C : 0 --> subus x, C
17353       if (CC == ISD::SETLT && Other->getOpcode() == ISD::XOR &&
17354           ISD::isBuildVectorAllZeros(CondRHS.getNode()) &&
17355           isSplatVector(OpRHS.getNode())) {
17356         APInt A = cast<ConstantSDNode>(OpRHS.getOperand(0))->getAPIntValue();
17357         if (A.isSignBit())
17358           return DAG.getNode(X86ISD::SUBUS, DL, VT, OpLHS, OpRHS);
17359       }
17360     }
17361   }
17362
17363   // Try to match a min/max vector operation.
17364   if (N->getOpcode() == ISD::VSELECT && Cond.getOpcode() == ISD::SETCC) {
17365     std::pair<unsigned, bool> ret = matchIntegerMINMAX(Cond, VT, LHS, RHS, DAG, Subtarget);
17366     unsigned Opc = ret.first;
17367     bool NeedSplit = ret.second;
17368
17369     if (Opc && NeedSplit) {
17370       unsigned NumElems = VT.getVectorNumElements();
17371       // Extract the LHS vectors
17372       SDValue LHS1 = Extract128BitVector(LHS, 0, DAG, DL);
17373       SDValue LHS2 = Extract128BitVector(LHS, NumElems/2, DAG, DL);
17374
17375       // Extract the RHS vectors
17376       SDValue RHS1 = Extract128BitVector(RHS, 0, DAG, DL);
17377       SDValue RHS2 = Extract128BitVector(RHS, NumElems/2, DAG, DL);
17378
17379       // Create min/max for each subvector
17380       LHS = DAG.getNode(Opc, DL, LHS1.getValueType(), LHS1, RHS1);
17381       RHS = DAG.getNode(Opc, DL, LHS2.getValueType(), LHS2, RHS2);
17382
17383       // Merge the result
17384       return DAG.getNode(ISD::CONCAT_VECTORS, DL, VT, LHS, RHS);
17385     } else if (Opc)
17386       return DAG.getNode(Opc, DL, VT, LHS, RHS);
17387   }
17388
17389   // Simplify vector selection if the selector will be produced by CMPP*/PCMP*.
17390   if (N->getOpcode() == ISD::VSELECT && Cond.getOpcode() == ISD::SETCC &&
17391       // Check if SETCC has already been promoted
17392       TLI.getSetCCResultType(*DAG.getContext(), VT) == CondVT &&
17393       // Check that condition value type matches vselect operand type
17394       CondVT == VT) { 
17395
17396     assert(Cond.getValueType().isVector() &&
17397            "vector select expects a vector selector!");
17398
17399     bool TValIsAllOnes = ISD::isBuildVectorAllOnes(LHS.getNode());
17400     bool FValIsAllZeros = ISD::isBuildVectorAllZeros(RHS.getNode());
17401
17402     if (!TValIsAllOnes && !FValIsAllZeros) {
17403       // Try invert the condition if true value is not all 1s and false value
17404       // is not all 0s.
17405       bool TValIsAllZeros = ISD::isBuildVectorAllZeros(LHS.getNode());
17406       bool FValIsAllOnes = ISD::isBuildVectorAllOnes(RHS.getNode());
17407
17408       if (TValIsAllZeros || FValIsAllOnes) {
17409         SDValue CC = Cond.getOperand(2);
17410         ISD::CondCode NewCC =
17411           ISD::getSetCCInverse(cast<CondCodeSDNode>(CC)->get(),
17412                                Cond.getOperand(0).getValueType().isInteger());
17413         Cond = DAG.getSetCC(DL, CondVT, Cond.getOperand(0), Cond.getOperand(1), NewCC);
17414         std::swap(LHS, RHS);
17415         TValIsAllOnes = FValIsAllOnes;
17416         FValIsAllZeros = TValIsAllZeros;
17417       }
17418     }
17419
17420     if (TValIsAllOnes || FValIsAllZeros) {
17421       SDValue Ret;
17422
17423       if (TValIsAllOnes && FValIsAllZeros)
17424         Ret = Cond;
17425       else if (TValIsAllOnes)
17426         Ret = DAG.getNode(ISD::OR, DL, CondVT, Cond,
17427                           DAG.getNode(ISD::BITCAST, DL, CondVT, RHS));
17428       else if (FValIsAllZeros)
17429         Ret = DAG.getNode(ISD::AND, DL, CondVT, Cond,
17430                           DAG.getNode(ISD::BITCAST, DL, CondVT, LHS));
17431
17432       return DAG.getNode(ISD::BITCAST, DL, VT, Ret);
17433     }
17434   }
17435
17436   // Try to fold this VSELECT into a MOVSS/MOVSD
17437   if (N->getOpcode() == ISD::VSELECT &&
17438       Cond.getOpcode() == ISD::BUILD_VECTOR && !DCI.isBeforeLegalize()) {
17439     if (VT == MVT::v4i32 || VT == MVT::v4f32 ||
17440         (Subtarget->hasSSE2() && (VT == MVT::v2i64 || VT == MVT::v2f64))) {
17441       bool CanFold = false;
17442       unsigned NumElems = Cond.getNumOperands();
17443       SDValue A = LHS;
17444       SDValue B = RHS;
17445       
17446       if (isZero(Cond.getOperand(0))) {
17447         CanFold = true;
17448
17449         // fold (vselect <0,-1,-1,-1>, A, B) -> (movss A, B)
17450         // fold (vselect <0,-1> -> (movsd A, B)
17451         for (unsigned i = 1, e = NumElems; i != e && CanFold; ++i)
17452           CanFold = isAllOnes(Cond.getOperand(i));
17453       } else if (isAllOnes(Cond.getOperand(0))) {
17454         CanFold = true;
17455         std::swap(A, B);
17456
17457         // fold (vselect <-1,0,0,0>, A, B) -> (movss B, A)
17458         // fold (vselect <-1,0> -> (movsd B, A)
17459         for (unsigned i = 1, e = NumElems; i != e && CanFold; ++i)
17460           CanFold = isZero(Cond.getOperand(i));
17461       }
17462
17463       if (CanFold) {
17464         if (VT == MVT::v4i32 || VT == MVT::v4f32)
17465           return getTargetShuffleNode(X86ISD::MOVSS, DL, VT, A, B, DAG);
17466         return getTargetShuffleNode(X86ISD::MOVSD, DL, VT, A, B, DAG);
17467       }
17468
17469       if (Subtarget->hasSSE2() && (VT == MVT::v4i32 || VT == MVT::v4f32)) {
17470         // fold (v4i32: vselect <0,0,-1,-1>, A, B) ->
17471         //      (v4i32 (bitcast (movsd (v2i64 (bitcast A)),
17472         //                             (v2i64 (bitcast B)))))
17473         //
17474         // fold (v4f32: vselect <0,0,-1,-1>, A, B) ->
17475         //      (v4f32 (bitcast (movsd (v2f64 (bitcast A)),
17476         //                             (v2f64 (bitcast B)))))
17477         //
17478         // fold (v4i32: vselect <-1,-1,0,0>, A, B) ->
17479         //      (v4i32 (bitcast (movsd (v2i64 (bitcast B)),
17480         //                             (v2i64 (bitcast A)))))
17481         //
17482         // fold (v4f32: vselect <-1,-1,0,0>, A, B) ->
17483         //      (v4f32 (bitcast (movsd (v2f64 (bitcast B)),
17484         //                             (v2f64 (bitcast A)))))
17485
17486         CanFold = (isZero(Cond.getOperand(0)) &&
17487                    isZero(Cond.getOperand(1)) &&
17488                    isAllOnes(Cond.getOperand(2)) &&
17489                    isAllOnes(Cond.getOperand(3)));
17490
17491         if (!CanFold && isAllOnes(Cond.getOperand(0)) &&
17492             isAllOnes(Cond.getOperand(1)) &&
17493             isZero(Cond.getOperand(2)) &&
17494             isZero(Cond.getOperand(3))) {
17495           CanFold = true;
17496           std::swap(LHS, RHS);
17497         }
17498
17499         if (CanFold) {
17500           EVT NVT = (VT == MVT::v4i32) ? MVT::v2i64 : MVT::v2f64;
17501           SDValue NewA = DAG.getNode(ISD::BITCAST, DL, NVT, LHS);
17502           SDValue NewB = DAG.getNode(ISD::BITCAST, DL, NVT, RHS);
17503           SDValue Select = getTargetShuffleNode(X86ISD::MOVSD, DL, NVT, NewA,
17504                                                 NewB, DAG);
17505           return DAG.getNode(ISD::BITCAST, DL, VT, Select);
17506         }
17507       }
17508     }
17509   }
17510
17511   // If we know that this node is legal then we know that it is going to be
17512   // matched by one of the SSE/AVX BLEND instructions. These instructions only
17513   // depend on the highest bit in each word. Try to use SimplifyDemandedBits
17514   // to simplify previous instructions.
17515   if (N->getOpcode() == ISD::VSELECT && DCI.isBeforeLegalizeOps() &&
17516       !DCI.isBeforeLegalize() && TLI.isOperationLegal(ISD::VSELECT, VT)) {
17517     unsigned BitWidth = Cond.getValueType().getScalarType().getSizeInBits();
17518
17519     // Don't optimize vector selects that map to mask-registers.
17520     if (BitWidth == 1)
17521       return SDValue();
17522
17523     // Check all uses of that condition operand to check whether it will be
17524     // consumed by non-BLEND instructions, which may depend on all bits are set
17525     // properly.
17526     for (SDNode::use_iterator I = Cond->use_begin(),
17527                               E = Cond->use_end(); I != E; ++I)
17528       if (I->getOpcode() != ISD::VSELECT)
17529         // TODO: Add other opcodes eventually lowered into BLEND.
17530         return SDValue();
17531
17532     assert(BitWidth >= 8 && BitWidth <= 64 && "Invalid mask size");
17533     APInt DemandedMask = APInt::getHighBitsSet(BitWidth, 1);
17534
17535     APInt KnownZero, KnownOne;
17536     TargetLowering::TargetLoweringOpt TLO(DAG, DCI.isBeforeLegalize(),
17537                                           DCI.isBeforeLegalizeOps());
17538     if (TLO.ShrinkDemandedConstant(Cond, DemandedMask) ||
17539         TLI.SimplifyDemandedBits(Cond, DemandedMask, KnownZero, KnownOne, TLO))
17540       DCI.CommitTargetLoweringOpt(TLO);
17541   }
17542
17543   return SDValue();
17544 }
17545
17546 // Check whether a boolean test is testing a boolean value generated by
17547 // X86ISD::SETCC. If so, return the operand of that SETCC and proper condition
17548 // code.
17549 //
17550 // Simplify the following patterns:
17551 // (Op (CMP (SETCC Cond EFLAGS) 1) EQ) or
17552 // (Op (CMP (SETCC Cond EFLAGS) 0) NEQ)
17553 // to (Op EFLAGS Cond)
17554 //
17555 // (Op (CMP (SETCC Cond EFLAGS) 0) EQ) or
17556 // (Op (CMP (SETCC Cond EFLAGS) 1) NEQ)
17557 // to (Op EFLAGS !Cond)
17558 //
17559 // where Op could be BRCOND or CMOV.
17560 //
17561 static SDValue checkBoolTestSetCCCombine(SDValue Cmp, X86::CondCode &CC) {
17562   // Quit if not CMP and SUB with its value result used.
17563   if (Cmp.getOpcode() != X86ISD::CMP &&
17564       (Cmp.getOpcode() != X86ISD::SUB || Cmp.getNode()->hasAnyUseOfValue(0)))
17565       return SDValue();
17566
17567   // Quit if not used as a boolean value.
17568   if (CC != X86::COND_E && CC != X86::COND_NE)
17569     return SDValue();
17570
17571   // Check CMP operands. One of them should be 0 or 1 and the other should be
17572   // an SetCC or extended from it.
17573   SDValue Op1 = Cmp.getOperand(0);
17574   SDValue Op2 = Cmp.getOperand(1);
17575
17576   SDValue SetCC;
17577   const ConstantSDNode* C = 0;
17578   bool needOppositeCond = (CC == X86::COND_E);
17579   bool checkAgainstTrue = false; // Is it a comparison against 1?
17580
17581   if ((C = dyn_cast<ConstantSDNode>(Op1)))
17582     SetCC = Op2;
17583   else if ((C = dyn_cast<ConstantSDNode>(Op2)))
17584     SetCC = Op1;
17585   else // Quit if all operands are not constants.
17586     return SDValue();
17587
17588   if (C->getZExtValue() == 1) {
17589     needOppositeCond = !needOppositeCond;
17590     checkAgainstTrue = true;
17591   } else if (C->getZExtValue() != 0)
17592     // Quit if the constant is neither 0 or 1.
17593     return SDValue();
17594
17595   bool truncatedToBoolWithAnd = false;
17596   // Skip (zext $x), (trunc $x), or (and $x, 1) node.
17597   while (SetCC.getOpcode() == ISD::ZERO_EXTEND ||
17598          SetCC.getOpcode() == ISD::TRUNCATE ||
17599          SetCC.getOpcode() == ISD::AND) {
17600     if (SetCC.getOpcode() == ISD::AND) {
17601       int OpIdx = -1;
17602       ConstantSDNode *CS;
17603       if ((CS = dyn_cast<ConstantSDNode>(SetCC.getOperand(0))) &&
17604           CS->getZExtValue() == 1)
17605         OpIdx = 1;
17606       if ((CS = dyn_cast<ConstantSDNode>(SetCC.getOperand(1))) &&
17607           CS->getZExtValue() == 1)
17608         OpIdx = 0;
17609       if (OpIdx == -1)
17610         break;
17611       SetCC = SetCC.getOperand(OpIdx);
17612       truncatedToBoolWithAnd = true;
17613     } else
17614       SetCC = SetCC.getOperand(0);
17615   }
17616
17617   switch (SetCC.getOpcode()) {
17618   case X86ISD::SETCC_CARRY:
17619     // Since SETCC_CARRY gives output based on R = CF ? ~0 : 0, it's unsafe to
17620     // simplify it if the result of SETCC_CARRY is not canonicalized to 0 or 1,
17621     // i.e. it's a comparison against true but the result of SETCC_CARRY is not
17622     // truncated to i1 using 'and'.
17623     if (checkAgainstTrue && !truncatedToBoolWithAnd)
17624       break;
17625     assert(X86::CondCode(SetCC.getConstantOperandVal(0)) == X86::COND_B &&
17626            "Invalid use of SETCC_CARRY!");
17627     // FALL THROUGH
17628   case X86ISD::SETCC:
17629     // Set the condition code or opposite one if necessary.
17630     CC = X86::CondCode(SetCC.getConstantOperandVal(0));
17631     if (needOppositeCond)
17632       CC = X86::GetOppositeBranchCondition(CC);
17633     return SetCC.getOperand(1);
17634   case X86ISD::CMOV: {
17635     // Check whether false/true value has canonical one, i.e. 0 or 1.
17636     ConstantSDNode *FVal = dyn_cast<ConstantSDNode>(SetCC.getOperand(0));
17637     ConstantSDNode *TVal = dyn_cast<ConstantSDNode>(SetCC.getOperand(1));
17638     // Quit if true value is not a constant.
17639     if (!TVal)
17640       return SDValue();
17641     // Quit if false value is not a constant.
17642     if (!FVal) {
17643       SDValue Op = SetCC.getOperand(0);
17644       // Skip 'zext' or 'trunc' node.
17645       if (Op.getOpcode() == ISD::ZERO_EXTEND ||
17646           Op.getOpcode() == ISD::TRUNCATE)
17647         Op = Op.getOperand(0);
17648       // A special case for rdrand/rdseed, where 0 is set if false cond is
17649       // found.
17650       if ((Op.getOpcode() != X86ISD::RDRAND &&
17651            Op.getOpcode() != X86ISD::RDSEED) || Op.getResNo() != 0)
17652         return SDValue();
17653     }
17654     // Quit if false value is not the constant 0 or 1.
17655     bool FValIsFalse = true;
17656     if (FVal && FVal->getZExtValue() != 0) {
17657       if (FVal->getZExtValue() != 1)
17658         return SDValue();
17659       // If FVal is 1, opposite cond is needed.
17660       needOppositeCond = !needOppositeCond;
17661       FValIsFalse = false;
17662     }
17663     // Quit if TVal is not the constant opposite of FVal.
17664     if (FValIsFalse && TVal->getZExtValue() != 1)
17665       return SDValue();
17666     if (!FValIsFalse && TVal->getZExtValue() != 0)
17667       return SDValue();
17668     CC = X86::CondCode(SetCC.getConstantOperandVal(2));
17669     if (needOppositeCond)
17670       CC = X86::GetOppositeBranchCondition(CC);
17671     return SetCC.getOperand(3);
17672   }
17673   }
17674
17675   return SDValue();
17676 }
17677
17678 /// Optimize X86ISD::CMOV [LHS, RHS, CONDCODE (e.g. X86::COND_NE), CONDVAL]
17679 static SDValue PerformCMOVCombine(SDNode *N, SelectionDAG &DAG,
17680                                   TargetLowering::DAGCombinerInfo &DCI,
17681                                   const X86Subtarget *Subtarget) {
17682   SDLoc DL(N);
17683
17684   // If the flag operand isn't dead, don't touch this CMOV.
17685   if (N->getNumValues() == 2 && !SDValue(N, 1).use_empty())
17686     return SDValue();
17687
17688   SDValue FalseOp = N->getOperand(0);
17689   SDValue TrueOp = N->getOperand(1);
17690   X86::CondCode CC = (X86::CondCode)N->getConstantOperandVal(2);
17691   SDValue Cond = N->getOperand(3);
17692
17693   if (CC == X86::COND_E || CC == X86::COND_NE) {
17694     switch (Cond.getOpcode()) {
17695     default: break;
17696     case X86ISD::BSR:
17697     case X86ISD::BSF:
17698       // If operand of BSR / BSF are proven never zero, then ZF cannot be set.
17699       if (DAG.isKnownNeverZero(Cond.getOperand(0)))
17700         return (CC == X86::COND_E) ? FalseOp : TrueOp;
17701     }
17702   }
17703
17704   SDValue Flags;
17705
17706   Flags = checkBoolTestSetCCCombine(Cond, CC);
17707   if (Flags.getNode() &&
17708       // Extra check as FCMOV only supports a subset of X86 cond.
17709       (FalseOp.getValueType() != MVT::f80 || hasFPCMov(CC))) {
17710     SDValue Ops[] = { FalseOp, TrueOp,
17711                       DAG.getConstant(CC, MVT::i8), Flags };
17712     return DAG.getNode(X86ISD::CMOV, DL, N->getVTList(),
17713                        Ops, array_lengthof(Ops));
17714   }
17715
17716   // If this is a select between two integer constants, try to do some
17717   // optimizations.  Note that the operands are ordered the opposite of SELECT
17718   // operands.
17719   if (ConstantSDNode *TrueC = dyn_cast<ConstantSDNode>(TrueOp)) {
17720     if (ConstantSDNode *FalseC = dyn_cast<ConstantSDNode>(FalseOp)) {
17721       // Canonicalize the TrueC/FalseC values so that TrueC (the true value) is
17722       // larger than FalseC (the false value).
17723       if (TrueC->getAPIntValue().ult(FalseC->getAPIntValue())) {
17724         CC = X86::GetOppositeBranchCondition(CC);
17725         std::swap(TrueC, FalseC);
17726         std::swap(TrueOp, FalseOp);
17727       }
17728
17729       // Optimize C ? 8 : 0 -> zext(setcc(C)) << 3.  Likewise for any pow2/0.
17730       // This is efficient for any integer data type (including i8/i16) and
17731       // shift amount.
17732       if (FalseC->getAPIntValue() == 0 && TrueC->getAPIntValue().isPowerOf2()) {
17733         Cond = DAG.getNode(X86ISD::SETCC, DL, MVT::i8,
17734                            DAG.getConstant(CC, MVT::i8), Cond);
17735
17736         // Zero extend the condition if needed.
17737         Cond = DAG.getNode(ISD::ZERO_EXTEND, DL, TrueC->getValueType(0), Cond);
17738
17739         unsigned ShAmt = TrueC->getAPIntValue().logBase2();
17740         Cond = DAG.getNode(ISD::SHL, DL, Cond.getValueType(), Cond,
17741                            DAG.getConstant(ShAmt, MVT::i8));
17742         if (N->getNumValues() == 2)  // Dead flag value?
17743           return DCI.CombineTo(N, Cond, SDValue());
17744         return Cond;
17745       }
17746
17747       // Optimize Cond ? cst+1 : cst -> zext(setcc(C)+cst.  This is efficient
17748       // for any integer data type, including i8/i16.
17749       if (FalseC->getAPIntValue()+1 == TrueC->getAPIntValue()) {
17750         Cond = DAG.getNode(X86ISD::SETCC, DL, MVT::i8,
17751                            DAG.getConstant(CC, MVT::i8), Cond);
17752
17753         // Zero extend the condition if needed.
17754         Cond = DAG.getNode(ISD::ZERO_EXTEND, DL,
17755                            FalseC->getValueType(0), Cond);
17756         Cond = DAG.getNode(ISD::ADD, DL, Cond.getValueType(), Cond,
17757                            SDValue(FalseC, 0));
17758
17759         if (N->getNumValues() == 2)  // Dead flag value?
17760           return DCI.CombineTo(N, Cond, SDValue());
17761         return Cond;
17762       }
17763
17764       // Optimize cases that will turn into an LEA instruction.  This requires
17765       // an i32 or i64 and an efficient multiplier (1, 2, 3, 4, 5, 8, 9).
17766       if (N->getValueType(0) == MVT::i32 || N->getValueType(0) == MVT::i64) {
17767         uint64_t Diff = TrueC->getZExtValue()-FalseC->getZExtValue();
17768         if (N->getValueType(0) == MVT::i32) Diff = (unsigned)Diff;
17769
17770         bool isFastMultiplier = false;
17771         if (Diff < 10) {
17772           switch ((unsigned char)Diff) {
17773           default: break;
17774           case 1:  // result = add base, cond
17775           case 2:  // result = lea base(    , cond*2)
17776           case 3:  // result = lea base(cond, cond*2)
17777           case 4:  // result = lea base(    , cond*4)
17778           case 5:  // result = lea base(cond, cond*4)
17779           case 8:  // result = lea base(    , cond*8)
17780           case 9:  // result = lea base(cond, cond*8)
17781             isFastMultiplier = true;
17782             break;
17783           }
17784         }
17785
17786         if (isFastMultiplier) {
17787           APInt Diff = TrueC->getAPIntValue()-FalseC->getAPIntValue();
17788           Cond = DAG.getNode(X86ISD::SETCC, DL, MVT::i8,
17789                              DAG.getConstant(CC, MVT::i8), Cond);
17790           // Zero extend the condition if needed.
17791           Cond = DAG.getNode(ISD::ZERO_EXTEND, DL, FalseC->getValueType(0),
17792                              Cond);
17793           // Scale the condition by the difference.
17794           if (Diff != 1)
17795             Cond = DAG.getNode(ISD::MUL, DL, Cond.getValueType(), Cond,
17796                                DAG.getConstant(Diff, Cond.getValueType()));
17797
17798           // Add the base if non-zero.
17799           if (FalseC->getAPIntValue() != 0)
17800             Cond = DAG.getNode(ISD::ADD, DL, Cond.getValueType(), Cond,
17801                                SDValue(FalseC, 0));
17802           if (N->getNumValues() == 2)  // Dead flag value?
17803             return DCI.CombineTo(N, Cond, SDValue());
17804           return Cond;
17805         }
17806       }
17807     }
17808   }
17809
17810   // Handle these cases:
17811   //   (select (x != c), e, c) -> select (x != c), e, x),
17812   //   (select (x == c), c, e) -> select (x == c), x, e)
17813   // where the c is an integer constant, and the "select" is the combination
17814   // of CMOV and CMP.
17815   //
17816   // The rationale for this change is that the conditional-move from a constant
17817   // needs two instructions, however, conditional-move from a register needs
17818   // only one instruction.
17819   //
17820   // CAVEAT: By replacing a constant with a symbolic value, it may obscure
17821   //  some instruction-combining opportunities. This opt needs to be
17822   //  postponed as late as possible.
17823   //
17824   if (!DCI.isBeforeLegalize() && !DCI.isBeforeLegalizeOps()) {
17825     // the DCI.xxxx conditions are provided to postpone the optimization as
17826     // late as possible.
17827
17828     ConstantSDNode *CmpAgainst = 0;
17829     if ((Cond.getOpcode() == X86ISD::CMP || Cond.getOpcode() == X86ISD::SUB) &&
17830         (CmpAgainst = dyn_cast<ConstantSDNode>(Cond.getOperand(1))) &&
17831         !isa<ConstantSDNode>(Cond.getOperand(0))) {
17832
17833       if (CC == X86::COND_NE &&
17834           CmpAgainst == dyn_cast<ConstantSDNode>(FalseOp)) {
17835         CC = X86::GetOppositeBranchCondition(CC);
17836         std::swap(TrueOp, FalseOp);
17837       }
17838
17839       if (CC == X86::COND_E &&
17840           CmpAgainst == dyn_cast<ConstantSDNode>(TrueOp)) {
17841         SDValue Ops[] = { FalseOp, Cond.getOperand(0),
17842                           DAG.getConstant(CC, MVT::i8), Cond };
17843         return DAG.getNode(X86ISD::CMOV, DL, N->getVTList (), Ops,
17844                            array_lengthof(Ops));
17845       }
17846     }
17847   }
17848
17849   return SDValue();
17850 }
17851
17852 /// PerformMulCombine - Optimize a single multiply with constant into two
17853 /// in order to implement it with two cheaper instructions, e.g.
17854 /// LEA + SHL, LEA + LEA.
17855 static SDValue PerformMulCombine(SDNode *N, SelectionDAG &DAG,
17856                                  TargetLowering::DAGCombinerInfo &DCI) {
17857   if (DCI.isBeforeLegalize() || DCI.isCalledByLegalizer())
17858     return SDValue();
17859
17860   EVT VT = N->getValueType(0);
17861   if (VT != MVT::i64)
17862     return SDValue();
17863
17864   ConstantSDNode *C = dyn_cast<ConstantSDNode>(N->getOperand(1));
17865   if (!C)
17866     return SDValue();
17867   uint64_t MulAmt = C->getZExtValue();
17868   if (isPowerOf2_64(MulAmt) || MulAmt == 3 || MulAmt == 5 || MulAmt == 9)
17869     return SDValue();
17870
17871   uint64_t MulAmt1 = 0;
17872   uint64_t MulAmt2 = 0;
17873   if ((MulAmt % 9) == 0) {
17874     MulAmt1 = 9;
17875     MulAmt2 = MulAmt / 9;
17876   } else if ((MulAmt % 5) == 0) {
17877     MulAmt1 = 5;
17878     MulAmt2 = MulAmt / 5;
17879   } else if ((MulAmt % 3) == 0) {
17880     MulAmt1 = 3;
17881     MulAmt2 = MulAmt / 3;
17882   }
17883   if (MulAmt2 &&
17884       (isPowerOf2_64(MulAmt2) || MulAmt2 == 3 || MulAmt2 == 5 || MulAmt2 == 9)){
17885     SDLoc DL(N);
17886
17887     if (isPowerOf2_64(MulAmt2) &&
17888         !(N->hasOneUse() && N->use_begin()->getOpcode() == ISD::ADD))
17889       // If second multiplifer is pow2, issue it first. We want the multiply by
17890       // 3, 5, or 9 to be folded into the addressing mode unless the lone use
17891       // is an add.
17892       std::swap(MulAmt1, MulAmt2);
17893
17894     SDValue NewMul;
17895     if (isPowerOf2_64(MulAmt1))
17896       NewMul = DAG.getNode(ISD::SHL, DL, VT, N->getOperand(0),
17897                            DAG.getConstant(Log2_64(MulAmt1), MVT::i8));
17898     else
17899       NewMul = DAG.getNode(X86ISD::MUL_IMM, DL, VT, N->getOperand(0),
17900                            DAG.getConstant(MulAmt1, VT));
17901
17902     if (isPowerOf2_64(MulAmt2))
17903       NewMul = DAG.getNode(ISD::SHL, DL, VT, NewMul,
17904                            DAG.getConstant(Log2_64(MulAmt2), MVT::i8));
17905     else
17906       NewMul = DAG.getNode(X86ISD::MUL_IMM, DL, VT, NewMul,
17907                            DAG.getConstant(MulAmt2, VT));
17908
17909     // Do not add new nodes to DAG combiner worklist.
17910     DCI.CombineTo(N, NewMul, false);
17911   }
17912   return SDValue();
17913 }
17914
17915 static SDValue PerformSHLCombine(SDNode *N, SelectionDAG &DAG) {
17916   SDValue N0 = N->getOperand(0);
17917   SDValue N1 = N->getOperand(1);
17918   ConstantSDNode *N1C = dyn_cast<ConstantSDNode>(N1);
17919   EVT VT = N0.getValueType();
17920
17921   // fold (shl (and (setcc_c), c1), c2) -> (and setcc_c, (c1 << c2))
17922   // since the result of setcc_c is all zero's or all ones.
17923   if (VT.isInteger() && !VT.isVector() &&
17924       N1C && N0.getOpcode() == ISD::AND &&
17925       N0.getOperand(1).getOpcode() == ISD::Constant) {
17926     SDValue N00 = N0.getOperand(0);
17927     if (N00.getOpcode() == X86ISD::SETCC_CARRY ||
17928         ((N00.getOpcode() == ISD::ANY_EXTEND ||
17929           N00.getOpcode() == ISD::ZERO_EXTEND) &&
17930          N00.getOperand(0).getOpcode() == X86ISD::SETCC_CARRY)) {
17931       APInt Mask = cast<ConstantSDNode>(N0.getOperand(1))->getAPIntValue();
17932       APInt ShAmt = N1C->getAPIntValue();
17933       Mask = Mask.shl(ShAmt);
17934       if (Mask != 0)
17935         return DAG.getNode(ISD::AND, SDLoc(N), VT,
17936                            N00, DAG.getConstant(Mask, VT));
17937     }
17938   }
17939
17940   // Hardware support for vector shifts is sparse which makes us scalarize the
17941   // vector operations in many cases. Also, on sandybridge ADD is faster than
17942   // shl.
17943   // (shl V, 1) -> add V,V
17944   if (isSplatVector(N1.getNode())) {
17945     assert(N0.getValueType().isVector() && "Invalid vector shift type");
17946     ConstantSDNode *N1C = dyn_cast<ConstantSDNode>(N1->getOperand(0));
17947     // We shift all of the values by one. In many cases we do not have
17948     // hardware support for this operation. This is better expressed as an ADD
17949     // of two values.
17950     if (N1C && (1 == N1C->getZExtValue())) {
17951       return DAG.getNode(ISD::ADD, SDLoc(N), VT, N0, N0);
17952     }
17953   }
17954
17955   return SDValue();
17956 }
17957
17958 /// \brief Returns a vector of 0s if the node in input is a vector logical
17959 /// shift by a constant amount which is known to be bigger than or equal
17960 /// to the vector element size in bits.
17961 static SDValue performShiftToAllZeros(SDNode *N, SelectionDAG &DAG,
17962                                       const X86Subtarget *Subtarget) {
17963   EVT VT = N->getValueType(0);
17964
17965   if (VT != MVT::v2i64 && VT != MVT::v4i32 && VT != MVT::v8i16 &&
17966       (!Subtarget->hasInt256() ||
17967        (VT != MVT::v4i64 && VT != MVT::v8i32 && VT != MVT::v16i16)))
17968     return SDValue();
17969
17970   SDValue Amt = N->getOperand(1);
17971   SDLoc DL(N);
17972   if (isSplatVector(Amt.getNode())) {
17973     SDValue SclrAmt = Amt->getOperand(0);
17974     if (ConstantSDNode *C = dyn_cast<ConstantSDNode>(SclrAmt)) {
17975       APInt ShiftAmt = C->getAPIntValue();
17976       unsigned MaxAmount = VT.getVectorElementType().getSizeInBits();
17977
17978       // SSE2/AVX2 logical shifts always return a vector of 0s
17979       // if the shift amount is bigger than or equal to
17980       // the element size. The constant shift amount will be
17981       // encoded as a 8-bit immediate.
17982       if (ShiftAmt.trunc(8).uge(MaxAmount))
17983         return getZeroVector(VT, Subtarget, DAG, DL);
17984     }
17985   }
17986
17987   return SDValue();
17988 }
17989
17990 /// PerformShiftCombine - Combine shifts.
17991 static SDValue PerformShiftCombine(SDNode* N, SelectionDAG &DAG,
17992                                    TargetLowering::DAGCombinerInfo &DCI,
17993                                    const X86Subtarget *Subtarget) {
17994   if (N->getOpcode() == ISD::SHL) {
17995     SDValue V = PerformSHLCombine(N, DAG);
17996     if (V.getNode()) return V;
17997   }
17998
17999   if (N->getOpcode() != ISD::SRA) {
18000     // Try to fold this logical shift into a zero vector.
18001     SDValue V = performShiftToAllZeros(N, DAG, Subtarget);
18002     if (V.getNode()) return V;
18003   }
18004
18005   return SDValue();
18006 }
18007
18008 // CMPEQCombine - Recognize the distinctive  (AND (setcc ...) (setcc ..))
18009 // where both setccs reference the same FP CMP, and rewrite for CMPEQSS
18010 // and friends.  Likewise for OR -> CMPNEQSS.
18011 static SDValue CMPEQCombine(SDNode *N, SelectionDAG &DAG,
18012                             TargetLowering::DAGCombinerInfo &DCI,
18013                             const X86Subtarget *Subtarget) {
18014   unsigned opcode;
18015
18016   // SSE1 supports CMP{eq|ne}SS, and SSE2 added CMP{eq|ne}SD, but
18017   // we're requiring SSE2 for both.
18018   if (Subtarget->hasSSE2() && isAndOrOfSetCCs(SDValue(N, 0U), opcode)) {
18019     SDValue N0 = N->getOperand(0);
18020     SDValue N1 = N->getOperand(1);
18021     SDValue CMP0 = N0->getOperand(1);
18022     SDValue CMP1 = N1->getOperand(1);
18023     SDLoc DL(N);
18024
18025     // The SETCCs should both refer to the same CMP.
18026     if (CMP0.getOpcode() != X86ISD::CMP || CMP0 != CMP1)
18027       return SDValue();
18028
18029     SDValue CMP00 = CMP0->getOperand(0);
18030     SDValue CMP01 = CMP0->getOperand(1);
18031     EVT     VT    = CMP00.getValueType();
18032
18033     if (VT == MVT::f32 || VT == MVT::f64) {
18034       bool ExpectingFlags = false;
18035       // Check for any users that want flags:
18036       for (SDNode::use_iterator UI = N->use_begin(), UE = N->use_end();
18037            !ExpectingFlags && UI != UE; ++UI)
18038         switch (UI->getOpcode()) {
18039         default:
18040         case ISD::BR_CC:
18041         case ISD::BRCOND:
18042         case ISD::SELECT:
18043           ExpectingFlags = true;
18044           break;
18045         case ISD::CopyToReg:
18046         case ISD::SIGN_EXTEND:
18047         case ISD::ZERO_EXTEND:
18048         case ISD::ANY_EXTEND:
18049           break;
18050         }
18051
18052       if (!ExpectingFlags) {
18053         enum X86::CondCode cc0 = (enum X86::CondCode)N0.getConstantOperandVal(0);
18054         enum X86::CondCode cc1 = (enum X86::CondCode)N1.getConstantOperandVal(0);
18055
18056         if (cc1 == X86::COND_E || cc1 == X86::COND_NE) {
18057           X86::CondCode tmp = cc0;
18058           cc0 = cc1;
18059           cc1 = tmp;
18060         }
18061
18062         if ((cc0 == X86::COND_E  && cc1 == X86::COND_NP) ||
18063             (cc0 == X86::COND_NE && cc1 == X86::COND_P)) {
18064           // FIXME: need symbolic constants for these magic numbers.
18065           // See X86ATTInstPrinter.cpp:printSSECC().
18066           unsigned x86cc = (cc0 == X86::COND_E) ? 0 : 4;
18067           if (Subtarget->hasAVX512()) {
18068             SDValue FSetCC = DAG.getNode(X86ISD::FSETCC, DL, MVT::i1, CMP00,
18069                                          CMP01, DAG.getConstant(x86cc, MVT::i8));
18070             if (N->getValueType(0) != MVT::i1)
18071               return DAG.getNode(ISD::ZERO_EXTEND, DL, N->getValueType(0),
18072                                  FSetCC);
18073             return FSetCC;
18074           }
18075           SDValue OnesOrZeroesF = DAG.getNode(X86ISD::FSETCC, DL,
18076                                               CMP00.getValueType(), CMP00, CMP01,
18077                                               DAG.getConstant(x86cc, MVT::i8));
18078
18079           bool is64BitFP = (CMP00.getValueType() == MVT::f64);
18080           MVT IntVT = is64BitFP ? MVT::i64 : MVT::i32;
18081
18082           if (is64BitFP && !Subtarget->is64Bit()) {
18083             // On a 32-bit target, we cannot bitcast the 64-bit float to a
18084             // 64-bit integer, since that's not a legal type. Since
18085             // OnesOrZeroesF is all ones of all zeroes, we don't need all the
18086             // bits, but can do this little dance to extract the lowest 32 bits
18087             // and work with those going forward.
18088             SDValue Vector64 = DAG.getNode(ISD::SCALAR_TO_VECTOR, DL, MVT::v2f64,
18089                                            OnesOrZeroesF);
18090             SDValue Vector32 = DAG.getNode(ISD::BITCAST, DL, MVT::v4f32,
18091                                            Vector64);
18092             OnesOrZeroesF = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, DL, MVT::f32,
18093                                         Vector32, DAG.getIntPtrConstant(0));
18094             IntVT = MVT::i32;
18095           }
18096
18097           SDValue OnesOrZeroesI = DAG.getNode(ISD::BITCAST, DL, IntVT, OnesOrZeroesF);
18098           SDValue ANDed = DAG.getNode(ISD::AND, DL, IntVT, OnesOrZeroesI,
18099                                       DAG.getConstant(1, IntVT));
18100           SDValue OneBitOfTruth = DAG.getNode(ISD::TRUNCATE, DL, MVT::i8, ANDed);
18101           return OneBitOfTruth;
18102         }
18103       }
18104     }
18105   }
18106   return SDValue();
18107 }
18108
18109 /// CanFoldXORWithAllOnes - Test whether the XOR operand is a AllOnes vector
18110 /// so it can be folded inside ANDNP.
18111 static bool CanFoldXORWithAllOnes(const SDNode *N) {
18112   EVT VT = N->getValueType(0);
18113
18114   // Match direct AllOnes for 128 and 256-bit vectors
18115   if (ISD::isBuildVectorAllOnes(N))
18116     return true;
18117
18118   // Look through a bit convert.
18119   if (N->getOpcode() == ISD::BITCAST)
18120     N = N->getOperand(0).getNode();
18121
18122   // Sometimes the operand may come from a insert_subvector building a 256-bit
18123   // allones vector
18124   if (VT.is256BitVector() &&
18125       N->getOpcode() == ISD::INSERT_SUBVECTOR) {
18126     SDValue V1 = N->getOperand(0);
18127     SDValue V2 = N->getOperand(1);
18128
18129     if (V1.getOpcode() == ISD::INSERT_SUBVECTOR &&
18130         V1.getOperand(0).getOpcode() == ISD::UNDEF &&
18131         ISD::isBuildVectorAllOnes(V1.getOperand(1).getNode()) &&
18132         ISD::isBuildVectorAllOnes(V2.getNode()))
18133       return true;
18134   }
18135
18136   return false;
18137 }
18138
18139 // On AVX/AVX2 the type v8i1 is legalized to v8i16, which is an XMM sized
18140 // register. In most cases we actually compare or select YMM-sized registers
18141 // and mixing the two types creates horrible code. This method optimizes
18142 // some of the transition sequences.
18143 static SDValue WidenMaskArithmetic(SDNode *N, SelectionDAG &DAG,
18144                                  TargetLowering::DAGCombinerInfo &DCI,
18145                                  const X86Subtarget *Subtarget) {
18146   EVT VT = N->getValueType(0);
18147   if (!VT.is256BitVector())
18148     return SDValue();
18149
18150   assert((N->getOpcode() == ISD::ANY_EXTEND ||
18151           N->getOpcode() == ISD::ZERO_EXTEND ||
18152           N->getOpcode() == ISD::SIGN_EXTEND) && "Invalid Node");
18153
18154   SDValue Narrow = N->getOperand(0);
18155   EVT NarrowVT = Narrow->getValueType(0);
18156   if (!NarrowVT.is128BitVector())
18157     return SDValue();
18158
18159   if (Narrow->getOpcode() != ISD::XOR &&
18160       Narrow->getOpcode() != ISD::AND &&
18161       Narrow->getOpcode() != ISD::OR)
18162     return SDValue();
18163
18164   SDValue N0  = Narrow->getOperand(0);
18165   SDValue N1  = Narrow->getOperand(1);
18166   SDLoc DL(Narrow);
18167
18168   // The Left side has to be a trunc.
18169   if (N0.getOpcode() != ISD::TRUNCATE)
18170     return SDValue();
18171
18172   // The type of the truncated inputs.
18173   EVT WideVT = N0->getOperand(0)->getValueType(0);
18174   if (WideVT != VT)
18175     return SDValue();
18176
18177   // The right side has to be a 'trunc' or a constant vector.
18178   bool RHSTrunc = N1.getOpcode() == ISD::TRUNCATE;
18179   bool RHSConst = (isSplatVector(N1.getNode()) &&
18180                    isa<ConstantSDNode>(N1->getOperand(0)));
18181   if (!RHSTrunc && !RHSConst)
18182     return SDValue();
18183
18184   const TargetLowering &TLI = DAG.getTargetLoweringInfo();
18185
18186   if (!TLI.isOperationLegalOrPromote(Narrow->getOpcode(), WideVT))
18187     return SDValue();
18188
18189   // Set N0 and N1 to hold the inputs to the new wide operation.
18190   N0 = N0->getOperand(0);
18191   if (RHSConst) {
18192     N1 = DAG.getNode(ISD::ZERO_EXTEND, DL, WideVT.getScalarType(),
18193                      N1->getOperand(0));
18194     SmallVector<SDValue, 8> C(WideVT.getVectorNumElements(), N1);
18195     N1 = DAG.getNode(ISD::BUILD_VECTOR, DL, WideVT, &C[0], C.size());
18196   } else if (RHSTrunc) {
18197     N1 = N1->getOperand(0);
18198   }
18199
18200   // Generate the wide operation.
18201   SDValue Op = DAG.getNode(Narrow->getOpcode(), DL, WideVT, N0, N1);
18202   unsigned Opcode = N->getOpcode();
18203   switch (Opcode) {
18204   case ISD::ANY_EXTEND:
18205     return Op;
18206   case ISD::ZERO_EXTEND: {
18207     unsigned InBits = NarrowVT.getScalarType().getSizeInBits();
18208     APInt Mask = APInt::getAllOnesValue(InBits);
18209     Mask = Mask.zext(VT.getScalarType().getSizeInBits());
18210     return DAG.getNode(ISD::AND, DL, VT,
18211                        Op, DAG.getConstant(Mask, VT));
18212   }
18213   case ISD::SIGN_EXTEND:
18214     return DAG.getNode(ISD::SIGN_EXTEND_INREG, DL, VT,
18215                        Op, DAG.getValueType(NarrowVT));
18216   default:
18217     llvm_unreachable("Unexpected opcode");
18218   }
18219 }
18220
18221 static SDValue PerformAndCombine(SDNode *N, SelectionDAG &DAG,
18222                                  TargetLowering::DAGCombinerInfo &DCI,
18223                                  const X86Subtarget *Subtarget) {
18224   EVT VT = N->getValueType(0);
18225   if (DCI.isBeforeLegalizeOps())
18226     return SDValue();
18227
18228   SDValue R = CMPEQCombine(N, DAG, DCI, Subtarget);
18229   if (R.getNode())
18230     return R;
18231
18232   // Create BEXTR and BZHI instructions
18233   // BZHI is X & ((1 << Y) - 1)
18234   // BEXTR is ((X >> imm) & (2**size-1))
18235   if (VT == MVT::i32 || VT == MVT::i64) {
18236     SDValue N0 = N->getOperand(0);
18237     SDValue N1 = N->getOperand(1);
18238     SDLoc DL(N);
18239
18240     if (Subtarget->hasBMI2()) {
18241       // Check for (and (add (shl 1, Y), -1), X)
18242       if (N0.getOpcode() == ISD::ADD && isAllOnes(N0.getOperand(1))) {
18243         SDValue N00 = N0.getOperand(0);
18244         if (N00.getOpcode() == ISD::SHL) {
18245           SDValue N001 = N00.getOperand(1);
18246           assert(N001.getValueType() == MVT::i8 && "unexpected type");
18247           ConstantSDNode *C = dyn_cast<ConstantSDNode>(N00.getOperand(0));
18248           if (C && C->getZExtValue() == 1)
18249             return DAG.getNode(X86ISD::BZHI, DL, VT, N1, N001);
18250         }
18251       }
18252
18253       // Check for (and X, (add (shl 1, Y), -1))
18254       if (N1.getOpcode() == ISD::ADD && isAllOnes(N1.getOperand(1))) {
18255         SDValue N10 = N1.getOperand(0);
18256         if (N10.getOpcode() == ISD::SHL) {
18257           SDValue N101 = N10.getOperand(1);
18258           assert(N101.getValueType() == MVT::i8 && "unexpected type");
18259           ConstantSDNode *C = dyn_cast<ConstantSDNode>(N10.getOperand(0));
18260           if (C && C->getZExtValue() == 1)
18261             return DAG.getNode(X86ISD::BZHI, DL, VT, N0, N101);
18262         }
18263       }
18264     }
18265
18266     // Check for BEXTR.
18267     if ((Subtarget->hasBMI() || Subtarget->hasTBM()) &&
18268         (N0.getOpcode() == ISD::SRA || N0.getOpcode() == ISD::SRL)) {
18269       ConstantSDNode *MaskNode = dyn_cast<ConstantSDNode>(N1);
18270       ConstantSDNode *ShiftNode = dyn_cast<ConstantSDNode>(N0.getOperand(1));
18271       if (MaskNode && ShiftNode) {
18272         uint64_t Mask = MaskNode->getZExtValue();
18273         uint64_t Shift = ShiftNode->getZExtValue();
18274         if (isMask_64(Mask)) {
18275           uint64_t MaskSize = CountPopulation_64(Mask);
18276           if (Shift + MaskSize <= VT.getSizeInBits())
18277             return DAG.getNode(X86ISD::BEXTR, DL, VT, N0.getOperand(0),
18278                                DAG.getConstant(Shift | (MaskSize << 8), VT));
18279         }
18280       }
18281     } // BEXTR
18282
18283     return SDValue();
18284   }
18285
18286   // Want to form ANDNP nodes:
18287   // 1) In the hopes of then easily combining them with OR and AND nodes
18288   //    to form PBLEND/PSIGN.
18289   // 2) To match ANDN packed intrinsics
18290   if (VT != MVT::v2i64 && VT != MVT::v4i64)
18291     return SDValue();
18292
18293   SDValue N0 = N->getOperand(0);
18294   SDValue N1 = N->getOperand(1);
18295   SDLoc DL(N);
18296
18297   // Check LHS for vnot
18298   if (N0.getOpcode() == ISD::XOR &&
18299       //ISD::isBuildVectorAllOnes(N0.getOperand(1).getNode()))
18300       CanFoldXORWithAllOnes(N0.getOperand(1).getNode()))
18301     return DAG.getNode(X86ISD::ANDNP, DL, VT, N0.getOperand(0), N1);
18302
18303   // Check RHS for vnot
18304   if (N1.getOpcode() == ISD::XOR &&
18305       //ISD::isBuildVectorAllOnes(N1.getOperand(1).getNode()))
18306       CanFoldXORWithAllOnes(N1.getOperand(1).getNode()))
18307     return DAG.getNode(X86ISD::ANDNP, DL, VT, N1.getOperand(0), N0);
18308
18309   return SDValue();
18310 }
18311
18312 static SDValue PerformOrCombine(SDNode *N, SelectionDAG &DAG,
18313                                 TargetLowering::DAGCombinerInfo &DCI,
18314                                 const X86Subtarget *Subtarget) {
18315   if (DCI.isBeforeLegalizeOps())
18316     return SDValue();
18317
18318   SDValue R = CMPEQCombine(N, DAG, DCI, Subtarget);
18319   if (R.getNode())
18320     return R;
18321
18322   SDValue N0 = N->getOperand(0);
18323   SDValue N1 = N->getOperand(1);
18324   EVT VT = N->getValueType(0);
18325
18326   // look for psign/blend
18327   if (VT == MVT::v2i64 || VT == MVT::v4i64) {
18328     if (!Subtarget->hasSSSE3() ||
18329         (VT == MVT::v4i64 && !Subtarget->hasInt256()))
18330       return SDValue();
18331
18332     // Canonicalize pandn to RHS
18333     if (N0.getOpcode() == X86ISD::ANDNP)
18334       std::swap(N0, N1);
18335     // or (and (m, y), (pandn m, x))
18336     if (N0.getOpcode() == ISD::AND && N1.getOpcode() == X86ISD::ANDNP) {
18337       SDValue Mask = N1.getOperand(0);
18338       SDValue X    = N1.getOperand(1);
18339       SDValue Y;
18340       if (N0.getOperand(0) == Mask)
18341         Y = N0.getOperand(1);
18342       if (N0.getOperand(1) == Mask)
18343         Y = N0.getOperand(0);
18344
18345       // Check to see if the mask appeared in both the AND and ANDNP and
18346       if (!Y.getNode())
18347         return SDValue();
18348
18349       // Validate that X, Y, and Mask are BIT_CONVERTS, and see through them.
18350       // Look through mask bitcast.
18351       if (Mask.getOpcode() == ISD::BITCAST)
18352         Mask = Mask.getOperand(0);
18353       if (X.getOpcode() == ISD::BITCAST)
18354         X = X.getOperand(0);
18355       if (Y.getOpcode() == ISD::BITCAST)
18356         Y = Y.getOperand(0);
18357
18358       EVT MaskVT = Mask.getValueType();
18359
18360       // Validate that the Mask operand is a vector sra node.
18361       // FIXME: what to do for bytes, since there is a psignb/pblendvb, but
18362       // there is no psrai.b
18363       unsigned EltBits = MaskVT.getVectorElementType().getSizeInBits();
18364       unsigned SraAmt = ~0;
18365       if (Mask.getOpcode() == ISD::SRA) {
18366         SDValue Amt = Mask.getOperand(1);
18367         if (isSplatVector(Amt.getNode())) {
18368           SDValue SclrAmt = Amt->getOperand(0);
18369           if (ConstantSDNode *C = dyn_cast<ConstantSDNode>(SclrAmt))
18370             SraAmt = C->getZExtValue();
18371         }
18372       } else if (Mask.getOpcode() == X86ISD::VSRAI) {
18373         SDValue SraC = Mask.getOperand(1);
18374         SraAmt  = cast<ConstantSDNode>(SraC)->getZExtValue();
18375       }
18376       if ((SraAmt + 1) != EltBits)
18377         return SDValue();
18378
18379       SDLoc DL(N);
18380
18381       // Now we know we at least have a plendvb with the mask val.  See if
18382       // we can form a psignb/w/d.
18383       // psign = x.type == y.type == mask.type && y = sub(0, x);
18384       if (Y.getOpcode() == ISD::SUB && Y.getOperand(1) == X &&
18385           ISD::isBuildVectorAllZeros(Y.getOperand(0).getNode()) &&
18386           X.getValueType() == MaskVT && Y.getValueType() == MaskVT) {
18387         assert((EltBits == 8 || EltBits == 16 || EltBits == 32) &&
18388                "Unsupported VT for PSIGN");
18389         Mask = DAG.getNode(X86ISD::PSIGN, DL, MaskVT, X, Mask.getOperand(0));
18390         return DAG.getNode(ISD::BITCAST, DL, VT, Mask);
18391       }
18392       // PBLENDVB only available on SSE 4.1
18393       if (!Subtarget->hasSSE41())
18394         return SDValue();
18395
18396       EVT BlendVT = (VT == MVT::v4i64) ? MVT::v32i8 : MVT::v16i8;
18397
18398       X = DAG.getNode(ISD::BITCAST, DL, BlendVT, X);
18399       Y = DAG.getNode(ISD::BITCAST, DL, BlendVT, Y);
18400       Mask = DAG.getNode(ISD::BITCAST, DL, BlendVT, Mask);
18401       Mask = DAG.getNode(ISD::VSELECT, DL, BlendVT, Mask, Y, X);
18402       return DAG.getNode(ISD::BITCAST, DL, VT, Mask);
18403     }
18404   }
18405
18406   if (VT != MVT::i16 && VT != MVT::i32 && VT != MVT::i64)
18407     return SDValue();
18408
18409   // fold (or (x << c) | (y >> (64 - c))) ==> (shld64 x, y, c)
18410   MachineFunction &MF = DAG.getMachineFunction();
18411   bool OptForSize = MF.getFunction()->getAttributes().
18412     hasAttribute(AttributeSet::FunctionIndex, Attribute::OptimizeForSize);
18413
18414   // SHLD/SHRD instructions have lower register pressure, but on some
18415   // platforms they have higher latency than the equivalent
18416   // series of shifts/or that would otherwise be generated.
18417   // Don't fold (or (x << c) | (y >> (64 - c))) if SHLD/SHRD instructions
18418   // have higher latencies and we are not optimizing for size.
18419   if (!OptForSize && Subtarget->isSHLDSlow())
18420     return SDValue();
18421
18422   if (N0.getOpcode() == ISD::SRL && N1.getOpcode() == ISD::SHL)
18423     std::swap(N0, N1);
18424   if (N0.getOpcode() != ISD::SHL || N1.getOpcode() != ISD::SRL)
18425     return SDValue();
18426   if (!N0.hasOneUse() || !N1.hasOneUse())
18427     return SDValue();
18428
18429   SDValue ShAmt0 = N0.getOperand(1);
18430   if (ShAmt0.getValueType() != MVT::i8)
18431     return SDValue();
18432   SDValue ShAmt1 = N1.getOperand(1);
18433   if (ShAmt1.getValueType() != MVT::i8)
18434     return SDValue();
18435   if (ShAmt0.getOpcode() == ISD::TRUNCATE)
18436     ShAmt0 = ShAmt0.getOperand(0);
18437   if (ShAmt1.getOpcode() == ISD::TRUNCATE)
18438     ShAmt1 = ShAmt1.getOperand(0);
18439
18440   SDLoc DL(N);
18441   unsigned Opc = X86ISD::SHLD;
18442   SDValue Op0 = N0.getOperand(0);
18443   SDValue Op1 = N1.getOperand(0);
18444   if (ShAmt0.getOpcode() == ISD::SUB) {
18445     Opc = X86ISD::SHRD;
18446     std::swap(Op0, Op1);
18447     std::swap(ShAmt0, ShAmt1);
18448   }
18449
18450   unsigned Bits = VT.getSizeInBits();
18451   if (ShAmt1.getOpcode() == ISD::SUB) {
18452     SDValue Sum = ShAmt1.getOperand(0);
18453     if (ConstantSDNode *SumC = dyn_cast<ConstantSDNode>(Sum)) {
18454       SDValue ShAmt1Op1 = ShAmt1.getOperand(1);
18455       if (ShAmt1Op1.getNode()->getOpcode() == ISD::TRUNCATE)
18456         ShAmt1Op1 = ShAmt1Op1.getOperand(0);
18457       if (SumC->getSExtValue() == Bits && ShAmt1Op1 == ShAmt0)
18458         return DAG.getNode(Opc, DL, VT,
18459                            Op0, Op1,
18460                            DAG.getNode(ISD::TRUNCATE, DL,
18461                                        MVT::i8, ShAmt0));
18462     }
18463   } else if (ConstantSDNode *ShAmt1C = dyn_cast<ConstantSDNode>(ShAmt1)) {
18464     ConstantSDNode *ShAmt0C = dyn_cast<ConstantSDNode>(ShAmt0);
18465     if (ShAmt0C &&
18466         ShAmt0C->getSExtValue() + ShAmt1C->getSExtValue() == Bits)
18467       return DAG.getNode(Opc, DL, VT,
18468                          N0.getOperand(0), N1.getOperand(0),
18469                          DAG.getNode(ISD::TRUNCATE, DL,
18470                                        MVT::i8, ShAmt0));
18471   }
18472
18473   return SDValue();
18474 }
18475
18476 // Generate NEG and CMOV for integer abs.
18477 static SDValue performIntegerAbsCombine(SDNode *N, SelectionDAG &DAG) {
18478   EVT VT = N->getValueType(0);
18479
18480   // Since X86 does not have CMOV for 8-bit integer, we don't convert
18481   // 8-bit integer abs to NEG and CMOV.
18482   if (VT.isInteger() && VT.getSizeInBits() == 8)
18483     return SDValue();
18484
18485   SDValue N0 = N->getOperand(0);
18486   SDValue N1 = N->getOperand(1);
18487   SDLoc DL(N);
18488
18489   // Check pattern of XOR(ADD(X,Y), Y) where Y is SRA(X, size(X)-1)
18490   // and change it to SUB and CMOV.
18491   if (VT.isInteger() && N->getOpcode() == ISD::XOR &&
18492       N0.getOpcode() == ISD::ADD &&
18493       N0.getOperand(1) == N1 &&
18494       N1.getOpcode() == ISD::SRA &&
18495       N1.getOperand(0) == N0.getOperand(0))
18496     if (ConstantSDNode *Y1C = dyn_cast<ConstantSDNode>(N1.getOperand(1)))
18497       if (Y1C->getAPIntValue() == VT.getSizeInBits()-1) {
18498         // Generate SUB & CMOV.
18499         SDValue Neg = DAG.getNode(X86ISD::SUB, DL, DAG.getVTList(VT, MVT::i32),
18500                                   DAG.getConstant(0, VT), N0.getOperand(0));
18501
18502         SDValue Ops[] = { N0.getOperand(0), Neg,
18503                           DAG.getConstant(X86::COND_GE, MVT::i8),
18504                           SDValue(Neg.getNode(), 1) };
18505         return DAG.getNode(X86ISD::CMOV, DL, DAG.getVTList(VT, MVT::Glue),
18506                            Ops, array_lengthof(Ops));
18507       }
18508   return SDValue();
18509 }
18510
18511 // PerformXorCombine - Attempts to turn XOR nodes into BLSMSK nodes
18512 static SDValue PerformXorCombine(SDNode *N, SelectionDAG &DAG,
18513                                  TargetLowering::DAGCombinerInfo &DCI,
18514                                  const X86Subtarget *Subtarget) {
18515   if (DCI.isBeforeLegalizeOps())
18516     return SDValue();
18517
18518   if (Subtarget->hasCMov()) {
18519     SDValue RV = performIntegerAbsCombine(N, DAG);
18520     if (RV.getNode())
18521       return RV;
18522   }
18523
18524   return SDValue();
18525 }
18526
18527 /// PerformLOADCombine - Do target-specific dag combines on LOAD nodes.
18528 static SDValue PerformLOADCombine(SDNode *N, SelectionDAG &DAG,
18529                                   TargetLowering::DAGCombinerInfo &DCI,
18530                                   const X86Subtarget *Subtarget) {
18531   LoadSDNode *Ld = cast<LoadSDNode>(N);
18532   EVT RegVT = Ld->getValueType(0);
18533   EVT MemVT = Ld->getMemoryVT();
18534   SDLoc dl(Ld);
18535   const TargetLowering &TLI = DAG.getTargetLoweringInfo();
18536   unsigned RegSz = RegVT.getSizeInBits();
18537
18538   // On Sandybridge unaligned 256bit loads are inefficient.
18539   ISD::LoadExtType Ext = Ld->getExtensionType();
18540   unsigned Alignment = Ld->getAlignment();
18541   bool IsAligned = Alignment == 0 || Alignment >= MemVT.getSizeInBits()/8;
18542   if (RegVT.is256BitVector() && !Subtarget->hasInt256() &&
18543       !DCI.isBeforeLegalizeOps() && !IsAligned && Ext == ISD::NON_EXTLOAD) {
18544     unsigned NumElems = RegVT.getVectorNumElements();
18545     if (NumElems < 2)
18546       return SDValue();
18547
18548     SDValue Ptr = Ld->getBasePtr();
18549     SDValue Increment = DAG.getConstant(16, TLI.getPointerTy());
18550
18551     EVT HalfVT = EVT::getVectorVT(*DAG.getContext(), MemVT.getScalarType(),
18552                                   NumElems/2);
18553     SDValue Load1 = DAG.getLoad(HalfVT, dl, Ld->getChain(), Ptr,
18554                                 Ld->getPointerInfo(), Ld->isVolatile(),
18555                                 Ld->isNonTemporal(), Ld->isInvariant(),
18556                                 Alignment);
18557     Ptr = DAG.getNode(ISD::ADD, dl, Ptr.getValueType(), Ptr, Increment);
18558     SDValue Load2 = DAG.getLoad(HalfVT, dl, Ld->getChain(), Ptr,
18559                                 Ld->getPointerInfo(), Ld->isVolatile(),
18560                                 Ld->isNonTemporal(), Ld->isInvariant(),
18561                                 std::min(16U, Alignment));
18562     SDValue TF = DAG.getNode(ISD::TokenFactor, dl, MVT::Other,
18563                              Load1.getValue(1),
18564                              Load2.getValue(1));
18565
18566     SDValue NewVec = DAG.getUNDEF(RegVT);
18567     NewVec = Insert128BitVector(NewVec, Load1, 0, DAG, dl);
18568     NewVec = Insert128BitVector(NewVec, Load2, NumElems/2, DAG, dl);
18569     return DCI.CombineTo(N, NewVec, TF, true);
18570   }
18571
18572   // If this is a vector EXT Load then attempt to optimize it using a
18573   // shuffle. If SSSE3 is not available we may emit an illegal shuffle but the
18574   // expansion is still better than scalar code.
18575   // We generate X86ISD::VSEXT for SEXTLOADs if it's available, otherwise we'll
18576   // emit a shuffle and a arithmetic shift.
18577   // TODO: It is possible to support ZExt by zeroing the undef values
18578   // during the shuffle phase or after the shuffle.
18579   if (RegVT.isVector() && RegVT.isInteger() && Subtarget->hasSSE2() &&
18580       (Ext == ISD::EXTLOAD || Ext == ISD::SEXTLOAD)) {
18581     assert(MemVT != RegVT && "Cannot extend to the same type");
18582     assert(MemVT.isVector() && "Must load a vector from memory");
18583
18584     unsigned NumElems = RegVT.getVectorNumElements();
18585     unsigned MemSz = MemVT.getSizeInBits();
18586     assert(RegSz > MemSz && "Register size must be greater than the mem size");
18587
18588     if (Ext == ISD::SEXTLOAD && RegSz == 256 && !Subtarget->hasInt256())
18589       return SDValue();
18590
18591     // All sizes must be a power of two.
18592     if (!isPowerOf2_32(RegSz * MemSz * NumElems))
18593       return SDValue();
18594
18595     // Attempt to load the original value using scalar loads.
18596     // Find the largest scalar type that divides the total loaded size.
18597     MVT SclrLoadTy = MVT::i8;
18598     for (unsigned tp = MVT::FIRST_INTEGER_VALUETYPE;
18599          tp < MVT::LAST_INTEGER_VALUETYPE; ++tp) {
18600       MVT Tp = (MVT::SimpleValueType)tp;
18601       if (TLI.isTypeLegal(Tp) && ((MemSz % Tp.getSizeInBits()) == 0)) {
18602         SclrLoadTy = Tp;
18603       }
18604     }
18605
18606     // On 32bit systems, we can't save 64bit integers. Try bitcasting to F64.
18607     if (TLI.isTypeLegal(MVT::f64) && SclrLoadTy.getSizeInBits() < 64 &&
18608         (64 <= MemSz))
18609       SclrLoadTy = MVT::f64;
18610
18611     // Calculate the number of scalar loads that we need to perform
18612     // in order to load our vector from memory.
18613     unsigned NumLoads = MemSz / SclrLoadTy.getSizeInBits();
18614     if (Ext == ISD::SEXTLOAD && NumLoads > 1)
18615       return SDValue();
18616
18617     unsigned loadRegZize = RegSz;
18618     if (Ext == ISD::SEXTLOAD && RegSz == 256)
18619       loadRegZize /= 2;
18620
18621     // Represent our vector as a sequence of elements which are the
18622     // largest scalar that we can load.
18623     EVT LoadUnitVecVT = EVT::getVectorVT(*DAG.getContext(), SclrLoadTy,
18624       loadRegZize/SclrLoadTy.getSizeInBits());
18625
18626     // Represent the data using the same element type that is stored in
18627     // memory. In practice, we ''widen'' MemVT.
18628     EVT WideVecVT =
18629           EVT::getVectorVT(*DAG.getContext(), MemVT.getScalarType(),
18630                        loadRegZize/MemVT.getScalarType().getSizeInBits());
18631
18632     assert(WideVecVT.getSizeInBits() == LoadUnitVecVT.getSizeInBits() &&
18633       "Invalid vector type");
18634
18635     // We can't shuffle using an illegal type.
18636     if (!TLI.isTypeLegal(WideVecVT))
18637       return SDValue();
18638
18639     SmallVector<SDValue, 8> Chains;
18640     SDValue Ptr = Ld->getBasePtr();
18641     SDValue Increment = DAG.getConstant(SclrLoadTy.getSizeInBits()/8,
18642                                         TLI.getPointerTy());
18643     SDValue Res = DAG.getUNDEF(LoadUnitVecVT);
18644
18645     for (unsigned i = 0; i < NumLoads; ++i) {
18646       // Perform a single load.
18647       SDValue ScalarLoad = DAG.getLoad(SclrLoadTy, dl, Ld->getChain(),
18648                                        Ptr, Ld->getPointerInfo(),
18649                                        Ld->isVolatile(), Ld->isNonTemporal(),
18650                                        Ld->isInvariant(), Ld->getAlignment());
18651       Chains.push_back(ScalarLoad.getValue(1));
18652       // Create the first element type using SCALAR_TO_VECTOR in order to avoid
18653       // another round of DAGCombining.
18654       if (i == 0)
18655         Res = DAG.getNode(ISD::SCALAR_TO_VECTOR, dl, LoadUnitVecVT, ScalarLoad);
18656       else
18657         Res = DAG.getNode(ISD::INSERT_VECTOR_ELT, dl, LoadUnitVecVT, Res,
18658                           ScalarLoad, DAG.getIntPtrConstant(i));
18659
18660       Ptr = DAG.getNode(ISD::ADD, dl, Ptr.getValueType(), Ptr, Increment);
18661     }
18662
18663     SDValue TF = DAG.getNode(ISD::TokenFactor, dl, MVT::Other, &Chains[0],
18664                                Chains.size());
18665
18666     // Bitcast the loaded value to a vector of the original element type, in
18667     // the size of the target vector type.
18668     SDValue SlicedVec = DAG.getNode(ISD::BITCAST, dl, WideVecVT, Res);
18669     unsigned SizeRatio = RegSz/MemSz;
18670
18671     if (Ext == ISD::SEXTLOAD) {
18672       // If we have SSE4.1 we can directly emit a VSEXT node.
18673       if (Subtarget->hasSSE41()) {
18674         SDValue Sext = DAG.getNode(X86ISD::VSEXT, dl, RegVT, SlicedVec);
18675         return DCI.CombineTo(N, Sext, TF, true);
18676       }
18677
18678       // Otherwise we'll shuffle the small elements in the high bits of the
18679       // larger type and perform an arithmetic shift. If the shift is not legal
18680       // it's better to scalarize.
18681       if (!TLI.isOperationLegalOrCustom(ISD::SRA, RegVT))
18682         return SDValue();
18683
18684       // Redistribute the loaded elements into the different locations.
18685       SmallVector<int, 8> ShuffleVec(NumElems * SizeRatio, -1);
18686       for (unsigned i = 0; i != NumElems; ++i)
18687         ShuffleVec[i*SizeRatio + SizeRatio-1] = i;
18688
18689       SDValue Shuff = DAG.getVectorShuffle(WideVecVT, dl, SlicedVec,
18690                                            DAG.getUNDEF(WideVecVT),
18691                                            &ShuffleVec[0]);
18692
18693       Shuff = DAG.getNode(ISD::BITCAST, dl, RegVT, Shuff);
18694
18695       // Build the arithmetic shift.
18696       unsigned Amt = RegVT.getVectorElementType().getSizeInBits() -
18697                      MemVT.getVectorElementType().getSizeInBits();
18698       Shuff = DAG.getNode(ISD::SRA, dl, RegVT, Shuff,
18699                           DAG.getConstant(Amt, RegVT));
18700
18701       return DCI.CombineTo(N, Shuff, TF, true);
18702     }
18703
18704     // Redistribute the loaded elements into the different locations.
18705     SmallVector<int, 8> ShuffleVec(NumElems * SizeRatio, -1);
18706     for (unsigned i = 0; i != NumElems; ++i)
18707       ShuffleVec[i*SizeRatio] = i;
18708
18709     SDValue Shuff = DAG.getVectorShuffle(WideVecVT, dl, SlicedVec,
18710                                          DAG.getUNDEF(WideVecVT),
18711                                          &ShuffleVec[0]);
18712
18713     // Bitcast to the requested type.
18714     Shuff = DAG.getNode(ISD::BITCAST, dl, RegVT, Shuff);
18715     // Replace the original load with the new sequence
18716     // and return the new chain.
18717     return DCI.CombineTo(N, Shuff, TF, true);
18718   }
18719
18720   return SDValue();
18721 }
18722
18723 /// PerformSTORECombine - Do target-specific dag combines on STORE nodes.
18724 static SDValue PerformSTORECombine(SDNode *N, SelectionDAG &DAG,
18725                                    const X86Subtarget *Subtarget) {
18726   StoreSDNode *St = cast<StoreSDNode>(N);
18727   EVT VT = St->getValue().getValueType();
18728   EVT StVT = St->getMemoryVT();
18729   SDLoc dl(St);
18730   SDValue StoredVal = St->getOperand(1);
18731   const TargetLowering &TLI = DAG.getTargetLoweringInfo();
18732
18733   // If we are saving a concatenation of two XMM registers, perform two stores.
18734   // On Sandy Bridge, 256-bit memory operations are executed by two
18735   // 128-bit ports. However, on Haswell it is better to issue a single 256-bit
18736   // memory  operation.
18737   unsigned Alignment = St->getAlignment();
18738   bool IsAligned = Alignment == 0 || Alignment >= VT.getSizeInBits()/8;
18739   if (VT.is256BitVector() && !Subtarget->hasInt256() &&
18740       StVT == VT && !IsAligned) {
18741     unsigned NumElems = VT.getVectorNumElements();
18742     if (NumElems < 2)
18743       return SDValue();
18744
18745     SDValue Value0 = Extract128BitVector(StoredVal, 0, DAG, dl);
18746     SDValue Value1 = Extract128BitVector(StoredVal, NumElems/2, DAG, dl);
18747
18748     SDValue Stride = DAG.getConstant(16, TLI.getPointerTy());
18749     SDValue Ptr0 = St->getBasePtr();
18750     SDValue Ptr1 = DAG.getNode(ISD::ADD, dl, Ptr0.getValueType(), Ptr0, Stride);
18751
18752     SDValue Ch0 = DAG.getStore(St->getChain(), dl, Value0, Ptr0,
18753                                 St->getPointerInfo(), St->isVolatile(),
18754                                 St->isNonTemporal(), Alignment);
18755     SDValue Ch1 = DAG.getStore(St->getChain(), dl, Value1, Ptr1,
18756                                 St->getPointerInfo(), St->isVolatile(),
18757                                 St->isNonTemporal(),
18758                                 std::min(16U, Alignment));
18759     return DAG.getNode(ISD::TokenFactor, dl, MVT::Other, Ch0, Ch1);
18760   }
18761
18762   // Optimize trunc store (of multiple scalars) to shuffle and store.
18763   // First, pack all of the elements in one place. Next, store to memory
18764   // in fewer chunks.
18765   if (St->isTruncatingStore() && VT.isVector()) {
18766     const TargetLowering &TLI = DAG.getTargetLoweringInfo();
18767     unsigned NumElems = VT.getVectorNumElements();
18768     assert(StVT != VT && "Cannot truncate to the same type");
18769     unsigned FromSz = VT.getVectorElementType().getSizeInBits();
18770     unsigned ToSz = StVT.getVectorElementType().getSizeInBits();
18771
18772     // From, To sizes and ElemCount must be pow of two
18773     if (!isPowerOf2_32(NumElems * FromSz * ToSz)) return SDValue();
18774     // We are going to use the original vector elt for storing.
18775     // Accumulated smaller vector elements must be a multiple of the store size.
18776     if (0 != (NumElems * FromSz) % ToSz) return SDValue();
18777
18778     unsigned SizeRatio  = FromSz / ToSz;
18779
18780     assert(SizeRatio * NumElems * ToSz == VT.getSizeInBits());
18781
18782     // Create a type on which we perform the shuffle
18783     EVT WideVecVT = EVT::getVectorVT(*DAG.getContext(),
18784             StVT.getScalarType(), NumElems*SizeRatio);
18785
18786     assert(WideVecVT.getSizeInBits() == VT.getSizeInBits());
18787
18788     SDValue WideVec = DAG.getNode(ISD::BITCAST, dl, WideVecVT, St->getValue());
18789     SmallVector<int, 8> ShuffleVec(NumElems * SizeRatio, -1);
18790     for (unsigned i = 0; i != NumElems; ++i)
18791       ShuffleVec[i] = i * SizeRatio;
18792
18793     // Can't shuffle using an illegal type.
18794     if (!TLI.isTypeLegal(WideVecVT))
18795       return SDValue();
18796
18797     SDValue Shuff = DAG.getVectorShuffle(WideVecVT, dl, WideVec,
18798                                          DAG.getUNDEF(WideVecVT),
18799                                          &ShuffleVec[0]);
18800     // At this point all of the data is stored at the bottom of the
18801     // register. We now need to save it to mem.
18802
18803     // Find the largest store unit
18804     MVT StoreType = MVT::i8;
18805     for (unsigned tp = MVT::FIRST_INTEGER_VALUETYPE;
18806          tp < MVT::LAST_INTEGER_VALUETYPE; ++tp) {
18807       MVT Tp = (MVT::SimpleValueType)tp;
18808       if (TLI.isTypeLegal(Tp) && Tp.getSizeInBits() <= NumElems * ToSz)
18809         StoreType = Tp;
18810     }
18811
18812     // On 32bit systems, we can't save 64bit integers. Try bitcasting to F64.
18813     if (TLI.isTypeLegal(MVT::f64) && StoreType.getSizeInBits() < 64 &&
18814         (64 <= NumElems * ToSz))
18815       StoreType = MVT::f64;
18816
18817     // Bitcast the original vector into a vector of store-size units
18818     EVT StoreVecVT = EVT::getVectorVT(*DAG.getContext(),
18819             StoreType, VT.getSizeInBits()/StoreType.getSizeInBits());
18820     assert(StoreVecVT.getSizeInBits() == VT.getSizeInBits());
18821     SDValue ShuffWide = DAG.getNode(ISD::BITCAST, dl, StoreVecVT, Shuff);
18822     SmallVector<SDValue, 8> Chains;
18823     SDValue Increment = DAG.getConstant(StoreType.getSizeInBits()/8,
18824                                         TLI.getPointerTy());
18825     SDValue Ptr = St->getBasePtr();
18826
18827     // Perform one or more big stores into memory.
18828     for (unsigned i=0, e=(ToSz*NumElems)/StoreType.getSizeInBits(); i!=e; ++i) {
18829       SDValue SubVec = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl,
18830                                    StoreType, ShuffWide,
18831                                    DAG.getIntPtrConstant(i));
18832       SDValue Ch = DAG.getStore(St->getChain(), dl, SubVec, Ptr,
18833                                 St->getPointerInfo(), St->isVolatile(),
18834                                 St->isNonTemporal(), St->getAlignment());
18835       Ptr = DAG.getNode(ISD::ADD, dl, Ptr.getValueType(), Ptr, Increment);
18836       Chains.push_back(Ch);
18837     }
18838
18839     return DAG.getNode(ISD::TokenFactor, dl, MVT::Other, &Chains[0],
18840                                Chains.size());
18841   }
18842
18843   // Turn load->store of MMX types into GPR load/stores.  This avoids clobbering
18844   // the FP state in cases where an emms may be missing.
18845   // A preferable solution to the general problem is to figure out the right
18846   // places to insert EMMS.  This qualifies as a quick hack.
18847
18848   // Similarly, turn load->store of i64 into double load/stores in 32-bit mode.
18849   if (VT.getSizeInBits() != 64)
18850     return SDValue();
18851
18852   const Function *F = DAG.getMachineFunction().getFunction();
18853   bool NoImplicitFloatOps = F->getAttributes().
18854     hasAttribute(AttributeSet::FunctionIndex, Attribute::NoImplicitFloat);
18855   bool F64IsLegal = !DAG.getTarget().Options.UseSoftFloat && !NoImplicitFloatOps
18856                      && Subtarget->hasSSE2();
18857   if ((VT.isVector() ||
18858        (VT == MVT::i64 && F64IsLegal && !Subtarget->is64Bit())) &&
18859       isa<LoadSDNode>(St->getValue()) &&
18860       !cast<LoadSDNode>(St->getValue())->isVolatile() &&
18861       St->getChain().hasOneUse() && !St->isVolatile()) {
18862     SDNode* LdVal = St->getValue().getNode();
18863     LoadSDNode *Ld = 0;
18864     int TokenFactorIndex = -1;
18865     SmallVector<SDValue, 8> Ops;
18866     SDNode* ChainVal = St->getChain().getNode();
18867     // Must be a store of a load.  We currently handle two cases:  the load
18868     // is a direct child, and it's under an intervening TokenFactor.  It is
18869     // possible to dig deeper under nested TokenFactors.
18870     if (ChainVal == LdVal)
18871       Ld = cast<LoadSDNode>(St->getChain());
18872     else if (St->getValue().hasOneUse() &&
18873              ChainVal->getOpcode() == ISD::TokenFactor) {
18874       for (unsigned i = 0, e = ChainVal->getNumOperands(); i != e; ++i) {
18875         if (ChainVal->getOperand(i).getNode() == LdVal) {
18876           TokenFactorIndex = i;
18877           Ld = cast<LoadSDNode>(St->getValue());
18878         } else
18879           Ops.push_back(ChainVal->getOperand(i));
18880       }
18881     }
18882
18883     if (!Ld || !ISD::isNormalLoad(Ld))
18884       return SDValue();
18885
18886     // If this is not the MMX case, i.e. we are just turning i64 load/store
18887     // into f64 load/store, avoid the transformation if there are multiple
18888     // uses of the loaded value.
18889     if (!VT.isVector() && !Ld->hasNUsesOfValue(1, 0))
18890       return SDValue();
18891
18892     SDLoc LdDL(Ld);
18893     SDLoc StDL(N);
18894     // If we are a 64-bit capable x86, lower to a single movq load/store pair.
18895     // Otherwise, if it's legal to use f64 SSE instructions, use f64 load/store
18896     // pair instead.
18897     if (Subtarget->is64Bit() || F64IsLegal) {
18898       EVT LdVT = Subtarget->is64Bit() ? MVT::i64 : MVT::f64;
18899       SDValue NewLd = DAG.getLoad(LdVT, LdDL, Ld->getChain(), Ld->getBasePtr(),
18900                                   Ld->getPointerInfo(), Ld->isVolatile(),
18901                                   Ld->isNonTemporal(), Ld->isInvariant(),
18902                                   Ld->getAlignment());
18903       SDValue NewChain = NewLd.getValue(1);
18904       if (TokenFactorIndex != -1) {
18905         Ops.push_back(NewChain);
18906         NewChain = DAG.getNode(ISD::TokenFactor, LdDL, MVT::Other, &Ops[0],
18907                                Ops.size());
18908       }
18909       return DAG.getStore(NewChain, StDL, NewLd, St->getBasePtr(),
18910                           St->getPointerInfo(),
18911                           St->isVolatile(), St->isNonTemporal(),
18912                           St->getAlignment());
18913     }
18914
18915     // Otherwise, lower to two pairs of 32-bit loads / stores.
18916     SDValue LoAddr = Ld->getBasePtr();
18917     SDValue HiAddr = DAG.getNode(ISD::ADD, LdDL, MVT::i32, LoAddr,
18918                                  DAG.getConstant(4, MVT::i32));
18919
18920     SDValue LoLd = DAG.getLoad(MVT::i32, LdDL, Ld->getChain(), LoAddr,
18921                                Ld->getPointerInfo(),
18922                                Ld->isVolatile(), Ld->isNonTemporal(),
18923                                Ld->isInvariant(), Ld->getAlignment());
18924     SDValue HiLd = DAG.getLoad(MVT::i32, LdDL, Ld->getChain(), HiAddr,
18925                                Ld->getPointerInfo().getWithOffset(4),
18926                                Ld->isVolatile(), Ld->isNonTemporal(),
18927                                Ld->isInvariant(),
18928                                MinAlign(Ld->getAlignment(), 4));
18929
18930     SDValue NewChain = LoLd.getValue(1);
18931     if (TokenFactorIndex != -1) {
18932       Ops.push_back(LoLd);
18933       Ops.push_back(HiLd);
18934       NewChain = DAG.getNode(ISD::TokenFactor, LdDL, MVT::Other, &Ops[0],
18935                              Ops.size());
18936     }
18937
18938     LoAddr = St->getBasePtr();
18939     HiAddr = DAG.getNode(ISD::ADD, StDL, MVT::i32, LoAddr,
18940                          DAG.getConstant(4, MVT::i32));
18941
18942     SDValue LoSt = DAG.getStore(NewChain, StDL, LoLd, LoAddr,
18943                                 St->getPointerInfo(),
18944                                 St->isVolatile(), St->isNonTemporal(),
18945                                 St->getAlignment());
18946     SDValue HiSt = DAG.getStore(NewChain, StDL, HiLd, HiAddr,
18947                                 St->getPointerInfo().getWithOffset(4),
18948                                 St->isVolatile(),
18949                                 St->isNonTemporal(),
18950                                 MinAlign(St->getAlignment(), 4));
18951     return DAG.getNode(ISD::TokenFactor, StDL, MVT::Other, LoSt, HiSt);
18952   }
18953   return SDValue();
18954 }
18955
18956 /// isHorizontalBinOp - Return 'true' if this vector operation is "horizontal"
18957 /// and return the operands for the horizontal operation in LHS and RHS.  A
18958 /// horizontal operation performs the binary operation on successive elements
18959 /// of its first operand, then on successive elements of its second operand,
18960 /// returning the resulting values in a vector.  For example, if
18961 ///   A = < float a0, float a1, float a2, float a3 >
18962 /// and
18963 ///   B = < float b0, float b1, float b2, float b3 >
18964 /// then the result of doing a horizontal operation on A and B is
18965 ///   A horizontal-op B = < a0 op a1, a2 op a3, b0 op b1, b2 op b3 >.
18966 /// In short, LHS and RHS are inspected to see if LHS op RHS is of the form
18967 /// A horizontal-op B, for some already available A and B, and if so then LHS is
18968 /// set to A, RHS to B, and the routine returns 'true'.
18969 /// Note that the binary operation should have the property that if one of the
18970 /// operands is UNDEF then the result is UNDEF.
18971 static bool isHorizontalBinOp(SDValue &LHS, SDValue &RHS, bool IsCommutative) {
18972   // Look for the following pattern: if
18973   //   A = < float a0, float a1, float a2, float a3 >
18974   //   B = < float b0, float b1, float b2, float b3 >
18975   // and
18976   //   LHS = VECTOR_SHUFFLE A, B, <0, 2, 4, 6>
18977   //   RHS = VECTOR_SHUFFLE A, B, <1, 3, 5, 7>
18978   // then LHS op RHS = < a0 op a1, a2 op a3, b0 op b1, b2 op b3 >
18979   // which is A horizontal-op B.
18980
18981   // At least one of the operands should be a vector shuffle.
18982   if (LHS.getOpcode() != ISD::VECTOR_SHUFFLE &&
18983       RHS.getOpcode() != ISD::VECTOR_SHUFFLE)
18984     return false;
18985
18986   MVT VT = LHS.getSimpleValueType();
18987
18988   assert((VT.is128BitVector() || VT.is256BitVector()) &&
18989          "Unsupported vector type for horizontal add/sub");
18990
18991   // Handle 128 and 256-bit vector lengths. AVX defines horizontal add/sub to
18992   // operate independently on 128-bit lanes.
18993   unsigned NumElts = VT.getVectorNumElements();
18994   unsigned NumLanes = VT.getSizeInBits()/128;
18995   unsigned NumLaneElts = NumElts / NumLanes;
18996   assert((NumLaneElts % 2 == 0) &&
18997          "Vector type should have an even number of elements in each lane");
18998   unsigned HalfLaneElts = NumLaneElts/2;
18999
19000   // View LHS in the form
19001   //   LHS = VECTOR_SHUFFLE A, B, LMask
19002   // If LHS is not a shuffle then pretend it is the shuffle
19003   //   LHS = VECTOR_SHUFFLE LHS, undef, <0, 1, ..., N-1>
19004   // NOTE: in what follows a default initialized SDValue represents an UNDEF of
19005   // type VT.
19006   SDValue A, B;
19007   SmallVector<int, 16> LMask(NumElts);
19008   if (LHS.getOpcode() == ISD::VECTOR_SHUFFLE) {
19009     if (LHS.getOperand(0).getOpcode() != ISD::UNDEF)
19010       A = LHS.getOperand(0);
19011     if (LHS.getOperand(1).getOpcode() != ISD::UNDEF)
19012       B = LHS.getOperand(1);
19013     ArrayRef<int> Mask = cast<ShuffleVectorSDNode>(LHS.getNode())->getMask();
19014     std::copy(Mask.begin(), Mask.end(), LMask.begin());
19015   } else {
19016     if (LHS.getOpcode() != ISD::UNDEF)
19017       A = LHS;
19018     for (unsigned i = 0; i != NumElts; ++i)
19019       LMask[i] = i;
19020   }
19021
19022   // Likewise, view RHS in the form
19023   //   RHS = VECTOR_SHUFFLE C, D, RMask
19024   SDValue C, D;
19025   SmallVector<int, 16> RMask(NumElts);
19026   if (RHS.getOpcode() == ISD::VECTOR_SHUFFLE) {
19027     if (RHS.getOperand(0).getOpcode() != ISD::UNDEF)
19028       C = RHS.getOperand(0);
19029     if (RHS.getOperand(1).getOpcode() != ISD::UNDEF)
19030       D = RHS.getOperand(1);
19031     ArrayRef<int> Mask = cast<ShuffleVectorSDNode>(RHS.getNode())->getMask();
19032     std::copy(Mask.begin(), Mask.end(), RMask.begin());
19033   } else {
19034     if (RHS.getOpcode() != ISD::UNDEF)
19035       C = RHS;
19036     for (unsigned i = 0; i != NumElts; ++i)
19037       RMask[i] = i;
19038   }
19039
19040   // Check that the shuffles are both shuffling the same vectors.
19041   if (!(A == C && B == D) && !(A == D && B == C))
19042     return false;
19043
19044   // If everything is UNDEF then bail out: it would be better to fold to UNDEF.
19045   if (!A.getNode() && !B.getNode())
19046     return false;
19047
19048   // If A and B occur in reverse order in RHS, then "swap" them (which means
19049   // rewriting the mask).
19050   if (A != C)
19051     CommuteVectorShuffleMask(RMask, NumElts);
19052
19053   // At this point LHS and RHS are equivalent to
19054   //   LHS = VECTOR_SHUFFLE A, B, LMask
19055   //   RHS = VECTOR_SHUFFLE A, B, RMask
19056   // Check that the masks correspond to performing a horizontal operation.
19057   for (unsigned l = 0; l != NumElts; l += NumLaneElts) {
19058     for (unsigned i = 0; i != NumLaneElts; ++i) {
19059       int LIdx = LMask[i+l], RIdx = RMask[i+l];
19060
19061       // Ignore any UNDEF components.
19062       if (LIdx < 0 || RIdx < 0 ||
19063           (!A.getNode() && (LIdx < (int)NumElts || RIdx < (int)NumElts)) ||
19064           (!B.getNode() && (LIdx >= (int)NumElts || RIdx >= (int)NumElts)))
19065         continue;
19066
19067       // Check that successive elements are being operated on.  If not, this is
19068       // not a horizontal operation.
19069       unsigned Src = (i/HalfLaneElts); // each lane is split between srcs
19070       int Index = 2*(i%HalfLaneElts) + NumElts*Src + l;
19071       if (!(LIdx == Index && RIdx == Index + 1) &&
19072           !(IsCommutative && LIdx == Index + 1 && RIdx == Index))
19073         return false;
19074     }
19075   }
19076
19077   LHS = A.getNode() ? A : B; // If A is 'UNDEF', use B for it.
19078   RHS = B.getNode() ? B : A; // If B is 'UNDEF', use A for it.
19079   return true;
19080 }
19081
19082 /// PerformFADDCombine - Do target-specific dag combines on floating point adds.
19083 static SDValue PerformFADDCombine(SDNode *N, SelectionDAG &DAG,
19084                                   const X86Subtarget *Subtarget) {
19085   EVT VT = N->getValueType(0);
19086   SDValue LHS = N->getOperand(0);
19087   SDValue RHS = N->getOperand(1);
19088
19089   // Try to synthesize horizontal adds from adds of shuffles.
19090   if (((Subtarget->hasSSE3() && (VT == MVT::v4f32 || VT == MVT::v2f64)) ||
19091        (Subtarget->hasFp256() && (VT == MVT::v8f32 || VT == MVT::v4f64))) &&
19092       isHorizontalBinOp(LHS, RHS, true))
19093     return DAG.getNode(X86ISD::FHADD, SDLoc(N), VT, LHS, RHS);
19094   return SDValue();
19095 }
19096
19097 /// PerformFSUBCombine - Do target-specific dag combines on floating point subs.
19098 static SDValue PerformFSUBCombine(SDNode *N, SelectionDAG &DAG,
19099                                   const X86Subtarget *Subtarget) {
19100   EVT VT = N->getValueType(0);
19101   SDValue LHS = N->getOperand(0);
19102   SDValue RHS = N->getOperand(1);
19103
19104   // Try to synthesize horizontal subs from subs of shuffles.
19105   if (((Subtarget->hasSSE3() && (VT == MVT::v4f32 || VT == MVT::v2f64)) ||
19106        (Subtarget->hasFp256() && (VT == MVT::v8f32 || VT == MVT::v4f64))) &&
19107       isHorizontalBinOp(LHS, RHS, false))
19108     return DAG.getNode(X86ISD::FHSUB, SDLoc(N), VT, LHS, RHS);
19109   return SDValue();
19110 }
19111
19112 /// PerformFORCombine - Do target-specific dag combines on X86ISD::FOR and
19113 /// X86ISD::FXOR nodes.
19114 static SDValue PerformFORCombine(SDNode *N, SelectionDAG &DAG) {
19115   assert(N->getOpcode() == X86ISD::FOR || N->getOpcode() == X86ISD::FXOR);
19116   // F[X]OR(0.0, x) -> x
19117   // F[X]OR(x, 0.0) -> x
19118   if (ConstantFPSDNode *C = dyn_cast<ConstantFPSDNode>(N->getOperand(0)))
19119     if (C->getValueAPF().isPosZero())
19120       return N->getOperand(1);
19121   if (ConstantFPSDNode *C = dyn_cast<ConstantFPSDNode>(N->getOperand(1)))
19122     if (C->getValueAPF().isPosZero())
19123       return N->getOperand(0);
19124   return SDValue();
19125 }
19126
19127 /// PerformFMinFMaxCombine - Do target-specific dag combines on X86ISD::FMIN and
19128 /// X86ISD::FMAX nodes.
19129 static SDValue PerformFMinFMaxCombine(SDNode *N, SelectionDAG &DAG) {
19130   assert(N->getOpcode() == X86ISD::FMIN || N->getOpcode() == X86ISD::FMAX);
19131
19132   // Only perform optimizations if UnsafeMath is used.
19133   if (!DAG.getTarget().Options.UnsafeFPMath)
19134     return SDValue();
19135
19136   // If we run in unsafe-math mode, then convert the FMAX and FMIN nodes
19137   // into FMINC and FMAXC, which are Commutative operations.
19138   unsigned NewOp = 0;
19139   switch (N->getOpcode()) {
19140     default: llvm_unreachable("unknown opcode");
19141     case X86ISD::FMIN:  NewOp = X86ISD::FMINC; break;
19142     case X86ISD::FMAX:  NewOp = X86ISD::FMAXC; break;
19143   }
19144
19145   return DAG.getNode(NewOp, SDLoc(N), N->getValueType(0),
19146                      N->getOperand(0), N->getOperand(1));
19147 }
19148
19149 /// PerformFANDCombine - Do target-specific dag combines on X86ISD::FAND nodes.
19150 static SDValue PerformFANDCombine(SDNode *N, SelectionDAG &DAG) {
19151   // FAND(0.0, x) -> 0.0
19152   // FAND(x, 0.0) -> 0.0
19153   if (ConstantFPSDNode *C = dyn_cast<ConstantFPSDNode>(N->getOperand(0)))
19154     if (C->getValueAPF().isPosZero())
19155       return N->getOperand(0);
19156   if (ConstantFPSDNode *C = dyn_cast<ConstantFPSDNode>(N->getOperand(1)))
19157     if (C->getValueAPF().isPosZero())
19158       return N->getOperand(1);
19159   return SDValue();
19160 }
19161
19162 /// PerformFANDNCombine - Do target-specific dag combines on X86ISD::FANDN nodes
19163 static SDValue PerformFANDNCombine(SDNode *N, SelectionDAG &DAG) {
19164   // FANDN(x, 0.0) -> 0.0
19165   // FANDN(0.0, x) -> x
19166   if (ConstantFPSDNode *C = dyn_cast<ConstantFPSDNode>(N->getOperand(0)))
19167     if (C->getValueAPF().isPosZero())
19168       return N->getOperand(1);
19169   if (ConstantFPSDNode *C = dyn_cast<ConstantFPSDNode>(N->getOperand(1)))
19170     if (C->getValueAPF().isPosZero())
19171       return N->getOperand(1);
19172   return SDValue();
19173 }
19174
19175 static SDValue PerformBTCombine(SDNode *N,
19176                                 SelectionDAG &DAG,
19177                                 TargetLowering::DAGCombinerInfo &DCI) {
19178   // BT ignores high bits in the bit index operand.
19179   SDValue Op1 = N->getOperand(1);
19180   if (Op1.hasOneUse()) {
19181     unsigned BitWidth = Op1.getValueSizeInBits();
19182     APInt DemandedMask = APInt::getLowBitsSet(BitWidth, Log2_32(BitWidth));
19183     APInt KnownZero, KnownOne;
19184     TargetLowering::TargetLoweringOpt TLO(DAG, !DCI.isBeforeLegalize(),
19185                                           !DCI.isBeforeLegalizeOps());
19186     const TargetLowering &TLI = DAG.getTargetLoweringInfo();
19187     if (TLO.ShrinkDemandedConstant(Op1, DemandedMask) ||
19188         TLI.SimplifyDemandedBits(Op1, DemandedMask, KnownZero, KnownOne, TLO))
19189       DCI.CommitTargetLoweringOpt(TLO);
19190   }
19191   return SDValue();
19192 }
19193
19194 static SDValue PerformVZEXT_MOVLCombine(SDNode *N, SelectionDAG &DAG) {
19195   SDValue Op = N->getOperand(0);
19196   if (Op.getOpcode() == ISD::BITCAST)
19197     Op = Op.getOperand(0);
19198   EVT VT = N->getValueType(0), OpVT = Op.getValueType();
19199   if (Op.getOpcode() == X86ISD::VZEXT_LOAD &&
19200       VT.getVectorElementType().getSizeInBits() ==
19201       OpVT.getVectorElementType().getSizeInBits()) {
19202     return DAG.getNode(ISD::BITCAST, SDLoc(N), VT, Op);
19203   }
19204   return SDValue();
19205 }
19206
19207 static SDValue PerformSIGN_EXTEND_INREGCombine(SDNode *N, SelectionDAG &DAG,
19208                                                const X86Subtarget *Subtarget) {
19209   EVT VT = N->getValueType(0);
19210   if (!VT.isVector())
19211     return SDValue();
19212
19213   SDValue N0 = N->getOperand(0);
19214   SDValue N1 = N->getOperand(1);
19215   EVT ExtraVT = cast<VTSDNode>(N1)->getVT();
19216   SDLoc dl(N);
19217
19218   // The SIGN_EXTEND_INREG to v4i64 is expensive operation on the
19219   // both SSE and AVX2 since there is no sign-extended shift right
19220   // operation on a vector with 64-bit elements.
19221   //(sext_in_reg (v4i64 anyext (v4i32 x )), ExtraVT) ->
19222   // (v4i64 sext (v4i32 sext_in_reg (v4i32 x , ExtraVT)))
19223   if (VT == MVT::v4i64 && (N0.getOpcode() == ISD::ANY_EXTEND ||
19224       N0.getOpcode() == ISD::SIGN_EXTEND)) {
19225     SDValue N00 = N0.getOperand(0);
19226
19227     // EXTLOAD has a better solution on AVX2,
19228     // it may be replaced with X86ISD::VSEXT node.
19229     if (N00.getOpcode() == ISD::LOAD && Subtarget->hasInt256())
19230       if (!ISD::isNormalLoad(N00.getNode()))
19231         return SDValue();
19232
19233     if (N00.getValueType() == MVT::v4i32 && ExtraVT.getSizeInBits() < 128) {
19234         SDValue Tmp = DAG.getNode(ISD::SIGN_EXTEND_INREG, dl, MVT::v4i32,
19235                                   N00, N1);
19236       return DAG.getNode(ISD::SIGN_EXTEND, dl, MVT::v4i64, Tmp);
19237     }
19238   }
19239   return SDValue();
19240 }
19241
19242 static SDValue PerformSExtCombine(SDNode *N, SelectionDAG &DAG,
19243                                   TargetLowering::DAGCombinerInfo &DCI,
19244                                   const X86Subtarget *Subtarget) {
19245   if (!DCI.isBeforeLegalizeOps())
19246     return SDValue();
19247
19248   if (!Subtarget->hasFp256())
19249     return SDValue();
19250
19251   EVT VT = N->getValueType(0);
19252   if (VT.isVector() && VT.getSizeInBits() == 256) {
19253     SDValue R = WidenMaskArithmetic(N, DAG, DCI, Subtarget);
19254     if (R.getNode())
19255       return R;
19256   }
19257
19258   return SDValue();
19259 }
19260
19261 static SDValue PerformFMACombine(SDNode *N, SelectionDAG &DAG,
19262                                  const X86Subtarget* Subtarget) {
19263   SDLoc dl(N);
19264   EVT VT = N->getValueType(0);
19265
19266   // Let legalize expand this if it isn't a legal type yet.
19267   if (!DAG.getTargetLoweringInfo().isTypeLegal(VT))
19268     return SDValue();
19269
19270   EVT ScalarVT = VT.getScalarType();
19271   if ((ScalarVT != MVT::f32 && ScalarVT != MVT::f64) ||
19272       (!Subtarget->hasFMA() && !Subtarget->hasFMA4()))
19273     return SDValue();
19274
19275   SDValue A = N->getOperand(0);
19276   SDValue B = N->getOperand(1);
19277   SDValue C = N->getOperand(2);
19278
19279   bool NegA = (A.getOpcode() == ISD::FNEG);
19280   bool NegB = (B.getOpcode() == ISD::FNEG);
19281   bool NegC = (C.getOpcode() == ISD::FNEG);
19282
19283   // Negative multiplication when NegA xor NegB
19284   bool NegMul = (NegA != NegB);
19285   if (NegA)
19286     A = A.getOperand(0);
19287   if (NegB)
19288     B = B.getOperand(0);
19289   if (NegC)
19290     C = C.getOperand(0);
19291
19292   unsigned Opcode;
19293   if (!NegMul)
19294     Opcode = (!NegC) ? X86ISD::FMADD : X86ISD::FMSUB;
19295   else
19296     Opcode = (!NegC) ? X86ISD::FNMADD : X86ISD::FNMSUB;
19297
19298   return DAG.getNode(Opcode, dl, VT, A, B, C);
19299 }
19300
19301 static SDValue PerformZExtCombine(SDNode *N, SelectionDAG &DAG,
19302                                   TargetLowering::DAGCombinerInfo &DCI,
19303                                   const X86Subtarget *Subtarget) {
19304   // (i32 zext (and (i8  x86isd::setcc_carry), 1)) ->
19305   //           (and (i32 x86isd::setcc_carry), 1)
19306   // This eliminates the zext. This transformation is necessary because
19307   // ISD::SETCC is always legalized to i8.
19308   SDLoc dl(N);
19309   SDValue N0 = N->getOperand(0);
19310   EVT VT = N->getValueType(0);
19311
19312   if (N0.getOpcode() == ISD::AND &&
19313       N0.hasOneUse() &&
19314       N0.getOperand(0).hasOneUse()) {
19315     SDValue N00 = N0.getOperand(0);
19316     if (N00.getOpcode() == X86ISD::SETCC_CARRY) {
19317       ConstantSDNode *C = dyn_cast<ConstantSDNode>(N0.getOperand(1));
19318       if (!C || C->getZExtValue() != 1)
19319         return SDValue();
19320       return DAG.getNode(ISD::AND, dl, VT,
19321                          DAG.getNode(X86ISD::SETCC_CARRY, dl, VT,
19322                                      N00.getOperand(0), N00.getOperand(1)),
19323                          DAG.getConstant(1, VT));
19324     }
19325   }
19326
19327   if (N0.getOpcode() == ISD::TRUNCATE &&
19328       N0.hasOneUse() &&
19329       N0.getOperand(0).hasOneUse()) {
19330     SDValue N00 = N0.getOperand(0);
19331     if (N00.getOpcode() == X86ISD::SETCC_CARRY) {
19332       return DAG.getNode(ISD::AND, dl, VT,
19333                          DAG.getNode(X86ISD::SETCC_CARRY, dl, VT,
19334                                      N00.getOperand(0), N00.getOperand(1)),
19335                          DAG.getConstant(1, VT));
19336     }
19337   }
19338   if (VT.is256BitVector()) {
19339     SDValue R = WidenMaskArithmetic(N, DAG, DCI, Subtarget);
19340     if (R.getNode())
19341       return R;
19342   }
19343
19344   return SDValue();
19345 }
19346
19347 // Optimize x == -y --> x+y == 0
19348 //          x != -y --> x+y != 0
19349 static SDValue PerformISDSETCCCombine(SDNode *N, SelectionDAG &DAG,
19350                                       const X86Subtarget* Subtarget) {
19351   ISD::CondCode CC = cast<CondCodeSDNode>(N->getOperand(2))->get();
19352   SDValue LHS = N->getOperand(0);
19353   SDValue RHS = N->getOperand(1);
19354   EVT VT = N->getValueType(0);
19355   SDLoc DL(N);
19356
19357   if ((CC == ISD::SETNE || CC == ISD::SETEQ) && LHS.getOpcode() == ISD::SUB)
19358     if (ConstantSDNode *C = dyn_cast<ConstantSDNode>(LHS.getOperand(0)))
19359       if (C->getAPIntValue() == 0 && LHS.hasOneUse()) {
19360         SDValue addV = DAG.getNode(ISD::ADD, SDLoc(N),
19361                                    LHS.getValueType(), RHS, LHS.getOperand(1));
19362         return DAG.getSetCC(SDLoc(N), N->getValueType(0),
19363                             addV, DAG.getConstant(0, addV.getValueType()), CC);
19364       }
19365   if ((CC == ISD::SETNE || CC == ISD::SETEQ) && RHS.getOpcode() == ISD::SUB)
19366     if (ConstantSDNode *C = dyn_cast<ConstantSDNode>(RHS.getOperand(0)))
19367       if (C->getAPIntValue() == 0 && RHS.hasOneUse()) {
19368         SDValue addV = DAG.getNode(ISD::ADD, SDLoc(N),
19369                                    RHS.getValueType(), LHS, RHS.getOperand(1));
19370         return DAG.getSetCC(SDLoc(N), N->getValueType(0),
19371                             addV, DAG.getConstant(0, addV.getValueType()), CC);
19372       }
19373
19374   if (VT.getScalarType() == MVT::i1) {
19375     bool IsSEXT0 = (LHS.getOpcode() == ISD::SIGN_EXTEND) &&
19376       (LHS.getOperand(0).getValueType().getScalarType() ==  MVT::i1);
19377     bool IsVZero0 = ISD::isBuildVectorAllZeros(LHS.getNode());
19378     if (!IsSEXT0 && !IsVZero0)
19379       return SDValue();
19380     bool IsSEXT1 = (RHS.getOpcode() == ISD::SIGN_EXTEND) &&
19381       (RHS.getOperand(0).getValueType().getScalarType() ==  MVT::i1);
19382     bool IsVZero1 = ISD::isBuildVectorAllZeros(RHS.getNode());
19383
19384     if (!IsSEXT1 && !IsVZero1)
19385       return SDValue();
19386
19387     if (IsSEXT0 && IsVZero1) {
19388       assert(VT == LHS.getOperand(0).getValueType() && "Uexpected operand type");
19389       if (CC == ISD::SETEQ)
19390         return DAG.getNOT(DL, LHS.getOperand(0), VT);
19391       return LHS.getOperand(0);
19392     }
19393     if (IsSEXT1 && IsVZero0) {
19394       assert(VT == RHS.getOperand(0).getValueType() && "Uexpected operand type");
19395       if (CC == ISD::SETEQ)
19396         return DAG.getNOT(DL, RHS.getOperand(0), VT);
19397       return RHS.getOperand(0);
19398     }
19399   }
19400
19401   return SDValue();
19402 }
19403
19404 // Helper function of PerformSETCCCombine. It is to materialize "setb reg"
19405 // as "sbb reg,reg", since it can be extended without zext and produces
19406 // an all-ones bit which is more useful than 0/1 in some cases.
19407 static SDValue MaterializeSETB(SDLoc DL, SDValue EFLAGS, SelectionDAG &DAG,
19408                                MVT VT) {
19409   if (VT == MVT::i8)
19410     return DAG.getNode(ISD::AND, DL, VT,
19411                        DAG.getNode(X86ISD::SETCC_CARRY, DL, MVT::i8,
19412                                    DAG.getConstant(X86::COND_B, MVT::i8), EFLAGS),
19413                        DAG.getConstant(1, VT));
19414   assert (VT == MVT::i1 && "Unexpected type for SECCC node");
19415   return DAG.getNode(ISD::TRUNCATE, DL, MVT::i1,
19416                      DAG.getNode(X86ISD::SETCC_CARRY, DL, MVT::i8,
19417                                  DAG.getConstant(X86::COND_B, MVT::i8), EFLAGS));
19418 }
19419
19420 // Optimize  RES = X86ISD::SETCC CONDCODE, EFLAG_INPUT
19421 static SDValue PerformSETCCCombine(SDNode *N, SelectionDAG &DAG,
19422                                    TargetLowering::DAGCombinerInfo &DCI,
19423                                    const X86Subtarget *Subtarget) {
19424   SDLoc DL(N);
19425   X86::CondCode CC = X86::CondCode(N->getConstantOperandVal(0));
19426   SDValue EFLAGS = N->getOperand(1);
19427
19428   if (CC == X86::COND_A) {
19429     // Try to convert COND_A into COND_B in an attempt to facilitate
19430     // materializing "setb reg".
19431     //
19432     // Do not flip "e > c", where "c" is a constant, because Cmp instruction
19433     // cannot take an immediate as its first operand.
19434     //
19435     if (EFLAGS.getOpcode() == X86ISD::SUB && EFLAGS.hasOneUse() &&
19436         EFLAGS.getValueType().isInteger() &&
19437         !isa<ConstantSDNode>(EFLAGS.getOperand(1))) {
19438       SDValue NewSub = DAG.getNode(X86ISD::SUB, SDLoc(EFLAGS),
19439                                    EFLAGS.getNode()->getVTList(),
19440                                    EFLAGS.getOperand(1), EFLAGS.getOperand(0));
19441       SDValue NewEFLAGS = SDValue(NewSub.getNode(), EFLAGS.getResNo());
19442       return MaterializeSETB(DL, NewEFLAGS, DAG, N->getSimpleValueType(0));
19443     }
19444   }
19445
19446   // Materialize "setb reg" as "sbb reg,reg", since it can be extended without
19447   // a zext and produces an all-ones bit which is more useful than 0/1 in some
19448   // cases.
19449   if (CC == X86::COND_B)
19450     return MaterializeSETB(DL, EFLAGS, DAG, N->getSimpleValueType(0));
19451
19452   SDValue Flags;
19453
19454   Flags = checkBoolTestSetCCCombine(EFLAGS, CC);
19455   if (Flags.getNode()) {
19456     SDValue Cond = DAG.getConstant(CC, MVT::i8);
19457     return DAG.getNode(X86ISD::SETCC, DL, N->getVTList(), Cond, Flags);
19458   }
19459
19460   return SDValue();
19461 }
19462
19463 // Optimize branch condition evaluation.
19464 //
19465 static SDValue PerformBrCondCombine(SDNode *N, SelectionDAG &DAG,
19466                                     TargetLowering::DAGCombinerInfo &DCI,
19467                                     const X86Subtarget *Subtarget) {
19468   SDLoc DL(N);
19469   SDValue Chain = N->getOperand(0);
19470   SDValue Dest = N->getOperand(1);
19471   SDValue EFLAGS = N->getOperand(3);
19472   X86::CondCode CC = X86::CondCode(N->getConstantOperandVal(2));
19473
19474   SDValue Flags;
19475
19476   Flags = checkBoolTestSetCCCombine(EFLAGS, CC);
19477   if (Flags.getNode()) {
19478     SDValue Cond = DAG.getConstant(CC, MVT::i8);
19479     return DAG.getNode(X86ISD::BRCOND, DL, N->getVTList(), Chain, Dest, Cond,
19480                        Flags);
19481   }
19482
19483   return SDValue();
19484 }
19485
19486 static SDValue PerformSINT_TO_FPCombine(SDNode *N, SelectionDAG &DAG,
19487                                         const X86TargetLowering *XTLI) {
19488   SDValue Op0 = N->getOperand(0);
19489   EVT InVT = Op0->getValueType(0);
19490
19491   // SINT_TO_FP(v4i8) -> SINT_TO_FP(SEXT(v4i8 to v4i32))
19492   if (InVT == MVT::v8i8 || InVT == MVT::v4i8) {
19493     SDLoc dl(N);
19494     MVT DstVT = InVT == MVT::v4i8 ? MVT::v4i32 : MVT::v8i32;
19495     SDValue P = DAG.getNode(ISD::SIGN_EXTEND, dl, DstVT, Op0);
19496     return DAG.getNode(ISD::SINT_TO_FP, dl, N->getValueType(0), P);
19497   }
19498
19499   // Transform (SINT_TO_FP (i64 ...)) into an x87 operation if we have
19500   // a 32-bit target where SSE doesn't support i64->FP operations.
19501   if (Op0.getOpcode() == ISD::LOAD) {
19502     LoadSDNode *Ld = cast<LoadSDNode>(Op0.getNode());
19503     EVT VT = Ld->getValueType(0);
19504     if (!Ld->isVolatile() && !N->getValueType(0).isVector() &&
19505         ISD::isNON_EXTLoad(Op0.getNode()) && Op0.hasOneUse() &&
19506         !XTLI->getSubtarget()->is64Bit() &&
19507         VT == MVT::i64) {
19508       SDValue FILDChain = XTLI->BuildFILD(SDValue(N, 0), Ld->getValueType(0),
19509                                           Ld->getChain(), Op0, DAG);
19510       DAG.ReplaceAllUsesOfValueWith(Op0.getValue(1), FILDChain.getValue(1));
19511       return FILDChain;
19512     }
19513   }
19514   return SDValue();
19515 }
19516
19517 // Optimize RES, EFLAGS = X86ISD::ADC LHS, RHS, EFLAGS
19518 static SDValue PerformADCCombine(SDNode *N, SelectionDAG &DAG,
19519                                  X86TargetLowering::DAGCombinerInfo &DCI) {
19520   // If the LHS and RHS of the ADC node are zero, then it can't overflow and
19521   // the result is either zero or one (depending on the input carry bit).
19522   // Strength reduce this down to a "set on carry" aka SETCC_CARRY&1.
19523   if (X86::isZeroNode(N->getOperand(0)) &&
19524       X86::isZeroNode(N->getOperand(1)) &&
19525       // We don't have a good way to replace an EFLAGS use, so only do this when
19526       // dead right now.
19527       SDValue(N, 1).use_empty()) {
19528     SDLoc DL(N);
19529     EVT VT = N->getValueType(0);
19530     SDValue CarryOut = DAG.getConstant(0, N->getValueType(1));
19531     SDValue Res1 = DAG.getNode(ISD::AND, DL, VT,
19532                                DAG.getNode(X86ISD::SETCC_CARRY, DL, VT,
19533                                            DAG.getConstant(X86::COND_B,MVT::i8),
19534                                            N->getOperand(2)),
19535                                DAG.getConstant(1, VT));
19536     return DCI.CombineTo(N, Res1, CarryOut);
19537   }
19538
19539   return SDValue();
19540 }
19541
19542 // fold (add Y, (sete  X, 0)) -> adc  0, Y
19543 //      (add Y, (setne X, 0)) -> sbb -1, Y
19544 //      (sub (sete  X, 0), Y) -> sbb  0, Y
19545 //      (sub (setne X, 0), Y) -> adc -1, Y
19546 static SDValue OptimizeConditionalInDecrement(SDNode *N, SelectionDAG &DAG) {
19547   SDLoc DL(N);
19548
19549   // Look through ZExts.
19550   SDValue Ext = N->getOperand(N->getOpcode() == ISD::SUB ? 1 : 0);
19551   if (Ext.getOpcode() != ISD::ZERO_EXTEND || !Ext.hasOneUse())
19552     return SDValue();
19553
19554   SDValue SetCC = Ext.getOperand(0);
19555   if (SetCC.getOpcode() != X86ISD::SETCC || !SetCC.hasOneUse())
19556     return SDValue();
19557
19558   X86::CondCode CC = (X86::CondCode)SetCC.getConstantOperandVal(0);
19559   if (CC != X86::COND_E && CC != X86::COND_NE)
19560     return SDValue();
19561
19562   SDValue Cmp = SetCC.getOperand(1);
19563   if (Cmp.getOpcode() != X86ISD::CMP || !Cmp.hasOneUse() ||
19564       !X86::isZeroNode(Cmp.getOperand(1)) ||
19565       !Cmp.getOperand(0).getValueType().isInteger())
19566     return SDValue();
19567
19568   SDValue CmpOp0 = Cmp.getOperand(0);
19569   SDValue NewCmp = DAG.getNode(X86ISD::CMP, DL, MVT::i32, CmpOp0,
19570                                DAG.getConstant(1, CmpOp0.getValueType()));
19571
19572   SDValue OtherVal = N->getOperand(N->getOpcode() == ISD::SUB ? 0 : 1);
19573   if (CC == X86::COND_NE)
19574     return DAG.getNode(N->getOpcode() == ISD::SUB ? X86ISD::ADC : X86ISD::SBB,
19575                        DL, OtherVal.getValueType(), OtherVal,
19576                        DAG.getConstant(-1ULL, OtherVal.getValueType()), NewCmp);
19577   return DAG.getNode(N->getOpcode() == ISD::SUB ? X86ISD::SBB : X86ISD::ADC,
19578                      DL, OtherVal.getValueType(), OtherVal,
19579                      DAG.getConstant(0, OtherVal.getValueType()), NewCmp);
19580 }
19581
19582 /// PerformADDCombine - Do target-specific dag combines on integer adds.
19583 static SDValue PerformAddCombine(SDNode *N, SelectionDAG &DAG,
19584                                  const X86Subtarget *Subtarget) {
19585   EVT VT = N->getValueType(0);
19586   SDValue Op0 = N->getOperand(0);
19587   SDValue Op1 = N->getOperand(1);
19588
19589   // Try to synthesize horizontal adds from adds of shuffles.
19590   if (((Subtarget->hasSSSE3() && (VT == MVT::v8i16 || VT == MVT::v4i32)) ||
19591        (Subtarget->hasInt256() && (VT == MVT::v16i16 || VT == MVT::v8i32))) &&
19592       isHorizontalBinOp(Op0, Op1, true))
19593     return DAG.getNode(X86ISD::HADD, SDLoc(N), VT, Op0, Op1);
19594
19595   return OptimizeConditionalInDecrement(N, DAG);
19596 }
19597
19598 static SDValue PerformSubCombine(SDNode *N, SelectionDAG &DAG,
19599                                  const X86Subtarget *Subtarget) {
19600   SDValue Op0 = N->getOperand(0);
19601   SDValue Op1 = N->getOperand(1);
19602
19603   // X86 can't encode an immediate LHS of a sub. See if we can push the
19604   // negation into a preceding instruction.
19605   if (ConstantSDNode *C = dyn_cast<ConstantSDNode>(Op0)) {
19606     // If the RHS of the sub is a XOR with one use and a constant, invert the
19607     // immediate. Then add one to the LHS of the sub so we can turn
19608     // X-Y -> X+~Y+1, saving one register.
19609     if (Op1->hasOneUse() && Op1.getOpcode() == ISD::XOR &&
19610         isa<ConstantSDNode>(Op1.getOperand(1))) {
19611       APInt XorC = cast<ConstantSDNode>(Op1.getOperand(1))->getAPIntValue();
19612       EVT VT = Op0.getValueType();
19613       SDValue NewXor = DAG.getNode(ISD::XOR, SDLoc(Op1), VT,
19614                                    Op1.getOperand(0),
19615                                    DAG.getConstant(~XorC, VT));
19616       return DAG.getNode(ISD::ADD, SDLoc(N), VT, NewXor,
19617                          DAG.getConstant(C->getAPIntValue()+1, VT));
19618     }
19619   }
19620
19621   // Try to synthesize horizontal adds from adds of shuffles.
19622   EVT VT = N->getValueType(0);
19623   if (((Subtarget->hasSSSE3() && (VT == MVT::v8i16 || VT == MVT::v4i32)) ||
19624        (Subtarget->hasInt256() && (VT == MVT::v16i16 || VT == MVT::v8i32))) &&
19625       isHorizontalBinOp(Op0, Op1, true))
19626     return DAG.getNode(X86ISD::HSUB, SDLoc(N), VT, Op0, Op1);
19627
19628   return OptimizeConditionalInDecrement(N, DAG);
19629 }
19630
19631 /// performVZEXTCombine - Performs build vector combines
19632 static SDValue performVZEXTCombine(SDNode *N, SelectionDAG &DAG,
19633                                         TargetLowering::DAGCombinerInfo &DCI,
19634                                         const X86Subtarget *Subtarget) {
19635   // (vzext (bitcast (vzext (x)) -> (vzext x)
19636   SDValue In = N->getOperand(0);
19637   while (In.getOpcode() == ISD::BITCAST)
19638     In = In.getOperand(0);
19639
19640   if (In.getOpcode() != X86ISD::VZEXT)
19641     return SDValue();
19642
19643   return DAG.getNode(X86ISD::VZEXT, SDLoc(N), N->getValueType(0),
19644                      In.getOperand(0));
19645 }
19646
19647 SDValue X86TargetLowering::PerformDAGCombine(SDNode *N,
19648                                              DAGCombinerInfo &DCI) const {
19649   SelectionDAG &DAG = DCI.DAG;
19650   switch (N->getOpcode()) {
19651   default: break;
19652   case ISD::EXTRACT_VECTOR_ELT:
19653     return PerformEXTRACT_VECTOR_ELTCombine(N, DAG, DCI);
19654   case ISD::VSELECT:
19655   case ISD::SELECT:         return PerformSELECTCombine(N, DAG, DCI, Subtarget);
19656   case X86ISD::CMOV:        return PerformCMOVCombine(N, DAG, DCI, Subtarget);
19657   case ISD::ADD:            return PerformAddCombine(N, DAG, Subtarget);
19658   case ISD::SUB:            return PerformSubCombine(N, DAG, Subtarget);
19659   case X86ISD::ADC:         return PerformADCCombine(N, DAG, DCI);
19660   case ISD::MUL:            return PerformMulCombine(N, DAG, DCI);
19661   case ISD::SHL:
19662   case ISD::SRA:
19663   case ISD::SRL:            return PerformShiftCombine(N, DAG, DCI, Subtarget);
19664   case ISD::AND:            return PerformAndCombine(N, DAG, DCI, Subtarget);
19665   case ISD::OR:             return PerformOrCombine(N, DAG, DCI, Subtarget);
19666   case ISD::XOR:            return PerformXorCombine(N, DAG, DCI, Subtarget);
19667   case ISD::LOAD:           return PerformLOADCombine(N, DAG, DCI, Subtarget);
19668   case ISD::STORE:          return PerformSTORECombine(N, DAG, Subtarget);
19669   case ISD::SINT_TO_FP:     return PerformSINT_TO_FPCombine(N, DAG, this);
19670   case ISD::FADD:           return PerformFADDCombine(N, DAG, Subtarget);
19671   case ISD::FSUB:           return PerformFSUBCombine(N, DAG, Subtarget);
19672   case X86ISD::FXOR:
19673   case X86ISD::FOR:         return PerformFORCombine(N, DAG);
19674   case X86ISD::FMIN:
19675   case X86ISD::FMAX:        return PerformFMinFMaxCombine(N, DAG);
19676   case X86ISD::FAND:        return PerformFANDCombine(N, DAG);
19677   case X86ISD::FANDN:       return PerformFANDNCombine(N, DAG);
19678   case X86ISD::BT:          return PerformBTCombine(N, DAG, DCI);
19679   case X86ISD::VZEXT_MOVL:  return PerformVZEXT_MOVLCombine(N, DAG);
19680   case ISD::ANY_EXTEND:
19681   case ISD::ZERO_EXTEND:    return PerformZExtCombine(N, DAG, DCI, Subtarget);
19682   case ISD::SIGN_EXTEND:    return PerformSExtCombine(N, DAG, DCI, Subtarget);
19683   case ISD::SIGN_EXTEND_INREG: return PerformSIGN_EXTEND_INREGCombine(N, DAG, Subtarget);
19684   case ISD::TRUNCATE:       return PerformTruncateCombine(N, DAG,DCI,Subtarget);
19685   case ISD::SETCC:          return PerformISDSETCCCombine(N, DAG, Subtarget);
19686   case X86ISD::SETCC:       return PerformSETCCCombine(N, DAG, DCI, Subtarget);
19687   case X86ISD::BRCOND:      return PerformBrCondCombine(N, DAG, DCI, Subtarget);
19688   case X86ISD::VZEXT:       return performVZEXTCombine(N, DAG, DCI, Subtarget);
19689   case X86ISD::SHUFP:       // Handle all target specific shuffles
19690   case X86ISD::PALIGNR:
19691   case X86ISD::UNPCKH:
19692   case X86ISD::UNPCKL:
19693   case X86ISD::MOVHLPS:
19694   case X86ISD::MOVLHPS:
19695   case X86ISD::PSHUFD:
19696   case X86ISD::PSHUFHW:
19697   case X86ISD::PSHUFLW:
19698   case X86ISD::MOVSS:
19699   case X86ISD::MOVSD:
19700   case X86ISD::VPERMILP:
19701   case X86ISD::VPERM2X128:
19702   case ISD::VECTOR_SHUFFLE: return PerformShuffleCombine(N, DAG, DCI,Subtarget);
19703   case ISD::FMA:            return PerformFMACombine(N, DAG, Subtarget);
19704   }
19705
19706   return SDValue();
19707 }
19708
19709 /// isTypeDesirableForOp - Return true if the target has native support for
19710 /// the specified value type and it is 'desirable' to use the type for the
19711 /// given node type. e.g. On x86 i16 is legal, but undesirable since i16
19712 /// instruction encodings are longer and some i16 instructions are slow.
19713 bool X86TargetLowering::isTypeDesirableForOp(unsigned Opc, EVT VT) const {
19714   if (!isTypeLegal(VT))
19715     return false;
19716   if (VT != MVT::i16)
19717     return true;
19718
19719   switch (Opc) {
19720   default:
19721     return true;
19722   case ISD::LOAD:
19723   case ISD::SIGN_EXTEND:
19724   case ISD::ZERO_EXTEND:
19725   case ISD::ANY_EXTEND:
19726   case ISD::SHL:
19727   case ISD::SRL:
19728   case ISD::SUB:
19729   case ISD::ADD:
19730   case ISD::MUL:
19731   case ISD::AND:
19732   case ISD::OR:
19733   case ISD::XOR:
19734     return false;
19735   }
19736 }
19737
19738 /// IsDesirableToPromoteOp - This method query the target whether it is
19739 /// beneficial for dag combiner to promote the specified node. If true, it
19740 /// should return the desired promotion type by reference.
19741 bool X86TargetLowering::IsDesirableToPromoteOp(SDValue Op, EVT &PVT) const {
19742   EVT VT = Op.getValueType();
19743   if (VT != MVT::i16)
19744     return false;
19745
19746   bool Promote = false;
19747   bool Commute = false;
19748   switch (Op.getOpcode()) {
19749   default: break;
19750   case ISD::LOAD: {
19751     LoadSDNode *LD = cast<LoadSDNode>(Op);
19752     // If the non-extending load has a single use and it's not live out, then it
19753     // might be folded.
19754     if (LD->getExtensionType() == ISD::NON_EXTLOAD /*&&
19755                                                      Op.hasOneUse()*/) {
19756       for (SDNode::use_iterator UI = Op.getNode()->use_begin(),
19757              UE = Op.getNode()->use_end(); UI != UE; ++UI) {
19758         // The only case where we'd want to promote LOAD (rather then it being
19759         // promoted as an operand is when it's only use is liveout.
19760         if (UI->getOpcode() != ISD::CopyToReg)
19761           return false;
19762       }
19763     }
19764     Promote = true;
19765     break;
19766   }
19767   case ISD::SIGN_EXTEND:
19768   case ISD::ZERO_EXTEND:
19769   case ISD::ANY_EXTEND:
19770     Promote = true;
19771     break;
19772   case ISD::SHL:
19773   case ISD::SRL: {
19774     SDValue N0 = Op.getOperand(0);
19775     // Look out for (store (shl (load), x)).
19776     if (MayFoldLoad(N0) && MayFoldIntoStore(Op))
19777       return false;
19778     Promote = true;
19779     break;
19780   }
19781   case ISD::ADD:
19782   case ISD::MUL:
19783   case ISD::AND:
19784   case ISD::OR:
19785   case ISD::XOR:
19786     Commute = true;
19787     // fallthrough
19788   case ISD::SUB: {
19789     SDValue N0 = Op.getOperand(0);
19790     SDValue N1 = Op.getOperand(1);
19791     if (!Commute && MayFoldLoad(N1))
19792       return false;
19793     // Avoid disabling potential load folding opportunities.
19794     if (MayFoldLoad(N0) && (!isa<ConstantSDNode>(N1) || MayFoldIntoStore(Op)))
19795       return false;
19796     if (MayFoldLoad(N1) && (!isa<ConstantSDNode>(N0) || MayFoldIntoStore(Op)))
19797       return false;
19798     Promote = true;
19799   }
19800   }
19801
19802   PVT = MVT::i32;
19803   return Promote;
19804 }
19805
19806 //===----------------------------------------------------------------------===//
19807 //                           X86 Inline Assembly Support
19808 //===----------------------------------------------------------------------===//
19809
19810 namespace {
19811   // Helper to match a string separated by whitespace.
19812   bool matchAsmImpl(StringRef s, ArrayRef<const StringRef *> args) {
19813     s = s.substr(s.find_first_not_of(" \t")); // Skip leading whitespace.
19814
19815     for (unsigned i = 0, e = args.size(); i != e; ++i) {
19816       StringRef piece(*args[i]);
19817       if (!s.startswith(piece)) // Check if the piece matches.
19818         return false;
19819
19820       s = s.substr(piece.size());
19821       StringRef::size_type pos = s.find_first_not_of(" \t");
19822       if (pos == 0) // We matched a prefix.
19823         return false;
19824
19825       s = s.substr(pos);
19826     }
19827
19828     return s.empty();
19829   }
19830   const VariadicFunction1<bool, StringRef, StringRef, matchAsmImpl> matchAsm={};
19831 }
19832
19833 static bool clobbersFlagRegisters(const SmallVector<StringRef, 4> &AsmPieces) {
19834
19835   if (AsmPieces.size() == 3 || AsmPieces.size() == 4) {
19836     if (std::count(AsmPieces.begin(), AsmPieces.end(), "~{cc}") &&
19837         std::count(AsmPieces.begin(), AsmPieces.end(), "~{flags}") &&
19838         std::count(AsmPieces.begin(), AsmPieces.end(), "~{fpsr}")) {
19839
19840       if (AsmPieces.size() == 3)
19841         return true;
19842       else if (std::count(AsmPieces.begin(), AsmPieces.end(), "~{dirflag}"))
19843         return true;
19844     }
19845   }
19846   return false;
19847 }
19848
19849 bool X86TargetLowering::ExpandInlineAsm(CallInst *CI) const {
19850   InlineAsm *IA = cast<InlineAsm>(CI->getCalledValue());
19851
19852   std::string AsmStr = IA->getAsmString();
19853
19854   IntegerType *Ty = dyn_cast<IntegerType>(CI->getType());
19855   if (!Ty || Ty->getBitWidth() % 16 != 0)
19856     return false;
19857
19858   // TODO: should remove alternatives from the asmstring: "foo {a|b}" -> "foo a"
19859   SmallVector<StringRef, 4> AsmPieces;
19860   SplitString(AsmStr, AsmPieces, ";\n");
19861
19862   switch (AsmPieces.size()) {
19863   default: return false;
19864   case 1:
19865     // FIXME: this should verify that we are targeting a 486 or better.  If not,
19866     // we will turn this bswap into something that will be lowered to logical
19867     // ops instead of emitting the bswap asm.  For now, we don't support 486 or
19868     // lower so don't worry about this.
19869     // bswap $0
19870     if (matchAsm(AsmPieces[0], "bswap", "$0") ||
19871         matchAsm(AsmPieces[0], "bswapl", "$0") ||
19872         matchAsm(AsmPieces[0], "bswapq", "$0") ||
19873         matchAsm(AsmPieces[0], "bswap", "${0:q}") ||
19874         matchAsm(AsmPieces[0], "bswapl", "${0:q}") ||
19875         matchAsm(AsmPieces[0], "bswapq", "${0:q}")) {
19876       // No need to check constraints, nothing other than the equivalent of
19877       // "=r,0" would be valid here.
19878       return IntrinsicLowering::LowerToByteSwap(CI);
19879     }
19880
19881     // rorw $$8, ${0:w}  -->  llvm.bswap.i16
19882     if (CI->getType()->isIntegerTy(16) &&
19883         IA->getConstraintString().compare(0, 5, "=r,0,") == 0 &&
19884         (matchAsm(AsmPieces[0], "rorw", "$$8,", "${0:w}") ||
19885          matchAsm(AsmPieces[0], "rolw", "$$8,", "${0:w}"))) {
19886       AsmPieces.clear();
19887       const std::string &ConstraintsStr = IA->getConstraintString();
19888       SplitString(StringRef(ConstraintsStr).substr(5), AsmPieces, ",");
19889       array_pod_sort(AsmPieces.begin(), AsmPieces.end());
19890       if (clobbersFlagRegisters(AsmPieces))
19891         return IntrinsicLowering::LowerToByteSwap(CI);
19892     }
19893     break;
19894   case 3:
19895     if (CI->getType()->isIntegerTy(32) &&
19896         IA->getConstraintString().compare(0, 5, "=r,0,") == 0 &&
19897         matchAsm(AsmPieces[0], "rorw", "$$8,", "${0:w}") &&
19898         matchAsm(AsmPieces[1], "rorl", "$$16,", "$0") &&
19899         matchAsm(AsmPieces[2], "rorw", "$$8,", "${0:w}")) {
19900       AsmPieces.clear();
19901       const std::string &ConstraintsStr = IA->getConstraintString();
19902       SplitString(StringRef(ConstraintsStr).substr(5), AsmPieces, ",");
19903       array_pod_sort(AsmPieces.begin(), AsmPieces.end());
19904       if (clobbersFlagRegisters(AsmPieces))
19905         return IntrinsicLowering::LowerToByteSwap(CI);
19906     }
19907
19908     if (CI->getType()->isIntegerTy(64)) {
19909       InlineAsm::ConstraintInfoVector Constraints = IA->ParseConstraints();
19910       if (Constraints.size() >= 2 &&
19911           Constraints[0].Codes.size() == 1 && Constraints[0].Codes[0] == "A" &&
19912           Constraints[1].Codes.size() == 1 && Constraints[1].Codes[0] == "0") {
19913         // bswap %eax / bswap %edx / xchgl %eax, %edx  -> llvm.bswap.i64
19914         if (matchAsm(AsmPieces[0], "bswap", "%eax") &&
19915             matchAsm(AsmPieces[1], "bswap", "%edx") &&
19916             matchAsm(AsmPieces[2], "xchgl", "%eax,", "%edx"))
19917           return IntrinsicLowering::LowerToByteSwap(CI);
19918       }
19919     }
19920     break;
19921   }
19922   return false;
19923 }
19924
19925 /// getConstraintType - Given a constraint letter, return the type of
19926 /// constraint it is for this target.
19927 X86TargetLowering::ConstraintType
19928 X86TargetLowering::getConstraintType(const std::string &Constraint) const {
19929   if (Constraint.size() == 1) {
19930     switch (Constraint[0]) {
19931     case 'R':
19932     case 'q':
19933     case 'Q':
19934     case 'f':
19935     case 't':
19936     case 'u':
19937     case 'y':
19938     case 'x':
19939     case 'Y':
19940     case 'l':
19941       return C_RegisterClass;
19942     case 'a':
19943     case 'b':
19944     case 'c':
19945     case 'd':
19946     case 'S':
19947     case 'D':
19948     case 'A':
19949       return C_Register;
19950     case 'I':
19951     case 'J':
19952     case 'K':
19953     case 'L':
19954     case 'M':
19955     case 'N':
19956     case 'G':
19957     case 'C':
19958     case 'e':
19959     case 'Z':
19960       return C_Other;
19961     default:
19962       break;
19963     }
19964   }
19965   return TargetLowering::getConstraintType(Constraint);
19966 }
19967
19968 /// Examine constraint type and operand type and determine a weight value.
19969 /// This object must already have been set up with the operand type
19970 /// and the current alternative constraint selected.
19971 TargetLowering::ConstraintWeight
19972   X86TargetLowering::getSingleConstraintMatchWeight(
19973     AsmOperandInfo &info, const char *constraint) const {
19974   ConstraintWeight weight = CW_Invalid;
19975   Value *CallOperandVal = info.CallOperandVal;
19976     // If we don't have a value, we can't do a match,
19977     // but allow it at the lowest weight.
19978   if (CallOperandVal == NULL)
19979     return CW_Default;
19980   Type *type = CallOperandVal->getType();
19981   // Look at the constraint type.
19982   switch (*constraint) {
19983   default:
19984     weight = TargetLowering::getSingleConstraintMatchWeight(info, constraint);
19985   case 'R':
19986   case 'q':
19987   case 'Q':
19988   case 'a':
19989   case 'b':
19990   case 'c':
19991   case 'd':
19992   case 'S':
19993   case 'D':
19994   case 'A':
19995     if (CallOperandVal->getType()->isIntegerTy())
19996       weight = CW_SpecificReg;
19997     break;
19998   case 'f':
19999   case 't':
20000   case 'u':
20001     if (type->isFloatingPointTy())
20002       weight = CW_SpecificReg;
20003     break;
20004   case 'y':
20005     if (type->isX86_MMXTy() && Subtarget->hasMMX())
20006       weight = CW_SpecificReg;
20007     break;
20008   case 'x':
20009   case 'Y':
20010     if (((type->getPrimitiveSizeInBits() == 128) && Subtarget->hasSSE1()) ||
20011         ((type->getPrimitiveSizeInBits() == 256) && Subtarget->hasFp256()))
20012       weight = CW_Register;
20013     break;
20014   case 'I':
20015     if (ConstantInt *C = dyn_cast<ConstantInt>(info.CallOperandVal)) {
20016       if (C->getZExtValue() <= 31)
20017         weight = CW_Constant;
20018     }
20019     break;
20020   case 'J':
20021     if (ConstantInt *C = dyn_cast<ConstantInt>(CallOperandVal)) {
20022       if (C->getZExtValue() <= 63)
20023         weight = CW_Constant;
20024     }
20025     break;
20026   case 'K':
20027     if (ConstantInt *C = dyn_cast<ConstantInt>(CallOperandVal)) {
20028       if ((C->getSExtValue() >= -0x80) && (C->getSExtValue() <= 0x7f))
20029         weight = CW_Constant;
20030     }
20031     break;
20032   case 'L':
20033     if (ConstantInt *C = dyn_cast<ConstantInt>(CallOperandVal)) {
20034       if ((C->getZExtValue() == 0xff) || (C->getZExtValue() == 0xffff))
20035         weight = CW_Constant;
20036     }
20037     break;
20038   case 'M':
20039     if (ConstantInt *C = dyn_cast<ConstantInt>(CallOperandVal)) {
20040       if (C->getZExtValue() <= 3)
20041         weight = CW_Constant;
20042     }
20043     break;
20044   case 'N':
20045     if (ConstantInt *C = dyn_cast<ConstantInt>(CallOperandVal)) {
20046       if (C->getZExtValue() <= 0xff)
20047         weight = CW_Constant;
20048     }
20049     break;
20050   case 'G':
20051   case 'C':
20052     if (dyn_cast<ConstantFP>(CallOperandVal)) {
20053       weight = CW_Constant;
20054     }
20055     break;
20056   case 'e':
20057     if (ConstantInt *C = dyn_cast<ConstantInt>(CallOperandVal)) {
20058       if ((C->getSExtValue() >= -0x80000000LL) &&
20059           (C->getSExtValue() <= 0x7fffffffLL))
20060         weight = CW_Constant;
20061     }
20062     break;
20063   case 'Z':
20064     if (ConstantInt *C = dyn_cast<ConstantInt>(CallOperandVal)) {
20065       if (C->getZExtValue() <= 0xffffffff)
20066         weight = CW_Constant;
20067     }
20068     break;
20069   }
20070   return weight;
20071 }
20072
20073 /// LowerXConstraint - try to replace an X constraint, which matches anything,
20074 /// with another that has more specific requirements based on the type of the
20075 /// corresponding operand.
20076 const char *X86TargetLowering::
20077 LowerXConstraint(EVT ConstraintVT) const {
20078   // FP X constraints get lowered to SSE1/2 registers if available, otherwise
20079   // 'f' like normal targets.
20080   if (ConstraintVT.isFloatingPoint()) {
20081     if (Subtarget->hasSSE2())
20082       return "Y";
20083     if (Subtarget->hasSSE1())
20084       return "x";
20085   }
20086
20087   return TargetLowering::LowerXConstraint(ConstraintVT);
20088 }
20089
20090 /// LowerAsmOperandForConstraint - Lower the specified operand into the Ops
20091 /// vector.  If it is invalid, don't add anything to Ops.
20092 void X86TargetLowering::LowerAsmOperandForConstraint(SDValue Op,
20093                                                      std::string &Constraint,
20094                                                      std::vector<SDValue>&Ops,
20095                                                      SelectionDAG &DAG) const {
20096   SDValue Result(0, 0);
20097
20098   // Only support length 1 constraints for now.
20099   if (Constraint.length() > 1) return;
20100
20101   char ConstraintLetter = Constraint[0];
20102   switch (ConstraintLetter) {
20103   default: break;
20104   case 'I':
20105     if (ConstantSDNode *C = dyn_cast<ConstantSDNode>(Op)) {
20106       if (C->getZExtValue() <= 31) {
20107         Result = DAG.getTargetConstant(C->getZExtValue(), Op.getValueType());
20108         break;
20109       }
20110     }
20111     return;
20112   case 'J':
20113     if (ConstantSDNode *C = dyn_cast<ConstantSDNode>(Op)) {
20114       if (C->getZExtValue() <= 63) {
20115         Result = DAG.getTargetConstant(C->getZExtValue(), Op.getValueType());
20116         break;
20117       }
20118     }
20119     return;
20120   case 'K':
20121     if (ConstantSDNode *C = dyn_cast<ConstantSDNode>(Op)) {
20122       if (isInt<8>(C->getSExtValue())) {
20123         Result = DAG.getTargetConstant(C->getZExtValue(), Op.getValueType());
20124         break;
20125       }
20126     }
20127     return;
20128   case 'N':
20129     if (ConstantSDNode *C = dyn_cast<ConstantSDNode>(Op)) {
20130       if (C->getZExtValue() <= 255) {
20131         Result = DAG.getTargetConstant(C->getZExtValue(), Op.getValueType());
20132         break;
20133       }
20134     }
20135     return;
20136   case 'e': {
20137     // 32-bit signed value
20138     if (ConstantSDNode *C = dyn_cast<ConstantSDNode>(Op)) {
20139       if (ConstantInt::isValueValidForType(Type::getInt32Ty(*DAG.getContext()),
20140                                            C->getSExtValue())) {
20141         // Widen to 64 bits here to get it sign extended.
20142         Result = DAG.getTargetConstant(C->getSExtValue(), MVT::i64);
20143         break;
20144       }
20145     // FIXME gcc accepts some relocatable values here too, but only in certain
20146     // memory models; it's complicated.
20147     }
20148     return;
20149   }
20150   case 'Z': {
20151     // 32-bit unsigned value
20152     if (ConstantSDNode *C = dyn_cast<ConstantSDNode>(Op)) {
20153       if (ConstantInt::isValueValidForType(Type::getInt32Ty(*DAG.getContext()),
20154                                            C->getZExtValue())) {
20155         Result = DAG.getTargetConstant(C->getZExtValue(), Op.getValueType());
20156         break;
20157       }
20158     }
20159     // FIXME gcc accepts some relocatable values here too, but only in certain
20160     // memory models; it's complicated.
20161     return;
20162   }
20163   case 'i': {
20164     // Literal immediates are always ok.
20165     if (ConstantSDNode *CST = dyn_cast<ConstantSDNode>(Op)) {
20166       // Widen to 64 bits here to get it sign extended.
20167       Result = DAG.getTargetConstant(CST->getSExtValue(), MVT::i64);
20168       break;
20169     }
20170
20171     // In any sort of PIC mode addresses need to be computed at runtime by
20172     // adding in a register or some sort of table lookup.  These can't
20173     // be used as immediates.
20174     if (Subtarget->isPICStyleGOT() || Subtarget->isPICStyleStubPIC())
20175       return;
20176
20177     // If we are in non-pic codegen mode, we allow the address of a global (with
20178     // an optional displacement) to be used with 'i'.
20179     GlobalAddressSDNode *GA = 0;
20180     int64_t Offset = 0;
20181
20182     // Match either (GA), (GA+C), (GA+C1+C2), etc.
20183     while (1) {
20184       if ((GA = dyn_cast<GlobalAddressSDNode>(Op))) {
20185         Offset += GA->getOffset();
20186         break;
20187       } else if (Op.getOpcode() == ISD::ADD) {
20188         if (ConstantSDNode *C = dyn_cast<ConstantSDNode>(Op.getOperand(1))) {
20189           Offset += C->getZExtValue();
20190           Op = Op.getOperand(0);
20191           continue;
20192         }
20193       } else if (Op.getOpcode() == ISD::SUB) {
20194         if (ConstantSDNode *C = dyn_cast<ConstantSDNode>(Op.getOperand(1))) {
20195           Offset += -C->getZExtValue();
20196           Op = Op.getOperand(0);
20197           continue;
20198         }
20199       }
20200
20201       // Otherwise, this isn't something we can handle, reject it.
20202       return;
20203     }
20204
20205     const GlobalValue *GV = GA->getGlobal();
20206     // If we require an extra load to get this address, as in PIC mode, we
20207     // can't accept it.
20208     if (isGlobalStubReference(Subtarget->ClassifyGlobalReference(GV,
20209                                                         getTargetMachine())))
20210       return;
20211
20212     Result = DAG.getTargetGlobalAddress(GV, SDLoc(Op),
20213                                         GA->getValueType(0), Offset);
20214     break;
20215   }
20216   }
20217
20218   if (Result.getNode()) {
20219     Ops.push_back(Result);
20220     return;
20221   }
20222   return TargetLowering::LowerAsmOperandForConstraint(Op, Constraint, Ops, DAG);
20223 }
20224
20225 std::pair<unsigned, const TargetRegisterClass*>
20226 X86TargetLowering::getRegForInlineAsmConstraint(const std::string &Constraint,
20227                                                 MVT VT) const {
20228   // First, see if this is a constraint that directly corresponds to an LLVM
20229   // register class.
20230   if (Constraint.size() == 1) {
20231     // GCC Constraint Letters
20232     switch (Constraint[0]) {
20233     default: break;
20234       // TODO: Slight differences here in allocation order and leaving
20235       // RIP in the class. Do they matter any more here than they do
20236       // in the normal allocation?
20237     case 'q':   // GENERAL_REGS in 64-bit mode, Q_REGS in 32-bit mode.
20238       if (Subtarget->is64Bit()) {
20239         if (VT == MVT::i32 || VT == MVT::f32)
20240           return std::make_pair(0U, &X86::GR32RegClass);
20241         if (VT == MVT::i16)
20242           return std::make_pair(0U, &X86::GR16RegClass);
20243         if (VT == MVT::i8 || VT == MVT::i1)
20244           return std::make_pair(0U, &X86::GR8RegClass);
20245         if (VT == MVT::i64 || VT == MVT::f64)
20246           return std::make_pair(0U, &X86::GR64RegClass);
20247         break;
20248       }
20249       // 32-bit fallthrough
20250     case 'Q':   // Q_REGS
20251       if (VT == MVT::i32 || VT == MVT::f32)
20252         return std::make_pair(0U, &X86::GR32_ABCDRegClass);
20253       if (VT == MVT::i16)
20254         return std::make_pair(0U, &X86::GR16_ABCDRegClass);
20255       if (VT == MVT::i8 || VT == MVT::i1)
20256         return std::make_pair(0U, &X86::GR8_ABCD_LRegClass);
20257       if (VT == MVT::i64)
20258         return std::make_pair(0U, &X86::GR64_ABCDRegClass);
20259       break;
20260     case 'r':   // GENERAL_REGS
20261     case 'l':   // INDEX_REGS
20262       if (VT == MVT::i8 || VT == MVT::i1)
20263         return std::make_pair(0U, &X86::GR8RegClass);
20264       if (VT == MVT::i16)
20265         return std::make_pair(0U, &X86::GR16RegClass);
20266       if (VT == MVT::i32 || VT == MVT::f32 || !Subtarget->is64Bit())
20267         return std::make_pair(0U, &X86::GR32RegClass);
20268       return std::make_pair(0U, &X86::GR64RegClass);
20269     case 'R':   // LEGACY_REGS
20270       if (VT == MVT::i8 || VT == MVT::i1)
20271         return std::make_pair(0U, &X86::GR8_NOREXRegClass);
20272       if (VT == MVT::i16)
20273         return std::make_pair(0U, &X86::GR16_NOREXRegClass);
20274       if (VT == MVT::i32 || !Subtarget->is64Bit())
20275         return std::make_pair(0U, &X86::GR32_NOREXRegClass);
20276       return std::make_pair(0U, &X86::GR64_NOREXRegClass);
20277     case 'f':  // FP Stack registers.
20278       // If SSE is enabled for this VT, use f80 to ensure the isel moves the
20279       // value to the correct fpstack register class.
20280       if (VT == MVT::f32 && !isScalarFPTypeInSSEReg(VT))
20281         return std::make_pair(0U, &X86::RFP32RegClass);
20282       if (VT == MVT::f64 && !isScalarFPTypeInSSEReg(VT))
20283         return std::make_pair(0U, &X86::RFP64RegClass);
20284       return std::make_pair(0U, &X86::RFP80RegClass);
20285     case 'y':   // MMX_REGS if MMX allowed.
20286       if (!Subtarget->hasMMX()) break;
20287       return std::make_pair(0U, &X86::VR64RegClass);
20288     case 'Y':   // SSE_REGS if SSE2 allowed
20289       if (!Subtarget->hasSSE2()) break;
20290       // FALL THROUGH.
20291     case 'x':   // SSE_REGS if SSE1 allowed or AVX_REGS if AVX allowed
20292       if (!Subtarget->hasSSE1()) break;
20293
20294       switch (VT.SimpleTy) {
20295       default: break;
20296       // Scalar SSE types.
20297       case MVT::f32:
20298       case MVT::i32:
20299         return std::make_pair(0U, &X86::FR32RegClass);
20300       case MVT::f64:
20301       case MVT::i64:
20302         return std::make_pair(0U, &X86::FR64RegClass);
20303       // Vector types.
20304       case MVT::v16i8:
20305       case MVT::v8i16:
20306       case MVT::v4i32:
20307       case MVT::v2i64:
20308       case MVT::v4f32:
20309       case MVT::v2f64:
20310         return std::make_pair(0U, &X86::VR128RegClass);
20311       // AVX types.
20312       case MVT::v32i8:
20313       case MVT::v16i16:
20314       case MVT::v8i32:
20315       case MVT::v4i64:
20316       case MVT::v8f32:
20317       case MVT::v4f64:
20318         return std::make_pair(0U, &X86::VR256RegClass);
20319       case MVT::v8f64:
20320       case MVT::v16f32:
20321       case MVT::v16i32:
20322       case MVT::v8i64:
20323         return std::make_pair(0U, &X86::VR512RegClass);
20324       }
20325       break;
20326     }
20327   }
20328
20329   // Use the default implementation in TargetLowering to convert the register
20330   // constraint into a member of a register class.
20331   std::pair<unsigned, const TargetRegisterClass*> Res;
20332   Res = TargetLowering::getRegForInlineAsmConstraint(Constraint, VT);
20333
20334   // Not found as a standard register?
20335   if (Res.second == 0) {
20336     // Map st(0) -> st(7) -> ST0
20337     if (Constraint.size() == 7 && Constraint[0] == '{' &&
20338         tolower(Constraint[1]) == 's' &&
20339         tolower(Constraint[2]) == 't' &&
20340         Constraint[3] == '(' &&
20341         (Constraint[4] >= '0' && Constraint[4] <= '7') &&
20342         Constraint[5] == ')' &&
20343         Constraint[6] == '}') {
20344
20345       Res.first = X86::ST0+Constraint[4]-'0';
20346       Res.second = &X86::RFP80RegClass;
20347       return Res;
20348     }
20349
20350     // GCC allows "st(0)" to be called just plain "st".
20351     if (StringRef("{st}").equals_lower(Constraint)) {
20352       Res.first = X86::ST0;
20353       Res.second = &X86::RFP80RegClass;
20354       return Res;
20355     }
20356
20357     // flags -> EFLAGS
20358     if (StringRef("{flags}").equals_lower(Constraint)) {
20359       Res.first = X86::EFLAGS;
20360       Res.second = &X86::CCRRegClass;
20361       return Res;
20362     }
20363
20364     // 'A' means EAX + EDX.
20365     if (Constraint == "A") {
20366       Res.first = X86::EAX;
20367       Res.second = &X86::GR32_ADRegClass;
20368       return Res;
20369     }
20370     return Res;
20371   }
20372
20373   // Otherwise, check to see if this is a register class of the wrong value
20374   // type.  For example, we want to map "{ax},i32" -> {eax}, we don't want it to
20375   // turn into {ax},{dx}.
20376   if (Res.second->hasType(VT))
20377     return Res;   // Correct type already, nothing to do.
20378
20379   // All of the single-register GCC register classes map their values onto
20380   // 16-bit register pieces "ax","dx","cx","bx","si","di","bp","sp".  If we
20381   // really want an 8-bit or 32-bit register, map to the appropriate register
20382   // class and return the appropriate register.
20383   if (Res.second == &X86::GR16RegClass) {
20384     if (VT == MVT::i8 || VT == MVT::i1) {
20385       unsigned DestReg = 0;
20386       switch (Res.first) {
20387       default: break;
20388       case X86::AX: DestReg = X86::AL; break;
20389       case X86::DX: DestReg = X86::DL; break;
20390       case X86::CX: DestReg = X86::CL; break;
20391       case X86::BX: DestReg = X86::BL; break;
20392       }
20393       if (DestReg) {
20394         Res.first = DestReg;
20395         Res.second = &X86::GR8RegClass;
20396       }
20397     } else if (VT == MVT::i32 || VT == MVT::f32) {
20398       unsigned DestReg = 0;
20399       switch (Res.first) {
20400       default: break;
20401       case X86::AX: DestReg = X86::EAX; break;
20402       case X86::DX: DestReg = X86::EDX; break;
20403       case X86::CX: DestReg = X86::ECX; break;
20404       case X86::BX: DestReg = X86::EBX; break;
20405       case X86::SI: DestReg = X86::ESI; break;
20406       case X86::DI: DestReg = X86::EDI; break;
20407       case X86::BP: DestReg = X86::EBP; break;
20408       case X86::SP: DestReg = X86::ESP; break;
20409       }
20410       if (DestReg) {
20411         Res.first = DestReg;
20412         Res.second = &X86::GR32RegClass;
20413       }
20414     } else if (VT == MVT::i64 || VT == MVT::f64) {
20415       unsigned DestReg = 0;
20416       switch (Res.first) {
20417       default: break;
20418       case X86::AX: DestReg = X86::RAX; break;
20419       case X86::DX: DestReg = X86::RDX; break;
20420       case X86::CX: DestReg = X86::RCX; break;
20421       case X86::BX: DestReg = X86::RBX; break;
20422       case X86::SI: DestReg = X86::RSI; break;
20423       case X86::DI: DestReg = X86::RDI; break;
20424       case X86::BP: DestReg = X86::RBP; break;
20425       case X86::SP: DestReg = X86::RSP; break;
20426       }
20427       if (DestReg) {
20428         Res.first = DestReg;
20429         Res.second = &X86::GR64RegClass;
20430       }
20431     }
20432   } else if (Res.second == &X86::FR32RegClass ||
20433              Res.second == &X86::FR64RegClass ||
20434              Res.second == &X86::VR128RegClass ||
20435              Res.second == &X86::VR256RegClass ||
20436              Res.second == &X86::FR32XRegClass ||
20437              Res.second == &X86::FR64XRegClass ||
20438              Res.second == &X86::VR128XRegClass ||
20439              Res.second == &X86::VR256XRegClass ||
20440              Res.second == &X86::VR512RegClass) {
20441     // Handle references to XMM physical registers that got mapped into the
20442     // wrong class.  This can happen with constraints like {xmm0} where the
20443     // target independent register mapper will just pick the first match it can
20444     // find, ignoring the required type.
20445
20446     if (VT == MVT::f32 || VT == MVT::i32)
20447       Res.second = &X86::FR32RegClass;
20448     else if (VT == MVT::f64 || VT == MVT::i64)
20449       Res.second = &X86::FR64RegClass;
20450     else if (X86::VR128RegClass.hasType(VT))
20451       Res.second = &X86::VR128RegClass;
20452     else if (X86::VR256RegClass.hasType(VT))
20453       Res.second = &X86::VR256RegClass;
20454     else if (X86::VR512RegClass.hasType(VT))
20455       Res.second = &X86::VR512RegClass;
20456   }
20457
20458   return Res;
20459 }